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

Bug Summary

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

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

→

1/* Interprocedural scalar replacement of aggregates
 Copyright (C) 2019-2023 Free Software Foundation, Inc.
 Contributed by Martin Jambor <mjambor@suse.cz>

5This file is part of GCC.

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

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

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

21/* IPA-SRA is an interprocedural pass that removes unused function return
 values (turning functions returning a value which is never used into void
 functions) and removes unused function parameters.  It can also replace an
 aggregate parameter by a set of other parameters representing part of the
 original, turning those passed by reference into new ones which pass the
 value directly.

 The pass is a true IPA one, which means that it works in three stages in
 order to be able to take advantage of LTO.  First, summaries about functions
 and each calls are generated.  Function summaries (often called call graph
 node summaries) contain mainly information about which parameters are
 potential transformation candidates and which bits of candidates are
 accessed.  We differentiate between accesses done as a part of a call
 statement (which might be not necessary if the callee is also transformed)
 and others (which are mandatory).  Call summaries (often called call graph
 edge summaries) contain information about which function formal parameters
 feed into which actual call arguments so that if two parameters are only
 used in a sum which is then passed to another function which then however
 does not use this parameter, all three parameters of the two functions can
 be eliminated.  Edge summaries also have flags whether the return value is
 used or if it is only returned in the caller too.  In LTO mode these
 summaries are then streamed to the object file in the compilation phase and
 streamed back in in the WPA analysis stage.

 The interprocedural analysis phase traverses the graph in topological order
 in two sweeps, one in each direction.  First, from callees to callers for
 parameter removal and splitting.  Each strongly-connected component is
 processed iteratively until the situation in it stabilizes.  The pass from
 callers to callees is then carried out to remove unused return values in a
 very similar fashion.

 Because parameter manipulation has big implications for call redirection
 which is done only after all call graph nodes materialize, the
 transformation phase is not part of this patch but is carried out by the
 clone materialization and edge redirection itself, see comments in
 ipa-param-manipulation.h for more details.  */


59#include "config.h"
60#include "system.h"
61#include "coretypes.h"
62#include "backend.h"
63#include "tree.h"
64#include "gimple.h"
65#include "predict.h"
66#include "tree-pass.h"
67#include "ssa.h"
68#include "cgraph.h"
69#include "gimple-pretty-print.h"
70#include "alias.h"
71#include "tree-eh.h"
72#include "gimple-iterator.h"
73#include "gimple-walk.h"
74#include "tree-dfa.h"
75#include "tree-sra.h"
76#include "alloc-pool.h"
77#include "symbol-summary.h"
78#include "dbgcnt.h"
79#include "tree-inline.h"
80#include "ipa-utils.h"
81#include "builtins.h"
82#include "cfganal.h"
83#include "tree-streamer.h"
84#include "internal-fn.h"
85#include "symtab-clones.h"
86#include "attribs.h"
87#include "ipa-prop.h"

89static void ipa_sra_summarize_function (cgraph_node *);

91/* Bits used to track size of an aggregate in bytes interprocedurally.  */
92#define ISRA_ARG_SIZE_LIMIT_BITS16 16
93#define ISRA_ARG_SIZE_LIMIT(1 << 16) (1 << ISRA_ARG_SIZE_LIMIT_BITS16)
94/* How many parameters can feed into a call actual argument and still be
 tracked.  */
96#define IPA_SRA_MAX_PARAM_FLOW_LEN7 7

98/* Structure describing accesses to a specific portion of an aggregate
 parameter, as given by the offset and size.  Any smaller accesses that occur
 within a function that fall within another access form a tree.  The pass
 cannot analyze parameters with only partially overlapping accesses.  */

103struct GTY(()) param_access
104{
/* Type that a potential replacement should have.  This field only has
   meaning in the summary building and transformation phases, when it is
   reconstructed from the body.  Must not be touched in IPA analysis
   stage.  */
tree type;

/* Alias reference type to be used in MEM_REFs when adjusting caller
   arguments.  */
tree alias_ptr_type;

/* Values returned by get_ref_base_and_extent but converted to bytes and
   stored as unsigned ints.  */
unsigned unit_offset;
unsigned unit_size : ISRA_ARG_SIZE_LIMIT_BITS16;

/* Set once we are sure that the access will really end up in a potentially
   transformed function - initially not set for portions of formal parameters
   that are only used as actual function arguments passed to callees.  */
unsigned certain : 1;
/* Set if the access has reverse scalar storage order.  */
unsigned reverse : 1;
126};

128/* This structure has the same purpose as the one above and additionally it
 contains some fields that are only necessary in the summary generation
 phase.  */

132struct gensum_param_access
133{
/* Values returned by get_ref_base_and_extent.  */
HOST_WIDE_INTlong offset;
HOST_WIDE_INTlong size;

/* if this access has any children (in terms of the definition above), this
   points to the first one.  */
struct gensum_param_access *first_child;
/* In intraprocedural SRA, pointer to the next sibling in the access tree as
   described above.  */
struct gensum_param_access *next_sibling;

/* Type that a potential replacement should have.  This field only has
   meaning in the summary building and transformation phases, when it is
   reconstructed from the body.  Must not be touched in IPA analysis
   stage.  */
tree type;
/* Alias reference type to be used in MEM_REFs when adjusting caller
   arguments.  */
tree alias_ptr_type;

/* Cumulative count of all loads. */
profile_count load_count;
/* Have there been writes to or reads from this exact location except for as
   arguments to a function call that can be tracked.  */
bool nonarg;

/* Set if the access has reverse scalar storage order.  */
bool reverse;
162};

164/* Summary describing a parameter in the IPA stages.  */

166struct GTY(()) isra_param_desc
167{
/* List of access representatives to the parameters, sorted according to
   their offset.  */
vec <param_access *, va_gc> *accesses;

/* Unit size limit of total size of all replacements.  */
unsigned param_size_limit : ISRA_ARG_SIZE_LIMIT_BITS16;
/* Sum of unit sizes of all certain replacements.  */
unsigned size_reached : ISRA_ARG_SIZE_LIMIT_BITS16;
/* Minimum offset that is known to be safe to dereference because of callers
   pass pointers to DECLs of at least this size or because of dereferences in
   callers.  */
unsigned safe_size : ISRA_ARG_SIZE_LIMIT_BITS16;

/* A parameter that is used only in call arguments and can be removed if all
   concerned actual arguments are removed.  */
unsigned locally_unused : 1;
/* An aggregate that is a candidate for breaking up or complete removal.  */
unsigned split_candidate : 1;
/* Is this a parameter passing stuff by reference?  */
unsigned by_ref : 1;
/* Parameter hint set during IPA analysis when there is a caller which does
   not construct the argument just to pass it to calls.  Only meaningful for
   by_ref parameters.  */
unsigned not_specially_constructed : 1;
/* Only meaningful for by_ref parameters.  If set, this parameter can only be
   a split candidate if all callers pass pointers that are known to point to
   a chunk of memory large enough to contain all accesses.  */
unsigned conditionally_dereferenceable : 1;
/* Set when safe_size has been updated from at least one caller.  */
unsigned safe_size_set : 1;
198};

200/* Structure used when generating summaries that describes a parameter.  */

202struct gensum_param_desc
203{
/* Roots of param_accesses.  */
gensum_param_access *accesses;
/* Number of accesses in the access tree rooted in field accesses.  */
unsigned access_count;

/* If the below is non-zero, this is the number of uses as actual arguments.  */
int call_uses;
/* Number of times this parameter has been directly passed to.  */
unsigned ptr_pt_count;

/* Size limit of total size of all replacements.  */
unsigned param_size_limit;
/* Sum of sizes of nonarg accesses.  */
unsigned nonarg_acc_size;

/* A parameter that is used only in call arguments and can be removed if all
   concerned actual arguments are removed.  */
bool locally_unused;
/* An aggregate that is a candidate for breaking up or a pointer passing data
   by reference that is a candidate for being converted to a set of
   parameters passing those data by value.  */
bool split_candidate;
/* Is this a parameter passing stuff by reference (either a pointer or a
   source language reference type)?  */
bool by_ref;
/* If this parameter passes stuff by reference, can it be safely dereferenced
   without performing further checks (for example because it is a
   REFERENCE_TYPE)?  */
bool safe_ref;
/* Only meaningful for by_ref parameters.  If set, this parameter can only be
   a split candidate if all callers pass pointers that are known to point to
   a chunk of memory large enough to contain all accesses.  */
bool conditionally_dereferenceable;

/* The number of this parameter as they are ordered in function decl.  */
int param_number;
/* For parameters passing data by reference, this is parameter index to
   compute indices to bb_dereferences.  */
int deref_index;
243};

245/* Properly deallocate accesses of DESC.  TODO: Since this data structure is
 allocated in GC memory, this is not necessary and we can consider removing
 the function.  */

249static void
250free_param_decl_accesses (isra_param_desc *desc)
251{
unsigned len = vec_safe_length (desc->accesses);
for (unsigned i = 0; i < len; ++i)
  ggc_free ((*desc->accesses)[i]);
vec_free (desc->accesses);
256}

258/* Class used to convey information about functions from the
 intra-procedural analysis stage to inter-procedural one.  */

261class GTY((for_user)) isra_func_summary
262{
263public:
/* initialize the object.  */

isra_func_summary ()
  : m_parameters (NULLnullptr), m_candidate (false), m_returns_value (false),
  m_return_ignored (false), m_queued (false)
{}

/* Destroy m_parameters.  */

~isra_func_summary ();

/* Mark the function as not a candidate for any IPA-SRA transformation.
   Return true if it was a candidate until now.  */

bool zap ();

/* Vector of parameter descriptors corresponding to the function being
   analyzed.  */
vec<isra_param_desc, va_gc> *m_parameters;

/* Whether the node is even a candidate for any IPA-SRA transformation at
   all.  */
unsigned m_candidate : 1;

/* Whether the original function returns any value.  */
unsigned m_returns_value : 1;

/* Set to true if all call statements do not actually use the returned
   value.  */

unsigned m_return_ignored : 1;

/* Whether the node is already queued in IPA SRA stack during processing of
   call graphs SCCs.  */

unsigned m_queued : 1;
300};

302/* Deallocate the memory pointed to by isra_func_summary.  TODO: Since this
 data structure is allocated in GC memory, this is not necessary and we can
 consider removing the destructor.  */

306isra_func_summary::~isra_func_summary ()
307{
unsigned len = vec_safe_length (m_parameters);
for (unsigned i = 0; i < len; ++i)
  free_param_decl_accesses (&(*m_parameters)[i]);
vec_free (m_parameters);
312}

314/* Mark the function as not a candidate for any IPA-SRA transformation.  Return
 true if it was a candidate until now.  */

317bool
318isra_func_summary::zap ()
319{
bool ret = m_candidate;
m_candidate = false;

/* TODO: see the destructor above.  */
unsigned len = vec_safe_length (m_parameters);
for (unsigned i = 0; i < len; ++i)
  free_param_decl_accesses (&(*m_parameters)[i]);
vec_free (m_parameters);

return ret;
330}

332/* Structure to describe which formal parameters feed into a particular actual
 argument.  */

335struct isra_param_flow
336{
/* Number of elements in array inputs that contain valid data.  */
char length;
/* Indices of formal parameters that feed into the described actual argument.
   If aggregate_pass_through or pointer_pass_through below are true, it must
   contain exactly one element which is passed through from a formal
   parameter if the given number.  Otherwise, the array contains indices of
   callee's formal parameters which are used to calculate value of this
   actual argument. */
unsigned char inputs[IPA_SRA_MAX_PARAM_FLOW_LEN7];

/* Offset within the formal parameter.  */
unsigned unit_offset;
/* When aggregate_pass_through is set, this is the size of the portion of an
   aggregate formal parameter that is being passed.  Otherwise, this is size
   of pointed to memory that is known to be valid be dereferenced.  */
unsigned unit_size : ISRA_ARG_SIZE_LIMIT_BITS16;

/* True when the value of this actual argument is a portion of a formal
   parameter.  */
unsigned aggregate_pass_through : 1;
/* True when the value of this actual copy is a verbatim pass through of an
   obtained pointer.  */
unsigned pointer_pass_through : 1;
/* True when it is safe to copy access candidates here from the callee, which
   would mean introducing dereferences into callers of the caller.  */
unsigned safe_to_import_accesses : 1;
/* True when the passed value is an address of a structure that has been
   constructed in the caller just to be passed by reference to functions
   (i.e. is never read).  */
unsigned constructed_for_calls : 1;
367};

369/* Structure used to convey information about calls from the intra-procedural
 analysis stage to inter-procedural one.  */

372class isra_call_summary
373{
374public:
isra_call_summary ()
  : m_arg_flow (), m_return_ignored (false), m_return_returned (false),
    m_bit_aligned_arg (false), m_before_any_store (false)
{}

void init_inputs (unsigned arg_count);
void dump (FILE *f);

/* Information about what formal parameters of the caller are used to compute
   individual actual arguments of this call.  */
auto_vec <isra_param_flow> m_arg_flow;

/* Set to true if the call statement does not have a LHS.  */
unsigned m_return_ignored : 1;

/* Set to true if the LHS of call statement is only used to construct the
   return value of the caller.  */
unsigned m_return_returned : 1;

/* Set when any of the call arguments are not byte-aligned.  */
unsigned m_bit_aligned_arg : 1;

/* Set to true if the call happend before any (other) store to memory in the
   caller.  */
unsigned m_before_any_store : 1;
400};

402/* Class to manage function summaries.  */

404class GTY((user)) ipa_sra_function_summaries
: public function_summary <isra_func_summary *>
406{
407public:
ipa_sra_function_summaries (symbol_table *table, bool ggc):
  function_summary<isra_func_summary *> (table, ggc) { }

void duplicate (cgraph_node *, cgraph_node *,
  isra_func_summary *old_sum,
  isra_func_summary *new_sum) final override;
void insert (cgraph_node *, isra_func_summary *) final override;
415};

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

419void
420ipa_sra_function_summaries::duplicate (cgraph_node *, cgraph_node *,
		       isra_func_summary *old_sum,
		       isra_func_summary *new_sum)
423{
/* TODO: Somehow stop copying when ISRA is doing the cloning, it is
   useless.  */
new_sum->m_candidate  = old_sum->m_candidate;
new_sum->m_returns_value = old_sum->m_returns_value;
new_sum->m_return_ignored = old_sum->m_return_ignored;
gcc_assert (!old_sum->m_queued)((void)(!(!old_sum->m_queued) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 429, __FUNCTION__), 0 : 0));
1
Assuming field 'm_queued' is 0→
2
←
'?' condition is false→
new_sum->m_queued = false;

unsigned param_count = vec_safe_length (old_sum->m_parameters);
3
←
Calling 'vec_safe_length<isra_param_desc, va_gc>'→
7
←
Returning from 'vec_safe_length<isra_param_desc, va_gc>'→
if (!param_count)
8
←
Assuming 'param_count' is not equal to 0→
9
←
Taking false branch→
  return;
vec_safe_reserve_exact (new_sum->m_parameters, param_count);
new_sum->m_parameters->quick_grow_cleared (param_count);
for (unsigned i = 0; i9.1
'i' is < 'param_count'
1
'i' is < 'param_count'
 < param_count; i++)
10
←
Loop condition is true.  Entering loop body→
  {
    isra_param_desc *s = &(*old_sum->m_parameters)[i];
    isra_param_desc *d = &(*new_sum->m_parameters)[i];

    d->param_size_limit = s->param_size_limit;
    d->size_reached = s->size_reached;
    d->safe_size = s->safe_size;
    d->locally_unused = s->locally_unused;
    d->split_candidate = s->split_candidate;
    d->by_ref = s->by_ref;
    d->not_specially_constructed = s->not_specially_constructed;
    d->conditionally_dereferenceable = s->conditionally_dereferenceable;
    d->safe_size_set = s->safe_size_set;

    unsigned acc_count = vec_safe_length (s->accesses);
    vec_safe_reserve_exact (d->accesses, acc_count);
11
←
Calling 'vec_safe_reserve_exact<param_access *, va_gc>'→
24
←
Returning from 'vec_safe_reserve_exact<param_access *, va_gc>'→
    for (unsigned j = 0; j24.1
'j' is < 'acc_count'
1
'j' is < 'acc_count'
 < acc_count; j++)
25
←
Loop condition is true.  Entering loop body→
{
 param_access *from = (*s->accesses)[j];
 param_access *to = ggc_cleared_alloc<param_access> ();
 to->type = from->type;
 to->alias_ptr_type = from->alias_ptr_type;
 to->unit_offset = from->unit_offset;
 to->unit_size = from->unit_size;
 to->certain = from->certain;
 to->reverse = from->reverse;
 d->accesses->quick_push (to);
26
←
Called C++ object pointer is null
}
  }
467}

469/* Pointer to the pass function summary holder.  */

471static GTY(()) ipa_sra_function_summaries *func_sums;

473/* Hook that is called by summary when new node appears.  */

475void
476ipa_sra_function_summaries::insert (cgraph_node *node, isra_func_summary *)
477{
if (opt_for_fn (node->decl, flag_ipa_sra)(opts_for_fn (node->decl)->x_flag_ipa_sra))
  {
    push_cfun (DECL_STRUCT_FUNCTION (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 480, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f));
    ipa_sra_summarize_function (node);
    pop_cfun ();
  }
else
  func_sums->remove (node);
486}

488/* Class to manage call summaries.  */

490class ipa_sra_call_summaries: public call_summary <isra_call_summary *>
491{
492public:
ipa_sra_call_summaries (symbol_table *table):
  call_summary<isra_call_summary *> (table) { }

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

502static ipa_sra_call_summaries *call_sums;


505/* Initialize m_arg_flow of a particular instance of isra_call_summary.
 ARG_COUNT is the number of actual arguments passed.  */

508void
509isra_call_summary::init_inputs (unsigned arg_count)
510{
if (arg_count == 0)
  {
    gcc_checking_assert (m_arg_flow.length () == 0)((void)(!(m_arg_flow.length () == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 513, __FUNCTION__), 0 : 0));
    return;
  }
if (m_arg_flow.length () == 0)
  {
    m_arg_flow.reserve_exact (arg_count);
    m_arg_flow.quick_grow_cleared (arg_count);
  }
else
  gcc_checking_assert (arg_count == m_arg_flow.length ())((void)(!(arg_count == m_arg_flow.length ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 522, __FUNCTION__), 0 : 0));
523}

525/* Dump all information in call summary to F.  */

527void
528isra_call_summary::dump (FILE *f)
529{
if (m_return_ignored)
  fprintf (f, "    return value ignored\n");
if (m_return_returned)
  fprintf (f, "    return value used only to compute caller return value\n");
if (m_before_any_store)
  fprintf (f, "    happens before any store to memory\n");
for (unsigned i = 0; i < m_arg_flow.length (); i++)
  {
    fprintf (f, "    Parameter %u:\n", i);
    isra_param_flow *ipf = &m_arg_flow[i];

    if (ipf->length)
{
 bool first = true;
 fprintf (f, "      Scalar param sources: ");
 for (int j = 0; j < ipf->length; j++)
   {
     if (!first)
fprintf (f, ", ");
     else
first = false;
     fprintf (f, "%i", (int) ipf->inputs[j]);
   }
 fprintf (f, "\n");
}
    if (ipf->aggregate_pass_through)
fprintf (f, "      Aggregate pass through from the param given above, "
 "unit offset: %u , unit size: %u\n",
 ipf->unit_offset, ipf->unit_size);
    else if (ipf->unit_size > 0)
fprintf (f, "      Known dereferenceable size: %u\n", ipf->unit_size);
    if (ipf->pointer_pass_through)
fprintf (f, "      Pointer pass through from the param given above, "
 "safe_to_import_accesses: %u\n", ipf->safe_to_import_accesses);
    if (ipf->constructed_for_calls)
fprintf (f, "      Variable constructed just to be passed to "
 "calls.\n");
  }
568}

570/* Duplicate edge summary when an edge is cloned.  */

572void
573ipa_sra_call_summaries::duplicate (cgraph_edge *, cgraph_edge *,
		   isra_call_summary *old_sum,
		   isra_call_summary *new_sum)
576{
unsigned arg_count = old_sum->m_arg_flow.length ();
new_sum->init_inputs (arg_count);
for (unsigned i = 0; i < arg_count; i++)
  new_sum->m_arg_flow[i] = old_sum->m_arg_flow[i];

new_sum->m_return_ignored = old_sum->m_return_ignored;
new_sum->m_return_returned = old_sum->m_return_returned;
new_sum->m_bit_aligned_arg = old_sum->m_bit_aligned_arg;
new_sum->m_before_any_store = old_sum->m_before_any_store;
586}


589/* With all GTY stuff done, we can move to anonymous namespace.  */
590namespace {
591/* Quick mapping from a decl to its param descriptor.  */

593hash_map<tree, gensum_param_desc *> *decl2desc;

595/* All local DECLs ever loaded from of and of those that have their address
 assigned to a variable.  */

598hash_set <tree> *loaded_decls;

600/* Countdown of allowed Alias Analysis steps during summary building.  */

602int aa_walking_limit;

604/* This is a table in which for each basic block and parameter there is a
 distance (offset + size) in that parameter which is dereferenced and
 accessed in that BB.  */
607HOST_WIDE_INTlong *bb_dereferences = NULLnullptr;
608/* How many by-reference parameters there are in the current function.  */
609int unsafe_by_ref_count;

611/* Bitmap of BBs that can cause the function to "stop" progressing by
 returning, throwing externally, looping infinitely or calling a function
 which might abort etc.. */
614bitmap final_bbs;

616/* Obstack to allocate various small structures required only when generating
 summary for a function.  */
618struct obstack gensum_obstack;

620/* Return false the function is apparently unsuitable for IPA-SRA based on it's
 attributes, return true otherwise.  NODE is the cgraph node of the current
 function.  */

624static bool
625ipa_sra_preliminary_function_checks (cgraph_node *node)
626{
if (!node->can_change_signature)
  {
    if (dump_file)
fprintf (dump_file, "Function cannot change signature.\n");
    return false;
  }

if (!tree_versionable_function_p (node->decl))
  {
    if (dump_file)
fprintf (dump_file, "Function is not versionable.\n");
    return false;
  }

if (!opt_for_fn (node->decl, optimize)(opts_for_fn (node->decl)->x_optimize)
    || !opt_for_fn (node->decl, flag_ipa_sra)(opts_for_fn (node->decl)->x_flag_ipa_sra))
  {
    if (dump_file)
fprintf (dump_file, "Not optimizing or IPA-SRA turned off for this "
 "function.\n");
    return false;
  }

if (DECL_VIRTUAL_P (node->decl)((contains_struct_check ((node->decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 650, __FUNCTION__))->decl_common.virtual_flag))
  {
    if (dump_file)
fprintf (dump_file, "Function is a virtual method.\n");
    return false;
  }

struct function *fun = DECL_STRUCT_FUNCTION (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 657, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f);
if (fun->stdarg)
  {
    if (dump_file)
fprintf (dump_file, "Function uses stdarg. \n");
    return false;
  }

if (DECL_DISREGARD_INLINE_LIMITS (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 665, __FUNCTION__, (FUNCTION_DECL)))->function_decl.disregard_inline_limits
))
  {
    if (dump_file)
fprintf (dump_file, "Always inline function will be inlined "
 "anyway. \n");
    return false;
  }

return true;
674}

676/* Print access tree starting at ACCESS to F.  */

678static void
679dump_gensum_access (FILE *f, gensum_param_access *access, unsigned indent)
680{
fprintf (f, "  ");
for (unsigned i = 0; i < indent; i++)
  fprintf (f, " ");
fprintf (f, "    * Access to offset: " HOST_WIDE_INT_PRINT_DEC"%" "l" "d",
  access->offset);
fprintf (f, ", size: " HOST_WIDE_INT_PRINT_DEC"%" "l" "d", access->size);
fprintf (f, ", type: ");
print_generic_expr (f, access->type);
fprintf (f, ", alias_ptr_type: ");
print_generic_expr (f, access->alias_ptr_type);
fprintf (f, ", load_count: ");
access->load_count.dump (f);
fprintf (f, ", nonarg: %u, reverse: %u\n", access->nonarg, access->reverse);
for (gensum_param_access *ch = access->first_child;
     ch;
     ch = ch->next_sibling)
  dump_gensum_access (f, ch, indent + 2);
698}


701/* Print access tree starting at ACCESS to F.  */

703static void
704dump_isra_access (FILE *f, param_access *access)
705{
fprintf (f, "    * Access to unit offset: %u", access->unit_offset);
fprintf (f, ", unit size: %u", access->unit_size);
fprintf (f, ", type: ");
print_generic_expr (f, access->type);
fprintf (f, ", alias_ptr_type: ");
print_generic_expr (f, access->alias_ptr_type);
if (access->certain)
  fprintf (f, ", certain");
else
  fprintf (f, ", not certain");
if (access->reverse)
  fprintf (f, ", reverse");
fprintf (f, "\n");
719}

721/* Dump access tree starting at ACCESS to stderr.  */

723DEBUG_FUNCTION__attribute__ ((__used__)) void
724debug_isra_access (param_access *access)
725{
dump_isra_access (stderrstderr, access);
727}

729/* Dump DESC to F.  */

731static void
732dump_gensum_param_descriptor (FILE *f, gensum_param_desc *desc)
733{
if (desc->locally_unused)
  fprintf (f, "    unused with %i call_uses\n", desc->call_uses);
if (!desc->split_candidate)
  {
    fprintf (f, "    not a candidate\n");
    return;
  }
if (desc->by_ref)
  fprintf (f, "    %s%s by_ref with %u pass throughs\n",
    desc->safe_ref ? "safe" : "unsafe",
    desc->conditionally_dereferenceable
    ? " conditionally_dereferenceable" : " ok",
    desc->ptr_pt_count);

for (gensum_param_access *acc = desc->accesses; acc; acc = acc->next_sibling)
  dump_gensum_access (f, acc, 2);
750}

752/* Dump all parameter descriptors in IFS, assuming it describes FNDECL, to
 F.  */

755static void
756dump_gensum_param_descriptors (FILE *f, tree fndecl,
	       vec<gensum_param_desc> *param_descriptions)
758{
tree parm = DECL_ARGUMENTS (fndecl)((tree_check ((fndecl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 759, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
);
for (unsigned i = 0;
     i < param_descriptions->length ();
     ++i, parm = DECL_CHAIN (parm)(((contains_struct_check (((contains_struct_check ((parm), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 762, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 762, __FUNCTION__))->common.chain)))
  {
    fprintf (f, "  Descriptor for parameter %i ", i);
    print_generic_expr (f, parm, TDF_UID);
    fprintf (f, "\n");
    dump_gensum_param_descriptor (f, &(*param_descriptions)[i]);
  }
769}


772/* Dump DESC to F.  If HINTS is true, also dump IPA-analysis computed
 hints.  */

775static void
776dump_isra_param_descriptor (FILE *f, isra_param_desc *desc, bool hints)
777{
if (desc->locally_unused)
  {
    fprintf (f, "    (locally) unused\n");
  }
if (!desc->split_candidate)
  {
    fprintf (f, "    not a candidate for splitting");
    if (hints && desc->by_ref && desc->safe_size_set)
fprintf (f, ", safe_size: %u", (unsigned) desc->safe_size);
    fprintf (f, "\n");
    return;
  }
fprintf (f, "    param_size_limit: %u, size_reached: %u%s",
  desc->param_size_limit, desc->size_reached,
  desc->by_ref ? ", by_ref" : "");
if (desc->by_ref && desc->conditionally_dereferenceable)
  fprintf (f, ", conditionally_dereferenceable");
if (hints)
  {
    if (desc->by_ref && !desc->not_specially_constructed)
fprintf (f, ", args_specially_constructed");
    if (desc->by_ref && desc->safe_size_set)
fprintf (f, ", safe_size: %u", (unsigned) desc->safe_size);
  }
fprintf (f, "\n");

for (unsigned i = 0; i < vec_safe_length (desc->accesses); ++i)
  {
    param_access *access = (*desc->accesses)[i];
    dump_isra_access (f, access);
  }
809}

811/* Dump all parameter descriptors in IFS, assuming it describes FNDECL, to F.
 If HINTS is true, also dump IPA-analysis computed hints.  */

814static void
815dump_isra_param_descriptors (FILE *f, tree fndecl, isra_func_summary *ifs,
	     bool hints)
817{
tree parm = DECL_ARGUMENTS (fndecl)((tree_check ((fndecl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 818, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
);
if (!ifs->m_parameters)
  {
    fprintf (f, "  parameter descriptors not available\n");
    return;
  }

for (unsigned i = 0;
     i < ifs->m_parameters->length ();
     ++i, parm = DECL_CHAIN (parm)(((contains_struct_check (((contains_struct_check ((parm), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 827, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 827, __FUNCTION__))->common.chain)))
  {
    fprintf (f, "  Descriptor for parameter %i ", i);
    print_generic_expr (f, parm, TDF_UID);
    fprintf (f, "\n");
    dump_isra_param_descriptor (f, &(*ifs->m_parameters)[i], hints);
  }
834}

836/* Add SRC to inputs of PARAM_FLOW, unless it would exceed storage.  If the
 function fails return false, otherwise return true.  SRC must fit into an
 unsigned char.  Used for purposes of transitive unused parameter
 removal.  */

841static bool
842add_src_to_param_flow (isra_param_flow *param_flow, int src)
843{
gcc_checking_assert (src >= 0 && src <= UCHAR_MAX)((void)(!(src >= 0 && src <= (127*2 +1)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 844, __FUNCTION__), 0 : 0));
if (param_flow->length == IPA_SRA_MAX_PARAM_FLOW_LEN7)
  return false;

param_flow->inputs[(int) param_flow->length] = src;
param_flow->length++;
return true;
851}

853/* Add a SRC to the inputs of PARAM_FLOW unless it is already there and assert
 it is the only input.  Used for purposes of transitive parameter
 splitting.  */

857static void
858set_single_param_flow_source (isra_param_flow *param_flow, int src)
859{
gcc_checking_assert (src >= 0 && src <= UCHAR_MAX)((void)(!(src >= 0 && src <= (127*2 +1)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 860, __FUNCTION__), 0 : 0));
if (param_flow->length == 0)
  {
    param_flow->inputs[0] = src;
    param_flow->length = 1;
  }
else if (param_flow->length == 1)
  gcc_assert (param_flow->inputs[0] == src)((void)(!(param_flow->inputs[0] == src) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 867, __FUNCTION__), 0 : 0));
else
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 869, __FUNCTION__));
870}

872/* Assert that there is only a single value in PARAM_FLOW's inputs and return
 it.  */

875static unsigned
876get_single_param_flow_source (const isra_param_flow *param_flow)
877{
gcc_assert (param_flow->length == 1)((void)(!(param_flow->length == 1) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 878, __FUNCTION__), 0 : 0));
return param_flow->inputs[0];
880}

882/* Inspect all uses of NAME and simple arithmetic calculations involving NAME
 in FUN represented with NODE and return a negative number if any of them is
 used for something else than either an actual call argument, simple
 arithmetic operation or debug statement.  If there are no such uses, return
 the number of actual arguments that this parameter eventually feeds to (or
 zero if there is none).  For any such parameter, mark PARM_NUM as one of its
 sources.  ANALYZED is a bitmap that tracks which SSA names we have already
 started investigating.  */

891static int
892isra_track_scalar_value_uses (function *fun, cgraph_node *node, tree name,
	      int parm_num, bitmap analyzed)
894{
int res = 0;
imm_use_iterator imm_iter;
gimple *stmt;

FOR_EACH_IMM_USE_STMT (stmt, imm_iter, name)for (struct auto_end_imm_use_stmt_traverse auto_end_imm_use_stmt_traverse
 ((((stmt) = first_imm_use_stmt (&(imm_iter), (name))), &
(imm_iter))); !end_imm_use_stmt_p (&(imm_iter)); (void) (
(stmt) = next_imm_use_stmt (&(imm_iter))))
  {
    if (is_gimple_debug (stmt))
continue;

    /* TODO: We could handle at least const builtin functions like arithmetic
operations below.  */
    if (is_gimple_call (stmt))
{
 int all_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_uses++;

 gcall *call = as_a <gcall *> (stmt);
 unsigned arg_count;
 if (gimple_call_internal_p (call)
     || (arg_count = gimple_call_num_args (call)) == 0)
   {
     res = -1;
     break;
   }

 cgraph_edge *cs = node->get_edge (stmt);
 gcc_checking_assert (cs)((void)(!(cs) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 923, __FUNCTION__), 0 : 0));
 isra_call_summary *csum = call_sums->get_create (cs);
 csum->init_inputs (arg_count);

 int simple_uses = 0;
 for (unsigned i = 0; i < arg_count; i++)
   if (gimple_call_arg (call, i) == name)
     {
if (!add_src_to_param_flow (&csum->m_arg_flow[i], parm_num))
  {
    simple_uses = -1;
    break;
  }
simple_uses++;
     }

 if (simple_uses < 0
     || all_uses != simple_uses)
   {
     res = -1;
     break;
   }
 res += all_uses;
}
    else if (!stmt_unremovable_because_of_non_call_eh_p (fun, stmt)
      && ((is_gimple_assign (stmt) && !gimple_has_volatile_ops (stmt))
   || gimple_code (stmt) == GIMPLE_PHI))
{
 tree lhs;
 if (gimple_code (stmt) == GIMPLE_PHI)
   lhs = gimple_phi_result (stmt);
 else
   lhs = gimple_assign_lhs (stmt);

 if (TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) != SSA_NAME)
   {
     res = -1;
     break;
   }
 gcc_assert (!gimple_vdef (stmt))((void)(!(!gimple_vdef (stmt)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 962, __FUNCTION__), 0 : 0));
 if (bitmap_set_bit (analyzed, SSA_NAME_VERSION (lhs)(tree_check ((lhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 963, __FUNCTION__, (SSA_NAME)))->base.u.version))
   {
     int tmp = isra_track_scalar_value_uses (fun, node, lhs, parm_num,
				      analyzed);
     if (tmp < 0)
{
  res = tmp;
  break;
}
     res += tmp;
   }
}
    else
{
 res = -1;
 break;
}
  }
return res;
982}

984/* Inspect all uses of PARM, which must be a gimple register, in FUN (which is
 also described by NODE) and simple arithmetic calculations involving PARM
 and return false if any of them is used for something else than either an
 actual call argument, simple arithmetic operation or debug statement.  If
 there are no such uses, return true and store the number of actual arguments
 that this parameter eventually feeds to (or zero if there is none) to
 *CALL_USES_P.  For any such parameter, mark PARM_NUM as one of its
 sources.

 This function is similar to ptr_parm_has_nonarg_uses but its results are
 meant for unused parameter removal, as opposed to splitting of parameters
 passed by reference or converting them to passed by value.  */

997static bool
998isra_track_scalar_param_local_uses (function *fun, cgraph_node *node, tree parm,
		    int parm_num, int *call_uses_p)
1000{
gcc_checking_assert (is_gimple_reg (parm))((void)(!(is_gimple_reg (parm)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1001, __FUNCTION__), 0 : 0));

tree name = ssa_default_def (fun, parm);
if (!name || has_zero_uses (name))
  {
    *call_uses_p = 0;
    return false;
  }

/* Edge summaries can only handle callers with fewer than 256 parameters.  */
if (parm_num > UCHAR_MAX(127*2 +1))
  return true;

bitmap analyzed = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
int call_uses = isra_track_scalar_value_uses (fun, node, name, parm_num,
				analyzed);
BITMAP_FREE (analyzed)((void) (bitmap_obstack_free ((bitmap) analyzed), (analyzed) =
 (bitmap) nullptr));
if (call_uses < 0)
  return true;
*call_uses_p = call_uses;
return false;
1022}

1024/* Scan immediate uses of a default definition SSA name of a parameter PARM and
 examine whether there are any nonarg uses that are not actual arguments or
 otherwise infeasible uses.  If so, return true, otherwise return false.
 Create pass-through IPA flow records for any direct uses as argument calls
 and if returning false, store their number into *PT_COUNT_P.  NODE and FUN
 must represent the function that is currently analyzed, PARM_NUM must be the
 index of the analyzed parameter.

 This function is similar to isra_track_scalar_param_local_uses but its
 results are meant for splitting of parameters passed by reference or turning
 them into bits passed by value, as opposed to generic unused parameter
 removal.  */

1037static bool
1038ptr_parm_has_nonarg_uses (cgraph_node *node, function *fun, tree parm,
	  int parm_num, unsigned *pt_count_p)
1040{
imm_use_iterator ui;
gimple *stmt;
tree name = ssa_default_def (fun, parm);
bool ret = false;
unsigned pt_count = 0;

if (!name || has_zero_uses (name))
  return false;

/* Edge summaries can only handle callers with fewer than 256 parameters.  */
if (parm_num > UCHAR_MAX(127*2 +1))
  return true;

FOR_EACH_IMM_USE_STMT (stmt, ui, name)for (struct auto_end_imm_use_stmt_traverse auto_end_imm_use_stmt_traverse
 ((((stmt) = first_imm_use_stmt (&(ui), (name))), &(ui
))); !end_imm_use_stmt_p (&(ui)); (void) ((stmt) = next_imm_use_stmt
 (&(ui))))
  {
    unsigned uses_ok = 0;
    use_operand_p use_p;

    if (is_gimple_debug (stmt))
continue;

    if (gimple_assign_single_p (stmt))
{
 tree rhs = gimple_assign_rhs1 (stmt);
 if (!TREE_THIS_VOLATILE (rhs)((rhs)->base.volatile_flag))
   {
     while (handled_component_p (rhs))
rhs = TREE_OPERAND (rhs, 0)(*((const_cast<tree*> (tree_operand_check ((rhs), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1068, __FUNCTION__)))));
     if (TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) == MEM_REF
  && TREE_OPERAND (rhs, 0)(*((const_cast<tree*> (tree_operand_check ((rhs), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1070, __FUNCTION__))))) == name
  && integer_zerop (TREE_OPERAND (rhs, 1)(*((const_cast<tree*> (tree_operand_check ((rhs), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1071, __FUNCTION__))))))
  && types_compatible_p (TREE_TYPE (rhs)((contains_struct_check ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1072, __FUNCTION__))->typed.type),
			 TREE_TYPE (TREE_TYPE (name))((contains_struct_check ((((contains_struct_check ((name), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1073, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1073, __FUNCTION__))->typed.type)))
uses_ok++;
   }
}
    else if (is_gimple_call (stmt))
{
 gcall *call = as_a <gcall *> (stmt);
 unsigned arg_count;
 if (gimple_call_internal_p (call)
     || (arg_count = gimple_call_num_args (call)) == 0)
   {
     ret = true;
     break;
   }

 cgraph_edge *cs = node->get_edge (stmt);
 gcc_checking_assert (cs)((void)(!(cs) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1089, __FUNCTION__), 0 : 0));
 isra_call_summary *csum = call_sums->get_create (cs);
 csum->init_inputs (arg_count);

 for (unsigned i = 0; i < arg_count; ++i)
   {
     tree arg = gimple_call_arg (stmt, i);

     if (arg == name)
{
  /* TODO: Allow &MEM_REF[name + offset] here,
     ipa_param_body_adjustments::modify_call_stmt has to be
     adjusted too.  */
  csum->m_arg_flow[i].pointer_pass_through = true;
  set_single_param_flow_source (&csum->m_arg_flow[i], parm_num);
  pt_count++;
  uses_ok++;
  continue;
}

     if (!TREE_THIS_VOLATILE (arg)((arg)->base.volatile_flag))
{
  while (handled_component_p (arg))
    arg = TREE_OPERAND (arg, 0)(*((const_cast<tree*> (tree_operand_check ((arg), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1112, __FUNCTION__)))));
  if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == MEM_REF
      && TREE_OPERAND (arg, 0)(*((const_cast<tree*> (tree_operand_check ((arg), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1114, __FUNCTION__))))) == name
      && integer_zerop (TREE_OPERAND (arg, 1)(*((const_cast<tree*> (tree_operand_check ((arg), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1115, __FUNCTION__))))))
      && types_compatible_p (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1116, __FUNCTION__))->typed.type),
			     TREE_TYPE (TREE_TYPE (name))((contains_struct_check ((((contains_struct_check ((name), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1117, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1117, __FUNCTION__))->typed.type)))
    uses_ok++;
}
   }
}

    /* If the number of valid uses does not match the number of
       uses in this stmt there is an unhandled use.  */
    unsigned all_uses = 0;
    FOR_EACH_IMM_USE_ON_STMT (use_p, ui)for ((use_p) = first_imm_use_on_stmt (&(ui)); !end_imm_use_on_stmt_p
 (&(ui)); (void) ((use_p) = next_imm_use_on_stmt (&(ui
))))
all_uses++;

    gcc_checking_assert (uses_ok <= all_uses)((void)(!(uses_ok <= all_uses) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1129, __FUNCTION__), 0 : 0));
    if (uses_ok != all_uses)
{
 ret = true;
 break;
}
  }

*pt_count_p = pt_count;
return ret;
1139}

1141/* Initialize vector of parameter descriptors of NODE.  Return true if there
 are any candidates for splitting or unused aggregate parameter removal (the
 function may return false if there are candidates for removal of register
 parameters).  */

1146static bool
1147create_parameter_descriptors (cgraph_node *node,
	      vec<gensum_param_desc> *param_descriptions)
1149{
function *fun = DECL_STRUCT_FUNCTION (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1150, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f);
bool ret = false;

int num = 0;
for (tree parm = DECL_ARGUMENTS (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1154, __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-sra.cc"
, 1156, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1156, __FUNCTION__))->common.chain)), num++)
  {
    const char *msg;
    gensum_param_desc *desc = &(*param_descriptions)[num];
    /* param_descriptions vector is grown cleared in the caller.  */
    desc->param_number = num;
    decl2desc->put (parm, desc);

    if (dump_file && (dump_flags & TDF_DETAILS))
print_generic_expr (dump_file, parm, TDF_UID);

    int scalar_call_uses;
    tree type = TREE_TYPE (parm)((contains_struct_check ((parm), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1168, __FUNCTION__))->typed.type);
    if (TREE_THIS_VOLATILE (parm)((parm)->base.volatile_flag))
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, " not a candidate, is volatile\n");
 continue;
}
    if (!is_gimple_reg_type (type) && is_va_list_type (type))
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, " not a candidate, is a va_list type\n");
 continue;
}
    if (TREE_ADDRESSABLE (parm)((parm)->base.addressable_flag))
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, " not a candidate, is addressable\n");
 continue;
}
    if (TREE_ADDRESSABLE (type)((type)->base.addressable_flag))
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, " not a candidate, type cannot be split\n");
 continue;
}

    if (is_gimple_reg (parm)
 && !isra_track_scalar_param_local_uses (fun, node, parm, num,
				  &scalar_call_uses))
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, " is a scalar with only %i call uses\n",
     scalar_call_uses);

 desc->locally_unused = true;
 desc->call_uses = scalar_call_uses;
}

    if (POINTER_TYPE_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE))
{
 desc->by_ref = true;
 if (TREE_CODE (type)((enum tree_code) (type)->base.code) == REFERENCE_TYPE
     || (num == 0
  && TREE_CODE (TREE_TYPE (node->decl))((enum tree_code) (((contains_struct_check ((node->decl), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1211, __FUNCTION__))->typed.type))->base.code) == METHOD_TYPE))
   desc->safe_ref = true;
 else
   desc->safe_ref = false;
 type = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1215, __FUNCTION__))->typed.type);

 if (TREE_CODE (type)((enum tree_code) (type)->base.code) == FUNCTION_TYPE
     || TREE_CODE (type)((enum tree_code) (type)->base.code) == METHOD_TYPE)
   {
     if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " not a candidate, reference to "
	 "a function\n");
     continue;
   }
 if (TYPE_VOLATILE (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1225, __FUNCTION__))->base.volatile_flag))
   {
     if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " not a candidate, reference to "
	 "a volatile type\n");
     continue;
   }
 if (TREE_CODE (type)((enum tree_code) (type)->base.code) == ARRAY_TYPE
     && TYPE_NONALIASED_COMPONENT (type)((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1233, __FUNCTION__, (ARRAY_TYPE)))->type_common.transparent_aggr_flag
))
   {
     if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " not a candidate, reference to "
	 "a nonaliased component array\n");
     continue;
   }
 if (!is_gimple_reg (parm))
   {
     if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " not a candidate, a reference which is "
	 "not a gimple register (probably addressable)\n");
     continue;
   }
 if (is_va_list_type (type))
   {
     if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " not a candidate, reference to "
	 "a va list\n");
     continue;
   }
 if (ptr_parm_has_nonarg_uses (node, fun, parm, num,
			&desc->ptr_pt_count))
   {
     if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " not a candidate, reference has "
	 "nonarg uses\n");
     continue;
   }
}
    else if (!AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
 tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE)))
{
 /* This is in an else branch because scalars passed by reference are
    still candidates to be passed by value.  */
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, " not a candidate, not an aggregate\n");
 continue;
}

    if (!COMPLETE_TYPE_P (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1272, __FUNCTION__))->type_common.size) != (tree) nullptr
))
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, " not a candidate, not a complete type\n");
 continue;
}
    if (!tree_fits_uhwi_p (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1278, __FUNCTION__))->type_common.size)))
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, " not a candidate, size not representable\n");
 continue;
}
    unsigned HOST_WIDE_INTlong type_size
= tree_to_uhwi (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1285, __FUNCTION__))->type_common.size)) / BITS_PER_UNIT(8);
    if (type_size == 0
 || type_size >= ISRA_ARG_SIZE_LIMIT(1 << 16))
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, " not a candidate, has zero or huge size\n");
 continue;
}
    if (type_internals_preclude_sra_p (type, &msg))
{
 if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, " not a candidate, %s\n", msg);
 continue;
}

    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " is a candidate\n");

    ret = true;
    desc->split_candidate = true;
    if (desc->by_ref && !desc->safe_ref)
desc->deref_index = unsafe_by_ref_count++;
  }
return ret;
1309}

1311/* Return pointer to descriptor of parameter DECL or NULL if it cannot be
 found, which happens if DECL is for a static chain.  */

1314static gensum_param_desc *
1315get_gensum_param_desc (tree decl)
1316{
if (!decl2desc)
  return NULLnullptr;
gcc_checking_assert (TREE_CODE (decl) == PARM_DECL)((void)(!(((enum tree_code) (decl)->base.code) == PARM_DECL
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1319, __FUNCTION__), 0 : 0));
gensum_param_desc **slot = decl2desc->get (decl);
if (!slot)
  /* This can happen for static chains which we cannot handle so far.  */
  return NULLnullptr;
gcc_checking_assert (*slot)((void)(!(*slot) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1324, __FUNCTION__), 0 : 0));
return *slot;
1326}


1329/* Remove parameter described by DESC from candidates for IPA-SRA splitting and
 write REASON to the dump file if there is one.  */

1332static void
1333disqualify_split_candidate (gensum_param_desc *desc, const char *reason)
1334{
if (!desc->split_candidate)
  return;

if (dump_file && (dump_flags & TDF_DETAILS))
  fprintf (dump_file, "! Disqualifying parameter number %i - %s\n",
    desc->param_number, reason);

desc->split_candidate = false;
1343}

1345/* Remove DECL from candidates for IPA-SRA and write REASON to the dump file if
 there is one.  */

1348static void
1349disqualify_split_candidate (tree decl, const char *reason)
1350{
gensum_param_desc *desc = get_gensum_param_desc (decl);
if (desc)
  disqualify_split_candidate (desc, reason);
1354}

1356/* Allocate a new access to DESC and fill it in with OFFSET and SIZE.  But
 first, check that there are not too many of them already.  If so, do not
 allocate anything and return NULL.  */

1360static gensum_param_access *
1361allocate_access (gensum_param_desc *desc,
 HOST_WIDE_INTlong offset, HOST_WIDE_INTlong size)
1363{
if (desc->access_count
    == (unsigned) param_ipa_sra_max_replacementsglobal_options.x_param_ipa_sra_max_replacements)
  {
    disqualify_split_candidate (desc, "Too many replacement candidates");
    return NULLnullptr;
  }

gensum_param_access *access
  = (gensum_param_access *) obstack_alloc (&gensum_obstack,__extension__ ({ struct obstack *__h = (&gensum_obstack);
 __extension__ ({ struct obstack *__o = (__h); size_t __len =
 ((sizeof (gensum_param_access))); if (__extension__ ({ struct
 obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit -
 __o1->next_free); }) < __len) _obstack_newchunk (__o, __len
); ((void) ((__o)->next_free += (__len))); }); __extension__
 ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1
->object_base; if (__o1->next_free == __value) __o1->
maybe_empty_object = 1; __o1->next_free = (sizeof (ptrdiff_t
) < sizeof (void *) ? ((__o1->object_base) + (((__o1->
next_free) - (__o1->object_base) + (__o1->alignment_mask
)) & ~(__o1->alignment_mask))) : (char *) (((ptrdiff_t
) (__o1->next_free) + (__o1->alignment_mask)) & ~(__o1
->alignment_mask))); if ((size_t) (__o1->next_free - (char
 *) __o1->chunk) > (size_t) (__o1->chunk_limit - (char
 *) __o1->chunk)) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; __value; }); })
			     sizeof (gensum_param_access))__extension__ ({ struct obstack *__h = (&gensum_obstack);
 __extension__ ({ struct obstack *__o = (__h); size_t __len =
 ((sizeof (gensum_param_access))); if (__extension__ ({ struct
 obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit -
 __o1->next_free); }) < __len) _obstack_newchunk (__o, __len
); ((void) ((__o)->next_free += (__len))); }); __extension__
 ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1
->object_base; if (__o1->next_free == __value) __o1->
maybe_empty_object = 1; __o1->next_free = (sizeof (ptrdiff_t
) < sizeof (void *) ? ((__o1->object_base) + (((__o1->
next_free) - (__o1->object_base) + (__o1->alignment_mask
)) & ~(__o1->alignment_mask))) : (char *) (((ptrdiff_t
) (__o1->next_free) + (__o1->alignment_mask)) & ~(__o1
->alignment_mask))); if ((size_t) (__o1->next_free - (char
 *) __o1->chunk) > (size_t) (__o1->chunk_limit - (char
 *) __o1->chunk)) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; __value; }); });
memset (access, 0, sizeof (*access));
access->offset = offset;
access->size = size;
access->load_count = profile_count::zero ();
return access;
1379}

1381/* In what context scan_expr_access has been called, whether it deals with a
 load, a function argument, or a store.  Please note that in rare
 circumstances when it is not clear if the access is a load or store,
 ISRA_CTX_STORE is used too.  */

1386enum isra_scan_context {ISRA_CTX_LOAD, ISRA_CTX_ARG, ISRA_CTX_STORE};

1388/* Return an access describing memory access to the variable described by DESC
 at OFFSET with SIZE in context CTX, starting at pointer to the linked list
 at a certain tree level FIRST.  Attempt to create it and put into the
 appropriate place in the access tree if does not exist, but fail and return
 NULL if there are already too many accesses, if it would create a partially
 overlapping access or if an access would end up within a pre-existing
 non-call access.  */

1396static gensum_param_access *
1397get_access_1 (gensum_param_desc *desc, gensum_param_access **first,
     HOST_WIDE_INTlong offset, HOST_WIDE_INTlong size, isra_scan_context ctx)
1399{
gensum_param_access *access = *first, **ptr = first;

if (!access)
  {
    /* No pre-existing access at this level, just create it.  */
    gensum_param_access *a = allocate_access (desc, offset, size);
    if (!a)
return NULLnullptr;
    *first = a;
    return *first;
  }

if (access->offset >= offset + size)
  {
    /* We want to squeeze it in front of the very first access, just do
it.  */
    gensum_param_access *r = allocate_access (desc, offset, size);
    if (!r)
return NULLnullptr;
    r->next_sibling = access;
    *first = r;
    return r;
  }

/* Skip all accesses that have to come before us until the next sibling is
   already too far.  */
while (offset >= access->offset + access->size
&& access->next_sibling
&& access->next_sibling->offset < offset + size)
  {
    ptr = &access->next_sibling;
    access = access->next_sibling;
  }

/* At this point we know we do not belong before access.  */
gcc_assert (access->offset < offset + size)((void)(!(access->offset < offset + size) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1435, __FUNCTION__), 0 : 0));

if (access->offset == offset && access->size == size)
  /* We found what we were looking for.  */
  return access;

if (access->offset <= offset
    && access->offset + access->size >= offset + size)
  {
  /* We fit into access which is larger than us.  We need to find/create
     something below access.  But we only allow nesting in call
     arguments.  */
    if (access->nonarg)
return NULLnullptr;

    return get_access_1 (desc, &access->first_child, offset, size, ctx);
  }

if (offset <= access->offset
    && offset + size  >= access->offset + access->size)
  /* We are actually bigger than access, which fully fits into us, take its
     place and make all accesses fitting into it its children.  */
  {
    /* But first, we only allow nesting in call arguments so check if that is
what we are trying to represent.  */
    if (ctx != ISRA_CTX_ARG)
return NULLnullptr;

    gensum_param_access *r = allocate_access (desc, offset, size);
    if (!r)
return NULLnullptr;
    r->first_child = access;

    while (access->next_sibling
    && access->next_sibling->offset < offset + size)
access = access->next_sibling;
    if (access->offset + access->size > offset + size)
{
 /* This must be a different access, which are sorted, so the
    following must be true and this signals a partial overlap.  */
 gcc_assert (access->offset > offset)((void)(!(access->offset > offset) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1475, __FUNCTION__), 0 : 0));
 return NULLnullptr;
}

    r->next_sibling = access->next_sibling;
    access->next_sibling = NULLnullptr;
    *ptr = r;
    return r;
  }

if (offset >= access->offset + access->size)
  {
    /* We belong after access.  */
    gensum_param_access *r = allocate_access (desc, offset, size);
    if (!r)
return NULLnullptr;
    r->next_sibling = access->next_sibling;
    access->next_sibling = r;
    return r;
  }

if (offset < access->offset)
  {
    /* We know the following, otherwise we would have created a
super-access. */
    gcc_checking_assert (offset + size < access->offset + access->size)((void)(!(offset + size < access->offset + access->size
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1500, __FUNCTION__), 0 : 0));
    return NULLnullptr;
  }

if (offset + size > access->offset + access->size)
  {
    /* Likewise.  */
    gcc_checking_assert (offset > access->offset)((void)(!(offset > access->offset) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1507, __FUNCTION__), 0 : 0));
    return NULLnullptr;
  }

gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1511, __FUNCTION__));
1512}

1514/* Return an access describing memory access to the variable described by DESC
 at OFFSET with SIZE in context CTX, mark it as used in context CTX.  Attempt
 to create if it does not exist, but fail and return NULL if there are
 already too many accesses, if it would create a partially overlapping access
 or if an access would end up in a non-call access.  */

1520static gensum_param_access *
1521get_access (gensum_param_desc *desc, HOST_WIDE_INTlong offset, HOST_WIDE_INTlong size,
   isra_scan_context ctx)
1523{
gcc_checking_assert (desc->split_candidate)((void)(!(desc->split_candidate) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1524, __FUNCTION__), 0 : 0));

gensum_param_access *access = get_access_1 (desc, &desc->accesses, offset,
			      size, ctx);
if (!access)
  {
    disqualify_split_candidate (desc,
		  "Bad access overlap or too many accesses");
    return NULLnullptr;
  }

switch (ctx)
  {
  case ISRA_CTX_STORE:
    gcc_assert (!desc->by_ref)((void)(!(!desc->by_ref) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1538, __FUNCTION__), 0 : 0));
    /* Fall-through */
  case ISRA_CTX_LOAD:
    access->nonarg = true;
    break;
  case ISRA_CTX_ARG:
    break;
  }

return access;
1548}

1550/* Verify that parameter access tree starting with ACCESS is in good shape.
 PARENT_OFFSET and PARENT_SIZE are the corresponding fields of parent of
 ACCESS or zero if there is none.  */

1554static bool
1555verify_access_tree_1 (gensum_param_access *access, HOST_WIDE_INTlong parent_offset,
      HOST_WIDE_INTlong parent_size)
1557{
while (access)
  {
    gcc_assert (access->offset >= 0 && access->size >= 0)((void)(!(access->offset >= 0 && access->size
 >= 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1560, __FUNCTION__), 0 : 0));

    if (parent_size != 0)
{
 if (access->offset < parent_offset)
   {
     error ("Access offset before parent offset");
     return true;
   }
 if (access->size >= parent_size)
   {
     error ("Access size greater or equal to its parent size");
     return true;
   }
 if (access->offset + access->size > parent_offset + parent_size)
   {
     error ("Access terminates outside of its parent");
     return true;
   }
}

    if (verify_access_tree_1 (access->first_child, access->offset,
		access->size))
return true;

    if (access->next_sibling
 && (access->next_sibling->offset < access->offset + access->size))
{
 error ("Access overlaps with its sibling");
 return true;
}

    access = access->next_sibling;
  }
return false;
1595}

1597/* Verify that parameter access tree starting with ACCESS is in good shape,
 halt compilation and dump the tree to stderr if not.  */

1600DEBUG_FUNCTION__attribute__ ((__used__)) void
1601isra_verify_access_tree (gensum_param_access *access)
1602{
if (verify_access_tree_1 (access, 0, 0))
  {
    for (; access; access = access->next_sibling)
      dump_gensum_access (stderrstderr, access, 2);
    internal_error ("IPA-SRA access verification failed");
  }
1609}


1612/* Callback of walk_stmt_load_store_addr_ops visit_addr used to determine
 GIMPLE_ASM operands with memory constrains which cannot be scalarized.  */

1615static bool
1616asm_visit_addr (gimple *, tree op, tree, void *)
1617{
op = get_base_address (op);
if (op
    && TREE_CODE (op)((enum tree_code) (op)->base.code) == PARM_DECL)
  disqualify_split_candidate (op, "Non-scalarizable GIMPLE_ASM operand.");

return false;
1624}

1626/* Mark a dereference of parameter identified by DESC of distance DIST in a
 basic block BB, unless the BB has already been marked as a potentially
 final.  */

1630static void
1631mark_param_dereference (gensum_param_desc *desc, HOST_WIDE_INTlong dist,
	basic_block bb)
1633{
gcc_assert (desc->by_ref)((void)(!(desc->by_ref) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1634, __FUNCTION__), 0 : 0));
gcc_checking_assert (desc->split_candidate)((void)(!(desc->split_candidate) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1635, __FUNCTION__), 0 : 0));

if (desc->safe_ref
    || bitmap_bit_p (final_bbs, bb->index))
  return;

int idx = bb->index * unsafe_by_ref_count + desc->deref_index;
if (bb_dereferences[idx] < dist)
  bb_dereferences[idx] = dist;
1644}

1646/* Return true, if any potential replacements should use NEW_TYPE as opposed to
 previously recorded OLD_TYPE.  */

1649static bool
1650type_prevails_p (tree old_type, tree new_type)
1651{
if (old_type == new_type)
  return false;

/* Non-aggregates are always better.  */
if (!is_gimple_reg_type (old_type)
    && is_gimple_reg_type (new_type))
  return true;
if (is_gimple_reg_type (old_type)
    && !is_gimple_reg_type (new_type))
  return false;

/* Prefer any complex or vector type over any other scalar type.  */
if (TREE_CODE (old_type)((enum tree_code) (old_type)->base.code) != COMPLEX_TYPE
    && TREE_CODE (old_type)((enum tree_code) (old_type)->base.code) != VECTOR_TYPE
    && (TREE_CODE (new_type)((enum tree_code) (new_type)->base.code) == COMPLEX_TYPE
 || TREE_CODE (new_type)((enum tree_code) (new_type)->base.code) == VECTOR_TYPE))
  return true;
if ((TREE_CODE (old_type)((enum tree_code) (old_type)->base.code) == COMPLEX_TYPE
     || TREE_CODE (old_type)((enum tree_code) (old_type)->base.code) == VECTOR_TYPE)
    && TREE_CODE (new_type)((enum tree_code) (new_type)->base.code) != COMPLEX_TYPE
    && TREE_CODE (new_type)((enum tree_code) (new_type)->base.code) != VECTOR_TYPE)
  return false;

/* Use the integral type with the bigger precision.  */
if (INTEGRAL_TYPE_P (old_type)(((enum tree_code) (old_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (old_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (old_type)->base.code) == INTEGER_TYPE
)
    && INTEGRAL_TYPE_P (new_type)(((enum tree_code) (new_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (new_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (new_type)->base.code) == INTEGER_TYPE
))
  return (TYPE_PRECISION (new_type)((tree_class_check ((new_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1678, __FUNCTION__))->type_common.precision) > TYPE_PRECISION (old_type)((tree_class_check ((old_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1678, __FUNCTION__))->type_common.precision));

/* Attempt to disregard any integral type with non-full precision.  */
if (INTEGRAL_TYPE_P (old_type)(((enum tree_code) (old_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (old_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (old_type)->base.code) == INTEGER_TYPE
)
    && (TREE_INT_CST_LOW (TYPE_SIZE (old_type))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
 ((old_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1682, __FUNCTION__))->type_common.size)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1682, __FUNCTION__)))
 != TYPE_PRECISION (old_type)((tree_class_check ((old_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1683, __FUNCTION__))->type_common.precision)))
  return true;
if (INTEGRAL_TYPE_P (new_type)(((enum tree_code) (new_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (new_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (new_type)->base.code) == INTEGER_TYPE
)
    && (TREE_INT_CST_LOW (TYPE_SIZE (new_type))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
 ((new_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1686, __FUNCTION__))->type_common.size)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1686, __FUNCTION__)))
 != TYPE_PRECISION (new_type)((tree_class_check ((new_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1687, __FUNCTION__))->type_common.precision)))
  return false;
/* Stabilize the selection.  */
return TYPE_UID (old_type)((tree_class_check ((old_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1690, __FUNCTION__))->type_common.uid) < TYPE_UID (new_type)((tree_class_check ((new_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1690, __FUNCTION__))->type_common.uid);
1691}

1693/* When scanning an expression which is a call argument, this structure
 specifies the call and the position of the argument.  */

1696struct scan_call_info
1697{
/* Call graph edge representing the call. */
cgraph_edge *cs;
/* Total number of arguments in the call.  */
unsigned argument_count;
/* Number of the actual argument being scanned.  */
unsigned arg_idx;
1704};

1706/* Record use of ACCESS which belongs to a parameter described by DESC in a
 call argument described by CALL_INFO.  */

1709static void
1710record_nonregister_call_use (gensum_param_desc *desc,
	     scan_call_info *call_info,
	     unsigned unit_offset, unsigned unit_size)
1713{
isra_call_summary *csum = call_sums->get_create (call_info->cs);
csum->init_inputs (call_info->argument_count);

isra_param_flow *param_flow = &csum->m_arg_flow[call_info->arg_idx];
param_flow->aggregate_pass_through = true;
set_single_param_flow_source (param_flow, desc->param_number);
param_flow->unit_offset = unit_offset;
param_flow->unit_size = unit_size;
desc->call_uses++;
1723}

1725/* Callback of walk_aliased_vdefs, just mark that there was a possible
 modification.  */

1728static bool
1729mark_maybe_modified (ao_ref *, tree, void *data)
1730{
bool *maybe_modified = (bool *) data;
*maybe_modified = true;
return true;
1734}

1736/* Analyze expression EXPR from GIMPLE for accesses to parameters. CTX
 specifies whether EXPR is used in a load, store or as an argument call. BB
 must be the basic block in which expr resides.  If CTX specifies call
 argument context, CALL_INFO must describe that call and argument position,
 otherwise it is ignored.  */

1742static void
1743scan_expr_access (tree expr, gimple *stmt, isra_scan_context ctx,
  basic_block bb, scan_call_info *call_info = NULLnullptr)
1745{
poly_int64 poffset, psize, pmax_size;
HOST_WIDE_INTlong offset, size, max_size;
tree base;
bool deref = false;
bool reverse;

if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == ADDR_EXPR)
  {
    if (ctx == ISRA_CTX_ARG)
return;
    tree t = get_base_address (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1756, __FUNCTION__))))));
    if (TREE_CODE (t)((enum tree_code) (t)->base.code) == VAR_DECL && !TREE_STATIC (t)((t)->base.static_flag))
loaded_decls->add (t);
    return;
  }
if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == SSA_NAME
    || CONSTANT_CLASS_P (expr)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (expr)->base.code))] == tcc_constant))
  return;

if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == BIT_FIELD_REF
    || TREE_CODE (expr)((enum tree_code) (expr)->base.code) == IMAGPART_EXPR
    || TREE_CODE (expr)((enum tree_code) (expr)->base.code) == REALPART_EXPR)
  expr = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1768, __FUNCTION__)))));

base = get_ref_base_and_extent (expr, &poffset, &psize, &pmax_size, &reverse);

if (TREE_CODE (base)((enum tree_code) (base)->base.code) == MEM_REF)
  {
    tree op = TREE_OPERAND (base, 0)(*((const_cast<tree*> (tree_operand_check ((base), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1774, __FUNCTION__)))));
    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-sra.cc"
, 1776, __FUNCTION__, (SSA_NAME)))->base.default_def_flag)
return;
    base = SSA_NAME_VAR (op)((tree_check ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1778, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((op)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (op)->ssa_name
.var);
    if (!base)
return;
    deref = true;
  }
else if (TREE_CODE (base)((enum tree_code) (base)->base.code) == VAR_DECL
  && !TREE_STATIC (base)((base)->base.static_flag)
  && (ctx == ISRA_CTX_ARG
      || ctx == ISRA_CTX_LOAD))
  loaded_decls->add (base);

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

gensum_param_desc *desc = get_gensum_param_desc (base);
if (!desc || !desc->split_candidate)
  return;

if (!poffset.is_constant (&offset)
    || !psize.is_constant (&size)
    || !pmax_size.is_constant (&max_size))
  {
    disqualify_split_candidate (desc, "Encountered a polynomial-sized "
		  "access.");
    return;
  }
if (size < 0 || size != max_size)
  {
    disqualify_split_candidate (desc, "Encountered a variable sized access.");
    return;
  }
if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == COMPONENT_REF
    && DECL_BIT_FIELD (TREE_OPERAND (expr, 1))((tree_check (((*((const_cast<tree*> (tree_operand_check
 ((expr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1810, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1810, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
))
  {
    disqualify_split_candidate (desc, "Encountered a bit-field access.");
    return;
  }
if (offset < 0)
  {
    disqualify_split_candidate (desc, "Encountered an access at a "
		  "negative offset.");
    return;
  }
gcc_assert ((offset % BITS_PER_UNIT) == 0)((void)(!((offset % (8)) == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1821, __FUNCTION__), 0 : 0));
gcc_assert ((size % BITS_PER_UNIT) == 0)((void)(!((size % (8)) == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1822, __FUNCTION__), 0 : 0));
if ((offset / BITS_PER_UNIT(8)) >= (UINT_MAX(2147483647 *2U +1U) - ISRA_ARG_SIZE_LIMIT(1 << 16))
    || (size / BITS_PER_UNIT(8)) >= ISRA_ARG_SIZE_LIMIT(1 << 16))
  {
    disqualify_split_candidate (desc, "Encountered an access with too big "
		  "offset or size");
    return;
  }

tree type = TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1831, __FUNCTION__))->typed.type);
unsigned int exp_align = get_object_alignment (expr);

if (exp_align < TYPE_ALIGN (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1834, __FUNCTION__))->type_common.align) ? ((unsigned)1)
 << (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1834, __FUNCTION__))->type_common.align) - 1) : 0))
  {
    disqualify_split_candidate (desc, "Underaligned access.");
    return;
  }

if (deref)
  {
    if (!desc->by_ref)
{
 disqualify_split_candidate (desc, "Dereferencing a non-reference.");
 return;
}
    else if (ctx == ISRA_CTX_STORE)
{
 disqualify_split_candidate (desc, "Storing to data passed by "
		      "reference.");
 return;
}

    if (!aa_walking_limit)
{
 disqualify_split_candidate (desc, "Out of alias analysis step "
		      "limit.");
 return;
}

    gcc_checking_assert (gimple_vuse (stmt))((void)(!(gimple_vuse (stmt)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1861, __FUNCTION__), 0 : 0));
    bool maybe_modified = false;
    ao_ref ar;

    ao_ref_init (&ar, expr);
    bitmap visited = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
    int walked = walk_aliased_vdefs (&ar, gimple_vuse (stmt),
		       mark_maybe_modified, &maybe_modified,
		       &visited, NULLnullptr, aa_walking_limit);
    BITMAP_FREE (visited)((void) (bitmap_obstack_free ((bitmap) visited), (visited) = (
bitmap) nullptr));
    if (walked > 0)
{
 gcc_assert (aa_walking_limit > walked)((void)(!(aa_walking_limit > walked) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1873, __FUNCTION__), 0 : 0));
 aa_walking_limit = aa_walking_limit - walked;
}
    if (walked < 0)
aa_walking_limit = 0;
    if (maybe_modified || walked < 0)
{
 disqualify_split_candidate (desc, "Data passed by reference possibly "
		      "modified through an alias.");
 return;
}
    else
mark_param_dereference (desc, offset + size, bb);
  }
else
  /* Pointer parameters with direct uses should have been ruled out by
     analyzing SSA default def when looking at the parameters.  */
  gcc_assert (!desc->by_ref)((void)(!(!desc->by_ref) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1890, __FUNCTION__), 0 : 0));

gensum_param_access *access = get_access (desc, offset, size, ctx);
if (!access)
  return;

if (ctx == ISRA_CTX_ARG)
  {
    gcc_checking_assert (call_info)((void)(!(call_info) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1898, __FUNCTION__), 0 : 0));

    if (!deref)
record_nonregister_call_use (desc, call_info, offset / BITS_PER_UNIT(8),
		     size / BITS_PER_UNIT(8));
    else
/* This is not a pass-through of a pointer, this is a use like any
  other.  */
access->nonarg = true;
  }
else if (ctx == ISRA_CTX_LOAD && bb->count.initialized_p ())
  access->load_count += bb->count;

if (!access->type)
  {
    access->type = type;
    access->alias_ptr_type = reference_alias_ptr_type (expr);
    access->reverse = reverse;
  }
else
  {
    if (exp_align < TYPE_ALIGN (access->type)(((tree_class_check ((access->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1919, __FUNCTION__))->type_common.align) ? ((unsigned)1)
 << (((tree_class_check ((access->type), (tcc_type),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1919, __FUNCTION__))->type_common.align) - 1) : 0))
{
 disqualify_split_candidate (desc, "Reference has lower alignment "
		      "than a previous one.");
 return;
}
    if (access->alias_ptr_type != reference_alias_ptr_type (expr))
{
 disqualify_split_candidate (desc, "Multiple alias pointer types.");
 return;
}
    if (access->reverse != reverse)
{
 disqualify_split_candidate (desc, "Both normal and reverse "
		      "scalar storage order.");
 return;
}
    if (!deref
 && (AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
 tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE)) || AGGREGATE_TYPE_P (access->type)(((enum tree_code) (access->type)->base.code) == ARRAY_TYPE
 || (((enum tree_code) (access->type)->base.code) == RECORD_TYPE
 || ((enum tree_code) (access->type)->base.code) == UNION_TYPE
 || ((enum tree_code) (access->type)->base.code) == QUAL_UNION_TYPE
)))
 && (TYPE_MAIN_VARIANT (access->type)((tree_class_check ((access->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1938, __FUNCTION__))->type_common.main_variant) != TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 1938, __FUNCTION__))->type_common.main_variant)))
{
 /* We need the same aggregate type on all accesses to be able to
    distinguish transformation spots from pass-through arguments in
    the transformation phase.  */
 disqualify_split_candidate (desc, "We do not support aggregate "
		      "type punning.");
 return;
}

    if (type_prevails_p (access->type, type))
access->type = type;
  }
1951}

1953/* Scan body function described by NODE and FUN and create access trees for
 parameters.  */

1956static void
1957scan_function (cgraph_node *node, struct function *fun)
1958{
basic_block bb;

FOR_EACH_BB_FN (bb, fun)for (bb = (fun)->cfg->x_entry_block_ptr->next_bb; bb
 != (fun)->cfg->x_exit_block_ptr; bb = bb->next_bb)
  {
    gimple_stmt_iterator gsi;
    for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
 gimple *stmt = gsi_stmt (gsi);

 if (final_bbs && stmt_can_throw_external (fun, stmt))
   bitmap_set_bit (final_bbs, bb->index);
 switch (gimple_code (stmt))
   {
   case GIMPLE_RETURN:
     {
tree t = gimple_return_retval (as_a <greturn *> (stmt));
if (t != NULL_TREE(tree) nullptr)
  scan_expr_access (t, stmt, ISRA_CTX_LOAD, bb);
if (final_bbs)
  bitmap_set_bit (final_bbs, bb->index);
     }
     break;

   case GIMPLE_ASSIGN:
     if (gimple_assign_single_p (stmt)
  && !gimple_clobber_p (stmt))
{
  tree rhs = gimple_assign_rhs1 (stmt);
  scan_expr_access (rhs, stmt, ISRA_CTX_LOAD, bb);
  tree lhs = gimple_assign_lhs (stmt);
  scan_expr_access (lhs, stmt, ISRA_CTX_STORE, bb);
}
     break;

   case GIMPLE_CALL:
     {
unsigned argument_count = gimple_call_num_args (stmt);
isra_scan_context ctx = ISRA_CTX_ARG;
scan_call_info call_info, *call_info_p = &call_info;
if (gimple_call_internal_p (stmt))
  {
    call_info_p = NULLnullptr;
    ctx = ISRA_CTX_LOAD;
    internal_fn ifn = gimple_call_internal_fn (stmt);
    if (internal_store_fn_p (ifn))
      ctx = ISRA_CTX_STORE;
  }
else
  {
    call_info.cs = node->get_edge (stmt);
    call_info.argument_count = argument_count;
  }

for (unsigned i = 0; i < argument_count; i++)
  {
    call_info.arg_idx = i;
    scan_expr_access (gimple_call_arg (stmt, i), stmt,
		      ctx, bb, call_info_p);
  }

tree lhs = gimple_call_lhs (stmt);
if (lhs)
  scan_expr_access (lhs, stmt, ISRA_CTX_STORE, bb);
int flags = gimple_call_flags (stmt);
if (final_bbs
    && (((flags & (ECF_CONST(1 << 0) | ECF_PURE(1 << 1))) == 0)
	|| (flags & ECF_LOOPING_CONST_OR_PURE(1 << 2))))
  bitmap_set_bit (final_bbs, bb->index);
     }
     break;

   case GIMPLE_ASM:
     {
gasm *asm_stmt = as_a <gasm *> (stmt);
walk_stmt_load_store_addr_ops (asm_stmt, NULLnullptr, NULLnullptr, NULLnullptr,
			       asm_visit_addr);
if (final_bbs)
  bitmap_set_bit (final_bbs, bb->index);

for (unsigned i = 0; i < gimple_asm_ninputs (asm_stmt); i++)
  {
    tree t = TREE_VALUE (gimple_asm_input_op (asm_stmt, i))((tree_check ((gimple_asm_input_op (asm_stmt, i)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2040, __FUNCTION__, (TREE_LIST)))->list.value);
    scan_expr_access (t, stmt, ISRA_CTX_LOAD, bb);
  }
for (unsigned i = 0; i < gimple_asm_noutputs (asm_stmt); i++)
  {
    tree t = TREE_VALUE (gimple_asm_output_op (asm_stmt, i))((tree_check ((gimple_asm_output_op (asm_stmt, i)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2045, __FUNCTION__, (TREE_LIST)))->list.value);
    scan_expr_access (t, stmt, ISRA_CTX_STORE, bb);
  }
     }
     break;

   default:
     break;
   }
}
  }
2056}

2058/* Return true if SSA_NAME NAME of function described by FUN is only used in
 return statements, or if results of any operations it is involved in are
 only used in return statements.  ANALYZED is a bitmap that tracks which SSA
 names we have already started investigating.  */

2063static bool
2064ssa_name_only_returned_p (function *fun, tree name, bitmap analyzed)
2065{
bool res = true;
imm_use_iterator imm_iter;
gimple *stmt;

FOR_EACH_IMM_USE_STMT (stmt, imm_iter, name)for (struct auto_end_imm_use_stmt_traverse auto_end_imm_use_stmt_traverse
 ((((stmt) = first_imm_use_stmt (&(imm_iter), (name))), &
(imm_iter))); !end_imm_use_stmt_p (&(imm_iter)); (void) (
(stmt) = next_imm_use_stmt (&(imm_iter))))
  {
    if (is_gimple_debug (stmt))
continue;

    if (gimple_code (stmt) == GIMPLE_RETURN)
{
 tree t = gimple_return_retval (as_a <greturn *> (stmt));
 if (t != name)
   {
     res = false;
     break;
   }
}
    else if (!stmt_unremovable_because_of_non_call_eh_p (fun, stmt)
      && ((is_gimple_assign (stmt) && !gimple_has_volatile_ops (stmt))
   || gimple_code (stmt) == GIMPLE_PHI))
{
 /* TODO: And perhaps for const function calls too?  */
 tree lhs;
 if (gimple_code (stmt) == GIMPLE_PHI)
   lhs = gimple_phi_result (stmt);
 else
   lhs = gimple_assign_lhs (stmt);

 if (TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) != SSA_NAME)
   {
     res = false;
     break;
   }
 gcc_assert (!gimple_vdef (stmt))((void)(!(!gimple_vdef (stmt)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2100, __FUNCTION__), 0 : 0));
 if (bitmap_set_bit (analyzed, SSA_NAME_VERSION (lhs)(tree_check ((lhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2101, __FUNCTION__, (SSA_NAME)))->base.u.version)
     && !ssa_name_only_returned_p (fun, lhs, analyzed))
   {
     res = false;
     break;
   }
}
    else
{
 res = false;
 break;
}
  }
return res;
2115}

2117/* Inspect the uses of the return value of the call associated with CS, and if
 it is not used or if it is only used to construct the return value of the
 caller, mark it as such in call or caller summary.  Also check for
 misaligned arguments.  */

2122static void
2123isra_analyze_call (cgraph_edge *cs)
2124{
gcall *call_stmt = cs->call_stmt;
unsigned count = gimple_call_num_args (call_stmt);
isra_call_summary *csum = call_sums->get_create (cs);

for (unsigned i = 0; i < count; i++)
  {
    tree arg = gimple_call_arg (call_stmt, i);
    if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == ADDR_EXPR)
{
 poly_int64 poffset, psize, pmax_size;
 bool reverse;
 tree base = get_ref_base_and_extent (TREE_OPERAND (arg, 0)(*((const_cast<tree*> (tree_operand_check ((arg), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2136, __FUNCTION__))))), &poffset,
			       &psize, &pmax_size, &reverse);
 HOST_WIDE_INTlong offset;
 unsigned HOST_WIDE_INTlong ds;
 if (DECL_P (base)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (base)->base.code))] == tcc_declaration)
     && (poffset.is_constant (&offset))
     && tree_fits_uhwi_p (DECL_SIZE (base)((contains_struct_check ((base), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2142, __FUNCTION__))->decl_common.size))
     && ((ds = tree_to_uhwi (DECL_SIZE (base)((contains_struct_check ((base), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2143, __FUNCTION__))->decl_common.size)) - offset)
  < ISRA_ARG_SIZE_LIMIT(1 << 16) * BITS_PER_UNIT(8)))
   {
     csum->init_inputs (count);
     gcc_assert (!csum->m_arg_flow[i].aggregate_pass_through)((void)(!(!csum->m_arg_flow[i].aggregate_pass_through) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2147, __FUNCTION__), 0 : 0));
     csum->m_arg_flow[i].unit_size = ds / BITS_PER_UNIT(8);
   }

 if (TREE_CODE (base)((enum tree_code) (base)->base.code) == VAR_DECL
     && !TREE_STATIC (base)((base)->base.static_flag)
     && !loaded_decls->contains (base))
   {
     csum->init_inputs (count);
     csum->m_arg_flow[i].constructed_for_calls = true;
   }
}

    if (is_gimple_reg (arg))
continue;

    tree offset;
    poly_int64 bitsize, bitpos;
    machine_mode mode;
    int unsignedp, reversep, volatilep = 0;
    get_inner_reference (arg, &bitsize, &bitpos, &offset, &mode,
	   &unsignedp, &reversep, &volatilep);
    if (!multiple_p (bitpos, BITS_PER_UNIT(8)))
{
 csum->m_bit_aligned_arg = true;
 break;
}
  }

tree lhs = gimple_call_lhs (call_stmt);
if (lhs)
  {
    /* TODO: Also detect aggregates on a LHS of a call that are only returned
from this function (without being read anywhere).  */
    if (TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == SSA_NAME)
{
 bitmap analyzed = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
 if (ssa_name_only_returned_p (DECL_STRUCT_FUNCTION (cs->caller->decl)((tree_check ((cs->caller->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2184, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f),
			lhs, analyzed))
   csum->m_return_returned = true;
 BITMAP_FREE (analyzed)((void) (bitmap_obstack_free ((bitmap) analyzed), (analyzed) =
 (bitmap) nullptr));
}
  }
else
  csum->m_return_ignored = true;
2192}

2194/* Look at all calls going out of NODE, described also by IFS and perform all
 analyses necessary for IPA-SRA that are not done at body scan time or done
 even when body is not scanned because the function is not a candidate.  */

2198static void
2199isra_analyze_all_outgoing_calls (cgraph_node *node)
2200{
for (cgraph_edge *cs = node->callees; cs; cs = cs->next_callee)
  isra_analyze_call (cs);
for (cgraph_edge *cs = node->indirect_calls; cs; cs = cs->next_callee)
  isra_analyze_call (cs);
2205}

2207/* Dump a dereferences table with heading STR to file F.  */

2209static void
2210dump_dereferences_table (FILE *f, struct function *fun, const char *str)
2211{
basic_block bb;

fprintf (dump_file, "%s", str);
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (fun),for (bb = ((fun)->cfg->x_entry_block_ptr); bb != ((fun)
->cfg->x_exit_block_ptr); bb = bb->next_bb)
  EXIT_BLOCK_PTR_FOR_FN (fun), next_bb)for (bb = ((fun)->cfg->x_entry_block_ptr); bb != ((fun)
->cfg->x_exit_block_ptr); bb = bb->next_bb)
  {
    fprintf (f, "%4i  %i   ", bb->index, bitmap_bit_p (final_bbs, bb->index));
    if (bb != EXIT_BLOCK_PTR_FOR_FN (fun)((fun)->cfg->x_exit_block_ptr))
{
 int i;
 for (i = 0; i < unsafe_by_ref_count; i++)
   {
     int idx = bb->index * unsafe_by_ref_count + i;
     fprintf (f, " %4" HOST_WIDE_INT_PRINT"l" "d", bb_dereferences[idx]);
   }
}
    fprintf (f, "\n");
  }
fprintf (dump_file, "\n");
2231}

2233/* Propagate distances in bb_dereferences in the opposite direction than the
 control flow edges, in each step storing the maximum of the current value
 and the minimum of all successors.  These steps are repeated until the table
 stabilizes.  Note that BBs which might terminate the functions (according to
 final_bbs bitmap) never updated in this way.  */

2239static void
2240propagate_dereference_distances (struct function *fun)
2241{
basic_block bb;

if (dump_file && (dump_flags & TDF_DETAILS))
  dump_dereferences_table (dump_file, fun,
	     "Dereference table before propagation:\n");

auto_vec<basic_block> queue (last_basic_block_for_fn (fun)((fun)->cfg->x_last_basic_block));
queue.quick_push (ENTRY_BLOCK_PTR_FOR_FN (fun)((fun)->cfg->x_entry_block_ptr));
FOR_EACH_BB_FN (bb, fun)for (bb = (fun)->cfg->x_entry_block_ptr->next_bb; bb
 != (fun)->cfg->x_exit_block_ptr; bb = bb->next_bb)
  {
    queue.quick_push (bb);
    bb->aux = bb;
  }

while (!queue.is_empty ())
  {
    edge_iterator ei;
    edge e;
    bool change = false;
    int i;

    bb = queue.pop ();
    bb->aux = NULLnullptr;

    if (bitmap_bit_p (final_bbs, bb->index))
continue;

    for (i = 0; i < unsafe_by_ref_count; i++)
{
 int idx = bb->index * unsafe_by_ref_count + i;
 bool first = true;
 HOST_WIDE_INTlong inh = 0;

 FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
 {
   int succ_idx = e->dest->index * unsafe_by_ref_count + i;

   if (e->dest == EXIT_BLOCK_PTR_FOR_FN (fun)((fun)->cfg->x_exit_block_ptr))
     continue;

   if (first)
     {
first = false;
inh = bb_dereferences [succ_idx];
     }
   else if (bb_dereferences [succ_idx] < inh)
     inh = bb_dereferences [succ_idx];
 }

 if (!first && bb_dereferences[idx] < inh)
   {
     bb_dereferences[idx] = inh;
     change = true;
   }
}

    if (change)
FOR_EACH_EDGE (e, ei, bb->preds)for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
 {
   if (e->src->aux)
     continue;

   e->src->aux = e->src;
   queue.quick_push (e->src);
 }
  }

if (dump_file && (dump_flags & TDF_DETAILS))
  dump_dereferences_table (dump_file, fun,
	     "Dereference table after propagation:\n");
2312}

2314/* Return true if the ACCESS loads happen frequently enough in FUN to risk
 moving them to the caller and only pass the result.  */

2317static bool
2318dereference_probable_p (struct function *fun, gensum_param_access *access)
2319{
int threshold = opt_for_fn (fun->decl, param_ipa_sra_deref_prob_threshold)(opts_for_fn (fun->decl)->x_param_ipa_sra_deref_prob_threshold
);
return access->load_count
  >= ENTRY_BLOCK_PTR_FOR_FN (fun)((fun)->cfg->x_entry_block_ptr)->count.apply_scale (threshold, 100);
2323}

2325/* Perform basic checks on ACCESS to PARM (of FUN) described by DESC and all
 its children, return true if the parameter cannot be split, otherwise return
 false and update *NONARG_ACC_SIZE and *ONLY_CALLS.  ENTRY_BB_INDEX must be
 the index of the entry BB in the function of PARM.  */

2330static bool
2331check_gensum_access (struct function *fun, tree parm, gensum_param_desc *desc,
     gensum_param_access *access,
     HOST_WIDE_INTlong *nonarg_acc_size, bool *only_calls,
     int entry_bb_index)
2335{
if (access->nonarg)
  {
    *only_calls = false;
    *nonarg_acc_size += access->size;

    if (access->first_child)
{
 disqualify_split_candidate (desc, "Overlapping non-call uses.");
 return true;
}
  }
/* Do not decompose a non-BLKmode param in a way that would create
   BLKmode params.  Especially for by-reference passing (thus,
   pointer-type param) this is hardly worthwhile.  */
if (DECL_MODE (parm)((contains_struct_check ((parm), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2350, __FUNCTION__))->decl_common.mode) != BLKmode((void) 0, E_BLKmode)
    && TYPE_MODE (access->type)((((enum tree_code) ((tree_class_check ((access->type), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2351, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (access->type) : (access->type)->type_common.mode) == BLKmode((void) 0, E_BLKmode))
  {
    disqualify_split_candidate (desc, "Would convert a non-BLK to a BLK.");
    return true;
  }

if (desc->by_ref)
  {
    if (desc->safe_ref)
{
 if (!dereference_probable_p (fun, access))
   {
     disqualify_split_candidate (desc, "Dereferences in callers "
			  "would happen much more frequently.");
     return true;
   }
}
    else
{
 int idx = (entry_bb_index * unsafe_by_ref_count + desc->deref_index);
 if ((access->offset + access->size) > bb_dereferences[idx])
   {
     if (!dereference_probable_p (fun, access))
{
  disqualify_split_candidate (desc, "Would create a possibly "
			      "illegal dereference in a "
			      "caller.");
  return true;
}
     desc->conditionally_dereferenceable = true;
   }
}
  }

for (gensum_param_access *ch = access->first_child;
     ch;
     ch = ch->next_sibling)
  if (check_gensum_access (fun, parm, desc, ch, nonarg_acc_size, only_calls,
	     entry_bb_index))
    return true;

return false;
2393}

2395/* Copy data from FROM and all of its children to a vector of accesses in IPA
 descriptor DESC.  */

2398static void
2399copy_accesses_to_ipa_desc (gensum_param_access *from, isra_param_desc *desc)
2400{
param_access *to = ggc_cleared_alloc<param_access> ();
gcc_checking_assert ((from->offset % BITS_PER_UNIT) == 0)((void)(!((from->offset % (8)) == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2402, __FUNCTION__), 0 : 0));
gcc_checking_assert ((from->size % BITS_PER_UNIT) == 0)((void)(!((from->size % (8)) == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2403, __FUNCTION__), 0 : 0));
to->unit_offset = from->offset / BITS_PER_UNIT(8);
to->unit_size = from->size / BITS_PER_UNIT(8);
to->type = from->type;
to->alias_ptr_type = from->alias_ptr_type;
to->certain = from->nonarg;
to->reverse = from->reverse;
vec_safe_push (desc->accesses, to);

for (gensum_param_access *ch = from->first_child;
     ch;
     ch = ch->next_sibling)
  copy_accesses_to_ipa_desc (ch, desc);
2416}

2418/* Analyze function body scan results stored in param_accesses and
 param_accesses, detect possible transformations and store information of
 those in function summary.  NODE, FUN and IFS are all various structures
 describing the currently analyzed function.  */

2423static void
2424process_scan_results (cgraph_node *node, struct function *fun,
      isra_func_summary *ifs,
      vec<gensum_param_desc> *param_descriptions)
2427{
bool check_pass_throughs = false;
bool dereferences_propagated = false;
tree parm = DECL_ARGUMENTS (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2430, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
);
unsigned param_count = param_descriptions->length();

for (unsigned desc_index = 0;
     desc_index < param_count;
     desc_index++, parm = DECL_CHAIN (parm)(((contains_struct_check (((contains_struct_check ((parm), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2435, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2435, __FUNCTION__))->common.chain)))
  {
    gensum_param_desc *desc = &(*param_descriptions)[desc_index];
    if (!desc->split_candidate)
continue;

    if (flag_checkingglobal_options.x_flag_checking)
isra_verify_access_tree (desc->accesses);

    if (!dereferences_propagated
 && desc->by_ref
 && !desc->safe_ref
 && desc->accesses)
{
 propagate_dereference_distances (fun);
 dereferences_propagated = true;
}

    HOST_WIDE_INTlong nonarg_acc_size = 0;
    bool only_calls = true;
    bool check_failed = false;

    int entry_bb_index = ENTRY_BLOCK_PTR_FOR_FN (fun)((fun)->cfg->x_entry_block_ptr)->index;
    for (gensum_param_access *acc = desc->accesses;
  acc;
  acc = acc->next_sibling)
if (check_gensum_access (fun, parm, desc, acc, &nonarg_acc_size,
		 &only_calls, entry_bb_index))
 {
   check_failed = true;
   break;
 }
    if (check_failed)
continue;

    if (only_calls)
desc->locally_unused = true;

    HOST_WIDE_INTlong cur_param_size
= tree_to_uhwi (TYPE_SIZE (TREE_TYPE (parm))((tree_class_check ((((contains_struct_check ((parm), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2474, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2474, __FUNCTION__))->type_common.size));
    HOST_WIDE_INTlong param_size_limit, optimistic_limit;
    if (!desc->by_ref || optimize_function_for_size_p (fun))
{
 param_size_limit = cur_param_size;
 optimistic_limit = cur_param_size;
}
    else
{
 param_size_limit
   = opt_for_fn (node->decl,(opts_for_fn (node->decl)->x_param_ipa_sra_ptr_growth_factor
)
	  param_ipa_sra_ptr_growth_factor)(opts_for_fn (node->decl)->x_param_ipa_sra_ptr_growth_factor
) * cur_param_size;
 optimistic_limit
   = (opt_for_fn (node->decl, param_ipa_sra_ptrwrap_growth_factor)(opts_for_fn (node->decl)->x_param_ipa_sra_ptrwrap_growth_factor
)
      * param_size_limit);
}

    if (nonarg_acc_size > optimistic_limit
 || (!desc->by_ref && nonarg_acc_size == param_size_limit))
{
 disqualify_split_candidate (desc, "Would result into a too big set "
		      "of replacements even in best "
		      "scenarios.");
}
    else
{
 /* create_parameter_descriptors makes sure unit sizes of all
    candidate parameters fit unsigned integers restricted to
    ISRA_ARG_SIZE_LIMIT.  */
 desc->param_size_limit = param_size_limit / BITS_PER_UNIT(8);
 desc->nonarg_acc_size = nonarg_acc_size / BITS_PER_UNIT(8);
 if (desc->split_candidate && desc->ptr_pt_count)
   {
     gcc_assert (desc->by_ref)((void)(!(desc->by_ref) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2507, __FUNCTION__), 0 : 0));
     check_pass_throughs = true;
   }
}
  }

/* When a pointer parameter is passed-through to a callee, in which it is
   only used to read only one or a few items, we can attempt to transform it
   to obtaining and passing through the items instead of the pointer.  But we
   must take extra care that 1) we do not introduce any segfault by moving
   dereferences above control flow and that 2) the data is not modified
   through an alias in this function.  The IPA analysis must not introduce
   any accesses candidates unless it can prove both.

   The current solution is very crude as it consists of ensuring that the
   call postdominates entry BB and that the definition of VUSE of the call is
   default definition.  TODO: For non-recursive callees in the same
   compilation unit we could do better by doing analysis in topological order
   an looking into access candidates of callees, using their alias_ptr_types
   to attempt real AA.  We could also use the maximum known dereferenced
   offset in this function at IPA level.

   TODO: Measure the overhead and the effect of just being pessimistic.
   Maybe this is only -O3 material?  */

hash_map<gimple *, bool> analyzed_stmts;
bitmap always_executed_bbs = NULLnullptr;
if (check_pass_throughs)
  for (cgraph_edge *cs = node->callees; cs; cs = cs->next_callee)
    {
gcall *call_stmt = cs->call_stmt;
tree vuse = gimple_vuse (call_stmt);

/* If the callee is a const function, we don't get a VUSE.  In such
  case there will be no memory accesses in the called function (or the
  const attribute is wrong) and then we just don't care.  */
bool uses_memory_as_obtained = vuse && SSA_NAME_IS_DEFAULT_DEF (vuse)(tree_check ((vuse), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2543, __FUNCTION__, (SSA_NAME)))->base.default_def_flag;

unsigned count = gimple_call_num_args (call_stmt);
isra_call_summary *csum = call_sums->get_create (cs);
csum->init_inputs (count);
csum->m_before_any_store = uses_memory_as_obtained;
for (unsigned argidx = 0; argidx < count; argidx++)
 {
   if (!csum->m_arg_flow[argidx].pointer_pass_through)
     continue;
   unsigned pidx
     = get_single_param_flow_source (&csum->m_arg_flow[argidx]);
   gensum_param_desc *desc = &(*param_descriptions)[pidx];
   if (!desc->split_candidate)
     {
csum->m_arg_flow[argidx].pointer_pass_through = false;
continue;
     }
   if (!uses_memory_as_obtained)
     continue;

   if (desc->safe_ref)
     {
csum->m_arg_flow[argidx].safe_to_import_accesses = true;
continue;
     }

   /* Walk basic block and see if its execution can terminate earlier.
      Keep the info for later re-use to avoid quadratic behavoiur here.  */
   gimple_stmt_iterator gsi = gsi_for_stmt (call_stmt);
   bool safe = true;
   int n = 0;
   for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
     {
bool *b = analyzed_stmts.get (gsi_stmt (gsi));
if (b)
  {
    safe = *b;
    gsi_next (&gsi);
    break;
  }
n++;
if (stmt_may_terminate_function_p (fun, gsi_stmt (gsi), false))
  {
    safe = false;
    break;
  }
     }
   if (n)
     {
if (gsi_end_p (gsi))
  gsi = gsi_start_bb (gimple_bb (call_stmt));
for (; gsi_stmt (gsi) != call_stmt; gsi_next (&gsi))
  analyzed_stmts.get_or_insert (gsi_stmt (gsi)) = safe;
     }

   if (safe && !always_executed_bbs)
     {
mark_dfs_back_edges ();
always_executed_bbs = find_always_executed_bbs (fun, false);
     }
   if (safe && bitmap_bit_p (always_executed_bbs, gimple_bb (call_stmt)->index))
     csum->m_arg_flow[argidx].safe_to_import_accesses = true;
 }

    }
BITMAP_FREE (always_executed_bbs)((void) (bitmap_obstack_free ((bitmap) always_executed_bbs), (
always_executed_bbs) = (bitmap) nullptr));

/* TODO: Add early exit if we disqualified everything.  This also requires
   that we either relax the restriction that
   ipa_param_adjustments.m_always_copy_start must be the number of PARM_DECLs
   or store the number of parameters to IPA-SRA function summary and use that
   when just removing params.  */

vec_safe_reserve_exact (ifs->m_parameters, param_count);
ifs->m_parameters->quick_grow_cleared (param_count);
for (unsigned desc_index = 0; desc_index < param_count; desc_index++)
  {
    gensum_param_desc *s = &(*param_descriptions)[desc_index];
    isra_param_desc *d = &(*ifs->m_parameters)[desc_index];

    d->param_size_limit = s->param_size_limit;
    d->size_reached = s->nonarg_acc_size;
    d->locally_unused = s->locally_unused;
    d->split_candidate = s->split_candidate;
    d->by_ref = s->by_ref;
    d->conditionally_dereferenceable = s->conditionally_dereferenceable;

    for (gensum_param_access *acc = s->accesses;
  acc;
  acc = acc->next_sibling)
copy_accesses_to_ipa_desc (acc, d);
  }

if (dump_file)
  dump_isra_param_descriptors (dump_file, node->decl, ifs, false);
2639}

2641/* Return true if there are any overlaps among certain accesses of DESC.  If
 non-NULL, set *CERTAIN_ACCESS_PRESENT_P upon encountering a certain access
 too.  DESC is assumed to be a split candidate that is not locally
 unused.  */

2646static bool
2647overlapping_certain_accesses_p (isra_param_desc *desc,
		bool *certain_access_present_p)
2649{
unsigned pclen = vec_safe_length (desc->accesses);
for (unsigned i = 0; i < pclen; i++)
  {
    param_access *a1 = (*desc->accesses)[i];

    if (!a1->certain)
continue;
    if (certain_access_present_p)
*certain_access_present_p = true;
    for (unsigned j = i + 1; j < pclen; j++)
{
 param_access *a2 = (*desc->accesses)[j];
 if (a2->certain
     && a1->unit_offset < a2->unit_offset + a2->unit_size
     && a1->unit_offset + a1->unit_size > a2->unit_offset)
   return true;
}
  }
return false;
2669}

2671/* Check for any overlaps of certain param accesses among splitting candidates
 and signal an ICE if there are any.  If CERTAIN_MUST_EXIST is set, also
 check that used splitting candidates have at least one certain access.  */

2675static void
2676verify_splitting_accesses (cgraph_node *node, bool certain_must_exist)
2677{
isra_func_summary *ifs = func_sums->get (node);
if (!ifs || !ifs->m_candidate)
  return;
unsigned param_count = vec_safe_length (ifs->m_parameters);
for (unsigned pidx = 0; pidx < param_count; pidx++)
  {
    isra_param_desc *desc = &(*ifs->m_parameters)[pidx];
    if (!desc->split_candidate || desc->locally_unused)
continue;

    bool certain_access_present = !certain_must_exist;
    if (overlapping_certain_accesses_p (desc, &certain_access_present))
internal_error ("function %qs, parameter %u, has IPA-SRA accesses "
	"which overlap", node->dump_name (), pidx);
    if (!certain_access_present)
internal_error ("function %qs, parameter %u, is used but does not "
	"have any certain IPA-SRA access",
	node->dump_name (), pidx);
  }
2697}

2699/* Intraprocedural part of IPA-SRA analysis.  Scan bodies of all functions in
 this compilation unit and create summary structures describing IPA-SRA
 opportunities and constraints in them.  */

2703static void
2704ipa_sra_generate_summary (void)
2705{
struct cgraph_node *node;

gcc_checking_assert (!func_sums)((void)(!(!func_sums) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2708, __FUNCTION__), 0 : 0));
gcc_checking_assert (!call_sums)((void)(!(!call_sums) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2709, __FUNCTION__), 0 : 0));
func_sums
  = (new (ggc_alloc_no_dtor <ipa_sra_function_summaries> ())
     ipa_sra_function_summaries (symtab, true));
call_sums = new ipa_sra_call_summaries (symtab);

FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)for ((node) = symtab->first_function_with_gimple_body (); (
node); (node) = symtab->next_function_with_gimple_body (node
))
  ipa_sra_summarize_function (node);
return;
2718}

2720/* Write intraprocedural analysis information about E and all of its outgoing
 edges into a stream for LTO WPA.  */

2723static void
2724isra_write_edge_summary (output_block *ob, cgraph_edge *e)
2725{
isra_call_summary *csum = call_sums->get (e);
unsigned input_count = csum->m_arg_flow.length ();
streamer_write_uhwi (ob, input_count);
for (unsigned i = 0; i < input_count; i++)
  {
    isra_param_flow *ipf = &csum->m_arg_flow[i];
    streamer_write_hwi (ob, ipf->length);
    bitpack_d bp = bitpack_create (ob->main_stream);
    for (int j = 0; j < ipf->length; j++)
bp_pack_value (&bp, ipf->inputs[j], 8);
    bp_pack_value (&bp, ipf->aggregate_pass_through, 1);
    bp_pack_value (&bp, ipf->pointer_pass_through, 1);
    bp_pack_value (&bp, ipf->safe_to_import_accesses, 1);
    bp_pack_value (&bp, ipf->constructed_for_calls, 1);
    streamer_write_bitpack (&bp);
    streamer_write_uhwi (ob, ipf->unit_offset);
    streamer_write_uhwi (ob, ipf->unit_size);
  }
bitpack_d bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, csum->m_return_ignored, 1);
bp_pack_value (&bp, csum->m_return_returned, 1);
bp_pack_value (&bp, csum->m_bit_aligned_arg, 1);
bp_pack_value (&bp, csum->m_before_any_store, 1);
streamer_write_bitpack (&bp);
2750}

2752/* Write intraprocedural analysis information about NODE and all of its outgoing
 edges into a stream for LTO WPA.  */

2755static void
2756isra_write_node_summary (output_block *ob, cgraph_node *node)
2757{
isra_func_summary *ifs = func_sums->get (node);
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);

unsigned param_desc_count = vec_safe_length (ifs->m_parameters);
streamer_write_uhwi (ob, param_desc_count);
for (unsigned i = 0; i < param_desc_count; i++)
  {
    isra_param_desc *desc = &(*ifs->m_parameters)[i];
    unsigned access_count = vec_safe_length (desc->accesses);
    streamer_write_uhwi (ob, access_count);
    for (unsigned j = 0; j < access_count; j++)
{
 param_access *acc = (*desc->accesses)[j];
 stream_write_tree (ob, acc->type, true)streamer_hooks.write_tree (ob, acc->type, true, true);
 stream_write_tree (ob, acc->alias_ptr_type, true)streamer_hooks.write_tree (ob, acc->alias_ptr_type, true, true
);
 streamer_write_uhwi (ob, acc->unit_offset);
 streamer_write_uhwi (ob, acc->unit_size);
 bitpack_d bp = bitpack_create (ob->main_stream);
 bp_pack_value (&bp, acc->certain, 1);
 bp_pack_value (&bp, acc->reverse, 1);
 streamer_write_bitpack (&bp);
}
    streamer_write_uhwi (ob, desc->param_size_limit);
    streamer_write_uhwi (ob, desc->size_reached);
    gcc_assert (desc->safe_size == 0)((void)(!(desc->safe_size == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2784, __FUNCTION__), 0 : 0));
    bitpack_d bp = bitpack_create (ob->main_stream);
    bp_pack_value (&bp, desc->locally_unused, 1);
    bp_pack_value (&bp, desc->split_candidate, 1);
    bp_pack_value (&bp, desc->by_ref, 1);
    gcc_assert (!desc->not_specially_constructed)((void)(!(!desc->not_specially_constructed) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2789, __FUNCTION__), 0 : 0));
    bp_pack_value (&bp, desc->conditionally_dereferenceable, 1);
    gcc_assert (!desc->safe_size_set)((void)(!(!desc->safe_size_set) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2791, __FUNCTION__), 0 : 0));
    streamer_write_bitpack (&bp);
  }
bitpack_d bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, ifs->m_candidate, 1);
bp_pack_value (&bp, ifs->m_returns_value, 1);
bp_pack_value (&bp, ifs->m_return_ignored, 1);
gcc_assert (!ifs->m_queued)((void)(!(!ifs->m_queued) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2798, __FUNCTION__), 0 : 0));
streamer_write_bitpack (&bp);

for (cgraph_edge *e = node->callees; e; e = e->next_callee)
  isra_write_edge_summary (ob, e);
for (cgraph_edge *e = node->indirect_calls; e; e = e->next_callee)
  isra_write_edge_summary (ob, e);
2805}

2807/* Write intraprocedural analysis information into a stream for LTO WPA.  */

2809static void
2810ipa_sra_write_summary (void)
2811{
if (!func_sums || !call_sums)
  return;

struct output_block *ob = create_output_block (LTO_section_ipa_sra);
lto_symtab_encoder_t encoder = ob->decl_state->symtab_node_encoder;
ob->symbol = NULLnullptr;

unsigned int count = 0;
lto_symtab_encoder_iterator lsei;
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 ()
 && func_sums->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 ()
 && func_sums->get (node) != NULLnullptr)
      isra_write_node_summary (ob, node);
  }
streamer_write_char_stream (ob->main_stream, 0);
produce_asm (ob, NULLnullptr);
destroy_output_block (ob);
2844}

2846/* Read intraprocedural analysis information about E and all of its outgoing
 edges into a stream for LTO WPA.  */

2849static void
2850isra_read_edge_summary (struct lto_input_block *ib, cgraph_edge *cs)
2851{
isra_call_summary *csum = call_sums->get_create (cs);
unsigned input_count = streamer_read_uhwi (ib);
csum->init_inputs (input_count);
for (unsigned i = 0; i < input_count; i++)
  {
    isra_param_flow *ipf = &csum->m_arg_flow[i];
    ipf->length = streamer_read_hwi (ib);
    bitpack_d bp = streamer_read_bitpack (ib);
    for (int j = 0; j < ipf->length; j++)
ipf->inputs[j] = bp_unpack_value (&bp, 8);
    ipf->aggregate_pass_through = bp_unpack_value (&bp, 1);
    ipf->pointer_pass_through = bp_unpack_value (&bp, 1);
    ipf->safe_to_import_accesses = bp_unpack_value (&bp, 1);
    ipf->constructed_for_calls = bp_unpack_value (&bp, 1);
    ipf->unit_offset = streamer_read_uhwi (ib);
    ipf->unit_size = streamer_read_uhwi (ib);
  }
bitpack_d bp = streamer_read_bitpack (ib);
csum->m_return_ignored = bp_unpack_value (&bp, 1);
csum->m_return_returned = bp_unpack_value (&bp, 1);
csum->m_bit_aligned_arg = bp_unpack_value (&bp, 1);
csum->m_before_any_store = bp_unpack_value (&bp, 1);
2874}

2876/* Read intraprocedural analysis information about NODE and all of its outgoing
 edges into a stream for LTO WPA.  */

2879static void
2880isra_read_node_info (struct lto_input_block *ib, cgraph_node *node,
     struct data_in *data_in)
2882{
isra_func_summary *ifs = func_sums->get_create (node);
unsigned param_desc_count = streamer_read_uhwi (ib);
if (param_desc_count > 0)
  {
    vec_safe_reserve_exact (ifs->m_parameters, param_desc_count);
    ifs->m_parameters->quick_grow_cleared (param_desc_count);
  }
for (unsigned i = 0; i < param_desc_count; i++)
  {
    isra_param_desc *desc = &(*ifs->m_parameters)[i];
    unsigned access_count = streamer_read_uhwi (ib);
    for (unsigned j = 0; j < access_count; j++)
{
 param_access *acc = ggc_cleared_alloc<param_access> ();
 acc->type = stream_read_tree (ib, data_in)streamer_hooks.read_tree (ib, data_in);
 acc->alias_ptr_type = stream_read_tree (ib, data_in)streamer_hooks.read_tree (ib, data_in);
 acc->unit_offset = streamer_read_uhwi (ib);
 acc->unit_size = streamer_read_uhwi (ib);
 bitpack_d bp = streamer_read_bitpack (ib);
 acc->certain = bp_unpack_value (&bp, 1);
 acc->reverse = bp_unpack_value (&bp, 1);
 vec_safe_push (desc->accesses, acc);
}
    desc->param_size_limit = streamer_read_uhwi (ib);
    desc->size_reached = streamer_read_uhwi (ib);
    desc->safe_size = 0;
    bitpack_d bp = streamer_read_bitpack (ib);
    desc->locally_unused = bp_unpack_value (&bp, 1);
    desc->split_candidate = bp_unpack_value (&bp, 1);
    desc->by_ref = bp_unpack_value (&bp, 1);
    desc->not_specially_constructed = 0;
    desc->conditionally_dereferenceable = bp_unpack_value (&bp, 1);
    desc->safe_size_set = 0;
  }
bitpack_d bp = streamer_read_bitpack (ib);
ifs->m_candidate = bp_unpack_value (&bp, 1);
ifs->m_returns_value = bp_unpack_value (&bp, 1);
ifs->m_return_ignored = bp_unpack_value (&bp, 1);
ifs->m_queued = 0;

for (cgraph_edge *e = node->callees; e; e = e->next_callee)
  isra_read_edge_summary (ib, e);
for (cgraph_edge *e = node->indirect_calls; e; e = e->next_callee)
  isra_read_edge_summary (ib, e);
2927}

2929/* Read IPA-SRA summaries from a section in file FILE_DATA of length LEN with
 data DATA.  TODO: This function was copied almost verbatim from ipa-prop.cc,
 it should be possible to unify them somehow.  */

2933static void
2934isra_read_summary_section (struct lto_file_decl_data *file_data,
	   const char *data, size_t len)
2936{
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;
struct 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-sra.cc"
, 2964, __FUNCTION__), 0 : 0));
    isra_read_node_info (&ib_main, node, data_in);
  }
lto_free_section_data (file_data, LTO_section_ipa_sra, NULLnullptr, data,
	 len);
lto_data_in_delete (data_in);
2970}

2972/* Read intraprocedural analysis information into a stream for LTO WPA.  */

2974static void
2975ipa_sra_read_summary (void)
2976{
struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
struct lto_file_decl_data *file_data;
unsigned int j = 0;

gcc_checking_assert (!func_sums)((void)(!(!func_sums) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2981, __FUNCTION__), 0 : 0));
gcc_checking_assert (!call_sums)((void)(!(!call_sums) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 2982, __FUNCTION__), 0 : 0));
func_sums
  = (new (ggc_alloc_no_dtor <ipa_sra_function_summaries> ())
     ipa_sra_function_summaries (symtab, true));
call_sums = new ipa_sra_call_summaries (symtab);

while ((file_data = file_data_vec[j++]))
  {
    size_t len;
    const char *data
= lto_get_summary_section_data (file_data, LTO_section_ipa_sra, &len);
    if (data)
      isra_read_summary_section (file_data, data, len);
  }
2996}

2998/* Dump all IPA-SRA summary data for all cgraph nodes and edges to file F.  If
 HINTS is true, also dump IPA-analysis computed hints.  */

3001static void
3002ipa_sra_dump_all_summaries (FILE *f, bool hints)
3003{
cgraph_node *node;
FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)for ((node) = symtab->first_function_with_gimple_body (); (
node); (node) = symtab->next_function_with_gimple_body (node
))
  {
    fprintf (f, "\nSummary for node %s:\n", node->dump_name ());

    isra_func_summary *ifs = func_sums->get (node);
    if (!ifs)
fprintf (f, "  Function does not have any associated IPA-SRA "
 "summary\n");
    else if (!ifs->m_candidate)
fprintf (f, "  Not a candidate function\n");
    else
{
 if (ifs->m_returns_value)
   fprintf (f, "  Returns value\n");
 if (vec_safe_is_empty (ifs->m_parameters))
   fprintf (f, "  No parameter information. \n");
 else
   for (unsigned i = 0; i < ifs->m_parameters->length (); ++i)
     {
fprintf (f, "  Descriptor for parameter %i:\n", i);
dump_isra_param_descriptor (f, &(*ifs->m_parameters)[i], hints);
     }
 fprintf (f, "\n");
}

    struct cgraph_edge *cs;
    for (cs = node->callees; cs; cs = cs->next_callee)
{
 fprintf (f, "  Summary for edge %s->%s:\n", cs->caller->dump_name (),
   cs->callee->dump_name ());
 isra_call_summary *csum = call_sums->get (cs);
 if (csum)
   csum->dump (f);
 else
   fprintf (f, "    Call summary is MISSING!\n");
}

  }
fprintf (f, "\n\n");
3044}

3046/* Perform function-scope viability tests that can be only made at IPA level
 and return false if the function is deemed unsuitable for IPA-SRA.  */

3049static bool
3050ipa_sra_ipa_function_checks (cgraph_node *node)
3051{
if (!node->can_be_local_p ())
  {
    if (dump_file)
fprintf (dump_file, "Function %s disqualified because it cannot be "
 "made local.\n", node->dump_name ());
    return false;
  }
if (!node->can_change_signature)
  {
    if (dump_file)
fprintf (dump_file, "Function can not change signature.\n");
    return false;
  }

return true;
3067}

3069/* Issues found out by check_callers_for_issues.  */

3071struct caller_issues
3072{
/* The candidate being considered.  */
cgraph_node *candidate;
/* There is a thunk among callers.  */
bool thunk;
/* Call site with no available information.  */
bool unknown_callsite;
/* Call from outside the candidate's comdat group.  */
bool call_from_outside_comdat;
/* There is a bit-aligned load into one of non-gimple-typed arguments. */
bool bit_aligned_aggregate_argument;
3083};

3085/* Worker for call_for_symbol_and_aliases, set any flags of passed caller_issues
 that apply.  */

3088static bool
3089check_for_caller_issues (struct cgraph_node *node, void *data)
3090{
struct caller_issues *issues = (struct caller_issues *) data;

for (cgraph_edge *cs = node->callers; cs; cs = cs->next_caller)
  {
    if (cs->caller->thunk)
{
 issues->thunk = true;
 /* TODO: We should be able to process at least some types of
    thunks.  */
 return true;
}
    if (issues->candidate->calls_comdat_local
 && issues->candidate->same_comdat_group
 && !issues->candidate->in_same_comdat_group_p (cs->caller))
{
 issues->call_from_outside_comdat = true;
 return true;
}

    isra_call_summary *csum = call_sums->get (cs);
    if (!csum)
{
 issues->unknown_callsite = true;
 return true;
}

    if (csum->m_bit_aligned_arg)
issues->bit_aligned_aggregate_argument = true;
  }
return false;
3121}

3123/* Look at all incoming edges to NODE, including aliases and thunks and look
 for problems.  Return true if NODE type should not be modified at all.  */

3126static bool
3127check_all_callers_for_issues (cgraph_node *node)
3128{
struct caller_issues issues;
memset (&issues, 0, sizeof (issues));
issues.candidate = node;

node->call_for_symbol_and_aliases (check_for_caller_issues, &issues, true);
if (issues.unknown_callsite)
  {
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "A call of %s has not been analyzed.  Disabling "
 "all modifications.\n", node->dump_name ());
    return true;
  }
/* TODO: We should be able to process at least some types of thunks.  */
if (issues.thunk)
  {
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "A call of %s is through thunk, which are not"
 " handled yet.  Disabling all modifications.\n",
 node->dump_name ());
    return true;
  }
if (issues.call_from_outside_comdat)
  {
    if (dump_file)
fprintf (dump_file, "Function would become private comdat called "
 "outside of its comdat group.\n");
    return true;
  }

if (issues.bit_aligned_aggregate_argument)
  {
    /* Let's only remove parameters/return values from such functions.
TODO: We could only prevent splitting the problematic parameters if
anybody thinks it is worth it.  */
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "A call of %s has bit-aligned aggregate argument,"
 " disabling parameter splitting.\n", node->dump_name ());

    isra_func_summary *ifs = func_sums->get (node);
    gcc_checking_assert (ifs)((void)(!(ifs) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 3168, __FUNCTION__), 0 : 0));
    unsigned param_count = vec_safe_length (ifs->m_parameters);
    for (unsigned i = 0; i < param_count; i++)
(*ifs->m_parameters)[i].split_candidate = false;
  }
return false;
3174}

3176/* Find the access with corresponding OFFSET and SIZE among accesses in
 PARAM_DESC and return it or NULL if such an access is not there.  */

3179static param_access *
3180find_param_access (isra_param_desc *param_desc, unsigned offset, unsigned size)
3181{
unsigned pclen = vec_safe_length (param_desc->accesses);

/* The search is linear but the number of stored accesses is bound by
   PARAM_IPA_SRA_MAX_REPLACEMENTS, so most probably 8.  */

for (unsigned i = 0; i < pclen; i++)
  if ((*param_desc->accesses)[i]->unit_offset == offset
&& (*param_desc->accesses)[i]->unit_size == size)
    return (*param_desc->accesses)[i];

return NULLnullptr;
3193}

3195/* Return iff the total size of definite replacement SIZE would violate the
 limit set for it in PARAM.  */

3198static bool
3199size_would_violate_limit_p (isra_param_desc *desc, unsigned size)
3200{
unsigned limit = desc->param_size_limit;
if (size > limit
    || (!desc->by_ref && size == limit))
  return true;
return false;
3206}

3208/* Increase reached size of DESC by SIZE or disqualify it if it would violate
 the set limit.  IDX is the parameter number which is dumped when
 disqualifying.  */

3212static void
3213bump_reached_size (isra_param_desc *desc, unsigned size, unsigned idx)
3214{
unsigned after = desc->size_reached + size;
if (size_would_violate_limit_p (desc, after))
  {
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "    ...size limit reached, disqualifying "
 "candidate parameter %u\n", idx);
    desc->split_candidate = false;
    return;
  }
desc->size_reached = after;
3225}

3227/* Take all actions required to deal with an edge CS that represents a call to
 an unknown or un-analyzed function, for both parameter removal and
 splitting.  */

3231static void
3232process_edge_to_unknown_caller (cgraph_edge *cs)
3233{
isra_func_summary *from_ifs = func_sums->get (cs->caller);
gcc_checking_assert (from_ifs)((void)(!(from_ifs) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 3235, __FUNCTION__), 0 : 0));
isra_call_summary *csum = call_sums->get (cs);

if (dump_file && (dump_flags & TDF_DETAILS))
  fprintf (dump_file, "Processing an edge to an unknown caller from %s:\n",
    cs->caller->dump_name ());

unsigned args_count = csum->m_arg_flow.length ();
for (unsigned i = 0; i < args_count; i++)
  {
    isra_param_flow *ipf = &csum->m_arg_flow[i];

   if (ipf->pointer_pass_through)
     {
       isra_param_desc *param_desc
         = &(*from_ifs->m_parameters)[get_single_param_flow_source (ipf)];
       param_desc->locally_unused = false;
       param_desc->split_candidate = false;
      continue;
     }
    if (ipf->aggregate_pass_through)
{
 unsigned idx = get_single_param_flow_source (ipf);
 isra_param_desc *param_desc = &(*from_ifs->m_parameters)[idx];

 param_desc->locally_unused = false;
 if (!param_desc->split_candidate)
   continue;
 gcc_assert (!param_desc->by_ref)((void)(!(!param_desc->by_ref) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 3263, __FUNCTION__), 0 : 0));
 param_access *pacc = find_param_access (param_desc, ipf->unit_offset,
				  ipf->unit_size);
 gcc_checking_assert (pacc)((void)(!(pacc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 3266, __FUNCTION__), 0 : 0));
 pacc->certain = true;
 if (overlapping_certain_accesses_p (param_desc, NULLnullptr))
   {
     if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "    ...leading to overlap, "
	 " disqualifying candidate parameter %u\n",
	 idx);
     param_desc->split_candidate = false;
   }
 else
   bump_reached_size (param_desc, pacc->unit_size, idx);
 ipf->aggregate_pass_through = false;
 continue;
}

    for (int j = 0; j < ipf->length; j++)
{
 int input_idx = ipf->inputs[j];
 (*from_ifs->m_parameters)[input_idx].locally_unused = false;
}
  }
3288}

3290/* Propagate parameter removal information through cross-SCC edge CS,
 i.e. decrease the use count in the caller parameter descriptor for each use
 in this call.  */

3294static void
3295param_removal_cross_scc_edge (cgraph_edge *cs)
3296{
enum availability availability;
cgraph_node *callee = cs->callee->function_symbol (&availability);
isra_func_summary *to_ifs = func_sums->get (callee);
if (!to_ifs || !to_ifs->m_candidate
    || (availability < AVAIL_AVAILABLE)
    || vec_safe_is_empty (to_ifs->m_parameters))
  {
    process_edge_to_unknown_caller (cs);
    return;
  }
isra_func_summary *from_ifs = func_sums->get (cs->caller);
gcc_checking_assert (from_ifs)((void)(!(from_ifs) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 3308, __FUNCTION__), 0 : 0));

isra_call_summary *csum = call_sums->get (cs);
unsigned args_count = csum->m_arg_flow.length ();
unsigned param_count = vec_safe_length (to_ifs->m_parameters);

for (unsigned i = 0; i < args_count; i++)
  {
    bool unused_in_callee;
    if (i < param_count)
unused_in_callee = (*to_ifs->m_parameters)[i].locally_unused;
    else
unused_in_callee = false;

    if (!unused_in_callee)
{
 isra_param_flow *ipf = &csum->m_arg_flow[i];
 for (int j = 0; j < ipf->length; j++)
   {
     int input_idx = ipf->inputs[j];
     (*from_ifs->m_parameters)[input_idx].locally_unused = false;
   }
}
  }
3332}

3334/* Unless it is already there, push NODE which is also described by IFS to
 STACK.  */

3337static void
3338isra_push_node_to_stack (cgraph_node *node, isra_func_summary *ifs,
    vec<cgraph_node *> *stack)
3340{
if (!ifs->m_queued)
  {
    ifs->m_queued = true;
    stack->safe_push (node);
  }
3346}

3348/* If parameter with index INPUT_IDX is marked as locally unused, mark it as
 used and push CALLER on STACK.  */

3351static void
3352isra_mark_caller_param_used (isra_func_summary *from_ifs, int input_idx,
	     cgraph_node *caller, vec<cgraph_node *> *stack)
3354{
if ((*from_ifs->m_parameters)[input_idx].locally_unused)
  {
    (*from_ifs->m_parameters)[input_idx].locally_unused = false;
    isra_push_node_to_stack (caller, from_ifs, stack);
  }
3360}

3362/* Combine safe_size of DESC with SIZE and return true if it has changed.  */

3364static bool
3365update_safe_size (isra_param_desc *desc, unsigned size)
3366{
if (!desc->safe_size_set)
  {
    desc->safe_size_set = 1;
    desc->safe_size = size;
    return true;
  }
if (desc->safe_size <= size)
  return false;
desc->safe_size = size;
return true;
3377}

3379/* Set all param hints in DESC to the pessimistic values.  Return true if any
 hints that need to potentially trigger further propagation have changed.  */

3382static bool
3383flip_all_hints_pessimistic (isra_param_desc *desc)
3384{
desc->not_specially_constructed = true;
return update_safe_size (desc, 0);
3387}

3389/* Because we have not analyzed or otherwise problematic caller, go over all
 parameter int flags of IFS describing a call graph node of a calllee and
 turn them pessimistic.  Return true if any hints that need to potentially
 trigger further propagation have changed.  */

3394static bool
3395flip_all_param_hints_pessimistic (isra_func_summary *ifs)
3396{
if (!ifs || !ifs->m_candidate)
  return false;

bool ret = false;
unsigned param_count = vec_safe_length (ifs->m_parameters);

for (unsigned i = 0; i < param_count; i++)
  ret |= flip_all_hints_pessimistic (&(*ifs->m_parameters)[i]);

return ret;
3407}

3409/* Propagate hints accross edge CS which ultimately leads to a node described
 by TO_IFS.  Return true if any hints of the callee which should potentially
 trigger further propagation have changed.  */

3413static bool
3414propagate_param_hints_accross_call (cgraph_edge *cs, isra_func_summary *to_ifs)
3415{
if (!to_ifs || !to_ifs->m_candidate)
  return false;

isra_call_summary *csum = call_sums->get (cs);
bool ret = false;
unsigned args_count = csum->m_arg_flow.length ();
unsigned param_count = vec_safe_length (to_ifs->m_parameters);

for (unsigned i = 0; i < param_count; i++)
  {
    isra_param_desc *desc = &(*to_ifs->m_parameters)[i];
    if (i >= args_count)
{
 ret |= flip_all_hints_pessimistic (desc);
 continue;
}

    if (desc->by_ref)
{
 isra_param_flow *ipf = &csum->m_arg_flow[i];

 if (!ipf->constructed_for_calls)
   desc->not_specially_constructed = true;

 if (ipf->pointer_pass_through)
   {
     isra_func_summary *from_ifs = func_sums->get (cs->caller);
     int srcidx = get_single_param_flow_source (ipf);
     if (vec_safe_length (from_ifs->m_parameters) > (unsigned) srcidx)
{
  isra_param_desc *src_d = &(*from_ifs->m_parameters)[srcidx];
  if (src_d->safe_size_set)
    ret |= update_safe_size (desc, src_d->safe_size);
}
     else
ret |= update_safe_size (desc, 0);
   }
 else if (!ipf->aggregate_pass_through)
   ret |= update_safe_size (desc, ipf->unit_size);
 else
   /* LTOing type-mismatched programs can end up here.  */
   ret |= update_safe_size (desc, 0);
}
  }
return ret;
3461}

3463/* Propagate hints from NODE described by FROM_IFS to all its (dorect) callees,
 push those that may need re-visiting onto STACK.  */

3466static void
3467propagate_hints_to_all_callees (cgraph_node *node, isra_func_summary *from_ifs,
		vec<cgraph_node *> *stack)
3469{
for (cgraph_edge *cs = node->callees; cs; cs = cs->next_callee)
  {
    enum availability availability;
    cgraph_node *callee = cs->callee->function_symbol (&availability);
    isra_func_summary *to_ifs = func_sums->get (callee);
    if (!from_ifs)
{
 if (flip_all_param_hints_pessimistic (to_ifs)
     && ipa_edge_within_scc (cs))
   isra_push_node_to_stack (callee, to_ifs, stack);
}
    else if (propagate_param_hints_accross_call (cs, to_ifs)
      && ipa_edge_within_scc (cs))
isra_push_node_to_stack (callee, to_ifs, stack);
  }
3485}

3487/* Propagate information that any parameter is not used only locally within a
 SCC across CS to the caller, which must be in the same SCC as the
 callee.  Push any callers that need to be re-processed to STACK.  */

3491static void
3492propagate_used_across_scc_edge (cgraph_edge *cs, vec<cgraph_node *> *stack)
3493{
isra_func_summary *from_ifs = func_sums->get (cs->caller);
if (!from_ifs || vec_safe_is_empty (from_ifs->m_parameters))
  return;

isra_call_summary *csum = call_sums->get (cs);
gcc_checking_assert (csum)((void)(!(csum) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 3499, __FUNCTION__), 0 : 0));
unsigned args_count = csum->m_arg_flow.length ();
enum availability availability;
cgraph_node *callee = cs->callee->function_symbol (&availability);
isra_func_summary *to_ifs = func_sums->get (callee);

unsigned param_count
  = (to_ifs && (availability >= AVAIL_AVAILABLE))
  ? vec_safe_length (to_ifs->m_parameters) : 0;
for (unsigned i = 0; i < args_count; i++)
  {
    if (i < param_count
 && (*to_ifs->m_parameters)[i].locally_unused)
   continue;

    /* The argument is needed in the callee it, we must mark the parameter as
used also in the caller and its callers within this SCC.  */
    isra_param_flow *ipf = &csum->m_arg_flow[i];
    for (int j = 0; j < ipf->length; j++)
{
 int input_idx = ipf->inputs[j];
 isra_mark_caller_param_used (from_ifs, input_idx, cs->caller, stack);
}
  }
3523}

3525/* Propagate information that any parameter is not used only locally within a
 SCC (i.e. is used also elsewhere) to all callers of NODE that are in the
 same SCC.  Push any callers that need to be re-processed to STACK.  */

3529static bool
3530propagate_used_to_scc_callers (cgraph_node *node, void *data)
3531{
vec<cgraph_node *> *stack = (vec<cgraph_node *> *) data;
cgraph_edge *cs;
for (cs = node->callers; cs; cs = cs->next_caller)
  if (ipa_edge_within_scc (cs))
    propagate_used_across_scc_edge (cs, stack);
return false;
3538}

3540/* Return true iff all certain accesses in ARG_DESC are also present as
 certain accesses in PARAM_DESC.  */

3543static bool
3544all_callee_accesses_present_p (isra_param_desc *param_desc,
	       isra_param_desc *arg_desc)
3546{
unsigned aclen = vec_safe_length (arg_desc->accesses);
for (unsigned j = 0; j < aclen; j++)
  {
    param_access *argacc = (*arg_desc->accesses)[j];
    if (!argacc->certain)
continue;
    param_access *pacc = find_param_access (param_desc, argacc->unit_offset,
			      argacc->unit_size);
    if (!pacc
 || !pacc->certain
 || !types_compatible_p (argacc->type, pacc->type))
return false;
  }
return true;
3561}

3563/* Type internal to function pull_accesses_from_callee.  Unfortunately gcc 4.8
 does not allow instantiating an auto_vec with a type defined within a
 function so it is a global type.   */
3566enum acc_prop_kind {ACC_PROP_DONT, ACC_PROP_COPY, ACC_PROP_CERTAIN};


3569/* Attempt to propagate all definite accesses from ARG_DESC to PARAM_DESC,
 (which belongs to CALLER) if they would not violate some constraint there.
 If successful, return NULL, otherwise return the string reason for failure
 (which can be written to the dump file).  DELTA_OFFSET is the known offset
 of the actual argument withing the formal parameter (so of ARG_DESCS within
 PARAM_DESCS), ARG_SIZE is the size of the actual argument or zero, if not
 known. In case of success, set *CHANGE_P to true if propagation actually
 changed anything.  */

3578static const char *
3579pull_accesses_from_callee (cgraph_node *caller, isra_param_desc *param_desc,
	   isra_param_desc *arg_desc,
	   unsigned delta_offset, unsigned arg_size,
	   bool *change_p)
3583{
unsigned pclen = vec_safe_length (param_desc->accesses);
unsigned aclen = vec_safe_length (arg_desc->accesses);
unsigned prop_count = 0;
unsigned prop_size = 0;
bool change = false;

auto_vec <enum acc_prop_kind, 8> prop_kinds (aclen);
for (unsigned j = 0; j < aclen; j++)
  {
    param_access *argacc = (*arg_desc->accesses)[j];
    prop_kinds.safe_push (ACC_PROP_DONT);

    if (arg_size > 0
 && argacc->unit_offset + argacc->unit_size > arg_size)
return "callee access outsize size boundary";

    if (!argacc->certain)
continue;

    unsigned offset = argacc->unit_offset + delta_offset;
    /* Given that accesses are initially stored according to increasing
offset and decreasing size in case of equal offsets, the following
searches could be written more efficiently if we kept the ordering
when copying. But the number of accesses is capped at
PARAM_IPA_SRA_MAX_REPLACEMENTS (so most likely 8) and the code gets
messy quickly, so let's improve on that only if necessary.  */

    bool exact_match = false;
    for (unsigned i = 0; i < pclen; i++)
{
 /* Check for overlaps.  */
 param_access *pacc = (*param_desc->accesses)[i];
 if (pacc->unit_offset == offset
     && pacc->unit_size == argacc->unit_size)
   {
     if (argacc->alias_ptr_type != pacc->alias_ptr_type
  || !types_compatible_p (argacc->type, pacc->type)
  || argacc->reverse != pacc->reverse)
return "propagated access types would not match existing ones";

     exact_match = true;
     if (!pacc->certain)
{
  prop_kinds[j] = ACC_PROP_CERTAIN;
  prop_size += argacc->unit_size;
  change = true;
}
     continue;
   }

 if (offset < pacc->unit_offset + pacc->unit_size
     && offset + argacc->unit_size > pacc->unit_offset)
   {
     /* None permissible with load accesses, possible to fit into
 argument ones.  */
     if (pacc->certain
  || offset < pacc->unit_offset
  || (offset + argacc->unit_size
      > pacc->unit_offset + pacc->unit_size))
return "a propagated access would conflict in caller";
   }
}

    if (!exact_match)
{
 prop_kinds[j] = ACC_PROP_COPY;
 prop_count++;
 prop_size += argacc->unit_size;
 change = true;
}
  }

  if (!change)
    return NULLnullptr;

  if ((prop_count + pclen
> (unsigned) opt_for_fn (caller->decl, param_ipa_sra_max_replacements)(opts_for_fn (caller->decl)->x_param_ipa_sra_max_replacements
))
|| size_would_violate_limit_p (param_desc,
		       param_desc->size_reached + prop_size))
    return "propagating accesses would violate the count or size limit";

*change_p = true;
for (unsigned j = 0; j < aclen; j++)
  {
    if (prop_kinds[j] == ACC_PROP_COPY)
{
 param_access *argacc = (*arg_desc->accesses)[j];

 param_access *copy = ggc_cleared_alloc<param_access> ();
 copy->unit_offset = argacc->unit_offset + delta_offset;
 copy->unit_size = argacc->unit_size;
 copy->type = argacc->type;
 copy->alias_ptr_type = argacc->alias_ptr_type;
 copy->certain = true;
 copy->reverse = argacc->reverse;
 vec_safe_push (param_desc->accesses, copy);
}
    else if (prop_kinds[j] == ACC_PROP_CERTAIN)
{
 param_access *argacc = (*arg_desc->accesses)[j];
 param_access *csp
   = find_param_access (param_desc, argacc->unit_offset + delta_offset,
		 argacc->unit_size);
 csp->certain = true;
}
  }

param_desc->size_reached += prop_size;

return NULLnullptr;
3694}

3696/* Propagate parameter splitting information through call graph edge CS.
 Return true if any changes that might need to be propagated within SCCs have
 been made.  The function also clears the aggregate_pass_through and
 pointer_pass_through in call summaries which do not need to be processed
 again if this CS is revisited when iterating while changes are propagated
 within an SCC.  */

3703static bool
3704param_splitting_across_edge (cgraph_edge *cs)
3705{
bool res = false;
bool cross_scc = !ipa_edge_within_scc (cs);
enum availability availability;
cgraph_node *callee = cs->callee->function_symbol (&availability);
isra_func_summary *from_ifs = func_sums->get (cs->caller);
gcc_checking_assert (from_ifs && from_ifs->m_parameters)((void)(!(from_ifs && from_ifs->m_parameters) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 3711, __FUNCTION__), 0 : 0));

isra_call_summary *csum = call_sums->get (cs);
gcc_checking_assert (csum)((void)(!(csum) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 3714, __FUNCTION__), 0 : 0));
unsigned args_count = csum->m_arg_flow.length ();
isra_func_summary *to_ifs = func_sums->get (callee);
unsigned param_count
  = ((to_ifs && to_ifs->m_candidate && (availability >= AVAIL_AVAILABLE))
     ? vec_safe_length (to_ifs->m_parameters)
     : 0);

if (dump_file && (dump_flags & TDF_DETAILS))
  fprintf (dump_file, "Splitting across %s->%s:\n",
    cs->caller->dump_name (), callee->dump_name ());

unsigned i;
for (i = 0; (i < args_count) && (i < param_count); i++)
  {
    isra_param_desc *arg_desc = &(*to_ifs->m_parameters)[i];
    isra_param_flow *ipf = &csum->m_arg_flow[i];

    if (arg_desc->locally_unused)
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, "    ->%u: unused in callee\n", i);
 ipf->pointer_pass_through = false;
 continue;
}

    if (ipf->pointer_pass_through)
{
 int idx = get_single_param_flow_source (ipf);
 isra_param_desc *param_desc = &(*from_ifs->m_parameters)[idx];
 if (!param_desc->split_candidate)
   continue;
 gcc_assert (param_desc->by_ref)((void)(!(param_desc->by_ref) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 3746, __FUNCTION__), 0 : 0));

 if (!arg_desc->split_candidate || !arg_desc->by_ref)
   {
     if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "  %u->%u: not candidate or not by "
	 "reference in callee\n", idx, i);
     param_desc->split_candidate = false;
     ipf->pointer_pass_through = false;
     res = true;
   }
 else if (!ipf->safe_to_import_accesses)
   {
     if (!csum->m_before_any_store
  || !all_callee_accesses_present_p (param_desc, arg_desc))
{
  if (dump_file && (dump_flags & TDF_DETAILS))
    fprintf (dump_file, "  %u->%u: cannot import accesses.\n",
	     idx, i);
  param_desc->split_candidate = false;
  ipf->pointer_pass_through = false;
  res = true;

}
     else
{
  if (dump_file && (dump_flags & TDF_DETAILS))
    fprintf (dump_file, "  %u->%u: verified callee accesses "
	     "present.\n", idx, i);
  if (cross_scc)
    ipf->pointer_pass_through = false;
}
   }
 else
   {
     const char *pull_failure
= pull_accesses_from_callee (cs->caller, param_desc, arg_desc,
			     0, 0, &res);
     if (pull_failure)
{
  if (dump_file && (dump_flags & TDF_DETAILS))
    fprintf (dump_file, "  %u->%u: by_ref access pull "
	     "failed: %s.\n", idx, i, pull_failure);
  param_desc->split_candidate = false;
  ipf->pointer_pass_through = false;
  res = true;
}
     else
{
  if (dump_file && (dump_flags & TDF_DETAILS))
    fprintf (dump_file, "  %u->%u: by_ref access pull "
	     "succeeded.\n", idx, i);
  if (cross_scc)
    ipf->pointer_pass_through = false;
}
   }
}
    else if (ipf->aggregate_pass_through)
{
 int idx = get_single_param_flow_source (ipf);
 isra_param_desc *param_desc = &(*from_ifs->m_parameters)[idx];
 if (!param_desc->split_candidate)
   continue;
 gcc_assert (!param_desc->by_ref)((void)(!(!param_desc->by_ref) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 3809, __FUNCTION__), 0 : 0));
 param_access *pacc = find_param_access (param_desc, ipf->unit_offset,
				  ipf->unit_size);
 gcc_checking_assert (pacc)((void)(!(pacc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 3812, __FUNCTION__), 0 : 0));

 if (pacc->certain)
   {
     if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "  %u->%u: already certain\n", idx, i);
     ipf->aggregate_pass_through = false;
   }
 else if (!arg_desc->split_candidate || arg_desc->by_ref)
   {
     if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "  %u->%u: not candidate or by "
	 "reference in callee\n", idx, i);

     pacc->certain = true;
     if (overlapping_certain_accesses_p (param_desc, NULLnullptr))
{
  if (dump_file && (dump_flags & TDF_DETAILS))
    fprintf (dump_file, "    ...leading to overlap, "
	     " disqualifying candidate parameter %u\n",
	     idx);
  param_desc->split_candidate = false;
}
     else
bump_reached_size (param_desc, pacc->unit_size, idx);

     ipf->aggregate_pass_through = false;
     res = true;
   }
 else
   {
     const char *pull_failure
= pull_accesses_from_callee (cs->caller, param_desc, arg_desc,
			     ipf->unit_offset,
			     ipf->unit_size, &res);
     if (pull_failure)
{
  if (dump_file && (dump_flags & TDF_DETAILS))
    fprintf (dump_file, "  %u->%u: arg access pull "
	     "failed: %s.\n", idx, i, pull_failure);

  ipf->aggregate_pass_through = false;
  pacc->certain = true;

  if (overlapping_certain_accesses_p (param_desc, NULLnullptr))
    {
      if (dump_file && (dump_flags & TDF_DETAILS))
	fprintf (dump_file, "    ...leading to overlap, "
		 " disqualifying candidate parameter %u\n",
		 idx);
      param_desc->split_candidate = false;
    }
  else
    bump_reached_size (param_desc, pacc->unit_size, idx);

  res = true;
}
     else
{
  if (dump_file && (dump_flags & TDF_DETAILS))
    fprintf (dump_file, "  %u->%u: arg access pull "
	     "succeeded.\n", idx, i);
  if (cross_scc)
    ipf->aggregate_pass_through = false;
}
   }
}
  }

/* Handle argument-parameter count mismatches. */
for (; (i < args_count); i++)
  {
    isra_param_flow *ipf = &csum->m_arg_flow[i];

    if (ipf->pointer_pass_through || ipf->aggregate_pass_through)
{
 int idx = get_single_param_flow_source (ipf);
 ipf->pointer_pass_through = false;
 ipf->aggregate_pass_through = false;
 isra_param_desc *param_desc = &(*from_ifs->m_parameters)[idx];
 if (!param_desc->split_candidate)
   continue;

 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, "  %u->%u: no corresponding formal parameter\n",
     idx, i);
 param_desc->split_candidate = false;
 res = true;
}
  }
return res;
3903}

3905/* Worker for call_for_symbol_and_aliases, look at all callers and if all their
 callers ignore the return value, or come from the same SCC and use the
 return value only to compute their return value, return false, otherwise
 return true.  */

3910static bool
3911retval_used_p (cgraph_node *node, void *)
3912{
for (cgraph_edge *cs = node->callers; cs; cs = cs->next_caller)
  {
    isra_call_summary *csum = call_sums->get (cs);
    gcc_checking_assert (csum)((void)(!(csum) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 3916, __FUNCTION__), 0 : 0));
    if (csum->m_return_ignored)
continue;
    if (!csum->m_return_returned)
return true;

    isra_func_summary *from_ifs = func_sums->get (cs->caller);
    if (!from_ifs || !from_ifs->m_candidate)
return true;

    if (!ipa_edge_within_scc (cs)
 && !from_ifs->m_return_ignored)
   return true;
  }

return false;
3932}

3934/* Push into NEW_PARAMS all required parameter adjustment entries to copy or
 modify parameter which originally had index BASE_INDEX, in the adjustment
 vector of parent clone (if any) had PREV_CLONE_INDEX and was described by
 PREV_ADJUSTMENT.  If IPA-CP has created a transformation summary for the
 original node, it needs to be passed in IPCP_TS, otherwise it should be
 NULL.  If the parent clone is the original function, PREV_ADJUSTMENT is NULL
 and PREV_CLONE_INDEX is equal to BASE_INDEX.  */

3942static void
3943push_param_adjustments_for_index (isra_func_summary *ifs, unsigned base_index,
		  unsigned prev_clone_index,
		  ipa_adjusted_param *prev_adjustment,
		  ipcp_transformation *ipcp_ts,
		  vec<ipa_adjusted_param, va_gc> **new_params)
3948{
isra_param_desc *desc = &(*ifs->m_parameters)[base_index];
if (desc->locally_unused)
  {
    if (dump_file)
fprintf (dump_file, "  Will remove parameter %u\n", base_index);
    return;
  }

if (!desc->split_candidate)
  {
    ipa_adjusted_param adj;
    if (prev_adjustment)
{
 adj = *prev_adjustment;
 adj.prev_clone_adjustment = true;
 adj.prev_clone_index = prev_clone_index;
}
    else
{
 memset (&adj, 0, sizeof (adj));
 adj.op = IPA_PARAM_OP_COPY;
 adj.base_index = base_index;
 adj.prev_clone_index = prev_clone_index;
}
    vec_safe_push ((*new_params), adj);
    return;
  }

if (dump_file)
  fprintf (dump_file, "  Will split parameter %u\n", base_index);

gcc_assert (!prev_adjustment || prev_adjustment->op == IPA_PARAM_OP_COPY)((void)(!(!prev_adjustment || prev_adjustment->op == IPA_PARAM_OP_COPY
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 3980, __FUNCTION__), 0 : 0));
unsigned aclen = vec_safe_length (desc->accesses);
for (unsigned j = 0; j < aclen; j++)
  {
    param_access *pa = (*desc->accesses)[j];
    if (!pa->certain)
continue;

    if (ipcp_ts)
{
 ipa_argagg_value_list avl (ipcp_ts);
 tree value = avl.get_value (base_index, pa->unit_offset);
 if (value && !AGGREGATE_TYPE_P (pa->type)(((enum tree_code) (pa->type)->base.code) == ARRAY_TYPE
 || (((enum tree_code) (pa->type)->base.code) == RECORD_TYPE
 || ((enum tree_code) (pa->type)->base.code) == UNION_TYPE
 || ((enum tree_code) (pa->type)->base.code) == QUAL_UNION_TYPE
)))
   {
     if (dump_file)
fprintf (dump_file, "    - omitting component at byte "
	 "offset %u which is known to have a constant value\n ",
	 pa->unit_offset);
     continue;
   }
}

    if (dump_file)
fprintf (dump_file, "    - component at byte offset %u, "
 "size %u\n", pa->unit_offset, pa->unit_size);

    ipa_adjusted_param adj;
    memset (&adj, 0, sizeof (adj));
    adj.op = IPA_PARAM_OP_SPLIT;
    adj.base_index = base_index;
    adj.prev_clone_index = prev_clone_index;
    adj.param_prefix_index = IPA_PARAM_PREFIX_ISRA;
    adj.reverse = pa->reverse;
    adj.type = pa->type;
    adj.alias_ptr_type = pa->alias_ptr_type;
    adj.unit_offset = pa->unit_offset;
    vec_safe_push ((*new_params), adj);
  }
4018}

4020/* Worker for all call_for_symbol_thunks_and_aliases.  Set calls_comdat_local
 flag of all callers of NODE.  */

4023static bool
4024mark_callers_calls_comdat_local (struct cgraph_node *node, void *)
4025{
for (cgraph_edge *cs = node->callers; cs; cs = cs->next_caller)
  cs->caller->calls_comdat_local = true;
return false;
4029}


4032/* Do final processing of results of IPA propagation regarding NODE, clone it
 if appropriate.  */

4035static void
4036process_isra_node_results (cgraph_node *node,
	   hash_map<const char *, unsigned> *clone_num_suffixes)
4038{
isra_func_summary *ifs = func_sums->get (node);
if (!ifs || !ifs->m_candidate)
  return;

auto_vec<bool, 16> surviving_params;
bool check_surviving = false;
clone_info *cinfo = clone_info::get (node);
if (cinfo && cinfo->param_adjustments)
  {
    check_surviving = true;
    cinfo->param_adjustments->get_surviving_params (&surviving_params);
  }

unsigned param_count = vec_safe_length (ifs->m_parameters);
bool will_change_function = false;
if (ifs->m_returns_value && ifs->m_return_ignored)
  will_change_function = true;
else
  for (unsigned i = 0; i < param_count; i++)
    {
isra_param_desc *desc = &(*ifs->m_parameters)[i];
if ((desc->locally_unused || desc->split_candidate)
   /* Make sure we do not clone just to attempt to remove an already
      removed unused argument.  */
   && (!check_surviving
|| (i < surviving_params.length ()
    && surviving_params[i])))
 {
   will_change_function = true;
   break;
 }
    }
if (!will_change_function)
  return;

if (dump_file)
  {
    fprintf (dump_file, "\nEvaluating analysis results for %s\n",
      node->dump_name ());
    if (ifs->m_returns_value && ifs->m_return_ignored)
fprintf (dump_file, "  Will remove return value.\n");
  }

ipcp_transformation *ipcp_ts = ipcp_get_transformation_summary (node);
vec<ipa_adjusted_param, va_gc> *new_params = NULLnullptr;
if (ipa_param_adjustments *old_adjustments
= cinfo ? cinfo->param_adjustments : NULLnullptr)
  {
    unsigned old_adj_len = vec_safe_length (old_adjustments->m_adj_params);
    for (unsigned i = 0; i < old_adj_len; i++)
{
 ipa_adjusted_param *old_adj = &(*old_adjustments->m_adj_params)[i];
 push_param_adjustments_for_index (ifs, old_adj->base_index, i,
			    old_adj, ipcp_ts, &new_params);
}
  }
else
  for (unsigned i = 0; i < param_count; i++)
    push_param_adjustments_for_index (ifs, i, i, NULLnullptr, ipcp_ts, &new_params);

ipa_param_adjustments *new_adjustments
  = (new (ggc_alloc <ipa_param_adjustments> ())
     ipa_param_adjustments (new_params, param_count,
	      ifs->m_returns_value && ifs->m_return_ignored));

if (dump_file && (dump_flags & TDF_DETAILS))
  {
    fprintf (dump_file, "\n  Created adjustments:\n");
    new_adjustments->dump (dump_file);
  }

unsigned &suffix_counter = clone_num_suffixes->get_or_insert (
	       IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (((const char *) (tree_check ((decl_assembler_name (node->decl
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4112, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)
		 node->decl))((const char *) (tree_check ((decl_assembler_name (node->decl
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4112, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
auto_vec<cgraph_edge *> callers = node->collect_callers ();
cgraph_node *new_node
  = node->create_virtual_clone (callers, NULLnullptr, new_adjustments, "isra",
		  suffix_counter);
suffix_counter++;
if (node->calls_comdat_local && node->same_comdat_group)
  {
    new_node->add_to_same_comdat_group (node);
    new_node->call_for_symbol_and_aliases (mark_callers_calls_comdat_local,
			     NULLnullptr, true);
  }
new_node->calls_comdat_local = node->calls_comdat_local;

if (dump_file)
  fprintf (dump_file, "  Created new node %s\n", new_node->dump_name ());
callers.release ();
4129}

4131/* If INDICES is not empty, dump a combination of NODE's dump_name and MSG
 followed by the list of numbers in INDICES.  */

4134static void
4135dump_list_of_param_indices (const cgraph_node *node, const char* msg,
	    const vec<unsigned> &indices)
4137{
if (indices.is_empty ())
  return;
fprintf (dump_file, "The following parameters of %s %s:", node->dump_name (),
  msg);
for (unsigned i : indices)
  fprintf (dump_file, " %u", i);
fprintf (dump_file, "\n");
4145}

4147/* Check which parameters of NODE described by IFS have survived until IPA-SRA
 and disable transformations for those which have not or which should not
 transformed because the associated debug counter reached its limit.  Return
 true if none survived or if there were no candidates to begin with.
 Additionally, also adjust parameter descriptions based on debug counters and
 hints propagated earlier.  */

4154static bool
4155adjust_parameter_descriptions (cgraph_node *node, isra_func_summary *ifs)
4156{
bool ret = true;
unsigned len = vec_safe_length (ifs->m_parameters);
if (!len)
  return true;

auto_vec<bool, 16> surviving_params;
bool check_surviving = false;
clone_info *cinfo = clone_info::get (node);
if (cinfo && cinfo->param_adjustments)
  {
    check_surviving = true;
    cinfo->param_adjustments->get_surviving_params (&surviving_params);
  }
ipcp_transformation *ipcp_ts = ipcp_get_transformation_summary (node);
auto_vec <unsigned> dump_dead_indices;
auto_vec <unsigned> dump_bad_cond_indices;
for (unsigned i = 0; i < len; i++)
  {
    isra_param_desc *desc = &(*ifs->m_parameters)[i];
    if (!dbg_cnt (ipa_sra_params))
{
 desc->locally_unused = false;
 desc->split_candidate = false;
}
    else if (check_surviving
      && (i >= surviving_params.length ()
   || !surviving_params[i]))
{
 /* Even if the parameter was removed by a previous IPA pass, we do
    not clear locally_unused because if it really is unused, this
    information might be useful in callers.  */
 desc->split_candidate = false;

 if (dump_file && (dump_flags & TDF_DETAILS))
   dump_dead_indices.safe_push (i);
}
    else
{
 if (desc->split_candidate && desc->conditionally_dereferenceable)
   {
     gcc_assert (desc->safe_size_set)((void)(!(desc->safe_size_set) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4197, __FUNCTION__), 0 : 0));
     for (param_access *pa : *desc->accesses)
if ((pa->unit_offset + pa->unit_size) > desc->safe_size)
  {
    if (dump_file && (dump_flags & TDF_DETAILS))
      dump_bad_cond_indices.safe_push (i);
    desc->split_candidate = false;
    break;
  }
   }

 if (desc->split_candidate)
   {
     if (desc->by_ref && !desc->not_specially_constructed)
{
  int extra_factor
    = opt_for_fn (node->decl,(opts_for_fn (node->decl)->x_param_ipa_sra_ptrwrap_growth_factor
)
		  param_ipa_sra_ptrwrap_growth_factor)(opts_for_fn (node->decl)->x_param_ipa_sra_ptrwrap_growth_factor
);
  desc->param_size_limit = extra_factor * desc->param_size_limit;
}
     if (size_would_violate_limit_p (desc, desc->size_reached))
desc->split_candidate = false;
   }

 /* Avoid ICEs on size-mismatched VIEW_CONVERT_EXPRs when callers and
    callees don't agree on types in aggregates and we try to do both
    IPA-CP and IPA-SRA.  */
 if (ipcp_ts && desc->split_candidate)
   {
     ipa_argagg_value_list avl (ipcp_ts);
     for (const param_access *pa : desc->accesses)
{
  if (!pa->certain)
    continue;
  tree value = avl.get_value (i, pa->unit_offset);
  if (value
      && ((tree_to_uhwi (TYPE_SIZE (TREE_TYPE (value))((tree_class_check ((((contains_struct_check ((value), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4233, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4233, __FUNCTION__))->type_common.size))
	   / BITS_PER_UNIT(8))
	  != pa->unit_size))
    {
      desc->split_candidate = false;
      if (dump_file && (dump_flags & TDF_DETAILS))
	dump_dead_indices.safe_push (i);
      break;
    }
}
   }

 if (desc->locally_unused || desc->split_candidate)
   ret = false;
}
  }

dump_list_of_param_indices (node, "are dead on arrival or have a type "
	      "mismatch with IPA-CP", dump_dead_indices);
dump_list_of_param_indices (node, "are not safe to dereference in all "
	      "callers", dump_bad_cond_indices);

return ret;
4256}


4259/* Run the interprocedural part of IPA-SRA. */

4261static unsigned int
4262ipa_sra_analysis (void)
4263{
if (dump_file)
  {
    fprintf (dump_file, "\n========== IPA-SRA IPA stage ==========\n");
    ipa_sra_dump_all_summaries (dump_file, false);
  }

gcc_checking_assert (func_sums)((void)(!(func_sums) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4270, __FUNCTION__), 0 : 0));
gcc_checking_assert (call_sums)((void)(!(call_sums) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4271, __FUNCTION__), 0 : 0));
cgraph_node **order = XCNEWVEC (cgraph_node *, symtab->cgraph_count)((cgraph_node * *) xcalloc ((symtab->cgraph_count), sizeof
 (cgraph_node *)));
auto_vec <cgraph_node *, 16> stack;
int node_scc_count = ipa_reduced_postorder (order, true, NULLnullptr);

/* One sweep from callers to callees for return value removal.  */
for (int i = node_scc_count - 1; i >= 0 ; i--)
  {
    cgraph_node *scc_rep = order[i];
    vec<cgraph_node *> cycle_nodes = ipa_get_nodes_in_cycle (scc_rep);

    /* Preliminary IPA function level checks.  */
    for (cgraph_node *v : cycle_nodes)
{
 isra_func_summary *ifs = func_sums->get (v);
 if (!ifs || !ifs->m_candidate)
   continue;
 if (!ipa_sra_ipa_function_checks (v)
     || check_all_callers_for_issues (v))
   ifs->zap ();
}

    for (cgraph_node *v : cycle_nodes)
{
 isra_func_summary *ifs = func_sums->get (v);
 if (!ifs || !ifs->m_candidate)
   continue;
 bool return_needed
   = (ifs->m_returns_value
      && (!dbg_cnt (ipa_sra_retvalues)
   || v->call_for_symbol_and_aliases (retval_used_p,
				      NULLnullptr, true)));
 ifs->m_return_ignored = !return_needed;
 if (return_needed)
   isra_push_node_to_stack (v, ifs, &stack);
}

    while (!stack.is_empty ())
{
 cgraph_node *node = stack.pop ();
 isra_func_summary *ifs = func_sums->get (node);
 gcc_checking_assert (ifs && ifs->m_queued)((void)(!(ifs && ifs->m_queued) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4312, __FUNCTION__), 0 : 0));
 ifs->m_queued = false;

 for (cgraph_edge *cs = node->callees; cs; cs = cs->next_callee)
   if (ipa_edge_within_scc (cs)
&& call_sums->get (cs)->m_return_returned)
     {
enum availability av;
cgraph_node *callee = cs->callee->function_symbol (&av);
isra_func_summary *to_ifs = func_sums->get (callee);
if (to_ifs && to_ifs->m_return_ignored)
  {
    to_ifs->m_return_ignored = false;
    isra_push_node_to_stack (callee, to_ifs, &stack);
  }
     }
}

    /* Parameter hint propagation.  */
    for (cgraph_node *v : cycle_nodes)
{
 isra_func_summary *ifs = func_sums->get (v);
 propagate_hints_to_all_callees (v, ifs, &stack);
}

    while (!stack.is_empty ())
{
 cgraph_node *node = stack.pop ();
 isra_func_summary *ifs = func_sums->get (node);
 gcc_checking_assert (ifs && ifs->m_queued)((void)(!(ifs && ifs->m_queued) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4341, __FUNCTION__), 0 : 0));
 ifs->m_queued = false;
 propagate_hints_to_all_callees (node, ifs, &stack);
}

    cycle_nodes.release ();
  }

/* One sweep from callees to callers for parameter removal and splitting.  */
for (int i = 0; i < node_scc_count; i++)
  {
    cgraph_node *scc_rep = order[i];
    vec<cgraph_node *> cycle_nodes = ipa_get_nodes_in_cycle (scc_rep);

    /* First step of parameter removal.  */
    for (cgraph_node *v : cycle_nodes)
{
 isra_func_summary *ifs = func_sums->get (v);
 if (!ifs || !ifs->m_candidate)
   continue;
 if (adjust_parameter_descriptions (v, ifs))
   continue;
 for (cgraph_edge *cs = v->indirect_calls; cs; cs = cs->next_callee)
   process_edge_to_unknown_caller (cs);
 for (cgraph_edge *cs = v->callees; cs; cs = cs->next_callee)
   if (!ipa_edge_within_scc (cs))
     param_removal_cross_scc_edge (cs);
}

    /* Look at edges within the current SCC and propagate used-ness across
them, pushing onto the stack all notes which might need to be
revisited.  */
    for (cgraph_node *v : cycle_nodes)
v->call_for_symbol_thunks_and_aliases (propagate_used_to_scc_callers,
			       &stack, true);

    /* Keep revisiting and pushing until nothing changes.  */
    while (!stack.is_empty ())
{
 cgraph_node *v = stack.pop ();
 isra_func_summary *ifs = func_sums->get (v);
 gcc_checking_assert (ifs && ifs->m_queued)((void)(!(ifs && ifs->m_queued) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4382, __FUNCTION__), 0 : 0));
 ifs->m_queued = false;

 v->call_for_symbol_thunks_and_aliases (propagate_used_to_scc_callers,
				 &stack, true);
}

    /* Parameter splitting.  */
    bool repeat_scc_access_propagation;
    do
{
 repeat_scc_access_propagation = false;
 for (cgraph_node *v : cycle_nodes)
   {
     isra_func_summary *ifs = func_sums->get (v);
     if (!ifs
  || !ifs->m_candidate
  || vec_safe_is_empty (ifs->m_parameters))
continue;
     for (cgraph_edge *cs = v->callees; cs; cs = cs->next_callee)
if (param_splitting_across_edge (cs))
  repeat_scc_access_propagation = true;
   }
}
    while (repeat_scc_access_propagation);

    if (flag_checkingglobal_options.x_flag_checking)
for (cgraph_node *v : cycle_nodes)
 verify_splitting_accesses (v, true);

    cycle_nodes.release ();
  }

ipa_free_postorder_info ();
free (order);

if (dump_file)
  {
    if (dump_flags & TDF_DETAILS)
{
 fprintf (dump_file, "\n========== IPA-SRA propagation final state "
   " ==========\n");
 ipa_sra_dump_all_summaries (dump_file, true);
}
    fprintf (dump_file, "\n========== IPA-SRA decisions ==========\n");
  }

hash_map<const char *, unsigned> *clone_num_suffixes
  = new hash_map<const char *, unsigned>;

cgraph_node *node;
FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)for ((node) = symtab->first_function_with_gimple_body (); (
node); (node) = symtab->next_function_with_gimple_body (node
))
  process_isra_node_results (node, clone_num_suffixes);

delete clone_num_suffixes;
ggc_delete (func_sums);
func_sums = NULLnullptr;
delete call_sums;
call_sums = NULLnullptr;

if (dump_file)
  fprintf (dump_file, "\n========== IPA SRA IPA analysis done "
    "==========\n\n");
return 0;
4446}


4449const pass_data pass_data_ipa_sra =
4450{
IPA_PASS, /* type */
"sra", /* name */
OPTGROUP_NONE, /* optinfo_flags */
TV_IPA_SRA, /* tv_id */
0, /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
( TODO_dump_symtab(1 << 7) | TODO_remove_functions(1 << 8) ), /* todo_flags_finish */
4460};

4462class pass_ipa_sra : public ipa_opt_pass_d
4463{
4464public:
pass_ipa_sra (gcc::context *ctxt)
  : ipa_opt_pass_d (pass_data_ipa_sra, ctxt,
      ipa_sra_generate_summary, /* generate_summary */
      ipa_sra_write_summary, /* write_summary */
      ipa_sra_read_summary, /* read_summary */
      NULLnullptr , /* write_optimization_summary */
      NULLnullptr, /* read_optimization_summary */
      NULLnullptr, /* stmt_fixup */
      0, /* function_transform_todo_flags_start */
      NULLnullptr, /* function_transform */
      NULLnullptr) /* variable_transform */
{}

/* opt_pass methods: */
bool gate (function *) final override
  {
    /* TODO: We should remove the optimize check after we ensure we never run
IPA passes when not optimizing.  */
    return (flag_ipa_sraglobal_options.x_flag_ipa_sra && optimizeglobal_options.x_optimize);
  }

unsigned int execute (function *)  final override
{
  return ipa_sra_analysis ();
}

4491}; // class pass_ipa_sra

4493} // anon namespace

4495/* Intraprocedural part of IPA-SRA analysis.  Scan function body of NODE and
 create a summary structure describing IPA-SRA opportunities and constraints
 in it.  */

4499static void
4500ipa_sra_summarize_function (cgraph_node *node)
4501{
if (dump_file)
  fprintf (dump_file, "Creating summary for %s/%i:\n", node->name (),
    node->order);
gcc_obstack_init (&gensum_obstack)_obstack_begin (((&gensum_obstack)), (memory_block_pool::
block_size), (0), (mempool_obstack_chunk_alloc), (mempool_obstack_chunk_free
));
loaded_decls = new hash_set<tree>;

isra_func_summary *ifs = NULLnullptr;
unsigned count = 0;
if (ipa_sra_preliminary_function_checks (node))
  {
    ifs = func_sums->get_create (node);
    ifs->m_candidate = true;
    tree ret = TREE_TYPE (TREE_TYPE (node->decl))((contains_struct_check ((((contains_struct_check ((node->
decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4514, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4514, __FUNCTION__))->typed.type);
    ifs->m_returns_value = (TREE_CODE (ret)((enum tree_code) (ret)->base.code) != VOID_TYPE);
    for (tree parm = DECL_ARGUMENTS (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4516, __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-sra.cc"
, 4518, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4518, __FUNCTION__))->common.chain)))
count++;
  }
auto_vec<gensum_param_desc, 16> param_descriptions (count);

struct function *fun = DECL_STRUCT_FUNCTION (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-sra.cc"
, 4523, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f);
bool cfun_pushed = false;
if (count > 0)
  {
    decl2desc = new hash_map<tree, gensum_param_desc *>;
    param_descriptions.reserve_exact (count);
    param_descriptions.quick_grow_cleared (count);

    if (create_parameter_descriptors (node, &param_descriptions))
{
 push_cfun (fun);
 cfun_pushed = true;
 final_bbs = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
 bb_dereferences = XCNEWVEC (HOST_WIDE_INT,((long *) xcalloc ((unsafe_by_ref_count * ((fun)->cfg->
x_last_basic_block)), sizeof (long)))
		      unsafe_by_ref_count((long *) xcalloc ((unsafe_by_ref_count * ((fun)->cfg->
x_last_basic_block)), sizeof (long)))
		      * last_basic_block_for_fn (fun))((long *) xcalloc ((unsafe_by_ref_count * ((fun)->cfg->
x_last_basic_block)), sizeof (long)));
 aa_walking_limit = opt_for_fn (node->decl, param_ipa_max_aa_steps)(opts_for_fn (node->decl)->x_param_ipa_max_aa_steps);
}
  }
/* Scan function is run even when there are no removal or splitting
   candidates so that we can calculate hints on call edges which can be
   useful in callees. */
scan_function (node, fun);

if (count > 0)
  {
    if (dump_file)
{
 dump_gensum_param_descriptors (dump_file, node->decl,
			 &param_descriptions);
 fprintf (dump_file, "----------------------------------------\n");
}

    process_scan_results (node, fun, ifs, &param_descriptions);

    if (cfun_pushed)
pop_cfun ();
    if (bb_dereferences)
{
 free (bb_dereferences);
 bb_dereferences = NULLnullptr;
 BITMAP_FREE (final_bbs)((void) (bitmap_obstack_free ((bitmap) final_bbs), (final_bbs
) = (bitmap) nullptr));
 final_bbs = NULLnullptr;
}
  }
isra_analyze_all_outgoing_calls (node);

delete loaded_decls;
loaded_decls = NULLnullptr;
if (decl2desc)
  {
    delete decl2desc;
    decl2desc = NULLnullptr;
  }
obstack_free (&gensum_obstack, NULL)__extension__ ({ struct obstack *__o = (&gensum_obstack);
 void *__obj = (void *) (nullptr); if (__obj > (void *) __o
->chunk && __obj < (void *) __o->chunk_limit
) __o->next_free = __o->object_base = (char *) __obj; else
 _obstack_free (__o, __obj); });
if (dump_file)
  fprintf (dump_file, "\n\n");
if (flag_checkingglobal_options.x_flag_checking)
  verify_splitting_accesses (node, false);
return;
4583}

4585ipa_opt_pass_d *
4586make_pass_ipa_sra (gcc::context *ctxt)
4587{
return new pass_ipa_sra (ctxt);
4589}


4592#include "gt-ipa-sra.h"

←

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

1/* Vector API for GNU compiler.
2   Copyright (C) 2004-2023 Free Software Foundation, Inc.
3   Contributed by Nathan Sidwell <nathan@codesourcery.com>
4   Re-implemented in C++ by Diego Novillo <dnovillo@google.com>
5 
6This file is part of GCC.
7 
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12 
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16for more details.
17 
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3.  If not see
20<http://www.gnu.org/licenses/>.  */
21 
22#ifndef GCC_VEC_H
23#define GCC_VEC_H
24 
25/* Some gen* file have no ggc support as the header file gtype-desc.h is
26   missing.  Provide these definitions in case ggc.h has not been included.
27   This is not a problem because any code that runs before gengtype is built
28   will never need to use GC vectors.*/
29 
30extern void ggc_free (void *);
31extern size_t ggc_round_alloc_size (size_t requested_size);
32extern void *ggc_realloc (void *, size_t MEM_STAT_DECL);
33 
34/* Templated vector type and associated interfaces.
35 
36   The interface functions are typesafe and use inline functions,
37   sometimes backed by out-of-line generic functions.  The vectors are
38   designed to interoperate with the GTY machinery.
39 
40   There are both 'index' and 'iterate' accessors.  The index accessor
41   is implemented by operator[].  The iterator returns a boolean
42   iteration condition and updates the iteration variable passed by
43   reference.  Because the iterator will be inlined, the address-of
44   can be optimized away.
45 
46   Each operation that increases the number of active elements is
47   available in 'quick' and 'safe' variants.  The former presumes that
48   there is sufficient allocated space for the operation to succeed
49   (it dies if there is not).  The latter will reallocate the
50   vector, if needed.  Reallocation causes an exponential increase in
51   vector size.  If you know you will be adding N elements, it would
52   be more efficient to use the reserve operation before adding the
53   elements with the 'quick' operation.  This will ensure there are at
54   least as many elements as you ask for, it will exponentially
55   increase if there are too few spare slots.  If you want reserve a
56   specific number of slots, but do not want the exponential increase
57   (for instance, you know this is the last allocation), use the
58   reserve_exact operation.  You can also create a vector of a
59   specific size from the get go.
60 
61   You should prefer the push and pop operations, as they append and
62   remove from the end of the vector. If you need to remove several
63   items in one go, use the truncate operation.  The insert and remove
64   operations allow you to change elements in the middle of the
65   vector.  There are two remove operations, one which preserves the
66   element ordering 'ordered_remove', and one which does not
67   'unordered_remove'.  The latter function copies the end element
68   into the removed slot, rather than invoke a memmove operation.  The
69   'lower_bound' function will determine where to place an item in the
70   array using insert that will maintain sorted order.
71 
72   Vectors are template types with three arguments: the type of the
73   elements in the vector, the allocation strategy, and the physical
74   layout to use
75 
76   Four allocation strategies are supported:
77 
78	- Heap: allocation is done using malloc/free.  This is the
79	  default allocation strategy.
80 
81  	- GC: allocation is done using ggc_alloc/ggc_free.
82 
83  	- GC atomic: same as GC with the exception that the elements
84	  themselves are assumed to be of an atomic type that does
85	  not need to be garbage collected.  This means that marking
86	  routines do not need to traverse the array marking the
87	  individual elements.  This increases the performance of
88	  GC activities.
89 
90   Two physical layouts are supported:
91 
92	- Embedded: The vector is structured using the trailing array
93	  idiom.  The last member of the structure is an array of size
94	  1.  When the vector is initially allocated, a single memory
95	  block is created to hold the vector's control data and the
96	  array of elements.  These vectors cannot grow without
97	  reallocation (see discussion on embeddable vectors below).
98 
99	- Space efficient: The vector is structured as a pointer to an
100	  embedded vector.  This is the default layout.  It means that
101	  vectors occupy a single word of storage before initial
102	  allocation.  Vectors are allowed to grow (the internal
103	  pointer is reallocated but the main vector instance does not
104	  need to relocate).
105 
106   The type, allocation and layout are specified when the vector is
107   declared.
108 
109   If you need to directly manipulate a vector, then the 'address'
110   accessor will return the address of the start of the vector.  Also
111   the 'space' predicate will tell you whether there is spare capacity
112   in the vector.  You will not normally need to use these two functions.
113 
114   Notes on the different layout strategies
115 
116   * Embeddable vectors (vec<T, A, vl_embed>)
117   
118     These vectors are suitable to be embedded in other data
119     structures so that they can be pre-allocated in a contiguous
120     memory block.
121 
122     Embeddable vectors are implemented using the trailing array
123     idiom, thus they are not resizeable without changing the address
124     of the vector object itself.  This means you cannot have
125     variables or fields of embeddable vector type -- always use a
126     pointer to a vector.  The one exception is the final field of a
127     structure, which could be a vector type.
128 
129     You will have to use the embedded_size & embedded_init calls to
130     create such objects, and they will not be resizeable (so the
131     'safe' allocation variants are not available).
132 
133     Properties of embeddable vectors:
134 
135	  - The whole vector and control data are allocated in a single
136	    contiguous block.  It uses the trailing-vector idiom, so
137	    allocation must reserve enough space for all the elements
138	    in the vector plus its control data.
139	  - The vector cannot be re-allocated.
140	  - The vector cannot grow nor shrink.
141	  - No indirections needed for access/manipulation.
142	  - It requires 2 words of storage (prior to vector allocation).
143 
144 
145   * Space efficient vector (vec<T, A, vl_ptr>)
146 
147     These vectors can grow dynamically and are allocated together
148     with their control data.  They are suited to be included in data
149     structures.  Prior to initial allocation, they only take a single
150     word of storage.
151 
152     These vectors are implemented as a pointer to embeddable vectors.
153     The semantics allow for this pointer to be NULL to represent
154     empty vectors.  This way, empty vectors occupy minimal space in
155     the structure containing them.
156 
157     Properties:
158 
159	- The whole vector and control data are allocated in a single
160	  contiguous block.
161  	- The whole vector may be re-allocated.
162  	- Vector data may grow and shrink.
163  	- Access and manipulation requires a pointer test and
164	  indirection.
165  	- It requires 1 word of storage (prior to vector allocation).
166 
167   An example of their use would be,
168 
169   struct my_struct {
170     // A space-efficient vector of tree pointers in GC memory.
171     vec<tree, va_gc, vl_ptr> v;
172   };
173 
174   struct my_struct *s;
175 
176   if (s->v.length ()) { we have some contents }
177   s->v.safe_push (decl); // append some decl onto the end
178   for (ix = 0; s->v.iterate (ix, &elt); ix++)
179     { do something with elt }
180*/
181 
182/* Support function for statistics.  */
183extern void dump_vec_loc_statistics (void);
184 
185/* Hashtable mapping vec addresses to descriptors.  */
186extern htab_t vec_mem_usage_hash;
187 
188/* Control data for vectors.  This contains the number of allocated
189   and used slots inside a vector.  */
190 
191struct vec_prefix
192{
193  /* FIXME - These fields should be private, but we need to cater to
194	     compilers that have stricter notions of PODness for types.  */
195 
196  /* Memory allocation support routines in vec.cc.  */
197  void register_overhead (void *, size_t, size_t CXX_MEM_STAT_INFO);
198  void release_overhead (void *, size_t, size_t, bool CXX_MEM_STAT_INFO);
199  static unsigned calculate_allocation (vec_prefix *, unsigned, bool);
200  static unsigned calculate_allocation_1 (unsigned, unsigned);
201 
202  /* Note that vec_prefix should be a base class for vec, but we use
203     offsetof() on vector fields of tree structures (e.g.,
204     tree_binfo::base_binfos), and offsetof only supports base types.
205 
206     To compensate, we make vec_prefix a field inside vec and make
207     vec a friend class of vec_prefix so it can access its fields.  */
208  template <typename, typename, typename> friend struct vec;
209 
210  /* The allocator types also need access to our internals.  */
211  friend struct va_gc;
212  friend struct va_gc_atomic;
213  friend struct va_heap;
214 
215  unsigned m_alloc : 31;
216  unsigned m_using_auto_storage : 1;
217  unsigned m_num;
218};
219 
220/* Calculate the number of slots to reserve a vector, making sure that
221   RESERVE slots are free.  If EXACT grow exactly, otherwise grow
222   exponentially.  PFX is the control data for the vector.  */
223 
224inline unsigned
225vec_prefix::calculate_allocation (vec_prefix *pfx, unsigned reserve,
226				  bool exact)
227{
228  if (exact)
229    return (pfx ? pfx->m_num : 0) + reserve;
230  else if (!pfx)
231    return MAX (4, reserve)((4) > (reserve) ? (4) : (reserve));
232  return calculate_allocation_1 (pfx->m_alloc, pfx->m_num + reserve);
233}
234 
235template<typename, typename, typename> struct vec;
236 
237/* Valid vector layouts
238 
239   vl_embed	- Embeddable vector that uses the trailing array idiom.
240   vl_ptr	- Space efficient vector that uses a pointer to an
241		  embeddable vector.  */
242struct vl_embed { };
243struct vl_ptr { };
244 
245 
246/* Types of supported allocations
247 
248   va_heap	- Allocation uses malloc/free.
249   va_gc	- Allocation uses ggc_alloc.
250   va_gc_atomic	- Same as GC, but individual elements of the array
251		  do not need to be marked during collection.  */
252 
253/* Allocator type for heap vectors.  */
254struct va_heap
255{
256  /* Heap vectors are frequently regular instances, so use the vl_ptr
257     layout for them.  */
258  typedef vl_ptr default_layout;
259 
260  template<typename T>
261  static void reserve (vec<T, va_heap, vl_embed> *&, unsigned, bool
262		       CXX_MEM_STAT_INFO);
263 
264  template<typename T>
265  static void release (vec<T, va_heap, vl_embed> *&);
266};
267 
268 
269/* Allocator for heap memory.  Ensure there are at least RESERVE free
270   slots in V.  If EXACT is true, grow exactly, else grow
271   exponentially.  As a special case, if the vector had not been
272   allocated and RESERVE is 0, no vector will be created.  */
273 
274template<typename T>
275inline void
276va_heap::reserve (vec<T, va_heap, vl_embed> *&v, unsigned reserve, bool exact
277		  MEM_STAT_DECL)
278{
279  size_t elt_size = sizeof (T);
280  unsigned alloc
281    = vec_prefix::calculate_allocation (v ? &v->m_vecpfx : 0, reserve, exact);
282  gcc_checking_assert (alloc)((void)(!(alloc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 282, __FUNCTION__), 0 : 0));
283 
284  if (GATHER_STATISTICS0 && v)
285    v->m_vecpfx.release_overhead (v, elt_size * v->allocated (),
286				  v->allocated (), false);
287 
288  size_t size = vec<T, va_heap, vl_embed>::embedded_size (alloc);
289  unsigned nelem = v ? v->length () : 0;
290  v = static_cast <vec<T, va_heap, vl_embed> *> (xrealloc (v, size));
291  v->embedded_init (alloc, nelem);
292 
293  if (GATHER_STATISTICS0)
294    v->m_vecpfx.register_overhead (v, alloc, elt_size PASS_MEM_STAT);
295}
296 
297 
298#if GCC_VERSION(4 * 1000 + 2) >= 4007
299#pragma GCC diagnostic push
300#pragma GCC diagnostic ignored "-Wfree-nonheap-object"
301#endif
302 
303/* Free the heap space allocated for vector V.  */
304 
305template<typename T>
306void
307va_heap::release (vec<T, va_heap, vl_embed> *&v)
308{
309  size_t elt_size = sizeof (T);
310  if (v == NULLnullptr)
311    return;
312 
313  if (GATHER_STATISTICS0)
314    v->m_vecpfx.release_overhead (v, elt_size * v->allocated (),
315				  v->allocated (), true);
316  ::free (v);
317  v = NULLnullptr;
318}
319 
320#if GCC_VERSION(4 * 1000 + 2) >= 4007
321#pragma GCC diagnostic pop
322#endif
323 
324/* Allocator type for GC vectors.  Notice that we need the structure
325   declaration even if GC is not enabled.  */
326 
327struct va_gc
328{
329  /* Use vl_embed as the default layout for GC vectors.  Due to GTY
330     limitations, GC vectors must always be pointers, so it is more
331     efficient to use a pointer to the vl_embed layout, rather than
332     using a pointer to a pointer as would be the case with vl_ptr.  */
333  typedef vl_embed default_layout;
334 
335  template<typename T, typename A>
336  static void reserve (vec<T, A, vl_embed> *&, unsigned, bool
337		       CXX_MEM_STAT_INFO);
338 
339  template<typename T, typename A>
340  static void release (vec<T, A, vl_embed> *&v);
341};
342 
343 
344/* Free GC memory used by V and reset V to NULL.  */
345 
346template<typename T, typename A>
347inline void
348va_gc::release (vec<T, A, vl_embed> *&v)
349{
350  if (v)
351    ::ggc_free (v);
352  v = NULLnullptr;
353}
354 
355 
356/* Allocator for GC memory.  Ensure there are at least RESERVE free
357   slots in V.  If EXACT is true, grow exactly, else grow
358   exponentially.  As a special case, if the vector had not been
359   allocated and RESERVE is 0, no vector will be created.  */
360 
361template<typename T, typename A>
362void
363va_gc::reserve (vec<T, A, vl_embed> *&v, unsigned reserve, bool exact
364		MEM_STAT_DECL)
365{
366  unsigned alloc
367    = vec_prefix::calculate_allocation (v17.1
'v' is non-null
17.1
'v' is non-null
 ? &v->m_vecpfx : 0, reserve, exact);
18
←
'?' condition is true→
368  if (!alloc)
19
←
Assuming 'alloc' is 0→
20
←
Taking true branch→
369    {
370      ::ggc_free (v);
371      v = NULLnullptr;
21
←
Null pointer value stored to field 'accesses'→
372      return;
373    }
374 
375  /* Calculate the amount of space we want.  */
376  size_t size = vec<T, A, vl_embed>::embedded_size (alloc);
377 
378  /* Ask the allocator how much space it will really give us.  */
379  size = ::ggc_round_alloc_size (size);
380 
381  /* Adjust the number of slots accordingly.  */
382  size_t vec_offset = sizeof (vec_prefix);
383  size_t elt_size = sizeof (T);
384  alloc = (size - vec_offset) / elt_size;
385 
386  /* And finally, recalculate the amount of space we ask for.  */
387  size = vec_offset + alloc * elt_size;
388 
389  unsigned nelem = v ? v->length () : 0;
390  v = static_cast <vec<T, A, vl_embed> *> (::ggc_realloc (v, size
391							       PASS_MEM_STAT));
392  v->embedded_init (alloc, nelem);
393}
394 
395 
396/* Allocator type for GC vectors.  This is for vectors of types
397   atomics w.r.t. collection, so allocation and deallocation is
398   completely inherited from va_gc.  */
399struct va_gc_atomic : va_gc
400{
401};
402 
403 
404/* Generic vector template.  Default values for A and L indicate the
405   most commonly used strategies.
406 
407   FIXME - Ideally, they would all be vl_ptr to encourage using regular
408           instances for vectors, but the existing GTY machinery is limited
409	   in that it can only deal with GC objects that are pointers
410	   themselves.
411 
412	   This means that vector operations that need to deal with
413	   potentially NULL pointers, must be provided as free
414	   functions (see the vec_safe_* functions above).  */
415template<typename T,
416         typename A = va_heap,
417         typename L = typename A::default_layout>
418struct GTY((user)) vec
419{
420};
421 
422/* Allow C++11 range-based 'for' to work directly on vec<T>*.  */
423template<typename T, typename A, typename L>
424T* begin (vec<T,A,L> *v) { return v ? v->begin () : nullptr; }
425template<typename T, typename A, typename L>
426T* end (vec<T,A,L> *v) { return v ? v->end () : nullptr; }
427template<typename T, typename A, typename L>
428const T* begin (const vec<T,A,L> *v) { return v ? v->begin () : nullptr; }
429template<typename T, typename A, typename L>
430const T* end (const vec<T,A,L> *v) { return v ? v->end () : nullptr; }
431 
432/* Generic vec<> debug helpers.
433 
434   These need to be instantiated for each vec<TYPE> used throughout
435   the compiler like this:
436 
437    DEFINE_DEBUG_VEC (TYPE)
438 
439   The reason we have a debug_helper() is because GDB can't
440   disambiguate a plain call to debug(some_vec), and it must be called
441   like debug<TYPE>(some_vec).  */
442 
443template<typename T>
444void
445debug_helper (vec<T> &ref)
446{
447  unsigned i;
448  for (i = 0; i < ref.length (); ++i)
449    {
450      fprintf (stderrstderr, "[%d] = ", i);
451      debug_slim (ref[i]);
452      fputc ('\n', stderrstderr);
453    }
454}
455 
456/* We need a separate va_gc variant here because default template
457   argument for functions cannot be used in c++-98.  Once this
458   restriction is removed, those variant should be folded with the
459   above debug_helper.  */
460 
461template<typename T>
462void
463debug_helper (vec<T, va_gc> &ref)
464{
465  unsigned i;
466  for (i = 0; i < ref.length (); ++i)
467    {
468      fprintf (stderrstderr, "[%d] = ", i);
469      debug_slim (ref[i]);
470      fputc ('\n', stderrstderr);
471    }
472}
473 
474/* Macro to define debug(vec<T>) and debug(vec<T, va_gc>) helper
475   functions for a type T.  */
476 
477#define DEFINE_DEBUG_VEC(T)template void debug_helper (vec<T> &); template void
 debug_helper (vec<T, va_gc> &); __attribute__ ((__used__
)) void debug (vec<T> &ref) { debug_helper <T>
 (ref); } __attribute__ ((__used__)) void debug (vec<T>
 *ptr) { if (ptr) debug (*ptr); else fprintf (stderr, "<nil>\n"
); } __attribute__ ((__used__)) void debug (vec<T, va_gc>
 &ref) { debug_helper <T> (ref); } __attribute__ ((
__used__)) void debug (vec<T, va_gc> *ptr) { if (ptr) debug
 (*ptr); else fprintf (stderr, "<nil>\n"); } \
478  template void debug_helper (vec<T> &);		\
479  template void debug_helper (vec<T, va_gc> &);		\
480  /* Define the vec<T> debug functions.  */		\
481  DEBUG_FUNCTION__attribute__ ((__used__)) void					\
482  debug (vec<T> &ref)					\
483  {							\
484    debug_helper <T> (ref);				\
485  }							\
486  DEBUG_FUNCTION__attribute__ ((__used__)) void					\
487  debug (vec<T> *ptr)					\
488  {							\
489    if (ptr)						\
490      debug (*ptr);					\
491    else						\
492      fprintf (stderrstderr, "<nil>\n");			\
493  }							\
494  /* Define the vec<T, va_gc> debug functions.  */	\
495  DEBUG_FUNCTION__attribute__ ((__used__)) void					\
496  debug (vec<T, va_gc> &ref)				\
497  {							\
498    debug_helper <T> (ref);				\
499  }							\
500  DEBUG_FUNCTION__attribute__ ((__used__)) void					\
501  debug (vec<T, va_gc> *ptr)				\
502  {							\
503    if (ptr)						\
504      debug (*ptr);					\
505    else						\
506      fprintf (stderrstderr, "<nil>\n");			\
507  }
508 
509/* Default-construct N elements in DST.  */
510 
511template <typename T>
512inline void
513vec_default_construct (T *dst, unsigned n)
514{
515#ifdef BROKEN_VALUE_INITIALIZATION
516  /* Versions of GCC before 4.4 sometimes leave certain objects
517     uninitialized when value initialized, though if the type has
518     user defined default ctor, that ctor is invoked.  As a workaround
519     perform clearing first and then the value initialization, which
520     fixes the case when value initialization doesn't initialize due to
521     the bugs and should initialize to all zeros, but still allows
522     vectors for types with user defined default ctor that initializes
523     some or all elements to non-zero.  If T has no user defined
524     default ctor and some non-static data members have user defined
525     default ctors that initialize to non-zero the workaround will
526     still not work properly; in that case we just need to provide
527     user defined default ctor.  */
528  memset (dst, '\0', sizeof (T) * n);
529#endif
530  for ( ; n; ++dst, --n)
531    ::new (static_cast<void*>(dst)) T ();
532}
533 
534/* Copy-construct N elements in DST from *SRC.  */
535 
536template <typename T>
537inline void
538vec_copy_construct (T *dst, const T *src, unsigned n)
539{
540  for ( ; n; ++dst, ++src, --n)
541    ::new (static_cast<void*>(dst)) T (*src);
542}
543 
544/* Type to provide zero-initialized values for vec<T, A, L>.  This is
545   used to  provide nil initializers for vec instances.  Since vec must
546   be a trivially copyable type that can be copied by memcpy and zeroed
547   out by memset, it must have defaulted default and copy ctor and copy
548   assignment.  To initialize a vec either use value initialization
549   (e.g., vec() or vec v{ };) or assign it the value vNULL.  This isn't
550   needed for file-scope and function-local static vectors, which are
551   zero-initialized by default.  */
552struct vnull { };
553constexpr vnull vNULL{ };
554 
555 
556/* Embeddable vector.  These vectors are suitable to be embedded
557   in other data structures so that they can be pre-allocated in a
558   contiguous memory block.
559 
560   Embeddable vectors are implemented using the trailing array idiom,
561   thus they are not resizeable without changing the address of the
562   vector object itself.  This means you cannot have variables or
563   fields of embeddable vector type -- always use a pointer to a
564   vector.  The one exception is the final field of a structure, which
565   could be a vector type.
566 
567   You will have to use the embedded_size & embedded_init calls to
568   create such objects, and they will not be resizeable (so the 'safe'
569   allocation variants are not available).
570 
571   Properties:
572 
573	- The whole vector and control data are allocated in a single
574	  contiguous block.  It uses the trailing-vector idiom, so
575	  allocation must reserve enough space for all the elements
576  	  in the vector plus its control data.
577  	- The vector cannot be re-allocated.
578  	- The vector cannot grow nor shrink.
579  	- No indirections needed for access/manipulation.
580  	- It requires 2 words of storage (prior to vector allocation).  */
581 
582template<typename T, typename A>
583struct GTY((user)) vec<T, A, vl_embed>
584{
585public:
586  unsigned allocated (void) const { return m_vecpfx.m_alloc; }
587  unsigned length (void) const { return m_vecpfx.m_num; }
588  bool is_empty (void) const { return m_vecpfx.m_num == 0; }
589  T *address (void) { return reinterpret_cast <T *> (this + 1); }
590  const T *address (void) const
591    { return reinterpret_cast <const T *> (this + 1); }
592  T *begin () { return address (); }
593  const T *begin () const { return address (); }
594  T *end () { return address () + length (); }
595  const T *end () const { return address () + length (); }
596  const T &operator[] (unsigned) const;
597  T &operator[] (unsigned);
598  T &last (void);
599  bool space (unsigned) const;
600  bool iterate (unsigned, T *) const;
601  bool iterate (unsigned, T **) const;
602  vec *copy (ALONE_CXX_MEM_STAT_INFO) const;
603  void splice (const vec &);
604  void splice (const vec *src);
605  T *quick_push (const T &);
606  T &pop (void);
607  void truncate (unsigned);
608  void quick_insert (unsigned, const T &);
609  void ordered_remove (unsigned);
610  void unordered_remove (unsigned);
611  void block_remove (unsigned, unsigned);
612  void qsort (int (*) (const void *, const void *))qsort (int (*) (const void *, const void *));
613  void sort (int (*) (const void *, const void *, void *), void *);
614  void stablesort (int (*) (const void *, const void *, void *), void *);
615  T *bsearch (const void *key, int (*compar) (const void *, const void *));
616  T *bsearch (const void *key,
617	      int (*compar)(const void *, const void *, void *), void *);
618  unsigned lower_bound (const T &, bool (*) (const T &, const T &)) const;
619  bool contains (const T &search) const;
620  static size_t embedded_size (unsigned);
621  void embedded_init (unsigned, unsigned = 0, unsigned = 0);
622  void quick_grow (unsigned len);
623  void quick_grow_cleared (unsigned len);
624 
625  /* vec class can access our internal data and functions.  */
626  template <typename, typename, typename> friend struct vec;
627 
628  /* The allocator types also need access to our internals.  */
629  friend struct va_gc;
630  friend struct va_gc_atomic;
631  friend struct va_heap;
632 
633  /* FIXME - This field should be private, but we need to cater to
634	     compilers that have stricter notions of PODness for types.  */
635  /* Align m_vecpfx to simplify address ().  */
636  alignas (T) alignas (vec_prefix) vec_prefix m_vecpfx;
637};
638 
639 
640/* Convenience wrapper functions to use when dealing with pointers to
641   embedded vectors.  Some functionality for these vectors must be
642   provided via free functions for these reasons:
643 
644	1- The pointer may be NULL (e.g., before initial allocation).
645 
646  	2- When the vector needs to grow, it must be reallocated, so
647  	   the pointer will change its value.
648 
649   Because of limitations with the current GC machinery, all vectors
650   in GC memory *must* be pointers.  */
651 
652 
653/* If V contains no room for NELEMS elements, return false. Otherwise,
654   return true.  */
655template<typename T, typename A>
656inline bool
657vec_safe_space (const vec<T, A, vl_embed> *v, unsigned nelems)
658{
659  return v ? v->space (nelems) : nelems == 0;
660}
661 
662 
663/* If V is NULL, return 0.  Otherwise, return V->length().  */
664template<typename T, typename A>
665inline unsigned
666vec_safe_length (const vec<T, A, vl_embed> *v)
667{
668  return v ? v->length () : 0;
4
←
Assuming 'v' is non-null→
5
←
'?' condition is true→
6
←
Returning value, which participates in a condition later→
669}
670 
671 
672/* If V is NULL, return NULL.  Otherwise, return V->address().  */
673template<typename T, typename A>
674inline T *
675vec_safe_address (vec<T, A, vl_embed> *v)
676{
677  return v ? v->address () : NULLnullptr;
678}
679 
680 
681/* If V is NULL, return true.  Otherwise, return V->is_empty().  */
682template<typename T, typename A>
683inline bool
684vec_safe_is_empty (vec<T, A, vl_embed> *v)
685{
686  return v ? v->is_empty () : true;
687}
688 
689/* If V does not have space for NELEMS elements, call
690   V->reserve(NELEMS, EXACT).  */
691template<typename T, typename A>
692inline bool
693vec_safe_reserve (vec<T, A, vl_embed> *&v, unsigned nelems, bool exact = false
694		  CXX_MEM_STAT_INFO)
695{
696  bool extend = nelems ? !vec_safe_space (v, nelems) : false;
13
←
Assuming 'nelems' is not equal to 0→
14
←
'?' condition is true→
15
←
Assuming the condition is true→
697  if (extend15.1
'extend' is true
15.1
'extend' is true
)
16
←
Taking true branch→
698    A::reserve (v, nelems, exact PASS_MEM_STAT);
17
←
Calling 'va_gc::reserve'→
22
←
Returning from 'va_gc::reserve'→
699  return extend;
700}
701 
702template<typename T, typename A>
703inline bool
704vec_safe_reserve_exact (vec<T, A, vl_embed> *&v, unsigned nelems
705			CXX_MEM_STAT_INFO)
706{
707  return vec_safe_reserve (v, nelems, true PASS_MEM_STAT);
12
←
Calling 'vec_safe_reserve<param_access *, va_gc>'→
23
←
Returning from 'vec_safe_reserve<param_access *, va_gc>'→
708}
709 
710 
711/* Allocate GC memory for V with space for NELEMS slots.  If NELEMS
712   is 0, V is initialized to NULL.  */
713 
714template<typename T, typename A>
715inline void
716vec_alloc (vec<T, A, vl_embed> *&v, unsigned nelems CXX_MEM_STAT_INFO)
717{
718  v = NULLnullptr;
719  vec_safe_reserve (v, nelems, false PASS_MEM_STAT);
720}
721 
722 
723/* Free the GC memory allocated by vector V and set it to NULL.  */
724 
725template<typename T, typename A>
726inline void
727vec_free (vec<T, A, vl_embed> *&v)
728{
729  A::release (v);
730}
731 
732 
733/* Grow V to length LEN.  Allocate it, if necessary.  */
734template<typename T, typename A>
735inline void
736vec_safe_grow (vec<T, A, vl_embed> *&v, unsigned len,
737	       bool exact = false CXX_MEM_STAT_INFO)
738{
739  unsigned oldlen = vec_safe_length (v);
740  gcc_checking_assert (len >= oldlen)((void)(!(len >= oldlen) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 740, __FUNCTION__), 0 : 0));
741  vec_safe_reserve (v, len - oldlen, exact PASS_MEM_STAT);
742  v->quick_grow (len);
743}
744 
745 
746/* If V is NULL, allocate it.  Call V->safe_grow_cleared(LEN).  */
747template<typename T, typename A>
748inline void
749vec_safe_grow_cleared (vec<T, A, vl_embed> *&v, unsigned len,
750		       bool exact = false CXX_MEM_STAT_INFO)
751{
752  unsigned oldlen = vec_safe_length (v);
753  vec_safe_grow (v, len, exact PASS_MEM_STAT);
754  vec_default_construct (v->address () + oldlen, len - oldlen);
755}
756 
757 
758/* Assume V is not NULL.  */
759 
760template<typename T>
761inline void
762vec_safe_grow_cleared (vec<T, va_heap, vl_ptr> *&v,
763		       unsigned len, bool exact = false CXX_MEM_STAT_INFO)
764{
765  v->safe_grow_cleared (len, exact PASS_MEM_STAT);
766}
767 
768/* If V does not have space for NELEMS elements, call
769   V->reserve(NELEMS, EXACT).  */
770 
771template<typename T>
772inline bool
773vec_safe_reserve (vec<T, va_heap, vl_ptr> *&v, unsigned nelems, bool exact = false
774		  CXX_MEM_STAT_INFO)
775{
776  return v->reserve (nelems, exact);
777}
778 
779 
780/* If V is NULL return false, otherwise return V->iterate(IX, PTR).  */
781template<typename T, typename A>
782inline bool
783vec_safe_iterate (const vec<T, A, vl_embed> *v, unsigned ix, T **ptr)
784{
785  if (v)
786    return v->iterate (ix, ptr);
787  else
788    {
789      *ptr = 0;
790      return false;
791    }
792}
793 
794template<typename T, typename A>
795inline bool
796vec_safe_iterate (const vec<T, A, vl_embed> *v, unsigned ix, T *ptr)
797{
798  if (v)
799    return v->iterate (ix, ptr);
800  else
801    {
802      *ptr = 0;
803      return false;
804    }
805}
806 
807 
808/* If V has no room for one more element, reallocate it.  Then call
809   V->quick_push(OBJ).  */
810template<typename T, typename A>
811inline T *
812vec_safe_push (vec<T, A, vl_embed> *&v, const T &obj CXX_MEM_STAT_INFO)
813{
814  vec_safe_reserve (v, 1, false PASS_MEM_STAT);
815  return v->quick_push (obj);
816}
817 
818 
819/* if V has no room for one more element, reallocate it.  Then call
820   V->quick_insert(IX, OBJ).  */
821template<typename T, typename A>
822inline void
823vec_safe_insert (vec<T, A, vl_embed> *&v, unsigned ix, const T &obj
824		 CXX_MEM_STAT_INFO)
825{
826  vec_safe_reserve (v, 1, false PASS_MEM_STAT);
827  v->quick_insert (ix, obj);
828}
829 
830 
831/* If V is NULL, do nothing.  Otherwise, call V->truncate(SIZE).  */
832template<typename T, typename A>
833inline void
834vec_safe_truncate (vec<T, A, vl_embed> *v, unsigned size)
835{
836  if (v)
837    v->truncate (size);
838}
839 
840 
841/* If SRC is not NULL, return a pointer to a copy of it.  */
842template<typename T, typename A>
843inline vec<T, A, vl_embed> *
844vec_safe_copy (vec<T, A, vl_embed> *src CXX_MEM_STAT_INFO)
845{
846  return src ? src->copy (ALONE_PASS_MEM_STAT) : NULLnullptr;
847}
848 
849/* Copy the elements from SRC to the end of DST as if by memcpy.
850   Reallocate DST, if necessary.  */
851template<typename T, typename A>
852inline void
853vec_safe_splice (vec<T, A, vl_embed> *&dst, const vec<T, A, vl_embed> *src
854		 CXX_MEM_STAT_INFO)
855{
856  unsigned src_len = vec_safe_length (src);
857  if (src_len)
858    {
859      vec_safe_reserve_exact (dst, vec_safe_length (dst) + src_len
860			      PASS_MEM_STAT);
861      dst->splice (*src);
862    }
863}
864 
865/* Return true if SEARCH is an element of V.  Note that this is O(N) in the
866   size of the vector and so should be used with care.  */
867 
868template<typename T, typename A>
869inline bool
870vec_safe_contains (vec<T, A, vl_embed> *v, const T &search)
871{
872  return v ? v->contains (search) : false;
873}
874 
875/* Index into vector.  Return the IX'th element.  IX must be in the
876   domain of the vector.  */
877 
878template<typename T, typename A>
879inline const T &
880vec<T, A, vl_embed>::operator[] (unsigned ix) const
881{
882  gcc_checking_assert (ix < m_vecpfx.m_num)((void)(!(ix < m_vecpfx.m_num) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 882, __FUNCTION__), 0 : 0));
883  return address ()[ix];
884}
885 
886template<typename T, typename A>
887inline T &
888vec<T, A, vl_embed>::operator[] (unsigned ix)
889{
890  gcc_checking_assert (ix < m_vecpfx.m_num)((void)(!(ix < m_vecpfx.m_num) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 890, __FUNCTION__), 0 : 0));
891  return address ()[ix];
892}
893 
894 
895/* Get the final element of the vector, which must not be empty.  */
896 
897template<typename T, typename A>
898inline T &
899vec<T, A, vl_embed>::last (void)
900{
901  gcc_checking_assert (m_vecpfx.m_num > 0)((void)(!(m_vecpfx.m_num > 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 901, __FUNCTION__), 0 : 0));
902  return (*this)[m_vecpfx.m_num - 1];
903}
904 
905 
906/* If this vector has space for NELEMS additional entries, return
907   true.  You usually only need to use this if you are doing your
908   own vector reallocation, for instance on an embedded vector.  This
909   returns true in exactly the same circumstances that vec::reserve
910   will.  */
911 
912template<typename T, typename A>
913inline bool
914vec<T, A, vl_embed>::space (unsigned nelems) const
915{
916  return m_vecpfx.m_alloc - m_vecpfx.m_num >= nelems;
917}
918 
919 
920/* Return iteration condition and update *PTR to (a copy of) the IX'th
921   element of this vector.  Use this to iterate over the elements of a
922   vector as follows,
923 
924     for (ix = 0; v->iterate (ix, &val); ix++)
925       continue;  */
926 
927template<typename T, typename A>
928inline bool
929vec<T, A, vl_embed>::iterate (unsigned ix, T *ptr) const
930{
931  if (ix < m_vecpfx.m_num)
932    {
933      *ptr = address ()[ix];
934      return true;
935    }
936  else
937    {
938      *ptr = 0;
939      return false;
940    }
941}
942 
943 
944/* Return iteration condition and update *PTR to point to the
945   IX'th element of this vector.  Use this to iterate over the
946   elements of a vector as follows,
947 
948     for (ix = 0; v->iterate (ix, &ptr); ix++)
949       continue;
950 
951   This variant is for vectors of objects.  */
952 
953template<typename T, typename A>
954inline bool
955vec<T, A, vl_embed>::iterate (unsigned ix, T **ptr) const
956{
957  if (ix < m_vecpfx.m_num)
958    {
959      *ptr = CONST_CAST (T *, &address ()[ix])(const_cast<T *> ((&address ()[ix])));
960      return true;
961    }
962  else
963    {
964      *ptr = 0;
965      return false;
966    }
967}
968 
969 
970/* Return a pointer to a copy of this vector.  */
971 
972template<typename T, typename A>
973inline vec<T, A, vl_embed> *
974vec<T, A, vl_embed>::copy (ALONE_MEM_STAT_DECLvoid) const
975{
976  vec<T, A, vl_embed> *new_vec = NULLnullptr;
977  unsigned len = length ();
978  if (len)
979    {
980      vec_alloc (new_vec, len PASS_MEM_STAT);
981      new_vec->embedded_init (len, len);
982      vec_copy_construct (new_vec->address (), address (), len);
983    }
984  return new_vec;
985}
986 
987 
988/* Copy the elements from SRC to the end of this vector as if by memcpy.
989   The vector must have sufficient headroom available.  */
990 
991template<typename T, typename A>
992inline void
993vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> &src)
994{
995  unsigned len = src.length ();
996  if (len)
997    {
998      gcc_checking_assert (space (len))((void)(!(space (len)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 998, __FUNCTION__), 0 : 0));
999      vec_copy_construct (end (), src.address (), len);
1000      m_vecpfx.m_num += len;
1001    }
1002}
1003 
1004template<typename T, typename A>
1005inline void
1006vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> *src)
1007{
1008  if (src)
1009    splice (*src);
1010}
1011 
1012 
1013/* Push OBJ (a new element) onto the end of the vector.  There must be
1014   sufficient space in the vector.  Return a pointer to the slot
1015   where OBJ was inserted.  */
1016 
1017template<typename T, typename A>
1018inline T *
1019vec<T, A, vl_embed>::quick_push (const T &obj)
1020{
1021  gcc_checking_assert (space (1))((void)(!(space (1)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1021, __FUNCTION__), 0 : 0));
1022  T *slot = &address ()[m_vecpfx.m_num++];
1023  *slot = obj;
1024  return slot;
1025}
1026 
1027 
1028/* Pop and return the last element off the end of the vector.  */
1029 
1030template<typename T, typename A>
1031inline T &
1032vec<T, A, vl_embed>::pop (void)
1033{
1034  gcc_checking_assert (length () > 0)((void)(!(length () > 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1034, __FUNCTION__), 0 : 0));
1035  return address ()[--m_vecpfx.m_num];
1036}
1037 
1038 
1039/* Set the length of the vector to SIZE.  The new length must be less
1040   than or equal to the current length.  This is an O(1) operation.  */
1041 
1042template<typename T, typename A>
1043inline void
1044vec<T, A, vl_embed>::truncate (unsigned size)
1045{
1046  gcc_checking_assert (length () >= size)((void)(!(length () >= size) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1046, __FUNCTION__), 0 : 0));
1047  m_vecpfx.m_num = size;
1048}
1049 
1050 
1051/* Insert an element, OBJ, at the IXth position of this vector.  There
1052   must be sufficient space.  */
1053 
1054template<typename T, typename A>
1055inline void
1056vec<T, A, vl_embed>::quick_insert (unsigned ix, const T &obj)
1057{
1058  gcc_checking_assert (length () < allocated ())((void)(!(length () < allocated ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1058, __FUNCTION__), 0 : 0));
1059  gcc_checking_assert (ix <= length ())((void)(!(ix <= length ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1059, __FUNCTION__), 0 : 0));
1060  T *slot = &address ()[ix];
1061  memmove (slot + 1, slot, (m_vecpfx.m_num++ - ix) * sizeof (T));
1062  *slot = obj;
1063}
1064 
1065 
1066/* Remove an element from the IXth position of this vector.  Ordering of
1067   remaining elements is preserved.  This is an O(N) operation due to
1068   memmove.  */
1069 
1070template<typename T, typename A>
1071inline void
1072vec<T, A, vl_embed>::ordered_remove (unsigned ix)
1073{
1074  gcc_checking_assert (ix < length ())((void)(!(ix < length ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1074, __FUNCTION__), 0 : 0));
1075  T *slot = &address ()[ix];
1076  memmove (slot, slot + 1, (--m_vecpfx.m_num - ix) * sizeof (T));
1077}
1078 
1079 
1080/* Remove elements in [START, END) from VEC for which COND holds.  Ordering of
1081   remaining elements is preserved.  This is an O(N) operation.  */
1082 
1083#define VEC_ORDERED_REMOVE_IF_FROM_TO(vec, read_index, write_index,	\{ ((void)(!((end) <= (vec).length ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1084, __FUNCTION__), 0 : 0)); for (read_index = write_index
 = (start); read_index < (end); ++read_index) { elem_ptr =
 &(vec)[read_index]; bool remove_p = (cond); if (remove_p
) continue; if (read_index != write_index) (vec)[write_index]
 = (vec)[read_index]; write_index++; } if (read_index - write_index
 > 0) (vec).block_remove (write_index, read_index - write_index
); }
1084				      elem_ptr, start, end, cond){ ((void)(!((end) <= (vec).length ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1084, __FUNCTION__), 0 : 0)); for (read_index = write_index
 = (start); read_index < (end); ++read_index) { elem_ptr =
 &(vec)[read_index]; bool remove_p = (cond); if (remove_p
) continue; if (read_index != write_index) (vec)[write_index]
 = (vec)[read_index]; write_index++; } if (read_index - write_index
 > 0) (vec).block_remove (write_index, read_index - write_index
); }	\
1085  {									\
1086    gcc_assert ((end) <= (vec).length ())((void)(!((end) <= (vec).length ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1086, __FUNCTION__), 0 : 0));				\
1087    for (read_index = write_index = (start); read_index < (end);	\
1088	 ++read_index)							\
1089      {									\
1090	elem_ptr = &(vec)[read_index];					\
1091	bool remove_p = (cond);						\
1092	if (remove_p)							\
1093	  continue;							\
1094									\
1095	if (read_index != write_index)					\
1096	  (vec)[write_index] = (vec)[read_index];			\
1097									\
1098	write_index++;							\
1099      }									\
1100									\
1101    if (read_index - write_index > 0)					\
1102      (vec).block_remove (write_index, read_index - write_index);	\
1103  }
1104 
1105 
1106/* Remove elements from VEC for which COND holds.  Ordering of remaining
1107   elements is preserved.  This is an O(N) operation.  */
1108 
1109#define VEC_ORDERED_REMOVE_IF(vec, read_index, write_index, elem_ptr,	\{ ((void)(!(((vec).length ()) <= ((vec)).length ()) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1110, __FUNCTION__), 0 : 0)); for (read_index = write_index
 = (0); read_index < ((vec).length ()); ++read_index) { elem_ptr
 = &((vec))[read_index]; bool remove_p = ((cond)); if (remove_p
) continue; if (read_index != write_index) ((vec))[write_index
] = ((vec))[read_index]; write_index++; } if (read_index - write_index
 > 0) ((vec)).block_remove (write_index, read_index - write_index
); }
1110			      cond){ ((void)(!(((vec).length ()) <= ((vec)).length ()) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1110, __FUNCTION__), 0 : 0)); for (read_index = write_index
 = (0); read_index < ((vec).length ()); ++read_index) { elem_ptr
 = &((vec))[read_index]; bool remove_p = ((cond)); if (remove_p
) continue; if (read_index != write_index) ((vec))[write_index
] = ((vec))[read_index]; write_index++; } if (read_index - write_index
 > 0) ((vec)).block_remove (write_index, read_index - write_index
); }					\
1111  VEC_ORDERED_REMOVE_IF_FROM_TO ((vec), read_index, write_index,	\{ ((void)(!(((vec).length ()) <= ((vec)).length ()) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1112, __FUNCTION__), 0 : 0)); for (read_index = write_index
 = (0); read_index < ((vec).length ()); ++read_index) { elem_ptr
 = &((vec))[read_index]; bool remove_p = ((cond)); if (remove_p
) continue; if (read_index != write_index) ((vec))[write_index
] = ((vec))[read_index]; write_index++; } if (read_index - write_index
 > 0) ((vec)).block_remove (write_index, read_index - write_index
); }
1112				 elem_ptr, 0, (vec).length (), (cond)){ ((void)(!(((vec).length ()) <= ((vec)).length ()) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1112, __FUNCTION__), 0 : 0)); for (read_index = write_index
 = (0); read_index < ((vec).length ()); ++read_index) { elem_ptr
 = &((vec))[read_index]; bool remove_p = ((cond)); if (remove_p
) continue; if (read_index != write_index) ((vec))[write_index
] = ((vec))[read_index]; write_index++; } if (read_index - write_index
 > 0) ((vec)).block_remove (write_index, read_index - write_index
); }
1113 
1114/* Remove an element from the IXth position of this vector.  Ordering of
1115   remaining elements is destroyed.  This is an O(1) operation.  */
1116 
1117template<typename T, typename A>
1118inline void
1119vec<T, A, vl_embed>::unordered_remove (unsigned ix)
1120{
1121  gcc_checking_assert (ix < length ())((void)(!(ix < length ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1121, __FUNCTION__), 0 : 0));
1122  T *p = address ();
1123  p[ix] = p[--m_vecpfx.m_num];
1124}
1125 
1126 
1127/* Remove LEN elements starting at the IXth.  Ordering is retained.
1128   This is an O(N) operation due to memmove.  */
1129 
1130template<typename T, typename A>
1131inline void
1132vec<T, A, vl_embed>::block_remove (unsigned ix, unsigned len)
1133{
1134  gcc_checking_assert (ix + len <= length ())((void)(!(ix + len <= length ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1134, __FUNCTION__), 0 : 0));
1135  T *slot = &address ()[ix];
1136  m_vecpfx.m_num -= len;
1137  memmove (slot, slot + len, (m_vecpfx.m_num - ix) * sizeof (T));
1138}
1139 
1140 
1141/* Sort the contents of this vector with qsort.  CMP is the comparison
1142   function to pass to qsort.  */
1143 
1144template<typename T, typename A>
1145inline void
1146vec<T, A, vl_embed>::qsort (int (*cmp) (const void *, const void *))qsort (int (*cmp) (const void *, const void *))
1147{
1148  if (length () > 1)
1149    gcc_qsort (address (), length (), sizeof (T), cmp);
1150}
1151 
1152/* Sort the contents of this vector with qsort.  CMP is the comparison
1153   function to pass to qsort.  */
1154 
1155template<typename T, typename A>
1156inline void
1157vec<T, A, vl_embed>::sort (int (*cmp) (const void *, const void *, void *),
1158			   void *data)
1159{
1160  if (length () > 1)
1161    gcc_sort_r (address (), length (), sizeof (T), cmp, data);
1162}
1163 
1164/* Sort the contents of this vector with gcc_stablesort_r.  CMP is the
1165   comparison function to pass to qsort.  */
1166 
1167template<typename T, typename A>
1168inline void
1169vec<T, A, vl_embed>::stablesort (int (*cmp) (const void *, const void *,
1170					     void *), void *data)
1171{
1172  if (length () > 1)
1173    gcc_stablesort_r (address (), length (), sizeof (T), cmp, data);
1174}
1175 
1176/* Search the contents of the sorted vector with a binary search.
1177   CMP is the comparison function to pass to bsearch.  */
1178 
1179template<typename T, typename A>
1180inline T *
1181vec<T, A, vl_embed>::bsearch (const void *key,
1182			      int (*compar) (const void *, const void *))
1183{
1184  const void *base = this->address ();
1185  size_t nmemb = this->length ();
1186  size_t size = sizeof (T);
1187  /* The following is a copy of glibc stdlib-bsearch.h.  */
1188  size_t l, u, idx;
1189  const void *p;
1190  int comparison;
1191 
1192  l = 0;
1193  u = nmemb;
1194  while (l < u)
1195    {
1196      idx = (l + u) / 2;
1197      p = (const void *) (((const char *) base) + (idx * size));
1198      comparison = (*compar) (key, p);
1199      if (comparison < 0)
1200	u = idx;
1201      else if (comparison > 0)
1202	l = idx + 1;
1203      else
1204	return (T *)const_cast<void *>(p);
1205    }
1206 
1207  return NULLnullptr;
1208}
1209 
1210/* Search the contents of the sorted vector with a binary search.
1211   CMP is the comparison function to pass to bsearch.  */
1212 
1213template<typename T, typename A>
1214inline T *
1215vec<T, A, vl_embed>::bsearch (const void *key,
1216			      int (*compar) (const void *, const void *,
1217					     void *), void *data)
1218{
1219  const void *base = this->address ();
1220  size_t nmemb = this->length ();
1221  size_t size = sizeof (T);
1222  /* The following is a copy of glibc stdlib-bsearch.h.  */
1223  size_t l, u, idx;
1224  const void *p;
1225  int comparison;
1226 
1227  l = 0;
1228  u = nmemb;
1229  while (l < u)
1230    {
1231      idx = (l + u) / 2;
1232      p = (const void *) (((const char *) base) + (idx * size));
1233      comparison = (*compar) (key, p, data);
1234      if (comparison < 0)
1235	u = idx;
1236      else if (comparison > 0)
1237	l = idx + 1;
1238      else
1239	return (T *)const_cast<void *>(p);
1240    }
1241 
1242  return NULLnullptr;
1243}
1244 
1245/* Return true if SEARCH is an element of V.  Note that this is O(N) in the
1246   size of the vector and so should be used with care.  */
1247 
1248template<typename T, typename A>
1249inline bool
1250vec<T, A, vl_embed>::contains (const T &search) const
1251{
1252  unsigned int len = length ();
1253  const T *p = address ();
1254  for (unsigned int i = 0; i < len; i++)
1255    {
1256      const T *slot = &p[i];
1257      if (*slot == search)
1258	return true;
1259    }
1260 
1261  return false;
1262}
1263 
1264/* Find and return the first position in which OBJ could be inserted
1265   without changing the ordering of this vector.  LESSTHAN is a
1266   function that returns true if the first argument is strictly less
1267   than the second.  */
1268 
1269template<typename T, typename A>
1270unsigned
1271vec<T, A, vl_embed>::lower_bound (const T &obj,
1272				  bool (*lessthan)(const T &, const T &))
1273  const
1274{
1275  unsigned int len = length ();
1276  unsigned int half, middle;
1277  unsigned int first = 0;
1278  while (len > 0)
1279    {
1280      half = len / 2;
1281      middle = first;
1282      middle += half;
1283      const T &middle_elem = address ()[middle];
1284      if (lessthan (middle_elem, obj))
1285	{
1286	  first = middle;
1287	  ++first;
1288	  len = len - half - 1;
1289	}
1290      else
1291	len = half;
1292    }
1293  return first;
1294}
1295 
1296 
1297/* Return the number of bytes needed to embed an instance of an
1298   embeddable vec inside another data structure.
1299 
1300   Use these methods to determine the required size and initialization
1301   of a vector V of type T embedded within another structure (as the
1302   final member):
1303 
1304   size_t vec<T, A, vl_embed>::embedded_size (unsigned alloc);
1305   void v->embedded_init (unsigned alloc, unsigned num);
1306 
1307   These allow the caller to perform the memory allocation.  */
1308 
1309template<typename T, typename A>
1310inline size_t
1311vec<T, A, vl_embed>::embedded_size (unsigned alloc)
1312{
1313  struct alignas (T) U { char data[sizeof (T)]; };
1314  typedef vec<U, A, vl_embed> vec_embedded;
1315  typedef typename std::conditional<std::is_standard_layout<T>::value,
1316				    vec, vec_embedded>::type vec_stdlayout;
1317  static_assert (sizeof (vec_stdlayout) == sizeof (vec), "");
1318  static_assert (alignof (vec_stdlayout) == alignof (vec), "");
1319  return sizeof (vec_stdlayout) + alloc * sizeof (T);
1320}
1321 
1322 
1323/* Initialize the vector to contain room for ALLOC elements and
1324   NUM active elements.  */
1325 
1326template<typename T, typename A>
1327inline void
1328vec<T, A, vl_embed>::embedded_init (unsigned alloc, unsigned num, unsigned aut)
1329{
1330  m_vecpfx.m_alloc = alloc;
1331  m_vecpfx.m_using_auto_storage = aut;
1332  m_vecpfx.m_num = num;
1333}
1334 
1335 
1336/* Grow the vector to a specific length.  LEN must be as long or longer than
1337   the current length.  The new elements are uninitialized.  */
1338 
1339template<typename T, typename A>
1340inline void
1341vec<T, A, vl_embed>::quick_grow (unsigned len)
1342{
1343  gcc_checking_assert (length () <= len && len <= m_vecpfx.m_alloc)((void)(!(length () <= len && len <= m_vecpfx.m_alloc
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1343, __FUNCTION__), 0 : 0));
1344  m_vecpfx.m_num = len;
1345}