/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc

Bug Summary

File:	build/gcc/builtins.cc
Warning:	line 4417, column 34 The result of the left shift is undefined because the right operand is negative
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 builtins.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-hNwszr.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc
1/* Expand builtin functions.
 Copyright (C) 1988-2023 Free Software Foundation, Inc.

4This file is part of GCC.

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

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

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

20/* Legacy warning!  Please add no further builtin simplifications here
 (apart from pure constant folding) - builtin simplifications should go
 to match.pd or gimple-fold.cc instead.  */

24#include "config.h"
25#include "system.h"
26#include "coretypes.h"
27#include "backend.h"
28#include "target.h"
29#include "rtl.h"
30#include "tree.h"
31#include "memmodel.h"
32#include "gimple.h"
33#include "predict.h"
34#include "tm_p.h"
35#include "stringpool.h"
36#include "tree-vrp.h"
37#include "tree-ssanames.h"
38#include "expmed.h"
39#include "optabs.h"
40#include "emit-rtl.h"
41#include "recog.h"
42#include "diagnostic-core.h"
43#include "alias.h"
44#include "fold-const.h"
45#include "fold-const-call.h"
46#include "gimple-ssa-warn-access.h"
47#include "stor-layout.h"
48#include "calls.h"
49#include "varasm.h"
50#include "tree-object-size.h"
51#include "tree-ssa-strlen.h"
52#include "realmpfr.h"
53#include "cfgrtl.h"
54#include "except.h"
55#include "dojump.h"
56#include "explow.h"
57#include "stmt.h"
58#include "expr.h"
59#include "libfuncs.h"
60#include "output.h"
61#include "typeclass.h"
62#include "langhooks.h"
63#include "value-prof.h"
64#include "builtins.h"
65#include "stringpool.h"
66#include "attribs.h"
67#include "asan.h"
68#include "internal-fn.h"
69#include "case-cfn-macros.h"
70#include "gimple-iterator.h"
71#include "gimple-fold.h"
72#include "intl.h"
73#include "file-prefix-map.h" /* remap_macro_filename()  */
74#include "gomp-constants.h"
75#include "omp-general.h"
76#include "tree-dfa.h"
77#include "gimple-ssa.h"
78#include "tree-ssa-live.h"
79#include "tree-outof-ssa.h"
80#include "attr-fnspec.h"
81#include "demangle.h"
82#include "gimple-range.h"
83#include "pointer-query.h"

85struct target_builtins default_target_builtins;
86#if SWITCHABLE_TARGET1
87struct target_builtins *this_target_builtins = &default_target_builtins;
88#endif

90/* Define the names of the builtin function types and codes.  */
91const char *const built_in_class_names[BUILT_IN_LAST(BUILT_IN_NORMAL + 1)]
= {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};

94#define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
95const char * built_in_names[(int) END_BUILTINS] =
96{
97#include "builtins.def"
98};

100/* Setup an array of builtin_info_type, make sure each element decl is
 initialized to NULL_TREE.  */
102builtin_info_type builtin_info[(int)END_BUILTINS];

104/* Non-zero if __builtin_constant_p should be folded right away.  */
105bool force_folding_builtin_constant_p;

107static int target_char_cast (tree, char *);
108static int apply_args_size (void);
109static int apply_result_size (void);
110static rtx result_vector (int, rtx);
111static void expand_builtin_prefetch (tree);
112static rtx expand_builtin_apply_args (void);
113static rtx expand_builtin_apply_args_1 (void);
114static rtx expand_builtin_apply (rtx, rtx, rtx);
115static void expand_builtin_return (rtx);
116static enum type_class type_to_class (tree);
117static rtx expand_builtin_classify_type (tree);
118static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
119static rtx expand_builtin_mathfn_ternary (tree, rtx, rtx);
120static rtx expand_builtin_interclass_mathfn (tree, rtx);
121static rtx expand_builtin_sincos (tree);
122static rtx expand_builtin_fegetround (tree, rtx, machine_mode);
123static rtx expand_builtin_feclear_feraise_except (tree, rtx, machine_mode,
				  optab);
125static rtx expand_builtin_cexpi (tree, rtx);
126static rtx expand_builtin_issignaling (tree, rtx);
127static rtx expand_builtin_int_roundingfn (tree, rtx);
128static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
129static rtx expand_builtin_next_arg (void);
130static rtx expand_builtin_va_start (tree);
131static rtx expand_builtin_va_end (tree);
132static rtx expand_builtin_va_copy (tree);
133static rtx inline_expand_builtin_bytecmp (tree, rtx);
134static rtx expand_builtin_strcmp (tree, rtx);
135static rtx expand_builtin_strncmp (tree, rtx, machine_mode);
136static rtx expand_builtin_memcpy (tree, rtx);
137static rtx expand_builtin_memory_copy_args (tree dest, tree src, tree len,
			    rtx target, tree exp,
			    memop_ret retmode,
			    bool might_overlap);
141static rtx expand_builtin_memmove (tree, rtx);
142static rtx expand_builtin_mempcpy (tree, rtx);
143static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx, tree, memop_ret);
144static rtx expand_builtin_strcpy (tree, rtx);
145static rtx expand_builtin_strcpy_args (tree, tree, tree, rtx);
146static rtx expand_builtin_stpcpy (tree, rtx, machine_mode);
147static rtx expand_builtin_strncpy (tree, rtx);
148static rtx expand_builtin_memset_args (tree, tree, tree, rtx, machine_mode, tree);
149static rtx expand_builtin_bzero (tree);
150static rtx expand_builtin_strlen (tree, rtx, machine_mode);
151static rtx expand_builtin_strnlen (tree, rtx, machine_mode);
152static rtx expand_builtin_alloca (tree);
153static rtx expand_builtin_unop (machine_mode, tree, rtx, rtx, optab);
154static rtx expand_builtin_frame_address (tree, tree);
155static tree stabilize_va_list_loc (location_t, tree, int);
156static rtx expand_builtin_expect (tree, rtx);
157static rtx expand_builtin_expect_with_probability (tree, rtx);
158static tree fold_builtin_constant_p (tree);
159static tree fold_builtin_classify_type (tree);
160static tree fold_builtin_strlen (location_t, tree, tree, tree);
161static tree fold_builtin_inf (location_t, tree, int);
162static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
163static bool validate_arg (const_tree, enum tree_code code);
164static rtx expand_builtin_fabs (tree, rtx, rtx);
165static rtx expand_builtin_signbit (tree, rtx);
166static tree fold_builtin_memcmp (location_t, tree, tree, tree);
167static tree fold_builtin_isascii (location_t, tree);
168static tree fold_builtin_toascii (location_t, tree);
169static tree fold_builtin_isdigit (location_t, tree);
170static tree fold_builtin_fabs (location_t, tree, tree);
171static tree fold_builtin_abs (location_t, tree, tree);
172static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
			enum tree_code);
174static tree fold_builtin_varargs (location_t, tree, tree*, int);

176static tree fold_builtin_strpbrk (location_t, tree, tree, tree, tree);
177static tree fold_builtin_strspn (location_t, tree, tree, tree);
178static tree fold_builtin_strcspn (location_t, tree, tree, tree);

180static rtx expand_builtin_object_size (tree);
181static rtx expand_builtin_memory_chk (tree, rtx, machine_mode,
		      enum built_in_function);
183static void maybe_emit_chk_warning (tree, enum built_in_function);
184static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
185static tree fold_builtin_object_size (tree, tree, enum built_in_function);

187unsigned HOST_WIDE_INTlong target_newline;
188unsigned HOST_WIDE_INTlong target_percent;
189static unsigned HOST_WIDE_INTlong target_c;
190static unsigned HOST_WIDE_INTlong target_s;
191char target_percent_c[3];
192char target_percent_s[3];
193char target_percent_s_newline[4];
194static tree do_mpfr_remquo (tree, tree, tree);
195static tree do_mpfr_lgamma_r (tree, tree, tree);
196static void expand_builtin_sync_synchronize (void);

198/* Return true if NAME starts with __builtin_ or __sync_.  */

200static bool
201is_builtin_name (const char *name)
202{
return (startswith (name, "__builtin_")
 || startswith (name, "__sync_")
 || startswith (name, "__atomic_"));
206}

208/* Return true if NODE should be considered for inline expansion regardless
 of the optimization level.  This means whenever a function is invoked with
 its "internal" name, which normally contains the prefix "__builtin".  */

212bool
213called_as_built_in (tree node)
214{
/* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
   we want the name used to call the function, not the name it
   will have. */
const char *name = IDENTIFIER_POINTER (DECL_NAME (node))((const char *) (tree_check ((((contains_struct_check ((node)
, (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 218, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 218, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
);
return is_builtin_name (name);
220}

222/* Compute values M and N such that M divides (address of EXP - N) and such
 that N < M.  If these numbers can be determined, store M in alignp and N in
 *BITPOSP and return true.  Otherwise return false and store BITS_PER_UNIT to
 *alignp and any bit-offset to *bitposp.

 Note that the address (and thus the alignment) computed here is based
 on the address to which a symbol resolves, whereas DECL_ALIGN is based
 on the address at which an object is actually located.  These two
 addresses are not always the same.  For example, on ARM targets,
 the address &foo of a Thumb function foo() has the lowest bit set,
 whereas foo() itself starts on an even address.

 If ADDR_P is true we are taking the address of the memory reference EXP
 and thus cannot rely on the access taking place.  */

237bool
238get_object_alignment_2 (tree exp, unsigned int *alignp,
	unsigned HOST_WIDE_INTlong *bitposp, bool addr_p)
240{
poly_int64 bitsize, bitpos;
tree offset;
machine_mode mode;
int unsignedp, reversep, volatilep;
unsigned int align = BITS_PER_UNIT(8);
bool known_alignment = false;

/* Get the innermost object and the constant (bitpos) and possibly
   variable (offset) offset of the access.  */
exp = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode,
	     &unsignedp, &reversep, &volatilep);

/* Extract alignment information from the innermost object and
   possibly adjust bitpos and offset.  */
if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == FUNCTION_DECL)
  {
    /* Function addresses can encode extra information besides their
alignment.  However, if TARGET_PTRMEMFUNC_VBIT_LOCATION
allows the low bit to be used as a virtual bit, we know
that the address itself must be at least 2-byte aligned.  */
    if (TARGET_PTRMEMFUNC_VBIT_LOCATIONptrmemfunc_vbit_in_pfn == ptrmemfunc_vbit_in_pfn)
align = 2 * BITS_PER_UNIT(8);
  }
else if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == LABEL_DECL)
  ;
else if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == CONST_DECL)
  {
    /* The alignment of a CONST_DECL is determined by its initializer.  */
    exp = DECL_INITIAL (exp)((contains_struct_check ((exp), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 269, __FUNCTION__))->decl_common.initial);
    align = TYPE_ALIGN (TREE_TYPE (exp))(((tree_class_check ((((contains_struct_check ((exp), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 270, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 270, __FUNCTION__))->type_common.align) ? ((unsigned)1) <<
 (((tree_class_check ((((contains_struct_check ((exp), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 270, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 270, __FUNCTION__))->type_common.align) - 1) : 0);
    if (CONSTANT_CLASS_P (exp)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (exp)->base.code))] == tcc_constant))
align = targetm.constant_alignment (exp, align);

    known_alignment = true;
  }
else if (DECL_P (exp)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (exp)->base.code))] == tcc_declaration))
  {
    align = DECL_ALIGN (exp)(((contains_struct_check ((exp), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 278, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
 (((contains_struct_check ((exp), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 278, __FUNCTION__))->decl_common.align) - 1) : 0);
    known_alignment = true;
  }
else if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == INDIRECT_REF
  || TREE_CODE (exp)((enum tree_code) (exp)->base.code) == MEM_REF
  || TREE_CODE (exp)((enum tree_code) (exp)->base.code) == TARGET_MEM_REF)
  {
    tree addr = TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 285, __FUNCTION__)))));
    unsigned ptr_align;
    unsigned HOST_WIDE_INTlong ptr_bitpos;
    unsigned HOST_WIDE_INTlong ptr_bitmask = ~0;

    /* If the address is explicitely aligned, handle that.  */
    if (TREE_CODE (addr)((enum tree_code) (addr)->base.code) == BIT_AND_EXPR
 && TREE_CODE (TREE_OPERAND (addr, 1))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((addr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 292, __FUNCTION__))))))->base.code) == INTEGER_CST)
{
 ptr_bitmask = TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))((unsigned long) (*tree_int_cst_elt_check (((*((const_cast<
tree*> (tree_operand_check ((addr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 294, __FUNCTION__)))))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 294, __FUNCTION__)));
 ptr_bitmask *= BITS_PER_UNIT(8);
 align = least_bit_hwi (ptr_bitmask);
 addr = TREE_OPERAND (addr, 0)(*((const_cast<tree*> (tree_operand_check ((addr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 297, __FUNCTION__)))));
}

    known_alignment
= get_pointer_alignment_1 (addr, &ptr_align, &ptr_bitpos);
    align = MAX (ptr_align, align)((ptr_align) > (align) ? (ptr_align) : (align));

    /* Re-apply explicit alignment to the bitpos.  */
    ptr_bitpos &= ptr_bitmask;

    /* The alignment of the pointer operand in a TARGET_MEM_REF
has to take the variable offset parts into account.  */
    if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == TARGET_MEM_REF)
{
 if (TMR_INDEX (exp)((*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 311, __FUNCTION__, (TARGET_MEM_REF)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 311, __FUNCTION__)))))))
   {
     unsigned HOST_WIDE_INTlong step = 1;
     if (TMR_STEP (exp)((*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 314, __FUNCTION__, (TARGET_MEM_REF)))), (3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 314, __FUNCTION__)))))))
step = TREE_INT_CST_LOW (TMR_STEP (exp))((unsigned long) (*tree_int_cst_elt_check ((((*((const_cast<
tree*> (tree_operand_check (((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 315, __FUNCTION__, (TARGET_MEM_REF)))), (3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 315, __FUNCTION__))))))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 315, __FUNCTION__)));
     align = MIN (align, least_bit_hwi (step) * BITS_PER_UNIT)((align) < (least_bit_hwi (step) * (8)) ? (align) : (least_bit_hwi
 (step) * (8)));
   }
 if (TMR_INDEX2 (exp)((*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 318, __FUNCTION__, (TARGET_MEM_REF)))), (4), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 318, __FUNCTION__)))))))
   align = BITS_PER_UNIT(8);
 known_alignment = false;
}

    /* When EXP is an actual memory reference then we can use
TYPE_ALIGN of a pointer indirection to derive alignment.
Do so only if get_pointer_alignment_1 did not reveal absolute
alignment knowledge and if using that alignment would
improve the situation.  */
    unsigned int talign;
    if (!addr_p && !known_alignment
 && (talign = min_align_of_type (TREE_TYPE (exp)((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 330, __FUNCTION__))->typed.type)) * BITS_PER_UNIT(8))
 && talign > align)
align = talign;
    else
{
 /* Else adjust bitpos accordingly.  */
 bitpos += ptr_bitpos;
 if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == MEM_REF
     || TREE_CODE (exp)((enum tree_code) (exp)->base.code) == TARGET_MEM_REF)
   bitpos += mem_ref_offset (exp).force_shwi () * BITS_PER_UNIT(8);
}
  }
else if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == STRING_CST)
  {
    /* STRING_CST are the only constant objects we allow to be not
       wrapped inside a CONST_DECL.  */
    align = TYPE_ALIGN (TREE_TYPE (exp))(((tree_class_check ((((contains_struct_check ((exp), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 346, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 346, __FUNCTION__))->type_common.align) ? ((unsigned)1) <<
 (((tree_class_check ((((contains_struct_check ((exp), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 346, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 346, __FUNCTION__))->type_common.align) - 1) : 0);
    if (CONSTANT_CLASS_P (exp)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (exp)->base.code))] == tcc_constant))
align = targetm.constant_alignment (exp, align);

    known_alignment = true;
  }

/* If there is a non-constant offset part extract the maximum
   alignment that can prevail.  */
if (offset)
  {
    unsigned int trailing_zeros = tree_ctz (offset);
    if (trailing_zeros < HOST_BITS_PER_INT(8 * 4))
{
 unsigned int inner = (1U << trailing_zeros) * BITS_PER_UNIT(8);
 if (inner)
   align = MIN (align, inner)((align) < (inner) ? (align) : (inner));
}
  }

/* Account for the alignment of runtime coefficients, so that the constant
   bitpos is guaranteed to be accurate.  */
unsigned int alt_align = ::known_alignment (bitpos - bitpos.coeffs[0]);
if (alt_align != 0 && alt_align < align)
  {
    align = alt_align;
    known_alignment = false;
  }

*alignp = align;
*bitposp = bitpos.coeffs[0] & (align - 1);
return known_alignment;
378}

380/* For a memory reference expression EXP compute values M and N such that M
 divides (&EXP - N) and such that N < M.  If these numbers can be determined,
 store M in alignp and N in *BITPOSP and return true.  Otherwise return false
 and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp.  */

385bool
386get_object_alignment_1 (tree exp, unsigned int *alignp,
	unsigned HOST_WIDE_INTlong *bitposp)
388{
/* Strip a WITH_SIZE_EXPR, get_inner_reference doesn't know how to deal
   with it.  */
if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == WITH_SIZE_EXPR)
  exp = TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 392, __FUNCTION__)))));
return get_object_alignment_2 (exp, alignp, bitposp, false);
394}

396/* Return the alignment in bits of EXP, an object.  */

398unsigned int
399get_object_alignment (tree exp)
400{
unsigned HOST_WIDE_INTlong bitpos = 0;
unsigned int align;

get_object_alignment_1 (exp, &align, &bitpos);

/* align and bitpos now specify known low bits of the pointer.
   ptr & (align - 1) == bitpos.  */

if (bitpos != 0)
  align = least_bit_hwi (bitpos);
return align;
412}

414/* For a pointer valued expression EXP compute values M and N such that M
 divides (EXP - N) and such that N < M.  If these numbers can be determined,
 store M in alignp and N in *BITPOSP and return true.  Return false if
 the results are just a conservative approximation.

 If EXP is not a pointer, false is returned too.  */

421bool
422get_pointer_alignment_1 (tree exp, unsigned int *alignp,
	 unsigned HOST_WIDE_INTlong *bitposp)
424{
STRIP_NOPS (exp)(exp) = tree_strip_nop_conversions ((const_cast<union tree_node
 *> (((exp)))));

if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == ADDR_EXPR)
  return get_object_alignment_2 (TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 428, __FUNCTION__))))),
		   alignp, bitposp, true);
else if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == POINTER_PLUS_EXPR)
  {
    unsigned int align;
    unsigned HOST_WIDE_INTlong bitpos;
    bool res = get_pointer_alignment_1 (TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 434, __FUNCTION__))))),
			  &align, &bitpos);
    if (TREE_CODE (TREE_OPERAND (exp, 1))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((exp), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 436, __FUNCTION__))))))->base.code) == INTEGER_CST)
bitpos += TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))((unsigned long) (*tree_int_cst_elt_check (((*((const_cast<
tree*> (tree_operand_check ((exp), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 437, __FUNCTION__)))))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 437, __FUNCTION__))) * BITS_PER_UNIT(8);
    else
{
 unsigned int trailing_zeros = tree_ctz (TREE_OPERAND (exp, 1)(*((const_cast<tree*> (tree_operand_check ((exp), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 440, __FUNCTION__))))));
 if (trailing_zeros < HOST_BITS_PER_INT(8 * 4))
   {
     unsigned int inner = (1U << trailing_zeros) * BITS_PER_UNIT(8);
     if (inner)
align = MIN (align, inner)((align) < (inner) ? (align) : (inner));
   }
}
    *alignp = align;
    *bitposp = bitpos & (align - 1);
    return res;
  }
else if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == SSA_NAME
  && POINTER_TYPE_P (TREE_TYPE (exp))(((enum tree_code) (((contains_struct_check ((exp), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 453, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((exp), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 453, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
  {
    unsigned int ptr_align, ptr_misalign;
    struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp)(tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 456, __FUNCTION__, (SSA_NAME)))->ssa_name.info.ptr_info;

    if (pi && get_ptr_info_alignment (pi, &ptr_align, &ptr_misalign))
{
 *bitposp = ptr_misalign * BITS_PER_UNIT(8);
 *alignp = ptr_align * BITS_PER_UNIT(8);
 /* Make sure to return a sensible alignment when the multiplication
    by BITS_PER_UNIT overflowed.  */
 if (*alignp == 0)
   *alignp = 1u << (HOST_BITS_PER_INT(8 * 4) - 1);
 /* We cannot really tell whether this result is an approximation.  */
 return false;
}
    else
{
 *bitposp = 0;
 *alignp = BITS_PER_UNIT(8);
 return false;
}
  }
else if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == INTEGER_CST)
  {
    *alignp = BIGGEST_ALIGNMENT(((global_options.x_target_flags & (1U << 12)) != 0
) ? 32 : (((global_options.x_ix86_isa_flags & (1UL <<
 15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags & (
1UL << 8)) != 0) ? 256 : 128)));
    *bitposp = ((TREE_INT_CST_LOW (exp)((unsigned long) (*tree_int_cst_elt_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 479, __FUNCTION__))) * BITS_PER_UNIT(8))
  & (BIGGEST_ALIGNMENT(((global_options.x_target_flags & (1U << 12)) != 0
) ? 32 : (((global_options.x_ix86_isa_flags & (1UL <<
 15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags & (
1UL << 8)) != 0) ? 256 : 128))) - 1));
    return true;
  }

*bitposp = 0;
*alignp = BITS_PER_UNIT(8);
return false;
487}

489/* Return the alignment in bits of EXP, a pointer valued expression.
 The alignment returned is, by default, the alignment of the thing that
 EXP points to.  If it is not a POINTER_TYPE, 0 is returned.

 Otherwise, look at the expression to see if we can do better, i.e., if the
 expression is actually pointing at an object whose alignment is tighter.  */

496unsigned int
497get_pointer_alignment (tree exp)
498{
unsigned HOST_WIDE_INTlong bitpos = 0;
unsigned int align;

get_pointer_alignment_1 (exp, &align, &bitpos);

/* align and bitpos now specify known low bits of the pointer.
   ptr & (align - 1) == bitpos.  */

if (bitpos != 0)
  align = least_bit_hwi (bitpos);

return align;
511}

513/* Return the number of leading non-zero elements in the sequence
 [ PTR, PTR + MAXELTS ) where each element's size is ELTSIZE bytes.
 ELTSIZE must be a power of 2 less than 8.  Used by c_strlen.  */

517unsigned
518string_length (const void *ptr, unsigned eltsize, unsigned maxelts)
519{
gcc_checking_assert (eltsize == 1 || eltsize == 2 || eltsize == 4)((void)(!(eltsize == 1 || eltsize == 2 || eltsize == 4) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 520, __FUNCTION__), 0 : 0));

unsigned n;

if (eltsize == 1)
  {
    /* Optimize the common case of plain char.  */
    for (n = 0; n < maxelts; n++)
{
 const char *elt = (const char*) ptr + n;
 if (!*elt)
   break;
}
  }
else
  {
    for (n = 0; n < maxelts; n++)
{
 const char *elt = (const char*) ptr + n * eltsize;
 if (!memcmp (elt, "\0\0\0\0", eltsize))
   break;
}
  }
return n;
544}

546/* Compute the length of a null-terminated character string or wide
 character string handling character sizes of 1, 2, and 4 bytes.
 TREE_STRING_LENGTH is not the right way because it evaluates to
 the size of the character array in bytes (as opposed to characters)
 and because it can contain a zero byte in the middle.

 ONLY_VALUE should be nonzero if the result is not going to be emitted
 into the instruction stream and zero if it is going to be expanded.
 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
 is returned, otherwise NULL, since
 len = c_strlen (ARG, 1); if (len) expand_expr (len, ...); would not
 evaluate the side-effects.

 If ONLY_VALUE is two then we do not emit warnings about out-of-bound
 accesses.  Note that this implies the result is not going to be emitted
 into the instruction stream.

 Additional information about the string accessed may be recorded
 in DATA.  For example, if ARG references an unterminated string,
 then the declaration will be stored in the DECL field.   If the
 length of the unterminated string can be determined, it'll be
 stored in the LEN field.  Note this length could well be different
 than what a C strlen call would return.

 ELTSIZE is 1 for normal single byte character strings, and 2 or
 4 for wide characer strings.  ELTSIZE is by default 1.

 The value returned is of type `ssizetype'.  */

575tree
576c_strlen (tree arg, int only_value, c_strlen_data *data, unsigned eltsize)
577{
/* If we were not passed a DATA pointer, then get one to a local
   structure.  That avoids having to check DATA for NULL before
   each time we want to use it.  */
c_strlen_data local_strlen_data = { };
if (!data)
  data = &local_strlen_data;

gcc_checking_assert (eltsize == 1 || eltsize == 2 || eltsize == 4)((void)(!(eltsize == 1 || eltsize == 2 || eltsize == 4) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 585, __FUNCTION__), 0 : 0));

tree src = STRIP_NOPS (arg)(arg) = tree_strip_nop_conversions ((const_cast<union tree_node
 *> (((arg)))));
if (TREE_CODE (src)((enum tree_code) (src)->base.code) == COND_EXPR
    && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))((non_type_check (((*((const_cast<tree*> (tree_operand_check
 ((src), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 589, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 589, __FUNCTION__))->base.side_effects_flag)))
  {
    tree len1, len2;

    len1 = c_strlen (TREE_OPERAND (src, 1)(*((const_cast<tree*> (tree_operand_check ((src), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 593, __FUNCTION__))))), only_value, data, eltsize);
    len2 = c_strlen (TREE_OPERAND (src, 2)(*((const_cast<tree*> (tree_operand_check ((src), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 594, __FUNCTION__))))), only_value, data, eltsize);
    if (tree_int_cst_equal (len1, len2))
return len1;
  }

if (TREE_CODE (src)((enum tree_code) (src)->base.code) == COMPOUND_EXPR
    && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))((non_type_check (((*((const_cast<tree*> (tree_operand_check
 ((src), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 600, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 600, __FUNCTION__))->base.side_effects_flag)))
  return c_strlen (TREE_OPERAND (src, 1)(*((const_cast<tree*> (tree_operand_check ((src), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 601, __FUNCTION__))))), only_value, data, eltsize);

location_t loc = EXPR_LOC_OR_LOC (src, input_location)((((IS_ADHOC_LOC (((((src)) && ((tree_code_type_tmpl <
0>::tree_code_type[(int) (((enum tree_code) ((src))->base
.code))]) >= tcc_reference && (tree_code_type_tmpl
 <0>::tree_code_type[(int) (((enum tree_code) ((src))->
base.code))]) <= tcc_expression)) ? (src)->exp.locus : (
(location_t) 0)))) ? get_location_from_adhoc_loc (line_table,
 ((((src)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((src))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((src))->base.code))]) <= tcc_expression
)) ? (src)->exp.locus : ((location_t) 0))) : (((((src)) &&
 ((tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
 tree_code) ((src))->base.code))]) >= tcc_reference &&
 (tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
 tree_code) ((src))->base.code))]) <= tcc_expression)) ?
 (src)->exp.locus : ((location_t) 0)))) != ((location_t) 0
)) ? (src)->exp.locus : (input_location));

/* Offset from the beginning of the string in bytes.  */
tree byteoff;
tree memsize;
tree decl;
src = string_constant (src, &byteoff, &memsize, &decl);
if (src == 0)
  return NULL_TREE(tree) __null;

/* Determine the size of the string element.  */
if (eltsize != tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (src)))((tree_class_check ((((contains_struct_check ((((contains_struct_check
 ((src), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 614, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 614, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 614, __FUNCTION__))->type_common.size_unit)))
  return NULL_TREE(tree) __null;

/* Set MAXELTS to ARRAY_SIZE (SRC) - 1, the maximum possible
   length of SRC.  Prefer TYPE_SIZE() to TREE_STRING_LENGTH() if possible
   in case the latter is less than the size of the array, such as when
   SRC refers to a short string literal used to initialize a large array.
   In that case, the elements of the array after the terminating NUL are
   all NUL.  */
HOST_WIDE_INTlong strelts = TREE_STRING_LENGTH (src)((tree_check ((src), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 623, __FUNCTION__, (STRING_CST)))->string.length);
strelts = strelts / eltsize;

if (!tree_fits_uhwi_p (memsize))
  return NULL_TREE(tree) __null;

HOST_WIDE_INTlong maxelts = tree_to_uhwi (memsize) / eltsize;

/* PTR can point to the byte representation of any string type, including
   char* and wchar_t*.  */
const char *ptr = TREE_STRING_POINTER (src)((const char *)((tree_check ((src), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 633, __FUNCTION__, (STRING_CST)))->string.str));

if (byteoff && TREE_CODE (byteoff)((enum tree_code) (byteoff)->base.code) != INTEGER_CST)
  {
    /* The code below works only for single byte character types.  */
    if (eltsize != 1)
return NULL_TREE(tree) __null;

    /* If the string has an internal NUL character followed by any
non-NUL characters (e.g., "foo\0bar"), we can't compute
the offset to the following NUL if we don't know where to
start searching for it.  */
    unsigned len = string_length (ptr, eltsize, strelts);

    /* Return when an embedded null character is found or none at all.
In the latter case, set the DECL/LEN field in the DATA structure
so that callers may examine them.  */
    if (len + 1 < strelts)
return NULL_TREE(tree) __null;
    else if (len >= maxelts)
{
 data->decl = decl;
 data->off = byteoff;
 data->minlen = ssize_int (len)size_int_kind (len, stk_ssizetype);
 return NULL_TREE(tree) __null;
}

    /* For empty strings the result should be zero.  */
    if (len == 0)
return ssize_int (0)size_int_kind (0, stk_ssizetype);

    /* We don't know the starting offset, but we do know that the string
has no internal zero bytes.  If the offset falls within the bounds
of the string subtract the offset from the length of the string,
and return that.  Otherwise the length is zero.  Take care to
use SAVE_EXPR in case the OFFSET has side-effects.  */
    tree offsave = TREE_SIDE_EFFECTS (byteoff)((non_type_check ((byteoff), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 669, __FUNCTION__))->base.side_effects_flag) ? save_expr (byteoff)
				 : byteoff;
    offsave = fold_convert_loc (loc, sizetypesizetype_tab[(int) stk_sizetype], offsave);
    tree condexp = fold_build2_loc (loc, LE_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], offsave,
		      size_int (len)size_int_kind (len, stk_sizetype));
    tree lenexp = fold_build2_loc (loc, MINUS_EXPR, sizetypesizetype_tab[(int) stk_sizetype], size_int (len)size_int_kind (len, stk_sizetype),
		     offsave);
    lenexp = fold_convert_loc (loc, ssizetypesizetype_tab[(int) stk_ssizetype], lenexp);
    return fold_build3_loc (loc, COND_EXPR, ssizetypesizetype_tab[(int) stk_ssizetype], condexp, lenexp,
	      build_zero_cst (ssizetypesizetype_tab[(int) stk_ssizetype]));
  }

/* Offset from the beginning of the string in elements.  */
HOST_WIDE_INTlong eltoff;

/* We have a known offset into the string.  Start searching there for
   a null character if we can represent it as a single HOST_WIDE_INT.  */
if (byteoff == 0)
  eltoff = 0;
else if (! tree_fits_uhwi_p (byteoff) || tree_to_uhwi (byteoff) % eltsize)
  eltoff = -1;
else
  eltoff = tree_to_uhwi (byteoff) / eltsize;

/* If the offset is known to be out of bounds, warn, and call strlen at
   runtime.  */
if (eltoff < 0 || eltoff >= maxelts)
  {
    /* Suppress multiple warnings for propagated constant strings.  */
    if (only_value != 2
 && !warning_suppressed_p (arg, OPT_Warray_bounds_)
 && warning_at (loc, OPT_Warray_bounds_,
	 "offset %qwi outside bounds of constant string",
	 eltoff))
{
 if (decl)
   inform (DECL_SOURCE_LOCATION (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 705, __FUNCTION__))->decl_minimal.locus), "%qE declared here", decl);
 suppress_warning (arg, OPT_Warray_bounds_);
}
    return NULL_TREE(tree) __null;
  }

/* If eltoff is larger than strelts but less than maxelts the
   string length is zero, since the excess memory will be zero.  */
if (eltoff > strelts)
  return ssize_int (0)size_int_kind (0, stk_ssizetype);

/* Use strlen to search for the first zero byte.  Since any strings
   constructed with build_string will have nulls appended, we win even
   if we get handed something like (char[4])"abcd".

   Since ELTOFF is our starting index into the string, no further
   calculation is needed.  */
unsigned len = string_length (ptr + eltoff * eltsize, eltsize,
		strelts - eltoff);

/* Don't know what to return if there was no zero termination.
   Ideally this would turn into a gcc_checking_assert over time.
   Set DECL/LEN so callers can examine them.  */
if (len >= maxelts - eltoff)
  {
    data->decl = decl;
    data->off = byteoff;
    data->minlen = ssize_int (len)size_int_kind (len, stk_ssizetype);
    return NULL_TREE(tree) __null;
  }

return ssize_int (len)size_int_kind (len, stk_ssizetype);
737}

739/* Return a constant integer corresponding to target reading
 GET_MODE_BITSIZE (MODE) bits from string constant STR.  If
 NULL_TERMINATED_P, reading stops after '\0' character, all further ones
 are assumed to be zero, otherwise it reads as many characters
 as needed.  */

745rtx
746c_readstr (const char *str, scalar_int_mode mode,
  bool null_terminated_p/*=true*/)
748{
HOST_WIDE_INTlong ch;
unsigned int i, j;
HOST_WIDE_INTlong tmp[MAX_BITSIZE_MODE_ANY_INT(64*(8)) / HOST_BITS_PER_WIDE_INT64];

gcc_assert (GET_MODE_CLASS (mode) == MODE_INT)((void)(!(((enum mode_class) mode_class[mode]) == MODE_INT) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 753, __FUNCTION__), 0 : 0));
unsigned int len = (GET_MODE_PRECISION (mode) + HOST_BITS_PER_WIDE_INT64 - 1)
  / HOST_BITS_PER_WIDE_INT64;

gcc_assert (len <= MAX_BITSIZE_MODE_ANY_INT / HOST_BITS_PER_WIDE_INT)((void)(!(len <= (64*(8)) / 64) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 757, __FUNCTION__), 0 : 0));
for (i = 0; i < len; i++)
  tmp[i] = 0;

ch = 1;
for (i = 0; i < GET_MODE_SIZE (mode); i++)
  {
    j = i;
    if (WORDS_BIG_ENDIAN0)
j = GET_MODE_SIZE (mode) - i - 1;
    if (BYTES_BIG_ENDIAN0 != WORDS_BIG_ENDIAN0
 && GET_MODE_SIZE (mode) >= UNITS_PER_WORD(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 8 : 4))
j = j + UNITS_PER_WORD(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 8 : 4) - 2 * (j % UNITS_PER_WORD(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 8 : 4)) - 1;
    j *= BITS_PER_UNIT(8);

    if (ch || !null_terminated_p)
ch = (unsigned char) str[i];
    tmp[j / HOST_BITS_PER_WIDE_INT64] |= ch << (j % HOST_BITS_PER_WIDE_INT64);
  }

wide_int c = wide_int::from_array (tmp, len, GET_MODE_PRECISION (mode));
return immed_wide_int_const (c, mode);
779}

781/* Cast a target constant CST to target CHAR and if that value fits into
 host char type, return zero and put that value into variable pointed to by
 P.  */

785static int
786target_char_cast (tree cst, char *p)
787{
unsigned HOST_WIDE_INTlong val, hostval;

if (TREE_CODE (cst)((enum tree_code) (cst)->base.code) != INTEGER_CST
    || CHAR_TYPE_SIZE(8) > HOST_BITS_PER_WIDE_INT64)
  return 1;

/* Do not care if it fits or not right here.  */
val = TREE_INT_CST_LOW (cst)((unsigned long) (*tree_int_cst_elt_check ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 795, __FUNCTION__)));

if (CHAR_TYPE_SIZE(8) < HOST_BITS_PER_WIDE_INT64)
  val &= (HOST_WIDE_INT_1U1UL << CHAR_TYPE_SIZE(8)) - 1;

hostval = val;
if (HOST_BITS_PER_CHAR8 < HOST_BITS_PER_WIDE_INT64)
  hostval &= (HOST_WIDE_INT_1U1UL << HOST_BITS_PER_CHAR8) - 1;

if (val != hostval)
  return 1;

*p = hostval;
return 0;
809}

811/* Similar to save_expr, but assumes that arbitrary code is not executed
 in between the multiple evaluations.  In particular, we assume that a
 non-addressable local variable will not be modified.  */

815static tree
816builtin_save_expr (tree exp)
817{
if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == SSA_NAME
    || (TREE_ADDRESSABLE (exp)((exp)->base.addressable_flag) == 0
 && (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == PARM_DECL
     || (VAR_P (exp)(((enum tree_code) (exp)->base.code) == VAR_DECL) && !TREE_STATIC (exp)((exp)->base.static_flag)))))
  return exp;

return save_expr (exp);
825}

827/* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
 times to get the address of either a higher stack frame, or a return
 address located within it (depending on FNDECL_CODE).  */

831static rtx
832expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
833{
int i;
rtx tem = INITIAL_FRAME_ADDRESS_RTX__null;
if (tem == NULL_RTX(rtx) 0)
  {
    /* For a zero count with __builtin_return_address, we don't care what
frame address we return, because target-specific definitions will
override us.  Therefore frame pointer elimination is OK, and using
the soft frame pointer is OK.

For a nonzero count, or a zero count with __builtin_frame_address,
we require a stable offset from the current frame pointer to the
previous one, so we must use the hard frame pointer, and
we must disable frame pointer elimination.  */
    if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
tem = frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_FRAME_POINTER]);
    else
{
 tem = hard_frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_HARD_FRAME_POINTER]);

 /* Tell reload not to eliminate the frame pointer.  */
 crtl(&x_rtl)->accesses_prior_frames = 1;
}
  }

if (count > 0)
  SETUP_FRAME_ADDRESSES ()ix86_setup_frame_addresses ();

/* On the SPARC, the return address is not in the frame, it is in a
   register.  There is no way to access it off of the current frame
   pointer, but it can be accessed off the previous frame pointer by
   reading the value from the register window save area.  */
if (RETURN_ADDR_IN_PREVIOUS_FRAME0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
  count--;

/* Scan back COUNT frames to the specified frame.  */
for (i = 0; i < count; i++)
  {
    /* Assume the dynamic chain pointer is in the word that the
frame address points to, unless otherwise specified.  */
    tem = DYNAMIC_CHAIN_ADDRESS (tem)(tem);
    tem = memory_address (Pmode, tem)memory_address_addr_space (((global_options.x_ix86_pmode == PMODE_DI
 ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) :
 (scalar_int_mode ((scalar_int_mode::from_int) E_SImode)))), (
tem), 0);
    tem = gen_frame_mem (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), tem);
    tem = copy_to_reg (tem);
  }

/* For __builtin_frame_address, return what we've got.  But, on
   the SPARC for example, we may have to add a bias.  */
if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
  return FRAME_ADDR_RTX (tem)(tem);

/* For __builtin_return_address, get the return address from that frame.  */
885#ifdef RETURN_ADDR_RTX
tem = RETURN_ADDR_RTX (count, tem)((count) == 0 ? gen_rtx_MEM ((global_options.x_ix86_pmode == PMODE_DI
 ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) :
 (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))), plus_constant
 ((global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode
 ((scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode (
(scalar_int_mode::from_int) E_SImode))), ((this_target_rtl->
x_global_rtl)[GR_ARG_POINTER]), -(((global_options.x_ix86_isa_flags
 & (1UL << 1)) != 0) ? 8 : 4))) : gen_rtx_MEM ((global_options
.x_ix86_pmode == PMODE_DI ? (scalar_int_mode ((scalar_int_mode
::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode::
from_int) E_SImode))), plus_constant ((global_options.x_ix86_pmode
 == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
), (tem), (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4))));
887#else
tem = memory_address (Pmode,memory_address_addr_space (((global_options.x_ix86_pmode == PMODE_DI
 ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) :
 (scalar_int_mode ((scalar_int_mode::from_int) E_SImode)))), (
plus_constant ((global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode
 ((scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode (
(scalar_int_mode::from_int) E_SImode))), tem, GET_MODE_SIZE (
(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))))), 0)
	plus_constant (Pmode, tem, GET_MODE_SIZE (Pmode)))memory_address_addr_space (((global_options.x_ix86_pmode == PMODE_DI
 ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) :
 (scalar_int_mode ((scalar_int_mode::from_int) E_SImode)))), (
plus_constant ((global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode
 ((scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode (
(scalar_int_mode::from_int) E_SImode))), tem, GET_MODE_SIZE (
(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))))), 0);
tem = gen_frame_mem (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), tem);
891#endif
return tem;
893}

895/* Alias set used for setjmp buffer.  */
896static alias_set_type setjmp_alias_set = -1;

898/* Construct the leading half of a __builtin_setjmp call.  Control will
 return to RECEIVER_LABEL.  This is also called directly by the SJLJ
 exception handling code.  */

902void
903expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
904{
machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL)((SAVE_NONLOCAL) == SAVE_NONLOCAL ? (((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))) : (global_options.x_ix86_pmode == PMODE_DI
 ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) :
 (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))));
rtx stack_save;
rtx mem;

if (setjmp_alias_set == -1)
  setjmp_alias_set = new_alias_set ();

buf_addr = convert_memory_address (Pmode, buf_addr)convert_memory_address_addr_space (((global_options.x_ix86_pmode
 == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
)), (buf_addr), 0);

buf_addr = force_reg (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), force_operand (buf_addr, NULL_RTX(rtx) 0));

/* We store the frame pointer and the address of receiver_label in
   the buffer and use the rest of it for the stack save area, which
   is machine-dependent.  */

mem = gen_rtx_MEM (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), buf_addr);
set_mem_alias_set (mem, setjmp_alias_set);
emit_move_insn (mem, hard_frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_HARD_FRAME_POINTER]));

mem = gen_rtx_MEM (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), plus_constant (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), buf_addr,
			   GET_MODE_SIZE (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))))),
set_mem_alias_set (mem, setjmp_alias_set);

emit_move_insn (validize_mem (mem),
  force_reg (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), gen_rtx_LABEL_REF (Pmode, receiver_label)gen_rtx_fmt_u_stat ((LABEL_REF), (((global_options.x_ix86_pmode
 == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
))), ((receiver_label)) )));

stack_save = gen_rtx_MEM (sa_mode,
	    plus_constant (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), buf_addr,
			   2 * GET_MODE_SIZE (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))))));
set_mem_alias_set (stack_save, setjmp_alias_set);
emit_stack_save (SAVE_NONLOCAL, &stack_save);

/* If there is further processing to do, do it.  */
if (targetm.have_builtin_setjmp_setup ())
  emit_insn (targetm.gen_builtin_setjmp_setup (buf_addr));

/* We have a nonlocal label.   */
cfun(cfun + 0)->has_nonlocal_label = 1;
943}

945/* Construct the trailing part of a __builtin_setjmp call.  This is
 also called directly by the SJLJ exception handling code.
 If RECEIVER_LABEL is NULL, instead contruct a nonlocal goto handler.  */

949void
950expand_builtin_setjmp_receiver (rtx receiver_label)
951{
rtx chain;

/* Mark the FP as used when we get here, so we have to make sure it's
   marked as used by this function.  */
emit_use (hard_frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_HARD_FRAME_POINTER]));

/* Mark the static chain as clobbered here so life information
   doesn't get messed up for it.  */
chain = rtx_for_static_chain (current_function_decl, true);
if (chain && REG_P (chain)(((enum rtx_code) (chain)->code) == REG))
  emit_clobber (chain);

if (!HARD_FRAME_POINTER_IS_ARG_POINTER(6 == 16) && fixed_regs(this_target_hard_regs->x_fixed_regs)[ARG_POINTER_REGNUM16])
  {
    /* If the argument pointer can be eliminated in favor of the
frame pointer, we don't need to restore it.  We assume here
that if such an elimination is present, it can always be used.
This is the case on all known machines; if we don't make this
assumption, we do unnecessary saving on many machines.  */
    size_t i;
    static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS{{ 16, 7}, { 16, 6}, { 19, 7}, { 19, 6}};

    for (i = 0; i < ARRAY_SIZE (elim_regs)(sizeof (elim_regs) / sizeof ((elim_regs)[0])); i++)
if (elim_regs[i].from == ARG_POINTER_REGNUM16
   && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM6)
 break;

    if (i == ARRAY_SIZE (elim_regs)(sizeof (elim_regs) / sizeof ((elim_regs)[0])))
{
 /* Now restore our arg pointer from the address at which it
    was saved in our stack frame.  */
 emit_move_insn (crtl(&x_rtl)->args.internal_arg_pointer,
	  copy_to_reg (get_arg_pointer_save_area ()));
}
  }

if (receiver_label != NULL__null && targetm.have_builtin_setjmp_receiver ())
  emit_insn (targetm.gen_builtin_setjmp_receiver (receiver_label));
else if (targetm.have_nonlocal_goto_receiver ())
  emit_insn (targetm.gen_nonlocal_goto_receiver ());
else
  { /* Nothing */ }

/* We must not allow the code we just generated to be reordered by
   scheduling.  Specifically, the update of the frame pointer must
   happen immediately, not later.  */
emit_insn (gen_blockage ());
999}

1001/* __builtin_longjmp is passed a pointer to an array of five words (not
 all will be used on all machines).  It operates similarly to the C
 library function of the same name, but is more efficient.  Much of
 the code below is copied from the handling of non-local gotos.  */

1006static void
1007expand_builtin_longjmp (rtx buf_addr, rtx value)
1008{
rtx fp, lab, stack;
rtx_insn *insn, *last;
machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL)((SAVE_NONLOCAL) == SAVE_NONLOCAL ? (((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))) : (global_options.x_ix86_pmode == PMODE_DI
 ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) :
 (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))));

/* DRAP is needed for stack realign if longjmp is expanded to current
   function  */
if (SUPPORTS_STACK_ALIGNMENT((((unsigned int) 1 << 28) * 8) > ((((global_options
.x_ix86_isa_flags & (1UL << 1)) != 0) && ix86_cfun_abi
 () == MS_ABI) ? 128 : ((8) * (((global_options.x_ix86_isa_flags
 & (1UL << 1)) != 0) ? 8 : 4)))))
  crtl(&x_rtl)->need_drap = true;

if (setjmp_alias_set == -1)
  setjmp_alias_set = new_alias_set ();

buf_addr = convert_memory_address (Pmode, buf_addr)convert_memory_address_addr_space (((global_options.x_ix86_pmode
 == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
)), (buf_addr), 0);

buf_addr = force_reg (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), buf_addr);

/* We require that the user must pass a second argument of 1, because
   that is what builtin_setjmp will return.  */
gcc_assert (value == const1_rtx)((void)(!(value == (const_int_rtx[64 +1])) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1027, __FUNCTION__), 0 : 0));

last = get_last_insn ();
if (targetm.have_builtin_longjmp ())
  emit_insn (targetm.gen_builtin_longjmp (buf_addr));
else
  {
    fp = gen_rtx_MEM (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), buf_addr);
    lab = gen_rtx_MEM (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), plus_constant (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), buf_addr,
			       GET_MODE_SIZE (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))))));

    stack = gen_rtx_MEM (sa_mode, plus_constant (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), buf_addr,
				   2 * GET_MODE_SIZE (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))))));
    set_mem_alias_set (fp, setjmp_alias_set);
    set_mem_alias_set (lab, setjmp_alias_set);
    set_mem_alias_set (stack, setjmp_alias_set);

    /* Pick up FP, label, and SP from the block and jump.  This code is
from expand_goto in stmt.cc; see there for detailed comments.  */
    if (targetm.have_nonlocal_goto ())
/* We have to pass a value to the nonlocal_goto pattern that will
  get copied into the static_chain pointer, but it does not matter
  what that value is, because builtin_setjmp does not use it.  */
emit_insn (targetm.gen_nonlocal_goto (value, lab, stack, fp));
    else
{
 emit_clobber (gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), gen_rtx_SCRATCH (VOIDmode)gen_rtx_fmt__stat ((SCRATCH), ((((void) 0, E_VOIDmode))) )));
 emit_clobber (gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), hard_frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_HARD_FRAME_POINTER])));

 lab = copy_to_reg (lab);

 /* Restore the frame pointer and stack pointer.  We must use a
    temporary since the setjmp buffer may be a local.  */
 fp = copy_to_reg (fp);
 emit_stack_restore (SAVE_NONLOCAL, stack);

 /* Ensure the frame pointer move is not optimized.  */
 emit_insn (gen_blockage ());
 emit_clobber (hard_frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_HARD_FRAME_POINTER]));
 emit_clobber (frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_FRAME_POINTER]));
 emit_move_insn (hard_frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_HARD_FRAME_POINTER]), fp);

 emit_use (hard_frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_HARD_FRAME_POINTER]));
 emit_use (stack_pointer_rtx((this_target_rtl->x_global_rtl)[GR_STACK_POINTER]));
 emit_indirect_jump (lab);
}
  }

/* Search backwards and mark the jump insn as a non-local goto.
   Note that this precludes the use of __builtin_longjmp to a
   __builtin_setjmp target in the same function.  However, we've
   already cautioned the user that these functions are for
   internal exception handling use only.  */
for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
  {
    gcc_assert (insn != last)((void)(!(insn != last) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1082, __FUNCTION__), 0 : 0));

    if (JUMP_P (insn)(((enum rtx_code) (insn)->code) == JUMP_INSN))
{
 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx(const_int_rtx[64]));
 break;
}
    else if (CALL_P (insn)(((enum rtx_code) (insn)->code) == CALL_INSN))
break;
  }
1092}

1094static inline bool
1095more_const_call_expr_args_p (const const_call_expr_arg_iterator *iter)
1096{
return (iter->i < iter->n);
1098}

1100/* This function validates the types of a function call argument list
 against a specified list of tree_codes.  If the last specifier is a 0,
 that represents an ellipsis, otherwise the last specifier must be a
 VOID_TYPE.  */

1105static bool
1106validate_arglist (const_tree callexpr, ...)
1107{
enum tree_code code;
bool res = 0;
va_list ap;
const_call_expr_arg_iterator iter;
const_tree arg;

va_start (ap, callexpr)__builtin_va_start(ap, callexpr);
init_const_call_expr_arg_iterator (callexpr, &iter);

/* Get a bitmap of pointer argument numbers declared attribute nonnull.  */
tree fn = CALL_EXPR_FN (callexpr)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((callexpr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1118, __FUNCTION__, (CALL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1118, __FUNCTION__)))));
bitmap argmap = get_nonnull_args (TREE_TYPE (TREE_TYPE (fn))((contains_struct_check ((((contains_struct_check ((fn), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1119, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1119, __FUNCTION__))->typed.type));

for (unsigned argno = 1; ; ++argno)
  {
    code = (enum tree_code) va_arg (ap, int)__builtin_va_arg(ap, int);

    switch (code)
{
case 0:
 /* This signifies an ellipses, any further arguments are all ok.  */
 res = true;
 goto end;
case VOID_TYPE:
 /* This signifies an endlink, if no arguments remain, return
    true, otherwise return false.  */
 res = !more_const_call_expr_args_p (&iter);
 goto end;
case POINTER_TYPE:
 /* The actual argument must be nonnull when either the whole
    called function has been declared nonnull, or when the formal
    argument corresponding to the actual argument has been.  */
 if (argmap
     && (bitmap_empty_p (argmap) || bitmap_bit_p (argmap, argno)))
   {
     arg = next_const_call_expr_arg (&iter);
     if (!validate_arg (arg, code) || integer_zerop (arg))
goto end;
     break;
   }
 /* FALLTHRU */
default:
 /* If no parameters remain or the parameter's code does not
    match the specified code, return false.  Otherwise continue
    checking any remaining arguments.  */
 arg = next_const_call_expr_arg (&iter);
 if (!validate_arg (arg, code))
   goto end;
 break;
}
  }

/* We need gotos here since we can only have one VA_CLOSE in a
   function.  */
end: ;
va_end (ap)__builtin_va_end(ap);

BITMAP_FREE (argmap)((void) (bitmap_obstack_free ((bitmap) argmap), (argmap) = (bitmap
) __null));

return res;
1168}

1170/* Expand a call to __builtin_nonlocal_goto.  We're passed the target label
 and the address of the save area.  */

1173static rtx
1174expand_builtin_nonlocal_goto (tree exp)
1175{
tree t_label, t_save_area;
rtx r_label, r_save_area, r_fp, r_sp;
rtx_insn *insn;

if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

t_label = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1183, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1183, __FUNCTION__)))));
t_save_area = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1184, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1184, __FUNCTION__)))));

r_label = expand_normal (t_label);
r_label = convert_memory_address (Pmode, r_label)convert_memory_address_addr_space (((global_options.x_ix86_pmode
 == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
)), (r_label), 0);
r_save_area = expand_normal (t_save_area);
r_save_area = convert_memory_address (Pmode, r_save_area)convert_memory_address_addr_space (((global_options.x_ix86_pmode
 == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
)), (r_save_area), 0);
/* Copy the address of the save location to a register just in case it was
   based on the frame pointer.   */
r_save_area = copy_to_reg (r_save_area);
r_fp = gen_rtx_MEM (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), r_save_area);
r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL)((SAVE_NONLOCAL) == SAVE_NONLOCAL ? (((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))) : (global_options.x_ix86_pmode == PMODE_DI
 ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) :
 (scalar_int_mode ((scalar_int_mode::from_int) E_SImode)))),
      plus_constant (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), r_save_area,
		     GET_MODE_SIZE (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))))));

crtl(&x_rtl)->has_nonlocal_goto = 1;

/* ??? We no longer need to pass the static chain value, afaik.  */
if (targetm.have_nonlocal_goto ())
  emit_insn (targetm.gen_nonlocal_goto (const0_rtx(const_int_rtx[64]), r_label, r_sp, r_fp));
else
  {
    emit_clobber (gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), gen_rtx_SCRATCH (VOIDmode)gen_rtx_fmt__stat ((SCRATCH), ((((void) 0, E_VOIDmode))) )));
    emit_clobber (gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), hard_frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_HARD_FRAME_POINTER])));

    r_label = copy_to_reg (r_label);

    /* Restore the frame pointer and stack pointer.  We must use a
temporary since the setjmp buffer may be a local.  */
    r_fp = copy_to_reg (r_fp);
    emit_stack_restore (SAVE_NONLOCAL, r_sp);

    /* Ensure the frame pointer move is not optimized.  */
    emit_insn (gen_blockage ());
    emit_clobber (hard_frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_HARD_FRAME_POINTER]));
    emit_clobber (frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_FRAME_POINTER]));
    emit_move_insn (hard_frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_HARD_FRAME_POINTER]), r_fp);

    /* USE of hard_frame_pointer_rtx added for consistency;
not clear if really needed.  */
    emit_use (hard_frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_HARD_FRAME_POINTER]));
    emit_use (stack_pointer_rtx((this_target_rtl->x_global_rtl)[GR_STACK_POINTER]));

    /* If the architecture is using a GP register, we must
conservatively assume that the target function makes use of it.
The prologue of functions with nonlocal gotos must therefore
initialize the GP register to the appropriate value, and we
must then make sure that this value is live at the point
of the jump.  (Note that this doesn't necessarily apply
to targets with a nonlocal_goto pattern; they are free
to implement it in their own way.  Note also that this is
a no-op if the GP register is a global invariant.)  */
    unsigned regnum = PIC_OFFSET_TABLE_REGNUM(ix86_use_pseudo_pic_reg () ? ((this_target_rtl->x_pic_offset_table_rtx
) ? (~(unsigned int) 0) : (((global_options.x_ix86_isa_flags &
 (1UL << 1)) != 0) ? 43 : 3)) : (~(unsigned int) 0));
    if (regnum != INVALID_REGNUM(~(unsigned int) 0) && fixed_regs(this_target_hard_regs->x_fixed_regs)[regnum])
emit_use (pic_offset_table_rtx(this_target_rtl->x_pic_offset_table_rtx));

    emit_indirect_jump (r_label);
  }

/* Search backwards to the jump insn and mark it as a
   non-local goto.  */
for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
  {
    if (JUMP_P (insn)(((enum rtx_code) (insn)->code) == JUMP_INSN))
{
 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx(const_int_rtx[64]));
 break;
}
    else if (CALL_P (insn)(((enum rtx_code) (insn)->code) == CALL_INSN))
break;
  }

return const0_rtx(const_int_rtx[64]);
1256}

1258/* __builtin_update_setjmp_buf is passed a pointer to an array of five words
 (not all will be used on all machines) that was passed to __builtin_setjmp.
 It updates the stack pointer in that block to the current value.  This is
 also called directly by the SJLJ exception handling code.  */

1263void
1264expand_builtin_update_setjmp_buf (rtx buf_addr)
1265{
machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL)((SAVE_NONLOCAL) == SAVE_NONLOCAL ? (((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))) : (global_options.x_ix86_pmode == PMODE_DI
 ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) :
 (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))));
buf_addr = convert_memory_address (Pmode, buf_addr)convert_memory_address_addr_space (((global_options.x_ix86_pmode
 == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
)), (buf_addr), 0);
rtx stack_save
  = gen_rtx_MEM (sa_mode,
   memory_addressmemory_address_addr_space ((sa_mode), (plus_constant ((global_options
.x_ix86_pmode == PMODE_DI ? (scalar_int_mode ((scalar_int_mode
::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode::
from_int) E_SImode))), buf_addr, 2 * GET_MODE_SIZE ((global_options
.x_ix86_pmode == PMODE_DI ? (scalar_int_mode ((scalar_int_mode
::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode::
from_int) E_SImode)))))), 0)
   (sa_mode,memory_address_addr_space ((sa_mode), (plus_constant ((global_options
.x_ix86_pmode == PMODE_DI ? (scalar_int_mode ((scalar_int_mode
::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode::
from_int) E_SImode))), buf_addr, 2 * GET_MODE_SIZE ((global_options
.x_ix86_pmode == PMODE_DI ? (scalar_int_mode ((scalar_int_mode
::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode::
from_int) E_SImode)))))), 0)
    plus_constant (Pmode, buf_addr,memory_address_addr_space ((sa_mode), (plus_constant ((global_options
.x_ix86_pmode == PMODE_DI ? (scalar_int_mode ((scalar_int_mode
::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode::
from_int) E_SImode))), buf_addr, 2 * GET_MODE_SIZE ((global_options
.x_ix86_pmode == PMODE_DI ? (scalar_int_mode ((scalar_int_mode
::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode::
from_int) E_SImode)))))), 0)
		   2 * GET_MODE_SIZE (Pmode)))memory_address_addr_space ((sa_mode), (plus_constant ((global_options
.x_ix86_pmode == PMODE_DI ? (scalar_int_mode ((scalar_int_mode
::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode::
from_int) E_SImode))), buf_addr, 2 * GET_MODE_SIZE ((global_options
.x_ix86_pmode == PMODE_DI ? (scalar_int_mode ((scalar_int_mode
::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode::
from_int) E_SImode)))))), 0));

emit_stack_save (SAVE_NONLOCAL, &stack_save);
1276}

1278/* Expand a call to __builtin_prefetch.  For a target that does not support
 data prefetch, evaluate the memory address argument in case it has side
 effects.  */

1282static void
1283expand_builtin_prefetch (tree exp)
1284{
tree arg0, arg1, arg2;
int nargs;
rtx op0, op1, op2;

if (!validate_arglist (exp, POINTER_TYPE, 0))
  return;

arg0 = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1292, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1292, __FUNCTION__)))));

/* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
   zero (read) and argument 2 (locality) defaults to 3 (high degree of
   locality).  */
nargs = call_expr_nargs (exp)(((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
 ((exp), (tcc_vl_exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1297, __FUNCTION__))->exp.operands[0]), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1297, __FUNCTION__)))) - 3);
if (nargs > 1)
  arg1 = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1299, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1299, __FUNCTION__)))));
else
  arg1 = integer_zero_nodeglobal_trees[TI_INTEGER_ZERO];
if (nargs > 2)
  arg2 = CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1303, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1303, __FUNCTION__)))));
else
  arg2 = integer_three_nodeglobal_trees[TI_INTEGER_THREE];

/* Argument 0 is an address.  */
op0 = expand_expr (arg0, NULL_RTX(rtx) 0, Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), EXPAND_NORMAL);

/* Argument 1 (read/write flag) must be a compile-time constant int.  */
if (TREE_CODE (arg1)((enum tree_code) (arg1)->base.code) != INTEGER_CST)
  {
    error ("second argument to %<__builtin_prefetch%> must be a constant");
    arg1 = integer_zero_nodeglobal_trees[TI_INTEGER_ZERO];
  }
op1 = expand_normal (arg1);
/* Argument 1 must be either zero or one.  */
if (INTVAL (op1)((op1)->u.hwint[0]) != 0 && INTVAL (op1)((op1)->u.hwint[0]) != 1)
  {
    warning (0, "invalid second argument to %<__builtin_prefetch%>;"
      " using zero");
    op1 = const0_rtx(const_int_rtx[64]);
  }

/* Argument 2 (locality) must be a compile-time constant int.  */
if (TREE_CODE (arg2)((enum tree_code) (arg2)->base.code) != INTEGER_CST)
  {
    error ("third argument to %<__builtin_prefetch%> must be a constant");
    arg2 = integer_zero_nodeglobal_trees[TI_INTEGER_ZERO];
  }
op2 = expand_normal (arg2);
/* Argument 2 must be 0, 1, 2, or 3.  */
if (INTVAL (op2)((op2)->u.hwint[0]) < 0 || INTVAL (op2)((op2)->u.hwint[0]) > 3)
  {
    warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
    op2 = const0_rtx(const_int_rtx[64]);
  }

if (targetm.have_prefetch ())
  {
    class expand_operand ops[3];

    create_address_operand (&ops[0], op0);
    create_integer_operand (&ops[1], INTVAL (op1)((op1)->u.hwint[0]));
    create_integer_operand (&ops[2], INTVAL (op2)((op2)->u.hwint[0]));
    if (maybe_expand_insn (targetm.code_for_prefetch, 3, ops))
return;
  }

/* Don't do anything with direct references to volatile memory, but
   generate code to handle other side effects.  */
if (!MEM_P (op0)(((enum rtx_code) (op0)->code) == MEM) && side_effects_p (op0))
  emit_insn (op0);
1354}

1356/* Get a MEM rtx for expression EXP which is the address of an operand
 to be used in a string instruction (cmpstrsi, cpymemsi, ..).  LEN is
 the maximum length of the block of memory that might be accessed or
 NULL if unknown.  */

1361rtx
1362get_memory_rtx (tree exp, tree len)
1363{
tree orig_exp = exp, base;
rtx addr, mem;

/* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
   from its expression, for expr->a.b only <variable>.a.b is recorded.  */
if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1369, __FUNCTION__, (SAVE_EXPR)))->base.public_flag))
  exp = TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1370, __FUNCTION__)))));

addr = expand_expr (orig_exp, NULL_RTX(rtx) 0, ptr_mode, EXPAND_NORMAL);
mem = gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), memory_address (BLKmode, addr)memory_address_addr_space ((((void) 0, E_BLKmode)), (addr), 0
));

/* Get an expression we can use to find the attributes to assign to MEM.
   First remove any nops.  */
while (CONVERT_EXPR_P (exp)((((enum tree_code) (exp)->base.code)) == NOP_EXPR || (((enum
 tree_code) (exp)->base.code)) == CONVERT_EXPR)
&& POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0)))(((enum tree_code) (((contains_struct_check (((*((const_cast<
tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1378, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1378, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check (((*((const_cast
<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1378, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1378, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
  exp = TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1379, __FUNCTION__)))));

/* Build a MEM_REF representing the whole accessed area as a byte blob,
   (as builtin stringops may alias with anything).  */
exp = fold_build2 (MEM_REF,fold_build2_loc (((location_t) 0), MEM_REF, build_array_type (
integer_types[itk_char], build_range_type (sizetype_tab[(int)
 stk_sizetype], global_trees[TI_SIZE_ONE], len)), exp, build_int_cst
 (global_trees[TI_PTR_TYPE], 0) )
     build_array_type (char_type_node,fold_build2_loc (((location_t) 0), MEM_REF, build_array_type (
integer_types[itk_char], build_range_type (sizetype_tab[(int)
 stk_sizetype], global_trees[TI_SIZE_ONE], len)), exp, build_int_cst
 (global_trees[TI_PTR_TYPE], 0) )
		       build_range_type (sizetype,fold_build2_loc (((location_t) 0), MEM_REF, build_array_type (
integer_types[itk_char], build_range_type (sizetype_tab[(int)
 stk_sizetype], global_trees[TI_SIZE_ONE], len)), exp, build_int_cst
 (global_trees[TI_PTR_TYPE], 0) )
					 size_one_node, len)),fold_build2_loc (((location_t) 0), MEM_REF, build_array_type (
integer_types[itk_char], build_range_type (sizetype_tab[(int)
 stk_sizetype], global_trees[TI_SIZE_ONE], len)), exp, build_int_cst
 (global_trees[TI_PTR_TYPE], 0) )
     exp, build_int_cst (ptr_type_node, 0))fold_build2_loc (((location_t) 0), MEM_REF, build_array_type (
integer_types[itk_char], build_range_type (sizetype_tab[(int)
 stk_sizetype], global_trees[TI_SIZE_ONE], len)), exp, build_int_cst
 (global_trees[TI_PTR_TYPE], 0) );

/* If the MEM_REF has no acceptable address, try to get the base object
   from the original address we got, and build an all-aliasing
   unknown-sized access to that one.  */
if (is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1392, __FUNCTION__)))))))
  set_mem_attributes (mem, exp, 0);
else if (TREE_CODE (TREE_OPERAND (exp, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1394, __FUNCTION__))))))->base.code) == ADDR_EXPR
  && (base = get_base_address (TREE_OPERAND (TREE_OPERAND (exp, 0),(*((const_cast<tree*> (tree_operand_check (((*((const_cast
<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1395, __FUNCTION__)))))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1396, __FUNCTION__)))))
				      0)(*((const_cast<tree*> (tree_operand_check (((*((const_cast
<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1395, __FUNCTION__)))))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1396, __FUNCTION__))))))))
  {
    unsigned int align = get_pointer_alignment (TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1398, __FUNCTION__))))));
    exp = build_fold_addr_expr (base)build_fold_addr_expr_loc (((location_t) 0), (base));
    exp = fold_build2 (MEM_REF,fold_build2_loc (((location_t) 0), MEM_REF, build_array_type (
integer_types[itk_char], build_range_type (sizetype_tab[(int)
 stk_sizetype], global_trees[TI_SIZE_ZERO], __null)), exp, build_int_cst
 (global_trees[TI_PTR_TYPE], 0) )
	 build_array_type (char_type_node,fold_build2_loc (((location_t) 0), MEM_REF, build_array_type (
integer_types[itk_char], build_range_type (sizetype_tab[(int)
 stk_sizetype], global_trees[TI_SIZE_ZERO], __null)), exp, build_int_cst
 (global_trees[TI_PTR_TYPE], 0) )
			   build_range_type (sizetype,fold_build2_loc (((location_t) 0), MEM_REF, build_array_type (
integer_types[itk_char], build_range_type (sizetype_tab[(int)
 stk_sizetype], global_trees[TI_SIZE_ZERO], __null)), exp, build_int_cst
 (global_trees[TI_PTR_TYPE], 0) )
					     size_zero_node,fold_build2_loc (((location_t) 0), MEM_REF, build_array_type (
integer_types[itk_char], build_range_type (sizetype_tab[(int)
 stk_sizetype], global_trees[TI_SIZE_ZERO], __null)), exp, build_int_cst
 (global_trees[TI_PTR_TYPE], 0) )
					     NULL)),fold_build2_loc (((location_t) 0), MEM_REF, build_array_type (
integer_types[itk_char], build_range_type (sizetype_tab[(int)
 stk_sizetype], global_trees[TI_SIZE_ZERO], __null)), exp, build_int_cst
 (global_trees[TI_PTR_TYPE], 0) )
	 exp, build_int_cst (ptr_type_node, 0))fold_build2_loc (((location_t) 0), MEM_REF, build_array_type (
integer_types[itk_char], build_range_type (sizetype_tab[(int)
 stk_sizetype], global_trees[TI_SIZE_ZERO], __null)), exp, build_int_cst
 (global_trees[TI_PTR_TYPE], 0) );
    set_mem_attributes (mem, exp, 0);
    /* Since we stripped parts make sure the offset is unknown and the
alignment is computed from the original address.  */
    clear_mem_offset (mem);
    set_mem_align (mem, align);
  }
set_mem_alias_set (mem, 0);
return mem;
1414}
1415
1416/* Built-in functions to perform an untyped call and return.  */

1418#define apply_args_mode(this_target_builtins->x_apply_args_mode) \
(this_target_builtins->x_apply_args_mode)
1420#define apply_result_mode(this_target_builtins->x_apply_result_mode) \
(this_target_builtins->x_apply_result_mode)

1423/* Return the size required for the block returned by __builtin_apply_args,
 and initialize apply_args_mode.  */

1426static int
1427apply_args_size (void)
1428{
static int size = -1;
int align;
unsigned int regno;

/* The values computed by this function never change.  */
if (size < 0)
  {
    /* The first value is the incoming arg-pointer.  */
    size = GET_MODE_SIZE (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))));

    /* The second value is the structure value address unless this is
passed as an "invisible" first argument.  */
    if (targetm.calls.struct_value_rtx (cfun(cfun + 0) ? TREE_TYPE (cfun->decl)((contains_struct_check (((cfun + 0)->decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1441, __FUNCTION__))->typed.type) : 0, 0))
size += GET_MODE_SIZE (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))));

    for (regno = 0; regno < FIRST_PSEUDO_REGISTER76; regno++)
if (FUNCTION_ARG_REGNO_P (regno)ix86_function_arg_regno_p (regno))
 {
   fixed_size_mode mode = targetm.calls.get_raw_arg_mode (regno);

   gcc_assert (mode != VOIDmode)((void)(!(mode != ((void) 0, E_VOIDmode)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1449, __FUNCTION__), 0 : 0));

   align = GET_MODE_ALIGNMENT (mode)get_mode_alignment (mode) / BITS_PER_UNIT(8);
   if (size % align != 0)
     size = CEIL (size, align)(((size) + (align) - 1) / (align)) * align;
   size += GET_MODE_SIZE (mode);
   apply_args_mode(this_target_builtins->x_apply_args_mode)[regno] = mode;
 }
else
 {
   apply_args_mode(this_target_builtins->x_apply_args_mode)[regno] = as_a <fixed_size_mode> (VOIDmode((void) 0, E_VOIDmode));
 }
  }
return size;
1463}

1465/* Return the size required for the block returned by __builtin_apply,
 and initialize apply_result_mode.  */

1468static int
1469apply_result_size (void)
1470{
static int size = -1;
int align, regno;

/* The values computed by this function never change.  */
if (size < 0)
  {
    size = 0;

    for (regno = 0; regno < FIRST_PSEUDO_REGISTER76; regno++)
if (targetm.calls.function_value_regno_p (regno))
 {
   fixed_size_mode mode = targetm.calls.get_raw_result_mode (regno);

   gcc_assert (mode != VOIDmode)((void)(!(mode != ((void) 0, E_VOIDmode)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1484, __FUNCTION__), 0 : 0));

   align = GET_MODE_ALIGNMENT (mode)get_mode_alignment (mode) / BITS_PER_UNIT(8);
   if (size % align != 0)
     size = CEIL (size, align)(((size) + (align) - 1) / (align)) * align;
   size += GET_MODE_SIZE (mode);
   apply_result_mode(this_target_builtins->x_apply_result_mode)[regno] = mode;
 }
else
 apply_result_mode(this_target_builtins->x_apply_result_mode)[regno] = as_a <fixed_size_mode> (VOIDmode((void) 0, E_VOIDmode));

    /* Allow targets that use untyped_call and untyped_return to override
the size so that machine-specific information can be stored here.  */
1497#ifdef APPLY_RESULT_SIZE(8+108)
    size = APPLY_RESULT_SIZE(8+108);
1499#endif
  }
return size;
1502}

1504/* Create a vector describing the result block RESULT.  If SAVEP is true,
 the result block is used to save the values; otherwise it is used to
 restore the values.  */

1508static rtx
1509result_vector (int savep, rtx result)
1510{
int regno, size, align, nelts;
fixed_size_mode mode;
rtx reg, mem;
rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER)((rtx *) __builtin_alloca(sizeof (rtx) * (76)));

size = nelts = 0;
for (regno = 0; regno < FIRST_PSEUDO_REGISTER76; regno++)
  if ((mode = apply_result_mode(this_target_builtins->x_apply_result_mode)[regno]) != VOIDmode((void) 0, E_VOIDmode))
    {
align = GET_MODE_ALIGNMENT (mode)get_mode_alignment (mode) / BITS_PER_UNIT(8);
if (size % align != 0)
 size = CEIL (size, align)(((size) + (align) - 1) / (align)) * align;
reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno)(regno));
mem = adjust_address (result, mode, size)adjust_address_1 (result, mode, size, 1, 1, 0, 0);
savevec[nelts++] = (savep
	    ? gen_rtx_SET (mem, reg)gen_rtx_fmt_ee_stat ((SET), (((void) 0, E_VOIDmode)), ((mem))
, ((reg)) )
	    : gen_rtx_SET (reg, mem)gen_rtx_fmt_ee_stat ((SET), (((void) 0, E_VOIDmode)), ((reg))
, ((mem)) ));
size += GET_MODE_SIZE (mode);
    }
return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec))gen_rtx_fmt_E_stat ((PARALLEL), ((((void) 0, E_VOIDmode))), (
(gen_rtvec_v (nelts, savevec))) );
1531}

1533/* Save the state required to perform an untyped call with the same
 arguments as were passed to the current function.  */

1536static rtx
1537expand_builtin_apply_args_1 (void)
1538{
rtx registers, tem;
int size, align, regno;
fixed_size_mode mode;
rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun(cfun + 0) ? TREE_TYPE (cfun->decl)((contains_struct_check (((cfun + 0)->decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1542, __FUNCTION__))->typed.type) : 0, 1);

/* Create a block where the arg-pointer, structure value address,
   and argument registers can be saved.  */
registers = assign_stack_local (BLKmode((void) 0, E_BLKmode), apply_args_size (), -1);

/* Walk past the arg-pointer and structure value address.  */
size = GET_MODE_SIZE (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))));
if (targetm.calls.struct_value_rtx (cfun(cfun + 0) ? TREE_TYPE (cfun->decl)((contains_struct_check (((cfun + 0)->decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1550, __FUNCTION__))->typed.type) : 0, 0))
  size += GET_MODE_SIZE (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))));

/* Save each register used in calling a function to the block.  */
for (regno = 0; regno < FIRST_PSEUDO_REGISTER76; regno++)
  if ((mode = apply_args_mode(this_target_builtins->x_apply_args_mode)[regno]) != VOIDmode((void) 0, E_VOIDmode))
    {
align = GET_MODE_ALIGNMENT (mode)get_mode_alignment (mode) / BITS_PER_UNIT(8);
if (size % align != 0)
 size = CEIL (size, align)(((size) + (align) - 1) / (align)) * align;

tem = gen_rtx_REG (mode, INCOMING_REGNO (regno)(regno));

emit_move_insn (adjust_address (registers, mode, size)adjust_address_1 (registers, mode, size, 1, 1, 0, 0), tem);
size += GET_MODE_SIZE (mode);
    }

/* Save the arg pointer to the block.  */
tem = copy_to_reg (crtl(&x_rtl)->args.internal_arg_pointer);
/* We need the pointer as the caller actually passed them to us, not
   as we might have pretended they were passed.  Make sure it's a valid
   operand, as emit_move_insn isn't expected to handle a PLUS.  */
if (STACK_GROWS_DOWNWARD1)
  tem
    = force_operand (plus_constant (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), tem,
		      crtl(&x_rtl)->args.pretend_args_size),
       NULL_RTX(rtx) 0);
emit_move_insn (adjust_address (registers, Pmode, 0)adjust_address_1 (registers, (global_options.x_ix86_pmode == PMODE_DI
 ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) :
 (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))), 0
, 1, 1, 0, 0), tem);

size = GET_MODE_SIZE (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))));

/* Save the structure value address unless this is passed as an
   "invisible" first argument.  */
if (struct_incoming_value)
  emit_move_insn (adjust_address (registers, Pmode, size)adjust_address_1 (registers, (global_options.x_ix86_pmode == PMODE_DI
 ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) :
 (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))), size
, 1, 1, 0, 0),
    copy_to_reg (struct_incoming_value));

/* Return the address of the block.  */
return copy_addr_to_reg (XEXP (registers, 0)(((registers)->u.fld[0]).rt_rtx));
1589}

1591/* __builtin_apply_args returns block of memory allocated on
 the stack into which is stored the arg pointer, structure
 value address, static chain, and all the registers that might
 possibly be used in performing a function call.  The code is
 moved to the start of the function so the incoming values are
 saved.  */

1598static rtx
1599expand_builtin_apply_args (void)
1600{
/* Don't do __builtin_apply_args more than once in a function.
   Save the result of the first call and reuse it.  */
if (apply_args_value((&x_rtl)->expr.x_apply_args_value) != 0)
  return apply_args_value((&x_rtl)->expr.x_apply_args_value);
{
  /* When this function is called, it means that registers must be
     saved on entry to this function.  So we migrate the
     call to the first insn of this function.  */
  rtx temp;

  start_sequence ();
  temp = expand_builtin_apply_args_1 ();
  rtx_insn *seq = get_insns ();
  end_sequence ();

  apply_args_value((&x_rtl)->expr.x_apply_args_value) = temp;

  /* Put the insns after the NOTE that starts the function.
     If this is inside a start_sequence, make the outer-level insn
     chain current, so the code is placed at the start of the
     function.  If internal_arg_pointer is a non-virtual pseudo,
     it needs to be placed after the function that initializes
     that pseudo.  */
  push_topmost_sequence ();
  if (REG_P (crtl->args.internal_arg_pointer)(((enum rtx_code) ((&x_rtl)->args.internal_arg_pointer
)->code) == REG)
&& REGNO (crtl->args.internal_arg_pointer)(rhs_regno((&x_rtl)->args.internal_arg_pointer)) > LAST_VIRTUAL_REGISTER(((76)) + 5))
    emit_insn_before (seq, parm_birth_insn((&x_rtl)->x_parm_birth_insn));
  else
    emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
  pop_topmost_sequence ();
  return temp;
}
1633}

1635/* Perform an untyped call and save the state required to perform an
 untyped return of whatever value was returned by the given function.  */

1638static rtx
1639expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1640{
int size, align, regno;
fixed_size_mode mode;
rtx incoming_args, result, reg, dest, src;
rtx_call_insn *call_insn;
rtx old_stack_level = 0;
rtx call_fusage = 0;
rtx struct_value = targetm.calls.struct_value_rtx (cfun(cfun + 0) ? TREE_TYPE (cfun->decl)((contains_struct_check (((cfun + 0)->decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1647, __FUNCTION__))->typed.type) : 0, 0);

arguments = convert_memory_address (Pmode, arguments)convert_memory_address_addr_space (((global_options.x_ix86_pmode
 == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
)), (arguments), 0);

/* Create a block where the return registers can be saved.  */
result = assign_stack_local (BLKmode((void) 0, E_BLKmode), apply_result_size (), -1);

/* Fetch the arg pointer from the ARGUMENTS block.  */
incoming_args = gen_reg_rtx (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))));
emit_move_insn (incoming_args, gen_rtx_MEM (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), arguments));
if (!STACK_GROWS_DOWNWARD1)
  incoming_args = expand_simple_binop (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), MINUS, incoming_args, argsize,
			 incoming_args, 0, OPTAB_LIB_WIDEN);

/* Push a new argument block and copy the arguments.  Do not allow
   the (potential) memcpy call below to interfere with our stack
   manipulations.  */
do_pending_stack_adjust ();
NO_DEFER_POP(((&x_rtl)->expr.x_inhibit_defer_pop) += 1);

/* Save the stack with nonlocal if available.  */
if (targetm.have_save_stack_nonlocal ())
  emit_stack_save (SAVE_NONLOCAL, &old_stack_level);
else
  emit_stack_save (SAVE_BLOCK, &old_stack_level);

/* Allocate a block of memory onto the stack and copy the memory
   arguments to the outgoing arguments address.  We can pass TRUE
   as the 4th argument because we just saved the stack pointer
   and will restore it right after the call.  */
allocate_dynamic_stack_space (argsize, 0, BIGGEST_ALIGNMENT(((global_options.x_target_flags & (1U << 12)) != 0
) ? 32 : (((global_options.x_ix86_isa_flags & (1UL <<
 15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags & (
1UL << 8)) != 0) ? 256 : 128))), -1, true);

/* Set DRAP flag to true, even though allocate_dynamic_stack_space
   may have already set current_function_calls_alloca to true.
   current_function_calls_alloca won't be set if argsize is zero,
   so we have to guarantee need_drap is true here.  */
if (SUPPORTS_STACK_ALIGNMENT((((unsigned int) 1 << 28) * 8) > ((((global_options
.x_ix86_isa_flags & (1UL << 1)) != 0) && ix86_cfun_abi
 () == MS_ABI) ? 128 : ((8) * (((global_options.x_ix86_isa_flags
 & (1UL << 1)) != 0) ? 8 : 4)))))
  crtl(&x_rtl)->need_drap = true;

dest = virtual_outgoing_args_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_OUTGOING_ARGS]
);
if (!STACK_GROWS_DOWNWARD1)
  {
    if (CONST_INT_P (argsize)(((enum rtx_code) (argsize)->code) == CONST_INT))
dest = plus_constant (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), dest, -INTVAL (argsize)((argsize)->u.hwint[0]));
    else
dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize))gen_rtx_fmt_ee_stat ((PLUS), (((global_options.x_ix86_pmode ==
 PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
))), ((dest)), ((negate_rtx ((global_options.x_ix86_pmode == PMODE_DI
 ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) :
 (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))), argsize
))) );
  }
dest = gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), dest);
set_mem_align (dest, PARM_BOUNDARY((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4)));
src = gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), incoming_args);
set_mem_align (src, PARM_BOUNDARY((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4)));
emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);

/* Refer to the argument block.  */
apply_args_size ();
arguments = gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), arguments);
set_mem_align (arguments, PARM_BOUNDARY((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4)));

/* Walk past the arg-pointer and structure value address.  */
size = GET_MODE_SIZE (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))));
if (struct_value)
  size += GET_MODE_SIZE (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))));

/* Restore each of the registers previously saved.  Make USE insns
   for each of these registers for use in making the call.  */
for (regno = 0; regno < FIRST_PSEUDO_REGISTER76; regno++)
  if ((mode = apply_args_mode(this_target_builtins->x_apply_args_mode)[regno]) != VOIDmode((void) 0, E_VOIDmode))
    {
align = GET_MODE_ALIGNMENT (mode)get_mode_alignment (mode) / BITS_PER_UNIT(8);
if (size % align != 0)
 size = CEIL (size, align)(((size) + (align) - 1) / (align)) * align;
reg = gen_rtx_REG (mode, regno);
emit_move_insn (reg, adjust_address (arguments, mode, size)adjust_address_1 (arguments, mode, size, 1, 1, 0, 0));
use_reg (&call_fusage, reg);
size += GET_MODE_SIZE (mode);
    }

/* Restore the structure value address unless this is passed as an
   "invisible" first argument.  */
size = GET_MODE_SIZE (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))));
if (struct_value)
  {
    rtx value = gen_reg_rtx (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))));
    emit_move_insn (value, adjust_address (arguments, Pmode, size)adjust_address_1 (arguments, (global_options.x_ix86_pmode == PMODE_DI
 ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) :
 (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))), size
, 1, 1, 0, 0));
    emit_move_insn (struct_value, value);
    if (REG_P (struct_value)(((enum rtx_code) (struct_value)->code) == REG))
use_reg (&call_fusage, struct_value);
  }

/* All arguments and registers used for the call are set up by now!  */
function = prepare_call_address (NULL__null, function, NULL__null, &call_fusage, 0, 0);

/* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
   and we don't want to load it into a register as an optimization,
   because prepare_call_address already did it if it should be done.  */
if (GET_CODE (function)((enum rtx_code) (function)->code) != SYMBOL_REF)
  function = memory_address (FUNCTION_MODE, function)memory_address_addr_space (((scalar_int_mode ((scalar_int_mode
::from_int) E_QImode))), (function), 0);

/* Generate the actual call instruction and save the return value.  */
if (targetm.have_untyped_call ())
  {
    rtx mem = gen_rtx_MEM (FUNCTION_MODE(scalar_int_mode ((scalar_int_mode::from_int) E_QImode)), function);
    rtx_insn *seq = targetm.gen_untyped_call (mem, result,
				result_vector (1, result));
    for (rtx_insn *insn = seq; insn; insn = NEXT_INSN (insn))
if (CALL_P (insn)(((enum rtx_code) (insn)->code) == CALL_INSN))
 add_reg_note (insn, REG_UNTYPED_CALL, NULL_RTX(rtx) 0);
    emit_insn (seq);
  }
else if (targetm.have_call_value ())
  {
    rtx valreg = 0;

    /* Locate the unique return register.  It is not possible to
express a call that sets more than one return register using
call_value; use untyped_call for that.  In fact, untyped_call
only needs to save the return registers in the given block.  */
    for (regno = 0; regno < FIRST_PSEUDO_REGISTER76; regno++)
if ((mode = apply_result_mode(this_target_builtins->x_apply_result_mode)[regno]) != VOIDmode((void) 0, E_VOIDmode))
 {
   gcc_assert (!valreg)((void)(!(!valreg) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1767, __FUNCTION__), 0 : 0)); /* have_untyped_call required.  */

   valreg = gen_rtx_REG (mode, regno);
 }

    emit_insn (targetm.gen_call_value (valreg,
			 gen_rtx_MEM (FUNCTION_MODE(scalar_int_mode ((scalar_int_mode::from_int) E_QImode)), function),
			 const0_rtx(const_int_rtx[64]), NULL_RTX(rtx) 0, const0_rtx(const_int_rtx[64])));

    emit_move_insn (adjust_address (result, GET_MODE (valreg), 0)adjust_address_1 (result, ((machine_mode) (valreg)->mode),
 0, 1, 1, 0, 0), valreg);
  }
else
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1779, __FUNCTION__));

/* Find the CALL insn we just emitted, and attach the register usage
   information.  */
call_insn = last_call_insn ();
add_function_usage_to (call_insn, call_fusage);

/* Restore the stack.  */
if (targetm.have_save_stack_nonlocal ())
  emit_stack_restore (SAVE_NONLOCAL, old_stack_level);
else
  emit_stack_restore (SAVE_BLOCK, old_stack_level);
fixup_args_size_notes (call_insn, get_last_insn (), 0);

OK_DEFER_POP(((&x_rtl)->expr.x_inhibit_defer_pop) -= 1);

/* Return the address of the result block.  */
result = copy_addr_to_reg (XEXP (result, 0)(((result)->u.fld[0]).rt_rtx));
return convert_memory_address (ptr_mode, result)convert_memory_address_addr_space ((ptr_mode), (result), 0);
1798}

1800/* Perform an untyped return.  */

1802static void
1803expand_builtin_return (rtx result)
1804{
int size, align, regno;
fixed_size_mode mode;
rtx reg;
rtx_insn *call_fusage = 0;

result = convert_memory_address (Pmode, result)convert_memory_address_addr_space (((global_options.x_ix86_pmode
 == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
)), (result), 0);

apply_result_size ();
result = gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), result);

if (targetm.have_untyped_return ())
  {
    rtx vector = result_vector (0, result);
    emit_jump_insn (targetm.gen_untyped_return (result, vector));
    emit_barrier ();
    return;
  }

/* Restore the return value and note that each value is used.  */
size = 0;
for (regno = 0; regno < FIRST_PSEUDO_REGISTER76; regno++)
  if ((mode = apply_result_mode(this_target_builtins->x_apply_result_mode)[regno]) != VOIDmode((void) 0, E_VOIDmode))
    {
align = GET_MODE_ALIGNMENT (mode)get_mode_alignment (mode) / BITS_PER_UNIT(8);
if (size % align != 0)
 size = CEIL (size, align)(((size) + (align) - 1) / (align)) * align;
reg = gen_rtx_REG (mode, INCOMING_REGNO (regno)(regno));
emit_move_insn (reg, adjust_address (result, mode, size)adjust_address_1 (result, mode, size, 1, 1, 0, 0));

push_to_sequence (call_fusage);
emit_use (reg);
call_fusage = get_insns ();
end_sequence ();
size += GET_MODE_SIZE (mode);
    }

/* Put the USE insns before the return.  */
emit_insn (call_fusage);

/* Return whatever values was restored by jumping directly to the end
   of the function.  */
expand_naked_return ();
1847}

1849/* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */

1851static enum type_class
1852type_to_class (tree type)
1853{
switch (TREE_CODE (type)((enum tree_code) (type)->base.code))
  {
  case VOID_TYPE:	   return void_type_class;
  case INTEGER_TYPE:	   return integer_type_class;
  case ENUMERAL_TYPE:	   return enumeral_type_class;
  case BOOLEAN_TYPE:	   return boolean_type_class;
  case POINTER_TYPE:	   return pointer_type_class;
  case REFERENCE_TYPE:   return reference_type_class;
  case OFFSET_TYPE:	   return offset_type_class;
  case REAL_TYPE:	   return real_type_class;
  case COMPLEX_TYPE:	   return complex_type_class;
  case FUNCTION_TYPE:	   return function_type_class;
  case METHOD_TYPE:	   return method_type_class;
  case RECORD_TYPE:	   return record_type_class;
  case UNION_TYPE:
  case QUAL_UNION_TYPE:  return union_type_class;
  case ARRAY_TYPE:	   return (TYPE_STRING_FLAG (type)((tree_check2 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1870, __FUNCTION__, (ARRAY_TYPE), (INTEGER_TYPE)))->type_common
.string_flag)
		   ? string_type_class : array_type_class);
  case LANG_TYPE:	   return lang_type_class;
  case OPAQUE_TYPE:      return opaque_type_class;
  default:		   return no_type_class;
  }
1876}

1878/* Expand a call EXP to __builtin_classify_type.  */

1880static rtx
1881expand_builtin_classify_type (tree exp)
1882{
if (call_expr_nargs (exp)(((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
 ((exp), (tcc_vl_exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1883, __FUNCTION__))->exp.operands[0]), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1883, __FUNCTION__)))) - 3))
  return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))))gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (type_to_class (((
contains_struct_check (((*((const_cast<tree*> (tree_operand_check
 (((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1884, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1884, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 1884, __FUNCTION__))->typed.type))));
return GEN_INT (no_type_class)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (no_type_class));
1886}

1888/* This helper macro, meant to be used in mathfn_built_in below, determines
 which among a set of builtin math functions is appropriate for a given type
 mode.  The `F' (float) and `L' (long double) are automatically generated
 from the 'double' case.  If a function supports the _Float<N> and _Float<N>X
 types, there are additional types that are considered with 'F32', 'F64',
 'F128', etc. suffixes.  */
1894#define CASE_MATHFN(MATHFN) \
CASE_CFN_##MATHFN: \
fcode = BUILT_IN_##MATHFN; fcodef = BUILT_IN_##MATHFN##F ; \
fcodel = BUILT_IN_##MATHFN##L ; break;
1898/* Similar to the above, but also add support for the _Float<N> and _Float<N>X
 types.  */
1900#define CASE_MATHFN_FLOATN(MATHFN) \
CASE_CFN_##MATHFN: \
fcode = BUILT_IN_##MATHFN; fcodef = BUILT_IN_##MATHFN##F ; \
fcodel = BUILT_IN_##MATHFN##L ; fcodef16 = BUILT_IN_##MATHFN##F16 ; \
fcodef32 = BUILT_IN_##MATHFN##F32; fcodef64 = BUILT_IN_##MATHFN##F64 ; \
fcodef128 = BUILT_IN_##MATHFN##F128 ; fcodef32x = BUILT_IN_##MATHFN##F32X ; \
fcodef64x = BUILT_IN_##MATHFN##F64X ; fcodef128x = BUILT_IN_##MATHFN##F128X ;\
break;
1908/* Similar to above, but appends _R after any F/L suffix.  */
1909#define CASE_MATHFN_REENT(MATHFN) \
case CFN_BUILT_IN_##MATHFN##_R: \
case CFN_BUILT_IN_##MATHFN##F_R: \
case CFN_BUILT_IN_##MATHFN##L_R: \
fcode = BUILT_IN_##MATHFN##_R; fcodef = BUILT_IN_##MATHFN##F_R ; \
fcodel = BUILT_IN_##MATHFN##L_R ; break;

1916/* Return a function equivalent to FN but operating on floating-point
 values of type TYPE, or END_BUILTINS if no such function exists.
 This is purely an operation on function codes; it does not guarantee
 that the target actually has an implementation of the function.  */

1921static built_in_function
1922mathfn_built_in_2 (tree type, combined_fn fn)
1923{
tree mtype;
built_in_function fcode, fcodef, fcodel;
built_in_function fcodef16 = END_BUILTINS;
built_in_function fcodef32 = END_BUILTINS;
built_in_function fcodef64 = END_BUILTINS;
built_in_function fcodef128 = END_BUILTINS;
built_in_function fcodef32x = END_BUILTINS;
built_in_function fcodef64x = END_BUILTINS;
built_in_function fcodef128x = END_BUILTINS;

/* If <math.h> has been included somehow, HUGE_VAL and NAN definitions
   break the uses below.  */
1936#undef HUGE_VAL
1937#undef NAN

switch (fn)
  {
1941#define SEQ_OF_CASE_MATHFN			\
  CASE_MATHFN_FLOATN (ACOS)			\
  CASE_MATHFN_FLOATN (ACOSH)			\
  CASE_MATHFN_FLOATN (ASIN)			\
  CASE_MATHFN_FLOATN (ASINH)			\
  CASE_MATHFN_FLOATN (ATAN)			\
  CASE_MATHFN_FLOATN (ATAN2)			\
  CASE_MATHFN_FLOATN (ATANH)			\
  CASE_MATHFN_FLOATN (CBRT)			\
  CASE_MATHFN_FLOATN (CEIL)			\
  CASE_MATHFN (CEXPI)				\
  CASE_MATHFN_FLOATN (COPYSIGN)		\
  CASE_MATHFN_FLOATN (COS)			\
  CASE_MATHFN_FLOATN (COSH)			\
  CASE_MATHFN (DREM)				\
  CASE_MATHFN_FLOATN (ERF)			\
  CASE_MATHFN_FLOATN (ERFC)			\
  CASE_MATHFN_FLOATN (EXP)			\
  CASE_MATHFN (EXP10)				\
  CASE_MATHFN_FLOATN (EXP2)			\
  CASE_MATHFN_FLOATN (EXPM1)			\
  CASE_MATHFN_FLOATN (FABS)			\
  CASE_MATHFN_FLOATN (FDIM)			\
  CASE_MATHFN_FLOATN (FLOOR)			\
  CASE_MATHFN_FLOATN (FMA)			\
  CASE_MATHFN_FLOATN (FMAX)			\
  CASE_MATHFN_FLOATN (FMIN)			\
  CASE_MATHFN_FLOATN (FMOD)			\
  CASE_MATHFN_FLOATN (FREXP)			\
  CASE_MATHFN (GAMMA)				\
  CASE_MATHFN_REENT (GAMMA) /* GAMMA_R */	\
  CASE_MATHFN_FLOATN (HUGE_VAL)		\
  CASE_MATHFN_FLOATN (HYPOT)			\
  CASE_MATHFN_FLOATN (ILOGB)			\
  CASE_MATHFN (ICEIL)				\
  CASE_MATHFN (IFLOOR)			\
  CASE_MATHFN_FLOATN (INF)			\
  CASE_MATHFN (IRINT)				\
  CASE_MATHFN (IROUND)			\
  CASE_MATHFN (ISINF)				\
  CASE_MATHFN (J0)				\
  CASE_MATHFN (J1)				\
  CASE_MATHFN (JN)				\
  CASE_MATHFN (LCEIL)				\
  CASE_MATHFN_FLOATN (LDEXP)			\
  CASE_MATHFN (LFLOOR)			\
  CASE_MATHFN_FLOATN (LGAMMA)			\
  CASE_MATHFN_REENT (LGAMMA) /* LGAMMA_R */	\
  CASE_MATHFN (LLCEIL)			\
  CASE_MATHFN (LLFLOOR)			\
  CASE_MATHFN_FLOATN (LLRINT)			\
  CASE_MATHFN_FLOATN (LLROUND)		\
  CASE_MATHFN_FLOATN (LOG)			\
  CASE_MATHFN_FLOATN (LOG10)			\
  CASE_MATHFN_FLOATN (LOG1P)			\
  CASE_MATHFN_FLOATN (LOG2)			\
  CASE_MATHFN_FLOATN (LOGB)			\
  CASE_MATHFN_FLOATN (LRINT)			\
  CASE_MATHFN_FLOATN (LROUND)			\
  CASE_MATHFN_FLOATN (MODF)			\
  CASE_MATHFN_FLOATN (NAN)			\
  CASE_MATHFN_FLOATN (NANS)			\
  CASE_MATHFN_FLOATN (NEARBYINT)		\
  CASE_MATHFN_FLOATN (NEXTAFTER)		\
  CASE_MATHFN (NEXTTOWARD)			\
  CASE_MATHFN_FLOATN (POW)			\
  CASE_MATHFN (POWI)				\
  CASE_MATHFN (POW10)				\
  CASE_MATHFN_FLOATN (REMAINDER)		\
  CASE_MATHFN_FLOATN (REMQUO)			\
  CASE_MATHFN_FLOATN (RINT)			\
  CASE_MATHFN_FLOATN (ROUND)			\
  CASE_MATHFN_FLOATN (ROUNDEVEN)		\
  CASE_MATHFN (SCALB)				\
  CASE_MATHFN_FLOATN (SCALBLN)		\
  CASE_MATHFN_FLOATN (SCALBN)			\
  CASE_MATHFN (SIGNBIT)			\
  CASE_MATHFN (SIGNIFICAND)			\
  CASE_MATHFN_FLOATN (SIN)			\
  CASE_MATHFN (SINCOS)			\
  CASE_MATHFN_FLOATN (SINH)			\
  CASE_MATHFN_FLOATN (SQRT)			\
  CASE_MATHFN_FLOATN (TAN)			\
  CASE_MATHFN_FLOATN (TANH)			\
  CASE_MATHFN_FLOATN (TGAMMA)			\
  CASE_MATHFN_FLOATN (TRUNC)			\
  CASE_MATHFN (Y0)				\
  CASE_MATHFN (Y1)				\
  CASE_MATHFN (YN)

  SEQ_OF_CASE_MATHFN

  default:
    return END_BUILTINS;
  }

mtype = TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2037, __FUNCTION__))->type_common.main_variant);
if (mtype == double_type_nodeglobal_trees[TI_DOUBLE_TYPE])
  return fcode;
else if (mtype == float_type_nodeglobal_trees[TI_FLOAT_TYPE])
  return fcodef;
else if (mtype == long_double_type_nodeglobal_trees[TI_LONG_DOUBLE_TYPE])
  return fcodel;
else if (mtype == float16_type_nodeglobal_trees[TI_FLOAT16_TYPE])
  return fcodef16;
else if (mtype == float32_type_nodeglobal_trees[TI_FLOAT32_TYPE])
  return fcodef32;
else if (mtype == float64_type_nodeglobal_trees[TI_FLOAT64_TYPE])
  return fcodef64;
else if (mtype == float128_type_nodeglobal_trees[TI_FLOAT128_TYPE])
  return fcodef128;
else if (mtype == float32x_type_nodeglobal_trees[TI_FLOAT32X_TYPE])
  return fcodef32x;
else if (mtype == float64x_type_nodeglobal_trees[TI_FLOAT64X_TYPE])
  return fcodef64x;
else if (mtype == float128x_type_nodeglobal_trees[TI_FLOAT128X_TYPE])
  return fcodef128x;
else
  return END_BUILTINS;
2060}

2062#undef CASE_MATHFN
2063#undef CASE_MATHFN_FLOATN
2064#undef CASE_MATHFN_REENT

2066/* Return mathematic function equivalent to FN but operating directly on TYPE,
 if available.  If IMPLICIT_P is true use the implicit builtin declaration,
 otherwise use the explicit declaration.  If we can't do the conversion,
 return null.  */

2071static tree
2072mathfn_built_in_1 (tree type, combined_fn fn, bool implicit_p)
2073{
built_in_function fcode2 = mathfn_built_in_2 (type, fn);
if (fcode2 == END_BUILTINS)
  return NULL_TREE(tree) __null;

if (implicit_p && !builtin_decl_implicit_p (fcode2))
  return NULL_TREE(tree) __null;

return builtin_decl_explicit (fcode2);
2082}

2084/* Like mathfn_built_in_1, but always use the implicit array.  */

2086tree
2087mathfn_built_in (tree type, combined_fn fn)
2088{
return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
2090}

2092/* Like mathfn_built_in_1, but always use the explicit array.  */

2094tree
2095mathfn_built_in_explicit (tree type, combined_fn fn)
2096{
return mathfn_built_in_1 (type, fn, /*implicit=*/ 0);
2098}

2100/* Like mathfn_built_in_1, but take a built_in_function and
 always use the implicit array.  */

2103tree
2104mathfn_built_in (tree type, enum built_in_function fn)
2105{
return mathfn_built_in_1 (type, as_combined_fn (fn), /*implicit=*/ 1);
2107}

2109/* Return the type associated with a built in function, i.e., the one
 to be passed to mathfn_built_in to get the type-specific
 function.  */

2113tree
2114mathfn_built_in_type (combined_fn fn)
2115{
2116#define CASE_MATHFN(MATHFN)			\
case CFN_BUILT_IN_##MATHFN:			\
  return double_type_nodeglobal_trees[TI_DOUBLE_TYPE];			\
case CFN_BUILT_IN_##MATHFN##F:		\
  return float_type_nodeglobal_trees[TI_FLOAT_TYPE];			\
case CFN_BUILT_IN_##MATHFN##L:		\
  return long_double_type_nodeglobal_trees[TI_LONG_DOUBLE_TYPE];

2124#define CASE_MATHFN_FLOATN(MATHFN)		\
CASE_MATHFN(MATHFN)				\
case CFN_BUILT_IN_##MATHFN##F16:		\
  return float16_type_nodeglobal_trees[TI_FLOAT16_TYPE];			\
case CFN_BUILT_IN_##MATHFN##F32:		\
  return float32_type_nodeglobal_trees[TI_FLOAT32_TYPE];			\
case CFN_BUILT_IN_##MATHFN##F64:		\
  return float64_type_nodeglobal_trees[TI_FLOAT64_TYPE];			\
case CFN_BUILT_IN_##MATHFN##F128:		\
  return float128_type_nodeglobal_trees[TI_FLOAT128_TYPE];			\
case CFN_BUILT_IN_##MATHFN##F32X:		\
  return float32x_type_nodeglobal_trees[TI_FLOAT32X_TYPE];			\
case CFN_BUILT_IN_##MATHFN##F64X:		\
  return float64x_type_nodeglobal_trees[TI_FLOAT64X_TYPE];			\
case CFN_BUILT_IN_##MATHFN##F128X:		\
  return float128x_type_nodeglobal_trees[TI_FLOAT128X_TYPE];

2141/* Similar to above, but appends _R after any F/L suffix.  */
2142#define CASE_MATHFN_REENT(MATHFN) \
case CFN_BUILT_IN_##MATHFN##_R:		\
  return double_type_nodeglobal_trees[TI_DOUBLE_TYPE];			\
case CFN_BUILT_IN_##MATHFN##F_R:		\
  return float_type_nodeglobal_trees[TI_FLOAT_TYPE];			\
case CFN_BUILT_IN_##MATHFN##L_R:		\
  return long_double_type_nodeglobal_trees[TI_LONG_DOUBLE_TYPE];

switch (fn)
  {
  SEQ_OF_CASE_MATHFN

  default:
    return NULL_TREE(tree) __null;
  }

2158#undef CASE_MATHFN
2159#undef CASE_MATHFN_FLOATN
2160#undef CASE_MATHFN_REENT
2161#undef SEQ_OF_CASE_MATHFN
2162}

2164/* Check whether there is an internal function associated with function FN
 and return type RETURN_TYPE.  Return the function if so, otherwise return
 IFN_LAST.

 Note that this function only tests whether the function is defined in
 internals.def, not whether it is actually available on the target.  */

2171static internal_fn
2172associated_internal_fn (built_in_function fn, tree return_type)
2173{
switch (fn)
  {
2176#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE) \
  CASE_FLT_FN (BUILT_IN_##NAME)case BUILT_IN_##NAME: case BUILT_IN_##NAMEF: case BUILT_IN_##
NAMEL: return IFN_##NAME;
2178#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE) \
  CASE_FLT_FN (BUILT_IN_##NAME)case BUILT_IN_##NAME: case BUILT_IN_##NAMEF: case BUILT_IN_##
NAMEL: return IFN_##NAME; \
  CASE_FLT_FN_FLOATN_NX (BUILT_IN_##NAME)case BUILT_IN_##NAMEF16: case BUILT_IN_##NAMEF32: case BUILT_IN_
##NAMEF64: case BUILT_IN_##NAMEF128: case BUILT_IN_##NAMEF32X
: case BUILT_IN_##NAMEF64X: case BUILT_IN_##NAMEF128X: return IFN_##NAME;
2181#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE) \
  CASE_INT_FN (BUILT_IN_##NAME)case BUILT_IN_##NAME: case BUILT_IN_##NAMEL: case BUILT_IN_##
NAMELL: case BUILT_IN_##NAMEIMAX: return IFN_##NAME;
2183#include "internal-fn.def"

  CASE_FLT_FN (BUILT_IN_POW10)case BUILT_IN_POW10: case BUILT_IN_POW10F: case BUILT_IN_POW10L:
    return IFN_EXP10;

  CASE_FLT_FN (BUILT_IN_DREM)case BUILT_IN_DREM: case BUILT_IN_DREMF: case BUILT_IN_DREML:
    return IFN_REMAINDER;

  CASE_FLT_FN (BUILT_IN_SCALBN)case BUILT_IN_SCALBN: case BUILT_IN_SCALBNF: case BUILT_IN_SCALBNL:
  CASE_FLT_FN (BUILT_IN_SCALBLN)case BUILT_IN_SCALBLN: case BUILT_IN_SCALBLNF: case BUILT_IN_SCALBLNL:
    if (REAL_MODE_FORMAT (TYPE_MODE (return_type))(real_format_for_mode[(((enum mode_class) mode_class[((((enum
 tree_code) ((tree_class_check ((return_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2193, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (return_type) : (return_type)->type_common.mode)]) == MODE_DECIMAL_FLOAT
) ? (((((((enum tree_code) ((tree_class_check ((return_type),
 (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2193, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (return_type) : (return_type)->type_common.mode)) - MIN_MODE_DECIMAL_FLOAT
) + (MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) : ((enum mode_class
) mode_class[((((enum tree_code) ((tree_class_check ((return_type
), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2193, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (return_type) : (return_type)->type_common.mode)]) == MODE_FLOAT
 ? ((((((enum tree_code) ((tree_class_check ((return_type), (
tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2193, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (return_type) : (return_type)->type_common.mode)) - MIN_MODE_FLOAT
) : ((fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2193, __FUNCTION__)), 0)])->b == 2)
return IFN_LDEXP;
    return IFN_LAST;

  default:
    return IFN_LAST;
  }
2200}

2202/* If BUILT_IN_NORMAL function FNDECL has an associated internal function,
 return its code, otherwise return IFN_LAST.  Note that this function
 only tests whether the function is defined in internals.def, not whether
 it is actually available on the target.  */

2207internal_fn
2208associated_internal_fn (tree fndecl)
2209{
gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)((void)(!(((built_in_class) (tree_check ((fndecl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2210, __FUNCTION__, (FUNCTION_DECL)))->function_decl.built_in_class
) == BUILT_IN_NORMAL) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2210, __FUNCTION__), 0 : 0));
return associated_internal_fn (DECL_FUNCTION_CODE (fndecl),
		 TREE_TYPE (TREE_TYPE (fndecl))((contains_struct_check ((((contains_struct_check ((fndecl), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2212, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2212, __FUNCTION__))->typed.type));
2213}

2215/* Check whether there is an internal function associated with function CFN
 and return type RETURN_TYPE.  Return the function if so, otherwise return
 IFN_LAST.

 Note that this function only tests whether the function is defined in
 internals.def, not whether it is actually available on the target.  */

2222internal_fn
2223associated_internal_fn (combined_fn cfn, tree return_type)
2224{
if (internal_fn_p (cfn))
  return as_internal_fn (cfn);
return associated_internal_fn (as_builtin_fn (cfn), return_type);
2228}

2230/* If CALL is a call to a BUILT_IN_NORMAL function that could be replaced
 on the current target by a call to an internal function, return the
 code of that internal function, otherwise return IFN_LAST.  The caller
 is responsible for ensuring that any side-effects of the built-in
 call are dealt with correctly.  E.g. if CALL sets errno, the caller
 must decide that the errno result isn't needed or make it available
 in some other way.  */

2238internal_fn
2239replacement_internal_fn (gcall *call)
2240{
if (gimple_call_builtin_p (call, BUILT_IN_NORMAL))
  {
    internal_fn ifn = associated_internal_fn (gimple_call_fndecl (call));
    if (ifn != IFN_LAST)
{
 tree_pair types = direct_internal_fn_types (ifn, call);
 optimization_type opt_type = bb_optimization_type (gimple_bb (call));
 if (direct_internal_fn_supported_p (ifn, types, opt_type))
   return ifn;
}
  }
return IFN_LAST;
2253}

2255/* Expand a call to the builtin trinary math functions (fma).
 Return NULL_RTX if a normal call should be emitted rather than expanding the
 function in-line.  EXP is the expression that is a call to the builtin
 function; if convenient, the result should be placed in TARGET.
 SUBTARGET may be used as the target for computing one of EXP's
 operands.  */

2262static rtx
2263expand_builtin_mathfn_ternary (tree exp, rtx target, rtx subtarget)
2264{
optab builtin_optab;
rtx op0, op1, op2, result;
rtx_insn *insns;
tree fndecl = get_callee_fndecl (exp);
tree arg0, arg1, arg2;
machine_mode mode;

if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, REAL_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

arg0 = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2275, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2275, __FUNCTION__)))));
arg1 = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2276, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2276, __FUNCTION__)))));
arg2 = CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2277, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2277, __FUNCTION__)))));

switch (DECL_FUNCTION_CODE (fndecl))
  {
  CASE_FLT_FN (BUILT_IN_FMA)case BUILT_IN_FMA: case BUILT_IN_FMAF: case BUILT_IN_FMAL:
  CASE_FLT_FN_FLOATN_NX (BUILT_IN_FMA)case BUILT_IN_FMAF16: case BUILT_IN_FMAF32: case BUILT_IN_FMAF64
: case BUILT_IN_FMAF128: case BUILT_IN_FMAF32X: case BUILT_IN_FMAF64X
: case BUILT_IN_FMAF128X:
    builtin_optab = fma_optab; break;
  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2285, __FUNCTION__));
  }

/* Make a suitable register to place result in.  */
mode = TYPE_MODE (TREE_TYPE (exp))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2289, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2289, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2289, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2289, __FUNCTION__))->typed.type))->type_common.mode);

/* Before working hard, check whether the instruction is available.  */
if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
  return NULL_RTX(rtx) 0;

result = gen_reg_rtx (mode);

/* Always stabilize the argument list.  */
CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2298, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2298, __FUNCTION__))))) = arg0 = builtin_save_expr (arg0);
CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2299, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2299, __FUNCTION__))))) = arg1 = builtin_save_expr (arg1);
CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2300, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2300, __FUNCTION__))))) = arg2 = builtin_save_expr (arg2);

op0 = expand_expr (arg0, subtarget, VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);
op1 = expand_normal (arg1);
op2 = expand_normal (arg2);

start_sequence ();

/* Compute into RESULT.
   Set RESULT to wherever the result comes back.  */
result = expand_ternary_op (mode, builtin_optab, op0, op1, op2,
	      result, 0);

/* If we were unable to expand via the builtin, stop the sequence
   (without outputting the insns) and call to the library function
   with the stabilized argument list.  */
if (result == 0)
  {
    end_sequence ();
    return expand_call (exp, target, target == const0_rtx(const_int_rtx[64]));
  }

/* Output the entire sequence.  */
insns = get_insns ();
end_sequence ();
emit_insn (insns);

return result;
2328}

2330/* Expand a call to the builtin sin and cos math functions.
 Return NULL_RTX if a normal call should be emitted rather than expanding the
 function in-line.  EXP is the expression that is a call to the builtin
 function; if convenient, the result should be placed in TARGET.
 SUBTARGET may be used as the target for computing one of EXP's
 operands.  */

2337static rtx
2338expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2339{
optab builtin_optab;
rtx op0;
rtx_insn *insns;
tree fndecl = get_callee_fndecl (exp);
machine_mode mode;
tree arg;

if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

arg = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2350, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2350, __FUNCTION__)))));

switch (DECL_FUNCTION_CODE (fndecl))
  {
  CASE_FLT_FN (BUILT_IN_SIN)case BUILT_IN_SIN: case BUILT_IN_SINF: case BUILT_IN_SINL:
  CASE_FLT_FN (BUILT_IN_COS)case BUILT_IN_COS: case BUILT_IN_COSF: case BUILT_IN_COSL:
    builtin_optab = sincos_optab; break;
  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2358, __FUNCTION__));
  }

/* Make a suitable register to place result in.  */
mode = TYPE_MODE (TREE_TYPE (exp))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2362, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2362, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2362, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2362, __FUNCTION__))->typed.type))->type_common.mode);

/* Check if sincos insn is available, otherwise fallback
   to sin or cos insn.  */
if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
  switch (DECL_FUNCTION_CODE (fndecl))
    {
    CASE_FLT_FN (BUILT_IN_SIN)case BUILT_IN_SIN: case BUILT_IN_SINF: case BUILT_IN_SINL:
builtin_optab = sin_optab; break;
    CASE_FLT_FN (BUILT_IN_COS)case BUILT_IN_COS: case BUILT_IN_COSF: case BUILT_IN_COSL:
builtin_optab = cos_optab; break;
    default:
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2374, __FUNCTION__));
    }

/* Before working hard, check whether the instruction is available.  */
if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
  {
    rtx result = gen_reg_rtx (mode);

    /* Wrap the computation of the argument in a SAVE_EXPR, as we may
need to expand the argument again.  This way, we will not perform
side-effects more the once.  */
    CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2385, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2385, __FUNCTION__))))) = arg = builtin_save_expr (arg);

    op0 = expand_expr (arg, subtarget, VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);

    start_sequence ();

    /* Compute into RESULT.
Set RESULT to wherever the result comes back.  */
    if (builtin_optab == sincos_optab)
{
 int ok;

 switch (DECL_FUNCTION_CODE (fndecl))
   {
   CASE_FLT_FN (BUILT_IN_SIN)case BUILT_IN_SIN: case BUILT_IN_SINF: case BUILT_IN_SINL:
     ok = expand_twoval_unop (builtin_optab, op0, 0, result, 0);
     break;
   CASE_FLT_FN (BUILT_IN_COS)case BUILT_IN_COS: case BUILT_IN_COSF: case BUILT_IN_COSL:
     ok = expand_twoval_unop (builtin_optab, op0, result, 0, 0);
     break;
   default:
     gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2406, __FUNCTION__));
   }
 gcc_assert (ok)((void)(!(ok) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2408, __FUNCTION__), 0 : 0));
}
    else
result = expand_unop (mode, builtin_optab, op0, result, 0);

    if (result != 0)
{
 /* Output the entire sequence.  */
 insns = get_insns ();
 end_sequence ();
 emit_insn (insns);
 return result;
}

    /* If we were unable to expand via the builtin, stop the sequence
(without outputting the insns) and call to the library function
with the stabilized argument list.  */
    end_sequence ();
  }

return expand_call (exp, target, target == const0_rtx(const_int_rtx[64]));
2429}

2431/* Given an interclass math builtin decl FNDECL and it's argument ARG
 return an RTL instruction code that implements the functionality.
 If that isn't possible or available return CODE_FOR_nothing.  */

2435static enum insn_code
2436interclass_mathfn_icode (tree arg, tree fndecl)
2437{
bool errno_set = false;
optab builtin_optab = unknown_optab;
machine_mode mode;

switch (DECL_FUNCTION_CODE (fndecl))
  {
  CASE_FLT_FN (BUILT_IN_ILOGB)case BUILT_IN_ILOGB: case BUILT_IN_ILOGBF: case BUILT_IN_ILOGBL:
    errno_set = true; builtin_optab = ilogb_optab; break;
  CASE_FLT_FN (BUILT_IN_ISINF)case BUILT_IN_ISINF: case BUILT_IN_ISINFF: case BUILT_IN_ISINFL:
    builtin_optab = isinf_optab; break;
  case BUILT_IN_ISNORMAL:
  case BUILT_IN_ISFINITE:
  CASE_FLT_FN (BUILT_IN_FINITE)case BUILT_IN_FINITE: case BUILT_IN_FINITEF: case BUILT_IN_FINITEL:
  case BUILT_IN_FINITED32:
  case BUILT_IN_FINITED64:
  case BUILT_IN_FINITED128:
  case BUILT_IN_ISINFD32:
  case BUILT_IN_ISINFD64:
  case BUILT_IN_ISINFD128:
    /* These builtins have no optabs (yet).  */
    break;
  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2460, __FUNCTION__));
  }

/* There's no easy way to detect the case we need to set EDOM.  */
if (flag_errno_mathglobal_options.x_flag_errno_math && errno_set)
  return CODE_FOR_nothing;

/* Optab mode depends on the mode of the input argument.  */
mode = TYPE_MODE (TREE_TYPE (arg))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2468, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2468, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2468, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2468, __FUNCTION__))->typed.type))->type_common.mode);

if (builtin_optab)
  return optab_handler (builtin_optab, mode);
return CODE_FOR_nothing;
2473}

2475/* Expand a call to one of the builtin math functions that operate on
 floating point argument and output an integer result (ilogb, isinf,
 isnan, etc).
 Return 0 if a normal call should be emitted rather than expanding the
 function in-line.  EXP is the expression that is a call to the builtin
 function; if convenient, the result should be placed in TARGET.  */

2482static rtx
2483expand_builtin_interclass_mathfn (tree exp, rtx target)
2484{
enum insn_code icode = CODE_FOR_nothing;
rtx op0;
tree fndecl = get_callee_fndecl (exp);
machine_mode mode;
tree arg;

if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

arg = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2494, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2494, __FUNCTION__)))));
icode = interclass_mathfn_icode (arg, fndecl);
mode = TYPE_MODE (TREE_TYPE (arg))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2496, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2496, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2496, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2496, __FUNCTION__))->typed.type))->type_common.mode);

if (icode != CODE_FOR_nothing)
  {
    class expand_operand ops[1];
    rtx_insn *last = get_last_insn ();
    tree orig_arg = arg;

    /* Wrap the computation of the argument in a SAVE_EXPR, as we may
need to expand the argument again.  This way, we will not perform
side-effects more the once.  */
    CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2507, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2507, __FUNCTION__))))) = arg = builtin_save_expr (arg);

    op0 = expand_expr (arg, NULL_RTX(rtx) 0, VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);

    if (mode != GET_MODE (op0)((machine_mode) (op0)->mode))
op0 = convert_to_mode (mode, op0, 0);

    create_output_operand (&ops[0], target, TYPE_MODE (TREE_TYPE (exp))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2514, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2514, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2514, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2514, __FUNCTION__))->typed.type))->type_common.mode));
    if (maybe_legitimize_operands (icode, 0, 1, ops)
 && maybe_emit_unop_insn (icode, ops[0].value, op0, UNKNOWN))
return ops[0].value;

    delete_insns_since (last);
    CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2520, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2520, __FUNCTION__))))) = orig_arg;
  }

return NULL_RTX(rtx) 0;
2524}

2526/* Expand a call to the builtin sincos math function.
 Return NULL_RTX if a normal call should be emitted rather than expanding the
 function in-line.  EXP is the expression that is a call to the builtin
 function.  */

2531static rtx
2532expand_builtin_sincos (tree exp)
2533{
rtx op0, op1, op2, target1, target2;
machine_mode mode;
tree arg, sinp, cosp;
int result;
location_t loc = EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0));
tree alias_type, alias_off;

if (!validate_arglist (exp, REAL_TYPE,
		 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

arg = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2545, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2545, __FUNCTION__)))));
sinp = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2546, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2546, __FUNCTION__)))));
cosp = CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2547, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2547, __FUNCTION__)))));

/* Make a suitable register to place result in.  */
mode = TYPE_MODE (TREE_TYPE (arg))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2550, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2550, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2550, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2550, __FUNCTION__))->typed.type))->type_common.mode);

/* Check if sincos insn is available, otherwise emit the call.  */
if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
  return NULL_RTX(rtx) 0;

target1 = gen_reg_rtx (mode);
target2 = gen_reg_rtx (mode);

op0 = expand_normal (arg);
alias_type = build_pointer_type_for_mode (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2560, __FUNCTION__))->typed.type), ptr_mode, true);
alias_off = build_int_cst (alias_type, 0);
op1 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2562, __FUNCTION__))->typed.type),
			sinp, alias_off));
op2 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2564, __FUNCTION__))->typed.type),
			cosp, alias_off));

/* Compute into target1 and target2.
   Set TARGET to wherever the result comes back.  */
result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
gcc_assert (result)((void)(!(result) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2570, __FUNCTION__), 0 : 0));

/* Move target1 and target2 to the memory locations indicated
   by op1 and op2.  */
emit_move_insn (op1, target1);
emit_move_insn (op2, target2);

return const0_rtx(const_int_rtx[64]);
2578}

2580/* Expand call EXP to the fegetround builtin (from C99 fenv.h), returning the
 result and setting it in TARGET.  Otherwise return NULL_RTX on failure.  */
2582static rtx
2583expand_builtin_fegetround (tree exp, rtx target, machine_mode target_mode)
2584{
if (!validate_arglist (exp, VOID_TYPE))
  return NULL_RTX(rtx) 0;

insn_code icode = direct_optab_handler (fegetround_optab, SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode)));
if (icode == CODE_FOR_nothing)
  return NULL_RTX(rtx) 0;

if (target == 0
    || GET_MODE (target)((machine_mode) (target)->mode) != target_mode
    || !(*insn_data[icode].operand[0].predicate) (target, target_mode))
  target = gen_reg_rtx (target_mode);

rtx pat = GEN_FCN (icode)(insn_data[icode].genfun) (target);
if (!pat)
  return NULL_RTX(rtx) 0;
emit_insn (pat);

return target;
2603}

2605/* Expand call EXP to either feclearexcept or feraiseexcept builtins (from C99
 fenv.h), returning the result and setting it in TARGET.  Otherwise return
 NULL_RTX on failure.  */
2608static rtx
2609expand_builtin_feclear_feraise_except (tree exp, rtx target,
		       machine_mode target_mode, optab op_optab)
2611{
if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;
rtx op0 = expand_normal (CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2614, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2614, __FUNCTION__))))));

insn_code icode = direct_optab_handler (op_optab, SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode)));
if (icode == CODE_FOR_nothing)
  return NULL_RTX(rtx) 0;

if (!(*insn_data[icode].operand[1].predicate) (op0, GET_MODE (op0)((machine_mode) (op0)->mode)))
  return NULL_RTX(rtx) 0;

if (target == 0
    || GET_MODE (target)((machine_mode) (target)->mode) != target_mode
    || !(*insn_data[icode].operand[0].predicate) (target, target_mode))
  target = gen_reg_rtx (target_mode);

rtx pat = GEN_FCN (icode)(insn_data[icode].genfun) (target, op0);
if (!pat)
  return NULL_RTX(rtx) 0;
emit_insn (pat);

return target;
2634}

2636/* Expand a call to the internal cexpi builtin to the sincos math function.
 EXP is the expression that is a call to the builtin function; if convenient,
 the result should be placed in TARGET.  */

2640static rtx
2641expand_builtin_cexpi (tree exp, rtx target)
2642{
tree fndecl = get_callee_fndecl (exp);
tree arg, type;
machine_mode mode;
rtx op0, op1, op2;
location_t loc = EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0));

if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

arg = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2652, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2652, __FUNCTION__)))));
type = TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2653, __FUNCTION__))->typed.type);
mode = TYPE_MODE (TREE_TYPE (arg))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2654, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2654, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2654, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2654, __FUNCTION__))->typed.type))->type_common.mode);

/* Try expanding via a sincos optab, fall back to emitting a libcall
   to sincos or cexp.  We are sure we have sincos or cexp because cexpi
   is only generated from sincos, cexp or if we have either of them.  */
if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
  {
    op1 = gen_reg_rtx (mode);
    op2 = gen_reg_rtx (mode);

    op0 = expand_expr (arg, NULL_RTX(rtx) 0, VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);

    /* Compute into op1 and op2.  */
    expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
  }
else if (targetm.libc_has_function (function_sincos, type))
  {
    tree call, fn = NULL_TREE(tree) __null;
    tree top1, top2;
    rtx op1a, op2a;

    if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
fn = builtin_decl_explicit (BUILT_IN_SINCOSF);
    else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
fn = builtin_decl_explicit (BUILT_IN_SINCOS);
    else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
fn = builtin_decl_explicit (BUILT_IN_SINCOSL);
    else
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2682, __FUNCTION__));

    op1 = assign_temp (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2684, __FUNCTION__))->typed.type), 1, 1);
    op2 = assign_temp (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2685, __FUNCTION__))->typed.type), 1, 1);
    op1a = copy_addr_to_reg (XEXP (op1, 0)(((op1)->u.fld[0]).rt_rtx));
    op2a = copy_addr_to_reg (XEXP (op2, 0)(((op2)->u.fld[0]).rt_rtx));
    top1 = make_tree (build_pointer_type (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2688, __FUNCTION__))->typed.type)), op1a);
    top2 = make_tree (build_pointer_type (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2689, __FUNCTION__))->typed.type)), op2a);

    /* Make sure not to fold the sincos call again.  */
    call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)((contains_struct_check ((fn), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2692, __FUNCTION__))->typed.type)), fn);
    expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn))((contains_struct_check ((((contains_struct_check ((fn), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2693, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2693, __FUNCTION__))->typed.type),
		      call, 3, arg, top1, top2));
  }
else
  {
    tree call, fn = NULL_TREE(tree) __null, narg;
    tree ctype = build_complex_type (type);

    if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
fn = builtin_decl_explicit (BUILT_IN_CEXPF);
    else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
fn = builtin_decl_explicit (BUILT_IN_CEXP);
    else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
fn = builtin_decl_explicit (BUILT_IN_CEXPL);
    else
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2708, __FUNCTION__));

    /* If we don't have a decl for cexp create one.  This is the
friendliest fallback if the user calls __builtin_cexpi
without full target C99 function support.  */
    if (fn == NULL_TREE(tree) __null)
{
 tree fntype;
 const char *name = NULL__null;

 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
   name = "cexpf";
 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
   name = "cexp";
 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
   name = "cexpl";

 fntype = build_function_type_list (ctype, ctype, NULL_TREE(tree) __null);
 fn = build_fn_decl (name, fntype);
}

    narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
	  build_real (type, dconst0), arg);

    /* Make sure not to fold the cexp call again.  */
    call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)((contains_struct_check ((fn), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2733, __FUNCTION__))->typed.type)), fn);
    return expand_expr (build_call_nary (ctype, call, 1, narg),
	  target, VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);
  }

/* Now build the proper return type.  */
return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
	      make_tree (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2740, __FUNCTION__))->typed.type), op2),
	      make_tree (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2741, __FUNCTION__))->typed.type), op1)),
      target, VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);
2743}

2745/* Conveniently construct a function call expression.  FNDECL names the
 function to be called, N is the number of arguments, and the "..."
 parameters are the argument expressions.  Unlike build_call_exr
 this doesn't fold the call, hence it will always return a CALL_EXPR.  */

2750static tree
2751build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2752{
va_list ap;
tree fntype = TREE_TYPE (fndecl)((contains_struct_check ((fndecl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2754, __FUNCTION__))->typed.type);
tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);

va_start (ap, n)__builtin_va_start(ap, n);
fn = build_call_valist (TREE_TYPE (fntype)((contains_struct_check ((fntype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2758, __FUNCTION__))->typed.type), fn, n, ap);
va_end (ap)__builtin_va_end(ap);
SET_EXPR_LOCATION (fn, loc)(expr_check (((fn)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2760, __FUNCTION__))->exp.locus = (loc);
return fn;
2762}

2764/* Expand the __builtin_issignaling builtin.  This needs to handle
 all floating point formats that do support NaNs (for those that
 don't it just sets target to 0).  */

2768static rtx
2769expand_builtin_issignaling (tree exp, rtx target)
2770{
if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

tree arg = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2774, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2774, __FUNCTION__)))));
scalar_float_mode fmode = SCALAR_FLOAT_TYPE_MODE (TREE_TYPE (arg))(as_a <scalar_float_mode> ((tree_class_check ((((contains_struct_check
 ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2775, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2775, __FUNCTION__))->type_common.mode));
const struct real_format *fmt = REAL_MODE_FORMAT (fmode)(real_format_for_mode[(((enum mode_class) mode_class[fmode]) ==
 MODE_DECIMAL_FLOAT) ? (((fmode) - MIN_MODE_DECIMAL_FLOAT) + (
MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) : ((enum mode_class) mode_class
[fmode]) == MODE_FLOAT ? ((fmode) - MIN_MODE_FLOAT) : ((fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2776, __FUNCTION__)), 0)]);

/* Expand the argument yielding a RTX expression. */
rtx temp = expand_normal (arg);

/* If mode doesn't support NaN, always return 0.
   Don't use !HONOR_SNANS (fmode) here, so there is some possibility of
   __builtin_issignaling working without -fsignaling-nans.  Especially
   when -fno-signaling-nans is the default.
   On the other side, MODE_HAS_NANS (fmode) is unnecessary, with
   -ffinite-math-only even __builtin_isnan or __builtin_fpclassify
   fold to 0 or non-NaN/Inf classification.  */
if (!HONOR_NANS (fmode))
  {
    emit_move_insn (target, const0_rtx(const_int_rtx[64]));
    return target;
  }

/* Check if the back end provides an insn that handles issignaling for the
   argument's mode. */
enum insn_code icode = optab_handler (issignaling_optab, fmode);
if (icode != CODE_FOR_nothing)
  {
    rtx_insn *last = get_last_insn ();
    rtx this_target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2800, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2800, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2800, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2800, __FUNCTION__))->typed.type))->type_common.mode));
    if (maybe_emit_unop_insn (icode, this_target, temp, UNKNOWN))
return this_target;
    delete_insns_since (last);
  }

if (DECIMAL_FLOAT_MODE_P (fmode)(((enum mode_class) mode_class[fmode]) == MODE_DECIMAL_FLOAT))
  {
    scalar_int_mode imode;
    rtx hi;
    switch (fmt->ieee_bits)
{
case 32:
case 64:
 imode = int_mode_for_mode (fmode).require ();
 temp = gen_lowpartrtl_hooks.gen_lowpart (imode, temp);
 break;
case 128:
 imode = int_mode_for_size (64, 1).require ();
 hi = NULL_RTX(rtx) 0;
 /* For decimal128, TImode support isn't always there and even when
    it is, working on the DImode high part is usually better.  */
 if (!MEM_P (temp)(((enum rtx_code) (temp)->code) == MEM))
   {
     if (rtx t = simplify_gen_subreg (imode, temp, fmode,
			       subreg_highpart_offset (imode,
						       fmode)))
hi = t;
     else
{
  scalar_int_mode imode2;
  if (int_mode_for_mode (fmode).exists (&imode2))
    {
      rtx temp2 = gen_lowpartrtl_hooks.gen_lowpart (imode2, temp);
      poly_uint64 off = subreg_highpart_offset (imode, imode2);
      if (rtx t = simplify_gen_subreg (imode, temp2,
				       imode2, off))
	hi = t;
    }
}
     if (!hi)
{
  rtx mem = assign_stack_temp (fmode, GET_MODE_SIZE (fmode));
  emit_move_insn (mem, temp);
  temp = mem;
}
   }
 if (!hi)
   {
     poly_int64 offset
= subreg_highpart_offset (imode, GET_MODE (temp)((machine_mode) (temp)->mode));
     hi = adjust_address (temp, imode, offset)adjust_address_1 (temp, imode, offset, 1, 1, 0, 0);
   }
 temp = hi;
 break;
default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2856, __FUNCTION__));
}
    /* In all of decimal{32,64,128}, there is MSB sign bit and sNaN
have 6 bits below it all set.  */
    rtx val
= GEN_INT (HOST_WIDE_INT_C (0x3f) << (GET_MODE_BITSIZE (imode) - 7))gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (0x3fL << (GET_MODE_BITSIZE
 (imode) - 7)));
    temp = expand_binop (imode, and_optab, temp, val,
	   NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
    temp = emit_store_flag_force (target, EQ, temp, val, imode, 1, 1);
    return temp;
  }

/* Only PDP11 has these defined differently but doesn't support NaNs.  */
gcc_assert (FLOAT_WORDS_BIG_ENDIAN == WORDS_BIG_ENDIAN)((void)(!(0 == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2869, __FUNCTION__), 0 : 0));
gcc_assert (fmt->signbit_ro > 0 && fmt->b == 2)((void)(!(fmt->signbit_ro > 0 && fmt->b == 2
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2870, __FUNCTION__), 0 : 0));
gcc_assert (MODE_COMPOSITE_P (fmode)((void)(!(((((enum mode_class) mode_class[fmode]) == MODE_FLOAT
 || ((enum mode_class) mode_class[fmode]) == MODE_DECIMAL_FLOAT
 || ((enum mode_class) mode_class[fmode]) == MODE_COMPLEX_FLOAT
 || ((enum mode_class) mode_class[fmode]) == MODE_VECTOR_FLOAT
) && ((real_format_for_mode[(((enum mode_class) mode_class
[as_a <scalar_float_mode> ((mode_to_inner (fmode)))]) ==
 MODE_DECIMAL_FLOAT) ? (((as_a <scalar_float_mode> ((mode_to_inner
 (fmode)))) - MIN_MODE_DECIMAL_FLOAT) + (MAX_MODE_FLOAT - MIN_MODE_FLOAT
 + 1)) : ((enum mode_class) mode_class[as_a <scalar_float_mode
> ((mode_to_inner (fmode)))]) == MODE_FLOAT ? ((as_a <scalar_float_mode
> ((mode_to_inner (fmode)))) - MIN_MODE_FLOAT) : ((fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2871, __FUNCTION__)), 0)]))->pnan < ((real_format_for_mode
[(((enum mode_class) mode_class[as_a <scalar_float_mode>
 ((mode_to_inner (fmode)))]) == MODE_DECIMAL_FLOAT) ? (((as_a
 <scalar_float_mode> ((mode_to_inner (fmode)))) - MIN_MODE_DECIMAL_FLOAT
) + (MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) : ((enum mode_class
) mode_class[as_a <scalar_float_mode> ((mode_to_inner (
fmode)))]) == MODE_FLOAT ? ((as_a <scalar_float_mode> (
(mode_to_inner (fmode)))) - MIN_MODE_FLOAT) : ((fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2871, __FUNCTION__)), 0)]))->p) || (fmt->pnan == fmt->
p && fmt->signbit_ro == fmt->signbit_rw)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2873, __FUNCTION__), 0 : 0))
     || (fmt->pnan == fmt->p((void)(!(((((enum mode_class) mode_class[fmode]) == MODE_FLOAT
 || ((enum mode_class) mode_class[fmode]) == MODE_DECIMAL_FLOAT
 || ((enum mode_class) mode_class[fmode]) == MODE_COMPLEX_FLOAT
 || ((enum mode_class) mode_class[fmode]) == MODE_VECTOR_FLOAT
) && ((real_format_for_mode[(((enum mode_class) mode_class
[as_a <scalar_float_mode> ((mode_to_inner (fmode)))]) ==
 MODE_DECIMAL_FLOAT) ? (((as_a <scalar_float_mode> ((mode_to_inner
 (fmode)))) - MIN_MODE_DECIMAL_FLOAT) + (MAX_MODE_FLOAT - MIN_MODE_FLOAT
 + 1)) : ((enum mode_class) mode_class[as_a <scalar_float_mode
> ((mode_to_inner (fmode)))]) == MODE_FLOAT ? ((as_a <scalar_float_mode
> ((mode_to_inner (fmode)))) - MIN_MODE_FLOAT) : ((fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2871, __FUNCTION__)), 0)]))->pnan < ((real_format_for_mode
[(((enum mode_class) mode_class[as_a <scalar_float_mode>
 ((mode_to_inner (fmode)))]) == MODE_DECIMAL_FLOAT) ? (((as_a
 <scalar_float_mode> ((mode_to_inner (fmode)))) - MIN_MODE_DECIMAL_FLOAT
) + (MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) : ((enum mode_class
) mode_class[as_a <scalar_float_mode> ((mode_to_inner (
fmode)))]) == MODE_FLOAT ? ((as_a <scalar_float_mode> (
(mode_to_inner (fmode)))) - MIN_MODE_FLOAT) : ((fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2871, __FUNCTION__)), 0)]))->p) || (fmt->pnan == fmt->
p && fmt->signbit_ro == fmt->signbit_rw)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2873, __FUNCTION__), 0 : 0))
  && fmt->signbit_ro == fmt->signbit_rw))((void)(!(((((enum mode_class) mode_class[fmode]) == MODE_FLOAT
 || ((enum mode_class) mode_class[fmode]) == MODE_DECIMAL_FLOAT
 || ((enum mode_class) mode_class[fmode]) == MODE_COMPLEX_FLOAT
 || ((enum mode_class) mode_class[fmode]) == MODE_VECTOR_FLOAT
) && ((real_format_for_mode[(((enum mode_class) mode_class
[as_a <scalar_float_mode> ((mode_to_inner (fmode)))]) ==
 MODE_DECIMAL_FLOAT) ? (((as_a <scalar_float_mode> ((mode_to_inner
 (fmode)))) - MIN_MODE_DECIMAL_FLOAT) + (MAX_MODE_FLOAT - MIN_MODE_FLOAT
 + 1)) : ((enum mode_class) mode_class[as_a <scalar_float_mode
> ((mode_to_inner (fmode)))]) == MODE_FLOAT ? ((as_a <scalar_float_mode
> ((mode_to_inner (fmode)))) - MIN_MODE_FLOAT) : ((fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2871, __FUNCTION__)), 0)]))->pnan < ((real_format_for_mode
[(((enum mode_class) mode_class[as_a <scalar_float_mode>
 ((mode_to_inner (fmode)))]) == MODE_DECIMAL_FLOAT) ? (((as_a
 <scalar_float_mode> ((mode_to_inner (fmode)))) - MIN_MODE_DECIMAL_FLOAT
) + (MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) : ((enum mode_class
) mode_class[as_a <scalar_float_mode> ((mode_to_inner (
fmode)))]) == MODE_FLOAT ? ((as_a <scalar_float_mode> (
(mode_to_inner (fmode)))) - MIN_MODE_FLOAT) : ((fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2871, __FUNCTION__)), 0)]))->p) || (fmt->pnan == fmt->
p && fmt->signbit_ro == fmt->signbit_rw)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2873, __FUNCTION__), 0 : 0));

switch (fmt->p)
  {
  case 106: /* IBM double double  */
    /* For IBM double double, recurse on the most significant double.  */
    gcc_assert (MODE_COMPOSITE_P (fmode))((void)(!(((((enum mode_class) mode_class[fmode]) == MODE_FLOAT
 || ((enum mode_class) mode_class[fmode]) == MODE_DECIMAL_FLOAT
 || ((enum mode_class) mode_class[fmode]) == MODE_COMPLEX_FLOAT
 || ((enum mode_class) mode_class[fmode]) == MODE_VECTOR_FLOAT
) && ((real_format_for_mode[(((enum mode_class) mode_class
[as_a <scalar_float_mode> ((mode_to_inner (fmode)))]) ==
 MODE_DECIMAL_FLOAT) ? (((as_a <scalar_float_mode> ((mode_to_inner
 (fmode)))) - MIN_MODE_DECIMAL_FLOAT) + (MAX_MODE_FLOAT - MIN_MODE_FLOAT
 + 1)) : ((enum mode_class) mode_class[as_a <scalar_float_mode
> ((mode_to_inner (fmode)))]) == MODE_FLOAT ? ((as_a <scalar_float_mode
> ((mode_to_inner (fmode)))) - MIN_MODE_FLOAT) : ((fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2879, __FUNCTION__)), 0)]))->pnan < ((real_format_for_mode
[(((enum mode_class) mode_class[as_a <scalar_float_mode>
 ((mode_to_inner (fmode)))]) == MODE_DECIMAL_FLOAT) ? (((as_a
 <scalar_float_mode> ((mode_to_inner (fmode)))) - MIN_MODE_DECIMAL_FLOAT
) + (MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) : ((enum mode_class
) mode_class[as_a <scalar_float_mode> ((mode_to_inner (
fmode)))]) == MODE_FLOAT ? ((as_a <scalar_float_mode> (
(mode_to_inner (fmode)))) - MIN_MODE_FLOAT) : ((fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2879, __FUNCTION__)), 0)]))->p)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2879, __FUNCTION__), 0 : 0));
    temp = convert_modes (DFmode(scalar_float_mode ((scalar_float_mode::from_int) E_DFmode)), fmode, temp, 0);
    fmode = DFmode(scalar_float_mode ((scalar_float_mode::from_int) E_DFmode));
    fmt = REAL_MODE_FORMAT (DFmode)(real_format_for_mode[(((enum mode_class) mode_class[(scalar_float_mode
 ((scalar_float_mode::from_int) E_DFmode))]) == MODE_DECIMAL_FLOAT
) ? ((((scalar_float_mode ((scalar_float_mode::from_int) E_DFmode
))) - MIN_MODE_DECIMAL_FLOAT) + (MAX_MODE_FLOAT - MIN_MODE_FLOAT
 + 1)) : ((enum mode_class) mode_class[(scalar_float_mode ((scalar_float_mode
::from_int) E_DFmode))]) == MODE_FLOAT ? (((scalar_float_mode
 ((scalar_float_mode::from_int) E_DFmode))) - MIN_MODE_FLOAT)
 : ((fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 2882, __FUNCTION__)), 0)]);
    /* FALLTHRU */
  case 8: /* bfloat */
  case 11: /* IEEE half */
  case 24: /* IEEE single */
  case 53: /* IEEE double or Intel extended with rounding to double */
    if (fmt->p == 53 && fmt->signbit_ro == 79)
goto extended;
    {
scalar_int_mode imode = int_mode_for_mode (fmode).require ();
temp = gen_lowpartrtl_hooks.gen_lowpart (imode, temp);
rtx val = GEN_INT ((HOST_WIDE_INT_M1U << (fmt->p - 2))gen_rtx_CONST_INT (((void) 0, E_VOIDmode), ((-1UL << (fmt
->p - 2)) & ~(-1UL << fmt->signbit_ro)))
	   & ~(HOST_WIDE_INT_M1U << fmt->signbit_ro))gen_rtx_CONST_INT (((void) 0, E_VOIDmode), ((-1UL << (fmt
->p - 2)) & ~(-1UL << fmt->signbit_ro)));
if (fmt->qnan_msb_set)
 {
   rtx mask = GEN_INT (~(HOST_WIDE_INT_M1U << fmt->signbit_ro))gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (~(-1UL << fmt
->signbit_ro)));
   rtx bit = GEN_INT (HOST_WIDE_INT_1U << (fmt->p - 2))gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (1UL << (fmt
->p - 2)));
   /* For non-MIPS/PA IEEE single/double/half or bfloat, expand to:
      ((temp ^ bit) & mask) > val.  */
   temp = expand_binop (imode, xor_optab, temp, bit,
		 NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
   temp = expand_binop (imode, and_optab, temp, mask,
		 NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
   temp = emit_store_flag_force (target, GTU, temp, val, imode,
			  1, 1);
 }
else
 {
   /* For MIPS/PA IEEE single/double, expand to:
      (temp & val) == val.  */
   temp = expand_binop (imode, and_optab, temp, val,
		 NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
   temp = emit_store_flag_force (target, EQ, temp, val, imode,
			  1, 1);
 }
    }
    break;
  case 113: /* IEEE quad */
    {
rtx hi = NULL_RTX(rtx) 0, lo = NULL_RTX(rtx) 0;
scalar_int_mode imode = int_mode_for_size (64, 1).require ();
/* For IEEE quad, TImode support isn't always there and even when
  it is, working on DImode parts is usually better.  */
if (!MEM_P (temp)(((enum rtx_code) (temp)->code) == MEM))
 {
   hi = simplify_gen_subreg (imode, temp, fmode,
		      subreg_highpart_offset (imode, fmode));
   lo = simplify_gen_subreg (imode, temp, fmode,
		      subreg_lowpart_offset (imode, fmode));
   if (!hi || !lo)
     {
scalar_int_mode imode2;
if (int_mode_for_mode (fmode).exists (&imode2))
  {
    rtx temp2 = gen_lowpartrtl_hooks.gen_lowpart (imode2, temp);
    hi = simplify_gen_subreg (imode, temp2, imode2,
			      subreg_highpart_offset (imode,
						      imode2));
    lo = simplify_gen_subreg (imode, temp2, imode2,
			      subreg_lowpart_offset (imode,
						     imode2));
  }
     }
   if (!hi || !lo)
     {
rtx mem = assign_stack_temp (fmode, GET_MODE_SIZE (fmode));
emit_move_insn (mem, temp);
temp = mem;
     }
 }
if (!hi || !lo)
 {
   poly_int64 offset
     = subreg_highpart_offset (imode, GET_MODE (temp)((machine_mode) (temp)->mode));
   hi = adjust_address (temp, imode, offset)adjust_address_1 (temp, imode, offset, 1, 1, 0, 0);
   offset = subreg_lowpart_offset (imode, GET_MODE (temp)((machine_mode) (temp)->mode));
   lo = adjust_address (temp, imode, offset)adjust_address_1 (temp, imode, offset, 1, 1, 0, 0);
 }
rtx val = GEN_INT ((HOST_WIDE_INT_M1U << (fmt->p - 2 - 64))gen_rtx_CONST_INT (((void) 0, E_VOIDmode), ((-1UL << (fmt
->p - 2 - 64)) & ~(-1UL << (fmt->signbit_ro -
 64))))
	   & ~(HOST_WIDE_INT_M1U << (fmt->signbit_ro - 64)))gen_rtx_CONST_INT (((void) 0, E_VOIDmode), ((-1UL << (fmt
->p - 2 - 64)) & ~(-1UL << (fmt->signbit_ro -
 64))));
if (fmt->qnan_msb_set)
 {
   rtx mask = GEN_INT (~(HOST_WIDE_INT_M1U << (fmt->signbit_rogen_rtx_CONST_INT (((void) 0, E_VOIDmode), (~(-1UL << (
fmt->signbit_ro - 64))))
					- 64)))gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (~(-1UL << (
fmt->signbit_ro - 64))));
   rtx bit = GEN_INT (HOST_WIDE_INT_1U << (fmt->p - 2 - 64))gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (1UL << (fmt
->p - 2 - 64)));
   /* For non-MIPS/PA IEEE quad, expand to:
      (((hi ^ bit) | ((lo | -lo) >> 63)) & mask) > val.  */
   rtx nlo = expand_unop (imode, neg_optab, lo, NULL_RTX(rtx) 0, 0);
   lo = expand_binop (imode, ior_optab, lo, nlo,
	       NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
   lo = expand_shift (RSHIFT_EXPR, imode, lo, 63, NULL_RTX(rtx) 0, 1);
   temp = expand_binop (imode, xor_optab, hi, bit,
		 NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
   temp = expand_binop (imode, ior_optab, temp, lo,
		 NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
   temp = expand_binop (imode, and_optab, temp, mask,
		 NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
   temp = emit_store_flag_force (target, GTU, temp, val, imode,
			  1, 1);
 }
else
 {
   /* For MIPS/PA IEEE quad, expand to:
      (hi & val) == val.  */
   temp = expand_binop (imode, and_optab, hi, val,
		 NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
   temp = emit_store_flag_force (target, EQ, temp, val, imode,
			  1, 1);
 }
    }
    break;
  case 64: /* Intel or Motorola extended */
  extended:
    {
rtx ex, hi, lo;
scalar_int_mode imode = int_mode_for_size (32, 1).require ();
scalar_int_mode iemode = int_mode_for_size (16, 1).require ();
if (!MEM_P (temp)(((enum rtx_code) (temp)->code) == MEM))
 {
   rtx mem = assign_stack_temp (fmode, GET_MODE_SIZE (fmode));
   emit_move_insn (mem, temp);
   temp = mem;
 }
if (fmt->signbit_ro == 95)
 {
   /* Motorola, always big endian, with 16-bit gap in between
      16-bit sign+exponent and 64-bit mantissa.  */
   ex = adjust_address (temp, iemode, 0)adjust_address_1 (temp, iemode, 0, 1, 1, 0, 0);
   hi = adjust_address (temp, imode, 4)adjust_address_1 (temp, imode, 4, 1, 1, 0, 0);
   lo = adjust_address (temp, imode, 8)adjust_address_1 (temp, imode, 8, 1, 1, 0, 0);
 }
else if (!WORDS_BIG_ENDIAN0)
 {
   /* Intel little endian, 64-bit mantissa followed by 16-bit
      sign+exponent and then either 16 or 48 bits of gap.  */
   ex = adjust_address (temp, iemode, 8)adjust_address_1 (temp, iemode, 8, 1, 1, 0, 0);
   hi = adjust_address (temp, imode, 4)adjust_address_1 (temp, imode, 4, 1, 1, 0, 0);
   lo = adjust_address (temp, imode, 0)adjust_address_1 (temp, imode, 0, 1, 1, 0, 0);
 }
else
 {
   /* Big endian Itanium.  */
   ex = adjust_address (temp, iemode, 0)adjust_address_1 (temp, iemode, 0, 1, 1, 0, 0);
   hi = adjust_address (temp, imode, 2)adjust_address_1 (temp, imode, 2, 1, 1, 0, 0);
   lo = adjust_address (temp, imode, 6)adjust_address_1 (temp, imode, 6, 1, 1, 0, 0);
 }
rtx val = GEN_INT (HOST_WIDE_INT_M1U << 30)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (-1UL << 30)
);
gcc_assert (fmt->qnan_msb_set)((void)(!(fmt->qnan_msb_set) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3029, __FUNCTION__), 0 : 0));
rtx mask = GEN_INT (0x7fff)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (0x7fff));
rtx bit = GEN_INT (HOST_WIDE_INT_1U << 30)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (1UL << 30));
/* For Intel/Motorola extended format, expand to:
  (ex & mask) == mask && ((hi ^ bit) | ((lo | -lo) >> 31)) > val.  */
rtx nlo = expand_unop (imode, neg_optab, lo, NULL_RTX(rtx) 0, 0);
lo = expand_binop (imode, ior_optab, lo, nlo,
	   NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
lo = expand_shift (RSHIFT_EXPR, imode, lo, 31, NULL_RTX(rtx) 0, 1);
temp = expand_binop (imode, xor_optab, hi, bit,
	     NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
temp = expand_binop (imode, ior_optab, temp, lo,
	     NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
temp = emit_store_flag_force (target, GTU, temp, val, imode, 1, 1);
ex = expand_binop (iemode, and_optab, ex, mask,
	   NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
ex = emit_store_flag_force (gen_reg_rtx (GET_MODE (temp)((machine_mode) (temp)->mode)), EQ,
		    ex, mask, iemode, 1, 1);
temp = expand_binop (GET_MODE (temp)((machine_mode) (temp)->mode), and_optab, temp, ex,
	     NULL_RTX(rtx) 0, 1, OPTAB_LIB_WIDEN);
    }
    break;
  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3052, __FUNCTION__));
  }

return temp;
3056}

3058/* Expand a call to one of the builtin rounding functions gcc defines
 as an extension (lfloor and lceil).  As these are gcc extensions we
 do not need to worry about setting errno to EDOM.
 If expanding via optab fails, lower expression to (int)(floor(x)).
 EXP is the expression that is a call to the builtin function;
 if convenient, the result should be placed in TARGET.  */

3065static rtx
3066expand_builtin_int_roundingfn (tree exp, rtx target)
3067{
convert_optab builtin_optab;
rtx op0, tmp;
rtx_insn *insns;
tree fndecl = get_callee_fndecl (exp);
enum built_in_function fallback_fn;
tree fallback_fndecl;
machine_mode mode;
tree arg;

if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

arg = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3080, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3080, __FUNCTION__)))));

switch (DECL_FUNCTION_CODE (fndecl))
  {
  CASE_FLT_FN (BUILT_IN_ICEIL)case BUILT_IN_ICEIL: case BUILT_IN_ICEILF: case BUILT_IN_ICEILL:
  CASE_FLT_FN (BUILT_IN_LCEIL)case BUILT_IN_LCEIL: case BUILT_IN_LCEILF: case BUILT_IN_LCEILL:
  CASE_FLT_FN (BUILT_IN_LLCEIL)case BUILT_IN_LLCEIL: case BUILT_IN_LLCEILF: case BUILT_IN_LLCEILL:
    builtin_optab = lceil_optab;
    fallback_fn = BUILT_IN_CEIL;
    break;

  CASE_FLT_FN (BUILT_IN_IFLOOR)case BUILT_IN_IFLOOR: case BUILT_IN_IFLOORF: case BUILT_IN_IFLOORL:
  CASE_FLT_FN (BUILT_IN_LFLOOR)case BUILT_IN_LFLOOR: case BUILT_IN_LFLOORF: case BUILT_IN_LFLOORL:
  CASE_FLT_FN (BUILT_IN_LLFLOOR)case BUILT_IN_LLFLOOR: case BUILT_IN_LLFLOORF: case BUILT_IN_LLFLOORL:
    builtin_optab = lfloor_optab;
    fallback_fn = BUILT_IN_FLOOR;
    break;

  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3099, __FUNCTION__));
  }

/* Make a suitable register to place result in.  */
mode = TYPE_MODE (TREE_TYPE (exp))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3103, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3103, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3103, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3103, __FUNCTION__))->typed.type))->type_common.mode);

target = gen_reg_rtx (mode);

/* Wrap the computation of the argument in a SAVE_EXPR, as we may
   need to expand the argument again.  This way, we will not perform
   side-effects more the once.  */
CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3110, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3110, __FUNCTION__))))) = arg = builtin_save_expr (arg);

op0 = expand_expr (arg, NULL__null, VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);

start_sequence ();

/* Compute into TARGET.  */
if (expand_sfix_optab (target, op0, builtin_optab))
  {
    /* Output the entire sequence.  */
    insns = get_insns ();
    end_sequence ();
    emit_insn (insns);
    return target;
  }

/* If we were unable to expand via the builtin, stop the sequence
   (without outputting the insns).  */
end_sequence ();

/* Fall back to floating point rounding optab.  */
fallback_fndecl = mathfn_built_in (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3131, __FUNCTION__))->typed.type), fallback_fn);

/* For non-C99 targets we may end up without a fallback fndecl here
   if the user called __builtin_lfloor directly.  In this case emit
   a call to the floor/ceil variants nevertheless.  This should result
   in the best user experience for not full C99 targets.  */
if (fallback_fndecl == NULL_TREE(tree) __null)
  {
    tree fntype;
    const char *name = NULL__null;

    switch (DECL_FUNCTION_CODE (fndecl))
{
case BUILT_IN_ICEIL:
case BUILT_IN_LCEIL:
case BUILT_IN_LLCEIL:
 name = "ceil";
 break;
case BUILT_IN_ICEILF:
case BUILT_IN_LCEILF:
case BUILT_IN_LLCEILF:
 name = "ceilf";
 break;
case BUILT_IN_ICEILL:
case BUILT_IN_LCEILL:
case BUILT_IN_LLCEILL:
 name = "ceill";
 break;
case BUILT_IN_IFLOOR:
case BUILT_IN_LFLOOR:
case BUILT_IN_LLFLOOR:
 name = "floor";
 break;
case BUILT_IN_IFLOORF:
case BUILT_IN_LFLOORF:
case BUILT_IN_LLFLOORF:
 name = "floorf";
 break;
case BUILT_IN_IFLOORL:
case BUILT_IN_LFLOORL:
case BUILT_IN_LLFLOORL:
 name = "floorl";
 break;
default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3175, __FUNCTION__));
}

    fntype = build_function_type_list (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3178, __FUNCTION__))->typed.type),
			 TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3179, __FUNCTION__))->typed.type), NULL_TREE(tree) __null);
    fallback_fndecl = build_fn_decl (name, fntype);
  }

exp = build_call_nofold_loc (EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0)), fallback_fndecl, 1, arg);

tmp = expand_normal (exp);
tmp = maybe_emit_group_store (tmp, TREE_TYPE (exp)((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3186, __FUNCTION__))->typed.type));

/* Truncate the result of floating point optab to integer
   via expand_fix ().  */
target = gen_reg_rtx (mode);
expand_fix (target, tmp, 0);

return target;
3194}

3196/* Expand a call to one of the builtin math functions doing integer
 conversion (lrint).
 Return 0 if a normal call should be emitted rather than expanding the
 function in-line.  EXP is the expression that is a call to the builtin
 function; if convenient, the result should be placed in TARGET.  */

3202static rtx
3203expand_builtin_int_roundingfn_2 (tree exp, rtx target)
3204{
convert_optab builtin_optab;
rtx op0;
rtx_insn *insns;
tree fndecl = get_callee_fndecl (exp);
tree arg;
machine_mode mode;
enum built_in_function fallback_fn = BUILT_IN_NONE;

if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

arg = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3216, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3216, __FUNCTION__)))));

switch (DECL_FUNCTION_CODE (fndecl))
  {
  CASE_FLT_FN (BUILT_IN_IRINT)case BUILT_IN_IRINT: case BUILT_IN_IRINTF: case BUILT_IN_IRINTL:
    fallback_fn = BUILT_IN_LRINT;
    gcc_fallthrough ();
  CASE_FLT_FN (BUILT_IN_LRINT)case BUILT_IN_LRINT: case BUILT_IN_LRINTF: case BUILT_IN_LRINTL:
  CASE_FLT_FN (BUILT_IN_LLRINT)case BUILT_IN_LLRINT: case BUILT_IN_LLRINTF: case BUILT_IN_LLRINTL:
    builtin_optab = lrint_optab;
    break;

  CASE_FLT_FN (BUILT_IN_IROUND)case BUILT_IN_IROUND: case BUILT_IN_IROUNDF: case BUILT_IN_IROUNDL:
    fallback_fn = BUILT_IN_LROUND;
    gcc_fallthrough ();
  CASE_FLT_FN (BUILT_IN_LROUND)case BUILT_IN_LROUND: case BUILT_IN_LROUNDF: case BUILT_IN_LROUNDL:
  CASE_FLT_FN (BUILT_IN_LLROUND)case BUILT_IN_LLROUND: case BUILT_IN_LLROUNDF: case BUILT_IN_LLROUNDL:
    builtin_optab = lround_optab;
    break;

  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3237, __FUNCTION__));
  }

/* There's no easy way to detect the case we need to set EDOM.  */
if (flag_errno_mathglobal_options.x_flag_errno_math && fallback_fn == BUILT_IN_NONE)
  return NULL_RTX(rtx) 0;

/* Make a suitable register to place result in.  */
mode = TYPE_MODE (TREE_TYPE (exp))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3245, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3245, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3245, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3245, __FUNCTION__))->typed.type))->type_common.mode);

/* There's no easy way to detect the case we need to set EDOM.  */
if (!flag_errno_mathglobal_options.x_flag_errno_math)
  {
    rtx result = gen_reg_rtx (mode);

    /* Wrap the computation of the argument in a SAVE_EXPR, as we may
need to expand the argument again.  This way, we will not perform
side-effects more the once.  */
    CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3255, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3255, __FUNCTION__))))) = arg = builtin_save_expr (arg);

    op0 = expand_expr (arg, NULL__null, VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);

    start_sequence ();

    if (expand_sfix_optab (result, op0, builtin_optab))
{
 /* Output the entire sequence.  */
 insns = get_insns ();
 end_sequence ();
 emit_insn (insns);
 return result;
}

    /* If we were unable to expand via the builtin, stop the sequence
(without outputting the insns) and call to the library function
with the stabilized argument list.  */
    end_sequence ();
  }

if (fallback_fn != BUILT_IN_NONE)
  {
    /* Fall back to rounding to long int.  Use implicit_p 0 - for non-C99
targets, (int) round (x) should never be transformed into
BUILT_IN_IROUND and if __builtin_iround is called directly, emit
a call to lround in the hope that the target provides at least some
C99 functions.  This should result in the best user experience for
not full C99 targets.
As scalar float conversions with same mode are useless in GIMPLE,
we can end up e.g. with _Float32 argument passed to float builtin,
try to get the type from the builtin prototype first.  */
    tree fallback_fndecl = NULL_TREE(tree) __null;
    if (tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl))((tree_check2 ((((contains_struct_check ((fndecl), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3288, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3288, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values))
      fallback_fndecl
        = mathfn_built_in_1 (TREE_VALUE (argtypes)((tree_check ((argtypes), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3290, __FUNCTION__, (TREE_LIST)))->list.value),
	       as_combined_fn (fallback_fn), 0);
    if (fallback_fndecl == NULL_TREE(tree) __null)
fallback_fndecl
 = mathfn_built_in_1 (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3294, __FUNCTION__))->typed.type),
	       as_combined_fn (fallback_fn), 0);
    if (fallback_fndecl)
{
 exp = build_call_nofold_loc (EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0)),
		       fallback_fndecl, 1, arg);

 target = expand_call (exp, NULL_RTX(rtx) 0, target == const0_rtx(const_int_rtx[64]));
 target = maybe_emit_group_store (target, TREE_TYPE (exp)((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3302, __FUNCTION__))->typed.type));
 return convert_to_mode (mode, target, 0);
}
  }

return expand_call (exp, target, target == const0_rtx(const_int_rtx[64]));
3308}

3310/* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
 a normal call should be emitted rather than expanding the function
 in-line.  EXP is the expression that is a call to the builtin
 function; if convenient, the result should be placed in TARGET.  */

3315static rtx
3316expand_builtin_powi (tree exp, rtx target)
3317{
tree arg0, arg1;
rtx op0, op1;
machine_mode mode;
machine_mode mode2;

if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

arg0 = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3326, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3326, __FUNCTION__)))));
arg1 = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3327, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3327, __FUNCTION__)))));
mode = TYPE_MODE (TREE_TYPE (exp))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3328, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3328, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3328, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3328, __FUNCTION__))->typed.type))->type_common.mode);

/* Emit a libcall to libgcc.  */

/* Mode of the 2nd argument must match that of an int.  */
mode2 = int_mode_for_size (INT_TYPE_SIZE32, 0).require ();

if (target == NULL_RTX(rtx) 0)
  target = gen_reg_rtx (mode);

op0 = expand_expr (arg0, NULL_RTX(rtx) 0, mode, EXPAND_NORMAL);
if (GET_MODE (op0)((machine_mode) (op0)->mode) != mode)
  op0 = convert_to_mode (mode, op0, 0);
op1 = expand_expr (arg1, NULL_RTX(rtx) 0, mode2, EXPAND_NORMAL);
if (GET_MODE (op1)((machine_mode) (op1)->mode) != mode2)
  op1 = convert_to_mode (mode2, op1, 0);

target = emit_library_call_value (optab_libfunc (powi_optab, mode),
		    target, LCT_CONST, mode,
		    op0, mode, op1, mode2);

return target;
3350}

3352/* Expand expression EXP which is a call to the strlen builtin.  Return
 NULL_RTX if we failed and the caller should emit a normal call, otherwise
 try to get the result in TARGET, if convenient.  */

3356static rtx
3357expand_builtin_strlen (tree exp, rtx target,
       machine_mode target_mode)
3359{
if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

tree src = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3363, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3363, __FUNCTION__)))));

/* If the length can be computed at compile-time, return it.  */
if (tree len = c_strlen (src, 0))
  return expand_expr (len, target, target_mode, EXPAND_NORMAL);

/* If the length can be computed at compile-time and is constant
   integer, but there are side-effects in src, evaluate
   src for side-effects, then return len.
   E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
   can be optimized into: i++; x = 3;  */
tree len = c_strlen (src, 1);
if (len && TREE_CODE (len)((enum tree_code) (len)->base.code) == INTEGER_CST)
  {
    expand_expr (src, const0_rtx(const_int_rtx[64]), VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);
    return expand_expr (len, target, target_mode, EXPAND_NORMAL);
  }

unsigned int align = get_pointer_alignment (src) / BITS_PER_UNIT(8);

/* If SRC is not a pointer type, don't do this operation inline.  */
if (align == 0)
  return NULL_RTX(rtx) 0;

/* Bail out if we can't compute strlen in the right mode.  */
machine_mode insn_mode;
enum insn_code icode = CODE_FOR_nothing;
FOR_EACH_MODE_FROM (insn_mode, target_mode)for ((insn_mode) = (target_mode); mode_iterator::iterate_p (&
(insn_mode)); mode_iterator::get_next (&(insn_mode)))
  {
    icode = optab_handler (strlen_optab, insn_mode);
    if (icode != CODE_FOR_nothing)
break;
  }
if (insn_mode == VOIDmode((void) 0, E_VOIDmode))
  return NULL_RTX(rtx) 0;

/* Make a place to hold the source address.  We will not expand
   the actual source until we are sure that the expansion will
   not fail -- there are trees that cannot be expanded twice.  */
rtx src_reg = gen_reg_rtx (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))));

/* Mark the beginning of the strlen sequence so we can emit the
   source operand later.  */
rtx_insn *before_strlen = get_last_insn ();

class expand_operand ops[4];
create_output_operand (&ops[0], target, insn_mode);
create_fixed_operand (&ops[1], gen_rtx_MEM (BLKmode((void) 0, E_BLKmode), src_reg));
create_integer_operand (&ops[2], 0);
create_integer_operand (&ops[3], align);
if (!maybe_expand_insn (icode, 4, ops))
  return NULL_RTX(rtx) 0;

/* Check to see if the argument was declared attribute nonstring
   and if so, issue a warning since at this point it's not known
   to be nul-terminated.  */
maybe_warn_nonstring_arg (get_callee_fndecl (exp), exp);

/* Now that we are assured of success, expand the source.  */
start_sequence ();
rtx pat = expand_expr (src, src_reg, Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), EXPAND_NORMAL);
if (pat != src_reg)
  {
3426#ifdef POINTERS_EXTEND_UNSIGNED1
    if (GET_MODE (pat)((machine_mode) (pat)->mode) != Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))))
pat = convert_to_mode (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), pat,
	       POINTERS_EXTEND_UNSIGNED1);
3430#endif
    emit_move_insn (src_reg, pat);
  }
pat = get_insns ();
end_sequence ();

if (before_strlen)
  emit_insn_after (pat, before_strlen);
else
  emit_insn_before (pat, get_insns ());

/* Return the value in the proper mode for this function.  */
if (GET_MODE (ops[0].value)((machine_mode) (ops[0].value)->mode) == target_mode)
  target = ops[0].value;
else if (target != 0)
  convert_move (target, ops[0].value, 0);
else
  target = convert_to_mode (target_mode, ops[0].value, 0);

return target;
3450}

3452/* Expand call EXP to the strnlen built-in, returning the result
 and setting it in TARGET.  Otherwise return NULL_RTX on failure.  */

3455static rtx
3456expand_builtin_strnlen (tree exp, rtx target, machine_mode target_mode)
3457{
if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

tree src = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3461, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3461, __FUNCTION__)))));
tree bound = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3462, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3462, __FUNCTION__)))));

if (!bound)
  return NULL_RTX(rtx) 0;

location_t loc = UNKNOWN_LOCATION((location_t) 0);
if (EXPR_HAS_LOCATION (exp)(((IS_ADHOC_LOC (((((exp)) && ((tree_code_type_tmpl <
0>::tree_code_type[(int) (((enum tree_code) ((exp))->base
.code))]) >= tcc_reference && (tree_code_type_tmpl
 <0>::tree_code_type[(int) (((enum tree_code) ((exp))->
base.code))]) <= tcc_expression)) ? (exp)->exp.locus : (
(location_t) 0)))) ? get_location_from_adhoc_loc (line_table,
 ((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0))) : (((((exp)) &&
 ((tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
 tree_code) ((exp))->base.code))]) >= tcc_reference &&
 (tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
 tree_code) ((exp))->base.code))]) <= tcc_expression)) ?
 (exp)->exp.locus : ((location_t) 0)))) != ((location_t) 0
)))
  loc = EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0));

/* FIXME: Change c_strlen() to return sizetype instead of ssizetype
   so these conversions aren't necessary.  */
c_strlen_data lendata = { };
tree len = c_strlen (src, 0, &lendata, 1);
if (len)
  len = fold_convert_loc (loc, TREE_TYPE (bound)((contains_struct_check ((bound), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3476, __FUNCTION__))->typed.type), len);

if (TREE_CODE (bound)((enum tree_code) (bound)->base.code) == INTEGER_CST)
  {
    if (!len)
return NULL_RTX(rtx) 0;

    len = fold_build2_loc (loc, MIN_EXPR, size_type_nodeglobal_trees[TI_SIZE_TYPE], len, bound);
    return expand_expr (len, target, target_mode, EXPAND_NORMAL);
  }

if (TREE_CODE (bound)((enum tree_code) (bound)->base.code) != SSA_NAME)
  return NULL_RTX(rtx) 0;

wide_int min, max;
value_range r;
get_global_range_query ()->range_of_expr (r, bound);
if (r.kind () != VR_RANGE)
  return NULL_RTX(rtx) 0;
min = r.lower_bound ();
max = r.upper_bound ();

if (!len || TREE_CODE (len)((enum tree_code) (len)->base.code) != INTEGER_CST)
  {
    bool exact;
    lendata.decl = unterminated_array (src, &len, &exact);
    if (!lendata.decl)
return NULL_RTX(rtx) 0;
  }

if (lendata.decl)
  return NULL_RTX(rtx) 0;

if (wi::gtu_p (min, wi::to_wide (len)))
  return expand_expr (len, target, target_mode, EXPAND_NORMAL);

len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len)((contains_struct_check ((len), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3512, __FUNCTION__))->typed.type), len, bound);
return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3514}

3516/* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
 bytes from bytes at DATA + OFFSET and return it reinterpreted as
 a target constant.  */

3520static rtx
3521builtin_memcpy_read_str (void *data, void *, HOST_WIDE_INTlong offset,
	 fixed_size_mode mode)
3523{
/* The REPresentation pointed to by DATA need not be a nul-terminated
   string but the caller guarantees it's large enough for MODE.  */
const char *rep = (const char *) data;

/* The by-pieces infrastructure does not try to pick a vector mode
   for memcpy expansion.  */
return c_readstr (rep + offset, as_a <scalar_int_mode> (mode),
    /*nul_terminated=*/false);
3532}

3534/* LEN specify length of the block of memcpy/memset operation.
 Figure out its range and put it into MIN_SIZE/MAX_SIZE. 
 In some cases we can make very likely guess on max size, then we
 set it into PROBABLE_MAX_SIZE.  */

3539static void
3540determine_block_size (tree len, rtx len_rtx,
      unsigned HOST_WIDE_INTlong *min_size,
      unsigned HOST_WIDE_INTlong *max_size,
      unsigned HOST_WIDE_INTlong *probable_max_size)
3544{
if (CONST_INT_P (len_rtx)(((enum rtx_code) (len_rtx)->code) == CONST_INT))
  {
    *min_size = *max_size = *probable_max_size = UINTVAL (len_rtx)((unsigned long) ((len_rtx)->u.hwint[0]));
    return;
  }
else
  {
    wide_int min, max;
    enum value_range_kind range_type = VR_UNDEFINED;

    /* Determine bounds from the type.  */
    if (tree_fits_uhwi_p (TYPE_MIN_VALUE (TREE_TYPE (len))((tree_check5 ((((contains_struct_check ((len), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3556, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3556, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)))
*min_size = tree_to_uhwi (TYPE_MIN_VALUE (TREE_TYPE (len))((tree_check5 ((((contains_struct_check ((len), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3557, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3557, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
));
    else
*min_size = 0;
    if (tree_fits_uhwi_p (TYPE_MAX_VALUE (TREE_TYPE (len))((tree_check5 ((((contains_struct_check ((len), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3560, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3560, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)))
*probable_max_size = *max_size
 = tree_to_uhwi (TYPE_MAX_VALUE (TREE_TYPE (len))((tree_check5 ((((contains_struct_check ((len), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3562, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3562, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
));
    else
*probable_max_size = *max_size = GET_MODE_MASK (GET_MODE (len_rtx))mode_mask_array[((machine_mode) (len_rtx)->mode)];

    if (TREE_CODE (len)((enum tree_code) (len)->base.code) == SSA_NAME)
{
 value_range r;
 get_global_range_query ()->range_of_expr (r, len);
 range_type = r.kind ();
 if (range_type != VR_UNDEFINED)
   {
     min = wi::to_wide (r.min ());
     max = wi::to_wide (r.max ());
   }
}
    if (range_type == VR_RANGE)
{
 if (wi::fits_uhwi_p (min) && *min_size < min.to_uhwi ())
   *min_size = min.to_uhwi ();
 if (wi::fits_uhwi_p (max) && *max_size > max.to_uhwi ())
   *probable_max_size = *max_size = max.to_uhwi ();
}
    else if (range_type == VR_ANTI_RANGE)
{
 /* Code like

    int n;
    if (n < 100)
      memcpy (a, b, n)

    Produce anti range allowing negative values of N.  We still
    can use the information and make a guess that N is not negative.
    */
 if (!wi::leu_p (max, 1 << 30) && wi::fits_uhwi_p (min))
   *probable_max_size = min.to_uhwi () - 1;
}
  }
gcc_checking_assert (*max_size <=((void)(!(*max_size <= (unsigned long) mode_mask_array[((machine_mode
) (len_rtx)->mode)]) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3601, __FUNCTION__), 0 : 0))
       (unsigned HOST_WIDE_INT)((void)(!(*max_size <= (unsigned long) mode_mask_array[((machine_mode
) (len_rtx)->mode)]) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3601, __FUNCTION__), 0 : 0))
	  GET_MODE_MASK (GET_MODE (len_rtx)))((void)(!(*max_size <= (unsigned long) mode_mask_array[((machine_mode
) (len_rtx)->mode)]) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3601, __FUNCTION__), 0 : 0));
3602}

3604/* Expand a call EXP to the memcpy builtin.
 Return NULL_RTX if we failed, the caller should emit a normal call,
 otherwise try to get the result in TARGET, if convenient (and in
 mode MODE if that's convenient).  */

3609static rtx
3610expand_builtin_memcpy (tree exp, rtx target)
3611{
if (!validate_arglist (exp,
		 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

tree dest = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3616, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3616, __FUNCTION__)))));
tree src = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3617, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3617, __FUNCTION__)))));
tree len = CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3618, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3618, __FUNCTION__)))));

return expand_builtin_memory_copy_args (dest, src, len, target, exp,
			  /*retmode=*/ RETURN_BEGIN, false);
3622}

3624/* Check a call EXP to the memmove built-in for validity.
 Return NULL_RTX on both success and failure.  */

3627static rtx
3628expand_builtin_memmove (tree exp, rtx target)
3629{
if (!validate_arglist (exp,
		 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

tree dest = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3634, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3634, __FUNCTION__)))));
tree src = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3635, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3635, __FUNCTION__)))));
tree len = CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3636, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3636, __FUNCTION__)))));

return expand_builtin_memory_copy_args (dest, src, len, target, exp,
			  /*retmode=*/ RETURN_BEGIN, true);
3640}

3642/* Expand a call EXP to the mempcpy builtin.
 Return NULL_RTX if we failed; the caller should emit a normal call,
 otherwise try to get the result in TARGET, if convenient (and in
 mode MODE if that's convenient).  */

3647static rtx
3648expand_builtin_mempcpy (tree exp, rtx target)
3649{
if (!validate_arglist (exp,
		 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

tree dest = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3654, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3654, __FUNCTION__)))));
tree src = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3655, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3655, __FUNCTION__)))));
tree len = CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3656, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3656, __FUNCTION__)))));

/* Policy does not generally allow using compute_objsize (which
   is used internally by check_memop_size) to change code generation
   or drive optimization decisions.

   In this instance it is safe because the code we generate has
   the same semantics regardless of the return value of
   check_memop_sizes.   Exactly the same amount of data is copied
   and the return value is exactly the same in both cases.

   Furthermore, check_memop_size always uses mode 0 for the call to
   compute_objsize, so the imprecise nature of compute_objsize is
   avoided.  */

/* Avoid expanding mempcpy into memcpy when the call is determined
   to overflow the buffer.  This also prevents the same overflow
   from being diagnosed again when expanding memcpy.  */

return expand_builtin_mempcpy_args (dest, src, len,
		      target, exp, /*retmode=*/ RETURN_END);
3677}

3679/* Helper function to do the actual work for expand of memory copy family
 functions (memcpy, mempcpy, stpcpy).  Expansing should assign LEN bytes
 of memory from SRC to DEST and assign to TARGET if convenient.  Return
 value is based on RETMODE argument.  */

3684static rtx
3685expand_builtin_memory_copy_args (tree dest, tree src, tree len,
		 rtx target, tree exp, memop_ret retmode,
		 bool might_overlap)
3688{
unsigned int src_align = get_pointer_alignment (src);
unsigned int dest_align = get_pointer_alignment (dest);
rtx dest_mem, src_mem, dest_addr, len_rtx;
HOST_WIDE_INTlong expected_size = -1;
unsigned int expected_align = 0;
unsigned HOST_WIDE_INTlong min_size;
unsigned HOST_WIDE_INTlong max_size;
unsigned HOST_WIDE_INTlong probable_max_size;

bool is_move_done;

/* If DEST is not a pointer type, call the normal function.  */
if (dest_align == 0)
  return NULL_RTX(rtx) 0;

/* If either SRC is not a pointer type, don't do this
   operation in-line.  */
if (src_align == 0)
  return NULL_RTX(rtx) 0;

if (currently_expanding_gimple_stmt)
  stringop_block_profile (currently_expanding_gimple_stmt,
	    &expected_align, &expected_size);

if (expected_align < dest_align)
  expected_align = dest_align;
dest_mem = get_memory_rtx (dest, len);
set_mem_align (dest_mem, dest_align);
len_rtx = expand_normal (len);
determine_block_size (len, len_rtx, &min_size, &max_size,
	&probable_max_size);

/* Try to get the byte representation of the constant SRC points to,
   with its byte size in NBYTES.  */
unsigned HOST_WIDE_INTlong nbytes;
const char *rep = getbyterep (src, &nbytes);

/* If the function's constant bound LEN_RTX is less than or equal
   to the byte size of the representation of the constant argument,
   and if block move would be done by pieces, we can avoid loading
   the bytes from memory and only store the computed constant.
   This works in the overlap (memmove) case as well because
   store_by_pieces just generates a series of stores of constants
   from the representation returned by getbyterep().  */
if (rep
    && CONST_INT_P (len_rtx)(((enum rtx_code) (len_rtx)->code) == CONST_INT)
    && (unsigned HOST_WIDE_INTlong) INTVAL (len_rtx)((len_rtx)->u.hwint[0]) <= nbytes
    && can_store_by_pieces (INTVAL (len_rtx)((len_rtx)->u.hwint[0]), builtin_memcpy_read_str,
	      CONST_CAST (char *, rep)(const_cast<char *> ((rep))),
	      dest_align, false))
  {
    dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx)((len_rtx)->u.hwint[0]),
		  builtin_memcpy_read_str,
		  CONST_CAST (char *, rep)(const_cast<char *> ((rep))),
		  dest_align, false, retmode);
    dest_mem = force_operand (XEXP (dest_mem, 0)(((dest_mem)->u.fld[0]).rt_rtx), target);
    dest_mem = convert_memory_address (ptr_mode, dest_mem)convert_memory_address_addr_space ((ptr_mode), (dest_mem), 0);
    return dest_mem;
  }

src_mem = get_memory_rtx (src, len);
set_mem_align (src_mem, src_align);

/* Copy word part most expediently.  */
enum block_op_methods method = BLOCK_OP_NORMAL;
if (CALL_EXPR_TAILCALL (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3754, __FUNCTION__, (CALL_EXPR)))->base.addressable_flag
)
    && (retmode == RETURN_BEGIN || target == const0_rtx(const_int_rtx[64])))
  method = BLOCK_OP_TAILCALL;
bool use_mempcpy_call = (targetm.libc_has_fast_function (BUILT_IN_MEMPCPY)
	   && retmode == RETURN_END
	   && !might_overlap
	   && target != const0_rtx(const_int_rtx[64]));
if (use_mempcpy_call)
  method = BLOCK_OP_NO_LIBCALL_RET;
dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx, method,
		     expected_align, expected_size,
		     min_size, max_size, probable_max_size,
		     use_mempcpy_call, &is_move_done,
		     might_overlap);

/* Bail out when a mempcpy call would be expanded as libcall and when
   we have a target that provides a fast implementation
   of mempcpy routine.  */
if (!is_move_done)
  return NULL_RTX(rtx) 0;

if (dest_addr == pc_rtx)
  return NULL_RTX(rtx) 0;

if (dest_addr == 0)
  {
    dest_addr = force_operand (XEXP (dest_mem, 0)(((dest_mem)->u.fld[0]).rt_rtx), target);
    dest_addr = convert_memory_address (ptr_mode, dest_addr)convert_memory_address_addr_space ((ptr_mode), (dest_addr), 0
);
  }

if (retmode != RETURN_BEGIN && target != const0_rtx(const_int_rtx[64]))
  {
    dest_addr = gen_rtx_PLUS (ptr_mode, dest_addr, len_rtx)gen_rtx_fmt_ee_stat ((PLUS), ((ptr_mode)), ((dest_addr)), ((len_rtx
)) );
    /* stpcpy pointer to last byte.  */
    if (retmode == RETURN_END_MINUS_ONE)
dest_addr = gen_rtx_MINUS (ptr_mode, dest_addr, const1_rtx)gen_rtx_fmt_ee_stat ((MINUS), ((ptr_mode)), ((dest_addr)), ((
(const_int_rtx[64 +1]))) );
  }

return dest_addr;
3793}

3795static rtx
3796expand_builtin_mempcpy_args (tree dest, tree src, tree len,
	     rtx target, tree orig_exp, memop_ret retmode)
3798{
return expand_builtin_memory_copy_args (dest, src, len, target, orig_exp,
			  retmode, false);
3801}

3803/* Expand into a movstr instruction, if one is available.  Return NULL_RTX if
 we failed, the caller should emit a normal call, otherwise try to
 get the result in TARGET, if convenient.
 Return value is based on RETMODE argument.  */

3808static rtx
3809expand_movstr (tree dest, tree src, rtx target, memop_ret retmode)
3810{
class expand_operand ops[3];
rtx dest_mem;
rtx src_mem;

if (!targetm.have_movstr ())
  return NULL_RTX(rtx) 0;

dest_mem = get_memory_rtx (dest, NULL__null);
src_mem = get_memory_rtx (src, NULL__null);
if (retmode == RETURN_BEGIN)
  {
    target = force_reg (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), XEXP (dest_mem, 0)(((dest_mem)->u.fld[0]).rt_rtx));
    dest_mem = replace_equiv_address (dest_mem, target);
  }

create_output_operand (&ops[0],
	 retmode != RETURN_BEGIN ? target : NULL_RTX(rtx) 0, Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))));
create_fixed_operand (&ops[1], dest_mem);
create_fixed_operand (&ops[2], src_mem);
if (!maybe_expand_insn (targetm.code_for_movstr, 3, ops))
  return NULL_RTX(rtx) 0;

if (retmode != RETURN_BEGIN && target != const0_rtx(const_int_rtx[64]))
  {
    target = ops[0].value;
    /* movstr is supposed to set end to the address of the NUL
terminator.  If the caller requested a mempcpy-like return value,
adjust it.  */
    if (retmode == RETURN_END)
{
 rtx tem = plus_constant (GET_MODE (target)((machine_mode) (target)->mode),
		   gen_lowpartrtl_hooks.gen_lowpart (GET_MODE (target)((machine_mode) (target)->mode), target), 1);
 emit_move_insn (target, force_operand (tem, NULL_RTX(rtx) 0));
}
  }
return target;
3847}

3849/* Expand expression EXP, which is a call to the strcpy builtin.  Return
 NULL_RTX if we failed the caller should emit a normal call, otherwise
 try to get the result in TARGET, if convenient (and in mode MODE if that's
 convenient).  */

3854static rtx
3855expand_builtin_strcpy (tree exp, rtx target)
3856{
if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

tree dest = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3860, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3860, __FUNCTION__)))));
tree src = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3861, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3861, __FUNCTION__)))));

return expand_builtin_strcpy_args (exp, dest, src, target);
3864}

3866/* Helper function to do the actual work for expand_builtin_strcpy.  The
 arguments to the builtin_strcpy call DEST and SRC are broken out
 so that this can also be called without constructing an actual CALL_EXPR.
 The other arguments and return value are the same as for
 expand_builtin_strcpy.  */

3872static rtx
3873expand_builtin_strcpy_args (tree, tree dest, tree src, rtx target)
3874{
return expand_movstr (dest, src, target, /*retmode=*/ RETURN_BEGIN);
3876}

3878/* Expand a call EXP to the stpcpy builtin.
 Return NULL_RTX if we failed the caller should emit a normal call,
 otherwise try to get the result in TARGET, if convenient (and in
 mode MODE if that's convenient).  */

3883static rtx
3884expand_builtin_stpcpy_1 (tree exp, rtx target, machine_mode mode)
3885{
tree dst, src;
location_t loc = EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0));

if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

dst = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3892, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3892, __FUNCTION__)))));
src = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3893, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3893, __FUNCTION__)))));

/* If return value is ignored, transform stpcpy into strcpy.  */
if (target == const0_rtx(const_int_rtx[64]) && builtin_decl_implicit (BUILT_IN_STRCPY))
  {
    tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
    tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
    return expand_expr (result, target, mode, EXPAND_NORMAL);
  }
else
  {
    tree len, lenp1;
    rtx ret;

    /* Ensure we get an actual string whose length can be evaluated at
compile-time, not an expression containing a string.  This is
because the latter will potentially produce pessimized code
when used to produce the return value.  */
    c_strlen_data lendata = { };
    if (!c_getstr (src)
 || !(len = c_strlen (src, 0, &lendata, 1)))
return expand_movstr (dst, src, target,
	      /*retmode=*/ RETURN_END_MINUS_ONE);

    lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1)size_int_kind (1, stk_ssizetype));
    ret = expand_builtin_mempcpy_args (dst, src, lenp1,
			 target, exp,
			 /*retmode=*/ RETURN_END_MINUS_ONE);

    if (ret)
return ret;

    if (TREE_CODE (len)((enum tree_code) (len)->base.code) == INTEGER_CST)
{
 rtx len_rtx = expand_normal (len);

 if (CONST_INT_P (len_rtx)(((enum rtx_code) (len_rtx)->code) == CONST_INT))
   {
     ret = expand_builtin_strcpy_args (exp, dst, src, target);

     if (ret)
{
  if (! target)
    {
      if (mode != VOIDmode((void) 0, E_VOIDmode))
	target = gen_reg_rtx (mode);
      else
	target = gen_reg_rtx (GET_MODE (ret)((machine_mode) (ret)->mode));
    }
  if (GET_MODE (target)((machine_mode) (target)->mode) != GET_MODE (ret)((machine_mode) (ret)->mode))
    ret = gen_lowpartrtl_hooks.gen_lowpart (GET_MODE (target)((machine_mode) (target)->mode), ret);

  ret = plus_constant (GET_MODE (ret)((machine_mode) (ret)->mode), ret, INTVAL (len_rtx)((len_rtx)->u.hwint[0]));
  ret = emit_move_insn (target, force_operand (ret, NULL_RTX(rtx) 0));
  gcc_assert (ret)((void)(!(ret) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 3947, __FUNCTION__), 0 : 0));

  return target;
}
   }
}

    return expand_movstr (dst, src, target,
	    /*retmode=*/ RETURN_END_MINUS_ONE);
  }
3957}

3959/* Expand a call EXP to the stpcpy builtin and diagnose uses of nonstring
 arguments while being careful to avoid duplicate warnings (which could
 be issued if the expander were to expand the call, resulting in it
 being emitted in expand_call().  */

3964static rtx
3965expand_builtin_stpcpy (tree exp, rtx target, machine_mode mode)
3966{
if (rtx ret = expand_builtin_stpcpy_1 (exp, target, mode))
  {
    /* The call has been successfully expanded.  Check for nonstring
arguments and issue warnings as appropriate.  */
    maybe_warn_nonstring_arg (get_callee_fndecl (exp), exp);
    return ret;
  }

return NULL_RTX(rtx) 0;
3976}

3978/* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
 bytes from constant string DATA + OFFSET and return it as target
 constant.  */

3982rtx
3983builtin_strncpy_read_str (void *data, void *, HOST_WIDE_INTlong offset,
	  fixed_size_mode mode)
3985{
const char *str = (const char *) data;

if ((unsigned HOST_WIDE_INTlong) offset > strlen (str))
  return const0_rtx(const_int_rtx[64]);

/* The by-pieces infrastructure does not try to pick a vector mode
   for strncpy expansion.  */
return c_readstr (str + offset, as_a <scalar_int_mode> (mode));
3994}

3996/* Helper to check the sizes of sequences and the destination of calls
 to __builtin_strncat and __builtin___strncat_chk.  Returns true on
 success (no overflow or invalid sizes), false otherwise.  */

4000static bool
4001check_strncat_sizes (tree exp, tree objsize)
4002{
tree dest = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4003, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4003, __FUNCTION__)))));
tree src = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4004, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4004, __FUNCTION__)))));
tree maxread = CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4005, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4005, __FUNCTION__)))));

/* Try to determine the range of lengths that the source expression
   refers to.  */
c_strlen_data lendata = { };
get_range_strlen (src, &lendata, /* eltsize = */ 1);

/* Try to verify that the destination is big enough for the shortest
   string.  */

access_data data (nullptr, exp, access_read_write, maxread, true);
if (!objsize && warn_stringop_overflowglobal_options.x_warn_stringop_overflow)
  {
    /* If it hasn't been provided by __strncat_chk, try to determine
the size of the destination object into which the source is
being copied.  */
    objsize = compute_objsize (dest, warn_stringop_overflowglobal_options.x_warn_stringop_overflow - 1, &data.dst);
  }

/* Add one for the terminating nul.  */
tree srclen = (lendata.minlen
 ? fold_build2 (PLUS_EXPR, size_type_node, lendata.minlen,fold_build2_loc (((location_t) 0), PLUS_EXPR, global_trees[TI_SIZE_TYPE
], lendata.minlen, global_trees[TI_SIZE_ONE] )
		size_one_node)fold_build2_loc (((location_t) 0), PLUS_EXPR, global_trees[TI_SIZE_TYPE
], lendata.minlen, global_trees[TI_SIZE_ONE] )
 : NULL_TREE(tree) __null);

/* The strncat function copies at most MAXREAD bytes and always appends
   the terminating nul so the specified upper bound should never be equal
   to (or greater than) the size of the destination.  */
if (tree_fits_uhwi_p (maxread) && tree_fits_uhwi_p (objsize)
    && tree_int_cst_equal (objsize, maxread))
  {
    location_t loc = EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0));
    warning_at (loc, OPT_Wstringop_overflow_,
  "%qD specified bound %E equals destination size",
  get_callee_fndecl (exp), maxread);

    return false;
  }

if (!srclen
    || (maxread && tree_fits_uhwi_p (maxread)
 && tree_fits_uhwi_p (srclen)
 && tree_int_cst_lt (maxread, srclen)))
  srclen = maxread;

/* The number of bytes to write is LEN but check_access will alsoa
   check SRCLEN if LEN's value isn't known.  */
return check_access (exp, /*dstwrite=*/NULL_TREE(tree) __null, maxread, srclen,
       objsize, data.mode, &data);
4054}

4056/* Expand expression EXP, which is a call to the strncpy builtin.  Return
 NULL_RTX if we failed the caller should emit a normal call.  */

4059static rtx
4060expand_builtin_strncpy (tree exp, rtx target)
4061{
location_t loc = EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0));

if (!validate_arglist (exp,
	 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;
tree dest = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4067, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4067, __FUNCTION__)))));
tree src = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4068, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4068, __FUNCTION__)))));
/* The number of bytes to write (not the maximum).  */
tree len = CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4070, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4070, __FUNCTION__)))));

/* The length of the source sequence.  */
tree slen = c_strlen (src, 1);

/* We must be passed a constant len and src parameter.  */
if (!tree_fits_uhwi_p (len) || !slen || !tree_fits_uhwi_p (slen))
  return NULL_RTX(rtx) 0;

slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1)size_int_kind (1, stk_ssizetype));

/* We're required to pad with trailing zeros if the requested
   len is greater than strlen(s2)+1.  In that case try to
   use store_by_pieces, if it fails, punt.  */
if (tree_int_cst_lt (slen, len))
  {
    unsigned int dest_align = get_pointer_alignment (dest);
    const char *p = c_getstr (src);
    rtx dest_mem;

    if (!p || dest_align == 0 || !tree_fits_uhwi_p (len)
 || !can_store_by_pieces (tree_to_uhwi (len),
		   builtin_strncpy_read_str,
		   CONST_CAST (char *, p)(const_cast<char *> ((p))),
		   dest_align, false))
return NULL_RTX(rtx) 0;

    dest_mem = get_memory_rtx (dest, len);
    store_by_pieces (dest_mem, tree_to_uhwi (len),
       builtin_strncpy_read_str,
       CONST_CAST (char *, p)(const_cast<char *> ((p))), dest_align, false,
       RETURN_BEGIN);
    dest_mem = force_operand (XEXP (dest_mem, 0)(((dest_mem)->u.fld[0]).rt_rtx), target);
    dest_mem = convert_memory_address (ptr_mode, dest_mem)convert_memory_address_addr_space ((ptr_mode), (dest_mem), 0);
    return dest_mem;
  }

return NULL_RTX(rtx) 0;
4108}

4110/* Return the RTL of a register in MODE generated from PREV in the
 previous iteration.  */

4113static rtx
4114gen_memset_value_from_prev (by_pieces_prev *prev, fixed_size_mode mode)
4115{
rtx target = nullptr;
if (prev != nullptr && prev->data != nullptr)
  {
    /* Use the previous data in the same mode.  */
    if (prev->mode == mode)
return prev->data;

    fixed_size_mode prev_mode = prev->mode;

    /* Don't use the previous data to write QImode if it is in a
vector mode.  */
    if (VECTOR_MODE_P (prev_mode)(((enum mode_class) mode_class[prev_mode]) == MODE_VECTOR_BOOL
 || ((enum mode_class) mode_class[prev_mode]) == MODE_VECTOR_INT
 || ((enum mode_class) mode_class[prev_mode]) == MODE_VECTOR_FLOAT
 || ((enum mode_class) mode_class[prev_mode]) == MODE_VECTOR_FRACT
 || ((enum mode_class) mode_class[prev_mode]) == MODE_VECTOR_UFRACT
 || ((enum mode_class) mode_class[prev_mode]) == MODE_VECTOR_ACCUM
 || ((enum mode_class) mode_class[prev_mode]) == MODE_VECTOR_UACCUM
) && mode == QImode(scalar_int_mode ((scalar_int_mode::from_int) E_QImode)))
return target;

    rtx prev_rtx = prev->data;

    if (REG_P (prev_rtx)(((enum rtx_code) (prev_rtx)->code) == REG)
 && HARD_REGISTER_P (prev_rtx)((((rhs_regno(prev_rtx))) < 76))
 && lowpart_subreg_regno (REGNO (prev_rtx)(rhs_regno(prev_rtx)), prev_mode, mode) < 0)
{
 /* This case occurs when PREV_MODE is a vector and when
    MODE is too small to store using vector operations.
    After register allocation, the code will need to move the
    lowpart of the vector register into a non-vector register.

    Also, the target has chosen to use a hard register
    instead of going with the default choice of using a
    pseudo register.  We should respect that choice and try to
    avoid creating a pseudo register with the same mode as the
    current hard register.

    In principle, we could just use a lowpart MODE subreg of
    the vector register.  However, the vector register mode might
    be too wide for non-vector registers, and we already know
    that the non-vector mode is too small for vector registers.
    It's therefore likely that we'd need to spill to memory in
    the vector mode and reload the non-vector value from there.

    Try to avoid that by reducing the vector register to the
    smallest size that it can hold.  This should increase the
    chances that non-vector registers can hold both the inner
    and outer modes of the subreg that we generate later.  */
 machine_mode m;
 fixed_size_mode candidate;
 FOR_EACH_MODE_IN_CLASS (m, GET_MODE_CLASS (mode))for (mode_iterator::start (&(m), ((enum mode_class) mode_class
[mode])); mode_iterator::iterate_p (&(m)); mode_iterator::
get_next (&(m)))
   if (is_a<fixed_size_mode> (m, &candidate))
     {
if (GET_MODE_SIZE (candidate)
    >= GET_MODE_SIZE (prev_mode))
  break;
if (GET_MODE_SIZE (candidate) >= GET_MODE_SIZE (mode)
    && lowpart_subreg_regno (REGNO (prev_rtx)(rhs_regno(prev_rtx)),
			     prev_mode, candidate) >= 0)
  {
    target = lowpart_subreg (candidate, prev_rtx,
			     prev_mode);
    prev_rtx = target;
    prev_mode = candidate;
    break;
  }
     }
 if (target == nullptr)
   prev_rtx = copy_to_reg (prev_rtx);
}

    target = lowpart_subreg (mode, prev_rtx, prev_mode);
  }
return target;
4184}

4186/* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
 bytes from constant string DATA + OFFSET and return it as target
 constant.  If PREV isn't nullptr, it has the RTL info from the
 previous iteration.  */

4191rtx
4192builtin_memset_read_str (void *data, void *prev,
	 HOST_WIDE_INTlong offset ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
	 fixed_size_mode mode)
4195{
const char *c = (const char *) data;
unsigned int size = GET_MODE_SIZE (mode);

rtx target = gen_memset_value_from_prev ((by_pieces_prev *) prev,
			   mode);
if (target != nullptr)
  return target;
rtx src = gen_int_mode (*c, QImode(scalar_int_mode ((scalar_int_mode::from_int) E_QImode)));

if (VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM))
  {
    gcc_assert (GET_MODE_INNER (mode) == QImode)((void)(!((mode_to_inner (mode)) == (scalar_int_mode ((scalar_int_mode
::from_int) E_QImode))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4207, __FUNCTION__), 0 : 0));

    rtx const_vec = gen_const_vec_duplicate (mode, src);
    if (prev == NULL__null)
/* Return CONST_VECTOR when called by a query function.  */
return const_vec;

    /* Use the move expander with CONST_VECTOR.  */
    target = gen_reg_rtx (mode);
    emit_move_insn (target, const_vec);
    return target;
  }

char *p = XALLOCAVEC (char, size)((char *) __builtin_alloca(sizeof (char) * (size)));

memset (p, *c, size);

/* Vector modes should be handled above.  */
return c_readstr (p, as_a <scalar_int_mode> (mode));
4226}

4228/* Callback routine for store_by_pieces.  Return the RTL of a register
 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
 char value given in the RTL register data.  For example, if mode is
 4 bytes wide, return the RTL for 0x01010101*data.  If PREV isn't
 nullptr, it has the RTL info from the previous iteration.  */

4234static rtx
4235builtin_memset_gen_str (void *data, void *prev,
	HOST_WIDE_INTlong offset ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
	fixed_size_mode mode)
4238{
rtx target, coeff;
size_t size;
char *p;

size = GET_MODE_SIZE (mode);
if (size == 1)
  return (rtx) data;

target = gen_memset_value_from_prev ((by_pieces_prev *) prev, mode);
if (target != nullptr)
  return target;

if (VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM))
  {
    gcc_assert (GET_MODE_INNER (mode) == QImode)((void)(!((mode_to_inner (mode)) == (scalar_int_mode ((scalar_int_mode
::from_int) E_QImode))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4253, __FUNCTION__), 0 : 0));

    /* vec_duplicate_optab is a precondition to pick a vector mode for
the memset expander.  */
    insn_code icode = optab_handler (vec_duplicate_optab, mode);

    target = gen_reg_rtx (mode);
    class expand_operand ops[2];
    create_output_operand (&ops[0], target, mode);
    create_input_operand (&ops[1], (rtx) data, QImode(scalar_int_mode ((scalar_int_mode::from_int) E_QImode)));
    expand_insn (icode, 2, ops);
    if (!rtx_equal_p (target, ops[0].value))
emit_move_insn (target, ops[0].value);

    return target;
  }

p = XALLOCAVEC (char, size)((char *) __builtin_alloca(sizeof (char) * (size)));
memset (p, 1, size);
/* Vector modes should be handled above.  */
coeff = c_readstr (p, as_a <scalar_int_mode> (mode));

target = convert_to_mode (mode, (rtx) data, 1);
target = expand_mult (mode, target, coeff, NULL_RTX(rtx) 0, 1);
return force_reg (mode, target);
4278}

4280/* Expand expression EXP, which is a call to the memset builtin.  Return
 NULL_RTX if we failed the caller should emit a normal call, otherwise
 try to get the result in TARGET, if convenient (and in mode MODE if that's
 convenient).  */

4285rtx
4286expand_builtin_memset (tree exp, rtx target, machine_mode mode)
4287{
if (!validate_arglist (exp,
1
Assuming the condition is false→
2
←
Taking false branch→
		 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

tree dest = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4292, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4292, __FUNCTION__)))));
tree val = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4293, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4293, __FUNCTION__)))));
tree len = CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4294, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4294, __FUNCTION__)))));

return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3
←
Calling 'expand_builtin_memset_args'→
4297}

4299/* Try to store VAL (or, if NULL_RTX, VALC) in LEN bytes starting at TO.
 Return TRUE if successful, FALSE otherwise.  TO is assumed to be
 aligned at an ALIGN-bits boundary.  LEN must be a multiple of
 1<<CTZ_LEN between MIN_LEN and MAX_LEN.

 The strategy is to issue one store_by_pieces for each power of two,
 from most to least significant, guarded by a test on whether there
 are at least that many bytes left to copy in LEN.

 ??? Should we skip some powers of two in favor of loops?  Maybe start
 at the max of TO/LEN/word alignment, at least when optimizing for
 size, instead of ensuring O(log len) dynamic compares?  */

4312bool
4313try_store_by_multiple_pieces (rtx to, rtx len, unsigned int ctz_len,
	      unsigned HOST_WIDE_INTlong min_len,
	      unsigned HOST_WIDE_INTlong max_len,
	      rtx val, char valc, unsigned int align)
4317{
int max_bits = floor_log2 (max_len);
18
←
'max_bits' initialized here→
int min_bits = floor_log2 (min_len);
int sctz_len = ctz_len;

gcc_checking_assert (sctz_len >= 0)((void)(!(sctz_len >= 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4322, __FUNCTION__), 0 : 0));
19
←
Assuming 'sctz_len' is >= 0→
20
←
'?' condition is false→

if (val)
21
←
Assuming 'val' is null→
  valc = 1;

/* Bits more significant than TST_BITS are part of the shared prefix
   in the binary representation of both min_len and max_len.  Since
   they're identical, we don't need to test them in the loop.  */
int tst_bits = (max_bits != min_bits ? max_bits
22
←
Taking false branch→
23
←
Assuming 'max_bits' is equal to 'min_bits'→
24
←
'?' condition is false→
  : floor_log2 (max_len ^ min_len));

/* Check whether it's profitable to start by storing a fixed BLKSIZE
   bytes, to lower max_bits.  In the unlikely case of a constant LEN
   (implied by identical MAX_LEN and MIN_LEN), we want to issue a
   single store_by_pieces, but otherwise, select the minimum multiple
   of the ALIGN (in bytes) and of the MCD of the possible LENs, that
   brings MAX_LEN below TST_BITS, if that's lower than min_len.  */
unsigned HOST_WIDE_INTlong blksize;
if (max_len24.1
'max_len' is > 'min_len'
 > min_len)
  {
    unsigned HOST_WIDE_INTlong alrng = MAX (HOST_WIDE_INT_1U << ctz_len,((1UL << ctz_len) > (align / (8)) ? (1UL << ctz_len
) : (align / (8)))
25
←
Taking true branch→
26
←
Assuming the condition is false→
27
←
'?' condition is false→
			  align / BITS_PER_UNIT)((1UL << ctz_len) > (align / (8)) ? (1UL << ctz_len
) : (align / (8)));
    blksize = max_len - (HOST_WIDE_INT_1U1UL << tst_bits) + alrng;
    blksize &= ~(alrng - 1);
  }
else if (max_len == min_len)
  blksize = max_len;
else
  /* Huh, max_len < min_len?  Punt.  See pr100843.c.  */
  return false;
if (min_len >= blksize)
28
←
Assuming 'min_len' is < 'blksize'→
29
←
Taking false branch→
  {
    min_len -= blksize;
    min_bits = floor_log2 (min_len);
    max_len -= blksize;
    max_bits = floor_log2 (max_len);

    tst_bits = (max_bits != min_bits ? max_bits
 : floor_log2 (max_len ^ min_len));
  }
else
  blksize = 0;

/* Check that we can use store by pieces for the maximum store count
   we may issue (initial fixed-size block, plus conditional
   power-of-two-sized from max_bits to ctz_len.  */
unsigned HOST_WIDE_INTlong xlenest = blksize;
if (max_bits29.1
'max_bits' is < 0
 >= 0)
30
←
Taking false branch→
  xlenest += ((HOST_WIDE_INT_1U1UL << max_bits) * 2
- (HOST_WIDE_INT_1U1UL << ctz_len));
if (!can_store_by_pieces (xlenest, builtin_memset_read_str,
31
←
Assuming the condition is false→
32
←
Taking false branch→
	    &valc, align, true))
  return false;

by_pieces_constfn constfun;
void *constfundata;
if (val32.1
'val' is null
)
33
←
Taking false branch→
  {
    constfun = builtin_memset_gen_str;
    constfundata = val = force_reg (TYPE_MODE (unsigned_char_type_node)((((enum tree_code) ((tree_class_check ((integer_types[itk_unsigned_char
]), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4381, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (integer_types[itk_unsigned_char]) : (integer_types[itk_unsigned_char
])->type_common.mode),
		      val);
  }
else
  {
    constfun = builtin_memset_read_str;
    constfundata = &valc;
  }

rtx ptr = copy_addr_to_reg (XEXP (to, 0)(((to)->u.fld[0]).rt_rtx));
rtx rem = copy_to_mode_reg (ptr_mode, convert_to_mode (ptr_mode, len, 0));
to = replace_equiv_address (to, ptr);
set_mem_align (to, align);

if (blksize33.1
'blksize' is 0
)
34
←
Taking false branch→
  {
    to = store_by_pieces (to, blksize,
	    constfun, constfundata,
	    align, true,
	    max_len != 0 ? RETURN_END : RETURN_BEGIN);
    if (max_len == 0)
return true;

    /* Adjust PTR, TO and REM.  Since TO's address is likely
PTR+offset, we have to replace it.  */
    emit_move_insn (ptr, force_operand (XEXP (to, 0)(((to)->u.fld[0]).rt_rtx), NULL_RTX(rtx) 0));
    to = replace_equiv_address (to, ptr);
    rtx rem_minus_blksize = plus_constant (ptr_mode, rem, -blksize);
    emit_move_insn (rem, force_operand (rem_minus_blksize, NULL_RTX(rtx) 0));
  }

/* Iterate over power-of-two block sizes from the maximum length to
   the least significant bit possibly set in the length.  */
for (int i = max_bits; i35.1
'i' is >= 'sctz_len'
 >= sctz_len; i--)
35
←
'i' initialized to -1→
36
←
Loop condition is true.  Entering loop body→
  {
    rtx_code_label *label = NULL__null;
    blksize = HOST_WIDE_INT_1U1UL << i;
37
←
The result of the left shift is undefined because the right operand is negative

    /* If we're past the bits shared between min_ and max_len, expand
a test on the dynamic length, comparing it with the
BLKSIZE.  */
    if (i <= tst_bits)
{
 label = gen_label_rtx ();
 emit_cmp_and_jump_insns (rem, GEN_INT (blksize)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (blksize)), LT, NULL__null,
		   ptr_mode, 1, label,
		   profile_probability::even ());
}
    /* If we are at a bit that is in the prefix shared by min_ and
max_len, skip this BLKSIZE if the bit is clear.  */
    else if ((max_len & blksize) == 0)
continue;

    /* Issue a store of BLKSIZE bytes.  */
    to = store_by_pieces (to, blksize,
	    constfun, constfundata,
	    align, true,
	    i != sctz_len ? RETURN_END : RETURN_BEGIN);

    /* Adjust REM and PTR, unless this is the last iteration.  */
    if (i != sctz_len)
{
 emit_move_insn (ptr, force_operand (XEXP (to, 0)(((to)->u.fld[0]).rt_rtx), NULL_RTX(rtx) 0));
 to = replace_equiv_address (to, ptr);
 rtx rem_minus_blksize = plus_constant (ptr_mode, rem, -blksize);
 emit_move_insn (rem, force_operand (rem_minus_blksize, NULL_RTX(rtx) 0));
}

    if (label)
{
 emit_label (label);

 /* Given conditional stores, the offset can no longer be
    known, so clear it.  */
 clear_mem_offset (to);
}
  }

return true;
4460}

4462/* Helper function to do the actual work for expand_builtin_memset.  The
 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
 so that this can also be called without constructing an actual CALL_EXPR.
 The other arguments and return value are the same as for
 expand_builtin_memset.  */

4468static rtx
4469expand_builtin_memset_args (tree dest, tree val, tree len,
	    rtx target, machine_mode mode, tree orig_exp)
4471{
tree fndecl, fn;
enum built_in_function fcode;
machine_mode val_mode;
char c;
unsigned int dest_align;
rtx dest_mem, dest_addr, len_rtx;
HOST_WIDE_INTlong expected_size = -1;
unsigned int expected_align = 0;
unsigned HOST_WIDE_INTlong min_size;
unsigned HOST_WIDE_INTlong max_size;
unsigned HOST_WIDE_INTlong probable_max_size;

dest_align = get_pointer_alignment (dest);

/* If DEST is not a pointer type, don't do this operation in-line.  */
if (dest_align == 0)
4
←
Assuming 'dest_align' is not equal to 0→
5
←
Taking false branch→
  return NULL_RTX(rtx) 0;

if (currently_expanding_gimple_stmt)
6
←
Assuming 'currently_expanding_gimple_stmt' is null→
7
←
Taking false branch→
  stringop_block_profile (currently_expanding_gimple_stmt,
	    &expected_align, &expected_size);

if (expected_align7.1
'expected_align' is < 'dest_align'
 < dest_align)
8
←
Taking true branch→
  expected_align = dest_align;

/* If the LEN parameter is zero, return DEST.  */
if (integer_zerop (len))
9
←
Assuming the condition is false→
10
←
Taking false branch→
  {
    /* Evaluate and ignore VAL in case it has side-effects.  */
    expand_expr (val, const0_rtx(const_int_rtx[64]), VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);
    return expand_expr (dest, target, mode, EXPAND_NORMAL);
  }

/* Stabilize the arguments in case we fail.  */
dest = builtin_save_expr (dest);
val = builtin_save_expr (val);
len = builtin_save_expr (len);

len_rtx = expand_normal (len);
determine_block_size (len, len_rtx, &min_size, &max_size,
	&probable_max_size);
dest_mem = get_memory_rtx (dest, len);
val_mode = TYPE_MODE (unsigned_char_type_node)((((enum tree_code) ((tree_class_check ((integer_types[itk_unsigned_char
]), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4514, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (integer_types[itk_unsigned_char]) : (integer_types[itk_unsigned_char
])->type_common.mode);
11
←
Assuming field 'code' is not equal to VECTOR_TYPE→
12
←
'?' condition is false→

if (TREE_CODE (val)((enum tree_code) (val)->base.code) != INTEGER_CST
13
←
Assuming field 'code' is equal to INTEGER_CST→
14
←
Taking true branch→
    || target_char_cast (val, &c))
  {
    rtx val_rtx;

    val_rtx = expand_normal (val);
    val_rtx = convert_to_mode (val_mode, val_rtx, 0);

    /* Assume that we can memset by pieces if we can store
     * the coefficients by pieces (in the required modes).
     * We can't pass builtin_memset_gen_str as that emits RTL.  */
    c = 1;
    if (tree_fits_uhwi_p (len)
15
←
Assuming the condition is false→
 && can_store_by_pieces (tree_to_uhwi (len),
		  builtin_memset_read_str, &c, dest_align,
		  true))
{
 val_rtx = force_reg (val_mode, val_rtx);
 store_by_pieces (dest_mem, tree_to_uhwi (len),
	   builtin_memset_gen_str, val_rtx, dest_align,
	   true, RETURN_BEGIN);
}
    else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
16
←
Assuming the condition is true→
			dest_align, expected_align,
			expected_size, min_size, max_size,
			probable_max_size)
      && !try_store_by_multiple_pieces (dest_mem, len_rtx,
17
←
Calling 'try_store_by_multiple_pieces'→
				 tree_ctz (len),
				 min_size, max_size,
				 val_rtx, 0,
				 dest_align))
goto do_libcall;

    dest_mem = force_operand (XEXP (dest_mem, 0)(((dest_mem)->u.fld[0]).rt_rtx), NULL_RTX(rtx) 0);
    dest_mem = convert_memory_address (ptr_mode, dest_mem)convert_memory_address_addr_space ((ptr_mode), (dest_mem), 0);
    return dest_mem;
  }

if (c)
  {
    if (tree_fits_uhwi_p (len)
 && can_store_by_pieces (tree_to_uhwi (len),
		  builtin_memset_read_str, &c, dest_align,
		  true))
store_by_pieces (dest_mem, tree_to_uhwi (len),
	 builtin_memset_read_str, &c, dest_align, true,
	 RETURN_BEGIN);
    else if (!set_storage_via_setmem (dest_mem, len_rtx,
			gen_int_mode (c, val_mode),
			dest_align, expected_align,
			expected_size, min_size, max_size,
			probable_max_size)
      && !try_store_by_multiple_pieces (dest_mem, len_rtx,
				 tree_ctz (len),
				 min_size, max_size,
				 NULL_RTX(rtx) 0, c,
				 dest_align))
goto do_libcall;

    dest_mem = force_operand (XEXP (dest_mem, 0)(((dest_mem)->u.fld[0]).rt_rtx), NULL_RTX(rtx) 0);
    dest_mem = convert_memory_address (ptr_mode, dest_mem)convert_memory_address_addr_space ((ptr_mode), (dest_mem), 0);
    return dest_mem;
  }

set_mem_align (dest_mem, dest_align);
dest_addr = clear_storage_hints (dest_mem, len_rtx,
		   CALL_EXPR_TAILCALL (orig_exp)((tree_check ((orig_exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4582, __FUNCTION__, (CALL_EXPR)))->base.addressable_flag
)
		   ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
		   expected_align, expected_size,
		   min_size, max_size,
		   probable_max_size, tree_ctz (len));

if (dest_addr == 0)
  {
    dest_addr = force_operand (XEXP (dest_mem, 0)(((dest_mem)->u.fld[0]).rt_rtx), NULL_RTX(rtx) 0);
    dest_addr = convert_memory_address (ptr_mode, dest_addr)convert_memory_address_addr_space ((ptr_mode), (dest_addr), 0
);
  }

return dest_addr;

do_libcall:
fndecl = get_callee_fndecl (orig_exp);
fcode = DECL_FUNCTION_CODE (fndecl);
if (fcode == BUILT_IN_MEMSET)
  fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp)((((orig_exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((orig_exp))->base.code))]) >=
 tcc_reference && (tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((orig_exp))->base.code))]) <=
 tcc_expression)) ? (orig_exp)->exp.locus : ((location_t) 0
)), fndecl, 3,
		dest, val, len);
else if (fcode == BUILT_IN_BZERO)
  fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp)((((orig_exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((orig_exp))->base.code))]) >=
 tcc_reference && (tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((orig_exp))->base.code))]) <=
 tcc_expression)) ? (orig_exp)->exp.locus : ((location_t) 0
)), fndecl, 2,
		dest, len);
else
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4606, __FUNCTION__));
gcc_assert (TREE_CODE (fn) == CALL_EXPR)((void)(!(((enum tree_code) (fn)->base.code) == CALL_EXPR)
 ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4607, __FUNCTION__), 0 : 0));
CALL_EXPR_TAILCALL (fn)((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4608, __FUNCTION__, (CALL_EXPR)))->base.addressable_flag
) = CALL_EXPR_TAILCALL (orig_exp)((tree_check ((orig_exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4608, __FUNCTION__, (CALL_EXPR)))->base.addressable_flag
);
return expand_call (fn, target, target == const0_rtx(const_int_rtx[64]));
4610}

4612/* Expand expression EXP, which is a call to the bzero builtin.  Return
 NULL_RTX if we failed the caller should emit a normal call.  */

4615static rtx
4616expand_builtin_bzero (tree exp)
4617{
if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

tree dest = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4621, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4621, __FUNCTION__)))));
tree size = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4622, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4622, __FUNCTION__)))));

/* New argument list transforming bzero(ptr x, int y) to
   memset(ptr x, int 0, size_t y).   This is done this way
   so that if it isn't expanded inline, we fallback to
   calling bzero instead of memset.  */

location_t loc = EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0));

return expand_builtin_memset_args (dest, integer_zero_nodeglobal_trees[TI_INTEGER_ZERO],
		     fold_convert_loc (loc,
				       size_type_nodeglobal_trees[TI_SIZE_TYPE], size),
		     const0_rtx(const_int_rtx[64]), VOIDmode((void) 0, E_VOIDmode), exp);
4635}

4637/* Try to expand cmpstr operation ICODE with the given operands.
 Return the result rtx on success, otherwise return null.  */

4640static rtx
4641expand_cmpstr (insn_code icode, rtx target, rtx arg1_rtx, rtx arg2_rtx,
      HOST_WIDE_INTlong align)
4643{
machine_mode insn_mode = insn_data[icode].operand[0].mode;

if (target && (!REG_P (target)(((enum rtx_code) (target)->code) == REG) || HARD_REGISTER_P (target)((((rhs_regno(target))) < 76))))
  target = NULL_RTX(rtx) 0;

class expand_operand ops[4];
create_output_operand (&ops[0], target, insn_mode);
create_fixed_operand (&ops[1], arg1_rtx);
create_fixed_operand (&ops[2], arg2_rtx);
create_integer_operand (&ops[3], align);
if (maybe_expand_insn (icode, 4, ops))
  return ops[0].value;
return NULL_RTX(rtx) 0;
4657}

4659/* Expand expression EXP, which is a call to the memcmp built-in function.
 Return NULL_RTX if we failed and the caller should emit a normal call,
 otherwise try to get the result in TARGET, if convenient.
 RESULT_EQ is true if we can relax the returned value to be either zero
 or nonzero, without caring about the sign.  */

4665static rtx
4666expand_builtin_memcmp (tree exp, rtx target, bool result_eq)
4667{
if (!validate_arglist (exp,
		 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

tree arg1 = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4672, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4672, __FUNCTION__)))));
tree arg2 = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4673, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4673, __FUNCTION__)))));
tree len = CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4674, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4674, __FUNCTION__)))));

/* Due to the performance benefit, always inline the calls first
   when result_eq is false.  */
rtx result = NULL_RTX(rtx) 0;
enum built_in_function fcode = DECL_FUNCTION_CODE (get_callee_fndecl (exp));
if (!result_eq && fcode != BUILT_IN_BCMP)
  {
    result = inline_expand_builtin_bytecmp (exp, target);
    if (result)
return result;
  }

machine_mode mode = TYPE_MODE (TREE_TYPE (exp))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4687, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4687, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4687, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4687, __FUNCTION__))->typed.type))->type_common.mode);
location_t loc = EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0));

unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT(8);
unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT(8);

/* If we don't have POINTER_TYPE, call the function.  */
if (arg1_align == 0 || arg2_align == 0)
  return NULL_RTX(rtx) 0;

rtx arg1_rtx = get_memory_rtx (arg1, len);
rtx arg2_rtx = get_memory_rtx (arg2, len);
rtx len_rtx = expand_normal (fold_convert_loc (loc, sizetypesizetype_tab[(int) stk_sizetype], len));

/* Set MEM_SIZE as appropriate.  */
if (CONST_INT_P (len_rtx)(((enum rtx_code) (len_rtx)->code) == CONST_INT))
  {
    set_mem_size (arg1_rtx, INTVAL (len_rtx)((len_rtx)->u.hwint[0]));
    set_mem_size (arg2_rtx, INTVAL (len_rtx)((len_rtx)->u.hwint[0]));
  }

by_pieces_constfn constfn = NULL__null;

/* Try to get the byte representation of the constant ARG2 (or, only
   when the function's result is used for equality to zero, ARG1)
   points to, with its byte size in NBYTES.  */
unsigned HOST_WIDE_INTlong nbytes;
const char *rep = getbyterep (arg2, &nbytes);
if (result_eq && rep == NULL__null)
  {
    /* For equality to zero the arguments are interchangeable.  */
    rep = getbyterep (arg1, &nbytes);
    if (rep != NULL__null)
std::swap (arg1_rtx, arg2_rtx);
  }

/* If the function's constant bound LEN_RTX is less than or equal
   to the byte size of the representation of the constant argument,
   and if block move would be done by pieces, we can avoid loading
   the bytes from memory and only store the computed constant result.  */
if (rep
    && CONST_INT_P (len_rtx)(((enum rtx_code) (len_rtx)->code) == CONST_INT)
    && (unsigned HOST_WIDE_INTlong) INTVAL (len_rtx)((len_rtx)->u.hwint[0]) <= nbytes)
  constfn = builtin_memcpy_read_str;

result = emit_block_cmp_hints (arg1_rtx, arg2_rtx, len_rtx,
		 TREE_TYPE (len)((contains_struct_check ((len), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4733, __FUNCTION__))->typed.type), target,
		 result_eq, constfn,
		 CONST_CAST (char *, rep)(const_cast<char *> ((rep))));

if (result)
  {
    /* Return the value in the proper mode for this function.  */
    if (GET_MODE (result)((machine_mode) (result)->mode) == mode)
return result;

    if (target != 0)
{
 convert_move (target, result, 0);
 return target;
}

    return convert_to_mode (mode, result, 0);
  }

return NULL_RTX(rtx) 0;
4753}

4755/* Expand expression EXP, which is a call to the strcmp builtin.  Return NULL_RTX
 if we failed the caller should emit a normal call, otherwise try to get
 the result in TARGET, if convenient.  */

4759static rtx
4760expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED__attribute__ ((__unused__)) rtx target)
4761{
if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

tree arg1 = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4765, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4765, __FUNCTION__)))));
tree arg2 = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4766, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4766, __FUNCTION__)))));

/* Due to the performance benefit, always inline the calls first.  */
rtx result = NULL_RTX(rtx) 0;
result = inline_expand_builtin_bytecmp (exp, target);
if (result)
  return result;

insn_code cmpstr_icode = direct_optab_handler (cmpstr_optab, SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode)));
insn_code cmpstrn_icode = direct_optab_handler (cmpstrn_optab, SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode)));
if (cmpstr_icode == CODE_FOR_nothing && cmpstrn_icode == CODE_FOR_nothing)
  return NULL_RTX(rtx) 0;

unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT(8);
unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT(8);

/* If we don't have POINTER_TYPE, call the function.  */
if (arg1_align == 0 || arg2_align == 0)
  return NULL_RTX(rtx) 0;

/* Stabilize the arguments in case gen_cmpstr(n)si fail.  */
arg1 = builtin_save_expr (arg1);
arg2 = builtin_save_expr (arg2);

rtx arg1_rtx = get_memory_rtx (arg1, NULL__null);
rtx arg2_rtx = get_memory_rtx (arg2, NULL__null);

/* Try to call cmpstrsi.  */
if (cmpstr_icode != CODE_FOR_nothing)
  result = expand_cmpstr (cmpstr_icode, target, arg1_rtx, arg2_rtx,
	    MIN (arg1_align, arg2_align)((arg1_align) < (arg2_align) ? (arg1_align) : (arg2_align)
));

/* Try to determine at least one length and call cmpstrnsi.  */
if (!result && cmpstrn_icode != CODE_FOR_nothing)
  {
    tree len;
    rtx arg3_rtx;

    tree len1 = c_strlen (arg1, 1);
    tree len2 = c_strlen (arg2, 1);

    if (len1)
len1 = size_binop (PLUS_EXPR, ssize_int (1), len1)size_binop_loc (((location_t) 0), PLUS_EXPR, size_int_kind (1
, stk_ssizetype), len1);
    if (len2)
len2 = size_binop (PLUS_EXPR, ssize_int (1), len2)size_binop_loc (((location_t) 0), PLUS_EXPR, size_int_kind (1
, stk_ssizetype), len2);

    /* If we don't have a constant length for the first, use the length
of the second, if we know it.  We don't require a constant for
this case; some cost analysis could be done if both are available
but neither is constant.  For now, assume they're equally cheap,
unless one has side effects.  If both strings have constant lengths,
use the smaller.  */

    if (!len1)
len = len2;
    else if (!len2)
len = len1;
    else if (TREE_SIDE_EFFECTS (len1)((non_type_check ((len1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4823, __FUNCTION__))->base.side_effects_flag))
len = len2;
    else if (TREE_SIDE_EFFECTS (len2)((non_type_check ((len2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4825, __FUNCTION__))->base.side_effects_flag))
len = len1;
    else if (TREE_CODE (len1)((enum tree_code) (len1)->base.code) != INTEGER_CST)
len = len2;
    else if (TREE_CODE (len2)((enum tree_code) (len2)->base.code) != INTEGER_CST)
len = len1;
    else if (tree_int_cst_lt (len1, len2))
len = len1;
    else
len = len2;

    /* If both arguments have side effects, we cannot optimize.  */
    if (len && !TREE_SIDE_EFFECTS (len)((non_type_check ((len), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4837, __FUNCTION__))->base.side_effects_flag))
{
 arg3_rtx = expand_normal (len);
 result = expand_cmpstrn_or_cmpmem
   (cmpstrn_icode, target, arg1_rtx, arg2_rtx, TREE_TYPE (len)((contains_struct_check ((len), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4841, __FUNCTION__))->typed.type),
    arg3_rtx, MIN (arg1_align, arg2_align)((arg1_align) < (arg2_align) ? (arg1_align) : (arg2_align)
));
}
  }

tree fndecl = get_callee_fndecl (exp);
if (result)
  {
    /* Return the value in the proper mode for this function.  */
    machine_mode mode = TYPE_MODE (TREE_TYPE (exp))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4850, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4850, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4850, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4850, __FUNCTION__))->typed.type))->type_common.mode);
    if (GET_MODE (result)((machine_mode) (result)->mode) == mode)
return result;
    if (target == 0)
return convert_to_mode (mode, result, 0);
    convert_move (target, result, 0);
    return target;
  }

/* Expand the library call ourselves using a stabilized argument
   list to avoid re-evaluating the function's arguments twice.  */
tree fn = build_call_nofold_loc (EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0)), fndecl, 2, arg1, arg2);
copy_warning (fn, exp);
gcc_assert (TREE_CODE (fn) == CALL_EXPR)((void)(!(((enum tree_code) (fn)->base.code) == CALL_EXPR)
 ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4863, __FUNCTION__), 0 : 0));
CALL_EXPR_TAILCALL (fn)((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4864, __FUNCTION__, (CALL_EXPR)))->base.addressable_flag
) = CALL_EXPR_TAILCALL (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4864, __FUNCTION__, (CALL_EXPR)))->base.addressable_flag
);
return expand_call (fn, target, target == const0_rtx(const_int_rtx[64]));
4866}

4868/* Expand expression EXP, which is a call to the strncmp builtin. Return
 NULL_RTX if we failed the caller should emit a normal call, otherwise
 try to get the result in TARGET, if convenient.  */

4872static rtx
4873expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED__attribute__ ((__unused__)) rtx target,
	ATTRIBUTE_UNUSED__attribute__ ((__unused__)) machine_mode mode)
4875{
if (!validate_arglist (exp,
		 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
  return NULL_RTX(rtx) 0;

tree arg1 = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4880, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4880, __FUNCTION__)))));
tree arg2 = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4881, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4881, __FUNCTION__)))));
tree arg3 = CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4882, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4882, __FUNCTION__)))));

location_t loc = EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0));
tree len1 = c_strlen (arg1, 1);
tree len2 = c_strlen (arg2, 1);

/* Due to the performance benefit, always inline the calls first.  */
rtx result = NULL_RTX(rtx) 0;
result = inline_expand_builtin_bytecmp (exp, target);
if (result)
  return result;

/* If c_strlen can determine an expression for one of the string
   lengths, and it doesn't have side effects, then emit cmpstrnsi
   using length MIN(strlen(string)+1, arg3).  */
insn_code cmpstrn_icode = direct_optab_handler (cmpstrn_optab, SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode)));
if (cmpstrn_icode == CODE_FOR_nothing)
  return NULL_RTX(rtx) 0;

tree len;

unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT(8);
unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT(8);

if (len1)
  len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1)size_int_kind (1, stk_ssizetype), len1);
if (len2)
  len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1)size_int_kind (1, stk_ssizetype), len2);

tree len3 = fold_convert_loc (loc, sizetypesizetype_tab[(int) stk_sizetype], arg3);

/* If we don't have a constant length for the first, use the length
   of the second, if we know it.  If neither string is constant length,
   use the given length argument.  We don't require a constant for
   this case; some cost analysis could be done if both are available
   but neither is constant.  For now, assume they're equally cheap,
   unless one has side effects.  If both strings have constant lengths,
   use the smaller.  */

if (!len1 && !len2)
  len = len3;
else if (!len1)
  len = len2;
else if (!len2)
  len = len1;
else if (TREE_SIDE_EFFECTS (len1)((non_type_check ((len1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4927, __FUNCTION__))->base.side_effects_flag))
  len = len2;
else if (TREE_SIDE_EFFECTS (len2)((non_type_check ((len2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4929, __FUNCTION__))->base.side_effects_flag))
  len = len1;
else if (TREE_CODE (len1)((enum tree_code) (len1)->base.code) != INTEGER_CST)
  len = len2;
else if (TREE_CODE (len2)((enum tree_code) (len2)->base.code) != INTEGER_CST)
  len = len1;
else if (tree_int_cst_lt (len1, len2))
  len = len1;
else
  len = len2;

/* If we are not using the given length, we must incorporate it here.
   The actual new length parameter will be MIN(len,arg3) in this case.  */
if (len != len3)
  {
    len = fold_convert_loc (loc, sizetypesizetype_tab[(int) stk_sizetype], len);
    len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len)((contains_struct_check ((len), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4945, __FUNCTION__))->typed.type), len, len3);
  }
rtx arg1_rtx = get_memory_rtx (arg1, len);
rtx arg2_rtx = get_memory_rtx (arg2, len);
rtx arg3_rtx = expand_normal (len);
result = expand_cmpstrn_or_cmpmem (cmpstrn_icode, target, arg1_rtx,
		     arg2_rtx, TREE_TYPE (len)((contains_struct_check ((len), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4951, __FUNCTION__))->typed.type), arg3_rtx,
		     MIN (arg1_align, arg2_align)((arg1_align) < (arg2_align) ? (arg1_align) : (arg2_align)
));

tree fndecl = get_callee_fndecl (exp);
if (result)
  {
    /* Return the value in the proper mode for this function.  */
    mode = TYPE_MODE (TREE_TYPE (exp))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4958, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4958, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4958, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4958, __FUNCTION__))->typed.type))->type_common.mode);
    if (GET_MODE (result)((machine_mode) (result)->mode) == mode)
return result;
    if (target == 0)
return convert_to_mode (mode, result, 0);
    convert_move (target, result, 0);
    return target;
  }

/* Expand the library call ourselves using a stabilized argument
   list to avoid re-evaluating the function's arguments twice.  */
tree call = build_call_nofold_loc (loc, fndecl, 3, arg1, arg2, len);
copy_warning (call, exp);
gcc_assert (TREE_CODE (call) == CALL_EXPR)((void)(!(((enum tree_code) (call)->base.code) == CALL_EXPR
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4971, __FUNCTION__), 0 : 0));
CALL_EXPR_TAILCALL (call)((tree_check ((call), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4972, __FUNCTION__, (CALL_EXPR)))->base.addressable_flag
) = CALL_EXPR_TAILCALL (exp)((tree_check ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 4972, __FUNCTION__, (CALL_EXPR)))->base.addressable_flag
);
return expand_call (call, target, target == const0_rtx(const_int_rtx[64]));
4974}

4976/* Expand a call to __builtin_saveregs, generating the result in TARGET,
 if that's convenient.  */

4979rtx
4980expand_builtin_saveregs (void)
4981{
rtx val;
rtx_insn *seq;

/* Don't do __builtin_saveregs more than once in a function.
   Save the result of the first call and reuse it.  */
if (saveregs_value((&x_rtl)->expr.x_saveregs_value) != 0)
  return saveregs_value((&x_rtl)->expr.x_saveregs_value);

/* When this function is called, it means that registers must be
   saved on entry to this function.  So we migrate the call to the
   first insn of this function.  */

start_sequence ();

/* Do whatever the machine needs done in this case.  */
val = targetm.calls.expand_builtin_saveregs ();

seq = get_insns ();
end_sequence ();

saveregs_value((&x_rtl)->expr.x_saveregs_value) = val;

/* Put the insns after the NOTE that starts the function.  If this
   is inside a start_sequence, make the outer-level insn chain current, so
   the code is placed at the start of the function.  */
push_topmost_sequence ();
emit_insn_after (seq, entry_of_function ());
pop_topmost_sequence ();

return val;
5012}

5014/* Expand a call to __builtin_next_arg.  */

5016static rtx
5017expand_builtin_next_arg (void)
5018{
/* Checking arguments is already done in fold_builtin_next_arg
   that must be called before this function.  */
return expand_binop (ptr_mode, add_optab,
       crtl(&x_rtl)->args.internal_arg_pointer,
       crtl(&x_rtl)->args.arg_offset_rtx,
       NULL_RTX(rtx) 0, 0, OPTAB_LIB_WIDEN);
5025}

5027/* Make it easier for the backends by protecting the valist argument
 from multiple evaluations.  */

5030static tree
5031stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
5032{
tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist)((contains_struct_check ((valist), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5033, __FUNCTION__))->typed.type));

/* The current way of determining the type of valist is completely
   bogus.  We should have the information on the va builtin instead.  */
if (!vatype)
  vatype = targetm.fn_abi_va_list (cfun(cfun + 0)->decl);

if (TREE_CODE (vatype)((enum tree_code) (vatype)->base.code) == ARRAY_TYPE)
  {
    if (TREE_SIDE_EFFECTS (valist)((non_type_check ((valist), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5042, __FUNCTION__))->base.side_effects_flag))
valist = save_expr (valist);

    /* For this case, the backends will be expecting a pointer to
vatype, but it's possible we've actually been given an array
(an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
So fix it.  */
    if (TREE_CODE (TREE_TYPE (valist))((enum tree_code) (((contains_struct_check ((valist), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5049, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE)
{
 tree p1 = build_pointer_type (TREE_TYPE (vatype)((contains_struct_check ((vatype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5051, __FUNCTION__))->typed.type));
 valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
}
  }
else
  {
    tree pt = build_pointer_type (vatype);

    if (! needs_lvalue)
{
 if (! TREE_SIDE_EFFECTS (valist)((non_type_check ((valist), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5061, __FUNCTION__))->base.side_effects_flag))
   return valist;

 valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
 TREE_SIDE_EFFECTS (valist)((non_type_check ((valist), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5065, __FUNCTION__))->base.side_effects_flag) = 1;
}

    if (TREE_SIDE_EFFECTS (valist)((non_type_check ((valist), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5068, __FUNCTION__))->base.side_effects_flag))
valist = save_expr (valist);
    valist = fold_build2_loc (loc, MEM_REF,
		vatype, valist, build_int_cst (pt, 0));
  }

return valist;
5075}

5077/* The "standard" definition of va_list is void*.  */

5079tree
5080std_build_builtin_va_list (void)
5081{
return ptr_type_nodeglobal_trees[TI_PTR_TYPE];
5083}

5085/* The "standard" abi va_list is va_list_type_node.  */

5087tree
5088std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
5089{
return va_list_type_nodeglobal_trees[TI_VA_LIST_TYPE];
5091}

5093/* The "standard" type of va_list is va_list_type_node.  */

5095tree
5096std_canonical_va_list_type (tree type)
5097{
tree wtype, htype;

wtype = va_list_type_nodeglobal_trees[TI_VA_LIST_TYPE];
htype = type;

if (TREE_CODE (wtype)((enum tree_code) (wtype)->base.code) == ARRAY_TYPE)
  {
    /* If va_list is an array type, the argument may have decayed
to a pointer type, e.g. by being passed to another function.
In that case, unwrap both types so that we can compare the
underlying records.  */
    if (TREE_CODE (htype)((enum tree_code) (htype)->base.code) == ARRAY_TYPE
 || POINTER_TYPE_P (htype)(((enum tree_code) (htype)->base.code) == POINTER_TYPE || (
(enum tree_code) (htype)->base.code) == REFERENCE_TYPE))
{
 wtype = TREE_TYPE (wtype)((contains_struct_check ((wtype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5112, __FUNCTION__))->typed.type);
 htype = TREE_TYPE (htype)((contains_struct_check ((htype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5113, __FUNCTION__))->typed.type);
}
  }
if (TYPE_MAIN_VARIANT (wtype)((tree_class_check ((wtype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5116, __FUNCTION__))->type_common.main_variant) == TYPE_MAIN_VARIANT (htype)((tree_class_check ((htype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5116, __FUNCTION__))->type_common.main_variant))
  return va_list_type_nodeglobal_trees[TI_VA_LIST_TYPE];

return NULL_TREE(tree) __null;
5120}

5122/* The "standard" implementation of va_start: just assign `nextarg' to
 the variable.  */

5125void
5126std_expand_builtin_va_start (tree valist, rtx nextarg)
5127{
rtx va_r = expand_expr (valist, NULL_RTX(rtx) 0, VOIDmode((void) 0, E_VOIDmode), EXPAND_WRITE);
convert_move (va_r, nextarg, 0);
5130}

5132/* Expand EXP, a call to __builtin_va_start.  */

5134static rtx
5135expand_builtin_va_start (tree exp)
5136{
rtx nextarg;
tree valist;
location_t loc = EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0));

if (call_expr_nargs (exp)(((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
 ((exp), (tcc_vl_exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5141, __FUNCTION__))->exp.operands[0]), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5141, __FUNCTION__)))) - 3) < 2)
  {
    error_at (loc, "too few arguments to function %<va_start%>");
    return const0_rtx(const_int_rtx[64]);
  }

if (fold_builtin_next_arg (exp, true))
  return const0_rtx(const_int_rtx[64]);

nextarg = expand_builtin_next_arg ();
valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5151, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5151, __FUNCTION__))))), 1);

if (targetm.expand_builtin_va_start)
  targetm.expand_builtin_va_start (valist, nextarg);
else
  std_expand_builtin_va_start (valist, nextarg);

return const0_rtx(const_int_rtx[64]);
5159}

5161/* Expand EXP, a call to __builtin_va_end.  */

5163static rtx
5164expand_builtin_va_end (tree exp)
5165{
tree valist = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5166, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5166, __FUNCTION__)))));

/* Evaluate for side effects, if needed.  I hate macros that don't
   do that.  */
if (TREE_SIDE_EFFECTS (valist)((non_type_check ((valist), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5170, __FUNCTION__))->base.side_effects_flag))
  expand_expr (valist, const0_rtx(const_int_rtx[64]), VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);

return const0_rtx(const_int_rtx[64]);
5174}

5176/* Expand EXP, a call to __builtin_va_copy.  We do this as a
 builtin rather than just as an assignment in stdarg.h because of the
 nastiness of array-type va_list types.  */

5180static rtx
5181expand_builtin_va_copy (tree exp)
5182{
tree dst, src, t;
location_t loc = EXPR_LOCATION (exp)((((exp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0));

dst = CALL_EXPR_ARG (exp, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5186, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5186, __FUNCTION__)))));
src = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5187, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5187, __FUNCTION__)))));

dst = stabilize_va_list_loc (loc, dst, 1);
src = stabilize_va_list_loc (loc, src, 0);

gcc_assert (cfun != NULL && cfun->decl != NULL_TREE)((void)(!((cfun + 0) != __null && (cfun + 0)->decl
 != (tree) __null) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5192, __FUNCTION__), 0 : 0));

if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl))((enum tree_code) (targetm.fn_abi_va_list ((cfun + 0)->decl
))->base.code) != ARRAY_TYPE)
  {
    t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun(cfun + 0)->decl), dst, src);
    TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5197, __FUNCTION__))->base.side_effects_flag) = 1;
    expand_expr (t, const0_rtx(const_int_rtx[64]), VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);
  }
else
  {
    rtx dstb, srcb, size;

    /* Evaluate to pointers.  */
    dstb = expand_expr (dst, NULL_RTX(rtx) 0, Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), EXPAND_NORMAL);
    srcb = expand_expr (src, NULL_RTX(rtx) 0, Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode))), EXPAND_NORMAL);
    size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl))((tree_class_check ((targetm.fn_abi_va_list ((cfun + 0)->decl
)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.cc"
, 5207, __FUNCTION__))->type_common.size_unit),
    		  NULL_RTX(rtx) 0, VOIDmode((void) 0, E_VOIDmode)