/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc

Bug Summary

File:	build/gcc/config/i386/i386.cc
Warning:	line 876, column 3 The result of the left shift is undefined because the right operand is negative
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name i386.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-uIZuWh.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc
/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc

→
1/* Subroutines used for code generation on IA-32.
 Copyright (C) 1988-2023 Free Software Foundation, Inc.

4This file is part of GCC.

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

11GCC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14GNU General Public License for 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#define IN_TARGET_CODE1 1

22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "backend.h"
26#include "rtl.h"
27#include "tree.h"
28#include "memmodel.h"
29#include "gimple.h"
30#include "cfghooks.h"
31#include "cfgloop.h"
32#include "df.h"
33#include "tm_p.h"
34#include "stringpool.h"
35#include "expmed.h"
36#include "optabs.h"
37#include "regs.h"
38#include "emit-rtl.h"
39#include "recog.h"
40#include "cgraph.h"
41#include "diagnostic.h"
42#include "cfgbuild.h"
43#include "alias.h"
44#include "fold-const.h"
45#include "attribs.h"
46#include "calls.h"
47#include "stor-layout.h"
48#include "varasm.h"
49#include "output.h"
50#include "insn-attr.h"
51#include "flags.h"
52#include "except.h"
53#include "explow.h"
54#include "expr.h"
55#include "cfgrtl.h"
56#include "common/common-target.h"
57#include "langhooks.h"
58#include "reload.h"
59#include "gimplify.h"
60#include "dwarf2.h"
61#include "tm-constrs.h"
62#include "cselib.h"
63#include "sched-int.h"
64#include "opts.h"
65#include "tree-pass.h"
66#include "context.h"
67#include "pass_manager.h"
68#include "target-globals.h"
69#include "gimple-iterator.h"
70#include "gimple-fold.h"
71#include "tree-vectorizer.h"
72#include "shrink-wrap.h"
73#include "builtins.h"
74#include "rtl-iter.h"
75#include "tree-iterator.h"
76#include "dbgcnt.h"
77#include "case-cfn-macros.h"
78#include "dojump.h"
79#include "fold-const-call.h"
80#include "tree-vrp.h"
81#include "tree-ssanames.h"
82#include "selftest.h"
83#include "selftest-rtl.h"
84#include "print-rtl.h"
85#include "intl.h"
86#include "ifcvt.h"
87#include "symbol-summary.h"
88#include "ipa-prop.h"
89#include "ipa-fnsummary.h"
90#include "wide-int-bitmask.h"
91#include "tree-vector-builder.h"
92#include "debug.h"
93#include "dwarf2out.h"
94#include "i386-options.h"
95#include "i386-builtins.h"
96#include "i386-expand.h"
97#include "i386-features.h"
98#include "function-abi.h"

100/* This file should be included last.  */
101#include "target-def.h"

103static rtx legitimize_dllimport_symbol (rtx, bool);
104static rtx legitimize_pe_coff_extern_decl (rtx, bool);
105static void ix86_print_operand_address_as (FILE *, rtx, addr_space_t, bool);
106static void ix86_emit_restore_reg_using_pop (rtx);


109#ifndef CHECK_STACK_LIMIT(-1)
110#define CHECK_STACK_LIMIT(-1) (-1)
111#endif

113/* Return index of given mode in mult and division cost tables.  */
114#define MODE_INDEX(mode)((mode) == (scalar_int_mode ((scalar_int_mode::from_int) E_QImode
)) ? 0 : (mode) == (scalar_int_mode ((scalar_int_mode::from_int
) E_HImode)) ? 1 : (mode) == (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)) ? 2 : (mode) == (scalar_int_mode ((scalar_int_mode
::from_int) E_DImode)) ? 3 : 4)					\
((mode) == QImode(scalar_int_mode ((scalar_int_mode::from_int) E_QImode)) ? 0						\
 : (mode) == HImode(scalar_int_mode ((scalar_int_mode::from_int) E_HImode)) ? 1					\
 : (mode) == SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode)) ? 2					\
 : (mode) == DImode(scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) ? 3					\
 : 4)


122/* Set by -mtune.  */
123const struct processor_costs *ix86_tune_cost = NULL__null;

125/* Set by -mtune or -Os.  */
126const struct processor_costs *ix86_cost = NULL__null;

128/* In case the average insn count for single function invocation is
 lower than this constant, emit fast (but longer) prologue and
 epilogue code.  */
131#define FAST_PROLOGUE_INSN_COUNT20 20

133/* Names for 8 (low), 8 (high), and 16-bit registers, respectively.  */
134static const char *const qi_reg_name[] = QI_REGISTER_NAMES{"al", "dl", "cl", "bl", "sil", "dil", "bpl", "spl"};
135static const char *const qi_high_reg_name[] = QI_HIGH_REGISTER_NAMES{"ah", "dh", "ch", "bh"};
136static const char *const hi_reg_name[] = HI_REGISTER_NAMES{"ax","dx","cx","bx","si","di","bp","sp", "st","st(1)","st(2)"
,"st(3)","st(4)","st(5)","st(6)","st(7)", "argp", "flags", "fpsr"
, "frame", "xmm0","xmm1","xmm2","xmm3","xmm4","xmm5","xmm6","xmm7"
, "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7", "r8"
, "r9", "r10", "r11", "r12", "r13", "r14", "r15", "xmm8", "xmm9"
, "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15", "xmm16"
, "xmm17", "xmm18", "xmm19", "xmm20", "xmm21", "xmm22", "xmm23"
, "xmm24", "xmm25", "xmm26", "xmm27", "xmm28", "xmm29", "xmm30"
, "xmm31", "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" };

138/* Array of the smallest class containing reg number REGNO, indexed by
 REGNO.  Used by REGNO_REG_CLASS in i386.h.  */

141enum reg_class const regclass_map[FIRST_PSEUDO_REGISTER76] =
142{
/* ax, dx, cx, bx */
AREG, DREG, CREG, BREG,
/* si, di, bp, sp */
SIREG, DIREG, NON_Q_REGS, NON_Q_REGS,
/* FP registers */
FP_TOP_REG, FP_SECOND_REG, FLOAT_REGS, FLOAT_REGS,
FLOAT_REGS, FLOAT_REGS, FLOAT_REGS, FLOAT_REGS,
/* arg pointer, flags, fpsr, frame */
NON_Q_REGS, NO_REGS, NO_REGS, NON_Q_REGS,
/* SSE registers */
SSE_FIRST_REG, SSE_REGS, SSE_REGS, SSE_REGS,
SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
/* MMX registers */
MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS,
MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS,
/* REX registers */
GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
/* SSE REX registers */
SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
/* AVX-512 SSE registers */
ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS,
ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS,
ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS,
ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS,
/* Mask registers.  */
ALL_MASK_REGS, MASK_REGS, MASK_REGS, MASK_REGS,
MASK_REGS, MASK_REGS, MASK_REGS, MASK_REGS
172};

174/* The "default" register map used in 32bit mode.  */

176int const debugger_register_map[FIRST_PSEUDO_REGISTER76] =
177{
/* general regs */
0, 2, 1, 3, 6, 7, 4, 5,
/* fp regs */
12, 13, 14, 15, 16, 17, 18, 19,
/* arg, flags, fpsr, frame */
IGNORED_DWARF_REGNUM((~(unsigned int) 0) - 1), IGNORED_DWARF_REGNUM((~(unsigned int) 0) - 1),
IGNORED_DWARF_REGNUM((~(unsigned int) 0) - 1), IGNORED_DWARF_REGNUM((~(unsigned int) 0) - 1),
/* SSE */
21, 22, 23, 24, 25, 26, 27, 28,
/* MMX */
29, 30, 31, 32, 33, 34, 35, 36,
/* extended integer registers */
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
/* extended sse registers */
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
/* AVX-512 registers 16-23 */
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
/* AVX-512 registers 24-31 */
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
/* Mask registers */
93, 94, 95, 96, 97, 98, 99, 100
203};

205/* The "default" register map used in 64bit mode.  */

207int const debugger64_register_map[FIRST_PSEUDO_REGISTER76] =
208{
/* general regs */
0, 1, 2, 3, 4, 5, 6, 7,
/* fp regs */
33, 34, 35, 36, 37, 38, 39, 40,
/* arg, flags, fpsr, frame */
IGNORED_DWARF_REGNUM((~(unsigned int) 0) - 1), IGNORED_DWARF_REGNUM((~(unsigned int) 0) - 1),
IGNORED_DWARF_REGNUM((~(unsigned int) 0) - 1), IGNORED_DWARF_REGNUM((~(unsigned int) 0) - 1),
/* SSE */
17, 18, 19, 20, 21, 22, 23, 24,
/* MMX */
41, 42, 43, 44, 45, 46, 47, 48,
/* extended integer registers */
8, 9, 10, 11, 12, 13, 14, 15,
/* extended SSE registers */
25, 26, 27, 28, 29, 30, 31, 32,
/* AVX-512 registers 16-23 */
67, 68, 69, 70, 71, 72, 73, 74,
/* AVX-512 registers 24-31 */
75, 76, 77, 78, 79, 80, 81, 82,
/* Mask registers */
118, 119, 120, 121, 122, 123, 124, 125
230};

232/* Define the register numbers to be used in Dwarf debugging information.
 The SVR4 reference port C compiler uses the following register numbers
 in its Dwarf output code:
0 for %eax (gcc regno = 0)
1 for %ecx (gcc regno = 2)
2 for %edx (gcc regno = 1)
3 for %ebx (gcc regno = 3)
4 for %esp (gcc regno = 7)
5 for %ebp (gcc regno = 6)
6 for %esi (gcc regno = 4)
7 for %edi (gcc regno = 5)
 The following three DWARF register numbers are never generated by
 the SVR4 C compiler or by the GNU compilers, but SDB on x86/svr4
 believed these numbers have these meanings.
8  for %eip    (no gcc equivalent)
9  for %eflags (gcc regno = 17)
10 for %trapno (no gcc equivalent)
 It is not at all clear how we should number the FP stack registers
 for the x86 architecture.  If the version of SDB on x86/svr4 were
 a bit less brain dead with respect to floating-point then we would
 have a precedent to follow with respect to DWARF register numbers
 for x86 FP registers, but the SDB on x86/svr4 was so completely
 broken with respect to FP registers that it is hardly worth thinking
 of it as something to strive for compatibility with.
 The version of x86/svr4 SDB I had does (partially)
 seem to believe that DWARF register number 11 is associated with
 the x86 register %st(0), but that's about all.  Higher DWARF
 register numbers don't seem to be associated with anything in
 particular, and even for DWARF regno 11, SDB only seemed to under-
 stand that it should say that a variable lives in %st(0) (when
 asked via an `=' command) if we said it was in DWARF regno 11,
 but SDB still printed garbage when asked for the value of the
 variable in question (via a `/' command).
 (Also note that the labels SDB printed for various FP stack regs
 when doing an `x' command were all wrong.)
 Note that these problems generally don't affect the native SVR4
 C compiler because it doesn't allow the use of -O with -g and
 because when it is *not* optimizing, it allocates a memory
 location for each floating-point variable, and the memory
 location is what gets described in the DWARF AT_location
 attribute for the variable in question.
 Regardless of the severe mental illness of the x86/svr4 SDB, we
 do something sensible here and we use the following DWARF
 register numbers.  Note that these are all stack-top-relative
 numbers.
11 for %st(0) (gcc regno = 8)
12 for %st(1) (gcc regno = 9)
13 for %st(2) (gcc regno = 10)
14 for %st(3) (gcc regno = 11)
15 for %st(4) (gcc regno = 12)
16 for %st(5) (gcc regno = 13)
17 for %st(6) (gcc regno = 14)
18 for %st(7) (gcc regno = 15)
285*/
286int const svr4_debugger_register_map[FIRST_PSEUDO_REGISTER76] =
287{
/* general regs */
0, 2, 1, 3, 6, 7, 5, 4,
/* fp regs */
11, 12, 13, 14, 15, 16, 17, 18,
/* arg, flags, fpsr, frame */
IGNORED_DWARF_REGNUM((~(unsigned int) 0) - 1), 9,
IGNORED_DWARF_REGNUM((~(unsigned int) 0) - 1), IGNORED_DWARF_REGNUM((~(unsigned int) 0) - 1),
/* SSE registers */
21, 22, 23, 24, 25, 26, 27, 28,
/* MMX registers */
29, 30, 31, 32, 33, 34, 35, 36,
/* extended integer registers */
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
/* extended sse registers */
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
/* AVX-512 registers 16-23 */
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
/* AVX-512 registers 24-31 */
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0), INVALID_REGNUM(~(unsigned int) 0),
/* Mask registers */
93, 94, 95, 96, 97, 98, 99, 100
313};

315/* Define parameter passing and return registers.  */

317static int const x86_64_int_parameter_registers[6] =
318{
DI_REG5, SI_REG4, DX_REG1, CX_REG2, R8_REG36, R9_REG37
320};

322static int const x86_64_ms_abi_int_parameter_registers[4] =
323{
CX_REG2, DX_REG1, R8_REG36, R9_REG37
325};

327static int const x86_64_int_return_registers[4] =
328{
AX_REG0, DX_REG1, DI_REG5, SI_REG4
330};

332/* Define the structure for the machine field in struct function.  */

334struct GTY(()) stack_local_entry {
unsigned short mode;
unsigned short n;
rtx rtl;
struct stack_local_entry *next;
339};

341/* Which cpu are we scheduling for.  */
342enum attr_cpu ix86_schedule;

344/* Which cpu are we optimizing for.  */
345enum processor_type ix86_tune;

347/* Which instruction set architecture to use.  */
348enum processor_type ix86_arch;

350/* True if processor has SSE prefetch instruction.  */
351unsigned char ix86_prefetch_sse;

353/* Preferred alignment for stack boundary in bits.  */
354unsigned int ix86_preferred_stack_boundary;

356/* Alignment for incoming stack boundary in bits specified at
 command line.  */
358unsigned int ix86_user_incoming_stack_boundary;

360/* Default alignment for incoming stack boundary in bits.  */
361unsigned int ix86_default_incoming_stack_boundary;

363/* Alignment for incoming stack boundary in bits.  */
364unsigned int ix86_incoming_stack_boundary;

366/* True if there is no direct access to extern symbols.  */
367bool ix86_has_no_direct_extern_access;

369/* Calling abi specific va_list type nodes.  */
370tree sysv_va_list_type_node;
371tree ms_va_list_type_node;

373/* Prefix built by ASM_GENERATE_INTERNAL_LABEL.  */
374char internal_label_prefix[16];
375int internal_label_prefix_len;

377/* Fence to use after loop using movnt.  */
378tree x86_mfence;

380/* Register class used for passing given 64bit part of the argument.
 These represent classes as documented by the PS ABI, with the exception
 of SSESF, SSEDF classes, that are basically SSE class, just gcc will
 use SF or DFmode move instead of DImode to avoid reformatting penalties.

 Similarly we play games with INTEGERSI_CLASS to use cheaper SImode moves
 whenever possible (upper half does contain padding).  */
387enum x86_64_reg_class
{
  X86_64_NO_CLASS,
  X86_64_INTEGER_CLASS,
  X86_64_INTEGERSI_CLASS,
  X86_64_SSE_CLASS,
  X86_64_SSEHF_CLASS,
  X86_64_SSESF_CLASS,
  X86_64_SSEDF_CLASS,
  X86_64_SSEUP_CLASS,
  X86_64_X87_CLASS,
  X86_64_X87UP_CLASS,
  X86_64_COMPLEX_X87_CLASS,
  X86_64_MEMORY_CLASS
};

403#define MAX_CLASSES8 8

405/* Table of constants used by fldpi, fldln2, etc....  */
406static REAL_VALUE_TYPEstruct real_value ext_80387_constants_table [5];
407static bool ext_80387_constants_init;

409
410static rtx ix86_function_value (const_tree, const_tree, bool);
411static bool ix86_function_value_regno_p (const unsigned int);
412static unsigned int ix86_function_arg_boundary (machine_mode,
				const_tree);
414static rtx ix86_static_chain (const_tree, bool);
415static int ix86_function_regparm (const_tree, const_tree);
416static void ix86_compute_frame_layout (void);
417static tree ix86_canonical_va_list_type (tree);
418static unsigned int split_stack_prologue_scratch_regno (void);
419static bool i386_asm_output_addr_const_extra (FILE *, rtx);

421static bool ix86_can_inline_p (tree, tree);
422static unsigned int ix86_minimum_incoming_stack_boundary (bool);

424
425/* Whether -mtune= or -march= were specified */
426int ix86_tune_defaulted;
427int ix86_arch_specified;
428
429/* Return true if a red-zone is in use.  We can't use red-zone when
 there are local indirect jumps, like "indirect_jump" or "tablejump",
 which jumps to another place in the function, since "call" in the
 indirect thunk pushes the return address onto stack, destroying
 red-zone.

 TODO: If we can reserve the first 2 WORDs, for PUSH and, another
 for CALL, in red-zone, we can allow local indirect jumps with
 indirect thunk.  */

439bool
440ix86_using_red_zone (void)
441{
return (TARGET_RED_ZONE((global_options.x_target_flags & (1U << 20)) == 0)
 && !TARGET_64BIT_MS_ABI(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) && ix86_cfun_abi () == MS_ABI)
 && (!cfun(cfun + 0)->machine->has_local_indirect_jump
     || cfun(cfun + 0)->machine->indirect_branch_type == indirect_branch_keep));
446}
447
448/* Return true, if profiling code should be emitted before
 prologue. Otherwise it returns false.
 Note: For x86 with "hotfix" it is sorried.  */
451static bool
452ix86_profile_before_prologue (void)
453{
return flag_fentryglobal_options.x_flag_fentry != 0;
455}

457/* Update register usage after having seen the compiler flags.  */

459static void
460ix86_conditional_register_usage (void)
461{
int i, c_mask;

/* If there are no caller-saved registers, preserve all registers.
   except fixed_regs and registers used for function return value
   since aggregate_value_p checks call_used_regs[regno] on return
   value.  */
if (cfun(cfun + 0) && cfun(cfun + 0)->machine->no_caller_saved_registers)
  for (i = 0; i < FIRST_PSEUDO_REGISTER76; i++)
    if (!fixed_regs(this_target_hard_regs->x_fixed_regs)[i] && !ix86_function_value_regno_p (i))
call_used_regs(this_target_hard_regs->x_call_used_regs)[i] = 0;

/* For 32-bit targets, disable the REX registers.  */
if (! TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  {
    for (i = FIRST_REX_INT_REG36; i <= LAST_REX_INT_REG43; i++)
CLEAR_HARD_REG_BIT (accessible_reg_set(this_target_hard_regs->x_accessible_reg_set), i);
    for (i = FIRST_REX_SSE_REG44; i <= LAST_REX_SSE_REG51; i++)
CLEAR_HARD_REG_BIT (accessible_reg_set(this_target_hard_regs->x_accessible_reg_set), i);
    for (i = FIRST_EXT_REX_SSE_REG52; i <= LAST_EXT_REX_SSE_REG67; i++)
CLEAR_HARD_REG_BIT (accessible_reg_set(this_target_hard_regs->x_accessible_reg_set), i);
  }

/*  See the definition of CALL_USED_REGISTERS in i386.h.  */
c_mask = CALL_USED_REGISTERS_MASK (TARGET_64BIT_MS_ABI)(((((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) && ix86_cfun_abi () == MS_ABI)) ? (1 << 3) :
 ((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? (1 << 2) : (1 << 1));

CLEAR_HARD_REG_SET (reg_class_contents(this_target_hard_regs->x_reg_class_contents)[(int)CLOBBERED_REGS]);

for (i = 0; i < FIRST_PSEUDO_REGISTER76; i++)
  {
    /* Set/reset conditionally defined registers from
CALL_USED_REGISTERS initializer.  */
    if (call_used_regs(this_target_hard_regs->x_call_used_regs)[i] > 1)
call_used_regs(this_target_hard_regs->x_call_used_regs)[i] = !!(call_used_regs(this_target_hard_regs->x_call_used_regs)[i] & c_mask);

    /* Calculate registers of CLOBBERED_REGS register set
as call used registers from GENERAL_REGS register set.  */
    if (TEST_HARD_REG_BIT (reg_class_contents(this_target_hard_regs->x_reg_class_contents)[(int)GENERAL_REGS], i)
 && call_used_regs(this_target_hard_regs->x_call_used_regs)[i])
SET_HARD_REG_BIT (reg_class_contents(this_target_hard_regs->x_reg_class_contents)[(int)CLOBBERED_REGS], i);
  }

/* If MMX is disabled, disable the registers.  */
if (! TARGET_MMX((global_options.x_ix86_isa_flags & (1UL << 36)) !=
 0))
  accessible_reg_set(this_target_hard_regs->x_accessible_reg_set) &= ~reg_class_contents(this_target_hard_regs->x_reg_class_contents)[MMX_REGS];

/* If SSE is disabled, disable the registers.  */
if (! TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0))
  accessible_reg_set(this_target_hard_regs->x_accessible_reg_set) &= ~reg_class_contents(this_target_hard_regs->x_reg_class_contents)[ALL_SSE_REGS];

/* If the FPU is disabled, disable the registers.  */
if (! (TARGET_80387((global_options.x_target_flags & (1U << 1)) != 0) || TARGET_FLOAT_RETURNS_IN_80387(((global_options.x_target_flags & (1U << 11)) != 0
) && ((global_options.x_target_flags & (1U <<
 1)) != 0) && !((global_options.x_target_flags & (
1U << 12)) != 0))))
  accessible_reg_set(this_target_hard_regs->x_accessible_reg_set) &= ~reg_class_contents(this_target_hard_regs->x_reg_class_contents)[FLOAT_REGS];

/* If AVX512F is disabled, disable the registers.  */
if (! TARGET_AVX512F((global_options.x_ix86_isa_flags & (1UL << 15)) !=
 0))
  {
    for (i = FIRST_EXT_REX_SSE_REG52; i <= LAST_EXT_REX_SSE_REG67; i++)
CLEAR_HARD_REG_BIT (accessible_reg_set(this_target_hard_regs->x_accessible_reg_set), i);

    accessible_reg_set(this_target_hard_regs->x_accessible_reg_set) &= ~reg_class_contents(this_target_hard_regs->x_reg_class_contents)[ALL_MASK_REGS];
  }
523}

525/* Canonicalize a comparison from one we don't have to one we do have.  */

527static void
528ix86_canonicalize_comparison (int *code, rtx *op0, rtx *op1,
	      bool op0_preserve_value)
530{
/* The order of operands in x87 ficom compare is forced by combine in
   simplify_comparison () function. Float operator is treated as RTX_OBJ
   with a precedence over other operators and is always put in the first
   place. Swap condition and operands to match ficom instruction.  */
if (!op0_preserve_value
    && GET_CODE (*op0)((enum rtx_code) (*op0)->code) == FLOAT && MEM_P (XEXP (*op0, 0))(((enum rtx_code) ((((*op0)->u.fld[0]).rt_rtx))->code) ==
 MEM) && REG_P (*op1)(((enum rtx_code) (*op1)->code) == REG))
  {
    enum rtx_code scode = swap_condition ((enum rtx_code) *code);

    /* We are called only for compares that are split to SAHF instruction.
Ensure that we have setcc/jcc insn for the swapped condition.  */
    if (ix86_fp_compare_code_to_integer (scode) != UNKNOWN)
{
 std::swap (*op0, *op1);
 *code = (int) scode;
}
  }
548}
549
550
551/* Hook to determine if one function can safely inline another.  */

553static bool
554ix86_can_inline_p (tree caller, tree callee)
555{
tree caller_tree = DECL_FUNCTION_SPECIFIC_TARGET (caller)((tree_check ((caller), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 556, __FUNCTION__, (FUNCTION_DECL)))->function_decl.function_specific_target
);
tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET (callee)((tree_check ((callee), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 557, __FUNCTION__, (FUNCTION_DECL)))->function_decl.function_specific_target
);

/* Changes of those flags can be tolerated for always inlines. Lets hope
   user knows what he is doing.  */
unsigned HOST_WIDE_INTlong always_inline_safe_mask
= (MASK_USE_8BIT_IDIV(1U << 2) | MASK_ACCUMULATE_OUTGOING_ARGS(1U << 3)
   | MASK_NO_ALIGN_STRINGOPS(1U << 5) | MASK_AVX256_SPLIT_UNALIGNED_LOAD(1U << 6)
   | MASK_AVX256_SPLIT_UNALIGNED_STORE(1U << 7) | MASK_CLD(1U << 9)
   | MASK_NO_FANCY_MATH_387(1U << 10) | MASK_IEEE_FP(1U << 13) | MASK_INLINE_ALL_STRINGOPS(1U << 14)
   | MASK_INLINE_STRINGOPS_DYNAMICALLY(1U << 15) | MASK_RECIP(1U << 22) | MASK_STACK_PROBE(1U << 26)
   | MASK_STV(1U << 27) | MASK_TLS_DIRECT_SEG_REFS(1U << 28) | MASK_VZEROUPPER(1U << 30)
   | MASK_NO_PUSH_ARGS(1U << 19) | MASK_OMIT_LEAF_FRAME_POINTER(1U << 21));


if (!callee_tree)
  callee_tree = target_option_default_nodeglobal_trees[TI_TARGET_OPTION_DEFAULT];
if (!caller_tree)
  caller_tree = target_option_default_nodeglobal_trees[TI_TARGET_OPTION_DEFAULT];
if (callee_tree == caller_tree)
  return true;

struct cl_target_option *caller_opts = TREE_TARGET_OPTION (caller_tree)((tree_check ((caller_tree), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 578, __FUNCTION__, (TARGET_OPTION_NODE)))->target_option
.opts);
struct cl_target_option *callee_opts = TREE_TARGET_OPTION (callee_tree)((tree_check ((callee_tree), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 579, __FUNCTION__, (TARGET_OPTION_NODE)))->target_option
.opts);
bool ret = false;
bool always_inline
  = (DECL_DISREGARD_INLINE_LIMITS (callee)((tree_check ((callee), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 582, __FUNCTION__, (FUNCTION_DECL)))->function_decl.disregard_inline_limits
)
     && lookup_attribute ("always_inline",
	    DECL_ATTRIBUTES (callee)((contains_struct_check ((callee), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 584, __FUNCTION__))->decl_common.attributes)));

/* If callee only uses GPRs, ignore MASK_80387.  */
if (TARGET_GENERAL_REGS_ONLY_P (callee_opts->x_ix86_target_flags)(((callee_opts->x_ix86_target_flags) & (1U << 0)
) != 0))
  always_inline_safe_mask |= MASK_80387(1U << 1);

cgraph_node *callee_node = cgraph_node::get (callee);
/* Callee's isa options should be a subset of the caller's, i.e. a SSE4
   function can inline a SSE2 function but a SSE2 function can't inline
   a SSE4 function.  */
if (((caller_opts->x_ix86_isa_flags & callee_opts->x_ix86_isa_flags)
     != callee_opts->x_ix86_isa_flags)
    || ((caller_opts->x_ix86_isa_flags2 & callee_opts->x_ix86_isa_flags2)
 != callee_opts->x_ix86_isa_flags2))
  ret = false;

/* See if we have the same non-isa options.  */
else if ((!always_inline
   && caller_opts->x_target_flags != callee_opts->x_target_flags)
  || (caller_opts->x_target_flags & ~always_inline_safe_mask)
      != (callee_opts->x_target_flags & ~always_inline_safe_mask))
  ret = false;

/* See if arch, tune, etc. are the same.  */
else if (caller_opts->arch != callee_opts->arch)
  ret = false;

else if (!always_inline && caller_opts->tune != callee_opts->tune)
  ret = false;

else if (caller_opts->x_ix86_fpmath != callee_opts->x_ix86_fpmath
  /* If the calle doesn't use FP expressions differences in
     ix86_fpmath can be ignored.  We are called from FEs
     for multi-versioning call optimization, so beware of
     ipa_fn_summaries not available.  */
  && (! ipa_fn_summaries
      || ipa_fn_summaries->get (callee_node) == NULL__null
      || ipa_fn_summaries->get (callee_node)->fp_expressions))
  ret = false;

else if (!always_inline
  && caller_opts->branch_cost != callee_opts->branch_cost)
  ret = false;

else
  ret = true;

return ret;
632}
633
634/* Return true if this goes in large data/bss.  */

636static bool
637ix86_in_large_data_p (tree exp)
638{
if (ix86_cmodelglobal_options.x_ix86_cmodel != CM_MEDIUM && ix86_cmodelglobal_options.x_ix86_cmodel != CM_MEDIUM_PIC)
  return false;

if (exp == NULL_TREE(tree) __null)
  return false;

/* Functions are never large data.  */
if (TREE_CODE (exp)((enum tree_code) (exp)->base.code) == FUNCTION_DECL)
  return false;

/* Automatic variables are never large data.  */
if (VAR_P (exp)(((enum tree_code) (exp)->base.code) == VAR_DECL) && !is_global_var (exp))
  return false;

if (VAR_P (exp)(((enum tree_code) (exp)->base.code) == VAR_DECL) && DECL_SECTION_NAME (exp)decl_section_name (exp))
  {
    const char *section = DECL_SECTION_NAME (exp)decl_section_name (exp);
    if (strcmp (section, ".ldata") == 0
 || strcmp (section, ".lbss") == 0)
return true;
    return false;
  }
else
  {
    HOST_WIDE_INTlong size = int_size_in_bytes (TREE_TYPE (exp)((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 663, __FUNCTION__))->typed.type));

    /* If this is an incomplete type with size 0, then we can't put it
in data because it might be too big when completed.  Also,
int_size_in_bytes returns -1 if size can vary or is larger than
an integer in which case also it is safer to assume that it goes in
large data.  */
    if (size <= 0 || size > ix86_section_thresholdglobal_options.x_ix86_section_threshold)
return true;
  }

return false;
675}

677/* i386-specific section flag to mark large sections.  */
678#define SECTION_LARGESECTION_MACH_DEP SECTION_MACH_DEP

680/* Switch to the appropriate section for output of DECL.
 DECL is either a `VAR_DECL' node or a constant of some sort.
 RELOC indicates whether forming the initial value of DECL requires
 link-time relocations.  */

685ATTRIBUTE_UNUSED__attribute__ ((__unused__)) static section *
686x86_64_elf_select_section (tree decl, int reloc,
	   unsigned HOST_WIDE_INTlong align)
688{
if (ix86_in_large_data_p (decl))
  {
    const char *sname = NULL__null;
    unsigned int flags = SECTION_WRITE | SECTION_LARGESECTION_MACH_DEP;
    switch (categorize_decl_for_section (decl, reloc))
{
case SECCAT_DATA:
 sname = ".ldata";
 break;
case SECCAT_DATA_REL:
 sname = ".ldata.rel";
 break;
case SECCAT_DATA_REL_LOCAL:
 sname = ".ldata.rel.local";
 break;
case SECCAT_DATA_REL_RO:
 sname = ".ldata.rel.ro";
 break;
case SECCAT_DATA_REL_RO_LOCAL:
 sname = ".ldata.rel.ro.local";
 break;
case SECCAT_BSS:
 sname = ".lbss";
 flags |= SECTION_BSS;
 break;
case SECCAT_RODATA:
case SECCAT_RODATA_MERGE_STR:
case SECCAT_RODATA_MERGE_STR_INIT:
case SECCAT_RODATA_MERGE_CONST:
 sname = ".lrodata";
 flags &= ~SECTION_WRITE;
 break;
case SECCAT_SRODATA:
case SECCAT_SDATA:
case SECCAT_SBSS:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 724, __FUNCTION__));
case SECCAT_TEXT:
case SECCAT_TDATA:
case SECCAT_TBSS:
 /* We don't split these for medium model.  Place them into
    default sections and hope for best.  */
 break;
}
    if (sname)
{
 /* We might get called with string constants, but get_named_section
    doesn't like them as they are not DECLs.  Also, we need to set
    flags in that case.  */
 if (!DECL_P (decl)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (decl)->base.code))] == tcc_declaration))
   return get_section (sname, flags, NULL__null);
 return get_named_section (decl, sname, reloc);
}
  }
return default_elf_select_section (decl, reloc, align);
743}

745/* Select a set of attributes for section NAME based on the properties
 of DECL and whether or not RELOC indicates that DECL's initializer
 might contain runtime relocations.  */

749static unsigned int ATTRIBUTE_UNUSED__attribute__ ((__unused__))
750x86_64_elf_section_type_flags (tree decl, const char *name, int reloc)
751{
unsigned int flags = default_section_type_flags (decl, name, reloc);

if (ix86_in_large_data_p (decl))
  flags |= SECTION_LARGESECTION_MACH_DEP;

if (decl == NULL_TREE(tree) __null
    && (strcmp (name, ".ldata.rel.ro") == 0
 || strcmp (name, ".ldata.rel.ro.local") == 0))
  flags |= SECTION_RELRO;

if (strcmp (name, ".lbss") == 0
    || startswith (name, ".lbss.")
    || startswith (name, ".gnu.linkonce.lb."))
  flags |= SECTION_BSS;

return flags;
768}

770/* Build up a unique section name, expressed as a
 STRING_CST node, and assign it to DECL_SECTION_NAME (decl).
 RELOC indicates whether the initial value of EXP requires
 link-time relocations.  */

775static void ATTRIBUTE_UNUSED__attribute__ ((__unused__))
776x86_64_elf_unique_section (tree decl, int reloc)
777{
if (ix86_in_large_data_p (decl))
  {
    const char *prefix = NULL__null;
    /* We only need to use .gnu.linkonce if we don't have COMDAT groups.  */
    bool one_only = DECL_COMDAT_GROUP (decl)decl_comdat_group (decl) && !HAVE_COMDAT_GROUP1;

    switch (categorize_decl_for_section (decl, reloc))
{
case SECCAT_DATA:
case SECCAT_DATA_REL:
case SECCAT_DATA_REL_LOCAL:
case SECCAT_DATA_REL_RO:
case SECCAT_DATA_REL_RO_LOCAL:
        prefix = one_only ? ".ld" : ".ldata";
 break;
case SECCAT_BSS:
        prefix = one_only ? ".lb" : ".lbss";
 break;
case SECCAT_RODATA:
case SECCAT_RODATA_MERGE_STR:
case SECCAT_RODATA_MERGE_STR_INIT:
case SECCAT_RODATA_MERGE_CONST:
        prefix = one_only ? ".lr" : ".lrodata";
 break;
case SECCAT_SRODATA:
case SECCAT_SDATA:
case SECCAT_SBSS:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 805, __FUNCTION__));
case SECCAT_TEXT:
case SECCAT_TDATA:
case SECCAT_TBSS:
 /* We don't split these for medium model.  Place them into
    default sections and hope for best.  */
 break;
}
    if (prefix)
{
 const char *name, *linkonce;
 char *string;

 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))((const char *) (tree_check ((decl_assembler_name (decl)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 818, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
);
 name = targetm.strip_name_encoding (name);

 /* If we're using one_only, then there needs to be a .gnu.linkonce
   	     prefix to the section name.  */
 linkonce = one_only ? ".gnu.linkonce" : "";

 string = ACONCAT ((linkonce, prefix, ".", name, NULL))(libiberty_concat_ptr = (char *) __builtin_alloca(concat_length
 (linkonce, prefix, ".", name, __null) + 1), concat_copy2 (linkonce
, prefix, ".", name, __null));

 set_decl_section_name (decl, string);
 return;
}
  }
default_unique_section (decl, reloc);
832}

834#ifdef COMMON_ASM_OP"\t.comm\t"

836#ifndef LARGECOMM_SECTION_ASM_OP"\t.largecomm\t"
837#define LARGECOMM_SECTION_ASM_OP"\t.largecomm\t" "\t.largecomm\t"
838#endif

840/* This says how to output assembler code to declare an
 uninitialized external linkage data object.

 For medium model x86-64 we need to use LARGECOMM_SECTION_ASM_OP opcode for
 large objects.  */
845void
846x86_elf_aligned_decl_common (FILE *file, tree decl,
	const char *name, unsigned HOST_WIDE_INTlong size,
	unsigned align)
849{
if ((ix86_cmodelglobal_options.x_ix86_cmodel == CM_MEDIUM || ix86_cmodelglobal_options.x_ix86_cmodel == CM_MEDIUM_PIC)
    && size > (unsigned int)ix86_section_thresholdglobal_options.x_ix86_section_threshold)
  {
    switch_to_section (get_named_section (decl, ".lbss", 0));
    fputs (LARGECOMM_SECTION_ASM_OP"\t.largecomm\t", file);
  }
else
  fputs (COMMON_ASM_OP"\t.comm\t", file);
assemble_name (file, name);
fprintf (file, "," HOST_WIDE_INT_PRINT_UNSIGNED"%" "l" "u" ",%u\n",
  size, align / BITS_PER_UNIT(8));
861}
862#endif

864/* Utility function for targets to use in implementing
 ASM_OUTPUT_ALIGNED_BSS.  */

867void
868x86_output_aligned_bss (FILE *file, tree decl, const char *name,
       	unsigned HOST_WIDE_INTlong size, unsigned align)
870{
if ((ix86_cmodelglobal_options.x_ix86_cmodel == CM_MEDIUM || ix86_cmodelglobal_options.x_ix86_cmodel == CM_MEDIUM_PIC)
1
Assuming field 'x_ix86_cmodel' is not equal to CM_MEDIUM→
2
←
Assuming field 'x_ix86_cmodel' is not equal to CM_MEDIUM_PIC→
    && size > (unsigned int)ix86_section_thresholdglobal_options.x_ix86_section_threshold)
  switch_to_section (get_named_section (decl, ".lbss", 0));
else
  switch_to_section (bss_section);
ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT))if ((floor_log2 (align / (8))) != 0) fprintf ((file), "\t.align %d\n"
, 1 << (floor_log2 (align / (8))));
3
←
Taking true branch→
4
←
Calling 'floor_log2'→
6
←
Returning from 'floor_log2'→
7
←
The result of the left shift is undefined because the right operand is negative
877#ifdef ASM_DECLARE_OBJECT_NAME
last_assemble_variable_decl = decl;
ASM_DECLARE_OBJECT_NAME (file, name, decl)do { long size; if (global_options.x_flag_gnu_unique &&
 (decl_comdat_group (decl) != (tree) __null && (((decl
)->base.public_flag) || ((contains_struct_check ((decl), (
TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 879, __FUNCTION__))->decl_common.decl_flag_1))) &&
 (!((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 879, __FUNCTION__))->decl_common.artificial_flag) || !((
non_type_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 879, __FUNCTION__))->base.readonly_flag))) do { fputs ("\t.type\t"
, file); assemble_name (file, name); fputs (", ", file); fprintf
 (file, "@%s", "gnu_unique_object"); putc ('\n', file); } while
 (0); else do { fputs ("\t.type\t", file); assemble_name (file
, name); fputs (", ", file); fprintf (file, "@%s", "object");
 putc ('\n', file); } while (0); size_directive_output = 0; if
 (!global_options.x_flag_inhibit_size_directive && (decl
) && ((contains_struct_check ((decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 879, __FUNCTION__))->decl_common.size)) { size_directive_output
 = 1; size = tree_to_uhwi (((contains_struct_check ((decl), (
TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 879, __FUNCTION__))->decl_common.size_unit)); do { long size_
 = (size); fputs ("\t.size\t", file); assemble_name (file, name
); fprintf (file, ", " "%" "l" "d" "\n", size_); } while (0);
 } do { assemble_name ((file), (name)); fputs (":\n", (file))
; } while (0); } while (0);
880#else
/* Standard thing is just output label for the object.  */
ASM_OUTPUT_LABEL (file, name)do { assemble_name ((file), (name)); fputs (":\n", (file)); }
 while (0);
883#endif /* ASM_DECLARE_OBJECT_NAME */
ASM_OUTPUT_SKIP (file, size ? size : 1)fprintf ((file), "%s" "%" "l" "u" "\n", "\t.zero\t", (size ? size
 : 1));
885}
886
887/* Decide whether we must probe the stack before any space allocation
 on this target.  It's essentially TARGET_STACK_PROBE except when
 -fstack-check causes the stack to be already probed differently.  */

891bool
892ix86_target_stack_probe (void)
893{
/* Do not probe the stack twice if static stack checking is enabled.  */
if (flag_stack_checkglobal_options.x_flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
  return false;

return TARGET_STACK_PROBE((global_options.x_target_flags & (1U << 26)) != 0);
899}
900
901/* Decide whether we can make a sibling call to a function.  DECL is the
 declaration of the function being targeted by the call and EXP is the
 CALL_EXPR representing the call.  */

905static bool
906ix86_function_ok_for_sibcall (tree decl, tree exp)
907{
tree type, decl_or_type;
rtx a, b;
bool bind_global = decl && !targetm.binds_local_p (decl);

if (ix86_function_naked (current_function_decl))
  return false;

/* Sibling call isn't OK if there are no caller-saved registers
   since all registers must be preserved before return.  */
if (cfun(cfun + 0)->machine->no_caller_saved_registers)
  return false;

/* If we are generating position-independent code, we cannot sibcall
   optimize direct calls to global functions, as the PLT requires
   %ebx be live. (Darwin does not have a PLT.)  */
if (!TARGET_MACHO0
    && !TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
)
    && flag_picglobal_options.x_flag_pic
    && flag_pltglobal_options.x_flag_plt
    && bind_global)
  return false;

/* If we need to align the outgoing stack, then sibcalling would
   unalign the stack, which may break the called function.  */
if (ix86_minimum_incoming_stack_boundary (true)
    < PREFERRED_STACK_BOUNDARYix86_preferred_stack_boundary)
  return false;

if (decl)
  {
    decl_or_type = decl;
    type = TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 939, __FUNCTION__))->typed.type);
  }
else
  {
    /* We're looking at the CALL_EXPR, we need the type of the function.  */
    type = CALL_EXPR_FN (exp)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 944, __FUNCTION__, (CALL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 944, __FUNCTION__)))));		/* pointer expression */
    type = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 945, __FUNCTION__))->typed.type);			/* pointer type */
    type = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 946, __FUNCTION__))->typed.type);			/* function type */
    decl_or_type = type;
  }

/* If outgoing reg parm stack space changes, we cannot do sibcall.  */
if ((OUTGOING_REG_PARM_STACK_SPACE (type)(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) && ix86_function_type_abi (type) == MS_ABI)
     != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl))(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) && ix86_function_type_abi (((contains_struct_check
 ((current_function_decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 952, __FUNCTION__))->typed.type)) == MS_ABI))
    || (REG_PARM_STACK_SPACE (decl_or_type)ix86_reg_parm_stack_space (decl_or_type)
 != REG_PARM_STACK_SPACE (current_function_decl)ix86_reg_parm_stack_space (current_function_decl)))
  {
    maybe_complain_about_tail_call (exp,
		      "inconsistent size of stack space"
		      " allocated for arguments which are"
		      " passed in registers");
    return false;
  }

/* Check that the return value locations are the same.  Like
   if we are returning floats on the 80387 register stack, we cannot
   make a sibcall from a function that doesn't return a float to a
   function that does or, conversely, from a function that does return
   a float to a function that doesn't; the necessary stack adjustment
   would not be executed.  This is also the place we notice
   differences in the return value ABI.  Note that it is ok for one
   of the functions to have void return type as long as the return
   value of the other is passed in a register.  */
a = ix86_function_value (TREE_TYPE (exp)((contains_struct_check ((exp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 972, __FUNCTION__))->typed.type), decl_or_type, false);
b = ix86_function_value (TREE_TYPE (DECL_RESULT (cfun->decl))((contains_struct_check ((((tree_check (((cfun + 0)->decl)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 973, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 973, __FUNCTION__))->typed.type),
	   cfun(cfun + 0)->decl, false);
if (STACK_REG_P (a)((((enum rtx_code) (a)->code) == REG) && ((unsigned
 long) (((rhs_regno(a)))) - (unsigned long) (8) <= (unsigned
 long) (15) - (unsigned long) (8))) || STACK_REG_P (b)((((enum rtx_code) (b)->code) == REG) && ((unsigned
 long) (((rhs_regno(b)))) - (unsigned long) (8) <= (unsigned
 long) (15) - (unsigned long) (8))))
  {
    if (!rtx_equal_p (a, b))
return false;
  }
else if (VOID_TYPE_P (TREE_TYPE (DECL_RESULT (cfun->decl)))(((enum tree_code) (((contains_struct_check ((((tree_check ((
(cfun + 0)->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 980, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 980, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
))
  ;
else if (!rtx_equal_p (a, b))
  return false;

if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  {
    /* The SYSV ABI has more call-clobbered registers;
disallow sibcalls from MS to SYSV.  */
    if (cfun(cfun + 0)->machine->call_abi == MS_ABI
 && ix86_function_type_abi (type) == SYSV_ABI)
return false;
  }
else
  {
    /* If this call is indirect, we'll need to be able to use a
call-clobbered register for the address of the target function.
Make sure that all such registers are not used for passing
parameters.  Note that DLLIMPORT functions and call to global
function via GOT slot are indirect.  */
    if (!decl
 || (bind_global && flag_picglobal_options.x_flag_pic && !flag_pltglobal_options.x_flag_plt)
 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES0 && DECL_DLLIMPORT_P (decl)((contains_struct_check ((decl), (TS_DECL_WITH_VIS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1002, __FUNCTION__))->decl_with_vis.dllimport_flag))
 || flag_force_indirect_callglobal_options.x_flag_force_indirect_call)
{
 /* Check if regparm >= 3 since arg_reg_available is set to
    false if regparm == 0.  If regparm is 1 or 2, there is
    always a call-clobbered register available.

    ??? The symbol indirect call doesn't need a call-clobbered
    register.  But we don't know if this is a symbol indirect
    call or not here.  */
 if (ix86_function_regparm (type, decl) >= 3
     && !cfun(cfun + 0)->machine->arg_reg_available)
   return false;
}
  }

if (decl && ix86_use_pseudo_pic_reg ())
  {
    /* When PIC register is used, it must be restored after ifunc
function returns.  */
     cgraph_node *node = cgraph_node::get (decl);
     if (node && node->ifunc_resolver)
return false;
  }

/* Disable sibcall if callee has indirect_return attribute and
   caller doesn't since callee will return to the caller's caller
   via an indirect jump.  */
if (((flag_cf_protectionglobal_options.x_flag_cf_protection & (CF_RETURN | CF_BRANCH))
     == (CF_RETURN | CF_BRANCH))
    && lookup_attribute ("indirect_return", TYPE_ATTRIBUTES (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1032, __FUNCTION__))->type_common.attributes))
    && !lookup_attribute ("indirect_return",
	    TYPE_ATTRIBUTES (TREE_TYPE (cfun->decl))((tree_class_check ((((contains_struct_check (((cfun + 0)->
decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1034, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1034, __FUNCTION__))->type_common.attributes)))
  return false;

/* Otherwise okay.  That also includes certain types of indirect calls.  */
return true;
1039}

1041/* This function determines from TYPE the calling-convention.  */

1043unsigned int
1044ix86_get_callcvt (const_tree type)
1045{
unsigned int ret = 0;
bool is_stdarg;
tree attrs;

if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  return IX86_CALLCVT_CDECL0x1;

attrs = TYPE_ATTRIBUTES (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1053, __FUNCTION__))->type_common.attributes);
if (attrs != NULL_TREE(tree) __null)
  {
    if (lookup_attribute ("cdecl", attrs))
ret |= IX86_CALLCVT_CDECL0x1;
    else if (lookup_attribute ("stdcall", attrs))
ret |= IX86_CALLCVT_STDCALL0x2;
    else if (lookup_attribute ("fastcall", attrs))
ret |= IX86_CALLCVT_FASTCALL0x4;
    else if (lookup_attribute ("thiscall", attrs))
ret |= IX86_CALLCVT_THISCALL0x8;

    /* Regparam isn't allowed for thiscall and fastcall.  */
    if ((ret & (IX86_CALLCVT_THISCALL0x8 | IX86_CALLCVT_FASTCALL0x4)) == 0)
{
 if (lookup_attribute ("regparm", attrs))
   ret |= IX86_CALLCVT_REGPARM0x10;
 if (lookup_attribute ("sseregparm", attrs))
   ret |= IX86_CALLCVT_SSEREGPARM0x20;
}

    if (IX86_BASE_CALLCVT(ret)((ret) & (0x1 | 0x2 | 0x4 | 0x8)) != 0)
return ret;
  }

is_stdarg = stdarg_p (type);
if (TARGET_RTD((global_options.x_target_flags & (1U << 24)) != 0) && !is_stdarg)
  return IX86_CALLCVT_STDCALL0x2 | ret;

if (ret != 0
    || is_stdarg
    || TREE_CODE (type)((enum tree_code) (type)->base.code) != METHOD_TYPE
    || ix86_function_type_abi (type) != MS_ABI)
  return IX86_CALLCVT_CDECL0x1 | ret;

return IX86_CALLCVT_THISCALL0x8;
1089}

1091/* Return 0 if the attributes for two types are incompatible, 1 if they
 are compatible, and 2 if they are nearly compatible (which causes a
 warning to be generated).  */

1095static int
1096ix86_comp_type_attributes (const_tree type1, const_tree type2)
1097{
unsigned int ccvt1, ccvt2;

if (TREE_CODE (type1)((enum tree_code) (type1)->base.code) != FUNCTION_TYPE
    && TREE_CODE (type1)((enum tree_code) (type1)->base.code) != METHOD_TYPE)
  return 1;

ccvt1 = ix86_get_callcvt (type1);
ccvt2 = ix86_get_callcvt (type2);
if (ccvt1 != ccvt2)
  return 0;
if (ix86_function_regparm (type1, NULL__null)
    != ix86_function_regparm (type2, NULL__null))
  return 0;

return 1;
1113}
1114
1115/* Return the regparm value for a function with the indicated TYPE and DECL.
 DECL may be NULL when calling function indirectly
 or considering a libcall.  */

1119static int
1120ix86_function_regparm (const_tree type, const_tree decl)
1121{
tree attr;
int regparm;
unsigned int ccvt;

if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  return (ix86_function_type_abi (type) == SYSV_ABI
   ? X86_64_REGPARM_MAX6 : X86_64_MS_REGPARM_MAX4);
ccvt = ix86_get_callcvt (type);
regparm = ix86_regparmglobal_options.x_ix86_regparm;

if ((ccvt & IX86_CALLCVT_REGPARM0x10) != 0)
  {
    attr = lookup_attribute ("regparm", TYPE_ATTRIBUTES (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1134, __FUNCTION__))->type_common.attributes));
    if (attr)
{
 regparm = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr)))((unsigned long) (*tree_int_cst_elt_check ((((tree_check ((((
tree_check ((attr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1137, __FUNCTION__, (TREE_LIST)))->list.value)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1137, __FUNCTION__, (TREE_LIST)))->list.value)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1137, __FUNCTION__)));
 return regparm;
}
  }
else if ((ccvt & IX86_CALLCVT_FASTCALL0x4) != 0)
  return 2;
else if ((ccvt & IX86_CALLCVT_THISCALL0x8) != 0)
  return 1;

/* Use register calling convention for local functions when possible.  */
if (decl
    && TREE_CODE (decl)((enum tree_code) (decl)->base.code) == FUNCTION_DECL)
  {
    cgraph_node *target = cgraph_node::get (decl);
    if (target)
target = target->function_symbol ();

    /* Caller and callee must agree on the calling convention, so
checking here just optimize means that with
__attribute__((optimize (...))) caller could use regparm convention
and callee not, or vice versa.  Instead look at whether the callee
is optimized or not.  */
    if (target && opt_for_fn (target->decl, optimize)(opts_for_fn (target->decl)->x_optimize)
 && !(profile_flagglobal_options.x_profile_flag && !flag_fentryglobal_options.x_flag_fentry))
{
 if (target->local && target->can_change_signature)
   {
     int local_regparm, globals = 0, regno;

     /* Make sure no regparm register is taken by a
 fixed register variable.  */
     for (local_regparm = 0; local_regparm < REGPARM_MAX(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? ((((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) && ix86_cfun_abi () == MS_ABI) ? 4 : 6) : 3
);
   local_regparm++)
if (fixed_regs(this_target_hard_regs->x_fixed_regs)[local_regparm])
  break;

     /* We don't want to use regparm(3) for nested functions as
 these use a static chain pointer in the third argument.  */
     if (local_regparm == 3 && DECL_STATIC_CHAIN (target->decl)((tree_check ((target->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1175, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.regdecl_flag
))
local_regparm = 2;

     /* Save a register for the split stack.  */
     if (flag_split_stackglobal_options.x_flag_split_stack)
{
  if (local_regparm == 3)
    local_regparm = 2;
  else if (local_regparm == 2
	   && DECL_STATIC_CHAIN (target->decl)((tree_check ((target->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1184, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.regdecl_flag
))
    local_regparm = 1;
}

     /* Each fixed register usage increases register pressure,
 so less registers should be used for argument passing.
 This functionality can be overriden by an explicit
 regparm value.  */
     for (regno = AX_REG0; regno <= DI_REG5; regno++)
if (fixed_regs(this_target_hard_regs->x_fixed_regs)[regno])
  globals++;

     local_regparm
= globals < local_regparm ? local_regparm - globals : 0;

     if (local_regparm > regparm)
regparm = local_regparm;
   }
}
  }

return regparm;
1206}

1208/* Return 1 or 2, if we can pass up to SSE_REGPARM_MAX SFmode (1) and
 DFmode (2) arguments in SSE registers for a function with the
 indicated TYPE and DECL.  DECL may be NULL when calling function
 indirectly or considering a libcall.  Return -1 if any FP parameter
 should be rejected by error.  This is used in siutation we imply SSE
 calling convetion but the function is called from another function with
 SSE disabled. Otherwise return 0.  */

1216static int
1217ix86_function_sseregparm (const_tree type, const_tree decl, bool warn)
1218{
gcc_assert (!TARGET_64BIT)((void)(!(!((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1219, __FUNCTION__), 0 : 0));

/* Use SSE registers to pass SFmode and DFmode arguments if requested
   by the sseregparm attribute.  */
if (TARGET_SSEREGPARM((global_options.x_target_flags & (1U << 25)) != 0)
    || (type && lookup_attribute ("sseregparm", TYPE_ATTRIBUTES (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1224, __FUNCTION__))->type_common.attributes))))
  {
    if (!TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0))
{
 if (warn)
   {
     if (decl)
error ("calling %qD with attribute sseregparm without "
       "SSE/SSE2 enabled", decl);
     else
error ("calling %qT with attribute sseregparm without "
       "SSE/SSE2 enabled", type);
   }
 return 0;
}

    return 2;
  }

if (!decl)
  return 0;

cgraph_node *target = cgraph_node::get (decl);
if (target)
  target = target->function_symbol ();

/* For local functions, pass up to SSE_REGPARM_MAX SFmode
   (and DFmode for SSE2) arguments in SSE registers.  */
if (target
    /* TARGET_SSE_MATH */
    && (target_opts_for_fn (target->decl)->x_ix86_fpmath & FPMATH_SSE)
    && opt_for_fn (target->decl, optimize)(opts_for_fn (target->decl)->x_optimize)
    && !(profile_flagglobal_options.x_profile_flag && !flag_fentryglobal_options.x_flag_fentry))
  {
    if (target->local && target->can_change_signature)
{
 /* Refuse to produce wrong code when local function with SSE enabled
    is called from SSE disabled function.
    FIXME: We need a way to detect these cases cross-ltrans partition
    and avoid using SSE calling conventions on local functions called
    from function with SSE disabled.  For now at least delay the
    warning until we know we are going to produce wrong code.
    See PR66047  */
 if (!TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0) && warn)
   return -1;
 return TARGET_SSE2_P (target_opts_for_fn (target->decl)(((target_opts_for_fn (target->decl) ->x_ix86_isa_flags
) & (1UL << 51)) != 0)
		->x_ix86_isa_flags)(((target_opts_for_fn (target->decl) ->x_ix86_isa_flags
) & (1UL << 51)) != 0) ? 2 : 1;
}
  }

return 0;
1275}

1277/* Return true if EAX is live at the start of the function.  Used by
 ix86_expand_prologue to determine if we need special help before
 calling allocate_stack_worker.  */

1281static bool
1282ix86_eax_live_at_start_p (void)
1283{
/* Cheat.  Don't bother working forward from ix86_function_regparm
   to the function type to whether an actual argument is located in
   eax.  Instead just look at cfg info, which is still close enough
   to correct at this point.  This gives false positives for broken
   functions that might use uninitialized data that happens to be
   allocated in eax, but who cares?  */
return REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR_FOR_FN (cfun)), 0)bitmap_bit_p (df_get_live_out ((((cfun + 0))->cfg->x_entry_block_ptr
)), 0);
1291}

1293static bool
1294ix86_keep_aggregate_return_pointer (tree fntype)
1295{
tree attr;

if (!TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  {
    attr = lookup_attribute ("callee_pop_aggregate_return",
	       TYPE_ATTRIBUTES (fntype)((tree_class_check ((fntype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1301, __FUNCTION__))->type_common.attributes));
    if (attr)
return (TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr)))((unsigned long) (*tree_int_cst_elt_check ((((tree_check ((((
tree_check ((attr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1303, __FUNCTION__, (TREE_LIST)))->list.value)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1303, __FUNCTION__, (TREE_LIST)))->list.value)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1303, __FUNCTION__))) == 0);

    /* For 32-bit MS-ABI the default is to keep aggregate
       return pointer.  */
    if (ix86_function_type_abi (fntype) == MS_ABI)
return true;
  }
return KEEP_AGGREGATE_RETURN_POINTER0 != 0;
1311}

1313/* Value is the number of bytes of arguments automatically
 popped when returning from a subroutine call.
 FUNDECL is the declaration node of the function (as a tree),
 FUNTYPE is the data type of the function (as a tree),
 or for a library call it is an identifier node for the subroutine name.
 SIZE is the number of bytes of arguments passed on the stack.

 On the 80386, the RTD insn may be used to pop them if the number
   of args is fixed, but if the number is variable then the caller
   must pop them all.  RTD can't be used for library calls now
   because the library is compiled with the Unix compiler.
 Use of RTD is a selectable option, since it is incompatible with
 standard Unix calling sequences.  If the option is not selected,
 the caller must always pop the args.

 The attribute stdcall is equivalent to RTD on a per module basis.  */

1330static poly_int64
1331ix86_return_pops_args (tree fundecl, tree funtype, poly_int64 size)
1332{
unsigned int ccvt;

/* None of the 64-bit ABIs pop arguments.  */
if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  return 0;

ccvt = ix86_get_callcvt (funtype);

if ((ccvt & (IX86_CALLCVT_STDCALL0x2 | IX86_CALLCVT_FASTCALL0x4
      | IX86_CALLCVT_THISCALL0x8)) != 0
    && ! stdarg_p (funtype))
  return size;

/* Lose any fake structure return argument if it is passed on the stack.  */
if (aggregate_value_p (TREE_TYPE (funtype)((contains_struct_check ((funtype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1347, __FUNCTION__))->typed.type), fundecl)
    && !ix86_keep_aggregate_return_pointer (funtype))
  {
    int nregs = ix86_function_regparm (funtype, fundecl);
    if (nregs == 0)
return GET_MODE_SIZE (Pmode)((unsigned short) mode_to_bytes ((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))
)).coeffs[0]);
  }

return 0;
1356}

1358/* Implement the TARGET_LEGITIMATE_COMBINED_INSN hook.  */

1360static bool
1361ix86_legitimate_combined_insn (rtx_insn *insn)
1362{
int i;

/* Check operand constraints in case hard registers were propagated
   into insn pattern.  This check prevents combine pass from
   generating insn patterns with invalid hard register operands.
   These invalid insns can eventually confuse reload to error out
   with a spill failure.  See also PRs 46829 and 46843.  */

gcc_assert (INSN_CODE (insn) >= 0)((void)(!((((insn)->u.fld[5]).rt_int) >= 0) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1371, __FUNCTION__), 0 : 0));

extract_insn (insn);
preprocess_constraints (insn);

int n_operands = recog_data.n_operands;
int n_alternatives = recog_data.n_alternatives;
for (i = 0; i < n_operands; i++)
  {
    rtx op = recog_data.operand[i];
    machine_mode mode = GET_MODE (op)((machine_mode) (op)->mode);
    const operand_alternative *op_alt;
    int offset = 0;
    bool win;
    int j;

    /* A unary operator may be accepted by the predicate, but it
is irrelevant for matching constraints.  */
    if (UNARY_P (op)((rtx_class[(int) (((enum rtx_code) (op)->code))]) == RTX_UNARY
))
op = XEXP (op, 0)(((op)->u.fld[0]).rt_rtx);

    if (SUBREG_P (op)(((enum rtx_code) (op)->code) == SUBREG))
{
 if (REG_P (SUBREG_REG (op))(((enum rtx_code) ((((op)->u.fld[0]).rt_rtx))->code) ==
 REG)
     && REGNO (SUBREG_REG (op))(rhs_regno((((op)->u.fld[0]).rt_rtx))) < FIRST_PSEUDO_REGISTER76)
   offset = subreg_regno_offset (REGNO (SUBREG_REG (op))(rhs_regno((((op)->u.fld[0]).rt_rtx))),
			  GET_MODE (SUBREG_REG (op))((machine_mode) ((((op)->u.fld[0]).rt_rtx))->mode),
			  SUBREG_BYTE (op)(((op)->u.fld[1]).rt_subreg),
			  GET_MODE (op)((machine_mode) (op)->mode));
 op = SUBREG_REG (op)(((op)->u.fld[0]).rt_rtx);
}

    if (!(REG_P (op)(((enum rtx_code) (op)->code) == REG) && HARD_REGISTER_P (op)((((rhs_regno(op))) < 76))))
continue;

    op_alt = recog_op_alt;

    /* Operand has no constraints, anything is OK.  */
    win = !n_alternatives;

    alternative_mask preferred = get_preferred_alternatives (insn);
    for (j = 0; j < n_alternatives; j++, op_alt += n_operands)
{
 if (!TEST_BIT (preferred, j)(((preferred) >> (j)) & 1))
   continue;
 if (op_alt[i].anything_ok
     || (op_alt[i].matches != -1
  && operands_match_p
  (recog_data.operand[i],
   recog_data.operand[op_alt[i].matches]))
     || reg_fits_class_p (op, op_alt[i].cl, offset, mode))
   {
     win = true;
     break;
   }
}

    if (!win)
return false;
  }

return true;
1433}
1434
1435/* Implement the TARGET_ASAN_SHADOW_OFFSET hook.  */

1437static unsigned HOST_WIDE_INTlong
1438ix86_asan_shadow_offset (void)
1439{
return SUBTARGET_SHADOW_OFFSET(((global_options.x_ix86_isa_flags & (1UL << 4)) !=
 0) ? 0x7fff8000L : 1L << 29);
1441}
1442
1443/* Argument support functions.  */

1445/* Return true when register may be used to pass function parameters.  */
1446bool
1447ix86_function_arg_regno_p (int regno)
1448{
int i;
enum calling_abi call_abi;
const int *parm_regs;

if (TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0) && SSE_REGNO_P (regno)(((unsigned long) ((regno)) - (unsigned long) (20) <= (unsigned
 long) (27) - (unsigned long) (20)) || ((unsigned long) ((regno
)) - (unsigned long) (44) <= (unsigned long) (51) - (unsigned
 long) (44)) || ((unsigned long) ((regno)) - (unsigned long) (
52) <= (unsigned long) (67) - (unsigned long) (52)))
    && regno < FIRST_SSE_REG20 + SSE_REGPARM_MAX(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? ((((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) && ix86_cfun_abi () == MS_ABI) ? 4 : 8) : (
((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0) ? (0 ? 4 : 3) : 0)))
  return true;

 if (!TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
   return (regno < REGPARM_MAX(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? ((((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) && ix86_cfun_abi () == MS_ABI) ? 4 : 6) : 3
)
    || (TARGET_MMX((global_options.x_ix86_isa_flags & (1UL << 36)) !=
 0) && MMX_REGNO_P (regno)((unsigned long) ((regno)) - (unsigned long) (28) <= (unsigned
 long) (35) - (unsigned long) (28))
 && regno < FIRST_MMX_REG28 + MMX_REGPARM_MAX(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 0 : (((global_options.x_ix86_isa_flags & (1UL <<
 36)) != 0) ? (0 ? 0 : 3) : 0))));

/* TODO: The function should depend on current function ABI but
   builtins.cc would need updating then. Therefore we use the
   default ABI.  */
call_abi = ix86_cfun_abi ();

/* RAX is used as hidden argument to va_arg functions.  */
if (call_abi == SYSV_ABI && regno == AX_REG0)
  return true;

if (call_abi == MS_ABI)
  parm_regs = x86_64_ms_abi_int_parameter_registers;
else
  parm_regs = x86_64_int_parameter_registers;

for (i = 0; i < (call_abi == MS_ABI
   ? X86_64_MS_REGPARM_MAX4 : X86_64_REGPARM_MAX6); i++)
  if (regno == parm_regs[i])
    return true;
return false;
1481}

1483/* Return if we do not know how to pass ARG solely in registers.  */

1485static bool
1486ix86_must_pass_in_stack (const function_arg_info &arg)
1487{
if (must_pass_in_stack_var_size_or_pad (arg))
  return true;

/* For 32-bit, we want TImode aggregates to go on the stack.  But watch out!
   The layout_type routine is crafty and tries to trick us into passing
   currently unsupported vector types on the stack by using TImode.  */
return (!TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
) && arg.mode == TImode(scalar_int_mode ((scalar_int_mode::from_int) E_TImode))
 && arg.type && TREE_CODE (arg.type)((enum tree_code) (arg.type)->base.code) != VECTOR_TYPE);
1496}

1498/* It returns the size, in bytes, of the area reserved for arguments passed
 in registers for the function represented by fndecl dependent to the used
 abi format.  */
1501int
1502ix86_reg_parm_stack_space (const_tree fndecl)
1503{
enum calling_abi call_abi = SYSV_ABI;
if (fndecl != NULL_TREE(tree) __null && TREE_CODE (fndecl)((enum tree_code) (fndecl)->base.code) == FUNCTION_DECL)
  call_abi = ix86_function_abi (fndecl);
else
  call_abi = ix86_function_type_abi (fndecl);
if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
) && call_abi == MS_ABI)
  return 32;
return 0;
1512}

1514/* We add this as a workaround in order to use libc_has_function
 hook in i386.md.  */
1516bool
1517ix86_libc_has_function (enum function_class fn_class)
1518{
return targetm.libc_has_function (fn_class, NULL_TREE(tree) __null);
1520}

1522/* Returns value SYSV_ABI, MS_ABI dependent on fntype,
 specifying the call abi used.  */
1524enum calling_abi
1525ix86_function_type_abi (const_tree fntype)
1526{
enum calling_abi abi = ix86_abiglobal_options.x_ix86_abi;

if (fntype == NULL_TREE(tree) __null || TYPE_ATTRIBUTES (fntype)((tree_class_check ((fntype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1529, __FUNCTION__))->type_common.attributes) == NULL_TREE(tree) __null)
  return abi;

if (abi == SYSV_ABI
    && lookup_attribute ("ms_abi", TYPE_ATTRIBUTES (fntype)((tree_class_check ((fntype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1533, __FUNCTION__))->type_common.attributes)))
  {
    static int warned;
    if (TARGET_X32((global_options.x_ix86_isa_flags & (1UL << 58)) !=
 0) && !warned)
{
 error ("X32 does not support %<ms_abi%> attribute");
 warned = 1;
}

    abi = MS_ABI;
  }
else if (abi == MS_ABI
  && lookup_attribute ("sysv_abi", TYPE_ATTRIBUTES (fntype)((tree_class_check ((fntype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1545, __FUNCTION__))->type_common.attributes)))
  abi = SYSV_ABI;

return abi;
1549}

1551enum calling_abi
1552ix86_function_abi (const_tree fndecl)
1553{
return fndecl ? ix86_function_type_abi (TREE_TYPE (fndecl)((contains_struct_check ((fndecl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1554, __FUNCTION__))->typed.type)) : ix86_abiglobal_options.x_ix86_abi;
1555}

1557/* Returns value SYSV_ABI, MS_ABI dependent on cfun,
 specifying the call abi used.  */
1559enum calling_abi
1560ix86_cfun_abi (void)
1561{
return cfun(cfun + 0) ? cfun(cfun + 0)->machine->call_abi : ix86_abiglobal_options.x_ix86_abi;
1563}

1565bool
1566ix86_function_ms_hook_prologue (const_tree fn)
1567{
if (fn && lookup_attribute ("ms_hook_prologue", DECL_ATTRIBUTES (fn)((contains_struct_check ((fn), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1568, __FUNCTION__))->decl_common.attributes)))
  {
    if (decl_function_context (fn) != NULL_TREE(tree) __null)
error_at (DECL_SOURCE_LOCATION (fn)((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1571, __FUNCTION__))->decl_minimal.locus),
  "%<ms_hook_prologue%> attribute is not compatible "
  "with nested function");
    else
      return true;
  }
return false;
1578}

1580bool
1581ix86_function_naked (const_tree fn)
1582{
if (fn && lookup_attribute ("naked", DECL_ATTRIBUTES (fn)((contains_struct_check ((fn), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1583, __FUNCTION__))->decl_common.attributes)))
  return true;

return false;
1587}

1589/* Write the extra assembler code needed to declare a function properly.  */

1591void
1592ix86_asm_output_function_label (FILE *out_file, const char *fname,
		tree decl)
1594{
bool is_ms_hook = ix86_function_ms_hook_prologue (decl);

if (cfun(cfun + 0))
  cfun(cfun + 0)->machine->function_label_emitted = true;

if (is_ms_hook)
  {
    int i, filler_count = (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
) ? 32 : 16);
    unsigned int filler_cc = 0xcccccccc;

    for (i = 0; i < filler_count; i += 4)
fprintf (out_file, ASM_LONG"\t.long\t" " %#x\n", filler_cc);
  }

1609#ifdef SUBTARGET_ASM_UNWIND_INIT
SUBTARGET_ASM_UNWIND_INIT (out_file);
1611#endif

ASM_OUTPUT_LABEL (out_file, fname)do { assemble_name ((out_file), (fname)); fputs (":\n", (out_file
)); } while (0);

/* Output magic byte marker, if hot-patch attribute is set.  */
if (is_ms_hook)
  {
    if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
{
 /* leaq [%rsp + 0], %rsp  */
 fputs (ASM_BYTE"\t.byte\t" "0x48, 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00\n",
 out_file);
}
    else
{
        /* movl.s %edi, %edi
    push   %ebp
    movl.s %esp, %ebp */
 fputs (ASM_BYTE"\t.byte\t" "0x8b, 0xff, 0x55, 0x8b, 0xec\n", out_file);
}
  }
1632}

1634/* Implementation of call abi switching target hook. Specific to FNDECL
 the specific call register sets are set.  See also
 ix86_conditional_register_usage for more details.  */
1637void
1638ix86_call_abi_override (const_tree fndecl)
1639{
cfun(cfun + 0)->machine->call_abi = ix86_function_abi (fndecl);
1641}

1643/* Return 1 if pseudo register should be created and used to hold
 GOT address for PIC code.  */
1645bool
1646ix86_use_pseudo_pic_reg (void)
1647{
if ((TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
)
     && (ix86_cmodelglobal_options.x_ix86_cmodel == CM_SMALL_PIC
  || TARGET_PECOFF0))
    || !flag_picglobal_options.x_flag_pic)
  return false;
return true;
1654}

1656/* Initialize large model PIC register.  */

1658static void
1659ix86_init_large_pic_reg (unsigned int tmp_regno)
1660{
rtx_code_label *label;
rtx tmp_reg;

gcc_assert (Pmode == DImode)((void)(!((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))) == (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1664, __FUNCTION__), 0 : 0));
label = gen_label_rtx ();
emit_label (label);
LABEL_PRESERVE_P (label)(__extension__ ({ __typeof ((label)) const _rtx = ((label)); if
 (((enum rtx_code) (_rtx)->code) != CODE_LABEL && (
(enum rtx_code) (_rtx)->code) != NOTE) rtl_check_failed_flag
 ("LABEL_PRESERVE_P",_rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1667, __FUNCTION__); _rtx; })->in_struct) = 1;
tmp_reg = gen_rtx_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))), tmp_regno);
gcc_assert (REGNO (pic_offset_table_rtx) != tmp_regno)((void)(!((rhs_regno((this_target_rtl->x_pic_offset_table_rtx
))) != tmp_regno) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1669, __FUNCTION__), 0 : 0));
emit_insn (gen_set_rip_rex64 (pic_offset_table_rtx(this_target_rtl->x_pic_offset_table_rtx),
		label));
emit_insn (gen_set_got_offset_rex64 (tmp_reg, label));
emit_insn (gen_add2_insn (pic_offset_table_rtx(this_target_rtl->x_pic_offset_table_rtx), tmp_reg));
const char *name = LABEL_NAME (label)(((label)->u.fld[6]).rt_str);
PUT_CODE (label, NOTE)((label)->code = (NOTE));
NOTE_KIND (label)(((label)->u.fld[4]).rt_int) = NOTE_INSN_DELETED_LABEL;
NOTE_DELETED_LABEL_NAME (label)(((label)->u.fld[3]).rt_str) = name;
1678}

1680/* Create and initialize PIC register if required.  */
1681static void
1682ix86_init_pic_reg (void)
1683{
edge entry_edge;
rtx_insn *seq;

if (!ix86_use_pseudo_pic_reg ())
  return;

start_sequence ();

if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  {
    if (ix86_cmodelglobal_options.x_ix86_cmodel == CM_LARGE_PIC)
ix86_init_large_pic_reg (R11_REG39);
    else
emit_insn (gen_set_got_rex64 (pic_offset_table_rtx(this_target_rtl->x_pic_offset_table_rtx)));
  }
else
  {
    /*  If there is future mcount call in the function it is more profitable
 to emit SET_GOT into ABI defined REAL_PIC_OFFSET_TABLE_REGNUM.  */
    rtx reg = crtl(&x_rtl)->profile
? gen_rtx_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))), REAL_PIC_OFFSET_TABLE_REGNUM(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 43 : 3))
: pic_offset_table_rtx(this_target_rtl->x_pic_offset_table_rtx);
    rtx_insn *insn = emit_insn (gen_set_got (reg));
    RTX_FRAME_RELATED_P (insn)(__extension__ ({ __typeof ((insn)) const _rtx = ((insn)); if
 (((enum rtx_code) (_rtx)->code) != DEBUG_INSN && (
(enum rtx_code) (_rtx)->code) != INSN && ((enum rtx_code
) (_rtx)->code) != CALL_INSN && ((enum rtx_code) (
_rtx)->code) != JUMP_INSN && ((enum rtx_code) (_rtx
)->code) != BARRIER && ((enum rtx_code) (_rtx)->
code) != SET) rtl_check_failed_flag ("RTX_FRAME_RELATED_P",_rtx
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1707, __FUNCTION__); _rtx; })->frame_related) = 1;
    if (crtl(&x_rtl)->profile)
      emit_move_insn (pic_offset_table_rtx(this_target_rtl->x_pic_offset_table_rtx), reg);
    add_reg_note (insn, REG_CFA_FLUSH_QUEUE, NULL_RTX(rtx) 0);
  }

seq = get_insns ();
end_sequence ();

entry_edge = single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr));
insert_insn_on_edge (seq, entry_edge);
commit_one_edge_insertion (entry_edge);
1719}

1721/* Initialize a variable CUM of type CUMULATIVE_ARGS
 for a call to a function whose data type is FNTYPE.
 For a library call, FNTYPE is 0.  */

1725void
1726init_cumulative_args (CUMULATIVE_ARGS *cum,  /* Argument info to initialize */
      tree fntype,	/* tree ptr for function decl */
      rtx libname,	/* SYMBOL_REF of library name or 0 */
      tree fndecl,
      int caller)
1731{
struct cgraph_node *local_info_node = NULL__null;
struct cgraph_node *target = NULL__null;

/* Set silent_p to false to raise an error for invalid calls when
   expanding function body.  */
cfun(cfun + 0)->machine->silent_p = false;

memset (cum, 0, sizeof (*cum));

if (fndecl)
  {
    target = cgraph_node::get (fndecl);
    if (target)
{
 target = target->function_symbol ();
 local_info_node = cgraph_node::local_info_node (target->decl);
 cum->call_abi = ix86_function_abi (target->decl);
}
    else
cum->call_abi = ix86_function_abi (fndecl);
  }
else
  cum->call_abi = ix86_function_type_abi (fntype);

cum->caller = caller;

/* Set up the number of registers to use for passing arguments.  */
cum->nregs = ix86_regparmglobal_options.x_ix86_regparm;
if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  {
    cum->nregs = (cum->call_abi == SYSV_ABI
                 ? X86_64_REGPARM_MAX6
                 : X86_64_MS_REGPARM_MAX4);
  }
if (TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0))
  {
    cum->sse_nregs = SSE_REGPARM_MAX(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? ((((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) && ix86_cfun_abi () == MS_ABI) ? 4 : 8) : (
((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0) ? (0 ? 4 : 3) : 0));
    if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
      {
        cum->sse_nregs = (cum->call_abi == SYSV_ABI
                         ? X86_64_SSE_REGPARM_MAX8
                         : X86_64_MS_SSE_REGPARM_MAX4);
      }
  }
if (TARGET_MMX((global_options.x_ix86_isa_flags & (1UL << 36)) !=
 0))
  cum->mmx_nregs = MMX_REGPARM_MAX(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 0 : (((global_options.x_ix86_isa_flags & (1UL <<
 36)) != 0) ? (0 ? 0 : 3) : 0));
cum->warn_avx512f = true;
cum->warn_avx = true;
cum->warn_sse = true;
cum->warn_mmx = true;

/* Because type might mismatch in between caller and callee, we need to
   use actual type of function for local calls.
   FIXME: cgraph_analyze can be told to actually record if function uses
   va_start so for local functions maybe_vaarg can be made aggressive
   helping K&R code.
   FIXME: once typesytem is fixed, we won't need this code anymore.  */
if (local_info_node && local_info_node->local
    && local_info_node->can_change_signature)
  fntype = TREE_TYPE (target->decl)((contains_struct_check ((target->decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1791, __FUNCTION__))->typed.type);
cum->stdarg = stdarg_p (fntype);
cum->maybe_vaarg = (fntype
      ? (!prototype_p (fntype) || stdarg_p (fntype))
      : !libname);

cum->decl = fndecl;

cum->warn_empty = !warn_abiglobal_options.x_warn_abi || cum->stdarg;
if (!cum->warn_empty && fntype)
  {
    function_args_iterator iter;
    tree argtype;
    bool seen_empty_type = false;
    FOREACH_FUNCTION_ARGS (fntype, argtype, iter)for (function_args_iter_init (&(iter), (fntype)); (argtype
 = function_args_iter_cond (&(iter))) != (tree) __null; function_args_iter_next
 (&(iter)))
{
 if (argtype == error_mark_nodeglobal_trees[TI_ERROR_MARK] || VOID_TYPE_P (argtype)(((enum tree_code) (argtype)->base.code) == VOID_TYPE))
   break;
 if (TYPE_EMPTY_P (argtype)((tree_class_check ((argtype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1809, __FUNCTION__))->type_common.empty_flag))
   seen_empty_type = true;
 else if (seen_empty_type)
   {
     cum->warn_empty = true;
     break;
   }
}
  }

if (!TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  {
    /* If there are variable arguments, then we won't pass anything
       in registers in 32-bit mode. */
    if (stdarg_p (fntype))
{
 cum->nregs = 0;
 /* Since in 32-bit, variable arguments are always passed on
    stack, there is scratch register available for indirect
    sibcall.  */
 cfun(cfun + 0)->machine->arg_reg_available = true;
 cum->sse_nregs = 0;
 cum->mmx_nregs = 0;
 cum->warn_avx512f = false;
 cum->warn_avx = false;
 cum->warn_sse = false;
 cum->warn_mmx = false;
 return;
}

    /* Use ecx and edx registers if function has fastcall attribute,
else look for regparm information.  */
    if (fntype)
{
 unsigned int ccvt = ix86_get_callcvt (fntype);
 if ((ccvt & IX86_CALLCVT_THISCALL0x8) != 0)
   {
     cum->nregs = 1;
     cum->fastcall = 1; /* Same first register as in fastcall.  */
   }
 else if ((ccvt & IX86_CALLCVT_FASTCALL0x4) != 0)
   {
     cum->nregs = 2;
     cum->fastcall = 1;
   }
 else
   cum->nregs = ix86_function_regparm (fntype, fndecl);
}

    /* Set up the number of SSE registers used for passing SFmode
and DFmode arguments.  Warn for mismatching ABI.  */
    cum->float_in_sse = ix86_function_sseregparm (fntype, fndecl, true);
  }

cfun(cfun + 0)->machine->arg_reg_available = (cum->nregs > 0);
1864}

1866/* Return the "natural" mode for TYPE.  In most cases, this is just TYPE_MODE.
 But in the case of vector types, it is some vector mode.

 When we have only some of our vector isa extensions enabled, then there
 are some modes for which vector_mode_supported_p is false.  For these
 modes, the generic vector support in gcc will choose some non-vector mode
 in order to implement the type.  By computing the natural mode, we'll
 select the proper ABI location for the operand and not depend on whatever
 the middle-end decides to do with these vector types.

 The midde-end can't deal with the vector types > 16 bytes.  In this
 case, we return the original mode and warn ABI change if CUM isn't
 NULL. 

 If INT_RETURN is true, warn ABI change if the vector mode isn't
 available for function return value.  */

1883static machine_mode
1884type_natural_mode (const_tree type, const CUMULATIVE_ARGS *cum,
   bool in_return)
1886{
machine_mode mode = TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1887, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (type) : (type)->type_common.mode);

if (TREE_CODE (type)((enum tree_code) (type)->base.code) == VECTOR_TYPE && !VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM))
  {
    HOST_WIDE_INTlong size = int_size_in_bytes (type);
    if ((size == 8 || size == 16 || size == 32 || size == 64)
 /* ??? Generic code allows us to create width 1 vectors.  Ignore.  */
 && TYPE_VECTOR_SUBPARTS (type) > 1)
{
 machine_mode innermode = TYPE_MODE (TREE_TYPE (type))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1896, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1896, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1896, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1896, __FUNCTION__))->typed.type))->type_common.mode);

 /* There are no XFmode vector modes ...  */
 if (innermode == XFmode(scalar_float_mode ((scalar_float_mode::from_int) E_XFmode)))
   return mode;

 /* ... and no decimal float vector modes.  */
 if (DECIMAL_FLOAT_MODE_P (innermode)(((enum mode_class) mode_class[innermode]) == MODE_DECIMAL_FLOAT
))
   return mode;

 if (TREE_CODE (TREE_TYPE (type))((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1906, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE)
   mode = MIN_MODE_VECTOR_FLOAT;
 else
   mode = MIN_MODE_VECTOR_INT;

 /* Get the mode which has this inner mode and number of units.  */
 FOR_EACH_MODE_FROM (mode, mode)for ((mode) = (mode); mode_iterator::iterate_p (&(mode));
 mode_iterator::get_next (&(mode)))
   if (GET_MODE_NUNITS (mode)(mode_to_nunits (mode).coeffs[0]) == TYPE_VECTOR_SUBPARTS (type)
&& GET_MODE_INNER (mode)(mode_to_inner (mode)) == innermode)
     {
if (size == 64 && !TARGET_AVX512F((global_options.x_ix86_isa_flags & (1UL << 15)) !=
 0) && !TARGET_IAMCU((global_options.x_target_flags & (1U << 12)) != 0))
  {
    static bool warnedavx512f;
    static bool warnedavx512f_ret;

    if (cum && cum->warn_avx512f && !warnedavx512f)
      {
	if (warning (OPT_Wpsabi, "AVX512F vector argument "
		     "without AVX512F enabled changes the ABI"))
	  warnedavx512f = true;
      }
    else if (in_return && !warnedavx512f_ret)
      {
	if (warning (OPT_Wpsabi, "AVX512F vector return "
		     "without AVX512F enabled changes the ABI"))
	  warnedavx512f_ret = true;
      }

    return TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1934, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (type) : (type)->type_common.mode);
  }
else if (size == 32 && !TARGET_AVX((global_options.x_ix86_isa_flags & (1UL << 8)) != 0
) && !TARGET_IAMCU((global_options.x_target_flags & (1U << 12)) != 0))
  {
    static bool warnedavx;
    static bool warnedavx_ret;

    if (cum && cum->warn_avx && !warnedavx)
      {
	if (warning (OPT_Wpsabi, "AVX vector argument "
		     "without AVX enabled changes the ABI"))
	  warnedavx = true;
      }
    else if (in_return && !warnedavx_ret)
      {
	if (warning (OPT_Wpsabi, "AVX vector return "
		     "without AVX enabled changes the ABI"))
	  warnedavx_ret = true;
      }

    return TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 1954, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (type) : (type)->type_common.mode);
  }
else if (((size == 8 && TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
)) || size == 16)
	 && !TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0)
	 && !TARGET_IAMCU((global_options.x_target_flags & (1U << 12)) != 0))
  {
    static bool warnedsse;
    static bool warnedsse_ret;

    if (cum && cum->warn_sse && !warnedsse)
      {
	if (warning (OPT_Wpsabi, "SSE vector argument "
		     "without SSE enabled changes the ABI"))
	  warnedsse = true;
      }
    else if (!TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
) && in_return && !warnedsse_ret)
      {
	if (warning (OPT_Wpsabi, "SSE vector return "
		     "without SSE enabled changes the ABI"))
	  warnedsse_ret = true;
      }
  }
else if ((size == 8 && !TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
	 && (!cfun(cfun + 0)
	     || cfun(cfun + 0)->machine->func_type == TYPE_NORMAL)
	 && !TARGET_MMX((global_options.x_ix86_isa_flags & (1UL << 36)) !=
 0)
	 && !TARGET_IAMCU((global_options.x_target_flags & (1U << 12)) != 0))
  {
    static bool warnedmmx;
    static bool warnedmmx_ret;

    if (cum && cum->warn_mmx && !warnedmmx)
      {
	if (warning (OPT_Wpsabi, "MMX vector argument "
		     "without MMX enabled changes the ABI"))
	  warnedmmx = true;
      }
    else if (in_return && !warnedmmx_ret)
      {
	if (warning (OPT_Wpsabi, "MMX vector return "
		     "without MMX enabled changes the ABI"))
	  warnedmmx_ret = true;
      }
  }
return mode;
     }

 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2001, __FUNCTION__));
}
  }

return mode;
2006}

2008/* We want to pass a value in REGNO whose "natural" mode is MODE.  However,
 this may not agree with the mode that the type system has chosen for the
 register, which is ORIG_MODE.  If ORIG_MODE is not BLKmode, then we can
 go ahead and use it.  Otherwise we have to build a PARALLEL instead.  */

2013static rtx
2014gen_reg_or_parallel (machine_mode mode, machine_mode orig_mode,
     unsigned int regno)
2016{
rtx tmp;

if (orig_mode != BLKmode((void) 0, E_BLKmode))
  tmp = gen_rtx_REG (orig_mode, regno);
else
  {
    tmp = gen_rtx_REG (mode, regno);
    tmp = gen_rtx_EXPR_LIST (VOIDmode((void) 0, E_VOIDmode), tmp, const0_rtx(const_int_rtx[64]));
    tmp = gen_rtx_PARALLEL (orig_mode, gen_rtvec (1, tmp))gen_rtx_fmt_E_stat ((PARALLEL), ((orig_mode)), ((gen_rtvec (1
, tmp))) );
  }

return tmp;
2029}

2031/* x86-64 register passing implementation.  See x86-64 ABI for details.  Goal
 of this code is to classify each 8bytes of incoming argument by the register
 class and assign registers accordingly.  */

2035/* Return the union class of CLASS1 and CLASS2.
 See the x86-64 PS ABI for details.  */

2038static enum x86_64_reg_class
2039merge_classes (enum x86_64_reg_class class1, enum x86_64_reg_class class2)
2040{
/* Rule #1: If both classes are equal, this is the resulting class.  */
if (class1 == class2)
  return class1;

/* Rule #2: If one of the classes is NO_CLASS, the resulting class is
   the other class.  */
if (class1 == X86_64_NO_CLASS)
  return class2;
if (class2 == X86_64_NO_CLASS)
  return class1;

/* Rule #3: If one of the classes is MEMORY, the result is MEMORY.  */
if (class1 == X86_64_MEMORY_CLASS || class2 == X86_64_MEMORY_CLASS)
  return X86_64_MEMORY_CLASS;

/* Rule #4: If one of the classes is INTEGER, the result is INTEGER.  */
if ((class1 == X86_64_INTEGERSI_CLASS
     && (class2 == X86_64_SSESF_CLASS || class2 == X86_64_SSEHF_CLASS))
    || (class2 == X86_64_INTEGERSI_CLASS
 && (class1 == X86_64_SSESF_CLASS || class1 == X86_64_SSEHF_CLASS)))
  return X86_64_INTEGERSI_CLASS;
if (class1 == X86_64_INTEGER_CLASS || class1 == X86_64_INTEGERSI_CLASS
    || class2 == X86_64_INTEGER_CLASS || class2 == X86_64_INTEGERSI_CLASS)
  return X86_64_INTEGER_CLASS;

/* Rule #5: If one of the classes is X87, X87UP, or COMPLEX_X87 class,
   MEMORY is used.  */
if (class1 == X86_64_X87_CLASS
    || class1 == X86_64_X87UP_CLASS
    || class1 == X86_64_COMPLEX_X87_CLASS
    || class2 == X86_64_X87_CLASS
    || class2 == X86_64_X87UP_CLASS
    || class2 == X86_64_COMPLEX_X87_CLASS)
  return X86_64_MEMORY_CLASS;

/* Rule #6: Otherwise class SSE is used.  */
return X86_64_SSE_CLASS;
2078}

2080/* Classify the argument of type TYPE and mode MODE.
 CLASSES will be filled by the register class used to pass each word
 of the operand.  The number of words is returned.  In case the parameter
 should be passed in memory, 0 is returned. As a special case for zero
 sized containers, classes[0] will be NO_CLASS and 1 is returned.

 BIT_OFFSET is used internally for handling records and specifies offset
 of the offset in bits modulo 512 to avoid overflow cases.

 See the x86-64 PS ABI for details.
2090*/

2092static int
2093classify_argument (machine_mode mode, const_tree type,
   enum x86_64_reg_class classes[MAX_CLASSES8], int bit_offset,
   int &zero_width_bitfields)
2096{
HOST_WIDE_INTlong bytes
  = mode == BLKmode((void) 0, E_BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]);
int words = CEIL (bytes + (bit_offset % 64) / 8, UNITS_PER_WORD)(((bytes + (bit_offset % 64) / 8) + ((((global_options.x_ix86_isa_flags
 & (1UL << 1)) != 0) ? 8 : 4)) - 1) / ((((global_options
.x_ix86_isa_flags & (1UL << 1)) != 0) ? 8 : 4)));

/* Variable sized entities are always passed/returned in memory.  */
if (bytes < 0)
  return 0;

if (mode != VOIDmode((void) 0, E_VOIDmode))
  {
    /* The value of "named" doesn't matter.  */
    function_arg_info arg (const_cast<tree> (type), mode, /*named=*/true);
    if (targetm.calls.must_pass_in_stack (arg))
return 0;
  }

if (type && AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
 tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE)))
  {
    int i;
    tree field;
    enum x86_64_reg_class subclasses[MAX_CLASSES8];

    /* On x86-64 we pass structures larger than 64 bytes on the stack.  */
    if (bytes > 64)
return 0;

    for (i = 0; i < words; i++)
classes[i] = X86_64_NO_CLASS;

    /* Zero sized arrays or structures are NO_CLASS.  We return 0 to
signalize memory class, so handle it as special case.  */
    if (!words)
{
 classes[0] = X86_64_NO_CLASS;
 return 1;
}

    /* Classify each field of record and merge classes.  */
    switch (TREE_CODE (type)((enum tree_code) (type)->base.code))
{
case RECORD_TYPE:
 /* And now merge the fields of structure.  */
 for (field = TYPE_FIELDS (type)((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2139, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values); field; field = DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2139, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2139, __FUNCTION__))->common.chain)))
   {
     if (TREE_CODE (field)((enum tree_code) (field)->base.code) == FIELD_DECL)
{
  int num;

  if (TREE_TYPE (field)((contains_struct_check ((field), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2145, __FUNCTION__))->typed.type) == error_mark_nodeglobal_trees[TI_ERROR_MARK])
    continue;

  /* Bitfields are always classified as integer.  Handle them
     early, since later code would consider them to be
     misaligned integers.  */
  if (DECL_BIT_FIELD (field)((tree_check ((field), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2151, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
))
    {
      if (integer_zerop (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2153, __FUNCTION__))->decl_common.size)))
	{
	  if (DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD (field)(((tree_check ((field), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2155, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
) && (field)->decl_common.decl_flag_0))
	    continue;
	  if (zero_width_bitfields != 2)
	    {
	      zero_width_bitfields = 1;
	      continue;
	    }
	}
      for (i = (int_bit_position (field)
		+ (bit_offset % 64)) / 8 / 8;
	   i < ((int_bit_position (field) + (bit_offset % 64))
	        + tree_to_shwi (DECL_SIZE (field)((contains_struct_check ((field), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2166, __FUNCTION__))->decl_common.size))
		+ 63) / 8 / 8; i++)
	classes[i]
	  = merge_classes (X86_64_INTEGER_CLASS, classes[i]);
    }
  else
    {
      int pos;

      type = TREE_TYPE (field)((contains_struct_check ((field), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2175, __FUNCTION__))->typed.type);

      /* Flexible array member is ignored.  */
      if (TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2178, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (type) : (type)->type_common.mode) == BLKmode((void) 0, E_BLKmode)
	  && TREE_CODE (type)((enum tree_code) (type)->base.code) == ARRAY_TYPE
	  && TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2180, __FUNCTION__))->type_common.size) == NULL_TREE(tree) __null
	  && TYPE_DOMAIN (type)((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2181, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
) != NULL_TREE(tree) __null
	  && (TYPE_MAX_VALUE (TYPE_DOMAIN (type))((tree_check5 ((((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2182, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2182, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
	      == NULL_TREE(tree) __null))
	{
	  static bool warned;

	  if (!warned && warn_psabiglobal_options.x_warn_psabi)
	    {
	      warned = true;
	      inform (input_location,
		      "the ABI of passing struct with"
		      " a flexible array member has"
		      " changed in GCC 4.4");
	    }
	  continue;
	}
      num = classify_argument (TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2197, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (type) : (type)->type_common.mode), type,
			       subclasses,
			       (int_bit_position (field)
				+ bit_offset) % 512,
			       zero_width_bitfields);
      if (!num)
	return 0;
      pos = (int_bit_position (field)
	     + (bit_offset % 64)) / 8 / 8;
      for (i = 0; i < num && (i + pos) < words; i++)
	classes[i + pos]
	  = merge_classes (subclasses[i], classes[i + pos]);
    }
}
   }
 break;

case ARRAY_TYPE:
 /* Arrays are handled as small records.  */
 {
   int num;
   num = classify_argument (TYPE_MODE (TREE_TYPE (type))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2218, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2218, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2218, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2218, __FUNCTION__))->typed.type))->type_common.mode),
		     TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2219, __FUNCTION__))->typed.type), subclasses, bit_offset,
		     zero_width_bitfields);
   if (!num)
     return 0;

   /* The partial classes are now full classes.  */
   if (subclasses[0] == X86_64_SSESF_CLASS && bytes != 4)
     subclasses[0] = X86_64_SSE_CLASS;
   if (subclasses[0] == X86_64_SSEHF_CLASS && bytes != 2)
     subclasses[0] = X86_64_SSE_CLASS;
   if (subclasses[0] == X86_64_INTEGERSI_CLASS
&& !((bit_offset % 64) == 0 && bytes == 4))
     subclasses[0] = X86_64_INTEGER_CLASS;

   for (i = 0; i < words; i++)
     classes[i] = subclasses[i % num];

   break;
 }
case UNION_TYPE:
case QUAL_UNION_TYPE:
 /* Unions are similar to RECORD_TYPE but offset is always 0.
    */
 for (field = TYPE_FIELDS (type)((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2242, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values); field; field = DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2242, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2242, __FUNCTION__))->common.chain)))
   {
     if (TREE_CODE (field)((enum tree_code) (field)->base.code) == FIELD_DECL)
{
  int num;

  if (TREE_TYPE (field)((contains_struct_check ((field), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2248, __FUNCTION__))->typed.type) == error_mark_nodeglobal_trees[TI_ERROR_MARK])
    continue;

  num = classify_argument (TYPE_MODE (TREE_TYPE (field))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((field), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2251, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2251, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((field), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2251, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((field), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2251, __FUNCTION__))->typed.type))->type_common.mode),
			   TREE_TYPE (field)((contains_struct_check ((field), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2252, __FUNCTION__))->typed.type), subclasses,
			   bit_offset, zero_width_bitfields);
  if (!num)
    return 0;
  for (i = 0; i < num && i < words; i++)
    classes[i] = merge_classes (subclasses[i], classes[i]);
}
   }
 break;

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

    if (words > 2)
{
 /* When size > 16 bytes, if the first one isn't
    X86_64_SSE_CLASS or any other ones aren't
    X86_64_SSEUP_CLASS, everything should be passed in
    memory.  */
 if (classes[0] != X86_64_SSE_CLASS)
   return 0;

 for (i = 1; i < words; i++)
   if (classes[i] != X86_64_SSEUP_CLASS)
     return 0;
}

    /* Final merger cleanup.  */
    for (i = 0; i < words; i++)
{
 /* If one class is MEMORY, everything should be passed in
    memory.  */
 if (classes[i] == X86_64_MEMORY_CLASS)
   return 0;

 /* The X86_64_SSEUP_CLASS should be always preceded by
    X86_64_SSE_CLASS or X86_64_SSEUP_CLASS.  */
 if (classes[i] == X86_64_SSEUP_CLASS
     && classes[i - 1] != X86_64_SSE_CLASS
     && classes[i - 1] != X86_64_SSEUP_CLASS)
   {
     /* The first one should never be X86_64_SSEUP_CLASS.  */
     gcc_assert (i != 0)((void)(!(i != 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2295, __FUNCTION__), 0 : 0));
     classes[i] = X86_64_SSE_CLASS;
   }

 /* If X86_64_X87UP_CLASS isn't preceded by X86_64_X87_CLASS,
    everything should be passed in memory.  */
 if (classes[i] == X86_64_X87UP_CLASS
     && (classes[i - 1] != X86_64_X87_CLASS))
   {
     static bool warned;

     /* The first one should never be X86_64_X87UP_CLASS.  */
     gcc_assert (i != 0)((void)(!(i != 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2307, __FUNCTION__), 0 : 0));
     if (!warned && warn_psabiglobal_options.x_warn_psabi)
{
  warned = true;
  inform (input_location,
	  "the ABI of passing union with %<long double%>"
	  " has changed in GCC 4.4");
}
     return 0;
   }
}
    return words;
  }

/* Compute alignment needed.  We align all types to natural boundaries with
   exception of XFmode that is aligned to 64bits.  */
if (mode != VOIDmode((void) 0, E_VOIDmode) && mode != BLKmode((void) 0, E_BLKmode))
  {
    int mode_alignment = GET_MODE_BITSIZE (mode)((unsigned short) mode_to_bits (mode).coeffs[0]);

    if (mode == XFmode(scalar_float_mode ((scalar_float_mode::from_int) E_XFmode)))
mode_alignment = 128;
    else if (mode == XCmode(complex_mode ((complex_mode::from_int) E_XCmode)))
mode_alignment = 256;
    if (COMPLEX_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_COMPLEX_INT || (
(enum mode_class) mode_class[mode]) == MODE_COMPLEX_FLOAT))
mode_alignment /= 2;
    /* Misaligned fields are always returned in memory.  */
    if (bit_offset % mode_alignment)
return 0;
  }

/* for V1xx modes, just use the base mode */
if (VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM) && mode != V1DImode((void) 0, E_V1DImode) && mode != V1TImode((void) 0, E_V1TImode)
    && GET_MODE_UNIT_SIZE (mode)mode_to_unit_size (mode) == bytes)
  mode = GET_MODE_INNER (mode)(mode_to_inner (mode));

/* Classification of atomic types.  */
switch (mode)
  {
  case E_SDmode:
  case E_DDmode:
    classes[0] = X86_64_SSE_CLASS;
    return 1;
  case E_TDmode:
    classes[0] = X86_64_SSE_CLASS;
    classes[1] = X86_64_SSEUP_CLASS;
    return 2;
  case E_DImode:
  case E_SImode:
  case E_HImode:
  case E_QImode:
  case E_CSImode:
  case E_CHImode:
  case E_CQImode:
    {
int size = bit_offset + (int) GET_MODE_BITSIZE (mode)((unsigned short) mode_to_bits (mode).coeffs[0]);

/* Analyze last 128 bits only.  */
size = (size - 1) & 0x7f;

if (size < 32)
 {
   classes[0] = X86_64_INTEGERSI_CLASS;
   return 1;
 }
else if (size < 64)
 {
   classes[0] = X86_64_INTEGER_CLASS;
   return 1;
 }
else if (size < 64+32)
 {
   classes[0] = X86_64_INTEGER_CLASS;
   classes[1] = X86_64_INTEGERSI_CLASS;
   return 2;
 }
else if (size < 64+64)
 {
   classes[0] = classes[1] = X86_64_INTEGER_CLASS;
   return 2;
 }
else
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2389, __FUNCTION__));
    }
  case E_CDImode:
  case E_TImode:
    classes[0] = classes[1] = X86_64_INTEGER_CLASS;
    return 2;
  case E_COImode:
  case E_OImode:
    /* OImode shouldn't be used directly.  */
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2398, __FUNCTION__));
  case E_CTImode:
    return 0;
  case E_HFmode:
  case E_BFmode:
    if (!(bit_offset % 64))
classes[0] = X86_64_SSEHF_CLASS;
    else
classes[0] = X86_64_SSE_CLASS;
    return 1;
  case E_SFmode:
    if (!(bit_offset % 64))
classes[0] = X86_64_SSESF_CLASS;
    else
classes[0] = X86_64_SSE_CLASS;
    return 1;
  case E_DFmode:
    classes[0] = X86_64_SSEDF_CLASS;
    return 1;
  case E_XFmode:
    classes[0] = X86_64_X87_CLASS;
    classes[1] = X86_64_X87UP_CLASS;
    return 2;
  case E_TFmode:
    classes[0] = X86_64_SSE_CLASS;
    classes[1] = X86_64_SSEUP_CLASS;
    return 2;
  case E_HCmode:
  case E_BCmode:
    classes[0] = X86_64_SSE_CLASS;
    if (!(bit_offset % 64))
return 1;
    else
{
 classes[1] = X86_64_SSEHF_CLASS;
 return 2;
}
  case E_SCmode:
    classes[0] = X86_64_SSE_CLASS;
    if (!(bit_offset % 64))
return 1;
    else
{
 static bool warned;

 if (!warned && warn_psabiglobal_options.x_warn_psabi)
   {
     warned = true;
     inform (input_location,
      "the ABI of passing structure with %<complex float%>"
      " member has changed in GCC 4.4");
   }
 classes[1] = X86_64_SSESF_CLASS;
 return 2;
}
  case E_DCmode:
    classes[0] = X86_64_SSEDF_CLASS;
    classes[1] = X86_64_SSEDF_CLASS;
    return 2;
  case E_XCmode:
    classes[0] = X86_64_COMPLEX_X87_CLASS;
    return 1;
  case E_TCmode:
    /* This modes is larger than 16 bytes.  */
    return 0;
  case E_V8SFmode:
  case E_V8SImode:
  case E_V32QImode:
  case E_V16HFmode:
  case E_V16BFmode:
  case E_V16HImode:
  case E_V4DFmode:
  case E_V4DImode:
    classes[0] = X86_64_SSE_CLASS;
    classes[1] = X86_64_SSEUP_CLASS;
    classes[2] = X86_64_SSEUP_CLASS;
    classes[3] = X86_64_SSEUP_CLASS;
    return 4;
  case E_V8DFmode:
  case E_V16SFmode:
  case E_V32HFmode:
  case E_V32BFmode:
  case E_V8DImode:
  case E_V16SImode:
  case E_V32HImode:
  case E_V64QImode:
    classes[0] = X86_64_SSE_CLASS;
    classes[1] = X86_64_SSEUP_CLASS;
    classes[2] = X86_64_SSEUP_CLASS;
    classes[3] = X86_64_SSEUP_CLASS;
    classes[4] = X86_64_SSEUP_CLASS;
    classes[5] = X86_64_SSEUP_CLASS;
    classes[6] = X86_64_SSEUP_CLASS;
    classes[7] = X86_64_SSEUP_CLASS;
    return 8;
  case E_V4SFmode:
  case E_V4SImode:
  case E_V16QImode:
  case E_V8HImode:
  case E_V8HFmode:
  case E_V8BFmode:
  case E_V2DFmode:
  case E_V2DImode:
    classes[0] = X86_64_SSE_CLASS;
    classes[1] = X86_64_SSEUP_CLASS;
    return 2;
  case E_V1TImode:
  case E_V1DImode:
  case E_V2SFmode:
  case E_V2SImode:
  case E_V4HImode:
  case E_V4HFmode:
  case E_V4BFmode:
  case E_V2HFmode:
  case E_V2BFmode:
  case E_V8QImode:
    classes[0] = X86_64_SSE_CLASS;
    return 1;
  case E_BLKmode:
  case E_VOIDmode:
    return 0;
  default:
    gcc_assert (VECTOR_MODE_P (mode))((void)(!((((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL
 || ((enum mode_class) mode_class[mode]) == MODE_VECTOR_INT ||
 ((enum mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT ||
 ((enum mode_class) mode_class[mode]) == MODE_VECTOR_FRACT ||
 ((enum mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT ||
 ((enum mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM ||
 ((enum mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM))
 ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2520, __FUNCTION__), 0 : 0));

    if (bytes > 16)
return 0;

    gcc_assert (GET_MODE_CLASS (GET_MODE_INNER (mode)) == MODE_INT)((void)(!(((enum mode_class) mode_class[(mode_to_inner (mode)
)]) == MODE_INT) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2525, __FUNCTION__), 0 : 0));

    if (bit_offset + GET_MODE_BITSIZE (mode)((unsigned short) mode_to_bits (mode).coeffs[0]) <= 32)
classes[0] = X86_64_INTEGERSI_CLASS;
    else
classes[0] = X86_64_INTEGER_CLASS;
    classes[1] = X86_64_INTEGER_CLASS;
    return 1 + (bytes > 8);
  }
2534}

2536/* Wrapper around classify_argument with the extra zero_width_bitfields
 argument, to diagnose GCC 12.1 ABI differences for C.  */

2539static int
2540classify_argument (machine_mode mode, const_tree type,
   enum x86_64_reg_class classes[MAX_CLASSES8], int bit_offset)
2542{
int zero_width_bitfields = 0;
static bool warned = false;
int n = classify_argument (mode, type, classes, bit_offset,
	     zero_width_bitfields);
if (!zero_width_bitfields || warned || !warn_psabiglobal_options.x_warn_psabi)
  return n;
enum x86_64_reg_class alt_classes[MAX_CLASSES8];
zero_width_bitfields = 2;
if (classify_argument (mode, type, alt_classes, bit_offset,
	 zero_width_bitfields) != n)
  zero_width_bitfields = 3;
else
  for (int i = 0; i < n; i++)
    if (classes[i] != alt_classes[i])
{
 zero_width_bitfields = 3;
 break;
}
if (zero_width_bitfields == 3)
  {
    warned = true;
    const char *url
= CHANGES_ROOT_URL"https://gcc.gnu.org/" "gcc-12/changes.html#zero_width_bitfields";

    inform (input_location,
     "the ABI of passing C structures with zero-width bit-fields"
     " has changed in GCC %{12.1%}", url);
  }
return n;
2572}

2574/* Examine the argument and return set number of register required in each
 class.  Return true iff parameter should be passed in memory.  */

2577static bool
2578examine_argument (machine_mode mode, const_tree type, int in_return,
  int *int_nregs, int *sse_nregs)
2580{
enum x86_64_reg_class regclass[MAX_CLASSES8];
int n = classify_argument (mode, type, regclass, 0);

*int_nregs = 0;
*sse_nregs = 0;

if (!n)
  return true;
for (n--; n >= 0; n--)
  switch (regclass[n])
    {
    case X86_64_INTEGER_CLASS:
    case X86_64_INTEGERSI_CLASS:
(*int_nregs)++;
break;
    case X86_64_SSE_CLASS:
    case X86_64_SSEHF_CLASS:
    case X86_64_SSESF_CLASS:
    case X86_64_SSEDF_CLASS:
(*sse_nregs)++;
break;
    case X86_64_NO_CLASS:
    case X86_64_SSEUP_CLASS:
break;
    case X86_64_X87_CLASS:
    case X86_64_X87UP_CLASS:
    case X86_64_COMPLEX_X87_CLASS:
if (!in_return)
 return true;
break;
    case X86_64_MEMORY_CLASS:
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2612, __FUNCTION__));
    }

return false;
2616}

2618/* Construct container for the argument used by GCC interface.  See
 FUNCTION_ARG for the detailed description.  */

2621static rtx
2622construct_container (machine_mode mode, machine_mode orig_mode,
     const_tree type, int in_return, int nintregs, int nsseregs,
     const int *intreg, int sse_regno)
2625{
/* The following variables hold the static issued_error state.  */
static bool issued_sse_arg_error;
static bool issued_sse_ret_error;
static bool issued_x87_ret_error;

machine_mode tmpmode;
int bytes
  = mode == BLKmode((void) 0, E_BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]);
enum x86_64_reg_class regclass[MAX_CLASSES8];
int n;
int i;
int nexps = 0;
int needed_sseregs, needed_intregs;
rtx exp[MAX_CLASSES8];
rtx ret;

n = classify_argument (mode, type, regclass, 0);
if (!n)
  return NULL__null;
if (examine_argument (mode, type, in_return, &needed_intregs,
	&needed_sseregs))
  return NULL__null;
if (needed_intregs > nintregs || needed_sseregs > nsseregs)
  return NULL__null;

/* We allowed the user to turn off SSE for kernel mode.  Don't crash if
   some less clueful developer tries to use floating-point anyway.  */
if (needed_sseregs && !TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0))
  {
    /* Return early if we shouldn't raise an error for invalid
calls.  */
    if (cfun(cfun + 0) != NULL__null && cfun(cfun + 0)->machine->silent_p)
return NULL__null;
    if (in_return)
{
 if (!issued_sse_ret_error)
   {
     error ("SSE register return with SSE disabled");
     issued_sse_ret_error = true;
   }
}
    else if (!issued_sse_arg_error)
{
 error ("SSE register argument with SSE disabled");
 issued_sse_arg_error = true;
}
    return NULL__null;
  }

/* Likewise, error if the ABI requires us to return values in the
   x87 registers and the user specified -mno-80387.  */
if (!TARGET_FLOAT_RETURNS_IN_80387(((global_options.x_target_flags & (1U << 11)) != 0
) && ((global_options.x_target_flags & (1U <<
 1)) != 0) && !((global_options.x_target_flags & (
1U << 12)) != 0)) && in_return)
  for (i = 0; i < n; i++)
    if (regclass[i] == X86_64_X87_CLASS
 || regclass[i] == X86_64_X87UP_CLASS
 || regclass[i] == X86_64_COMPLEX_X87_CLASS)
{
 /* Return early if we shouldn't raise an error for invalid
    calls.  */
 if (cfun(cfun + 0) != NULL__null && cfun(cfun + 0)->machine->silent_p)
   return NULL__null;
 if (!issued_x87_ret_error)
   {
     error ("x87 register return with x87 disabled");
     issued_x87_ret_error = true;
   }
 return NULL__null;
}

/* First construct simple cases.  Avoid SCmode, since we want to use
   single register to pass this type.  */
if (n == 1 && mode != SCmode(complex_mode ((complex_mode::from_int) E_SCmode)) && mode != HCmode(complex_mode ((complex_mode::from_int) E_HCmode)))
  switch (regclass[0])
    {
    case X86_64_INTEGER_CLASS:
    case X86_64_INTEGERSI_CLASS:
return gen_rtx_REG (mode, intreg[0]);
    case X86_64_SSE_CLASS:
    case X86_64_SSEHF_CLASS:
    case X86_64_SSESF_CLASS:
    case X86_64_SSEDF_CLASS:
if (mode != BLKmode((void) 0, E_BLKmode))
 return gen_reg_or_parallel (mode, orig_mode,
		      GET_SSE_REGNO (sse_regno)((sse_regno) < 8 ? 20 + (sse_regno) : (sse_regno) < 16 ?
+ (sse_regno) - 8 : 52 + (sse_regno) - 16));
break;
    case X86_64_X87_CLASS:
    case X86_64_COMPLEX_X87_CLASS:
return gen_rtx_REG (mode, FIRST_STACK_REG8);
    case X86_64_NO_CLASS:
/* Zero sized array, struct or class.  */
return NULL__null;
    default:
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2718, __FUNCTION__));
    }
if (n == 2
    && regclass[0] == X86_64_SSE_CLASS
    && regclass[1] == X86_64_SSEUP_CLASS
    && mode != BLKmode((void) 0, E_BLKmode))
  return gen_reg_or_parallel (mode, orig_mode,
		GET_SSE_REGNO (sse_regno)((sse_regno) < 8 ? 20 + (sse_regno) : (sse_regno) < 16 ?
+ (sse_regno) - 8 : 52 + (sse_regno) - 16));
if (n == 4
    && regclass[0] == X86_64_SSE_CLASS
    && regclass[1] == X86_64_SSEUP_CLASS
    && regclass[2] == X86_64_SSEUP_CLASS
    && regclass[3] == X86_64_SSEUP_CLASS
    && mode != BLKmode((void) 0, E_BLKmode))
  return gen_reg_or_parallel (mode, orig_mode,
		GET_SSE_REGNO (sse_regno)((sse_regno) < 8 ? 20 + (sse_regno) : (sse_regno) < 16 ?
+ (sse_regno) - 8 : 52 + (sse_regno) - 16));
if (n == 8
    && regclass[0] == X86_64_SSE_CLASS
    && regclass[1] == X86_64_SSEUP_CLASS
    && regclass[2] == X86_64_SSEUP_CLASS
    && regclass[3] == X86_64_SSEUP_CLASS
    && regclass[4] == X86_64_SSEUP_CLASS
    && regclass[5] == X86_64_SSEUP_CLASS
    && regclass[6] == X86_64_SSEUP_CLASS
    && regclass[7] == X86_64_SSEUP_CLASS
    && mode != BLKmode((void) 0, E_BLKmode))
  return gen_reg_or_parallel (mode, orig_mode,
		GET_SSE_REGNO (sse_regno)((sse_regno) < 8 ? 20 + (sse_regno) : (sse_regno) < 16 ?
+ (sse_regno) - 8 : 52 + (sse_regno) - 16));
if (n == 2
    && regclass[0] == X86_64_X87_CLASS
    && regclass[1] == X86_64_X87UP_CLASS)
  return gen_rtx_REG (XFmode(scalar_float_mode ((scalar_float_mode::from_int) E_XFmode)), FIRST_STACK_REG8);

if (n == 2
    && regclass[0] == X86_64_INTEGER_CLASS
    && regclass[1] == X86_64_INTEGER_CLASS
    && (mode == CDImode(complex_mode ((complex_mode::from_int) E_CDImode)) || mode == TImode(scalar_int_mode ((scalar_int_mode::from_int) E_TImode)) || mode == BLKmode((void) 0, E_BLKmode))
    && intreg[0] + 1 == intreg[1])
  {
    if (mode == BLKmode((void) 0, E_BLKmode))
{
 /* Use TImode for BLKmode values in 2 integer registers.  */
 exp[0] = gen_rtx_EXPR_LIST (VOIDmode((void) 0, E_VOIDmode),
		      gen_rtx_REG (TImode(scalar_int_mode ((scalar_int_mode::from_int) E_TImode)), intreg[0]),
		      GEN_INT (0)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (0)));
 ret = gen_rtx_PARALLEL (mode, rtvec_alloc (1))gen_rtx_fmt_E_stat ((PARALLEL), ((mode)), ((rtvec_alloc (1)))
 );
 XVECEXP (ret, 0, 0)(((((ret)->u.fld[0]).rt_rtvec))->elem[0]) = exp[0];
 return ret;
}
    else
return gen_rtx_REG (mode, intreg[0]);
  }

/* Otherwise figure out the entries of the PARALLEL.  */
for (i = 0; i < n; i++)
  {
    int pos;

    switch (regclass[i])
      {
 case X86_64_NO_CLASS:
   break;
 case X86_64_INTEGER_CLASS:
 case X86_64_INTEGERSI_CLASS:
   /* Merge TImodes on aligned occasions here too.  */
   if (i * 8 + 8 > bytes)
     {
unsigned int tmpbits = (bytes - i * 8) * BITS_PER_UNIT(8);
if (!int_mode_for_size (tmpbits, 0).exists (&tmpmode))
  /* We've requested 24 bytes we
     don't have mode for.  Use DImode.  */
  tmpmode = DImode(scalar_int_mode ((scalar_int_mode::from_int) E_DImode));
     }
   else if (regclass[i] == X86_64_INTEGERSI_CLASS)
     tmpmode = SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode));
   else
     tmpmode = DImode(scalar_int_mode ((scalar_int_mode::from_int) E_DImode));
   exp [nexps++]
     = gen_rtx_EXPR_LIST (VOIDmode((void) 0, E_VOIDmode),
		   gen_rtx_REG (tmpmode, *intreg),
		   GEN_INT (i*8)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (i*8)));
   intreg++;
   break;
 case X86_64_SSEHF_CLASS:
   tmpmode = (mode == BFmode(scalar_float_mode ((scalar_float_mode::from_int) E_BFmode)) ? BFmode(scalar_float_mode ((scalar_float_mode::from_int) E_BFmode)) : HFmode(scalar_float_mode ((scalar_float_mode::from_int) E_HFmode)));
   exp [nexps++]
     = gen_rtx_EXPR_LIST (VOIDmode((void) 0, E_VOIDmode),
		   gen_rtx_REG (tmpmode,
				GET_SSE_REGNO (sse_regno)((sse_regno) < 8 ? 20 + (sse_regno) : (sse_regno) < 16 ?
+ (sse_regno) - 8 : 52 + (sse_regno) - 16)),
		   GEN_INT (i*8)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (i*8)));
   sse_regno++;
   break;
 case X86_64_SSESF_CLASS:
   exp [nexps++]
     = gen_rtx_EXPR_LIST (VOIDmode((void) 0, E_VOIDmode),
		   gen_rtx_REG (SFmode(scalar_float_mode ((scalar_float_mode::from_int) E_SFmode)),
				GET_SSE_REGNO (sse_regno)((sse_regno) < 8 ? 20 + (sse_regno) : (sse_regno) < 16 ?
+ (sse_regno) - 8 : 52 + (sse_regno) - 16)),
		   GEN_INT (i*8)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (i*8)));
   sse_regno++;
   break;
 case X86_64_SSEDF_CLASS:
   exp [nexps++]
     = gen_rtx_EXPR_LIST (VOIDmode((void) 0, E_VOIDmode),
		   gen_rtx_REG (DFmode(scalar_float_mode ((scalar_float_mode::from_int) E_DFmode)),
				GET_SSE_REGNO (sse_regno)((sse_regno) < 8 ? 20 + (sse_regno) : (sse_regno) < 16 ?
+ (sse_regno) - 8 : 52 + (sse_regno) - 16)),
		   GEN_INT (i*8)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (i*8)));
   sse_regno++;
   break;
 case X86_64_SSE_CLASS:
   pos = i;
   switch (n)
     {
     case 1:
tmpmode = DImode(scalar_int_mode ((scalar_int_mode::from_int) E_DImode));
break;
     case 2:
if (i == 0 && regclass[1] == X86_64_SSEUP_CLASS)
  {
    tmpmode = TImode(scalar_int_mode ((scalar_int_mode::from_int) E_TImode));
    i++;
  }
else
  tmpmode = DImode(scalar_int_mode ((scalar_int_mode::from_int) E_DImode));
break;
     case 4:
gcc_assert (i == 0((void)(!(i == 0 && regclass[1] == X86_64_SSEUP_CLASS
 && regclass[2] == X86_64_SSEUP_CLASS && regclass
[3] == X86_64_SSEUP_CLASS) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2846, __FUNCTION__), 0 : 0))
	    && regclass[1] == X86_64_SSEUP_CLASS((void)(!(i == 0 && regclass[1] == X86_64_SSEUP_CLASS
 && regclass[2] == X86_64_SSEUP_CLASS && regclass
[3] == X86_64_SSEUP_CLASS) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2846, __FUNCTION__), 0 : 0))
	    && regclass[2] == X86_64_SSEUP_CLASS((void)(!(i == 0 && regclass[1] == X86_64_SSEUP_CLASS
 && regclass[2] == X86_64_SSEUP_CLASS && regclass
[3] == X86_64_SSEUP_CLASS) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2846, __FUNCTION__), 0 : 0))
	    && regclass[3] == X86_64_SSEUP_CLASS)((void)(!(i == 0 && regclass[1] == X86_64_SSEUP_CLASS
 && regclass[2] == X86_64_SSEUP_CLASS && regclass
[3] == X86_64_SSEUP_CLASS) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2846, __FUNCTION__), 0 : 0));
tmpmode = OImode(scalar_int_mode ((scalar_int_mode::from_int) E_OImode));
i += 3;
break;
     case 8:
gcc_assert (i == 0((void)(!(i == 0 && regclass[1] == X86_64_SSEUP_CLASS
 && regclass[2] == X86_64_SSEUP_CLASS && regclass
[3] == X86_64_SSEUP_CLASS && regclass[4] == X86_64_SSEUP_CLASS
 && regclass[5] == X86_64_SSEUP_CLASS && regclass
[6] == X86_64_SSEUP_CLASS && regclass[7] == X86_64_SSEUP_CLASS
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2858, __FUNCTION__), 0 : 0))
	    && regclass[1] == X86_64_SSEUP_CLASS((void)(!(i == 0 && regclass[1] == X86_64_SSEUP_CLASS
 && regclass[2] == X86_64_SSEUP_CLASS && regclass
[3] == X86_64_SSEUP_CLASS && regclass[4] == X86_64_SSEUP_CLASS
 && regclass[5] == X86_64_SSEUP_CLASS && regclass
[6] == X86_64_SSEUP_CLASS && regclass[7] == X86_64_SSEUP_CLASS
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2858, __FUNCTION__), 0 : 0))
	    && regclass[2] == X86_64_SSEUP_CLASS((void)(!(i == 0 && regclass[1] == X86_64_SSEUP_CLASS
 && regclass[2] == X86_64_SSEUP_CLASS && regclass
[3] == X86_64_SSEUP_CLASS && regclass[4] == X86_64_SSEUP_CLASS
 && regclass[5] == X86_64_SSEUP_CLASS && regclass
[6] == X86_64_SSEUP_CLASS && regclass[7] == X86_64_SSEUP_CLASS
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2858, __FUNCTION__), 0 : 0))
	    && regclass[3] == X86_64_SSEUP_CLASS((void)(!(i == 0 && regclass[1] == X86_64_SSEUP_CLASS
 && regclass[2] == X86_64_SSEUP_CLASS && regclass
[3] == X86_64_SSEUP_CLASS && regclass[4] == X86_64_SSEUP_CLASS
 && regclass[5] == X86_64_SSEUP_CLASS && regclass
[6] == X86_64_SSEUP_CLASS && regclass[7] == X86_64_SSEUP_CLASS
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2858, __FUNCTION__), 0 : 0))
	    && regclass[4] == X86_64_SSEUP_CLASS((void)(!(i == 0 && regclass[1] == X86_64_SSEUP_CLASS
 && regclass[2] == X86_64_SSEUP_CLASS && regclass
[3] == X86_64_SSEUP_CLASS && regclass[4] == X86_64_SSEUP_CLASS
 && regclass[5] == X86_64_SSEUP_CLASS && regclass
[6] == X86_64_SSEUP_CLASS && regclass[7] == X86_64_SSEUP_CLASS
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2858, __FUNCTION__), 0 : 0))
	    && regclass[5] == X86_64_SSEUP_CLASS((void)(!(i == 0 && regclass[1] == X86_64_SSEUP_CLASS
 && regclass[2] == X86_64_SSEUP_CLASS && regclass
[3] == X86_64_SSEUP_CLASS && regclass[4] == X86_64_SSEUP_CLASS
 && regclass[5] == X86_64_SSEUP_CLASS && regclass
[6] == X86_64_SSEUP_CLASS && regclass[7] == X86_64_SSEUP_CLASS
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2858, __FUNCTION__), 0 : 0))
	    && regclass[6] == X86_64_SSEUP_CLASS((void)(!(i == 0 && regclass[1] == X86_64_SSEUP_CLASS
 && regclass[2] == X86_64_SSEUP_CLASS && regclass
[3] == X86_64_SSEUP_CLASS && regclass[4] == X86_64_SSEUP_CLASS
 && regclass[5] == X86_64_SSEUP_CLASS && regclass
[6] == X86_64_SSEUP_CLASS && regclass[7] == X86_64_SSEUP_CLASS
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2858, __FUNCTION__), 0 : 0))
	    && regclass[7] == X86_64_SSEUP_CLASS)((void)(!(i == 0 && regclass[1] == X86_64_SSEUP_CLASS
 && regclass[2] == X86_64_SSEUP_CLASS && regclass
[3] == X86_64_SSEUP_CLASS && regclass[4] == X86_64_SSEUP_CLASS
 && regclass[5] == X86_64_SSEUP_CLASS && regclass
[6] == X86_64_SSEUP_CLASS && regclass[7] == X86_64_SSEUP_CLASS
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2858, __FUNCTION__), 0 : 0));
tmpmode = XImode(scalar_int_mode ((scalar_int_mode::from_int) E_XImode));
i += 7;
break;
     default:
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2863, __FUNCTION__));
     }
   exp [nexps++]
     = gen_rtx_EXPR_LIST (VOIDmode((void) 0, E_VOIDmode),
		   gen_rtx_REG (tmpmode,
				GET_SSE_REGNO (sse_regno)((sse_regno) < 8 ? 20 + (sse_regno) : (sse_regno) < 16 ?
+ (sse_regno) - 8 : 52 + (sse_regno) - 16)),
		   GEN_INT (pos*8)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (pos*8)));
   sse_regno++;
   break;
 default:
   gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2873, __FUNCTION__));
}
  }

/* Empty aligned struct, union or class.  */
if (nexps == 0)
  return NULL__null;

ret =  gen_rtx_PARALLEL (mode, rtvec_alloc (nexps))gen_rtx_fmt_E_stat ((PARALLEL), ((mode)), ((rtvec_alloc (nexps
))) );
for (i = 0; i < nexps; i++)
  XVECEXP (ret, 0, i)(((((ret)->u.fld[0]).rt_rtvec))->elem[i]) = exp [i];
return ret;
2885}

2887/* Update the data in CUM to advance over an argument of mode MODE
 and data type TYPE.  (TYPE is null for libcalls where that information
 may not be available.)

 Return a number of integer regsiters advanced over.  */

2893static int
2894function_arg_advance_32 (CUMULATIVE_ARGS *cum, machine_mode mode,
	 const_tree type, HOST_WIDE_INTlong bytes,
	 HOST_WIDE_INTlong words)
2897{
int res = 0;
bool error_p = false;

if (TARGET_IAMCU((global_options.x_target_flags & (1U << 12)) != 0))
  {
    /* Intel MCU psABI passes scalars and aggregates no larger than 8
bytes in registers.  */
    if (!VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM) && bytes <= 8)
goto pass_in_reg;
    return res;
  }

switch (mode)
  {
  default:
    break;

  case E_BLKmode:
    if (bytes < 0)
break;
    /* FALLTHRU */

  case E_DImode:
  case E_SImode:
  case E_HImode:
  case E_QImode:
2924pass_in_reg:
    cum->words += words;
    cum->nregs -= words;
    cum->regno += words;
    if (cum->nregs >= 0)
res = words;
    if (cum->nregs <= 0)
{
 cum->nregs = 0;
 cfun(cfun + 0)->machine->arg_reg_available = false;
 cum->regno = 0;
}
    break;

  case E_OImode:
    /* OImode shouldn't be used directly.  */
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 2940, __FUNCTION__));

  case E_DFmode:
    if (cum->float_in_sse == -1)
error_p = true;
    if (cum->float_in_sse < 2)
break;
    /* FALLTHRU */
  case E_SFmode:
    if (cum->float_in_sse == -1)
error_p = true;
    if (cum->float_in_sse < 1)
break;
    /* FALLTHRU */

  case E_V16HFmode:
  case E_V16BFmode:
  case E_V8SFmode:
  case E_V8SImode:
  case E_V64QImode:
  case E_V32HImode:
  case E_V16SImode:
  case E_V8DImode:
  case E_V32HFmode:
  case E_V32BFmode:
  case E_V16SFmode:
  case E_V8DFmode:
  case E_V32QImode:
  case E_V16HImode:
  case E_V4DFmode:
  case E_V4DImode:
  case E_TImode:
  case E_V16QImode:
  case E_V8HImode:
  case E_V4SImode:
  case E_V2DImode:
  case E_V8HFmode:
  case E_V8BFmode:
  case E_V4SFmode:
  case E_V2DFmode:
    if (!type || !AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
 tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE)))
{
 cum->sse_words += words;
 cum->sse_nregs -= 1;
 cum->sse_regno += 1;
 if (cum->sse_nregs <= 0)
   {
     cum->sse_nregs = 0;
     cum->sse_regno = 0;
   }
}
    break;

  case E_V8QImode:
  case E_V4HImode:
  case E_V4HFmode:
  case E_V4BFmode:
  case E_V2SImode:
  case E_V2SFmode:
  case E_V1TImode:
  case E_V1DImode:
    if (!type || !AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
 tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE)))
{
 cum->mmx_words += words;
 cum->mmx_nregs -= 1;
 cum->mmx_regno += 1;
 if (cum->mmx_nregs <= 0)
   {
     cum->mmx_nregs = 0;
     cum->mmx_regno = 0;
   }
}
    break;
  }
if (error_p)
  {
    cum->float_in_sse = 0;
    error ("calling %qD with SSE calling convention without "
    "SSE/SSE2 enabled", cum->decl);
    sorry ("this is a GCC bug that can be worked around by adding "
    "attribute used to function called");
  }

return res;
3024}

3026static int
3027function_arg_advance_64 (CUMULATIVE_ARGS *cum, machine_mode mode,
	 const_tree type, HOST_WIDE_INTlong words, bool named)
3029{
int int_nregs, sse_nregs;

/* Unnamed 512 and 256bit vector mode parameters are passed on stack.  */
if (!named && (VALID_AVX512F_REG_MODE (mode)((mode) == ((void) 0, E_V8DImode) || (mode) == ((void) 0, E_V8DFmode
) || (mode) == ((void) 0, E_V64QImode) || (mode) == ((void) 0
, E_V16SImode) || (mode) == ((void) 0, E_V16SFmode) || (mode)
 == ((void) 0, E_V32HImode) || (mode) == ((void) 0, E_V4TImode
) || (mode) == ((void) 0, E_V32HFmode) || (mode) == ((void) 0
, E_V32BFmode))
 || VALID_AVX256_REG_MODE (mode)((mode) == ((void) 0, E_V32QImode) || (mode) == ((void) 0, E_V16HImode
) || (mode) == ((void) 0, E_V8SImode) || (mode) == ((void) 0,
 E_V4DImode) || (mode) == ((void) 0, E_V2TImode) || (mode) ==
 ((void) 0, E_V8SFmode) || (mode) == ((void) 0, E_V4DFmode) ||
 (mode) == ((void) 0, E_V16HFmode) || (mode) == ((void) 0, E_V16BFmode
))))
  return 0;

if (!examine_argument (mode, type, 0, &int_nregs, &sse_nregs)
    && sse_nregs <= cum->sse_nregs && int_nregs <= cum->nregs)
  {
    cum->nregs -= int_nregs;
    cum->sse_nregs -= sse_nregs;
    cum->regno += int_nregs;
    cum->sse_regno += sse_nregs;
    return int_nregs;
  }
else
  {
    int align = ix86_function_arg_boundary (mode, type) / BITS_PER_WORD((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4));
    cum->words = ROUND_UP (cum->words, align)(((cum->words) + (align) - 1) & ~((align) - 1));
    cum->words += words;
    return 0;
  }
3053}

3055static int
3056function_arg_advance_ms_64 (CUMULATIVE_ARGS *cum, HOST_WIDE_INTlong bytes,
	    HOST_WIDE_INTlong words)
3058{
/* Otherwise, this should be passed indirect.  */
gcc_assert (bytes == 1 || bytes == 2 || bytes == 4 || bytes == 8)((void)(!(bytes == 1 || bytes == 2 || bytes == 4 || bytes == 8
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3060, __FUNCTION__), 0 : 0));

cum->words += words;
if (cum->nregs > 0)
  {
    cum->nregs -= 1;
    cum->regno += 1;
    return 1;
  }
return 0;
3070}

3072/* Update the data in CUM to advance over argument ARG.  */

3074static void
3075ix86_function_arg_advance (cumulative_args_t cum_v,
	   const function_arg_info &arg)
3077{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
machine_mode mode = arg.mode;
HOST_WIDE_INTlong bytes, words;
int nregs;

/* The argument of interrupt handler is a special case and is
   handled in ix86_function_arg.  */
if (!cum->caller && cfun(cfun + 0)->machine->func_type != TYPE_NORMAL)
  return;

bytes = arg.promoted_size_in_bytes ();
words = CEIL (bytes, UNITS_PER_WORD)(((bytes) + ((((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4)) - 1) / ((((global_options.x_ix86_isa_flags
 & (1UL << 1)) != 0) ? 8 : 4)));

if (arg.type)
  mode = type_natural_mode (arg.type, NULL__null, false);

if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  {
    enum calling_abi call_abi = cum ? cum->call_abi : ix86_abiglobal_options.x_ix86_abi;

    if (call_abi == MS_ABI)
nregs = function_arg_advance_ms_64 (cum, bytes, words);
    else
nregs = function_arg_advance_64 (cum, mode, arg.type, words,
			 arg.named);
  }
else
  nregs = function_arg_advance_32 (cum, mode, arg.type, bytes, words);

if (!nregs)
  {
    /* Track if there are outgoing arguments on stack.  */
    if (cum->caller)
cfun(cfun + 0)->machine->outgoing_args_on_stack = true;
  }
3113}

3115/* Define where to put the arguments to a function.
 Value is zero to push the argument on the stack,
 or a hard register in which to store the argument.

 MODE is the argument's machine mode.
 TYPE is the data type of the argument (as a tree).
  This is null for libcalls where that information may
  not be available.
 CUM is a variable of type CUMULATIVE_ARGS which gives info about
  the preceding args and about the function being called.
 NAMED is nonzero if this argument is a named parameter
  (otherwise it is an extra parameter matching an ellipsis).  */

3128static rtx
3129function_arg_32 (CUMULATIVE_ARGS *cum, machine_mode mode,
 machine_mode orig_mode, const_tree type,
 HOST_WIDE_INTlong bytes, HOST_WIDE_INTlong words)
3132{
bool error_p = false;

/* Avoid the AL settings for the Unix64 ABI.  */
if (mode == VOIDmode((void) 0, E_VOIDmode))
  return constm1_rtx(const_int_rtx[64 -1]);

if (TARGET_IAMCU((global_options.x_target_flags & (1U << 12)) != 0))
  {
    /* Intel MCU psABI passes scalars and aggregates no larger than 8
bytes in registers.  */
    if (!VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM) && bytes <= 8)
goto pass_in_reg;
    return NULL_RTX(rtx) 0;
  }

switch (mode)
  {
  default:
    break;

  case E_BLKmode:
    if (bytes < 0)
break;
    /* FALLTHRU */
  case E_DImode:
  case E_SImode:
  case E_HImode:
  case E_QImode:
3161pass_in_reg:
    if (words <= cum->nregs)
{
 int regno = cum->regno;

 /* Fastcall allocates the first two DWORD (SImode) or
          smaller arguments to ECX and EDX if it isn't an
          aggregate type .  */
 if (cum->fastcall)
   {
     if (mode == BLKmode((void) 0, E_BLKmode)
  || mode == DImode(scalar_int_mode ((scalar_int_mode::from_int) E_DImode))
  || (type && AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
 tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE))))
       break;

     /* ECX not EAX is the first allocated register.  */
     if (regno == AX_REG0)
regno = CX_REG2;
   }
 return gen_rtx_REG (mode, regno);
}
    break;

  case E_DFmode:
    if (cum->float_in_sse == -1)
error_p = true;
    if (cum->float_in_sse < 2)
break;
    /* FALLTHRU */
  case E_SFmode:
    if (cum->float_in_sse == -1)
error_p = true;
    if (cum->float_in_sse < 1)
break;
    /* FALLTHRU */
  case E_TImode:
    /* In 32bit, we pass TImode in xmm registers.  */
  case E_V16QImode:
  case E_V8HImode:
  case E_V4SImode:
  case E_V2DImode:
  case E_V8HFmode:
  case E_V8BFmode:
  case E_V4SFmode:
  case E_V2DFmode:
    if (!type || !AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
 tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE)))
{
 if (cum->sse_nregs)
   return gen_reg_or_parallel (mode, orig_mode,
		        cum->sse_regno + FIRST_SSE_REG20);
}
    break;

  case E_OImode:
  case E_XImode:
    /* OImode and XImode shouldn't be used directly.  */
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3217, __FUNCTION__));

  case E_V64QImode:
  case E_V32HImode:
  case E_V16SImode:
  case E_V8DImode:
  case E_V32HFmode:
  case E_V32BFmode:
  case E_V16SFmode:
  case E_V8DFmode:
  case E_V16HFmode:
  case E_V16BFmode:
  case E_V8SFmode:
  case E_V8SImode:
  case E_V32QImode:
  case E_V16HImode:
  case E_V4DFmode:
  case E_V4DImode:
    if (!type || !AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
 tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE)))
{
 if (cum->sse_nregs)
   return gen_reg_or_parallel (mode, orig_mode,
		        cum->sse_regno + FIRST_SSE_REG20);
}
    break;

  case E_V8QImode:
  case E_V4HImode:
  case E_V4HFmode:
  case E_V4BFmode:
  case E_V2SImode:
  case E_V2SFmode:
  case E_V1TImode:
  case E_V1DImode:
    if (!type || !AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
 tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE)))
{
 if (cum->mmx_nregs)
   return gen_reg_or_parallel (mode, orig_mode,
		        cum->mmx_regno + FIRST_MMX_REG28);
}
    break;
  }
if (error_p)
  {
    cum->float_in_sse = 0;
    error ("calling %qD with SSE calling convention without "
    "SSE/SSE2 enabled", cum->decl);
    sorry ("this is a GCC bug that can be worked around by adding "
    "attribute used to function called");
  }

return NULL_RTX(rtx) 0;
3269}

3271static rtx
3272function_arg_64 (const CUMULATIVE_ARGS *cum, machine_mode mode,
 machine_mode orig_mode, const_tree type, bool named)
3274{
/* Handle a hidden AL argument containing number of registers
   for varargs x86-64 functions.  */
if (mode == VOIDmode((void) 0, E_VOIDmode))
  return GEN_INT (cum->maybe_vaarggen_rtx_CONST_INT (((void) 0, E_VOIDmode), (cum->maybe_vaarg
 ? (cum->sse_nregs < 0 ? 8 : cum->sse_regno) : -1))
    ? (cum->sse_nregs < 0gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (cum->maybe_vaarg
 ? (cum->sse_nregs < 0 ? 8 : cum->sse_regno) : -1))
       ? X86_64_SSE_REGPARM_MAXgen_rtx_CONST_INT (((void) 0, E_VOIDmode), (cum->maybe_vaarg
 ? (cum->sse_nregs < 0 ? 8 : cum->sse_regno) : -1))
       : cum->sse_regno)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (cum->maybe_vaarg
 ? (cum->sse_nregs < 0 ? 8 : cum->sse_regno) : -1))
    : -1)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (cum->maybe_vaarg
 ? (cum->sse_nregs < 0 ? 8 : cum->sse_regno) : -1));

switch (mode)
  {
  default:
    break;

  case E_V16HFmode:
  case E_V16BFmode:
  case E_V8SFmode:
  case E_V8SImode:
  case E_V32QImode:
  case E_V16HImode:
  case E_V4DFmode:
  case E_V4DImode:
  case E_V32HFmode:
  case E_V32BFmode:
  case E_V16SFmode:
  case E_V16SImode:
  case E_V64QImode:
  case E_V32HImode:
  case E_V8DFmode:
  case E_V8DImode:
    /* Unnamed 256 and 512bit vector mode parameters are passed on stack.  */
    if (!named)
return NULL__null;
    break;
  }

return construct_container (mode, orig_mode, type, 0, cum->nregs,
	      cum->sse_nregs,
	      &x86_64_int_parameter_registers [cum->regno],
	      cum->sse_regno);
3315}

3317static rtx
3318function_arg_ms_64 (const CUMULATIVE_ARGS *cum, machine_mode mode,
    machine_mode orig_mode, bool named, const_tree type,
    HOST_WIDE_INTlong bytes)
3321{
unsigned int regno;

/* We need to add clobber for MS_ABI->SYSV ABI calls in expand_call.
   We use value of -2 to specify that current function call is MSABI.  */
if (mode == VOIDmode((void) 0, E_VOIDmode))
  return GEN_INT (-2)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (-2));

/* If we've run out of registers, it goes on the stack.  */
if (cum->nregs == 0)
  return NULL_RTX(rtx) 0;

regno = x86_64_ms_abi_int_parameter_registers[cum->regno];

/* Only floating point modes are passed in anything but integer regs.  */
if (TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0) && (mode == SFmode(scalar_float_mode ((scalar_float_mode::from_int) E_SFmode)) || mode == DFmode(scalar_float_mode ((scalar_float_mode::from_int) E_DFmode))))
  {
    if (named)
{
 if (type == NULL_TREE(tree) __null || !AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
 tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE)))
   regno = cum->regno + FIRST_SSE_REG20;
}
    else
{
 rtx t1, t2;

 /* Unnamed floating parameters are passed in both the
    SSE and integer registers.  */
 t1 = gen_rtx_REG (mode, cum->regno + FIRST_SSE_REG20);
 t2 = gen_rtx_REG (mode, regno);
 t1 = gen_rtx_EXPR_LIST (VOIDmode((void) 0, E_VOIDmode), t1, const0_rtx(const_int_rtx[64]));
 t2 = gen_rtx_EXPR_LIST (VOIDmode((void) 0, E_VOIDmode), t2, const0_rtx(const_int_rtx[64]));
 return gen_rtx_PARALLEL (mode, gen_rtvec (2, t1, t2))gen_rtx_fmt_E_stat ((PARALLEL), ((mode)), ((gen_rtvec (2, t1,
 t2))) );
}
  }
/* Handle aggregated types passed in register.  */
if (orig_mode == BLKmode((void) 0, E_BLKmode))
  {
    if (bytes > 0 && bytes <= 8)
      mode = (bytes > 4 ? DImode(scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) : SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode)));
    if (mode == BLKmode((void) 0, E_BLKmode))
      mode = DImode(scalar_int_mode ((scalar_int_mode::from_int) E_DImode));
  }

return gen_reg_or_parallel (mode, orig_mode, regno);
3366}

3368/* Return where to put the arguments to a function.
 Return zero to push the argument on the stack, or a hard register in which to store the argument.

 ARG describes the argument while CUM gives information about the
 preceding args and about the function being called.  */

3374static rtx
3375ix86_function_arg (cumulative_args_t cum_v, const function_arg_info &arg)
3376{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
machine_mode mode = arg.mode;
HOST_WIDE_INTlong bytes, words;
rtx reg;

if (!cum->caller && cfun(cfun + 0)->machine->func_type != TYPE_NORMAL)
  {
    gcc_assert (arg.type != NULL_TREE)((void)(!(arg.type != (tree) __null) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3384, __FUNCTION__), 0 : 0));
    if (POINTER_TYPE_P (arg.type)(((enum tree_code) (arg.type)->base.code) == POINTER_TYPE ||
 ((enum tree_code) (arg.type)->base.code) == REFERENCE_TYPE
))
{
 /* This is the pointer argument.  */
 gcc_assert (TYPE_MODE (arg.type) == ptr_mode)((void)(!(((((enum tree_code) ((tree_class_check ((arg.type),
 (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3388, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (arg.type) : (arg.type)->type_common.mode) == ptr_mode) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3388, __FUNCTION__), 0 : 0));
 /* It is at -WORD(AP) in the current frame in interrupt and
    exception handlers.  */
 reg = 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))), arg_pointer_rtx((this_target_rtl->x_global_rtl)[GR_ARG_POINTER]), -UNITS_PER_WORD(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 8 : 4));
}
    else
{
 gcc_assert (cfun->machine->func_type == TYPE_EXCEPTION((void)(!((cfun + 0)->machine->func_type == TYPE_EXCEPTION
 && ((enum tree_code) (arg.type)->base.code) == INTEGER_TYPE
 && ((((enum tree_code) ((tree_class_check ((arg.type
), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3397, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (arg.type) : (arg.type)->type_common.mode) == word_mode) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3397, __FUNCTION__), 0 : 0))
      && TREE_CODE (arg.type) == INTEGER_TYPE((void)(!((cfun + 0)->machine->func_type == TYPE_EXCEPTION
 && ((enum tree_code) (arg.type)->base.code) == INTEGER_TYPE
 && ((((enum tree_code) ((tree_class_check ((arg.type
), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3397, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (arg.type) : (arg.type)->type_common.mode) == word_mode) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3397, __FUNCTION__), 0 : 0))
      && TYPE_MODE (arg.type) == word_mode)((void)(!((cfun + 0)->machine->func_type == TYPE_EXCEPTION
 && ((enum tree_code) (arg.type)->base.code) == INTEGER_TYPE
 && ((((enum tree_code) ((tree_class_check ((arg.type
), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3397, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (arg.type) : (arg.type)->type_common.mode) == word_mode) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3397, __FUNCTION__), 0 : 0));
 /* The error code is the word-mode integer argument at
    -2 * WORD(AP) in the current frame of the exception
    handler.  */
 reg = gen_rtx_MEM (word_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))),
			    arg_pointer_rtx((this_target_rtl->x_global_rtl)[GR_ARG_POINTER]),
			    -2 * UNITS_PER_WORD(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 8 : 4)));
}
    return reg;
  }

bytes = arg.promoted_size_in_bytes ();
words = CEIL (bytes, UNITS_PER_WORD)(((bytes) + ((((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4)) - 1) / ((((global_options.x_ix86_isa_flags
 & (1UL << 1)) != 0) ? 8 : 4)));

/* To simplify the code below, represent vector types with a vector mode
   even if MMX/SSE are not active.  */
if (arg.type && TREE_CODE (arg.type)((enum tree_code) (arg.type)->base.code) == VECTOR_TYPE)
  mode = type_natural_mode (arg.type, cum, false);

if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  {
    enum calling_abi call_abi = cum ? cum->call_abi : ix86_abiglobal_options.x_ix86_abi;

    if (call_abi == MS_ABI)
reg = function_arg_ms_64 (cum, mode, arg.mode, arg.named,
		  arg.type, bytes);
    else
reg = function_arg_64 (cum, mode, arg.mode, arg.type, arg.named);
  }
else
  reg = function_arg_32 (cum, mode, arg.mode, arg.type, bytes, words);

/* Track if there are outgoing arguments on stack.  */
if (reg == NULL_RTX(rtx) 0 && cum->caller)
  cfun(cfun + 0)->machine->outgoing_args_on_stack = true;

return reg;
3435}

3437/* A C expression that indicates when an argument must be passed by
 reference.  If nonzero for an argument, a copy of that argument is
 made in memory and a pointer to the argument is passed instead of
 the argument itself.  The pointer is passed in whatever way is
 appropriate for passing a pointer to that type.  */

3443static bool
3444ix86_pass_by_reference (cumulative_args_t cum_v, const function_arg_info &arg)
3445{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);

if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  {
    enum calling_abi call_abi = cum ? cum->call_abi : ix86_abiglobal_options.x_ix86_abi;

    /* See Windows x64 Software Convention.  */
    if (call_abi == MS_ABI)
{
 HOST_WIDE_INTlong msize = GET_MODE_SIZE (arg.mode)((unsigned short) mode_to_bytes (arg.mode).coeffs[0]);

 if (tree type = arg.type)
   {
     /* Arrays are passed by reference.  */
     if (TREE_CODE (type)((enum tree_code) (type)->base.code) == ARRAY_TYPE)
return true;

     if (RECORD_OR_UNION_TYPE_P (type)(((enum tree_code) (type)->base.code) == RECORD_TYPE || ((
enum tree_code) (type)->base.code) == UNION_TYPE || ((enum
 tree_code) (type)->base.code) == QUAL_UNION_TYPE))
{
  /* Structs/unions of sizes other than 8, 16, 32, or 64 bits
     are passed by reference.  */
  msize = int_size_in_bytes (type);
}
   }

 /* __m128 is passed by reference.  */
 return msize != 1 && msize != 2 && msize != 4 && msize != 8;
}
    else if (arg.type && int_size_in_bytes (arg.type) == -1)
return true;
  }

return false;
3479}

3481/* Return true when TYPE should be 128bit aligned for 32bit argument
 passing ABI.  XXX: This function is obsolete and is only used for
 checking psABI compatibility with previous versions of GCC.  */

3485static bool
3486ix86_compat_aligned_value_p (const_tree type)
3487{
machine_mode mode = TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3488, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (type) : (type)->type_common.mode);
if (((TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0) && SSE_REG_MODE_P (mode)((mode) == ((void) 0, E_V1TImode) || (mode) == (scalar_int_mode
 ((scalar_int_mode::from_int) E_TImode)) || (mode) == ((void)
 0, E_V16QImode) || (mode) == (scalar_float_mode ((scalar_float_mode
::from_int) E_TFmode)) || (mode) == ((void) 0, E_V8HImode) ||
 (mode) == ((void) 0, E_V2DFmode) || (mode) == ((void) 0, E_V2DImode
) || (mode) == ((void) 0, E_V4SFmode) || (mode) == ((void) 0,
 E_V4SImode) || (mode) == ((void) 0, E_V32QImode) || (mode) ==
 ((void) 0, E_V16HImode) || (mode) == ((void) 0, E_V8SImode) ||
 (mode) == ((void) 0, E_V4DImode) || (mode) == ((void) 0, E_V8SFmode
) || (mode) == ((void) 0, E_V4DFmode) || (mode) == ((void) 0,
 E_V2TImode) || (mode) == ((void) 0, E_V8DImode) || (mode) ==
 ((void) 0, E_V64QImode) || (mode) == ((void) 0, E_V16SImode)
 || (mode) == ((void) 0, E_V32HImode) || (mode) == ((void) 0,
 E_V8DFmode) || (mode) == ((void) 0, E_V16SFmode) || (mode) ==
 ((void) 0, E_V32HFmode) || (mode) == ((void) 0, E_V16HFmode)
 || (mode) == ((void) 0, E_V8HFmode) || (mode) == ((void) 0, E_V32BFmode
) || (mode) == ((void) 0, E_V16BFmode) || (mode) == ((void) 0
, E_V8BFmode)))
     || mode == TDmode(scalar_float_mode ((scalar_float_mode::from_int) E_TDmode))
     || mode == TFmode(scalar_float_mode ((scalar_float_mode::from_int) E_TFmode))
     || mode == TCmode(complex_mode ((complex_mode::from_int) E_TCmode)))
    && (!TYPE_USER_ALIGN (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3493, __FUNCTION__))->base.u.bits.user_align) || TYPE_ALIGN (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3493, __FUNCTION__))->type_common.align) ? ((unsigned)1)
 << (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3493, __FUNCTION__))->type_common.align) - 1) : 0) > 128))
  return true;
if (TYPE_ALIGN (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3495, __FUNCTION__))->type_common.align) ? ((unsigned)1)
 << (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3495, __FUNCTION__))->type_common.align) - 1) : 0) < 128)
  return false;

if (AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
 tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE)))
  {
    /* Walk the aggregates recursively.  */
    switch (TREE_CODE (type)((enum tree_code) (type)->base.code))
{
case RECORD_TYPE:
case UNION_TYPE:
case QUAL_UNION_TYPE:
 {
   tree field;

   /* Walk all the structure fields.  */
   for (field = TYPE_FIELDS (type)((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3510, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values); field; field = DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3510, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3510, __FUNCTION__))->common.chain)))
     {
if (TREE_CODE (field)((enum tree_code) (field)->base.code) == FIELD_DECL
    && ix86_compat_aligned_value_p (TREE_TYPE (field)((contains_struct_check ((field), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3513, __FUNCTION__))->typed.type)))
  return true;
     }
   break;
 }

case ARRAY_TYPE:
 /* Just for use if some languages passes arrays by value.  */
 if (ix86_compat_aligned_value_p (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3521, __FUNCTION__))->typed.type)))
   return true;
 break;

default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3526, __FUNCTION__));
}
  }
return false;
3530}

3532/* Return the alignment boundary for MODE and TYPE with alignment ALIGN.
 XXX: This function is obsolete and is only used for checking psABI
 compatibility with previous versions of GCC.  */

3536static unsigned int
3537ix86_compat_function_arg_boundary (machine_mode mode,
		   const_tree type, unsigned int align)
3539{
/* In 32bit, only _Decimal128 and __float128 are aligned to their
   natural boundaries.  */
if (!TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
) && mode != TDmode(scalar_float_mode ((scalar_float_mode::from_int) E_TDmode)) && mode != TFmode(scalar_float_mode ((scalar_float_mode::from_int) E_TFmode)))
  {
    /* i386 ABI defines all arguments to be 4 byte aligned.  We have to
make an exception for SSE modes since these require 128bit
alignment.

The handling here differs from field_alignment.  ICC aligns MMX
arguments to 4 byte boundaries, while structure fields are aligned
to 8 byte boundaries.  */
    if (!type)
{
 if (!(TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0) && SSE_REG_MODE_P (mode)((mode) == ((void) 0, E_V1TImode) || (mode) == (scalar_int_mode
 ((scalar_int_mode::from_int) E_TImode)) || (mode) == ((void)
 0, E_V16QImode) || (mode) == (scalar_float_mode ((scalar_float_mode
::from_int) E_TFmode)) || (mode) == ((void) 0, E_V8HImode) ||
 (mode) == ((void) 0, E_V2DFmode) || (mode) == ((void) 0, E_V2DImode
) || (mode) == ((void) 0, E_V4SFmode) || (mode) == ((void) 0,
 E_V4SImode) || (mode) == ((void) 0, E_V32QImode) || (mode) ==
 ((void) 0, E_V16HImode) || (mode) == ((void) 0, E_V8SImode) ||
 (mode) == ((void) 0, E_V4DImode) || (mode) == ((void) 0, E_V8SFmode
) || (mode) == ((void) 0, E_V4DFmode) || (mode) == ((void) 0,
 E_V2TImode) || (mode) == ((void) 0, E_V8DImode) || (mode) ==
 ((void) 0, E_V64QImode) || (mode) == ((void) 0, E_V16SImode)
 || (mode) == ((void) 0, E_V32HImode) || (mode) == ((void) 0,
 E_V8DFmode) || (mode) == ((void) 0, E_V16SFmode) || (mode) ==
 ((void) 0, E_V32HFmode) || (mode) == ((void) 0, E_V16HFmode)
 || (mode) == ((void) 0, E_V8HFmode) || (mode) == ((void) 0, E_V32BFmode
) || (mode) == ((void) 0, E_V16BFmode) || (mode) == ((void) 0
, E_V8BFmode))))
   align = PARM_BOUNDARY((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4));
}
    else
{
 if (!ix86_compat_aligned_value_p (type))
   align = PARM_BOUNDARY((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4));
}
  }
if (align > 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))))
  align = 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)));
return align;
3565}

3567/* Return true when TYPE should be 128bit aligned for 32bit argument
 passing ABI.  */

3570static bool
3571ix86_contains_aligned_value_p (const_tree type)
3572{
machine_mode mode = TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3573, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (type) : (type)->type_common.mode);

if (mode == XFmode(scalar_float_mode ((scalar_float_mode::from_int) E_XFmode)) || mode == XCmode(complex_mode ((complex_mode::from_int) E_XCmode)))
  return false;

if (TYPE_ALIGN (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3578, __FUNCTION__))->type_common.align) ? ((unsigned)1)
 << (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3578, __FUNCTION__))->type_common.align) - 1) : 0) < 128)
  return false;

if (AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
 tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE)))
  {
    /* Walk the aggregates recursively.  */
    switch (TREE_CODE (type)((enum tree_code) (type)->base.code))
{
case RECORD_TYPE:
case UNION_TYPE:
case QUAL_UNION_TYPE:
 {
   tree field;

   /* Walk all the structure fields.  */
   for (field = TYPE_FIELDS (type)((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3593, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values);
 field;
 field = DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3595, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3595, __FUNCTION__))->common.chain)))
     {
if (TREE_CODE (field)((enum tree_code) (field)->base.code) == FIELD_DECL
    && ix86_contains_aligned_value_p (TREE_TYPE (field)((contains_struct_check ((field), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3598, __FUNCTION__))->typed.type)))
  return true;
     }
   break;
 }

case ARRAY_TYPE:
 /* Just for use if some languages passes arrays by value.  */
 if (ix86_contains_aligned_value_p (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3606, __FUNCTION__))->typed.type)))
   return true;
 break;

default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3611, __FUNCTION__));
}
  }
else
  return TYPE_ALIGN (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3615, __FUNCTION__))->type_common.align) ? ((unsigned)1)
 << (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3615, __FUNCTION__))->type_common.align) - 1) : 0) >= 128;

return false;
3618}

3620/* Gives the alignment boundary, in bits, of an argument with the
 specified mode and type.  */

3623static unsigned int
3624ix86_function_arg_boundary (machine_mode mode, const_tree type)
3625{
unsigned int align;
if (type)
  {
    /* Since the main variant type is used for call, we convert it to
the main variant type.  */
    type = TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3631, __FUNCTION__))->type_common.main_variant);
    align = TYPE_ALIGN (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3632, __FUNCTION__))->type_common.align) ? ((unsigned)1)
 << (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3632, __FUNCTION__))->type_common.align) - 1) : 0);
    if (TYPE_EMPTY_P (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3633, __FUNCTION__))->type_common.empty_flag))
return PARM_BOUNDARY((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4));
  }
else
  align = GET_MODE_ALIGNMENT (mode)get_mode_alignment (mode);
if (align < PARM_BOUNDARY((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4)))
  align = PARM_BOUNDARY((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4));
else
  {
    static bool warned;
    unsigned int saved_align = align;

    if (!TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
{
 /* i386 ABI defines XFmode arguments to be 4 byte aligned.  */
 if (!type)
   {
     if (mode == XFmode(scalar_float_mode ((scalar_float_mode::from_int) E_XFmode)) || mode == XCmode(complex_mode ((complex_mode::from_int) E_XCmode)))
align = PARM_BOUNDARY((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4));
   }
 else if (!ix86_contains_aligned_value_p (type))
   align = PARM_BOUNDARY((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4));

 if (align < 128)
   align = PARM_BOUNDARY((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4));
}

    if (warn_psabiglobal_options.x_warn_psabi
 && !warned
 && align != ix86_compat_function_arg_boundary (mode, type,
					 saved_align))
{
 warned = true;
 inform (input_location,
  "the ABI for passing parameters with %d-byte"
  " alignment has changed in GCC 4.6",
  align / BITS_PER_UNIT(8));
}
  }

return align;
3674}

3676/* Return true if N is a possible register number of function value.  */

3678static bool
3679ix86_function_value_regno_p (const unsigned int regno)
3680{
switch (regno)
  {
  case AX_REG0:
    return true;
  case DX_REG1:
    return (!TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
) || ix86_cfun_abi () != MS_ABI);
  case DI_REG5:
  case SI_REG4:
    return TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
) && ix86_cfun_abi () != MS_ABI;

    /* Complex values are returned in %st(0)/%st(1) pair.  */
  case ST0_REG8:
  case ST1_REG9:
    /* TODO: The function should depend on current function ABI but
     builtins.cc would need updating then. Therefore we use the
     default ABI.  */
    if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
) && ix86_cfun_abi () == MS_ABI)
return false;
    return TARGET_FLOAT_RETURNS_IN_80387(((global_options.x_target_flags & (1U << 11)) != 0
) && ((global_options.x_target_flags & (1U <<
 1)) != 0) && !((global_options.x_target_flags & (
1U << 12)) != 0));

    /* Complex values are returned in %xmm0/%xmm1 pair.  */
  case XMM0_REG20:
  case XMM1_REG21:
    return TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0);

  case MM0_REG28:
    if (TARGET_MACHO0 || TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
return false;
    return TARGET_MMX((global_options.x_ix86_isa_flags & (1UL << 36)) !=
 0);
  }

return false;
3713}

3715/* Check whether the register REGNO should be zeroed on X86.
 When ALL_SSE_ZEROED is true, all SSE registers have been zeroed
 together, no need to zero it again.
 When NEED_ZERO_MMX is true, MMX registers should be cleared.  */

3720static bool
3721zero_call_used_regno_p (const unsigned int regno,
	bool all_sse_zeroed,
	bool need_zero_mmx)
3724{
return GENERAL_REGNO_P (regno)((((unsigned long) ((regno)) - (unsigned long) (0) <= (unsigned
 long) (7) - (unsigned long) (0))) || ((unsigned long) ((regno
)) - (unsigned long) (36) <= (unsigned long) (43) - (unsigned
 long) (36)))
|| (!all_sse_zeroed && SSE_REGNO_P (regno)(((unsigned long) ((regno)) - (unsigned long) (20) <= (unsigned
 long) (27) - (unsigned long) (20)) || ((unsigned long) ((regno
)) - (unsigned long) (44) <= (unsigned long) (51) - (unsigned
 long) (44)) || ((unsigned long) ((regno)) - (unsigned long) (
52) <= (unsigned long) (67) - (unsigned long) (52))))
|| MASK_REGNO_P (regno)((unsigned long) ((regno)) - (unsigned long) (68) <= (unsigned
 long) (75) - (unsigned long) (68))
|| (need_zero_mmx && MMX_REGNO_P (regno)((unsigned long) ((regno)) - (unsigned long) (28) <= (unsigned
 long) (35) - (unsigned long) (28)));
3729}

3731/* Return the machine_mode that is used to zero register REGNO.  */

3733static machine_mode
3734zero_call_used_regno_mode (const unsigned int regno)
3735{
/* NB: We only need to zero the lower 32 bits for integer registers
   and the lower 128 bits for vector registers since destination are
   zero-extended to the full register width.  */
if (GENERAL_REGNO_P (regno)((((unsigned long) ((regno)) - (unsigned long) (0) <= (unsigned
 long) (7) - (unsigned long) (0))) || ((unsigned long) ((regno
)) - (unsigned long) (36) <= (unsigned long) (43) - (unsigned
 long) (36))))
  return SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode));
else if (SSE_REGNO_P (regno)(((unsigned long) ((regno)) - (unsigned long) (20) <= (unsigned
 long) (27) - (unsigned long) (20)) || ((unsigned long) ((regno
)) - (unsigned long) (44) <= (unsigned long) (51) - (unsigned
 long) (44)) || ((unsigned long) ((regno)) - (unsigned long) (
52) <= (unsigned long) (67) - (unsigned long) (52))))
  return V4SFmode((void) 0, E_V4SFmode);
else if (MASK_REGNO_P (regno)((unsigned long) ((regno)) - (unsigned long) (68) <= (unsigned
 long) (75) - (unsigned long) (68)))
  return HImode(scalar_int_mode ((scalar_int_mode::from_int) E_HImode));
else if (MMX_REGNO_P (regno)((unsigned long) ((regno)) - (unsigned long) (28) <= (unsigned
 long) (35) - (unsigned long) (28)))
  return V2SImode((void) 0, E_V2SImode);
else
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3748, __FUNCTION__));
3749}

3751/* Generate a rtx to zero all vector registers together if possible,
 otherwise, return NULL.  */

3754static rtx
3755zero_all_vector_registers (HARD_REG_SET need_zeroed_hardregs)
3756{
if (!TARGET_AVX((global_options.x_ix86_isa_flags & (1UL << 8)) != 0
))
  return NULL__null;

for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER76; regno++)
  if ((LEGACY_SSE_REGNO_P (regno)((unsigned long) ((regno)) - (unsigned long) (20) <= (unsigned
 long) (27) - (unsigned long) (20))
|| (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
)
    && (REX_SSE_REGNO_P (regno)((unsigned long) ((regno)) - (unsigned long) (44) <= (unsigned
 long) (51) - (unsigned long) (44))
 || (TARGET_AVX512F((global_options.x_ix86_isa_flags & (1UL << 15)) !=
 0) && EXT_REX_SSE_REGNO_P (regno)((unsigned long) ((regno)) - (unsigned long) (52) <= (unsigned
 long) (67) - (unsigned long) (52))))))
&& !TEST_HARD_REG_BIT (need_zeroed_hardregs, regno))
    return NULL__null;

return gen_avx_vzeroall ();
3769}

3771/* Generate insns to zero all st registers together.
 Return true when zeroing instructions are generated.
 Assume the number of st registers that are zeroed is num_of_st,
 we will emit the following sequence to zero them together:
  fldz;		\
  fldz;		\
  ...
  fldz;		\
  fstp %%st(0);	\
  fstp %%st(0);	\
  ...
  fstp %%st(0);
 i.e., num_of_st fldz followed by num_of_st fstp to clear the stack
 mark stack slots empty.

 How to compute the num_of_st:
 There is no direct mapping from stack registers to hard register
 numbers.  If one stack register needs to be cleared, we don't know
 where in the stack the value remains.  So, if any stack register
 needs to be cleared, the whole stack should be cleared.  However,
 x87 stack registers that hold the return value should be excluded.
 x87 returns in the top (two for complex values) register, so
 num_of_st should be 7/6 when x87 returns, otherwise it will be 8.
 return the value of num_of_st.  */


3797static int
3798zero_all_st_registers (HARD_REG_SET need_zeroed_hardregs)
3799{

/* If the FPU is disabled, no need to zero all st registers.  */
if (! (TARGET_80387((global_options.x_target_flags & (1U << 1)) != 0) || TARGET_FLOAT_RETURNS_IN_80387(((global_options.x_target_flags & (1U << 11)) != 0
) && ((global_options.x_target_flags & (1U <<
 1)) != 0) && !((global_options.x_target_flags & (
1U << 12)) != 0))))
  return 0;

unsigned int num_of_st = 0;
for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER76; regno++)
  if ((STACK_REGNO_P (regno)((unsigned long) ((regno)) - (unsigned long) (8) <= (unsigned
 long) (15) - (unsigned long) (8)) || MMX_REGNO_P (regno)((unsigned long) ((regno)) - (unsigned long) (28) <= (unsigned
 long) (35) - (unsigned long) (28)))
&& TEST_HARD_REG_BIT (need_zeroed_hardregs, regno))
    {
num_of_st++;
break;
    }

if (num_of_st == 0)
  return 0;

bool return_with_x87 = false;
return_with_x87 = (crtl(&x_rtl)->return_rtx
     && (STACK_REG_P (crtl->return_rtx)((((enum rtx_code) ((&x_rtl)->return_rtx)->code) ==
 REG) && ((unsigned long) (((rhs_regno((&x_rtl)->
return_rtx)))) - (unsigned long) (8) <= (unsigned long) (15
) - (unsigned long) (8)))));

bool complex_return = false;
complex_return = (crtl(&x_rtl)->return_rtx
    && COMPLEX_MODE_P (GET_MODE (crtl->return_rtx))(((enum mode_class) mode_class[((machine_mode) ((&x_rtl)->
return_rtx)->mode)]) == MODE_COMPLEX_INT || ((enum mode_class
) mode_class[((machine_mode) ((&x_rtl)->return_rtx)->
mode)]) == MODE_COMPLEX_FLOAT));

if (return_with_x87)
  if (complex_return)
    num_of_st = 6;
  else
    num_of_st = 7;
else
  num_of_st = 8;

rtx st_reg = gen_rtx_REG (XFmode(scalar_float_mode ((scalar_float_mode::from_int) E_XFmode)), FIRST_STACK_REG8);
for (unsigned int i = 0; i < num_of_st; i++)
  emit_insn (gen_rtx_SET (st_reg, CONST0_RTX (XFmode))gen_rtx_fmt_ee_stat ((SET), (((void) 0, E_VOIDmode)), ((st_reg
)), (((const_tiny_rtx[0][(int) ((scalar_float_mode ((scalar_float_mode
::from_int) E_XFmode)))]))) ));

for (unsigned int i = 0; i < num_of_st; i++)
  {
    rtx insn;
    insn = emit_insn (gen_rtx_SET (st_reg, st_reg)gen_rtx_fmt_ee_stat ((SET), (((void) 0, E_VOIDmode)), ((st_reg
)), ((st_reg)) ));
    add_reg_note (insn, REG_DEAD, st_reg);
  }
return num_of_st;
3844}


3847/* When the routine exit in MMX mode, if any ST register needs
 to be zeroed, we should clear all MMX registers except the
 RET_MMX_REGNO that holds the return value.  */
3850static bool
3851zero_all_mm_registers (HARD_REG_SET need_zeroed_hardregs,
       unsigned int ret_mmx_regno)
3853{
bool need_zero_all_mm = false;
for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER76; regno++)
  if (STACK_REGNO_P (regno)((unsigned long) ((regno)) - (unsigned long) (8) <= (unsigned
 long) (15) - (unsigned long) (8))
&& TEST_HARD_REG_BIT (need_zeroed_hardregs, regno))
    {
need_zero_all_mm = true;
break;
    }

if (!need_zero_all_mm)
  return false;

machine_mode mode = V2SImode((void) 0, E_V2SImode);
for (unsigned int regno = FIRST_MMX_REG28; regno <= LAST_MMX_REG35; regno++)
  if (regno != ret_mmx_regno)
    {
rtx reg = gen_rtx_REG (mode, regno);
emit_insn (gen_rtx_SET (reg, CONST0_RTX (mode))gen_rtx_fmt_ee_stat ((SET), (((void) 0, E_VOIDmode)), ((reg))
, (((const_tiny_rtx[0][(int) (mode)]))) ));
    }
return true;
3874}

3876/* TARGET_ZERO_CALL_USED_REGS.  */
3877/* Generate a sequence of instructions that zero registers specified by
 NEED_ZEROED_HARDREGS.  Return the ZEROED_HARDREGS that are actually
 zeroed.  */
3880static HARD_REG_SET
3881ix86_zero_call_used_regs (HARD_REG_SET need_zeroed_hardregs)
3882{
HARD_REG_SET zeroed_hardregs;
bool all_sse_zeroed = false;
int all_st_zeroed_num = 0;
bool all_mm_zeroed = false;

CLEAR_HARD_REG_SET (zeroed_hardregs);

/* first, let's see whether we can zero all vector registers together.  */
rtx zero_all_vec_insn = zero_all_vector_registers (need_zeroed_hardregs);
if (zero_all_vec_insn)
  {
    emit_insn (zero_all_vec_insn);
    all_sse_zeroed = true;
  }

/* mm/st registers are shared registers set, we should follow the following
   rules to clear them:
	MMX exit mode	      x87 exit mode
-------------|----------------------|---------------
uses x87 reg | clear all MMX	    | clear all x87
uses MMX reg | clear individual MMX | clear all x87
x87 + MMX    | clear all MMX	    | clear all x87

   first, we should decide which mode (MMX mode or x87 mode) the function
   exit with.  */

bool exit_with_mmx_mode = (crtl(&x_rtl)->return_rtx
	     && (MMX_REG_P (crtl->return_rtx)((((enum rtx_code) ((&x_rtl)->return_rtx)->code) ==
 REG) && ((unsigned long) (((rhs_regno((&x_rtl)->
return_rtx)))) - (unsigned long) (28) <= (unsigned long) (
35) - (unsigned long) (28)))));

if (!exit_with_mmx_mode)
  /* x87 exit mode, we should zero all st registers together.  */
  {
    all_st_zeroed_num = zero_all_st_registers (need_zeroed_hardregs);

    if (all_st_zeroed_num > 0)
for (unsigned int regno = FIRST_STACK_REG8; regno <= LAST_STACK_REG15; regno++)
 /* x87 stack registers that hold the return value should be excluded.
    x87 returns in the top (two for complex values) register.  */
 if (all_st_zeroed_num == 8
     || !((all_st_zeroed_num >= 6 && regno == REGNO (crtl->return_rtx)(rhs_regno((&x_rtl)->return_rtx)))
   || (all_st_zeroed_num == 6
       && (regno == (REGNO (crtl->return_rtx)(rhs_regno((&x_rtl)->return_rtx)) + 1)))))
   SET_HARD_REG_BIT (zeroed_hardregs, regno);
  }
else
  /* MMX exit mode, check whether we can zero all mm registers.  */
  {
    unsigned int exit_mmx_regno = REGNO (crtl->return_rtx)(rhs_regno((&x_rtl)->return_rtx));
    all_mm_zeroed = zero_all_mm_registers (need_zeroed_hardregs,
			     exit_mmx_regno);
    if (all_mm_zeroed)
for (unsigned int regno = FIRST_MMX_REG28; regno <= LAST_MMX_REG35; regno++)
 if (regno != exit_mmx_regno)
   SET_HARD_REG_BIT (zeroed_hardregs, regno);
  }

/* Now, generate instructions to zero all the other registers.  */

for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER76; regno++)
  {
    if (!TEST_HARD_REG_BIT (need_zeroed_hardregs, regno))
continue;
    if (!zero_call_used_regno_p (regno, all_sse_zeroed,
		   exit_with_mmx_mode && !all_mm_zeroed))
continue;

    SET_HARD_REG_BIT (zeroed_hardregs, regno);

    machine_mode mode = zero_call_used_regno_mode (regno);

    rtx reg = gen_rtx_REG (mode, regno);
    rtx tmp = gen_rtx_SET (reg, CONST0_RTX (mode))gen_rtx_fmt_ee_stat ((SET), (((void) 0, E_VOIDmode)), ((reg))
, (((const_tiny_rtx[0][(int) (mode)]))) );

    switch (mode)
{
case E_SImode:
 if (!TARGET_USE_MOV0ix86_tune_features[X86_TUNE_USE_MOV0] || optimize_insn_for_size_p ())
   {
     rtx clob = gen_rtx_CLOBBER (VOIDmode,gen_rtx_fmt_e_stat ((CLOBBER), ((((void) 0, E_VOIDmode))), ((
gen_rtx_REG (((void) 0, E_CCmode), 17))) )
			  gen_rtx_REG (CCmode,gen_rtx_fmt_e_stat ((CLOBBER), ((((void) 0, E_VOIDmode))), ((
gen_rtx_REG (((void) 0, E_CCmode), 17))) )
				       FLAGS_REG))gen_rtx_fmt_e_stat ((CLOBBER), ((((void) 0, E_VOIDmode))), ((
gen_rtx_REG (((void) 0, E_CCmode), 17))) );
     tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2,gen_rtx_fmt_E_stat ((PARALLEL), ((((void) 0, E_VOIDmode))), (
(gen_rtvec (2, tmp, clob))) )
					   tmp,gen_rtx_fmt_E_stat ((PARALLEL), ((((void) 0, E_VOIDmode))), (
(gen_rtvec (2, tmp, clob))) )
					   clob))gen_rtx_fmt_E_stat ((PARALLEL), ((((void) 0, E_VOIDmode))), (
(gen_rtvec (2, tmp, clob))) );
   }
 /* FALLTHRU.  */

case E_V4SFmode:
case E_HImode:
case E_V2SImode:
 emit_insn (tmp);
 break;

default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 3977, __FUNCTION__));
}
  }
return zeroed_hardregs;
3981}

3983/* Define how to find the value returned by a function.
 VALTYPE is the data type of the value (as a tree).
 If the precise function being called is known, FUNC is its FUNCTION_DECL;
 otherwise, FUNC is 0.  */

3988static rtx
3989function_value_32 (machine_mode orig_mode, machine_mode mode,
   const_tree fntype, const_tree fn)
3991{
unsigned int regno;

/* 8-byte vector modes in %mm0. See ix86_return_in_memory for where
   we normally prevent this case when mmx is not available.  However
   some ABIs may require the result to be returned like DImode.  */
if (VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM) && GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]) == 8)
  regno = FIRST_MMX_REG28;

/* 16-byte vector modes in %xmm0.  See ix86_return_in_memory for where
   we prevent this case when sse is not available.  However some ABIs
   may require the result to be returned like integer TImode.  */
else if (mode == TImode(scalar_int_mode ((scalar_int_mode::from_int) E_TImode))
  || (VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM) && GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]) == 16))
  regno = FIRST_SSE_REG20;

/* 32-byte vector modes in %ymm0.   */
else if (VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM) && GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]) == 32)
  regno = FIRST_SSE_REG20;

/* 64-byte vector modes in %zmm0.   */
else if (VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM) && GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]) == 64)
  regno = FIRST_SSE_REG20;

/* Floating point return values in %st(0) (unless -mno-fp-ret-in-387).  */
else if (X87_FLOAT_MODE_P (mode)(((global_options.x_target_flags & (1U << 1)) != 0)
 && ((mode) == (scalar_float_mode ((scalar_float_mode
::from_int) E_SFmode)) || (mode) == (scalar_float_mode ((scalar_float_mode
::from_int) E_DFmode)) || (mode) == (scalar_float_mode ((scalar_float_mode
::from_int) E_XFmode)))) && TARGET_FLOAT_RETURNS_IN_80387(((global_options.x_target_flags & (1U << 11)) != 0
) && ((global_options.x_target_flags & (1U <<
 1)) != 0) && !((global_options.x_target_flags & (
1U << 12)) != 0)))
  regno = FIRST_FLOAT_REG8;
else
  /* Most things go in %eax.  */
  regno = AX_REG0;

/* Return __bf16/ _Float16/_Complex _Foat16 by sse register.  */
if (mode == HFmode(scalar_float_mode ((scalar_float_mode::from_int) E_HFmode)) || mode == BFmode(scalar_float_mode ((scalar_float_mode::from_int) E_BFmode)))
  regno = FIRST_SSE_REG20;
if (mode == HCmode(complex_mode ((complex_mode::from_int) E_HCmode)))
  {
    rtx ret = gen_rtx_PARALLEL (mode, rtvec_alloc(1))gen_rtx_fmt_E_stat ((PARALLEL), ((mode)), ((rtvec_alloc(1))) );
    XVECEXP (ret, 0, 0)(((((ret)->u.fld[0]).rt_rtvec))->elem[0])
= gen_rtx_EXPR_LIST (VOIDmode((void) 0, E_VOIDmode),
	     gen_rtx_REG (SImode(scalar_int_mode ((scalar_int_mode::from_int) E_SImode)), FIRST_SSE_REG20),
	     GEN_INT (0)gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (0)));
    return ret;
  }

/* Override FP return register with %xmm0 for local functions when
   SSE math is enabled or for functions with sseregparm attribute.  */
if ((fn || fntype) && (mode == SFmode(scalar_float_mode ((scalar_float_mode::from_int) E_SFmode)) || mode == DFmode(scalar_float_mode ((scalar_float_mode::from_int) E_DFmode))))
  {
    int sse_level = ix86_function_sseregparm (fntype, fn, false);
    if (sse_level == -1)
{
 error ("calling %qD with SSE calling convention without "
 "SSE/SSE2 enabled", fn);
 sorry ("this is a GCC bug that can be worked around by adding "
 "attribute used to function called");
}
    else if ((sse_level >= 1 && mode == SFmode(scalar_float_mode ((scalar_float_mode::from_int) E_SFmode)))
      || (sse_level == 2 && mode == DFmode(scalar_float_mode ((scalar_float_mode::from_int) E_DFmode))))
regno = FIRST_SSE_REG20;
  }

/* OImode shouldn't be used directly.  */
gcc_assert (mode != OImode)((void)(!(mode != (scalar_int_mode ((scalar_int_mode::from_int
) E_OImode))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4053, __FUNCTION__), 0 : 0));

return gen_rtx_REG (orig_mode, regno);
4056}

4058static rtx
4059function_value_64 (machine_mode orig_mode, machine_mode mode,
   const_tree valtype)
4061{
rtx ret;

/* Handle libcalls, which don't provide a type node.  */
if (valtype == NULL__null)
  {
    unsigned int regno;

    switch (mode)
{
case E_BFmode:
case E_HFmode:
case E_HCmode:
case E_SFmode:
case E_SCmode:
case E_DFmode:
case E_DCmode:
case E_TFmode:
case E_SDmode:
case E_DDmode:
case E_TDmode:
 regno = FIRST_SSE_REG20;
 break;
case E_XFmode:
case E_XCmode:
 regno = FIRST_FLOAT_REG8;
 break;
case E_TCmode:
 return NULL__null;
default:
 regno = AX_REG0;
}

    return gen_rtx_REG (mode, regno);
  }
else if (POINTER_TYPE_P (valtype)(((enum tree_code) (valtype)->base.code) == POINTER_TYPE ||
 ((enum tree_code) (valtype)->base.code) == REFERENCE_TYPE
))
  {
    /* Pointers are always returned in word_mode.  */
    mode = word_mode;
  }

ret = construct_container (mode, orig_mode, valtype, 1,
	     X86_64_REGPARM_MAX6, X86_64_SSE_REGPARM_MAX8,
	     x86_64_int_return_registers, 0);

/* For zero sized structures, construct_container returns NULL, but we
   need to keep rest of compiler happy by returning meaningful value.  */
if (!ret)
  ret = gen_rtx_REG (orig_mode, AX_REG0);

return ret;
4112}

4114static rtx
4115function_value_ms_32 (machine_mode orig_mode, machine_mode mode,
      const_tree fntype, const_tree fn, const_tree valtype)
4117{
unsigned int regno;

/* Floating point return values in %st(0)
   (unless -mno-fp-ret-in-387 or aggregate type of up to 8 bytes).  */
if (X87_FLOAT_MODE_P (mode)(((global_options.x_target_flags & (1U << 1)) != 0)
 && ((mode) == (scalar_float_mode ((scalar_float_mode
::from_int) E_SFmode)) || (mode) == (scalar_float_mode ((scalar_float_mode
::from_int) E_DFmode)) || (mode) == (scalar_float_mode ((scalar_float_mode
::from_int) E_XFmode)))) && TARGET_FLOAT_RETURNS_IN_80387(((global_options.x_target_flags & (1U << 11)) != 0
) && ((global_options.x_target_flags & (1U <<
 1)) != 0) && !((global_options.x_target_flags & (
1U << 12)) != 0))
  && (GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]) > 8
      || valtype == NULL_TREE(tree) __null || !AGGREGATE_TYPE_P (valtype)(((enum tree_code) (valtype)->base.code) == ARRAY_TYPE || (
((enum tree_code) (valtype)->base.code) == RECORD_TYPE || (
(enum tree_code) (valtype)->base.code) == UNION_TYPE || ((
enum tree_code) (valtype)->base.code) == QUAL_UNION_TYPE))))
{
  regno = FIRST_FLOAT_REG8;
  return gen_rtx_REG (orig_mode, regno);
}
else
  return function_value_32(orig_mode, mode, fntype,fn);
4131}

4133static rtx
4134function_value_ms_64 (machine_mode orig_mode, machine_mode mode,
      const_tree valtype)
4136{
unsigned int regno = AX_REG0;

if (TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0))
  {
    switch (GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]))
{
case 16:
 if (valtype != NULL_TREE(tree) __null
     && !VECTOR_INTEGER_TYPE_P (valtype)((((enum tree_code) (valtype)->base.code) == VECTOR_TYPE) &&
 ((enum tree_code) (((contains_struct_check ((valtype), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4145, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
     && !VECTOR_INTEGER_TYPE_P (valtype)((((enum tree_code) (valtype)->base.code) == VECTOR_TYPE) &&
 ((enum tree_code) (((contains_struct_check ((valtype), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4146, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
     && !INTEGRAL_TYPE_P (valtype)(((enum tree_code) (valtype)->base.code) == ENUMERAL_TYPE ||
 ((enum tree_code) (valtype)->base.code) == BOOLEAN_TYPE ||
 ((enum tree_code) (valtype)->base.code) == INTEGER_TYPE)
     && !VECTOR_FLOAT_TYPE_P (valtype)((((enum tree_code) (valtype)->base.code) == VECTOR_TYPE) &&
 ((enum tree_code) (((contains_struct_check ((valtype), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4148, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
))
   break;
 if ((SCALAR_INT_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_INT || ((enum mode_class
) mode_class[mode]) == MODE_PARTIAL_INT) || VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM))
     && !COMPLEX_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_COMPLEX_INT || (
(enum mode_class) mode_class[mode]) == MODE_COMPLEX_FLOAT))
   regno = FIRST_SSE_REG20;
 break;
case 8:
case 4:
 if (valtype != NULL_TREE(tree) __null && AGGREGATE_TYPE_P (valtype)(((enum tree_code) (valtype)->base.code) == ARRAY_TYPE || (
((enum tree_code) (valtype)->base.code) == RECORD_TYPE || (
(enum tree_code) (valtype)->base.code) == UNION_TYPE || ((
enum tree_code) (valtype)->base.code) == QUAL_UNION_TYPE)))
   break;
 if (mode == SFmode(scalar_float_mode ((scalar_float_mode::from_int) E_SFmode)) || mode == DFmode(scalar_float_mode ((scalar_float_mode::from_int) E_DFmode)))
   regno = FIRST_SSE_REG20;
 break;
default:
 break;
      }
  }
return gen_rtx_REG (orig_mode, regno);
4166}

4168static rtx
4169ix86_function_value_1 (const_tree valtype, const_tree fntype_or_decl,
       machine_mode orig_mode, machine_mode mode)
4171{
const_tree fn, fntype;

fn = NULL_TREE(tree) __null;
if (fntype_or_decl && DECL_P (fntype_or_decl)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (fntype_or_decl)->base.code))] == tcc_declaration))
  fn = fntype_or_decl;
fntype = fn ? TREE_TYPE (fn)((contains_struct_check ((fn), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4177, __FUNCTION__))->typed.type) : fntype_or_decl;

if (ix86_function_type_abi (fntype) == MS_ABI)
  {
    if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
return function_value_ms_64 (orig_mode, mode, valtype);
    else
return function_value_ms_32 (orig_mode, mode, fntype, fn, valtype);
  }
else if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  return function_value_64 (orig_mode, mode, valtype);
else
  return function_value_32 (orig_mode, mode, fntype, fn);
4190}

4192static rtx
4193ix86_function_value (const_tree valtype, const_tree fntype_or_decl, bool)
4194{
machine_mode mode, orig_mode;

orig_mode = TYPE_MODE (valtype)((((enum tree_code) ((tree_class_check ((valtype), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4197, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (valtype) : (valtype)->type_common.mode);
mode = type_natural_mode (valtype, NULL__null, true);
return ix86_function_value_1 (valtype, fntype_or_decl, orig_mode, mode);
4200}

4202/* Pointer function arguments and return values are promoted to
 word_mode for normal functions.  */

4205static machine_mode
4206ix86_promote_function_mode (const_tree type, machine_mode mode,
	    int *punsignedp, const_tree fntype,
	    int for_return)
4209{
if (cfun(cfun + 0)->machine->func_type == TYPE_NORMAL
    && type != NULL_TREE(tree) __null
    && POINTER_TYPE_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE))
  {
    *punsignedp = POINTERS_EXTEND_UNSIGNED1;
    return word_mode;
  }
return default_promote_function_mode (type, mode, punsignedp, fntype,
			for_return);
4219}

4221/* Return true if a structure, union or array with MODE containing FIELD
 should be accessed using BLKmode.  */

4224static bool
4225ix86_member_type_forces_blk (const_tree field, machine_mode mode)
4226{
/* Union with XFmode must be in BLKmode.  */
return (mode == XFmode(scalar_float_mode ((scalar_float_mode::from_int) E_XFmode))
 && (TREE_CODE (DECL_FIELD_CONTEXT (field))((enum tree_code) (((tree_check ((field), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4229, __FUNCTION__, (FIELD_DECL)))->decl_minimal.context
))->base.code) == UNION_TYPE
     || TREE_CODE (DECL_FIELD_CONTEXT (field))((enum tree_code) (((tree_check ((field), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4230, __FUNCTION__, (FIELD_DECL)))->decl_minimal.context
))->base.code) == QUAL_UNION_TYPE));
4231}

4233rtx
4234ix86_libcall_value (machine_mode mode)
4235{
return ix86_function_value_1 (NULL__null, NULL__null, mode, mode);
4237}

4239/* Return true iff type is returned in memory.  */

4241static bool
4242ix86_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
4243{
const machine_mode mode = type_natural_mode (type, NULL__null, true);
HOST_WIDE_INTlong size;

if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  {
    if (ix86_function_type_abi (fntype) == MS_ABI)
{
 size = int_size_in_bytes (type);

 /* __m128 is returned in xmm0.  */
 if ((!type || VECTOR_INTEGER_TYPE_P (type)((((enum tree_code) (type)->base.code) == VECTOR_TYPE) &&
 ((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4254, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
      || 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)
      || VECTOR_FLOAT_TYPE_P (type)((((enum tree_code) (type)->base.code) == VECTOR_TYPE) &&
 ((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4256, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
))
     && (SCALAR_INT_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_INT || ((enum mode_class
) mode_class[mode]) == MODE_PARTIAL_INT) || VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM))
     && !COMPLEX_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_COMPLEX_INT || (
(enum mode_class) mode_class[mode]) == MODE_COMPLEX_FLOAT)
     && (GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]) == 16 || size == 16))
   return false;

 /* Otherwise, the size must be exactly in [1248]. */
 return size != 1 && size != 2 && size != 4 && size != 8;
}
    else
{
 int needed_intregs, needed_sseregs;

 return examine_argument (mode, type, 1,
		   &needed_intregs, &needed_sseregs);
}
  }
else
  {
    size = int_size_in_bytes (type);

    /* Intel MCU psABI returns scalars and aggregates no larger than 8
bytes in registers.  */
    if (TARGET_IAMCU((global_options.x_target_flags & (1U << 12)) != 0))
return VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM) || size < 0 || size > 8;

    if (mode == BLKmode((void) 0, E_BLKmode))
return true;

    if (MS_AGGREGATE_RETURN0 && AGGREGATE_TYPE_P (type)(((enum tree_code) (type)->base.code) == ARRAY_TYPE || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
 tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE)) && size <= 8)
return false;

    if (VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
 mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM) || mode == TImode(scalar_int_mode ((scalar_int_mode::from_int) E_TImode)))
{
 /* User-created vectors small enough to fit in EAX.  */
 if (size < 8)
   return false;

 /* Unless ABI prescibes otherwise,
    MMX/3dNow values are returned in MM0 if available.  */
    
 if (size == 8)
   return TARGET_VECT8_RETURNS((global_options.x_target_flags & (1U << 29)) != 0) || !TARGET_MMX((global_options.x_ix86_isa_flags & (1UL << 36)) !=
 0);

 /* SSE values are returned in XMM0 if available.  */
 if (size == 16)
   return !TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0);

 /* AVX values are returned in YMM0 if available.  */
 if (size == 32)
   return !TARGET_AVX((global_options.x_ix86_isa_flags & (1UL << 8)) != 0
);

 /* AVX512F values are returned in ZMM0 if available.  */
 if (size == 64)
   return !TARGET_AVX512F((global_options.x_ix86_isa_flags & (1UL << 15)) !=
 0);
}

    if (mode == XFmode(scalar_float_mode ((scalar_float_mode::from_int) E_XFmode)))
return false;

    if (size > 12)
return true;

    /* OImode shouldn't be used directly.  */
    gcc_assert (mode != OImode)((void)(!(mode != (scalar_int_mode ((scalar_int_mode::from_int
) E_OImode))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4320, __FUNCTION__), 0 : 0));

    return false;
  }
4324}

4326/* Implement TARGET_PUSH_ARGUMENT.  */

4328static bool
4329ix86_push_argument (unsigned int npush)
4330{
/* If SSE2 is available, use vector move to put large argument onto
   stack.  NB:  In 32-bit mode, use 8-byte vector move.  */
return ((!TARGET_SSE2((global_options.x_ix86_isa_flags & (1UL << 51)) !=
 0) || npush < (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
) ? 16 : 8))
 && TARGET_PUSH_ARGS((global_options.x_target_flags & (1U << 19)) == 0)
 && !ACCUMULATE_OUTGOING_ARGS((((global_options.x_target_flags & (1U << 3)) != 0
) && optimize_function_for_speed_p ((cfun + 0))) || (
(cfun + 0)->machine->func_type != TYPE_NORMAL &&
 (&x_rtl)->stack_realign_needed) || ((global_options.x_target_flags
 & (1U << 26)) != 0) || (((global_options.x_ix86_isa_flags
 & (1UL << 1)) != 0) && ix86_cfun_abi () ==
 MS_ABI) || (0 && (&x_rtl)->profile)));
4336}

4338
4339/* Create the va_list data type.  */

4341static tree
4342ix86_build_builtin_va_list_64 (void)
4343{
tree f_gpr, f_fpr, f_ovf, f_sav, record, type_decl;

record = lang_hooks.types.make_type (RECORD_TYPE);
type_decl = build_decl (BUILTINS_LOCATION((location_t) 1),
	  TYPE_DECL, get_identifier ("__va_list_tag")(__builtin_constant_p ("__va_list_tag") ? get_identifier_with_length
 (("__va_list_tag"), strlen ("__va_list_tag")) : get_identifier
 ("__va_list_tag")), record);

f_gpr = build_decl (BUILTINS_LOCATION((location_t) 1),
      FIELD_DECL, get_identifier ("gp_offset")(__builtin_constant_p ("gp_offset") ? get_identifier_with_length
 (("gp_offset"), strlen ("gp_offset")) : get_identifier ("gp_offset"
)),
      unsigned_type_nodeinteger_types[itk_unsigned_int]);
f_fpr = build_decl (BUILTINS_LOCATION((location_t) 1),
      FIELD_DECL, get_identifier ("fp_offset")(__builtin_constant_p ("fp_offset") ? get_identifier_with_length
 (("fp_offset"), strlen ("fp_offset")) : get_identifier ("fp_offset"
)),
      unsigned_type_nodeinteger_types[itk_unsigned_int]);
f_ovf = build_decl (BUILTINS_LOCATION((location_t) 1),
      FIELD_DECL, get_identifier ("overflow_arg_area")(__builtin_constant_p ("overflow_arg_area") ? get_identifier_with_length
 (("overflow_arg_area"), strlen ("overflow_arg_area")) : get_identifier
 ("overflow_arg_area")),
      ptr_type_nodeglobal_trees[TI_PTR_TYPE]);
f_sav = build_decl (BUILTINS_LOCATION((location_t) 1),
      FIELD_DECL, get_identifier ("reg_save_area")(__builtin_constant_p ("reg_save_area") ? get_identifier_with_length
 (("reg_save_area"), strlen ("reg_save_area")) : get_identifier
 ("reg_save_area")),
      ptr_type_nodeglobal_trees[TI_PTR_TYPE]);

va_list_gpr_counter_fieldglobal_trees[TI_VA_LIST_GPR_COUNTER_FIELD] = f_gpr;
va_list_fpr_counter_fieldglobal_trees[TI_VA_LIST_FPR_COUNTER_FIELD] = f_fpr;

DECL_FIELD_CONTEXT (f_gpr)((tree_check ((f_gpr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4366, __FUNCTION__, (FIELD_DECL)))->decl_minimal.context
) = record;
DECL_FIELD_CONTEXT (f_fpr)((tree_check ((f_fpr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4367, __FUNCTION__, (FIELD_DECL)))->decl_minimal.context
) = record;
DECL_FIELD_CONTEXT (f_ovf)((tree_check ((f_ovf), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4368, __FUNCTION__, (FIELD_DECL)))->decl_minimal.context
) = record;
DECL_FIELD_CONTEXT (f_sav)((tree_check ((f_sav), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4369, __FUNCTION__, (FIELD_DECL)))->decl_minimal.context
) = record;

TYPE_STUB_DECL (record)(((contains_struct_check (((tree_class_check ((record), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4371, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4371, __FUNCTION__))->common.chain)) = type_decl;
TYPE_NAME (record)((tree_class_check ((record), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4372, __FUNCTION__))->type_common.name) = type_decl;
TYPE_FIELDS (record)((tree_check3 ((record), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4373, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values) = f_gpr;
DECL_CHAIN (f_gpr)(((contains_struct_check (((contains_struct_check ((f_gpr), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4374, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4374, __FUNCTION__))->common.chain)) = f_fpr;
DECL_CHAIN (f_fpr)(((contains_struct_check (((contains_struct_check ((f_fpr), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4375, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4375, __FUNCTION__))->common.chain)) = f_ovf;
DECL_CHAIN (f_ovf)(((contains_struct_check (((contains_struct_check ((f_ovf), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4376, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4376, __FUNCTION__))->common.chain)) = f_sav;

layout_type (record);

TYPE_ATTRIBUTES (record)((tree_class_check ((record), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4380, __FUNCTION__))->type_common.attributes) = tree_cons (get_identifier ("sysv_abi va_list")(__builtin_constant_p ("sysv_abi va_list") ? get_identifier_with_length
 (("sysv_abi va_list"), strlen ("sysv_abi va_list")) : get_identifier
 ("sysv_abi va_list")),
			NULL_TREE(tree) __null, TYPE_ATTRIBUTES (record)((tree_class_check ((record), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4381, __FUNCTION__))->type_common.attributes));

/* The correct type is an array type of one element.  */
return build_array_type (record, build_index_type (size_zero_nodeglobal_trees[TI_SIZE_ZERO]));
4385}

4387/* Setup the builtin va_list data type and for 64-bit the additional
 calling convention specific va_list data types.  */

4390static tree
4391ix86_build_builtin_va_list (void)
4392{
if (TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  {
    /* Initialize ABI specific va_list builtin types.

In lto1, we can encounter two va_list types:
- one as a result of the type-merge across TUs, and
- the one constructed here.
These two types will not have the same TYPE_MAIN_VARIANT, and therefore
a type identity check in canonical_va_list_type based on
TYPE_MAIN_VARIANT (which we used to have) will not work.
Instead, we tag each va_list_type_node with its unique attribute, and
look for the attribute in the type identity check in
canonical_va_list_type.

Tagging sysv_va_list_type_node directly with the attribute is
problematic since it's a array of one record, which will degrade into a
pointer to record when used as parameter (see build_va_arg comments for
an example), dropping the attribute in the process.  So we tag the
record instead.  */

    /* For SYSV_ABI we use an array of one record.  */
    sysv_va_list_type_node = ix86_build_builtin_va_list_64 ();

    /* For MS_ABI we use plain pointer to argument area.  */
    tree char_ptr_type = build_pointer_type (char_type_nodeinteger_types[itk_char]);
    tree attr = tree_cons (get_identifier ("ms_abi va_list")(__builtin_constant_p ("ms_abi va_list") ? get_identifier_with_length
 (("ms_abi va_list"), strlen ("ms_abi va_list")) : get_identifier
 ("ms_abi va_list")), NULL_TREE(tree) __null,
	     TYPE_ATTRIBUTES (char_ptr_type)((tree_class_check ((char_ptr_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4419, __FUNCTION__))->type_common.attributes));
    ms_va_list_type_node = build_type_attribute_variant (char_ptr_type, attr);

    return ((ix86_abiglobal_options.x_ix86_abi == MS_ABI)
     ? ms_va_list_type_node
     : sysv_va_list_type_node);
  }
else
  {
    /* For i386 we use plain pointer to argument area.  */
    return build_pointer_type (char_type_nodeinteger_types[itk_char]);
  }
4431}

4433/* Worker function for TARGET_SETUP_INCOMING_VARARGS.  */

4435static void
4436setup_incoming_varargs_64 (CUMULATIVE_ARGS *cum)
4437{
rtx save_area, mem;
alias_set_type set;
int i, max;

/* GPR size of varargs save area.  */
if (cfun(cfun + 0)->va_list_gpr_size)
  ix86_varargs_gpr_size((cfun + 0)->machine->varargs_gpr_size) = X86_64_REGPARM_MAX6 * UNITS_PER_WORD(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 8 : 4);
else
  ix86_varargs_gpr_size((cfun + 0)->machine->varargs_gpr_size) = 0;

/* FPR size of varargs save area.  We don't need it if we don't pass
   anything in SSE registers.  */
if (TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0) && cfun(cfun + 0)->va_list_fpr_size)
  ix86_varargs_fpr_size((cfun + 0)->machine->varargs_fpr_size) = X86_64_SSE_REGPARM_MAX8 * 16;
else
  ix86_varargs_fpr_size((cfun + 0)->machine->varargs_fpr_size) = 0;

if (! ix86_varargs_gpr_size((cfun + 0)->machine->varargs_gpr_size) && ! ix86_varargs_fpr_size((cfun + 0)->machine->varargs_fpr_size))
  return;

save_area = frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_FRAME_POINTER]);
set = get_varargs_alias_set ();

max = cum->regno + cfun(cfun + 0)->va_list_gpr_size / UNITS_PER_WORD(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 8 : 4);
if (max > X86_64_REGPARM_MAX6)
  max = X86_64_REGPARM_MAX6;

for (i = cum->regno; i < max; i++)
  {
    mem = gen_rtx_MEM (word_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))), save_area, i * UNITS_PER_WORD(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 8 : 4)));
    MEM_NOTRAP_P (mem)(__extension__ ({ __typeof ((mem)) const _rtx = ((mem)); if (
((enum rtx_code) (_rtx)->code) != MEM) rtl_check_failed_flag
 ("MEM_NOTRAP_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4469, __FUNCTION__); _rtx; })->call) = 1;
    set_mem_alias_set (mem, set);
    emit_move_insn (mem,
      gen_rtx_REG (word_mode,
		   x86_64_int_parameter_registers[i]));
  }

if (ix86_varargs_fpr_size((cfun + 0)->machine->varargs_fpr_size))
  {
    machine_mode smode;
    rtx_code_label *label;
    rtx test;

    /* Now emit code to save SSE registers.  The AX parameter contains number
of SSE parameter registers used to call this function, though all we
actually check here is the zero/non-zero status.  */

    label = gen_label_rtx ();
    test = gen_rtx_EQ (VOIDmode, gen_rtx_REG (QImode, AX_REG), const0_rtx)gen_rtx_fmt_ee_stat ((EQ), ((((void) 0, E_VOIDmode))), ((gen_rtx_REG
 ((scalar_int_mode ((scalar_int_mode::from_int) E_QImode)), 0
))), (((const_int_rtx[64]))) );
    emit_jump_insn (gen_cbranchqi4 (test, XEXP (test, 0)(((test)->u.fld[0]).rt_rtx), XEXP (test, 1)(((test)->u.fld[1]).rt_rtx),
		      label));

    /* ??? If !TARGET_SSE_TYPELESS_STORES, would we perform better if
we used movdqa (i.e. TImode) instead?  Perhaps even better would
be if we could determine the real mode of the data, via a hook
into pass_stdarg.  Ignore all that for now.  */
    smode = V4SFmode((void) 0, E_V4SFmode);
    if (crtl(&x_rtl)->stack_alignment_needed < GET_MODE_ALIGNMENT (smode)get_mode_alignment (smode))
crtl(&x_rtl)->stack_alignment_needed = GET_MODE_ALIGNMENT (smode)get_mode_alignment (smode);

    max = cum->sse_regno + cfun(cfun + 0)->va_list_fpr_size / 16;
    if (max > X86_64_SSE_REGPARM_MAX8)
max = X86_64_SSE_REGPARM_MAX8;

    for (i = cum->sse_regno; i < max; ++i)
{
 mem = 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))), save_area,
	       i * 16 + ix86_varargs_gpr_size((cfun + 0)->machine->varargs_gpr_size));
 mem = gen_rtx_MEM (smode, mem);
 MEM_NOTRAP_P (mem)(__extension__ ({ __typeof ((mem)) const _rtx = ((mem)); if (
((enum rtx_code) (_rtx)->code) != MEM) rtl_check_failed_flag
 ("MEM_NOTRAP_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4508, __FUNCTION__); _rtx; })->call) = 1;
 set_mem_alias_set (mem, set);
 set_mem_align (mem, GET_MODE_ALIGNMENT (smode)get_mode_alignment (smode));

 emit_move_insn (mem, gen_rtx_REG (smode, GET_SSE_REGNO (i)((i) < 8 ? 20 + (i) : (i) < 16 ? 44 + (i) - 8 : 52 + (i
) - 16)));
}

    emit_label (label);
  }
4517}

4519static void
4520setup_incoming_varargs_ms_64 (CUMULATIVE_ARGS *cum)
4521{
alias_set_type set = get_varargs_alias_set ();
int i;

/* Reset to zero, as there might be a sysv vaarg used
   before.  */
ix86_varargs_gpr_size((cfun + 0)->machine->varargs_gpr_size) = 0;
ix86_varargs_fpr_size((cfun + 0)->machine->varargs_fpr_size) = 0;

for (i = cum->regno; i < X86_64_MS_REGPARM_MAX4; i++)
  {
    rtx reg, mem;

    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))), virtual_incoming_args_rtx((this_target_rtl->x_global_rtl)[GR_VIRTUAL_INCOMING_ARGS]
),
			i * UNITS_PER_WORD(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 8 : 4)));
    MEM_NOTRAP_P (mem)(__extension__ ({ __typeof ((mem)) const _rtx = ((mem)); if (
((enum rtx_code) (_rtx)->code) != MEM) rtl_check_failed_flag
 ("MEM_NOTRAP_P", _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4537, __FUNCTION__); _rtx; })->call) = 1;
    set_mem_alias_set (mem, set);

    reg = gen_rtx_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))), x86_64_ms_abi_int_parameter_registers[i]);
    emit_move_insn (mem, reg);
  }
4543}

4545static void
4546ix86_setup_incoming_varargs (cumulative_args_t cum_v,
	     const function_arg_info &arg,
	     int *, int no_rtl)
4549{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
CUMULATIVE_ARGS next_cum;
tree fntype;

/* This argument doesn't appear to be used anymore.  Which is good,
   because the old code here didn't suppress rtl generation.  */
gcc_assert (!no_rtl)((void)(!(!no_rtl) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4556, __FUNCTION__), 0 : 0));

if (!TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  return;

fntype = TREE_TYPE (current_function_decl)((contains_struct_check ((current_function_decl), (TS_TYPED),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4561, __FUNCTION__))->typed.type);

/* For varargs, we do not want to skip the dummy va_dcl argument.
   For stdargs, we do want to skip the last named argument.  */
next_cum = *cum;
if (!TYPE_NO_NAMED_ARGS_STDARG_P (TREE_TYPE (current_function_decl))((tree_class_check ((((contains_struct_check ((current_function_decl
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4566, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4566, __FUNCTION__))->type_common.no_named_args_stdarg_p
)
    && stdarg_p (fntype))
  ix86_function_arg_advance (pack_cumulative_args (&next_cum), arg);

if (cum->call_abi == MS_ABI)
  setup_incoming_varargs_ms_64 (&next_cum);
else
  setup_incoming_varargs_64 (&next_cum);
4574}

4576/* Checks if TYPE is of kind va_list char *.  */

4578static bool
4579is_va_list_char_pointer (tree type)
4580{
tree canonic;

/* For 32-bit it is always true.  */
if (!TARGET_64BIT((global_options.x_ix86_isa_flags & (1UL << 1)) != 0
))
  return true;
canonic = ix86_canonical_va_list_type (type);
return (canonic == ms_va_list_type_node
        || (ix86_abiglobal_options.x_ix86_abi == MS_ABI && canonic == va_list_type_nodeglobal_trees[TI_VA_LIST_TYPE]));
4589}

4591/* Implement va_start.  */

4593static void
4594ix86_va_start (tree valist, rtx nextarg)
4595{
HOST_WIDE_INTlong words, n_gpr, n_fpr;
tree f_gpr, f_fpr, f_ovf, f_sav;
tree gpr, fpr, ovf, sav, t;
tree type;
rtx ovf_rtx;

if (flag_split_stackglobal_options.x_flag_split_stack
    && cfun(cfun + 0)->machine->split_stack_varargs_pointer == NULL_RTX(rtx) 0)
  {
    unsigned int scratch_regno;

    /* When we are splitting the stack, we can't refer to the stack
arguments using internal_arg_pointer, because they may be on
the old stack.  The split stack prologue will arrange to
leave a pointer to the old stack arguments in a scratch
register, which we here copy to a pseudo-register.  The split
stack prologue can't set the pseudo-register directly because
it (the prologue) runs before any registers have been saved.  */

    scratch_regno = split_stack_prologue_scratch_regno ();
    if (scratch_regno != INVALID_REGNUM(~(unsigned int) 0))
{
 rtx reg;
 rtx_insn *seq;

 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))));
 cfun(cfun + 0)->machine->split_stack_varargs_pointer = reg;

 start_sequence ();
 emit_move_insn (reg, gen_rtx_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))), scratch_regno));
 seq = get_insns ();
 end_sequence ();

 push_topmost_sequence ();
 emit_insn_after (seq, entry_of_function ());
 pop_topmost_sequence ();
}
  }

/* Only 64bit target needs something special.  */
if (is_va_list_char_pointer (TREE_TYPE (valist)((contains_struct_check ((valist), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4636, __FUNCTION__))->typed.type)))
  {
    if (cfun(cfun + 0)->machine->split_stack_varargs_pointer == NULL_RTX(rtx) 0)
std_expand_builtin_va_start (valist, nextarg);
    else
{
 rtx va_r, next;

 va_r = expand_expr (valist, NULL_RTX(rtx) 0, VOIDmode((void) 0, E_VOIDmode), EXPAND_WRITE);
 next = expand_binop (ptr_mode, add_optab,
	       cfun(cfun + 0)->machine->split_stack_varargs_pointer,
	       crtl(&x_rtl)->args.arg_offset_rtx,
	       NULL_RTX(rtx) 0, 0, OPTAB_LIB_WIDEN);
 convert_move (va_r, next, 0);
}
    return;
  }

f_gpr = TYPE_FIELDS (TREE_TYPE (sysv_va_list_type_node))((tree_check3 ((((contains_struct_check ((sysv_va_list_type_node
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4654, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4654, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values);
f_fpr = DECL_CHAIN (f_gpr)(((contains_struct_check (((contains_struct_check ((f_gpr), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4655, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4655, __FUNCTION__))->common.chain));
f_ovf = DECL_CHAIN (f_fpr)(((contains_struct_check (((contains_struct_check ((f_fpr), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4656, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4656, __FUNCTION__))->common.chain));
f_sav = DECL_CHAIN (f_ovf)(((contains_struct_check (((contains_struct_check ((f_ovf), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4657, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4657, __FUNCTION__))->common.chain));

valist = build_simple_mem_ref (valist)build_simple_mem_ref_loc (((location_t) 0), valist);
TREE_TYPE (valist)((contains_struct_check ((valist), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4660, __FUNCTION__))->typed.type) = TREE_TYPE (sysv_va_list_type_node)((contains_struct_check ((sysv_va_list_type_node), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4660, __FUNCTION__))->typed.type);
/* The following should be folded into the MEM_REF offset.  */
gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr)((contains_struct_check ((f_gpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4662, __FUNCTION__))->typed.type), unshare_expr (valist),
f_gpr, NULL_TREE(tree) __null);
fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr)((contains_struct_check ((f_fpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4664, __FUNCTION__))->typed.type), unshare_expr (valist),
f_fpr, NULL_TREE(tree) __null);
ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf)((contains_struct_check ((f_ovf), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4666, __FUNCTION__))->typed.type), unshare_expr (valist),
f_ovf, NULL_TREE(tree) __null);
sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav)((contains_struct_check ((f_sav), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4668, __FUNCTION__))->typed.type), unshare_expr (valist),
f_sav, NULL_TREE(tree) __null);

/* Count number of gp and fp argument registers used.  */
words = crtl(&x_rtl)->args.info.words;
n_gpr = crtl(&x_rtl)->args.info.regno;
n_fpr = crtl(&x_rtl)->args.info.sse_regno;

if (cfun(cfun + 0)->va_list_gpr_size)
  {
    type = TREE_TYPE (gpr)((contains_struct_check ((gpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4678, __FUNCTION__))->typed.type);
    t = build2 (MODIFY_EXPR, type,
  gpr, build_int_cst (type, n_gpr * 8));
    TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4681, __FUNCTION__))->base.side_effects_flag) = 1;
    expand_expr (t, const0_rtx(const_int_rtx[64]), VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);
  }

if (TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0) && cfun(cfun + 0)->va_list_fpr_size)
  {
    type = TREE_TYPE (fpr)((contains_struct_check ((fpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4687, __FUNCTION__))->typed.type);
    t = build2 (MODIFY_EXPR, type, fpr,
  build_int_cst (type, n_fpr * 16 + 8*X86_64_REGPARM_MAX6));
    TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4690, __FUNCTION__))->base.side_effects_flag) = 1;
    expand_expr (t, const0_rtx(const_int_rtx[64]), VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);
  }

/* Find the overflow area.  */
type = TREE_TYPE (ovf)((contains_struct_check ((ovf), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4695, __FUNCTION__))->typed.type);
if (cfun(cfun + 0)->machine->split_stack_varargs_pointer == NULL_RTX(rtx) 0)
  ovf_rtx = crtl(&x_rtl)->args.internal_arg_pointer;
else
  ovf_rtx = cfun(cfun + 0)->machine->split_stack_varargs_pointer;
t = make_tree (type, ovf_rtx);
if (words != 0)
  t = fold_build_pointer_plus_hwi (t, words * UNITS_PER_WORD)fold_build_pointer_plus_hwi_loc (((location_t) 0), t, words *
 (((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 8 : 4));

t = build2 (MODIFY_EXPR, type, ovf, t);
TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4705, __FUNCTION__))->base.side_effects_flag) = 1;
expand_expr (t, const0_rtx(const_int_rtx[64]), VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);

if (ix86_varargs_gpr_size((cfun + 0)->machine->varargs_gpr_size) || ix86_varargs_fpr_size((cfun + 0)->machine->varargs_fpr_size))
  {
    /* Find the register save area.
Prologue of the function save it right above stack frame.  */
    type = TREE_TYPE (sav)((contains_struct_check ((sav), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4712, __FUNCTION__))->typed.type);
    t = make_tree (type, frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_FRAME_POINTER]));
    if (!ix86_varargs_gpr_size((cfun + 0)->machine->varargs_gpr_size))
t = fold_build_pointer_plus_hwi (t, -8 * X86_64_REGPARM_MAX)fold_build_pointer_plus_hwi_loc (((location_t) 0), t, -8 * 6);

    t = build2 (MODIFY_EXPR, type, sav, t);
    TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4718, __FUNCTION__))->base.side_effects_flag) = 1;
    expand_expr (t, const0_rtx(const_int_rtx[64]), VOIDmode((void) 0, E_VOIDmode), EXPAND_NORMAL);
  }
4721}

4723/* Implement va_arg.  */

4725static tree
4726ix86_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
      gimple_seq *post_p)
4728{
static const int intreg[6] = { 0, 1, 2, 3, 4, 5 };
tree f_gpr, f_fpr, f_ovf, f_sav;
tree gpr, fpr, ovf, sav, t;
int size, rsize;
tree lab_false, lab_over = NULL_TREE(tree) __null;
tree addr, t2;
rtx container;
int indirect_p = 0;
tree ptrtype;
machine_mode nat_mode;
unsigned int arg_boundary;
unsigned int type_align;

/* Only 64bit target needs something special.  */
if (is_va_list_char_pointer (TREE_TYPE (valist)((contains_struct_check ((valist), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4743, __FUNCTION__))->typed.type)))
  return std_gimplify_va_arg_expr (valist, type, pre_p, post_p);

f_gpr = TYPE_FIELDS (TREE_TYPE (sysv_va_list_type_node))((tree_check3 ((((contains_struct_check ((sysv_va_list_type_node
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4746, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4746, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values);
f_fpr = DECL_CHAIN (f_gpr)(((contains_struct_check (((contains_struct_check ((f_gpr), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4747, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4747, __FUNCTION__))->common.chain));
f_ovf = DECL_CHAIN (f_fpr)(((contains_struct_check (((contains_struct_check ((f_fpr), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4748, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4748, __FUNCTION__))->common.chain));
f_sav = DECL_CHAIN (f_ovf)(((contains_struct_check (((contains_struct_check ((f_ovf), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4749, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4749, __FUNCTION__))->common.chain));

gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr)((contains_struct_check ((f_gpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4751, __FUNCTION__))->typed.type),
valist, f_gpr, NULL_TREE(tree) __null);

fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr)((contains_struct_check ((f_fpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4754, __FUNCTION__))->typed.type), valist, f_fpr, NULL_TREE(tree) __null);
ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf)((contains_struct_check ((f_ovf), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4755, __FUNCTION__))->typed.type), valist, f_ovf, NULL_TREE(tree) __null);
sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav)((contains_struct_check ((f_sav), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4756, __FUNCTION__))->typed.type), valist, f_sav, NULL_TREE(tree) __null);

indirect_p = pass_va_arg_by_reference (type);
if (indirect_p)
  type = build_pointer_type (type);
size = arg_int_size_in_bytes (type);
rsize = CEIL (size, UNITS_PER_WORD)(((size) + ((((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4)) - 1) / ((((global_options.x_ix86_isa_flags
 & (1UL << 1)) != 0) ? 8 : 4)));

nat_mode = type_natural_mode (type, NULL__null, false);
switch (nat_mode)
  {
  case E_V16HFmode:
  case E_V16BFmode:
  case E_V8SFmode:
  case E_V8SImode:
  case E_V32QImode:
  case E_V16HImode:
  case E_V4DFmode:
  case E_V4DImode:
  case E_V32HFmode:
  case E_V32BFmode:
  case E_V16SFmode:
  case E_V16SImode:
  case E_V64QImode:
  case E_V32HImode:
  case E_V8DFmode:
  case E_V8DImode:
    /* Unnamed 256 and 512bit vector mode parameters are passed on stack.  */
    if (!TARGET_64BIT_MS_ABI(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) && ix86_cfun_abi () == MS_ABI))
{
 container = NULL__null;
 break;
}
    /* FALLTHRU */

  default:
    container = construct_container (nat_mode, TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4792, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (type) : (type)->type_common.mode),
		       type, 0, X86_64_REGPARM_MAX6,
		       X86_64_SSE_REGPARM_MAX8, intreg,
		       0);
    break;
  }

/* Pull the value out of the saved registers.  */

addr = create_tmp_var (ptr_type_nodeglobal_trees[TI_PTR_TYPE], "addr");
type_align = TYPE_ALIGN (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4802, __FUNCTION__))->type_common.align) ? ((unsigned)1)
 << (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4802, __FUNCTION__))->type_common.align) - 1) : 0);

if (container)
  {
    int needed_intregs, needed_sseregs;
    bool need_temp;
    tree int_addr, sse_addr;

    lab_false = create_artificial_label (UNKNOWN_LOCATION((location_t) 0));
    lab_over = create_artificial_label (UNKNOWN_LOCATION((location_t) 0));

    examine_argument (nat_mode, type, 0, &needed_intregs, &needed_sseregs);

    need_temp = (!REG_P (container)(((enum rtx_code) (container)->code) == REG)
   && ((needed_intregs && TYPE_ALIGN (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4816, __FUNCTION__))->type_common.align) ? ((unsigned)1)
 << (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4816, __FUNCTION__))->type_common.align) - 1) : 0) > 64)
       || TYPE_ALIGN (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4817, __FUNCTION__))->type_common.align) ? ((unsigned)1)
 << (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4817, __FUNCTION__))->type_common.align) - 1) : 0) > 128));

    /* In case we are passing structure, verify that it is consecutive block
       on the register save area.  If not we need to do moves.  */
    if (!need_temp && !REG_P (container)(((enum rtx_code) (container)->code) == REG))
{
 /* Verify that all registers are strictly consecutive  */
 if (SSE_REGNO_P (REGNO (XEXP (XVECEXP (container, 0, 0), 0)))(((unsigned long) (((rhs_regno(((((((((container)->u.fld[0
]).rt_rtvec))->elem[0]))->u.fld[0]).rt_rtx))))) - (unsigned
 long) (20) <= (unsigned long) (27) - (unsigned long) (20)
) || ((unsigned long) (((rhs_regno(((((((((container)->u.fld
[0]).rt_rtvec))->elem[0]))->u.fld[0]).rt_rtx))))) - (unsigned
 long) (44) <= (unsigned long) (51) - (unsigned long) (44)
) || ((unsigned long) (((rhs_regno(((((((((container)->u.fld
[0]).rt_rtvec))->elem[0]))->u.fld[0]).rt_rtx))))) - (unsigned
 long) (52) <= (unsigned long) (67) - (unsigned long) (52)
)))
   {
     int i;

     for (i = 0; i < XVECLEN (container, 0)(((((container)->u.fld[0]).rt_rtvec))->num_elem) && !need_temp; i++)
{
  rtx slot = XVECEXP (container, 0, i)(((((container)->u.fld[0]).rt_rtvec))->elem[i]);
  if (REGNO (XEXP (slot, 0))(rhs_regno((((slot)->u.fld[0]).rt_rtx))) != FIRST_SSE_REG20 + (unsigned int) i
      || INTVAL (XEXP (slot, 1))(((((slot)->u.fld[1]).rt_rtx))->u.hwint[0]) != i * 16)
    need_temp = true;
}
   }
 else
   {
     int i;

     for (i = 0; i < XVECLEN (container, 0)(((((container)->u.fld[0]).rt_rtvec))->num_elem) && !need_temp; i++)
{
  rtx slot = XVECEXP (container, 0, i)(((((container)->u.fld[0]).rt_rtvec))->elem[i]);
  if (REGNO (XEXP (slot, 0))(rhs_regno((((slot)->u.fld[0]).rt_rtx))) != (unsigned int) i
      || INTVAL (XEXP (slot, 1))(((((slot)->u.fld[1]).rt_rtx))->u.hwint[0]) != i * 8)
    need_temp = true;
}
   }
}
    if (!need_temp)
{
 int_addr = addr;
 sse_addr = addr;
}
    else
{
 int_addr = create_tmp_var (ptr_type_nodeglobal_trees[TI_PTR_TYPE], "int_addr");
 sse_addr = create_tmp_var (ptr_type_nodeglobal_trees[TI_PTR_TYPE], "sse_addr");
}

    /* First ensure that we fit completely in registers.  */
    if (needed_intregs)
{
 t = build_int_cst (TREE_TYPE (gpr)((contains_struct_check ((gpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4863, __FUNCTION__))->typed.type),
	     (X86_64_REGPARM_MAX6 - needed_intregs + 1) * 8);
 t = build2 (GE_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], gpr, t);
 t2 = build1 (GOTO_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE], lab_false);
 t = build3 (COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE], t, t2, NULL_TREE(tree) __null);
 gimplify_and_add (t, pre_p);
}
    if (needed_sseregs)
{
 t = build_int_cst (TREE_TYPE (fpr)((contains_struct_check ((fpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4872, __FUNCTION__))->typed.type),
	     (X86_64_SSE_REGPARM_MAX8 - needed_sseregs + 1) * 16
	     + X86_64_REGPARM_MAX6 * 8);
 t = build2 (GE_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], fpr, t);
 t2 = build1 (GOTO_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE], lab_false);
 t = build3 (COND_EXPR, void_type_nodeglobal_trees[TI_VOID_TYPE], t, t2, NULL_TREE(tree) __null);
 gimplify_and_add (t, pre_p);
}

    /* Compute index to start of area used for integer regs.  */
    if (needed_intregs)
{
 /* int_addr = gpr + sav; */
 t = fold_build_pointer_plus (sav, gpr)fold_build_pointer_plus_loc (((location_t) 0), sav, gpr);
 gimplify_assign (int_addr, t, pre_p);
}
    if (needed_sseregs)
{
 /* sse_addr = fpr + sav; */
 t = fold_build_pointer_plus (sav, fpr)fold_build_pointer_plus_loc (((location_t) 0), sav, fpr);
 gimplify_assign (sse_addr, t, pre_p);
}
    if (need_temp)
{
 int i, prev_size = 0;
 tree temp = create_tmp_var (type, "va_arg_tmp");
 TREE_ADDRESSABLE (temp)((temp)->base.addressable_flag) = 1;

 /* addr = &temp; */
 t = build1 (ADDR_EXPR, build_pointer_type (type), temp);
 gimplify_assign (addr, t, pre_p);

 for (i = 0; i < XVECLEN (container, 0)(((((container)->u.fld[0]).rt_rtvec))->num_elem); i++)
   {
     rtx slot = XVECEXP (container, 0, i)(((((container)->u.fld[0]).rt_rtvec))->elem[i]);
     rtx reg = XEXP (slot, 0)(((slot)->u.fld[0]).rt_rtx);
     machine_mode mode = GET_MODE (reg)((machine_mode) (reg)->mode);
     tree piece_type;
     tree addr_type;
     tree daddr_type;
     tree src_addr, src;
     int src_offset;
     tree dest_addr, dest;
     int cur_size = GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]);

     gcc_assert (prev_size <= INTVAL (XEXP (slot, 1)))((void)(!(prev_size <= (((((slot)->u.fld[1]).rt_rtx))->
u.hwint[0])) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4917, __FUNCTION__), 0 : 0));
     prev_size = INTVAL (XEXP (slot, 1))(((((slot)->u.fld[1]).rt_rtx))->u.hwint[0]);
     if (prev_size + cur_size > size)
{
  cur_size = size - prev_size;
  unsigned int nbits = cur_size * BITS_PER_UNIT(8);
  if (!int_mode_for_size (nbits, 1).exists (&mode))
    mode = QImode(scalar_int_mode ((scalar_int_mode::from_int) E_QImode));
}
     piece_type = lang_hooks.types.type_for_mode (mode, 1);
     if (mode == GET_MODE (reg)((machine_mode) (reg)->mode))
addr_type = build_pointer_type (piece_type);
     else
addr_type = build_pointer_type_for_mode (piece_type, ptr_mode,
					 true);
     daddr_type = build_pointer_type_for_mode (piece_type, ptr_mode,
					true);

     if (SSE_REGNO_P (REGNO (reg))(((unsigned long) (((rhs_regno(reg)))) - (unsigned long) (20)
 <= (unsigned long) (27) - (unsigned long) (20)) || ((unsigned
 long) (((rhs_regno(reg)))) - (unsigned long) (44) <= (unsigned
 long) (51) - (unsigned long) (44)) || ((unsigned long) (((rhs_regno
(reg)))) - (unsigned long) (52) <= (unsigned long) (67) - (
unsigned long) (52))))
{
  src_addr = sse_addr;
  src_offset = (REGNO (reg)(rhs_regno(reg)) - FIRST_SSE_REG20) * 16;
}
     else
{
  src_addr = int_addr;
  src_offset = REGNO (reg)(rhs_regno(reg)) * 8;
}
     src_addr = fold_convert (addr_type, src_addr)fold_convert_loc (((location_t) 0), addr_type, src_addr);
     src_addr = fold_build_pointer_plus_hwi (src_addr, src_offset)fold_build_pointer_plus_hwi_loc (((location_t) 0), src_addr, src_offset
);

     dest_addr = fold_convert (daddr_type, addr)fold_convert_loc (((location_t) 0), daddr_type, addr);
     dest_addr = fold_build_pointer_plus_hwi (dest_addr, prev_size)fold_build_pointer_plus_hwi_loc (((location_t) 0), dest_addr,
 prev_size);
     if (cur_size == GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]))
{
  src = build_va_arg_indirect_ref (src_addr);
  dest = build_va_arg_indirect_ref (dest_addr);

  gimplify_assign (dest, src, pre_p);
}
     else
{
  tree copy
    = build_call_expr (builtin_decl_implicit (BUILT_IN_MEMCPY),
		       3, dest_addr, src_addr,
		       size_int (cur_size)size_int_kind (cur_size, stk_sizetype));
  gimplify_and_add (copy, pre_p);
}
     prev_size += cur_size;
   }
}

    if (needed_intregs)
{
 t = build2 (PLUS_EXPR, TREE_TYPE (gpr)((contains_struct_check ((gpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4971, __FUNCTION__))->typed.type), gpr,
      build_int_cst (TREE_TYPE (gpr)((contains_struct_check ((gpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4972, __FUNCTION__))->typed.type), needed_intregs * 8));
 gimplify_assign (gpr, t, pre_p);
 /* The GPR save area guarantees only 8-byte alignment.  */
 if (!need_temp)
   type_align = MIN (type_align, 64)((type_align) < (64) ? (type_align) : (64));
}

    if (needed_sseregs)
{
 t = build2 (PLUS_EXPR, TREE_TYPE (fpr)((contains_struct_check ((fpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4981, __FUNCTION__))->typed.type), fpr,
      build_int_cst (TREE_TYPE (fpr)((contains_struct_check ((fpr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 4982, __FUNCTION__))->typed.type), needed_sseregs * 16));
 gimplify_assign (unshare_expr (fpr), t, pre_p);
}

    gimple_seq_add_stmt (pre_p, gimple_build_goto (lab_over));

    gimple_seq_add_stmt (pre_p, gimple_build_label (lab_false));
  }

/* ... otherwise out of the overflow area.  */

/* When we align parameter on stack for caller, if the parameter
   alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
   aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
   here with caller.  */
arg_boundary = ix86_function_arg_boundary (VOIDmode((void) 0, E_VOIDmode), type);
if ((unsigned int) arg_boundary > MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8))
  arg_boundary = MAX_SUPPORTED_STACK_ALIGNMENT(((unsigned int) 1 << 28) * 8);

/* Care for on-stack alignment if needed.  */
if (arg_boundary <= 64 || size == 0)
  t = ovf;
else
  {
    HOST_WIDE_INTlong align = arg_boundary / 8;
    t = fold_build_pointer_plus_hwi (ovf, align - 1)fold_build_pointer_plus_hwi_loc (((location_t) 0), ovf, align
 - 1);
    t = build2 (BIT_AND_EXPR, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5008, __FUNCTION__))->typed.type), t,
  build_int_cst (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5009, __FUNCTION__))->typed.type), -align));
  }

gimplify_expr (&t, pre_p, NULL__null, is_gimple_val, fb_rvalue);
gimplify_assign (addr, t, pre_p);

t = fold_build_pointer_plus_hwi (t, rsize * UNITS_PER_WORD)fold_build_pointer_plus_hwi_loc (((location_t) 0), t, rsize *
 (((global_options.x_ix86_isa_flags & (1UL << 1)) !=
 0) ? 8 : 4));
gimplify_assign (unshare_expr (ovf), t, pre_p);

if (container)
  gimple_seq_add_stmt (pre_p, gimple_build_label (lab_over));

type = build_aligned_type (type, type_align);
ptrtype = build_pointer_type_for_mode (type, ptr_mode, true);
addr = fold_convert (ptrtype, addr)fold_convert_loc (((location_t) 0), ptrtype, addr);

if (indirect_p)
  addr = build_va_arg_indirect_ref (addr);
return build_va_arg_indirect_ref (addr);
5028}
5029
5030/* Return true if OPNUM's MEM should be matched
 in movabs* patterns.  */

5033bool
5034ix86_check_movabs (rtx insn, int opnum)
5035{
rtx set, mem;

set = PATTERN (insn);
if (GET_CODE (set)((enum rtx_code) (set)->code) == PARALLEL)
  set = XVECEXP (set, 0, 0)(((((set)->u.fld[0]).rt_rtvec))->elem[0]);
gcc_assert (GET_CODE (set) == SET)((void)(!(((enum rtx_code) (set)->code) == SET) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5041, __FUNCTION__), 0 : 0));
mem = XEXP (set, opnum)(((set)->u.fld[opnum]).rt_rtx);
while (SUBREG_P (mem)(((enum rtx_code) (mem)->code) == SUBREG))
  mem = SUBREG_REG (mem)(((mem)->u.fld[0]).rt_rtx);
gcc_assert (MEM_P (mem))((void)(!((((enum rtx_code) (mem)->code) == MEM)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5045, __FUNCTION__), 0 : 0));
return volatile_ok || !MEM_VOLATILE_P (mem)(__extension__ ({ __typeof ((mem)) const _rtx = ((mem)); if (
((enum rtx_code) (_rtx)->code) != MEM && ((enum rtx_code
) (_rtx)->code) != ASM_OPERANDS && ((enum rtx_code
) (_rtx)->code) != ASM_INPUT) rtl_check_failed_flag ("MEM_VOLATILE_P"
, _rtx, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5046, __FUNCTION__); _rtx; })->volatil);
5047}

5049/* Return false if INSN contains a MEM with a non-default address space.  */
5050bool
5051ix86_check_no_addr_space (rtx insn)
5052{
subrtx_var_iterator::array_type array;
FOR_EACH_SUBRTX_VAR (iter, array, PATTERN (insn), ALL)for (subrtx_var_iterator iter (array, PATTERN (insn), rtx_all_subrtx_bounds
); !iter.at_end (); iter.next ())
  {
    rtx x = *iter;
    if (MEM_P (x)(((enum rtx_code) (x)->code) == MEM) && !ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (x))(((get_mem_attrs (x)->addrspace)) == 0))
return false;
  }
return true;
5061}
5062
5063/* Initialize the table of extra 80387 mathematical constants.  */

5065static void
5066init_ext_80387_constants (void)
5067{
static const char * cst[5] =
{
  "0.3010299956639811952256464283594894482",  /* 0: fldlg2  */
  "0.6931471805599453094286904741849753009",  /* 1: fldln2  */
  "1.4426950408889634073876517827983434472",  /* 2: fldl2e  */
  "3.3219280948873623478083405569094566090",  /* 3: fldl2t  */
  "3.1415926535897932385128089594061862044",  /* 4: fldpi   */
};
int i;

for (i = 0; i < 5; i++)
  {
    real_from_string (&ext_80387_constants_table[i], cst[i]);
    /* Ensure each constant is rounded to XFmode precision.  */
    real_convert (&ext_80387_constants_table[i],
    XFmode(scalar_float_mode ((scalar_float_mode::from_int) E_XFmode)), &ext_80387_constants_table[i]);
  }

ext_80387_constants_init = 1;
5087}

5089/* Return non-zero if the constant is something that
 can be loaded with a special instruction.  */

5092int
5093standard_80387_constant_p (rtx x)
5094{
machine_mode mode = GET_MODE (x)((machine_mode) (x)->mode);

const REAL_VALUE_TYPEstruct real_value *r;

if (!(CONST_DOUBLE_P (x)(((enum rtx_code) (x)->code) == CONST_DOUBLE) && X87_FLOAT_MODE_P (mode)(((global_options.x_target_flags & (1U << 1)) != 0)
 && ((mode) == (scalar_float_mode ((scalar_float_mode
::from_int) E_SFmode)) || (mode) == (scalar_float_mode ((scalar_float_mode
::from_int) E_DFmode)) || (mode) == (scalar_float_mode ((scalar_float_mode
::from_int) E_XFmode))))))
  return -1;

if (x == CONST0_RTX (mode)(const_tiny_rtx[0][(int) (mode)]))
  return 1;
if (x == CONST1_RTX (mode)(const_tiny_rtx[1][(int) (mode)]))
  return 2;

r = CONST_DOUBLE_REAL_VALUE (x)((const struct real_value *) (&(x)->u.rv));

/* For XFmode constants, try to find a special 80387 instruction when
   optimizing for size or on those CPUs that benefit from them.  */
if (mode == XFmode(scalar_float_mode ((scalar_float_mode::from_int) E_XFmode))
    && (optimize_function_for_size_p (cfun(cfun + 0)) || TARGET_EXT_80387_CONSTANTSix86_tune_features[X86_TUNE_EXT_80387_CONSTANTS])
    && !flag_rounding_mathglobal_options.x_flag_rounding_math)
  {
    int i;

    if (! ext_80387_constants_init)
init_ext_80387_constants ();

    for (i = 0; i < 5; i++)
      if (real_identical (r, &ext_80387_constants_table[i]))
 return i + 3;
  }

/* Load of the constant -0.0 or -1.0 will be split as
   fldz;fchs or fld1;fchs sequence.  */
if (real_isnegzero (r))
  return 8;
if (real_identical (r, &dconstm1))
  return 9;

return 0;
5133}

5135/* Return the opcode of the special instruction to be used to load
 the constant X.  */

5138const char *
5139standard_80387_constant_opcode (rtx x)
5140{
switch (standard_80387_constant_p (x))
  {
  case 1:
    return "fldz";
  case 2:
    return "fld1";
  case 3:
    return "fldlg2";
  case 4:
    return "fldln2";
  case 5:
    return "fldl2e";
  case 6:
    return "fldl2t";
  case 7:
    return "fldpi";
  case 8:
  case 9:
    return "#";
  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5161, __FUNCTION__));
  }
5163}

5165/* Return the CONST_DOUBLE representing the 80387 constant that is
 loaded by the specified special instruction.  The argument IDX
 matches the return value from standard_80387_constant_p.  */

5169rtx
5170standard_80387_constant_rtx (int idx)
5171{
int i;

if (! ext_80387_constants_init)
  init_ext_80387_constants ();

switch (idx)
  {
  case 3:
  case 4:
  case 5:
  case 6:
  case 7:
    i = idx - 3;
    break;

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

return const_double_from_real_value (ext_80387_constants_table[i],
		       XFmode(scalar_float_mode ((scalar_float_mode::from_int) E_XFmode)));
5193}

5195/* Return 1 if X is all bits 0, 2 if X is all bits 1
 and 3 if X is all bits 1 with zero extend
 in supported SSE/AVX vector mode.  */

5199int
5200standard_sse_constant_p (rtx x, machine_mode pred_mode)
5201{
machine_mode mode;

if (!TARGET_SSE((global_options.x_ix86_isa_flags & (1UL << 50)) !=
 0))
  return 0;

mode = GET_MODE (x)((machine_mode) (x)->mode);

if (x == const0_rtx(const_int_rtx[64]) || const0_operand (x, mode))
  return 1;

if (x == constm1_rtx(const_int_rtx[64 -1])
    || vector_all_ones_operand (x, mode)
    || ((GET_MODE_CLASS (mode)((enum mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT
  || GET_MODE_CLASS (pred_mode)((enum mode_class) mode_class[pred_mode]) == MODE_VECTOR_FLOAT)
 && float_vector_all_ones_operand (x, mode)))
  {
    /* VOIDmode integer constant, get mode from the predicate.  */
    if (mode == VOIDmode((void) 0, E_VOIDmode))
mode = pred_mode;

    switch (GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]))
{
case 64:
 if (TARGET_AVX512F((global_options.x_ix86_isa_flags & (1UL << 15)) !=
 0))
   return 2;
 break;
case 32:
 if (TARGET_AVX2((global_options.x_ix86_isa_flags & (1UL << 9)) != 0
))
   return 2;
 break;
case 16:
 if (TARGET_SSE2((global_options.x_ix86_isa_flags & (1UL << 51)) !=
 0))
   return 2;
 break;
case 0:
 /* VOIDmode */
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5238, __FUNCTION__));
default:
 break;
}
  }

if (vector_all_ones_zero_extend_half_operand (x, mode)
    || vector_all_ones_zero_extend_quarter_operand (x, mode))
  return 3;

return 0;
5249}

5251/* Return the opcode of the special instruction to be used to load
 the constant operands[1] into operands[0].  */

5254const char *
5255standard_sse_constant_opcode (rtx_insn *insn, rtx *operands)
5256{
machine_mode mode;
rtx x = operands[1];

gcc_assert (TARGET_SSE)((void)(!(((global_options.x_ix86_isa_flags & (1UL <<
 50)) != 0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5260, __FUNCTION__), 0 : 0));

mode = GET_MODE (x)((machine_mode) (x)->mode);

if (x == const0_rtx(const_int_rtx[64]) || const0_operand (x, mode))
  {
    switch (get_attr_mode (insn))
{
case MODE_TI:
 if (!EXT_REX_SSE_REG_P (operands[0])((((enum rtx_code) (operands[0])->code) == REG) &&
 ((unsigned long) (((rhs_regno(operands[0])))) - (unsigned long
) (52) <= (unsigned long) (67) - (unsigned long) (52))))
   return "%vpxor\t%0, %d0";
 /* FALLTHRU */
case MODE_XI:
case MODE_OI:
 if (EXT_REX_SSE_REG_P (operands[0])((((enum rtx_code) (operands[0])->code) == REG) &&
 ((unsigned long) (((rhs_regno(operands[0])))) - (unsigned long
) (52) <= (unsigned long) (67) - (unsigned long) (52))))
   return (TARGET_AVX512VL((global_options.x_ix86_isa_flags & (1UL << 20)) !=
 0)
    ? "vpxord\t%x0, %x0, %x0"
    : "vpxord\t%g0, %g0, %g0");
 return "vpxor\t%x0, %x0, %x0";

case MODE_V2DF:
 if (!EXT_REX_SSE_REG_P (operands[0])((((enum rtx_code) (operands[0])->code) == REG) &&
 ((unsigned long) (((rhs_regno(operands[0])))) - (unsigned long
) (52) <= (unsigned long) (67) - (unsigned long) (52))))
   return "%vxorpd\t%0, %d0";
 /* FALLTHRU */
case MODE_V8DF:
case MODE_V4DF:
 if (!EXT_REX_SSE_REG_P (operands[0])((((enum rtx_code) (operands[0])->code) == REG) &&
 ((unsigned long) (((rhs_regno(operands[0])))) - (unsigned long
) (52) <= (unsigned long) (67) - (unsigned long) (52))))
   return "vxorpd\t%x0, %x0, %x0";
 else if (TARGET_AVX512DQ((global_options.x_ix86_isa_flags & (1UL << 13)) !=
 0))
   return (TARGET_AVX512VL((global_options.x_ix86_isa_flags & (1UL << 20)) !=
 0)
    ? "vxorpd\t%x0, %x0, %x0"
    : "vxorpd\t%g0, %g0, %g0");
 else
   return (TARGET_AVX512VL((global_options.x_ix86_isa_flags & (1UL << 20)) !=
 0)
    ? "vpxorq\t%x0, %x0, %x0"
    : "vpxorq\t%g0, %g0, %g0");

case MODE_V4SF:
 if (!EXT_REX_SSE_REG_P (operands[0])((((enum rtx_code) (operands[0])->code) == REG) &&
 ((unsigned long) (((rhs_regno(operands[0])))) - (unsigned long
) (52) <= (unsigned long) (67) - (unsigned long) (52))))
   return "%vxorps\t%0, %d0";
 /* FALLTHRU */
case MODE_V16SF:
case MODE_V8SF:
 if (!EXT_REX_SSE_REG_P (operands[0])((((enum rtx_code) (operands[0])->code) == REG) &&
 ((unsigned long) (((rhs_regno(operands[0])))) - (unsigned long
) (52) <= (unsigned long) (67) - (unsigned long) (52))))
   return "vxorps\t%x0, %x0, %x0";
 else if (TARGET_AVX512DQ((global_options.x_ix86_isa_flags & (1UL << 13)) !=
 0))
   return (TARGET_AVX512VL((global_options.x_ix86_isa_flags & (1UL << 20)) !=
 0)
    ? "vxorps\t%x0, %x0, %x0"
    : "vxorps\t%g0, %g0, %g0");
 else
   return (TARGET_AVX512VL((global_options.x_ix86_isa_flags & (1UL << 20)) !=
 0)
    ? "vpxord\t%x0, %x0, %x0"
    : "vpxord\t%g0, %g0, %g0");

default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5315, __FUNCTION__));
}
  }
else if (x == constm1_rtx(const_int_rtx[64 -1])
  || vector_all_ones_operand (x, mode)
  || (GET_MODE_CLASS (mode)((enum mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT
      && float_vector_all_ones_operand (x, mode)))
  {
    enum attr_mode insn_mode = get_attr_mode (insn);
    
    switch (insn_mode)
{
case MODE_XI:
case MODE_V8DF:
case MODE_V16SF:
 gcc_assert (TARGET_AVX512F)((void)(!(((global_options.x_ix86_isa_flags & (1UL <<
 15)) != 0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5330, __FUNCTION__), 0 : 0));
 return "vpternlogd\t{$0xFF, %g0, %g0, %g0|%g0, %g0, %g0, 0xFF}";

case MODE_OI:
case MODE_V4DF:
case MODE_V8SF:
 gcc_assert (TARGET_AVX2)((void)(!(((global_options.x_ix86_isa_flags & (1UL <<
 9)) != 0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5336, __FUNCTION__), 0 : 0));
 /* FALLTHRU */
case MODE_TI:
case MODE_V2DF:
case MODE_V4SF:
 gcc_assert (TARGET_SSE2)((void)(!(((global_options.x_ix86_isa_flags & (1UL <<
 51)) != 0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5341, __FUNCTION__), 0 : 0));
 if (!EXT_REX_SSE_REG_P (operands[0])((((enum rtx_code) (operands[0])->code) == REG) &&
 ((unsigned long) (((rhs_regno(operands[0])))) - (unsigned long
) (52) <= (unsigned long) (67) - (unsigned long) (52))))
   return (TARGET_AVX((global_options.x_ix86_isa_flags & (1UL << 8)) != 0
)
    ? "vpcmpeqd\t%0, %0, %0"
    : "pcmpeqd\t%0, %0");
 else if (TARGET_AVX512VL((global_options.x_ix86_isa_flags & (1UL << 20)) !=
 0))
   return "vpternlogd\t{$0xFF, %0, %0, %0|%0, %0, %0, 0xFF}";
 else
   return "vpternlogd\t{$0xFF, %g0, %g0, %g0|%g0, %g0, %g0, 0xFF}";

default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5352, __FUNCTION__));
}
 }
else if (vector_all_ones_zero_extend_half_operand (x, mode))
  {
    if (GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]) == 64)
{
 gcc_assert (TARGET_AVX512F)((void)(!(((global_options.x_ix86_isa_flags & (1UL <<
 15)) != 0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5359, __FUNCTION__), 0 : 0));
 return "vpcmpeqd \t %t0, %t0, %t0";
}
    else if (GET_MODE_SIZE (mode)((unsigned short) mode_to_bytes (mode).coeffs[0]) == 32)
{
 gcc_assert (TARGET_AVX)((void)(!(((global_options.x_ix86_isa_flags & (1UL <<
 8)) != 0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5364, __FUNCTION__), 0 : 0));
 return "vpcmpeqd \t %x0, %x0, %x0";
}
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5367, __FUNCTION__));
  }
else if (vector_all_ones_zero_extend_quarter_operand (x, mode))
  {
    gcc_assert (TARGET_AVX512F)((void)(!(((global_options.x_ix86_isa_flags & (1UL <<
 15)) != 0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5371, __FUNCTION__), 0 : 0));
    return "vpcmpeqd \t %x0, %x0, %x0";
  }

gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5375, __FUNCTION__));
5376}

5378/* Returns true if INSN can be transformed from a memory load
 to a supported FP constant load.  */

5381bool
5382ix86_standard_x87sse_constant_load_p (const rtx_insn *insn, rtx dst)
5383{
rtx src = find_constant_src (insn);

gcc_assert (REG_P (dst))((void)(!((((enum rtx_code) (dst)->code) == REG)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/config/i386/i386.cc"
, 5386, __FUNCTION__), 0 : 0));

if (src == NULL__null
    || (SSE_REGNO_P (REGNO (dst))(((unsigned long) (((rhs_regno(dst)))) - (unsigned long) (20)
 <= (unsigned long) (27) - (unsigned long) (20)) || ((unsigned
 long) (((rhs_regno(dst)))) - (unsigned long) (44) <= (unsigned
 long) (51) - (unsigned long) (44)) || ((unsigned long) (((rhs_regno
(dst)))) - (unsigned long) (52) <= (unsigned long) (67) - (
unsigned long) (52)))
 && standard_sse_constant_p (src, GET_MODE (dst)((machine_mode) (dst)->mode)) != 1)
    || (STACK_REGNO_P (REG