/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c

Bug Summary

File:	build/gcc/builtins.c
Warning:	line 5660, column 4 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name builtins.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-error=format-diag -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir /home/marxin/BIG/buildbot/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 -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-01-16-135054-17580-1/report-UT4b4o.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c
/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c

→
1/* Expand builtin functions.
 Copyright (C) 1988-2021 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.c 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-restrict.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-fold.h"
71#include "intl.h"
72#include "file-prefix-map.h" /* remap_macro_filename()  */
73#include "gomp-constants.h"
74#include "omp-general.h"
75#include "tree-dfa.h"
76#include "gimple-iterator.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"

83struct target_builtins default_target_builtins;
84#if SWITCHABLE_TARGET1
85struct target_builtins *this_target_builtins = &default_target_builtins;
86#endif

88/* Define the names of the builtin function types and codes.  */
89const 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"};

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

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

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

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

178static tree fold_builtin_strpbrk (location_t, tree, tree, tree, tree);
179static tree fold_builtin_strspn (location_t, tree, tree, tree);
180static tree fold_builtin_strcspn (location_t, tree, tree, tree);

182static rtx expand_builtin_object_size (tree);
183static rtx expand_builtin_memory_chk (tree, rtx, machine_mode,
		      enum built_in_function);
185static void maybe_emit_chk_warning (tree, enum built_in_function);
186static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
187static tree fold_builtin_object_size (tree, tree);
188static bool check_read_access (tree, tree, tree = NULL_TREE(tree) __null, int = 1);
189static bool compute_objsize_r (tree, int, access_ref *, ssa_name_limit_t &,
	       pointer_query *);

192unsigned HOST_WIDE_INTlong target_newline;
193unsigned HOST_WIDE_INTlong target_percent;
194static unsigned HOST_WIDE_INTlong target_c;
195static unsigned HOST_WIDE_INTlong target_s;
196char target_percent_c[3];
197char target_percent_s[3];
198char target_percent_s_newline[4];
199static tree do_mpfr_remquo (tree, tree, tree);
200static tree do_mpfr_lgamma_r (tree, tree, tree);
201static void expand_builtin_sync_synchronize (void);

203access_ref::access_ref (tree bound /* = NULL_TREE */,
	bool minaccess /* = false */)
ref (), eval ([](tree x){ return x; }), deref (), trail1special (true),
base0 (true), parmarray ()
207{
/* Set to valid.  */
offrng[0] = offrng[1] = 0;
/* Invalidate.   */
sizrng[0] = sizrng[1] = -1;

/* Set the default bounds of the access and adjust below.  */
bndrng[0] = minaccess ? 1 : 0;
bndrng[1] = HOST_WIDE_INT_M1U-1UL;

/* When BOUND is nonnull and a range can be extracted from it,
   set the bounds of the access to reflect both it and MINACCESS.
   BNDRNG[0] is the size of the minimum access.  */
tree rng[2];
if (bound && get_size_range (bound, rng, SR_ALLOW_ZERO))
  {
    bndrng[0] = wi::to_offset (rng[0]);
    bndrng[1] = wi::to_offset (rng[1]);
    bndrng[0] = bndrng[0] > 0 && minaccess ? 1 : 0;
  }
227}

229/* Return the PHI node REF refers to or null if it doesn't.  */

231gphi *
232access_ref::phi () const
233{
if (!ref || TREE_CODE (ref)((enum tree_code) (ref)->base.code) != SSA_NAME)
  return NULL__null;

gimple *def_stmt = SSA_NAME_DEF_STMT (ref)(tree_check ((ref), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 237, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
if (gimple_code (def_stmt) != GIMPLE_PHI)
  return NULL__null;

return as_a <gphi *> (def_stmt);
242}

244/* Determine and return the largest object to which *THIS.  If *THIS
 refers to a PHI and PREF is nonnull, fill *PREF with the details
 of the object determined by compute_objsize(ARG, OSTYPE) for each
 PHI argument ARG.  */

249tree
250access_ref::get_ref (vec<access_ref> *all_refs,
     access_ref *pref /* = NULL */,
     int ostype /* = 1 */,
     ssa_name_limit_t *psnlim /* = NULL */,
     pointer_query *qry /* = NULL */) const
255{
gphi *phi_stmt = this->phi ();
if (!phi_stmt)
  return ref;

/* FIXME: Calling get_ref() with a null PSNLIM is dangerous and might
   cause unbounded recursion.  */
ssa_name_limit_t snlim_buf;
if (!psnlim)
  psnlim = &snlim_buf;

if (!psnlim->visit_phi (ref))
  return NULL_TREE(tree) __null;

/* Reflects the range of offsets of all PHI arguments refer to the same
   object (i.e., have the same REF).  */
access_ref same_ref;
/* The conservative result of the PHI reflecting the offset and size
   of the largest PHI argument, regardless of whether or not they all
   refer to the same object.  */
pointer_query empty_qry;
if (!qry)
  qry = &empty_qry;

access_ref phi_ref;
if (pref)
  {
    phi_ref = *pref;
    same_ref = *pref;
  }

/* Set if any argument is a function array (or VLA) parameter not
   declared [static].  */
bool parmarray = false;
/* The size of the smallest object referenced by the PHI arguments.  */
offset_int minsize = 0;
const offset_int maxobjsize = wi::to_offset (max_object_size ());
/* The offset of the PHI, not reflecting those of its arguments.  */
const offset_int orng[2] = { phi_ref.offrng[0], phi_ref.offrng[1] };

const unsigned nargs = gimple_phi_num_args (phi_stmt);
for (unsigned i = 0; i < nargs; ++i)
  {
    access_ref phi_arg_ref;
    tree arg = gimple_phi_arg_def (phi_stmt, i);
    if (!compute_objsize_r (arg, ostype, &phi_arg_ref, *psnlim, qry)
 || phi_arg_ref.sizrng[0] < 0)
/* A PHI with all null pointer arguments.  */
return NULL_TREE(tree) __null;

    /* Add PREF's offset to that of the argument.  */
    phi_arg_ref.add_offset (orng[0], orng[1]);
    if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == SSA_NAME)
qry->put_ref (arg, phi_arg_ref);

    if (all_refs)
all_refs->safe_push (phi_arg_ref);

    const bool arg_known_size = (phi_arg_ref.sizrng[0] != 0
		   || phi_arg_ref.sizrng[1] != maxobjsize);

    parmarray |= phi_arg_ref.parmarray;

    const bool nullp = integer_zerop (arg) && (i || i + 1 < nargs);

    if (phi_ref.sizrng[0] < 0)
{
 if (!nullp)
   same_ref = phi_arg_ref;
 phi_ref = phi_arg_ref;
 if (arg_known_size)
   minsize = phi_arg_ref.sizrng[0];
 continue;
}

    const bool phi_known_size = (phi_ref.sizrng[0] != 0
		   || phi_ref.sizrng[1] != maxobjsize);

    if (phi_known_size && phi_arg_ref.sizrng[0] < minsize)
minsize = phi_arg_ref.sizrng[0];

    /* Disregard null pointers in PHIs with two or more arguments.
TODO: Handle this better!  */
    if (nullp)
continue;

    /* Determine the amount of remaining space in the argument.  */
    offset_int argrem[2];
    argrem[1] = phi_arg_ref.size_remaining (argrem);

    /* Determine the amount of remaining space computed so far and
if the remaining space in the argument is more use it instead.  */
    offset_int phirem[2];
    phirem[1] = phi_ref.size_remaining (phirem);

    if (phi_arg_ref.ref != same_ref.ref)
same_ref.ref = NULL_TREE(tree) __null;

    if (phirem[1] < argrem[1]
 || (phirem[1] == argrem[1]
     && phi_ref.sizrng[1] < phi_arg_ref.sizrng[1]))
/* Use the argument with the most space remaining as the result,
  or the larger one if the space is equal.  */
phi_ref = phi_arg_ref;

    /* Set SAME_REF.OFFRNG to the maximum range of all arguments.  */
    if (phi_arg_ref.offrng[0] < same_ref.offrng[0])
same_ref.offrng[0] = phi_arg_ref.offrng[0];
    if (same_ref.offrng[1] < phi_arg_ref.offrng[1])
same_ref.offrng[1] = phi_arg_ref.offrng[1];
  }

if (phi_ref.sizrng[0] < 0)
  {
    /* Fail if none of the PHI's arguments resulted in updating PHI_REF
(perhaps because they have all been already visited by prior
recursive calls).  */
    psnlim->leave_phi (ref);
    return NULL_TREE(tree) __null;
  }

if (!same_ref.ref && same_ref.offrng[0] != 0)
  /* Clear BASE0 if not all the arguments refer to the same object and
     if not all their offsets are zero-based.  This allows the final
     PHI offset to out of bounds for some arguments but not for others
     (or negative even of all the arguments are BASE0), which is overly
     permissive.  */
  phi_ref.base0 = false;

if (same_ref.ref)
  phi_ref = same_ref;
else
  {
    /* Replace the lower bound of the largest argument with the size
of the smallest argument, and set PARMARRAY if any argument
was one.  */
    phi_ref.sizrng[0] = minsize;
    phi_ref.parmarray = parmarray;
  }

/* Avoid changing *THIS.  */
if (pref && pref != this)
  *pref = phi_ref;

psnlim->leave_phi (ref);

return phi_ref.ref;
402}

404/* Return the maximum amount of space remaining and if non-null, set
 argument to the minimum.  */

407offset_int
408access_ref::size_remaining (offset_int *pmin /* = NULL */) const
409{
offset_int minbuf;
if (!pmin)
  pmin = &minbuf;

/* add_offset() ensures the offset range isn't inverted.  */
gcc_checking_assert (offrng[0] <= offrng[1])((void)(!(offrng[0] <= offrng[1]) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 415, __FUNCTION__), 0 : 0));

if (base0)
  {
    /* The offset into referenced object is zero-based (i.e., it's
not referenced by a pointer into middle of some unknown object).  */
    if (offrng[0] < 0 && offrng[1] < 0)
{
 /* If the offset is negative the remaining size is zero.  */
 *pmin = 0;
 return 0;
}

    if (sizrng[1] <= offrng[0])
{
 /* If the starting offset is greater than or equal to the upper
    bound on the size of the object, the space remaining is zero.
    As a special case, if it's equal, set *PMIN to -1 to let
    the caller know the offset is valid and just past the end.  */
 *pmin = sizrng[1] == offrng[0] ? -1 : 0;
 return 0;
}

    /* Otherwise return the size minus the lower bound of the offset.  */
    offset_int or0 = offrng[0] < 0 ? 0 : offrng[0];

    *pmin = sizrng[0] - or0;
    return sizrng[1] - or0;
  }

/* The offset to the referenced object isn't zero-based (i.e., it may
   refer to a byte other than the first.  The size of such an object
   is constrained only by the size of the address space (the result
   of max_object_size()).  */
if (sizrng[1] <= offrng[0])
  {
    *pmin = 0;
    return 0;
  }

offset_int or0 = offrng[0] < 0 ? 0 : offrng[0];

*pmin = sizrng[0] - or0;
return sizrng[1] - or0;
459}

461/* Add the range [MIN, MAX] to the offset range.  For known objects (with
 zero-based offsets) at least one of whose offset's bounds is in range,
 constrain the other (or both) to the bounds of the object (i.e., zero
 and the upper bound of its size).  This improves the quality of
 diagnostics.  */

467void access_ref::add_offset (const offset_int &min, const offset_int &max)
468{
if (min <= max)
  {
    /* To add an ordinary range just add it to the bounds.  */
    offrng[0] += min;
    offrng[1] += max;
  }
else if (!base0)
  {
    /* To add an inverted range to an offset to an unknown object
expand it to the maximum.  */
    add_max_offset ();
    return;
  }
else
  {
    /* To add an inverted range to an offset to an known object set
the upper bound to the maximum representable offset value
(which may be greater than MAX_OBJECT_SIZE).
The lower bound is either the sum of the current offset and
MIN when abs(MAX) is greater than the former, or zero otherwise.
Zero because then then inverted range includes the negative of
the lower bound.  */
    offset_int maxoff = wi::to_offset (TYPE_MAX_VALUE (ptrdiff_type_node)((tree_check5 ((global_trees[TI_PTRDIFF_TYPE]), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 491, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
));
    offrng[1] = maxoff;

    if (max >= 0)
{
 offrng[0] = 0;
 return;
}

    offset_int absmax = wi::abs (max);
    if (offrng[0] < absmax)
{
 offrng[0] += min;
 /* Cap the lower bound at the upper (set to MAXOFF above)
    to avoid inadvertently recreating an inverted range.  */
 if (offrng[1] < offrng[0])
   offrng[0] = offrng[1];
}
    else
offrng[0] = 0;
  }

if (!base0)
  return;

/* When referencing a known object check to see if the offset computed
   so far is in bounds... */
offset_int remrng[2];
remrng[1] = size_remaining (remrng);
if (remrng[1] > 0 || remrng[0] < 0)
  {
    /* ...if so, constrain it so that neither bound exceeds the size of
the object.  Out of bounds offsets are left unchanged, and, for
better or worse, become in bounds later.  They should be detected
and diagnosed at the point they first become invalid by
-Warray-bounds.  */
    if (offrng[0] < 0)
offrng[0] = 0;
    if (offrng[1] > sizrng[1])
offrng[1] = sizrng[1];
  }
532}

534/* Set a bit for the PHI in VISITED and return true if it wasn't
 already set.  */

537bool
538ssa_name_limit_t::visit_phi (tree ssa_name)
539{
if (!visited)
  visited = BITMAP_ALLOCbitmap_alloc (NULL__null);

/* Return false if SSA_NAME has already been visited.  */
return bitmap_set_bit (visited, SSA_NAME_VERSION (ssa_name)(tree_check ((ssa_name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 544, __FUNCTION__, (SSA_NAME)))->base.u.version);
545}

547/* Clear a bit for the PHI in VISITED.  */

549void
550ssa_name_limit_t::leave_phi (tree ssa_name)
551{
/* Return false if SSA_NAME has already been visited.  */
bitmap_clear_bit (visited, SSA_NAME_VERSION (ssa_name)(tree_check ((ssa_name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 553, __FUNCTION__, (SSA_NAME)))->base.u.version);
554}

556/* Return false if the SSA_NAME chain length counter has reached
 the limit, otherwise increment the counter and return true.  */

559bool
560ssa_name_limit_t::next ()
561{
/* Return a negative value to let caller avoid recursing beyond
   the specified limit.  */
if (ssa_def_max == 0)
27
←
Assuming field 'ssa_def_max' is not equal to 0→
28
←
Taking false branch→
  return false;

--ssa_def_max;
return true;
29
←
Returning the value 1, which participates in a condition later→
569}

571/* If the SSA_NAME has already been "seen" return a positive value.
 Otherwise add it to VISITED.  If the SSA_NAME limit has been
 reached, return a negative value.  Otherwise return zero.  */

575int
576ssa_name_limit_t::next_phi (tree ssa_name)
577{
{
  gimple *def_stmt = SSA_NAME_DEF_STMT (ssa_name)(tree_check ((ssa_name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 579, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
  /* Return a positive value if the PHI has already been visited.  */
  if (gimple_code (def_stmt) == GIMPLE_PHI
&& !visit_phi (ssa_name))
    return 1;
}

/* Return a negative value to let caller avoid recursing beyond
   the specified limit.  */
if (ssa_def_max == 0)
  return -1;

--ssa_def_max;

return 0;
594}

596ssa_name_limit_t::~ssa_name_limit_t ()
597{
if (visited)
  BITMAP_FREE (visited)((void) (bitmap_obstack_free ((bitmap) visited), (visited) = (
bitmap) __null));
600}

602/* Default ctor.  Initialize object with pointers to the range_query
 and cache_type instances to use or null.  */

605pointer_query::pointer_query (range_query *qry /* = NULL */,
	      cache_type *cache /* = NULL */)
rvals (qry), var_cache (cache), hits (), misses (),
failures (), depth (), max_depth ()
609{
/* No op.  */
611}

613/* Return a pointer to the cached access_ref instance for the SSA_NAME
 PTR if it's there or null otherwise.  */

616const access_ref *
617pointer_query::get_ref (tree ptr, int ostype /* = 1 */) const
618{
if (!var_cache)
  {
    ++misses;
    return NULL__null;
  }

unsigned version = SSA_NAME_VERSION (ptr)(tree_check ((ptr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 625, __FUNCTION__, (SSA_NAME)))->base.u.version;
unsigned idx = version << 1 | (ostype & 1);
if (var_cache->indices.length () <= idx)
  {
    ++misses;
    return NULL__null;
  }

unsigned cache_idx = var_cache->indices[idx];
if (var_cache->access_refs.length () <= cache_idx)
  {
    ++misses;
    return NULL__null;
  }

access_ref &cache_ref = var_cache->access_refs[cache_idx];
if (cache_ref.ref)
  {
    ++hits;
    return &cache_ref;
  }

++misses;
return NULL__null;
649}

651/* Retrieve the access_ref instance for a variable from the cache if it's
 there or compute it and insert it into the cache if it's nonnonull.  */

654bool
655pointer_query::get_ref (tree ptr, access_ref *pref, int ostype /* = 1 */)
656{
const unsigned version
  = TREE_CODE (ptr)((enum tree_code) (ptr)->base.code) == SSA_NAME ? SSA_NAME_VERSION (ptr)(tree_check ((ptr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 658, __FUNCTION__, (SSA_NAME)))->base.u.version : 0;

if (var_cache && version)
  {
    unsigned idx = version << 1 | (ostype & 1);
    if (idx < var_cache->indices.length ())
{
 unsigned cache_idx = var_cache->indices[idx] - 1;
 if (cache_idx < var_cache->access_refs.length ()
     && var_cache->access_refs[cache_idx].ref)
   {
     ++hits;
     *pref = var_cache->access_refs[cache_idx];
     return true;
   }
}

    ++misses;
  }

if (!compute_objsize (ptr, ostype, pref, this))
  {
    ++failures;
    return false;
  }

return true;
685}

687/* Add a copy of the access_ref REF for the SSA_NAME to the cache if it's
 nonnull.  */

690void
691pointer_query::put_ref (tree ptr, const access_ref &ref, int ostype /* = 1 */)
692{
/* Only add populated/valid entries.  */
if (!var_cache || !ref.ref || ref.sizrng[0] < 0)
  return;

/* Add REF to the two-level cache.  */
unsigned version = SSA_NAME_VERSION (ptr)(tree_check ((ptr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 698, __FUNCTION__, (SSA_NAME)))->base.u.version;
unsigned idx = version << 1 | (ostype & 1);

/* Grow INDICES if necessary.  An index is valid if it's nonzero.
   Its value minus one is the index into ACCESS_REFS.  Not all
   entries are valid.  */
if (var_cache->indices.length () <= idx)
  var_cache->indices.safe_grow_cleared (idx + 1);

if (!var_cache->indices[idx])
  var_cache->indices[idx] = var_cache->access_refs.length () + 1;

/* Grow ACCESS_REF cache if necessary.  An entry is valid if its
   REF member is nonnull.  All entries except for the last two
   are valid.  Once nonnull, the REF value must stay unchanged.  */
unsigned cache_idx = var_cache->indices[idx];
if (var_cache->access_refs.length () <= cache_idx)
  var_cache->access_refs.safe_grow_cleared (cache_idx + 1);

access_ref cache_ref = var_cache->access_refs[cache_idx - 1];
if (cache_ref.ref)
{
  gcc_checking_assert (cache_ref.ref == ref.ref)((void)(!(cache_ref.ref == ref.ref) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 720, __FUNCTION__), 0 : 0));
  return;
}

cache_ref = ref;
725}

727/* Flush the cache if it's nonnull.  */

729void
730pointer_query::flush_cache ()
731{
if (!var_cache)
  return;
var_cache->indices.release ();
var_cache->access_refs.release ();
736}

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

740static bool
741is_builtin_name (const char *name)
742{
if (strncmp (name, "__builtin_", 10) == 0)
  return true;
if (strncmp (name, "__sync_", 7) == 0)
  return true;
if (strncmp (name, "__atomic_", 9) == 0)
  return true;
return false;
750}

752/* 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".  */

756bool
757called_as_built_in (tree node)
758{
/* 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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 762, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 762, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
);
return is_builtin_name (name);
764}

766/* 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.  */

781static bool
782get_object_alignment_2 (tree exp, unsigned int *alignp,
	unsigned HOST_WIDE_INTlong *bitposp, bool addr_p)
784{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 813, __FUNCTION__))->decl_common.initial);
    align = TYPE_ALIGN (TREE_TYPE (exp))((tree_class_check ((((contains_struct_check ((exp), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 814, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 814, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
 ((((contains_struct_check ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 814, __FUNCTION__))->typed.type))->type_common.align -
 1) : 0);
    if (CONSTANT_CLASS_P (exp)(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[(int) (((enum tree_code) (exp)->base.code)
)] == tcc_declaration))
  {
    align = DECL_ALIGN (exp)(((contains_struct_check ((exp), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 822, __FUNCTION__))->decl_common.align) ? ((unsigned)1) <<
 (((contains_struct_check ((exp), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 822, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 829, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 836, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 838, __FUNCTION__)))))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 838, __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),
 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 841, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 855, __FUNCTION__, (TARGET_MEM_REF)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 855, __FUNCTION__)))))))
   {
     unsigned HOST_WIDE_INTlong step = 1;
     if (TMR_STEP (exp)((*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 858, __FUNCTION__, (TARGET_MEM_REF)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 858, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 859, __FUNCTION__, (TARGET_MEM_REF)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 859, __FUNCTION__))))))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 859, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 862, __FUNCTION__, (TARGET_MEM_REF)))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 862, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 874, __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
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 890, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 890, __FUNCTION__))->type_common.align ? ((unsigned)1) <<
 ((((contains_struct_check ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 890, __FUNCTION__))->typed.type))->type_common.align -
 1) : 0);
    if (CONSTANT_CLASS_P (exp)(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;
922}

924/* 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.  */

929bool
930get_object_alignment_1 (tree exp, unsigned int *alignp,
	unsigned HOST_WIDE_INTlong *bitposp)
932{
return get_object_alignment_2 (exp, alignp, bitposp, false);
934}

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

938unsigned int
939get_object_alignment (tree exp)
940{
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;
952}

954/* 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.  */

961bool
962get_pointer_alignment_1 (tree exp, unsigned int *alignp,
	 unsigned HOST_WIDE_INTlong *bitposp)
964{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 968, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 974, __FUNCTION__))))),
			  &align, &bitpos);
    if (TREE_CODE (TREE_OPERAND (exp, 1))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((exp), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 976, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 977, __FUNCTION__)))))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 977, __FUNCTION__))) * BITS_PER_UNIT(8);
    else
{
 unsigned int trailing_zeros = tree_ctz (TREE_OPERAND (exp, 1)(*((const_cast<tree*> (tree_operand_check ((exp), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 980, __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
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 993, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((exp), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 993, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 996, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1019, __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;
1027}

1029/* 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.  */

1036unsigned int
1037get_pointer_alignment (tree exp)
1038{
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;
1051}

1053/* 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.  */

1057unsigned
1058string_length (const void *ptr, unsigned eltsize, unsigned maxelts)
1059{
gcc_checking_assert (eltsize == 1 || eltsize == 2 || eltsize == 4)((void)(!(eltsize == 1 || eltsize == 2 || eltsize == 4) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1060, __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;
1084}

1086/* For a call EXPR at LOC to a function FNAME that expects a string
 in the argument ARG, issue a diagnostic due to it being a called
 with an argument that is a character array with no terminating
 NUL.  SIZE is the EXACT size of the array, and BNDRNG the number
 of characters in which the NUL is expected.  Either EXPR or FNAME
 may be null but noth both.  SIZE may be null when BNDRNG is null.  */

1093void
1094warn_string_no_nul (location_t loc, tree expr, const char *fname,
    tree arg, tree decl, tree size /* = NULL_TREE */,
    bool exact /* = false */,
    const wide_int bndrng[2] /* = NULL */)
1098{
if ((expr && TREE_NO_WARNING (expr)((expr)->base.nowarning_flag)) || TREE_NO_WARNING (arg)((arg)->base.nowarning_flag))
  return;

loc = expansion_point_location_if_in_system_header (loc);
bool warned;

/* Format the bound range as a string to keep the nuber of messages
   from exploding.  */
char bndstr[80];
*bndstr = 0;
if (bndrng)
  {
    if (bndrng[0] == bndrng[1])
sprintf (bndstr, "%llu", (unsigned long long) bndrng[0].to_uhwi ());
    else
sprintf (bndstr, "[%llu, %llu]",
 (unsigned long long) bndrng[0].to_uhwi (),
 (unsigned long long) bndrng[1].to_uhwi ());
  }

const tree maxobjsize = max_object_size ();
const wide_int maxsiz = wi::to_wide (maxobjsize);
if (expr)
  {
    tree func = get_callee_fndecl (expr);
    if (bndrng)
{
 if (wi::ltu_p (maxsiz, bndrng[0]))
   warned = warning_at (loc, OPT_Wstringop_overread,
		 "%K%qD specified bound %s exceeds "
		 "maximum object size %E",
		 expr, func, bndstr, maxobjsize);
 else
   {
     bool maybe = wi::to_wide (size) == bndrng[0];
     warned = warning_at (loc, OPT_Wstringop_overread,
		   exact
		   ? G_("%K%qD specified bound %s exceeds ""%K%qD specified bound %s exceeds " "the size %E of unterminated array"
			"the size %E of unterminated array")"%K%qD specified bound %s exceeds " "the size %E of unterminated array"
		   : (maybe
		      ? G_("%K%qD specified bound %s may ""%K%qD specified bound %s may " "exceed the size of at most %E "
 "of unterminated array"
			   "exceed the size of at most %E ""%K%qD specified bound %s may " "exceed the size of at most %E "
 "of unterminated array"
			   "of unterminated array")"%K%qD specified bound %s may " "exceed the size of at most %E "
 "of unterminated array"
		      : G_("%K%qD specified bound %s exceeds ""%K%qD specified bound %s exceeds " "the size of at most %E "
 "of unterminated array"
			   "the size of at most %E ""%K%qD specified bound %s exceeds " "the size of at most %E "
 "of unterminated array"
			   "of unterminated array")"%K%qD specified bound %s exceeds " "the size of at most %E "
 "of unterminated array"),
		   expr, func, bndstr, size);
   }
}
    else
warned = warning_at (loc, OPT_Wstringop_overread,
	     "%K%qD argument missing terminating nul",
	     expr, func);
  }
else
  {
    if (bndrng)
{
 if (wi::ltu_p (maxsiz, bndrng[0]))
   warned = warning_at (loc, OPT_Wstringop_overread,
		 "%qs specified bound %s exceeds "
		 "maximum object size %E",
		 fname, bndstr, maxobjsize);
 else
   {
     bool maybe = wi::to_wide (size) == bndrng[0];
     warned = warning_at (loc, OPT_Wstringop_overread,
		   exact
		   ? G_("%qs specified bound %s exceeds ""%qs specified bound %s exceeds " "the size %E of unterminated array"
			"the size %E of unterminated array")"%qs specified bound %s exceeds " "the size %E of unterminated array"
		   : (maybe
		      ? G_("%qs specified bound %s may ""%qs specified bound %s may " "exceed the size of at most %E "
 "of unterminated array"
			   "exceed the size of at most %E ""%qs specified bound %s may " "exceed the size of at most %E "
 "of unterminated array"
			   "of unterminated array")"%qs specified bound %s may " "exceed the size of at most %E "
 "of unterminated array"
		      : G_("%qs specified bound %s exceeds ""%qs specified bound %s exceeds " "the size of at most %E " "of unterminated array"
			   "the size of at most %E ""%qs specified bound %s exceeds " "the size of at most %E " "of unterminated array"
			   "of unterminated array")"%qs specified bound %s exceeds " "the size of at most %E " "of unterminated array"),
		   fname, bndstr, size);
   }
}
    else
warned = warning_at (loc, OPT_Wstringop_overread,
	     "%qsargument missing terminating nul",
	     fname);
  }

if (warned)
  {
    inform (DECL_SOURCE_LOCATION (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1187, __FUNCTION__))->decl_minimal.locus),
     "referenced argument declared here");
    TREE_NO_WARNING (arg)((arg)->base.nowarning_flag) = 1;
    if (expr)
TREE_NO_WARNING (expr)((expr)->base.nowarning_flag) = 1;
  }
1193}

1195/* For a call EXPR (which may be null) that expects a string argument
 SRC as an argument, returns false if SRC is a character array with
 no terminating NUL.  When nonnull, BOUND is the number of characters
 in which to expect the terminating NUL.  RDONLY is true for read-only
 accesses such as strcmp, false for read-write such as strcpy.  When
 EXPR is also issues a warning.  */

1202bool
1203check_nul_terminated_array (tree expr, tree src,
	    tree bound /* = NULL_TREE */)
1205{
/* The constant size of the array SRC points to.  The actual size
   may be less of EXACT is true, but not more.  */
tree size;
/* True if SRC involves a non-constant offset into the array.  */
bool exact;
/* The unterminated constant array SRC points to.  */
tree nonstr = unterminated_array (src, &size, &exact);
if (!nonstr)
  return true;

/* NONSTR refers to the non-nul terminated constant array and SIZE
   is the constant size of the array in bytes.  EXACT is true when
   SIZE is exact.  */

wide_int bndrng[2];
if (bound)
  {
    if (TREE_CODE (bound)((enum tree_code) (bound)->base.code) == INTEGER_CST)
bndrng[0] = bndrng[1] = wi::to_wide (bound);
    else
{
 value_range_kind rng = get_range_info (bound, bndrng, bndrng + 1);
 if (rng != VR_RANGE)
   return true;
}

    if (exact)
{
 if (wi::leu_p (bndrng[0], wi::to_wide (size)))
   return true;
}
    else if (wi::lt_p (bndrng[0], wi::to_wide (size), UNSIGNED))
return true;
  }

if (expr)
  warn_string_no_nul (EXPR_LOCATION (expr)((((expr)) && ((tree_code_type[(int) (((enum tree_code
) ((expr))->base.code))]) >= tcc_reference && (
tree_code_type[(int) (((enum tree_code) ((expr))->base.code
))]) <= tcc_expression)) ? (expr)->exp.locus : ((location_t
) 0)), expr, NULL__null, src, nonstr,
	size, exact, bound ? bndrng : NULL__null);

return false;
1246}

1248/* If EXP refers to an unterminated constant character array return
 the declaration of the object of which the array is a member or
 element and if SIZE is not null, set *SIZE to the size of
 the unterminated array and set *EXACT if the size is exact or
 clear it otherwise.  Otherwise return null.  */

1254tree
1255unterminated_array (tree exp, tree *size /* = NULL */, bool *exact /* = NULL */)
1256{
/* C_STRLEN will return NULL and set DECL in the info
   structure if EXP references a unterminated array.  */
c_strlen_data lendata = { };
tree len = c_strlen (exp, 1, &lendata);
if (len == NULL_TREE(tree) __null && lendata.minlen && lendata.decl)
   {
     if (size)
{
 len = lendata.minlen;
 if (lendata.off)
   {
     /* Constant offsets are already accounted for in LENDATA.MINLEN,
 but not in a SSA_NAME + CST expression.  */
     if (TREE_CODE (lendata.off)((enum tree_code) (lendata.off)->base.code) == INTEGER_CST)
*exact = true;
     else if (TREE_CODE (lendata.off)((enum tree_code) (lendata.off)->base.code) == PLUS_EXPR
       && TREE_CODE (TREE_OPERAND (lendata.off, 1))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((lendata.off), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1273, __FUNCTION__))))))->base.code) == INTEGER_CST)
{
  /* Subtract the offset from the size of the array.  */
  *exact = false;
  tree temp = TREE_OPERAND (lendata.off, 1)(*((const_cast<tree*> (tree_operand_check ((lendata.off
), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1277, __FUNCTION__)))));
  temp = fold_convert (ssizetype, temp)fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_ssizetype
], temp);
  len = fold_build2 (MINUS_EXPR, ssizetype, len, temp)fold_build2_loc (((location_t) 0), MINUS_EXPR, sizetype_tab[(
int) stk_ssizetype], len, temp );
}
     else
*exact = false;
   }
 else
   *exact = true;

 *size = len;
}
     return lendata.decl;
   }

return NULL_TREE(tree) __null;
1293}

1295/* 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'.  */

1324tree
1325c_strlen (tree arg, int only_value, c_strlen_data *data, unsigned eltsize)
1326{
/* 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
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1334, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1338, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1338, __FUNCTION__))->base.side_effects_flag)))
  {
    tree len1, len2;

    len1 = c_strlen (TREE_OPERAND (src, 1)(*((const_cast<tree*> (tree_operand_check ((src), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1342, __FUNCTION__))))), only_value, data, eltsize);
    len2 = c_strlen (TREE_OPERAND (src, 2)(*((const_cast<tree*> (tree_operand_check ((src), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1343, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1349, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1349, __FUNCTION__))->base.side_effects_flag)))
  return c_strlen (TREE_OPERAND (src, 1)(*((const_cast<tree*> (tree_operand_check ((src), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1350, __FUNCTION__))))), only_value, data, eltsize);

location_t loc = EXPR_LOC_OR_LOC (src, input_location)((((IS_ADHOC_LOC (((((src)) && ((tree_code_type[(int)
 (((enum tree_code) ((src))->base.code))]) >= tcc_reference
 && (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[(int) (((enum tree_code
) ((src))->base.code))]) >= tcc_reference && (tree_code_type
[(int) (((enum tree_code) ((src))->base.code))]) <= tcc_expression
)) ? (src)->exp.locus : ((location_t) 0))) : (((((src)) &&
 ((tree_code_type[(int) (((enum tree_code) ((src))->base.code
))]) >= tcc_reference && (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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1363, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1363, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1363, __FUNCTION__))->type_common.size_unit)))
  return NULL_TREE(tree) __null;

/* Set MAXELTS to sizeof (SRC) / sizeof (*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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1372, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1382, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1418, __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
 && !TREE_NO_WARNING (arg)((arg)->base.nowarning_flag)
 && 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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1454, __FUNCTION__))->decl_minimal.locus), "%qE declared here", decl);
 TREE_NO_WARNING (arg)((arg)->base.nowarning_flag) = 1;
}
    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);
1486}

1488/* 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.  */

1494rtx
1495c_readstr (const char *str, scalar_int_mode mode,
  bool null_terminated_p/*=true*/)
1497{
HOST_WIDE_INTlong ch;
unsigned int i, j;
HOST_WIDE_INTlong tmp[MAX_BITSIZE_MODE_ANY_INT160 / HOST_BITS_PER_WIDE_INT64];

gcc_assert (GET_MODE_CLASS (mode) == MODE_INT)((void)(!(((enum mode_class) mode_class[mode]) == MODE_INT) ?
 fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1502, __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 <= 160 / 64) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1506, __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);
1528}

1530/* 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.  */

1534static int
1535target_char_cast (tree cst, char *p)
1536{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1544, __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;
1558}

1560/* 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.  */

1564static tree
1565builtin_save_expr (tree exp)
1566{
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);
1574}

1576/* 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).  */

1580static rtx
1581expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
1582{
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.  */
1634#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))));
1636#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);
1640#endif
return tem;
1642}

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

1647/* 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.  */

1651void
1652expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
1653{
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;
1692}

1694/* 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.  */

1698void
1699expand_builtin_setjmp_receiver (rtx receiver_label)
1700{
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 ());
1748}

1750/* __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.  */

1755static void
1756expand_builtin_longjmp (rtx buf_addr, rtx value)
1757{
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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1776, __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.c; 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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1831, __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;
  }
1841}

1843static inline bool
1844more_const_call_expr_args_p (const const_call_expr_arg_iterator *iter)
1845{
return (iter->i < iter->n);
1847}

1849/* 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.  */

1854static bool
1855validate_arglist (const_tree callexpr, ...)
1856{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1867, __FUNCTION__, (CALL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1867, __FUNCTION__)))));
bitmap argmap = get_nonnull_args (TREE_TYPE (TREE_TYPE (fn))((contains_struct_check ((((contains_struct_check ((fn), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1868, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1868, __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;
1917}

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

1922static rtx
1923expand_builtin_nonlocal_goto (tree exp)
1924{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1932, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1932, __FUNCTION__)))));
t_save_area = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1933, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 1933, __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]);
2005}

2007/* __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.  */

2012void
2013expand_builtin_update_setjmp_buf (rtx buf_addr)
2014{
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);
2025}

2027/* 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.  */

2031static void
2032expand_builtin_prefetch (tree exp)
2033{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2041, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2041, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2046, __FUNCTION__))->exp.operands[0]), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2046, __FUNCTION__)))) - 3);
if (nargs > 1)
  arg1 = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2048, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2048, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2052, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2052, __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);
2103}

2105/* 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.  */

2110static rtx
2111get_memory_rtx (tree exp, tree len)
2112{
tree orig_exp = exp;
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2118, __FUNCTION__, (SAVE_EXPR)))->base.public_flag))
  exp = TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2119, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2127, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2127, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check (((*((const_cast
<tree*> (tree_operand_check ((exp), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2127, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2127, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
  exp = TREE_OPERAND (exp, 0)(*((const_cast<tree*> (tree_operand_check ((exp), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2128, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2141, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2143, __FUNCTION__))))))->base.code) == ADDR_EXPR
  && (exp = get_base_address (TREE_OPERAND (TREE_OPERAND (exp, 0),(*((const_cast<tree*> (tree_operand_check (((*((const_cast
<tree*> (tree_operand_check ((exp), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2144, __FUNCTION__)))))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2145, __FUNCTION__)))))
				     0)(*((const_cast<tree*> (tree_operand_check (((*((const_cast
<tree*> (tree_operand_check ((exp), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2144, __FUNCTION__)))))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2145, __FUNCTION__))))))))
  {
    exp = build_fold_addr_expr (exp)build_fold_addr_expr_loc (((location_t) 0), (exp));
    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);
  }
set_mem_alias_set (mem, 0);
return mem;
2158}
2159
2160/* Built-in functions to perform an untyped call and return.  */

2162#define apply_args_mode(this_target_builtins->x_apply_args_mode) \
(this_target_builtins->x_apply_args_mode)
2164#define apply_result_mode(this_target_builtins->x_apply_result_mode) \
(this_target_builtins->x_apply_result_mode)

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

2170static int
2171apply_args_size (void)
2172{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2185, __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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2193, __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;
2207}

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

2212static int
2213apply_result_size (void)
2214{
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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2228, __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.  */
2241#ifdef APPLY_RESULT_SIZE(8+108)
    size = APPLY_RESULT_SIZE(8+108);
2243#endif
  }
return size;
2246}

2248/* 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.  */

2252static rtx
2253result_vector (int savep, rtx result)
2254{
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))) );
2275}

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

2280static rtx
2281expand_builtin_apply_args_1 (void)
2282{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2286, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2294, __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));
2333}

2335/* __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.  */

2342static rtx
2343expand_builtin_apply_args (void)
2344{
/* 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;
}
2377}

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

2382static rtx
2383expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
2384{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2391, __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);
    emit_call_insn (targetm.gen_untyped_call (mem, result,
				result_vector (1, result)));
  }
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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2507, __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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2519, __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);
2538}

2540/* Perform an untyped return.  */

2542static void
2543expand_builtin_return (rtx result)
2544{
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 ();
2587}

2589/* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */

2591static enum type_class
2592type_to_class (tree type)
2593{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2610, __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;
  }
2616}

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

2620static rtx
2621expand_builtin_classify_type (tree exp)
2622{
if (call_expr_nargs (exp)(((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
 ((exp), (tcc_vl_exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2623, __FUNCTION__))->exp.operands[0]), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2623, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2624, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2624, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2624, __FUNCTION__))->typed.type))));
return GEN_INT (no_type_class)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (no_type_class));
2626}

2628/* 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.  */
2634#define CASE_MATHFN(MATHFN) \
CASE_CFN_##MATHFN: \
fcode = BUILT_IN_##MATHFN; fcodef = BUILT_IN_##MATHFN##F ; \
fcodel = BUILT_IN_##MATHFN##L ; break;
2638/* Similar to the above, but also add support for the _Float<N> and _Float<N>X
 types.  */
2640#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;
2648/* Similar to above, but appends _R after any F/L suffix.  */
2649#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;

2656/* 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.  */

2661static built_in_function
2662mathfn_built_in_2 (tree type, combined_fn fn)
2663{
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;

switch (fn)
  {
2676#define SEQ_OF_CASE_MATHFN			\
  CASE_MATHFN (ACOS)				\
  CASE_MATHFN (ACOSH)				\
  CASE_MATHFN (ASIN)				\
  CASE_MATHFN (ASINH)				\
  CASE_MATHFN (ATAN)				\
  CASE_MATHFN (ATAN2)				\
  CASE_MATHFN (ATANH)				\
  CASE_MATHFN (CBRT)				\
  CASE_MATHFN_FLOATN (CEIL)			\
  CASE_MATHFN (CEXPI)				\
  CASE_MATHFN_FLOATN (COPYSIGN)		\
  CASE_MATHFN (COS)				\
  CASE_MATHFN (COSH)				\
  CASE_MATHFN (DREM)				\
  CASE_MATHFN (ERF)				\
  CASE_MATHFN (ERFC)				\
  CASE_MATHFN (EXP)				\
  CASE_MATHFN (EXP10)				\
  CASE_MATHFN (EXP2)				\
  CASE_MATHFN (EXPM1)				\
  CASE_MATHFN (FABS)				\
  CASE_MATHFN (FDIM)				\
  CASE_MATHFN_FLOATN (FLOOR)			\
  CASE_MATHFN_FLOATN (FMA)			\
  CASE_MATHFN_FLOATN (FMAX)			\
  CASE_MATHFN_FLOATN (FMIN)			\
  CASE_MATHFN (FMOD)				\
  CASE_MATHFN (FREXP)				\
  CASE_MATHFN (GAMMA)				\
  CASE_MATHFN_REENT (GAMMA) /* GAMMA_R */	\
  CASE_MATHFN (HUGE_VAL)			\
  CASE_MATHFN (HYPOT)				\
  CASE_MATHFN (ILOGB)				\
  CASE_MATHFN (ICEIL)				\
  CASE_MATHFN (IFLOOR)			\
  CASE_MATHFN (INF)				\
  CASE_MATHFN (IRINT)				\
  CASE_MATHFN (IROUND)			\
  CASE_MATHFN (ISINF)				\
  CASE_MATHFN (J0)				\
  CASE_MATHFN (J1)				\
  CASE_MATHFN (JN)				\
  CASE_MATHFN (LCEIL)				\
  CASE_MATHFN (LDEXP)				\
  CASE_MATHFN (LFLOOR)			\
  CASE_MATHFN (LGAMMA)			\
  CASE_MATHFN_REENT (LGAMMA) /* LGAMMA_R */	\
  CASE_MATHFN (LLCEIL)			\
  CASE_MATHFN (LLFLOOR)			\
  CASE_MATHFN (LLRINT)			\
  CASE_MATHFN (LLROUND)			\
  CASE_MATHFN (LOG)				\
  CASE_MATHFN (LOG10)				\
  CASE_MATHFN (LOG1P)				\
  CASE_MATHFN (LOG2)				\
  CASE_MATHFN (LOGB)				\
  CASE_MATHFN (LRINT)				\
  CASE_MATHFN (LROUND)			\
  CASE_MATHFN (MODF)				\
  CASE_MATHFN (NAN)				\
  CASE_MATHFN (NANS)				\
  CASE_MATHFN_FLOATN (NEARBYINT)		\
  CASE_MATHFN (NEXTAFTER)			\
  CASE_MATHFN (NEXTTOWARD)			\
  CASE_MATHFN (POW)				\
  CASE_MATHFN (POWI)				\
  CASE_MATHFN (POW10)				\
  CASE_MATHFN (REMAINDER)			\
  CASE_MATHFN (REMQUO)			\
  CASE_MATHFN_FLOATN (RINT)			\
  CASE_MATHFN_FLOATN (ROUND)			\
  CASE_MATHFN_FLOATN (ROUNDEVEN)		\
  CASE_MATHFN (SCALB)				\
  CASE_MATHFN (SCALBLN)			\
  CASE_MATHFN (SCALBN)			\
  CASE_MATHFN (SIGNBIT)			\
  CASE_MATHFN (SIGNIFICAND)			\
  CASE_MATHFN (SIN)				\
  CASE_MATHFN (SINCOS)			\
  CASE_MATHFN (SINH)				\
  CASE_MATHFN_FLOATN (SQRT)			\
  CASE_MATHFN (TAN)				\
  CASE_MATHFN (TANH)				\
  CASE_MATHFN (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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2772, __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;
2795}

2797#undef CASE_MATHFN
2798#undef CASE_MATHFN_FLOATN
2799#undef CASE_MATHFN_REENT

2801/* 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.  */

2806static tree
2807mathfn_built_in_1 (tree type, combined_fn fn, bool implicit_p)
2808{
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);
2817}

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

2821tree
2822mathfn_built_in (tree type, combined_fn fn)
2823{
return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
2825}

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

2830tree
2831mathfn_built_in (tree type, enum built_in_function fn)
2832{
return mathfn_built_in_1 (type, as_combined_fn (fn), /*implicit=*/ 1);
2834}

2836/* 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.  */

2840tree
2841mathfn_built_in_type (combined_fn fn)
2842{
2843#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];

2851#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];

2868/* Similar to above, but appends _R after any F/L suffix.  */
2869#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;
  }

2885#undef CASE_MATHFN
2886#undef CASE_MATHFN_FLOATN
2887#undef CASE_MATHFN_REENT
2888#undef SEQ_OF_CASE_MATHFN
2889}

2891/* 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.  */

2896internal_fn
2897associated_internal_fn (tree fndecl)
2898{
gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)((void)(!(((built_in_class) (tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2899, __FUNCTION__, (FUNCTION_DECL)))->function_decl.built_in_class
) == BUILT_IN_NORMAL) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2899, __FUNCTION__), 0 : 0));
tree return_type = TREE_TYPE (TREE_TYPE (fndecl))((contains_struct_check ((((contains_struct_check ((fndecl), (
TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2900, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2900, __FUNCTION__))->typed.type);
switch (DECL_FUNCTION_CODE (fndecl))
  {
2903#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;
2905#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;
2908#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;
2910#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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2920, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2920, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2920, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2920, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (return_type) : (return_type)->type_common.mode)) - MIN_MODE_FLOAT
) : ((fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2920, __FUNCTION__)), 0)])->b == 2)
return IFN_LDEXP;
    return IFN_LAST;

  default:
    return IFN_LAST;
  }
2927}

2929/* 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.  */

2937internal_fn
2938replacement_internal_fn (gcall *call)
2939{
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;
2952}

2954/* 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.  */

2961static rtx
2962expand_builtin_mathfn_ternary (tree exp, rtx target, rtx subtarget)
2963{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2974, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2974, __FUNCTION__)))));
arg1 = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2975, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2975, __FUNCTION__)))));
arg2 = CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2976, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2976, __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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2984, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2988, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2988, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2988, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2988, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2997, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2997, __FUNCTION__))))) = arg0 = builtin_save_expr (arg0);
CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2998, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2998, __FUNCTION__))))) = arg1 = builtin_save_expr (arg1);
CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2999, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 2999, __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;
3027}

3029/* 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.  */

3036static rtx
3037expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
3038{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3049, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3049, __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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3057, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3061, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3061, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3061, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3061, __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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3073, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3084, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3084, __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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3105, __FUNCTION__));
   }
 gcc_assert (ok)((void)(!(ok) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3107, __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]));
3128}

3130/* 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.  */

3134static enum insn_code
3135interclass_mathfn_icode (tree arg, tree fndecl)
3136{
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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3159, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3167, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3167, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3167, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3167, __FUNCTION__))->typed.type))->type_common.mode);

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

3174/* 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.  */

3181static rtx
3182expand_builtin_interclass_mathfn (tree exp, rtx target)
3183{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3193, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3193, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3195, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3195, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3195, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3195, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3206, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3206, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3213, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3213, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3213, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3213, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3219, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3219, __FUNCTION__))))) = orig_arg;
  }

return NULL_RTX(rtx) 0;
3223}

3225/* 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.  */

3230static rtx
3231expand_builtin_sincos (tree exp)
3232{
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[(int) (((enum tree_code
) ((exp))->base.code))]) >= tcc_reference && (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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3244, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3244, __FUNCTION__)))));
sinp = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3245, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3245, __FUNCTION__)))));
cosp = CALL_EXPR_ARG (exp, 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3246, __FUNCTION__, (CALL_EXPR)))), ((2) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3246, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3249, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3249, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3249, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3249, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3259, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3261, __FUNCTION__))->typed.type),
			sinp, alias_off));
op2 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3263, __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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3269, __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]);
3277}

3279/* 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.  */

3283static rtx
3284expand_builtin_cexpi (tree exp, rtx target)
3285{
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[(int) (((enum tree_code
) ((exp))->base.code))]) >= tcc_reference && (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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3295, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3295, __FUNCTION__)))));
type = TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3296, __FUNCTION__))->typed.type);
mode = TYPE_MODE (TREE_TYPE (arg))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3297, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3297, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3297, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3297, __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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3325, __FUNCTION__));

    op1 = assign_temp (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3327, __FUNCTION__))->typed.type), 1, 1);
    op2 = assign_temp (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3328, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3331, __FUNCTION__))->typed.type)), op1a);
    top2 = make_tree (build_pointer_type (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3332, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3335, __FUNCTION__))->typed.type)), fn);
    expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn))((contains_struct_check ((((contains_struct_check ((fn), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3336, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3336, __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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3351, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3376, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3383, __FUNCTION__))->typed.type), op2),
	      make_tree (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3384, __FUNCTION__))->typed.type), op1)),
      target, VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);
3386}

3388/* 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.  */

3393static tree
3394build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
3395{
va_list ap;
tree fntype = TREE_TYPE (fndecl)((contains_struct_check ((fndecl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3397, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3401, __FUNCTION__))->typed.type), fn, n, ap);
va_end (ap)__builtin_va_end(ap);
SET_EXPR_LOCATION (fn, loc)(expr_check (((fn)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3403, __FUNCTION__))->exp.locus = (loc);
return fn;
3405}

3407/* 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.  */

3414static rtx
3415expand_builtin_int_roundingfn (tree exp, rtx target)
3416{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3429, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3429, __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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3448, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3452, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3452, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3452, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3452, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3459, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3459, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3480, __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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3524, __FUNCTION__));
}

    fntype = build_function_type_list (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3527, __FUNCTION__))->typed.type),
			 TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3528, __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[(int) (((enum tree_code
) ((exp))->base.code))]) >= tcc_reference && (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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3535, __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;
3543}

3545/* 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.  */

3551static rtx
3552expand_builtin_int_roundingfn_2 (tree exp, rtx target)
3553{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3565, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3565, __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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3586, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3594, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3594, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3594, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3594, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3604, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3604, __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.  */
    tree fallback_fndecl = mathfn_built_in_1
(TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3634, __FUNCTION__))->typed.type), as_combined_fn (fallback_fn), 0);

    exp = build_call_nofold_loc (EXPR_LOCATION (exp)((((exp)) && ((tree_code_type[(int) (((enum tree_code
) ((exp))->base.code))]) >= tcc_reference && (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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3640, __FUNCTION__))->typed.type));
    return convert_to_mode (mode, target, 0);
  }

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

3647/* 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.  */

3652static rtx
3653expand_builtin_powi (tree exp, rtx target)
3654{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3663, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3663, __FUNCTION__)))));
arg1 = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3664, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3664, __FUNCTION__)))));
mode = TYPE_MODE (TREE_TYPE (exp))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3665, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3665, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3665, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((exp), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3665, __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;
3687}

3689/* 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.  */

3693static rtx
3694expand_builtin_strlen (tree exp, rtx target,
       machine_mode target_mode)
3696{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3700, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3700, __FUNCTION__)))));
if (!check_read_access (exp, src))
  return NULL_RTX(rtx) 0;

/* 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_wider (&(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)
  {
3765#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);
3769#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;
3789}

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

3794static rtx
3795expand_builtin_strnlen (tree exp, rtx target, machine_mode target_mode)
3796{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3800, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3800, __FUNCTION__)))));
tree bound = CALL_EXPR_ARG (exp, 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3801, __FUNCTION__, (CALL_EXPR)))), ((1) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3801, __FUNCTION__)))));

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

check_read_access (exp, src, bound);

location_t loc = UNKNOWN_LOCATION((location_t) 0);
if (EXPR_HAS_LOCATION (exp)(((IS_ADHOC_LOC (((((exp)) && ((tree_code_type[(int) (
((enum tree_code) ((exp))->base.code))]) >= tcc_reference
 && (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[(int) (((enum tree_code
) ((exp))->base.code))]) >= tcc_reference && (tree_code_type
[(int) (((enum tree_code) ((exp))->base.code))]) <= tcc_expression
)) ? (exp)->exp.locus : ((location_t) 0))) : (((((exp)) &&
 ((tree_code_type[(int) (((enum tree_code) ((exp))->base.code
))]) >= tcc_reference && (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[(int) (((enum tree_code
) ((exp))->base.code))]) >= tcc_reference && (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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3817, __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;
enum value_range_kind rng = get_range_info (bound, &min, &max);
if (rng != VR_RANGE)
  return NULL_RTX(rtx) 0;

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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3850, __FUNCTION__))->typed.type), len, bound);
return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3852}

3854/* 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.  */

3858static rtx
3859builtin_memcpy_read_str (void *data, HOST_WIDE_INTlong offset,
	 scalar_int_mode mode)
3861{
/* 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;

return c_readstr (rep + offset, mode, /*nul_terminated=*/false);
3867}

3869/* 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.  */

3874static void
3875determine_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)
3879{
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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3891, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3891, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3892, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3892, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3895, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3895, __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), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3897, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3897, __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)
range_type = get_range_info (len, &min, &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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3927, __FUNCTION__), 0 : 0))
       (unsigned HOST_WIDE_INT)((void)(!(*max_size <= (unsigned long) mode_mask_array[((machine_mode
) (len_rtx)->mode)]) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3927, __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 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 3927, __FUNCTION__), 0 : 0));
3928}

3930/* Issue a warning OPT for a bounded call EXP with a bound in RANGE
 accessing an object with SIZE.  */

3933static bool
3934maybe_warn_for_bound (int opt, location_t loc, tree exp, tree func,
      tree bndrng[2], tree size, const access_data *pad = NULL__null)
3936{
if (!bndrng[0] || TREE_NO_WARNING (exp)((exp)->base.nowarning_flag))
  return false;

tree maxobjsize = max_object_size ();

bool warned = false;

if (opt == OPT_Wstringop_overread)
  {
    bool maybe = pad && pad->src.phi ();

    if (tree_int_cst_lt (maxobjsize, bndrng[0]))
{
 if (bndrng[0] == bndrng[1])
   warned = (func
      ? warning_at (loc, opt,
		    (maybe
		     ? G_("%K%qD specified bound %E may ""%K%qD specified bound %E may " "exceed maximum object size %E"
			  "exceed maximum object size %E")"%K%qD specified bound %E may " "exceed maximum object size %E"
		     : G_("%K%qD specified bound %E ""%K%qD specified bound %E " "exceeds maximum object size %E"
			  "exceeds maximum object size %E")"%K%qD specified bound %E " "exceeds maximum object size %E"),
		    exp, func, bndrng[0], maxobjsize)
      : warning_at (loc, opt,
		    (maybe
		     ? G_("%Kspecified bound %E may ""%Kspecified bound %E may " "exceed maximum object size %E"
			  "exceed maximum object size %E")"%Kspecified bound %E may " "exceed maximum object size %E"
		     : G_("%Kspecified bound %E ""%Kspecified bound %E " "exceeds maximum object size %E"
			  "exceeds maximum object size %E")"%Kspecified bound %E " "exceeds maximum object size %E"),
		    exp, bndrng[0], maxobjsize));
 else
   warned = (func
      ? warning_at (loc, opt,
		    (maybe
		     ? G_("%K%qD specified bound [%E, %E] may ""%K%qD specified bound [%E, %E] may " "exceed maximum object size %E"
			  "exceed maximum object size %E")"%K%qD specified bound [%E, %E] may " "exceed maximum object size %E"
		     : G_("%K%qD specified bound [%E, %E] ""%K%qD specified bound [%E, %E] " "exceeds maximum object size %E"
			  "exceeds maximum object size %E")"%K%qD specified bound [%E, %E] " "exceeds maximum object size %E"),
		    exp, func,
		    bndrng[0], bndrng[1], maxobjsize)
      : warning_at (loc, opt,
		    (maybe
		     ? G_("%Kspecified bound [%E, %E] may ""%Kspecified bound [%E, %E] may " "exceed maximum object size %E"
			  "exceed maximum object size %E")"%Kspecified bound [%E, %E] may " "exceed maximum object size %E"
		     : G_("%Kspecified bound [%E, %E] ""%Kspecified bound [%E, %E] " "exceeds maximum object size %E"
			  "exceeds maximum object size %E")"%Kspecified bound [%E, %E] " "exceeds maximum object size %E"),
		    exp, bndrng[0], bndrng[1], maxobjsize));
}
    else if (!size || tree_int_cst_le (bndrng[0], size))
return false;
    else if (tree_int_cst_equal (bndrng[0], bndrng[1]))
warned = (func
  ? warning_at (loc, opt,
		(maybe
		 ? G_("%K%qD specified bound %E may exceed ""%K%qD specified bound %E may exceed " "source size %E"
		      "source size %E")"%K%qD specified bound %E may exceed " "source size %E"
		 : G_("%K%qD specified bound %E exceeds ""%K%qD specified bound %E exceeds " "source size %E"
		      "source size %E")"%K%qD specified bound %E exceeds " "source size %E"),
		exp, func, bndrng[0], size)
  : warning_at (loc, opt,
		(maybe
		 ? G_("%Kspecified bound %E may exceed ""%Kspecified bound %E may exceed " "source size %E"
		      "source size %E")"%Kspecified bound %E may exceed " "source size %E"
		 : G_("%Kspecified bound %E exceeds ""%Kspecified bound %E exceeds " "source size %E"
		      "source size %E")"%Kspecified bound %E exceeds " "source size %E"),
		exp, bndrng[0], size));
    else
warned = (func
  ? warning_at (loc, opt,
		(maybe
		 ? G_("%K%qD specified bound [%E, %E] may ""%K%qD specified bound [%E, %E] may " "exceed source size %E"
		      "exceed source size %E")"%K%qD specified bound [%E, %E] may " "exceed source size %E"
		 : G_("%K%qD specified bound [%E, %E] exceeds ""%K%qD specified bound [%E, %E] exceeds " "source size %E"
		      "source size %E")"%K%qD specified bound [%E, %E] exceeds " "source size %E"),
		exp, func, bndrng[0], bndrng[1], size)
  : warning_at (loc, opt,
		(maybe
		 ? G_("%Kspecified bound [%E, %E] may exceed ""%Kspecified bound [%E, %E] may exceed " "source size %E"
		      "source size %E")"%Kspecified bound [%E, %E] may exceed " "source size %E"
		 : G_("%Kspecified bound [%E, %E] exceeds ""%Kspecified bound [%E, %E] exceeds " "source size %E"
		      "source size %E")"%Kspecified bound [%E, %E] exceeds " "source size %E"),
		exp, bndrng[0], bndrng[1], size));
    if (warned)
{
 if (pad && pad->src.ref)
   {
     if (DECL_P (pad->src.ref)(tree_code_type[(int) (((enum tree_code) (pad->src.ref)->
base.code))] == tcc_declaration))
inform (DECL_SOURCE_LOCATION (pad->src.ref)((contains_struct_check ((pad->src.ref), (TS_DECL_MINIMAL)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4023, __FUNCTION__))->decl_minimal.locus),
	"source object declared here");
     else if (EXPR_HAS_LOCATION (pad->src.ref)(((IS_ADHOC_LOC (((((pad->src.ref)) && ((tree_code_type
[(int) (((enum tree_code) ((pad->src.ref))->base.code))
]) >= tcc_reference && (tree_code_type[(int) (((enum
 tree_code) ((pad->src.ref))->base.code))]) <= tcc_expression
)) ? (pad->src.ref)->exp.locus : ((location_t) 0)))) ? get_location_from_adhoc_loc
 (line_table, ((((pad->src.ref)) && ((tree_code_type
[(int) (((enum tree_code) ((pad->src.ref))->base.code))
]) >= tcc_reference && (tree_code_type[(int) (((enum
 tree_code) ((pad->src.ref))->base.code))]) <= tcc_expression
)) ? (pad->src.ref)->exp.locus : ((location_t) 0))) : (
((((pad->src.ref)) && ((tree_code_type[(int) (((enum
 tree_code) ((pad->src.ref))->base.code))]) >= tcc_reference
 && (tree_code_type[(int) (((enum tree_code) ((pad->
src.ref))->base.code))]) <= tcc_expression)) ? (pad->
src.ref)->exp.locus : ((location_t) 0)))) != ((location_t)
 0)))
inform (EXPR_LOCATION (pad->src.ref)((((pad->src.ref)) && ((tree_code_type[(int) (((enum
 tree_code) ((pad->src.ref))->base.code))]) >= tcc_reference
 && (tree_code_type[(int) (((enum tree_code) ((pad->
src.ref))->base.code))]) <= tcc_expression)) ? (pad->
src.ref)->exp.locus : ((location_t) 0)),
	"source object allocated here");
   }
 TREE_NO_WARNING (exp)((exp)->base.nowarning_flag) = true;
}

    return warned;
  }

bool maybe = pad && pad->dst.phi ();
if (tree_int_cst_lt (maxobjsize, bndrng[0]))
  {
    if (bndrng[0] == bndrng[1])
warned = (func
  ? warning_at (loc, opt,
		(maybe
		 ? G_("%K%qD specified size %E may ""%K%qD specified size %E may " "exceed maximum object size %E"
		      "exceed maximum object size %E")"%K%qD specified size %E may " "exceed maximum object size %E"
		 : G_("%K%qD specified size %E ""%K%qD specified size %E " "exceeds maximum object size %E"
		      "exceeds maximum object size %E")"%K%qD specified size %E " "exceeds maximum object size %E"),
		exp, func, bndrng[0], maxobjsize)
  : warning_at (loc, opt,
		(maybe
		 ? G_("%Kspecified size %E may exceed ""%Kspecified size %E may exceed " "maximum object size %E"
		      "maximum object size %E")"%Kspecified size %E may exceed " "maximum object size %E"
		 : G_("%Kspecified size %E exceeds ""%Kspecified size %E exceeds " "maximum object size %E"
		      "maximum object size %E")"%Kspecified size %E exceeds " "maximum object size %E"),
		exp, bndrng[0], maxobjsize));
    else
warned = (func
  ? warning_at (loc, opt,
		(maybe
		 ? G_("%K%qD specified size between %E and %E ""%K%qD specified size between %E and %E " "may exceed maximum object size %E"
		      "may exceed maximum object size %E")"%K%qD specified size between %E and %E " "may exceed maximum object size %E"
		 : G_("%K%qD specified size between %E and %E ""%K%qD specified size between %E and %E " "exceeds maximum object size %E"
		      "exceeds maximum object size %E")"%K%qD specified size between %E and %E " "exceeds maximum object size %E"),
		exp, func,
		bndrng[0], bndrng[1], maxobjsize)
  : warning_at (loc, opt,
		(maybe
		 ? G_("%Kspecified size between %E and %E ""%Kspecified size between %E and %E " "may exceed maximum object size %E"
		      "may exceed maximum object size %E")"%Kspecified size between %E and %E " "may exceed maximum object size %E"
		 : G_("%Kspecified size between %E and %E ""%Kspecified size between %E and %E " "exceeds maximum object size %E"
		      "exceeds maximum object size %E")"%Kspecified size between %E and %E " "exceeds maximum object size %E"),
		exp, bndrng[0], bndrng[1], maxobjsize));
  }
else if (!size || tree_int_cst_le (bndrng[0], size))
  return false;
else if (tree_int_cst_equal (bndrng[0], bndrng[1]))
  warned = (func
     ? warning_at (loc, OPT_Wstringop_overflow_,
	    (maybe
	     ? G_("%K%qD specified bound %E may exceed ""%K%qD specified bound %E may exceed " "destination size %E"
		  "destination size %E")"%K%qD specified bound %E may exceed " "destination size %E"
	     : G_("%K%qD specified bound %E exceeds ""%K%qD specified bound %E exceeds " "destination size %E"
		  "destination size %E")"%K%qD specified bound %E exceeds " "destination size %E"),
	    exp, func, bndrng[0], size)
     : warning_at (loc, OPT_Wstringop_overflow_,
	    (maybe
	     ? G_("%Kspecified bound %E may exceed ""%Kspecified bound %E may exceed " "destination size %E"
		  "destination size %E")"%Kspecified bound %E may exceed " "destination size %E"
	     : G_("%Kspecified bound %E exceeds ""%Kspecified bound %E exceeds " "destination size %E"
		  "destination size %E")"%Kspecified bound %E exceeds " "destination size %E"),
	    exp, bndrng[0], size));
else
  warned = (func
     ? warning_at (loc, OPT_Wstringop_overflow_,
	    (maybe
	     ? G_("%K%qD specified bound [%E, %E] may exceed ""%K%qD specified bound [%E, %E] may exceed " "destination size %E"
		  "destination size %E")"%K%qD specified bound [%E, %E] may exceed " "destination size %E"
	     : G_("%K%qD specified bound [%E, %E] exceeds ""%K%qD specified bound [%E, %E] exceeds " "destination size %E"
		  "destination size %E")"%K%qD specified bound [%E, %E] exceeds " "destination size %E"),
	    exp, func, bndrng[0], bndrng[1], size)
     : warning_at (loc, OPT_Wstringop_overflow_,
	    (maybe
	     ? G_("%Kspecified bound [%E, %E] exceeds ""%Kspecified bound [%E, %E] exceeds " "destination size %E"
		  "destination size %E")"%Kspecified bound [%E, %E] exceeds " "destination size %E"
	     : G_("%Kspecified bound [%E, %E] exceeds ""%Kspecified bound [%E, %E] exceeds " "destination size %E"
		  "destination size %E")"%Kspecified bound [%E, %E] exceeds " "destination size %E"),
	    exp, bndrng[0], bndrng[1], size));

if (warned)
  {
    if (pad && pad->dst.ref)
{
 if (DECL_P (pad->dst.ref)(tree_code_type[(int) (((enum tree_code) (pad->dst.ref)->
base.code))] == tcc_declaration))
   inform (DECL_SOURCE_LOCATION (pad->dst.ref)((contains_struct_check ((pad->dst.ref), (TS_DECL_MINIMAL)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4112, __FUNCTION__))->decl_minimal.locus),
    "destination object declared here");
 else if (EXPR_HAS_LOCATION (pad->dst.ref)(((IS_ADHOC_LOC (((((pad->dst.ref)) && ((tree_code_type
[(int) (((enum tree_code) ((pad->dst.ref))->base.code))
]) >= tcc_reference && (tree_code_type[(int) (((enum
 tree_code) ((pad->dst.ref))->base.code))]) <= tcc_expression
)) ? (pad->dst.ref)->exp.locus : ((location_t) 0)))) ? get_location_from_adhoc_loc
 (line_table, ((((pad->dst.ref)) && ((tree_code_type
[(int) (((enum tree_code) ((pad->dst.ref))->base.code))
]) >= tcc_reference && (tree_code_type[(int) (((enum
 tree_code) ((pad->dst.ref))->base.code))]) <= tcc_expression
)) ? (pad->dst.ref)->exp.locus : ((location_t) 0))) : (
((((pad->dst.ref)) && ((tree_code_type[(int) (((enum
 tree_code) ((pad->dst.ref))->base.code))]) >= tcc_reference
 && (tree_code_type[(int) (((enum tree_code) ((pad->
dst.ref))->base.code))]) <= tcc_expression)) ? (pad->
dst.ref)->exp.locus : ((location_t) 0)))) != ((location_t)
 0)))
   inform (EXPR_LOCATION (pad->dst.ref)((((pad->dst.ref)) && ((tree_code_type[(int) (((enum
 tree_code) ((pad->dst.ref))->base.code))]) >= tcc_reference
 && (tree_code_type[(int) (((enum tree_code) ((pad->
dst.ref))->base.code))]) <= tcc_expression)) ? (pad->
dst.ref)->exp.locus : ((location_t) 0)),
    "destination object allocated here");
}
    TREE_NO_WARNING (exp)((exp)->base.nowarning_flag) = true;
  }

return warned;
4122}

4124/* For an expression EXP issue an access warning controlled by option OPT
 with access to a region SIZE bytes in size in the RANGE of sizes.
 WRITE is true for a write access, READ for a read access, neither for
 call that may or may not perform an access but for which the range
 is expected to valid.
 Returns true when a warning has been issued.  */

4131static bool
4132warn_for_access (location_t loc, tree func, tree exp, int opt, tree range[2],
 tree size, bool write, bool read, bool maybe)
4134{
bool warned = false;

if (write && read)
  {
    if (tree_int_cst_equal (range[0], range[1]))
warned = (func
  ? warning_n (loc, opt, tree_to_uhwi (range[0]),
	       (maybe
		? G_("%K%qD may access %E byte in a region ""%K%qD may access %E byte in a region " "of size %E"
		     "of size %E")"%K%qD may access %E byte in a region " "of size %E"
		: G_("%K%qD accessing %E byte in a region ""%K%qD accessing %E byte in a region " "of size %E"
		     "of size %E")"%K%qD accessing %E byte in a region " "of size %E"),
		(maybe
		 ? G_ ("%K%qD may access %E bytes in a region ""%K%qD may access %E bytes in a region " "of size %E"
		       "of size %E")"%K%qD may access %E bytes in a region " "of size %E"
		 : G_ ("%K%qD accessing %E bytes in a region ""%K%qD accessing %E bytes in a region " "of size %E"
		       "of size %E")"%K%qD accessing %E bytes in a region " "of size %E"),
	       exp, func, range[0], size)
  : warning_n (loc, opt, tree_to_uhwi (range[0]),
	       (maybe
		? G_("%Kmay access %E byte in a region ""%Kmay access %E byte in a region " "of size %E"
		     "of size %E")"%Kmay access %E byte in a region " "of size %E"
		: G_("%Kaccessing %E byte in a region ""%Kaccessing %E byte in a region " "of size %E"
		     "of size %E")"%Kaccessing %E byte in a region " "of size %E"),
	       (maybe
		? G_("%Kmay access %E bytes in a region ""%Kmay access %E bytes in a region " "of size %E"
		     "of size %E")"%Kmay access %E bytes in a region " "of size %E"
		: G_("%Kaccessing %E bytes in a region ""%Kaccessing %E bytes in a region " "of size %E"
		     "of size %E")"%Kaccessing %E bytes in a region " "of size %E"),
	       exp, range[0], size));
    else if (tree_int_cst_sign_bit (range[1]))
{
 /* Avoid printing the upper bound if it's invalid.  */
 warned = (func
    ? warning_at (loc, opt,
		  (maybe
		   ? G_("%K%qD may access %E or more bytes ""%K%qD may access %E or more bytes " "in a region of size %E"
			"in a region of size %E")"%K%qD may access %E or more bytes " "in a region of size %E"
		   : G_("%K%qD accessing %E or more bytes ""%K%qD accessing %E or more bytes " "in a region of size %E"
			"in a region of size %E")"%K%qD accessing %E or more bytes " "in a region of size %E"),
		  exp, func, range[0], size)
    : warning_at (loc, opt,
		  (maybe
		   ? G_("%Kmay access %E or more bytes ""%Kmay access %E or more bytes " "in a region of size %E"
			"in a region of size %E")"%Kmay access %E or more bytes " "in a region of size %E"
		   : G_("%Kaccessing %E or more bytes ""%Kaccessing %E or more bytes " "in a region of size %E"
			"in a region of size %E")"%Kaccessing %E or more bytes " "in a region of size %E"),
		  exp, range[0], size));
}
    else
warned = (func
  ? warning_at (loc, opt,
		(maybe
		 ? G_("%K%qD may access between %E and %E ""%K%qD may access between %E and %E " "bytes in a region of size %E"
		      "bytes in a region of size %E")"%K%qD may access between %E and %E " "bytes in a region of size %E"
		 : G_("%K%qD accessing between %E and %E ""%K%qD accessing between %E and %E " "bytes in a region of size %E"
		      "bytes in a region of size %E")"%K%qD accessing between %E and %E " "bytes in a region of size %E"),
		exp, func, range[0], range[1],
		size)
  : warning_at (loc, opt,
		(maybe
		 ? G_("%Kmay access between %E and %E bytes ""%Kmay access between %E and %E bytes " "in a region of size %E"
		      "in a region of size %E")"%Kmay access between %E and %E bytes " "in a region of size %E"
		 : G_("%Kaccessing between %E and %E bytes ""%Kaccessing between %E and %E bytes " "in a region of size %E"
		      "in a region of size %E")"%Kaccessing between %E and %E bytes " "in a region of size %E"),
		exp, range[0], range[1],
		size));
    return warned;
  }

if (write)
  {
    if (tree_int_cst_equal (range[0], range[1]))
warned = (func
  ? warning_n (loc, opt, tree_to_uhwi (range[0]),
	       (maybe
		? G_("%K%qD may write %E byte into a region ""%K%qD may write %E byte into a region " "of size %E"
		     "of size %E")"%K%qD may write %E byte into a region " "of size %E"
		: G_("%K%qD writing %E byte into a region ""%K%qD writing %E byte into a region " "of size %E overflows the destination"
		     "of size %E overflows the destination")"%K%qD writing %E byte into a region " "of size %E overflows the destination"),
	       (maybe
		? G_("%K%qD may write %E bytes into a region ""%K%qD may write %E bytes into a region " "of size %E"
		     "of size %E")"%K%qD may write %E bytes into a region " "of size %E"
		: G_("%K%qD writing %E bytes into a region ""%K%qD writing %E bytes into a region " "of size %E overflows the destination"
		     "of size %E overflows the destination")"%K%qD writing %E bytes into a region " "of size %E overflows the destination"),
	       exp, func, range[0], size)
  : warning_n (loc, opt, tree_to_uhwi (range[0]),
	       (maybe
		? G_("%Kmay write %E byte into a region ""%Kmay write %E byte into a region " "of size %E"
		     "of size %E")"%Kmay write %E byte into a region " "of size %E"
		: G_("%Kwriting %E byte into a region ""%Kwriting %E byte into a region " "of size %E overflows the destination"
		     "of size %E overflows the destination")"%Kwriting %E byte into a region " "of size %E overflows the destination"),
	       (maybe
		? G_("%Kmay write %E bytes into a region ""%Kmay write %E bytes into a region " "of size %E"
		     "of size %E")"%Kmay write %E bytes into a region " "of size %E"
		: G_("%Kwriting %E bytes into a region ""%Kwriting %E bytes into a region " "of size %E overflows the destination"
		     "of size %E overflows the destination")"%Kwriting %E bytes into a region " "of size %E overflows the destination"),
	       exp, range[0], size));
    else if (tree_int_cst_sign_bit (range[1]))
{
 /* Avoid printing the upper bound if it's invalid.  */
 warned = (func
    ? warning_at (loc, opt,
		  (maybe
		   ? G_("%K%qD may write %E or more bytes ""%K%qD may write %E or more bytes " "into a region of size %E "
 "the destination"
			"into a region of size %E ""%K%qD may write %E or more bytes " "into a region of size %E "
 "the destination"
			"the destination")"%K%qD may write %E or more bytes " "into a region of size %E "
 "the destination"
		   : G_("%K%qD writing %E or more bytes ""%K%qD writing %E or more bytes " "into a region of size %E overflows "
 "the destination"
			"into a region of size %E overflows ""%K%qD writing %E or more bytes " "into a region of size %E overflows "
 "the destination"
			"the destination")"%K%qD writing %E or more bytes " "into a region of size %E overflows "
 "the destination"),
		  exp, func, range[0], size)
    : warning_at (loc, opt,
		  (maybe
		   ? G_("%Kmay write %E or more bytes into ""%Kmay write %E or more bytes into " "a region of size %E"
			"a region of size %E")"%Kmay write %E or more bytes into " "a region of size %E"
		   : G_("%Kwriting %E or more bytes into ""%Kwriting %E or more bytes into " "a region of size %E overflows "
 "the destination"
			"a region of size %E overflows ""%Kwriting %E or more bytes into " "a region of size %E overflows "
 "the destination"
			"the destination")"%Kwriting %E or more bytes into " "a region of size %E overflows "
 "the destination"),
		  exp, range[0], size));
}
    else
warned = (func
  ? warning_at (loc, opt,
		(maybe
		 ? G_("%K%qD may write between %E and %E bytes ""%K%qD may write between %E and %E bytes " "into a region of size %E"
		      "into a region of size %E")"%K%qD may write between %E and %E bytes " "into a region of size %E"
		 : G_("%K%qD writing between %E and %E bytes ""%K%qD writing between %E and %E bytes " "into a region of size %E overflows "
 "the destination"
		      "into a region of size %E overflows ""%K%qD writing between %E and %E bytes " "into a region of size %E overflows "
 "the destination"
		      "the destination")"%K%qD writing between %E and %E bytes " "into a region of size %E overflows "
 "the destination"),
		exp, func, range[0], range[1],
		size)
  : warning_at (loc, opt,
		(maybe
		 ? G_("%Kmay write between %E and %E bytes ""%Kmay write between %E and %E bytes " "into a region of size %E"
		      "into a region of size %E")"%Kmay write between %E and %E bytes " "into a region of size %E"
		 : G_("%Kwriting between %E and %E bytes ""%Kwriting between %E and %E bytes " "into a region of size %E overflows "
 "the destination"
		      "into a region of size %E overflows ""%Kwriting between %E and %E bytes " "into a region of size %E overflows "
 "the destination"
		      "the destination")"%Kwriting between %E and %E bytes " "into a region of size %E overflows "
 "the destination"),
		exp, range[0], range[1],
		size));
    return warned;
  }

if (read)
  {
    if (tree_int_cst_equal (range[0], range[1]))
warned = (func
  ? warning_n (loc, OPT_Wstringop_overread,
	       tree_to_uhwi (range[0]),
	       (maybe
		? G_("%K%qD may reade %E byte from a region ""%K%qD may reade %E byte from a region " "of size %E"
		     "of size %E")"%K%qD may reade %E byte from a region " "of size %E"
		: G_("%K%qD reading %E byte from a region ""%K%qD reading %E byte from a region " "of size %E"
		     "of size %E")"%K%qD reading %E byte from a region " "of size %E"),
	       (maybe
		? G_("%K%qD may read %E bytes from a region ""%K%qD may read %E bytes from a region " "of size %E"
		     "of size %E")"%K%qD may read %E bytes from a region " "of size %E"
		: G_("%K%qD reading %E bytes from a region ""%K%qD reading %E bytes from a region " "of size %E"
		     "of size %E")"%K%qD reading %E bytes from a region " "of size %E"),
	       exp, func, range[0], size)
  : warning_n (loc, OPT_Wstringop_overread,
	       tree_to_uhwi (range[0]),
	       (maybe
		? G_("%Kmay read %E byte from a region ""%Kmay read %E byte from a region " "of size %E"
		     "of size %E")"%Kmay read %E byte from a region " "of size %E"
		: G_("%Kreading %E byte from a region ""%Kreading %E byte from a region " "of size %E"
		     "of size %E")"%Kreading %E byte from a region " "of size %E"),
	       (maybe
		? G_("%Kmay read %E bytes from a region ""%Kmay read %E bytes from a region " "of size %E"
		     "of size %E")"%Kmay read %E bytes from a region " "of size %E"
		: G_("%Kreading %E bytes from a region ""%Kreading %E bytes from a region " "of size %E"
		     "of size %E")"%Kreading %E bytes from a region " "of size %E"),
	       exp, range[0], size));
    else if (tree_int_cst_sign_bit (range[1]))
{
 /* Avoid printing the upper bound if it's invalid.  */
 warned = (func
    ? warning_at (loc, OPT_Wstringop_overread,
		  (maybe
		   ? G_("%K%qD may read %E or more bytes ""%K%qD may read %E or more bytes " "from a region of size %E"
			"from a region of size %E")"%K%qD may read %E or more bytes " "from a region of size %E"
		   : G_("%K%qD reading %E or more bytes ""%K%qD reading %E or more bytes " "from a region of size %E"
			"from a region of size %E")"%K%qD reading %E or more bytes " "from a region of size %E"),
		  exp, func, range[0], size)
    : warning_at (loc, OPT_Wstringop_overread,
		  (maybe
		   ? G_("%Kmay read %E or more bytes ""%Kmay read %E or more bytes " "from a region of size %E"
			"from a region of size %E")"%Kmay read %E or more bytes " "from a region of size %E"
		   : G_("%Kreading %E or more bytes ""%Kreading %E or more bytes " "from a region of size %E"
			"from a region of size %E")"%Kreading %E or more bytes " "from a region of size %E"),
		  exp, range[0], size));
}
    else
warned = (func
  ? warning_at (loc, OPT_Wstringop_overread,
		(maybe
		 ? G_("%K%qD may read between %E and %E bytes ""%K%qD may read between %E and %E bytes " "from a region of size %E"
		      "from a region of size %E")"%K%qD may read between %E and %E bytes " "from a region of size %E"
		 : G_("%K%qD reading between %E and %E bytes ""%K%qD reading between %E and %E bytes " "from a region of size %E"
		      "from a region of size %E")"%K%qD reading between %E and %E bytes " "from a region of size %E"),
		exp, func, range[0], range[1], size)
  : warning_at (loc, opt,
		(maybe
		 ? G_("%Kmay read between %E and %E bytes ""%Kmay read between %E and %E bytes " "from a region of size %E"
		      "from a region of size %E")"%Kmay read between %E and %E bytes " "from a region of size %E"
		 : G_("%Kreading between %E and %E bytes ""%Kreading between %E and %E bytes " "from a region of size %E"
		      "from a region of size %E")"%Kreading between %E and %E bytes " "from a region of size %E"),
		exp, range[0], range[1], size));

    if (warned)
TREE_NO_WARNING (exp)((exp)->base.nowarning_flag) = true;

    return warned;
  }

if (tree_int_cst_equal (range[0], range[1])
    || tree_int_cst_sign_bit (range[1]))
  warned = (func
     ? warning_n (loc, OPT_Wstringop_overread,
	   tree_to_uhwi (range[0]),
	   "%K%qD epecting %E byte in a region of size %E",
	   "%K%qD expecting %E bytes in a region of size %E",
	   exp, func, range[0], size)
     : warning_n (loc, OPT_Wstringop_overread,
	   tree_to_uhwi (range[0]),
	   "%Kexpecting %E byte in a region of size %E",
	   "%Kexpecting %E bytes in a region of size %E",
	   exp, range[0], size));
else if (tree_int_cst_sign_bit (range[1]))
  {
    /* Avoid printing the upper bound if it's invalid.  */
    warned = (func
? warning_at (loc, OPT_Wstringop_overread,
	      "%K%qD expecting %E or more bytes in a region "
	      "of size %E",
	      exp, func, range[0], size)
: warning_at (loc, OPT_Wstringop_overread,
	      "%Kexpecting %E or more bytes in a region "
	      "of size %E",
	      exp, range[0], size));
  }
else
  warned = (func
     ? warning_at (loc, OPT_Wstringop_overread,
	    "%K%qD expecting between %E and %E bytes in "
	    "a region of size %E",
	    exp, func, range[0], range[1], size)
     : warning_at (loc, OPT_Wstringop_overread,
	    "%Kexpectting between %E and %E bytes in "
	    "a region of size %E",
	    exp, range[0], range[1], size));

if (warned)
  TREE_NO_WARNING (exp)((exp)->base.nowarning_flag) = true;

return warned;
4391}

4393/* Issue one inform message describing each target of an access REF.
 WRITE is set for a write access and clear for a read access.  */

4396void
4397access_ref::inform_access (access_mode mode) const
4398{
const access_ref &aref = *this;
if (!aref.ref)
  return;

if (aref.phi ())
  {
    /* Set MAXREF to refer to the largest object and fill ALL_REFS
with data for all objects referenced by the PHI arguments.  */
    access_ref maxref;
    auto_vec<access_ref> all_refs;
    if (!get_ref (&all_refs, &maxref))
return;

    /* Except for MAXREF, the rest of the arguments' offsets need not
reflect one added to the PHI itself.  Determine the latter from
MAXREF on which the result is based.  */
    const offset_int orng[] =
{
offrng[0] - maxref.offrng[0],
wi::smax (offrng[1] - maxref.offrng[1], offrng[0]),
};

    /* Add the final PHI's offset to that of each of the arguments
and recurse to issue an inform message for it.  */
    for (unsigned i = 0; i != all_refs.length (); ++i)
{
 /* Skip any PHIs; those could lead to infinite recursion.  */
 if (all_refs[i].phi ())
   continue;

 all_refs[i].add_offset (orng[0], orng[1]);
 all_refs[i].inform_access (mode);
}
    return;
  }

/* Convert offset range and avoid including a zero range since it
   isn't necessarily meaningful.  */
HOST_WIDE_INTlong diff_min = tree_to_shwi (TYPE_MIN_VALUE (ptrdiff_type_node)((tree_check5 ((global_trees[TI_PTRDIFF_TYPE]), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4437, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
));
HOST_WIDE_INTlong diff_max = tree_to_shwi (TYPE_MAX_VALUE (ptrdiff_type_node)((tree_check5 ((global_trees[TI_PTRDIFF_TYPE]), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4438, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
));
HOST_WIDE_INTlong minoff;
HOST_WIDE_INTlong maxoff = diff_max;
if (wi::fits_shwi_p (aref.offrng[0]))
  minoff = aref.offrng[0].to_shwi ();
else
  minoff = aref.offrng[0] < 0 ? diff_min : diff_max;

if (wi::fits_shwi_p (aref.offrng[1]))
  maxoff = aref.offrng[1].to_shwi ();

if (maxoff <= diff_min || maxoff >= diff_max)
  /* Avoid mentioning an upper bound that's equal to or in excess
     of the maximum of ptrdiff_t.  */
  maxoff = minoff;

/* Convert size range and always include it since all sizes are
   meaningful. */
unsigned long long minsize = 0, maxsize = 0;
if (wi::fits_shwi_p (aref.sizrng[0])
    && wi::fits_shwi_p (aref.sizrng[1]))
  {
    minsize = aref.sizrng[0].to_shwi ();
    maxsize = aref.sizrng[1].to_shwi ();
  }

/* SIZRNG doesn't necessarily have the same range as the allocation
   size determined by gimple_call_alloc_size ().  */
char sizestr[80];
if (minsize == maxsize)
  sprintf (sizestr, "%llu", minsize);
else
  sprintf (sizestr, "[%llu, %llu]", minsize, maxsize);

char offstr[80];
if (minoff == 0
    && (maxoff == 0 || aref.sizrng[1] <= maxoff))
  offstr[0] = '\0';
else if (minoff == maxoff)
  sprintf (offstr, "%lli", (long long) minoff);
else
  sprintf (offstr, "[%lli, %lli]", (long long) minoff, (long long) maxoff);

location_t loc = UNKNOWN_LOCATION((location_t) 0);

tree ref = this->ref;
tree allocfn = NULL_TREE(tree) __null;
if (TREE_CODE (ref)((enum tree_code) (ref)->base.code) == SSA_NAME)
  {
    gimple *stmt = SSA_NAME_DEF_STMT (ref)(tree_check ((ref), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4487, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
    if (is_gimple_call (stmt))
{
 loc = gimple_location (stmt);
 if (gimple_call_builtin_p (stmt, BUILT_IN_ALLOCA_WITH_ALIGN))
   {
     /* Strip the SSA_NAME suffix from the variable name and
 recreate an identifier with the VLA's original name.  */
     ref = gimple_call_lhs (stmt);
     ref = SSA_NAME_IDENTIFIER (ref)((tree_check ((ref), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4496, __FUNCTION__, (SSA_NAME)))->ssa_name.var != (tree)
 __null ? (((enum tree_code) ((ref)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (ref)->ssa_name.var : ((contains_struct_check
 (((ref)->ssa_name.var), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4496, __FUNCTION__))->decl_minimal.name)) : (tree) __null
);
     const char *id = IDENTIFIER_POINTER (ref)((const char *) (tree_check ((ref), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4497, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
);
     size_t len = strcspn (id, ".$");
     if (!len)
len = strlen (id);
     ref = get_identifier_with_length (id, len);
   }
 else
   {
     /* Except for VLAs, retrieve the allocation function.  */
     allocfn = gimple_call_fndecl (stmt);
     if (!allocfn)
allocfn = gimple_call_fn (stmt);
     if (TREE_CODE (allocfn)((enum tree_code) (allocfn)->base.code) == SSA_NAME)
{
  /* For an ALLOC_CALL via a function pointer make a small
     effort to determine the destination of the pointer.  */
  gimple *def = SSA_NAME_DEF_STMT (allocfn)(tree_check ((allocfn), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4513, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
  if (gimple_assign_single_p (def))
    {
      tree rhs = gimple_assign_rhs1 (def);
      if (DECL_P (rhs)(tree_code_type[(int) (((enum tree_code) (rhs)->base.code)
)] == tcc_declaration))
	allocfn = rhs;
      else if (TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) == COMPONENT_REF)
	allocfn = TREE_OPERAND (rhs, 1)(*((const_cast<tree*> (tree_operand_check ((rhs), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4520, __FUNCTION__)))));
    }
}
   }
}
    else if (gimple_nop_p (stmt))
/* Handle DECL_PARM below.  */
ref = SSA_NAME_VAR (ref)((tree_check ((ref), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4527, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 __null || ((enum tree_code) ((ref)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) __null : (ref)->ssa_name
.var);
  }

if (DECL_P (ref)(tree_code_type[(int) (((enum tree_code) (ref)->base.code)
)] == tcc_declaration))
  loc = DECL_SOURCE_LOCATION (ref)((contains_struct_check ((ref), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4531, __FUNCTION__))->decl_minimal.locus);
else if (EXPR_P (ref)((tree_code_type[(int) (((enum tree_code) (ref)->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) (ref)->base.code))]) <= tcc_expression) && EXPR_HAS_LOCATION (ref)(((IS_ADHOC_LOC (((((ref)) && ((tree_code_type[(int) (
((enum tree_code) ((ref))->base.code))]) >= tcc_reference
 && (tree_code_type[(int) (((enum tree_code) ((ref))->
base.code))]) <= tcc_expression)) ? (ref)->exp.locus : (
(location_t) 0)))) ? get_location_from_adhoc_loc (line_table,
 ((((ref)) && ((tree_code_type[(int) (((enum tree_code
) ((ref))->base.code))]) >= tcc_reference && (tree_code_type
[(int) (((enum tree_code) ((ref))->base.code))]) <= tcc_expression
)) ? (ref)->exp.locus : ((location_t) 0))) : (((((ref)) &&
 ((tree_code_type[(int) (((enum tree_code) ((ref))->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) ((ref))->base.code))]) <= tcc_expression
)) ? (ref)->exp.locus : ((location_t) 0)))) != ((location_t
) 0)))
  loc = EXPR_LOCATION (ref)((((ref)) && ((tree_code_type[(int) (((enum tree_code
) ((ref))->base.code))]) >= tcc_reference && (tree_code_type
[(int) (((enum tree_code) ((ref))->base.code))]) <= tcc_expression
)) ? (ref)->exp.locus : ((location_t) 0));
else if (TREE_CODE (ref)((enum tree_code) (ref)->base.code) != IDENTIFIER_NODE
  && TREE_CODE (ref)((enum tree_code) (ref)->base.code) != SSA_NAME)
  return;

if (mode == access_read_write || mode == access_write_only)
  {
    if (allocfn == NULL_TREE(tree) __null)
{
 if (*offstr)
   inform (loc, "at offset %s into destination object %qE of size %s",
    offstr, ref, sizestr);
 else
   inform (loc, "destination object %qE of size %s", ref, sizestr);
 return;
}

    if (*offstr)
inform (loc,
"at offset %s into destination object of size %s "
"allocated by %qE", offstr, sizestr, allocfn);
    else
inform (loc, "destination object of size %s allocated by %qE",
sizestr, allocfn);
    return;
  }

if (DECL_P (ref)(tree_code_type[(int) (((enum tree_code) (ref)->base.code)
)] == tcc_declaration))
  {
    if (*offstr)
inform (loc, "at offset %s into source object %qD of size %s",
offstr, ref, sizestr);
    else
inform (loc, "source object %qD of size %s", ref,  sizestr);

    return;
  }

if (*offstr)
  inform (loc,
   "at offset %s into source object of size %s allocated by %qE",
   offstr, sizestr, allocfn);
else
  inform (loc, "source object of size %s allocated by %qE",
   sizestr, allocfn);
4578}

4580/* Helper to set RANGE to the range of BOUND if it's nonnull, bounded
 by BNDRNG if nonnull and valid.  */

4583static void
4584get_size_range (tree bound, tree range[2], const offset_int bndrng[2])
4585{
if (bound)
  get_size_range (bound, range);

if (!bndrng || (bndrng[0] == 0 && bndrng[1] == HOST_WIDE_INT_M1U-1UL))
  return;

if (range[0] && TREE_CODE (range[0])((enum tree_code) (range[0])->base.code) == INTEGER_CST)
  {
    offset_int r[] =
{ wi::to_offset (range[0]), wi::to_offset (range[1]) };
    if (r[0] < bndrng[0])
range[0] = wide_int_to_tree (sizetypesizetype_tab[(int) stk_sizetype], bndrng[0]);
    if (bndrng[1] < r[1])
range[1] = wide_int_to_tree (sizetypesizetype_tab[(int) stk_sizetype], bndrng[1]);
  }
else
  {
    range[0] = wide_int_to_tree (sizetypesizetype_tab[(int) stk_sizetype], bndrng[0]);
    range[1] = wide_int_to_tree (sizetypesizetype_tab[(int) stk_sizetype], bndrng[1]);
  }
4606}

4608/* Try to verify that the sizes and lengths of the arguments to a string
 manipulation function given by EXP are within valid bounds and that
 the operation does not lead to buffer overflow or read past the end.
 Arguments other than EXP may be null.  When non-null, the arguments
 have the following meaning:
 DST is the destination of a copy call or NULL otherwise.
 SRC is the source of a copy call or NULL otherwise.
 DSTWRITE is the number of bytes written into the destination obtained
 from the user-supplied size argument to the function (such as in
 memcpy(DST, SRCs, DSTWRITE) or strncpy(DST, DRC, DSTWRITE).
 MAXREAD is the user-supplied bound on the length of the source sequence
 (such as in strncat(d, s, N).  It specifies the upper limit on the number
 of bytes to write.  If NULL, it's taken to be the same as DSTWRITE.
 SRCSTR is the source string (such as in strcpy(DST, SRC)) when the
 expression EXP is a string function call (as opposed to a memory call
 like memcpy).  As an exception, SRCSTR can also be an integer denoting
 the precomputed size of the source string or object (for functions like
 memcpy).
 DSTSIZE is the size of the destination object.

 When DSTWRITE is null LEN is checked to verify that it doesn't exceed
 SIZE_MAX.

 WRITE is true for write accesses, READ is true for reads.  Both are
 false for simple size checks in calls to functions that neither read
 from nor write to the region.

 When nonnull, PAD points to a more detailed description of the access.

 If the call is successfully verified as safe return true, otherwise
 return false.  */

4640bool
4641check_access (tree exp, tree dstwrite,
     tree maxread, tree srcstr, tree dstsize,
     access_mode mode, const access_data *pad /* = NULL */)
4644{
/* The size of the largest object is half the address space, or
   PTRDIFF_MAX.  (This is way too permissive.)  */
tree maxobjsize = max_object_size ();

/* Either an approximate/minimum the length of the source string for
   string functions or the size of the source object for raw memory
   functions.  */
tree slen = NULL_TREE(tree) __null;

/* The range of the access in bytes; first set to the write access
   for functions that write and then read for those that also (or
   just) read.  */
tree range[2] = { NULL_TREE(tree) __null, NULL_TREE(tree) __null };

/* Set to true when the exact number of bytes written by a string
   function like strcpy is not known and the only thing that is
   known is that it must be at least one (for the terminating nul).  */
bool at_least_one = false;
if (srcstr)
  {
    /* SRCSTR is normally a pointer to string but as a special case
it can be an integer denoting the length of a string.  */
    if (POINTER_TYPE_P (TREE_TYPE (srcstr))(((enum tree_code) (((contains_struct_check ((srcstr), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4667, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((srcstr), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4667, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
{
 if (!check_nul_terminated_array (exp, srcstr, maxread))
   return false;
 /* Try to determine the range of lengths the source string
    refers to.  If it can be determined and is less than
    the upper bound given by MAXREAD add one to it for
    the terminating nul.  Otherwise, set it to one for
    the same reason, or to MAXREAD as appropriate.  */
 c_strlen_data lendata = { };
 get_range_strlen (srcstr, &lendata, /* eltsize = */ 1);
 range[0] = lendata.minlen;
 range[1] = lendata.maxbound ? lendata.maxbound : lendata.maxlen;
 if (range[0]
     && TREE_CODE (range[0])((enum tree_code) (range[0])->base.code) == INTEGER_CST
     && TREE_CODE (range[1])((enum tree_code) (range[1])->base.code) == INTEGER_CST
     && (!maxread || TREE_CODE (maxread)((enum tree_code) (maxread)->base.code) == INTEGER_CST))
   {
     if (maxread && tree_int_cst_le (maxread, range[0]))
range[0] = range[1] = maxread;
     else
range[0] = fold_build2 (PLUS_EXPR, size_type_node,fold_build2_loc (((location_t) 0), PLUS_EXPR, global_trees[TI_SIZE_TYPE
], range[0], global_trees[TI_SIZE_ONE] )
			range[0], size_one_node)fold_build2_loc (((location_t) 0), PLUS_EXPR, global_trees[TI_SIZE_TYPE
], range[0], global_trees[TI_SIZE_ONE] );

     if (maxread && tree_int_cst_le (maxread, range[1]))
range[1] = maxread;
     else if (!integer_all_onesp (range[1]))
range[1] = fold_build2 (PLUS_EXPR, size_type_node,fold_build2_loc (((location_t) 0), PLUS_EXPR, global_trees[TI_SIZE_TYPE
], range[1], global_trees[TI_SIZE_ONE] )
			range[1], size_one_node)fold_build2_loc (((location_t) 0), PLUS_EXPR, global_trees[TI_SIZE_TYPE
], range[1], global_trees[TI_SIZE_ONE] );

     slen = range[0];
   }
 else
   {
     at_least_one = true;
     slen = size_one_nodeglobal_trees[TI_SIZE_ONE];
   }
}
    else
slen = srcstr;
  }

if (!dstwrite && !maxread)
  {
    /* When the only available piece of data is the object size
there is nothing to do.  */
    if (!slen)
return true;

    /* Otherwise, when the length of the source sequence is known
(as with strlen), set DSTWRITE to it.  */
    if (!range[0])
dstwrite = slen;
  }

if (!dstsize)
  dstsize = maxobjsize;

/* Set RANGE to that of DSTWRITE if non-null, bounded by PAD->DST.BNDRNG
   if valid.  */
get_size_range (dstwrite, range, pad ? pad->dst.bndrng : NULL__null);

tree func = get_callee_fndecl (exp);
/* Read vs write access by built-ins can be determined from the const
   qualifiers on the pointer argument.  In the absence of attribute
   access, non-const qualified pointer arguments to user-defined
   functions are assumed to both read and write the objects.  */
const bool builtin = func ? fndecl_built_in_p (func) : false;

/* First check the number of bytes to be written against the maximum
   object size.  */
if (range[0]
    && TREE_CODE (range[0])((enum tree_code) (range[0])->base.code) == INTEGER_CST
    && tree_int_cst_lt (maxobjsize, range[0]))
  {
    location_t loc = tree_inlined_location (exp);
    maybe_warn_for_bound (OPT_Wstringop_overflow_, loc, exp, func, range,
	    NULL_TREE(tree) __null, pad);
    return false;
  }

/* The number of bytes to write is "exact" if DSTWRITE is non-null,
   constant, and in range of unsigned HOST_WIDE_INT.  */
bool exactwrite = dstwrite && tree_fits_uhwi_p (dstwrite);

/* Next check the number of bytes to be written against the destination
   object size.  */
if (range[0] || !exactwrite || integer_all_onesp (dstwrite))
  {
    if (range[0]
 && TREE_CODE (range[0])((enum tree_code) (range[0])->base.code) == INTEGER_CST
 && ((tree_fits_uhwi_p (dstsize)
      && tree_int_cst_lt (dstsize, range[0]))
     || (dstwrite
  && tree_fits_uhwi_p (dstwrite)
  && tree_int_cst_lt (dstwrite, range[0]))))
{
 if (TREE_NO_WARNING (exp)((exp)->base.nowarning_flag)
     || (pad && pad->dst.ref && TREE_NO_WARNING (pad->dst.ref)((pad->dst.ref)->base.nowarning_flag)))
   return false;

 location_t loc = tree_inlined_location (exp);
 bool warned = false;
 if (dstwrite == slen && at_least_one)
   {
     /* This is a call to strcpy with a destination of 0 size
 and a source of unknown length.  The call will write
 at least one byte past the end of the destination.  */
     warned = (func
	? warning_at (loc, OPT_Wstringop_overflow_,
		      "%K%qD writing %E or more bytes into "
		      "a region of size %E overflows "
		      "the destination",
		      exp, func, range[0], dstsize)
	: warning_at (loc, OPT_Wstringop_overflow_,
		      "%Kwriting %E or more bytes into "
		      "a region of size %E overflows "
		      "the destination",
		      exp, range[0], dstsize));
   }
 else
   {
     const bool read
= mode == access_read_only || mode == access_read_write;
     const bool write
= mode == access_write_only || mode == access_read_write;
     const bool maybe = pad && pad->dst.parmarray;
     warned = warn_for_access (loc, func, exp,
			OPT_Wstringop_overflow_,
			range, dstsize,
			write, read && !builtin, maybe);
   }

 if (warned)
   {
     TREE_NO_WARNING (exp)((exp)->base.nowarning_flag) = true;
     if (pad)
pad->dst.inform_access (pad->mode);
   }

 /* Return error when an overflow has been detected.  */
 return false;
}
  }

/* Check the maximum length of the source sequence against the size
   of the destination object if known, or against the maximum size
   of an object.  */
if (maxread)
  {
    /* Set RANGE to that of MAXREAD, bounded by PAD->SRC.BNDRNG if
PAD is nonnull and BNDRNG is valid.  */
    get_size_range (maxread, range, pad ? pad->src.bndrng : NULL__null);

    location_t loc = tree_inlined_location (exp);
    tree size = dstsize;
    if (pad && pad->mode == access_read_only)
size = wide_int_to_tree (sizetypesizetype_tab[(int) stk_sizetype], pad->src.sizrng[1]);

    if (range[0] && maxread && tree_fits_uhwi_p (size))
{
 if (tree_int_cst_lt (maxobjsize, range[0]))
   {
     maybe_warn_for_bound (OPT_Wstringop_overread, loc, exp, func,
		    range, size, pad);
     return false;
   }

 if (size != maxobjsize && tree_int_cst_lt (size, range[0]))
   {
     int opt = (dstwrite || mode != access_read_only
	 ? OPT_Wstringop_overflow_
	 : OPT_Wstringop_overread);
     maybe_warn_for_bound (opt, loc, exp, func, range, size, pad);
     return false;
   }
}

    maybe_warn_nonstring_arg (func, exp);
  }

/* Check for reading past the end of SRC.  */
bool overread = (slen
   && slen == srcstr
   && dstwrite
   && range[0]
   && TREE_CODE (slen)((enum tree_code) (slen)->base.code) == INTEGER_CST
   && tree_int_cst_lt (slen, range[0]));
/* If none is determined try to get a better answer based on the details
   in PAD.  */
if (!overread
    && pad
    && pad->src.sizrng[1] >= 0
    && pad->src.offrng[0] >= 0
    && (pad->src.offrng[1] < 0
 || pad->src.offrng[0] <= pad->src.offrng[1]))
  {
    /* Set RANGE to that of MAXREAD, bounded by PAD->SRC.BNDRNG if
PAD is nonnull and BNDRNG is valid.  */
    get_size_range (maxread, range, pad ? pad->src.bndrng : NULL__null);
    /* Set OVERREAD for reads starting just past the end of an object.  */
    overread = pad->src.sizrng[1] - pad->src.offrng[0] < pad->src.bndrng[0];
    range[0] = wide_int_to_tree (sizetypesizetype_tab[(int) stk_sizetype], pad->src.bndrng[0]);
    slen = size_zero_nodeglobal_trees[TI_SIZE_ZERO];
  }

if (overread)
  {
    if (TREE_NO_WARNING (exp)((exp)->base.nowarning_flag)
 || (srcstr && TREE_NO_WARNING (srcstr)((srcstr)->base.nowarning_flag))
 || (pad && pad->src.ref && TREE_NO_WARNING (pad->src.ref)((pad->src.ref)->base.nowarning_flag)))
return false;

    location_t loc = tree_inlined_location (exp);
    const bool read
= mode == access_read_only || mode == access_read_write;
    const bool maybe = pad && pad->dst.parmarray;
    if (warn_for_access (loc, func, exp, OPT_Wstringop_overread, range,
	   slen, false, read, maybe))
{
 TREE_NO_WARNING (exp)((exp)->base.nowarning_flag) = true;
 if (pad)
   pad->src.inform_access (access_read_only);
}
    return false;
  }

return true;
4895}

4897/* A convenience wrapper for check_access above to check access
 by a read-only function like puts.  */

4900static bool
4901check_read_access (tree exp, tree src, tree bound /* = NULL_TREE */,
   int ost /* = 1 */)
4903{
if (!warn_stringop_overreadglobal_options.x_warn_stringop_overread)
  return true;

access_data data (exp, access_read_only, NULL_TREE(tree) __null, false, bound, true);
compute_objsize (src, ost, &data.src);
return check_access (exp, /*dstwrite=*/ NULL_TREE(tree) __null, /*maxread=*/ bound,
       /*srcstr=*/ src, /*dstsize=*/ NULL_TREE(tree) __null, data.mode,
       &data);
4912}

4914/* If STMT is a call to an allocation function, returns the constant
 maximum size of the object allocated by the call represented as
 sizetype.  If nonnull, sets RNG1[] to the range of the size.
 When nonnull, uses RVALS for range information, otherwise calls
 get_range_info to get it.
 Returns null when STMT is not a call to a valid allocation function.  */

4921tree
4922gimple_call_alloc_size (gimple *stmt, wide_int rng1[2] /* = NULL */,
	range_query * /* = NULL */)
4924{
if (!stmt)
  return NULL_TREE(tree) __null;

tree allocfntype;
if (tree fndecl = gimple_call_fndecl (stmt))
  allocfntype = TREE_TYPE (fndecl)((contains_struct_check ((fndecl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4930, __FUNCTION__))->typed.type);
else
  allocfntype = gimple_call_fntype (stmt);

if (!allocfntype)
  return NULL_TREE(tree) __null;

unsigned argidx1 = UINT_MAX(2147483647 *2U +1U), argidx2 = UINT_MAX(2147483647 *2U +1U);
tree at = lookup_attribute ("alloc_size", TYPE_ATTRIBUTES (allocfntype)((tree_class_check ((allocfntype), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4938, __FUNCTION__))->type_common.attributes));
if (!at)
  {
    if (!gimple_call_builtin_p (stmt, BUILT_IN_ALLOCA_WITH_ALIGN))
return NULL_TREE(tree) __null;

    argidx1 = 0;
  }

unsigned nargs = gimple_call_num_args (stmt);

if (argidx1 == UINT_MAX(2147483647 *2U +1U))
  {
    tree atval = TREE_VALUE (at)((tree_check ((at), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4951, __FUNCTION__, (TREE_LIST)))->list.value);
    if (!atval)
return NULL_TREE(tree) __null;

    argidx1 = TREE_INT_CST_LOW (TREE_VALUE (atval))((unsigned long) (*tree_int_cst_elt_check ((((tree_check ((atval
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4955, __FUNCTION__, (TREE_LIST)))->list.value)), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4955, __FUNCTION__))) - 1;
    if (nargs <= argidx1)
return NULL_TREE(tree) __null;

    atval = TREE_CHAIN (atval)((contains_struct_check ((atval), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4959, __FUNCTION__))->common.chain);
    if (atval)
{
 argidx2 = TREE_INT_CST_LOW (TREE_VALUE (atval))((unsigned long) (*tree_int_cst_elt_check ((((tree_check ((atval
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4962, __FUNCTION__, (TREE_LIST)))->list.value)), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 4962, __FUNCTION__))) - 1;
 if (nargs <= argidx2)
   return NULL_TREE(tree) __null;
}
  }

tree size = gimple_call_arg (stmt, argidx1);

wide_int rng1_buf[2];
/* If RNG1 is not set, use the buffer.  */
if (!rng1)
  rng1 = rng1_buf;

/* Use maximum precision to avoid overflow below.  */
const int prec = ADDR_MAX_PRECISION((64 + 4 + 64 - 1) & ~(64 - 1));

{
  tree r[2];
  /* Determine the largest valid range size, including zero.  */
  if (!get_size_range (size, r, SR_ALLOW_ZERO | SR_USE_LARGEST))
    return NULL_TREE(tree) __null;
  rng1[0] = wi::to_wide (r[0], prec);
  rng1[1] = wi::to_wide (r[1], prec);
}

if (argidx2 > nargs && TREE_CODE (size)((enum tree_code) (size)->base.code) == INTEGER_CST)
  return fold_convert (sizetype, size)fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], size);

/* To handle ranges do the math in wide_int and return the product
   of the upper bounds as a constant.  Ignore anti-ranges.  */
tree n = argidx2 < nargs ? gimple_call_arg (stmt, argidx2) : integer_one_nodeglobal_trees[TI_INTEGER_ONE];
wide_int rng2[2];
{
  tree r[2];
    /* As above, use the full non-negative range on failure.  */
  if (!get_size_range (n, r, SR_ALLOW_ZERO | SR_USE_LARGEST))
    return NULL_TREE(tree) __null;
  rng2[0] = wi::to_wide (r[0], prec);
  rng2[1] = wi::to_wide (r[1], prec);
}

/* Compute products of both bounds for the caller but return the lesser
   of SIZE_MAX and the product of the upper bounds as a constant.  */
rng1[0] = rng1[0] * rng2[0];
rng1[1] = rng1[1] * rng2[1];

const tree size_max = TYPE_MAX_VALUE (sizetype)((tree_check5 ((sizetype_tab[(int) stk_sizetype]), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5008, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
);
if (wi::gtu_p (rng1[1], wi::to_wide (size_max, prec)))
  {
    rng1[1] = wi::to_wide (size_max, prec);
    return size_max;
  }

return wide_int_to_tree (sizetypesizetype_tab[(int) stk_sizetype], rng1[1]);
5016}

5018/* For an access to an object referenced to by the function parameter PTR
 of pointer type, and set RNG[] to the range of sizes of the object
 obtainedfrom the attribute access specification for the current function.
 Set STATIC_ARRAY if the array parameter has been declared [static].
 Return the function parameter on success and null otherwise.  */

5024tree
5025gimple_parm_array_size (tree ptr, wide_int rng[2],
	bool *static_array /* = NULL */)
5027{
/* For a function argument try to determine the byte size of the array
   from the current function declaratation (e.g., attribute access or
   related).  */
tree var = SSA_NAME_VAR (ptr)((tree_check ((ptr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5031, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 __null || ((enum tree_code) ((ptr)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) __null : (ptr)->ssa_name
.var);
44
←
Assuming the condition is false→
45
←
Assuming field 'code' is not equal to IDENTIFIER_NODE→
46
←
'?' condition is false→
if (TREE_CODE (var)((enum tree_code) (var)->base.code) != PARM_DECL)
47
←
Assuming field 'code' is not equal to PARM_DECL→
48
←
Taking true branch→
  return NULL_TREE(tree) __null;
49
←
Returning null pointer, which participates in a condition later→

const unsigned prec = TYPE_PRECISION (sizetype)((tree_class_check ((sizetype_tab[(int) stk_sizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5035, __FUNCTION__))->type_common.precision);

rdwr_map rdwr_idx;
attr_access *access = get_parm_access (rdwr_idx, var);
if (!access)
  return NULL_TREE(tree) __null;

if (access->sizarg != UINT_MAX(2147483647 *2U +1U))
  {
    /* TODO: Try to extract the range from the argument based on
those of subsequent assertions or based on known calls to
the current function.  */
    return NULL_TREE(tree) __null;
  }

if (!access->minsize)
  return NULL_TREE(tree) __null;

/* Only consider ordinary array bound at level 2 (or above if it's
   ever added).  */
if (warn_array_parameterglobal_options.x_warn_array_parameter < 2 && !access->static_p)
  return NULL_TREE(tree) __null;

if (static_array)
  *static_array = access->static_p;

rng[0] = wi::zero (prec);
rng[1] = wi::uhwi (access->minsize, prec);
/* Multiply the array bound encoded in the attribute by the size
   of what the pointer argument to which it decays points to.  */
tree eltype = TREE_TYPE (TREE_TYPE (ptr))((contains_struct_check ((((contains_struct_check ((ptr), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5065, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5065, __FUNCTION__))->typed.type);
tree size = TYPE_SIZE_UNIT (eltype)((tree_class_check ((eltype), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5066, __FUNCTION__))->type_common.size_unit);
if (!size || TREE_CODE (size)((enum tree_code) (size)->base.code) != INTEGER_CST)
  return NULL_TREE(tree) __null;

rng[1] *= wi::to_wide (size, prec);
return var;
5072}

5074/* Wrapper around the wide_int overload of get_range that accepts
 offset_int instead.  For middle end expressions returns the same
 result.  For a subset of nonconstamt expressions emitted by the front
 end determines a more precise range than would be possible otherwise.  */

5079static bool
5080get_offset_range (tree x, gimple *stmt, offset_int r[2], range_query *rvals)
5081{
offset_int add = 0;
if (TREE_CODE (x)((enum tree_code) (x)->base.code) == PLUS_EXPR)
  {
    /* Handle constant offsets in pointer addition expressions seen
n the front end IL.  */
    tree op = TREE_OPERAND (x, 1)(*((const_cast<tree*> (tree_operand_check ((x), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5087, __FUNCTION__)))));
    if (TREE_CODE (op)((enum tree_code) (op)->base.code) == INTEGER_CST)
{
 op = fold_convert (signed_type_for (TREE_TYPE (op)), op)fold_convert_loc (((location_t) 0), signed_type_for (((contains_struct_check
 ((op), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5090, __FUNCTION__))->typed.type)), op);
 add = wi::to_offset (op);
 x = TREE_OPERAND (x, 0)(*((const_cast<tree*> (tree_operand_check ((x), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5092, __FUNCTION__)))));
}
  }

if (TREE_CODE (x)((enum tree_code) (x)->base.code) == NOP_EXPR)
  /* Also handle conversions to sizetype seen in the front end IL.  */
  x = TREE_OPERAND (x, 0)(*((const_cast<tree*> (tree_operand_check ((x), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5098, __FUNCTION__)))));

tree type = TREE_TYPE (x)((contains_struct_check ((x), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5100, __FUNCTION__))->typed.type);
if (!INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
 tree_code) (type)->base.code) == INTEGER_TYPE) && !POINTER_TYPE_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE))
  return false;

 if (TREE_CODE (x)((enum tree_code) (x)->base.code) != INTEGER_CST
    && TREE_CODE (x)((enum tree_code) (x)->base.code) != SSA_NAME)
  {
    if (TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5107, __FUNCTION__))->base.u.bits.unsigned_flag)
 && TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5108, __FUNCTION__))->type_common.precision) == TYPE_PRECISION (sizetype)((tree_class_check ((sizetype_tab[(int) stk_sizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5108, __FUNCTION__))->type_common.precision))
type = signed_type_for (type);

    r[0] = wi::to_offset (TYPE_MIN_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5111, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)) + add;
    r[1] = wi::to_offset (TYPE_MAX_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5112, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)) + add;
    return x;
  }

wide_int wr[2];
if (!get_range (x, stmt, wr, rvals))
  return false;

signop sgn = SIGNED;
/* Only convert signed integers or unsigned sizetype to a signed
   offset and avoid converting large positive values in narrower
   types to negative offsets.  */
if (TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5124, __FUNCTION__))->base.u.bits.unsigned_flag)
    && wr[0].get_precision () < TYPE_PRECISION (sizetype)((tree_class_check ((sizetype_tab[(int) stk_sizetype]), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5125, __FUNCTION__))->type_common.precision))
  sgn = UNSIGNED;

r[0] = offset_int::from (wr[0], sgn);
r[1] = offset_int::from (wr[1], sgn);
return true;
5131}

5133/* Return the argument that the call STMT to a built-in function returns
 or null if it doesn't.  On success, set OFFRNG[] to the range of offsets
 from the argument reflected in the value returned by the built-in if it
 can be determined, otherwise to 0 and HWI_M1U respectively.  */

5138static tree
5139gimple_call_return_array (gimple *stmt, offset_int offrng[2],
	  range_query *rvals)
5141{
if (!gimple_call_builtin_p (stmt, BUILT_IN_NORMAL)
    || gimple_call_num_args (stmt) < 1)
  return NULL_TREE(tree) __null;

tree fn = gimple_call_fndecl (stmt);
switch (DECL_FUNCTION_CODE (fn))
  {
  case BUILT_IN_MEMCPY:
  case BUILT_IN_MEMCPY_CHK:
  case BUILT_IN_MEMMOVE:
  case BUILT_IN_MEMMOVE_CHK:
  case BUILT_IN_MEMSET:
  case BUILT_IN_STPCPY:
  case BUILT_IN_STPCPY_CHK:
  case BUILT_IN_STPNCPY:
  case BUILT_IN_STPNCPY_CHK:
  case BUILT_IN_STRCAT:
  case BUILT_IN_STRCAT_CHK:
  case BUILT_IN_STRCPY:
  case BUILT_IN_STRCPY_CHK:
  case BUILT_IN_STRNCAT:
  case BUILT_IN_STRNCAT_CHK:
  case BUILT_IN_STRNCPY:
  case BUILT_IN_STRNCPY_CHK:
    offrng[0] = offrng[1] = 0;
    return gimple_call_arg (stmt, 0);

  case BUILT_IN_MEMPCPY:
  case BUILT_IN_MEMPCPY_CHK:
    {
tree off = gimple_call_arg (stmt, 2);
if (!get_offset_range (off, stmt, offrng, rvals))
 {
   offrng[0] = 0;
   offrng[1] = HOST_WIDE_INT_M1U-1UL;
 }
return gimple_call_arg (stmt, 0);
    }

  case BUILT_IN_MEMCHR:
    {
tree off = gimple_call_arg (stmt, 2);
if (get_offset_range (off, stmt, offrng, rvals))
 offrng[0] = 0;
else
 {
   offrng[0] = 0;
   offrng[1] = HOST_WIDE_INT_M1U-1UL;
 }
return gimple_call_arg (stmt, 0);
    }

  case BUILT_IN_STRCHR:
  case BUILT_IN_STRRCHR:
  case BUILT_IN_STRSTR:
    {
offrng[0] = 0;
offrng[1] = HOST_WIDE_INT_M1U-1UL;
    }
    return gimple_call_arg (stmt, 0);

  default:
    break;
  }

return NULL_TREE(tree) __null;
5208}

5210/* A helper of compute_objsize() to determine the size from an assignment
 statement STMT with the RHS of either MIN_EXPR or MAX_EXPR.  */

5213static bool
5214handle_min_max_size (gimple *stmt, int ostype, access_ref *pref,
     ssa_name_limit_t &snlim, pointer_query *qry)
5216{
tree_code code = gimple_assign_rhs_code (stmt);

tree ptr = gimple_assign_rhs1 (stmt);

/* In a valid MAX_/MIN_EXPR both operands must refer to the same array.
   Determine the size/offset of each and use the one with more or less
   space remaining, respectively.  If either fails, use the information
   determined from the other instead, adjusted up or down as appropriate
   for the expression.  */
access_ref aref[2] = { *pref, *pref };
if (!compute_objsize_r (ptr, ostype, &aref[0], snlim, qry))
  {
    aref[0].base0 = false;
    aref[0].offrng[0] = aref[0].offrng[1] = 0;
    aref[0].add_max_offset ();
    aref[0].set_max_size_range ();
  }

ptr = gimple_assign_rhs2 (stmt);
if (!compute_objsize_r (ptr, ostype, &aref[1], snlim, qry))
  {
    aref[1].base0 = false;
    aref[1].offrng[0] = aref[1].offrng[1] = 0;
    aref[1].add_max_offset ();
    aref[1].set_max_size_range ();
  }

if (!aref[0].ref && !aref[1].ref)
  /* Fail if the identity of neither argument could be determined.  */
  return false;

bool i0 = false;
if (aref[0].ref && aref[0].base0)
  {
    if (aref[1].ref && aref[1].base0)
{
 /* If the object referenced by both arguments has been determined
    set *PREF to the one with more or less space remainng, whichever
    is appopriate for CODE.
    TODO: Indicate when the objects are distinct so it can be
    diagnosed.  */
 i0 = code == MAX_EXPR;
 const bool i1 = !i0;

 if (aref[i0].size_remaining () < aref[i1].size_remaining ())
   *pref = aref[i1];
 else
   *pref = aref[i0];
 return true;
}

    /* If only the object referenced by one of the arguments could be
determined, use it and...  */
    *pref = aref[0];
    i0 = true;
  }
else
  *pref = aref[1];

const bool i1 = !i0;
/* ...see if the offset obtained from the other pointer can be used
   to tighten up the bound on the offset obtained from the first.  */
if ((code == MAX_EXPR && aref[i1].offrng[1] < aref[i0].offrng[0])
    || (code == MIN_EXPR && aref[i0].offrng[0] < aref[i1].offrng[1]))
  {
    pref->offrng[0] = aref[i0].offrng[0];
    pref->offrng[1] = aref[i0].offrng[1];
  }
return true;
5286}

5288/* Helper to compute the size of the object referenced by the PTR
 expression which must have pointer type, using Object Size type
 OSTYPE (only the least significant 2 bits are used).
 On success, sets PREF->REF to the DECL of the referenced object
 if it's unique, otherwise to null, PREF->OFFRNG to the range of
 offsets into it, and PREF->SIZRNG to the range of sizes of
 the object(s).
 SNLIM is used to avoid visiting the same PHI operand multiple
 times, and, when nonnull, RVALS to determine range information.
 Returns true on success, false when a meaningful size (or range)
 cannot be determined.

 The function is intended for diagnostics and should not be used
 to influence code generation or optimization.  */

5303static bool
5304compute_objsize_r (tree ptr, int ostype, access_ref *pref,
   ssa_name_limit_t &snlim, pointer_query *qry)
5306{
STRIP_NOPS (ptr)(ptr) = tree_strip_nop_conversions ((const_cast<union tree_node
 *> (((ptr)))));

const bool addr = TREE_CODE (ptr)((enum tree_code) (ptr)->base.code) == ADDR_EXPR;
1
Assuming field 'code' is not equal to ADDR_EXPR→
if (addr1.1
'addr' is false
1
'addr' is false
)
2
←
Taking false branch→
  {
    --pref->deref;
    ptr = TREE_OPERAND (ptr, 0)(*((const_cast<tree*> (tree_operand_check ((ptr), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5313, __FUNCTION__)))));
  }

if (DECL_P (ptr)(tree_code_type[(int) (((enum tree_code) (ptr)->base.code)
)] == tcc_declaration))
3
←
Assuming the condition is false→
4
←
Taking false branch→
  {
    pref->ref = ptr;

    if (!addr && POINTER_TYPE_P (TREE_TYPE (ptr))(((enum tree_code) (((contains_struct_check ((ptr), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5320, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((ptr), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5320, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
{
 /* Set the maximum size if the reference is to the pointer
    itself (as opposed to what it points to).  */
 pref->set_max_size_range ();
 return true;
}

    if (tree size = decl_init_size (ptr, false))
if (TREE_CODE (size)((enum tree_code) (size)->base.code) == INTEGER_CST)
 {
   pref->sizrng[0] = pref->sizrng[1] = wi::to_offset (size);
   return true;
 }

    pref->set_max_size_range ();
    return true;
  }

const tree_code code = TREE_CODE (ptr)((enum tree_code) (ptr)->base.code);
range_query *const rvals = qry ? qry->rvals : NULL__null;
5
←
Assuming 'qry' is null→
6
←
'?' condition is false→

if (code == BIT_FIELD_REF)
7
←
Assuming 'code' is not equal to BIT_FIELD_REF→
8
←
Taking false branch→
  {
    tree ref = TREE_OPERAND (ptr, 0)(*((const_cast<tree*> (tree_operand_check ((ptr), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5344, __FUNCTION__)))));
    if (!compute_objsize_r (ref, ostype, pref, snlim, qry))
return false;

    offset_int off = wi::to_offset (pref->eval (TREE_OPERAND (ptr, 2)(*((const_cast<tree*> (tree_operand_check ((ptr), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5348, __FUNCTION__)))))));
    pref->add_offset (off / BITS_PER_UNIT(8));
    return true;
  }

if (code == COMPONENT_REF)
9
←
Assuming 'code' is not equal to COMPONENT_REF→
10
←
Taking false branch→
  {
    tree ref = TREE_OPERAND (ptr, 0)(*((const_cast<tree*> (tree_operand_check ((ptr), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5355, __FUNCTION__)))));
    if (TREE_CODE (TREE_TYPE (ref))((enum tree_code) (((contains_struct_check ((ref), (TS_TYPED)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5356, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE)
/* In accesses through union types consider the entire unions
  rather than just their members.  */
ostype = 0;
    tree field = TREE_OPERAND (ptr, 1)(*((const_cast<tree*> (tree_operand_check ((ptr), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5360, __FUNCTION__)))));

    if (ostype == 0)
{
 /* In OSTYPE zero (for raw memory functions like memcpy), use
    the maximum size instead if the identity of the enclosing
    object cannot be determined.  */
 if (!compute_objsize_r (ref, ostype, pref, snlim, qry))
   return false;

 /* Otherwise, use the size of the enclosing object and add
    the offset of the member to the offset computed so far.  */
 tree offset = byte_position (field);
 if (TREE_CODE (offset)((enum tree_code) (offset)->base.code) == INTEGER_CST)
   pref->add_offset (wi::to_offset (offset));
 else
   pref->add_max_offset ();

 if (!pref->ref)
   /* REF may have been already set to an SSA_NAME earlier
      to provide better context for diagnostics.  In that case,
      leave it unchanged.  */
   pref->ref = ref;
 return true;
}

    pref->ref = field;

    if (!addr && POINTER_TYPE_P (TREE_TYPE (field))(((enum tree_code) (((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5388, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((field), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/builtins.c"
, 5388, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
{
 /* Set maximum size if the reference is to the pointer member
    itself (as opposed to what it points to).  */
 pref->set_max_size_range ();
 return true;
}

    /* SAM is set for array members that might need special treatment.  */
    special_array_member sam;
    tree size = component_ref_size (ptr, &sam);
    if (sam == special_array_member::int_0)
pref->sizrng[0] = pref->sizrng[1] = 0;
    else if (!pref->trail1special && sam == special_array_member::trail_1)
pref->sizrng[0] = pref->sizrng[1] = 1;
    else if (size && TREE_CODE (size)((enum tree_code) (size)->base.code) == INTEGER_CST)
pref->sizrng[0] = pref->sizrng[1] = wi::to_offset (size);
    else
{