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

Bug Summary

File:	build/gcc/tree-sra.cc
Warning:	line 2186, column 3 The left operand of '==' is a garbage value
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 tree-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-ToyIVd.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc
1/* Scalar Replacement of Aggregates (SRA) converts some structure
 references into scalar references, exposing them to the scalar
 optimizers.
 Copyright (C) 2008-2023 Free Software Foundation, Inc.
 Contributed by Martin Jambor <mjambor@suse.cz>

7This file is part of GCC.

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

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

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

23/* This file implements Scalar Reduction of Aggregates (SRA).  SRA is run
 twice, once in the early stages of compilation (early SRA) and once in the
 late stages (late SRA).  The aim of both is to turn references to scalar
 parts of aggregates into uses of independent scalar variables.

 The two passes are nearly identical, the only difference is that early SRA
 does not scalarize unions which are used as the result in a GIMPLE_RETURN
 statement because together with inlining this can lead to weird type
 conversions.

 Both passes operate in four stages:

 1. The declarations that have properties which make them candidates for
    scalarization are identified in function find_var_candidates().  The
    candidates are stored in candidate_bitmap.

 2. The function body is scanned.  In the process, declarations which are
    used in a manner that prevent their scalarization are removed from the
    candidate bitmap.  More importantly, for every access into an aggregate,
    an access structure (struct access) is created by create_access() and
    stored in a vector associated with the aggregate.  Among other
    information, the aggregate declaration, the offset and size of the access
    and its type are stored in the structure.

    On a related note, assign_link structures are created for every assign
    statement between candidate aggregates and attached to the related
    accesses.

 3. The vectors of accesses are analyzed.  They are first sorted according to
    their offset and size and then scanned for partially overlapping accesses
    (i.e. those which overlap but one is not entirely within another).  Such
    an access disqualifies the whole aggregate from being scalarized.

    If there is no such inhibiting overlap, a representative access structure
    is chosen for every unique combination of offset and size.  Afterwards,
    the pass builds a set of trees from these structures, in which children
    of an access are within their parent (in terms of offset and size).

    Then accesses  are propagated  whenever possible (i.e.  in cases  when it
    does not create a partially overlapping access) across assign_links from
    the right hand side to the left hand side.

    Then the set of trees for each declaration is traversed again and those
    accesses which should be replaced by a scalar are identified.

 4. The function is traversed again, and for every reference into an
    aggregate that has some component which is about to be scalarized,
    statements are amended and new statements are created as necessary.
    Finally, if a parameter got scalarized, the scalar replacements are
    initialized with values from respective parameter aggregates.  */

74#include "config.h"
75#include "system.h"
76#include "coretypes.h"
77#include "backend.h"
78#include "target.h"
79#include "rtl.h"
80#include "tree.h"
81#include "gimple.h"
82#include "predict.h"
83#include "alloc-pool.h"
84#include "tree-pass.h"
85#include "ssa.h"
86#include "cgraph.h"
87#include "gimple-pretty-print.h"
88#include "alias.h"
89#include "fold-const.h"
90#include "tree-eh.h"
91#include "stor-layout.h"
92#include "gimplify.h"
93#include "gimple-iterator.h"
94#include "gimplify-me.h"
95#include "gimple-walk.h"
96#include "tree-cfg.h"
97#include "tree-dfa.h"
98#include "tree-ssa.h"
99#include "dbgcnt.h"
100#include "builtins.h"
101#include "tree-sra.h"
102#include "opts.h"

104/* Enumeration of all aggregate reductions we can do.  */
105enum sra_mode { SRA_MODE_EARLY_IPA,   /* early call regularization */
SRA_MODE_EARLY_INTRA, /* early intraprocedural SRA */
SRA_MODE_INTRA };     /* late intraprocedural SRA */

109/* Global variable describing which aggregate reduction we are performing at
 the moment.  */
111static enum sra_mode sra_mode;

113struct assign_link;

115/* ACCESS represents each access to an aggregate variable (as a whole or a
 part).  It can also represent a group of accesses that refer to exactly the
 same fragment of an aggregate (i.e. those that have exactly the same offset
 and size).  Such representatives for a single aggregate, once determined,
 are linked in a linked list and have the group fields set.

 Moreover, when doing intraprocedural SRA, a tree is built from those
 representatives (by the means of first_child and next_sibling pointers), in
 which all items in a subtree are "within" the root, i.e. their offset is
 greater or equal to offset of the root and offset+size is smaller or equal
 to offset+size of the root.  Children of an access are sorted by offset.

 Note that accesses to parts of vector and complex number types always
 represented by an access to the whole complex number or a vector.  It is a
 duty of the modifying functions to replace them appropriately.  */

131struct access
132{
/* Values returned by  `get_ref_base_and_extent' for each component reference
   If EXPR isn't a component reference  just set `BASE = EXPR', `OFFSET = 0',
   `SIZE = TREE_SIZE (TREE_TYPE (expr))'.  */
HOST_WIDE_INTlong offset;
HOST_WIDE_INTlong size;
tree base;

/* Expression.  It is context dependent so do not use it to create new
   expressions to access the original aggregate.  See PR 42154 for a
   testcase.  */
tree expr;
/* Type.  */
tree type;

/* The statement this access belongs to.  */
gimple *stmt;

/* Next group representative for this aggregate. */
struct access *next_grp;

/* Pointer to the group representative.  Pointer to itself if the struct is
   the representative.  */
struct access *group_representative;

/* After access tree has been constructed, this points to the parent of the
   current access, if there is one.  NULL for roots.  */
struct access *parent;

/* If this access has any children (in terms of the definition above), this
   points to the first one.  */
struct access *first_child;

/* In intraprocedural SRA, pointer to the next sibling in the access tree as
   described above.  */
struct access *next_sibling;

/* Pointers to the first and last element in the linked list of assign
   links for propagation from LHS to RHS.  */
struct assign_link *first_rhs_link, *last_rhs_link;

/* Pointers to the first and last element in the linked list of assign
   links for propagation from LHS to RHS.  */
struct assign_link *first_lhs_link, *last_lhs_link;

/* Pointer to the next access in the work queues.  */
struct access *next_rhs_queued, *next_lhs_queued;

/* Replacement variable for this access "region."  Never to be accessed
   directly, always only by the means of get_access_replacement() and only
   when grp_to_be_replaced flag is set.  */
tree replacement_decl;

/* Is this access made in reverse storage order? */
unsigned reverse : 1;

/* Is this particular access write access? */
unsigned write : 1;

/* Is this access currently in the rhs work queue?  */
unsigned grp_rhs_queued : 1;

/* Is this access currently in the lhs work queue?  */
unsigned grp_lhs_queued : 1;

/* Does this group contain a write access?  This flag is propagated down the
   access tree.  */
unsigned grp_write : 1;

/* Does this group contain a read access?  This flag is propagated down the
   access tree.  */
unsigned grp_read : 1;

/* Does this group contain a read access that comes from an assignment
   statement?  This flag is propagated down the access tree.  */
unsigned grp_assignment_read : 1;

/* Does this group contain a write access that comes from an assignment
   statement?  This flag is propagated down the access tree.  */
unsigned grp_assignment_write : 1;

/* Does this group contain a read access through a scalar type?  This flag is
   not propagated in the access tree in any direction.  */
unsigned grp_scalar_read : 1;

/* Does this group contain a write access through a scalar type?  This flag
   is not propagated in the access tree in any direction.  */
unsigned grp_scalar_write : 1;

/* In a root of an access tree, true means that the entire tree should be
   totally scalarized - that all scalar leafs should be scalarized and
   non-root grp_total_scalarization accesses should be honored.  Otherwise,
   non-root accesses with grp_total_scalarization should never get scalar
   replacements.  */
unsigned grp_total_scalarization : 1;

/* Other passes of the analysis use this bit to make function
   analyze_access_subtree create scalar replacements for this group if
   possible.  */
unsigned grp_hint : 1;

/* Is the subtree rooted in this access fully covered by scalar
   replacements?  */
unsigned grp_covered : 1;

/* If set to true, this access and all below it in an access tree must not be
   scalarized.  */
unsigned grp_unscalarizable_region : 1;

/* Whether data have been written to parts of the aggregate covered by this
   access which is not to be scalarized.  This flag is propagated up in the
   access tree.  */
unsigned grp_unscalarized_data : 1;

/* Set if all accesses in the group consist of the same chain of
   COMPONENT_REFs and ARRAY_REFs.  */
unsigned grp_same_access_path : 1;

/* Does this access and/or group contain a write access through a
   BIT_FIELD_REF?  */
unsigned grp_partial_lhs : 1;

/* Set when a scalar replacement should be created for this variable.  */
unsigned grp_to_be_replaced : 1;

/* Set when we want a replacement for the sole purpose of having it in
   generated debug statements.  */
unsigned grp_to_be_debug_replaced : 1;

/* Should TREE_NO_WARNING of a replacement be set?  */
unsigned grp_no_warning : 1;

/* Result of propagation accross link from LHS to RHS.  */
unsigned grp_result_of_prop_from_lhs : 1;
266};

268typedef struct access *access_p;


271/* Alloc pool for allocating access structures.  */
272static object_allocator<struct access> access_pool ("SRA accesses");

274/* A structure linking lhs and rhs accesses from an aggregate assignment.  They
 are used to propagate subaccesses from rhs to lhs and vice versa as long as
 they don't conflict with what is already there.  In the RHS->LHS direction,
 we also propagate grp_write flag to lazily mark that the access contains any
 meaningful data.  */
279struct assign_link
280{
struct access *lacc, *racc;
struct assign_link *next_rhs, *next_lhs;
283};

285/* Alloc pool for allocating assign link structures.  */
286static object_allocator<assign_link> assign_link_pool ("SRA links");

288/* Base (tree) -> Vector (vec<access_p> *) map.  */
289static hash_map<tree, auto_vec<access_p> > *base_access_vec;

291/* Hash to limit creation of artificial accesses */
292static hash_map<tree, unsigned> *propagation_budget;

294/* Candidate hash table helpers.  */

296struct uid_decl_hasher : nofree_ptr_hash <tree_node>
297{
static inline hashval_t hash (const tree_node *);
static inline bool equal (const tree_node *, const tree_node *);
300};

302/* Hash a tree in a uid_decl_map.  */

304inline hashval_t
305uid_decl_hasher::hash (const tree_node *item)
306{
return item->decl_minimal.uid;
308}

310/* Return true if the DECL_UID in both trees are equal.  */

312inline bool
313uid_decl_hasher::equal (const tree_node *a, const tree_node *b)
314{
return (a->decl_minimal.uid == b->decl_minimal.uid);
316}

318/* Set of candidates.  */
319static bitmap candidate_bitmap;
320static hash_table<uid_decl_hasher> *candidates;

322/* For a candidate UID return the candidates decl.  */

324static inline tree
325candidate (unsigned uid)
326{
tree_node t;
t.decl_minimal.uid = uid;
return candidates->find_with_hash (&t, static_cast <hashval_t> (uid));
330}

332/* Bitmap of candidates which we should try to entirely scalarize away and
 those which cannot be (because they are and need be used as a whole).  */
334static bitmap should_scalarize_away_bitmap, cannot_scalarize_away_bitmap;

336/* Bitmap of candidates in the constant pool, which cannot be scalarized
 because this would produce non-constant expressions (e.g. Ada).  */
338static bitmap disqualified_constants;

340/* Obstack for creation of fancy names.  */
341static struct obstack name_obstack;

343/* Head of a linked list of accesses that need to have its subaccesses
 propagated to their assignment counterparts. */
345static struct access *rhs_work_queue_head, *lhs_work_queue_head;

347/* Dump contents of ACCESS to file F in a human friendly way.  If GRP is true,
 representative fields are dumped, otherwise those which only describe the
 individual access are.  */

351static struct
352{
/* Number of processed aggregates is readily available in
   analyze_all_variable_accesses and so is not stored here.  */

/* Number of created scalar replacements.  */
int replacements;

/* Number of times sra_modify_expr or sra_modify_assign themselves changed an
   expression.  */
int exprs;

/* Number of statements created by generate_subtree_copies.  */
int subtree_copies;

/* Number of statements created by load_assign_lhs_subreplacements.  */
int subreplacements;

/* Number of times sra_modify_assign has deleted a statement.  */
int deleted;

/* Number of times sra_modify_assign has to deal with subaccesses of LHS and
   RHS reparately due to type conversions or nonexistent matching
   references.  */
int separate_lhs_rhs_handling;

/* Number of parameters that were removed because they were unused.  */
int deleted_unused_parameters;

/* Number of scalars passed as parameters by reference that have been
   converted to be passed by value.  */
int scalar_by_ref_to_by_val;

/* Number of aggregate parameters that were replaced by one or more of their
   components.  */
int aggregate_params_reduced;

/* Numbber of components created when splitting aggregate parameters.  */
int param_reductions_created;

/* Number of deferred_init calls that are modified.  */
int deferred_init;

/* Number of deferred_init calls that are created by
   generate_subtree_deferred_init.  */
int subtree_deferred_init;
397} sra_stats;

399static void
400dump_access (FILE *f, struct access *access, bool grp)
401{
fprintf (f, "access { ");
fprintf (f, "base = (%d)'", DECL_UID (access->base)((contains_struct_check ((access->base), (TS_DECL_MINIMAL)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 403, __FUNCTION__))->decl_minimal.uid));
print_generic_expr (f, access->base);
fprintf (f, "', offset = " HOST_WIDE_INT_PRINT_DEC"%" "l" "d", access->offset);
fprintf (f, ", size = " HOST_WIDE_INT_PRINT_DEC"%" "l" "d", access->size);
fprintf (f, ", expr = ");
print_generic_expr (f, access->expr);
fprintf (f, ", type = ");
print_generic_expr (f, access->type);
fprintf (f, ", reverse = %d", access->reverse);
if (grp)
  fprintf (f, ", grp_read = %d, grp_write = %d, grp_assignment_read = %d, "
    "grp_assignment_write = %d, grp_scalar_read = %d, "
    "grp_scalar_write = %d, grp_total_scalarization = %d, "
    "grp_hint = %d, grp_covered = %d, "
    "grp_unscalarizable_region = %d, grp_unscalarized_data = %d, "
    "grp_same_access_path = %d, grp_partial_lhs = %d, "
    "grp_to_be_replaced = %d, grp_to_be_debug_replaced = %d}\n",
    access->grp_read, access->grp_write, access->grp_assignment_read,
    access->grp_assignment_write, access->grp_scalar_read,
    access->grp_scalar_write, access->grp_total_scalarization,
    access->grp_hint, access->grp_covered,
    access->grp_unscalarizable_region, access->grp_unscalarized_data,
    access->grp_same_access_path, access->grp_partial_lhs,
    access->grp_to_be_replaced, access->grp_to_be_debug_replaced);
else
  fprintf (f, ", write = %d, grp_total_scalarization = %d, "
    "grp_partial_lhs = %d}\n",
    access->write, access->grp_total_scalarization,
    access->grp_partial_lhs);
432}

434/* Dump a subtree rooted in ACCESS to file F, indent by LEVEL.  */

436static void
437dump_access_tree_1 (FILE *f, struct access *access, int level)
438{
do
  {
    int i;

    for (i = 0; i < level; i++)
fputs ("* ", f);

    dump_access (f, access, true);

    if (access->first_child)
dump_access_tree_1 (f, access->first_child, level + 1);

    access = access->next_sibling;
  }
while (access);
454}

456/* Dump all access trees for a variable, given the pointer to the first root in
 ACCESS.  */

459static void
460dump_access_tree (FILE *f, struct access *access)
461{
for (; access; access = access->next_grp)
  dump_access_tree_1 (f, access, 0);
464}

466/* Return true iff ACC is non-NULL and has subaccesses.  */

468static inline bool
469access_has_children_p (struct access *acc)
470{
return acc && acc->first_child;
472}

474/* Return true iff ACC is (partly) covered by at least one replacement.  */

476static bool
477access_has_replacements_p (struct access *acc)
478{
struct access *child;
if (acc->grp_to_be_replaced)
  return true;
for (child = acc->first_child; child; child = child->next_sibling)
  if (access_has_replacements_p (child))
    return true;
return false;
486}

488/* Return a vector of pointers to accesses for the variable given in BASE or
 NULL if there is none.  */

491static vec<access_p> *
492get_base_access_vector (tree base)
493{
return base_access_vec->get (base);
495}

497/* Find an access with required OFFSET and SIZE in a subtree of accesses rooted
 in ACCESS.  Return NULL if it cannot be found.  */

500static struct access *
501find_access_in_subtree (struct access *access, HOST_WIDE_INTlong offset,
	HOST_WIDE_INTlong size)
503{
while (access && (access->offset != offset || access->size != size))
  {
    struct access *child = access->first_child;

    while (child && (child->offset + child->size <= offset))
child = child->next_sibling;
    access = child;
  }

/* Total scalarization does not replace single field structures with their
   single field but rather creates an access for them underneath.  Look for
   it.  */
if (access)
  while (access->first_child
  && access->first_child->offset == offset
  && access->first_child->size == size)
    access = access->first_child;

return access;
523}

525/* Return the first group representative for DECL or NULL if none exists.  */

527static struct access *
528get_first_repr_for_decl (tree base)
529{
vec<access_p> *access_vec;

access_vec = get_base_access_vector (base);
if (!access_vec)
  return NULLnullptr;

return (*access_vec)[0];
537}

539/* Find an access representative for the variable BASE and given OFFSET and
 SIZE.  Requires that access trees have already been built.  Return NULL if
 it cannot be found.  */

543static struct access *
544get_var_base_offset_size_access (tree base, HOST_WIDE_INTlong offset,
		 HOST_WIDE_INTlong size)
546{
struct access *access;

access = get_first_repr_for_decl (base);
while (access && (access->offset + access->size <= offset))
  access = access->next_grp;
if (!access)
  return NULLnullptr;

return find_access_in_subtree (access, offset, size);
556}

558/* Add LINK to the linked list of assign links of RACC.  */

560static void
561add_link_to_rhs (struct access *racc, struct assign_link *link)
562{
gcc_assert (link->racc == racc)((void)(!(link->racc == racc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 563, __FUNCTION__), 0 : 0));

if (!racc->first_rhs_link)
  {
    gcc_assert (!racc->last_rhs_link)((void)(!(!racc->last_rhs_link) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 567, __FUNCTION__), 0 : 0));
    racc->first_rhs_link = link;
  }
else
  racc->last_rhs_link->next_rhs = link;

racc->last_rhs_link = link;
link->next_rhs = NULLnullptr;
575}

577/* Add LINK to the linked list of lhs assign links of LACC.  */

579static void
580add_link_to_lhs (struct access *lacc, struct assign_link *link)
581{
gcc_assert (link->lacc == lacc)((void)(!(link->lacc == lacc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 582, __FUNCTION__), 0 : 0));

if (!lacc->first_lhs_link)
  {
    gcc_assert (!lacc->last_lhs_link)((void)(!(!lacc->last_lhs_link) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 586, __FUNCTION__), 0 : 0));
    lacc->first_lhs_link = link;
  }
else
  lacc->last_lhs_link->next_lhs = link;

lacc->last_lhs_link = link;
link->next_lhs = NULLnullptr;
594}

596/* Move all link structures in their linked list in OLD_ACC to the linked list
 in NEW_ACC.  */
598static void
599relink_to_new_repr (struct access *new_acc, struct access *old_acc)
600{
if (old_acc->first_rhs_link)
  {

    if (new_acc->first_rhs_link)
{
 gcc_assert (!new_acc->last_rhs_link->next_rhs)((void)(!(!new_acc->last_rhs_link->next_rhs) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 606, __FUNCTION__), 0 : 0));
 gcc_assert (!old_acc->last_rhs_link((void)(!(!old_acc->last_rhs_link || !old_acc->last_rhs_link
->next_rhs) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 608, __FUNCTION__), 0 : 0))
      || !old_acc->last_rhs_link->next_rhs)((void)(!(!old_acc->last_rhs_link || !old_acc->last_rhs_link
->next_rhs) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 608, __FUNCTION__), 0 : 0));

 new_acc->last_rhs_link->next_rhs = old_acc->first_rhs_link;
 new_acc->last_rhs_link = old_acc->last_rhs_link;
}
    else
{
 gcc_assert (!new_acc->last_rhs_link)((void)(!(!new_acc->last_rhs_link) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 615, __FUNCTION__), 0 : 0));

 new_acc->first_rhs_link = old_acc->first_rhs_link;
 new_acc->last_rhs_link = old_acc->last_rhs_link;
}
    old_acc->first_rhs_link = old_acc->last_rhs_link = NULLnullptr;
  }
else
  gcc_assert (!old_acc->last_rhs_link)((void)(!(!old_acc->last_rhs_link) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 623, __FUNCTION__), 0 : 0));

if (old_acc->first_lhs_link)
  {

    if (new_acc->first_lhs_link)
{
 gcc_assert (!new_acc->last_lhs_link->next_lhs)((void)(!(!new_acc->last_lhs_link->next_lhs) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 630, __FUNCTION__), 0 : 0));
 gcc_assert (!old_acc->last_lhs_link((void)(!(!old_acc->last_lhs_link || !old_acc->last_lhs_link
->next_lhs) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 632, __FUNCTION__), 0 : 0))
      || !old_acc->last_lhs_link->next_lhs)((void)(!(!old_acc->last_lhs_link || !old_acc->last_lhs_link
->next_lhs) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 632, __FUNCTION__), 0 : 0));

 new_acc->last_lhs_link->next_lhs = old_acc->first_lhs_link;
 new_acc->last_lhs_link = old_acc->last_lhs_link;
}
    else
{
 gcc_assert (!new_acc->last_lhs_link)((void)(!(!new_acc->last_lhs_link) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 639, __FUNCTION__), 0 : 0));

 new_acc->first_lhs_link = old_acc->first_lhs_link;
 new_acc->last_lhs_link = old_acc->last_lhs_link;
}
    old_acc->first_lhs_link = old_acc->last_lhs_link = NULLnullptr;
  }
else
  gcc_assert (!old_acc->last_lhs_link)((void)(!(!old_acc->last_lhs_link) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 647, __FUNCTION__), 0 : 0));

649}

651/* Add ACCESS to the work to queue for propagation of subaccesses from RHS to
 LHS (which is actually a stack).  */

654static void
655add_access_to_rhs_work_queue (struct access *access)
656{
if (access->first_rhs_link && !access->grp_rhs_queued)
  {
    gcc_assert (!access->next_rhs_queued)((void)(!(!access->next_rhs_queued) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 659, __FUNCTION__), 0 : 0));
    access->next_rhs_queued = rhs_work_queue_head;
    access->grp_rhs_queued = 1;
    rhs_work_queue_head = access;
  }
664}

666/* Add ACCESS to the work to queue for propagation of subaccesses from LHS to
 RHS (which is actually a stack).  */

669static void
670add_access_to_lhs_work_queue (struct access *access)
671{
if (access->first_lhs_link && !access->grp_lhs_queued)
  {
    gcc_assert (!access->next_lhs_queued)((void)(!(!access->next_lhs_queued) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 674, __FUNCTION__), 0 : 0));
    access->next_lhs_queued = lhs_work_queue_head;
    access->grp_lhs_queued = 1;
    lhs_work_queue_head = access;
  }
679}

681/* Pop an access from the work queue for propagating from RHS to LHS, and
 return it, assuming there is one.  */

684static struct access *
685pop_access_from_rhs_work_queue (void)
686{
struct access *access = rhs_work_queue_head;

rhs_work_queue_head = access->next_rhs_queued;
access->next_rhs_queued = NULLnullptr;
access->grp_rhs_queued = 0;
return access;
693}

695/* Pop an access from the work queue for propagating from LHS to RHS, and
 return it, assuming there is one.  */

698static struct access *
699pop_access_from_lhs_work_queue (void)
700{
struct access *access = lhs_work_queue_head;

lhs_work_queue_head = access->next_lhs_queued;
access->next_lhs_queued = NULLnullptr;
access->grp_lhs_queued = 0;
return access;
707}

709/* Allocate necessary structures.  */

711static void
712sra_initialize (void)
713{
candidate_bitmap = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
candidates = new hash_table<uid_decl_hasher>
  (vec_safe_length (cfun(cfun + 0)->local_decls) / 2);
should_scalarize_away_bitmap = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
cannot_scalarize_away_bitmap = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
disqualified_constants = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
gcc_obstack_init (&name_obstack)_obstack_begin (((&name_obstack)), (memory_block_pool::block_size
), (0), (mempool_obstack_chunk_alloc), (mempool_obstack_chunk_free
));
base_access_vec = new hash_map<tree, auto_vec<access_p> >;
memset (&sra_stats, 0, sizeof (sra_stats));
723}

725/* Deallocate all general structures.  */

727static void
728sra_deinitialize (void)
729{
BITMAP_FREE (candidate_bitmap)((void) (bitmap_obstack_free ((bitmap) candidate_bitmap), (candidate_bitmap
) = (bitmap) nullptr));
delete candidates;
candidates = NULLnullptr;
BITMAP_FREE (should_scalarize_away_bitmap)((void) (bitmap_obstack_free ((bitmap) should_scalarize_away_bitmap
), (should_scalarize_away_bitmap) = (bitmap) nullptr));
BITMAP_FREE (cannot_scalarize_away_bitmap)((void) (bitmap_obstack_free ((bitmap) cannot_scalarize_away_bitmap
), (cannot_scalarize_away_bitmap) = (bitmap) nullptr));
BITMAP_FREE (disqualified_constants)((void) (bitmap_obstack_free ((bitmap) disqualified_constants
), (disqualified_constants) = (bitmap) nullptr));
access_pool.release ();
assign_link_pool.release ();
obstack_free (&name_obstack, NULL)__extension__ ({ struct obstack *__o = (&name_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); });

delete base_access_vec;
741}

743/* Return true if DECL is a VAR_DECL in the constant pool, false otherwise.  */

745static bool constant_decl_p (tree decl)
746{
return VAR_P (decl)(((enum tree_code) (decl)->base.code) == VAR_DECL) && DECL_IN_CONSTANT_POOL (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 747, __FUNCTION__, (VAR_DECL)))->decl_with_vis.in_constant_pool
);
748}

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

753static void
754disqualify_candidate (tree decl, const char *reason)
755{
if (bitmap_clear_bit (candidate_bitmap, DECL_UID (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 756, __FUNCTION__))->decl_minimal.uid)))
  candidates->remove_elt_with_hash (decl, DECL_UID (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 757, __FUNCTION__))->decl_minimal.uid));
if (constant_decl_p (decl))
  bitmap_set_bit (disqualified_constants, DECL_UID (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 759, __FUNCTION__))->decl_minimal.uid));

if (dump_file && (dump_flags & TDF_DETAILS))
  {
    fprintf (dump_file, "! Disqualifying ");
    print_generic_expr (dump_file, decl);
    fprintf (dump_file, " - %s\n", reason);
  }
767}

769/* Return true iff the type contains a field or an element which does not allow
 scalarization.  Use VISITED_TYPES to avoid re-checking already checked
 (sub-)types.  */

773static bool
774type_internals_preclude_sra_p_1 (tree type, const char **msg,
		 hash_set<tree> *visited_types)
776{
tree fld;
tree et;

if (visited_types->contains (type))
  return false;
visited_types->add (type);

switch (TREE_CODE (type)((enum tree_code) (type)->base.code))
  {
  case RECORD_TYPE:
  case UNION_TYPE:
  case QUAL_UNION_TYPE:
    for (fld = TYPE_FIELDS (type)((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 789, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values); fld; fld = DECL_CHAIN (fld)(((contains_struct_check (((contains_struct_check ((fld), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 789, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 789, __FUNCTION__))->common.chain)))
if (TREE_CODE (fld)((enum tree_code) (fld)->base.code) == FIELD_DECL)
 {
   if (TREE_CODE (fld)((enum tree_code) (fld)->base.code) == FUNCTION_DECL)
     continue;
   tree ft = TREE_TYPE (fld)((contains_struct_check ((fld), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 794, __FUNCTION__))->typed.type);

   if (TREE_THIS_VOLATILE (fld)((fld)->base.volatile_flag))
     {
*msg = "volatile structure field";
return true;
     }
   if (!DECL_FIELD_OFFSET (fld)((tree_check ((fld), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 801, __FUNCTION__, (FIELD_DECL)))->field_decl.offset))
     {
*msg = "no structure field offset";
return true;
     }
   if (!DECL_SIZE (fld)((contains_struct_check ((fld), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 806, __FUNCTION__))->decl_common.size))
     {
*msg = "zero structure field size";
       return true;
     }
   if (!tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld)((tree_check ((fld), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 811, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)))
     {
*msg = "structure field offset not fixed";
return true;
     }
   if (!tree_fits_uhwi_p (DECL_SIZE (fld)((contains_struct_check ((fld), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 816, __FUNCTION__))->decl_common.size)))
     {
       *msg = "structure field size not fixed";
return true;
     }
   if (!tree_fits_shwi_p (bit_position (fld)))
     {
       *msg = "structure field size too big";
return true;
     }
   if (AGGREGATE_TYPE_P (ft)(((enum tree_code) (ft)->base.code) == ARRAY_TYPE || (((enum
 tree_code) (ft)->base.code) == RECORD_TYPE || ((enum tree_code
) (ft)->base.code) == UNION_TYPE || ((enum tree_code) (ft)
->base.code) == QUAL_UNION_TYPE))
    && int_bit_position (fld) % BITS_PER_UNIT(8) != 0)
     {
*msg = "structure field is bit field";
       return true;
     }

   if (AGGREGATE_TYPE_P (ft)(((enum tree_code) (ft)->base.code) == ARRAY_TYPE || (((enum
 tree_code) (ft)->base.code) == RECORD_TYPE || ((enum tree_code
) (ft)->base.code) == UNION_TYPE || ((enum tree_code) (ft)
->base.code) == QUAL_UNION_TYPE))
     && type_internals_preclude_sra_p_1 (ft, msg, visited_types))
     return true;
 }

    return false;

  case ARRAY_TYPE:
    et = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 841, __FUNCTION__))->typed.type);

    if (TYPE_VOLATILE (et)((tree_class_check ((et), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 843, __FUNCTION__))->base.volatile_flag))
{
 *msg = "element type is volatile";
 return true;
}

    if (AGGREGATE_TYPE_P (et)(((enum tree_code) (et)->base.code) == ARRAY_TYPE || (((enum
 tree_code) (et)->base.code) == RECORD_TYPE || ((enum tree_code
) (et)->base.code) == UNION_TYPE || ((enum tree_code) (et)
->base.code) == QUAL_UNION_TYPE))
 && type_internals_preclude_sra_p_1 (et, msg, visited_types))
return true;

    return false;

  default:
    return false;
  }
858}

860/* Return true iff the type contains a field or an element which does not allow
 scalarization.  */

863bool
864type_internals_preclude_sra_p (tree type, const char **msg)
865{
hash_set<tree> visited_types;
return type_internals_preclude_sra_p_1 (type, msg, &visited_types);
868}


871/* Allocate an access structure for BASE, OFFSET and SIZE, clear it, fill in
 the three fields.  Also add it to the vector of accesses corresponding to
 the base.  Finally, return the new access.  */

875static struct access *
876create_access_1 (tree base, HOST_WIDE_INTlong offset, HOST_WIDE_INTlong size)
877{
struct access *access = access_pool.allocate ();

memset (access, 0, sizeof (struct access));
access->base = base;
access->offset = offset;
access->size = size;

base_access_vec->get_or_insert (base).safe_push (access);

return access;
888}

890static bool maybe_add_sra_candidate (tree);

892/* Create and insert access for EXPR. Return created access, or NULL if it is
 not possible.  Also scan for uses of constant pool as we go along and add
 to candidates.  */

896static struct access *
897create_access (tree expr, gimple *stmt, bool write)
898{
struct access *access;
poly_int64 poffset, psize, pmax_size;
tree base = expr;
bool reverse, unscalarizable_region = false;

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

/* For constant-pool entries, check we can substitute the constant value.  */
if (constant_decl_p (base))
  {
    gcc_assert (!bitmap_bit_p (disqualified_constants, DECL_UID (base)))((void)(!(!bitmap_bit_p (disqualified_constants, ((contains_struct_check
 ((base), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 910, __FUNCTION__))->decl_minimal.uid))) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 910, __FUNCTION__), 0 : 0));
    if (expr != base
 && !is_gimple_reg_type (TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 912, __FUNCTION__))->typed.type))
 && dump_file && (dump_flags & TDF_DETAILS))
{
 /* This occurs in Ada with accesses to ARRAY_RANGE_REFs,
    and elements of multidimensional arrays (which are
    multi-element arrays in their own right).  */
 fprintf (dump_file, "Allowing non-reg-type load of part"
	      " of constant-pool entry: ");
 print_generic_expr (dump_file, expr);
}
    maybe_add_sra_candidate (base);
  }

if (!DECL_P (base)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (base)->base.code))] == tcc_declaration) || !bitmap_bit_p (candidate_bitmap, DECL_UID (base)((contains_struct_check ((base), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 925, __FUNCTION__))->decl_minimal.uid)))
  return NULLnullptr;

if (write && TREE_READONLY (base)((non_type_check ((base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 928, __FUNCTION__))->base.readonly_flag))
  {
    disqualify_candidate (base, "Encountered a store to a read-only decl.");
    return NULLnullptr;
  }

HOST_WIDE_INTlong offset, size, max_size;
if (!poffset.is_constant (&offset)
    || !psize.is_constant (&size)
    || !pmax_size.is_constant (&max_size))
  {
    disqualify_candidate (base, "Encountered a polynomial-sized access.");
    return NULLnullptr;
  }

if (size != max_size)
  {
    size = max_size;
    unscalarizable_region = true;
  }
if (size == 0)
  return NULLnullptr;
if (offset < 0)
  {
    disqualify_candidate (base, "Encountered a negative offset access.");
    return NULLnullptr;
  }
if (size < 0)
  {
    disqualify_candidate (base, "Encountered an unconstrained access.");
    return NULLnullptr;
  }
if (offset + size > tree_to_shwi (DECL_SIZE (base)((contains_struct_check ((base), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 960, __FUNCTION__))->decl_common.size)))
  {
    disqualify_candidate (base, "Encountered an access beyond the base.");
    return NULLnullptr;
  }

access = create_access_1 (base, offset, size);
access->expr = expr;
access->type = TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 968, __FUNCTION__))->typed.type);
access->write = write;
access->grp_unscalarizable_region = unscalarizable_region;
access->stmt = stmt;
access->reverse = reverse;

return access;
975}


978/* Return true iff TYPE is scalarizable - i.e. a RECORD_TYPE or fixed-length
 ARRAY_TYPE with fields that are either of gimple register types (excluding
 bit-fields) or (recursively) scalarizable types.  CONST_DECL must be true if
 we are considering a decl from constant pool.  If it is false, char arrays
 will be refused.  */

984static bool
985scalarizable_type_p (tree type, bool const_decl)
986{
if (is_gimple_reg_type (type))
  return true;
if (type_contains_placeholder_p (type))
  return false;

bool have_predecessor_field = false;
HOST_WIDE_INTlong prev_pos = 0;

switch (TREE_CODE (type)((enum tree_code) (type)->base.code))
{
case RECORD_TYPE:
  for (tree fld = TYPE_FIELDS (type)((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 998, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values); fld; fld = DECL_CHAIN (fld)(((contains_struct_check (((contains_struct_check ((fld), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 998, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 998, __FUNCTION__))->common.chain)))
    if (TREE_CODE (fld)((enum tree_code) (fld)->base.code) == FIELD_DECL)
{
 tree ft = TREE_TYPE (fld)((contains_struct_check ((fld), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1001, __FUNCTION__))->typed.type);

 if (zerop (DECL_SIZE (fld)((contains_struct_check ((fld), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1003, __FUNCTION__))->decl_common.size)))
   continue;

 HOST_WIDE_INTlong pos = int_bit_position (fld);
 if (have_predecessor_field
     && pos <= prev_pos)
   return false;

 have_predecessor_field = true;
 prev_pos = pos;

 if (DECL_BIT_FIELD (fld)((tree_check ((fld), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1014, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
))
   return false;

 if (!scalarizable_type_p (ft, const_decl))
   return false;
}

  return true;

case ARRAY_TYPE:
  {
    HOST_WIDE_INTlong min_elem_size;
    if (const_decl)
min_elem_size = 0;
    else
min_elem_size = BITS_PER_UNIT(8);

    if (TYPE_DOMAIN (type)((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1031, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
) == NULL_TREE(tree) nullptr
 || !tree_fits_shwi_p (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1032, __FUNCTION__))->type_common.size))
 || !tree_fits_shwi_p (TYPE_SIZE (TREE_TYPE (type))((tree_class_check ((((contains_struct_check ((type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1033, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1033, __FUNCTION__))->type_common.size))
 || (tree_to_shwi (TYPE_SIZE (TREE_TYPE (type))((tree_class_check ((((contains_struct_check ((type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1034, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1034, __FUNCTION__))->type_common.size)) <= min_elem_size)
 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type))((tree_check5 ((((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1035, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1035, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)))
return false;
    if (tree_to_shwi (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1037, __FUNCTION__))->type_common.size)) == 0
 && TYPE_MAX_VALUE (TYPE_DOMAIN (type))((tree_check5 ((((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1038, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1038, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
) == NULL_TREE(tree) nullptr)
/* Zero-element array, should not prevent scalarization.  */
;
    else if ((tree_to_shwi (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1041, __FUNCTION__))->type_common.size)) <= 0)
      || !tree_fits_shwi_p (TYPE_MAX_VALUE (TYPE_DOMAIN (type))((tree_check5 ((((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1042, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1042, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)))
/* Variable-length array, do not allow scalarization.  */
return false;

    tree elem = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1046, __FUNCTION__))->typed.type);
    if (!scalarizable_type_p (elem, const_decl))
return false;
    return true;
  }
default:
  return false;
}
1054}

1056/* Return true if REF has an VIEW_CONVERT_EXPR somewhere in it.  */

1058static inline bool
1059contains_view_convert_expr_p (const_tree ref)
1060{
while (handled_component_p (ref))
  {
    if (TREE_CODE (ref)((enum tree_code) (ref)->base.code) == VIEW_CONVERT_EXPR)
return true;
    ref = TREE_OPERAND (ref, 0)(*((const_cast<tree*> (tree_operand_check ((ref), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1065, __FUNCTION__)))));
  }

return false;
1069}

1071/* Return true if REF contains a VIEW_CONVERT_EXPR or a COMPONENT_REF with a
 bit-field field declaration.  If TYPE_CHANGING_P is non-NULL, set the bool
 it points to will be set if REF contains any of the above or a MEM_REF
 expression that effectively performs type conversion.  */

1076static bool
1077contains_vce_or_bfcref_p (const_tree ref, bool *type_changing_p = NULLnullptr)
1078{
while (handled_component_p (ref))
  {
    if (TREE_CODE (ref)((enum tree_code) (ref)->base.code) == VIEW_CONVERT_EXPR
 || (TREE_CODE (ref)((enum tree_code) (ref)->base.code) == COMPONENT_REF
     && DECL_BIT_FIELD (TREE_OPERAND (ref, 1))((tree_check (((*((const_cast<tree*> (tree_operand_check
 ((ref), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1083, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1083, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
)))
{
 if (type_changing_p)
   *type_changing_p = true;
 return true;
}
    ref = TREE_OPERAND (ref, 0)(*((const_cast<tree*> (tree_operand_check ((ref), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1089, __FUNCTION__)))));
  }

if (!type_changing_p
    || TREE_CODE (ref)((enum tree_code) (ref)->base.code) != MEM_REF
    || TREE_CODE (TREE_OPERAND (ref, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((ref), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1094, __FUNCTION__))))))->base.code) != ADDR_EXPR)
  return false;

tree mem = TREE_OPERAND (TREE_OPERAND (ref, 0), 0)(*((const_cast<tree*> (tree_operand_check (((*((const_cast
<tree*> (tree_operand_check ((ref), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1097, __FUNCTION__)))))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1097, __FUNCTION__)))));
if (TYPE_MAIN_VARIANT (TREE_TYPE (ref))((tree_class_check ((((contains_struct_check ((ref), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1098, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1098, __FUNCTION__))->type_common.main_variant)
    != TYPE_MAIN_VARIANT (TREE_TYPE (mem))((tree_class_check ((((contains_struct_check ((mem), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1099, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1099, __FUNCTION__))->type_common.main_variant))
  *type_changing_p = true;

return false;
1103}

1105/* Search the given tree for a declaration by skipping handled components and
 exclude it from the candidates.  */

1108static void
1109disqualify_base_of_expr (tree t, const char *reason)
1110{
t = get_base_address (t);
if (t && DECL_P (t)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_declaration))
  disqualify_candidate (t, reason);
1114}

1116/* Scan expression EXPR and create access structures for all accesses to
 candidates for scalarization.  Return the created access or NULL if none is
 created.  */

1120static struct access *
1121build_access_from_expr_1 (tree expr, gimple *stmt, bool write)
1122{
struct access *ret = NULLnullptr;
bool partial_ref;

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/tree-sra.cc"
, 1130, __FUNCTION__)))));
    partial_ref = true;
  }
else
  partial_ref = false;

if (storage_order_barrier_p (expr))
  {
    disqualify_base_of_expr (expr, "storage order barrier.");
    return NULLnullptr;
  }

/* We need to dive through V_C_Es in order to get the size of its parameter
   and not the result type.  Ada produces such statements.  We are also
   capable of handling the topmost V_C_E but not any of those buried in other
   handled components.  */
if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == VIEW_CONVERT_EXPR)
  expr = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1147, __FUNCTION__)))));

if (contains_view_convert_expr_p (expr))
  {
    disqualify_base_of_expr (expr, "V_C_E under a different handled "
	       "component.");
    return NULLnullptr;
  }
if (TREE_THIS_VOLATILE (expr)((expr)->base.volatile_flag))
  {
    disqualify_base_of_expr (expr, "part of a volatile reference.");
    return NULLnullptr;
  }

switch (TREE_CODE (expr)((enum tree_code) (expr)->base.code))
  {
  case MEM_REF:
    if (TREE_CODE (TREE_OPERAND (expr, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1164, __FUNCTION__))))))->base.code) != ADDR_EXPR)
return NULLnullptr;
    /* fall through */
  case VAR_DECL:
  case PARM_DECL:
  case RESULT_DECL:
  case COMPONENT_REF:
  case ARRAY_REF:
  case ARRAY_RANGE_REF:
    ret = create_access (expr, stmt, write);
    break;

  default:
    break;
  }

if (write && partial_ref && ret)
  ret->grp_partial_lhs = 1;

return ret;
1184}

1186/* Scan expression EXPR and create access structures for all accesses to
 candidates for scalarization.  Return true if any access has been inserted.
 STMT must be the statement from which the expression is taken, WRITE must be
 true if the expression is a store and false otherwise. */

1191static bool
1192build_access_from_expr (tree expr, gimple *stmt, bool write)
1193{
struct access *access;

access = build_access_from_expr_1 (expr, stmt, write);
if (access)
  {
    /* This means the aggregate is accesses as a whole in a way other than an
assign statement and thus cannot be removed even if we had a scalar
replacement for everything.  */
    if (cannot_scalarize_away_bitmap)
bitmap_set_bit (cannot_scalarize_away_bitmap, DECL_UID (access->base)((contains_struct_check ((access->base), (TS_DECL_MINIMAL)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1203, __FUNCTION__))->decl_minimal.uid));
    return true;
  }
return false;
1207}

1209/* Return the single non-EH successor edge of BB or NULL if there is none or
 more than one.  */

1212static edge
1213single_non_eh_succ (basic_block bb)
1214{
edge e, res = NULLnullptr;
edge_iterator ei;

FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
  if (!(e->flags & EDGE_EH))
    {
if (res)
 return NULLnullptr;
res = e;
    }

return res;
1227}

1229/* Disqualify LHS and RHS for scalarization if STMT has to terminate its BB and
 there is no alternative spot where to put statements SRA might need to
 generate after it.  The spot we are looking for is an edge leading to a
 single non-EH successor, if it exists and is indeed single.  RHS may be
 NULL, in that case ignore it.  */

1235static bool
1236disqualify_if_bad_bb_terminating_stmt (gimple *stmt, tree lhs, tree rhs)
1237{
if (stmt_ends_bb_p (stmt))
  {
    if (single_non_eh_succ (gimple_bb (stmt)))
return false;

    disqualify_base_of_expr (lhs, "LHS of a throwing stmt.");
    if (rhs)
disqualify_base_of_expr (rhs, "RHS of a throwing stmt.");
    return true;
  }
return false;
1249}

1251/* Return true if the nature of BASE is such that it contains data even if
 there is no write to it in the function.  */

1254static bool
1255comes_initialized_p (tree base)
1256{
return TREE_CODE (base)((enum tree_code) (base)->base.code) == PARM_DECL || constant_decl_p (base);
1258}

1260/* Scan expressions occurring in STMT, create access structures for all accesses
 to candidates for scalarization and remove those candidates which occur in
 statements or expressions that prevent them from being split apart.  Return
 true if any access has been inserted.  */

1265static bool
1266build_accesses_from_assign (gimple *stmt)
1267{
tree lhs, rhs;
struct access *lacc, *racc;

if (!gimple_assign_single_p (stmt)
    /* Scope clobbers don't influence scalarization.  */
    || gimple_clobber_p (stmt))
  return false;

lhs = gimple_assign_lhs (stmt);
rhs = gimple_assign_rhs1 (stmt);

if (disqualify_if_bad_bb_terminating_stmt (stmt, lhs, rhs))
  return false;

racc = build_access_from_expr_1 (rhs, stmt, false);
lacc = build_access_from_expr_1 (lhs, stmt, true);

if (lacc)
  {
    lacc->grp_assignment_write = 1;
    if (storage_order_barrier_p (rhs))
lacc->grp_unscalarizable_region = 1;

    if (should_scalarize_away_bitmap && !is_gimple_reg_type (lacc->type))
{
 bool type_changing_p = false;
 contains_vce_or_bfcref_p (lhs, &type_changing_p);
 if (type_changing_p)
   bitmap_set_bit (cannot_scalarize_away_bitmap,
	    DECL_UID (lacc->base)((contains_struct_check ((lacc->base), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1297, __FUNCTION__))->decl_minimal.uid));
}
  }

if (racc)
  {
    racc->grp_assignment_read = 1;
    if (should_scalarize_away_bitmap && !is_gimple_reg_type (racc->type))
{
 bool type_changing_p = false;
 contains_vce_or_bfcref_p (rhs, &type_changing_p);

 if (type_changing_p || gimple_has_volatile_ops (stmt))
   bitmap_set_bit (cannot_scalarize_away_bitmap,
	    DECL_UID (racc->base)((contains_struct_check ((racc->base), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1311, __FUNCTION__))->decl_minimal.uid));
 else
   bitmap_set_bit (should_scalarize_away_bitmap,
	    DECL_UID (racc->base)((contains_struct_check ((racc->base), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1314, __FUNCTION__))->decl_minimal.uid));
}
    if (storage_order_barrier_p (lhs))
racc->grp_unscalarizable_region = 1;
  }

if (lacc && racc
    && (sra_mode == SRA_MODE_EARLY_INTRA || sra_mode == SRA_MODE_INTRA)
    && !lacc->grp_unscalarizable_region
    && !racc->grp_unscalarizable_region
    && AGGREGATE_TYPE_P (TREE_TYPE (lhs))(((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1324, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE
 || (((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1324, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1324, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1324, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE
))
    && lacc->size == racc->size
    && useless_type_conversion_p (lacc->type, racc->type))
  {
    struct assign_link *link;

    link = assign_link_pool.allocate ();
    memset (link, 0, sizeof (struct assign_link));

    link->lacc = lacc;
    link->racc = racc;
    add_link_to_rhs (racc, link);
    add_link_to_lhs (lacc, link);
    add_access_to_rhs_work_queue (racc);
    add_access_to_lhs_work_queue (lacc);

    /* Let's delay marking the areas as written until propagation of accesses
across link, unless the nature of rhs tells us that its data comes
from elsewhere.  */
    if (!comes_initialized_p (racc->base))
lacc->write = false;
  }

return lacc || racc;
1348}

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

1353static bool
1354asm_visit_addr (gimple *, tree op, tree, void *)
1355{
op = get_base_address (op);
if (op
    && DECL_P (op)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (op)->base.code))] == tcc_declaration))
  disqualify_candidate (op, "Non-scalarizable GIMPLE_ASM operand.");

return false;
1362}

1364/* Scan function and look for interesting expressions and create access
 structures for them.  Return true iff any access is created.  */

1367static bool
1368scan_function (void)
1369{
basic_block bb;
bool ret = false;

FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->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);
 tree t;
 unsigned i;

 switch (gimple_code (stmt))
   {
   case GIMPLE_RETURN:
     t = gimple_return_retval (as_a <greturn *> (stmt));
     if (t != NULL_TREE(tree) nullptr)
ret |= build_access_from_expr (t, stmt, false);
     break;

   case GIMPLE_ASSIGN:
     ret |= build_accesses_from_assign (stmt);
     break;

   case GIMPLE_CALL:
     for (i = 0; i < gimple_call_num_args (stmt); i++)
ret |= build_access_from_expr (gimple_call_arg (stmt, i),
			       stmt, false);

     t = gimple_call_lhs (stmt);
     if (t && !disqualify_if_bad_bb_terminating_stmt (stmt, t, NULLnullptr))
{
  /* If the STMT is a call to DEFERRED_INIT, avoid setting
     cannot_scalarize_away_bitmap.  */
  if (gimple_call_internal_p (stmt, IFN_DEFERRED_INIT))
    ret |= !!build_access_from_expr_1 (t, stmt, true);
  else
    ret |= build_access_from_expr (t, stmt, true);
}
     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);
for (i = 0; i < gimple_asm_ninputs (asm_stmt); i++)
  {
    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/tree-sra.cc"
, 1418, __FUNCTION__, (TREE_LIST)))->list.value);
    ret |= build_access_from_expr (t, asm_stmt, false);
  }
for (i = 0; i < gimple_asm_noutputs (asm_stmt); i++)
  {
    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/tree-sra.cc"
, 1423, __FUNCTION__, (TREE_LIST)))->list.value);
    ret |= build_access_from_expr (t, asm_stmt, true);
  }
     }
     break;

   default:
     break;
   }
}
  }

return ret;
1436}

1438/* Helper of QSORT function. There are pointers to accesses in the array.  An
 access is considered smaller than another if it has smaller offset or if the
 offsets are the same but is size is bigger. */

1442static int
1443compare_access_positions (const void *a, const void *b)
1444{
const access_p *fp1 = (const access_p *) a;
const access_p *fp2 = (const access_p *) b;
const access_p f1 = *fp1;
const access_p f2 = *fp2;

if (f1->offset != f2->offset)
  return f1->offset < f2->offset ? -1 : 1;

if (f1->size == f2->size)
  {
    if (f1->type == f2->type)
return 0;
    /* Put any non-aggregate type before any aggregate type.  */
    else if (!is_gimple_reg_type (f1->type)
 && is_gimple_reg_type (f2->type))
return 1;
    else if (is_gimple_reg_type (f1->type)
      && !is_gimple_reg_type (f2->type))
return -1;
    /* Put any complex or vector type before any other scalar type.  */
    else if (TREE_CODE (f1->type)((enum tree_code) (f1->type)->base.code) != COMPLEX_TYPE
      && TREE_CODE (f1->type)((enum tree_code) (f1->type)->base.code) != VECTOR_TYPE
      && (TREE_CODE (f2->type)((enum tree_code) (f2->type)->base.code) == COMPLEX_TYPE
   || TREE_CODE (f2->type)((enum tree_code) (f2->type)->base.code) == VECTOR_TYPE))
return 1;
    else if ((TREE_CODE (f1->type)((enum tree_code) (f1->type)->base.code) == COMPLEX_TYPE
|| TREE_CODE (f1->type)((enum tree_code) (f1->type)->base.code) == VECTOR_TYPE)
      && TREE_CODE (f2->type)((enum tree_code) (f2->type)->base.code) != COMPLEX_TYPE
      && TREE_CODE (f2->type)((enum tree_code) (f2->type)->base.code) != VECTOR_TYPE)
return -1;
    /* Put any integral type before any non-integral type.  When splicing, we
make sure that those with insufficient precision and occupying the
same space are not scalarized.  */
    else if (INTEGRAL_TYPE_P (f1->type)(((enum tree_code) (f1->type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (f1->type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (f1->type)->base.code) == INTEGER_TYPE
)
      && !INTEGRAL_TYPE_P (f2->type)(((enum tree_code) (f2->type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (f2->type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (f2->type)->base.code) == INTEGER_TYPE
))
return -1;
    else if (!INTEGRAL_TYPE_P (f1->type)(((enum tree_code) (f1->type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (f1->type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (f1->type)->base.code) == INTEGER_TYPE
)
      && INTEGRAL_TYPE_P (f2->type)(((enum tree_code) (f2->type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (f2->type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (f2->type)->base.code) == INTEGER_TYPE
))
return 1;
    /* Put the integral type with the bigger precision first.  */
    else if (INTEGRAL_TYPE_P (f1->type)(((enum tree_code) (f1->type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (f1->type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (f1->type)->base.code) == INTEGER_TYPE
)
      && INTEGRAL_TYPE_P (f2->type)(((enum tree_code) (f2->type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (f2->type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (f2->type)->base.code) == INTEGER_TYPE
)
      && (TYPE_PRECISION (f2->type)((tree_class_check ((f2->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1487, __FUNCTION__))->type_common.precision) != TYPE_PRECISION (f1->type)((tree_class_check ((f1->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1487, __FUNCTION__))->type_common.precision)))
return TYPE_PRECISION (f2->type)((tree_class_check ((f2->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1488, __FUNCTION__))->type_common.precision) - TYPE_PRECISION (f1->type)((tree_class_check ((f1->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1488, __FUNCTION__))->type_common.precision);
    /* Stabilize the sort.  */
    return TYPE_UID (f1->type)((tree_class_check ((f1->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1490, __FUNCTION__))->type_common.uid) - TYPE_UID (f2->type)((tree_class_check ((f2->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1490, __FUNCTION__))->type_common.uid);
  }

/* We want the bigger accesses first, thus the opposite operator in the next
   line: */
return f1->size > f2->size ? -1 : 1;
1496}


1499/* Append a name of the declaration to the name obstack.  A helper function for
 make_fancy_name.  */

1502static void
1503make_fancy_decl_name (tree decl)
1504{
char buffer[32];

tree name = DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1507, __FUNCTION__))->decl_minimal.name);
if (name)
  obstack_grow (&name_obstack, IDENTIFIER_POINTER (name),__extension__ ({ struct obstack *__o = (&name_obstack); size_t
 __len = (((tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1510, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1509, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
  IDENTIFIER_LENGTH (name))__extension__ ({ struct obstack *__o = (&name_obstack); size_t
 __len = (((tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1510, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1509, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; });
else
  {
    sprintf (buffer, "D%u", DECL_UID (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1513, __FUNCTION__))->decl_minimal.uid));
    obstack_grow (&name_obstack, buffer, strlen (buffer))__extension__ ({ struct obstack *__o = (&name_obstack); size_t
 __len = (strlen (buffer)); if (__extension__ ({ struct obstack
 const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
 (__o->next_free, buffer, __len); __o->next_free += __len
; (void) 0; });
  }
1516}

1518/* Helper for make_fancy_name.  */

1520static void
1521make_fancy_name_1 (tree expr)
1522{
char buffer[32];
tree index;

if (DECL_P (expr)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (expr)->base.code))] == tcc_declaration))
  {
    make_fancy_decl_name (expr);
    return;
  }

switch (TREE_CODE (expr)((enum tree_code) (expr)->base.code))
  {
  case COMPONENT_REF:
    make_fancy_name_1 (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1535, __FUNCTION__))))));
    obstack_1grow (&name_obstack, '$')__extension__ ({ struct obstack *__o = (&name_obstack); if
 (__extension__ ({ struct obstack const *__o1 = (__o); (size_t
) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
 (__o, 1); ((void) (*((__o)->next_free)++ = ('$'))); });
    make_fancy_decl_name (TREE_OPERAND (expr, 1)(*((const_cast<tree*> (tree_operand_check ((expr), (1),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1537, __FUNCTION__))))));
    break;

  case ARRAY_REF:
    make_fancy_name_1 (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1541, __FUNCTION__))))));
    obstack_1grow (&name_obstack, '$')__extension__ ({ struct obstack *__o = (&name_obstack); if
 (__extension__ ({ struct obstack const *__o1 = (__o); (size_t
) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
 (__o, 1); ((void) (*((__o)->next_free)++ = ('$'))); });
    /* Arrays with only one element may not have a constant as their
index. */
    index = TREE_OPERAND (expr, 1)(*((const_cast<tree*> (tree_operand_check ((expr), (1),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1545, __FUNCTION__)))));
    if (TREE_CODE (index)((enum tree_code) (index)->base.code) != INTEGER_CST)
break;
    sprintf (buffer, HOST_WIDE_INT_PRINT_DEC"%" "l" "d", TREE_INT_CST_LOW (index)((unsigned long) (*tree_int_cst_elt_check ((index), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1548, __FUNCTION__))));
    obstack_grow (&name_obstack, buffer, strlen (buffer))__extension__ ({ struct obstack *__o = (&name_obstack); size_t
 __len = (strlen (buffer)); if (__extension__ ({ struct obstack
 const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
 (__o->next_free, buffer, __len); __o->next_free += __len
; (void) 0; });
    break;

  case ADDR_EXPR:
    make_fancy_name_1 (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1553, __FUNCTION__))))));
    break;

  case MEM_REF:
    make_fancy_name_1 (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1557, __FUNCTION__))))));
    if (!integer_zerop (TREE_OPERAND (expr, 1)(*((const_cast<tree*> (tree_operand_check ((expr), (1),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1558, __FUNCTION__)))))))
{
 obstack_1grow (&name_obstack, '$')__extension__ ({ struct obstack *__o = (&name_obstack); if
 (__extension__ ({ struct obstack const *__o1 = (__o); (size_t
) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
 (__o, 1); ((void) (*((__o)->next_free)++ = ('$'))); });
 sprintf (buffer, HOST_WIDE_INT_PRINT_DEC"%" "l" "d",
   TREE_INT_CST_LOW (TREE_OPERAND (expr, 1))((unsigned long) (*tree_int_cst_elt_check (((*((const_cast<
tree*> (tree_operand_check ((expr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1562, __FUNCTION__)))))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1562, __FUNCTION__))));
 obstack_grow (&name_obstack, buffer, strlen (buffer))__extension__ ({ struct obstack *__o = (&name_obstack); size_t
 __len = (strlen (buffer)); if (__extension__ ({ struct obstack
 const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
 (__o->next_free, buffer, __len); __o->next_free += __len
; (void) 0; });
}
    break;

  case BIT_FIELD_REF:
  case REALPART_EXPR:
  case IMAGPART_EXPR:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1570, __FUNCTION__)); 	/* we treat these as scalars.  */
    break;
  default:
    break;
  }
1575}

1577/* Create a human readable name for replacement variable of ACCESS.  */

1579static char *
1580make_fancy_name (tree expr)
1581{
make_fancy_name_1 (expr);
obstack_1grow (&name_obstack, '\0')__extension__ ({ struct obstack *__o = (&name_obstack); if
 (__extension__ ({ struct obstack const *__o1 = (__o); (size_t
) (__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
 (__o, 1); ((void) (*((__o)->next_free)++ = ('\0'))); });
return XOBFINISH (&name_obstack, char *)((char *) __extension__ ({ struct obstack *__o1 = ((&name_obstack
)); 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; }));
1585}

1587/* Construct a MEM_REF that would reference a part of aggregate BASE of type
 EXP_TYPE at the given OFFSET and with storage order REVERSE.  If BASE is
 something for which get_addr_base_and_unit_offset returns NULL, gsi must
 be non-NULL and is used to insert new statements either before or below
 the current one as specified by INSERT_AFTER.  This function is not capable
 of handling bitfields.  */

1594tree
1595build_ref_for_offset (location_t loc, tree base, poly_int64 offset,
      bool reverse, tree exp_type, gimple_stmt_iterator *gsi,
      bool insert_after)
1598{
tree prev_base = base;
tree off;
tree mem_ref;
poly_int64 base_offset;
unsigned HOST_WIDE_INTlong misalign;
unsigned int align;

/* Preserve address-space information.  */
addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (base))((tree_class_check ((((contains_struct_check ((base), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1607, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1607, __FUNCTION__))->base.u.bits.address_space);
if (as != TYPE_ADDR_SPACE (exp_type)((tree_class_check ((exp_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1608, __FUNCTION__))->base.u.bits.address_space))
  exp_type = build_qualified_type (exp_type,
		     TYPE_QUALS (exp_type)((int) ((((tree_class_check ((exp_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1610, __FUNCTION__))->base.readonly_flag) * TYPE_QUAL_CONST
) | (((tree_class_check ((exp_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1610, __FUNCTION__))->base.volatile_flag) * TYPE_QUAL_VOLATILE
) | (((tree_class_check ((exp_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1610, __FUNCTION__))->base.u.bits.atomic_flag) * TYPE_QUAL_ATOMIC
) | (((tree_class_check ((exp_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1610, __FUNCTION__))->type_common.restrict_flag) * TYPE_QUAL_RESTRICT
) | (((((tree_class_check ((exp_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1610, __FUNCTION__))->base.u.bits.address_space) & 0xFF
) << 8))))
		     | ENCODE_QUAL_ADDR_SPACE (as)((as & 0xFF) << 8));

poly_int64 byte_offset = exact_div (offset, BITS_PER_UNIT(8));
get_object_alignment_1 (base, &align, &misalign);
base = get_addr_base_and_unit_offset (base, &base_offset);

/* get_addr_base_and_unit_offset returns NULL for references with a variable
   offset such as array[var_index].  */
if (!base)
  {
    gassign *stmt;
    tree tmp, addr;

    gcc_checking_assert (gsi)((void)(!(gsi) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1624, __FUNCTION__), 0 : 0));
    tmp = make_ssa_name (build_pointer_type (TREE_TYPE (prev_base)((contains_struct_check ((prev_base), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1625, __FUNCTION__))->typed.type)));
    addr = build_fold_addr_expr (unshare_expr (prev_base))build_fold_addr_expr_loc (((location_t) 0), (unshare_expr (prev_base
)));
    STRIP_USELESS_TYPE_CONVERSION (addr)(addr) = tree_ssa_strip_useless_type_conversions (addr);
    stmt = gimple_build_assign (tmp, addr);
    gimple_set_location (stmt, loc);
    if (insert_after)
gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
    else
gsi_insert_before (gsi, stmt, GSI_SAME_STMT);

    off = build_int_cst (reference_alias_ptr_type (prev_base), byte_offset);
    base = tmp;
  }
else if (TREE_CODE (base)((enum tree_code) (base)->base.code) == MEM_REF)
  {
    off = build_int_cst (TREE_TYPE (TREE_OPERAND (base, 1))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
 ((base), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1640, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1640, __FUNCTION__))->typed.type),
	   base_offset + byte_offset);
    off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1)(*((const_cast<tree*> (tree_operand_check ((base), (1),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1642, __FUNCTION__))))), off);
    base = unshare_expr (TREE_OPERAND (base, 0)(*((const_cast<tree*> (tree_operand_check ((base), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1643, __FUNCTION__))))));
  }
else
  {
    off = build_int_cst (reference_alias_ptr_type (prev_base),
	   base_offset + byte_offset);
    base = build_fold_addr_expr (unshare_expr (base))build_fold_addr_expr_loc (((location_t) 0), (unshare_expr (base
)));
  }

unsigned int align_bound = known_alignment (misalign + offset);
if (align_bound != 0)
  align = MIN (align, align_bound)((align) < (align_bound) ? (align) : (align_bound));
if (align != TYPE_ALIGN (exp_type)(((tree_class_check ((exp_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1655, __FUNCTION__))->type_common.align) ? ((unsigned)1)
 << (((tree_class_check ((exp_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1655, __FUNCTION__))->type_common.align) - 1) : 0))
  exp_type = build_aligned_type (exp_type, align);

mem_ref = fold_build2_loc (loc, MEM_REF, exp_type, base, off);
REF_REVERSE_STORAGE_ORDER (mem_ref)((tree_check2 ((mem_ref), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1659, __FUNCTION__, (BIT_FIELD_REF), (MEM_REF)))->base.default_def_flag
) = reverse;
if (TREE_THIS_VOLATILE (prev_base)((prev_base)->base.volatile_flag))
  TREE_THIS_VOLATILE (mem_ref)((mem_ref)->base.volatile_flag) = 1;
if (TREE_SIDE_EFFECTS (prev_base)((non_type_check ((prev_base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1662, __FUNCTION__))->base.side_effects_flag))
  TREE_SIDE_EFFECTS (mem_ref)((non_type_check ((mem_ref), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1663, __FUNCTION__))->base.side_effects_flag) = 1;
return mem_ref;
1665}

1667/* Construct and return a memory reference that is equal to a portion of
 MODEL->expr but is based on BASE.  If this cannot be done, return NULL.  */

1670static tree
1671build_reconstructed_reference (location_t, tree base, struct access *model)
1672{
tree expr = model->expr;
/* We have to make sure to start just below the outermost union.  */
tree start_expr = expr;
while (handled_component_p (expr))
  {
    if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0)))((enum tree_code) (((contains_struct_check (((*((const_cast<
tree*> (tree_operand_check ((expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1678, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1678, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE)
start_expr = expr;
    expr = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1680, __FUNCTION__)))));
  }

expr = start_expr;
tree prev_expr = NULL_TREE(tree) nullptr;
while (!types_compatible_p (TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1685, __FUNCTION__))->typed.type), TREE_TYPE (base)((contains_struct_check ((base), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1685, __FUNCTION__))->typed.type)))
  {
    if (!handled_component_p (expr))
return NULL_TREE(tree) nullptr;
    prev_expr = expr;
    expr = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1690, __FUNCTION__)))));
  }

/* Guard against broken VIEW_CONVERT_EXPRs...  */
if (!prev_expr)
  return NULL_TREE(tree) nullptr;

TREE_OPERAND (prev_expr, 0)(*((const_cast<tree*> (tree_operand_check ((prev_expr),
 (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1697, __FUNCTION__))))) = base;
tree ref = unshare_expr (model->expr);
TREE_OPERAND (prev_expr, 0)(*((const_cast<tree*> (tree_operand_check ((prev_expr),
 (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1699, __FUNCTION__))))) = expr;
return ref;
1701}

1703/* Construct a memory reference to a part of an aggregate BASE at the given
 OFFSET and of the same type as MODEL.  In case this is a reference to a
 bit-field, the function will replicate the last component_ref of model's
 expr to access it.  GSI and INSERT_AFTER have the same meaning as in
 build_ref_for_offset.  */

1709static tree
1710build_ref_for_model (location_t loc, tree base, HOST_WIDE_INTlong offset,
     struct access *model, gimple_stmt_iterator *gsi,
     bool insert_after)
1713{
gcc_assert (offset >= 0)((void)(!(offset >= 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1714, __FUNCTION__), 0 : 0));
if (TREE_CODE (model->expr)((enum tree_code) (model->expr)->base.code) == COMPONENT_REF
    && DECL_BIT_FIELD (TREE_OPERAND (model->expr, 1))((tree_check (((*((const_cast<tree*> (tree_operand_check
 ((model->expr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1716, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1716, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
))
  {
    /* This access represents a bit-field.  */
    tree t, exp_type, fld = TREE_OPERAND (model->expr, 1)(*((const_cast<tree*> (tree_operand_check ((model->expr
), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1719, __FUNCTION__)))));

    offset -= int_bit_position (fld);
    exp_type = TREE_TYPE (TREE_OPERAND (model->expr, 0))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
 ((model->expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1722, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1722, __FUNCTION__))->typed.type);
    t = build_ref_for_offset (loc, base, offset, model->reverse, exp_type,
		gsi, insert_after);
    /* The flag will be set on the record type.  */
    REF_REVERSE_STORAGE_ORDER (t)((tree_check2 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1726, __FUNCTION__, (BIT_FIELD_REF), (MEM_REF)))->base.default_def_flag
) = 0;
    return fold_build3_loc (loc, COMPONENT_REF, TREE_TYPE (fld)((contains_struct_check ((fld), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1727, __FUNCTION__))->typed.type), t, fld,
	      NULL_TREE(tree) nullptr);
  }
else
  {
    tree res;
    if (model->grp_same_access_path
 && !TREE_THIS_VOLATILE (base)((base)->base.volatile_flag)
 && (TYPE_ADDR_SPACE (TREE_TYPE (base))((tree_class_check ((((contains_struct_check ((base), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1735, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1735, __FUNCTION__))->base.u.bits.address_space)
     == TYPE_ADDR_SPACE (TREE_TYPE (model->expr))((tree_class_check ((((contains_struct_check ((model->expr
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1736, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1736, __FUNCTION__))->base.u.bits.address_space))
 && offset <= model->offset
 /* build_reconstructed_reference can still fail if we have already
    massaged BASE because of another type incompatibility.  */
 && (res = build_reconstructed_reference (loc, base, model)))
return res;
    else
return build_ref_for_offset (loc, base, offset, model->reverse,
		     model->type, gsi, insert_after);
  }
1746}

1748/* Attempt to build a memory reference that we could but into a gimple
 debug_bind statement.  Similar to build_ref_for_model but punts if it has to
 create statements and return s NULL instead.  This function also ignores
 alignment issues and so its results should never end up in non-debug
 statements.  */

1754static tree
1755build_debug_ref_for_model (location_t loc, tree base, HOST_WIDE_INTlong offset,
	   struct access *model)
1757{
poly_int64 base_offset;
tree off;

if (TREE_CODE (model->expr)((enum tree_code) (model->expr)->base.code) == COMPONENT_REF
    && DECL_BIT_FIELD (TREE_OPERAND (model->expr, 1))((tree_check (((*((const_cast<tree*> (tree_operand_check
 ((model->expr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1762, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1762, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
))
  return NULL_TREE(tree) nullptr;

base = get_addr_base_and_unit_offset (base, &base_offset);
if (!base)
  return NULL_TREE(tree) nullptr;
if (TREE_CODE (base)((enum tree_code) (base)->base.code) == MEM_REF)
  {
    off = build_int_cst (TREE_TYPE (TREE_OPERAND (base, 1))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
 ((base), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1770, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1770, __FUNCTION__))->typed.type),
	   base_offset + offset / BITS_PER_UNIT(8));
    off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1)(*((const_cast<tree*> (tree_operand_check ((base), (1),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1772, __FUNCTION__))))), off);
    base = unshare_expr (TREE_OPERAND (base, 0)(*((const_cast<tree*> (tree_operand_check ((base), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1773, __FUNCTION__))))));
  }
else
  {
    off = build_int_cst (reference_alias_ptr_type (base),
	   base_offset + offset / BITS_PER_UNIT(8));
    base = build_fold_addr_expr (unshare_expr (base))build_fold_addr_expr_loc (((location_t) 0), (unshare_expr (base
)));
  }

return fold_build2_loc (loc, MEM_REF, model->type, base, off);
1783}

1785/* Construct a memory reference consisting of component_refs and array_refs to
 a part of an aggregate *RES (which is of type TYPE).  The requested part
 should have type EXP_TYPE at be the given OFFSET.  This function might not
 succeed, it returns true when it does and only then *RES points to something
 meaningful.  This function should be used only to build expressions that we
 might need to present to user (e.g. in warnings).  In all other situations,
 build_ref_for_model or build_ref_for_offset should be used instead.  */

1793static bool
1794build_user_friendly_ref_for_offset (tree *res, tree type, HOST_WIDE_INTlong offset,
		    tree exp_type)
1796{
while (1)
  {
    tree fld;
    tree tr_size, index, minidx;
    HOST_WIDE_INTlong el_size;

    if (offset == 0 && exp_type
 && types_compatible_p (exp_type, type))
return true;

    switch (TREE_CODE (type)((enum tree_code) (type)->base.code))
{
case UNION_TYPE:
case QUAL_UNION_TYPE:
case RECORD_TYPE:
 for (fld = TYPE_FIELDS (type)((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1812, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values); fld; fld = DECL_CHAIN (fld)(((contains_struct_check (((contains_struct_check ((fld), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1812, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1812, __FUNCTION__))->common.chain)))
   {
     HOST_WIDE_INTlong pos, size;
     tree tr_pos, expr, *expr_ptr;

     if (TREE_CODE (fld)((enum tree_code) (fld)->base.code) != FIELD_DECL)
continue;

     tr_pos = bit_position (fld);
     if (!tr_pos || !tree_fits_uhwi_p (tr_pos))
continue;
     pos = tree_to_uhwi (tr_pos);
     gcc_assert (TREE_CODE (type) == RECORD_TYPE || pos == 0)((void)(!(((enum tree_code) (type)->base.code) == RECORD_TYPE
 || pos == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1824, __FUNCTION__), 0 : 0));
     tr_size = DECL_SIZE (fld)((contains_struct_check ((fld), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1825, __FUNCTION__))->decl_common.size);
     if (!tr_size || !tree_fits_uhwi_p (tr_size))
continue;
     size = tree_to_uhwi (tr_size);
     if (size == 0)
{
  if (pos != offset)
    continue;
}
     else if (pos > offset || (pos + size) <= offset)
continue;

     expr = build3 (COMPONENT_REF, TREE_TYPE (fld)((contains_struct_check ((fld), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1837, __FUNCTION__))->typed.type), *res, fld,
	     NULL_TREE(tree) nullptr);
     expr_ptr = &expr;
     if (build_user_friendly_ref_for_offset (expr_ptr, TREE_TYPE (fld)((contains_struct_check ((fld), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1840, __FUNCTION__))->typed.type),
				      offset - pos, exp_type))
{
  *res = expr;
  return true;
}
   }
 return false;

case ARRAY_TYPE:
 tr_size = TYPE_SIZE (TREE_TYPE (type))((tree_class_check ((((contains_struct_check ((type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1850, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1850, __FUNCTION__))->type_common.size);
 if (!tr_size || !tree_fits_uhwi_p (tr_size))
   return false;
 el_size = tree_to_uhwi (tr_size);

 minidx = TYPE_MIN_VALUE (TYPE_DOMAIN (type))((tree_check5 ((((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1855, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1855, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
);
 if (TREE_CODE (minidx)((enum tree_code) (minidx)->base.code) != INTEGER_CST || el_size == 0)
   return false;
 index = build_int_cst (TYPE_DOMAIN (type)((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1858, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
), offset / el_size);
 if (!integer_zerop (minidx))
   index = int_const_binop (PLUS_EXPR, index, minidx);
 *res = build4 (ARRAY_REF, TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1861, __FUNCTION__))->typed.type), *res, index,
	 NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
 offset = offset % el_size;
 type = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1864, __FUNCTION__))->typed.type);
 break;

default:
 if (offset != 0)
   return false;

 if (exp_type)
   return false;
 else
   return true;
}
  }
1877}

1879/* Print message to dump file why a variable was rejected. */

1881static void
1882reject (tree var, const char *msg)
1883{
if (dump_file && (dump_flags & TDF_DETAILS))
  {
    fprintf (dump_file, "Rejected (%d): %s: ", DECL_UID (var)((contains_struct_check ((var), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1886, __FUNCTION__))->decl_minimal.uid), msg);
    print_generic_expr (dump_file, var);
    fprintf (dump_file, "\n");
  }
1890}

1892/* Return true if VAR is a candidate for SRA.  */

1894static bool
1895maybe_add_sra_candidate (tree var)
1896{
tree type = TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1897, __FUNCTION__))->typed.type);
const char *msg;
tree_node **slot;

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))) 
  {
    reject (var, "not aggregate");
    return false;
  }
/* Allow constant-pool entries that "need to live in memory".  */
if (needs_to_live_in_memory (var) && !constant_decl_p (var))
  {
    reject (var, "needs to live in memory");
    return false;
  }
if (TREE_THIS_VOLATILE (var)((var)->base.volatile_flag))
  {
    reject (var, "is volatile");
    return false;
  }
if (!COMPLETE_TYPE_P (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1917, __FUNCTION__))->type_common.size) != (tree) nullptr
))
  {
    reject (var, "has incomplete type");
    return false;
  }
if (!tree_fits_shwi_p (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1922, __FUNCTION__))->type_common.size)))
  {
    reject (var, "type size not fixed");
    return false;
  }
if (tree_to_shwi (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1927, __FUNCTION__))->type_common.size)) == 0)
  {
    reject (var, "type size is zero");
    return false;
  }
if (type_internals_preclude_sra_p (type, &msg))
  {
    reject (var, msg);
    return false;
  }
if (/* Fix for PR 41089.  tree-stdarg.cc needs to have va_lists intact but
we also want to schedule it rather late.  Thus we ignore it in
the early pass. */
    (sra_mode == SRA_MODE_EARLY_INTRA
     && is_va_list_type (type)))
  {
    reject (var, "is va_list");
    return false;
  }

bitmap_set_bit (candidate_bitmap, DECL_UID (var)((contains_struct_check ((var), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1947, __FUNCTION__))->decl_minimal.uid));
slot = candidates->find_slot_with_hash (var, DECL_UID (var)((contains_struct_check ((var), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1948, __FUNCTION__))->decl_minimal.uid), INSERT);
*slot = var;

if (dump_file && (dump_flags & TDF_DETAILS))
  {
    fprintf (dump_file, "Candidate (%d): ", DECL_UID (var)((contains_struct_check ((var), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1953, __FUNCTION__))->decl_minimal.uid));
    print_generic_expr (dump_file, var);
    fprintf (dump_file, "\n");
  }

return true;
1959}

1961/* The very first phase of intraprocedural SRA.  It marks in candidate_bitmap
 those with type which is suitable for scalarization.  */

1964static bool
1965find_var_candidates (void)
1966{
tree var, parm;
unsigned int i;
bool ret = false;

for (parm = DECL_ARGUMENTS (current_function_decl)((tree_check ((current_function_decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1971, __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/tree-sra.cc"
, 1973, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 1973, __FUNCTION__))->common.chain)))
  ret |= maybe_add_sra_candidate (parm);

FOR_EACH_LOCAL_DECL (cfun, i, var)for (i = vec_safe_length (((cfun + 0))->local_decls) - 1; vec_safe_iterate
 ((((cfun + 0))->local_decls), (i), &(var)); (i)--)
  {
    if (!VAR_P (var)(((enum tree_code) (var)->base.code) == VAR_DECL))
      continue;

    ret |= maybe_add_sra_candidate (var);
  }

return ret;
1985}

1987/* Return true if EXP is a reference chain of COMPONENT_REFs and AREAY_REFs
 ending either with a DECL or a MEM_REF with zero offset.  */

1990static bool
1991path_comparable_for_same_access (tree expr)
1992{
while (handled_component_p (expr))
  {
    if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == ARRAY_REF)
{
 /* SSA name indices can occur here too when the array is of sie one.
    But we cannot just re-use array_refs with SSA names elsewhere in
    the function, so disallow non-constant indices.  TODO: Remove this
    limitation after teaching build_reconstructed_reference to replace
    the index with the index type lower bound.  */
 if (TREE_CODE (TREE_OPERAND (expr, 1))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((expr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2002, __FUNCTION__))))))->base.code) != INTEGER_CST)
   return false;
}
    expr = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2005, __FUNCTION__)))));
  }

if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == MEM_REF)
  {
    if (!zerop (TREE_OPERAND (expr, 1)(*((const_cast<tree*> (tree_operand_check ((expr), (1),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2010, __FUNCTION__)))))))
return false;
  }
else
  gcc_assert (DECL_P (expr))((void)(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (expr)->base.code))] == tcc_declaration
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2014, __FUNCTION__), 0 : 0));

return true;
2017}

2019/* Assuming that EXP1 consists of only COMPONENT_REFs and ARRAY_REFs, return
 true if the chain of these handled components are exactly the same as EXP2
 and the expression under them is the same DECL or an equivalent MEM_REF.
 The reference picked by compare_access_positions must go to EXP1.  */

2024static bool
2025same_access_path_p (tree exp1, tree exp2)
2026{
if (TREE_CODE (exp1)((enum tree_code) (exp1)->base.code) != TREE_CODE (exp2)((enum tree_code) (exp2)->base.code))
  {
    /* Special case single-field structures loaded sometimes as the field
and sometimes as the structure.  If the field is of a scalar type,
compare_access_positions will put it into exp1.

TODO: The gimple register type condition can be removed if teach
compare_access_positions to put inner types first.  */
    if (is_gimple_reg_type (TREE_TYPE (exp1)((contains_struct_check ((exp1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2035, __FUNCTION__))->typed.type))
 && TREE_CODE (exp1)((enum tree_code) (exp1)->base.code) == COMPONENT_REF
 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (exp1, 0)))((tree_class_check ((((contains_struct_check (((*((const_cast
<tree*> (tree_operand_check ((exp1), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2037, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2037, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2037, __FUNCTION__))->type_common.main_variant)
     == TYPE_MAIN_VARIANT (TREE_TYPE (exp2))((tree_class_check ((((contains_struct_check ((exp2), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2038, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2038, __FUNCTION__))->type_common.main_variant)))
exp1 = TREE_OPERAND (exp1, 0)(*((const_cast<tree*> (tree_operand_check ((exp1), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2039, __FUNCTION__)))));
    else
return false;
  }

if (!operand_equal_p (exp1, exp2, OEP_ADDRESS_OF))
  return false;

return true;
2048}

2050/* Sort all accesses for the given variable, check for partial overlaps and
 return NULL if there are any.  If there are none, pick a representative for
 each combination of offset and size and create a linked list out of them.
 Return the pointer to the first representative and make sure it is the first
 one in the vector of accesses.  */

2056static struct access *
2057sort_and_splice_var_accesses (tree var)
2058{
int i, j, access_count;
struct access *res, **prev_acc_ptr = &res;
3
←
'res' declared without an initial value→
vec<access_p> *access_vec;
bool first = true;
HOST_WIDE_INTlong low = -1, high = 0;

access_vec = get_base_access_vector (var);
if (!access_vec)
4
←
Assuming 'access_vec' is non-null→
5
←
Taking false branch→
  return NULLnullptr;
access_count = access_vec->length ();

/* Sort by <OFFSET, SIZE>.  */
access_vec->qsort (compare_access_positions)qsort (compare_access_positions);

i = 0;
while (i < access_count)
6
←
Assuming 'i' is >= 'access_count'→
7
←
Loop condition is false. Execution continues on line 2186→
  {
    struct access *access = (*access_vec)[i];
    bool grp_write = access->write;
    bool grp_read = !access->write;
    bool grp_scalar_write = access->write
&& is_gimple_reg_type (access->type);
    bool grp_scalar_read = !access->write
&& is_gimple_reg_type (access->type);
    bool grp_assignment_read = access->grp_assignment_read;
    bool grp_assignment_write = access->grp_assignment_write;
    bool multiple_scalar_reads = false;
    bool grp_partial_lhs = access->grp_partial_lhs;
    bool first_scalar = is_gimple_reg_type (access->type);
    bool unscalarizable_region = access->grp_unscalarizable_region;
    bool grp_same_access_path = true;
    bool bf_non_full_precision
= (INTEGRAL_TYPE_P (access->type)(((enum tree_code) (access->type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (access->type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (access->type)->base.code) == INTEGER_TYPE
)
  && TYPE_PRECISION (access->type)((tree_class_check ((access->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2092, __FUNCTION__))->type_common.precision) != access->size
  && TREE_CODE (access->expr)((enum tree_code) (access->expr)->base.code) == COMPONENT_REF
  && DECL_BIT_FIELD (TREE_OPERAND (access->expr, 1))((tree_check (((*((const_cast<tree*> (tree_operand_check
 ((access->expr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2094, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2094, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
));

    if (first || access->offset >= high)
{
 first = false;
 low = access->offset;
 high = access->offset + access->size;
}
    else if (access->offset > low && access->offset + access->size > high)
return NULLnullptr;
    else
gcc_assert (access->offset >= low((void)(!(access->offset >= low && access->offset
 + access->size <= high) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2106, __FUNCTION__), 0 : 0))
    && access->offset + access->size <= high)((void)(!(access->offset >= low && access->offset
 + access->size <= high) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2106, __FUNCTION__), 0 : 0));

    grp_same_access_path = path_comparable_for_same_access (access->expr);

    j = i + 1;
    while (j < access_count)
{
 struct access *ac2 = (*access_vec)[j];
 if (ac2->offset != access->offset || ac2->size != access->size)
   break;
 if (ac2->write)
   {
     grp_write = true;
     grp_scalar_write = (grp_scalar_write
		  || is_gimple_reg_type (ac2->type));
   }
 else
   {
     grp_read = true;
     if (is_gimple_reg_type (ac2->type))
{
  if (grp_scalar_read)
    multiple_scalar_reads = true;
  else
    grp_scalar_read = true;
}
   }
 grp_assignment_read |= ac2->grp_assignment_read;
 grp_assignment_write |= ac2->grp_assignment_write;
 grp_partial_lhs |= ac2->grp_partial_lhs;
 unscalarizable_region |= ac2->grp_unscalarizable_region;
 relink_to_new_repr (access, ac2);

 /* If there are both aggregate-type and scalar-type accesses with
    this combination of size and offset, the comparison function
    should have put the scalars first.  */
 gcc_assert (first_scalar || !is_gimple_reg_type (ac2->type))((void)(!(first_scalar || !is_gimple_reg_type (ac2->type))
 ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2142, __FUNCTION__), 0 : 0));
 /* It also prefers integral types to non-integral.  However, when the
    precision of the selected type does not span the entire area and
    should also be used for a non-integer (i.e. float), we must not
    let that happen.  Normally analyze_access_subtree expands the type
    to cover the entire area but for bit-fields it doesn't.  */
 if (bf_non_full_precision && !INTEGRAL_TYPE_P (ac2->type)(((enum tree_code) (ac2->type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (ac2->type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (ac2->type)->base.code) == INTEGER_TYPE
))
   {
     if (dump_file && (dump_flags & TDF_DETAILS))
{
  fprintf (dump_file, "Cannot scalarize the following access "
	   "because insufficient precision integer type was "
	   "selected.\n  ");
  dump_access (dump_file, access, false);
}
     unscalarizable_region = true;
   }

 if (grp_same_access_path
     && !same_access_path_p (access->expr, ac2->expr))
   grp_same_access_path = false;

 ac2->group_representative = access;
 j++;
}

    i = j;

    access->group_representative = access;
    access->grp_write = grp_write;
    access->grp_read = grp_read;
    access->grp_scalar_read = grp_scalar_read;
    access->grp_scalar_write = grp_scalar_write;
    access->grp_assignment_read = grp_assignment_read;
    access->grp_assignment_write = grp_assignment_write;
    access->grp_hint = multiple_scalar_reads && !constant_decl_p (var);
    access->grp_partial_lhs = grp_partial_lhs;
    access->grp_unscalarizable_region = unscalarizable_region;
    access->grp_same_access_path = grp_same_access_path;

    *prev_acc_ptr = access;
    prev_acc_ptr = &access->next_grp;
  }

gcc_assert (res == (*access_vec)[0])((void)(!(res == (*access_vec)[0]) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2186, __FUNCTION__), 0 : 0));
8
←
The left operand of '==' is a garbage value
return res;
2188}

2190/* Create a variable for the given ACCESS which determines the type, name and a
 few other properties.  Return the variable declaration and store it also to
 ACCESS->replacement.  REG_TREE is used when creating a declaration to base a
 default-definition SSA name on in order to facilitate an uninitialized
 warning.  It is used instead of the actual ACCESS type if that is not of a
 gimple register type.  */

2197static tree
2198create_access_replacement (struct access *access, tree reg_type = NULL_TREE(tree) nullptr)
2199{
tree repl;

tree type = access->type;
if (reg_type && !is_gimple_reg_type (type))
  type = reg_type;

if (access->grp_to_be_debug_replaced)
  {
    repl = create_tmp_var_raw (access->type);
    DECL_CONTEXT (repl)((contains_struct_check ((repl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2209, __FUNCTION__))->decl_minimal.context) = current_function_decl;
  }
else
  /* Drop any special alignment on the type if it's not on the main
     variant.  This avoids issues with weirdo ABIs like AAPCS.  */
  repl = create_tmp_var (build_qualified_type (TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2214, __FUNCTION__))->type_common.main_variant),
				 TYPE_QUALS (type)((int) ((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2215, __FUNCTION__))->base.readonly_flag) * TYPE_QUAL_CONST
) | (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2215, __FUNCTION__))->base.volatile_flag) * TYPE_QUAL_VOLATILE
) | (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2215, __FUNCTION__))->base.u.bits.atomic_flag) * TYPE_QUAL_ATOMIC
) | (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2215, __FUNCTION__))->type_common.restrict_flag) * TYPE_QUAL_RESTRICT
) | (((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2215, __FUNCTION__))->base.u.bits.address_space) & 0xFF
) << 8))))), "SR");
if (access->grp_partial_lhs
    && is_gimple_reg_type (type))
  DECL_NOT_GIMPLE_REG_P (repl)(contains_struct_check ((repl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2218, __FUNCTION__))->decl_common.not_gimple_reg_flag = 1;

DECL_SOURCE_LOCATION (repl)((contains_struct_check ((repl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2220, __FUNCTION__))->decl_minimal.locus) = DECL_SOURCE_LOCATION (access->base)((contains_struct_check ((access->base), (TS_DECL_MINIMAL)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2220, __FUNCTION__))->decl_minimal.locus);
DECL_ARTIFICIAL (repl)((contains_struct_check ((repl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2221, __FUNCTION__))->decl_common.artificial_flag) = 1;
DECL_IGNORED_P (repl)((contains_struct_check ((repl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2222, __FUNCTION__))->decl_common.ignored_flag) = DECL_IGNORED_P (access->base)((contains_struct_check ((access->base), (TS_DECL_COMMON),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2222, __FUNCTION__))->decl_common.ignored_flag);

if (DECL_NAME (access->base)((contains_struct_check ((access->base), (TS_DECL_MINIMAL)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2224, __FUNCTION__))->decl_minimal.name)
    && !DECL_IGNORED_P (access->base)((contains_struct_check ((access->base), (TS_DECL_COMMON),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2225, __FUNCTION__))->decl_common.ignored_flag)
    && !DECL_ARTIFICIAL (access->base)((contains_struct_check ((access->base), (TS_DECL_COMMON),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2226, __FUNCTION__))->decl_common.artificial_flag))
  {
    char *pretty_name = make_fancy_name (access->expr);
    tree debug_expr = unshare_expr_without_location (access->expr), d;
    bool fail = false;

    DECL_NAME (repl)((contains_struct_check ((repl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2232, __FUNCTION__))->decl_minimal.name) = get_identifier (pretty_name)(__builtin_constant_p (pretty_name) ? get_identifier_with_length
 ((pretty_name), strlen (pretty_name)) : get_identifier (pretty_name
));
    DECL_NAMELESS (repl)((contains_struct_check ((repl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2233, __FUNCTION__))->base.u.bits.nameless_flag) = 1;
    obstack_free (&name_obstack, pretty_name)__extension__ ({ struct obstack *__o = (&name_obstack); void
 *__obj = (void *) (pretty_name); if (__obj > (void *) __o
->chunk && __obj < (void *) __o->chunk_limit
) __o->next_free = __o->object_base = (char *) __obj; else
 _obstack_free (__o, __obj); });

    /* Get rid of any SSA_NAMEs embedded in debug_expr,
as DECL_DEBUG_EXPR isn't considered when looking for still
used SSA_NAMEs and thus they could be freed.  All debug info
generation cares is whether something is constant or variable
and that get_ref_base_and_extent works properly on the
expression.  It cannot handle accesses at a non-constant offset
though, so just give up in those cases.  */
    for (d = debug_expr;
  !fail && (handled_component_p (d) || TREE_CODE (d)((enum tree_code) (d)->base.code) == MEM_REF);
  d = TREE_OPERAND (d, 0)(*((const_cast<tree*> (tree_operand_check ((d), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2245, __FUNCTION__))))))
switch (TREE_CODE (d)((enum tree_code) (d)->base.code))
 {
 case ARRAY_REF:
 case ARRAY_RANGE_REF:
   if (TREE_OPERAND (d, 1)(*((const_cast<tree*> (tree_operand_check ((d), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2250, __FUNCTION__)))))
&& TREE_CODE (TREE_OPERAND (d, 1))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((d), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2251, __FUNCTION__))))))->base.code) != INTEGER_CST)
     fail = true;
   if (TREE_OPERAND (d, 3)(*((const_cast<tree*> (tree_operand_check ((d), (3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2253, __FUNCTION__)))))
&& TREE_CODE (TREE_OPERAND (d, 3))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((d), (3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2254, __FUNCTION__))))))->base.code) != INTEGER_CST)
     fail = true;
   /* FALLTHRU */
 case COMPONENT_REF:
   if (TREE_OPERAND (d, 2)(*((const_cast<tree*> (tree_operand_check ((d), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2258, __FUNCTION__)))))
&& TREE_CODE (TREE_OPERAND (d, 2))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((d), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2259, __FUNCTION__))))))->base.code) != INTEGER_CST)
     fail = true;
   break;
 case MEM_REF:
   if (TREE_CODE (TREE_OPERAND (d, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((d), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2263, __FUNCTION__))))))->base.code) != ADDR_EXPR)
     fail = true;
   else
     d = TREE_OPERAND (d, 0)(*((const_cast<tree*> (tree_operand_check ((d), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2266, __FUNCTION__)))));
   break;
 default:
   break;
 }
    if (!fail)
{
 SET_DECL_DEBUG_EXPR (repl, debug_expr)(decl_debug_expr_insert ((tree_check ((repl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2273, __FUNCTION__, (VAR_DECL))), debug_expr));
 DECL_HAS_DEBUG_EXPR_P (repl)((tree_check ((repl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2274, __FUNCTION__, (VAR_DECL)))->decl_common.debug_expr_is_from
) = 1;
}
    if (access->grp_no_warning)
suppress_warning (repl /* Be more selective! */);
    else
copy_warning (repl, access->base);
  }
else
  suppress_warning (repl /* Be more selective! */);

if (dump_file)
  {
    if (access->grp_to_be_debug_replaced)
{
 fprintf (dump_file, "Created a debug-only replacement for ");
 print_generic_expr (dump_file, access->base);
 fprintf (dump_file, " offset: %u, size: %u\n",
   (unsigned) access->offset, (unsigned) access->size);
}
    else
{
 fprintf (dump_file, "Created a replacement for ");
 print_generic_expr (dump_file, access->base);
 fprintf (dump_file, " offset: %u, size: %u: ",
   (unsigned) access->offset, (unsigned) access->size);
 print_generic_expr (dump_file, repl, TDF_UID);
 fprintf (dump_file, "\n");
}
  }
sra_stats.replacements++;

return repl;
2306}

2308/* Return ACCESS scalar replacement, which must exist.  */

2310static inline tree
2311get_access_replacement (struct access *access)
2312{
gcc_checking_assert (access->replacement_decl)((void)(!(access->replacement_decl) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2313, __FUNCTION__), 0 : 0));
return access->replacement_decl;
2315}


2318/* Build a subtree of accesses rooted in *ACCESS, and move the pointer in the
 linked list along the way.  Stop when *ACCESS is NULL or the access pointed
 to it is not "within" the root.  Return false iff some accesses partially
 overlap.  */

2323static bool
2324build_access_subtree (struct access **access)
2325{
struct access *root = *access, *last_child = NULLnullptr;
HOST_WIDE_INTlong limit = root->offset + root->size;

*access = (*access)->next_grp;
while  (*access && (*access)->offset + (*access)->size <= limit)
  {
    if (!last_child)
root->first_child = *access;
    else
last_child->next_sibling = *access;
    last_child = *access;
    (*access)->parent = root;
    (*access)->grp_write |= root->grp_write;

    if (!build_access_subtree (access))
return false;
  }

if (*access && (*access)->offset < limit)
  return false;

return true;
2348}

2350/* Build a tree of access representatives, ACCESS is the pointer to the first
 one, others are linked in a list by the next_grp field.  Return false iff
 some accesses partially overlap.  */

2354static bool
2355build_access_trees (struct access *access)
2356{
while (access)
  {
    struct access *root = access;

    if (!build_access_subtree (&access))
return false;
    root->next_grp = access;
  }
return true;
2366}

2368/* Traverse the access forest where ROOT is the first root and verify that
 various important invariants hold true.  */

2371DEBUG_FUNCTION__attribute__ ((__used__)) void
2372verify_sra_access_forest (struct access *root)
2373{
struct access *access = root;
tree first_base = root->base;
gcc_assert (DECL_P (first_base))((void)(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (first_base)->base.code))] == tcc_declaration
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2376, __FUNCTION__), 0 : 0));
do
  {
    gcc_assert (access->base == first_base)((void)(!(access->base == first_base) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2379, __FUNCTION__), 0 : 0));
    if (access->parent)
gcc_assert (access->offset >= access->parent->offset((void)(!(access->offset >= access->parent->offset
 && access->size <= access->parent->size)
 ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2382, __FUNCTION__), 0 : 0))
    && access->size <= access->parent->size)((void)(!(access->offset >= access->parent->offset
 && access->size <= access->parent->size)
 ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2382, __FUNCTION__), 0 : 0));
    if (access->next_sibling)
gcc_assert (access->next_sibling->offset((void)(!(access->next_sibling->offset >= access->
offset + access->size) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2385, __FUNCTION__), 0 : 0))
    >= access->offset + access->size)((void)(!(access->next_sibling->offset >= access->
offset + access->size) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2385, __FUNCTION__), 0 : 0));

    poly_int64 poffset, psize, pmax_size;
    bool reverse;
    tree base = get_ref_base_and_extent (access->expr, &poffset, &psize,
			   &pmax_size, &reverse);
    HOST_WIDE_INTlong offset, size, max_size;
    if (!poffset.is_constant (&offset)
 || !psize.is_constant (&size)
 || !pmax_size.is_constant (&max_size))
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2395, __FUNCTION__));
    gcc_assert (base == first_base)((void)(!(base == first_base) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2396, __FUNCTION__), 0 : 0));
    gcc_assert (offset == access->offset)((void)(!(offset == access->offset) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2397, __FUNCTION__), 0 : 0));
    gcc_assert (access->grp_unscalarizable_region((void)(!(access->grp_unscalarizable_region || access->
grp_total_scalarization || size == max_size) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2400, __FUNCTION__), 0 : 0))
  || access->grp_total_scalarization((void)(!(access->grp_unscalarizable_region || access->
grp_total_scalarization || size == max_size) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2400, __FUNCTION__), 0 : 0))
  || size == max_size)((void)(!(access->grp_unscalarizable_region || access->
grp_total_scalarization || size == max_size) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2400, __FUNCTION__), 0 : 0));
    gcc_assert (access->grp_unscalarizable_region((void)(!(access->grp_unscalarizable_region || !is_gimple_reg_type
 (access->type) || size == access->size) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2403, __FUNCTION__), 0 : 0))
  || !is_gimple_reg_type (access->type)((void)(!(access->grp_unscalarizable_region || !is_gimple_reg_type
 (access->type) || size == access->size) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2403, __FUNCTION__), 0 : 0))
  || size == access->size)((void)(!(access->grp_unscalarizable_region || !is_gimple_reg_type
 (access->type) || size == access->size) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2403, __FUNCTION__), 0 : 0));
    gcc_assert (reverse == access->reverse)((void)(!(reverse == access->reverse) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2404, __FUNCTION__), 0 : 0));

    if (access->first_child)
{
 gcc_assert (access->first_child->parent == access)((void)(!(access->first_child->parent == access) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2408, __FUNCTION__), 0 : 0));
 access = access->first_child;
}
    else if (access->next_sibling)
{
 gcc_assert (access->next_sibling->parent == access->parent)((void)(!(access->next_sibling->parent == access->parent
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2413, __FUNCTION__), 0 : 0));
 access = access->next_sibling;
}
    else
{
 while (access->parent && !access->next_sibling)
   access = access->parent;
 if (access->next_sibling)
   access = access->next_sibling;
 else
   {
     gcc_assert (access == root)((void)(!(access == root) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2424, __FUNCTION__), 0 : 0));
     root = root->next_grp;
     access = root;
   }
}
  }
while (access);
2431}

2433/* Verify access forests of all candidates with accesses by calling
 verify_access_forest on each on them.  */

2436DEBUG_FUNCTION__attribute__ ((__used__)) void
2437verify_all_sra_access_forests (void)
2438{
bitmap_iterator bi;
unsigned i;
EXECUTE_IF_SET_IN_BITMAP (candidate_bitmap, 0, i, bi)for (bmp_iter_set_init (&(bi), (candidate_bitmap), (0), &
(i)); bmp_iter_set (&(bi), &(i)); bmp_iter_next (&
(bi), &(i)))
  {
    tree var = candidate (i);
    struct access *access = get_first_repr_for_decl (var);
    if (access)
{
 gcc_assert (access->base == var)((void)(!(access->base == var) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2447, __FUNCTION__), 0 : 0));
 verify_sra_access_forest (access);
}
  }
2451}

2453/* Return true if expr contains some ARRAY_REFs into a variable bounded
 array.  */

2456static bool
2457expr_with_var_bounded_array_refs_p (tree expr)
2458{
while (handled_component_p (expr))
  {
    if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == ARRAY_REF
 && !tree_fits_shwi_p (array_ref_low_bound (expr)))
return true;
    expr = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2464, __FUNCTION__)))));
  }
return false;
2467}

2469/* Analyze the subtree of accesses rooted in ROOT, scheduling replacements when
 both seeming beneficial and when ALLOW_REPLACEMENTS allows it.  If TOTALLY
 is set, we are totally scalarizing the aggregate.  Also set all sorts of
 access flags appropriately along the way, notably always set grp_read and
 grp_assign_read according to MARK_READ and grp_write when MARK_WRITE is
 true.

 Creating a replacement for a scalar access is considered beneficial if its
 grp_hint ot TOTALLY is set (this means either that there is more than one
 direct read access or that we are attempting total scalarization) or
 according to the following table:

 Access written to through a scalar type (once or more times)
 |
 |	Written to in an assignment statement
 |	|
 |	|	Access read as scalar _once_
 |	|	|
 |   	|	|	Read in an assignment statement
 |	|	|	|
 |   	|	|	|	Scalarize	Comment
2490-----------------------------------------------------------------------------
 0	0	0	0			No access for the scalar
 0	0	0	1			No access for the scalar
 0	0	1	0	No		Single read - won't help
 0	0	1	1	No		The same case
 0	1	0	0			No access for the scalar
 0	1	0	1			No access for the scalar
 0	1	1	0	Yes		s = *g; return s.i;
 0	1	1	1       Yes		The same case as above
 1	0	0	0	No		Won't help
 1	0	0	1	Yes		s.i = 1; *g = s;
 1	0	1	0	Yes		s.i = 5; g = s.i;
 1	0	1	1	Yes		The same case as above
 1	1	0	0	No		Won't help.
 1	1	0	1	Yes		s.i = 1; *g = s;
 1	1	1	0	Yes		s = *g; return s.i;
 1	1	1	1	Yes		Any of the above yeses  */

2508static bool
2509analyze_access_subtree (struct access *root, struct access *parent,
	bool allow_replacements, bool totally)
2511{
struct access *child;
HOST_WIDE_INTlong limit = root->offset + root->size;
HOST_WIDE_INTlong covered_to = root->offset;
bool scalar = is_gimple_reg_type (root->type);
bool hole = false, sth_created = false;

if (parent)
  {
    if (parent->grp_read)
root->grp_read = 1;
    if (parent->grp_assignment_read)
root->grp_assignment_read = 1;
    if (parent->grp_write)
root->grp_write = 1;
    if (parent->grp_assignment_write)
root->grp_assignment_write = 1;
    if (!parent->grp_same_access_path)
root->grp_same_access_path = 0;
  }

if (root->grp_unscalarizable_region)
  allow_replacements = false;

if (allow_replacements && expr_with_var_bounded_array_refs_p (root->expr))
  allow_replacements = false;

if (!totally && root->grp_result_of_prop_from_lhs)
  allow_replacements = false;

for (child = root->first_child; child; child = child->next_sibling)
  {
    hole |= covered_to < child->offset;
    sth_created |= analyze_access_subtree (child, root,
			     allow_replacements && !scalar,
			     totally);

    root->grp_unscalarized_data |= child->grp_unscalarized_data;
    if (child->grp_covered)
covered_to += child->size;
    else
hole = true;
  }

if (allow_replacements && scalar && !root->first_child
    && (totally || !root->grp_total_scalarization)
    && (totally
 || root->grp_hint
 || ((root->grp_scalar_read || root->grp_assignment_read)
     && (root->grp_scalar_write || root->grp_assignment_write))))
  {
    /* Always create access replacements that cover the whole access.
       For integral types this means the precision has to match.
Avoid assumptions based on the integral type kind, too.  */
    if (INTEGRAL_TYPE_P (root->type)(((enum tree_code) (root->type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (root->type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (root->type)->base.code) == INTEGER_TYPE
)
 && (TREE_CODE (root->type)((enum tree_code) (root->type)->base.code) != INTEGER_TYPE
     || TYPE_PRECISION (root->type)((tree_class_check ((root->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2567, __FUNCTION__))->type_common.precision) != root->size)
 /* But leave bitfield accesses alone.  */
 && (TREE_CODE (root->expr)((enum tree_code) (root->expr)->base.code) != COMPONENT_REF
     || !DECL_BIT_FIELD (TREE_OPERAND (root->expr, 1))((tree_check (((*((const_cast<tree*> (tree_operand_check
 ((root->expr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2570, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2570, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
)))
{
 tree rt = root->type;
 gcc_assert ((root->offset % BITS_PER_UNIT) == 0((void)(!((root->offset % (8)) == 0 && (root->size
 % (8)) == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2574, __FUNCTION__), 0 : 0))
      && (root->size % BITS_PER_UNIT) == 0)((void)(!((root->offset % (8)) == 0 && (root->size
 % (8)) == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2574, __FUNCTION__), 0 : 0));
 root->type = build_nonstandard_integer_type (root->size,
				       TYPE_UNSIGNED (rt)((tree_class_check ((rt), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2576, __FUNCTION__))->base.u.bits.unsigned_flag));
 root->expr = build_ref_for_offset (UNKNOWN_LOCATION((location_t) 0), root->base,
			     root->offset, root->reverse,
			     root->type, NULLnullptr, false);

 if (dump_file && (dump_flags & TDF_DETAILS))
   {
     fprintf (dump_file, "Changing the type of a replacement for ");
     print_generic_expr (dump_file, root->base);
     fprintf (dump_file, " offset: %u, size: %u ",
       (unsigned) root->offset, (unsigned) root->size);
     fprintf (dump_file, " to an integer.\n");
   }
}

    root->grp_to_be_replaced = 1;
    root->replacement_decl = create_access_replacement (root);
    sth_created = true;
    hole = false;
  }
else
  {
    if (allow_replacements
 && scalar && !root->first_child
 && !root->grp_total_scalarization
 && (root->grp_scalar_write || root->grp_assignment_write)
 && !bitmap_bit_p (cannot_scalarize_away_bitmap,
	    DECL_UID (root->base)((contains_struct_check ((root->base), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2603, __FUNCTION__))->decl_minimal.uid)))
{
 gcc_checking_assert (!root->grp_scalar_read((void)(!(!root->grp_scalar_read && !root->grp_assignment_read
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2606, __FUNCTION__), 0 : 0))
	       && !root->grp_assignment_read)((void)(!(!root->grp_scalar_read && !root->grp_assignment_read
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2606, __FUNCTION__), 0 : 0));
 sth_created = true;
 if (MAY_HAVE_DEBUG_BIND_STMTSglobal_options.x_flag_var_tracking_assignments)
   {
     root->grp_to_be_debug_replaced = 1;
     root->replacement_decl = create_access_replacement (root);
   }
}

    if (covered_to < limit)
hole = true;
    if (scalar || !allow_replacements)
root->grp_total_scalarization = 0;
  }

if (!hole || totally)
  root->grp_covered = 1;
else if (root->grp_write || comes_initialized_p (root->base))
  root->grp_unscalarized_data = 1; /* not covered and written to */
return sth_created;
2626}

2628/* Analyze all access trees linked by next_grp by the means of
 analyze_access_subtree.  */
2630static bool
2631analyze_access_trees (struct access *access)
2632{
bool ret = false;

while (access)
  {
    if (analyze_access_subtree (access, NULLnullptr, true,
		  access->grp_total_scalarization))
ret = true;
    access = access->next_grp;
  }

return ret;
2644}

2646/* Return true iff a potential new child of ACC at offset OFFSET and with size
 SIZE would conflict with an already existing one.  If exactly such a child
 already exists in ACC, store a pointer to it in EXACT_MATCH.  */

2650static bool
2651child_would_conflict_in_acc (struct access *acc, HOST_WIDE_INTlong norm_offset,
	      HOST_WIDE_INTlong size, struct access **exact_match)
2653{
struct access *child;

for (child = acc->first_child; child; child = child->next_sibling)
  {
    if (child->offset == norm_offset && child->size == size)
{
 *exact_match = child;
 return true;
}

    if (child->offset < norm_offset + size
 && child->offset + child->size > norm_offset)
return true;
  }

return false;
2670}

2672/* Create a new child access of PARENT, with all properties just like MODEL
 except for its offset and with its grp_write false and grp_read true.
 Return the new access or NULL if it cannot be created.  Note that this
 access is created long after all splicing and sorting, it's not located in
 any access vector and is automatically a representative of its group.  Set
 the gpr_write flag of the new accesss if SET_GRP_WRITE is true.  */

2679static struct access *
2680create_artificial_child_access (struct access *parent, struct access *model,
		HOST_WIDE_INTlong new_offset,
		bool set_grp_read, bool set_grp_write)
2683{
struct access **child;
tree expr = parent->base;

gcc_assert (!model->grp_unscalarizable_region)((void)(!(!model->grp_unscalarizable_region) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2687, __FUNCTION__), 0 : 0));

struct access *access = access_pool.allocate ();
memset (access, 0, sizeof (struct access));
if (!build_user_friendly_ref_for_offset (&expr, TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2691, __FUNCTION__))->typed.type), new_offset,
			   model->type))
  {
    access->grp_no_warning = true;
    expr = build_ref_for_model (EXPR_LOCATION (parent->base)((((parent->base)) && ((tree_code_type_tmpl <0>
::tree_code_type[(int) (((enum tree_code) ((parent->base))
->base.code))]) >= tcc_reference && (tree_code_type_tmpl
 <0>::tree_code_type[(int) (((enum tree_code) ((parent->
base))->base.code))]) <= tcc_expression)) ? (parent->
base)->exp.locus : ((location_t) 0)), parent->base,
		  new_offset, model, NULLnullptr, false);
  }

access->base = parent->base;
access->expr = expr;
access->offset = new_offset;
access->size = model->size;
access->type = model->type;
access->parent = parent;
access->grp_read = set_grp_read;
access->grp_write = set_grp_write;
access->reverse = model->reverse;

child = &parent->first_child;
while (*child && (*child)->offset < new_offset)
  child = &(*child)->next_sibling;

access->next_sibling = *child;
*child = access;

return access;
2717}


2720/* Beginning with ACCESS, traverse its whole access subtree and mark all
 sub-trees as written to.  If any of them has not been marked so previously
 and has assignment links leading from it, re-enqueue it.  */

2724static void
2725subtree_mark_written_and_rhs_enqueue (struct access *access)
2726{
if (access->grp_write)
  return;
access->grp_write = true;
add_access_to_rhs_work_queue (access);

struct access *child;
for (child = access->first_child; child; child = child->next_sibling)
  subtree_mark_written_and_rhs_enqueue (child);
2735}

2737/* If there is still budget to create a propagation access for DECL, return
 true and decrement the budget.  Otherwise return false.  */

2740static bool
2741budget_for_propagation_access (tree decl)
2742{
unsigned b, *p = propagation_budget->get (decl);
if (p)
  b = *p;
else
  b = param_sra_max_propagationsglobal_options.x_param_sra_max_propagations;

if (b == 0)
  return false;
b--;

if (b == 0 && dump_file && (dump_flags & TDF_DETAILS))
  {
    fprintf (dump_file, "The propagation budget of ");
    print_generic_expr (dump_file, decl);
    fprintf (dump_file, " (UID: %u) has been exhausted.\n", DECL_UID (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2757, __FUNCTION__))->decl_minimal.uid));
  }
propagation_budget->put (decl, b);
return true;
2761}

2763/* Return true if ACC or any of its subaccesses has grp_child set.  */

2765static bool
2766access_or_its_child_written (struct access *acc)
2767{
if (acc->grp_write)
  return true;
for (struct access *sub = acc->first_child; sub; sub = sub->next_sibling)
  if (access_or_its_child_written (sub))
    return true;
return false;
2774}

2776/* Propagate subaccesses and grp_write flags of RACC across an assignment link
 to LACC.  Enqueue sub-accesses as necessary so that the write flag is
 propagated transitively.  Return true if anything changed.  Additionally, if
 RACC is a scalar access but LACC is not, change the type of the latter, if
 possible.  */

2782static bool
2783propagate_subaccesses_from_rhs (struct access *lacc, struct access *racc)
2784{
struct access *rchild;
HOST_WIDE_INTlong norm_delta = lacc->offset - racc->offset;
bool ret = false;

/* IF the LHS is still not marked as being written to, we only need to do so
   if the RHS at this level actually was.  */
if (!lacc->grp_write)
  {
    gcc_checking_assert (!comes_initialized_p (racc->base))((void)(!(!comes_initialized_p (racc->base)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2793, __FUNCTION__), 0 : 0));
    if (racc->grp_write)
{
 subtree_mark_written_and_rhs_enqueue (lacc);
 ret = true;
}
  }

if (is_gimple_reg_type (lacc->type)
    || lacc->grp_unscalarizable_region
    || racc->grp_unscalarizable_region)
  {
    if (!lacc->grp_write)
{
 ret = true;
 subtree_mark_written_and_rhs_enqueue (lacc);
}
    return ret;
  }

if (is_gimple_reg_type (racc->type))
  {
    if (!lacc->grp_write)
{
 ret = true;
 subtree_mark_written_and_rhs_enqueue (lacc);
}
    if (!lacc->first_child && !racc->first_child)
{
 /* We are about to change the access type from aggregate to scalar,
    so we need to put the reverse flag onto the access, if any.  */
 const bool reverse
   = TYPE_REVERSE_STORAGE_ORDER (lacc->type)((tree_check4 ((lacc->type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2825, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
     && !POINTER_TYPE_P (racc->type)(((enum tree_code) (racc->type)->base.code) == POINTER_TYPE
 || ((enum tree_code) (racc->type)->base.code) == REFERENCE_TYPE
)
     && !VECTOR_TYPE_P (racc->type)(((enum tree_code) (racc->type)->base.code) == VECTOR_TYPE
);
 tree t = lacc->base;

 lacc->type = racc->type;
 if (build_user_friendly_ref_for_offset (&t, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2831, __FUNCTION__))->typed.type),
				  lacc->offset, racc->type))
   {
     lacc->expr = t;
     lacc->grp_same_access_path = true;
   }
 else
   {
     lacc->expr = build_ref_for_model (EXPR_LOCATION (lacc->base)((((lacc->base)) && ((tree_code_type_tmpl <0>
::tree_code_type[(int) (((enum tree_code) ((lacc->base))->
base.code))]) >= tcc_reference && (tree_code_type_tmpl
 <0>::tree_code_type[(int) (((enum tree_code) ((lacc->
base))->base.code))]) <= tcc_expression)) ? (lacc->base
)->exp.locus : ((location_t) 0)),
				lacc->base, lacc->offset,
				racc, NULLnullptr, false);
     if (TREE_CODE (lacc->expr)((enum tree_code) (lacc->expr)->base.code) == MEM_REF)
REF_REVERSE_STORAGE_ORDER (lacc->expr)((tree_check2 ((lacc->expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2843, __FUNCTION__, (BIT_FIELD_REF), (MEM_REF)))->base.default_def_flag
) = reverse;
     lacc->grp_no_warning = true;
     lacc->grp_same_access_path = false;
   }
 lacc->reverse = reverse;
}
    return ret;
  }

for (rchild = racc->first_child; rchild; rchild = rchild->next_sibling)
  {
    struct access *new_acc = NULLnullptr;
    HOST_WIDE_INTlong norm_offset = rchild->offset + norm_delta;

    if (child_would_conflict_in_acc (lacc, norm_offset, rchild->size,
			&new_acc))
{
 if (new_acc)
   {
     if (!new_acc->grp_write && rchild->grp_write)
{
  gcc_assert (!lacc->grp_write)((void)(!(!lacc->grp_write) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2864, __FUNCTION__), 0 : 0));
  subtree_mark_written_and_rhs_enqueue (new_acc);
  ret = true;
}

     rchild->grp_hint = 1;
     new_acc->grp_hint |= new_acc->grp_read;
     if (rchild->first_child
  && propagate_subaccesses_from_rhs (new_acc, rchild))
{
  ret = 1;
  add_access_to_rhs_work_queue (new_acc);
}
   }
 else
   {
     if (!lacc->grp_write)
{
  ret = true;
  subtree_mark_written_and_rhs_enqueue (lacc);
}
   }
 continue;
}

    if (rchild->grp_unscalarizable_region
 || !budget_for_propagation_access (lacc->base))
{
 if (!lacc->grp_write && access_or_its_child_written (rchild))
   {
     ret = true;
     subtree_mark_written_and_rhs_enqueue (lacc);
   }
 continue;
}

    rchild->grp_hint = 1;
    /* Because get_ref_base_and_extent always includes padding in size for
accesses to DECLs but not necessarily for COMPONENT_REFs of the same
type, we might be actually attempting to here to create a child of the
same type as the parent.  */
    if (!types_compatible_p (lacc->type, rchild->type))
new_acc = create_artificial_child_access (lacc, rchild, norm_offset,
				  false,
				  (lacc->grp_write
				   || rchild->grp_write));
    else
new_acc = lacc;
    gcc_checking_assert (new_acc)((void)(!(new_acc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2912, __FUNCTION__), 0 : 0));
    if (racc->first_child)
propagate_subaccesses_from_rhs (new_acc, rchild);

    add_access_to_rhs_work_queue (lacc);
    ret = true;
  }

return ret;
2921}

2923/* Propagate subaccesses of LACC across an assignment link to RACC if they
 should inhibit total scalarization of the corresponding area.  No flags are
 being propagated in the process.  Return true if anything changed.  */

2927static bool
2928propagate_subaccesses_from_lhs (struct access *lacc, struct access *racc)
2929{
if (is_gimple_reg_type (racc->type)
    || lacc->grp_unscalarizable_region
    || racc->grp_unscalarizable_region)
  return false;

/* TODO: Do we want set some new racc flag to stop potential total
   scalarization if lacc is a scalar access (and none fo the two have
   children)?  */

bool ret = false;
HOST_WIDE_INTlong norm_delta = racc->offset - lacc->offset;
for (struct access *lchild = lacc->first_child;
     lchild;
     lchild = lchild->next_sibling)
  {
    struct access *matching_acc = NULLnullptr;
    HOST_WIDE_INTlong norm_offset = lchild->offset + norm_delta;

    if (lchild->grp_unscalarizable_region
 || child_would_conflict_in_acc (racc, norm_offset, lchild->size,
			  &matching_acc)
 || !budget_for_propagation_access (racc->base))
{
 if (matching_acc
     && propagate_subaccesses_from_lhs (lchild, matching_acc))
   add_access_to_lhs_work_queue (matching_acc);
 continue;
}

    /* Because get_ref_base_and_extent always includes padding in size for
accesses to DECLs but not necessarily for COMPONENT_REFs of the same
type, we might be actually attempting to here to create a child of the
same type as the parent.  */
    if (!types_compatible_p (racc->type, lchild->type))
{
 struct access *new_acc
   = create_artificial_child_access (racc, lchild, norm_offset,
			      true, false);
 new_acc->grp_result_of_prop_from_lhs = 1;
 propagate_subaccesses_from_lhs (lchild, new_acc);
}
    else
propagate_subaccesses_from_lhs (lchild, racc);
    ret = true;
  }
return ret;
2976}

2978/* Propagate all subaccesses across assignment links.  */

2980static void
2981propagate_all_subaccesses (void)
2982{
propagation_budget = new hash_map<tree, unsigned>;
while (rhs_work_queue_head)
  {
    struct access *racc = pop_access_from_rhs_work_queue ();
    struct assign_link *link;

    if (racc->group_representative)
racc= racc->group_representative;
    gcc_assert (racc->first_rhs_link)((void)(!(racc->first_rhs_link) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2991, __FUNCTION__), 0 : 0));

    for (link = racc->first_rhs_link; link; link = link->next_rhs)
{
 struct access *lacc = link->lacc;

 if (!bitmap_bit_p (candidate_bitmap, DECL_UID (lacc->base)((contains_struct_check ((lacc->base), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 2997, __FUNCTION__))->decl_minimal.uid)))
   continue;
 lacc = lacc->group_representative;

 bool reque_parents = false;
 if (!bitmap_bit_p (candidate_bitmap, DECL_UID (racc->base)((contains_struct_check ((racc->base), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3002, __FUNCTION__))->decl_minimal.uid)))
   {
     if (!lacc->grp_write)
{
  subtree_mark_written_and_rhs_enqueue (lacc);
  reque_parents = true;
}
   }
 else if (propagate_subaccesses_from_rhs (lacc, racc))
   reque_parents = true;

 if (reque_parents)
   do
     {
add_access_to_rhs_work_queue (lacc);
lacc = lacc->parent;
     }
   while (lacc);
}
  }

while (lhs_work_queue_head)
  {
    struct access *lacc = pop_access_from_lhs_work_queue ();
    struct assign_link *link;

    if (lacc->group_representative)
lacc = lacc->group_representative;
    gcc_assert (lacc->first_lhs_link)((void)(!(lacc->first_lhs_link) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3030, __FUNCTION__), 0 : 0));

    if (!bitmap_bit_p (candidate_bitmap, DECL_UID (lacc->base)((contains_struct_check ((lacc->base), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3032, __FUNCTION__))->decl_minimal.uid)))
continue;

    for (link = lacc->first_lhs_link; link; link = link->next_lhs)
{
 struct access *racc = link->racc;

 if (racc->group_representative)
   racc = racc->group_representative;
 if (!bitmap_bit_p (candidate_bitmap, DECL_UID (racc->base)((contains_struct_check ((racc->base), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3041, __FUNCTION__))->decl_minimal.uid)))
   continue;
 if (propagate_subaccesses_from_lhs (lacc, racc))
   add_access_to_lhs_work_queue (racc);
}
  }
delete propagation_budget;
3048}

3050/* Return true if the forest beginning with ROOT does not contain
 unscalarizable regions or non-byte aligned accesses.  */

3053static bool
3054can_totally_scalarize_forest_p (struct access *root)
3055{
struct access *access = root;
do
  {
    if (access->grp_unscalarizable_region
 || (access->offset % BITS_PER_UNIT(8)) != 0
 || (access->size % BITS_PER_UNIT(8)) != 0
 || (is_gimple_reg_type (access->type)
     && access->first_child))
return false;

    if (access->first_child)
access = access->first_child;
    else if (access->next_sibling)
access = access->next_sibling;
    else
{
 while (access->parent && !access->next_sibling)
   access = access->parent;
 if (access->next_sibling)
   access = access->next_sibling;
 else
   {
     gcc_assert (access == root)((void)(!(access == root) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3078, __FUNCTION__), 0 : 0));
     root = root->next_grp;
     access = root;
   }
}
  }
while (access);
return true;
3086}

3088/* Create and return an ACCESS in PARENT spanning from POS with SIZE, TYPE and
 reference EXPR for total scalarization purposes and mark it as such.  Within
 the children of PARENT, link it in between PTR and NEXT_SIBLING.  */

3092static struct access *
3093create_total_scalarization_access (struct access *parent, HOST_WIDE_INTlong pos,
		   HOST_WIDE_INTlong size, tree type, tree expr,
		   struct access **ptr,
		   struct access *next_sibling)
3097{
struct access *access = access_pool.allocate ();
memset (access, 0, sizeof (struct access));
access->base = parent->base;
access->offset = pos;
access->size = size;
access->expr = expr;
access->type = type;
access->parent = parent;
access->grp_write = parent->grp_write;
access->grp_total_scalarization = 1;
access->grp_hint = 1;
access->grp_same_access_path = path_comparable_for_same_access (expr);
access->reverse = reverse_storage_order_for_component_p (expr);

access->next_sibling = next_sibling;
*ptr = access;
return access;
3115}

3117/* Create and return an ACCESS in PARENT spanning from POS with SIZE, TYPE and
 reference EXPR for total scalarization purposes and mark it as such, link it
 at *PTR and reshape the tree so that those elements at *PTR and their
 siblings which fall within the part described by POS and SIZE are moved to
 be children of the new access.  If a partial overlap is detected, return
 NULL.  */

3124static struct access *
3125create_total_access_and_reshape (struct access *parent, HOST_WIDE_INTlong pos,
		 HOST_WIDE_INTlong size, tree type, tree expr,
		 struct access **ptr)
3128{
struct access **p = ptr;

while (*p && (*p)->offset < pos + size)
  {
    if ((*p)->offset + (*p)->size > pos + size)
return NULLnullptr;
    p = &(*p)->next_sibling;
  }

struct access *next_child = *ptr;
struct access *new_acc
  = create_total_scalarization_access (parent, pos, size, type, expr,
			 ptr, *p);
if (p != ptr)
  {
    new_acc->first_child = next_child;
    *p = NULLnullptr;
    for (struct access *a = next_child; a; a = a->next_sibling)
a->parent = new_acc;
  }
return new_acc;
3150}

3152static bool totally_scalarize_subtree (struct access *root);

3154/* Return true if INNER is either the same type as OUTER or if it is the type
 of a record field in OUTER at offset zero, possibly in nested
 sub-records.  */

3158static bool
3159access_and_field_type_match_p (tree outer, tree inner)
3160{
if (TYPE_MAIN_VARIANT (outer)((tree_class_check ((outer), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3161, __FUNCTION__))->type_common.main_variant) == TYPE_MAIN_VARIANT (inner)((tree_class_check ((inner), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3161, __FUNCTION__))->type_common.main_variant))
  return true;
if (TREE_CODE (outer)((enum tree_code) (outer)->base.code) != RECORD_TYPE)
  return false;
tree fld = TYPE_FIELDS (outer)((tree_check3 ((outer), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3165, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values);
while (fld)
  {
   if (TREE_CODE (fld)((enum tree_code) (fld)->base.code) == FIELD_DECL)
     {
if (!zerop (DECL_FIELD_OFFSET (fld)((tree_check ((fld), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3170, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)))
 return false;
if (TYPE_MAIN_VARIANT (TREE_TYPE (fld))((tree_class_check ((((contains_struct_check ((fld), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3172, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3172, __FUNCTION__))->type_common.main_variant) == inner)
 return true;
if (TREE_CODE (TREE_TYPE (fld))((enum tree_code) (((contains_struct_check ((fld), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3174, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE)
 fld = TYPE_FIELDS (TREE_TYPE (fld))((tree_check3 ((((contains_struct_check ((fld), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3175, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3175, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values);
else
 return false;
     }
   else
     fld = DECL_CHAIN (fld)(((contains_struct_check (((contains_struct_check ((fld), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3180, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3180, __FUNCTION__))->common.chain));
  }
return false;
3183}

3185/* Return type of total_should_skip_creating_access indicating whether a total
 scalarization access for a field/element should be created, whether it
 already exists or whether the entire total scalarization has to fail.  */

3189enum total_sra_field_state {TOTAL_FLD_CREATE, TOTAL_FLD_DONE, TOTAL_FLD_FAILED};

3191/* Do all the necessary steps in total scalarization when the given aggregate
 type has a TYPE at POS with the given SIZE should be put into PARENT and
 when we have processed all its siblings with smaller offsets up until and
 including LAST_SEEN_SIBLING (which can be NULL).

 If some further siblings are to be skipped, set *LAST_SEEN_SIBLING as
 appropriate.  Return TOTAL_FLD_CREATE id the caller should carry on with
 creating a new access, TOTAL_FLD_DONE if access or accesses capable of
 representing the described part of the aggregate for the purposes of total
 scalarization already exist or TOTAL_FLD_FAILED if there is a problem which
 prevents total scalarization from happening at all.  */

3203static enum total_sra_field_state
3204total_should_skip_creating_access (struct access *parent,
		   struct access **last_seen_sibling,
		   tree type, HOST_WIDE_INTlong pos,
		   HOST_WIDE_INTlong size)
3208{
struct access *next_child;
if (!*last_seen_sibling)
  next_child = parent->first_child;
else
  next_child = (*last_seen_sibling)->next_sibling;

/* First, traverse the chain of siblings until it points to an access with
   offset at least equal to POS.  Check all skipped accesses whether they
   span the POS boundary and if so, return with a failure.  */
while (next_child && next_child->offset < pos)
  {
    if (next_child->offset + next_child->size > pos)
return TOTAL_FLD_FAILED;
    *last_seen_sibling = next_child;
    next_child = next_child->next_sibling;
  }

/* Now check whether next_child has exactly the right POS and SIZE and if so,
   whether it can represent what we need and can be totally scalarized
   itself.  */
if (next_child && next_child->offset == pos
    && next_child->size == size)
  {
    if (!is_gimple_reg_type (next_child->type)
 && (!access_and_field_type_match_p (type, next_child->type)
     || !totally_scalarize_subtree (next_child)))
return TOTAL_FLD_FAILED;

    *last_seen_sibling = next_child;
    return TOTAL_FLD_DONE;
  }

/* If the child we're looking at would partially overlap, we just cannot
   totally scalarize.  */
if (next_child
    && next_child->offset < pos + size
    && next_child->offset + next_child->size > pos + size)
  return TOTAL_FLD_FAILED;

if (is_gimple_reg_type (type))
  {
    /* We don't scalarize accesses that are children of other scalar type
accesses, so if we go on and create an access for a register type,
there should not be any pre-existing children.  There are rare cases
where the requested type is a vector but we already have register
accesses for all its elements which is equally good.  Detect that
situation or whether we need to bail out.  */

    HOST_WIDE_INTlong covered = pos;
    bool skipping = false;
    while (next_child
    && next_child->offset + next_child->size <= pos + size)
{
 if (next_child->offset != covered
     || !is_gimple_reg_type (next_child->type))
   return TOTAL_FLD_FAILED;

 covered += next_child->size;
 *last_seen_sibling = next_child;
 next_child = next_child->next_sibling;
 skipping = true;
}

    if (skipping)
{
 if (covered != pos + size)
   return TOTAL_FLD_FAILED;
 else
   return TOTAL_FLD_DONE;
}
  }

return TOTAL_FLD_CREATE;
3282}

3284/* Go over sub-tree rooted in ROOT and attempt to create scalar accesses
 spanning all uncovered areas covered by ROOT, return false if the attempt
 failed.  All created accesses will have grp_unscalarizable_region set (and
 should be ignored if the function returns false).  */

3289static bool
3290totally_scalarize_subtree (struct access *root)
3291{
gcc_checking_assert (!root->grp_unscalarizable_region)((void)(!(!root->grp_unscalarizable_region) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3292, __FUNCTION__), 0 : 0));
gcc_checking_assert (!is_gimple_reg_type (root->type))((void)(!(!is_gimple_reg_type (root->type)) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3293, __FUNCTION__), 0 : 0));

struct access *last_seen_sibling = NULLnullptr;

switch (TREE_CODE (root->type)((enum tree_code) (root->type)->base.code))
  {
  case RECORD_TYPE:
    for (tree fld = TYPE_FIELDS (root->type)((tree_check3 ((root->type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3300, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values); fld; fld = DECL_CHAIN (fld)(((contains_struct_check (((contains_struct_check ((fld), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3300, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3300, __FUNCTION__))->common.chain)))
if (TREE_CODE (fld)((enum tree_code) (fld)->base.code) == FIELD_DECL)
 {
   tree ft = TREE_TYPE (fld)((contains_struct_check ((fld), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3303, __FUNCTION__))->typed.type);
   HOST_WIDE_INTlong fsize = tree_to_uhwi (DECL_SIZE (fld)((contains_struct_check ((fld), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3304, __FUNCTION__))->decl_common.size));
   if (!fsize)
     continue;

   HOST_WIDE_INTlong pos = root->offset + int_bit_position (fld);
   if (pos + fsize > root->offset + root->size)
     return false;
   enum total_sra_field_state
     state = total_should_skip_creating_access (root,
					 &last_seen_sibling,
					 ft, pos, fsize);
   switch (state)
     {
     case TOTAL_FLD_FAILED:
return false;
     case TOTAL_FLD_DONE:
continue;
     case TOTAL_FLD_CREATE:
break;
     default:
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3324, __FUNCTION__));
     }

   struct access **p = (last_seen_sibling
		 ? &last_seen_sibling->next_sibling
		 : &root->first_child);
   tree nref = build3 (COMPONENT_REF, ft, root->expr, fld, NULL_TREE(tree) nullptr);
   struct access *new_child
     = create_total_access_and_reshape (root, pos, fsize, ft, nref, p);
   if (!new_child)
     return false;

   if (!is_gimple_reg_type (ft)
&& !totally_scalarize_subtree (new_child))
     return false;
   last_seen_sibling = new_child;
 }
    break;
  case ARRAY_TYPE:
    {
tree elemtype = TREE_TYPE (root->type)((contains_struct_check ((root->type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3344, __FUNCTION__))->typed.type);
tree elem_size = TYPE_SIZE (elemtype)((tree_class_check ((elemtype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3345, __FUNCTION__))->type_common.size);
gcc_assert (elem_size && tree_fits_shwi_p (elem_size))((void)(!(elem_size && tree_fits_shwi_p (elem_size)) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3346, __FUNCTION__), 0 : 0));
HOST_WIDE_INTlong el_size = tree_to_shwi (elem_size);
gcc_assert (el_size > 0)((void)(!(el_size > 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3348, __FUNCTION__), 0 : 0));

tree minidx = TYPE_MIN_VALUE (TYPE_DOMAIN (root->type))((tree_check5 ((((tree_check ((root->type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3350, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3350, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
);
gcc_assert (TREE_CODE (minidx) == INTEGER_CST)((void)(!(((enum tree_code) (minidx)->base.code) == INTEGER_CST
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3351, __FUNCTION__), 0 : 0));
tree maxidx = TYPE_MAX_VALUE (TYPE_DOMAIN (root->type))((tree_check5 ((((tree_check ((root->type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3352, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3352, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
);
/* Skip (some) zero-length arrays; others have MAXIDX == MINIDX - 1.  */
if (!maxidx)
 goto out;
gcc_assert (TREE_CODE (maxidx) == INTEGER_CST)((void)(!(((enum tree_code) (maxidx)->base.code) == INTEGER_CST
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3356, __FUNCTION__), 0 : 0));
tree domain = TYPE_DOMAIN (root->type)((tree_check ((root->type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3357, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
);
/* MINIDX and MAXIDX are inclusive, and must be interpreted in
  DOMAIN (e.g. signed int, whereas min/max may be size_int).  */
offset_int idx = wi::to_offset (minidx);
offset_int max = wi::to_offset (maxidx);
if (!TYPE_UNSIGNED (domain)((tree_class_check ((domain), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3362, __FUNCTION__))->base.u.bits.unsigned_flag))
 {
   idx = wi::sext (idx, TYPE_PRECISION (domain)((tree_class_check ((domain), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3364, __FUNCTION__))->type_common.precision));
   max = wi::sext (max, TYPE_PRECISION (domain)((tree_class_check ((domain), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3365, __FUNCTION__))->type_common.precision));
 }
for (HOST_WIDE_INTlong pos = root->offset;
    idx <= max;
    pos += el_size, ++idx)
 {
   enum total_sra_field_state
     state = total_should_skip_creating_access (root,
					 &last_seen_sibling,
					 elemtype, pos,
					 el_size);
   switch (state)
     {
     case TOTAL_FLD_FAILED:
return false;
     case TOTAL_FLD_DONE:
continue;
     case TOTAL_FLD_CREATE:
break;
     default:
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3385, __FUNCTION__));
     }

   struct access **p = (last_seen_sibling
		 ? &last_seen_sibling->next_sibling
		 : &root->first_child);
   tree nref = build4 (ARRAY_REF, elemtype, root->expr,
		wide_int_to_tree (domain, idx),
		NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
   struct access *new_child
     = create_total_access_and_reshape (root, pos, el_size, elemtype,
				 nref, p);
   if (!new_child)
     return false;

   if (!is_gimple_reg_type (elemtype)
&& !totally_scalarize_subtree (new_child))
     return false;
   last_seen_sibling = new_child;
 }
    }
    break;
  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3408, __FUNCTION__));
  }

out:
return true;
3413}

3415/* Go through all accesses collected throughout the (intraprocedural) analysis
 stage, exclude overlapping ones, identify representatives and build trees
 out of them, making decisions about scalarization on the way.  Return true
 iff there are any to-be-scalarized variables after this stage. */

3420static bool
3421analyze_all_variable_accesses (void)
3422{
int res = 0;
bitmap tmp = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
bitmap_iterator bi;
unsigned i;

bitmap_copy (tmp, candidate_bitmap);
EXECUTE_IF_SET_IN_BITMAP (tmp, 0, i, bi)for (bmp_iter_set_init (&(bi), (tmp), (0), &(i)); bmp_iter_set
 (&(bi), &(i)); bmp_iter_next (&(bi), &(i)))
1
Loop condition is true.  Entering loop body→
  {
    tree var = candidate (i);
    struct access *access;

    access = sort_and_splice_var_accesses (var);
2
←
Calling 'sort_and_splice_var_accesses'→
    if (!access || !build_access_trees (access))
disqualify_candidate (var,
	      "No or inhibitingly overlapping accesses.");
  }

propagate_all_subaccesses ();

bool optimize_speed_p = !optimize_function_for_size_p (cfun(cfun + 0));
/* If the user didn't set PARAM_SRA_MAX_SCALARIZATION_SIZE_<...>,
   fall back to a target default.  */
unsigned HOST_WIDE_INTlong max_scalarization_size
  = get_move_ratio (optimize_speed_p) * UNITS_PER_WORD(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 8 : 4);

if (optimize_speed_p)
  {
    if (OPTION_SET_P (param_sra_max_scalarization_size_speed)global_options_set.x_param_sra_max_scalarization_size_speed)
max_scalarization_size = param_sra_max_scalarization_size_speedglobal_options.x_param_sra_max_scalarization_size_speed;
  }
else
  {
    if (OPTION_SET_P (param_sra_max_scalarization_size_size)global_options_set.x_param_sra_max_scalarization_size_size)
max_scalarization_size = param_sra_max_scalarization_size_sizeglobal_options.x_param_sra_max_scalarization_size_size;
  }
max_scalarization_size *= BITS_PER_UNIT(8);

EXECUTE_IF_SET_IN_BITMAP (candidate_bitmap, 0, i, bi)for (bmp_iter_set_init (&(bi), (candidate_bitmap), (0), &
(i)); bmp_iter_set (&(bi), &(i)); bmp_iter_next (&
(bi), &(i)))
  if (bitmap_bit_p (should_scalarize_away_bitmap, i)
&& !bitmap_bit_p (cannot_scalarize_away_bitmap, i))
    {
tree var = candidate (i);
if (!VAR_P (var)(((enum tree_code) (var)->base.code) == VAR_DECL))
 continue;

if (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (var))((tree_class_check ((((contains_struct_check ((var), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3468, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3468, __FUNCTION__))->type_common.size)) > max_scalarization_size)
 {
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
fprintf (dump_file, "Too big to totally scalarize: ");
print_generic_expr (dump_file, var);
fprintf (dump_file, " (UID: %u)\n", DECL_UID (var)((contains_struct_check ((var), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3474, __FUNCTION__))->decl_minimal.uid));
     }
   continue;
 }

bool all_types_ok = true;
for (struct access *access = get_first_repr_for_decl (var);
    access;
    access = access->next_grp)
 if (!can_totally_scalarize_forest_p (access)
     || !scalarizable_type_p (access->type, constant_decl_p (var)))
   {
     all_types_ok = false;
     break;
   }
if (!all_types_ok)
 continue;

if (dump_file && (dump_flags & TDF_DETAILS))
 {
   fprintf (dump_file, "Will attempt to totally scalarize ");
   print_generic_expr (dump_file, var);
   fprintf (dump_file, " (UID: %u): \n", DECL_UID (var)((contains_struct_check ((var), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3496, __FUNCTION__))->decl_minimal.uid));
 }
bool scalarized = true;
for (struct access *access = get_first_repr_for_decl (var);
    access;
    access = access->next_grp)
 if (!is_gimple_reg_type (access->type)
     && !totally_scalarize_subtree (access))
   {
     scalarized = false;
     break;
   }

if (scalarized)
 for (struct access *access = get_first_repr_for_decl (var);
      access;
      access = access->next_grp)
   access->grp_total_scalarization = true;
    }

if (flag_checkingglobal_options.x_flag_checking)
  verify_all_sra_access_forests ();

bitmap_copy (tmp, candidate_bitmap);
EXECUTE_IF_SET_IN_BITMAP (tmp, 0, i, bi)for (bmp_iter_set_init (&(bi), (tmp), (0), &(i)); bmp_iter_set
 (&(bi), &(i)); bmp_iter_next (&(bi), &(i)))
  {
    tree var = candidate (i);
    struct access *access = get_first_repr_for_decl (var);

    if (analyze_access_trees (access))
{
 res++;
 if (dump_file && (dump_flags & TDF_DETAILS))
   {
     fprintf (dump_file, "\nAccess trees for ");
     print_generic_expr (dump_file, var);
     fprintf (dump_file, " (UID: %u): \n", DECL_UID (var)((contains_struct_check ((var), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3532, __FUNCTION__))->decl_minimal.uid));
     dump_access_tree (dump_file, access);
     fprintf (dump_file, "\n");
   }
}
    else
disqualify_candidate (var, "No scalar replacements to be created.");
  }

BITMAP_FREE (tmp)((void) (bitmap_obstack_free ((bitmap) tmp), (tmp) = (bitmap)
 nullptr));

if (res)
  {
    statistics_counter_event (cfun(cfun + 0), "Scalarized aggregates", res);
    return true;
  }
else
  return false;
3550}

3552/* Generate statements copying scalar replacements of accesses within a subtree
 into or out of AGG.  ACCESS, all its children, siblings and their children
 are to be processed.  AGG is an aggregate type expression (can be a
 declaration but does not have to be, it can for example also be a mem_ref or
 a series of handled components).  TOP_OFFSET is the offset of the processed
 subtree which has to be subtracted from offsets of individual accesses to
 get corresponding offsets for AGG.  If CHUNK_SIZE is non-null, copy only
 replacements in the interval <start_offset, start_offset + chunk_size>,
 otherwise copy all.  GSI is a statement iterator used to place the new
 statements.  WRITE should be true when the statements should write from AGG
 to the replacement and false if vice versa.  if INSERT_AFTER is true, new
 statements will be added after the current statement in GSI, they will be
 added before the statement otherwise.  */

3566static void
3567generate_subtree_copies (struct access *access, tree agg,
	 HOST_WIDE_INTlong top_offset,
	 HOST_WIDE_INTlong start_offset, HOST_WIDE_INTlong chunk_size,
	 gimple_stmt_iterator *gsi, bool write,
	 bool insert_after, location_t loc)
3572{
/* Never write anything into constant pool decls.  See PR70602.  */
if (!write && constant_decl_p (agg))
  return;
do
  {
    if (chunk_size && access->offset >= start_offset + chunk_size)
return;

    if (access->grp_to_be_replaced
 && (chunk_size == 0
     || access->offset + access->size > start_offset))
{
 tree expr, repl = get_access_replacement (access);
 gassign *stmt;

 expr = build_ref_for_model (loc, agg, access->offset - top_offset,
		      access, gsi, insert_after);

 if (write)
   {
     if (access->grp_partial_lhs)
expr = force_gimple_operand_gsi (gsi, expr, true, NULL_TREE(tree) nullptr,
				 !insert_after,
				 insert_after ? GSI_NEW_STMT
				 : GSI_SAME_STMT);
     stmt = gimple_build_assign (repl, expr);
   }
 else
   {
     suppress_warning (repl /* Be more selective! */);
     if (access->grp_partial_lhs)
repl = force_gimple_operand_gsi (gsi, repl, true, NULL_TREE(tree) nullptr,
				 !insert_after,
				 insert_after ? GSI_NEW_STMT
				 : GSI_SAME_STMT);
     stmt = gimple_build_assign (expr, repl);
   }
 gimple_set_location (stmt, loc);

 if (insert_after)
   gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
 else
   gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
 update_stmt (stmt);
 sra_stats.subtree_copies++;
}
    else if (write
      && access->grp_to_be_debug_replaced
      && (chunk_size == 0
   || access->offset + access->size > start_offset))
{
 gdebug *ds;
 tree drhs = build_debug_ref_for_model (loc, agg,
				 access->offset - top_offset,
				 access);
 ds = gimple_build_debug_bind (get_access_replacement (access),
			drhs, gsi_stmt (*gsi));
 if (insert_after)
   gsi_insert_after (gsi, ds, GSI_NEW_STMT);
 else
   gsi_insert_before (gsi, ds, GSI_SAME_STMT);
}

    if (access->first_child)
generate_subtree_copies (access->first_child, agg, top_offset,
		 start_offset, chunk_size, gsi,
		 write, insert_after, loc);

    access = access->next_sibling;
  }
while (access);
3644}

3646/* Assign zero to all scalar replacements in an access subtree.  ACCESS is the
 root of the subtree to be processed.  GSI is the statement iterator used
 for inserting statements which are added after the current statement if
 INSERT_AFTER is true or before it otherwise.  */

3651static void
3652init_subtree_with_zero (struct access *access, gimple_stmt_iterator *gsi,
	bool insert_after, location_t loc)

3655{
struct access *child;

if (access->grp_to_be_replaced)
  {
    gassign *stmt;

    stmt = gimple_build_assign (get_access_replacement (access),
		  build_zero_cst (access->type));
    if (insert_after)
gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
    else
gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
    update_stmt (stmt);
    gimple_set_location (stmt, loc);
  }
else if (access->grp_to_be_debug_replaced)
  {
    gdebug *ds
= gimple_build_debug_bind (get_access_replacement (access),
		   build_zero_cst (access->type),
		   gsi_stmt (*gsi));
    if (insert_after)
gsi_insert_after (gsi, ds, GSI_NEW_STMT);
    else
gsi_insert_before (gsi, ds, GSI_SAME_STMT);
  }

for (child = access->first_child; child; child = child->next_sibling)
  init_subtree_with_zero (child, gsi, insert_after, loc);
3685}

3687/* Clobber all scalar replacements in an access subtree.  ACCESS is the
 root of the subtree to be processed.  GSI is the statement iterator used
 for inserting statements which are added after the current statement if
 INSERT_AFTER is true or before it otherwise.  */

3692static void
3693clobber_subtree (struct access *access, gimple_stmt_iterator *gsi,
bool insert_after, location_t loc)

3696{
struct access *child;

if (access->grp_to_be_replaced)
  {
    tree rep = get_access_replacement (access);
    tree clobber = build_clobber (access->type);
    gimple *stmt = gimple_build_assign (rep, clobber);

    if (insert_after)
gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
    else
gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
    update_stmt (stmt);
    gimple_set_location (stmt, loc);
  }

for (child = access->first_child; child; child = child->next_sibling)
  clobber_subtree (child, gsi, insert_after, loc);
3715}

3717/* Search for an access representative for the given expression EXPR and
 return it or NULL if it cannot be found.  */

3720static struct access *
3721get_access_for_expr (tree expr)
3722{
poly_int64 poffset, psize, pmax_size;
HOST_WIDE_INTlong offset, max_size;
tree base;
bool reverse;

/* FIXME: This should not be necessary but Ada produces V_C_Es with a type of
   a different size than the size of its argument and we need the latter
   one.  */
if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == VIEW_CONVERT_EXPR)
  expr = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3732, __FUNCTION__)))));

base = get_ref_base_and_extent (expr, &poffset, &psize, &pmax_size,
		  &reverse);
if (!known_size_p (pmax_size)
    || !pmax_size.is_constant (&max_size)
    || !poffset.is_constant (&offset)
    || !DECL_P (base)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (base)->base.code))] == tcc_declaration))
  return NULLnullptr;

if (tree basesize = DECL_SIZE (base)((contains_struct_check ((base), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3742, __FUNCTION__))->decl_common.size))
  {
    poly_int64 sz;
    if (offset < 0
 || !poly_int_tree_p (basesize, &sz)
 || known_le (sz, offset)(!maybe_lt (offset, sz)))
return NULLnullptr;
  }

if (max_size == 0
    || !bitmap_bit_p (candidate_bitmap, DECL_UID (base)((contains_struct_check ((base), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3752, __FUNCTION__))->decl_minimal.uid)))
  return NULLnullptr;

return get_var_base_offset_size_access (base, offset, max_size);
3756}

3758/* Replace the expression EXPR with a scalar replacement if there is one and
 generate other statements to do type conversion or subtree copying if
 necessary.  GSI is used to place newly created statements, WRITE is true if
 the expression is being written to (it is on a LHS of a statement or output
 in an assembly statement).  */

3764static bool
3765sra_modify_expr (tree *expr, gimple_stmt_iterator *gsi, bool write)
3766{
location_t loc;
struct access *access;
tree type, bfr, orig_expr;
bool partial_cplx_access = false;

if (TREE_CODE (*expr)((enum tree_code) (*expr)->base.code) == BIT_FIELD_REF)
  {
    bfr = *expr;
    expr = &TREE_OPERAND (*expr, 0)(*((const_cast<tree*> (tree_operand_check ((*expr), (0)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3775, __FUNCTION__)))));
  }
else
  bfr = NULL_TREE(tree) nullptr;

if (TREE_CODE (*expr)((enum tree_code) (*expr)->base.code) == REALPART_EXPR || TREE_CODE (*expr)((enum tree_code) (*expr)->base.code) == IMAGPART_EXPR)
  {
    expr = &TREE_OPERAND (*expr, 0)(*((const_cast<tree*> (tree_operand_check ((*expr), (0)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3782, __FUNCTION__)))));
    partial_cplx_access = true;
  }
access = get_access_for_expr (*expr);
if (!access)
  return false;
type = TREE_TYPE (*expr)((contains_struct_check ((*expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3788, __FUNCTION__))->typed.type);
orig_expr = *expr;

loc = gimple_location (gsi_stmt (*gsi));
gimple_stmt_iterator alt_gsi = gsi_none ();
if (write && stmt_ends_bb_p (gsi_stmt (*gsi)))
  {
    alt_gsi = gsi_start_edge (single_non_eh_succ (gsi_bb (*gsi)));
    gsi = &alt_gsi;
  }

if (access->grp_to_be_replaced)
  {
    tree repl = get_access_replacement (access);
    /* If we replace a non-register typed access simply use the original
       access expression to extract the scalar component afterwards.
This happens if scalarizing a function return value or parameter
like in gcc.c-torture/execute/20041124-1.c, 20050316-1.c and
gcc.c-torture/compile/20011217-1.c.

       We also want to use this when accessing a complex or vector which can
       be accessed as a different type too, potentially creating a need for
       type conversion (see PR42196) and when scalarized unions are involved
       in assembler statements (see PR42398).  */
    if (!bfr && !useless_type_conversion_p (type, access->type))
{
 tree ref;

 ref = build_ref_for_model (loc, orig_expr, 0, access, gsi, false);

 if (partial_cplx_access)
   {
   /* VIEW_CONVERT_EXPRs in partial complex access are always fine in
      the case of a write because in such case the replacement cannot
      be a gimple register.  In the case of a load, we have to
      differentiate in between a register an non-register
      replacement.  */
     tree t = build1 (VIEW_CONVERT_EXPR, type, repl);
     gcc_checking_assert (!write || access->grp_partial_lhs)((void)(!(!write || access->grp_partial_lhs) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3826, __FUNCTION__), 0 : 0));
     if (!access->grp_partial_lhs)
{
  tree tmp = make_ssa_name (type);
  gassign *stmt = gimple_build_assign (tmp, t);
  /* This is always a read. */
  gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
  t = tmp;
}
     *expr = t;
   }
 else if (write)
   {
     gassign *stmt;

     if (access->grp_partial_lhs)
ref = force_gimple_operand_gsi (gsi, ref, true, NULL_TREE(tree) nullptr,
				 false, GSI_NEW_STMT);
     stmt = gimple_build_assign (repl, ref);
     gimple_set_location (stmt, loc);
     gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
   }
 else
   {
     gassign *stmt;

     if (access->grp_partial_lhs)
repl = force_gimple_operand_gsi (gsi, repl, true, NULL_TREE(tree) nullptr,
				 true, GSI_SAME_STMT);
     stmt = gimple_build_assign (ref, repl);
     gimple_set_location (stmt, loc);
     gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
   }
}
    else
{
 /* If we are going to replace a scalar field in a structure with
    reverse storage order by a stand-alone scalar, we are going to
    effectively byte-swap the scalar and we also need to byte-swap
    the portion of it represented by the bit-field.  */
 if (bfr && REF_REVERSE_STORAGE_ORDER (bfr)((tree_check2 ((bfr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3866, __FUNCTION__, (BIT_FIELD_REF), (MEM_REF)))->base.default_def_flag
))
   {
     REF_REVERSE_STORAGE_ORDER (bfr)((tree_check2 ((bfr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3868, __FUNCTION__, (BIT_FIELD_REF), (MEM_REF)))->base.default_def_flag
) = 0;
     TREE_OPERAND (bfr, 2)(*((const_cast<tree*> (tree_operand_check ((bfr), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3869, __FUNCTION__)))))
= size_binop (MINUS_EXPR, TYPE_SIZE (TREE_TYPE (repl)),size_binop_loc (((location_t) 0), MINUS_EXPR, ((tree_class_check
 ((((contains_struct_check ((repl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3870, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3870, __FUNCTION__))->type_common.size), size_binop_loc (
((location_t) 0), PLUS_EXPR, (*((const_cast<tree*> (tree_operand_check
 ((bfr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3871, __FUNCTION__))))), (*((const_cast<tree*> (tree_operand_check
 ((bfr), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3872, __FUNCTION__)))))))
	      size_binop (PLUS_EXPR, TREE_OPERAND (bfr, 1),size_binop_loc (((location_t) 0), MINUS_EXPR, ((tree_class_check
 ((((contains_struct_check ((repl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3870, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3870, __FUNCTION__))->type_common.size), size_binop_loc (
((location_t) 0), PLUS_EXPR, (*((const_cast<tree*> (tree_operand_check
 ((bfr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3871, __FUNCTION__))))), (*((const_cast<tree*> (tree_operand_check
 ((bfr), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3872, __FUNCTION__)))))))
				     TREE_OPERAND (bfr, 2)))size_binop_loc (((location_t) 0), MINUS_EXPR, ((tree_class_check
 ((((contains_struct_check ((repl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3870, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3870, __FUNCTION__))->type_common.size), size_binop_loc (
((location_t) 0), PLUS_EXPR, (*((const_cast<tree*> (tree_operand_check
 ((bfr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3871, __FUNCTION__))))), (*((const_cast<tree*> (tree_operand_check
 ((bfr), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3872, __FUNCTION__)))))));
   }

 *expr = repl;
}

    sra_stats.exprs++;
  }
else if (write && access->grp_to_be_debug_replaced)
  {
    gdebug *ds = gimple_build_debug_bind (get_access_replacement (access),
			    NULL_TREE(tree) nullptr,
			    gsi_stmt (*gsi));
    gsi_insert_after (gsi, ds, GSI_NEW_STMT);
  }

if (access->first_child && !TREE_READONLY (access->base)((non_type_check ((access->base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3888, __FUNCTION__))->base.readonly_flag))
  {
    HOST_WIDE_INTlong start_offset, chunk_size;
    if (bfr
 && tree_fits_uhwi_p (TREE_OPERAND (bfr, 1)(*((const_cast<tree*> (tree_operand_check ((bfr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3892, __FUNCTION__))))))
 && tree_fits_uhwi_p (TREE_OPERAND (bfr, 2)(*((const_cast<tree*> (tree_operand_check ((bfr), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3893, __FUNCTION__)))))))
{
 chunk_size = tree_to_uhwi (TREE_OPERAND (bfr, 1)(*((const_cast<tree*> (tree_operand_check ((bfr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3895, __FUNCTION__))))));
 start_offset = access->offset
   + tree_to_uhwi (TREE_OPERAND (bfr, 2)(*((const_cast<tree*> (tree_operand_check ((bfr), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3897, __FUNCTION__))))));
}
    else
start_offset = chunk_size = 0;

    generate_subtree_copies (access->first_child, orig_expr, access->offset,
	       start_offset, chunk_size, gsi, write, write,
	       loc);
  }
return true;
3907}

3909/* Where scalar replacements of the RHS have been written to when a replacement
 of a LHS of an assigments cannot be direclty loaded from a replacement of
 the RHS. */
3912enum unscalarized_data_handling { SRA_UDH_NONE,  /* Nothing done so far. */
		  SRA_UDH_RIGHT, /* Data flushed to the RHS. */
		  SRA_UDH_LEFT }; /* Data flushed to the LHS. */

3916struct subreplacement_assignment_data
3917{
/* Offset of the access representing the lhs of the assignment.  */
HOST_WIDE_INTlong left_offset;

/* LHS and RHS of the original assignment.  */
tree assignment_lhs, assignment_rhs;

/* Access representing the rhs of the whole assignment.  */
struct access *top_racc;

/* Stmt iterator used for statement insertions after the original assignment.
 It points to the main GSI used to traverse a BB during function body
 modification.  */
gimple_stmt_iterator *new_gsi;

/* Stmt iterator used for statement insertions before the original
 assignment.  Keeps on pointing to the original statement.  */
gimple_stmt_iterator old_gsi;

/* Location of the assignment.   */
location_t loc;

/* Keeps the information whether we have needed to refresh replacements of
 the LHS and from which side of the assignments this takes place.  */
enum unscalarized_data_handling refreshed;
3942};

3944/* Store all replacements in the access tree rooted in TOP_RACC either to their
 base aggregate if there are unscalarized data or directly to LHS of the
 statement that is pointed to by GSI otherwise.  */

3948static void
3949handle_unscalarized_data_in_subtree (struct subreplacement_assignment_data *sad)
3950{
tree src;
/* If the RHS is a load from a constant, we do not need to (and must not)
   flush replacements to it and can use it directly as if we did.  */
if (TREE_READONLY (sad->top_racc->base)((non_type_check ((sad->top_racc->base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 3954, __FUNCTION__))->base.readonly_flag))
  {
    sad->refreshed = SRA_UDH_RIGHT;
    return;
  }
if (sad->top_racc->grp_unscalarized_data)
  {
    src = sad->assignment_rhs;
    sad->refreshed = SRA_UDH_RIGHT;
  }
else
  {
    src = sad->assignment_lhs;
    sad->refreshed = SRA_UDH_LEFT;
  }
generate_subtree_copies (sad->top_racc->first_child, src,
	   sad->top_racc->offset, 0, 0,
	   &sad->old_gsi, false, false, sad->loc);
3972}

3974/* Try to generate statements to load all sub-replacements in an access subtree
 formed by children of LACC from scalar replacements in the SAD->top_racc
 subtree.  If that is not possible, refresh the SAD->top_racc base aggregate
 and load the accesses from it.  */

3979static void
3980load_assign_lhs_subreplacements (struct access *lacc,
		 struct subreplacement_assignment_data *sad)
3982{
for (lacc = lacc->first_child; lacc; lacc = lacc->next_sibling)
  {
    HOST_WIDE_INTlong offset;
    offset = lacc->offset - sad->left_offset + sad->top_racc->offset;

    if (lacc->grp_to_be_replaced)
{
 struct access *racc;
 gassign *stmt;
 tree rhs;

 racc = find_access_in_subtree (sad->top_racc, offset, lacc->size);
 if (racc && racc->grp_to_be_replaced)
   {
     rhs = get_access_replacement (racc);
     if (!useless_type_conversion_p (lacc->type, racc->type))
rhs = fold_build1_loc (sad->loc, VIEW_CONVERT_EXPR,
		       lacc->type, rhs);

     if (racc->grp_partial_lhs && lacc->grp_partial_lhs)
rhs = force_gimple_operand_gsi (&sad->old_gsi, rhs, true,
				NULL_TREE(tree) nullptr, true, GSI_SAME_STMT);
   }
 else
   {
     /* No suitable access on the right hand side, need to load from
 the aggregate.  See if we have to update it first... */
     if (sad->refreshed == SRA_UDH_NONE)
handle_unscalarized_data_in_subtree (sad);

     if (sad->refreshed == SRA_UDH_LEFT)
rhs = build_ref_for_model (sad->loc, sad->assignment_lhs,
			   lacc->offset - sad->left_offset,
			   lacc, sad->new_gsi, true);
     else
rhs = build_ref_for_model (sad->loc, sad->assignment_rhs,
			   lacc->offset - sad->left_offset,
			   lacc, sad->new_gsi, true);
     if (lacc->grp_partial_lhs)
rhs = force_gimple_operand_gsi (sad->new_gsi,
				rhs, true, NULL_TREE(tree) nullptr,
				false, GSI_NEW_STMT);
   }

 stmt = gimple_build_assign (get_access_replacement (lacc), rhs);
 gsi_insert_after (sad->new_gsi, stmt, GSI_NEW_STMT);
 gimple_set_location (stmt, sad->loc);
 update_stmt (stmt);
 sra_stats.subreplacements++;
}
    else
{
 if (sad->refreshed == SRA_UDH_NONE
     && lacc->grp_read && !lacc->grp_covered)
   handle_unscalarized_data_in_subtree (sad);

 if (lacc && lacc->grp_to_be_debug_replaced)
   {
     gdebug *ds;
     tree drhs;
     struct access *racc = find_access_in_subtree (sad->top_racc,
					    offset,
					    lacc->size);

     if (racc && racc->grp_to_be_replaced)
{
  if (racc->grp_write || constant_decl_p (racc->base))
    drhs = get_access_replacement (racc);
  else
    drhs = NULLnullptr;
}
     else if (sad->refreshed == SRA_UDH_LEFT)
drhs = build_debug_ref_for_model (sad->loc, lacc->base,
				  lacc->offset, lacc);
     else if (sad->refreshed == SRA_UDH_RIGHT)
drhs = build_debug_ref_for_model (sad->loc, sad->top_racc->base,
				  offset, lacc);
     else
drhs = NULL_TREE(tree) nullptr;
     if (drhs
  && !useless_type_conversion_p (lacc->type, TREE_TYPE (drhs)((contains_struct_check ((drhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4063, __FUNCTION__))->typed.type)))
drhs = fold_build1_loc (sad->loc, VIEW_CONVERT_EXPR,
			lacc->type, drhs);
     ds = gimple_build_debug_bind (get_access_replacement (lacc),
			    drhs, gsi_stmt (sad->old_gsi));
     gsi_insert_after (sad->new_gsi, ds, GSI_NEW_STMT);
   }
}

    if (lacc->first_child)
load_assign_lhs_subreplacements (lacc, sad);
  }
4075}

4077/* Result code for SRA assignment modification.  */
4078enum assignment_mod_result { SRA_AM_NONE,       /* nothing done for the stmt */
	     SRA_AM_MODIFIED,  /* stmt changed but not
				  removed */
	     SRA_AM_REMOVED };  /* stmt eliminated */

4083/* Modify assignments with a CONSTRUCTOR on their RHS.  STMT contains a pointer
 to the assignment and GSI is the statement iterator pointing at it.  Returns
 the same values as sra_modify_assign.  */

4087static enum assignment_mod_result
4088sra_modify_constructor_assign (gimple *stmt, gimple_stmt_iterator *gsi)
4089{
tree lhs = gimple_assign_lhs (stmt);
struct access *acc = get_access_for_expr (lhs);
if (!acc)
  return SRA_AM_NONE;
location_t loc = gimple_location (stmt);

if (gimple_clobber_p (stmt))
  {
    /* Clobber the replacement variable.  */
    clobber_subtree (acc, gsi, !acc->grp_covered, loc);
    /* Remove clobbers of fully scalarized variables, they are dead.  */
    if (acc->grp_covered)
{
 unlink_stmt_vdef (stmt);
 gsi_remove (gsi, true);
 release_defs (stmt);
 return SRA_AM_REMOVED;
}
    else
return SRA_AM_MODIFIED;
  }

if (CONSTRUCTOR_NELTS (gimple_assign_rhs1 (stmt))(vec_safe_length (((tree_check ((gimple_assign_rhs1 (stmt)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4112, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))) > 0)
  {
    /* I have never seen this code path trigger but if it can happen the
following should handle it gracefully.  */
    if (access_has_children_p (acc))
generate_subtree_copies (acc->first_child, lhs, acc->offset, 0, 0, gsi,
		 true, true, loc);
    return SRA_AM_MODIFIED;
  }

if (acc->grp_covered)
  {
    init_subtree_with_zero (acc, gsi, false, loc);
    unlink_stmt_vdef (stmt);
    gsi_remove (gsi, true);
    release_defs (stmt);
    return SRA_AM_REMOVED;
  }
else
  {
    init_subtree_with_zero (acc, gsi, true, loc);
    return SRA_AM_MODIFIED;
  }
4135}

4137/* Create and return a new suitable default definition SSA_NAME for RACC which
 is an access describing an uninitialized part of an aggregate that is being
 loaded.  REG_TREE is used instead of the actual RACC type if that is not of
 a gimple register type.  */

4142static tree
4143get_repl_default_def_ssa_name (struct access *racc, tree reg_type)
4144{
gcc_checking_assert (!racc->grp_to_be_replaced((void)(!(!racc->grp_to_be_replaced && !racc->grp_to_be_debug_replaced
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4146, __FUNCTION__), 0 : 0))
       && !racc->grp_to_be_debug_replaced)((void)(!(!racc->grp_to_be_replaced && !racc->grp_to_be_debug_replaced
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4146, __FUNCTION__), 0 : 0));
if (!racc->replacement_decl)
  racc->replacement_decl = create_access_replacement (racc, reg_type);
return get_or_create_ssa_default_def (cfun(cfun + 0), racc->replacement_decl);
4150}


4153/* Generate statements to call .DEFERRED_INIT to initialize scalar replacements
 of accesses within a subtree ACCESS; all its children, siblings and their
 children are to be processed.
 GSI is a statement iterator used to place the new statements.  */
4157static void
4158generate_subtree_deferred_init (struct access *access,
		tree init_type,
		tree decl_name,
		gimple_stmt_iterator *gsi,
		location_t loc)
4163{
do
  {
    if (access->grp_to_be_replaced)
{
 tree repl = get_access_replacement (access);
 gimple *call
   = gimple_build_call_internal (IFN_DEFERRED_INIT, 3,
			  TYPE_SIZE_UNIT (TREE_TYPE (repl))((tree_class_check ((((contains_struct_check ((repl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4171, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4171, __FUNCTION__))->type_common.size_unit),
			  init_type, decl_name);
 gimple_call_set_lhs (call, repl);
 gsi_insert_before (gsi, call, GSI_SAME_STMT);
 update_stmt (call);
 gimple_set_location (call, loc);
 sra_stats.subtree_deferred_init++;
}
    if (access->first_child)
generate_subtree_deferred_init (access->first_child, init_type,
			decl_name, gsi, loc);

    access = access ->next_sibling;
  }
while (access);
4186}

4188/* For a call to .DEFERRED_INIT:
 var = .DEFERRED_INIT (size_of_var, init_type, name_of_var);
 examine the LHS variable VAR and replace it with a scalar replacement if
 there is one, also replace the RHS call to a call to .DEFERRED_INIT of
 the corresponding scalar relacement variable.  Examine the subtree and
 do the scalar replacements in the subtree too.  STMT is the call, GSI is
 the statment iterator to place newly created statement.  */

4196static enum assignment_mod_result
4197sra_modify_deferred_init (gimple *stmt, gimple_stmt_iterator *gsi)
4198{
tree lhs = gimple_call_lhs (stmt);
tree init_type = gimple_call_arg (stmt, 1);
tree decl_name = gimple_call_arg (stmt, 2);

struct access *lhs_access = get_access_for_expr (lhs);
if (!lhs_access)
  return SRA_AM_NONE;

location_t loc = gimple_location (stmt);

if (lhs_access->grp_to_be_replaced)
  {
    tree lhs_repl = get_access_replacement (lhs_access);
    gimple_call_set_lhs (stmt, lhs_repl);
    tree arg0_repl = TYPE_SIZE_UNIT (TREE_TYPE (lhs_repl))((tree_class_check ((((contains_struct_check ((lhs_repl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4213, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4213, __FUNCTION__))->type_common.size_unit);
    gimple_call_set_arg (stmt, 0, arg0_repl);
    sra_stats.deferred_init++;
    gcc_assert (!lhs_access->first_child)((void)(!(!lhs_access->first_child) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4216, __FUNCTION__), 0 : 0));
    return SRA_AM_MODIFIED;
  }

if (lhs_access->first_child)
  generate_subtree_deferred_init (lhs_access->first_child,
		    init_type, decl_name, gsi, loc);
if (lhs_access->grp_covered)
  {
    unlink_stmt_vdef (stmt);
    gsi_remove (gsi, true);
    release_defs (stmt);
    return SRA_AM_REMOVED;
  }

return SRA_AM_MODIFIED;
4232}

4234/* Examine both sides of the assignment statement pointed to by STMT, replace
 them with a scalare replacement if there is one and generate copying of
 replacements if scalarized aggregates have been used in the assignment.  GSI
 is used to hold generated statements for type conversions and subtree
 copying.  */

4240static enum assignment_mod_result
4241sra_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi)
4242{
struct access *lacc, *racc;
tree lhs, rhs;
bool modify_this_stmt = false;
bool force_gimple_rhs = false;
location_t loc;
gimple_stmt_iterator orig_gsi = *gsi;

if (!gimple_assign_single_p (stmt))
  return SRA_AM_NONE;
lhs = gimple_assign_lhs (stmt);
rhs = gimple_assign_rhs1 (stmt);

if (TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) == CONSTRUCTOR)
  return sra_modify_constructor_assign (stmt, gsi);

if (TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) == REALPART_EXPR || TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == REALPART_EXPR
    || TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) == IMAGPART_EXPR || TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == IMAGPART_EXPR
    || TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) == BIT_FIELD_REF || TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == BIT_FIELD_REF)
  {
    modify_this_stmt = sra_modify_expr (gimple_assign_rhs1_ptr (stmt),
			  gsi, false);
    modify_this_stmt |= sra_modify_expr (gimple_assign_lhs_ptr (stmt),
			   gsi, true);
    return modify_this_stmt ? SRA_AM_MODIFIED : SRA_AM_NONE;
  }

lacc = get_access_for_expr (lhs);
racc = get_access_for_expr (rhs);
if (!lacc && !racc)
  return SRA_AM_NONE;
/* Avoid modifying initializations of constant-pool replacements.  */
if (racc && (racc->replacement_decl == lhs))
  return SRA_AM_NONE;

loc = gimple_location (stmt);
if (lacc && lacc->grp_to_be_replaced)
  {
    lhs = get_access_replacement (lacc);
    gimple_assign_set_lhs (stmt, lhs);
    modify_this_stmt = true;
    if (lacc->grp_partial_lhs)
force_gimple_rhs = true;
    sra_stats.exprs++;
  }

if (racc && racc->grp_to_be_replaced)
  {
    rhs = get_access_replacement (racc);
    modify_this_stmt = true;
    if (racc->grp_partial_lhs)
force_gimple_rhs = true;
    sra_stats.exprs++;
  }
else if (racc
  && !racc->grp_unscalarized_data
  && !racc->grp_unscalarizable_region
  && TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == SSA_NAME
  && !access_has_replacements_p (racc))
  {
    rhs = get_repl_default_def_ssa_name (racc, TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4302, __FUNCTION__))->typed.type));
    modify_this_stmt = true;
    sra_stats.exprs++;
  }

if (modify_this_stmt
    && !useless_type_conversion_p (TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4308, __FUNCTION__))->typed.type), TREE_TYPE (rhs)((contains_struct_check ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4308, __FUNCTION__))->typed.type)))
  {
    /* If we can avoid creating a VIEW_CONVERT_EXPR, then do so.
??? This should move to fold_stmt which we simply should
call after building a VIEW_CONVERT_EXPR here.  */
    if (AGGREGATE_TYPE_P (TREE_TYPE (lhs))(((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4313, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE
 || (((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4313, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4313, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4313, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE
))
 && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (lhs))((tree_check4 ((((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4314, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4314, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag) == racc->reverse
 && !contains_bitfld_component_ref_p (lhs))
{
 lhs = build_ref_for_model (loc, lhs, 0, racc, gsi, false);
 gimple_assign_set_lhs (stmt, lhs);
}
    else if (lacc
      && AGGREGATE_TYPE_P (TREE_TYPE (rhs))(((enum tree_code) (((contains_struct_check ((rhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4321, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE
 || (((enum tree_code) (((contains_struct_check ((rhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4321, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4321, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4321, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE
))
      && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (rhs))((tree_check4 ((((contains_struct_check ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4322, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4322, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag) == lacc->reverse
      && !contains_vce_or_bfcref_p (rhs))
rhs = build_ref_for_model (loc, rhs, 0, lacc, gsi, false);

    if (!useless_type_conversion_p (TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4326, __FUNCTION__))->typed.type), TREE_TYPE (rhs)((contains_struct_check ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4326, __FUNCTION__))->typed.type)))
{
 rhs = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4328, __FUNCTION__))->typed.type), rhs);
 if (is_gimple_reg_type (TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4329, __FUNCTION__))->typed.type))
     && TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) != SSA_NAME)
   force_gimple_rhs = true;
}
  }

if (lacc && lacc->grp_to_be_debug_replaced)
  {
    tree dlhs = get_access_replacement (lacc);
    tree drhs = unshare_expr (rhs);
    if (!useless_type_conversion_p (TREE_TYPE (dlhs)((contains_struct_check ((dlhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4339, __FUNCTION__))->typed.type), TREE_TYPE (drhs)((contains_struct_check ((drhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4339, __FUNCTION__))->typed.type)))
{
 if (AGGREGATE_TYPE_P (TREE_TYPE (drhs))(((enum tree_code) (((contains_struct_check ((drhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4341, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE
 || (((enum tree_code) (((contains_struct_check ((drhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4341, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
 || ((enum tree_code) (((contains_struct_check ((drhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4341, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE
 || ((enum tree_code) (((contains_struct_check ((drhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4341, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE
))
     && !contains_vce_or_bfcref_p (drhs))
   drhs = build_debug_ref_for_model (loc, drhs, 0, lacc);
 if (drhs
     && !useless_type_conversion_p (TREE_TYPE (dlhs)((contains_struct_check ((dlhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4345, __FUNCTION__))->typed.type),
			     TREE_TYPE (drhs)((contains_struct_check ((drhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4346, __FUNCTION__))->typed.type)))
   drhs = fold_build1_loc (loc, VIEW_CONVERT_EXPR,
		    TREE_TYPE (dlhs)((contains_struct_check ((dlhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4348, __FUNCTION__))->typed.type), drhs);
}
    gdebug *ds = gimple_build_debug_bind (dlhs, drhs, stmt);
    gsi_insert_before (gsi, ds, GSI_SAME_STMT);
  }

/* From this point on, the function deals with assignments in between
   aggregates when at least one has scalar reductions of some of its
   components.  There are three possible scenarios: Both the LHS and RHS have
   to-be-scalarized components, 2) only the RHS has or 3) only the LHS has.

   In the first case, we would like to load the LHS components from RHS
   components whenever possible.  If that is not possible, we would like to
   read it directly from the RHS (after updating it by storing in it its own
   components).  If there are some necessary unscalarized data in the LHS,
   those will be loaded by the original assignment too.  If neither of these
   cases happen, the original statement can be removed.  Most of this is done
   by load_assign_lhs_subreplacements.

   In the second case, we would like to store all RHS scalarized components
   directly into LHS and if they cover the aggregate completely, remove the
   statement too.  In the third case, we want the LHS components to be loaded
   directly from the RHS (DSE will remove the original statement if it
   becomes redundant).

   This is a bit complex but manageable when types match and when unions do
   not cause confusion in a way that we cannot really load a component of LHS
   from the RHS or vice versa (the access representing this level can have
   subaccesses that are accessible only through a different union field at a
   higher level - different from the one used in the examined expression).
   Unions are fun.

   Therefore, I specially handle a fourth case, happening when there is a
   specific type cast or it is impossible to locate a scalarized subaccess on
   the other side of the expression.  If that happens, I simply "refresh" the
   RHS by storing in it is scalarized components leave the original statement
   there to do the copying and then load the scalar replacements of the LHS.
   This is what the first branch does.  */

if (modify_this_stmt
    || gimple_has_volatile_ops (stmt)
    || contains_vce_or_bfcref_p (rhs)
    || contains_vce_or_bfcref_p (lhs)
    || stmt_ends_bb_p (stmt))
  {
    /* No need to copy into a constant, it comes pre-initialized.  */
    if (access_has_children_p (racc) && !TREE_READONLY (racc->base)((non_type_check ((racc->base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4394, __FUNCTION__))->base.readonly_flag))
generate_subtree_copies (racc->first_child, rhs, racc->offset, 0, 0,
		 gsi, false, false, loc);
    if (access_has_children_p (lacc))
{
 gimple_stmt_iterator alt_gsi = gsi_none ();
 if (stmt_ends_bb_p (stmt))
   {
     alt_gsi = gsi_start_edge (single_non_eh_succ (gsi_bb (*gsi)));
     gsi = &alt_gsi;
   }
 generate_subtree_copies (lacc->first_child, lhs, lacc->offset, 0, 0,
		   gsi, true, true, loc);
}
    sra_stats.separate_lhs_rhs_handling++;

    /* This gimplification must be done after generate_subtree_copies,
lest we insert the subtree copies in the middle of the gimplified
sequence.  */
    if (force_gimple_rhs)
rhs = force_gimple_operand_gsi (&orig_gsi, rhs, true, NULL_TREE(tree) nullptr,
			true, GSI_SAME_STMT);
    if (gimple_assign_rhs1 (stmt) != rhs)
{
 modify_this_stmt = true;
 gimple_assign_set_rhs_from_tree (&orig_gsi, rhs);
 gcc_assert (stmt == gsi_stmt (orig_gsi))((void)(!(stmt == gsi_stmt (orig_gsi)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4420, __FUNCTION__), 0 : 0));
}

    return modify_this_stmt ? SRA_AM_MODIFIED : SRA_AM_NONE;
  }
else
  {
    if (access_has_children_p (lacc)
 && access_has_children_p (racc)
 /* When an access represents an unscalarizable region, it usually
    represents accesses with variable offset and thus must not be used
    to generate new memory accesses.  */
 && !lacc->grp_unscalarizable_region
 && !racc->grp_unscalarizable_region)
{
 struct subreplacement_assignment_data sad;

 sad.left_offset = lacc->offset;
 sad.assignment_lhs = lhs;
 sad.assignment_rhs = rhs;
 sad.top_racc = racc;
 sad.old_gsi = *gsi;
 sad.new_gsi = gsi;
 sad.loc = gimple_location (stmt);
 sad.refreshed = SRA_UDH_NONE;

 if (lacc->grp_read && !lacc->grp_covered)
   handle_unscalarized_data_in_subtree (&sad);

 load_assign_lhs_subreplacements (lacc, &sad);
 if (sad.refreshed != SRA_UDH_RIGHT)
   {
     gsi_next (gsi);
     unlink_stmt_vdef (stmt);
     gsi_remove (&sad.old_gsi, true);
     release_defs (stmt);
     sra_stats.deleted++;
     return SRA_AM_REMOVED;
   }
}
    else
{
 if (access_has_children_p (racc)
     && !racc->grp_unscalarized_data
     && TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) != SSA_NAME)
   {
     if (dump_file)
{
  fprintf (dump_file, "Removing load: ");
  print_gimple_stmt (dump_file, stmt, 0);
}
     generate_subtree_copies (racc->first_child, lhs,
		       racc->offset, 0, 0, gsi,
		       false, false, loc);
     gcc_assert (stmt == gsi_stmt (*gsi))((void)(!(stmt == gsi_stmt (*gsi)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4474, __FUNCTION__), 0 : 0));
     unlink_stmt_vdef (stmt);
     gsi_remove (gsi, true);
     release_defs (stmt);
     sra_stats.deleted++;
     return SRA_AM_REMOVED;
   }
 /* Restore the aggregate RHS from its components so the
    prevailing aggregate copy does the right thing.  */
 if (access_has_children_p (racc) && !TREE_READONLY (racc->base)((non_type_check ((racc->base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4483, __FUNCTION__))->base.readonly_flag))
   generate_subtree_copies (racc->first_child, rhs, racc->offset, 0, 0,
		     gsi, false, false, loc);
 /* Re-load the components of the aggregate copy destination.
    But use the RHS aggregate to load from to expose more
    optimization opportunities.  */
 if (access_has_children_p (lacc))
   generate_subtree_copies (lacc->first_child, rhs, lacc->offset,
		     0, 0, gsi, true, true, loc);
}

    return SRA_AM_NONE;
  }
4496}

4498/* Set any scalar replacements of values in the constant pool to the initial
 value of the constant.  (Constant-pool decls like *.LC0 have effectively
 been initialized before the program starts, we must do the same for their
 replacements.)  Thus, we output statements like 'SR.1 = *.LC0[0];' into
 the function's entry block.  */

4504static void
4505initialize_constant_pool_replacements (void)
4506{
gimple_seq seq = NULLnullptr;
gimple_stmt_iterator gsi = gsi_start (seq);
bitmap_iterator bi;
unsigned i;

EXECUTE_IF_SET_IN_BITMAP (candidate_bitmap, 0, i, bi)for (bmp_iter_set_init (&(bi), (candidate_bitmap), (0), &
(i)); bmp_iter_set (&(bi), &(i)); bmp_iter_next (&
(bi), &(i)))
  {
    tree var = candidate (i);
    if (!constant_decl_p (var))
continue;

    struct access *access = get_first_repr_for_decl (var);

    while (access)
{
 if (access->replacement_decl)
   {
     gassign *stmt
= gimple_build_assign (get_access_replacement (access),
		       unshare_expr (access->expr));
     if (dump_file && (dump_flags & TDF_DETAILS))
{
  fprintf (dump_file, "Generating constant initializer: ");
  print_gimple_stmt (dump_file, stmt, 0);
  fprintf (dump_file, "\n");
}
     gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
     update_stmt (stmt);
   }

 if (access->first_child)
   access = access->first_child;
 else if (access->next_sibling)
   access = access->next_sibling;
 else
   {
     while (access->parent && !access->next_sibling)
access = access->parent;
     if (access->next_sibling)
access = access->next_sibling;
     else
access = access->next_grp;
   }
}
  }

seq = gsi_seq (gsi);
if (seq)
  gsi_insert_seq_on_edge_immediate (
    single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)), seq);
4557}

4559/* Traverse the function body and all modifications as decided in
 analyze_all_variable_accesses.  Return true iff the CFG has been
 changed.  */

4563static bool
4564sra_modify_function_body (void)
4565{
bool cfg_changed = false;
basic_block bb;

initialize_constant_pool_replacements ();

FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  {
    gimple_stmt_iterator gsi = gsi_start_bb (bb);
    while (!gsi_end_p (gsi))
{
 gimple *stmt = gsi_stmt (gsi);
 enum assignment_mod_result assign_result;
 bool modified = false, deleted = false;
 tree *t;
 unsigned i;

 switch (gimple_code (stmt))
   {
   case GIMPLE_RETURN:
     t = gimple_return_retval_ptr (as_a <greturn *> (stmt));
     if (*t != NULL_TREE(tree) nullptr)
modified |= sra_modify_expr (t, &gsi, false);
     break;

   case GIMPLE_ASSIGN:
     assign_result = sra_modify_assign (stmt, &gsi);
     modified |= assign_result == SRA_AM_MODIFIED;
     deleted = assign_result == SRA_AM_REMOVED;
     break;

   case GIMPLE_CALL:
     /* Handle calls to .DEFERRED_INIT specially.  */
     if (gimple_call_internal_p (stmt, IFN_DEFERRED_INIT))
{
  assign_result = sra_modify_deferred_init (stmt, &gsi);
  modified |= assign_result == SRA_AM_MODIFIED;
  deleted = assign_result == SRA_AM_REMOVED;
}
     else
{
  /* Operands must be processed before the lhs.  */
  for (i = 0; i < gimple_call_num_args (stmt); i++)
    {
      t = gimple_call_arg_ptr (stmt, i);
      modified |= sra_modify_expr (t, &gsi, false);
    }

     	  if (gimple_call_lhs (stmt))
    {
      t = gimple_call_lhs_ptr (stmt);
      modified |= sra_modify_expr (t, &gsi, true);
    }
}
     break;

   case GIMPLE_ASM:
     {
gasm *asm_stmt = as_a <gasm *> (stmt);
for (i = 0; i < gimple_asm_ninputs (asm_stmt); i++)
  {
    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/tree-sra.cc"
, 4626, __FUNCTION__, (TREE_LIST)))->list.value);
    modified |= sra_modify_expr (t, &gsi, false);
  }
for (i = 0; i < gimple_asm_noutputs (asm_stmt); i++)
  {
    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/tree-sra.cc"
, 4631, __FUNCTION__, (TREE_LIST)))->list.value);
    modified |= sra_modify_expr (t, &gsi, true);
  }
     }
     break;

   default:
     break;
   }

 if (modified)
   {
     update_stmt (stmt);
     if (maybe_clean_eh_stmt (stmt)
  && gimple_purge_dead_eh_edges (gimple_bb (stmt)))
cfg_changed = true;
   }
 if (!deleted)
   gsi_next (&gsi);
}
  }

gsi_commit_edge_inserts ();
return cfg_changed;
4655}

4657/* Generate statements initializing scalar replacements of parts of function
 parameters.  */

4660static void
4661initialize_parameter_reductions (void)
4662{
gimple_stmt_iterator gsi;
gimple_seq seq = NULLnullptr;
tree parm;

gsi = gsi_start (seq);
for (parm = DECL_ARGUMENTS (current_function_decl)((tree_check ((current_function_decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4668, __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/tree-sra.cc"
, 4670, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4670, __FUNCTION__))->common.chain)))
  {
    vec<access_p> *access_vec;
    struct access *access;

    if (!bitmap_bit_p (candidate_bitmap, DECL_UID (parm)((contains_struct_check ((parm), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-sra.cc"
, 4675, __FUNCTION__))->decl_minimal.uid)))
continue;
    access_vec = get_base_access_vector (parm);
    if (!access_vec)
continue;

    for (access = (*access_vec)[0];
  access;
  access = access->next_grp)
generate_subtree_copies (access, parm, 0, 0, 0, &gsi, true, true,
		 EXPR_LOCATION (parm)((((parm)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((parm))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((parm))->base.code))]) <= tcc_expression
)) ? (parm)->exp.locus : ((location_t) 0)));
  }

seq = gsi_seq (gsi);
if (seq)
  gsi_insert_seq_on_edge_immediate (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)), seq);
4691}

4693/* The "main" function of intraprocedural SRA passes.  Runs the analysis and if
 it reveals there are components of some aggregates to be scalarized, it runs
 the required transformations.  */
4696static unsigned int
4697perform_intra_sra (void)
4698{
int ret = 0;
sra_initialize ();

if (!find_var_candidates ())
  goto out;

if (!scan_function ())
  goto out;

if (!analyze_all_variable_accesses ())
  goto out;

if (sra_modify_function_body ())
  ret = TODO_update_ssa(1 << 11) | TODO_cleanup_cfg(1 << 5);
else
  ret = TODO_update_ssa(1 << 11);
initialize_parameter_reductions ();

statistics_counter_event (cfun(cfun + 0), "Scalar replacements created",
	    sra_stats.replacements);
statistics_counter_event (cfun(cfun + 0), "Modified expressions", sra_stats.exprs);
statistics_counter_event (cfun(cfun + 0), "Subtree copy stmts",
	    sra_stats.subtree_copies);
statistics_counter_event (cfun(cfun + 0), "Subreplacement stmts",
	    sra_stats.subreplacements);
statistics_counter_event (cfun(cfun + 0), "Deleted stmts", sra_stats.deleted);
statistics_counter_event (cfun(cfun + 0), "Separate LHS and RHS handling",
	    sra_stats.separate_lhs_rhs_handling);

out:
sra_deinitialize ();
return ret;
4731}

4733/* Perform early intraprocedural SRA.  */
4734static unsigned int
4735early_intra_sra (void)
4736{
sra_mode = SRA_MODE_EARLY_INTRA;
return perform_intra_sra ();
4739}

4741/* Perform "late" intraprocedural SRA.  */
4742static unsigned int
4743late_intra_sra (void)
4744{
sra_mode = SRA_MODE_INTRA;
return perform_intra_sra ();
4747}


4750static bool
4751gate_intra_sra (void)
4752{
return flag_tree_sraglobal_options.x_flag_tree_sra != 0 && dbg_cnt (tree_sra);
4754}


4757namespace {

4759const pass_data pass_data_sra_early =
4760{
GIMPLE_PASS, /* type */
"esra", /* name */
OPTGROUP_NONE, /* optinfo_flags */
TV_TREE_SRA, /* tv_id */
( PROP_cfg(1 << 3) | PROP_ssa(1 << 5) ), /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
TODO_update_ssa(1 << 11), /* todo_flags_finish */
4770};

4772class pass_sra_early : public gimple_opt_pass
4773{
4774public:
pass_sra_early (gcc::context *ctxt)
  : gimple_opt_pass (pass_data_sra_early, ctxt)
{}

/* opt_pass methods: */
bool gate (function *) final override { return gate_intra_sra (); }
unsigned int execute (function *) final override
{
  return early_intra_sra ();
}

4786}; // class pass_sra_early

4788} // anon namespace

4790gimple_opt_pass *
4791make_pass_sra_early (gcc::context *ctxt)
4792{
return new pass_sra_early (ctxt);
4794}

4796namespace {

4798const pass_data pass_data_sra =
4799{
GIMPLE_PASS, /* type */
"sra", /* name */
OPTGROUP_NONE, /* optinfo_flags */
TV_TREE_SRA, /* tv_id */
( PROP_cfg(1 << 3) | PROP_ssa(1 << 5) ), /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
TODO_update_address_taken(1 << 21), /* todo_flags_start */
TODO_update_ssa(1 << 11), /* todo_flags_finish */
4809};

4811class pass_sra : public gimple_opt_pass
4812{
4813public:
pass_sra (gcc::context *ctxt)
  : gimple_opt_pass (pass_data_sra, ctxt)
{}

/* opt_pass methods: */
bool gate (function *) final override { return gate_intra_sra (); }
unsigned int execute (function *) final override { return late_intra_sra (); }

4822}; // class pass_sra

4824} // anon namespace

4826gimple_opt_pass *
4827make_pass_sra (gcc::context *ctxt)
4828{
return new pass_sra (ctxt);
4830}