/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc

Bug Summary

File:	build/gcc/gimple-ssa-store-merging.cc
Warning:	line 4511, column 5 4th function call argument is an uninitialized 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 gimple-ssa-store-merging.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-971bqJ.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc

1/* GIMPLE store merging and byte swapping passes.
 Copyright (C) 2009-2023 Free Software Foundation, Inc.
 Contributed by ARM Ltd.

 This file is part of GCC.

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

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

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

21/* The purpose of the store merging pass is to combine multiple memory stores
 of constant values, values loaded from memory, bitwise operations on those,
 or bit-field values, to consecutive locations, into fewer wider stores.

 For example, if we have a sequence peforming four byte stores to
 consecutive memory locations:
 [p     ] := imm1;
 [p + 1B] := imm2;
 [p + 2B] := imm3;
 [p + 3B] := imm4;
 we can transform this into a single 4-byte store if the target supports it:
 [p] := imm1:imm2:imm3:imm4 concatenated according to endianness.

 Or:
 [p     ] := [q     ];
 [p + 1B] := [q + 1B];
 [p + 2B] := [q + 2B];
 [p + 3B] := [q + 3B];
 if there is no overlap can be transformed into a single 4-byte
 load followed by single 4-byte store.

 Or:
 [p     ] := [q     ] ^ imm1;
 [p + 1B] := [q + 1B] ^ imm2;
 [p + 2B] := [q + 2B] ^ imm3;
 [p + 3B] := [q + 3B] ^ imm4;
 if there is no overlap can be transformed into a single 4-byte
 load, xored with imm1:imm2:imm3:imm4 and stored using a single 4-byte store.

 Or:
 [p:1 ] := imm;
 [p:31] := val & 0x7FFFFFFF;
 we can transform this into a single 4-byte store if the target supports it:
 [p] := imm:(val & 0x7FFFFFFF) concatenated according to endianness.

 The algorithm is applied to each basic block in three phases:

 1) Scan through the basic block and record assignments to destinations
 that can be expressed as a store to memory of a certain size at a certain
 bit offset from base expressions we can handle.  For bit-fields we also
 record the surrounding bit region, i.e. bits that could be stored in
 a read-modify-write operation when storing the bit-field.  Record store
 chains to different bases in a hash_map (m_stores) and make sure to
 terminate such chains when appropriate (for example when the stored
 values get used subsequently).
 These stores can be a result of structure element initializers, array stores
 etc.  A store_immediate_info object is recorded for every such store.
 Record as many such assignments to a single base as possible until a
 statement that interferes with the store sequence is encountered.
 Each store has up to 2 operands, which can be a either constant, a memory
 load or an SSA name, from which the value to be stored can be computed.
 At most one of the operands can be a constant.  The operands are recorded
 in store_operand_info struct.

 2) Analyze the chains of stores recorded in phase 1) (i.e. the vector of
 store_immediate_info objects) and coalesce contiguous stores into
 merged_store_group objects.  For bit-field stores, we don't need to
 require the stores to be contiguous, just their surrounding bit regions
 have to be contiguous.  If the expression being stored is different
 between adjacent stores, such as one store storing a constant and
 following storing a value loaded from memory, or if the loaded memory
 objects are not adjacent, a new merged_store_group is created as well.

 For example, given the stores:
 [p     ] := 0;
 [p + 1B] := 1;
 [p + 3B] := 0;
 [p + 4B] := 1;
 [p + 5B] := 0;
 [p + 6B] := 0;
 This phase would produce two merged_store_group objects, one recording the
 two bytes stored in the memory region [p : p + 1] and another
 recording the four bytes stored in the memory region [p + 3 : p + 6].

 3) The merged_store_group objects produced in phase 2) are processed
 to generate the sequence of wider stores that set the contiguous memory
 regions to the sequence of bytes that correspond to it.  This may emit
 multiple stores per store group to handle contiguous stores that are not
 of a size that is a power of 2.  For example it can try to emit a 40-bit
 store as a 32-bit store followed by an 8-bit store.
 We try to emit as wide stores as we can while respecting STRICT_ALIGNMENT
 or TARGET_SLOW_UNALIGNED_ACCESS settings.

 Note on endianness and example:
 Consider 2 contiguous 16-bit stores followed by 2 contiguous 8-bit stores:
 [p     ] := 0x1234;
 [p + 2B] := 0x5678;
 [p + 4B] := 0xab;
 [p + 5B] := 0xcd;

 The memory layout for little-endian (LE) and big-endian (BE) must be:
p |LE|BE|
---------
0 |34|12|
1 |12|34|
2 |78|56|
3 |56|78|
4 |ab|ab|
5 |cd|cd|

To merge these into a single 48-bit merged value 'val' in phase 2)
on little-endian we insert stores to higher (consecutive) bitpositions
into the most significant bits of the merged value.
The final merged value would be: 0xcdab56781234

For big-endian we insert stores to higher bitpositions into the least
significant bits of the merged value.
The final merged value would be: 0x12345678abcd

Then, in phase 3), we want to emit this 48-bit value as a 32-bit store
followed by a 16-bit store.  Again, we must consider endianness when
breaking down the 48-bit value 'val' computed above.
For little endian we emit:
[p]      (32-bit) := 0x56781234; // val & 0x0000ffffffff;
[p + 4B] (16-bit) := 0xcdab;    // (val & 0xffff00000000) >> 32;

Whereas for big-endian we emit:
[p]      (32-bit) := 0x12345678; // (val & 0xffffffff0000) >> 16;
[p + 4B] (16-bit) := 0xabcd;     //  val & 0x00000000ffff;  */

141#include "config.h"
142#include "system.h"
143#include "coretypes.h"
144#include "backend.h"
145#include "tree.h"
146#include "gimple.h"
147#include "builtins.h"
148#include "fold-const.h"
149#include "tree-pass.h"
150#include "ssa.h"
151#include "gimple-pretty-print.h"
152#include "alias.h"
153#include "fold-const.h"
154#include "print-tree.h"
155#include "tree-hash-traits.h"
156#include "gimple-iterator.h"
157#include "gimplify.h"
158#include "gimple-fold.h"
159#include "stor-layout.h"
160#include "timevar.h"
161#include "cfganal.h"
162#include "cfgcleanup.h"
163#include "tree-cfg.h"
164#include "except.h"
165#include "tree-eh.h"
166#include "target.h"
167#include "gimplify-me.h"
168#include "rtl.h"
169#include "expr.h"	/* For get_bit_range.  */
170#include "optabs-tree.h"
171#include "dbgcnt.h"
172#include "selftest.h"

174/* The maximum size (in bits) of the stores this pass should generate.  */
175#define MAX_STORE_BITSIZE(((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4))) (BITS_PER_WORD((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4)))
176#define MAX_STORE_BYTES((((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4))) / (8)) (MAX_STORE_BITSIZE(((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4))) / BITS_PER_UNIT(8))

178/* Limit to bound the number of aliasing checks for loads with the same
 vuse as the corresponding store.  */
180#define MAX_STORE_ALIAS_CHECKS64 64

182namespace {

184struct bswap_stat
185{
/* Number of hand-written 16-bit nop / bswaps found.  */
int found_16bit;

/* Number of hand-written 32-bit nop / bswaps found.  */
int found_32bit;

/* Number of hand-written 64-bit nop / bswaps found.  */
int found_64bit;
194} nop_stats, bswap_stats;

196/* A symbolic number structure is used to detect byte permutation and selection
 patterns of a source.  To achieve that, its field N contains an artificial
 number consisting of BITS_PER_MARKER sized markers tracking where does each
 byte come from in the source:

 0	   - target byte has the value 0
 FF	   - target byte has an unknown value (eg. due to sign extension)
 1..size - marker value is the byte index in the source (0 for lsb).

 To detect permutations on memory sources (arrays and structures), a symbolic
 number is also associated:
 - a base address BASE_ADDR and an OFFSET giving the address of the source;
 - a range which gives the difference between the highest and lowest accessed
   memory location to make such a symbolic number;
 - the address SRC of the source element of lowest address as a convenience
   to easily get BASE_ADDR + offset + lowest bytepos;
 - number of expressions N_OPS bitwise ored together to represent
   approximate cost of the computation.

 Note 1: the range is different from size as size reflects the size of the
 type of the current expression.  For instance, for an array char a[],
 (short) a[0] | (short) a[3] would have a size of 2 but a range of 4 while
 (short) a[0] | ((short) a[0] << 1) would still have a size of 2 but this
 time a range of 1.

 Note 2: for non-memory sources, range holds the same value as size.

 Note 3: SRC points to the SSA_NAME in case of non-memory source.  */

225struct symbolic_number {
uint64_t n;
tree type;
tree base_addr;
tree offset;
poly_int64_pod bytepos;
tree src;
tree alias_set;
tree vuse;
unsigned HOST_WIDE_INTlong range;
int n_ops;
236};

238#define BITS_PER_MARKER8 8
239#define MARKER_MASK((1 << 8) - 1) ((1 << BITS_PER_MARKER8) - 1)
240#define MARKER_BYTE_UNKNOWN((1 << 8) - 1) MARKER_MASK((1 << 8) - 1)
241#define HEAD_MARKER(n, size)((n) & ((uint64_t) ((1 << 8) - 1) << (((size)
 - 1) * 8))) \
((n) & ((uint64_t) MARKER_MASK((1 << 8) - 1) << (((size) - 1) * BITS_PER_MARKER8)))

244/* The number which the find_bswap_or_nop_1 result should match in
 order to have a nop.  The number is masked according to the size of
 the symbolic number before using it.  */
247#define CMPNOP(sizeof (int64_t) < 8 ? 0 : (uint64_t)0x08070605 << 32
 | 0x04030201) (sizeof (int64_t) < 8 ? 0 : \
(uint64_t)0x08070605 << 32 | 0x04030201)

250/* The number which the find_bswap_or_nop_1 result should match in
 order to have a byte swap.  The number is masked according to the
 size of the symbolic number before using it.  */
253#define CMPXCHG(sizeof (int64_t) < 8 ? 0 : (uint64_t)0x01020304 << 32
 | 0x05060708) (sizeof (int64_t) < 8 ? 0 : \
(uint64_t)0x01020304 << 32 | 0x05060708)

256/* Perform a SHIFT or ROTATE operation by COUNT bits on symbolic
 number N.  Return false if the requested operation is not permitted
 on a symbolic number.  */

260inline bool
261do_shift_rotate (enum tree_code code,
 struct symbolic_number *n,
 int count)
264{
int i, size = TYPE_PRECISION (n->type)((tree_class_check ((n->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 265, __FUNCTION__))->type_common.precision) / BITS_PER_UNIT(8);
uint64_t head_marker;

if (count < 0
    || count >= TYPE_PRECISION (n->type)((tree_class_check ((n->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 269, __FUNCTION__))->type_common.precision)
    || count % BITS_PER_UNIT(8) != 0)
  return false;
count = (count / BITS_PER_UNIT(8)) * BITS_PER_MARKER8;

/* Zero out the extra bits of N in order to avoid them being shifted
   into the significant bits.  */
if (size < 64 / BITS_PER_MARKER8)
  n->n &= ((uint64_t) 1 << (size * BITS_PER_MARKER8)) - 1;

switch (code)
  {
  case LSHIFT_EXPR:
    n->n <<= count;
    break;
  case RSHIFT_EXPR:
    head_marker = HEAD_MARKER (n->n, size)((n->n) & ((uint64_t) ((1 << 8) - 1) << ((
(size) - 1) * 8)));
    n->n >>= count;
    /* Arithmetic shift of signed type: result is dependent on the value.  */
    if (!TYPE_UNSIGNED (n->type)((tree_class_check ((n->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 288, __FUNCTION__))->base.u.bits.unsigned_flag) && head_marker)
for (i = 0; i < count / BITS_PER_MARKER8; i++)
 n->n |= (uint64_t) MARKER_BYTE_UNKNOWN((1 << 8) - 1)
  << ((size - 1 - i) * BITS_PER_MARKER8);
    break;
  case LROTATE_EXPR:
    n->n = (n->n << count) | (n->n >> ((size * BITS_PER_MARKER8) - count));
    break;
  case RROTATE_EXPR:
    n->n = (n->n >> count) | (n->n << ((size * BITS_PER_MARKER8) - count));
    break;
  default:
    return false;
  }
/* Zero unused bits for size.  */
if (size < 64 / BITS_PER_MARKER8)
  n->n &= ((uint64_t) 1 << (size * BITS_PER_MARKER8)) - 1;
return true;
306}

308/* Perform sanity checking for the symbolic number N and the gimple
 statement STMT.  */

311inline bool
312verify_symbolic_number_p (struct symbolic_number *n, gimple *stmt)
313{
tree lhs_type;

lhs_type = TREE_TYPE (gimple_get_lhs (stmt))((contains_struct_check ((gimple_get_lhs (stmt)), (TS_TYPED),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 316, __FUNCTION__))->typed.type);

if (TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != INTEGER_TYPE
    && TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != ENUMERAL_TYPE)
  return false;

if (TYPE_PRECISION (lhs_type)((tree_class_check ((lhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 322, __FUNCTION__))->type_common.precision) != TYPE_PRECISION (n->type)((tree_class_check ((n->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 322, __FUNCTION__))->type_common.precision))
  return false;

return true;
326}

328/* Initialize the symbolic number N for the bswap pass from the base element
 SRC manipulated by the bitwise OR expression.  */

331bool
332init_symbolic_number (struct symbolic_number *n, tree src)
333{
int size;

if (!INTEGRAL_TYPE_P (TREE_TYPE (src))(((enum tree_code) (((contains_struct_check ((src), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 336, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((src), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 336, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((src), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 336, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
) && !POINTER_TYPE_P (TREE_TYPE (src))(((enum tree_code) (((contains_struct_check ((src), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 336, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((src), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 336, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
  return false;

n->base_addr = n->offset = n->alias_set = n->vuse = NULL_TREE(tree) nullptr;
n->src = src;

/* Set up the symbolic number N by setting each byte to a value between 1 and
   the byte size of rhs1.  The highest order byte is set to n->size and the
   lowest order byte to 1.  */
n->type = TREE_TYPE (src)((contains_struct_check ((src), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 345, __FUNCTION__))->typed.type);
size = TYPE_PRECISION (n->type)((tree_class_check ((n->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 346, __FUNCTION__))->type_common.precision);
if (size % BITS_PER_UNIT(8) != 0)
  return false;
size /= BITS_PER_UNIT(8);
if (size > 64 / BITS_PER_MARKER8)
  return false;
n->range = size;
n->n = CMPNOP(sizeof (int64_t) < 8 ? 0 : (uint64_t)0x08070605 << 32
 | 0x04030201);
n->n_ops = 1;

if (size < 64 / BITS_PER_MARKER8)
  n->n &= ((uint64_t) 1 << (size * BITS_PER_MARKER8)) - 1;

return true;
360}

362/* Check if STMT might be a byte swap or a nop from a memory source and returns
 the answer. If so, REF is that memory source and the base of the memory area
 accessed and the offset of the access from that base are recorded in N.  */

366bool
367find_bswap_or_nop_load (gimple *stmt, tree ref, struct symbolic_number *n)
368{
/* Leaf node is an array or component ref. Memorize its base and
   offset from base to compare to other such leaf node.  */
poly_int64 bitsize, bitpos, bytepos;
machine_mode mode;
int unsignedp, reversep, volatilep;
tree offset, base_addr;

/* Not prepared to handle PDP endian.  */
if (BYTES_BIG_ENDIAN0 != WORDS_BIG_ENDIAN0)
  return false;

if (!gimple_assign_load_p (stmt) || gimple_has_volatile_ops (stmt))
  return false;

base_addr = get_inner_reference (ref, &bitsize, &bitpos, &offset, &mode,
		   &unsignedp, &reversep, &volatilep);

if (TREE_CODE (base_addr)((enum tree_code) (base_addr)->base.code) == TARGET_MEM_REF)
  /* Do not rewrite TARGET_MEM_REF.  */
  return false;
else if (TREE_CODE (base_addr)((enum tree_code) (base_addr)->base.code) == MEM_REF)
  {
    poly_offset_int bit_offset = 0;
    tree off = TREE_OPERAND (base_addr, 1)(*((const_cast<tree*> (tree_operand_check ((base_addr),
 (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 392, __FUNCTION__)))));

    if (!integer_zerop (off))
{
 poly_offset_int boff = mem_ref_offset (base_addr);
 boff <<= LOG2_BITS_PER_UNIT3;
 bit_offset += boff;
}

    base_addr = TREE_OPERAND (base_addr, 0)(*((const_cast<tree*> (tree_operand_check ((base_addr),
 (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 401, __FUNCTION__)))));

    /* Avoid returning a negative bitpos as this may wreak havoc later.  */
    if (maybe_lt (bit_offset, 0))
{
 tree byte_offset = wide_int_to_tree
   (sizetypesizetype_tab[(int) stk_sizetype], bits_to_bytes_round_down (bit_offset)force_align_down_and_div (bit_offset, (8)));
 bit_offset = num_trailing_bits (bit_offset)force_get_misalignment (bit_offset, (8));
 if (offset)
   offset = size_binop (PLUS_EXPR, offset, byte_offset)size_binop_loc (((location_t) 0), PLUS_EXPR, offset, byte_offset
);
 else
   offset = byte_offset;
}

    bitpos += bit_offset.force_shwi ();
  }
else
  base_addr = build_fold_addr_expr (base_addr)build_fold_addr_expr_loc (((location_t) 0), (base_addr));

if (!multiple_p (bitpos, BITS_PER_UNIT(8), &bytepos))
  return false;
if (!multiple_p (bitsize, BITS_PER_UNIT(8)))
  return false;
if (reversep)
  return false;

if (!init_symbolic_number (n, ref))
  return false;
n->base_addr = base_addr;
n->offset = offset;
n->bytepos = bytepos;
n->alias_set = reference_alias_ptr_type (ref);
n->vuse = gimple_vuse (stmt);
return true;
435}

437/* Compute the symbolic number N representing the result of a bitwise OR,
 bitwise XOR or plus on 2 symbolic number N1 and N2 whose source statements
 are respectively SOURCE_STMT1 and SOURCE_STMT2.  CODE is the operation.  */

441gimple *
442perform_symbolic_merge (gimple *source_stmt1, struct symbolic_number *n1,
	gimple *source_stmt2, struct symbolic_number *n2,
	struct symbolic_number *n, enum tree_code code)
445{
int i, size;
uint64_t mask;
gimple *source_stmt;
struct symbolic_number *n_start;

tree rhs1 = gimple_assign_rhs1 (source_stmt1);
if (TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == BIT_FIELD_REF
    && TREE_CODE (TREE_OPERAND (rhs1, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((rhs1), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 453, __FUNCTION__))))))->base.code) == SSA_NAME)
  rhs1 = TREE_OPERAND (rhs1, 0)(*((const_cast<tree*> (tree_operand_check ((rhs1), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 454, __FUNCTION__)))));
tree rhs2 = gimple_assign_rhs1 (source_stmt2);
if (TREE_CODE (rhs2)((enum tree_code) (rhs2)->base.code) == BIT_FIELD_REF
    && TREE_CODE (TREE_OPERAND (rhs2, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((rhs2), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 457, __FUNCTION__))))))->base.code) == SSA_NAME)
  rhs2 = TREE_OPERAND (rhs2, 0)(*((const_cast<tree*> (tree_operand_check ((rhs2), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 458, __FUNCTION__)))));

/* Sources are different, cancel bswap if they are not memory location with
   the same base (array, structure, ...).  */
if (rhs1 != rhs2)
  {
    uint64_t inc;
    HOST_WIDE_INTlong start1, start2, start_sub, end_sub, end1, end2, end;
    struct symbolic_number *toinc_n_ptr, *n_end;
    basic_block bb1, bb2;

    if (!n1->base_addr || !n2->base_addr
 || !operand_equal_p (n1->base_addr, n2->base_addr, 0))
return NULLnullptr;

    if (!n1->offset != !n2->offset
 || (n1->offset && !operand_equal_p (n1->offset, n2->offset, 0)))
return NULLnullptr;

    start1 = 0;
    if (!(n2->bytepos - n1->bytepos).is_constant (&start2))
return NULLnullptr;

    if (start1 < start2)
{
 n_start = n1;
 start_sub = start2 - start1;
}
    else
{
 n_start = n2;
 start_sub = start1 - start2;
}

    bb1 = gimple_bb (source_stmt1);
    bb2 = gimple_bb (source_stmt2);
    if (dominated_by_p (CDI_DOMINATORS, bb1, bb2))
source_stmt = source_stmt1;
    else
source_stmt = source_stmt2;

    /* Find the highest address at which a load is performed and
compute related info.  */
    end1 = start1 + (n1->range - 1);
    end2 = start2 + (n2->range - 1);
    if (end1 < end2)
{
 end = end2;
 end_sub = end2 - end1;
}
    else
{
 end = end1;
 end_sub = end1 - end2;
}
    n_end = (end2 > end1) ? n2 : n1;

    /* Find symbolic number whose lsb is the most significant.  */
    if (BYTES_BIG_ENDIAN0)
toinc_n_ptr = (n_end == n1) ? n2 : n1;
    else
toinc_n_ptr = (n_start == n1) ? n2 : n1;

    n->range = end - MIN (start1, start2)((start1) < (start2) ? (start1) : (start2)) + 1;

    /* Check that the range of memory covered can be represented by
a symbolic number.  */
    if (n->range > 64 / BITS_PER_MARKER8)
return NULLnullptr;

    /* Reinterpret byte marks in symbolic number holding the value of
bigger weight according to target endianness.  */
    inc = BYTES_BIG_ENDIAN0 ? end_sub : start_sub;
    size = TYPE_PRECISION (n1->type)((tree_class_check ((n1->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 531, __FUNCTION__))->type_common.precision) / BITS_PER_UNIT(8);
    for (i = 0; i < size; i++, inc <<= BITS_PER_MARKER8)
{
 unsigned marker
   = (toinc_n_ptr->n >> (i * BITS_PER_MARKER8)) & MARKER_MASK((1 << 8) - 1);
 if (marker && marker != MARKER_BYTE_UNKNOWN((1 << 8) - 1))
   toinc_n_ptr->n += inc;
}
  }
else
  {
    n->range = n1->range;
    n_start = n1;
    source_stmt = source_stmt1;
  }

if (!n1->alias_set
    || alias_ptr_types_compatible_p (n1->alias_set, n2->alias_set))
  n->alias_set = n1->alias_set;
else
  n->alias_set = ptr_type_nodeglobal_trees[TI_PTR_TYPE];
n->vuse = n_start->vuse;
n->base_addr = n_start->base_addr;
n->offset = n_start->offset;
n->src = n_start->src;
n->bytepos = n_start->bytepos;
n->type = n_start->type;
size = TYPE_PRECISION (n->type)((tree_class_check ((n->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 558, __FUNCTION__))->type_common.precision) / BITS_PER_UNIT(8);
uint64_t res_n = n1->n | n2->n;

for (i = 0, mask = MARKER_MASK((1 << 8) - 1); i < size; i++, mask <<= BITS_PER_MARKER8)
  {
    uint64_t masked1, masked2;

    masked1 = n1->n & mask;
    masked2 = n2->n & mask;
    /* If at least one byte is 0, all of 0 | x == 0 ^ x == 0 + x == x.  */
    if (masked1 && masked2)
{
 /* + can carry into upper bits, just punt.  */
 if (code == PLUS_EXPR)
   return NULLnullptr;
 /* x | x is still x.  */
 if (code == BIT_IOR_EXPR && masked1 == masked2)
   continue;
 if (code == BIT_XOR_EXPR)
   {
     /* x ^ x is 0, but MARKER_BYTE_UNKNOWN stands for
 unknown values and unknown ^ unknown is unknown.  */
     if (masked1 == masked2
  && masked1 != ((uint64_t) MARKER_BYTE_UNKNOWN((1 << 8) - 1)
		 << i * BITS_PER_MARKER8))
{
  res_n &= ~mask;
  continue;
}
   }
 /* Otherwise set the byte to unknown, it might still be
    later masked off.  */
 res_n |= mask;
}
  }
n->n = res_n;
n->n_ops = n1->n_ops + n2->n_ops;

return source_stmt;
597}

599/* find_bswap_or_nop_1 invokes itself recursively with N and tries to perform
 the operation given by the rhs of STMT on the result.  If the operation
 could successfully be executed the function returns a gimple stmt whose
 rhs's first tree is the expression of the source operand and NULL
 otherwise.  */

605gimple *
606find_bswap_or_nop_1 (gimple *stmt, struct symbolic_number *n, int limit)
607{
enum tree_code code;
tree rhs1, rhs2 = NULLnullptr;
gimple *rhs1_stmt, *rhs2_stmt, *source_stmt1;
enum gimple_rhs_class rhs_class;

if (!limit || !is_gimple_assign (stmt))
  return NULLnullptr;

rhs1 = gimple_assign_rhs1 (stmt);

if (find_bswap_or_nop_load (stmt, rhs1, n))
  return stmt;

/* Handle BIT_FIELD_REF.  */
if (TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == BIT_FIELD_REF
    && TREE_CODE (TREE_OPERAND (rhs1, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((rhs1), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 623, __FUNCTION__))))))->base.code) == SSA_NAME)
  {
    if (!tree_fits_uhwi_p (TREE_OPERAND (rhs1, 1)(*((const_cast<tree*> (tree_operand_check ((rhs1), (1),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 625, __FUNCTION__))))))
 || !tree_fits_uhwi_p (TREE_OPERAND (rhs1, 2)(*((const_cast<tree*> (tree_operand_check ((rhs1), (2),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 626, __FUNCTION__)))))))
return NULLnullptr;

    unsigned HOST_WIDE_INTlong bitsize = tree_to_uhwi (TREE_OPERAND (rhs1, 1)(*((const_cast<tree*> (tree_operand_check ((rhs1), (1),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 629, __FUNCTION__))))));
    unsigned HOST_WIDE_INTlong bitpos = tree_to_uhwi (TREE_OPERAND (rhs1, 2)(*((const_cast<tree*> (tree_operand_check ((rhs1), (2),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 630, __FUNCTION__))))));
    if (bitpos % BITS_PER_UNIT(8) == 0
 && bitsize % BITS_PER_UNIT(8) == 0
 && init_symbolic_number (n, TREE_OPERAND (rhs1, 0)(*((const_cast<tree*> (tree_operand_check ((rhs1), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 633, __FUNCTION__)))))))
{
 /* Handle big-endian bit numbering in BIT_FIELD_REF.  */
 if (BYTES_BIG_ENDIAN0)
   bitpos = TYPE_PRECISION (n->type)((tree_class_check ((n->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 637, __FUNCTION__))->type_common.precision) - bitpos - bitsize;

 /* Shift.  */
 if (!do_shift_rotate (RSHIFT_EXPR, n, bitpos))
   return NULLnullptr;

 /* Mask.  */
 uint64_t mask = 0;
 uint64_t tmp = (1 << BITS_PER_UNIT(8)) - 1;
 for (unsigned i = 0; i < bitsize / BITS_PER_UNIT(8);
      i++, tmp <<= BITS_PER_UNIT(8))
   mask |= (uint64_t) MARKER_MASK((1 << 8) - 1) << (i * BITS_PER_MARKER8);
 n->n &= mask;

 /* Convert.  */
 n->type = TREE_TYPE (rhs1)((contains_struct_check ((rhs1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 652, __FUNCTION__))->typed.type);
 if (!n->base_addr)
   n->range = TYPE_PRECISION (n->type)((tree_class_check ((n->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 654, __FUNCTION__))->type_common.precision) / BITS_PER_UNIT(8);

 return verify_symbolic_number_p (n, stmt) ? stmt : NULLnullptr;
}

    return NULLnullptr;
  }

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

code = gimple_assign_rhs_code (stmt);
rhs_class = gimple_assign_rhs_class (stmt);
rhs1_stmt = SSA_NAME_DEF_STMT (rhs1)(tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 667, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;

if (rhs_class == GIMPLE_BINARY_RHS)
  rhs2 = gimple_assign_rhs2 (stmt);

/* Handle unary rhs and binary rhs with integer constants as second
   operand.  */

if (rhs_class == GIMPLE_UNARY_RHS
    || (rhs_class == GIMPLE_BINARY_RHS
 && TREE_CODE (rhs2)((enum tree_code) (rhs2)->base.code) == INTEGER_CST))
  {
    if (code != BIT_AND_EXPR
 && code != LSHIFT_EXPR
 && code != RSHIFT_EXPR
 && code != LROTATE_EXPR
 && code != RROTATE_EXPR
 && !CONVERT_EXPR_CODE_P (code)((code) == NOP_EXPR || (code) == CONVERT_EXPR))
return NULLnullptr;

    source_stmt1 = find_bswap_or_nop_1 (rhs1_stmt, n, limit - 1);

    /* If find_bswap_or_nop_1 returned NULL, STMT is a leaf node and
we have to initialize the symbolic number.  */
    if (!source_stmt1)
{
 if (gimple_assign_load_p (stmt)
     || !init_symbolic_number (n, rhs1))
   return NULLnullptr;
 source_stmt1 = stmt;
}

    switch (code)
{
case BIT_AND_EXPR:
 {
   int i, size = TYPE_PRECISION (n->type)((tree_class_check ((n->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 703, __FUNCTION__))->type_common.precision) / BITS_PER_UNIT(8);
   uint64_t val = int_cst_value (rhs2), mask = 0;
   uint64_t tmp = (1 << BITS_PER_UNIT(8)) - 1;

   /* Only constants masking full bytes are allowed.  */
   for (i = 0; i < size; i++, tmp <<= BITS_PER_UNIT(8))
     if ((val & tmp) != 0 && (val & tmp) != tmp)
return NULLnullptr;
     else if (val & tmp)
mask |= (uint64_t) MARKER_MASK((1 << 8) - 1) << (i * BITS_PER_MARKER8);

   n->n &= mask;
 }
 break;
case LSHIFT_EXPR:
case RSHIFT_EXPR:
case LROTATE_EXPR:
case RROTATE_EXPR:
 if (!do_shift_rotate (code, n, (int) TREE_INT_CST_LOW (rhs2)((unsigned long) (*tree_int_cst_elt_check ((rhs2), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 721, __FUNCTION__)))))
   return NULLnullptr;
 break;
CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
 {
   int i, type_size, old_type_size;
   tree type;

   type = TREE_TYPE (gimple_assign_lhs (stmt))((contains_struct_check ((gimple_assign_lhs (stmt)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 729, __FUNCTION__))->typed.type);
   type_size = TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 730, __FUNCTION__))->type_common.precision);
   if (type_size % BITS_PER_UNIT(8) != 0)
     return NULLnullptr;
   type_size /= BITS_PER_UNIT(8);
   if (type_size > 64 / BITS_PER_MARKER8)
     return NULLnullptr;

   /* Sign extension: result is dependent on the value.  */
   old_type_size = TYPE_PRECISION (n->type)((tree_class_check ((n->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 738, __FUNCTION__))->type_common.precision) / BITS_PER_UNIT(8);
   if (!TYPE_UNSIGNED (n->type)((tree_class_check ((n->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 739, __FUNCTION__))->base.u.bits.unsigned_flag) && type_size > old_type_size
&& HEAD_MARKER (n->n, old_type_size)((n->n) & ((uint64_t) ((1 << 8) - 1) << ((
(old_type_size) - 1) * 8))))
     for (i = 0; i < type_size - old_type_size; i++)
n->n |= (uint64_t) MARKER_BYTE_UNKNOWN((1 << 8) - 1)
	<< ((type_size - 1 - i) * BITS_PER_MARKER8);

   if (type_size < 64 / BITS_PER_MARKER8)
     {
/* If STMT casts to a smaller type mask out the bits not
   belonging to the target type.  */
n->n &= ((uint64_t) 1 << (type_size * BITS_PER_MARKER8)) - 1;
     }
   n->type = type;
   if (!n->base_addr)
     n->range = type_size;
 }
 break;
default:
 return NULLnullptr;
};
    return verify_symbolic_number_p (n, stmt) ? source_stmt1 : NULLnullptr;
  }

/* Handle binary rhs.  */

if (rhs_class == GIMPLE_BINARY_RHS)
  {
    struct symbolic_number n1, n2;
    gimple *source_stmt, *source_stmt2;

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

    rhs2_stmt = SSA_NAME_DEF_STMT (rhs2)(tree_check ((rhs2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 772, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;

    switch (code)
{
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
case PLUS_EXPR:
 source_stmt1 = find_bswap_or_nop_1 (rhs1_stmt, &n1, limit - 1);

 if (!source_stmt1)
   return NULLnullptr;

 source_stmt2 = find_bswap_or_nop_1 (rhs2_stmt, &n2, limit - 1);

 if (!source_stmt2)
   return NULLnullptr;

 if (TYPE_PRECISION (n1.type)((tree_class_check ((n1.type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 789, __FUNCTION__))->type_common.precision) != TYPE_PRECISION (n2.type)((tree_class_check ((n2.type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 789, __FUNCTION__))->type_common.precision))
   return NULLnullptr;

 if (n1.vuse != n2.vuse)
   return NULLnullptr;

 source_stmt
   = perform_symbolic_merge (source_stmt1, &n1, source_stmt2, &n2, n,
		      code);

 if (!source_stmt)
   return NULLnullptr;

 if (!verify_symbolic_number_p (n, stmt))
   return NULLnullptr;

 break;
default:
 return NULLnullptr;
}
    return source_stmt;
  }
return NULLnullptr;
812}

814/* Helper for find_bswap_or_nop and try_coalesce_bswap to compute
 *CMPXCHG, *CMPNOP and adjust *N.  */

817void
818find_bswap_or_nop_finalize (struct symbolic_number *n, uint64_t *cmpxchg,
	    uint64_t *cmpnop, bool *cast64_to_32)
820{
unsigned rsize;
uint64_t tmpn, mask;

/* The number which the find_bswap_or_nop_1 result should match in order
   to have a full byte swap.  The number is shifted to the right
   according to the size of the symbolic number before using it.  */
*cmpxchg = CMPXCHG(sizeof (int64_t) < 8 ? 0 : (uint64_t)0x01020304 << 32
 | 0x05060708);
*cmpnop = CMPNOP(sizeof (int64_t) < 8 ? 0 : (uint64_t)0x08070605 << 32
 | 0x04030201);
*cast64_to_32 = false;

/* Find real size of result (highest non-zero byte).  */
if (n->base_addr)
  for (tmpn = n->n, rsize = 0; tmpn; tmpn >>= BITS_PER_MARKER8, rsize++);
else
  rsize = n->range;

/* Zero out the bits corresponding to untouched bytes in original gimple
   expression.  */
if (n->range < (int) sizeof (int64_t))
  {
    mask = ((uint64_t) 1 << (n->range * BITS_PER_MARKER8)) - 1;
    if (n->base_addr == NULLnullptr
 && n->range == 4
 && int_size_in_bytes (TREE_TYPE (n->src)((contains_struct_check ((n->src), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 844, __FUNCTION__))->typed.type)) == 8)
{
 /* If all bytes in n->n are either 0 or in [5..8] range, this
    might be a candidate for (unsigned) __builtin_bswap64 (src).
    It is not worth it for (unsigned short) __builtin_bswap64 (src)
    or (unsigned short) __builtin_bswap32 (src).  */
 *cast64_to_32 = true;
 for (tmpn = n->n; tmpn; tmpn >>= BITS_PER_MARKER8)
   if ((tmpn & MARKER_MASK((1 << 8) - 1))
&& ((tmpn & MARKER_MASK((1 << 8) - 1)) <= 4 || (tmpn & MARKER_MASK((1 << 8) - 1)) > 8))
     {
*cast64_to_32 = false;
break;
     }
}
    if (*cast64_to_32)
*cmpxchg &= mask;
    else
*cmpxchg >>= (64 / BITS_PER_MARKER8 - n->range) * BITS_PER_MARKER8;
    *cmpnop &= mask;
  }

/* Zero out the bits corresponding to unused bytes in the result of the
   gimple expression.  */
if (rsize < n->range)
  {
    if (BYTES_BIG_ENDIAN0)
{
 mask = ((uint64_t) 1 << (rsize * BITS_PER_MARKER8)) - 1;
 *cmpxchg &= mask;
 if (n->range - rsize == sizeof (int64_t))
   *cmpnop = 0;
 else
   *cmpnop >>= (n->range - rsize) * BITS_PER_MARKER8;
}
    else
{
 mask = ((uint64_t) 1 << (rsize * BITS_PER_MARKER8)) - 1;
 if (n->range - rsize == sizeof (int64_t))
   *cmpxchg = 0;
 else
   *cmpxchg >>= (n->range - rsize) * BITS_PER_MARKER8;
 *cmpnop &= mask;
}
    n->range = rsize;
  }

if (*cast64_to_32)
  n->range = 8;
n->range *= BITS_PER_UNIT(8);
894}

896/* Check if STMT completes a bswap implementation or a read in a given
 endianness consisting of ORs, SHIFTs and ANDs and sets *BSWAP
 accordingly.  It also sets N to represent the kind of operations
 performed: size of the resulting expression and whether it works on
 a memory source, and if so alias-set and vuse.  At last, the
 function returns a stmt whose rhs's first tree is the source
 expression.  */

904gimple *
905find_bswap_or_nop (gimple *stmt, struct symbolic_number *n, bool *bswap,
   bool *cast64_to_32, uint64_t *mask)
907{
tree type_size = TYPE_SIZE_UNIT (TREE_TYPE (gimple_get_lhs (stmt)))((tree_class_check ((((contains_struct_check ((gimple_get_lhs
 (stmt)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 908, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 908, __FUNCTION__))->type_common.size_unit);
if (!tree_fits_uhwi_p (type_size))
  return NULLnullptr;

/* The last parameter determines the depth search limit.  It usually
   correlates directly to the number n of bytes to be touched.  We
   increase that number by 2 * (log2(n) + 1) here in order to also
   cover signed -> unsigned conversions of the src operand as can be seen
   in libgcc, and for initial shift/and operation of the src operand.  */
int limit = tree_to_uhwi (type_size);
limit += 2 * (1 + (int) ceil_log2 ((unsigned HOST_WIDE_INTlong) limit));
gimple *ins_stmt = find_bswap_or_nop_1 (stmt, n, limit);

if (!ins_stmt)
  {
    if (gimple_assign_rhs_code (stmt) != CONSTRUCTOR
 || BYTES_BIG_ENDIAN0 != WORDS_BIG_ENDIAN0)
return NULLnullptr;
    unsigned HOST_WIDE_INTlong sz = tree_to_uhwi (type_size) * BITS_PER_UNIT(8);
    if (sz != 16 && sz != 32 && sz != 64)
return NULLnullptr;
    tree rhs = gimple_assign_rhs1 (stmt);
    if (CONSTRUCTOR_NELTS (rhs)(vec_safe_length (((tree_check ((rhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 930, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))) == 0)
return NULLnullptr;
    tree eltype = TREE_TYPE (TREE_TYPE (rhs))((contains_struct_check ((((contains_struct_check ((rhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 932, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 932, __FUNCTION__))->typed.type);
    unsigned HOST_WIDE_INTlong eltsz
= int_size_in_bytes (eltype) * BITS_PER_UNIT(8);
    if (TYPE_PRECISION (eltype)((tree_class_check ((eltype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 935, __FUNCTION__))->type_common.precision) != eltsz)
return NULLnullptr;
    constructor_elt *elt;
    unsigned int i;
    tree type = build_nonstandard_integer_type (sz, 1);
    FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (rhs), i, elt)for (i = 0; vec_safe_iterate ((((tree_check ((rhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 940, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)), (
i), &(elt)); ++(i))
{
 if (TREE_CODE (elt->value)((enum tree_code) (elt->value)->base.code) != SSA_NAME
     || !INTEGRAL_TYPE_P (TREE_TYPE (elt->value))(((enum tree_code) (((contains_struct_check ((elt->value),
 (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 943, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((elt->value
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 943, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((elt->value
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 943, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
))
   return NULLnullptr;
 struct symbolic_number n1;
 gimple *source_stmt
   = find_bswap_or_nop_1 (SSA_NAME_DEF_STMT (elt->value)(tree_check ((elt->value), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 947, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt, &n1,
		   limit - 1);

 if (!source_stmt)
   return NULLnullptr;

 n1.type = type;
 if (!n1.base_addr)
   n1.range = sz / BITS_PER_UNIT(8);

 if (i == 0)
   {
     ins_stmt = source_stmt;
     *n = n1;
   }
 else
   {
     if (n->vuse != n1.vuse)
return NULLnullptr;

     struct symbolic_number n0 = *n;

     if (!BYTES_BIG_ENDIAN0)
{
  if (!do_shift_rotate (LSHIFT_EXPR, &n1, i * eltsz))
    return NULLnullptr;
}
     else if (!do_shift_rotate (LSHIFT_EXPR, &n0, eltsz))
return NULLnullptr;
     ins_stmt
= perform_symbolic_merge (ins_stmt, &n0, source_stmt, &n1, n,
			  BIT_IOR_EXPR);

     if (!ins_stmt)
return NULLnullptr;
   }
}
  }

uint64_t cmpxchg, cmpnop;
find_bswap_or_nop_finalize (n, &cmpxchg, &cmpnop, cast64_to_32);

/* A complete byte swap should make the symbolic number to start with
   the largest digit in the highest order byte. Unchanged symbolic
   number indicates a read with same endianness as target architecture.  */
*mask = ~(uint64_t) 0;
if (n->n == cmpnop)
  *bswap = false;
else if (n->n == cmpxchg)
  *bswap = true;
else
  {
    int set = 0;
    for (uint64_t msk = MARKER_MASK((1 << 8) - 1); msk; msk <<= BITS_PER_MARKER8)
if ((n->n & msk) == 0)
 *mask &= ~msk;
else if ((n->n & msk) == (cmpxchg & msk))
 set++;
else
 return NULLnullptr;
    if (set < 2)
return NULLnullptr;
    *bswap = true;
  }

/* Useless bit manipulation performed by code.  */
if (!n->base_addr && n->n == cmpnop && n->n_ops == 1)
  return NULLnullptr;

return ins_stmt;
1017}

1019const pass_data pass_data_optimize_bswap =
1020{
GIMPLE_PASS, /* type */
"bswap", /* name */
OPTGROUP_NONE, /* optinfo_flags */
TV_NONE, /* tv_id */
PROP_ssa(1 << 5), /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
0, /* todo_flags_finish */
1030};

1032class pass_optimize_bswap : public gimple_opt_pass
1033{
1034public:
pass_optimize_bswap (gcc::context *ctxt)
  : gimple_opt_pass (pass_data_optimize_bswap, ctxt)
{}

/* opt_pass methods: */
bool gate (function *) final override
  {
    return flag_expensive_optimizationsglobal_options.x_flag_expensive_optimizations && optimizeglobal_options.x_optimize && BITS_PER_UNIT(8) == 8;
  }

unsigned int execute (function *) final override;

1047}; // class pass_optimize_bswap

1049/* Helper function for bswap_replace.  Build VIEW_CONVERT_EXPR from
 VAL to TYPE.  If VAL has different type size, emit a NOP_EXPR cast
 first.  */

1053static tree
1054bswap_view_convert (gimple_stmt_iterator *gsi, tree type, tree val,
    bool before)
1056{
gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (val))((void)(!((((enum tree_code) (((contains_struct_check ((val),
 (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1057, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((val), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1057, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((val), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1057, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
) || (((enum tree_code) (((contains_struct_check ((val), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1058, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((val), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1058, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1058, __FUNCTION__), 0 : 0))
     || POINTER_TYPE_P (TREE_TYPE (val)))((void)(!((((enum tree_code) (((contains_struct_check ((val),
 (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1057, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((val), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1057, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((val), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1057, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
) || (((enum tree_code) (((contains_struct_check ((val), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1058, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((val), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1058, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1058, __FUNCTION__), 0 : 0));
if (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1059, __FUNCTION__))->type_common.size) != TYPE_SIZE (TREE_TYPE (val))((tree_class_check ((((contains_struct_check ((val), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1059, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1059, __FUNCTION__))->type_common.size))
  {
    HOST_WIDE_INTlong prec = TREE_INT_CST_LOW (TYPE_SIZE (type))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
 ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1061, __FUNCTION__))->type_common.size)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1061, __FUNCTION__)));
    if (POINTER_TYPE_P (TREE_TYPE (val))(((enum tree_code) (((contains_struct_check ((val), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1062, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((val), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1062, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
{
 gimple *g
   = gimple_build_assign (make_ssa_name (pointer_sized_int_nodeglobal_trees[TI_POINTER_SIZED_TYPE]),
		   NOP_EXPR, val);
 if (before)
   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 else
   gsi_insert_after (gsi, g, GSI_NEW_STMT);
 val = gimple_assign_lhs (g);
}
    tree itype = build_nonstandard_integer_type (prec, 1);
    gimple *g = gimple_build_assign (make_ssa_name (itype), NOP_EXPR, val);
    if (before)
gsi_insert_before (gsi, g, GSI_SAME_STMT);
    else
gsi_insert_after (gsi, g, GSI_NEW_STMT);
    val = gimple_assign_lhs (g);
  }
return build1 (VIEW_CONVERT_EXPR, type, val);
1082}

1084/* Perform the bswap optimization: replace the expression computed in the rhs
 of gsi_stmt (GSI) (or if NULL add instead of replace) by an equivalent
 bswap, load or load + bswap expression.
 Which of these alternatives replace the rhs is given by N->base_addr (non
 null if a load is needed) and BSWAP.  The type, VUSE and set-alias of the
 load to perform are also given in N while the builtin bswap invoke is given
 in FNDEL.  Finally, if a load is involved, INS_STMT refers to one of the
 load statements involved to construct the rhs in gsi_stmt (GSI) and
 N->range gives the size of the rhs expression for maintaining some
 statistics.

 Note that if the replacement involve a load and if gsi_stmt (GSI) is
 non-NULL, that stmt is moved just after INS_STMT to do the load with the
 same VUSE which can lead to gsi_stmt (GSI) changing of basic block.  */

1099tree
1100bswap_replace (gimple_stmt_iterator gsi, gimple *ins_stmt, tree fndecl,
      tree bswap_type, tree load_type, struct symbolic_number *n,
      bool bswap, uint64_t mask)
1103{
tree src, tmp, tgt = NULL_TREE(tree) nullptr;
gimple *bswap_stmt, *mask_stmt = NULLnullptr;
tree_code conv_code = NOP_EXPR;

gimple *cur_stmt = gsi_stmt (gsi);
src = n->src;
if (cur_stmt)
  {
    tgt = gimple_assign_lhs (cur_stmt);
    if (gimple_assign_rhs_code (cur_stmt) == CONSTRUCTOR
 && tgt
 && VECTOR_TYPE_P (TREE_TYPE (tgt))(((enum tree_code) (((contains_struct_check ((tgt), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1115, __FUNCTION__))->typed.type))->base.code) == VECTOR_TYPE
))
conv_code = VIEW_CONVERT_EXPR;
  }

/* Need to load the value from memory first.  */
if (n->base_addr)
  {
    gimple_stmt_iterator gsi_ins = gsi;
    if (ins_stmt)
gsi_ins = gsi_for_stmt (ins_stmt);
    tree addr_expr, addr_tmp, val_expr, val_tmp;
    tree load_offset_ptr, aligned_load_type;
    gimple *load_stmt;
    unsigned align = get_object_alignment (src);
    poly_int64 load_offset = 0;

    if (cur_stmt)
{
 basic_block ins_bb = gimple_bb (ins_stmt);
 basic_block cur_bb = gimple_bb (cur_stmt);
 if (!dominated_by_p (CDI_DOMINATORS, cur_bb, ins_bb))
   return NULL_TREE(tree) nullptr;

 /* Move cur_stmt just before one of the load of the original
    to ensure it has the same VUSE.  See PR61517 for what could
    go wrong.  */
 if (gimple_bb (cur_stmt) != gimple_bb (ins_stmt))
   reset_flow_sensitive_info (gimple_assign_lhs (cur_stmt));
 gsi_move_before (&gsi, &gsi_ins);
 gsi = gsi_for_stmt (cur_stmt);
}
    else
gsi = gsi_ins;

    /* Compute address to load from and cast according to the size
of the load.  */
    addr_expr = build_fold_addr_expr (src)build_fold_addr_expr_loc (((location_t) 0), (src));
    if (is_gimple_mem_ref_addr (addr_expr))
addr_tmp = unshare_expr (addr_expr);
    else
{
 addr_tmp = unshare_expr (n->base_addr);
 if (!is_gimple_mem_ref_addr (addr_tmp))
   addr_tmp = force_gimple_operand_gsi_1 (&gsi, addr_tmp,
				   is_gimple_mem_ref_addr,
				   NULL_TREE(tree) nullptr, true,
				   GSI_SAME_STMT);
 load_offset = n->bytepos;
 if (n->offset)
   {
     tree off
= force_gimple_operand_gsi (&gsi, unshare_expr (n->offset),
			    true, NULL_TREE(tree) nullptr, true,
			    GSI_SAME_STMT);
     gimple *stmt
= gimple_build_assign (make_ssa_name (TREE_TYPE (addr_tmp)((contains_struct_check ((addr_tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1170, __FUNCTION__))->typed.type)),
		       POINTER_PLUS_EXPR, addr_tmp, off);
     gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
     addr_tmp = gimple_assign_lhs (stmt);
   }
}

    /* Perform the load.  */
    aligned_load_type = load_type;
    if (align < TYPE_ALIGN (load_type)(((tree_class_check ((load_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1179, __FUNCTION__))->type_common.align) ? ((unsigned)1)
 << (((tree_class_check ((load_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1179, __FUNCTION__))->type_common.align) - 1) : 0))
aligned_load_type = build_aligned_type (load_type, align);
    load_offset_ptr = build_int_cst (n->alias_set, load_offset);
    val_expr = fold_build2 (MEM_REF, aligned_load_type, addr_tmp,fold_build2_loc (((location_t) 0), MEM_REF, aligned_load_type
, addr_tmp, load_offset_ptr )
	      load_offset_ptr)fold_build2_loc (((location_t) 0), MEM_REF, aligned_load_type
, addr_tmp, load_offset_ptr );

    if (!bswap)
{
 if (n->range == 16)
   nop_stats.found_16bit++;
 else if (n->range == 32)
   nop_stats.found_32bit++;
 else
   {
     gcc_assert (n->range == 64)((void)(!(n->range == 64) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1193, __FUNCTION__), 0 : 0));
     nop_stats.found_64bit++;
   }

 /* Convert the result of load if necessary.  */
 if (tgt && !useless_type_conversion_p (TREE_TYPE (tgt)((contains_struct_check ((tgt), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1198, __FUNCTION__))->typed.type), load_type))
   {
     val_tmp = make_temp_ssa_name (aligned_load_type, NULLnullptr,
			    "load_dst");
     load_stmt = gimple_build_assign (val_tmp, val_expr);
     gimple_set_vuse (load_stmt, n->vuse);
     gsi_insert_before (&gsi, load_stmt, GSI_SAME_STMT);
     if (conv_code == VIEW_CONVERT_EXPR)
val_tmp = bswap_view_convert (&gsi, TREE_TYPE (tgt)((contains_struct_check ((tgt), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1206, __FUNCTION__))->typed.type), val_tmp,
			      true);
     gimple_assign_set_rhs_with_ops (&gsi, conv_code, val_tmp);
     update_stmt (cur_stmt);
   }
 else if (cur_stmt)
   {
     gimple_assign_set_rhs_with_ops (&gsi, MEM_REF, val_expr);
     gimple_set_vuse (cur_stmt, n->vuse);
     update_stmt (cur_stmt);
   }
 else
   {
     tgt = make_ssa_name (load_type);
     cur_stmt = gimple_build_assign (tgt, MEM_REF, val_expr);
     gimple_set_vuse (cur_stmt, n->vuse);
     gsi_insert_before (&gsi, cur_stmt, GSI_SAME_STMT);
   }

 if (dump_file)
   {
     fprintf (dump_file,
       "%d bit load in target endianness found at: ",
       (int) n->range);
     print_gimple_stmt (dump_file, cur_stmt, 0);
   }
 return tgt;
}
    else
{
 val_tmp = make_temp_ssa_name (aligned_load_type, NULLnullptr, "load_dst");
 load_stmt = gimple_build_assign (val_tmp, val_expr);
 gimple_set_vuse (load_stmt, n->vuse);
 gsi_insert_before (&gsi, load_stmt, GSI_SAME_STMT);
}
    src = val_tmp;
  }
else if (!bswap)
  {
    gimple *g = NULLnullptr;
    if (tgt && !useless_type_conversion_p (TREE_TYPE (tgt)((contains_struct_check ((tgt), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1246, __FUNCTION__))->typed.type), TREE_TYPE (src)((contains_struct_check ((src), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1246, __FUNCTION__))->typed.type)))
{
 if (!is_gimple_val (src))
   return NULL_TREE(tree) nullptr;
 if (conv_code == VIEW_CONVERT_EXPR)
   src = bswap_view_convert (&gsi, TREE_TYPE (tgt)((contains_struct_check ((tgt), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1251, __FUNCTION__))->typed.type), src, true);
 g = gimple_build_assign (tgt, conv_code, src);
}
    else if (cur_stmt)
g = gimple_build_assign (tgt, src);
    else
tgt = src;
    if (n->range == 16)
nop_stats.found_16bit++;
    else if (n->range == 32)
nop_stats.found_32bit++;
    else
{
 gcc_assert (n->range == 64)((void)(!(n->range == 64) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1264, __FUNCTION__), 0 : 0));
 nop_stats.found_64bit++;
}
    if (dump_file)
{
 fprintf (dump_file,
   "%d bit reshuffle in target endianness found at: ",
   (int) n->range);
 if (cur_stmt)
   print_gimple_stmt (dump_file, cur_stmt, 0);
 else
   {
     print_generic_expr (dump_file, tgt, TDF_NONE);
     fprintf (dump_file, "\n");
   }
}
    if (cur_stmt)
gsi_replace (&gsi, g, true);
    return tgt;
  }
else if (TREE_CODE (src)((enum tree_code) (src)->base.code) == BIT_FIELD_REF)
  src = TREE_OPERAND (src, 0)(*((const_cast<tree*> (tree_operand_check ((src), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1285, __FUNCTION__)))));

if (n->range == 16)
  bswap_stats.found_16bit++;
else if (n->range == 32)
  bswap_stats.found_32bit++;
else
  {
    gcc_assert (n->range == 64)((void)(!(n->range == 64) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1293, __FUNCTION__), 0 : 0));
    bswap_stats.found_64bit++;
  }

tmp = src;

/* Convert the src expression if necessary.  */
if (!useless_type_conversion_p (TREE_TYPE (tmp)((contains_struct_check ((tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1300, __FUNCTION__))->typed.type), bswap_type))
  {
    gimple *convert_stmt;

    tmp = make_temp_ssa_name (bswap_type, NULLnullptr, "bswapsrc");
    convert_stmt = gimple_build_assign (tmp, NOP_EXPR, src);
    gsi_insert_before (&gsi, convert_stmt, GSI_SAME_STMT);
  }

/* Canonical form for 16 bit bswap is a rotate expression.  Only 16bit values
   are considered as rotation of 2N bit values by N bits is generally not
   equivalent to a bswap.  Consider for instance 0x01020304 r>> 16 which
   gives 0x03040102 while a bswap for that value is 0x04030201.  */
if (bswap && n->range == 16)
  {
    tree count = build_int_cst (NULLnullptr, BITS_PER_UNIT(8));
    src = fold_build2 (LROTATE_EXPR, bswap_type, tmp, count)fold_build2_loc (((location_t) 0), LROTATE_EXPR, bswap_type, tmp
, count );
    bswap_stmt = gimple_build_assign (NULLnullptr, src);
  }
else
  bswap_stmt = gimple_build_call (fndecl, 1, tmp);

if (tgt == NULL_TREE(tree) nullptr)
  tgt = make_ssa_name (bswap_type);
tmp = tgt;

if (mask != ~(uint64_t) 0)
  {
    tree m = build_int_cst (bswap_type, mask);
    tmp = make_temp_ssa_name (bswap_type, NULLnullptr, "bswapdst");
    gimple_set_lhs (bswap_stmt, tmp);
    mask_stmt = gimple_build_assign (tgt, BIT_AND_EXPR, tmp, m);
    tmp = tgt;
  }

/* Convert the result if necessary.  */
if (!useless_type_conversion_p (TREE_TYPE (tgt)((contains_struct_check ((tgt), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1336, __FUNCTION__))->typed.type), bswap_type))
  {
    tmp = make_temp_ssa_name (bswap_type, NULLnullptr, "bswapdst");
    tree atmp = tmp;
    gimple_stmt_iterator gsi2 = gsi;
    if (conv_code == VIEW_CONVERT_EXPR)
atmp = bswap_view_convert (&gsi2, TREE_TYPE (tgt)((contains_struct_check ((tgt), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1342, __FUNCTION__))->typed.type), tmp, false);
    gimple *convert_stmt = gimple_build_assign (tgt, conv_code, atmp);
    gsi_insert_after (&gsi2, convert_stmt, GSI_SAME_STMT);
  }

gimple_set_lhs (mask_stmt ? mask_stmt : bswap_stmt, tmp);

if (dump_file)
  {
    fprintf (dump_file, "%d bit bswap implementation found at: ",
      (int) n->range);
    if (cur_stmt)
print_gimple_stmt (dump_file, cur_stmt, 0);
    else
{
 print_generic_expr (dump_file, tgt, TDF_NONE);
 fprintf (dump_file, "\n");
}
  }

if (cur_stmt)
  {
    if (mask_stmt)
gsi_insert_after (&gsi, mask_stmt, GSI_SAME_STMT);
    gsi_insert_after (&gsi, bswap_stmt, GSI_SAME_STMT);
    gsi_remove (&gsi, true);
  }
else
  {
    gsi_insert_before (&gsi, bswap_stmt, GSI_SAME_STMT);
    if (mask_stmt)
gsi_insert_before (&gsi, mask_stmt, GSI_SAME_STMT);
  }
return tgt;
1376}

1378/* Try to optimize an assignment CUR_STMT with CONSTRUCTOR on the rhs
 using bswap optimizations.  CDI_DOMINATORS need to be
 computed on entry.  Return true if it has been optimized and
 TODO_update_ssa is needed.  */

1383static bool
1384maybe_optimize_vector_constructor (gimple *cur_stmt)
1385{
tree fndecl = NULL_TREE(tree) nullptr, bswap_type = NULL_TREE(tree) nullptr, load_type;
struct symbolic_number n;
bool bswap;

gcc_assert (is_gimple_assign (cur_stmt)((void)(!(is_gimple_assign (cur_stmt) && gimple_assign_rhs_code
 (cur_stmt) == CONSTRUCTOR) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1391, __FUNCTION__), 0 : 0))
     && gimple_assign_rhs_code (cur_stmt) == CONSTRUCTOR)((void)(!(is_gimple_assign (cur_stmt) && gimple_assign_rhs_code
 (cur_stmt) == CONSTRUCTOR) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1391, __FUNCTION__), 0 : 0));

tree rhs = gimple_assign_rhs1 (cur_stmt);
if (!VECTOR_TYPE_P (TREE_TYPE (rhs))(((enum tree_code) (((contains_struct_check ((rhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1394, __FUNCTION__))->typed.type))->base.code) == VECTOR_TYPE
)
    || !INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (rhs)))(((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1395, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1395, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1395, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1395, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1395, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1395, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
    || gimple_assign_lhs (cur_stmt) == NULL_TREE(tree) nullptr)
  return false;

HOST_WIDE_INTlong sz = int_size_in_bytes (TREE_TYPE (rhs)((contains_struct_check ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1399, __FUNCTION__))->typed.type)) * BITS_PER_UNIT(8);
switch (sz)
  {
  case 16:
    load_type = bswap_type = uint16_type_nodeglobal_trees[TI_UINT16_TYPE];
    break;
  case 32:
    if (builtin_decl_explicit_p (BUILT_IN_BSWAP32)
 && optab_handler (bswap_optab, SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode))) != CODE_FOR_nothing)
{
 load_type = uint32_type_nodeglobal_trees[TI_UINT32_TYPE];
 fndecl = builtin_decl_explicit (BUILT_IN_BSWAP32);
 bswap_type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))((tree_check ((((tree_check2 ((((contains_struct_check ((fndecl
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1411, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1411, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1411, __FUNCTION__, (TREE_LIST)))->list.value);
}
    else
return false;
    break;
  case 64:
    if (builtin_decl_explicit_p (BUILT_IN_BSWAP64)
 && (optab_handler (bswap_optab, DImode(scalar_int_mode ((scalar_int_mode::from_int) E_DImode))) != CODE_FOR_nothing
     || (word_mode == SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
  && builtin_decl_explicit_p (BUILT_IN_BSWAP32)
  && optab_handler (bswap_optab, SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode))) != CODE_FOR_nothing)))
{
 load_type = uint64_type_nodeglobal_trees[TI_UINT64_TYPE];
 fndecl = builtin_decl_explicit (BUILT_IN_BSWAP64);
 bswap_type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))((tree_check ((((tree_check2 ((((contains_struct_check ((fndecl
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1425, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1425, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1425, __FUNCTION__, (TREE_LIST)))->list.value);
}
    else
return false;
    break;
  default:
    return false;
  }

bool cast64_to_32;
uint64_t mask;
gimple *ins_stmt = find_bswap_or_nop (cur_stmt, &n, &bswap,
			&cast64_to_32, &mask);
if (!ins_stmt
    || n.range != (unsigned HOST_WIDE_INTlong) sz
    || cast64_to_32
    || mask != ~(uint64_t) 0)
  return false;

if (bswap && !fndecl && n.range != 16)
  return false;

memset (&nop_stats, 0, sizeof (nop_stats));
memset (&bswap_stats, 0, sizeof (bswap_stats));
return bswap_replace (gsi_for_stmt (cur_stmt), ins_stmt, fndecl,
	bswap_type, load_type, &n, bswap, mask) != NULL_TREE(tree) nullptr;
1451}

1453/* Find manual byte swap implementations as well as load in a given
 endianness. Byte swaps are turned into a bswap builtin invokation
 while endian loads are converted to bswap builtin invokation or
 simple load according to the target endianness.  */

1458unsigned int
1459pass_optimize_bswap::execute (function *fun)
1460{
basic_block bb;
bool bswap32_p, bswap64_p;
bool changed = false;
tree bswap32_type = NULL_TREE(tree) nullptr, bswap64_type = NULL_TREE(tree) nullptr;

bswap32_p = (builtin_decl_explicit_p (BUILT_IN_BSWAP32)
      && optab_handler (bswap_optab, SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode))) != CODE_FOR_nothing);
bswap64_p = (builtin_decl_explicit_p (BUILT_IN_BSWAP64)
      && (optab_handler (bswap_optab, DImode(scalar_int_mode ((scalar_int_mode::from_int) E_DImode))) != CODE_FOR_nothing
   || (bswap32_p && word_mode == SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode)))));

/* Determine the argument type of the builtins.  The code later on
   assumes that the return and argument type are the same.  */
if (bswap32_p)
  {
    tree fndecl = builtin_decl_explicit (BUILT_IN_BSWAP32);
    bswap32_type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))((tree_check ((((tree_check2 ((((contains_struct_check ((fndecl
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1477, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1477, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1477, __FUNCTION__, (TREE_LIST)))->list.value);
  }

if (bswap64_p)
  {
    tree fndecl = builtin_decl_explicit (BUILT_IN_BSWAP64);
    bswap64_type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))((tree_check ((((tree_check2 ((((contains_struct_check ((fndecl
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1483, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1483, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1483, __FUNCTION__, (TREE_LIST)))->list.value);
  }

memset (&nop_stats, 0, sizeof (nop_stats));
memset (&bswap_stats, 0, sizeof (bswap_stats));
calculate_dominance_info (CDI_DOMINATORS);

FOR_EACH_BB_FN (bb, fun)for (bb = (fun)->cfg->x_entry_block_ptr->next_bb; bb
 != (fun)->cfg->x_exit_block_ptr; bb = bb->next_bb)
  {
    gimple_stmt_iterator gsi;

    /* We do a reverse scan for bswap patterns to make sure we get the
widest match. As bswap pattern matching doesn't handle previously
inserted smaller bswap replacements as sub-patterns, the wider
variant wouldn't be detected.  */
    for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi);)
{
 gimple *ins_stmt, *cur_stmt = gsi_stmt (gsi);
 tree fndecl = NULL_TREE(tree) nullptr, bswap_type = NULL_TREE(tree) nullptr, load_type;
 enum tree_code code;
 struct symbolic_number n;
 bool bswap, cast64_to_32;
 uint64_t mask;

 /* This gsi_prev (&gsi) is not part of the for loop because cur_stmt
    might be moved to a different basic block by bswap_replace and gsi
    must not points to it if that's the case.  Moving the gsi_prev
    there make sure that gsi points to the statement previous to
    cur_stmt while still making sure that all statements are
    considered in this basic block.  */
 gsi_prev (&gsi);

 if (!is_gimple_assign (cur_stmt))
   continue;

 code = gimple_assign_rhs_code (cur_stmt);
 switch (code)
   {
   case LROTATE_EXPR:
   case RROTATE_EXPR:
     if (!tree_fits_uhwi_p (gimple_assign_rhs2 (cur_stmt))
  || tree_to_uhwi (gimple_assign_rhs2 (cur_stmt))
     % BITS_PER_UNIT(8))
continue;
     /* Fall through.  */
   case BIT_IOR_EXPR:
   case BIT_XOR_EXPR:
   case PLUS_EXPR:
     break;
   case CONSTRUCTOR:
     {
tree rhs = gimple_assign_rhs1 (cur_stmt);
if (VECTOR_TYPE_P (TREE_TYPE (rhs))(((enum tree_code) (((contains_struct_check ((rhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1535, __FUNCTION__))->typed.type))->base.code) == VECTOR_TYPE
)
    && INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (rhs)))(((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1536, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1536, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1536, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1536, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1536, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1536, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
))
  break;
     }
     continue;
   default:
     continue;
   }

 ins_stmt = find_bswap_or_nop (cur_stmt, &n, &bswap,
			&cast64_to_32, &mask);

 if (!ins_stmt)
   continue;

 switch (n.range)
   {
   case 16:
     /* Already in canonical form, nothing to do.  */
     if (code == LROTATE_EXPR || code == RROTATE_EXPR)
continue;
     load_type = bswap_type = uint16_type_nodeglobal_trees[TI_UINT16_TYPE];
     break;
   case 32:
     load_type = uint32_type_nodeglobal_trees[TI_UINT32_TYPE];
     if (bswap32_p)
{
  fndecl = builtin_decl_explicit (BUILT_IN_BSWAP32);
  bswap_type = bswap32_type;
}
     break;
   case 64:
     load_type = uint64_type_nodeglobal_trees[TI_UINT64_TYPE];
     if (bswap64_p)
{
  fndecl = builtin_decl_explicit (BUILT_IN_BSWAP64);
  bswap_type = bswap64_type;
}
     break;
   default:
     continue;
   }

 if (bswap && !fndecl && n.range != 16)
   continue;

 if (bswap_replace (gsi_for_stmt (cur_stmt), ins_stmt, fndecl,
	     bswap_type, load_type, &n, bswap, mask))
   changed = true;
}
  }

statistics_counter_event (fun, "16-bit nop implementations found",
	    nop_stats.found_16bit);
statistics_counter_event (fun, "32-bit nop implementations found",
	    nop_stats.found_32bit);
statistics_counter_event (fun, "64-bit nop implementations found",
	    nop_stats.found_64bit);
statistics_counter_event (fun, "16-bit bswap implementations found",
	    bswap_stats.found_16bit);
statistics_counter_event (fun, "32-bit bswap implementations found",
	    bswap_stats.found_32bit);
statistics_counter_event (fun, "64-bit bswap implementations found",
	    bswap_stats.found_64bit);

return (changed ? TODO_update_ssa(1 << 11) : 0);
1601}

1603} // anon namespace

1605gimple_opt_pass *
1606make_pass_optimize_bswap (gcc::context *ctxt)
1607{
return new pass_optimize_bswap (ctxt);
1609}

1611namespace {

1613/* Struct recording one operand for the store, which is either a constant,
 then VAL represents the constant and all the other fields are zero, or
 a memory load, then VAL represents the reference, BASE_ADDR is non-NULL
 and the other fields also reflect the memory load, or an SSA name, then
 VAL represents the SSA name and all the other fields are zero.  */

1619class store_operand_info
1620{
1621public:
tree val;
tree base_addr;
poly_uint64 bitsize;
poly_uint64 bitpos;
poly_uint64 bitregion_start;
poly_uint64 bitregion_end;
gimple *stmt;
bool bit_not_p;
store_operand_info ();
1631};

1633store_operand_info::store_operand_info ()
: val (NULL_TREE(tree) nullptr), base_addr (NULL_TREE(tree) nullptr), bitsize (0), bitpos (0),
  bitregion_start (0), bitregion_end (0), stmt (NULLnullptr), bit_not_p (false)
1636{
1637}

1639/* Struct recording the information about a single store of an immediate
 to memory.  These are created in the first phase and coalesced into
 merged_store_group objects in the second phase.  */

1643class store_immediate_info
1644{
1645public:
unsigned HOST_WIDE_INTlong bitsize;
unsigned HOST_WIDE_INTlong bitpos;
unsigned HOST_WIDE_INTlong bitregion_start;
/* This is one past the last bit of the bit region.  */
unsigned HOST_WIDE_INTlong bitregion_end;
gimple *stmt;
unsigned int order;
/* INTEGER_CST for constant store, STRING_CST for string store,
   MEM_REF for memory copy, BIT_*_EXPR for logical bitwise operation,
   BIT_INSERT_EXPR for bit insertion.
   LROTATE_EXPR if it can be only bswap optimized and
   ops are not really meaningful.
   NOP_EXPR if bswap optimization detected identity, ops
   are not meaningful.  */
enum tree_code rhs_code;
/* Two fields for bswap optimization purposes.  */
struct symbolic_number n;
gimple *ins_stmt;
/* True if BIT_{AND,IOR,XOR}_EXPR result is inverted before storing.  */
bool bit_not_p;
/* True if ops have been swapped and thus ops[1] represents
   rhs1 of BIT_{AND,IOR,XOR}_EXPR and ops[0] represents rhs2.  */
bool ops_swapped_p;
/* The index number of the landing pad, or 0 if there is none.  */
int lp_nr;
/* Operands.  For BIT_*_EXPR rhs_code both operands are used, otherwise
   just the first one.  */
store_operand_info ops[2];
store_immediate_info (unsigned HOST_WIDE_INTlong, unsigned HOST_WIDE_INTlong,
	unsigned HOST_WIDE_INTlong, unsigned HOST_WIDE_INTlong,
	gimple *, unsigned int, enum tree_code,
	struct symbolic_number &, gimple *, bool, int,
	const store_operand_info &,
	const store_operand_info &);
1680};

1682store_immediate_info::store_immediate_info (unsigned HOST_WIDE_INTlong bs,
			    unsigned HOST_WIDE_INTlong bp,
			    unsigned HOST_WIDE_INTlong brs,
			    unsigned HOST_WIDE_INTlong bre,
			    gimple *st,
			    unsigned int ord,
			    enum tree_code rhscode,
			    struct symbolic_number &nr,
			    gimple *ins_stmtp,
			    bool bitnotp,
			    int nr2,
			    const store_operand_info &op0r,
			    const store_operand_info &op1r)
: bitsize (bs), bitpos (bp), bitregion_start (brs), bitregion_end (bre),
  stmt (st), order (ord), rhs_code (rhscode), n (nr),
  ins_stmt (ins_stmtp), bit_not_p (bitnotp), ops_swapped_p (false),
  lp_nr (nr2), ops { op0r, op1r }
1699{
1700}

1702/* Struct representing a group of stores to contiguous memory locations.
 These are produced by the second phase (coalescing) and consumed in the
 third phase that outputs the widened stores.  */

1706class merged_store_group
1707{
1708public:
unsigned HOST_WIDE_INTlong start;
unsigned HOST_WIDE_INTlong width;
unsigned HOST_WIDE_INTlong bitregion_start;
unsigned HOST_WIDE_INTlong bitregion_end;
/* The size of the allocated memory for val and mask.  */
unsigned HOST_WIDE_INTlong buf_size;
unsigned HOST_WIDE_INTlong align_base;
poly_uint64 load_align_base[2];

unsigned int align;
unsigned int load_align[2];
unsigned int first_order;
unsigned int last_order;
bool bit_insertion;
bool string_concatenation;
bool only_constants;
bool consecutive;
unsigned int first_nonmergeable_order;
int lp_nr;

auto_vec<store_immediate_info *> stores;
/* We record the first and last original statements in the sequence because
   we'll need their vuse/vdef and replacement position.  It's easier to keep
   track of them separately as 'stores' is reordered by apply_stores.  */
gimple *last_stmt;
gimple *first_stmt;
unsigned char *val;
unsigned char *mask;

merged_store_group (store_immediate_info *);
~merged_store_group ();
bool can_be_merged_into (store_immediate_info *);
void merge_into (store_immediate_info *);
void merge_overlapping (store_immediate_info *);
bool apply_stores ();
1744private:
void do_merge (store_immediate_info *);
1746};

1748/* Debug helper.  Dump LEN elements of byte array PTR to FD in hex.  */

1750static void
1751dump_char_array (FILE *fd, unsigned char *ptr, unsigned int len)
1752{
if (!fd)
  return;

for (unsigned int i = 0; i < len; i++)
  fprintf (fd, "%02x ", ptr[i]);
fprintf (fd, "\n");
1759}

1761/* Clear out LEN bits starting from bit START in the byte array
 PTR.  This clears the bits to the *right* from START.
 START must be within [0, BITS_PER_UNIT) and counts starting from
 the least significant bit.  */

1766static void
1767clear_bit_region_be (unsigned char *ptr, unsigned int start,
     unsigned int len)
1769{
if (len == 0)
  return;
/* Clear len bits to the right of start.  */
else if (len <= start + 1)
  {
    unsigned char mask = (~(~0U << len));
    mask = mask << (start + 1U - len);
    ptr[0] &= ~mask;
  }
else if (start != BITS_PER_UNIT(8) - 1)
  {
    clear_bit_region_be (ptr, start, (start % BITS_PER_UNIT(8)) + 1);
    clear_bit_region_be (ptr + 1, BITS_PER_UNIT(8) - 1,
	   len - (start % BITS_PER_UNIT(8)) - 1);
  }
else if (start == BITS_PER_UNIT(8) - 1
  && len > BITS_PER_UNIT(8))
  {
    unsigned int nbytes = len / BITS_PER_UNIT(8);
    memset (ptr, 0, nbytes);
    if (len % BITS_PER_UNIT(8) != 0)
clear_bit_region_be (ptr + nbytes, BITS_PER_UNIT(8) - 1,
	     len % BITS_PER_UNIT(8));
  }
else
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1795, __FUNCTION__));
1796}

1798/* In the byte array PTR clear the bit region starting at bit
 START and is LEN bits wide.
 For regions spanning multiple bytes do this recursively until we reach
 zero LEN or a region contained within a single byte.  */

1803static void
1804clear_bit_region (unsigned char *ptr, unsigned int start,
  unsigned int len)
1806{
/* Degenerate base case.  */
if (len == 0)
  return;
else if (start >= BITS_PER_UNIT(8))
  clear_bit_region (ptr + 1, start - BITS_PER_UNIT(8), len);
/* Second base case.  */
else if ((start + len) <= BITS_PER_UNIT(8))
  {
    unsigned char mask = (~0U) << (unsigned char) (BITS_PER_UNIT(8) - len);
    mask >>= BITS_PER_UNIT(8) - (start + len);

    ptr[0] &= ~mask;

    return;
  }
/* Clear most significant bits in a byte and proceed with the next byte.  */
else if (start != 0)
  {
    clear_bit_region (ptr, start, BITS_PER_UNIT(8) - start);
    clear_bit_region (ptr + 1, 0, len - (BITS_PER_UNIT(8) - start));
  }
/* Whole bytes need to be cleared.  */
else if (start == 0 && len > BITS_PER_UNIT(8))
  {
    unsigned int nbytes = len / BITS_PER_UNIT(8);
    /* We could recurse on each byte but we clear whole bytes, so a simple
memset will do.  */
    memset (ptr, '\0', nbytes);
    /* Clear the remaining sub-byte region if there is one.  */
    if (len % BITS_PER_UNIT(8) != 0)
clear_bit_region (ptr + nbytes, 0, len % BITS_PER_UNIT(8));
  }
else
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1840, __FUNCTION__));
1841}

1843/* Write BITLEN bits of EXPR to the byte array PTR at
 bit position BITPOS.  PTR should contain TOTAL_BYTES elements.
 Return true if the operation succeeded.  */

1847static bool
1848encode_tree_to_bitpos (tree expr, unsigned char *ptr, int bitlen, int bitpos,
       unsigned int total_bytes)
1850{
unsigned int first_byte = bitpos / BITS_PER_UNIT(8);
bool sub_byte_op_p = ((bitlen % BITS_PER_UNIT(8))
	|| (bitpos % BITS_PER_UNIT(8))
	|| !int_mode_for_size (bitlen, 0).exists ());
bool empty_ctor_p
  = (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == CONSTRUCTOR
     && CONSTRUCTOR_NELTS (expr)(vec_safe_length (((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1857, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))) == 0
     && TYPE_SIZE_UNIT (TREE_TYPE (expr))((tree_class_check ((((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1858, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1858, __FUNCTION__))->type_common.size_unit)
       && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (expr))((tree_class_check ((((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1859, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1859, __FUNCTION__))->type_common.size_unit)));

if (!sub_byte_op_p)
  {
    if (first_byte >= total_bytes)
return false;
    total_bytes -= first_byte;
    if (empty_ctor_p)
{
 unsigned HOST_WIDE_INTlong rhs_bytes
   = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (expr))((tree_class_check ((((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1869, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1869, __FUNCTION__))->type_common.size_unit));
 if (rhs_bytes > total_bytes)
   return false;
 memset (ptr + first_byte, '\0', rhs_bytes);
 return true;
}
    return native_encode_expr (expr, ptr + first_byte, total_bytes) != 0;
  }

/* LITTLE-ENDIAN
   We are writing a non byte-sized quantity or at a position that is not
   at a byte boundary.
   |--------|--------|--------| ptr + first_byte
         ^              ^
         xxx xxxxxxxx xxx< bp>
         |______EXPR____|

   First native_encode_expr EXPR into a temporary buffer and shift each
   byte in the buffer by 'bp' (carrying the bits over as necessary).
   |00000000|00xxxxxx|xxxxxxxx| << bp = |000xxxxx|xxxxxxxx|xxx00000|
                                            <------bitlen---->< bp>
  Then we clear the destination bits:
  |---00000|00000000|000-----| ptr + first_byte
      <-------bitlen--->< bp>

  Finally we ORR the bytes of the shifted EXPR into the cleared region:
  |---xxxxx||xxxxxxxx||xxx-----| ptr + first_byte.

 BIG-ENDIAN
 We are writing a non byte-sized quantity or at a position that is not
 at a byte boundary.
   ptr + first_byte |--------|--------|--------|
                          ^              ^
                     <bp >xxx xxxxxxxx xxx
                          |_____EXPR_____|

   First native_encode_expr EXPR into a temporary buffer and shift each
   byte in the buffer to the right by (carrying the bits over as necessary).
   We shift by as much as needed to align the most significant bit of EXPR
   with bitpos:
   |00xxxxxx|xxxxxxxx| >> 3 = |00000xxx|xxxxxxxx|xxxxx000|
      <---bitlen---->          <bp ><-----bitlen----->
  Then we clear the destination bits:
  ptr + first_byte |-----000||00000000||00000---|
                    <bp ><-------bitlen----->

  Finally we ORR the bytes of the shifted EXPR into the cleared region:
  ptr + first_byte |---xxxxx||xxxxxxxx||xxx-----|.
  The awkwardness comes from the fact that bitpos is counted from the
  most significant bit of a byte.  */

/* We must be dealing with fixed-size data at this point, since the
   total size is also fixed.  */
unsigned int byte_size;
if (empty_ctor_p)
  {
    unsigned HOST_WIDE_INTlong rhs_bytes
= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (expr))((tree_class_check ((((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1926, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1926, __FUNCTION__))->type_common.size_unit));
    if (rhs_bytes > total_bytes)
return false;
    byte_size = rhs_bytes;
  }
else
  {
    fixed_size_mode mode
= as_a <fixed_size_mode> (TYPE_MODE (TREE_TYPE (expr))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1934, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1934, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1934, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1934, __FUNCTION__))->typed.type))->type_common.mode));
    byte_size
= mode == BLKmode((void) 0, E_BLKmode)
? tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (expr))((tree_class_check ((((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1937, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1937, __FUNCTION__))->type_common.size_unit))
: GET_MODE_SIZE (mode);
  }
/* Allocate an extra byte so that we have space to shift into.  */
byte_size++;
unsigned char *tmpbuf = XALLOCAVEC (unsigned char, byte_size)((unsigned char *) __builtin_alloca(sizeof (unsigned char) * (
byte_size)));
memset (tmpbuf, '\0', byte_size);
/* The store detection code should only have allowed constants that are
   accepted by native_encode_expr or empty ctors.  */
if (!empty_ctor_p
    && native_encode_expr (expr, tmpbuf, byte_size - 1) == 0)
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 1948, __FUNCTION__));

/* The native_encode_expr machinery uses TYPE_MODE to determine how many
   bytes to write.  This means it can write more than
   ROUND_UP (bitlen, BITS_PER_UNIT) / BITS_PER_UNIT bytes (for example
   write 8 bytes for a bitlen of 40).  Skip the bytes that are not within
   bitlen and zero out the bits that are not relevant as well (that may
   contain a sign bit due to sign-extension).  */
unsigned int padding
  = byte_size - ROUND_UP (bitlen, BITS_PER_UNIT)(((bitlen) + ((8)) - 1) & ~(((8)) - 1)) / BITS_PER_UNIT(8) - 1;
/* On big-endian the padding is at the 'front' so just skip the initial
   bytes.  */
if (BYTES_BIG_ENDIAN0)
  tmpbuf += padding;

byte_size -= padding;

if (bitlen % BITS_PER_UNIT(8) != 0)
  {
    if (BYTES_BIG_ENDIAN0)
clear_bit_region_be (tmpbuf, BITS_PER_UNIT(8) - 1,
	     BITS_PER_UNIT(8) - (bitlen % BITS_PER_UNIT(8)));
    else
clear_bit_region (tmpbuf, bitlen,
	  byte_size * BITS_PER_UNIT(8) - bitlen);
  }
/* Left shifting relies on the last byte being clear if bitlen is
   a multiple of BITS_PER_UNIT, which might not be clear if
   there are padding bytes.  */
else if (!BYTES_BIG_ENDIAN0)
  tmpbuf[byte_size - 1] = '\0';

/* Clear the bit region in PTR where the bits from TMPBUF will be
   inserted into.  */
if (BYTES_BIG_ENDIAN0)
  clear_bit_region_be (ptr + first_byte,
	 BITS_PER_UNIT(8) - 1 - (bitpos % BITS_PER_UNIT(8)), bitlen);
else
  clear_bit_region (ptr + first_byte, bitpos % BITS_PER_UNIT(8), bitlen);

int shift_amnt;
int bitlen_mod = bitlen % BITS_PER_UNIT(8);
int bitpos_mod = bitpos % BITS_PER_UNIT(8);

bool skip_byte = false;
if (BYTES_BIG_ENDIAN0)
  {
    /* BITPOS and BITLEN are exactly aligned and no shifting
is necessary.  */
    if (bitpos_mod + bitlen_mod == BITS_PER_UNIT(8)
 || (bitpos_mod == 0 && bitlen_mod == 0))
shift_amnt = 0;
    /* |. . . . . . . .|
 <bp >   <blen >.
We always shift right for BYTES_BIG_ENDIAN so shift the beginning
of the value until it aligns with 'bp' in the next byte over.  */
    else if (bitpos_mod + bitlen_mod < BITS_PER_UNIT(8))
{
 shift_amnt = bitlen_mod + bitpos_mod;
 skip_byte = bitlen_mod != 0;
}
    /* |. . . . . . . .|
 <----bp--->
   <---blen---->.
Shift the value right within the same byte so it aligns with 'bp'.  */
    else
shift_amnt = bitlen_mod + bitpos_mod - BITS_PER_UNIT(8);
  }
else
  shift_amnt = bitpos % BITS_PER_UNIT(8);

/* Create the shifted version of EXPR.  */
if (!BYTES_BIG_ENDIAN0)
  {
    shift_bytes_in_array_left (tmpbuf, byte_size, shift_amnt);
    if (shift_amnt == 0)
byte_size--;
  }
else
  {
    gcc_assert (BYTES_BIG_ENDIAN)((void)(!(0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2028, __FUNCTION__), 0 : 0));
    shift_bytes_in_array_right (tmpbuf, byte_size, shift_amnt);
    /* If shifting right forced us to move into the next byte skip the now
empty byte.  */
    if (skip_byte)
{
 tmpbuf++;
 byte_size--;
}
  }

/* Insert the bits from TMPBUF.  */
for (unsigned int i = 0; i < byte_size; i++)
  ptr[first_byte + i] |= tmpbuf[i];

return true;
2044}

2046/* Sorting function for store_immediate_info objects.
 Sorts them by bitposition.  */

2049static int
2050sort_by_bitpos (const void *x, const void *y)
2051{
store_immediate_info *const *tmp = (store_immediate_info * const *) x;
store_immediate_info *const *tmp2 = (store_immediate_info * const *) y;

if ((*tmp)->bitpos < (*tmp2)->bitpos)
  return -1;
else if ((*tmp)->bitpos > (*tmp2)->bitpos)
  return 1;
else
  /* If they are the same let's use the order which is guaranteed to
     be different.  */
  return (*tmp)->order - (*tmp2)->order;
2063}

2065/* Sorting function for store_immediate_info objects.
 Sorts them by the order field.  */

2068static int
2069sort_by_order (const void *x, const void *y)
2070{
store_immediate_info *const *tmp = (store_immediate_info * const *) x;
store_immediate_info *const *tmp2 = (store_immediate_info * const *) y;

if ((*tmp)->order < (*tmp2)->order)
  return -1;
else if ((*tmp)->order > (*tmp2)->order)
  return 1;

gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2079, __FUNCTION__));
2080}

2082/* Initialize a merged_store_group object from a store_immediate_info
 object.  */

2085merged_store_group::merged_store_group (store_immediate_info *info)
2086{
start = info->bitpos;
width = info->bitsize;
bitregion_start = info->bitregion_start;
bitregion_end = info->bitregion_end;
/* VAL has memory allocated for it in apply_stores once the group
   width has been finalized.  */
val = NULLnullptr;
mask = NULLnullptr;
bit_insertion = info->rhs_code == BIT_INSERT_EXPR;
string_concatenation = info->rhs_code == STRING_CST;
only_constants = info->rhs_code == INTEGER_CST;
consecutive = true;
first_nonmergeable_order = ~0U;
lp_nr = info->lp_nr;
unsigned HOST_WIDE_INTlong align_bitpos = 0;
get_object_alignment_1 (gimple_assign_lhs (info->stmt),
	  &align, &align_bitpos);
align_base = start - align_bitpos;
for (int i = 0; i < 2; ++i)
  {
    store_operand_info &op = info->ops[i];
    if (op.base_addr == NULL_TREE(tree) nullptr)
{
 load_align[i] = 0;
 load_align_base[i] = 0;
}
    else
{
 get_object_alignment_1 (op.val, &load_align[i], &align_bitpos);
 load_align_base[i] = op.bitpos - align_bitpos;
}
  }
stores.create (1);
stores.safe_push (info);
last_stmt = info->stmt;
last_order = info->order;
first_stmt = last_stmt;
first_order = last_order;
buf_size = 0;
2126}

2128merged_store_group::~merged_store_group ()
2129{
if (val)
  XDELETEVEC (val)free ((void*) (val));
2132}

2134/* Return true if the store described by INFO can be merged into the group.  */

2136bool
2137merged_store_group::can_be_merged_into (store_immediate_info *info)
2138{
/* Do not merge bswap patterns.  */
if (info->rhs_code == LROTATE_EXPR)
  return false;

if (info->lp_nr != lp_nr)
  return false;

/* The canonical case.  */
if (info->rhs_code == stores[0]->rhs_code)
  return true;

/* BIT_INSERT_EXPR is compatible with INTEGER_CST if no STRING_CST.  */
if (info->rhs_code == BIT_INSERT_EXPR && stores[0]->rhs_code == INTEGER_CST)
  return !string_concatenation;

if (stores[0]->rhs_code == BIT_INSERT_EXPR && info->rhs_code == INTEGER_CST)
  return !string_concatenation;

/* We can turn MEM_REF into BIT_INSERT_EXPR for bit-field stores, but do it
   only for small regions since this can generate a lot of instructions.  */
if (info->rhs_code == MEM_REF
    && (stores[0]->rhs_code == INTEGER_CST
 || stores[0]->rhs_code == BIT_INSERT_EXPR)
    && info->bitregion_start == stores[0]->bitregion_start
    && info->bitregion_end == stores[0]->bitregion_end
    && info->bitregion_end - info->bitregion_start <= MAX_FIXED_MODE_SIZEGET_MODE_BITSIZE (((global_options.x_ix86_isa_flags & (1UL
 << 1)) != 0) ? (scalar_int_mode ((scalar_int_mode::from_int
) E_TImode)) : (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
))))
  return !string_concatenation;

if (stores[0]->rhs_code == MEM_REF
    && (info->rhs_code == INTEGER_CST
 || info->rhs_code == BIT_INSERT_EXPR)
    && info->bitregion_start == stores[0]->bitregion_start
    && info->bitregion_end == stores[0]->bitregion_end
    && info->bitregion_end - info->bitregion_start <= MAX_FIXED_MODE_SIZEGET_MODE_BITSIZE (((global_options.x_ix86_isa_flags & (1UL
 << 1)) != 0) ? (scalar_int_mode ((scalar_int_mode::from_int
) E_TImode)) : (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
))))
  return !string_concatenation;

/* STRING_CST is compatible with INTEGER_CST if no BIT_INSERT_EXPR.  */
if (info->rhs_code == STRING_CST
    && stores[0]->rhs_code == INTEGER_CST
    && stores[0]->bitsize == CHAR_BIT8)
  return !bit_insertion;

if (stores[0]->rhs_code == STRING_CST
    && info->rhs_code == INTEGER_CST
    && info->bitsize == CHAR_BIT8)
  return !bit_insertion;

return false;
2187}

2189/* Helper method for merge_into and merge_overlapping to do
 the common part.  */

2192void
2193merged_store_group::do_merge (store_immediate_info *info)
2194{
bitregion_start = MIN (bitregion_start, info->bitregion_start)((bitregion_start) < (info->bitregion_start) ? (bitregion_start
) : (info->bitregion_start));
bitregion_end = MAX (bitregion_end, info->bitregion_end)((bitregion_end) > (info->bitregion_end) ? (bitregion_end
) : (info->bitregion_end));

unsigned int this_align;
unsigned HOST_WIDE_INTlong align_bitpos = 0;
get_object_alignment_1 (gimple_assign_lhs (info->stmt),
	  &this_align, &align_bitpos);
if (this_align > align)
  {
    align = this_align;
    align_base = info->bitpos - align_bitpos;
  }
for (int i = 0; i < 2; ++i)
  {
    store_operand_info &op = info->ops[i];
    if (!op.base_addr)
continue;

    get_object_alignment_1 (op.val, &this_align, &align_bitpos);
    if (this_align > load_align[i])
{
 load_align[i] = this_align;
 load_align_base[i] = op.bitpos - align_bitpos;
}
  }

gimple *stmt = info->stmt;
stores.safe_push (info);
if (info->order > last_order)
  {
    last_order = info->order;
    last_stmt = stmt;
  }
else if (info->order < first_order)
  {
    first_order = info->order;
    first_stmt = stmt;
  }

if (info->bitpos != start + width)
  consecutive = false;

/* We need to use extraction if there is any bit-field.  */
if (info->rhs_code == BIT_INSERT_EXPR)
  {
    bit_insertion = true;
    gcc_assert (!string_concatenation)((void)(!(!string_concatenation) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2241, __FUNCTION__), 0 : 0));
  }

/* We want to use concatenation if there is any string.  */
if (info->rhs_code == STRING_CST)
  {
    string_concatenation = true;
    gcc_assert (!bit_insertion)((void)(!(!bit_insertion) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2248, __FUNCTION__), 0 : 0));
  }

/* But we cannot use it if we don't have consecutive stores.  */
if (!consecutive)
  string_concatenation = false;

if (info->rhs_code != INTEGER_CST)
  only_constants = false;
2257}

2259/* Merge a store recorded by INFO into this merged store.
 The store is not overlapping with the existing recorded
 stores.  */

2263void
2264merged_store_group::merge_into (store_immediate_info *info)
2265{
do_merge (info);

/* Make sure we're inserting in the position we think we're inserting.  */
gcc_assert (info->bitpos >= start + width((void)(!(info->bitpos >= start + width && info
->bitregion_start <= bitregion_end) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2270, __FUNCTION__), 0 : 0))
     && info->bitregion_start <= bitregion_end)((void)(!(info->bitpos >= start + width && info
->bitregion_start <= bitregion_end) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2270, __FUNCTION__), 0 : 0));

width = info->bitpos + info->bitsize - start;
2273}

2275/* Merge a store described by INFO into this merged store.
 INFO overlaps in some way with the current store (i.e. it's not contiguous
 which is handled by merged_store_group::merge_into).  */

2279void
2280merged_store_group::merge_overlapping (store_immediate_info *info)
2281{
do_merge (info);

/* If the store extends the size of the group, extend the width.  */
if (info->bitpos + info->bitsize > start + width)
  width = info->bitpos + info->bitsize - start;
2287}

2289/* Go through all the recorded stores in this group in program order and
 apply their values to the VAL byte array to create the final merged
 value.  Return true if the operation succeeded.  */

2293bool
2294merged_store_group::apply_stores ()
2295{
store_immediate_info *info;
unsigned int i;

/* Make sure we have more than one store in the group, otherwise we cannot
   merge anything.  */
if (bitregion_start % BITS_PER_UNIT(8) != 0
    || bitregion_end % BITS_PER_UNIT(8) != 0
    || stores.length () == 1)
  return false;

buf_size = (bitregion_end - bitregion_start) / BITS_PER_UNIT(8);

/* Really do string concatenation for large strings only.  */
if (buf_size <= MOVE_MAX((((global_options.x_ix86_isa_flags & (1UL << 15)) !=
 0) && (global_options.x_ix86_move_max == PVW_AVX512 ||
 global_options.x_ix86_store_max == PVW_AVX512)) ? 64 : ((((global_options
.x_ix86_isa_flags & (1UL << 8)) != 0) && (global_options
.x_ix86_move_max >= PVW_AVX256 || global_options.x_ix86_store_max
 >= PVW_AVX256)) ? 32 : ((((global_options.x_ix86_isa_flags
 & (1UL << 51)) != 0) && ix86_tune_features
[X86_TUNE_SSE_UNALIGNED_LOAD_OPTIMAL] && ix86_tune_features
[X86_TUNE_SSE_UNALIGNED_STORE_OPTIMAL]) ? 16 : (((global_options
.x_ix86_isa_flags & (1UL << 1)) != 0) ? 8 : 4)))))
  string_concatenation = false;

/* String concatenation only works for byte aligned start and end.  */
if (start % BITS_PER_UNIT(8) != 0 || width % BITS_PER_UNIT(8) != 0)
  string_concatenation = false;

/* Create a power-of-2-sized buffer for native_encode_expr.  */
if (!string_concatenation)
  buf_size = 1 << ceil_log2 (buf_size);

val = XNEWVEC (unsigned char, 2 * buf_size)((unsigned char *) xmalloc (sizeof (unsigned char) * (2 * buf_size
)));
mask = val + buf_size;
memset (val, 0, buf_size);
memset (mask, ~0U, buf_size);

stores.qsort (sort_by_order)qsort (sort_by_order);

FOR_EACH_VEC_ELT (stores, i, info)for (i = 0; (stores).iterate ((i), &(info)); ++(i))
  {
    unsigned int pos_in_buffer = info->bitpos - bitregion_start;
    tree cst;
    if (info->ops[0].val && info->ops[0].base_addr == NULL_TREE(tree) nullptr)
cst = info->ops[0].val;
    else if (info->ops[1].val && info->ops[1].base_addr == NULL_TREE(tree) nullptr)
cst = info->ops[1].val;
    else
cst = NULL_TREE(tree) nullptr;
    bool ret = true;
    if (cst && info->rhs_code != BIT_INSERT_EXPR)
ret = encode_tree_to_bitpos (cst, val, info->bitsize, pos_in_buffer,
		     buf_size);
    unsigned char *m = mask + (pos_in_buffer / BITS_PER_UNIT(8));
    if (BYTES_BIG_ENDIAN0)
clear_bit_region_be (m, (BITS_PER_UNIT(8) - 1
		 - (pos_in_buffer % BITS_PER_UNIT(8))),
	     info->bitsize);
    else
clear_bit_region (m, pos_in_buffer % BITS_PER_UNIT(8), info->bitsize);
    if (cst && dump_file && (dump_flags & TDF_DETAILS))
{
 if (ret)
   {
     fputs ("After writing ", dump_file);
     print_generic_expr (dump_file, cst, TDF_NONE);
     fprintf (dump_file, " of size " HOST_WIDE_INT_PRINT_DEC"%" "l" "d"
       " at position %d\n", info->bitsize, pos_in_buffer);
     fputs ("  the merged value contains ", dump_file);
     dump_char_array (dump_file, val, buf_size);
     fputs ("  the merged mask contains  ", dump_file);
     dump_char_array (dump_file, mask, buf_size);
     if (bit_insertion)
fputs ("  bit insertion is required\n", dump_file);
     if (string_concatenation)
fputs ("  string concatenation is required\n", dump_file);
   }
 else
   fprintf (dump_file, "Failed to merge stores\n");
}
    if (!ret)
return false;
  }
stores.qsort (sort_by_bitpos)qsort (sort_by_bitpos);
return true;
2373}

2375/* Structure describing the store chain.  */

2377class imm_store_chain_info
2378{
2379public:
/* Doubly-linked list that imposes an order on chain processing.
   PNXP (prev's next pointer) points to the head of a list, or to
   the next field in the previous chain in the list.
   See pass_store_merging::m_stores_head for more rationale.  */
imm_store_chain_info *next, **pnxp;
tree base_addr;
auto_vec<store_immediate_info *> m_store_info;
auto_vec<merged_store_group *> m_merged_store_groups;

imm_store_chain_info (imm_store_chain_info *&inspt, tree b_a)
: next (inspt), pnxp (&inspt), base_addr (b_a)
{
  inspt = this;
  if (next)
    {
gcc_checking_assert (pnxp == next->pnxp)((void)(!(pnxp == next->pnxp) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2395, __FUNCTION__), 0 : 0));
next->pnxp = &next;
    }
}
~imm_store_chain_info ()
{
  *pnxp = next;
  if (next)
    {
gcc_checking_assert (&next == next->pnxp)((void)(!(&next == next->pnxp) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2404, __FUNCTION__), 0 : 0));
next->pnxp = pnxp;
    }
}
bool terminate_and_process_chain ();
bool try_coalesce_bswap (merged_store_group *, unsigned int, unsigned int,
	   unsigned int);
bool coalesce_immediate_stores ();
bool output_merged_store (merged_store_group *);
bool output_merged_stores ();
2414};

2416const pass_data pass_data_tree_store_merging = {
GIMPLE_PASS,     /* type */
"store-merging", /* name */
OPTGROUP_NONE,   /* optinfo_flags */
TV_GIMPLE_STORE_MERGING,	 /* tv_id */
PROP_ssa(1 << 5),	/* properties_required */
0,		   /* properties_provided */
0,		   /* properties_destroyed */
0,		   /* todo_flags_start */
TODO_update_ssa(1 << 11), /* todo_flags_finish */
2426};

2428class pass_store_merging : public gimple_opt_pass
2429{
2430public:
pass_store_merging (gcc::context *ctxt)
  : gimple_opt_pass (pass_data_tree_store_merging, ctxt), m_stores_head (),
    m_n_chains (0), m_n_stores (0)
{
}

/* Pass not supported for PDP-endian, nor for insane hosts or
   target character sizes where native_{encode,interpret}_expr
   doesn't work properly.  */
bool
gate (function *) final override
{
  return flag_store_mergingglobal_options.x_flag_store_merging
  && BYTES_BIG_ENDIAN0 == WORDS_BIG_ENDIAN0
  && CHAR_BIT8 == 8
  && BITS_PER_UNIT(8) == 8;
}

unsigned int execute (function *) final override;

2451private:
hash_map<tree_operand_hash, class imm_store_chain_info *> m_stores;

/* Form a doubly-linked stack of the elements of m_stores, so that
   we can iterate over them in a predictable way.  Using this order
   avoids extraneous differences in the compiler output just because
   of tree pointer variations (e.g. different chains end up in
   different positions of m_stores, so they are handled in different
   orders, so they allocate or release SSA names in different
   orders, and when they get reused, subsequent passes end up
   getting different SSA names, which may ultimately change
   decisions when going out of SSA).  */
imm_store_chain_info *m_stores_head;

/* The number of store chains currently tracked.  */
unsigned m_n_chains;
/* The number of stores currently tracked.  */
unsigned m_n_stores;

bool process_store (gimple *);
bool terminate_and_process_chain (imm_store_chain_info *);
bool terminate_all_aliasing_chains (imm_store_chain_info **, gimple *);
bool terminate_and_process_all_chains ();
2474}; // class pass_store_merging

2476/* Terminate and process all recorded chains.  Return true if any changes
 were made.  */

2479bool
2480pass_store_merging::terminate_and_process_all_chains ()
2481{
bool ret = false;
while (m_stores_head)
  ret |= terminate_and_process_chain (m_stores_head);
gcc_assert (m_stores.is_empty ())((void)(!(m_stores.is_empty ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2485, __FUNCTION__), 0 : 0));
return ret;
2487}

2489/* Terminate all chains that are affected by the statement STMT.
 CHAIN_INFO is the chain we should ignore from the checks if
 non-NULL.  Return true if any changes were made.  */

2493bool
2494pass_store_merging::terminate_all_aliasing_chains (imm_store_chain_info
				     **chain_info,
				   gimple *stmt)
2497{
bool ret = false;

/* If the statement doesn't touch memory it can't alias.  */
if (!gimple_vuse (stmt))
  return false;

tree store_lhs = gimple_store_p (stmt) ? gimple_get_lhs (stmt) : NULL_TREE(tree) nullptr;
ao_ref store_lhs_ref;
ao_ref_init (&store_lhs_ref, store_lhs);
for (imm_store_chain_info *next = m_stores_head, *cur = next; cur; cur = next)
  {
    next = cur->next;

    /* We already checked all the stores in chain_info and terminated the
chain if necessary.  Skip it here.  */
    if (chain_info && *chain_info == cur)
continue;

    store_immediate_info *info;
    unsigned int i;
    FOR_EACH_VEC_ELT (cur->m_store_info, i, info)for (i = 0; (cur->m_store_info).iterate ((i), &(info))
; ++(i))
{
 tree lhs = gimple_assign_lhs (info->stmt);
 ao_ref lhs_ref;
 ao_ref_init (&lhs_ref, lhs);
 if (ref_maybe_used_by_stmt_p (stmt, &lhs_ref)
     || stmt_may_clobber_ref_p_1 (stmt, &lhs_ref)
     || (store_lhs && refs_may_alias_p_1 (&store_lhs_ref,
				   &lhs_ref, false)))
   {
     if (dump_file && (dump_flags & TDF_DETAILS))
{
  fprintf (dump_file, "stmt causes chain termination:\n");
  print_gimple_stmt (dump_file, stmt, 0);
}
     ret |= terminate_and_process_chain (cur);
     break;
   }
}
  }

return ret;
2540}

2542/* Helper function.  Terminate the recorded chain storing to base object
 BASE.  Return true if the merging and output was successful.  The m_stores
 entry is removed after the processing in any case.  */

2546bool
2547pass_store_merging::terminate_and_process_chain (imm_store_chain_info *chain_info)
2548{
m_n_stores -= chain_info->m_store_info.length ();
m_n_chains--;
bool ret = chain_info->terminate_and_process_chain ();
m_stores.remove (chain_info->base_addr);
delete chain_info;
return ret;
2555}

2557/* Return true if stmts in between FIRST (inclusive) and LAST (exclusive)
 may clobber REF.  FIRST and LAST must have non-NULL vdef.  We want to
 be able to sink load of REF across stores between FIRST and LAST, up
 to right before LAST.  */

2562bool
2563stmts_may_clobber_ref_p (gimple *first, gimple *last, tree ref)
2564{
ao_ref r;
ao_ref_init (&r, ref);
unsigned int count = 0;
tree vop = gimple_vdef (last);
gimple *stmt;

/* Return true conservatively if the basic blocks are different.  */
if (gimple_bb (first) != gimple_bb (last))
  return true;

do
  {
    stmt = SSA_NAME_DEF_STMT (vop)(tree_check ((vop), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2577, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
    if (stmt_may_clobber_ref_p_1 (stmt, &r))
return true;
    if (gimple_store_p (stmt)
 && refs_anti_dependent_p (ref, gimple_get_lhs (stmt)))
return true;
    /* Avoid quadratic compile time by bounding the number of checks
we perform.  */
    if (++count > MAX_STORE_ALIAS_CHECKS64)
return true;
    vop = gimple_vuse (stmt);
  }
while (stmt != first);

return false;
2592}

2594/* Return true if INFO->ops[IDX] is mergeable with the
 corresponding loads already in MERGED_STORE group.
 BASE_ADDR is the base address of the whole store group.  */

2598bool
2599compatible_load_p (merged_store_group *merged_store,
   store_immediate_info *info,
   tree base_addr, int idx)
2602{
store_immediate_info *infof = merged_store->stores[0];
if (!info->ops[idx].base_addr
    || maybe_ne (info->ops[idx].bitpos - infof->ops[idx].bitpos,
   info->bitpos - infof->bitpos)
    || !operand_equal_p (info->ops[idx].base_addr,
	   infof->ops[idx].base_addr, 0))
  return false;

store_immediate_info *infol = merged_store->stores.last ();
tree load_vuse = gimple_vuse (info->ops[idx].stmt);
/* In this case all vuses should be the same, e.g.
   _1 = s.a; _2 = s.b; _3 = _1 | 1; t.a = _3; _4 = _2 | 2; t.b = _4;
   or
   _1 = s.a; _2 = s.b; t.a = _1; t.b = _2;
   and we can emit the coalesced load next to any of those loads.  */
if (gimple_vuse (infof->ops[idx].stmt) == load_vuse
    && gimple_vuse (infol->ops[idx].stmt) == load_vuse)
  return true;

/* Otherwise, at least for now require that the load has the same
   vuse as the store.  See following examples.  */
if (gimple_vuse (info->stmt) != load_vuse)
  return false;

if (gimple_vuse (infof->stmt) != gimple_vuse (infof->ops[idx].stmt)
    || (infof != infol
 && gimple_vuse (infol->stmt) != gimple_vuse (infol->ops[idx].stmt)))
  return false;

/* If the load is from the same location as the store, already
   the construction of the immediate chain info guarantees no intervening
   stores, so no further checks are needed.  Example:
   _1 = s.a; _2 = _1 & -7; s.a = _2; _3 = s.b; _4 = _3 & -7; s.b = _4;  */
if (known_eq (info->ops[idx].bitpos, info->bitpos)(!maybe_ne (info->ops[idx].bitpos, info->bitpos))
    && operand_equal_p (info->ops[idx].base_addr, base_addr, 0))
  return true;

/* Otherwise, we need to punt if any of the loads can be clobbered by any
   of the stores in the group, or any other stores in between those.
   Previous calls to compatible_load_p ensured that for all the
   merged_store->stores IDX loads, no stmts starting with
   merged_store->first_stmt and ending right before merged_store->last_stmt
   clobbers those loads.  */
gimple *first = merged_store->first_stmt;
gimple *last = merged_store->last_stmt;
/* The stores are sorted by increasing store bitpos, so if info->stmt store
   comes before the so far first load, we'll be changing
   merged_store->first_stmt.  In that case we need to give up if
   any of the earlier processed loads clobber with the stmts in the new
   range.  */
if (info->order < merged_store->first_order)
  {
    for (store_immediate_info *infoc : merged_store->stores)
if (stmts_may_clobber_ref_p (info->stmt, first, infoc->ops[idx].val))
 return false;
    first = info->stmt;
  }
/* Similarly, we could change merged_store->last_stmt, so ensure
   in that case no stmts in the new range clobber any of the earlier
   processed loads.  */
else if (info->order > merged_store->last_order)
  {
    for (store_immediate_info *infoc : merged_store->stores)
if (stmts_may_clobber_ref_p (last, info->stmt, infoc->ops[idx].val))
 return false;
    last = info->stmt;
  }
/* And finally, we'd be adding a new load to the set, ensure it isn't
   clobbered in the new range.  */
if (stmts_may_clobber_ref_p (first, last, info->ops[idx].val))
  return false;

/* Otherwise, we are looking for:
   _1 = s.a; _2 = _1 ^ 15; t.a = _2; _3 = s.b; _4 = _3 ^ 15; t.b = _4;
   or
   _1 = s.a; t.a = _1; _2 = s.b; t.b = _2;  */
return true;
2680}

2682/* Add all refs loaded to compute VAL to REFS vector.  */

2684void
2685gather_bswap_load_refs (vec<tree> *refs, tree val)
2686{
if (TREE_CODE (val)((enum tree_code) (val)->base.code) != SSA_NAME)
  return;

gimple *stmt = SSA_NAME_DEF_STMT (val)(tree_check ((val), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2690, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
if (!is_gimple_assign (stmt))
  return;

if (gimple_assign_load_p (stmt))
  {
    refs->safe_push (gimple_assign_rhs1 (stmt));
    return;
  }

switch (gimple_assign_rhs_class (stmt))
  {
  case GIMPLE_BINARY_RHS:
    gather_bswap_load_refs (refs, gimple_assign_rhs2 (stmt));
    /* FALLTHRU */
  case GIMPLE_UNARY_RHS:
    gather_bswap_load_refs (refs, gimple_assign_rhs1 (stmt));
    break;
  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2709, __FUNCTION__));
  }
2711}

2713/* Check if there are any stores in M_STORE_INFO after index I
 (where M_STORE_INFO must be sorted by sort_by_bitpos) that overlap
 a potential group ending with END that have their order
 smaller than LAST_ORDER.  ALL_INTEGER_CST_P is true if
 all the stores already merged and the one under consideration
 have rhs_code of INTEGER_CST.  Return true if there are no such stores.
 Consider:
   MEM[(long long int *)p_28] = 0;
   MEM[(long long int *)p_28 + 8B] = 0;
   MEM[(long long int *)p_28 + 16B] = 0;
   MEM[(long long int *)p_28 + 24B] = 0;
   _129 = (int) _130;
   MEM[(int *)p_28 + 8B] = _129;
   MEM[(int *)p_28].a = -1;
 We already have
   MEM[(long long int *)p_28] = 0;
   MEM[(int *)p_28].a = -1;
 stmts in the current group and need to consider if it is safe to
 add MEM[(long long int *)p_28 + 8B] = 0; store into the same group.
 There is an overlap between that store and the MEM[(int *)p_28 + 8B] = _129;
 store though, so if we add the MEM[(long long int *)p_28 + 8B] = 0;
 into the group and merging of those 3 stores is successful, merged
 stmts will be emitted at the latest store from that group, i.e.
 LAST_ORDER, which is the MEM[(int *)p_28].a = -1; store.
 The MEM[(int *)p_28 + 8B] = _129; store that originally follows
 the MEM[(long long int *)p_28 + 8B] = 0; would now be before it,
 so we need to refuse merging MEM[(long long int *)p_28 + 8B] = 0;
 into the group.  That way it will be its own store group and will
 not be touched.  If ALL_INTEGER_CST_P and there are overlapping
 INTEGER_CST stores, those are mergeable using merge_overlapping,
 so don't return false for those.

 Similarly, check stores from FIRST_EARLIER (inclusive) to END_EARLIER
 (exclusive), whether they don't overlap the bitrange START to END
 and have order in between FIRST_ORDER and LAST_ORDER.  This is to
 prevent merging in cases like:
   MEM <char[12]> [&b + 8B] = {};
   MEM[(short *) &b] = 5;
   _5 = *x_4(D);
   MEM <long long unsigned int> [&b + 2B] = _5;
   MEM[(char *)&b + 16B] = 88;
   MEM[(int *)&b + 20B] = 1;
 The = {} store comes in sort_by_bitpos before the = 88 store, and can't
 be merged with it, because the = _5 store overlaps these and is in between
 them in sort_by_order ordering.  If it was merged, the merged store would
 go after the = _5 store and thus change behavior.  */

2760static bool
2761check_no_overlap (const vec<store_immediate_info *> &m_store_info,
  unsigned int i,
  bool all_integer_cst_p, unsigned int first_order,
  unsigned int last_order, unsigned HOST_WIDE_INTlong start,
  unsigned HOST_WIDE_INTlong end, unsigned int first_earlier,
  unsigned end_earlier)
2767{
unsigned int len = m_store_info.length ();
for (unsigned int j = first_earlier; j < end_earlier; j++)
  {
    store_immediate_info *info = m_store_info[j];
    if (info->order > first_order
 && info->order < last_order
 && info->bitpos + info->bitsize > start)
return false;
  }
for (++i; i < len; ++i)
  {
    store_immediate_info *info = m_store_info[i];
    if (info->bitpos >= end)
break;
    if (info->order < last_order
 && (!all_integer_cst_p || info->rhs_code != INTEGER_CST))
return false;
  }
return true;
2787}

2789/* Return true if m_store_info[first] and at least one following store
 form a group which store try_size bitsize value which is byte swapped
 from a memory load or some value, or identity from some value.
 This uses the bswap pass APIs.  */

2794bool
2795imm_store_chain_info::try_coalesce_bswap (merged_store_group *merged_store,
			  unsigned int first,
			  unsigned int try_size,
			  unsigned int first_earlier)
2799{
unsigned int len = m_store_info.length (), last = first;
unsigned HOST_WIDE_INTlong width = m_store_info[first]->bitsize;
if (width >= try_size)
  return false;
for (unsigned int i = first + 1; i < len; ++i)
  {
    if (m_store_info[i]->bitpos != m_store_info[first]->bitpos + width
 || m_store_info[i]->lp_nr != merged_store->lp_nr
 || m_store_info[i]->ins_stmt == NULLnullptr)
return false;
    width += m_store_info[i]->bitsize;
    if (width >= try_size)
{
 last = i;
 break;
}
  }
if (width != try_size)
  return false;

bool allow_unaligned
  = !STRICT_ALIGNMENT0 && param_store_merging_allow_unalignedglobal_options.x_param_store_merging_allow_unaligned;
/* Punt if the combined store would not be aligned and we need alignment.  */
if (!allow_unaligned)
  {
    unsigned int align = merged_store->align;
    unsigned HOST_WIDE_INTlong align_base = merged_store->align_base;
    for (unsigned int i = first + 1; i <= last; ++i)
{
 unsigned int this_align;
 unsigned HOST_WIDE_INTlong align_bitpos = 0;
 get_object_alignment_1 (gimple_assign_lhs (m_store_info[i]->stmt),
		  &this_align, &align_bitpos);
 if (this_align > align)
   {
     align = this_align;
     align_base = m_store_info[i]->bitpos - align_bitpos;
   }
}
    unsigned HOST_WIDE_INTlong align_bitpos
= (m_store_info[first]->bitpos - align_base) & (align - 1);
    if (align_bitpos)
align = least_bit_hwi (align_bitpos);
    if (align < try_size)
return false;
  }

tree type;
switch (try_size)
  {
  case 16: type = uint16_type_nodeglobal_trees[TI_UINT16_TYPE]; break;
  case 32: type = uint32_type_nodeglobal_trees[TI_UINT32_TYPE]; break;
  case 64: type = uint64_type_nodeglobal_trees[TI_UINT64_TYPE]; break;
  default: gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2853, __FUNCTION__));
  }
struct symbolic_number n;
gimple *ins_stmt = NULLnullptr;
int vuse_store = -1;
unsigned int first_order = merged_store->first_order;
unsigned int last_order = merged_store->last_order;
gimple *first_stmt = merged_store->first_stmt;
gimple *last_stmt = merged_store->last_stmt;
unsigned HOST_WIDE_INTlong end = merged_store->start + merged_store->width;
store_immediate_info *infof = m_store_info[first];

for (unsigned int i = first; i <= last; ++i)
  {
    store_immediate_info *info = m_store_info[i];
    struct symbolic_number this_n = info->n;
    this_n.type = type;
    if (!this_n.base_addr)
this_n.range = try_size / BITS_PER_UNIT(8);
    else
/* Update vuse in case it has changed by output_merged_stores.  */
this_n.vuse = gimple_vuse (info->ins_stmt);
    unsigned int bitpos = info->bitpos - infof->bitpos;
    if (!do_shift_rotate (LSHIFT_EXPR, &this_n,
	    BYTES_BIG_ENDIAN0
	    ? try_size - info->bitsize - bitpos
	    : bitpos))
return false;
    if (this_n.base_addr && vuse_store)
{
 unsigned int j;
 for (j = first; j <= last; ++j)
   if (this_n.vuse == gimple_vuse (m_store_info[j]->stmt))
     break;
 if (j > last)
   {
     if (vuse_store == 1)
return false;
     vuse_store = 0;
   }
}
    if (i == first)
{
 n = this_n;
 ins_stmt = info->ins_stmt;
}
    else
{
 if (n.base_addr && n.vuse != this_n.vuse)
   {
     if (vuse_store == 0)
return false;
     vuse_store = 1;
   }
 if (info->order > last_order)
   {
     last_order = info->order;
     last_stmt = info->stmt;
   }
 else if (info->order < first_order)
   {
     first_order = info->order;
     first_stmt = info->stmt;
   }
 end = MAX (end, info->bitpos + info->bitsize)((end) > (info->bitpos + info->bitsize) ? (end) : (info
->bitpos + info->bitsize));

 ins_stmt = perform_symbolic_merge (ins_stmt, &n, info->ins_stmt,
			     &this_n, &n, BIT_IOR_EXPR);
 if (ins_stmt == NULLnullptr)
   return false;
}
  }

uint64_t cmpxchg, cmpnop;
bool cast64_to_32;
find_bswap_or_nop_finalize (&n, &cmpxchg, &cmpnop, &cast64_to_32);

/* A complete byte swap should make the symbolic number to start with
   the largest digit in the highest order byte.  Unchanged symbolic
   number indicates a read with same endianness as target architecture.  */
if (n.n != cmpnop && n.n != cmpxchg)
  return false;

/* For now.  */
if (cast64_to_32)
  return false;

if (n.base_addr == NULL_TREE(tree) nullptr && !is_gimple_val (n.src))
  return false;

if (!check_no_overlap (m_store_info, last, false, first_order, last_order,
	 merged_store->start, end, first_earlier, first))
  return false;

/* Don't handle memory copy this way if normal non-bswap processing
   would handle it too.  */
if (n.n == cmpnop && (unsigned) n.n_ops == last - first + 1)
  {
    unsigned int i;
    for (i = first; i <= last; ++i)
if (m_store_info[i]->rhs_code != MEM_REF)
 break;
    if (i == last + 1)
return false;
  }

if (n.n == cmpxchg)
  switch (try_size)
    {
    case 16:
/* Will emit LROTATE_EXPR.  */
break;
    case 32:
if (builtin_decl_explicit_p (BUILT_IN_BSWAP32)
   && optab_handler (bswap_optab, SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode))) != CODE_FOR_nothing)
 break;
return false;
    case 64:
if (builtin_decl_explicit_p (BUILT_IN_BSWAP64)
   && optab_handler (bswap_optab, DImode(scalar_int_mode ((scalar_int_mode::from_int) E_DImode))) != CODE_FOR_nothing)
 break;
return false;
    default:
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 2976, __FUNCTION__));
    }

if (!allow_unaligned && n.base_addr)
  {
    unsigned int align = get_object_alignment (n.src);
    if (align < try_size)
return false;
  }

/* If each load has vuse of the corresponding store, need to verify
   the loads can be sunk right before the last store.  */
if (vuse_store == 1)
  {
    auto_vec<tree, 64> refs;
    for (unsigned int i = first; i <= last; ++i)
gather_bswap_load_refs (&refs,
		gimple_assign_rhs1 (m_store_info[i]->stmt));

    for (tree ref : refs)
if (stmts_may_clobber_ref_p (first_stmt, last_stmt, ref))
 return false;
    n.vuse = NULL_TREE(tree) nullptr;
  }

infof->n = n;
infof->ins_stmt = ins_stmt;
for (unsigned int i = first; i <= last; ++i)
  {
    m_store_info[i]->rhs_code = n.n == cmpxchg ? LROTATE_EXPR : NOP_EXPR;
    m_store_info[i]->ops[0].base_addr = NULL_TREE(tree) nullptr;
    m_store_info[i]->ops[1].base_addr = NULL_TREE(tree) nullptr;
    if (i != first)
merged_store->merge_into (m_store_info[i]);
  }

return true;
3013}

3015/* Go through the candidate stores recorded in m_store_info and merge them
 into merged_store_group objects recorded into m_merged_store_groups
 representing the widened stores.  Return true if coalescing was successful
 and the number of widened stores is fewer than the original number
 of stores.  */

3021bool
3022imm_store_chain_info::coalesce_immediate_stores ()
3023{
/* Anything less can't be processed.  */
if (m_store_info.length () < 2)
  return false;

if (dump_file && (dump_flags & TDF_DETAILS))
  fprintf (dump_file, "Attempting to coalesce %u stores in chain\n",
    m_store_info.length ());

store_immediate_info *info;
unsigned int i, ignore = 0;
unsigned int first_earlier = 0;
unsigned int end_earlier = 0;

/* Order the stores by the bitposition they write to.  */
m_store_info.qsort (sort_by_bitpos)qsort (sort_by_bitpos);

info = m_store_info[0];
merged_store_group *merged_store = new merged_store_group (info);
if (dump_file && (dump_flags & TDF_DETAILS))
  fputs ("New store group\n", dump_file);

FOR_EACH_VEC_ELT (m_store_info, i, info)for (i = 0; (m_store_info).iterate ((i), &(info)); ++(i))
  {
    unsigned HOST_WIDE_INTlong new_bitregion_start, new_bitregion_end;

    if (i <= ignore)
goto done;

    while (first_earlier < end_earlier
    && (m_store_info[first_earlier]->bitpos
 + m_store_info[first_earlier]->bitsize
 <= merged_store->start))
first_earlier++;

    /* First try to handle group of stores like:
p[0] = data >> 24;
p[1] = data >> 16;
p[2] = data >> 8;
p[3] = data;
using the bswap framework.  */
    if (info->bitpos == merged_store->start + merged_store->width
 && merged_store->stores.length () == 1
 && merged_store->stores[0]->ins_stmt != NULLnullptr
 && info->lp_nr == merged_store->lp_nr
 && info->ins_stmt != NULLnullptr)
{
 unsigned int try_size;
 for (try_size = 64; try_size >= 16; try_size >>= 1)
   if (try_coalesce_bswap (merged_store, i - 1, try_size,
		    first_earlier))
     break;

 if (try_size >= 16)
   {
     ignore = i + merged_store->stores.length () - 1;
     m_merged_store_groups.safe_push (merged_store);
     if (ignore < m_store_info.length ())
{
  merged_store = new merged_store_group (m_store_info[ignore]);
  end_earlier = ignore;
}
     else
merged_store = NULLnullptr;
     goto done;
   }
}

    new_bitregion_start
= MIN (merged_store->bitregion_start, info->bitregion_start)((merged_store->bitregion_start) < (info->bitregion_start
) ? (merged_store->bitregion_start) : (info->bitregion_start
));
    new_bitregion_end
= MAX (merged_store->bitregion_end, info->bitregion_end)((merged_store->bitregion_end) > (info->bitregion_end
) ? (merged_store->bitregion_end) : (info->bitregion_end
));

    if (info->order >= merged_store->first_nonmergeable_order
 || (((new_bitregion_end - new_bitregion_start + 1) / BITS_PER_UNIT(8))
     > (unsigned) param_store_merging_max_sizeglobal_options.x_param_store_merging_max_size))
;

    /* |---store 1---|
      |---store 2---|
Overlapping stores.  */
    else if (IN_RANGE (info->bitpos, merged_store->start,((unsigned long) (info->bitpos) - (unsigned long) (merged_store
->start) <= (unsigned long) (merged_store->start + merged_store
->width - 1) - (unsigned long) (merged_store->start))
	 merged_store->start + merged_store->width - 1)((unsigned long) (info->bitpos) - (unsigned long) (merged_store
->start) <= (unsigned long) (merged_store->start + merged_store
->width - 1) - (unsigned long) (merged_store->start))
      /* |---store 1---||---store 2---|
  Handle also the consecutive INTEGER_CST stores case here,
  as we have here the code to deal with overlaps.  */
      || (info->bitregion_start <= merged_store->bitregion_end
   && info->rhs_code == INTEGER_CST
   && merged_store->only_constants
   && merged_store->can_be_merged_into (info)))
{
 /* Only allow overlapping stores of constants.  */
 if (info->rhs_code == INTEGER_CST
     && merged_store->only_constants
     && info->lp_nr == merged_store->lp_nr)
   {
     unsigned int first_order
= MIN (merged_store->first_order, info->order)((merged_store->first_order) < (info->order) ? (merged_store
->first_order) : (info->order));
     unsigned int last_order
= MAX (merged_store->last_order, info->order)((merged_store->last_order) > (info->order) ? (merged_store
->last_order) : (info->order));
     unsigned HOST_WIDE_INTlong end
= MAX (merged_store->start + merged_store->width,((merged_store->start + merged_store->width) > (info
->bitpos + info->bitsize) ? (merged_store->start + merged_store
->width) : (info->bitpos + info->bitsize))
       info->bitpos + info->bitsize)((merged_store->start + merged_store->width) > (info
->bitpos + info->bitsize) ? (merged_store->start + merged_store
->width) : (info->bitpos + info->bitsize));
     if (check_no_overlap (m_store_info, i, true, first_order,
		    last_order, merged_store->start, end,
		    first_earlier, end_earlier))
{
  /* check_no_overlap call above made sure there are no
     overlapping stores with non-INTEGER_CST rhs_code
     in between the first and last of the stores we've
     just merged.  If there are any INTEGER_CST rhs_code
     stores in between, we need to merge_overlapping them
     even if in the sort_by_bitpos order there are other
     overlapping stores in between.  Keep those stores as is.
     Example:
	MEM[(int *)p_28] = 0;
	MEM[(char *)p_28 + 3B] = 1;
	MEM[(char *)p_28 + 1B] = 2;
	MEM[(char *)p_28 + 2B] = MEM[(char *)p_28 + 6B];
     We can't merge the zero store with the store of two and
     not merge anything else, because the store of one is
     in the original order in between those two, but in
     store_by_bitpos order it comes after the last store that
     we can't merge with them.  We can merge the first 3 stores
     and keep the last store as is though.  */
  unsigned int len = m_store_info.length ();
  unsigned int try_order = last_order;
  unsigned int first_nonmergeable_order;
  unsigned int k;
  bool last_iter = false;
  int attempts = 0;
  do
    {
      unsigned int max_order = 0;
      unsigned int min_order = first_order;
      unsigned first_nonmergeable_int_order = ~0U;
      unsigned HOST_WIDE_INTlong this_end = end;
      k = i;
      first_nonmergeable_order = ~0U;
      for (unsigned int j = i + 1; j < len; ++j)
	{
	  store_immediate_info *info2 = m_store_info[j];
	  if (info2->bitpos >= this_end)
	    break;
	  if (info2->order < try_order)
	    {
	      if (info2->rhs_code != INTEGER_CST
		  || info2->lp_nr != merged_store->lp_nr)
		{
		  /* Normally check_no_overlap makes sure this
		     doesn't happen, but if end grows below,
		     then we need to process more stores than
		     check_no_overlap verified.  Example:
		      MEM[(int *)p_5] = 0;
		      MEM[(short *)p_5 + 3B] = 1;
		      MEM[(char *)p_5 + 4B] = _9;
		      MEM[(char *)p_5 + 2B] = 2;  */
		  k = 0;
		  break;
		}
	      k = j;
	      min_order = MIN (min_order, info2->order)((min_order) < (info2->order) ? (min_order) : (info2->
order));
	      this_end = MAX (this_end,((this_end) > (info2->bitpos + info2->bitsize) ? (this_end
) : (info2->bitpos + info2->bitsize))
			      info2->bitpos + info2->bitsize)((this_end) > (info2->bitpos + info2->bitsize) ? (this_end
) : (info2->bitpos + info2->bitsize));
	    }
	  else if (info2->rhs_code == INTEGER_CST
		   && info2->lp_nr == merged_store->lp_nr
		   && !last_iter)
	    {
	      max_order = MAX (max_order, info2->order + 1)((max_order) > (info2->order + 1) ? (max_order) : (info2
->order + 1));
	      first_nonmergeable_int_order
		= MIN (first_nonmergeable_int_order,((first_nonmergeable_int_order) < (info2->order) ? (first_nonmergeable_int_order
) : (info2->order))
		       info2->order)((first_nonmergeable_int_order) < (info2->order) ? (first_nonmergeable_int_order
) : (info2->order));
	    }
	  else
	    first_nonmergeable_order
	      = MIN (first_nonmergeable_order, info2->order)((first_nonmergeable_order) < (info2->order) ? (first_nonmergeable_order
) : (info2->order));
	}
      if (k > i
	  && !check_no_overlap (m_store_info, len - 1, true,
				min_order, try_order,
				merged_store->start, this_end,
				first_earlier, end_earlier))
	k = 0;
      if (k == 0)
	{
	  if (last_order == try_order)
	    break;
	  /* If this failed, but only because we grew
	     try_order, retry with the last working one,
	     so that we merge at least something.  */
	  try_order = last_order;
	  last_iter = true;
	  continue;
	}
      last_order = try_order;
      /* Retry with a larger try_order to see if we could
	 merge some further INTEGER_CST stores.  */
      if (max_order
	  && (first_nonmergeable_int_order
	      < first_nonmergeable_order))
	{
	  try_order = MIN (max_order,((max_order) < (first_nonmergeable_order) ? (max_order) : (
first_nonmergeable_order))
			   first_nonmergeable_order)((max_order) < (first_nonmergeable_order) ? (max_order) : (
first_nonmergeable_order));
	  try_order
	    = MIN (try_order,((try_order) < (merged_store->first_nonmergeable_order)
 ? (try_order) : (merged_store->first_nonmergeable_order))
		   merged_store->first_nonmergeable_order)((try_order) < (merged_store->first_nonmergeable_order)
 ? (try_order) : (merged_store->first_nonmergeable_order));
	  if (try_order > last_order && ++attempts < 16)
	    continue;
	}
      first_nonmergeable_order
	= MIN (first_nonmergeable_order,((first_nonmergeable_order) < (first_nonmergeable_int_order
) ? (first_nonmergeable_order) : (first_nonmergeable_int_order
))
	       first_nonmergeable_int_order)((first_nonmergeable_order) < (first_nonmergeable_int_order
) ? (first_nonmergeable_order) : (first_nonmergeable_int_order
));
      end = this_end;
      break;
    }
  while (1);

  if (k != 0)
    {
      merged_store->merge_overlapping (info);

      merged_store->first_nonmergeable_order
	= MIN (merged_store->first_nonmergeable_order,((merged_store->first_nonmergeable_order) < (first_nonmergeable_order
) ? (merged_store->first_nonmergeable_order) : (first_nonmergeable_order
))
	       first_nonmergeable_order)((merged_store->first_nonmergeable_order) < (first_nonmergeable_order
) ? (merged_store->first_nonmergeable_order) : (first_nonmergeable_order
));

      for (unsigned int j = i + 1; j <= k; j++)
	{
	  store_immediate_info *info2 = m_store_info[j];
	  gcc_assert (info2->bitpos < end)((void)(!(info2->bitpos < end) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3252, __FUNCTION__), 0 : 0));
	  if (info2->order < last_order)
	    {
	      gcc_assert (info2->rhs_code == INTEGER_CST)((void)(!(info2->rhs_code == INTEGER_CST) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3255, __FUNCTION__), 0 : 0));
	      if (info != info2)
		merged_store->merge_overlapping (info2);
	    }
	  /* Other stores are kept and not merged in any
	     way.  */
	}
      ignore = k;
      goto done;
    }
}
   }
}
    /* |---store 1---||---store 2---|
This store is consecutive to the previous one.
Merge it into the current store group.  There can be gaps in between
the stores, but there can't be gaps in between bitregions.  */
    else if (info->bitregion_start <= merged_store->bitregion_end
      && merged_store->can_be_merged_into (info))
{
 store_immediate_info *infof = merged_store->stores[0];

 /* All the rhs_code ops that take 2 operands are commutative,
    swap the operands if it could make the operands compatible.  */
 if (infof->ops[0].base_addr
     && infof->ops[1].base_addr
     && info->ops[0].base_addr
     && info->ops[1].base_addr
     && known_eq (info->ops[1].bitpos - infof->ops[0].bitpos,(!maybe_ne (info->ops[1].bitpos - infof->ops[0].bitpos,
 info->bitpos - infof->bitpos))
	   info->bitpos - infof->bitpos)(!maybe_ne (info->ops[1].bitpos - infof->ops[0].bitpos,
 info->bitpos - infof->bitpos))
     && operand_equal_p (info->ops[1].base_addr,
		  infof->ops[0].base_addr, 0))
   {
     std::swap (info->ops[0], info->ops[1]);
     info->ops_swapped_p = true;
   }
 if (check_no_overlap (m_store_info, i, false,
		MIN (merged_store->first_order, info->order)((merged_store->first_order) < (info->order) ? (merged_store
->first_order) : (info->order)),
		MAX (merged_store->last_order, info->order)((merged_store->last_order) > (info->order) ? (merged_store
->last_order) : (info->order)),
		merged_store->start,
		MAX (merged_store->start + merged_store->width,((merged_store->start + merged_store->width) > (info
->bitpos + info->bitsize) ? (merged_store->start + merged_store
->width) : (info->bitpos + info->bitsize))
		     info->bitpos + info->bitsize)((merged_store->start + merged_store->width) > (info
->bitpos + info->bitsize) ? (merged_store->start + merged_store
->width) : (info->bitpos + info->bitsize)),
		first_earlier, end_earlier))
   {
     /* Turn MEM_REF into BIT_INSERT_EXPR for bit-field stores.  */
     if (info->rhs_code == MEM_REF && infof->rhs_code != MEM_REF)
{
  info->rhs_code = BIT_INSERT_EXPR;
  info->ops[0].val = gimple_assign_rhs1 (info->stmt);
  info->ops[0].base_addr = NULL_TREE(tree) nullptr;
}
     else if (infof->rhs_code == MEM_REF && info->rhs_code != MEM_REF)
{
  for (store_immediate_info *infoj : merged_store->stores)
    {
      infoj->rhs_code = BIT_INSERT_EXPR;
      infoj->ops[0].val = gimple_assign_rhs1 (infoj->stmt);
      infoj->ops[0].base_addr = NULL_TREE(tree) nullptr;
    }
  merged_store->bit_insertion = true;
}
     if ((infof->ops[0].base_addr
   ? compatible_load_p (merged_store, info, base_addr, 0)
   : !info->ops[0].base_addr)
  && (infof->ops[1].base_addr
      ? compatible_load_p (merged_store, info, base_addr, 1)
      : !info->ops[1].base_addr))
{
  merged_store->merge_into (info);
  goto done;
}
   }
}

    /* |---store 1---| <gap> |---store 2---|.
Gap between stores or the rhs not compatible.  Start a new group.  */

    /* Try to apply all the stores recorded for the group to determine
the bitpattern they write and discard it if that fails.
This will also reject single-store groups.  */
    if (merged_store->apply_stores ())
m_merged_store_groups.safe_push (merged_store);
    else
delete merged_store;

    merged_store = new merged_store_group (info);
    end_earlier = i;
    if (dump_file && (dump_flags & TDF_DETAILS))
fputs ("New store group\n", dump_file);

  done:
    if (dump_file && (dump_flags & TDF_DETAILS))
{
 fprintf (dump_file, "Store %u:\nbitsize:" HOST_WIDE_INT_PRINT_DEC"%" "l" "d"
	      " bitpos:" HOST_WIDE_INT_PRINT_DEC"%" "l" "d" " val:",
   i, info->bitsize, info->bitpos);
 print_generic_expr (dump_file, gimple_assign_rhs1 (info->stmt));
 fputc ('\n', dump_file);
}
  }

/* Record or discard the last store group.  */
if (merged_store)
  {
    if (merged_store->apply_stores ())
m_merged_store_groups.safe_push (merged_store);
    else
delete merged_store;
  }

gcc_assert (m_merged_store_groups.length () <= m_store_info.length ())((void)(!(m_merged_store_groups.length () <= m_store_info.
length ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3365, __FUNCTION__), 0 : 0));

bool success
  = !m_merged_store_groups.is_empty ()
    && m_merged_store_groups.length () < m_store_info.length ();

if (success && dump_file)
  fprintf (dump_file, "Coalescing successful!\nMerged into %u stores\n",
    m_merged_store_groups.length ());

return success;
3376}

3378/* Return the type to use for the merged stores or loads described by STMTS.
 This is needed to get the alias sets right.  If IS_LOAD, look for rhs,
 otherwise lhs.  Additionally set *CLIQUEP and *BASEP to MR_DEPENDENCE_*
 of the MEM_REFs if any.  */

3383static tree
3384get_alias_type_for_stmts (vec<gimple *> &stmts, bool is_load,
	  unsigned short *cliquep, unsigned short *basep)
3386{
gimple *stmt;
unsigned int i;
tree type = NULL_TREE(tree) nullptr;
tree ret = NULL_TREE(tree) nullptr;
*cliquep = 0;
*basep = 0;

FOR_EACH_VEC_ELT (stmts, i, stmt)for (i = 0; (stmts).iterate ((i), &(stmt)); ++(i))
  {
    tree ref = is_load ? gimple_assign_rhs1 (stmt)
	 : gimple_assign_lhs (stmt);
    tree type1 = reference_alias_ptr_type (ref);
    tree base = get_base_address (ref);

    if (i == 0)
{
 if (TREE_CODE (base)((enum tree_code) (base)->base.code) == MEM_REF)
   {
     *cliquep = MR_DEPENDENCE_CLIQUE (base)((tree_check2 ((base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3405, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique);
     *basep = MR_DEPENDENCE_BASE (base)((tree_check2 ((base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3406, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.base);
   }
 ret = type = type1;
 continue;
}
    if (!alias_ptr_types_compatible_p (type, type1))
ret = ptr_type_nodeglobal_trees[TI_PTR_TYPE];
    if (TREE_CODE (base)((enum tree_code) (base)->base.code) != MEM_REF
 || *cliquep != MR_DEPENDENCE_CLIQUE (base)((tree_check2 ((base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3414, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique)
 || *basep != MR_DEPENDENCE_BASE (base)((tree_check2 ((base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3415, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.base))
{
 *cliquep = 0;
 *basep = 0;
}
  }
return ret;
3422}

3424/* Return the location_t information we can find among the statements
 in STMTS.  */

3427static location_t
3428get_location_for_stmts (vec<gimple *> &stmts)
3429{
for (gimple *stmt : stmts)
  if (gimple_has_location (stmt))
    return gimple_location (stmt);

return UNKNOWN_LOCATION((location_t) 0);
3435}

3437/* Used to decribe a store resulting from splitting a wide store in smaller
 regularly-sized stores in split_group.  */

3440class split_store
3441{
3442public:
unsigned HOST_WIDE_INTlong bytepos;
unsigned HOST_WIDE_INTlong size;
unsigned HOST_WIDE_INTlong align;
auto_vec<store_immediate_info *> orig_stores;
/* True if there is a single orig stmt covering the whole split store.  */
bool orig;
split_store (unsigned HOST_WIDE_INTlong, unsigned HOST_WIDE_INTlong,
      unsigned HOST_WIDE_INTlong);
3451};

3453/* Simple constructor.  */

3455split_store::split_store (unsigned HOST_WIDE_INTlong bp,
	  unsigned HOST_WIDE_INTlong sz,
	  unsigned HOST_WIDE_INTlong al)
	  : bytepos (bp), size (sz), align (al), orig (false)
3459{
orig_stores.create (0);
3461}

3463/* Record all stores in GROUP that write to the region starting at BITPOS and
 is of size BITSIZE.  Record infos for such statements in STORES if
 non-NULL.  The stores in GROUP must be sorted by bitposition.  Return INFO
 if there is exactly one original store in the range (in that case ignore
 clobber stmts, unless there are only clobber stmts).  */

3469static store_immediate_info *
3470find_constituent_stores (class merged_store_group *group,
	 vec<store_immediate_info *> *stores,
	 unsigned int *first,
	 unsigned HOST_WIDE_INTlong bitpos,
	 unsigned HOST_WIDE_INTlong bitsize)
3475{
store_immediate_info *info, *ret = NULLnullptr;
unsigned int i;
bool second = false;
bool update_first = true;
unsigned HOST_WIDE_INTlong end = bitpos + bitsize;
for (i = *first; group->stores.iterate (i, &info); ++i)
  {
    unsigned HOST_WIDE_INTlong stmt_start = info->bitpos;
    unsigned HOST_WIDE_INTlong stmt_end = stmt_start + info->bitsize;
    if (stmt_end <= bitpos)
{
 /* BITPOS passed to this function never decreases from within the
    same split_group call, so optimize and don't scan info records
    which are known to end before or at BITPOS next time.
    Only do it if all stores before this one also pass this.  */
 if (update_first)
   *first = i + 1;
 continue;
}
    else
update_first = false;

    /* The stores in GROUP are ordered by bitposition so if we're past
the region for this group return early.  */
    if (stmt_start >= end)
return ret;

    if (gimple_clobber_p (info->stmt))
{
 if (stores)
   stores->safe_push (info);
 if (ret == NULLnullptr)
   ret = info;
 continue;
}
    if (stores)
{
 stores->safe_push (info);
 if (ret && !gimple_clobber_p (ret->stmt))
   {
     ret = NULLnullptr;
     second = true;
   }
}
    else if (ret && !gimple_clobber_p (ret->stmt))
return NULLnullptr;
    if (!second)
ret = info;
  }
return ret;
3526}

3528/* Return how many SSA_NAMEs used to compute value to store in the INFO
 store have multiple uses.  If any SSA_NAME has multiple uses, also
 count statements needed to compute it.  */

3532static unsigned
3533count_multiple_uses (store_immediate_info *info)
3534{
gimple *stmt = info->stmt;
unsigned ret = 0;
switch (info->rhs_code)
  {
  case INTEGER_CST:
  case STRING_CST:
    return 0;
  case BIT_AND_EXPR:
  case BIT_IOR_EXPR:
  case BIT_XOR_EXPR:
    if (info->bit_not_p)
{
 if (!has_single_use (gimple_assign_rhs1 (stmt)))
   ret = 1; /* Fall through below to return
	the BIT_NOT_EXPR stmt and then
	BIT_{AND,IOR,XOR}_EXPR and anything it
	uses.  */
 else
   /* stmt is after this the BIT_NOT_EXPR.  */
   stmt = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt))(tree_check ((gimple_assign_rhs1 (stmt)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3554, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
}
    if (!has_single_use (gimple_assign_rhs1 (stmt)))
{
 ret += 1 + info->ops[0].bit_not_p;
 if (info->ops[1].base_addr)
   ret += 1 + info->ops[1].bit_not_p;
 return ret + 1;
}
    stmt = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt))(tree_check ((gimple_assign_rhs1 (stmt)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3563, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
    /* stmt is now the BIT_*_EXPR.  */
    if (!has_single_use (gimple_assign_rhs1 (stmt)))
ret += 1 + info->ops[info->ops_swapped_p].bit_not_p;
    else if (info->ops[info->ops_swapped_p].bit_not_p)
{
 gimple *stmt2 = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt))(tree_check ((gimple_assign_rhs1 (stmt)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3569, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
 if (!has_single_use (gimple_assign_rhs1 (stmt2)))
   ++ret;
}
    if (info->ops[1].base_addr == NULL_TREE(tree) nullptr)
{
 gcc_checking_assert (!info->ops_swapped_p)((void)(!(!info->ops_swapped_p) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3575, __FUNCTION__), 0 : 0));
 return ret;
}
    if (!has_single_use (gimple_assign_rhs2 (stmt)))
ret += 1 + info->ops[1 - info->ops_swapped_p].bit_not_p;
    else if (info->ops[1 - info->ops_swapped_p].bit_not_p)
{
 gimple *stmt2 = SSA_NAME_DEF_STMT (gimple_assign_rhs2 (stmt))(tree_check ((gimple_assign_rhs2 (stmt)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3582, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
 if (!has_single_use (gimple_assign_rhs1 (stmt2)))
   ++ret;
}
    return ret;
  case MEM_REF:
    if (!has_single_use (gimple_assign_rhs1 (stmt)))
return 1 + info->ops[0].bit_not_p;
    else if (info->ops[0].bit_not_p)
{
 stmt = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt))(tree_check ((gimple_assign_rhs1 (stmt)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3592, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
 if (!has_single_use (gimple_assign_rhs1 (stmt)))
   return 1;
}
    return 0;
  case BIT_INSERT_EXPR:
    return has_single_use (gimple_assign_rhs1 (stmt)) ? 0 : 1;
  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3600, __FUNCTION__));
  }
3602}

3604/* Split a merged store described by GROUP by populating the SPLIT_STORES
 vector (if non-NULL) with split_store structs describing the byte offset
 (from the base), the bit size and alignment of each store as well as the
 original statements involved in each such split group.
 This is to separate the splitting strategy from the statement
 building/emission/linking done in output_merged_store.
 Return number of new stores.
 If ALLOW_UNALIGNED_STORE is false, then all stores must be aligned.
 If ALLOW_UNALIGNED_LOAD is false, then all loads must be aligned.
 BZERO_FIRST may be true only when the first store covers the whole group
 and clears it; if BZERO_FIRST is true, keep that first store in the set
 unmodified and emit further stores for the overrides only.
 If SPLIT_STORES is NULL, it is just a dry run to count number of
 new stores.  */

3619static unsigned int
3620split_group (merged_store_group *group, bool allow_unaligned_store,
    bool allow_unaligned_load, bool bzero_first,
    vec<split_store *> *split_stores,
    unsigned *total_orig,
    unsigned *total_new)
3625{
unsigned HOST_WIDE_INTlong pos = group->bitregion_start;
unsigned HOST_WIDE_INTlong size = group->bitregion_end - pos;
unsigned HOST_WIDE_INTlong bytepos = pos / BITS_PER_UNIT(8);
unsigned HOST_WIDE_INTlong group_align = group->align;
unsigned HOST_WIDE_INTlong align_base = group->align_base;
unsigned HOST_WIDE_INTlong group_load_align = group_align;
bool any_orig = false;

gcc_assert ((size % BITS_PER_UNIT == 0) && (pos % BITS_PER_UNIT == 0))((void)(!((size % (8) == 0) && (pos % (8) == 0)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3634, __FUNCTION__), 0 : 0));

/* For bswap framework using sets of stores, all the checking has been done
   earlier in try_coalesce_bswap and the result always needs to be emitted
   as a single store.  Likewise for string concatenation.  */
if (group->stores[0]->rhs_code == LROTATE_EXPR
    || group->stores[0]->rhs_code == NOP_EXPR
    || group->string_concatenation)
  {
    gcc_assert (!bzero_first)((void)(!(!bzero_first) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3643, __FUNCTION__), 0 : 0));
    if (total_orig)
{
 /* Avoid the old/new stmt count heuristics.  It should be
    always beneficial.  */
 total_new[0] = 1;
 total_orig[0] = 2;
}

    if (split_stores)
{
 unsigned HOST_WIDE_INTlong align_bitpos
   = (group->start - align_base) & (group_align - 1);
 unsigned HOST_WIDE_INTlong align = group_align;
 if (align_bitpos)
   align = least_bit_hwi (align_bitpos);
 bytepos = group->start / BITS_PER_UNIT(8);
 split_store *store
   = new split_store (bytepos, group->width, align);
 unsigned int first = 0;
 find_constituent_stores (group, &store->orig_stores,
		   &first, group->start, group->width);
 split_stores->safe_push (store);
}

    return 1;
  }

unsigned int ret = 0, first = 0;
unsigned HOST_WIDE_INTlong try_pos = bytepos;

if (total_orig)
  {
    unsigned int i;
    store_immediate_info *info = group->stores[0];

    total_new[0] = 0;
    total_orig[0] = 1; /* The orig store.  */
    info = group->stores[0];
    if (info->ops[0].base_addr)
total_orig[0]++;
    if (info->ops[1].base_addr)
total_orig[0]++;
    switch (info->rhs_code)
{
case BIT_AND_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
 total_orig[0]++; /* The orig BIT_*_EXPR stmt.  */
 break;
default:
 break;
}
    total_orig[0] *= group->stores.length ();

    FOR_EACH_VEC_ELT (group->stores, i, info)for (i = 0; (group->stores).iterate ((i), &(info)); ++
(i))
{
 total_new[0] += count_multiple_uses (info);
 total_orig[0] += (info->bit_not_p
	    + info->ops[0].bit_not_p
	    + info->ops[1].bit_not_p);
}
  }

if (!allow_unaligned_load)
  for (int i = 0; i < 2; ++i)
    if (group->load_align[i])
group_load_align = MIN (group_load_align, group->load_align[i])((group_load_align) < (group->load_align[i]) ? (group_load_align
) : (group->load_align[i]));

if (bzero_first)
  {
    store_immediate_info *gstore;
    FOR_EACH_VEC_ELT (group->stores, first, gstore)for (first = 0; (group->stores).iterate ((first), &(gstore
)); ++(first))
if (!gimple_clobber_p (gstore->stmt))
 break;
    ++first;
    ret = 1;
    if (split_stores)
{
 split_store *store
   = new split_store (bytepos, gstore->bitsize, align_base);
 store->orig_stores.safe_push (gstore);
 store->orig = true;
 any_orig = true;
 split_stores->safe_push (store);
}
  }

while (size > 0)
  {
    if ((allow_unaligned_store || group_align <= BITS_PER_UNIT(8))
 && (group->mask[try_pos - bytepos] == (unsigned char) ~0U
     || (bzero_first && group->val[try_pos - bytepos] == 0)))
{
 /* Skip padding bytes.  */
 ++try_pos;
 size -= BITS_PER_UNIT(8);
 continue;
}

    unsigned HOST_WIDE_INTlong try_bitpos = try_pos * BITS_PER_UNIT(8);
    unsigned int try_size = MAX_STORE_BITSIZE(((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4))), nonmasked;
    unsigned HOST_WIDE_INTlong align_bitpos
= (try_bitpos - align_base) & (group_align - 1);
    unsigned HOST_WIDE_INTlong align = group_align;
    bool found_orig = false;
    if (align_bitpos)
align = least_bit_hwi (align_bitpos);
    if (!allow_unaligned_store)
try_size = MIN (try_size, align)((try_size) < (align) ? (try_size) : (align));
    if (!allow_unaligned_load)
{
 /* If we can't do or don't want to do unaligned stores
    as well as loads, we need to take the loads into account
    as well.  */
 unsigned HOST_WIDE_INTlong load_align = group_load_align;
 align_bitpos = (try_bitpos - align_base) & (load_align - 1);
 if (align_bitpos)
   load_align = least_bit_hwi (align_bitpos);
 for (int i = 0; i < 2; ++i)
   if (group->load_align[i])
     {
align_bitpos
  = known_alignment (try_bitpos
		     - group->stores[0]->bitpos
		     + group->stores[0]->ops[i].bitpos
		     - group->load_align_base[i]);
if (align_bitpos & (group_load_align - 1))
  {
    unsigned HOST_WIDE_INTlong a = least_bit_hwi (align_bitpos);
    load_align = MIN (load_align, a)((load_align) < (a) ? (load_align) : (a));
  }
     }
 try_size = MIN (try_size, load_align)((try_size) < (load_align) ? (try_size) : (load_align));
}
    store_immediate_info *info
= find_constituent_stores (group, NULLnullptr, &first, try_bitpos, try_size);
    if (info && !gimple_clobber_p (info->stmt))
{
 /* If there is just one original statement for the range, see if
    we can just reuse the original store which could be even larger
    than try_size.  */
 unsigned HOST_WIDE_INTlong stmt_end
   = ROUND_UP (info->bitpos + info->bitsize, BITS_PER_UNIT)(((info->bitpos + info->bitsize) + ((8)) - 1) & ~((
(8)) - 1));
 info = find_constituent_stores (group, NULLnullptr, &first, try_bitpos,
			  stmt_end - try_bitpos);
 if (info && info->bitpos >= try_bitpos)
   {
     store_immediate_info *info2 = NULLnullptr;
     unsigned int first_copy = first;
     if (info->bitpos > try_bitpos
  && stmt_end - try_bitpos <= try_size)
{
  info2 = find_constituent_stores (group, NULLnullptr, &first_copy,
				   try_bitpos,
				   info->bitpos - try_bitpos);
  gcc_assert (info2 == NULL || gimple_clobber_p (info2->stmt))((void)(!(info2 == nullptr || gimple_clobber_p (info2->stmt
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3799, __FUNCTION__), 0 : 0));
}
     if (info2 == NULLnullptr && stmt_end - try_bitpos < try_size)
{
  info2 = find_constituent_stores (group, NULLnullptr, &first_copy,
				   stmt_end,
				   (try_bitpos + try_size)
				   - stmt_end);
  gcc_assert (info2 == NULL || gimple_clobber_p (info2->stmt))((void)(!(info2 == nullptr || gimple_clobber_p (info2->stmt
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3807, __FUNCTION__), 0 : 0));
}
     if (info2 == NULLnullptr)
{
  try_size = stmt_end - try_bitpos;
  found_orig = true;
  goto found;
}
   }
}

    /* Approximate store bitsize for the case when there are no padding
bits.  */
    while (try_size > size)
try_size /= 2;
    /* Now look for whole padding bytes at the end of that bitsize.  */
    for (nonmasked = try_size / BITS_PER_UNIT(8); nonmasked > 0; --nonmasked)
if (group->mask[try_pos - bytepos + nonmasked - 1]
   != (unsigned char) ~0U
   && (!bzero_first
|| group->val[try_pos - bytepos + nonmasked - 1] != 0))
 break;
    if (nonmasked == 0 || (info && gimple_clobber_p (info->stmt)))
{
 /* If entire try_size range is padding, skip it.  */
 try_pos += try_size / BITS_PER_UNIT(8);
 size -= try_size;
 continue;
}
    /* Otherwise try to decrease try_size if second half, last 3 quarters
etc. are padding.  */
    nonmasked *= BITS_PER_UNIT(8);
    while (nonmasked <= try_size / 2)
try_size /= 2;
    if (!allow_unaligned_store && group_align > BITS_PER_UNIT(8))
{
 /* Now look for whole padding bytes at the start of that bitsize.  */
 unsigned int try_bytesize = try_size / BITS_PER_UNIT(8), masked;
 for (masked = 0; masked < try_bytesize; ++masked)
   if (group->mask[try_pos - bytepos + masked] != (unsigned char) ~0U
&& (!bzero_first
    || group->val[try_pos - bytepos + masked] != 0))
     break;
 masked *= BITS_PER_UNIT(8);
 gcc_assert (masked < try_size)((void)(!(masked < try_size) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3851, __FUNCTION__), 0 : 0));
 if (masked >= try_size / 2)
   {
     while (masked >= try_size / 2)
{
  try_size /= 2;
  try_pos += try_size / BITS_PER_UNIT(8);
  size -= try_size;
  masked -= try_size;
}
     /* Need to recompute the alignment, so just retry at the new
 position.  */
     continue;
   }
}

  found:
    ++ret;

    if (split_stores)
{
 split_store *store
   = new split_store (try_pos, try_size, align);
 info = find_constituent_stores (group, &store->orig_stores,
			  &first, try_bitpos, try_size);
 if (info
     && !gimple_clobber_p (info->stmt)
     && info->bitpos >= try_bitpos
     && info->bitpos + info->bitsize <= try_bitpos + try_size
     && (store->orig_stores.length () == 1
  || found_orig
  || (info->bitpos == try_bitpos
      && (info->bitpos + info->bitsize
	  == try_bitpos + try_size))))
   {
     store->orig = true;
     any_orig = true;
   }
 split_stores->safe_push (store);
}

    try_pos += try_size / BITS_PER_UNIT(8);
    size -= try_size;
  }

if (total_orig)
  {
    unsigned int i;
    split_store *store;
    /* If we are reusing some original stores and any of the
original SSA_NAMEs had multiple uses, we need to subtract
those now before we add the new ones.  */
    if (total_new[0] && any_orig)
{
 FOR_EACH_VEC_ELT (*split_stores, i, store)for (i = 0; (*split_stores).iterate ((i), &(store)); ++(i
))
   if (store->orig)
     total_new[0] -= count_multiple_uses (store->orig_stores[0]);
}
    total_new[0] += ret; /* The new store.  */
    store_immediate_info *info = group->stores[0];
    if (info->ops[0].base_addr)
total_new[0] += ret;
    if (info->ops[1].base_addr)
total_new[0] += ret;
    switch (info->rhs_code)
{
case BIT_AND_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
 total_new[0] += ret; /* The new BIT_*_EXPR stmt.  */
 break;
default:
 break;
}
    FOR_EACH_VEC_ELT (*split_stores, i, store)for (i = 0; (*split_stores).iterate ((i), &(store)); ++(i
))
{
 unsigned int j;
 bool bit_not_p[3] = { false, false, false };
 /* If all orig_stores have certain bit_not_p set, then
    we'd use a BIT_NOT_EXPR stmt and need to account for it.
    If some orig_stores have certain bit_not_p set, then
    we'd use a BIT_XOR_EXPR with a mask and need to account for
    it.  */
 FOR_EACH_VEC_ELT (store->orig_stores, j, info)for (j = 0; (store->orig_stores).iterate ((j), &(info)
); ++(j))
   {
     if (info->ops[0].bit_not_p)
bit_not_p[0] = true;
     if (info->ops[1].bit_not_p)
bit_not_p[1] = true;
     if (info->bit_not_p)
bit_not_p[2] = true;
   }
 total_new[0] += bit_not_p[0] + bit_not_p[1] + bit_not_p[2];
}

  }

return ret;
3949}

3951/* Return the operation through which the operand IDX (if < 2) or
 result (IDX == 2) should be inverted.  If NOP_EXPR, no inversion
 is done, if BIT_NOT_EXPR, all bits are inverted, if BIT_XOR_EXPR,
 the bits should be xored with mask.  */

3956static enum tree_code
3957invert_op (split_store *split_store, int idx, tree int_type, tree &mask)
3958{
unsigned int i;
store_immediate_info *info;
unsigned int cnt = 0;
bool any_paddings = false;
FOR_EACH_VEC_ELT (split_store->orig_stores, i, info)for (i = 0; (split_store->orig_stores).iterate ((i), &
(info)); ++(i))
  {
    bool bit_not_p = idx < 2 ? info->ops[idx].bit_not_p : info->bit_not_p;
    if (bit_not_p)
{
 ++cnt;
 tree lhs = gimple_assign_lhs (info->stmt);
 if (INTEGRAL_TYPE_P (TREE_TYPE (lhs))(((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3970, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3970, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3970, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
     && TYPE_PRECISION (TREE_TYPE (lhs))((tree_class_check ((((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3971, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 3971, __FUNCTION__))->type_common.precision) < info->bitsize)
   any_paddings = true;
}
  }
mask = NULL_TREE(tree) nullptr;
if (cnt == 0)
  return NOP_EXPR;
if (cnt == split_store->orig_stores.length () && !any_paddings)
  return BIT_NOT_EXPR;

unsigned HOST_WIDE_INTlong try_bitpos = split_store->bytepos * BITS_PER_UNIT(8);
unsigned buf_size = split_store->size / BITS_PER_UNIT(8);
unsigned char *buf
  = XALLOCAVEC (unsigned char, buf_size)((unsigned char *) __builtin_alloca(sizeof (unsigned char) * (
buf_size)));
memset (buf, ~0U, buf_size);
FOR_EACH_VEC_ELT (split_store->orig_stores, i, info)for (i = 0; (split_store->orig_stores).iterate ((i), &
(info)); ++(i))
  {
    bool bit_not_p = idx < 2 ? info->ops[idx].bit_not_p : info->bit_not_p;
    if (!bit_not_p)
continue;
    /* Clear regions with bit_not_p and invert afterwards, rather than
clear regions with !bit_not_p, so that gaps in between stores aren't
set in the mask.  */
    unsigned HOST_WIDE_INTlong bitsize = info->bitsize;
    unsigned HOST_WIDE_INTlong prec = bitsize;
    unsigned int pos_in_buffer = 0;
    if (any_paddings)
{
 tree lhs = gimple_assign_lhs (info->stmt);
 if (INTEGRAL_TYPE_P (TREE_TYPE (lhs))(((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4000, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4000, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4000, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
     && TYPE_PRECISION (TREE_TYPE (lhs))((tree_class_check ((((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4001, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4001, __FUNCTION__))->type_common.precision) < bitsize)
   prec = TYPE_PRECISION (TREE_TYPE (lhs))((tree_class_check ((((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4002, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4002, __FUNCTION__))->type_common.precision);
}
    if (info->bitpos < try_bitpos)
{
 gcc_assert (info->bitpos + bitsize > try_bitpos)((void)(!(info->bitpos + bitsize > try_bitpos) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4006, __FUNCTION__), 0 : 0));
 if (!BYTES_BIG_ENDIAN0)
   {
     if (prec <= try_bitpos - info->bitpos)
continue;
     prec -= try_bitpos - info->bitpos;
   }
 bitsize -= try_bitpos - info->bitpos;
 if (BYTES_BIG_ENDIAN0 && prec > bitsize)
   prec = bitsize;
}
    else
pos_in_buffer = info->bitpos - try_bitpos;
    if (prec < bitsize)
{
 /* If this is a bool inversion, invert just the least significant
    prec bits rather than all bits of it.  */
 if (BYTES_BIG_ENDIAN0)
   {
     pos_in_buffer += bitsize - prec;
     if (pos_in_buffer >= split_store->size)
continue;
   }
 bitsize = prec;
}
    if (pos_in_buffer + bitsize > split_store->size)
bitsize = split_store->size - pos_in_buffer;
    unsigned char *p = buf + (pos_in_buffer / BITS_PER_UNIT(8));
    if (BYTES_BIG_ENDIAN0)
clear_bit_region_be (p, (BITS_PER_UNIT(8) - 1
		 - (pos_in_buffer % BITS_PER_UNIT(8))), bitsize);
    else
clear_bit_region (p, pos_in_buffer % BITS_PER_UNIT(8), bitsize);
  }
for (unsigned int i = 0; i < buf_size; ++i)
  buf[i] = ~buf[i];
mask = native_interpret_expr (int_type, buf, buf_size);
return BIT_XOR_EXPR;
4044}

4046/* Given a merged store group GROUP output the widened version of it.
 The store chain is against the base object BASE.
 Try store sizes of at most MAX_STORE_BITSIZE bits wide and don't output
 unaligned stores for STRICT_ALIGNMENT targets or if it's too expensive.
 Make sure that the number of statements output is less than the number of
 original statements.  If a better sequence is possible emit it and
 return true.  */

4054bool
4055imm_store_chain_info::output_merged_store (merged_store_group *group)
4056{
const unsigned HOST_WIDE_INTlong start_byte_pos
  = group->bitregion_start / BITS_PER_UNIT(8);
unsigned int orig_num_stmts = group->stores.length ();
if (orig_num_stmts < 2)
1
Assuming 'orig_num_stmts' is >= 2→
  return false;

bool allow_unaligned_store
  = !STRICT_ALIGNMENT0 && param_store_merging_allow_unalignedglobal_options.x_param_store_merging_allow_unaligned;
bool allow_unaligned_load = allow_unaligned_store;
bool bzero_first = false;
store_immediate_info *store;
unsigned int num_clobber_stmts = 0;
if (group->stores[0]->rhs_code == INTEGER_CST)
2
←
Assuming field 'rhs_code' is not equal to INTEGER_CST→
  {
    unsigned int i;
    FOR_EACH_VEC_ELT (group->stores, i, store)for (i = 0; (group->stores).iterate ((i), &(store)); ++
(i))
if (gimple_clobber_p (store->stmt))
 num_clobber_stmts++;
else if (TREE_CODE (gimple_assign_rhs1 (store->stmt))((enum tree_code) (gimple_assign_rhs1 (store->stmt))->base
.code) == CONSTRUCTOR
 && CONSTRUCTOR_NELTS (gimple_assign_rhs1 (store->stmt))(vec_safe_length (((tree_check ((gimple_assign_rhs1 (store->
stmt)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4076, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))) == 0
 && group->start == store->bitpos
 && group->width == store->bitsize
 && (group->start % BITS_PER_UNIT(8)) == 0
 && (group->width % BITS_PER_UNIT(8)) == 0)
 {
   bzero_first = true;
   break;
 }
else
 break;
    FOR_EACH_VEC_ELT_FROM (group->stores, i, store, i)for (i = (i); (group->stores).iterate ((i), &(store));
 ++(i))
if (gimple_clobber_p (store->stmt))
 num_clobber_stmts++;
    if (num_clobber_stmts == orig_num_stmts)
return false;
    orig_num_stmts -= num_clobber_stmts;
  }
if (allow_unaligned_store || bzero_first3.1
'bzero_first' is false
)
3
←
Assuming 'allow_unaligned_store' is false→
4
←
Taking false branch→
  {
    /* If unaligned stores are allowed, see how many stores we'd emit
for unaligned and how many stores we'd emit for aligned stores.
Only use unaligned stores if it allows fewer stores than aligned.
Similarly, if there is a whole region clear first, prefer expanding
it together compared to expanding clear first followed by merged
further stores.  */
    unsigned cnt[4] = { ~0U, ~0U, ~0U, ~0U };
    int pass_min = 0;
    for (int pass = 0; pass < 4; ++pass)
{
 if (!allow_unaligned_store && (pass & 1) != 0)
   continue;
 if (!bzero_first && (pass & 2) != 0)
   continue;
 cnt[pass] = split_group (group, (pass & 1) != 0,
		   allow_unaligned_load, (pass & 2) != 0,
		   NULLnullptr, NULLnullptr, NULLnullptr);
 if (cnt[pass] < cnt[pass_min])
   pass_min = pass;
}
    if ((pass_min & 1) == 0)
allow_unaligned_store = false;
    if ((pass_min & 2) == 0)
bzero_first = false;
  }

auto_vec<class split_store *, 32> split_stores;
split_store *split_store;
unsigned total_orig, total_new, i;
split_group (group, allow_unaligned_store, allow_unaligned_load, bzero_first,
      &split_stores, &total_orig, &total_new);

/* Determine if there is a clobber covering the whole group at the start,
   followed by proposed split stores that cover the whole group.  In that
   case, prefer the transformation even if
   split_stores.length () == orig_num_stmts.  */
bool clobber_first = false;
if (num_clobber_stmts

4.1	'num_clobber_stmts' is 0

4134 && gimple_clobber_p (group->stores[0]->stmt) 4135 && group->start == group->stores[0]->bitpos 4136 && group->width == group->stores[0]->bitsize 4137 && (group->start % BITS_PER_UNIT(8)) == 0 4138 && (group->width % BITS_PER_UNIT(8)) == 0) 4139 { 4140 clobber_first = true; 4141 unsigned HOST_WIDE_INTlong pos = group->start / BITS_PER_UNIT(8); 4142 FOR_EACH_VEC_ELT (split_stores, i, split_store)for (i = 0; (split_stores).iterate ((i), &(split_store));
++(i)) 4143 if (split_store->bytepos != pos) 4144 { 4145 clobber_first = false; 4146 break; 4147 } 4148 else 4149 pos += split_store->size / BITS_PER_UNIT(8); 4150 if (pos != (group->start + group->width) / BITS_PER_UNIT(8)) 4151 clobber_first = false; 4152 } 4153 4154 if (split_stores.length () >= orig_num_stmts + clobber_first)

←

Assuming the condition is false

→

←

Taking false branch

→

4155 { 4156 4157 /* We didn't manage to reduce the number of statements. Bail out. */ 4158 if (dump_file && (dump_flags & TDF_DETAILS)) 4159 fprintf (dump_file, "Exceeded original number of stmts (%u)." 4160 " Not profitable to emit new sequence.\n", 4161 orig_num_stmts); 4162 FOR_EACH_VEC_ELT (split_stores, i, split_store)for (i = 0; (split_stores).iterate ((i), &(split_store));
++(i)) 4163 delete split_store; 4164 return false; 4165 } 4166 if (total_orig <= total_new)

←

Assuming 'total_orig' is > 'total_new'

→

←

Taking false branch

→

4167 { 4168 /* If number of estimated new statements is above estimated original 4169 statements, bail out too. */ 4170 if (dump_file && (dump_flags & TDF_DETAILS)) 4171 fprintf (dump_file, "Estimated number of original stmts (%u)" 4172 " not larger than estimated number of new" 4173 " stmts (%u).\n", 4174 total_orig, total_new); 4175 FOR_EACH_VEC_ELT (split_stores, i, split_store)for (i = 0; (split_stores).iterate ((i), &(split_store));
++(i)) 4176 delete split_store; 4177 return false; 4178 } 4179 if (group->stores[0]->rhs_code == INTEGER_CST)

←

Assuming field 'rhs_code' is not equal to INTEGER_CST

→

←

Taking false branch

→

4180 { 4181 bool all_orig = true; 4182 FOR_EACH_VEC_ELT (split_stores, i, split_store)for (i = 0; (split_stores).iterate ((i), &(split_store));
++(i)) 4183 if (!split_store->orig) 4184 { 4185 all_orig = false; 4186 break; 4187 } 4188 if (all_orig) 4189 { 4190 unsigned int cnt = split_stores.length (); 4191 store_immediate_info *store; 4192 FOR_EACH_VEC_ELT (group->stores, i, store)for (i = 0; (group->stores).iterate ((i), &(store)); ++
(i)) 4193 if (gimple_clobber_p (store->stmt)) 4194 ++cnt; 4195 /* Punt if we wouldn't make any real changes, i.e. keep all 4196 orig stmts + all clobbers. */ 4197 if (cnt == group->stores.length ()) 4198 { 4199 if (dump_file && (dump_flags & TDF_DETAILS)) 4200 fprintf (dump_file, "Exceeded original number of stmts (%u)." 4201 " Not profitable to emit new sequence.\n", 4202 orig_num_stmts); 4203 FOR_EACH_VEC_ELT (split_stores, i, split_store)for (i = 0; (split_stores).iterate ((i), &(split_store));
++(i)) 4204 delete split_store; 4205 return false; 4206 } 4207 } 4208 } 4209 4210 gimple_stmt_iterator last_gsi = gsi_for_stmt (group->last_stmt); 4211 gimple_seq seq = NULLnullptr; 4212 tree last_vdef, new_vuse; 4213 last_vdef = gimple_vdef (group->last_stmt); 4214 new_vuse = gimple_vuse (group->last_stmt); 4215 tree bswap_res = NULL_TREE(tree) nullptr; 4216 4217 /* Clobbers are not removed. */ 4218 if (gimple_clobber_p (group->last_stmt)) 4219 { 4220 new_vuse = make_ssa_name (gimple_vop (cfun(cfun + 0)), group->last_stmt); 4221 gimple_set_vdef (group->last_stmt, new_vuse); 4222 } 4223 4224 if (group->stores[0]->rhs_code == LROTATE_EXPR

←

Assuming field 'rhs_code' is not equal to LROTATE_EXPR

→

←

Taking false branch

→

4225 || group->stores[0]->rhs_code == NOP_EXPR)

←

Assuming field 'rhs_code' is not equal to NOP_EXPR

→

4226 { 4227 tree fndecl = NULL_TREE(tree) nullptr, bswap_type = NULL_TREE(tree) nullptr, load_type; 4228 gimple *ins_stmt = group->stores[0]->ins_stmt; 4229 struct symbolic_number *n = &group->stores[0]->n; 4230 bool bswap = group->stores[0]->rhs_code == LROTATE_EXPR; 4231 4232 switch (n->range) 4233 { 4234 case 16: 4235 load_type = bswap_type = uint16_type_nodeglobal_trees[TI_UINT16_TYPE]; 4236 break; 4237 case 32: 4238 load_type = uint32_type_nodeglobal_trees[TI_UINT32_TYPE]; 4239 if (bswap) 4240 { 4241 fndecl = builtin_decl_explicit (BUILT_IN_BSWAP32); 4242 bswap_type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))((tree_check ((((tree_check2 ((((contains_struct_check ((fndecl
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4242, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4242, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4242, __FUNCTION__, (TREE_LIST)))->list.value); 4243 } 4244 break; 4245 case 64: 4246 load_type = uint64_type_nodeglobal_trees[TI_UINT64_TYPE]; 4247 if (bswap) 4248 { 4249 fndecl = builtin_decl_explicit (BUILT_IN_BSWAP64); 4250 bswap_type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))((tree_check ((((tree_check2 ((((contains_struct_check ((fndecl
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4250, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4250, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4250, __FUNCTION__, (TREE_LIST)))->list.value); 4251 } 4252 break; 4253 default: 4254 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4254, __FUNCTION__)); 4255 } 4256 4257 /* If the loads have each vuse of the corresponding store, 4258 we've checked the aliasing already in try_coalesce_bswap and 4259 we want to sink the need load into seq. So need to use new_vuse 4260 on the load. */ 4261 if (n->base_addr) 4262 { 4263 if (n->vuse == NULLnullptr) 4264 { 4265 n->vuse = new_vuse; 4266 ins_stmt = NULLnullptr; 4267 } 4268 else 4269 /* Update vuse in case it has changed by output_merged_stores. */ 4270 n->vuse = gimple_vuse (ins_stmt); 4271 } 4272 bswap_res = bswap_replace (gsi_start (seq), ins_stmt, fndecl, 4273 bswap_type, load_type, n, bswap, 4274 ~(uint64_t) 0); 4275 gcc_assert (bswap_res)((void)(!(bswap_res) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4275, __FUNCTION__), 0 : 0)); 4276 } 4277 4278 gimple *stmt = NULLnullptr; 4279 auto_vec<gimple *, 32> orig_stmts; 4280 gimple_seq this_seq; 4281 tree addr = force_gimple_operand_1 (unshare_expr (base_addr), &this_seq, 4282 is_gimple_mem_ref_addr, NULL_TREE(tree) nullptr); 4283 gimple_seq_add_seq_without_update (&seq, this_seq); 4284 4285 tree load_addr[2] = { NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr }; 4286 gimple_seq load_seq[2] = { NULLnullptr, NULLnullptr }; 4287 gimple_stmt_iterator load_gsi[2] = { gsi_none (), gsi_none () }; 4288 for (int j = 0; j < 2; ++j)

←

Loop condition is true. Entering loop body

→

←

Loop condition is true. Entering loop body

→

←

Loop condition is false. Execution continues on line 4338

→

4289 { 4290 store_operand_info &op = group->stores[0]->ops[j]; 4291 if (op.base_addr == NULL_TREE(tree) nullptr)

←

Assuming the condition is false

Taking false branch

Assuming the condition is true

Taking true branch

4292 continue;

Execution continues on line 4288

→

4293 4294 store_immediate_info *infol = group->stores.last (); 4295 if (gimple_vuse (op.stmt) == gimple_vuse (infol->ops[j].stmt))

←

Taking true branch

→

4296 { 4297 /* We can't pick the location randomly; while we've verified 4298 all the loads have the same vuse, they can be still in different 4299 basic blocks and we need to pick the one from the last bb: 4300 int x = q[0]; 4301 if (x == N) return; 4302 int y = q[1]; 4303 p[0] = x; 4304 p[1] = y; 4305 otherwise if we put the wider load at the q[0] load, we might 4306 segfault if q[1] is not mapped. */ 4307 basic_block bb = gimple_bb (op.stmt); 4308 gimple *ostmt = op.stmt; 4309 store_immediate_info *info; 4310 FOR_EACH_VEC_ELT (group->stores, i, info)for (i = 0; (group->stores).iterate ((i), &(info)); ++
(i))

←

Loop condition is false. Execution continues on line 4320

→

4311 { 4312 gimple *tstmt = info->ops[j].stmt; 4313 basic_block tbb = gimple_bb (tstmt); 4314 if (dominated_by_p (CDI_DOMINATORS, tbb, bb)) 4315 { 4316 ostmt = tstmt; 4317 bb = tbb; 4318 } 4319 } 4320 load_gsi[j] = gsi_for_stmt (ostmt); 4321 load_addr[j] 4322 = force_gimple_operand_1 (unshare_expr (op.base_addr), 4323 &load_seq[j], is_gimple_mem_ref_addr, 4324 NULL_TREE(tree) nullptr); 4325 } 4326 else if (operand_equal_p (base_addr, op.base_addr, 0)) 4327 load_addr[j] = addr; 4328 else 4329 { 4330 load_addr[j] 4331 = force_gimple_operand_1 (unshare_expr (op.base_addr), 4332 &this_seq, is_gimple_mem_ref_addr, 4333 NULL_TREE(tree) nullptr); 4334 gimple_seq_add_seq_without_update (&seq, this_seq); 4335 } 4336 } 4337 4338 FOR_EACH_VEC_ELT (split_stores, i, split_store)for (i = 0; (split_stores).iterate ((i), &(split_store));
++(i))

←

Loop condition is true. Entering loop body

→

4339 { 4340 const unsigned HOST_WIDE_INTlong try_size = split_store->size; 4341 const unsigned HOST_WIDE_INTlong try_pos = split_store->bytepos; 4342 const unsigned HOST_WIDE_INTlong try_bitpos = try_pos * BITS_PER_UNIT(8); 4343 const unsigned HOST_WIDE_INTlong try_align = split_store->align; 4344 const unsigned HOST_WIDE_INTlong try_offset = try_pos - start_byte_pos; 4345 tree dest, src; 4346 location_t loc; 4347 4348 if (split_store->orig)

←

Assuming field 'orig' is false

→

←

Taking false branch

→

4349 { 4350 /* If there is just a single non-clobber constituent store 4351 which covers the whole area, just reuse the lhs and rhs. */ 4352 gimple *orig_stmt = NULLnullptr; 4353 store_immediate_info *store; 4354 unsigned int j; 4355 FOR_EACH_VEC_ELT (split_store->orig_stores, j, store)for (j = 0; (split_store->orig_stores).iterate ((j), &
(store)); ++(j)) 4356 if (!gimple_clobber_p (store->stmt)) 4357 { 4358 orig_stmt = store->stmt; 4359 break; 4360 } 4361 dest = gimple_assign_lhs (orig_stmt); 4362 src = gimple_assign_rhs1 (orig_stmt); 4363 loc = gimple_location (orig_stmt); 4364 } 4365 else 4366 { 4367 store_immediate_info *info; 4368 unsigned short clique, base; 4369 unsigned int k; 4370 FOR_EACH_VEC_ELT (split_store->orig_stores, k, info)for (k = 0; (split_store->orig_stores).iterate ((k), &
(info)); ++(k))

←

Loop condition is false. Execution continues on line 4373

→

4371 orig_stmts.safe_push (info->stmt); 4372 tree offset_type 4373 = get_alias_type_for_stmts (orig_stmts, false, &clique, &base); 4374 tree dest_type; 4375 loc = get_location_for_stmts (orig_stmts); 4376 orig_stmts.truncate (0); 4377 4378 if (group->string_concatenation)

←

Assuming field 'string_concatenation' is false

→

←

Taking false branch

→

4379 dest_type 4380 = build_array_type_nelts (char_type_nodeinteger_types[itk_char], 4381 try_size / BITS_PER_UNIT(8)); 4382 else 4383 { 4384 dest_type = build_nonstandard_integer_type (try_size, UNSIGNED); 4385 dest_type = build_aligned_type (dest_type, try_align); 4386 } 4387 dest = fold_build2 (MEM_REF, dest_type, addr,fold_build2_loc (((location_t) 0), MEM_REF, dest_type, addr, build_int_cst
(offset_type, try_pos) ) 4388 build_int_cst (offset_type, try_pos))fold_build2_loc (((location_t) 0), MEM_REF, dest_type, addr, build_int_cst
(offset_type, try_pos) ); 4389 if (TREE_CODE (dest)((enum tree_code) (dest)->base.code) == MEM_REF)

←

Assuming field 'code' is not equal to MEM_REF

→

←

Taking false branch

→

4390 { 4391 MR_DEPENDENCE_CLIQUE (dest)((tree_check2 ((dest), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4391, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique) = clique; 4392 MR_DEPENDENCE_BASE (dest)((tree_check2 ((dest), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4392, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.base) = base; 4393 } 4394 4395 tree mask; 4396 if (bswap_res

31.1	'bswap_res' is null

|| group->string_concatenation

31.2	Field 'string_concatenation' is false

)

←

Taking false branch

→

4397 mask = integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]; 4398 else 4399 mask = native_interpret_expr (dest_type, 4400 group->mask + try_offset, 4401 group->buf_size); 4402 4403 tree ops[2]; 4404 for (int j = 0;

←

Loop condition is true. Entering loop body

→

←

Loop condition is false. Execution continues on line 4496

→

4405 j < 1 + (split_store->orig_stores[0]->ops[1].val != NULL_TREE(tree) nullptr);

←

Assuming the condition is false

→

←

Assuming the condition is false

→

4406 ++j) 4407 { 4408 store_operand_info &op = split_store->orig_stores[0]->ops[j]; 4409 if (bswap_res

34.1	'bswap_res' is null

)

←

Taking false branch

→

4410 ops[j] = bswap_res; 4411 else if (group->string_concatenation

35.1	Field 'string_concatenation' is false

)

←

Taking false branch

→

4412 { 4413 ops[j] = build_string (try_size / BITS_PER_UNIT(8), 4414 (const char *) group->val + try_offset); 4415 TREE_TYPE (ops[j])((contains_struct_check ((ops[j]), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4415, __FUNCTION__))->typed.type) = dest_type; 4416 } 4417 else if (op.base_addr)

←

Assuming field 'base_addr' is null

→

←

Taking false branch

→

4418 { 4419 FOR_EACH_VEC_ELT (split_store->orig_stores, k, info)for (k = 0; (split_store->orig_stores).iterate ((k), &
(info)); ++(k)) 4420 orig_stmts.safe_push (info->ops[j].stmt); 4421 4422 offset_type = get_alias_type_for_stmts (orig_stmts, true, 4423 &clique, &base); 4424 location_t load_loc = get_location_for_stmts (orig_stmts); 4425 orig_stmts.truncate (0); 4426 4427 unsigned HOST_WIDE_INTlong load_align = group->load_align[j]; 4428 unsigned HOST_WIDE_INTlong align_bitpos 4429 = known_alignment (try_bitpos 4430 - split_store->orig_stores[0]->bitpos 4431 + op.bitpos); 4432 if (align_bitpos & (load_align - 1)) 4433 load_align = least_bit_hwi (align_bitpos); 4434 4435 tree load_int_type 4436 = build_nonstandard_integer_type (try_size, UNSIGNED); 4437 load_int_type 4438 = build_aligned_type (load_int_type, load_align); 4439 4440 poly_uint64 load_pos 4441 = exact_div (try_bitpos 4442 - split_store->orig_stores[0]->bitpos 4443 + op.bitpos, 4444 BITS_PER_UNIT(8)); 4445 ops[j] = fold_build2 (MEM_REF, load_int_type, load_addr[j],fold_build2_loc (((location_t) 0), MEM_REF, load_int_type, load_addr
[j], build_int_cst (offset_type, load_pos) ) 4446 build_int_cst (offset_type, load_pos))fold_build2_loc (((location_t) 0), MEM_REF, load_int_type, load_addr
[j], build_int_cst (offset_type, load_pos) ); 4447 if (TREE_CODE (ops[j])((enum tree_code) (ops[j])->base.code) == MEM_REF) 4448 { 4449 MR_DEPENDENCE_CLIQUE (ops[j])((tree_check2 ((ops[j]), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4449, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique) = clique; 4450 MR_DEPENDENCE_BASE (ops[j])((tree_check2 ((ops[j]), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4450, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.base) = base; 4451 } 4452 if (!integer_zerop (mask)) 4453 { 4454 /* The load might load some bits (that will be masked 4455 off later on) uninitialized, avoid -W*uninitialized 4456 warnings in that case. */ 4457 suppress_warning (ops[j], OPT_Wuninitialized); 4458 } 4459 4460 stmt = gimple_build_assign (make_ssa_name (dest_type), ops[j]); 4461 gimple_set_location (stmt, load_loc); 4462 if (gsi_bb (load_gsi[j])) 4463 { 4464 gimple_set_vuse (stmt, gimple_vuse (op.stmt)); 4465 gimple_seq_add_stmt_without_update (&load_seq[j], stmt); 4466 } 4467 else 4468 { 4469 gimple_set_vuse (stmt, new_vuse); 4470 gimple_seq_add_stmt_without_update (&seq, stmt); 4471 } 4472 ops[j] = gimple_assign_lhs (stmt); 4473 tree xor_mask; 4474 enum tree_code inv_op 4475 = invert_op (split_store, j, dest_type, xor_mask); 4476 if (inv_op != NOP_EXPR) 4477 { 4478 stmt = gimple_build_assign (make_ssa_name (dest_type), 4479 inv_op, ops[j], xor_mask); 4480 gimple_set_location (stmt, load_loc); 4481 ops[j] = gimple_assign_lhs (stmt); 4482 4483 if (gsi_bb (load_gsi[j])) 4484 gimple_seq_add_stmt_without_update (&load_seq[j], 4485 stmt); 4486 else 4487 gimple_seq_add_stmt_without_update (&seq, stmt); 4488 } 4489 } 4490 else 4491 ops[j] = native_interpret_expr (dest_type, 4492 group->val + try_offset, 4493 group->buf_size); 4494 } 4495 4496 switch (split_store->orig_stores[0]->rhs_code)

←

Control jumps to 'case BIT_XOR_EXPR:' at line 4500

→

4497 { 4498 case BIT_AND_EXPR: 4499 case BIT_IOR_EXPR: 4500 case BIT_XOR_EXPR: 4501 FOR_EACH_VEC_ELT (split_store->orig_stores, k, info)for (k = 0; (split_store->orig_stores).iterate ((k), &
(info)); ++(k))

←

Loop condition is false. Execution continues on line 4506

→

4502 { 4503 tree rhs1 = gimple_assign_rhs1 (info->stmt); 4504 orig_stmts.safe_push (SSA_NAME_DEF_STMT (rhs1)(tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4504, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt); 4505 } 4506 location_t bit_loc; 4507 bit_loc = get_location_for_stmts (orig_stmts); 4508 orig_stmts.truncate (0); 4509 4510 stmt 4511 = gimple_build_assign (make_ssa_name (dest_type),

←

4th function call argument is an uninitialized value

4512 split_store->orig_stores[0]->rhs_code, 4513 ops[0], ops[1]); 4514 gimple_set_location (stmt, bit_loc); 4515 /* If there is just one load and there is a separate 4516 load_seq[0], emit the bitwise op right after it. */ 4517 if (load_addr[1] == NULL_TREE(tree) nullptr && gsi_bb (load_gsi[0])) 4518 gimple_seq_add_stmt_without_update (&load_seq[0], stmt); 4519 /* Otherwise, if at least one load is in seq, we need to 4520 emit the bitwise op right before the store. If there 4521 are two loads and are emitted somewhere else, it would 4522 be better to emit the bitwise op as early as possible; 4523 we don't track where that would be possible right now 4524 though. */ 4525 else 4526 gimple_seq_add_stmt_without_update (&seq, stmt); 4527 src = gimple_assign_lhs (stmt); 4528 tree xor_mask; 4529 enum tree_code inv_op; 4530 inv_op = invert_op (split_store, 2, dest_type, xor_mask); 4531 if (inv_op != NOP_EXPR) 4532 { 4533 stmt = gimple_build_assign (make_ssa_name (dest_type), 4534 inv_op, src, xor_mask); 4535 gimple_set_location (stmt, bit_loc); 4536 if (load_addr[1] == NULL_TREE(tree) nullptr && gsi_bb (load_gsi[0])) 4537 gimple_seq_add_stmt_without_update (&load_seq[0], stmt); 4538 else 4539 gimple_seq_add_stmt_without_update (&seq, stmt); 4540 src = gimple_assign_lhs (stmt); 4541 } 4542 break; 4543 case LROTATE_EXPR: 4544 case NOP_EXPR: 4545 src = ops[0]; 4546 if (!is_gimple_val (src)) 4547 { 4548 stmt = gimple_build_assign (make_ssa_name (TREE_TYPE (src)((contains_struct_check ((src), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4548, __FUNCTION__))->typed.type)), 4549 src); 4550 gimple_seq_add_stmt_without_update (&seq, stmt); 4551 src = gimple_assign_lhs (stmt); 4552 } 4553 if (!useless_type_conversion_p (dest_type, TREE_TYPE (src)((contains_struct_check ((src), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4553, __FUNCTION__))->typed.type))) 4554 { 4555 stmt = gimple_build_assign (make_ssa_name (dest_type), 4556 NOP_EXPR, src); 4557 gimple_seq_add_stmt_without_update (&seq, stmt); 4558 src = gimple_assign_lhs (stmt); 4559 } 4560 inv_op = invert_op (split_store, 2, dest_type, xor_mask); 4561 if (inv_op != NOP_EXPR) 4562 { 4563 stmt = gimple_build_assign (make_ssa_name (dest_type), 4564 inv_op, src, xor_mask); 4565 gimple_set_location (stmt, loc); 4566 gimple_seq_add_stmt_without_update (&seq, stmt); 4567 src = gimple_assign_lhs (stmt); 4568 } 4569 break; 4570 default: 4571 src = ops[0]; 4572 break; 4573 } 4574 4575 /* If bit insertion is required, we use the source as an accumulator 4576 into which the successive bit-field values are manually inserted. 4577 FIXME: perhaps use BIT_INSERT_EXPR instead in some cases? */ 4578 if (group->bit_insertion) 4579 FOR_EACH_VEC_ELT (split_store->orig_stores, k, info)for (k = 0; (split_store->orig_stores).iterate ((k), &
(info)); ++(k)) 4580 if (info->rhs_code == BIT_INSERT_EXPR 4581 && info->bitpos < try_bitpos + try_size 4582 && info->bitpos + info->bitsize > try_bitpos) 4583 { 4584 /* Mask, truncate, convert to final type, shift and ior into 4585 the accumulator. Note that every step can be a no-op. */ 4586 const HOST_WIDE_INTlong start_gap = info->bitpos - try_bitpos; 4587 const HOST_WIDE_INTlong end_gap 4588 = (try_bitpos + try_size) - (info->bitpos + info->bitsize); 4589 tree tem = info->ops[0].val; 4590 if (!INTEGRAL_TYPE_P (TREE_TYPE (tem))(((enum tree_code) (((contains_struct_check ((tem), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4590, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((tem), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4590, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((tem), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4590, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)) 4591 { 4592 const unsigned HOST_WIDE_INTlong size 4593 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (tem))((tree_class_check ((((contains_struct_check ((tem), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4593, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4593, __FUNCTION__))->type_common.size)); 4594 tree integer_type 4595 = build_nonstandard_integer_type (size, UNSIGNED); 4596 tem = gimple_build (&seq, loc, VIEW_CONVERT_EXPR, 4597 integer_type, tem); 4598 } 4599 if (TYPE_PRECISION (TREE_TYPE (tem))((tree_class_check ((((contains_struct_check ((tem), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4599, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4599, __FUNCTION__))->type_common.precision) <= info->bitsize) 4600 { 4601 tree bitfield_type 4602 = build_nonstandard_integer_type (info->bitsize, 4603 UNSIGNED); 4604 tem = gimple_convert (&seq, loc, bitfield_type, tem); 4605 } 4606 else if ((BYTES_BIG_ENDIAN0 ? start_gap : end_gap) > 0) 4607 { 4608 const unsigned HOST_WIDE_INTlong imask 4609 = (HOST_WIDE_INT_1U1UL << info->bitsize) - 1; 4610 tem = gimple_build (&seq, loc, 4611 BIT_AND_EXPR, TREE_TYPE (tem)((contains_struct_check ((tem), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4611, __FUNCTION__))->typed.type), tem, 4612 build_int_cst (TREE_TYPE (tem)((contains_struct_check ((tem), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4612, __FUNCTION__))->typed.type), 4613 imask)); 4614 } 4615 const HOST_WIDE_INTlong shift 4616 = (BYTES_BIG_ENDIAN0 ? end_gap : start_gap); 4617 if (shift < 0) 4618 tem = gimple_build (&seq, loc, 4619 RSHIFT_EXPR, TREE_TYPE (tem)((contains_struct_check ((tem), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4619, __FUNCTION__))->typed.type), tem, 4620 build_int_cst (NULL_TREE(tree) nullptr, -shift)); 4621 tem = gimple_convert (&seq, loc, dest_type, tem); 4622 if (shift > 0) 4623 tem = gimple_build (&seq, loc, 4624 LSHIFT_EXPR, dest_type, tem, 4625 build_int_cst (NULL_TREE(tree) nullptr, shift)); 4626 src = gimple_build (&seq, loc, 4627 BIT_IOR_EXPR, dest_type, tem, src); 4628 } 4629 4630 if (!integer_zerop (mask)) 4631 { 4632 tree tem = make_ssa_name (dest_type); 4633 tree load_src = unshare_expr (dest); 4634 /* The load might load some or all bits uninitialized, 4635 avoid -W*uninitialized warnings in that case. 4636 As optimization, it would be nice if all the bits are 4637 provably uninitialized (no stores at all yet or previous 4638 store a CLOBBER) we'd optimize away the load and replace 4639 it e.g. with 0. */ 4640 suppress_warning (load_src, OPT_Wuninitialized); 4641 stmt = gimple_build_assign (tem, load_src); 4642 gimple_set_location (stmt, loc); 4643 gimple_set_vuse (stmt, new_vuse); 4644 gimple_seq_add_stmt_without_update (&seq, stmt); 4645 4646 /* FIXME: If there is a single chunk of zero bits in mask, 4647 perhaps use BIT_INSERT_EXPR instead? */ 4648 stmt = gimple_build_assign (make_ssa_name (dest_type), 4649 BIT_AND_EXPR, tem, mask); 4650 gimple_set_location (stmt, loc); 4651 gimple_seq_add_stmt_without_update (&seq, stmt); 4652 tem = gimple_assign_lhs (stmt); 4653 4654 if (TREE_CODE (src)((enum tree_code) (src)->base.code) == INTEGER_CST) 4655 src = wide_int_to_tree (dest_type, 4656 wi::bit_and_not (wi::to_wide (src), 4657 wi::to_wide (mask))); 4658 else 4659 { 4660 tree nmask 4661 = wide_int_to_tree (dest_type, 4662 wi::bit_not (wi::to_wide (mask))); 4663 stmt = gimple_build_assign (make_ssa_name (dest_type), 4664 BIT_AND_EXPR, src, nmask); 4665 gimple_set_location (stmt, loc); 4666 gimple_seq_add_stmt_without_update (&seq, stmt); 4667 src = gimple_assign_lhs (stmt); 4668 } 4669 stmt = gimple_build_assign (make_ssa_name (dest_type), 4670 BIT_IOR_EXPR, tem, src); 4671 gimple_set_location (stmt, loc); 4672 gimple_seq_add_stmt_without_update (&seq, stmt); 4673 src = gimple_assign_lhs (stmt); 4674 } 4675 } 4676 4677 stmt = gimple_build_assign (dest, src); 4678 gimple_set_location (stmt, loc); 4679 gimple_set_vuse (stmt, new_vuse); 4680 gimple_seq_add_stmt_without_update (&seq, stmt); 4681 4682 if (group->lp_nr && stmt_could_throw_p (cfun(cfun + 0), stmt)) 4683 add_stmt_to_eh_lp (stmt, group->lp_nr); 4684 4685 tree new_vdef; 4686 if (i < split_stores.length () - 1) 4687 new_vdef = make_ssa_name (gimple_vop (cfun(cfun + 0)), stmt); 4688 else 4689 new_vdef = last_vdef; 4690 4691 gimple_set_vdef (stmt, new_vdef); 4692 SSA_NAME_DEF_STMT (new_vdef)(tree_check ((new_vdef), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4692, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt = stmt; 4693 new_vuse = new_vdef; 4694 } 4695 4696 FOR_EACH_VEC_ELT (split_stores, i, split_store)for (i = 0; (split_stores).iterate ((i), &(split_store));
++(i)) 4697 delete split_store; 4698 4699 gcc_assert (seq)((void)(!(seq) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4699, __FUNCTION__), 0 : 0)); 4700 if (dump_file) 4701 { 4702 fprintf (dump_file, 4703 "New sequence of %u stores to replace old one of %u stores\n", 4704 split_stores.length (), orig_num_stmts); 4705 if (dump_flags & TDF_DETAILS) 4706 print_gimple_seq (dump_file, seq, 0, TDF_VOPS | TDF_MEMSYMS); 4707 } 4708 4709 if (gimple_clobber_p (group->last_stmt)) 4710 update_stmt (group->last_stmt); 4711 4712 if (group->lp_nr > 0) 4713 { 4714 /* We're going to insert a sequence of (potentially) throwing stores 4715 into an active EH region. This means that we're going to create 4716 new basic blocks with EH edges pointing to the post landing pad 4717 and, therefore, to have to update its PHI nodes, if any. For the 4718 virtual PHI node, we're going to use the VDEFs created above, but 4719 for the other nodes, we need to record the original reaching defs. */ 4720 eh_landing_pad lp = get_eh_landing_pad_from_number (group->lp_nr); 4721 basic_block lp_bb = label_to_block (cfun(cfun + 0), lp->post_landing_pad); 4722 basic_block last_bb = gimple_bb (group->last_stmt); 4723 edge last_edge = find_edge (last_bb, lp_bb); 4724 auto_vec<tree, 16> last_defs; 4725 gphi_iterator gpi; 4726 for (gpi = gsi_start_phis (lp_bb); !gsi_end_p (gpi); gsi_next (&gpi)) 4727 { 4728 gphi *phi = gpi.phi (); 4729 tree last_def; 4730 if (virtual_operand_p (gimple_phi_result (phi))) 4731 last_def = NULL_TREE(tree) nullptr; 4732 else 4733 last_def = gimple_phi_arg_def (phi, last_edge->dest_idx); 4734 last_defs.safe_push (last_def); 4735 } 4736 4737 /* Do the insertion. Then, if new basic blocks have been created in the 4738 process, rewind the chain of VDEFs create above to walk the new basic 4739 blocks and update the corresponding arguments of the PHI nodes. */ 4740 update_modified_stmts (seq); 4741 if (gimple_find_sub_bbs (seq, &last_gsi)) 4742 while (last_vdef != gimple_vuse (group->last_stmt)) 4743 { 4744 gimple *stmt = SSA_NAME_DEF_STMT (last_vdef)(tree_check ((last_vdef), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4744, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt; 4745 if (stmt_could_throw_p (cfun(cfun + 0), stmt)) 4746 { 4747 edge new_edge = find_edge (gimple_bb (stmt), lp_bb); 4748 unsigned int i; 4749 for (gpi = gsi_start_phis (lp_bb), i = 0; 4750 !gsi_end_p (gpi); 4751 gsi_next (&gpi), i++) 4752 { 4753 gphi *phi = gpi.phi (); 4754 tree new_def; 4755 if (virtual_operand_p (gimple_phi_result (phi))) 4756 new_def = last_vdef; 4757 else 4758 new_def = last_defs[i]; 4759 add_phi_arg (phi, new_def, new_edge, UNKNOWN_LOCATION((location_t) 0)); 4760 } 4761 } 4762 last_vdef = gimple_vuse (stmt); 4763 } 4764 } 4765 else 4766 gsi_insert_seq_after (&last_gsi, seq, GSI_SAME_STMT); 4767 4768 for (int j = 0; j < 2; ++j) 4769 if (load_seq[j]) 4770 gsi_insert_seq_after (&load_gsi[j], load_seq[j], GSI_SAME_STMT); 4771 4772 return true; 4773} 4774 4775/* Process the merged_store_group objects created in the coalescing phase. 4776 The stores are all against the base object BASE. 4777 Try to output the widened stores and delete the original statements if 4778 successful. Return true iff any changes were made. */ 4779 4780bool 4781imm_store_chain_info::output_merged_stores () 4782{ 4783 unsigned int i; 4784 merged_store_group *merged_store; 4785 bool ret = false; 4786 FOR_EACH_VEC_ELT (m_merged_store_groups, i, merged_store)for (i = 0; (m_merged_store_groups).iterate ((i), &(merged_store
)); ++(i)) 4787 { 4788 if (dbg_cnt (store_merging) 4789 && output_merged_store (merged_store)) 4790 { 4791 unsigned int j; 4792 store_immediate_info *store; 4793 FOR_EACH_VEC_ELT (merged_store->stores, j, store)for (j = 0; (merged_store->stores).iterate ((j), &(store
)); ++(j)) 4794 { 4795 gimple *stmt = store->stmt; 4796 gimple_stmt_iterator gsi = gsi_for_stmt (stmt); 4797 /* Don't remove clobbers, they are still useful even if 4798 everything is overwritten afterwards. */ 4799 if (gimple_clobber_p (stmt)) 4800 continue; 4801 gsi_remove (&gsi, true); 4802 if (store->lp_nr) 4803 remove_stmt_from_eh_lp (stmt); 4804 if (stmt != merged_store->last_stmt) 4805 { 4806 unlink_stmt_vdef (stmt); 4807 release_defs (stmt); 4808 } 4809 } 4810 ret = true; 4811 } 4812 } 4813 if (ret && dump_file) 4814 fprintf (dump_file, "Merging successful!\n"); 4815 4816 return ret; 4817} 4818 4819/* Coalesce the store_immediate_info objects recorded against the base object 4820 BASE in the first phase and output them. 4821 Delete the allocated structures. 4822 Return true if any changes were made. */ 4823 4824bool 4825imm_store_chain_info::terminate_and_process_chain () 4826{ 4827 if (dump_file && (dump_flags & TDF_DETAILS)) 4828 fprintf (dump_file, "Terminating chain with %u stores\n", 4829 m_store_info.length ()); 4830 /* Process store chain. */ 4831 bool ret = false; 4832 if (m_store_info.length () > 1) 4833 { 4834 ret = coalesce_immediate_stores (); 4835 if (ret) 4836 ret = output_merged_stores (); 4837 } 4838 4839 /* Delete all the entries we allocated ourselves. */ 4840 store_immediate_info *info; 4841 unsigned int i; 4842 FOR_EACH_VEC_ELT (m_store_info, i, info)for (i = 0; (m_store_info).iterate ((i), &(info)); ++(i)) 4843 delete info; 4844 4845 merged_store_group *merged_info; 4846 FOR_EACH_VEC_ELT (m_merged_store_groups, i, merged_info)for (i = 0; (m_merged_store_groups).iterate ((i), &(merged_info
)); ++(i)) 4847 delete merged_info; 4848 4849 return ret; 4850} 4851 4852/* Return true iff LHS is a destination potentially interesting for 4853 store merging. In practice these are the codes that get_inner_reference 4854 can process. */ 4855 4856static bool 4857lhs_valid_for_store_merging_p (tree lhs) 4858{ 4859 if (DECL_P (lhs)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (lhs)->base.code))] == tcc_declaration)) 4860 return true; 4861 4862 switch (TREE_CODE (lhs)((enum tree_code) (lhs)->base.code)) 4863 { 4864 case ARRAY_REF: 4865 case ARRAY_RANGE_REF: 4866 case BIT_FIELD_REF: 4867 case COMPONENT_REF: 4868 case MEM_REF: 4869 case VIEW_CONVERT_EXPR: 4870 return true; 4871 default: 4872 return false; 4873 } 4874} 4875 4876/* Return true if the tree RHS is a constant we want to consider 4877 during store merging. In practice accept all codes that 4878 native_encode_expr accepts. */ 4879 4880static bool 4881rhs_valid_for_store_merging_p (tree rhs) 4882{ 4883 unsigned HOST_WIDE_INTlong size; 4884 if (TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) == CONSTRUCTOR 4885 && CONSTRUCTOR_NELTS (rhs)(vec_safe_length (((tree_check ((rhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4885, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))) == 0 4886 && TYPE_SIZE_UNIT (TREE_TYPE (rhs))((tree_class_check ((((contains_struct_check ((rhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4886, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4886, __FUNCTION__))->type_common.size_unit) 4887 && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (rhs))((tree_class_check ((((contains_struct_check ((rhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4887, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4887, __FUNCTION__))->type_common.size_unit))) 4888 return true; 4889 return (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (rhs))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4889, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4889, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4889, __FUNCTION__))->typed.type)) : (((contains_struct_check
((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4889, __FUNCTION__))->typed.type))->type_common.mode)).is_constant (&size) 4890 && native_encode_expr (rhs, NULLnullptr, size) != 0); 4891} 4892 4893/* Adjust *PBITPOS, *PBITREGION_START and *PBITREGION_END by BYTE_OFF bytes 4894 and return true on success or false on failure. */ 4895 4896static bool 4897adjust_bit_pos (poly_offset_int byte_off, 4898 poly_int64 *pbitpos, 4899 poly_uint64 *pbitregion_start, 4900 poly_uint64 *pbitregion_end) 4901{ 4902 poly_offset_int bit_off = byte_off << LOG2_BITS_PER_UNIT3; 4903 bit_off += *pbitpos; 4904 4905 if (known_ge (bit_off, 0)(!maybe_lt (bit_off, 0)) && bit_off.to_shwi (pbitpos)) 4906 { 4907 if (maybe_ne (*pbitregion_end, 0U)) 4908 { 4909 bit_off = byte_off << LOG2_BITS_PER_UNIT3; 4910 bit_off += *pbitregion_start; 4911 if (bit_off.to_uhwi (pbitregion_start)) 4912 { 4913 bit_off = byte_off << LOG2_BITS_PER_UNIT3; 4914 bit_off += *pbitregion_end; 4915 if (!bit_off.to_uhwi (pbitregion_end)) 4916 *pbitregion_end = 0; 4917 } 4918 else 4919 *pbitregion_end = 0; 4920 } 4921 return true; 4922 } 4923 else 4924 return false; 4925} 4926 4927/* If MEM is a memory reference usable for store merging (either as 4928 store destination or for loads), return the non-NULL base_addr 4929 and set *PBITSIZE, *PBITPOS, *PBITREGION_START and *PBITREGION_END. 4930 Otherwise return NULL, *PBITPOS should be still valid even for that 4931 case. */ 4932 4933static tree 4934mem_valid_for_store_merging (tree mem, poly_uint64 *pbitsize, 4935 poly_uint64 *pbitpos, 4936 poly_uint64 *pbitregion_start, 4937 poly_uint64 *pbitregion_end) 4938{ 4939 poly_int64 bitsize, bitpos; 4940 poly_uint64 bitregion_start = 0, bitregion_end = 0; 4941 machine_mode mode; 4942 int unsignedp = 0, reversep = 0, volatilep = 0; 4943 tree offset; 4944 tree base_addr = get_inner_reference (mem, &bitsize, &bitpos, &offset, &mode, 4945 &unsignedp, &reversep, &volatilep); 4946 *pbitsize = bitsize; 4947 if (known_le (bitsize, 0)(!maybe_lt (0, bitsize))) 4948 return NULL_TREE(tree) nullptr; 4949 4950 if (TREE_CODE (mem)((enum tree_code) (mem)->base.code) == COMPONENT_REF 4951 && DECL_BIT_FIELD_TYPE (TREE_OPERAND (mem, 1))((tree_check (((*((const_cast<tree*> (tree_operand_check
((mem), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4951, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4951, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)) 4952 { 4953 get_bit_range (&bitregion_start, &bitregion_end, mem, &bitpos, &offset); 4954 if (maybe_ne (bitregion_end, 0U)) 4955 bitregion_end += 1; 4956 } 4957 4958 if (reversep) 4959 return NULL_TREE(tree) nullptr; 4960 4961 /* We do not want to rewrite TARGET_MEM_REFs. */ 4962 if (TREE_CODE (base_addr)((enum tree_code) (base_addr)->base.code) == TARGET_MEM_REF) 4963 return NULL_TREE(tree) nullptr; 4964 /* In some cases get_inner_reference may return a 4965 MEM_REF [ptr + byteoffset]. For the purposes of this pass 4966 canonicalize the base_addr to MEM_REF [ptr] and take 4967 byteoffset into account in the bitpos. This occurs in 4968 PR 23684 and this way we can catch more chains. */ 4969 else if (TREE_CODE (base_addr)((enum tree_code) (base_addr)->base.code) == MEM_REF) 4970 { 4971 if (!adjust_bit_pos (mem_ref_offset (base_addr), &bitpos, 4972 &bitregion_start, &bitregion_end)) 4973 return NULL_TREE(tree) nullptr; 4974 base_addr = TREE_OPERAND (base_addr, 0)(*((const_cast<tree*> (tree_operand_check ((base_addr),
(0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4974, __FUNCTION__))))); 4975 } 4976 /* get_inner_reference returns the base object, get at its 4977 address now. */ 4978 else 4979 { 4980 if (maybe_lt (bitpos, 0)) 4981 return NULL_TREE(tree) nullptr; 4982 base_addr = build_fold_addr_expr (base_addr)build_fold_addr_expr_loc (((location_t) 0), (base_addr)); 4983 } 4984 4985 if (offset) 4986 { 4987 /* If the access is variable offset then a base decl has to be 4988 address-taken to be able to emit pointer-based stores to it. 4989 ??? We might be able to get away with re-using the original 4990 base up to the first variable part and then wrapping that inside 4991 a BIT_FIELD_REF. */ 4992 tree base = get_base_address (base_addr); 4993 if (!base || (DECL_P (base)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (base)->base.code))] == tcc_declaration) && !TREE_ADDRESSABLE (base)((base)->base.addressable_flag))) 4994 return NULL_TREE(tree) nullptr; 4995 4996 /* Similarly to above for the base, remove constant from the offset. */ 4997 if (TREE_CODE (offset)((enum tree_code) (offset)->base.code) == PLUS_EXPR 4998 && TREE_CODE (TREE_OPERAND (offset, 1))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((offset), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4998, __FUNCTION__))))))->base.code) == INTEGER_CST 4999 && adjust_bit_pos (wi::to_poly_offset (TREE_OPERAND (offset, 1)(*((const_cast<tree*> (tree_operand_check ((offset), (1
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 4999, __FUNCTION__)))))), 5000 &bitpos, &bitregion_start, &bitregion_end)) 5001 offset = TREE_OPERAND (offset, 0)(*((const_cast<tree*> (tree_operand_check ((offset), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5001, __FUNCTION__))))); 5002 5003 base_addr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (base_addr)((contains_struct_check ((base_addr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5003, __FUNCTION__))->typed.type), 5004 base_addr, offset); 5005 } 5006 5007 if (known_eq (bitregion_end, 0U)(!maybe_ne (bitregion_end, 0U))) 5008 { 5009 bitregion_start = round_down_to_byte_boundary (bitpos)force_align_down (bitpos, (8)); 5010 bitregion_end = round_up_to_byte_boundary (bitpos + bitsize)force_align_up (bitpos + bitsize, (8)); 5011 } 5012 5013 *pbitsize = bitsize; 5014 *pbitpos = bitpos; 5015 *pbitregion_start = bitregion_start; 5016 *pbitregion_end = bitregion_end; 5017 return base_addr; 5018} 5019 5020/* Return true if STMT is a load that can be used for store merging. 5021 In that case fill in *OP. BITSIZE, BITPOS, BITREGION_START and 5022 BITREGION_END are properties of the corresponding store. */ 5023 5024static bool 5025handled_load (gimple *stmt, store_operand_info *op, 5026 poly_uint64 bitsize, poly_uint64 bitpos, 5027 poly_uint64 bitregion_start, poly_uint64 bitregion_end) 5028{ 5029 if (!is_gimple_assign (stmt)) 5030 return false; 5031 if (gimple_assign_rhs_code (stmt) == BIT_NOT_EXPR) 5032 { 5033 tree rhs1 = gimple_assign_rhs1 (stmt); 5034 if (TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == SSA_NAME 5035 && handled_load (SSA_NAME_DEF_STMT (rhs1)(tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5035, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt, op, bitsize, bitpos, 5036 bitregion_start, bitregion_end)) 5037 { 5038 /* Don't allow _1 = load; _2 = ~1; _3 = ~_2; which should have 5039 been optimized earlier, but if allowed here, would confuse the 5040 multiple uses counting. */ 5041 if (op->bit_not_p) 5042 return false; 5043 op->bit_not_p = !op->bit_not_p; 5044 return true; 5045 } 5046 return false; 5047 } 5048 if (gimple_vuse (stmt) 5049 && gimple_assign_load_p (stmt) 5050 && !stmt_can_throw_internal (cfun(cfun + 0), stmt) 5051 && !gimple_has_volatile_ops (stmt)) 5052 { 5053 tree mem = gimple_assign_rhs1 (stmt); 5054 op->base_addr 5055 = mem_valid_for_store_merging (mem, &op->bitsize, &op->bitpos, 5056 &op->bitregion_start, 5057 &op->bitregion_end); 5058 if (op->base_addr != NULL_TREE(tree) nullptr 5059 && known_eq (op->bitsize, bitsize)(!maybe_ne (op->bitsize, bitsize)) 5060 && multiple_p (op->bitpos - bitpos, BITS_PER_UNIT(8)) 5061 && known_ge (op->bitpos - op->bitregion_start,(!maybe_lt (op->bitpos - op->bitregion_start, bitpos - bitregion_start
)) 5062 bitpos - bitregion_start)(!maybe_lt (op->bitpos - op->bitregion_start, bitpos - bitregion_start
)) 5063 && known_ge (op->bitregion_end - op->bitpos,(!maybe_lt (op->bitregion_end - op->bitpos, bitregion_end
- bitpos)) 5064 bitregion_end - bitpos)(!maybe_lt (op->bitregion_end - op->bitpos, bitregion_end
- bitpos))) 5065 { 5066 op->stmt = stmt; 5067 op->val = mem; 5068 op->bit_not_p = false; 5069 return true; 5070 } 5071 } 5072 return false; 5073} 5074 5075/* Return the index number of the landing pad for STMT, if any. */ 5076 5077static int 5078lp_nr_for_store (gimple *stmt) 5079{ 5080 if (!cfun(cfun + 0)->can_throw_non_call_exceptions || !cfun(cfun + 0)->eh) 5081 return 0; 5082 5083 if (!stmt_could_throw_p (cfun(cfun + 0), stmt)) 5084 return 0; 5085 5086 return lookup_stmt_eh_lp (stmt); 5087} 5088 5089/* Record the store STMT for store merging optimization if it can be 5090 optimized. Return true if any changes were made. */ 5091 5092bool 5093pass_store_merging::process_store (gimple *stmt) 5094{ 5095 tree lhs = gimple_assign_lhs (stmt); 5096 tree rhs = gimple_assign_rhs1 (stmt); 5097 poly_uint64 bitsize, bitpos = 0; 5098 poly_uint64 bitregion_start = 0, bitregion_end = 0; 5099 tree base_addr 5100 = mem_valid_for_store_merging (lhs, &bitsize, &bitpos, 5101 &bitregion_start, &bitregion_end); 5102 if (known_eq (bitsize, 0U)(!maybe_ne (bitsize, 0U))) 5103 return false; 5104 5105 bool invalid = (base_addr == NULL_TREE(tree) nullptr 5106 || (maybe_gt (bitsize,maybe_lt ((unsigned int) (64*(8)), bitsize) 5107 (unsigned int) MAX_BITSIZE_MODE_ANY_INT)maybe_lt ((unsigned int) (64*(8)), bitsize) 5108 && TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) != INTEGER_CST 5109 && (TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) != CONSTRUCTOR 5110 || CONSTRUCTOR_NELTS (rhs)(vec_safe_length (((tree_check ((rhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5110, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))) != 0))); 5111 enum tree_code rhs_code = ERROR_MARK; 5112 bool bit_not_p = false; 5113 struct symbolic_number n; 5114 gimple *ins_stmt = NULLnullptr; 5115 store_operand_info ops[2]; 5116 if (invalid) 5117 ; 5118 else if (TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) == STRING_CST) 5119 { 5120 rhs_code = STRING_CST; 5121 ops[0].val = rhs; 5122 } 5123 else if (rhs_valid_for_store_merging_p (rhs)) 5124 { 5125 rhs_code = INTEGER_CST; 5126 ops[0].val = rhs; 5127 } 5128 else if (TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) == SSA_NAME) 5129 { 5130 gimple *def_stmt = SSA_NAME_DEF_STMT (rhs)(tree_check ((rhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5130, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt, *def_stmt1, *def_stmt2; 5131 if (!is_gimple_assign (def_stmt)) 5132 invalid = true; 5133 else if (handled_load (def_stmt, &ops[0], bitsize, bitpos, 5134 bitregion_start, bitregion_end)) 5135 rhs_code = MEM_REF; 5136 else if (gimple_assign_rhs_code (def_stmt) == BIT_NOT_EXPR) 5137 { 5138 tree rhs1 = gimple_assign_rhs1 (def_stmt); 5139 if (TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == SSA_NAME 5140 && is_gimple_assign (SSA_NAME_DEF_STMT (rhs1)(tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5140, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt)) 5141 { 5142 bit_not_p = true; 5143 def_stmt = SSA_NAME_DEF_STMT (rhs1)(tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5143, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt; 5144 } 5145 } 5146 5147 if (rhs_code == ERROR_MARK && !invalid) 5148 switch ((rhs_code = gimple_assign_rhs_code (def_stmt))) 5149 { 5150 case BIT_AND_EXPR: 5151 case BIT_IOR_EXPR: 5152 case BIT_XOR_EXPR: 5153 tree rhs1, rhs2; 5154 rhs1 = gimple_assign_rhs1 (def_stmt); 5155 rhs2 = gimple_assign_rhs2 (def_stmt); 5156 invalid = true; 5157 if (TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) != SSA_NAME) 5158 break; 5159 def_stmt1 = SSA_NAME_DEF_STMT (rhs1)(tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5159, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt; 5160 if (!is_gimple_assign (def_stmt1) 5161 || !handled_load (def_stmt1, &ops[0], bitsize, bitpos, 5162 bitregion_start, bitregion_end)) 5163 break; 5164 if (rhs_valid_for_store_merging_p (rhs2)) 5165 ops[1].val = rhs2; 5166 else if (TREE_CODE (rhs2)((enum tree_code) (rhs2)->base.code) != SSA_NAME) 5167 break; 5168 else 5169 { 5170 def_stmt2 = SSA_NAME_DEF_STMT (rhs2)(tree_check ((rhs2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5170, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt; 5171 if (!is_gimple_assign (def_stmt2)) 5172 break; 5173 else if (!handled_load (def_stmt2, &ops[1], bitsize, bitpos, 5174 bitregion_start, bitregion_end)) 5175 break; 5176 } 5177 invalid = false; 5178 break; 5179 default: 5180 invalid = true; 5181 break; 5182 } 5183 5184 unsigned HOST_WIDE_INTlong const_bitsize; 5185 if (bitsize.is_constant (&const_bitsize) 5186 && (const_bitsize % BITS_PER_UNIT(8)) == 0 5187 && const_bitsize <= 64 5188 && multiple_p (bitpos, BITS_PER_UNIT(8))) 5189 { 5190 ins_stmt = find_bswap_or_nop_1 (def_stmt, &n, 12); 5191 if (ins_stmt) 5192 { 5193 uint64_t nn = n.n; 5194 for (unsigned HOST_WIDE_INTlong i = 0; 5195 i < const_bitsize; 5196 i += BITS_PER_UNIT(8), nn >>= BITS_PER_MARKER8) 5197 if ((nn & MARKER_MASK((1 << 8) - 1)) == 0 5198 || (nn & MARKER_MASK((1 << 8) - 1)) == MARKER_BYTE_UNKNOWN((1 << 8) - 1)) 5199 { 5200 ins_stmt = NULLnullptr; 5201 break; 5202 } 5203 if (ins_stmt) 5204 { 5205 if (invalid) 5206 { 5207 rhs_code = LROTATE_EXPR; 5208 ops[0].base_addr = NULL_TREE(tree) nullptr; 5209 ops[1].base_addr = NULL_TREE(tree) nullptr; 5210 } 5211 invalid = false; 5212 } 5213 } 5214 } 5215 5216 if (invalid 5217 && bitsize.is_constant (&const_bitsize) 5218 && ((const_bitsize % BITS_PER_UNIT(8)) != 0 5219 || !multiple_p (bitpos, BITS_PER_UNIT(8))) 5220 && const_bitsize <= MAX_FIXED_MODE_SIZEGET_MODE_BITSIZE (((global_options.x_ix86_isa_flags & (1UL
<< 1)) != 0) ? (scalar_int_mode ((scalar_int_mode::from_int
) E_TImode)) : (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)))) 5221 { 5222 /* Bypass a conversion to the bit-field type. */ 5223 if (!bit_not_p 5224 && is_gimple_assign (def_stmt) 5225 && CONVERT_EXPR_CODE_P (rhs_code)((rhs_code) == NOP_EXPR || (rhs_code) == CONVERT_EXPR)) 5226 { 5227 tree rhs1 = gimple_assign_rhs1 (def_stmt); 5228 if (TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == SSA_NAME 5229 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))(((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5229, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5229, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5229, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)) 5230 rhs = rhs1; 5231 } 5232 rhs_code = BIT_INSERT_EXPR; 5233 bit_not_p = false; 5234 ops[0].val = rhs; 5235 ops[0].base_addr = NULL_TREE(tree) nullptr; 5236 ops[1].base_addr = NULL_TREE(tree) nullptr; 5237 invalid = false; 5238 } 5239 } 5240 else 5241 invalid = true; 5242 5243 unsigned HOST_WIDE_INTlong const_bitsize, const_bitpos; 5244 unsigned HOST_WIDE_INTlong const_bitregion_start, const_bitregion_end; 5245 if (invalid 5246 || !bitsize.is_constant (&const_bitsize) 5247 || !bitpos.is_constant (&const_bitpos) 5248 || !bitregion_start.is_constant (&const_bitregion_start) 5249 || !bitregion_end.is_constant (&const_bitregion_end)) 5250 return terminate_all_aliasing_chains (NULLnullptr, stmt); 5251 5252 if (!ins_stmt) 5253 memset (&n, 0, sizeof (n)); 5254 5255 class imm_store_chain_info **chain_info = NULLnullptr; 5256 bool ret = false; 5257 if (base_addr) 5258 chain_info = m_stores.get (base_addr); 5259 5260 store_immediate_info *info; 5261 if (chain_info) 5262 { 5263 unsigned int ord = (*chain_info)->m_store_info.length (); 5264 info = new store_immediate_info (const_bitsize, const_bitpos, 5265 const_bitregion_start, 5266 const_bitregion_end, 5267 stmt, ord, rhs_code, n, ins_stmt, 5268 bit_not_p, lp_nr_for_store (stmt), 5269 ops[0], ops[1]); 5270 if (dump_file && (dump_flags & TDF_DETAILS)) 5271 { 5272 fprintf (dump_file, "Recording immediate store from stmt:\n"); 5273 print_gimple_stmt (dump_file, stmt, 0); 5274 } 5275 (*chain_info)->m_store_info.safe_push (info); 5276 m_n_stores++; 5277 ret |= terminate_all_aliasing_chains (chain_info, stmt); 5278 /* If we reach the limit of stores to merge in a chain terminate and 5279 process the chain now. */ 5280 if ((*chain_info)->m_store_info.length () 5281 == (unsigned int) param_max_stores_to_mergeglobal_options.x_param_max_stores_to_merge) 5282 { 5283 if (dump_file && (dump_flags & TDF_DETAILS)) 5284 fprintf (dump_file, 5285 "Reached maximum number of statements to merge:\n"); 5286 ret |= terminate_and_process_chain (*chain_info); 5287 } 5288 } 5289 else 5290 { 5291 /* Store aliases any existing chain? */ 5292 ret |= terminate_all_aliasing_chains (NULLnullptr, stmt); 5293 5294 /* Start a new chain. */ 5295 class imm_store_chain_info *new_chain 5296 = new imm_store_chain_info (m_stores_head, base_addr); 5297 info = new store_immediate_info (const_bitsize, const_bitpos, 5298 const_bitregion_start, 5299 const_bitregion_end, 5300 stmt, 0, rhs_code, n, ins_stmt, 5301 bit_not_p, lp_nr_for_store (stmt), 5302 ops[0], ops[1]); 5303 new_chain->m_store_info.safe_push (info); 5304 m_n_stores++; 5305 m_stores.put (base_addr, new_chain); 5306 m_n_chains++; 5307 if (dump_file && (dump_flags & TDF_DETAILS)) 5308 { 5309 fprintf (dump_file, "Starting active chain number %u with statement:\n", 5310 m_n_chains); 5311 print_gimple_stmt (dump_file, stmt, 0); 5312 fprintf (dump_file, "The base object is:\n"); 5313 print_generic_expr (dump_file, base_addr); 5314 fprintf (dump_file, "\n"); 5315 } 5316 } 5317 5318 /* Prune oldest chains so that after adding the chain or store above 5319 we're again within the limits set by the params. */ 5320 if (m_n_chains > (unsigned)param_max_store_chains_to_trackglobal_options.x_param_max_store_chains_to_track 5321 || m_n_stores > (unsigned)param_max_stores_to_trackglobal_options.x_param_max_stores_to_track) 5322 { 5323 if (dump_file && (dump_flags & TDF_DETAILS)) 5324 fprintf (dump_file, "Too many chains (%u > %d) or stores (%u > %d), " 5325 "terminating oldest chain(s).\n", m_n_chains, 5326 param_max_store_chains_to_trackglobal_options.x_param_max_store_chains_to_track, m_n_stores, 5327 param_max_stores_to_trackglobal_options.x_param_max_stores_to_track); 5328 imm_store_chain_info **e = &m_stores_head; 5329 unsigned idx = 0; 5330 unsigned n_stores = 0; 5331 while (*e) 5332 { 5333 if (idx >= (unsigned)param_max_store_chains_to_trackglobal_options.x_param_max_store_chains_to_track 5334 || (n_stores + (*e)->m_store_info.length () 5335 > (unsigned)param_max_stores_to_trackglobal_options.x_param_max_stores_to_track)) 5336 ret |= terminate_and_process_chain (*e); 5337 else 5338 { 5339 n_stores += (*e)->m_store_info.length (); 5340 e = &(*e)->next; 5341 ++idx; 5342 } 5343 } 5344 } 5345 5346 return ret; 5347} 5348 5349/* Return true if STMT is a store valid for store merging. */ 5350 5351static bool 5352store_valid_for_store_merging_p (gimple *stmt) 5353{ 5354 return gimple_assign_single_p (stmt) 5355 && gimple_vdef (stmt) 5356 && lhs_valid_for_store_merging_p (gimple_assign_lhs (stmt)) 5357 && (!gimple_has_volatile_ops (stmt) || gimple_clobber_p (stmt)); 5358} 5359 5360enum basic_block_status { BB_INVALID, BB_VALID, BB_EXTENDED_VALID }; 5361 5362/* Return the status of basic block BB wrt store merging. */ 5363 5364static enum basic_block_status 5365get_status_for_store_merging (basic_block bb) 5366{ 5367 unsigned int num_statements = 0; 5368 unsigned int num_constructors = 0; 5369 gimple_stmt_iterator gsi; 5370 edge e; 5371 gimple *last_stmt = NULLnullptr; 5372 5373 for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 5374 { 5375 gimple *stmt = gsi_stmt (gsi); 5376 5377 if (is_gimple_debug (stmt)) 5378 continue; 5379 5380 last_stmt = stmt; 5381 5382 if (store_valid_for_store_merging_p (stmt) && ++num_statements >= 2) 5383 break; 5384 5385 if (is_gimple_assign (stmt) 5386 && gimple_assign_rhs_code (stmt) == CONSTRUCTOR) 5387 { 5388 tree rhs = gimple_assign_rhs1 (stmt); 5389 if (VECTOR_TYPE_P (TREE_TYPE (rhs))(((enum tree_code) (((contains_struct_check ((rhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5389, __FUNCTION__))->typed.type))->base.code) == VECTOR_TYPE
) 5390 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (rhs)))(((enum tree_code) (((contains_struct_check ((((contains_struct_check
((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5390, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5390, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((((contains_struct_check
((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5390, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5390, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((((contains_struct_check
((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5390, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5390, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
) 5391 && gimple_assign_lhs (stmt) != NULL_TREE(tree) nullptr) 5392 { 5393 HOST_WIDE_INTlong sz 5394 = int_size_in_bytes (TREE_TYPE (rhs)((contains_struct_check ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5394, __FUNCTION__))->typed.type)) * BITS_PER_UNIT(8); 5395 if (sz == 16 || sz == 32 || sz == 64) 5396 { 5397 num_constructors = 1; 5398 break; 5399 } 5400 } 5401 } 5402 } 5403 5404 if (num_statements == 0 && num_constructors == 0) 5405 return BB_INVALID; 5406 5407 if (cfun(cfun + 0)->can_throw_non_call_exceptions && cfun(cfun + 0)->eh 5408 && store_valid_for_store_merging_p (last_stmt) 5409 && (e = find_fallthru_edge (bb->succs)) 5410 && e->dest == bb->next_bb) 5411 return BB_EXTENDED_VALID; 5412 5413 return (num_statements >= 2 || num_constructors) ? BB_VALID : BB_INVALID; 5414} 5415 5416/* Entry point for the pass. Go over each basic block recording chains of 5417 immediate stores. Upon encountering a terminating statement (as defined 5418 by stmt_terminates_chain_p) process the recorded stores and emit the widened 5419 variants. */ 5420 5421unsigned int 5422pass_store_merging::execute (function *fun) 5423{ 5424 basic_block bb; 5425 hash_set<gimple *> orig_stmts; 5426 bool changed = false, open_chains = false; 5427 5428 /* If the function can throw and catch non-call exceptions, we'll be trying 5429 to merge stores across different basic blocks so we need to first unsplit 5430 the EH edges in order to streamline the CFG of the function. */ 5431 if (cfun(cfun + 0)->can_throw_non_call_exceptions && cfun(cfun + 0)->eh) 5432 unsplit_eh_edges (); 5433 5434 calculate_dominance_info (CDI_DOMINATORS); 5435 5436 FOR_EACH_BB_FN (bb, fun)for (bb = (fun)->cfg->x_entry_block_ptr->next_bb; bb
!= (fun)->cfg->x_exit_block_ptr; bb = bb->next_bb) 5437 { 5438 const basic_block_status bb_status = get_status_for_store_merging (bb); 5439 gimple_stmt_iterator gsi; 5440 5441 if (open_chains && (bb_status == BB_INVALID || !single_pred_p (bb))) 5442 { 5443 changed |= terminate_and_process_all_chains (); 5444 open_chains = false; 5445 } 5446 5447 if (bb_status == BB_INVALID) 5448 continue; 5449 5450 if (dump_file && (dump_flags & TDF_DETAILS)) 5451 fprintf (dump_file, "Processing basic block <%d>:\n", bb->index); 5452 5453 for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); ) 5454 { 5455 gimple *stmt = gsi_stmt (gsi); 5456 gsi_next (&gsi); 5457 5458 if (is_gimple_debug (stmt)) 5459 continue; 5460 5461 if (gimple_has_volatile_ops (stmt) && !gimple_clobber_p (stmt)) 5462 { 5463 /* Terminate all chains. */ 5464 if (dump_file && (dump_flags & TDF_DETAILS)) 5465 fprintf (dump_file, "Volatile access terminates " 5466 "all chains\n"); 5467 changed |= terminate_and_process_all_chains (); 5468 open_chains = false; 5469 continue; 5470 } 5471 5472 if (is_gimple_assign (stmt) 5473 && gimple_assign_rhs_code (stmt) == CONSTRUCTOR 5474 && maybe_optimize_vector_constructor (stmt)) 5475 continue; 5476 5477 if (store_valid_for_store_merging_p (stmt)) 5478 changed |= process_store (stmt); 5479 else 5480 changed |= terminate_all_aliasing_chains (NULLnullptr, stmt); 5481 } 5482 5483 if (bb_status == BB_EXTENDED_VALID) 5484 open_chains = true; 5485 else 5486 { 5487 changed |= terminate_and_process_all_chains (); 5488 open_chains = false; 5489 } 5490 } 5491 5492 if (open_chains) 5493 changed |= terminate_and_process_all_chains (); 5494 5495 /* If the function can throw and catch non-call exceptions and something 5496 changed during the pass, then the CFG has (very likely) changed too. */ 5497 if (cfun(cfun + 0)->can_throw_non_call_exceptions && cfun(cfun + 0)->eh && changed) 5498 { 5499 free_dominance_info (CDI_DOMINATORS); 5500 return TODO_cleanup_cfg(1 << 5); 5501 } 5502 5503 return 0; 5504} 5505 5506} // anon namespace 5507 5508/* Construct and return a store merging pass object. */ 5509 5510gimple_opt_pass * 5511make_pass_store_merging (gcc::context *ctxt) 5512{ 5513 return new pass_store_merging (ctxt); 5514} 5515 5516#if CHECKING_P1 5517 5518namespace selftest { 5519 5520/* Selftests for store merging helpers. */ 5521 5522/* Assert that all elements of the byte arrays X and Y, both of length N 5523 are equal. */ 5524 5525static void 5526verify_array_eq (unsigned char *x, unsigned char *y, unsigned int n) 5527{ 5528 for (unsigned int i = 0; i < n; i++) 5529 { 5530 if (x[i] != y[i]) 5531 { 5532 fprintf (stderrstderr, "Arrays do not match. X:\n"); 5533 dump_char_array (stderrstderr, x, n); 5534 fprintf (stderrstderr, "Y:\n"); 5535 dump_char_array (stderrstderr, y, n); 5536 } 5537 ASSERT_EQ (x[i], y[i])do { const char *desc_ = "ASSERT_EQ (" "(x[i])" ", " "(y[i])"
")"; if (((x[i])) == ((y[i]))) ::selftest::pass ((((::selftest
::location ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5537, __FUNCTION__)))), desc_); else ::selftest::fail ((((::
selftest::location ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple-ssa-store-merging.cc"
, 5537, __FUNCTION__)))), desc_); } while (0); 5538 } 5539} 5540 5541/* Test shift_bytes_in_array_left and that it carries bits across between 5542 bytes correctly. */ 5543 5544static void 5545verify_shift_bytes_in_array_left (void) 5546{ 5547 /* byte 1 | byte 0 5548 00011111 | 11100000. */ 5549 unsigned char orig[2] = { 0xe0, 0x1f }; 5550 unsigned char in[2]; 5551 memcpy (in, orig, sizeof orig); 5552 5553 unsigned char expected[2] = { 0x80, 0x7f }; 5554 shift_bytes_in_array_left (in, sizeof (in), 2); 5555 verify_array_eq (in, expected, sizeof (in)); 5556 5557 memcpy (in, orig, sizeof orig); 5558 memcpy (expected, orig, sizeof orig); 5559 /* Check that shifting by zero doesn't change anything. */ 5560 shift_bytes_in_array_left (in, sizeof (in), 0); 5561 verify_array_eq (in, expected, sizeof (in)); 5562 5563} 5564 5565/* Test shift_bytes_in_array_right and that it carries bits across between 5566 bytes correctly. */ 5567 5568static void 5569verify_shift_bytes_in_array_right (void) 5570{ 5571 /* byte 1 | byte 0 5572 00011111 | 11100000. */ 5573 unsigned char orig[2] = { 0x1f, 0xe0}; 5574 unsigned char in[2]; 5575 memcpy (in, orig, sizeof orig); 5576 unsigned char expected[2] = { 0x07, 0xf8}; 5577 shift_bytes_in_array_right (in, sizeof (in), 2); 5578 verify_array_eq (in, expected, sizeof (in)); 5579 5580 memcpy (in, orig, sizeof orig); 5581 memcpy (expected, orig, sizeof orig); 5582 /* Check that shifting by zero doesn't change anything. */ 5583 shift_bytes_in_array_right (in, sizeof (in), 0); 5584 verify_array_eq (in, expected, sizeof (in)); 5585} 5586 5587/* Test clear_bit_region that it clears exactly the bits asked and 5588 nothing more. */ 5589 5590static void 5591verify_clear_bit_region (void) 5592{ 5593 /* Start with all bits set and test clearing various patterns in them. */ 5594 unsigned char orig[3] = { 0xff, 0xff, 0xff}; 5595 unsigned char in[3]; 5596 unsigned char expected[3]; 5597 memcpy (in, orig, sizeof in); 5598 5599 /* Check zeroing out all the bits. */ 5600 clear_bit_region (in, 0, 3 * BITS_PER_UNIT(8)); 5601 expected[0] = expected[1] = expected[2] = 0; 5602 verify_array_eq (in, expected, sizeof in); 5603 5604 memcpy (in, orig, sizeof in); 5605 /* Leave the first and last bits intact. */ 5606 clear_bit_region (in, 1, 3 * BITS_PER_UNIT(8) - 2); 5607 expected[0] = 0x1; 5608 expected[1] = 0; 5609 expected[2] = 0x80; 5610 verify_array_eq (in, expected, sizeof in); 5611} 5612 5613/* Test clear_bit_region_be that it clears exactly the bits asked and 5614 nothing more. */ 5615