LCOV - code coverage report
Current view: top level - gcc/config/i386 - i386.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 9071 10383 87.4 %
Date: 2020-03-28 11:57:23 Functions: 365 386 94.6 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Subroutines used for code generation on IA-32.
       2                 :            :    Copyright (C) 1988-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify
       7                 :            : it under the terms of the GNU General Public License as published by
       8                 :            : the Free Software Foundation; either version 3, or (at your option)
       9                 :            : any later version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful,
      12                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            : GNU General Public License for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #define IN_TARGET_CODE 1
      21                 :            : 
      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 "tree-vectorizer.h"
      71                 :            : #include "shrink-wrap.h"
      72                 :            : #include "builtins.h"
      73                 :            : #include "rtl-iter.h"
      74                 :            : #include "tree-iterator.h"
      75                 :            : #include "dbgcnt.h"
      76                 :            : #include "case-cfn-macros.h"
      77                 :            : #include "dojump.h"
      78                 :            : #include "fold-const-call.h"
      79                 :            : #include "tree-vrp.h"
      80                 :            : #include "tree-ssanames.h"
      81                 :            : #include "selftest.h"
      82                 :            : #include "selftest-rtl.h"
      83                 :            : #include "print-rtl.h"
      84                 :            : #include "intl.h"
      85                 :            : #include "ifcvt.h"
      86                 :            : #include "symbol-summary.h"
      87                 :            : #include "ipa-prop.h"
      88                 :            : #include "ipa-fnsummary.h"
      89                 :            : #include "wide-int-bitmask.h"
      90                 :            : #include "tree-vector-builder.h"
      91                 :            : #include "debug.h"
      92                 :            : #include "dwarf2out.h"
      93                 :            : #include "i386-options.h"
      94                 :            : #include "i386-builtins.h"
      95                 :            : #include "i386-expand.h"
      96                 :            : #include "i386-features.h"
      97                 :            : #include "function-abi.h"
      98                 :            : 
      99                 :            : /* This file should be included last.  */
     100                 :            : #include "target-def.h"
     101                 :            : 
     102                 :            : static rtx legitimize_dllimport_symbol (rtx, bool);
     103                 :            : static rtx legitimize_pe_coff_extern_decl (rtx, bool);
     104                 :            : static void ix86_print_operand_address_as (FILE *, rtx, addr_space_t, bool);
     105                 :            : static void ix86_emit_restore_reg_using_pop (rtx);
     106                 :            : 
     107                 :            : 
     108                 :            : #ifndef CHECK_STACK_LIMIT
     109                 :            : #define CHECK_STACK_LIMIT (-1)
     110                 :            : #endif
     111                 :            : 
     112                 :            : /* Return index of given mode in mult and division cost tables.  */
     113                 :            : #define MODE_INDEX(mode)                                        \
     114                 :            :   ((mode) == QImode ? 0                                         \
     115                 :            :    : (mode) == HImode ? 1                                       \
     116                 :            :    : (mode) == SImode ? 2                                       \
     117                 :            :    : (mode) == DImode ? 3                                       \
     118                 :            :    : 4)
     119                 :            : 
     120                 :            : 
     121                 :            : /* Set by -mtune.  */
     122                 :            : const struct processor_costs *ix86_tune_cost = NULL;
     123                 :            : 
     124                 :            : /* Set by -mtune or -Os.  */
     125                 :            : const struct processor_costs *ix86_cost = NULL;
     126                 :            : 
     127                 :            : /* In case the average insn count for single function invocation is
     128                 :            :    lower than this constant, emit fast (but longer) prologue and
     129                 :            :    epilogue code.  */
     130                 :            : #define FAST_PROLOGUE_INSN_COUNT 20
     131                 :            : 
     132                 :            : /* Names for 8 (low), 8 (high), and 16-bit registers, respectively.  */
     133                 :            : static const char *const qi_reg_name[] = QI_REGISTER_NAMES;
     134                 :            : static const char *const qi_high_reg_name[] = QI_HIGH_REGISTER_NAMES;
     135                 :            : static const char *const hi_reg_name[] = HI_REGISTER_NAMES;
     136                 :            : 
     137                 :            : /* Array of the smallest class containing reg number REGNO, indexed by
     138                 :            :    REGNO.  Used by REGNO_REG_CLASS in i386.h.  */
     139                 :            : 
     140                 :            : enum reg_class const regclass_map[FIRST_PSEUDO_REGISTER] =
     141                 :            : {
     142                 :            :   /* ax, dx, cx, bx */
     143                 :            :   AREG, DREG, CREG, BREG,
     144                 :            :   /* si, di, bp, sp */
     145                 :            :   SIREG, DIREG, NON_Q_REGS, NON_Q_REGS,
     146                 :            :   /* FP registers */
     147                 :            :   FP_TOP_REG, FP_SECOND_REG, FLOAT_REGS, FLOAT_REGS,
     148                 :            :   FLOAT_REGS, FLOAT_REGS, FLOAT_REGS, FLOAT_REGS,
     149                 :            :   /* arg pointer, flags, fpsr, frame */
     150                 :            :   NON_Q_REGS, NO_REGS, NO_REGS, NON_Q_REGS,
     151                 :            :   /* SSE registers */
     152                 :            :   SSE_FIRST_REG, SSE_REGS, SSE_REGS, SSE_REGS,
     153                 :            :   SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
     154                 :            :   /* MMX registers */
     155                 :            :   MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS,
     156                 :            :   MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS,
     157                 :            :   /* REX registers */
     158                 :            :   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
     159                 :            :   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
     160                 :            :   /* SSE REX registers */
     161                 :            :   SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
     162                 :            :   SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
     163                 :            :   /* AVX-512 SSE registers */
     164                 :            :   ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS,
     165                 :            :   ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS,
     166                 :            :   ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS,
     167                 :            :   ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS, ALL_SSE_REGS,
     168                 :            :   /* Mask registers.  */
     169                 :            :   ALL_MASK_REGS, MASK_REGS, MASK_REGS, MASK_REGS,
     170                 :            :   MASK_REGS, MASK_REGS, MASK_REGS, MASK_REGS
     171                 :            : };
     172                 :            : 
     173                 :            : /* The "default" register map used in 32bit mode.  */
     174                 :            : 
     175                 :            : int const dbx_register_map[FIRST_PSEUDO_REGISTER] =
     176                 :            : {
     177                 :            :   /* general regs */
     178                 :            :   0, 2, 1, 3, 6, 7, 4, 5,
     179                 :            :   /* fp regs */
     180                 :            :   12, 13, 14, 15, 16, 17, 18, 19,
     181                 :            :   /* arg, flags, fpsr, frame */
     182                 :            :   IGNORED_DWARF_REGNUM, IGNORED_DWARF_REGNUM,
     183                 :            :   IGNORED_DWARF_REGNUM, IGNORED_DWARF_REGNUM,
     184                 :            :   /* SSE */
     185                 :            :   21, 22, 23, 24, 25, 26, 27, 28,
     186                 :            :   /* MMX */
     187                 :            :   29, 30, 31, 32, 33, 34, 35, 36,
     188                 :            :   /* extended integer registers */
     189                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     190                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     191                 :            :   /* extended sse registers */
     192                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     193                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     194                 :            :   /* AVX-512 registers 16-23 */
     195                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     196                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     197                 :            :   /* AVX-512 registers 24-31 */
     198                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     199                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     200                 :            :   /* Mask registers */
     201                 :            :   93, 94, 95, 96, 97, 98, 99, 100
     202                 :            : };
     203                 :            : 
     204                 :            : /* The "default" register map used in 64bit mode.  */
     205                 :            : 
     206                 :            : int const dbx64_register_map[FIRST_PSEUDO_REGISTER] =
     207                 :            : {
     208                 :            :   /* general regs */
     209                 :            :   0, 1, 2, 3, 4, 5, 6, 7,
     210                 :            :   /* fp regs */
     211                 :            :   33, 34, 35, 36, 37, 38, 39, 40,
     212                 :            :   /* arg, flags, fpsr, frame */
     213                 :            :   IGNORED_DWARF_REGNUM, IGNORED_DWARF_REGNUM,
     214                 :            :   IGNORED_DWARF_REGNUM, IGNORED_DWARF_REGNUM,
     215                 :            :   /* SSE */
     216                 :            :   17, 18, 19, 20, 21, 22, 23, 24,
     217                 :            :   /* MMX */
     218                 :            :   41, 42, 43, 44, 45, 46, 47, 48,
     219                 :            :   /* extended integer registers */
     220                 :            :   8, 9, 10, 11, 12, 13, 14, 15,
     221                 :            :   /* extended SSE registers */
     222                 :            :   25, 26, 27, 28, 29, 30, 31, 32,
     223                 :            :   /* AVX-512 registers 16-23 */
     224                 :            :   67, 68, 69, 70, 71, 72, 73, 74,
     225                 :            :   /* AVX-512 registers 24-31 */
     226                 :            :   75, 76, 77, 78, 79, 80, 81, 82,
     227                 :            :   /* Mask registers */
     228                 :            :   118, 119, 120, 121, 122, 123, 124, 125
     229                 :            : };
     230                 :            : 
     231                 :            : /* Define the register numbers to be used in Dwarf debugging information.
     232                 :            :    The SVR4 reference port C compiler uses the following register numbers
     233                 :            :    in its Dwarf output code:
     234                 :            :         0 for %eax (gcc regno = 0)
     235                 :            :         1 for %ecx (gcc regno = 2)
     236                 :            :         2 for %edx (gcc regno = 1)
     237                 :            :         3 for %ebx (gcc regno = 3)
     238                 :            :         4 for %esp (gcc regno = 7)
     239                 :            :         5 for %ebp (gcc regno = 6)
     240                 :            :         6 for %esi (gcc regno = 4)
     241                 :            :         7 for %edi (gcc regno = 5)
     242                 :            :    The following three DWARF register numbers are never generated by
     243                 :            :    the SVR4 C compiler or by the GNU compilers, but SDB on x86/svr4
     244                 :            :    believed these numbers have these meanings.
     245                 :            :         8  for %eip    (no gcc equivalent)
     246                 :            :         9  for %eflags (gcc regno = 17)
     247                 :            :         10 for %trapno (no gcc equivalent)
     248                 :            :    It is not at all clear how we should number the FP stack registers
     249                 :            :    for the x86 architecture.  If the version of SDB on x86/svr4 were
     250                 :            :    a bit less brain dead with respect to floating-point then we would
     251                 :            :    have a precedent to follow with respect to DWARF register numbers
     252                 :            :    for x86 FP registers, but the SDB on x86/svr4 was so completely
     253                 :            :    broken with respect to FP registers that it is hardly worth thinking
     254                 :            :    of it as something to strive for compatibility with.
     255                 :            :    The version of x86/svr4 SDB I had does (partially)
     256                 :            :    seem to believe that DWARF register number 11 is associated with
     257                 :            :    the x86 register %st(0), but that's about all.  Higher DWARF
     258                 :            :    register numbers don't seem to be associated with anything in
     259                 :            :    particular, and even for DWARF regno 11, SDB only seemed to under-
     260                 :            :    stand that it should say that a variable lives in %st(0) (when
     261                 :            :    asked via an `=' command) if we said it was in DWARF regno 11,
     262                 :            :    but SDB still printed garbage when asked for the value of the
     263                 :            :    variable in question (via a `/' command).
     264                 :            :    (Also note that the labels SDB printed for various FP stack regs
     265                 :            :    when doing an `x' command were all wrong.)
     266                 :            :    Note that these problems generally don't affect the native SVR4
     267                 :            :    C compiler because it doesn't allow the use of -O with -g and
     268                 :            :    because when it is *not* optimizing, it allocates a memory
     269                 :            :    location for each floating-point variable, and the memory
     270                 :            :    location is what gets described in the DWARF AT_location
     271                 :            :    attribute for the variable in question.
     272                 :            :    Regardless of the severe mental illness of the x86/svr4 SDB, we
     273                 :            :    do something sensible here and we use the following DWARF
     274                 :            :    register numbers.  Note that these are all stack-top-relative
     275                 :            :    numbers.
     276                 :            :         11 for %st(0) (gcc regno = 8)
     277                 :            :         12 for %st(1) (gcc regno = 9)
     278                 :            :         13 for %st(2) (gcc regno = 10)
     279                 :            :         14 for %st(3) (gcc regno = 11)
     280                 :            :         15 for %st(4) (gcc regno = 12)
     281                 :            :         16 for %st(5) (gcc regno = 13)
     282                 :            :         17 for %st(6) (gcc regno = 14)
     283                 :            :         18 for %st(7) (gcc regno = 15)
     284                 :            : */
     285                 :            : int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER] =
     286                 :            : {
     287                 :            :   /* general regs */
     288                 :            :   0, 2, 1, 3, 6, 7, 5, 4,
     289                 :            :   /* fp regs */
     290                 :            :   11, 12, 13, 14, 15, 16, 17, 18,
     291                 :            :   /* arg, flags, fpsr, frame */
     292                 :            :   IGNORED_DWARF_REGNUM, 9,
     293                 :            :   IGNORED_DWARF_REGNUM, IGNORED_DWARF_REGNUM,
     294                 :            :   /* SSE registers */
     295                 :            :   21, 22, 23, 24, 25, 26, 27, 28,
     296                 :            :   /* MMX registers */
     297                 :            :   29, 30, 31, 32, 33, 34, 35, 36,
     298                 :            :   /* extended integer registers */
     299                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     300                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     301                 :            :   /* extended sse registers */
     302                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     303                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     304                 :            :   /* AVX-512 registers 16-23 */
     305                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     306                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     307                 :            :   /* AVX-512 registers 24-31 */
     308                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     309                 :            :   INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM, INVALID_REGNUM,
     310                 :            :   /* Mask registers */
     311                 :            :   93, 94, 95, 96, 97, 98, 99, 100
     312                 :            : };
     313                 :            : 
     314                 :            : /* Define parameter passing and return registers.  */
     315                 :            : 
     316                 :            : static int const x86_64_int_parameter_registers[6] =
     317                 :            : {
     318                 :            :   DI_REG, SI_REG, DX_REG, CX_REG, R8_REG, R9_REG
     319                 :            : };
     320                 :            : 
     321                 :            : static int const x86_64_ms_abi_int_parameter_registers[4] =
     322                 :            : {
     323                 :            :   CX_REG, DX_REG, R8_REG, R9_REG
     324                 :            : };
     325                 :            : 
     326                 :            : static int const x86_64_int_return_registers[4] =
     327                 :            : {
     328                 :            :   AX_REG, DX_REG, DI_REG, SI_REG
     329                 :            : };
     330                 :            : 
     331                 :            : /* Define the structure for the machine field in struct function.  */
     332                 :            : 
     333                 :            : struct GTY(()) stack_local_entry {
     334                 :            :   unsigned short mode;
     335                 :            :   unsigned short n;
     336                 :            :   rtx rtl;
     337                 :            :   struct stack_local_entry *next;
     338                 :            : };
     339                 :            : 
     340                 :            : /* Which cpu are we scheduling for.  */
     341                 :            : enum attr_cpu ix86_schedule;
     342                 :            : 
     343                 :            : /* Which cpu are we optimizing for.  */
     344                 :            : enum processor_type ix86_tune;
     345                 :            : 
     346                 :            : /* Which instruction set architecture to use.  */
     347                 :            : enum processor_type ix86_arch;
     348                 :            : 
     349                 :            : /* True if processor has SSE prefetch instruction.  */
     350                 :            : unsigned char x86_prefetch_sse;
     351                 :            : 
     352                 :            : /* Preferred alignment for stack boundary in bits.  */
     353                 :            : unsigned int ix86_preferred_stack_boundary;
     354                 :            : 
     355                 :            : /* Alignment for incoming stack boundary in bits specified at
     356                 :            :    command line.  */
     357                 :            : unsigned int ix86_user_incoming_stack_boundary;
     358                 :            : 
     359                 :            : /* Default alignment for incoming stack boundary in bits.  */
     360                 :            : unsigned int ix86_default_incoming_stack_boundary;
     361                 :            : 
     362                 :            : /* Alignment for incoming stack boundary in bits.  */
     363                 :            : unsigned int ix86_incoming_stack_boundary;
     364                 :            : 
     365                 :            : /* Calling abi specific va_list type nodes.  */
     366                 :            : tree sysv_va_list_type_node;
     367                 :            : tree ms_va_list_type_node;
     368                 :            : 
     369                 :            : /* Prefix built by ASM_GENERATE_INTERNAL_LABEL.  */
     370                 :            : char internal_label_prefix[16];
     371                 :            : int internal_label_prefix_len;
     372                 :            : 
     373                 :            : /* Fence to use after loop using movnt.  */
     374                 :            : tree x86_mfence;
     375                 :            : 
     376                 :            : /* Register class used for passing given 64bit part of the argument.
     377                 :            :    These represent classes as documented by the PS ABI, with the exception
     378                 :            :    of SSESF, SSEDF classes, that are basically SSE class, just gcc will
     379                 :            :    use SF or DFmode move instead of DImode to avoid reformatting penalties.
     380                 :            : 
     381                 :            :    Similarly we play games with INTEGERSI_CLASS to use cheaper SImode moves
     382                 :            :    whenever possible (upper half does contain padding).  */
     383                 :            : enum x86_64_reg_class
     384                 :            :   {
     385                 :            :     X86_64_NO_CLASS,
     386                 :            :     X86_64_INTEGER_CLASS,
     387                 :            :     X86_64_INTEGERSI_CLASS,
     388                 :            :     X86_64_SSE_CLASS,
     389                 :            :     X86_64_SSESF_CLASS,
     390                 :            :     X86_64_SSEDF_CLASS,
     391                 :            :     X86_64_SSEUP_CLASS,
     392                 :            :     X86_64_X87_CLASS,
     393                 :            :     X86_64_X87UP_CLASS,
     394                 :            :     X86_64_COMPLEX_X87_CLASS,
     395                 :            :     X86_64_MEMORY_CLASS
     396                 :            :   };
     397                 :            : 
     398                 :            : #define MAX_CLASSES 8
     399                 :            : 
     400                 :            : /* Table of constants used by fldpi, fldln2, etc....  */
     401                 :            : static REAL_VALUE_TYPE ext_80387_constants_table [5];
     402                 :            : static bool ext_80387_constants_init;
     403                 :            : 
     404                 :            : 
     405                 :            : static rtx ix86_function_value (const_tree, const_tree, bool);
     406                 :            : static bool ix86_function_value_regno_p (const unsigned int);
     407                 :            : static unsigned int ix86_function_arg_boundary (machine_mode,
     408                 :            :                                                 const_tree);
     409                 :            : static rtx ix86_static_chain (const_tree, bool);
     410                 :            : static int ix86_function_regparm (const_tree, const_tree);
     411                 :            : static void ix86_compute_frame_layout (void);
     412                 :            : static tree ix86_canonical_va_list_type (tree);
     413                 :            : static unsigned int split_stack_prologue_scratch_regno (void);
     414                 :            : static bool i386_asm_output_addr_const_extra (FILE *, rtx);
     415                 :            : 
     416                 :            : static bool ix86_can_inline_p (tree, tree);
     417                 :            : static unsigned int ix86_minimum_incoming_stack_boundary (bool);
     418                 :            : 
     419                 :            : 
     420                 :            : /* Whether -mtune= or -march= were specified */
     421                 :            : int ix86_tune_defaulted;
     422                 :            : int ix86_arch_specified;
     423                 :            : 
     424                 :            : /* Return true if a red-zone is in use.  We can't use red-zone when
     425                 :            :    there are local indirect jumps, like "indirect_jump" or "tablejump",
     426                 :            :    which jumps to another place in the function, since "call" in the
     427                 :            :    indirect thunk pushes the return address onto stack, destroying
     428                 :            :    red-zone.
     429                 :            : 
     430                 :            :    TODO: If we can reserve the first 2 WORDs, for PUSH and, another
     431                 :            :    for CALL, in red-zone, we can allow local indirect jumps with
     432                 :            :    indirect thunk.  */
     433                 :            : 
     434                 :            : bool
     435                 :    7088370 : ix86_using_red_zone (void)
     436                 :            : {
     437                 :    7088370 :   return (TARGET_RED_ZONE
     438                 :    6300920 :           && !TARGET_64BIT_MS_ABI
     439                 :   13246700 :           && (!cfun->machine->has_local_indirect_jump
     440                 :      69794 :               || cfun->machine->indirect_branch_type == indirect_branch_keep));
     441                 :            : }
     442                 :            : 
     443                 :            : /* Return true, if profiling code should be emitted before
     444                 :            :    prologue. Otherwise it returns false.
     445                 :            :    Note: For x86 with "hotfix" it is sorried.  */
     446                 :            : static bool
     447                 :    2836300 : ix86_profile_before_prologue (void)
     448                 :            : {
     449                 :    2836300 :   return flag_fentry != 0;
     450                 :            : }
     451                 :            : 
     452                 :            : /* Update register usage after having seen the compiler flags.  */
     453                 :            : 
     454                 :            : static void
     455                 :     458020 : ix86_conditional_register_usage (void)
     456                 :            : {
     457                 :     458020 :   int i, c_mask;
     458                 :            : 
     459                 :            :   /* If there are no caller-saved registers, preserve all registers.
     460                 :            :      except fixed_regs and registers used for function return value
     461                 :            :      since aggregate_value_p checks call_used_regs[regno] on return
     462                 :            :      value.  */
     463                 :     458020 :   if (cfun && cfun->machine->no_caller_saved_registers)
     464                 :     204127 :     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     465                 :     201476 :       if (!fixed_regs[i] && !ix86_function_value_regno_p (i))
     466                 :     177611 :         call_used_regs[i] = 0;
     467                 :            : 
     468                 :            :   /* For 32-bit targets, disable the REX registers.  */
     469                 :     458020 :   if (! TARGET_64BIT)
     470                 :            :     {
     471                 :      85005 :       for (i = FIRST_REX_INT_REG; i <= LAST_REX_INT_REG; i++)
     472                 :      75560 :         CLEAR_HARD_REG_BIT (accessible_reg_set, i);
     473                 :      85005 :       for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++)
     474                 :      75560 :         CLEAR_HARD_REG_BIT (accessible_reg_set, i);
     475                 :     160565 :       for (i = FIRST_EXT_REX_SSE_REG; i <= LAST_EXT_REX_SSE_REG; i++)
     476                 :     151120 :         CLEAR_HARD_REG_BIT (accessible_reg_set, i);
     477                 :            :     }
     478                 :            : 
     479                 :            :   /*  See the definition of CALL_USED_REGISTERS in i386.h.  */
     480                 :     458020 :   c_mask = CALL_USED_REGISTERS_MASK (TARGET_64BIT_MS_ABI);
     481                 :            :   
     482                 :     458020 :   CLEAR_HARD_REG_SET (reg_class_contents[(int)CLOBBERED_REGS]);
     483                 :            : 
     484                 :   35267500 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     485                 :            :     {
     486                 :            :       /* Set/reset conditionally defined registers from
     487                 :            :          CALL_USED_REGISTERS initializer.  */
     488                 :   34809500 :       if (call_used_regs[i] > 1)
     489                 :    7291150 :         call_used_regs[i] = !!(call_used_regs[i] & c_mask);
     490                 :            : 
     491                 :            :       /* Calculate registers of CLOBBERED_REGS register set
     492                 :            :          as call used registers from GENERAL_REGS register set.  */
     493                 :   34809500 :       if (TEST_HARD_REG_BIT (reg_class_contents[(int)GENERAL_REGS], i)
     494                 :   34809500 :           && call_used_regs[i])
     495                 :   34809500 :         SET_HARD_REG_BIT (reg_class_contents[(int)CLOBBERED_REGS], i);
     496                 :            :     }
     497                 :            : 
     498                 :            :   /* If MMX is disabled, disable the registers.  */
     499                 :     458020 :   if (! TARGET_MMX)
     500                 :      36752 :     accessible_reg_set &= ~reg_class_contents[MMX_REGS];
     501                 :            : 
     502                 :            :   /* If SSE is disabled, disable the registers.  */
     503                 :     458020 :   if (! TARGET_SSE)
     504                 :      28068 :     accessible_reg_set &= ~reg_class_contents[ALL_SSE_REGS];
     505                 :            : 
     506                 :            :   /* If the FPU is disabled, disable the registers.  */
     507                 :     458020 :   if (! (TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387))
     508                 :      21752 :     accessible_reg_set &= ~reg_class_contents[FLOAT_REGS];
     509                 :            : 
     510                 :            :   /* If AVX512F is disabled, disable the registers.  */
     511                 :     458020 :   if (! TARGET_AVX512F)
     512                 :            :     {
     513                 :    4525350 :       for (i = FIRST_EXT_REX_SSE_REG; i <= LAST_EXT_REX_SSE_REG; i++)
     514                 :    4259150 :         CLEAR_HARD_REG_BIT (accessible_reg_set, i);
     515                 :            : 
     516                 :    1064790 :       accessible_reg_set &= ~reg_class_contents[ALL_MASK_REGS];
     517                 :            :     }
     518                 :     458020 : }
     519                 :            : 
     520                 :            : /* Canonicalize a comparison from one we don't have to one we do have.  */
     521                 :            : 
     522                 :            : static void
     523                 :   14153500 : ix86_canonicalize_comparison (int *code, rtx *op0, rtx *op1,
     524                 :            :                               bool op0_preserve_value)
     525                 :            : {
     526                 :            :   /* The order of operands in x87 ficom compare is forced by combine in
     527                 :            :      simplify_comparison () function. Float operator is treated as RTX_OBJ
     528                 :            :      with a precedence over other operators and is always put in the first
     529                 :            :      place. Swap condition and operands to match ficom instruction.  */
     530                 :   14153500 :   if (!op0_preserve_value
     531                 :   13649100 :       && GET_CODE (*op0) == FLOAT && MEM_P (XEXP (*op0, 0)) && REG_P (*op1))
     532                 :            :     {
     533                 :         17 :       enum rtx_code scode = swap_condition ((enum rtx_code) *code);
     534                 :            : 
     535                 :            :       /* We are called only for compares that are split to SAHF instruction.
     536                 :            :          Ensure that we have setcc/jcc insn for the swapped condition.  */
     537                 :         17 :       if (ix86_fp_compare_code_to_integer (scode) != UNKNOWN)
     538                 :            :         {
     539                 :          3 :           std::swap (*op0, *op1);
     540                 :          3 :           *code = (int) scode;
     541                 :            :         }
     542                 :            :     }
     543                 :   14153500 : }
     544                 :            : 
     545                 :            : 
     546                 :            : /* Hook to determine if one function can safely inline another.  */
     547                 :            : 
     548                 :            : static bool
     549                 :    5020620 : ix86_can_inline_p (tree caller, tree callee)
     550                 :            : {
     551                 :    5020620 :   tree caller_tree = DECL_FUNCTION_SPECIFIC_TARGET (caller);
     552                 :    5020620 :   tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET (callee);
     553                 :            : 
     554                 :            :   /* Changes of those flags can be tolerated for always inlines. Lets hope
     555                 :            :      user knows what he is doing.  */
     556                 :    5020620 :   const unsigned HOST_WIDE_INT always_inline_safe_mask
     557                 :            :          = (MASK_USE_8BIT_IDIV | MASK_ACCUMULATE_OUTGOING_ARGS
     558                 :            :             | MASK_NO_ALIGN_STRINGOPS | MASK_AVX256_SPLIT_UNALIGNED_LOAD
     559                 :            :             | MASK_AVX256_SPLIT_UNALIGNED_STORE | MASK_CLD
     560                 :            :             | MASK_NO_FANCY_MATH_387 | MASK_IEEE_FP | MASK_INLINE_ALL_STRINGOPS
     561                 :            :             | MASK_INLINE_STRINGOPS_DYNAMICALLY | MASK_RECIP | MASK_STACK_PROBE
     562                 :            :             | MASK_STV | MASK_TLS_DIRECT_SEG_REFS | MASK_VZEROUPPER
     563                 :            :             | MASK_NO_PUSH_ARGS | MASK_OMIT_LEAF_FRAME_POINTER);
     564                 :            : 
     565                 :            : 
     566                 :    5020620 :   if (!callee_tree)
     567                 :    4830780 :     callee_tree = target_option_default_node;
     568                 :    5020620 :   if (!caller_tree)
     569                 :    4828190 :     caller_tree = target_option_default_node;
     570                 :    5020620 :   if (callee_tree == caller_tree)
     571                 :            :     return true;
     572                 :            : 
     573                 :       4465 :   struct cl_target_option *caller_opts = TREE_TARGET_OPTION (caller_tree);
     574                 :       4465 :   struct cl_target_option *callee_opts = TREE_TARGET_OPTION (callee_tree);
     575                 :       4465 :   bool ret = false;
     576                 :       4465 :   bool always_inline
     577                 :       4465 :     = (DECL_DISREGARD_INLINE_LIMITS (callee)
     578                 :       4022 :        && lookup_attribute ("always_inline",
     579                 :       8487 :                             DECL_ATTRIBUTES (callee)));
     580                 :            : 
     581                 :       4465 :   cgraph_node *callee_node = cgraph_node::get (callee);
     582                 :            :   /* Callee's isa options should be a subset of the caller's, i.e. a SSE4
     583                 :            :      function can inline a SSE2 function but a SSE2 function can't inline
     584                 :            :      a SSE4 function.  */
     585                 :       4465 :   if (((caller_opts->x_ix86_isa_flags & callee_opts->x_ix86_isa_flags)
     586                 :            :        != callee_opts->x_ix86_isa_flags)
     587                 :       4311 :       || ((caller_opts->x_ix86_isa_flags2 & callee_opts->x_ix86_isa_flags2)
     588                 :            :           != callee_opts->x_ix86_isa_flags2))
     589                 :            :     ret = false;
     590                 :            : 
     591                 :            :   /* See if we have the same non-isa options.  */
     592                 :       4311 :   else if ((!always_inline
     593                 :        294 :             && caller_opts->x_target_flags != callee_opts->x_target_flags)
     594                 :       4310 :            || (caller_opts->x_target_flags & ~always_inline_safe_mask)
     595                 :       4310 :                != (callee_opts->x_target_flags & ~always_inline_safe_mask))
     596                 :            :     ret = false;
     597                 :            : 
     598                 :            :   /* See if arch, tune, etc. are the same.  */
     599                 :       4310 :   else if (caller_opts->arch != callee_opts->arch)
     600                 :            :     ret = false;
     601                 :            : 
     602                 :       4310 :   else if (!always_inline && caller_opts->tune != callee_opts->tune)
     603                 :            :     ret = false;
     604                 :            : 
     605                 :       4310 :   else if (caller_opts->x_ix86_fpmath != callee_opts->x_ix86_fpmath
     606                 :            :            /* If the calle doesn't use FP expressions differences in
     607                 :            :               ix86_fpmath can be ignored.  We are called from FEs
     608                 :            :               for multi-versioning call optimization, so beware of
     609                 :            :               ipa_fn_summaries not available.  */
     610                 :        274 :            && (! ipa_fn_summaries
     611                 :        274 :                || ipa_fn_summaries->get (callee_node) == NULL
     612                 :        274 :                || ipa_fn_summaries->get (callee_node)->fp_expressions))
     613                 :            :     ret = false;
     614                 :            : 
     615                 :       4036 :   else if (!always_inline
     616                 :         19 :            && caller_opts->branch_cost != callee_opts->branch_cost)
     617                 :            :     ret = false;
     618                 :            : 
     619                 :            :   else
     620                 :       4036 :     ret = true;
     621                 :            : 
     622                 :            :   return ret;
     623                 :            : }
     624                 :            : 
     625                 :            : /* Return true if this goes in large data/bss.  */
     626                 :            : 
     627                 :            : static bool
     628                 :   45085000 : ix86_in_large_data_p (tree exp)
     629                 :            : {
     630                 :   45085000 :   if (ix86_cmodel != CM_MEDIUM && ix86_cmodel != CM_MEDIUM_PIC)
     631                 :            :     return false;
     632                 :            : 
     633                 :        215 :   if (exp == NULL_TREE)
     634                 :            :     return false;
     635                 :            : 
     636                 :            :   /* Functions are never large data.  */
     637                 :        215 :   if (TREE_CODE (exp) == FUNCTION_DECL)
     638                 :            :     return false;
     639                 :            : 
     640                 :            :   /* Automatic variables are never large data.  */
     641                 :         47 :   if (VAR_P (exp) && !is_global_var (exp))
     642                 :            :     return false;
     643                 :            : 
     644                 :         47 :   if (VAR_P (exp) && DECL_SECTION_NAME (exp))
     645                 :            :     {
     646                 :          3 :       const char *section = DECL_SECTION_NAME (exp);
     647                 :          3 :       if (strcmp (section, ".ldata") == 0
     648                 :          3 :           || strcmp (section, ".lbss") == 0)
     649                 :            :         return true;
     650                 :          3 :       return false;
     651                 :            :     }
     652                 :            :   else
     653                 :            :     {
     654                 :         44 :       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
     655                 :            : 
     656                 :            :       /* If this is an incomplete type with size 0, then we can't put it
     657                 :            :          in data because it might be too big when completed.  Also,
     658                 :            :          int_size_in_bytes returns -1 if size can vary or is larger than
     659                 :            :          an integer in which case also it is safer to assume that it goes in
     660                 :            :          large data.  */
     661                 :         44 :       if (size <= 0 || size > ix86_section_threshold)
     662                 :         25 :         return true;
     663                 :            :     }
     664                 :            : 
     665                 :            :   return false;
     666                 :            : }
     667                 :            : 
     668                 :            : /* i386-specific section flag to mark large sections.  */
     669                 :            : #define SECTION_LARGE SECTION_MACH_DEP
     670                 :            : 
     671                 :            : /* Switch to the appropriate section for output of DECL.
     672                 :            :    DECL is either a `VAR_DECL' node or a constant of some sort.
     673                 :            :    RELOC indicates whether forming the initial value of DECL requires
     674                 :            :    link-time relocations.  */
     675                 :            : 
     676                 :            : ATTRIBUTE_UNUSED static section *
     677                 :    1050430 : x86_64_elf_select_section (tree decl, int reloc,
     678                 :            :                            unsigned HOST_WIDE_INT align)
     679                 :            : {
     680                 :    1050430 :   if (ix86_in_large_data_p (decl))
     681                 :            :     {
     682                 :          4 :       const char *sname = NULL;
     683                 :          4 :       unsigned int flags = SECTION_WRITE | SECTION_LARGE;
     684                 :          4 :       switch (categorize_decl_for_section (decl, reloc))
     685                 :            :         {
     686                 :            :         case SECCAT_DATA:
     687                 :            :           sname = ".ldata";
     688                 :            :           break;
     689                 :          0 :         case SECCAT_DATA_REL:
     690                 :          0 :           sname = ".ldata.rel";
     691                 :          0 :           break;
     692                 :          0 :         case SECCAT_DATA_REL_LOCAL:
     693                 :          0 :           sname = ".ldata.rel.local";
     694                 :          0 :           break;
     695                 :          0 :         case SECCAT_DATA_REL_RO:
     696                 :          0 :           sname = ".ldata.rel.ro";
     697                 :          0 :           break;
     698                 :          0 :         case SECCAT_DATA_REL_RO_LOCAL:
     699                 :          0 :           sname = ".ldata.rel.ro.local";
     700                 :          0 :           break;
     701                 :          0 :         case SECCAT_BSS:
     702                 :          0 :           sname = ".lbss";
     703                 :          0 :           flags |= SECTION_BSS;
     704                 :          0 :           break;
     705                 :          4 :         case SECCAT_RODATA:
     706                 :          4 :         case SECCAT_RODATA_MERGE_STR:
     707                 :          4 :         case SECCAT_RODATA_MERGE_STR_INIT:
     708                 :          4 :         case SECCAT_RODATA_MERGE_CONST:
     709                 :          4 :           sname = ".lrodata";
     710                 :          4 :           flags &= ~SECTION_WRITE;
     711                 :          4 :           break;
     712                 :          0 :         case SECCAT_SRODATA:
     713                 :          0 :         case SECCAT_SDATA:
     714                 :          0 :         case SECCAT_SBSS:
     715                 :          0 :           gcc_unreachable ();
     716                 :            :         case SECCAT_TEXT:
     717                 :            :         case SECCAT_TDATA:
     718                 :            :         case SECCAT_TBSS:
     719                 :            :           /* We don't split these for medium model.  Place them into
     720                 :            :              default sections and hope for best.  */
     721                 :            :           break;
     722                 :            :         }
     723                 :          4 :       if (sname)
     724                 :            :         {
     725                 :            :           /* We might get called with string constants, but get_named_section
     726                 :            :              doesn't like them as they are not DECLs.  Also, we need to set
     727                 :            :              flags in that case.  */
     728                 :          4 :           if (!DECL_P (decl))
     729                 :          3 :             return get_section (sname, flags, NULL);
     730                 :          1 :           return get_named_section (decl, sname, reloc);
     731                 :            :         }
     732                 :            :     }
     733                 :    1050430 :   return default_elf_select_section (decl, reloc, align);
     734                 :            : }
     735                 :            : 
     736                 :            : /* Select a set of attributes for section NAME based on the properties
     737                 :            :    of DECL and whether or not RELOC indicates that DECL's initializer
     738                 :            :    might contain runtime relocations.  */
     739                 :            : 
     740                 :            : static unsigned int ATTRIBUTE_UNUSED
     741                 :   35207100 : x86_64_elf_section_type_flags (tree decl, const char *name, int reloc)
     742                 :            : {
     743                 :   35207100 :   unsigned int flags = default_section_type_flags (decl, name, reloc);
     744                 :            : 
     745                 :   35207100 :   if (ix86_in_large_data_p (decl))
     746                 :          3 :     flags |= SECTION_LARGE;
     747                 :            : 
     748                 :   35207100 :   if (decl == NULL_TREE
     749                 :        146 :       && (strcmp (name, ".ldata.rel.ro") == 0
     750                 :        146 :           || strcmp (name, ".ldata.rel.ro.local") == 0))
     751                 :          0 :     flags |= SECTION_RELRO;
     752                 :            : 
     753                 :   35207100 :   if (strcmp (name, ".lbss") == 0
     754                 :   35207100 :       || strncmp (name, ".lbss.", sizeof (".lbss.") - 1) == 0
     755                 :   35207100 :       || strncmp (name, ".gnu.linkonce.lb.",
     756                 :            :                   sizeof (".gnu.linkonce.lb.") - 1) == 0)
     757                 :          5 :     flags |= SECTION_BSS;
     758                 :            : 
     759                 :   35207100 :   return flags;
     760                 :            : }
     761                 :            : 
     762                 :            : /* Build up a unique section name, expressed as a
     763                 :            :    STRING_CST node, and assign it to DECL_SECTION_NAME (decl).
     764                 :            :    RELOC indicates whether the initial value of EXP requires
     765                 :            :    link-time relocations.  */
     766                 :            : 
     767                 :            : static void ATTRIBUTE_UNUSED
     768                 :    1507560 : x86_64_elf_unique_section (tree decl, int reloc)
     769                 :            : {
     770                 :    1507560 :   if (ix86_in_large_data_p (decl))
     771                 :            :     {
     772                 :          3 :       const char *prefix = NULL;
     773                 :            :       /* We only need to use .gnu.linkonce if we don't have COMDAT groups.  */
     774                 :          3 :       bool one_only = DECL_COMDAT_GROUP (decl) && !HAVE_COMDAT_GROUP;
     775                 :            : 
     776                 :          3 :       switch (categorize_decl_for_section (decl, reloc))
     777                 :            :         {
     778                 :            :         case SECCAT_DATA:
     779                 :            :         case SECCAT_DATA_REL:
     780                 :            :         case SECCAT_DATA_REL_LOCAL:
     781                 :            :         case SECCAT_DATA_REL_RO:
     782                 :            :         case SECCAT_DATA_REL_RO_LOCAL:
     783                 :            :           prefix = one_only ? ".ld" : ".ldata";
     784                 :            :           break;
     785                 :          3 :         case SECCAT_BSS:
     786                 :          3 :           prefix = one_only ? ".lb" : ".lbss";
     787                 :          3 :           break;
     788                 :          0 :         case SECCAT_RODATA:
     789                 :          0 :         case SECCAT_RODATA_MERGE_STR:
     790                 :          0 :         case SECCAT_RODATA_MERGE_STR_INIT:
     791                 :          0 :         case SECCAT_RODATA_MERGE_CONST:
     792                 :          0 :           prefix = one_only ? ".lr" : ".lrodata";
     793                 :          0 :           break;
     794                 :          0 :         case SECCAT_SRODATA:
     795                 :          0 :         case SECCAT_SDATA:
     796                 :          0 :         case SECCAT_SBSS:
     797                 :          0 :           gcc_unreachable ();
     798                 :            :         case SECCAT_TEXT:
     799                 :            :         case SECCAT_TDATA:
     800                 :            :         case SECCAT_TBSS:
     801                 :            :           /* We don't split these for medium model.  Place them into
     802                 :            :              default sections and hope for best.  */
     803                 :            :           break;
     804                 :            :         }
     805                 :          3 :       if (prefix)
     806                 :            :         {
     807                 :          3 :           const char *name, *linkonce;
     808                 :          3 :           char *string;
     809                 :            : 
     810                 :          3 :           name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
     811                 :          3 :           name = targetm.strip_name_encoding (name);
     812                 :            : 
     813                 :            :           /* If we're using one_only, then there needs to be a .gnu.linkonce
     814                 :            :              prefix to the section name.  */
     815                 :          3 :           linkonce = one_only ? ".gnu.linkonce" : "";
     816                 :            : 
     817                 :          3 :           string = ACONCAT ((linkonce, prefix, ".", name, NULL));
     818                 :            : 
     819                 :          3 :           set_decl_section_name (decl, string);
     820                 :          3 :           return;
     821                 :            :         }
     822                 :            :     }
     823                 :    1507560 :   default_unique_section (decl, reloc);
     824                 :            : }
     825                 :            : 
     826                 :            : #ifdef COMMON_ASM_OP
     827                 :            : 
     828                 :            : #ifndef LARGECOMM_SECTION_ASM_OP
     829                 :            : #define LARGECOMM_SECTION_ASM_OP "\t.largecomm\t"
     830                 :            : #endif
     831                 :            : 
     832                 :            : /* This says how to output assembler code to declare an
     833                 :            :    uninitialized external linkage data object.
     834                 :            : 
     835                 :            :    For medium model x86-64 we need to use LARGECOMM_SECTION_ASM_OP opcode for
     836                 :            :    large objects.  */
     837                 :            : void
     838                 :       9470 : x86_elf_aligned_decl_common (FILE *file, tree decl,
     839                 :            :                         const char *name, unsigned HOST_WIDE_INT size,
     840                 :            :                         int align)
     841                 :            : {
     842                 :       9470 :   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
     843                 :          0 :       && size > (unsigned int)ix86_section_threshold)
     844                 :            :     {
     845                 :          0 :       switch_to_section (get_named_section (decl, ".lbss", 0));
     846                 :          0 :       fputs (LARGECOMM_SECTION_ASM_OP, file);
     847                 :            :     }
     848                 :            :   else
     849                 :       9470 :     fputs (COMMON_ASM_OP, file);
     850                 :       9470 :   assemble_name (file, name);
     851                 :       9470 :   fprintf (file, "," HOST_WIDE_INT_PRINT_UNSIGNED ",%u\n",
     852                 :            :            size, align / BITS_PER_UNIT);
     853                 :       9470 : }
     854                 :            : #endif
     855                 :            : 
     856                 :            : /* Utility function for targets to use in implementing
     857                 :            :    ASM_OUTPUT_ALIGNED_BSS.  */
     858                 :            : 
     859                 :            : void
     860                 :     718214 : x86_output_aligned_bss (FILE *file, tree decl, const char *name,
     861                 :            :                         unsigned HOST_WIDE_INT size, int align)
     862                 :            : {
     863                 :     718214 :   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
     864                 :         12 :       && size > (unsigned int)ix86_section_threshold)
     865                 :          2 :     switch_to_section (get_named_section (decl, ".lbss", 0));
     866                 :            :   else
     867                 :     718212 :     switch_to_section (bss_section);
     868                 :     825483 :   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
     869                 :            : #ifdef ASM_DECLARE_OBJECT_NAME
     870                 :     718214 :   last_assemble_variable_decl = decl;
     871                 :    1436430 :   ASM_DECLARE_OBJECT_NAME (file, name, decl);
     872                 :            : #else
     873                 :            :   /* Standard thing is just output label for the object.  */
     874                 :            :   ASM_OUTPUT_LABEL (file, name);
     875                 :            : #endif /* ASM_DECLARE_OBJECT_NAME */
     876                 :     718214 :   ASM_OUTPUT_SKIP (file, size ? size : 1);
     877                 :     718214 : }
     878                 :            : 
     879                 :            : /* Decide whether we must probe the stack before any space allocation
     880                 :            :    on this target.  It's essentially TARGET_STACK_PROBE except when
     881                 :            :    -fstack-check causes the stack to be already probed differently.  */
     882                 :            : 
     883                 :            : bool
     884                 :     526086 : ix86_target_stack_probe (void)
     885                 :            : {
     886                 :            :   /* Do not probe the stack twice if static stack checking is enabled.  */
     887                 :     526086 :   if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
     888                 :            :     return false;
     889                 :            : 
     890                 :     526086 :   return TARGET_STACK_PROBE;
     891                 :            : }
     892                 :            : 
     893                 :            : /* Decide whether we can make a sibling call to a function.  DECL is the
     894                 :            :    declaration of the function being targeted by the call and EXP is the
     895                 :            :    CALL_EXPR representing the call.  */
     896                 :            : 
     897                 :            : static bool
     898                 :      96360 : ix86_function_ok_for_sibcall (tree decl, tree exp)
     899                 :            : {
     900                 :      96360 :   tree type, decl_or_type;
     901                 :      96360 :   rtx a, b;
     902                 :      96360 :   bool bind_global = decl && !targetm.binds_local_p (decl);
     903                 :            : 
     904                 :      96360 :   if (ix86_function_naked (current_function_decl))
     905                 :            :     return false;
     906                 :            : 
     907                 :            :   /* Sibling call isn't OK if there are no caller-saved registers
     908                 :            :      since all registers must be preserved before return.  */
     909                 :      96358 :   if (cfun->machine->no_caller_saved_registers)
     910                 :            :     return false;
     911                 :            : 
     912                 :            :   /* If we are generating position-independent code, we cannot sibcall
     913                 :            :      optimize direct calls to global functions, as the PLT requires
     914                 :            :      %ebx be live. (Darwin does not have a PLT.)  */
     915                 :      96336 :   if (!TARGET_MACHO
     916                 :      96336 :       && !TARGET_64BIT
     917                 :       9140 :       && flag_pic
     918                 :       5973 :       && flag_plt
     919                 :       5973 :       && bind_global)
     920                 :            :     return false;
     921                 :            : 
     922                 :            :   /* If we need to align the outgoing stack, then sibcalling would
     923                 :            :      unalign the stack, which may break the called function.  */
     924                 :      93414 :   if (ix86_minimum_incoming_stack_boundary (true)
     925                 :      93414 :       < PREFERRED_STACK_BOUNDARY)
     926                 :            :     return false;
     927                 :            : 
     928                 :      93025 :   if (decl)
     929                 :            :     {
     930                 :      85983 :       decl_or_type = decl;
     931                 :      85983 :       type = TREE_TYPE (decl);
     932                 :            :     }
     933                 :            :   else
     934                 :            :     {
     935                 :            :       /* We're looking at the CALL_EXPR, we need the type of the function.  */
     936                 :       7042 :       type = CALL_EXPR_FN (exp);                /* pointer expression */
     937                 :       7042 :       type = TREE_TYPE (type);                  /* pointer type */
     938                 :       7042 :       type = TREE_TYPE (type);                  /* function type */
     939                 :       7042 :       decl_or_type = type;
     940                 :            :     }
     941                 :            : 
     942                 :            :   /* Check that the return value locations are the same.  Like
     943                 :            :      if we are returning floats on the 80387 register stack, we cannot
     944                 :            :      make a sibcall from a function that doesn't return a float to a
     945                 :            :      function that does or, conversely, from a function that does return
     946                 :            :      a float to a function that doesn't; the necessary stack adjustment
     947                 :            :      would not be executed.  This is also the place we notice
     948                 :            :      differences in the return value ABI.  Note that it is ok for one
     949                 :            :      of the functions to have void return type as long as the return
     950                 :            :      value of the other is passed in a register.  */
     951                 :      93025 :   a = ix86_function_value (TREE_TYPE (exp), decl_or_type, false);
     952                 :      93025 :   b = ix86_function_value (TREE_TYPE (DECL_RESULT (cfun->decl)),
     953                 :      93025 :                            cfun->decl, false);
     954                 :      93025 :   if (STACK_REG_P (a) || STACK_REG_P (b))
     955                 :            :     {
     956                 :        408 :       if (!rtx_equal_p (a, b))
     957                 :            :         return false;
     958                 :            :     }
     959                 :      92617 :   else if (VOID_TYPE_P (TREE_TYPE (DECL_RESULT (cfun->decl))))
     960                 :            :     ;
     961                 :      15279 :   else if (!rtx_equal_p (a, b))
     962                 :            :     return false;
     963                 :            : 
     964                 :      92654 :   if (TARGET_64BIT)
     965                 :            :     {
     966                 :            :       /* The SYSV ABI has more call-clobbered registers;
     967                 :            :          disallow sibcalls from MS to SYSV.  */
     968                 :      86437 :       if (cfun->machine->call_abi == MS_ABI
     969                 :      86437 :           && ix86_function_type_abi (type) == SYSV_ABI)
     970                 :          0 :         return false;
     971                 :            :     }
     972                 :            :   else
     973                 :            :     {
     974                 :            :       /* If this call is indirect, we'll need to be able to use a
     975                 :            :          call-clobbered register for the address of the target function.
     976                 :            :          Make sure that all such registers are not used for passing
     977                 :            :          parameters.  Note that DLLIMPORT functions and call to global
     978                 :            :          function via GOT slot are indirect.  */
     979                 :       6217 :       if (!decl
     980                 :       4776 :           || (bind_global && flag_pic && !flag_plt)
     981                 :            :           || (TARGET_DLLIMPORT_DECL_ATTRIBUTES && DECL_DLLIMPORT_P (decl))
     982                 :       4776 :           || flag_force_indirect_call)
     983                 :            :         {
     984                 :            :           /* Check if regparm >= 3 since arg_reg_available is set to
     985                 :            :              false if regparm == 0.  If regparm is 1 or 2, there is
     986                 :            :              always a call-clobbered register available.
     987                 :            : 
     988                 :            :              ??? The symbol indirect call doesn't need a call-clobbered
     989                 :            :              register.  But we don't know if this is a symbol indirect
     990                 :            :              call or not here.  */
     991                 :       1441 :           if (ix86_function_regparm (type, decl) >= 3
     992                 :       1441 :               && !cfun->machine->arg_reg_available)
     993                 :            :             return false;
     994                 :            :         }
     995                 :            :     }
     996                 :            : 
     997                 :            :   /* Otherwise okay.  That also includes certain types of indirect calls.  */
     998                 :            :   return true;
     999                 :            : }
    1000                 :            : 
    1001                 :            : /* This function determines from TYPE the calling-convention.  */
    1002                 :            : 
    1003                 :            : unsigned int
    1004                 :    4761220 : ix86_get_callcvt (const_tree type)
    1005                 :            : {
    1006                 :    4761220 :   unsigned int ret = 0;
    1007                 :    4761220 :   bool is_stdarg;
    1008                 :    4761220 :   tree attrs;
    1009                 :            : 
    1010                 :    4761220 :   if (TARGET_64BIT)
    1011                 :            :     return IX86_CALLCVT_CDECL;
    1012                 :            : 
    1013                 :    2634270 :   attrs = TYPE_ATTRIBUTES (type);
    1014                 :    2634270 :   if (attrs != NULL_TREE)
    1015                 :            :     {
    1016                 :      44647 :       if (lookup_attribute ("cdecl", attrs))
    1017                 :            :         ret |= IX86_CALLCVT_CDECL;
    1018                 :      44647 :       else if (lookup_attribute ("stdcall", attrs))
    1019                 :            :         ret |= IX86_CALLCVT_STDCALL;
    1020                 :      44647 :       else if (lookup_attribute ("fastcall", attrs))
    1021                 :            :         ret |= IX86_CALLCVT_FASTCALL;
    1022                 :      44629 :       else if (lookup_attribute ("thiscall", attrs))
    1023                 :          0 :         ret |= IX86_CALLCVT_THISCALL;
    1024                 :            : 
    1025                 :            :       /* Regparam isn't allowed for thiscall and fastcall.  */
    1026                 :      44647 :       if ((ret & (IX86_CALLCVT_THISCALL | IX86_CALLCVT_FASTCALL)) == 0)
    1027                 :            :         {
    1028                 :      44629 :           if (lookup_attribute ("regparm", attrs))
    1029                 :       8072 :             ret |= IX86_CALLCVT_REGPARM;
    1030                 :      44629 :           if (lookup_attribute ("sseregparm", attrs))
    1031                 :          0 :             ret |= IX86_CALLCVT_SSEREGPARM;
    1032                 :            :         }
    1033                 :            : 
    1034                 :      44647 :       if (IX86_BASE_CALLCVT(ret) != 0)
    1035                 :            :         return ret;
    1036                 :            :     }
    1037                 :            : 
    1038                 :    2634250 :   is_stdarg = stdarg_p (type);
    1039                 :    2634250 :   if (TARGET_RTD && !is_stdarg)
    1040                 :          0 :     return IX86_CALLCVT_STDCALL | ret;
    1041                 :            : 
    1042                 :    2634250 :   if (ret != 0
    1043                 :    2634250 :       || is_stdarg
    1044                 :    2618830 :       || TREE_CODE (type) != METHOD_TYPE
    1045                 :    2744200 :       || ix86_function_type_abi (type) != MS_ABI)
    1046                 :    2634250 :     return IX86_CALLCVT_CDECL | ret;
    1047                 :            : 
    1048                 :            :   return IX86_CALLCVT_THISCALL;
    1049                 :            : }
    1050                 :            : 
    1051                 :            : /* Return 0 if the attributes for two types are incompatible, 1 if they
    1052                 :            :    are compatible, and 2 if they are nearly compatible (which causes a
    1053                 :            :    warning to be generated).  */
    1054                 :            : 
    1055                 :            : static int
    1056                 :    1073380 : ix86_comp_type_attributes (const_tree type1, const_tree type2)
    1057                 :            : {
    1058                 :    1073380 :   unsigned int ccvt1, ccvt2;
    1059                 :            : 
    1060                 :    1073380 :   if (TREE_CODE (type1) != FUNCTION_TYPE
    1061                 :    1073380 :       && TREE_CODE (type1) != METHOD_TYPE)
    1062                 :            :     return 1;
    1063                 :            : 
    1064                 :    1066790 :   ccvt1 = ix86_get_callcvt (type1);
    1065                 :    1066790 :   ccvt2 = ix86_get_callcvt (type2);
    1066                 :    1066790 :   if (ccvt1 != ccvt2)
    1067                 :            :     return 0;
    1068                 :    2126950 :   if (ix86_function_regparm (type1, NULL)
    1069                 :    1063480 :       != ix86_function_regparm (type2, NULL))
    1070                 :     531747 :     return 0;
    1071                 :            : 
    1072                 :            :   return 1;
    1073                 :            : }
    1074                 :            : 
    1075                 :            : /* Return the regparm value for a function with the indicated TYPE and DECL.
    1076                 :            :    DECL may be NULL when calling function indirectly
    1077                 :            :    or considering a libcall.  */
    1078                 :            : 
    1079                 :            : static int
    1080                 :    3154100 : ix86_function_regparm (const_tree type, const_tree decl)
    1081                 :            : {
    1082                 :    3154100 :   tree attr;
    1083                 :    3154100 :   int regparm;
    1084                 :    3154100 :   unsigned int ccvt;
    1085                 :            : 
    1086                 :    3154100 :   if (TARGET_64BIT)
    1087                 :    2126950 :     return (ix86_function_type_abi (type) == SYSV_ABI
    1088                 :    2126950 :             ? X86_64_REGPARM_MAX : X86_64_MS_REGPARM_MAX);
    1089                 :    1027150 :   ccvt = ix86_get_callcvt (type);
    1090                 :    1027150 :   regparm = ix86_regparm;
    1091                 :            : 
    1092                 :    1027150 :   if ((ccvt & IX86_CALLCVT_REGPARM) != 0)
    1093                 :            :     {
    1094                 :       2017 :       attr = lookup_attribute ("regparm", TYPE_ATTRIBUTES (type));
    1095                 :       2017 :       if (attr)
    1096                 :            :         {
    1097                 :       2017 :           regparm = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr)));
    1098                 :       2017 :           return regparm;
    1099                 :            :         }
    1100                 :            :     }
    1101                 :    1025130 :   else if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
    1102                 :            :     return 2;
    1103                 :    1025130 :   else if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
    1104                 :            :     return 1;
    1105                 :            : 
    1106                 :            :   /* Use register calling convention for local functions when possible.  */
    1107                 :    1025130 :   if (decl
    1108                 :     973348 :       && TREE_CODE (decl) == FUNCTION_DECL)
    1109                 :            :     {
    1110                 :     963436 :       cgraph_node *target = cgraph_node::get (decl);
    1111                 :     963436 :       if (target)
    1112                 :     957936 :         target = target->function_symbol ();
    1113                 :            : 
    1114                 :            :       /* Caller and callee must agree on the calling convention, so
    1115                 :            :          checking here just optimize means that with
    1116                 :            :          __attribute__((optimize (...))) caller could use regparm convention
    1117                 :            :          and callee not, or vice versa.  Instead look at whether the callee
    1118                 :            :          is optimized or not.  */
    1119                 :     957936 :       if (target && opt_for_fn (target->decl, optimize)
    1120                 :    1920550 :           && !(profile_flag && !flag_fentry))
    1121                 :            :         {
    1122                 :     957111 :           if (target->local && target->can_change_signature)
    1123                 :            :             {
    1124                 :     104956 :               int local_regparm, globals = 0, regno;
    1125                 :            : 
    1126                 :            :               /* Make sure no regparm register is taken by a
    1127                 :            :                  fixed register variable.  */
    1128                 :     104956 :               for (local_regparm = 0; local_regparm < REGPARM_MAX;
    1129                 :            :                    local_regparm++)
    1130                 :      78717 :                 if (fixed_regs[local_regparm])
    1131                 :            :                   break;
    1132                 :            : 
    1133                 :            :               /* We don't want to use regparm(3) for nested functions as
    1134                 :            :                  these use a static chain pointer in the third argument.  */
    1135                 :      26239 :               if (local_regparm == 3 && DECL_STATIC_CHAIN (target->decl))
    1136                 :            :                 local_regparm = 2;
    1137                 :            : 
    1138                 :            :               /* Save a register for the split stack.  */
    1139                 :      26239 :               if (flag_split_stack)
    1140                 :            :                 {
    1141                 :      17470 :                   if (local_regparm == 3)
    1142                 :            :                     local_regparm = 2;
    1143                 :        676 :                   else if (local_regparm == 2
    1144                 :        676 :                            && DECL_STATIC_CHAIN (target->decl))
    1145                 :            :                     local_regparm = 1;
    1146                 :            :                 }
    1147                 :            : 
    1148                 :            :               /* Each fixed register usage increases register pressure,
    1149                 :            :                  so less registers should be used for argument passing.
    1150                 :            :                  This functionality can be overriden by an explicit
    1151                 :            :                  regparm value.  */
    1152                 :     183673 :               for (regno = AX_REG; regno <= DI_REG; regno++)
    1153                 :     157434 :                 if (fixed_regs[regno])
    1154                 :          0 :                   globals++;
    1155                 :            : 
    1156                 :      26239 :               local_regparm
    1157                 :      26239 :                 = globals < local_regparm ? local_regparm - globals : 0;
    1158                 :            : 
    1159                 :      26239 :               if (local_regparm > regparm)
    1160                 :            :                 regparm = local_regparm;
    1161                 :            :             }
    1162                 :            :         }
    1163                 :            :     }
    1164                 :            : 
    1165                 :            :   return regparm;
    1166                 :            : }
    1167                 :            : 
    1168                 :            : /* Return 1 or 2, if we can pass up to SSE_REGPARM_MAX SFmode (1) and
    1169                 :            :    DFmode (2) arguments in SSE registers for a function with the
    1170                 :            :    indicated TYPE and DECL.  DECL may be NULL when calling function
    1171                 :            :    indirectly or considering a libcall.  Return -1 if any FP parameter
    1172                 :            :    should be rejected by error.  This is used in siutation we imply SSE
    1173                 :            :    calling convetion but the function is called from another function with
    1174                 :            :    SSE disabled. Otherwise return 0.  */
    1175                 :            : 
    1176                 :            : static int
    1177                 :     861091 : ix86_function_sseregparm (const_tree type, const_tree decl, bool warn)
    1178                 :            : {
    1179                 :     861091 :   gcc_assert (!TARGET_64BIT);
    1180                 :            : 
    1181                 :            :   /* Use SSE registers to pass SFmode and DFmode arguments if requested
    1182                 :            :      by the sseregparm attribute.  */
    1183                 :     861091 :   if (TARGET_SSEREGPARM
    1184                 :    1709750 :       || (type && lookup_attribute ("sseregparm", TYPE_ATTRIBUTES (type))))
    1185                 :            :     {
    1186                 :          0 :       if (!TARGET_SSE)
    1187                 :            :         {
    1188                 :          0 :           if (warn)
    1189                 :            :             {
    1190                 :          0 :               if (decl)
    1191                 :          0 :                 error ("calling %qD with attribute sseregparm without "
    1192                 :            :                        "SSE/SSE2 enabled", decl);
    1193                 :            :               else
    1194                 :          0 :                 error ("calling %qT with attribute sseregparm without "
    1195                 :            :                        "SSE/SSE2 enabled", type);
    1196                 :            :             }
    1197                 :          0 :           return 0;
    1198                 :            :         }
    1199                 :            : 
    1200                 :            :       return 2;
    1201                 :            :     }
    1202                 :            : 
    1203                 :     861091 :   if (!decl)
    1204                 :            :     return 0;
    1205                 :            : 
    1206                 :     786745 :   cgraph_node *target = cgraph_node::get (decl);
    1207                 :     786745 :   if (target)
    1208                 :     781250 :     target = target->function_symbol ();
    1209                 :            : 
    1210                 :            :   /* For local functions, pass up to SSE_REGPARM_MAX SFmode
    1211                 :            :      (and DFmode for SSE2) arguments in SSE registers.  */
    1212                 :     786745 :   if (target
    1213                 :            :       /* TARGET_SSE_MATH */
    1214                 :     781250 :       && (target_opts_for_fn (target->decl)->x_ix86_fpmath & FPMATH_SSE)
    1215                 :       1344 :       && opt_for_fn (target->decl, optimize)
    1216                 :     788089 :       && !(profile_flag && !flag_fentry))
    1217                 :            :     {
    1218                 :       1344 :       if (target->local && target->can_change_signature)
    1219                 :            :         {
    1220                 :            :           /* Refuse to produce wrong code when local function with SSE enabled
    1221                 :            :              is called from SSE disabled function.
    1222                 :            :              FIXME: We need a way to detect these cases cross-ltrans partition
    1223                 :            :              and avoid using SSE calling conventions on local functions called
    1224                 :            :              from function with SSE disabled.  For now at least delay the
    1225                 :            :              warning until we know we are going to produce wrong code.
    1226                 :            :              See PR66047  */
    1227                 :          0 :           if (!TARGET_SSE && warn)
    1228                 :            :             return -1;
    1229                 :          0 :           return TARGET_SSE2_P (target_opts_for_fn (target->decl)
    1230                 :          0 :                                 ->x_ix86_isa_flags) ? 2 : 1;
    1231                 :            :         }
    1232                 :            :     }
    1233                 :            : 
    1234                 :            :   return 0;
    1235                 :            : }
    1236                 :            : 
    1237                 :            : /* Return true if EAX is live at the start of the function.  Used by
    1238                 :            :    ix86_expand_prologue to determine if we need special help before
    1239                 :            :    calling allocate_stack_worker.  */
    1240                 :            : 
    1241                 :            : static bool
    1242                 :       7047 : ix86_eax_live_at_start_p (void)
    1243                 :            : {
    1244                 :            :   /* Cheat.  Don't bother working forward from ix86_function_regparm
    1245                 :            :      to the function type to whether an actual argument is located in
    1246                 :            :      eax.  Instead just look at cfg info, which is still close enough
    1247                 :            :      to correct at this point.  This gives false positives for broken
    1248                 :            :      functions that might use uninitialized data that happens to be
    1249                 :            :      allocated in eax, but who cares?  */
    1250                 :       7047 :   return REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR_FOR_FN (cfun)), 0);
    1251                 :            : }
    1252                 :            : 
    1253                 :            : static bool
    1254                 :     135362 : ix86_keep_aggregate_return_pointer (tree fntype)
    1255                 :            : {
    1256                 :     135362 :   tree attr;
    1257                 :            : 
    1258                 :     135362 :   if (!TARGET_64BIT)
    1259                 :            :     {
    1260                 :     135362 :       attr = lookup_attribute ("callee_pop_aggregate_return",
    1261                 :     135362 :                                TYPE_ATTRIBUTES (fntype));
    1262                 :     135362 :       if (attr)
    1263                 :          0 :         return (TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr))) == 0);
    1264                 :            : 
    1265                 :            :       /* For 32-bit MS-ABI the default is to keep aggregate
    1266                 :            :          return pointer.  */
    1267                 :     135362 :       if (ix86_function_type_abi (fntype) == MS_ABI)
    1268                 :          0 :         return true;
    1269                 :            :     }
    1270                 :            :   return KEEP_AGGREGATE_RETURN_POINTER != 0;
    1271                 :            : }
    1272                 :            : 
    1273                 :            : /* Value is the number of bytes of arguments automatically
    1274                 :            :    popped when returning from a subroutine call.
    1275                 :            :    FUNDECL is the declaration node of the function (as a tree),
    1276                 :            :    FUNTYPE is the data type of the function (as a tree),
    1277                 :            :    or for a library call it is an identifier node for the subroutine name.
    1278                 :            :    SIZE is the number of bytes of arguments passed on the stack.
    1279                 :            : 
    1280                 :            :    On the 80386, the RTD insn may be used to pop them if the number
    1281                 :            :      of args is fixed, but if the number is variable then the caller
    1282                 :            :      must pop them all.  RTD can't be used for library calls now
    1283                 :            :      because the library is compiled with the Unix compiler.
    1284                 :            :    Use of RTD is a selectable option, since it is incompatible with
    1285                 :            :    standard Unix calling sequences.  If the option is not selected,
    1286                 :            :    the caller must always pop the args.
    1287                 :            : 
    1288                 :            :    The attribute stdcall is equivalent to RTD on a per module basis.  */
    1289                 :            : 
    1290                 :            : static poly_int64
    1291                 :    4990100 : ix86_return_pops_args (tree fundecl, tree funtype, poly_int64 size)
    1292                 :            : {
    1293                 :    4990100 :   unsigned int ccvt;
    1294                 :            : 
    1295                 :            :   /* None of the 64-bit ABIs pop arguments.  */
    1296                 :    4990100 :   if (TARGET_64BIT)
    1297                 :    4274650 :     return 0;
    1298                 :            : 
    1299                 :     715452 :   ccvt = ix86_get_callcvt (funtype);
    1300                 :            : 
    1301                 :     715452 :   if ((ccvt & (IX86_CALLCVT_STDCALL | IX86_CALLCVT_FASTCALL
    1302                 :            :                | IX86_CALLCVT_THISCALL)) != 0
    1303                 :     715452 :       && ! stdarg_p (funtype))
    1304                 :          6 :     return size;
    1305                 :            : 
    1306                 :            :   /* Lose any fake structure return argument if it is passed on the stack.  */
    1307                 :     715446 :   if (aggregate_value_p (TREE_TYPE (funtype), fundecl)
    1308                 :     715446 :       && !ix86_keep_aggregate_return_pointer (funtype))
    1309                 :            :     {
    1310                 :     135362 :       int nregs = ix86_function_regparm (funtype, fundecl);
    1311                 :     135362 :       if (nregs == 0)
    1312                 :     389991 :         return GET_MODE_SIZE (Pmode);
    1313                 :            :     }
    1314                 :            : 
    1315                 :     585449 :   return 0;
    1316                 :            : }
    1317                 :            : 
    1318                 :            : /* Implement the TARGET_LEGITIMATE_COMBINED_INSN hook.  */
    1319                 :            : 
    1320                 :            : static bool
    1321                 :    5513030 : ix86_legitimate_combined_insn (rtx_insn *insn)
    1322                 :            : {
    1323                 :    5513030 :   int i;
    1324                 :            : 
    1325                 :            :   /* Check operand constraints in case hard registers were propagated
    1326                 :            :      into insn pattern.  This check prevents combine pass from
    1327                 :            :      generating insn patterns with invalid hard register operands.
    1328                 :            :      These invalid insns can eventually confuse reload to error out
    1329                 :            :      with a spill failure.  See also PRs 46829 and 46843.  */
    1330                 :            : 
    1331                 :    5513030 :   gcc_assert (INSN_CODE (insn) >= 0);
    1332                 :            : 
    1333                 :    5513030 :   extract_insn (insn);
    1334                 :    5513030 :   preprocess_constraints (insn);
    1335                 :            : 
    1336                 :    5513030 :   int n_operands = recog_data.n_operands;
    1337                 :    5513030 :   int n_alternatives = recog_data.n_alternatives;
    1338                 :   19006200 :   for (i = 0; i < n_operands; i++)
    1339                 :            :     {
    1340                 :   13496600 :       rtx op = recog_data.operand[i];
    1341                 :   13496600 :       machine_mode mode = GET_MODE (op);
    1342                 :   13496600 :       const operand_alternative *op_alt;
    1343                 :   13496600 :       int offset = 0;
    1344                 :   13496600 :       bool win;
    1345                 :   13496600 :       int j;
    1346                 :            : 
    1347                 :            :       /* A unary operator may be accepted by the predicate, but it
    1348                 :            :          is irrelevant for matching constraints.  */
    1349                 :   13496600 :       if (UNARY_P (op))
    1350                 :      24840 :         op = XEXP (op, 0);
    1351                 :            : 
    1352                 :   13496600 :       if (SUBREG_P (op))
    1353                 :            :         {
    1354                 :     611339 :           if (REG_P (SUBREG_REG (op))
    1355                 :     611339 :               && REGNO (SUBREG_REG (op)) < FIRST_PSEUDO_REGISTER)
    1356                 :         34 :             offset = subreg_regno_offset (REGNO (SUBREG_REG (op)),
    1357                 :         34 :                                           GET_MODE (SUBREG_REG (op)),
    1358                 :         34 :                                           SUBREG_BYTE (op),
    1359                 :         34 :                                           GET_MODE (op));
    1360                 :     611339 :           op = SUBREG_REG (op);
    1361                 :            :         }
    1362                 :            : 
    1363                 :   13496600 :       if (!(REG_P (op) && HARD_REGISTER_P (op)))
    1364                 :   13336600 :         continue;
    1365                 :            : 
    1366                 :     160017 :       op_alt = recog_op_alt;
    1367                 :            : 
    1368                 :            :       /* Operand has no constraints, anything is OK.  */
    1369                 :     160017 :       win = !n_alternatives;
    1370                 :            : 
    1371                 :     160017 :       alternative_mask preferred = get_preferred_alternatives (insn);
    1372                 :     250331 :       for (j = 0; j < n_alternatives; j++, op_alt += n_operands)
    1373                 :            :         {
    1374                 :     246909 :           if (!TEST_BIT (preferred, j))
    1375                 :      41834 :             continue;
    1376                 :     205075 :           if (op_alt[i].anything_ok
    1377                 :     100539 :               || (op_alt[i].matches != -1
    1378                 :      21352 :                   && operands_match_p
    1379                 :      21352 :                   (recog_data.operand[i],
    1380                 :      21352 :                    recog_data.operand[op_alt[i].matches]))
    1381                 :     301990 :               || reg_fits_class_p (op, op_alt[i].cl, offset, mode))
    1382                 :            :             {
    1383                 :            :               win = true;
    1384                 :            :               break;
    1385                 :            :             }
    1386                 :            :         }
    1387                 :            : 
    1388                 :     160017 :       if (!win)
    1389                 :            :         return false;
    1390                 :            :     }
    1391                 :            : 
    1392                 :            :   return true;
    1393                 :            : }
    1394                 :            : 
    1395                 :            : /* Implement the TARGET_ASAN_SHADOW_OFFSET hook.  */
    1396                 :            : 
    1397                 :            : static unsigned HOST_WIDE_INT
    1398                 :       1341 : ix86_asan_shadow_offset (void)
    1399                 :            : {
    1400                 :       1341 :   return TARGET_LP64 ? (TARGET_MACHO ? (HOST_WIDE_INT_1 << 44)
    1401                 :            :                                      : HOST_WIDE_INT_C (0x7fff8000))
    1402                 :       1341 :                      : (HOST_WIDE_INT_1 << 29);
    1403                 :            : }
    1404                 :            : 
    1405                 :            : /* Argument support functions.  */
    1406                 :            : 
    1407                 :            : /* Return true when register may be used to pass function parameters.  */
    1408                 :            : bool
    1409                 :  744345000 : ix86_function_arg_regno_p (int regno)
    1410                 :            : {
    1411                 :  744345000 :   int i;
    1412                 :  744345000 :   enum calling_abi call_abi;
    1413                 :  744345000 :   const int *parm_regs;
    1414                 :            : 
    1415                 :  744345000 :   if (!TARGET_64BIT)
    1416                 :            :     {
    1417                 :   80938700 :       if (TARGET_MACHO)
    1418                 :            :         return (regno < REGPARM_MAX
    1419                 :            :                 || (TARGET_SSE && SSE_REGNO_P (regno) && !fixed_regs[regno]));
    1420                 :            :       else
    1421                 :   80938700 :         return (regno < REGPARM_MAX
    1422                 :   77743600 :                 || (TARGET_MMX && MMX_REGNO_P (regno)
    1423                 :    8315080 :                     && (regno < FIRST_MMX_REG + MMX_REGPARM_MAX))
    1424                 :  155564000 :                 || (TARGET_SSE && SSE_REGNO_P (regno)
    1425                 :   33258100 :                     && (regno < FIRST_SSE_REG + SSE_REGPARM_MAX)));
    1426                 :            :     }
    1427                 :            : 
    1428                 :  663151000 :   if (TARGET_SSE && SSE_REGNO_P (regno)
    1429                 : 1217280000 :       && (regno < FIRST_SSE_REG + SSE_REGPARM_MAX))
    1430                 :            :     return true;
    1431                 :            : 
    1432                 :            :   /* TODO: The function should depend on current function ABI but
    1433                 :            :      builtins.c would need updating then. Therefore we use the
    1434                 :            :      default ABI.  */
    1435                 :  594173000 :   call_abi = ix86_cfun_abi ();
    1436                 :            : 
    1437                 :            :   /* RAX is used as hidden argument to va_arg functions.  */
    1438                 :  594173000 :   if (call_abi == SYSV_ABI && regno == AX_REG)
    1439                 :            :     return true;
    1440                 :            : 
    1441                 :  585585000 :   if (call_abi == MS_ABI)
    1442                 :            :     parm_regs = x86_64_ms_abi_int_parameter_registers;
    1443                 :            :   else
    1444                 :  575373000 :     parm_regs = x86_64_int_parameter_registers;
    1445                 :            : 
    1446                 : 7793500000 :   for (i = 0; i < (call_abi == MS_ABI
    1447                 : 3896750000 :                    ? X86_64_MS_REGPARM_MAX : X86_64_REGPARM_MAX); i++)
    1448                 : 3363290000 :     if (regno == parm_regs[i])
    1449                 :            :       return true;
    1450                 :            :   return false;
    1451                 :            : }
    1452                 :            : 
    1453                 :            : /* Return if we do not know how to pass ARG solely in registers.  */
    1454                 :            : 
    1455                 :            : static bool
    1456                 :  169491000 : ix86_must_pass_in_stack (const function_arg_info &arg)
    1457                 :            : {
    1458                 :  169491000 :   if (must_pass_in_stack_var_size_or_pad (arg))
    1459                 :            :     return true;
    1460                 :            : 
    1461                 :            :   /* For 32-bit, we want TImode aggregates to go on the stack.  But watch out!
    1462                 :            :      The layout_type routine is crafty and tries to trick us into passing
    1463                 :            :      currently unsupported vector types on the stack by using TImode.  */
    1464                 :    1432580 :   return (!TARGET_64BIT && arg.mode == TImode
    1465                 :  169491000 :           && arg.type && TREE_CODE (arg.type) != VECTOR_TYPE);
    1466                 :            : }
    1467                 :            : 
    1468                 :            : /* It returns the size, in bytes, of the area reserved for arguments passed
    1469                 :            :    in registers for the function represented by fndecl dependent to the used
    1470                 :            :    abi format.  */
    1471                 :            : int
    1472                 :    6905210 : ix86_reg_parm_stack_space (const_tree fndecl)
    1473                 :            : {
    1474                 :    6905210 :   enum calling_abi call_abi = SYSV_ABI;
    1475                 :    6905210 :   if (fndecl != NULL_TREE && TREE_CODE (fndecl) == FUNCTION_DECL)
    1476                 :    6673720 :     call_abi = ix86_function_abi (fndecl);
    1477                 :            :   else
    1478                 :     231484 :     call_abi = ix86_function_type_abi (fndecl);
    1479                 :    6905210 :   if (TARGET_64BIT && call_abi == MS_ABI)
    1480                 :      65822 :     return 32;
    1481                 :            :   return 0;
    1482                 :            : }
    1483                 :            : 
    1484                 :            : /* We add this as a workaround in order to use libc_has_function
    1485                 :            :    hook in i386.md.  */
    1486                 :            : bool
    1487                 :          0 : ix86_libc_has_function (enum function_class fn_class)
    1488                 :            : {
    1489                 :          0 :   return targetm.libc_has_function (fn_class);
    1490                 :            : }
    1491                 :            : 
    1492                 :            : /* Returns value SYSV_ABI, MS_ABI dependent on fntype,
    1493                 :            :    specifying the call abi used.  */
    1494                 :            : enum calling_abi
    1495                 :  151192000 : ix86_function_type_abi (const_tree fntype)
    1496                 :            : {
    1497                 :  151192000 :   enum calling_abi abi = ix86_abi;
    1498                 :            : 
    1499                 :  301524000 :   if (fntype == NULL_TREE || TYPE_ATTRIBUTES (fntype) == NULL_TREE)
    1500                 :            :     return abi;
    1501                 :            : 
    1502                 :    8745320 :   if (abi == SYSV_ABI
    1503                 :    8745320 :       && lookup_attribute ("ms_abi", TYPE_ATTRIBUTES (fntype)))
    1504                 :            :     {
    1505                 :    1604120 :       static int warned;
    1506                 :    1604120 :       if (TARGET_X32 && !warned)
    1507                 :            :         {
    1508                 :          1 :           error ("X32 does not support %<ms_abi%> attribute");
    1509                 :          1 :           warned = 1;
    1510                 :            :         }
    1511                 :            : 
    1512                 :            :       abi = MS_ABI;
    1513                 :            :     }
    1514                 :    7141200 :   else if (abi == MS_ABI
    1515                 :    7142310 :            && lookup_attribute ("sysv_abi", TYPE_ATTRIBUTES (fntype)))
    1516                 :            :     abi = SYSV_ABI;
    1517                 :            : 
    1518                 :            :   return abi;
    1519                 :            : }
    1520                 :            : 
    1521                 :            : enum calling_abi
    1522                 :   54185900 : ix86_function_abi (const_tree fndecl)
    1523                 :            : {
    1524                 :  108220000 :   return fndecl ? ix86_function_type_abi (TREE_TYPE (fndecl)) : ix86_abi;
    1525                 :            : }
    1526                 :            : 
    1527                 :            : /* Returns value SYSV_ABI, MS_ABI dependent on cfun,
    1528                 :            :    specifying the call abi used.  */
    1529                 :            : enum calling_abi
    1530                 : 1091700000 : ix86_cfun_abi (void)
    1531                 :            : {
    1532                 : 1091700000 :   return cfun ? cfun->machine->call_abi : ix86_abi;
    1533                 :            : }
    1534                 :            : 
    1535                 :            : bool
    1536                 :    1098420 : ix86_function_ms_hook_prologue (const_tree fn)
    1537                 :            : {
    1538                 :    2196840 :   if (fn && lookup_attribute ("ms_hook_prologue", DECL_ATTRIBUTES (fn)))
    1539                 :            :     {
    1540                 :          1 :       if (decl_function_context (fn) != NULL_TREE)
    1541                 :          0 :         error_at (DECL_SOURCE_LOCATION (fn),
    1542                 :            :                   "%<ms_hook_prologue%> attribute is not compatible "
    1543                 :            :                   "with nested function");
    1544                 :            :       else
    1545                 :            :         return true;
    1546                 :            :     }
    1547                 :            :   return false;
    1548                 :            : }
    1549                 :            : 
    1550                 :            : bool
    1551                 :   42522800 : ix86_function_naked (const_tree fn)
    1552                 :            : {
    1553                 :   85045600 :   if (fn && lookup_attribute ("naked", DECL_ATTRIBUTES (fn)))
    1554                 :        591 :     return true;
    1555                 :            : 
    1556                 :            :   return false;
    1557                 :            : }
    1558                 :            : 
    1559                 :            : /* Write the extra assembler code needed to declare a function properly.  */
    1560                 :            : 
    1561                 :            : void
    1562                 :     996282 : ix86_asm_output_function_label (FILE *asm_out_file, const char *fname,
    1563                 :            :                                 tree decl)
    1564                 :            : {
    1565                 :     996282 :   bool is_ms_hook = ix86_function_ms_hook_prologue (decl);
    1566                 :            : 
    1567                 :     996282 :   if (is_ms_hook)
    1568                 :            :     {
    1569                 :          1 :       int i, filler_count = (TARGET_64BIT ? 32 : 16);
    1570                 :          1 :       unsigned int filler_cc = 0xcccccccc;
    1571                 :            : 
    1572                 :          9 :       for (i = 0; i < filler_count; i += 4)
    1573                 :          8 :         fprintf (asm_out_file, ASM_LONG " %#x\n", filler_cc);
    1574                 :            :     }
    1575                 :            : 
    1576                 :            : #ifdef SUBTARGET_ASM_UNWIND_INIT
    1577                 :            :   SUBTARGET_ASM_UNWIND_INIT (asm_out_file);
    1578                 :            : #endif
    1579                 :            : 
    1580                 :     996282 :   ASM_OUTPUT_LABEL (asm_out_file, fname);
    1581                 :            : 
    1582                 :            :   /* Output magic byte marker, if hot-patch attribute is set.  */
    1583                 :     996282 :   if (is_ms_hook)
    1584                 :            :     {
    1585                 :          1 :       if (TARGET_64BIT)
    1586                 :            :         {
    1587                 :            :           /* leaq [%rsp + 0], %rsp  */
    1588                 :          1 :           fputs (ASM_BYTE "0x48, 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00\n",
    1589                 :            :                  asm_out_file);
    1590                 :            :         }
    1591                 :            :       else
    1592                 :            :         {
    1593                 :            :           /* movl.s %edi, %edi
    1594                 :            :              push   %ebp
    1595                 :            :              movl.s %esp, %ebp */
    1596                 :          0 :           fputs (ASM_BYTE "0x8b, 0xff, 0x55, 0x8b, 0xec\n", asm_out_file);
    1597                 :            :         }
    1598                 :            :     }
    1599                 :     996282 : }
    1600                 :            : 
    1601                 :            : /* Implementation of call abi switching target hook. Specific to FNDECL
    1602                 :            :    the specific call register sets are set.  See also
    1603                 :            :    ix86_conditional_register_usage for more details.  */
    1604                 :            : void
    1605                 :   40932300 : ix86_call_abi_override (const_tree fndecl)
    1606                 :            : {
    1607                 :   40932300 :   cfun->machine->call_abi = ix86_function_abi (fndecl);
    1608                 :   40932300 : }
    1609                 :            : 
    1610                 :            : /* Return 1 if pseudo register should be created and used to hold
    1611                 :            :    GOT address for PIC code.  */
    1612                 :            : bool
    1613                 :   90206900 : ix86_use_pseudo_pic_reg (void)
    1614                 :            : {
    1615                 :   90206900 :   if ((TARGET_64BIT
    1616                 :   81621800 :        && (ix86_cmodel == CM_SMALL_PIC
    1617                 :            :            || TARGET_PECOFF))
    1618                 :   86487400 :       || !flag_pic)
    1619                 :   86503300 :     return false;
    1620                 :            :   return true;
    1621                 :            : }
    1622                 :            : 
    1623                 :            : /* Initialize large model PIC register.  */
    1624                 :            : 
    1625                 :            : static void
    1626                 :         40 : ix86_init_large_pic_reg (unsigned int tmp_regno)
    1627                 :            : {
    1628                 :         40 :   rtx_code_label *label;
    1629                 :         40 :   rtx tmp_reg;
    1630                 :            : 
    1631                 :         40 :   gcc_assert (Pmode == DImode);
    1632                 :         40 :   label = gen_label_rtx ();
    1633                 :         40 :   emit_label (label);
    1634                 :         40 :   LABEL_PRESERVE_P (label) = 1;
    1635                 :         40 :   tmp_reg = gen_rtx_REG (Pmode, tmp_regno);
    1636                 :         40 :   gcc_assert (REGNO (pic_offset_table_rtx) != tmp_regno);
    1637                 :         40 :   emit_insn (gen_set_rip_rex64 (pic_offset_table_rtx,
    1638                 :            :                                 label));
    1639                 :         40 :   emit_insn (gen_set_got_offset_rex64 (tmp_reg, label));
    1640                 :         40 :   emit_insn (gen_add2_insn (pic_offset_table_rtx, tmp_reg));
    1641                 :         40 :   const char *name = LABEL_NAME (label);
    1642                 :         40 :   PUT_CODE (label, NOTE);
    1643                 :         40 :   NOTE_KIND (label) = NOTE_INSN_DELETED_LABEL;
    1644                 :         40 :   NOTE_DELETED_LABEL_NAME (label) = name;
    1645                 :         40 : }
    1646                 :            : 
    1647                 :            : /* Create and initialize PIC register if required.  */
    1648                 :            : static void
    1649                 :     942959 : ix86_init_pic_reg (void)
    1650                 :            : {
    1651                 :     942959 :   edge entry_edge;
    1652                 :     942959 :   rtx_insn *seq;
    1653                 :            : 
    1654                 :     942959 :   if (!ix86_use_pseudo_pic_reg ())
    1655                 :            :     return;
    1656                 :            : 
    1657                 :      30794 :   start_sequence ();
    1658                 :            : 
    1659                 :      30794 :   if (TARGET_64BIT)
    1660                 :            :     {
    1661                 :         53 :       if (ix86_cmodel == CM_LARGE_PIC)
    1662                 :         36 :         ix86_init_large_pic_reg (R11_REG);
    1663                 :            :       else
    1664                 :         17 :         emit_insn (gen_set_got_rex64 (pic_offset_table_rtx));
    1665                 :            :     }
    1666                 :            :   else
    1667                 :            :     {
    1668                 :            :       /*  If there is future mcount call in the function it is more profitable
    1669                 :            :           to emit SET_GOT into ABI defined REAL_PIC_OFFSET_TABLE_REGNUM.  */
    1670                 :      30741 :       rtx reg = crtl->profile
    1671                 :      30741 :                 ? gen_rtx_REG (Pmode, REAL_PIC_OFFSET_TABLE_REGNUM)
    1672                 :      30741 :                 : pic_offset_table_rtx;
    1673                 :      30741 :       rtx_insn *insn = emit_insn (gen_set_got (reg));
    1674                 :      30741 :       RTX_FRAME_RELATED_P (insn) = 1;
    1675                 :      30741 :       if (crtl->profile)
    1676                 :          0 :         emit_move_insn (pic_offset_table_rtx, reg);
    1677                 :      30741 :       add_reg_note (insn, REG_CFA_FLUSH_QUEUE, NULL_RTX);
    1678                 :            :     }
    1679                 :            : 
    1680                 :      30794 :   seq = get_insns ();
    1681                 :      30794 :   end_sequence ();
    1682                 :            : 
    1683                 :      30794 :   entry_edge = single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun));
    1684                 :      30794 :   insert_insn_on_edge (seq, entry_edge);
    1685                 :      30794 :   commit_one_edge_insertion (entry_edge);
    1686                 :            : }
    1687                 :            : 
    1688                 :            : /* Initialize a variable CUM of type CUMULATIVE_ARGS
    1689                 :            :    for a call to a function whose data type is FNTYPE.
    1690                 :            :    For a library call, FNTYPE is 0.  */
    1691                 :            : 
    1692                 :            : void
    1693                 :    6793520 : init_cumulative_args (CUMULATIVE_ARGS *cum,  /* Argument info to initialize */
    1694                 :            :                       tree fntype,      /* tree ptr for function decl */
    1695                 :            :                       rtx libname,      /* SYMBOL_REF of library name or 0 */
    1696                 :            :                       tree fndecl,
    1697                 :            :                       int caller)
    1698                 :            : {
    1699                 :    6793520 :   struct cgraph_node *local_info_node = NULL;
    1700                 :    6793520 :   struct cgraph_node *target = NULL;
    1701                 :            : 
    1702                 :    6793520 :   memset (cum, 0, sizeof (*cum));
    1703                 :            : 
    1704                 :    6793520 :   if (fndecl)
    1705                 :            :     {
    1706                 :    6542200 :       target = cgraph_node::get (fndecl);
    1707                 :    6542200 :       if (target)
    1708                 :            :         {
    1709                 :    6461180 :           target = target->function_symbol ();
    1710                 :    6461180 :           local_info_node = cgraph_node::local_info_node (target->decl);
    1711                 :    6461180 :           cum->call_abi = ix86_function_abi (target->decl);
    1712                 :            :         }
    1713                 :            :       else
    1714                 :      81018 :         cum->call_abi = ix86_function_abi (fndecl);
    1715                 :            :     }
    1716                 :            :   else
    1717                 :     251321 :     cum->call_abi = ix86_function_type_abi (fntype);
    1718                 :            : 
    1719                 :    6793520 :   cum->caller = caller;
    1720                 :            : 
    1721                 :            :   /* Set up the number of registers to use for passing arguments.  */
    1722                 :    6793520 :   cum->nregs = ix86_regparm;
    1723                 :    6793520 :   if (TARGET_64BIT)
    1724                 :            :     {
    1725                 :    5957850 :       cum->nregs = (cum->call_abi == SYSV_ABI
    1726                 :    5957850 :                    ? X86_64_REGPARM_MAX
    1727                 :            :                    : X86_64_MS_REGPARM_MAX);
    1728                 :            :     }
    1729                 :    6793520 :   if (TARGET_SSE)
    1730                 :            :     {
    1731                 :    6779390 :       cum->sse_nregs = SSE_REGPARM_MAX;
    1732                 :    6779390 :       if (TARGET_64BIT)
    1733                 :            :         {
    1734                 :    5956670 :           cum->sse_nregs = (cum->call_abi == SYSV_ABI
    1735                 :    5956670 :                            ? X86_64_SSE_REGPARM_MAX
    1736                 :            :                            : X86_64_MS_SSE_REGPARM_MAX);
    1737                 :            :         }
    1738                 :            :     }
    1739                 :    6793520 :   if (TARGET_MMX)
    1740                 :    7462520 :     cum->mmx_nregs = MMX_REGPARM_MAX;
    1741                 :    6793520 :   cum->warn_avx512f = true;
    1742                 :    6793520 :   cum->warn_avx = true;
    1743                 :    6793520 :   cum->warn_sse = true;
    1744                 :    6793520 :   cum->warn_mmx = true;
    1745                 :            : 
    1746                 :            :   /* Because type might mismatch in between caller and callee, we need to
    1747                 :            :      use actual type of function for local calls.
    1748                 :            :      FIXME: cgraph_analyze can be told to actually record if function uses
    1749                 :            :      va_start so for local functions maybe_vaarg can be made aggressive
    1750                 :            :      helping K&R code.
    1751                 :            :      FIXME: once typesytem is fixed, we won't need this code anymore.  */
    1752                 :    6793520 :   if (local_info_node && local_info_node->local
    1753                 :    6461180 :       && local_info_node->can_change_signature)
    1754                 :     237494 :     fntype = TREE_TYPE (target->decl);
    1755                 :    6793520 :   cum->stdarg = stdarg_p (fntype);
    1756                 :   13587000 :   cum->maybe_vaarg = (fntype
    1757                 :    6996320 :                       ? (!prototype_p (fntype) || stdarg_p (fntype))
    1758                 :      86440 :                       : !libname);
    1759                 :            : 
    1760                 :    6793520 :   cum->decl = fndecl;
    1761                 :            : 
    1762                 :    6793520 :   cum->warn_empty = !warn_abi || cum->stdarg;
    1763                 :    6793520 :   if (!cum->warn_empty && fntype)
    1764                 :            :     {
    1765                 :      93570 :       function_args_iterator iter;
    1766                 :      93570 :       tree argtype;
    1767                 :      93570 :       bool seen_empty_type = false;
    1768                 :     266382 :       FOREACH_FUNCTION_ARGS (fntype, argtype, iter)
    1769                 :            :         {
    1770                 :     266382 :           if (argtype == error_mark_node || VOID_TYPE_P (argtype))
    1771                 :            :             break;
    1772                 :     173206 :           if (TYPE_EMPTY_P (argtype))
    1773                 :            :             seen_empty_type = true;
    1774                 :     172369 :           else if (seen_empty_type)
    1775                 :            :             {
    1776                 :        394 :               cum->warn_empty = true;
    1777                 :        394 :               break;
    1778                 :            :             }
    1779                 :            :         }
    1780                 :            :     }
    1781                 :            : 
    1782                 :    6793520 :   if (!TARGET_64BIT)
    1783                 :            :     {
    1784                 :            :       /* If there are variable arguments, then we won't pass anything
    1785                 :            :          in registers in 32-bit mode. */
    1786                 :     835670 :       if (stdarg_p (fntype))
    1787                 :            :         {
    1788                 :       7379 :           cum->nregs = 0;
    1789                 :            :           /* Since in 32-bit, variable arguments are always passed on
    1790                 :            :              stack, there is scratch register available for indirect
    1791                 :            :              sibcall.  */
    1792                 :       7379 :           cfun->machine->arg_reg_available = true;
    1793                 :       7379 :           cum->sse_nregs = 0;
    1794                 :       7379 :           cum->mmx_nregs = 0;
    1795                 :       7379 :           cum->warn_avx512f = false;
    1796                 :       7379 :           cum->warn_avx = false;
    1797                 :       7379 :           cum->warn_sse = false;
    1798                 :       7379 :           cum->warn_mmx = false;
    1799                 :       7379 :           return;
    1800                 :            :         }
    1801                 :            : 
    1802                 :            :       /* Use ecx and edx registers if function has fastcall attribute,
    1803                 :            :          else look for regparm information.  */
    1804                 :     828291 :       if (fntype)
    1805                 :            :         {
    1806                 :     815862 :           unsigned int ccvt = ix86_get_callcvt (fntype);
    1807                 :     815862 :           if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
    1808                 :            :             {
    1809                 :          0 :               cum->nregs = 1;
    1810                 :          0 :               cum->fastcall = 1; /* Same first register as in fastcall.  */
    1811                 :            :             }
    1812                 :     815862 :           else if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
    1813                 :            :             {
    1814                 :          8 :               cum->nregs = 2;
    1815                 :          8 :               cum->fastcall = 1;
    1816                 :            :             }
    1817                 :            :           else
    1818                 :     815854 :             cum->nregs = ix86_function_regparm (fntype, fndecl);
    1819                 :            :         }
    1820                 :            : 
    1821                 :            :       /* Set up the number of SSE registers used for passing SFmode
    1822                 :            :          and DFmode arguments.  Warn for mismatching ABI.  */
    1823                 :     828291 :       cum->float_in_sse = ix86_function_sseregparm (fntype, fndecl, true);
    1824                 :            :     }
    1825                 :            : 
    1826                 :    6786140 :   cfun->machine->arg_reg_available = (cum->nregs > 0);
    1827                 :            : }
    1828                 :            : 
    1829                 :            : /* Return the "natural" mode for TYPE.  In most cases, this is just TYPE_MODE.
    1830                 :            :    But in the case of vector types, it is some vector mode.
    1831                 :            : 
    1832                 :            :    When we have only some of our vector isa extensions enabled, then there
    1833                 :            :    are some modes for which vector_mode_supported_p is false.  For these
    1834                 :            :    modes, the generic vector support in gcc will choose some non-vector mode
    1835                 :            :    in order to implement the type.  By computing the natural mode, we'll
    1836                 :            :    select the proper ABI location for the operand and not depend on whatever
    1837                 :            :    the middle-end decides to do with these vector types.
    1838                 :            : 
    1839                 :            :    The midde-end can't deal with the vector types > 16 bytes.  In this
    1840                 :            :    case, we return the original mode and warn ABI change if CUM isn't
    1841                 :            :    NULL. 
    1842                 :            : 
    1843                 :            :    If INT_RETURN is true, warn ABI change if the vector mode isn't
    1844                 :            :    available for function return value.  */
    1845                 :            : 
    1846                 :            : static machine_mode
    1847                 :  100911000 : type_natural_mode (const_tree type, const CUMULATIVE_ARGS *cum,
    1848                 :            :                    bool in_return)
    1849                 :            : {
    1850                 :  100911000 :   machine_mode mode = TYPE_MODE (type);
    1851                 :            : 
    1852                 :  100911000 :   if (TREE_CODE (type) == VECTOR_TYPE && !VECTOR_MODE_P (mode))
    1853                 :            :     {
    1854                 :     438145 :       HOST_WIDE_INT size = int_size_in_bytes (type);
    1855                 :     425947 :       if ((size == 8 || size == 16 || size == 32 || size == 64)
    1856                 :            :           /* ??? Generic code allows us to create width 1 vectors.  Ignore.  */
    1857                 :     864092 :           && TYPE_VECTOR_SUBPARTS (type) > 1)
    1858                 :            :         {
    1859                 :     405922 :           machine_mode innermode = TYPE_MODE (TREE_TYPE (type));
    1860                 :            : 
    1861                 :            :           /* There are no XFmode vector modes.  */
    1862                 :     405922 :           if (innermode == XFmode)
    1863                 :            :             return mode;
    1864                 :            : 
    1865                 :     405447 :           if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
    1866                 :            :             mode = MIN_MODE_VECTOR_FLOAT;
    1867                 :            :           else
    1868                 :     340750 :             mode = MIN_MODE_VECTOR_INT;
    1869                 :            : 
    1870                 :            :           /* Get the mode which has this inner mode and number of units.  */
    1871                 :    7790230 :           FOR_EACH_MODE_FROM (mode, mode)
    1872                 :   16037000 :             if (GET_MODE_NUNITS (mode) == TYPE_VECTOR_SUBPARTS (type)
    1873                 :    8652180 :                 && GET_MODE_INNER (mode) == innermode)
    1874                 :            :               {
    1875                 :     405447 :                 if (size == 64 && !TARGET_AVX512F && !TARGET_IAMCU)
    1876                 :            :                   {
    1877                 :     276484 :                     static bool warnedavx512f;
    1878                 :     276484 :                     static bool warnedavx512f_ret;
    1879                 :            : 
    1880                 :     276484 :                     if (cum && cum->warn_avx512f && !warnedavx512f)
    1881                 :            :                       {
    1882                 :        739 :                         if (warning (OPT_Wpsabi, "AVX512F vector argument "
    1883                 :            :                                      "without AVX512F enabled changes the ABI"))
    1884                 :          2 :                           warnedavx512f = true;
    1885                 :            :                       }
    1886                 :     275745 :                     else if (in_return && !warnedavx512f_ret)
    1887                 :            :                       {
    1888                 :     273700 :                         if (warning (OPT_Wpsabi, "AVX512F vector return "
    1889                 :            :                                      "without AVX512F enabled changes the ABI"))
    1890                 :          2 :                           warnedavx512f_ret = true;
    1891                 :            :                       }
    1892                 :            : 
    1893                 :     276484 :                     return TYPE_MODE (type);
    1894                 :            :                   }
    1895                 :     128963 :                 else if (size == 32 && !TARGET_AVX && !TARGET_IAMCU)
    1896                 :            :                   {
    1897                 :     127506 :                     static bool warnedavx;
    1898                 :     127506 :                     static bool warnedavx_ret;
    1899                 :            : 
    1900                 :     127506 :                     if (cum && cum->warn_avx && !warnedavx)
    1901                 :            :                       {
    1902                 :        523 :                         if (warning (OPT_Wpsabi, "AVX vector argument "
    1903                 :            :                                      "without AVX enabled changes the ABI"))
    1904                 :          5 :                           warnedavx = true;
    1905                 :            :                       }
    1906                 :     126983 :                     else if (in_return && !warnedavx_ret)
    1907                 :            :                       {
    1908                 :     125230 :                         if (warning (OPT_Wpsabi, "AVX vector return "
    1909                 :            :                                      "without AVX enabled changes the ABI"))
    1910                 :          7 :                           warnedavx_ret = true;
    1911                 :            :                       }
    1912                 :            : 
    1913                 :     127506 :                     return TYPE_MODE (type);
    1914                 :            :                   }
    1915                 :       1457 :                 else if (((size == 8 && TARGET_64BIT) || size == 16)
    1916                 :       1457 :                          && !TARGET_SSE
    1917                 :         68 :                          && !TARGET_IAMCU)
    1918                 :            :                   {
    1919                 :         68 :                     static bool warnedsse;
    1920                 :         68 :                     static bool warnedsse_ret;
    1921                 :            : 
    1922                 :         68 :                     if (cum && cum->warn_sse && !warnedsse)
    1923                 :            :                       {
    1924                 :         17 :                         if (warning (OPT_Wpsabi, "SSE vector argument "
    1925                 :            :                                      "without SSE enabled changes the ABI"))
    1926                 :          4 :                           warnedsse = true;
    1927                 :            :                       }
    1928                 :         51 :                     else if (!TARGET_64BIT && in_return && !warnedsse_ret)
    1929                 :            :                       {
    1930                 :          0 :                         if (warning (OPT_Wpsabi, "SSE vector return "
    1931                 :            :                                      "without SSE enabled changes the ABI"))
    1932                 :          0 :                           warnedsse_ret = true;
    1933                 :            :                       }
    1934                 :            :                   }
    1935                 :       1389 :                 else if ((size == 8 && !TARGET_64BIT)
    1936                 :          0 :                          && (!cfun
    1937                 :          0 :                              || cfun->machine->func_type == TYPE_NORMAL)
    1938                 :          0 :                          && !TARGET_MMX
    1939                 :          0 :                          && !TARGET_IAMCU)
    1940                 :            :                   {
    1941                 :          0 :                     static bool warnedmmx;
    1942                 :          0 :                     static bool warnedmmx_ret;
    1943                 :            : 
    1944                 :          0 :                     if (cum && cum->warn_mmx && !warnedmmx)
    1945                 :            :                       {
    1946                 :          0 :                         if (warning (OPT_Wpsabi, "MMX vector argument "
    1947                 :            :                                      "without MMX enabled changes the ABI"))
    1948                 :          0 :                           warnedmmx = true;
    1949                 :            :                       }
    1950                 :          0 :                     else if (in_return && !warnedmmx_ret)
    1951                 :            :                       {
    1952                 :          0 :                         if (warning (OPT_Wpsabi, "MMX vector return "
    1953                 :            :                                      "without MMX enabled changes the ABI"))
    1954                 :          0 :                           warnedmmx_ret = true;
    1955                 :            :                       }
    1956                 :            :                   }
    1957                 :       1457 :                 return mode;
    1958                 :            :               }
    1959                 :            : 
    1960                 :          0 :           gcc_unreachable ();
    1961                 :            :         }
    1962                 :            :     }
    1963                 :            : 
    1964                 :            :   return mode;
    1965                 :            : }
    1966                 :            : 
    1967                 :            : /* We want to pass a value in REGNO whose "natural" mode is MODE.  However,
    1968                 :            :    this may not agree with the mode that the type system has chosen for the
    1969                 :            :    register, which is ORIG_MODE.  If ORIG_MODE is not BLKmode, then we can
    1970                 :            :    go ahead and use it.  Otherwise we have to build a PARALLEL instead.  */
    1971                 :            : 
    1972                 :            : static rtx
    1973                 :   18194700 : gen_reg_or_parallel (machine_mode mode, machine_mode orig_mode,
    1974                 :            :                      unsigned int regno)
    1975                 :            : {
    1976                 :   18194700 :   rtx tmp;
    1977                 :            : 
    1978                 :   18194700 :   if (orig_mode != BLKmode)
    1979                 :   18194100 :     tmp = gen_rtx_REG (orig_mode, regno);
    1980                 :            :   else
    1981                 :            :     {
    1982                 :        680 :       tmp = gen_rtx_REG (mode, regno);
    1983                 :        680 :       tmp = gen_rtx_EXPR_LIST (VOIDmode, tmp, const0_rtx);
    1984                 :        680 :       tmp = gen_rtx_PARALLEL (orig_mode, gen_rtvec (1, tmp));
    1985                 :            :     }
    1986                 :            : 
    1987                 :   18194700 :   return tmp;
    1988                 :            : }
    1989                 :            : 
    1990                 :            : /* x86-64 register passing implementation.  See x86-64 ABI for details.  Goal
    1991                 :            :    of this code is to classify each 8bytes of incoming argument by the register
    1992                 :            :    class and assign registers accordingly.  */
    1993                 :            : 
    1994                 :            : /* Return the union class of CLASS1 and CLASS2.
    1995                 :            :    See the x86-64 PS ABI for details.  */
    1996                 :            : 
    1997                 :            : static enum x86_64_reg_class
    1998                 :   12743900 : merge_classes (enum x86_64_reg_class class1, enum x86_64_reg_class class2)
    1999                 :            : {
    2000                 :            :   /* Rule #1: If both classes are equal, this is the resulting class.  */
    2001                 :   12743900 :   if (class1 == class2)
    2002                 :            :     return class1;
    2003                 :            : 
    2004                 :            :   /* Rule #2: If one of the classes is NO_CLASS, the resulting class is
    2005                 :            :      the other class.  */
    2006                 :   11591700 :   if (class1 == X86_64_NO_CLASS)
    2007                 :            :     return class2;
    2008                 :   11554700 :   if (class2 == X86_64_NO_CLASS)
    2009                 :            :     return class1;
    2010                 :            : 
    2011                 :            :   /* Rule #3: If one of the classes is MEMORY, the result is MEMORY.  */
    2012                 :     423924 :   if (class1 == X86_64_MEMORY_CLASS || class2 == X86_64_MEMORY_CLASS)
    2013                 :            :     return X86_64_MEMORY_CLASS;
    2014                 :            : 
    2015                 :            :   /* Rule #4: If one of the classes is INTEGER, the result is INTEGER.  */
    2016                 :     423330 :   if ((class1 == X86_64_INTEGERSI_CLASS && class2 == X86_64_SSESF_CLASS)
    2017                 :     422163 :       || (class2 == X86_64_INTEGERSI_CLASS && class1 == X86_64_SSESF_CLASS))
    2018                 :            :     return X86_64_INTEGERSI_CLASS;
    2019                 :     418336 :   if (class1 == X86_64_INTEGER_CLASS || class1 == X86_64_INTEGERSI_CLASS
    2020                 :      86580 :       || class2 == X86_64_INTEGER_CLASS || class2 == X86_64_INTEGERSI_CLASS)
    2021                 :            :     return X86_64_INTEGER_CLASS;
    2022                 :            : 
    2023                 :            :   /* Rule #5: If one of the classes is X87, X87UP, or COMPLEX_X87 class,
    2024                 :            :      MEMORY is used.  */
    2025                 :      47754 :   if (class1 == X86_64_X87_CLASS
    2026                 :            :       || class1 == X86_64_X87UP_CLASS
    2027                 :      47754 :       || class1 == X86_64_COMPLEX_X87_CLASS
    2028                 :            :       || class2 == X86_64_X87_CLASS
    2029                 :      47339 :       || class2 == X86_64_X87UP_CLASS
    2030                 :      47064 :       || class2 == X86_64_COMPLEX_X87_CLASS)
    2031                 :        690 :     return X86_64_MEMORY_CLASS;
    2032                 :            : 
    2033                 :            :   /* Rule #6: Otherwise class SSE is used.  */
    2034                 :            :   return X86_64_SSE_CLASS;
    2035                 :            : }
    2036                 :            : 
    2037                 :            : /* Classify the argument of type TYPE and mode MODE.
    2038                 :            :    CLASSES will be filled by the register class used to pass each word
    2039                 :            :    of the operand.  The number of words is returned.  In case the parameter
    2040                 :            :    should be passed in memory, 0 is returned. As a special case for zero
    2041                 :            :    sized containers, classes[0] will be NO_CLASS and 1 is returned.
    2042                 :            : 
    2043                 :            :    BIT_OFFSET is used internally for handling records and specifies offset
    2044                 :            :    of the offset in bits modulo 512 to avoid overflow cases.
    2045                 :            : 
    2046                 :            :    See the x86-64 PS ABI for details.
    2047                 :            : */
    2048                 :            : 
    2049                 :            : static int
    2050                 :  160260000 : classify_argument (machine_mode mode, const_tree type,
    2051                 :            :                    enum x86_64_reg_class classes[MAX_CLASSES], int bit_offset)
    2052                 :            : {
    2053                 :  160260000 :   HOST_WIDE_INT bytes
    2054                 :  318940000 :     = mode == BLKmode ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
    2055                 :  160260000 :   int words = CEIL (bytes + (bit_offset % 64) / 8, UNITS_PER_WORD);
    2056                 :            : 
    2057                 :            :   /* Variable sized entities are always passed/returned in memory.  */
    2058                 :  160260000 :   if (bytes < 0)
    2059                 :            :     return 0;
    2060                 :            : 
    2061                 :  160260000 :   if (mode != VOIDmode)
    2062                 :            :     {
    2063                 :            :       /* The value of "named" doesn't matter.  */
    2064                 :  160074000 :       function_arg_info arg (const_cast<tree> (type), mode, /*named=*/true);
    2065                 :  160074000 :       if (targetm.calls.must_pass_in_stack (arg))
    2066                 :          0 :         return 0;
    2067                 :            :     }
    2068                 :            : 
    2069                 :  160260000 :   if (type && AGGREGATE_TYPE_P (type))
    2070                 :            :     {
    2071                 :    6941600 :       int i;
    2072                 :    6941600 :       tree field;
    2073                 :    6941600 :       enum x86_64_reg_class subclasses[MAX_CLASSES];
    2074                 :            : 
    2075                 :            :       /* On x86-64 we pass structures larger than 64 bytes on the stack.  */
    2076                 :    6941600 :       if (bytes > 64)
    2077                 :            :         return 0;
    2078                 :            : 
    2079                 :   19206100 :       for (i = 0; i < words; i++)
    2080                 :   12393400 :         classes[i] = X86_64_NO_CLASS;
    2081                 :            : 
    2082                 :            :       /* Zero sized arrays or structures are NO_CLASS.  We return 0 to
    2083                 :            :          signalize memory class, so handle it as special case.  */
    2084                 :    6812720 :       if (!words)
    2085                 :            :         {
    2086                 :      48367 :           classes[0] = X86_64_NO_CLASS;
    2087                 :      48367 :           return 1;
    2088                 :            :         }
    2089                 :            : 
    2090                 :            :       /* Classify each field of record and merge classes.  */
    2091                 :    6764360 :       switch (TREE_CODE (type))
    2092                 :            :         {
    2093                 :    6403000 :         case RECORD_TYPE:
    2094                 :            :           /* And now merge the fields of structure.  */
    2095                 :  111734000 :           for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
    2096                 :            :             {
    2097                 :  105417000 :               if (TREE_CODE (field) == FIELD_DECL)
    2098                 :            :                 {
    2099                 :   11182200 :                   int num;
    2100                 :            : 
    2101                 :   11182200 :                   if (TREE_TYPE (field) == error_mark_node)
    2102                 :          5 :                     continue;
    2103                 :            : 
    2104                 :            :                   /* Bitfields are always classified as integer.  Handle them
    2105                 :            :                      early, since later code would consider them to be
    2106                 :            :                      misaligned integers.  */
    2107                 :   11182200 :                   if (DECL_BIT_FIELD (field))
    2108                 :            :                     {
    2109                 :     201408 :                       for (i = (int_bit_position (field)
    2110                 :     201408 :                                 + (bit_offset % 64)) / 8 / 8;
    2111                 :     402989 :                            i < ((int_bit_position (field) + (bit_offset % 64))
    2112                 :     402989 :                                 + tree_to_shwi (DECL_SIZE (field))
    2113                 :     402989 :                                 + 63) / 8 / 8; i++)
    2114                 :     201581 :                         classes[i]
    2115                 :     201581 :                           = merge_classes (X86_64_INTEGER_CLASS, classes[i]);
    2116                 :            :                     }
    2117                 :            :                   else
    2118                 :            :                     {
    2119                 :   10980800 :                       int pos;
    2120                 :            : 
    2121                 :   10980800 :                       type = TREE_TYPE (field);
    2122                 :            : 
    2123                 :            :                       /* Flexible array member is ignored.  */
    2124                 :   10980800 :                       if (TYPE_MODE (type) == BLKmode
    2125                 :     156321 :                           && TREE_CODE (type) == ARRAY_TYPE
    2126                 :      95397 :                           && TYPE_SIZE (type) == NULL_TREE
    2127                 :       1637 :                           && TYPE_DOMAIN (type) != NULL_TREE
    2128                 :   10982000 :                           && (TYPE_MAX_VALUE (TYPE_DOMAIN (type))
    2129                 :            :                               == NULL_TREE))
    2130                 :            :                         {
    2131                 :       1202 :                           static bool warned;
    2132                 :            : 
    2133                 :       1202 :                           if (!warned && warn_psabi)
    2134                 :            :                             {
    2135                 :          2 :                               warned = true;
    2136                 :          2 :                               inform (input_location,
    2137                 :            :                                       "the ABI of passing struct with"
    2138                 :            :                                       " a flexible array member has"
    2139                 :            :                                       " changed in GCC 4.4");
    2140                 :            :                             }
    2141                 :       1202 :                           continue;
    2142                 :            :                         }
    2143                 :   10979600 :                       num = classify_argument (TYPE_MODE (type), type,
    2144                 :            :                                                subclasses,
    2145                 :   10979600 :                                                (int_bit_position (field)
    2146                 :   10979600 :                                                 + bit_offset) % 512);
    2147                 :   10979600 :                       if (!num)
    2148                 :            :                         return 0;
    2149                 :   10893000 :                       pos = (int_bit_position (field)
    2150                 :   10893000 :                              + (bit_offset % 64)) / 8 / 8;
    2151                 :   22965100 :                       for (i = 0; i < num && (i + pos) < words; i++)
    2152                 :   12072100 :                         classes[i + pos]
    2153                 :   12072100 :                           = merge_classes (subclasses[i], classes[i + pos]);
    2154                 :            :                     }
    2155                 :            :                 }
    2156                 :            :             }
    2157                 :            :           break;
    2158                 :            : 
    2159                 :     210169 :         case ARRAY_TYPE:
    2160                 :            :           /* Arrays are handled as small records.  */
    2161                 :     210169 :           {
    2162                 :     210169 :             int num;
    2163                 :     210169 :             num = classify_argument (TYPE_MODE (TREE_TYPE (type)),
    2164                 :     210169 :                                      TREE_TYPE (type), subclasses, bit_offset);
    2165                 :     210169 :             if (!num)
    2166                 :            :               return 0;
    2167                 :            : 
    2168                 :            :             /* The partial classes are now full classes.  */
    2169                 :     207992 :             if (subclasses[0] == X86_64_SSESF_CLASS && bytes != 4)
    2170                 :       9562 :               subclasses[0] = X86_64_SSE_CLASS;
    2171                 :     207992 :             if (subclasses[0] == X86_64_INTEGERSI_CLASS
    2172                 :      98088 :                 && !((bit_offset % 64) == 0 && bytes == 4))
    2173                 :      79651 :               subclasses[0] = X86_64_INTEGER_CLASS;
    2174                 :            : 
    2175                 :     669836 :             for (i = 0; i < words; i++)
    2176                 :     461844 :               classes[i] = subclasses[i % num];
    2177                 :            : 
    2178                 :            :             break;
    2179                 :            :           }
    2180                 :     151187 :         case UNION_TYPE:
    2181                 :     151187 :         case QUAL_UNION_TYPE:
    2182                 :            :           /* Unions are similar to RECORD_TYPE but offset is always 0.
    2183                 :            :              */
    2184                 :    1561990 :           for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
    2185                 :            :             {
    2186                 :    1428940 :               if (TREE_CODE (field) == FIELD_DECL)
    2187                 :            :                 {
    2188                 :     387808 :                   int num;
    2189                 :            : 
    2190                 :     387808 :                   if (TREE_TYPE (field) == error_mark_node)
    2191                 :          1 :                     continue;
    2192                 :            : 
    2193                 :     387807 :                   num = classify_argument (TYPE_MODE (TREE_TYPE (field)),
    2194                 :     387807 :                                            TREE_TYPE (field), subclasses,
    2195                 :            :                                            bit_offset);
    2196                 :     387807 :                   if (!num)
    2197                 :            :                     return 0;
    2198                 :     839897 :                   for (i = 0; i < num && i < words; i++)
    2199                 :     470223 :                     classes[i] = merge_classes (subclasses[i], classes[i]);
    2200                 :            :                 }
    2201                 :            :             }
    2202                 :            :           break;
    2203                 :            : 
    2204                 :          0 :         default:
    2205                 :          0 :           gcc_unreachable ();
    2206                 :            :         }
    2207                 :            : 
    2208                 :    6657460 :       if (words > 2)
    2209                 :            :         {
    2210                 :            :           /* When size > 16 bytes, if the first one isn't
    2211                 :            :              X86_64_SSE_CLASS or any other ones aren't
    2212                 :            :              X86_64_SSEUP_CLASS, everything should be passed in
    2213                 :            :              memory.  */
    2214                 :     640646 :           if (classes[0] != X86_64_SSE_CLASS)
    2215                 :            :               return 0;
    2216                 :            : 
    2217                 :      46167 :           for (i = 1; i < words; i++)
    2218                 :      42078 :             if (classes[i] != X86_64_SSEUP_CLASS)
    2219                 :            :               return 0;
    2220                 :            :         }
    2221                 :            : 
    2222                 :            :       /* Final merger cleanup.  */
    2223                 :   15572100 :       for (i = 0; i < words; i++)
    2224                 :            :         {
    2225                 :            :           /* If one class is MEMORY, everything should be passed in
    2226                 :            :              memory.  */
    2227                 :    9553590 :           if (classes[i] == X86_64_MEMORY_CLASS)
    2228                 :            :             return 0;
    2229                 :            : 
    2230                 :            :           /* The X86_64_SSEUP_CLASS should be always preceded by
    2231                 :            :              X86_64_SSE_CLASS or X86_64_SSEUP_CLASS.  */
    2232                 :    9553160 :           if (classes[i] == X86_64_SSEUP_CLASS
    2233                 :      28124 :               && classes[i - 1] != X86_64_SSE_CLASS
    2234                 :      17885 :               && classes[i - 1] != X86_64_SSEUP_CLASS)
    2235                 :            :             {
    2236                 :            :               /* The first one should never be X86_64_SSEUP_CLASS.  */
    2237                 :       1867 :               gcc_assert (i != 0);
    2238                 :       1867 :               classes[i] = X86_64_SSE_CLASS;
    2239                 :            :             }
    2240                 :            : 
    2241                 :            :           /*  If X86_64_X87UP_CLASS isn't preceded by X86_64_X87_CLASS,
    2242                 :            :                everything should be passed in memory.  */
    2243                 :    9553160 :           if (classes[i] == X86_64_X87UP_CLASS
    2244                 :      15604 :               && (classes[i - 1] != X86_64_X87_CLASS))
    2245                 :            :             {
    2246                 :       1949 :               static bool warned;
    2247                 :            : 
    2248                 :            :               /* The first one should never be X86_64_X87UP_CLASS.  */
    2249                 :       1949 :               gcc_assert (i != 0);
    2250                 :       1949 :               if (!warned && warn_psabi)
    2251                 :            :                 {
    2252                 :          1 :                   warned = true;
    2253                 :          1 :                   inform (input_location,
    2254                 :            :                           "the ABI of passing union with %<long double%>"
    2255                 :            :                           " has changed in GCC 4.4");
    2256                 :            :                 }
    2257                 :       1949 :               return 0;
    2258                 :            :             }
    2259                 :            :         }
    2260                 :            :       return words;
    2261                 :            :     }
    2262                 :            : 
    2263                 :            :   /* Compute alignment needed.  We align all types to natural boundaries with
    2264                 :            :      exception of XFmode that is aligned to 64bits.  */
    2265                 :  153318000 :   if (mode != VOIDmode && mode != BLKmode)
    2266                 :            :     {
    2267                 :  152702000 :       int mode_alignment = GET_MODE_BITSIZE (mode);
    2268                 :            : 
    2269                 :  152702000 :       if (mode == XFmode)
    2270                 :            :         mode_alignment = 128;
    2271                 :  151887000 :       else if (mode == XCmode)
    2272                 :      41525 :         mode_alignment = 256;
    2273                 :  152702000 :       if (COMPLEX_MODE_P (mode))
    2274                 :     476004 :         mode_alignment /= 2;
    2275                 :            :       /* Misaligned fields are always returned in memory.  */
    2276                 :  152702000 :       if (bit_offset % mode_alignment)
    2277                 :            :         return 0;
    2278                 :            :     }
    2279                 :            : 
    2280                 :            :   /* for V1xx modes, just use the base mode */
    2281                 :  153312000 :   if (VECTOR_MODE_P (mode) && mode != V1DImode && mode != V1TImode
    2282                 :  204677000 :       && GET_MODE_UNIT_SIZE (mode) == bytes)
    2283                 :          0 :     mode = GET_MODE_INNER (mode);
    2284                 :            : 
    2285                 :            :   /* Classification of atomic types.  */
    2286                 :  153312000 :   switch (mode)
    2287                 :            :     {
    2288                 :     212669 :     case E_SDmode:
    2289                 :     212669 :     case E_DDmode:
    2290                 :     212669 :       classes[0] = X86_64_SSE_CLASS;
    2291                 :     212669 :       return 1;
    2292                 :     102405 :     case E_TDmode:
    2293                 :     102405 :       classes[0] = X86_64_SSE_CLASS;
    2294                 :     102405 :       classes[1] = X86_64_SSEUP_CLASS;
    2295                 :     102405 :       return 2;
    2296                 :   96231700 :     case E_DImode:
    2297                 :   96231700 :     case E_SImode:
    2298                 :   96231700 :     case E_HImode:
    2299                 :   96231700 :     case E_QImode:
    2300                 :   96231700 :     case E_CSImode:
    2301                 :   96231700 :     case E_CHImode:
    2302                 :   96231700 :     case E_CQImode:
    2303                 :   96231700 :       {
    2304                 :   96231700 :         int size = bit_offset + (int) GET_MODE_BITSIZE (mode);
    2305                 :            : 
    2306                 :            :         /* Analyze last 128 bits only.  */
    2307                 :   96231700 :         size = (size - 1) & 0x7f;
    2308                 :            : 
    2309                 :   96231700 :         if (size < 32)
    2310                 :            :           {
    2311                 :   40809300 :             classes[0] = X86_64_INTEGERSI_CLASS;
    2312                 :   40809300 :             return 1;
    2313                 :            :           }
    2314                 :   55422400 :         else if (size < 64)
    2315                 :            :           {
    2316                 :   51830200 :             classes[0] = X86_64_INTEGER_CLASS;
    2317                 :   51830200 :             return 1;
    2318                 :            :           }
    2319                 :    3592230 :         else if (size < 64+32)
    2320                 :            :           {
    2321                 :     544967 :             classes[0] = X86_64_INTEGER_CLASS;
    2322                 :     544967 :             classes[1] = X86_64_INTEGERSI_CLASS;
    2323                 :     544967 :             return 2;
    2324                 :            :           }
    2325                 :    3047260 :         else if (size < 64+64)
    2326                 :            :           {
    2327                 :    3047260 :             classes[0] = classes[1] = X86_64_INTEGER_CLASS;
    2328                 :    3047260 :             return 2;
    2329                 :            :           }
    2330                 :            :         else
    2331                 :            :           gcc_unreachable ();
    2332                 :            :       }
    2333                 :     696238 :     case E_CDImode:
    2334                 :     696238 :     case E_TImode:
    2335                 :     696238 :       classes[0] = classes[1] = X86_64_INTEGER_CLASS;
    2336                 :     696238 :       return 2;
    2337                 :          0 :     case E_COImode:
    2338                 :          0 :     case E_OImode:
    2339                 :            :       /* OImode shouldn't be used directly.  */
    2340                 :          0 :       gcc_unreachable ();
    2341                 :            :     case E_CTImode:
    2342                 :            :       return 0;
    2343                 :    1269800 :     case E_SFmode:
    2344                 :    1269800 :       if (!(bit_offset % 64))
    2345                 :    1222880 :         classes[0] = X86_64_SSESF_CLASS;
    2346                 :            :       else
    2347                 :      46921 :         classes[0] = X86_64_SSE_CLASS;
    2348                 :            :       return 1;
    2349                 :    1399260 :     case E_DFmode:
    2350                 :    1399260 :       classes[0] = X86_64_SSEDF_CLASS;
    2351                 :    1399260 :       return 1;
    2352                 :     815110 :     case E_XFmode:
    2353                 :     815110 :       classes[0] = X86_64_X87_CLASS;
    2354                 :     815110 :       classes[1] = X86_64_X87UP_CLASS;
    2355                 :     815110 :       return 2;
    2356                 :     325192 :     case E_TFmode:
    2357                 :     325192 :       classes[0] = X86_64_SSE_CLASS;
    2358                 :     325192 :       classes[1] = X86_64_SSEUP_CLASS;
    2359                 :     325192 :       return 2;
    2360                 :      82678 :     case E_SCmode:
    2361                 :      82678 :       classes[0] = X86_64_SSE_CLASS;
    2362                 :      82678 :       if (!(bit_offset % 64))
    2363                 :            :         return 1;
    2364                 :            :       else
    2365                 :            :         {
    2366                 :       1090 :           static bool warned;
    2367                 :            : 
    2368                 :       1090 :           if (!warned && warn_psabi)
    2369                 :            :             {
    2370                 :          1 :               warned = true;
    2371                 :          1 :               inform (input_location,
    2372                 :            :                       "the ABI of passing structure with %<complex float%>"
    2373                 :            :                       " member has changed in GCC 4.4");
    2374                 :            :             }
    2375                 :       1090 :           classes[1] = X86_64_SSESF_CLASS;
    2376                 :       1090 :           return 2;
    2377                 :            :         }
    2378                 :      93160 :     case E_DCmode:
    2379                 :      93160 :       classes[0] = X86_64_SSEDF_CLASS;
    2380                 :      93160 :       classes[1] = X86_64_SSEDF_CLASS;
    2381                 :      93160 :       return 2;
    2382                 :      41525 :     case E_XCmode:
    2383                 :      41525 :       classes[0] = X86_64_COMPLEX_X87_CLASS;
    2384                 :      41525 :       return 1;
    2385                 :            :     case E_TCmode:
    2386                 :            :       /* This modes is larger than 16 bytes.  */
    2387                 :            :       return 0;
    2388                 :   13904200 :     case E_V8SFmode:
    2389                 :   13904200 :     case E_V8SImode:
    2390                 :   13904200 :     case E_V32QImode:
    2391                 :   13904200 :     case E_V16HImode:
    2392                 :   13904200 :     case E_V4DFmode:
    2393                 :   13904200 :     case E_V4DImode:
    2394                 :   13904200 :       classes[0] = X86_64_SSE_CLASS;
    2395                 :   13904200 :       classes[1] = X86_64_SSEUP_CLASS;
    2396                 :   13904200 :       classes[2] = X86_64_SSEUP_CLASS;
    2397                 :   13904200 :       classes[3] = X86_64_SSEUP_CLASS;
    2398                 :   13904200 :       return 4;
    2399                 :   14832200 :     case E_V8DFmode:
    2400                 :   14832200 :     case E_V16SFmode:
    2401                 :   14832200 :     case E_V8DImode:
    2402                 :   14832200 :     case E_V16SImode:
    2403                 :   14832200 :     case E_V32HImode:
    2404                 :   14832200 :     case E_V64QImode:
    2405                 :   14832200 :       classes[0] = X86_64_SSE_CLASS;
    2406                 :   14832200 :       classes[1] = X86_64_SSEUP_CLASS;
    2407                 :   14832200 :       classes[2] = X86_64_SSEUP_CLASS;
    2408                 :   14832200 :       classes[3] = X86_64_SSEUP_CLASS;
    2409                 :   14832200 :       classes[4] = X86_64_SSEUP_CLASS;
    2410                 :   14832200 :       classes[5] = X86_64_SSEUP_CLASS;
    2411                 :   14832200 :       classes[6] = X86_64_SSEUP_CLASS;
    2412                 :   14832200 :       classes[7] = X86_64_SSEUP_CLASS;
    2413                 :   14832200 :       return 8;
    2414                 :   20069800 :     case E_V4SFmode:
    2415                 :   20069800 :     case E_V4SImode:
    2416                 :   20069800 :     case E_V16QImode:
    2417                 :   20069800 :     case E_V8HImode:
    2418                 :   20069800 :     case E_V2DFmode:
    2419                 :   20069800 :     case E_V2DImode:
    2420                 :   20069800 :       classes[0] = X86_64_SSE_CLASS;
    2421                 :   20069800 :       classes[1] = X86_64_SSEUP_CLASS;
    2422                 :   20069800 :       return 2;
    2423                 :    2555220 :     case E_V1TImode:
    2424                 :    2555220 :     case E_V1DImode:
    2425                 :    2555220 :     case E_V2SFmode:
    2426                 :    2555220 :     case E_V2SImode:
    2427                 :    2555220 :     case E_V4HImode:
    2428                 :    2555220 :     case E_V8QImode:
    2429                 :    2555220 :       classes[0] = X86_64_SSE_CLASS;
    2430                 :    2555220 :       return 1;
    2431                 :            :     case E_BLKmode:
    2432                 :            :     case E_VOIDmode:
    2433                 :            :       return 0;
    2434                 :      10256 :     default:
    2435                 :      10256 :       gcc_assert (VECTOR_MODE_P (mode));
    2436                 :            : 
    2437                 :      10256 :       if (bytes > 16)
    2438                 :            :         return 0;
    2439                 :            : 
    2440                 :          0 :       gcc_assert (GET_MODE_CLASS (GET_MODE_INNER (mode)) == MODE_INT);
    2441                 :            : 
    2442                 :          0 :       if (bit_offset + GET_MODE_BITSIZE (mode) <= 32)
    2443                 :          0 :         classes[0] = X86_64_INTEGERSI_CLASS;
    2444                 :            :       else
    2445                 :          0 :         classes[0] = X86_64_INTEGER_CLASS;
    2446                 :          0 :       classes[1] = X86_64_INTEGER_CLASS;
    2447                 :          0 :       return 1 + (bytes > 8);
    2448                 :            :     }
    2449                 :            : }
    2450                 :            : 
    2451                 :            : /* Examine the argument and return set number of register required in each
    2452                 :            :    class.  Return true iff parameter should be passed in memory.  */
    2453                 :            : 
    2454                 :            : static bool
    2455                 :   99839100 : examine_argument (machine_mode mode, const_tree type, int in_return,
    2456                 :            :                   int *int_nregs, int *sse_nregs)
    2457                 :            : {
    2458                 :   99839100 :   enum x86_64_reg_class regclass[MAX_CLASSES];
    2459                 :   99839100 :   int n = classify_argument (mode, type, regclass, 0);
    2460                 :            : 
    2461                 :   99839100 :   *int_nregs = 0;
    2462                 :   99839100 :   *sse_nregs = 0;
    2463                 :            : 
    2464                 :   99839100 :   if (!n)
    2465                 :            :     return true;
    2466                 :  310937000 :   for (n--; n >= 0; n--)
    2467                 :  212293000 :     switch (regclass[n])
    2468                 :            :       {
    2469                 :   64020100 :       case X86_64_INTEGER_CLASS:
    2470                 :   64020100 :       case X86_64_INTEGERSI_CLASS:
    2471                 :   64020100 :         (*int_nregs)++;
    2472                 :   64020100 :         break;
    2473                 :   36474200 :       case X86_64_SSE_CLASS:
    2474                 :   36474200 :       case X86_64_SSESF_CLASS:
    2475                 :   36474200 :       case X86_64_SSEDF_CLASS:
    2476                 :   36474200 :         (*sse_nregs)++;
    2477                 :   36474200 :         break;
    2478                 :            :       case X86_64_NO_CLASS:
    2479                 :            :       case X86_64_SSEUP_CLASS:
    2480                 :            :         break;
    2481                 :    1005370 :       case X86_64_X87_CLASS:
    2482                 :    1005370 :       case X86_64_X87UP_CLASS:
    2483                 :    1005370 :       case X86_64_COMPLEX_X87_CLASS:
    2484                 :    1005370 :         if (!in_return)
    2485                 :            :           return true;
    2486                 :            :         break;
    2487                 :          0 :       case X86_64_MEMORY_CLASS:
    2488                 :          0 :         gcc_unreachable ();
    2489                 :            :       }
    2490                 :            : 
    2491                 :            :   return false;
    2492                 :            : }
    2493                 :            : 
    2494                 :            : /* Construct container for the argument used by GCC interface.  See
    2495                 :            :    FUNCTION_ARG for the detailed description.  */
    2496                 :            : 
    2497                 :            : static rtx
    2498                 :   48843600 : construct_container (machine_mode mode, machine_mode orig_mode,
    2499                 :            :                      const_tree type, int in_return, int nintregs, int nsseregs,
    2500                 :            :                      const int *intreg, int sse_regno)
    2501                 :            : {
    2502                 :            :   /* The following variables hold the static issued_error state.  */
    2503                 :   48843600 :   static bool issued_sse_arg_error;
    2504                 :   48843600 :   static bool issued_sse_ret_error;
    2505                 :   48843600 :   static bool issued_x87_ret_error;
    2506                 :            : 
    2507                 :   48843600 :   machine_mode tmpmode;
    2508                 :   48843600 :   int bytes
    2509                 :   97427600 :     = mode == BLKmode ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
    2510                 :   48843600 :   enum x86_64_reg_class regclass[MAX_CLASSES];
    2511                 :   48843600 :   int n;
    2512                 :   48843600 :   int i;
    2513                 :   48843600 :   int nexps = 0;
    2514                 :   48843600 :   int needed_sseregs, needed_intregs;
    2515                 :   48843600 :   rtx exp[MAX_CLASSES];
    2516                 :   48843600 :   rtx ret;
    2517                 :            : 
    2518                 :   48843600 :   n = classify_argument (mode, type, regclass, 0);
    2519                 :   48843600 :   if (!n)
    2520                 :            :     return NULL;
    2521                 :   48509200 :   if (examine_argument (mode, type, in_return, &needed_intregs,
    2522                 :            :                         &needed_sseregs))
    2523                 :            :     return NULL;
    2524                 :   48473200 :   if (needed_intregs > nintregs || needed_sseregs > nsseregs)
    2525                 :            :     return NULL;
    2526                 :            : 
    2527                 :            :   /* We allowed the user to turn off SSE for kernel mode.  Don't crash if
    2528                 :            :      some less clueful developer tries to use floating-point anyway.  */
    2529                 :   47675700 :   if (needed_sseregs && !TARGET_SSE)
    2530                 :            :     {
    2531                 :         13 :       if (in_return)
    2532                 :            :         {
    2533                 :         12 :           if (!issued_sse_ret_error)
    2534                 :            :             {
    2535                 :          4 :               error ("SSE register return with SSE disabled");
    2536                 :          4 :               issued_sse_ret_error = true;
    2537                 :            :             }
    2538                 :            :         }
    2539                 :          1 :       else if (!issued_sse_arg_error)
    2540                 :            :         {
    2541                 :          1 :           error ("SSE register argument with SSE disabled");
    2542                 :          1 :           issued_sse_arg_error = true;
    2543                 :            :         }
    2544                 :         13 :       return NULL;
    2545                 :            :     }
    2546                 :            : 
    2547                 :            :   /* Likewise, error if the ABI requires us to return values in the
    2548                 :            :      x87 registers and the user specified -mno-80387.  */
    2549                 :   47675600 :   if (!TARGET_FLOAT_RETURNS_IN_80387 && in_return)
    2550                 :       4305 :     for (i = 0; i < n; i++)
    2551                 :       2158 :       if (regclass[i] == X86_64_X87_CLASS
    2552                 :            :           || regclass[i] == X86_64_X87UP_CLASS
    2553                 :       2158 :           || regclass[i] == X86_64_COMPLEX_X87_CLASS)
    2554                 :            :         {
    2555                 :         11 :           if (!issued_x87_ret_error)
    2556                 :            :             {
    2557                 :          3 :               error ("x87 register return with x87 disabled");
    2558                 :          3 :               issued_x87_ret_error = true;
    2559                 :            :             }
    2560                 :         11 :           return NULL;
    2561                 :            :         }
    2562                 :            : 
    2563                 :            :   /* First construct simple cases.  Avoid SCmode, since we want to use
    2564                 :            :      single register to pass this type.  */
    2565                 :   47675600 :   if (n == 1 && mode != SCmode)
    2566                 :   29815200 :     switch (regclass[0])
    2567                 :            :       {
    2568                 :   28067800 :       case X86_64_INTEGER_CLASS:
    2569                 :   28067800 :       case X86_64_INTEGERSI_CLASS:
    2570                 :   28067800 :         return gen_rtx_REG (mode, intreg[0]);
    2571                 :    1720340 :       case X86_64_SSE_CLASS:
    2572                 :    1720340 :       case X86_64_SSESF_CLASS:
    2573                 :    1720340 :       case X86_64_SSEDF_CLASS:
    2574                 :    1720340 :         if (mode != BLKmode)
    2575                 :    3440240 :           return gen_reg_or_parallel (mode, orig_mode,
    2576                 :    3440240 :                                       GET_SSE_REGNO (sse_regno));
    2577                 :            :         break;
    2578                 :      10066 :       case X86_64_X87_CLASS:
    2579                 :      10066 :       case X86_64_COMPLEX_X87_CLASS:
    2580                 :      10066 :         return gen_rtx_REG (mode, FIRST_STACK_REG);
    2581                 :            :       case X86_64_NO_CLASS:
    2582                 :            :         /* Zero sized array, struct or class.  */
    2583                 :            :         return NULL;
    2584                 :          0 :       default:
    2585                 :          0 :         gcc_unreachable ();
    2586                 :            :       }
    2587                 :   17860600 :   if (n == 2
    2588                 :    8274420 :       && regclass[0] == X86_64_SSE_CLASS
    2589                 :    6820580 :       && regclass[1] == X86_64_SSEUP_CLASS
    2590                 :    6817270 :       && mode != BLKmode)
    2591                 :   13634500 :     return gen_reg_or_parallel (mode, orig_mode,
    2592                 :   13634500 :                                 GET_SSE_REGNO (sse_regno));
    2593                 :   11043300 :   if (n == 4
    2594                 :    4627990 :       && regclass[0] == X86_64_SSE_CLASS
    2595                 :    4627990 :       && regclass[1] == X86_64_SSEUP_CLASS
    2596                 :    4627990 :       && regclass[2] == X86_64_SSEUP_CLASS
    2597                 :    4627990 :       && regclass[3] == X86_64_SSEUP_CLASS
    2598                 :    4627990 :       && mode != BLKmode)
    2599                 :    9255310 :     return gen_reg_or_parallel (mode, orig_mode,
    2600                 :    9255310 :                                 GET_SSE_REGNO (sse_regno));
    2601                 :    6415690 :   if (n == 8
    2602                 :    4936860 :       && regclass[0] == X86_64_SSE_CLASS
    2603                 :    4936860 :       && regclass[1] == X86_64_SSEUP_CLASS
    2604                 :    4936860 :       && regclass[2] == X86_64_SSEUP_CLASS
    2605                 :    4936860 :       && regclass[3] == X86_64_SSEUP_CLASS
    2606                 :    4936860 :       && regclass[4] == X86_64_SSEUP_CLASS
    2607                 :    4936860 :       && regclass[5] == X86_64_SSEUP_CLASS
    2608                 :    4936860 :       && regclass[6] == X86_64_SSEUP_CLASS
    2609                 :    4936860 :       && regclass[7] == X86_64_SSEUP_CLASS
    2610                 :    4936860 :       && mode != BLKmode)
    2611                 :    9872830 :     return gen_reg_or_parallel (mode, orig_mode,
    2612                 :    9872830 :                                 GET_SSE_REGNO (sse_regno));
    2613                 :    1479280 :   if (n == 2
    2614                 :    1457150 :       && regclass[0] == X86_64_X87_CLASS
    2615                 :     231217 :       && regclass[1] == X86_64_X87UP_CLASS)
    2616                 :     231217 :     return gen_rtx_REG (XFmode, FIRST_STACK_REG);
    2617                 :            : 
    2618                 :    1248060 :   if (n == 2
    2619                 :    1225930 :       && regclass[0] == X86_64_INTEGER_CLASS
    2620                 :    1152700 :       && regclass[1] == X86_64_INTEGER_CLASS
    2621                 :    1146740 :       && (mode == CDImode || mode == TImode || mode == BLKmode)
    2622                 :    1146740 :       && intreg[0] + 1 == intreg[1])
    2623                 :            :     {
    2624                 :     950961 :       if (mode == BLKmode)
    2625                 :            :         {
    2626                 :            :           /* Use TImode for BLKmode values in 2 integer registers.  */
    2627                 :      78642 :           exp[0] = gen_rtx_EXPR_LIST (VOIDmode,
    2628                 :      39321 :                                       gen_rtx_REG (TImode, intreg[0]),
    2629                 :            :                                       GEN_INT (0));
    2630                 :      39321 :           ret = gen_rtx_PARALLEL (mode, rtvec_alloc (1));
    2631                 :      39321 :           XVECEXP (ret, 0, 0) = exp[0];
    2632                 :      39321 :           return ret;
    2633                 :            :         }
    2634                 :            :       else
    2635                 :     911640 :         return gen_rtx_REG (mode, intreg[0]);
    2636                 :            :     }
    2637                 :            : 
    2638                 :            :   /* Otherwise figure out the entries of the PARALLEL.  */
    2639                 :     869164 :   for (i = 0; i < n; i++)
    2640                 :            :     {
    2641                 :     572067 :       int pos;
    2642                 :            : 
    2643                 :     572067 :       switch (regclass[i])
    2644                 :            :         {
    2645                 :            :           case X86_64_NO_CLASS:
    2646                 :            :             break;
    2647                 :     463339 :           case X86_64_INTEGER_CLASS:
    2648                 :     463339 :           case X86_64_INTEGERSI_CLASS:
    2649                 :            :             /* Merge TImodes on aligned occasions here too.  */
    2650                 :     463339 :             if (i * 8 + 8 > bytes)
    2651                 :            :               {
    2652                 :       2383 :                 unsigned int tmpbits = (bytes - i * 8) * BITS_PER_UNIT;
    2653                 :       6815 :                 if (!int_mode_for_size (tmpbits, 0).exists (&tmpmode))
    2654                 :            :                   /* We've requested 24 bytes we
    2655                 :            :                      don't have mode for.  Use DImode.  */
    2656                 :        334 :                   tmpmode = DImode;
    2657                 :            :               }
    2658                 :     460956 :             else if (regclass[i] == X86_64_INTEGERSI_CLASS)
    2659                 :            :               tmpmode = SImode;
    2660                 :            :             else
    2661                 :     429034 :               tmpmode = DImode;
    2662                 :     926678 :             exp [nexps++]
    2663                 :     463339 :               = gen_rtx_EXPR_LIST (VOIDmode,
    2664                 :     463339 :                                    gen_rtx_REG (tmpmode, *intreg),
    2665                 :     463339 :                                    GEN_INT (i*8));
    2666                 :     463339 :             intreg++;
    2667                 :     463339 :             break;
    2668                 :       1870 :           case X86_64_SSESF_CLASS:
    2669                 :       3740 :             exp [nexps++]
    2670                 :       3740 :               = gen_rtx_EXPR_LIST (VOIDmode,
    2671                 :            :                                    gen_rtx_REG (SFmode,
    2672                 :       1870 :                                                 GET_SSE_REGNO (sse_regno)),
    2673                 :       1870 :                                    GEN_INT (i*8));
    2674                 :       1870 :             sse_regno++;
    2675                 :       1870 :             break;
    2676                 :      71839 :           case X86_64_SSEDF_CLASS:
    2677                 :     143678 :             exp [nexps++]
    2678                 :     143678 :               = gen_rtx_EXPR_LIST (VOIDmode,
    2679                 :            :                                    gen_rtx_REG (DFmode,
    2680                 :      71839 :                                                 GET_SSE_REGNO (sse_regno)),
    2681                 :      71839 :                                    GEN_INT (i*8));
    2682                 :      71839 :             sse_regno++;
    2683                 :      71839 :             break;
    2684                 :      28851 :           case X86_64_SSE_CLASS:
    2685                 :      28851 :             pos = i;
    2686                 :      28851 :             switch (n)
    2687                 :            :               {
    2688                 :            :               case 1:
    2689                 :            :                 tmpmode = DImode;
    2690                 :            :                 break;
    2691                 :       6940 :               case 2:
    2692                 :       6940 :                 if (i == 0 && regclass[1] == X86_64_SSEUP_CLASS)
    2693                 :            :                   {
    2694                 :          0 :                     tmpmode = TImode;
    2695                 :          0 :                     i++;
    2696                 :            :                   }
    2697                 :            :                 else
    2698                 :            :                   tmpmode = DImode;
    2699                 :            :                 break;
    2700                 :        336 :               case 4:
    2701                 :        336 :                 gcc_assert (i == 0
    2702                 :            :                             && regclass[1] == X86_64_SSEUP_CLASS
    2703                 :            :                             && regclass[2] == X86_64_SSEUP_CLASS
    2704                 :            :                             && regclass[3] == X86_64_SSEUP_CLASS);
    2705                 :            :                 tmpmode = OImode;
    2706                 :            :                 i += 3;
    2707                 :            :                 break;
    2708                 :        448 :               case 8:
    2709                 :        448 :                 gcc_assert (i == 0
    2710                 :            :                             && regclass[1] == X86_64_SSEUP_CLASS
    2711                 :            :                             && regclass[2] == X86_64_SSEUP_CLASS
    2712                 :            :                             && regclass[3] == X86_64_SSEUP_CLASS
    2713                 :            :                             && regclass[4] == X86_64_SSEUP_CLASS
    2714                 :            :                             && regclass[5] == X86_64_SSEUP_CLASS
    2715                 :            :                             && regclass[6] == X86_64_SSEUP_CLASS
    2716                 :            :                             && regclass[7] == X86_64_SSEUP_CLASS);
    2717                 :            :                 tmpmode = XImode;
    2718                 :            :                 i += 7;
    2719                 :            :                 break;
    2720                 :          0 :               default:
    2721                 :          0 :                 gcc_unreachable ();
    2722                 :            :               }
    2723                 :      57702 :             exp [nexps++]
    2724                 :      57702 :               = gen_rtx_EXPR_LIST (VOIDmode,
    2725                 :            :                                    gen_rtx_REG (tmpmode,
    2726                 :      28851 :                                                 GET_SSE_REGNO (sse_regno)),
    2727                 :      28851 :                                    GEN_INT (pos*8));
    2728                 :      28851 :             sse_regno++;
    2729                 :      28851 :             break;
    2730                 :          0 :           default:
    2731                 :          0 :             gcc_unreachable ();
    2732                 :            :         }
    2733                 :            :     }
    2734                 :            : 
    2735                 :            :   /* Empty aligned struct, union or class.  */
    2736                 :     297097 :   if (nexps == 0)
    2737                 :            :     return NULL;
    2738                 :            : 
    2739                 :     296902 :   ret =  gen_rtx_PARALLEL (mode, rtvec_alloc (nexps));
    2740                 :     862801 :   for (i = 0; i < nexps; i++)
    2741                 :     565899 :     XVECEXP (ret, 0, i) = exp [i];
    2742                 :            :   return ret;
    2743                 :            : }
    2744                 :            : 
    2745                 :            : /* Update the data in CUM to advance over an argument of mode MODE
    2746                 :            :    and data type TYPE.  (TYPE is null for libcalls where that information
    2747                 :            :    may not be available.)
    2748                 :            : 
    2749                 :            :    Return a number of integer regsiters advanced over.  */
    2750                 :            : 
    2751                 :            : static int
    2752                 :    1706210 : function_arg_advance_32 (CUMULATIVE_ARGS *cum, machine_mode mode,
    2753                 :            :                          const_tree type, HOST_WIDE_INT bytes,
    2754                 :            :                          HOST_WIDE_INT words)
    2755                 :            : {
    2756                 :    1706210 :   int res = 0;
    2757                 :    1706210 :   bool error_p = false;
    2758                 :            : 
    2759                 :    1706210 :   if (TARGET_IAMCU)
    2760                 :            :     {
    2761                 :            :       /* Intel MCU psABI passes scalars and aggregates no larger than 8
    2762                 :            :          bytes in registers.  */
    2763                 :          0 :       if (!VECTOR_MODE_P (mode) && bytes <= 8)
    2764                 :          0 :         goto pass_in_reg;
    2765                 :            :       return res;
    2766                 :            :     }
    2767                 :            : 
    2768                 :    1706210 :   switch (mode)
    2769                 :            :     {
    2770                 :            :     default:
    2771                 :            :       break;
    2772                 :            : 
    2773                 :      82720 :     case E_BLKmode:
    2774                 :      82720 :       if (bytes < 0)
    2775                 :            :         break;
    2776                 :            :       /* FALLTHRU */
    2777                 :            : 
    2778                 :    1675050 :     case E_DImode:
    2779                 :    1675050 :     case E_SImode:
    2780                 :    1675050 :     case E_HImode:
    2781                 :    1675050 :     case E_QImode:
    2782                 :      82720 : pass_in_reg:
    2783                 :    1675050 :       cum->words += words;
    2784                 :    1675050 :       cum->nregs -= words;
    2785                 :    1675050 :       cum->regno += words;
    2786                 :    1675050 :       if (cum->nregs >= 0)
    2787                 :      35453 :         res = words;
    2788                 :    1675050 :       if (cum->nregs <= 0)
    2789                 :            :         {
    2790                 :    1649840 :           cum->nregs = 0;
    2791                 :    1649840 :           cfun->machine->arg_reg_available = false;
    2792                 :    1649840 :           cum->regno = 0;
    2793                 :            :         }
    2794                 :            :       break;
    2795                 :            : 
    2796                 :          0 :     case E_OImode:
    2797                 :            :       /* OImode shouldn't be used directly.  */
    2798                 :          0 :       gcc_unreachable ();
    2799                 :            : 
    2800                 :       3164 :     case E_DFmode:
    2801                 :       3164 :       if (cum->float_in_sse == -1)
    2802                 :          0 :         error_p = true;
    2803                 :       3164 :       if (cum->float_in_sse < 2)
    2804                 :            :         break;
    2805                 :            :       /* FALLTHRU */
    2806                 :        518 :     case E_SFmode:
    2807                 :        518 :       if (cum->float_in_sse == -1)
    2808                 :          0 :         error_p = true;
    2809                 :        518 :       if (cum->float_in_sse < 1)
    2810                 :            :         break;
    2811                 :            :       /* FALLTHRU */
    2812                 :            : 
    2813                 :         56 :     case E_V8SFmode:
    2814                 :         56 :     case E_V8SImode:
    2815                 :         56 :     case E_V64QImode:
    2816                 :         56 :     case E_V32HImode:
    2817                 :         56 :     case E_V16SImode:
    2818                 :         56 :     case E_V8DImode:
    2819                 :         56 :     case E_V16SFmode:
    2820                 :         56 :     case E_V8DFmode:
    2821                 :         56 :     case E_V32QImode:
    2822                 :         56 :     case E_V16HImode:
    2823                 :         56 :     case E_V4DFmode:
    2824                 :         56 :     case E_V4DImode:
    2825                 :         56 :     case E_TImode:
    2826                 :         56 :     case E_V16QImode:
    2827                 :         56 :     case E_V8HImode:
    2828                 :         56 :     case E_V4SImode:
    2829                 :         56 :     case E_V2DImode:
    2830                 :         56 :     case E_V4SFmode:
    2831                 :         56 :     case E_V2DFmode:
    2832                 :         56 :       if (!type || !AGGREGATE_TYPE_P (type))
    2833                 :            :         {
    2834                 :         56 :           cum->sse_words += words;
    2835                 :         56 :           cum->sse_nregs -= 1;
    2836                 :         56 :           cum->sse_regno += 1;
    2837                 :         56 :           if (cum->sse_nregs <= 0)
    2838                 :            :             {
    2839                 :          4 :               cum->sse_nregs = 0;
    2840                 :          4 :               cum->sse_regno = 0;
    2841                 :            :             }
    2842                 :            :         }
    2843                 :            :       break;
    2844                 :            : 
    2845                 :         12 :     case E_V8QImode:
    2846                 :         12 :     case E_V4HImode:
    2847                 :         12 :     case E_V2SImode:
    2848                 :         12 :     case E_V2SFmode:
    2849                 :         12 :     case E_V1TImode:
    2850                 :         12 :     case E_V1DImode:
    2851                 :         12 :       if (!type || !AGGREGATE_TYPE_P (type))
    2852                 :            :         {
    2853                 :         12 :           cum->mmx_words += words;
    2854                 :         12 :           cum->mmx_nregs -= 1;
    2855                 :         12 :           cum->mmx_regno += 1;
    2856                 :         12 :           if (cum->mmx_nregs <= 0)
    2857                 :            :             {
    2858                 :          0 :               cum->mmx_nregs = 0;
    2859                 :          0 :               cum->mmx_regno = 0;
    2860                 :            :             }
    2861                 :            :         }
    2862                 :            :       break;
    2863                 :            :     }
    2864                 :    1653580 :   if (error_p)
    2865                 :            :     {
    2866                 :          0 :       cum->float_in_sse = 0;
    2867                 :          0 :       error ("calling %qD with SSE calling convention without "
    2868                 :            :              "SSE/SSE2 enabled", cum->decl);
    2869                 :          0 :       sorry ("this is a GCC bug that can be worked around by adding "
    2870                 :            :              "attribute used to function called");
    2871                 :            :     }
    2872                 :            : 
    2873                 :            :   return res;
    2874                 :            : }
    2875                 :            : 
    2876                 :            : static int
    2877                 :   11607800 : function_arg_advance_64 (CUMULATIVE_ARGS *cum, machine_mode mode,
    2878                 :            :                          const_tree type, HOST_WIDE_INT words, bool named)
    2879                 :            : {
    2880                 :   11607800 :   int int_nregs, sse_nregs;
    2881                 :            : 
    2882                 :            :   /* Unnamed 512 and 256bit vector mode parameters are passed on stack.  */
    2883                 :   11607800 :   if (!named && (VALID_AVX512F_REG_MODE (mode)
    2884                 :     461324 :                  || VALID_AVX256_REG_MODE (mode)))
    2885                 :            :     return 0;
    2886                 :            : 
    2887                 :   11607700 :   if (!examine_argument (mode, type, 0, &int_nregs, &sse_nregs)
    2888                 :   11607700 :       && sse_nregs <= cum->sse_nregs && int_nregs <= cum->nregs)
    2889                 :            :     {
    2890                 :    9805370 :       cum->nregs -= int_nregs;
    2891                 :    9805370 :       cum->sse_nregs -= sse_nregs;
    2892                 :    9805370 :       cum->regno += int_nregs;
    2893                 :    9805370 :       cum->sse_regno += sse_nregs;
    2894                 :    9805370 :       return int_nregs;
    2895                 :            :     }
    2896                 :            :   else
    2897                 :            :     {
    2898                 :    1802290 :       int align = ix86_function_arg_boundary (mode, type) / BITS_PER_WORD;
    2899                 :    1802290 :       cum->words = ROUND_UP (cum->words, align);
    2900                 :    1802290 :       cum->words += words;
    2901                 :    1802290 :       return 0;
    2902                 :            :     }
    2903                 :            : }
    2904                 :            : 
    2905                 :            : static int
    2906                 :     150112 : function_arg_advance_ms_64 (CUMULATIVE_ARGS *cum, HOST_WIDE_INT bytes,
    2907                 :            :                             HOST_WIDE_INT words)
    2908                 :            : {
    2909                 :            :   /* Otherwise, this should be passed indirect.  */
    2910                 :     150112 :   gcc_assert (bytes == 1 || bytes == 2 || bytes == 4 || bytes == 8);
    2911                 :            : 
    2912                 :     150112 :   cum->words += words;
    2913                 :     150112 :   if (cum->nregs > 0)
    2914                 :            :     {
    2915                 :     124371 :       cum->nregs -= 1;
    2916                 :     124371 :       cum->regno += 1;
    2917                 :     124371 :       return 1;
    2918                 :            :     }
    2919                 :            :   return 0;
    2920                 :            : }
    2921                 :            : 
    2922                 :            : /* Update the data in CUM to advance over argument ARG.  */
    2923                 :            : 
    2924                 :            : static void
    2925                 :   13464300 : ix86_function_arg_advance (cumulative_args_t cum_v,
    2926                 :            :                            const function_arg_info &arg)
    2927                 :            : {
    2928                 :   13464300 :   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
    2929                 :   13464300 :   machine_mode mode = arg.mode;
    2930                 :   13464300 :   HOST_WIDE_INT bytes, words;
    2931                 :   13464300 :   int nregs;
    2932                 :            : 
    2933                 :            :   /* The argument of interrupt handler is a special case and is
    2934                 :            :      handled in ix86_function_arg.  */
    2935                 :   13464300 :   if (!cum->caller && cfun->machine->func_type != TYPE_NORMAL)
    2936                 :            :     return;
    2937                 :            : 
    2938                 :   13464100 :   bytes = arg.promoted_size_in_bytes ();
    2939                 :   13464100 :   words = CEIL (bytes, UNITS_PER_WORD);
    2940                 :            : 
    2941                 :   13464100 :   if (arg.type)
    2942                 :   13255900 :     mode = type_natural_mode (arg.type, NULL, false);
    2943                 :            : 
    2944                 :   13464100 :   if (TARGET_64BIT)
    2945                 :            :     {
    2946                 :   11757900 :       enum calling_abi call_abi = cum ? cum->call_abi : ix86_abi;
    2947                 :            : 
    2948                 :   11757900 :       if (call_abi == MS_ABI)
    2949                 :     150112 :         nregs = function_arg_advance_ms_64 (cum, bytes, words);
    2950                 :            :       else
    2951                 :   11607800 :         nregs = function_arg_advance_64 (cum, mode, arg.type, words,
    2952                 :   11607800 :                                          arg.named);
    2953                 :            :     }
    2954                 :            :   else
    2955                 :    1706210 :     nregs = function_arg_advance_32 (cum, mode, arg.type, bytes, words);
    2956                 :            : 
    2957                 :   13464100 :   if (!nregs)
    2958                 :            :     {
    2959                 :            :       /* Track if there are outgoing arguments on stack.  */
    2960                 :    4068360 :       if (cum->caller)
    2961                 :    1841580 :         cfun->machine->outgoing_args_on_stack = true;
    2962                 :            :     }
    2963                 :            : }
    2964                 :            : 
    2965                 :            : /* Define where to put the arguments to a function.
    2966                 :            :    Value is zero to push the argument on the stack,
    2967                 :            :    or a hard register in which to store the argument.
    2968                 :            : 
    2969                 :            :    MODE is the argument's machine mode.
    2970                 :            :    TYPE is the data type of the argument (as a tree).
    2971                 :            :     This is null for libcalls where that information may
    2972                 :            :     not be available.
    2973                 :            :    CUM is a variable of type CUMULATIVE_ARGS which gives info about
    2974                 :            :     the preceding args and about the function being called.
    2975                 :            :    NAMED is nonzero if this argument is a named parameter
    2976                 :            :     (otherwise it is an extra parameter matching an ellipsis).  */
    2977                 :            : 
    2978                 :            : static rtx
    2979                 :    2086220 : function_arg_32 (CUMULATIVE_ARGS *cum, machine_mode mode,
    2980                 :            :                  machine_mode orig_mode, const_tree type,
    2981                 :            :                  HOST_WIDE_INT bytes, HOST_WIDE_INT words)
    2982                 :            : {
    2983                 :    2086220 :   bool error_p = false;
    2984                 :            : 
    2985                 :            :   /* Avoid the AL settings for the Unix64 ABI.  */
    2986                 :    2086220 :   if (mode == VOIDmode)
    2987                 :     615068 :     return constm1_rtx;
    2988                 :            : 
    2989                 :    1471150 :   if (TARGET_IAMCU)
    2990                 :            :     {
    2991                 :            :       /* Intel MCU psABI passes scalars and aggregates no larger than 8
    2992                 :            :          bytes in registers.  */
    2993                 :          0 :       if (!VECTOR_MODE_P (mode) && bytes <= 8)
    2994                 :          0 :         goto pass_in_reg;
    2995                 :            :       return NULL_RTX;
    2996                 :            :     }
    2997                 :            : 
    2998                 :    1471150 :   switch (mode)
    2999                 :            :     {
    3000                 :            :     default:
    3001                 :            :       break;
    3002                 :            : 
    3003                 :      69000 :     case E_BLKmode:
    3004                 :      69000 :       if (bytes < 0)
    3005                 :            :         break;
    3006                 :            :       /* FALLTHRU */
    3007                 :    1442100 :     case E_DImode:
    3008                 :    1442100 :     case E_SImode:
    3009                 :    1442100 :     case E_HImode:
    3010                 :    1442100 :     case E_QImode:
    3011                 :      69000 : pass_in_reg:
    3012                 :    1442100 :       if (words <= cum->nregs)
    3013                 :            :         {
    3014                 :      33635 :           int regno = cum->regno;
    3015                 :            : 
    3016                 :            :           /* Fastcall allocates the first two DWORD (SImode) or
    3017                 :            :             smaller arguments to ECX and EDX if it isn't an
    3018                 :            :             aggregate type .  */
    3019                 :      33635 :           if (cum->fastcall)
    3020                 :            :             {
    3021                 :         12 :               if (mode == BLKmode
    3022                 :         12 :                   || mode == DImode
    3023                 :         12 :                   || (type && AGGREGATE_TYPE_P (type)))
    3024                 :            :                 break;
    3025                 :            : 
    3026                 :            :               /* ECX not EAX is the first allocated register.  */
    3027                 :         12 :               if (regno == AX_REG)
    3028                 :          6 :                 regno = CX_REG;
    3029                 :            :             }
    3030                 :      33635 :           return gen_rtx_REG (mode, regno);
    3031                 :            :         }
    3032                 :            :       break;
    3033                 :            : 
    3034                 :       2196 :     case E_DFmode:
    3035                 :       2196 :       if (cum->float_in_sse == -1)
    3036                 :          0 :         error_p = true;
    3037                 :       2196 :       if (cum->float_in_sse < 2)
    3038                 :            :         break;
    3039                 :            :       /* FALLTHRU */
    3040                 :        374 :     case E_SFmode:
    3041                 :        374 :       if (cum->float_in_sse == -1)
    3042                 :          0 :         error_p = true;
    3043                 :        374 :       if (cum->float_in_sse < 1)
    3044                 :            :         break;
    3045                 :            :       /* FALLTHRU */
    3046                 :         12 :     case E_TImode:
    3047                 :            :       /* In 32bit, we pass TImode in xmm registers.  */
    3048                 :         12 :     case E_V16QImode:
    3049                 :         12 :     case E_V8HImode:
    3050                 :         12 :     case E_V4SImode:
    3051                 :         12 :     case E_V2DImode:
    3052                 :         12 :     case E_V4SFmode:
    3053                 :         12 :     case E_V2DFmode:
    3054                 :         12 :       if (!type || !AGGREGATE_TYPE_P (type))
    3055                 :            :         {
    3056                 :         12 :           if (cum->sse_nregs)
    3057                 :         12 :             return gen_reg_or_parallel (mode, orig_mode,
    3058                 :         12 :                                         cum->sse_regno + FIRST_SSE_REG);
    3059                 :            :         }
    3060                 :            :       break;
    3061                 :            : 
    3062                 :          0 :     case E_OImode:
    3063                 :          0 :     case E_XImode:
    3064                 :            :       /* OImode and XImode shouldn't be used directly.  */
    3065                 :          0 :       gcc_unreachable ();
    3066                 :            : 
    3067                 :          9 :     case E_V64QImode:
    3068                 :          9 :     case E_V32HImode:
    3069                 :          9 :     case E_V16SImode:
    3070                 :          9 :     case E_V8DImode:
    3071                 :          9 :     case E_V16SFmode:
    3072                 :          9 :     case E_V8DFmode:
    3073                 :          9 :     case E_V8SFmode:
    3074                 :          9 :     case E_V8SImode:
    3075                 :          9 :     case E_V32QImode:
    3076                 :          9 :     case E_V16HImode:
    3077                 :          9 :     case E_V4DFmode:
    3078                 :          9 :     case E_V4DImode:
    3079                 :          9 :       if (!type || !AGGREGATE_TYPE_P (type))
    3080                 :            :         {
    3081                 :          9 :           if (cum->sse_nregs)
    3082                 :          9 :             return gen_reg_or_parallel (mode, orig_mode,
    3083                 :          9 :                                         cum->sse_regno + FIRST_SSE_REG);
    3084                 :            :         }
    3085                 :            :       break;
    3086                 :            : 
    3087                 :          6 :     case E_V8QImode:
    3088                 :          6 :     case E_V4HImode:
    3089                 :          6 :     case E_V2SImode:
    3090                 :          6 :     case E_V2SFmode:
    3091                 :          6 :     case E_V1TImode:
    3092                 :          6 :     case E_V1DImode:
    3093                 :          6 :       if (!type || !AGGREGATE_TYPE_P (type))
    3094                 :            :         {
    3095                 :          6 :           if (cum->mmx_nregs)
    3096                 :          6 :             return gen_reg_or_parallel (mode, orig_mode,
    3097                 :          6 :                                         cum->mmx_regno + FIRST_MMX_REG);
    3098                 :            :         }
    3099                 :            :       break;
    3100                 :            :     }
    3101                 :       2570 :   if (error_p)
    3102                 :            :     {
    3103                 :          0 :       cum->float_in_sse = 0;
    3104                 :          0 :       error ("calling %qD with SSE calling convention without "
    3105                 :            :              "SSE/SSE2 enabled", cum->decl);
    3106                 :          0 :       sorry ("this is a GCC bug that can be worked around by adding "
    3107                 :            :              "attribute used to function called");
    3108                 :            :     }
    3109                 :            : 
    3110                 :            :   return NULL_RTX;
    3111                 :            : }
    3112                 :            : 
    3113                 :            : static rtx
    3114                 :   11411100 : function_arg_64 (const CUMULATIVE_ARGS *cum, machine_mode mode,
    3115                 :            :                  machine_mode orig_mode, const_tree type, bool named)
    3116                 :            : {
    3117                 :            :   /* Handle a hidden AL argument containing number of registers
    3118                 :            :      for varargs x86-64 functions.  */
    3119                 :   11411100 :   if (mode == VOIDmode)
    3120                 :    3304880 :     return GEN_INT (cum->maybe_vaarg
    3121                 :            :                     ? (cum->sse_nregs < 0
    3122                 :            :                        ? X86_64_SSE_REGPARM_MAX
    3123                 :            :                        : cum->sse_regno)
    3124                 :            :                     : -1);
    3125                 :            : 
    3126                 :    8106170 :   switch (mode)
    3127                 :            :     {
    3128                 :            :     default:
    3129                 :            :       break;
    3130                 :            : 
    3131                 :      58375 :     case E_V8SFmode:
    3132                 :      58375 :     case E_V8SImode:
    3133                 :      58375 :     case E_V32QImode:
    3134                 :      58375 :     case E_V16HImode:
    3135                 :      58375 :     case E_V4DFmode:
    3136                 :      58375 :     case E_V4DImode:
    3137                 :      58375 :     case E_V16SFmode:
    3138                 :      58375 :     case E_V16SImode:
    3139                 :      58375 :     case E_V64QImode:
    3140                 :      58375 :     case E_V32HImode:
    3141                 :      58375 :     case E_V8DFmode:
    3142                 :      58375 :     case E_V8DImode:
    3143                 :            :       /* Unnamed 256 and 512bit vector mode parameters are passed on stack.  */
    3144                 :      58375 :       if (!named)
    3145                 :            :         return NULL;
    3146                 :            :       break;
    3147                 :            :     }
    3148                 :            : 
    3149                 :    8106080 :   return construct_container (mode, orig_mode, type, 0, cum->nregs,
    3150                 :    8106080 :                               cum->sse_nregs,
    3151                 :    8106080 :                               &x86_64_int_parameter_registers [cum->regno],
    3152                 :    8106080 :                               cum->sse_regno);
    3153                 :            : }
    3154                 :            : 
    3155                 :            : static rtx
    3156                 :     146464 : function_arg_ms_64 (const CUMULATIVE_ARGS *cum, machine_mode mode,
    3157                 :            :                     machine_mode orig_mode, bool named, const_tree type,
    3158                 :            :                     HOST_WIDE_INT bytes)
    3159                 :            : {
    3160                 :     146464 :   unsigned int regno;
    3161                 :            : 
    3162                 :            :   /* We need to add clobber for MS_ABI->SYSV ABI calls in expand_call.
    3163                 :            :      We use value of -2 to specify that current function call is MSABI.  */
    3164                 :     146464 :   if (mode == VOIDmode)
    3165                 :      35941 :     return GEN_INT (-2);
    3166                 :            : 
    3167                 :            :   /* If we've run out of registers, it goes on the stack.  */
    3168                 :     110523 :   if (cum->nregs == 0)
    3169                 :            :     return NULL_RTX;
    3170                 :            : 
    3171                 :      93249 :   regno = x86_64_ms_abi_int_parameter_registers[cum->regno];
    3172                 :            : 
    3173                 :            :   /* Only floating point modes are passed in anything but integer regs.  */
    3174                 :      93249 :   if (TARGET_SSE && (mode == SFmode || mode == DFmode))
    3175                 :            :     {
    3176                 :         38 :       if (named)
    3177                 :            :         {
    3178                 :         38 :           if (type == NULL_TREE || !AGGREGATE_TYPE_P (type))
    3179                 :         14 :             regno = cum->regno + FIRST_SSE_REG;
    3180                 :            :         }
    3181                 :            :       else
    3182                 :            :         {
    3183                 :          0 :           rtx t1, t2;
    3184                 :            : 
    3185                 :            :           /* Unnamed floating parameters are passed in both the
    3186                 :            :              SSE and integer registers.  */
    3187                 :          0 :           t1 = gen_rtx_REG (mode, cum->regno + FIRST_SSE_REG);
    3188                 :          0 :           t2 = gen_rtx_REG (mode, regno);
    3189                 :          0 :           t1 = gen_rtx_EXPR_LIST (VOIDmode, t1, const0_rtx);
    3190                 :          0 :           t2 = gen_rtx_EXPR_LIST (VOIDmode, t2, const0_rtx);
    3191                 :          0 :           return gen_rtx_PARALLEL (mode, gen_rtvec (2, t1, t2));
    3192                 :            :         }
    3193                 :            :     }
    3194                 :            :   /* Handle aggregated types passed in register.  */
    3195                 :      93249 :   if (orig_mode == BLKmode)
    3196                 :            :     {
    3197                 :          0 :       if (bytes > 0 && bytes <= 8)
    3198                 :          0 :         mode = (bytes > 4 ? DImode : SImode);
    3199                 :          0 :       if (mode == BLKmode)
    3200                 :          0 :         mode = DImode;
    3201                 :            :     }
    3202                 :            : 
    3203                 :      93249 :   return gen_reg_or_parallel (mode, orig_mode, regno);
    3204                 :            : }
    3205                 :            : 
    3206                 :            : /* Return where to put the arguments to a function.
    3207                 :            :    Return zero to push the argument on the stack, or a hard register in which to store the argument.
    3208                 :            : 
    3209                 :            :    ARG describes the argument while CUM gives information about the
    3210                 :            :    preceding args and about the function being called.  */
    3211                 :            : 
    3212                 :            : static rtx
    3213                 :   13643800 : ix86_function_arg (cumulative_args_t cum_v, const function_arg_info &arg)
    3214                 :            : {
    3215                 :   13643800 :   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
    3216                 :   13643800 :   machine_mode mode = arg.mode;
    3217                 :   13643800 :   HOST_WIDE_INT bytes, words;
    3218                 :   13643800 :   rtx reg;
    3219                 :            : 
    3220                 :   13643800 :   if (!cum->caller && cfun->machine->func_type != TYPE_NORMAL)
    3221                 :            :     {
    3222                 :        103 :       gcc_assert (arg.type != NULL_TREE);
    3223                 :        103 :       if (POINTER_TYPE_P (arg.type))
    3224                 :            :         {
    3225                 :            :           /* This is the pointer argument.  */
    3226                 :         78 :           gcc_assert (TYPE_MODE (arg.type) == Pmode);
    3227                 :            :           /* It is at -WORD(AP) in the current frame in interrupt and
    3228                 :            :              exception handlers.  */
    3229                 :         78 :           reg = plus_constant (Pmode, arg_pointer_rtx, -UNITS_PER_WORD);
    3230                 :            :         }
    3231                 :            :       else
    3232                 :            :         {
    3233                 :         25 :           gcc_assert (cfun->machine->func_type == TYPE_EXCEPTION
    3234                 :            :                       && TREE_CODE (arg.type) == INTEGER_TYPE
    3235                 :            :                       && TYPE_MODE (arg.type) == word_mode);
    3236                 :            :           /* The error code is the word-mode integer argument at
    3237                 :            :              -2 * WORD(AP) in the current frame of the exception
    3238                 :            :              handler.  */
    3239                 :         25 :           reg = gen_rtx_MEM (word_mode,
    3240                 :         25 :                              plus_constant (Pmode,
    3241                 :            :                                             arg_pointer_rtx,
    3242                 :         25 :                                             -2 * UNITS_PER_WORD));
    3243                 :            :         }
    3244                 :        103 :       return reg;
    3245                 :            :     }
    3246                 :            : 
    3247                 :   13643700 :   bytes = arg.promoted_size_in_bytes ();
    3248                 :   13643700 :   words = CEIL (bytes, UNITS_PER_WORD);
    3249                 :            : 
    3250                 :            :   /* To simplify the code below, represent vector types with a vector mode
    3251                 :            :      even if MMX/SSE are not active.  */
    3252                 :   13643700 :   if (arg.type && TREE_CODE (arg.type) == VECTOR_TYPE)
    3253                 :     112751 :     mode = type_natural_mode (arg.type, cum, false);
    3254                 :            : 
    3255                 :   13643700 :   if (TARGET_64BIT)
    3256                 :            :     {
    3257                 :   11557500 :       enum calling_abi call_abi = cum ? cum->call_abi : ix86_abi;
    3258                 :            : 
    3259                 :   11557500 :       if (call_abi == MS_ABI)
    3260                 :     146464 :         reg = function_arg_ms_64 (cum, mode, arg.mode, arg.named,
    3261                 :     146464 :                                   arg.type, bytes);
    3262                 :            :       else
    3263                 :   11411100 :         reg = function_arg_64 (cum, mode, arg.mode, arg.type, arg.named);
    3264                 :            :     }
    3265                 :            :   else
    3266                 :    2086220 :     reg = function_arg_32 (cum, mode, arg.mode, arg.type, bytes, words);
    3267                 :            : 
    3268                 :            :   /* Track if there are outgoing arguments on stack.  */
    3269                 :   13643700 :   if (reg == NULL_RTX && cum->caller)
    3270                 :    1628360 :     cfun->machine->outgoing_args_on_stack = true;
    3271                 :            : 
    3272                 :            :   return reg;
    3273                 :            : }
    3274                 :            : 
    3275                 :            : /* A C expression that indicates when an argument must be passed by
    3276                 :            :    reference.  If nonzero for an argument, a copy of that argument is
    3277                 :            :    made in memory and a pointer to the argument is passed instead of
    3278                 :            :    the argument itself.  The pointer is passed in whatever way is
    3279                 :            :    appropriate for passing a pointer to that type.  */
    3280                 :            : 
    3281                 :            : static bool
    3282                 :   13427900 : ix86_pass_by_reference (cumulative_args_t cum_v, const function_arg_info &arg)
    3283                 :            : {
    3284                 :   13427900 :   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
    3285                 :            : 
    3286                 :   13427900 :   if (TARGET_64BIT)
    3287                 :            :     {
    3288                 :   11731800 :       enum calling_abi call_abi = cum ? cum->call_abi : ix86_abi;
    3289                 :            : 
    3290                 :            :       /* See Windows x64 Software Convention.  */
    3291                 :   11731800 :       if (call_abi == MS_ABI)
    3292                 :            :         {
    3293                 :     144513 :           HOST_WIDE_INT msize = GET_MODE_SIZE (arg.mode);
    3294                 :            : 
    3295                 :     144513 :           if (tree type = arg.type)
    3296                 :            :             {
    3297                 :            :               /* Arrays are passed by reference.  */
    3298                 :     144513 :               if (TREE_CODE (type) == ARRAY_TYPE)
    3299                 :            :                 return true;
    3300                 :            : 
    3301                 :     144513 :               if (RECORD_OR_UNION_TYPE_P (type))
    3302                 :            :                 {
    3303                 :            :                   /* Structs/unions of sizes other than 8, 16, 32, or 64 bits
    3304                 :            :                      are passed by reference.  */
    3305                 :         56 :                   msize = int_size_in_bytes (type);
    3306                 :            :                 }
    3307                 :            :             }
    3308                 :            : 
    3309                 :            :           /* __m128 is passed by reference.  */
    3310                 :     288906 :           return msize != 1 && msize != 2 && msize != 4 && msize != 8;
    3311                 :            :         }
    3312                 :   11587300 :       else if (arg.type && int_size_in_bytes (arg.type) == -1)
    3313                 :          0 :         return true;
    3314                 :            :     }
    3315                 :            : 
    3316                 :            :   return false;
    3317                 :            : }
    3318                 :            : 
    3319                 :            : /* Return true when TYPE should be 128bit aligned for 32bit argument
    3320                 :            :    passing ABI.  XXX: This function is obsolete and is only used for
    3321                 :            :    checking psABI compatibility with previous versions of GCC.  */
    3322                 :            : 
    3323                 :            : static bool
    3324                 :    1574930 : ix86_compat_aligned_value_p (const_tree type)
    3325                 :            : {
    3326                 :    1574930 :   machine_mode mode = TYPE_MODE (type);
    3327                 :    1553570 :   if (((TARGET_SSE && SSE_REG_MODE_P (mode))
    3328                 :    1574890 :        || mode == TDmode
    3329                 :    1574890 :        || mode == TFmode
    3330                 :    1574890 :        || mode == TCmode)
    3331                 :    1575140 :       && (!TYPE_USER_ALIGN (type) || TYPE_ALIGN (type) > 128))
    3332                 :            :     return true;
    3333                 :    1574720 :   if (TYPE_ALIGN (type) < 128)
    3334                 :            :     return false;
    3335                 :            : 
    3336                 :          0 :   if (AGGREGATE_TYPE_P (type))
    3337                 :            :     {
    3338                 :            :       /* Walk the aggregates recursively.  */
    3339                 :          0 :       switch (TREE_CODE (type))
    3340                 :            :         {
    3341                 :          0 :         case RECORD_TYPE:
    3342                 :          0 :         case UNION_TYPE:
    3343                 :          0 :         case QUAL_UNION_TYPE:
    3344                 :          0 :           {
    3345                 :          0 :             tree field;
    3346                 :            : 
    3347                 :            :             /* Walk all the structure fields.  */
    3348                 :          0 :             for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
    3349                 :            :               {
    3350                 :          0 :                 if (TREE_CODE (field) == FIELD_DECL
    3351                 :          0 :                     && ix86_compat_aligned_value_p (TREE_TYPE (field)))
    3352                 :            :                   return true;
    3353                 :            :               }
    3354                 :            :             break;
    3355                 :            :           }
    3356                 :            : 
    3357                 :          0 :         case ARRAY_TYPE:
    3358                 :            :           /* Just for use if some languages passes arrays by value.  */
    3359                 :          0 :           if (ix86_compat_aligned_value_p (TREE_TYPE (type)))
    3360                 :          0 :             return true;
    3361                 :            :           break;
    3362                 :            : 
    3363                 :            :         default:
    3364                 :            :           gcc_unreachable ();
    3365                 :            :         }
    3366                 :            :     }
    3367                 :            :   return false;
    3368                 :            : }
    3369                 :            : 
    3370                 :            : /* Return the alignment boundary for MODE and TYPE with alignment ALIGN.
    3371                 :            :    XXX: This function is obsolete and is only used for checking psABI
    3372                 :            :    compatibility with previous versions of GCC.  */
    3373                 :            : 
    3374                 :            : static unsigned int
    3375                 :    3970770 : ix86_compat_function_arg_boundary (machine_mode mode,
    3376                 :            :                                    const_tree type, unsigned int align)
    3377                 :            : {
    3378                 :            :   /* In 32bit, only _Decimal128 and __float128 are aligned to their
    3379                 :            :      natural boundaries.  */
    3380                 :    3970770 :   if (!TARGET_64BIT && mode != TDmode && mode != TFmode)
    3381                 :            :     {
    3382                 :            :       /* i386 ABI defines all arguments to be 4 byte aligned.  We have to
    3383                 :            :          make an exception for SSE modes since these require 128bit
    3384                 :            :          alignment.
    3385                 :            : 
    3386                 :            :          The handling here differs from field_alignment.  ICC aligns MMX
    3387                 :            :          arguments to 4 byte boundaries, while structure fields are aligned
    3388                 :            :          to 8 byte boundaries.  */
    3389                 :    1586560 :       if (!type)
    3390                 :            :         {
    3391                 :      11624 :           if (!(TARGET_SSE && SSE_REG_MODE_P (mode)))
    3392                 :      11624 :             align = PARM_BOUNDARY;
    3393                 :            :         }
    3394                 :            :       else
    3395                 :            :         {
    3396                 :    1574930 :           if (!ix86_compat_aligned_value_p (type))
    3397                 :    1574720 :             align = PARM_BOUNDARY;
    3398                 :            :         }
    3399                 :            :     }
    3400                 :    7663120 :   if (align > BIGGEST_ALIGNMENT)
    3401                 :         59 :     align = BIGGEST_ALIGNMENT;
    3402                 :    3970770 :   return align;
    3403                 :            : }
    3404                 :            : 
    3405                 :            : /* Return true when TYPE should be 128bit aligned for 32bit argument
    3406                 :            :    passing ABI.  */
    3407                 :            : 
    3408                 :            : static bool
    3409                 :    1577250 : ix86_contains_aligned_value_p (const_tree type)
    3410                 :            : {
    3411                 :    1577250 :   machine_mode mode = TYPE_MODE (type);
    3412                 :            : 
    3413                 :    1577250 :   if (mode == XFmode || mode == XCmode)
    3414                 :            :     return false;
    3415                 :            : 
    3416                 :    1576230 :   if (TYPE_ALIGN (type) < 128)
    3417                 :            :     return false;
    3418                 :            : 
    3419                 :       2529 :   if (AGGREGATE_TYPE_P (type))
    3420                 :            :     {
    3421                 :            :       /* Walk the aggregates recursively.  */
    3422                 :          0 :       switch (TREE_CODE (type))
    3423                 :            :         {
    3424                 :          0 :         case RECORD_TYPE:
    3425                 :          0 :         case UNION_TYPE:
    3426                 :          0 :         case QUAL_UNION_TYPE:
    3427                 :          0 :           {
    3428                 :          0 :             tree field;
    3429                 :            : 
    3430                 :            :             /* Walk all the structure fields.  */
    3431                 :          0 :             for (field = TYPE_FIELDS (type);
    3432                 :          0 :                  field;
    3433                 :          0 :                  field = DECL_CHAIN (field))
    3434                 :            :               {
    3435                 :          0 :                 if (TREE_CODE (field) == FIELD_DECL
    3436                 :          0 :                     && ix86_contains_aligned_value_p (TREE_TYPE (field)))
    3437                 :            :                   return true;
    3438                 :            :               }
    3439                 :            :             break;
    3440                 :            :           }
    3441                 :            : 
    3442                 :          0 :         case ARRAY_TYPE:
    3443                 :            :           /* Just for use if some languages passes arrays by value.  */
    3444                 :          0 :           if (ix86_contains_aligned_value_p (TREE_TYPE (type)))
    3445                 :          0 :             return true;
    3446                 :            :           break;
    3447                 :            : 
    3448                 :            :         default:
    3449                 :            :           gcc_unreachable ();
    3450                 :            :         }
    3451                 :            :     }
    3452                 :            :   else
    3453                 :    1577250 :     return TYPE_ALIGN (type) >= 128;
    3454                 :            : 
    3455                 :            :   return false;
    3456                 :            : }
    3457                 :            : 
    3458                 :            : /* Gives the alignment boundary, in bits, of an argument with the
    3459                 :            :    specified mode and type.  */
    3460                 :            : 
    3461                 :            : static unsigned int
    3462                 :    7552470 : ix86_function_arg_boundary (machine_mode mode, const_tree type)
    3463                 :            : {
    3464                 :    7552470 :   unsigned int align;
    3465                 :    7552470 :   if (type)
    3466                 :            :     {
    3467                 :            :       /* Since the main variant type is used for call, we convert it to
    3468                 :            :          the main variant type.  */
    3469                 :    7515760 :       type = TYPE_MAIN_VARIANT (type);
    3470                 :    7515760 :       align = TYPE_ALIGN (type);
    3471                 :    7515760 :       if (TYPE_EMPTY_P (type))
    3472                 :      14782 :         return PARM_BOUNDARY;
    3473                 :            :     }
    3474                 :            :   else
    3475                 :      36706 :     align = GET_MODE_ALIGNMENT (mode);
    3476                 :    9168750 :   if (align < PARM_BOUNDARY)
    3477                 :            :     align = PARM_BOUNDARY;
    3478                 :            :   else
    3479                 :            :     {
    3480                 :    4203780 :       static bool warned;
    3481                 :    4203780 :       unsigned int saved_align = align;
    3482                 :            : 
    3483                 :    4203780 :       if (!TARGET_64BIT)
    3484                 :            :         {
    3485                 :            :           /* i386 ABI defines XFmode arguments to be 4 byte aligned.  */
    3486                 :    1611780 :           if (!type)
    3487                 :            :             {
    3488                 :      34528 :               if (mode == XFmode || mode == XCmode)
    3489                 :            :                 align = PARM_BOUNDARY;
    3490                 :            :             }
    3491                 :    1577250 :           else if (!ix86_contains_aligned_value_p (type))
    3492                 :            :             align = PARM_BOUNDARY;
    3493                 :            : 
    3494                 :      37049 :           if (align < 128)
    3495                 :    1586340 :             align = PARM_BOUNDARY;
    3496                 :            :         }
    3497                 :            : 
    3498                 :    4203780 :       if (warn_psabi
    3499                 :    3973360 :           && !warned
    3500                 :    8174540 :           && align != ix86_compat_function_arg_boundary (mode, type,
    3501                 :            :                                                          saved_align))
    3502                 :            :         {
    3503                 :         59 :           warned = true;
    3504                 :         59 :           inform (input_location,
    3505                 :            :                   "the ABI for passing parameters with %d-byte"
    3506                 :            :                   " alignment has changed in GCC 4.6",
    3507                 :            :                   align / BITS_PER_UNIT);
    3508                 :            :         }
    3509                 :            :     }
    3510                 :            : 
    3511                 :            :   return align;
    3512                 :            : }
    3513                 :            : 
    3514                 :            : /* Return true if N is a possible register number of function value.  */
    3515                 :            : 
    3516                 :            : static bool
    3517                 :    2039540 : ix86_function_value_regno_p (const unsigned int regno)
    3518                 :            : {
    3519                 :    2039540 :   switch (regno)
    3520                 :            :     {
    3521                 :            :     case AX_REG:
    3522                 :            :       return true;
    3523                 :      66647 :     case DX_REG:
    3524                 :      66647 :       return (!TARGET_64BIT || ix86_cfun_abi () != MS_ABI);
    3525                 :      70556 :     case DI_REG:
    3526                 :      70556 :     case SI_REG:
    3527                 :      70556 :       return TARGET_64BIT && ix86_cfun_abi () != MS_ABI;
    3528                 :            : 
    3529                 :            :       /* Complex values are returned in %st(0)/%st(1) pair.  */
    3530                 :      17002 :     case ST0_REG:
    3531                 :      17002 :     case ST1_REG:
    3532                 :            :       /* TODO: The function should depend on current function ABI but
    3533                 :            :        builtins.c would need updating then. Therefore we use the
    3534                 :            :        default ABI.  */
    3535                 :      17002 :       if (TARGET_64BIT && ix86_cfun_abi () == MS_ABI)
    3536                 :            :         return false;
    3537                 :      17002 :       return TARGET_FLOAT_RETURNS_IN_80387;
    3538                 :            : 
    3539                 :            :       /* Complex values are returned in %xmm0/%xmm1 pair.  */
    3540                 :     261890 :     case XMM0_REG:
    3541                 :     261890 :     case XMM1_REG:
    3542                 :     261890 :       return TARGET_SSE;
    3543                 :            : 
    3544                 :       5902 :     case MM0_REG:
    3545                 :       5902 :       if (TARGET_MACHO || TARGET_64BIT)
    3546                 :            :         return false;
    3547                 :       3037 :       return TARGET_MMX;
    3548                 :            :     }
    3549                 :            : 
    3550                 :     443017 :   return false;
    3551                 :            : }
    3552                 :            : 
    3553                 :            : /* Define how to find the value returned by a function.
    3554                 :            :    VALTYPE is the data type of the value (as a tree).
    3555                 :            :    If the precise function being called is known, FUNC is its FUNCTION_DECL;
    3556                 :            :    otherwise, FUNC is 0.  */
    3557                 :            : 
    3558                 :            : static rtx
    3559                 :    2873960 : function_value_32 (machine_mode orig_mode, machine_mode mode,
    3560                 :            :                    const_tree fntype, const_tree fn)
    3561                 :            : {
    3562                 :    2873960 :   unsigned int regno;
    3563                 :            : 
    3564                 :            :   /* 8-byte vector modes in %mm0. See ix86_return_in_memory for where
    3565                 :            :      we normally prevent this case when mmx is not available.  However
    3566                 :            :      some ABIs may require the result to be returned like DImode.  */
    3567                 :    3069630 :   if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 8)
    3568                 :            :     regno = FIRST_MMX_REG;
    3569                 :            : 
    3570                 :            :   /* 16-byte vector modes in %xmm0.  See ix86_return_in_memory for where
    3571                 :            :      we prevent this case when sse is not available.  However some ABIs
    3572                 :            :      may require the result to be returned like integer TImode.  */
    3573                 :    2864720 :   else if (mode == TImode
    3574                 :    3051130 :            || (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 16))
    3575                 :            :     regno = FIRST_SSE_REG;
    3576                 :            : 
    3577                 :            :   /* 32-byte vector modes in %ymm0.   */
    3578                 :    2894640 :   else if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 32)
    3579                 :            :     regno = FIRST_SSE_REG;
    3580                 :            : 
    3581                 :            :   /* 64-byte vector modes in %zmm0.   */
    3582                 :    2789390 :   else if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 64)
    3583                 :            :     regno = FIRST_SSE_REG;
    3584                 :            : 
    3585                 :            :   /* Floating point return values in %st(0) (unless -mno-fp-ret-in-387).  */
    3586                 :    2678300 :   else if (X87_FLOAT_MODE_P (mode) && TARGET_FLOAT_RETURNS_IN_80387)
    3587                 :            :     regno = FIRST_FLOAT_REG;
    3588                 :            :   else
    3589                 :            :     /* Most things go in %eax.  */
    3590                 :    2637860 :     regno = AX_REG;
    3591                 :            : 
    3592                 :            :   /* Override FP return register with %xmm0 for local functions when
    3593                 :            :      SSE math is enabled or for functions with sseregparm attribute.  */
    3594                 :    2873960 :   if ((fn || fntype) && (mode == SFmode || mode == DFmode))
    3595                 :            :     {
    3596                 :      32800 :       int sse_level = ix86_function_sseregparm (fntype, fn, false);
    3597                 :      32800 :       if (sse_level == -1)
    3598                 :            :         {
    3599                 :          0 :           error ("calling %qD with SSE calling convention without "
    3600                 :            :                  "SSE/SSE2 enabled", fn);
    3601                 :          0 :           sorry ("this is a GCC bug that can be worked around by adding "
    3602                 :            :                  "attribute used to function called");
    3603                 :            :         }
    3604                 :      32800 :       else if ((sse_level >= 1 && mode == SFmode)
    3605                 :      32800 :                || (sse_level == 2 && mode == DFmode))
    3606                 :          0 :         regno = FIRST_SSE_REG;
    3607                 :            :     }
    3608                 :            : 
    3609                 :            :   /* OImode shouldn't be used directly.  */
    3610                 :    2873960 :   gcc_assert (mode != OImode);
    3611                 :            : 
    3612                 :    2873960 :   return gen_rtx_REG (orig_mode, regno);
    3613                 :            : }
    3614                 :            : 
    3615                 :            : static rtx
    3616                 :   40776100 : function_value_64 (machine_mode orig_mode, machine_mode mode,
    3617                 :            :                    const_tree valtype)
    3618                 :            : {
    3619                 :   40776100 :   rtx ret;
    3620                 :            : 
    3621                 :            :   /* Handle libcalls, which don't provide a type node.  */
    3622                 :   40776100 :   if (valtype == NULL)
    3623                 :            :     {
    3624                 :      74156 :       unsigned int regno;
    3625                 :            : 
    3626                 :      74156 :       switch (mode)
    3627                 :            :         {
    3628                 :            :         case E_SFmode:
    3629                 :            :         case E_SCmode:
    3630                 :            :         case E_DFmode:
    3631                 :            :         case E_DCmode:
    3632                 :            :         case E_TFmode:
    3633                 :            :         case E_SDmode:
    3634                 :            :         case E_DDmode:
    3635                 :            :         case E_TDmode:
    3636                 :            :           regno = FIRST_SSE_REG;
    3637                 :            :           break;
    3638                 :       1122 :         case E_XFmode:
    3639                 :       1122 :         case E_XCmode:
    3640                 :       1122 :           regno = FIRST_FLOAT_REG;
    3641                 :       1122 :           break;
    3642                 :            :         case E_TCmode:
    3643                 :            :           return NULL;
    3644                 :      48046 :         default:
    3645                 :      48046 :           regno = AX_REG;
    3646                 :            :         }
    3647                 :            : 
    3648                 :      74156 :       return gen_rtx_REG (mode, regno);
    3649                 :            :     }
    3650                 :   40701900 :   else if (POINTER_TYPE_P (valtype))
    3651                 :            :     {
    3652                 :            :       /* Pointers are always returned in word_mode.  */
    3653                 :    6751340 :       mode = word_mode;
    3654                 :            :     }
    3655                 :            : 
    3656                 :   40701900 :   ret = construct_container (mode, orig_mode, valtype, 1,
    3657                 :            :                              X86_64_REGPARM_MAX, X86_64_SSE_REGPARM_MAX,
    3658                 :            :                              x86_64_int_return_registers, 0);
    3659                 :            : 
    3660                 :            :   /* For zero sized structures, construct_container returns NULL, but we
    3661                 :            :      need to keep rest of compiler happy by returning meaningful value.  */
    3662                 :   40701900 :   if (!ret)
    3663                 :     138552 :     ret = gen_rtx_REG (orig_mode, AX_REG);
    3664                 :            : 
    3665                 :            :   return ret;
    3666                 :            : }
    3667                 :            : 
    3668                 :            : static rtx
    3669                 :          0 : function_value_ms_32 (machine_mode orig_mode, machine_mode mode,
    3670                 :            :                       const_tree fntype, const_tree fn, const_tree valtype)
    3671                 :            : {
    3672                 :          0 :   unsigned int regno;
    3673                 :            : 
    3674                 :            :   /* Floating point return values in %st(0)
    3675                 :            :      (unless -mno-fp-ret-in-387 or aggregate type of up to 8 bytes).  */
    3676                 :          0 :   if (X87_FLOAT_MODE_P (mode) && TARGET_FLOAT_RETURNS_IN_80387
    3677                 :          0 :            && (GET_MODE_SIZE (mode) > 8
    3678                 :          0 :                || valtype == NULL_TREE || !AGGREGATE_TYPE_P (valtype)))
    3679                 :            :   {
    3680                 :          0 :     regno = FIRST_FLOAT_REG;
    3681                 :          0 :     return gen_rtx_REG (orig_mode, regno);
    3682                 :            :   }
    3683                 :            :   else
    3684                 :          0 :     return function_value_32(orig_mode, mode, fntype,fn);
    3685                 :            : }
    3686                 :            : 
    3687                 :            : static rtx
    3688                 :     428588 : function_value_ms_64 (machine_mode orig_mode, machine_mode mode,
    3689                 :            :                       const_tree valtype)
    3690                 :            : {
    3691                 :     428588 :   unsigned int regno = AX_REG;
    3692                 :            : 
    3693                 :     428588 :   if (TARGET_SSE)
    3694                 :            :     {
    3695                 :     857174 :       switch (GET_MODE_SIZE (mode))
    3696                 :            :         {
    3697                 :       4809 :         case 16:
    3698                 :       4809 :           if (valtype != NULL_TREE
    3699                 :       9618 :               && !VECTOR_INTEGER_TYPE_P (valtype)
    3700                 :       4302 :               && !VECTOR_INTEGER_TYPE_P (valtype)
    3701                 :       2151 :               && !INTEGRAL_TYPE_P (valtype)
    3702                 :       9111 :               && !VECTOR_FLOAT_TYPE_P (valtype))
    3703                 :            :             break;
    3704                 :       4809 :           if ((SCALAR_INT_MODE_P (mode) || VECTOR_MODE_P (mode))
    3705                 :       4809 :               && !COMPLEX_MODE_P (mode))
    3706                 :       4809 :             regno = FIRST_SSE_REG;
    3707                 :            :           break;
    3708                 :     422476 :         case 8:
    3709                 :     422476 :         case 4:
    3710                 :     422476 :           if (valtype != NULL_TREE && AGGREGATE_TYPE_P (valtype))
    3711                 :            :             break;
    3712                 :     422388 :           if (mode == SFmode || mode == DFmode)
    3713                 :        102 :             regno = FIRST_SSE_REG;
    3714                 :            :           break;
    3715                 :            :         default:
    3716                 :            :           break;
    3717                 :            :         }
    3718                 :            :     }
    3719                 :     428588 :   return gen_rtx_REG (orig_mode, regno);
    3720                 :            : }
    3721                 :            : 
    3722                 :            : static rtx
    3723                 :   44078600 : ix86_function_value_1 (const_tree valtype, const_tree fntype_or_decl,
    3724                 :            :                        machine_mode orig_mode, machine_mode mode)
    3725                 :            : {
    3726                 :   44078600 :   const_tree fn, fntype;
    3727                 :            : 
    3728                 :   44078600 :   fn = NULL_TREE;
    3729                 :   44078600 :   if (fntype_or_decl && DECL_P (fntype_or_decl))
    3730                 :    2138540 :     fn = fntype_or_decl;
    3731                 :    2138540 :   fntype = fn ? TREE_TYPE (fn) : fntype_or_decl;
    3732                 :            :   
    3733                 :   44078600 :   if (ix86_function_type_abi (fntype) == MS_ABI)
    3734                 :            :     {
    3735                 :     428588 :       if (TARGET_64BIT)
    3736                 :     428588 :         return function_value_ms_64 (orig_mode, mode, valtype);
    3737                 :            :       else
    3738                 :          0 :         return function_value_ms_32 (orig_mode, mode, fntype, fn, valtype);
    3739                 :            :     }
    3740                 :   43650100 :   else if (TARGET_64BIT)
    3741                 :   40776100 :     return function_value_64 (orig_mode, mode, valtype);
    3742                 :            :   else
    3743                 :    2873960 :     return function_value_32 (orig_mode, mode, fntype, fn);
    3744                 :            : }
    3745                 :            : 
    3746                 :            : static rtx
    3747                 :   44001900 : ix86_function_value (const_tree valtype, const_tree fntype_or_decl, bool)
    3748                 :            : {
    3749                 :   44001900 :   machine_mode mode, orig_mode;
    3750                 :            : 
    3751                 :   44001900 :   orig_mode = TYPE_MODE (valtype);
    3752                 :   44001900 :   mode = type_natural_mode (valtype, NULL, true);
    3753                 :   44001900 :   return ix86_function_value_1 (valtype, fntype_or_decl, orig_mode, mode);
    3754                 :            : }
    3755                 :            : 
    3756                 :            : /* Pointer function arguments and return values are promoted to
    3757                 :            :    word_mode for normal functions.  */
    3758                 :            : 
    3759                 :            : static machine_mode
    3760                 :   20050000 : ix86_promote_function_mode (const_tree type, machine_mode mode,
    3761                 :            :                             int *punsignedp, const_tree fntype,
    3762                 :            :                             int for_return)
    3763                 :            : {
    3764                 :   20050000 :   if (cfun->machine->func_type == TYPE_NORMAL
    3765                 :   20049500 :       && type != NULL_TREE
    3766                 :   20036500 :       && POINTER_TYPE_P (type))
    3767                 :            :     {
    3768                 :    9636910 :       *punsignedp = POINTERS_EXTEND_UNSIGNED;
    3769                 :    9636910 :       return word_mode;
    3770                 :            :     }
    3771                 :   10413100 :   return default_promote_function_mode (type, mode, punsignedp, fntype,
    3772                 :   10413100 :                                         for_return);
    3773                 :            : }
    3774                 :            : 
    3775                 :            : /* Return true if a structure, union or array with MODE containing FIELD
    3776                 :            :    should be accessed using BLKmode.  */
    3777                 :            : 
    3778                 :            : static bool
    3779                 :   26700100 : ix86_member_type_forces_blk (const_tree field, machine_mode mode)
    3780                 :            : {
    3781                 :            :   /* Union with XFmode must be in BLKmode.  */
    3782                 :   26700100 :   return (mode == XFmode
    3783                 :   26708500 :           && (TREE_CODE (DECL_FIELD_CONTEXT (field)) == UNION_TYPE
    3784                 :       7047 :               || TREE_CODE (DECL_FIELD_CONTEXT (field)) == QUAL_UNION_TYPE));
    3785                 :            : }
    3786                 :            : 
    3787                 :            : rtx
    3788                 :      76707 : ix86_libcall_value (machine_mode mode)
    3789                 :            : {
    3790                 :      76707 :   return ix86_function_value_1 (NULL, NULL, mode, mode);
    3791                 :            : }
    3792                 :            : 
    3793                 :            : /* Return true iff type is returned in memory.  */
    3794                 :            : 
    3795                 :            : static bool
    3796                 :   43505200 : ix86_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
    3797                 :            : {
    3798                 :            : #ifdef SUBTARGET_RETURN_IN_MEMORY
    3799                 :            :   return SUBTARGET_RETURN_IN_MEMORY (type, fntype);
    3800                 :            : #else
    3801                 :   43505200 :   const machine_mode mode = type_natural_mode (type, NULL, true);
    3802                 :   43505200 :   HOST_WIDE_INT size;
    3803                 :            : 
    3804                 :   43505200 :   if (TARGET_64BIT)
    3805                 :            :     {
    3806                 :   40081700 :       if (ix86_function_type_abi (fntype) == MS_ABI)
    3807                 :            :         {
    3808                 :     379707 :           size = int_size_in_bytes (type);
    3809                 :            : 
    3810                 :            :           /* __m128 is returned in xmm0.  */
    3811                 :     392319 :           if ((!type || VECTOR_INTEGER_TYPE_P (type)
    3812                 :     372024 :                || INTEGRAL_TYPE_P (type)
    3813                 :      11336 :                || VECTOR_FLOAT_TYPE_P (type))
    3814                 :     378229 :               && (SCALAR_INT_MODE_P (mode) || VECTOR_MODE_P (mode))
    3815                 :     378229 :               && !COMPLEX_MODE_P (mode)
    3816                 :     757936 :               && (GET_MODE_SIZE (mode) == 16 || size == 16))
    3817                 :            :             return false;
    3818                 :            : 
    3819                 :            :           /* Otherwise, the size must be exactly in [1248]. */
    3820                 :     741233 :           return size != 1 && size != 2 && size != 4 && size != 8;
    3821                 :            :         }
    3822                 :            :       else
    3823                 :            :         {
    3824                 :   39702000 :           int needed_intregs, needed_sseregs;
    3825                 :            : 
    3826                 :   39702000 :           return examine_argument (mode, type, 1,
    3827                 :            :                                    &needed_intregs, &needed_sseregs);
    3828                 :            :         }
    3829                 :            :     }
    3830                 :            :   else
    3831                 :            :     {
    3832                 :    3423530 :       size = int_size_in_bytes (type);
    3833                 :            : 
    3834                 :            :       /* Intel MCU psABI returns scalars and aggregates no larger than 8
    3835                 :            :          bytes in registers.  */
    3836                 :    3423530 :       if (TARGET_IAMCU)
    3837                 :          0 :         return VECTOR_MODE_P (mode) || size < 0 || size > 8;
    3838                 :            : 
    3839                 :    3423530 :       if (mode == BLKmode)
    3840                 :            :         return true;
    3841                 :            : 
    3842                 :    3423530 :       if (MS_AGGREGATE_RETURN && AGGREGATE_TYPE_P (type) && size <= 8)
    3843                 :            :         return false;
    3844                 :            : 
    3845                 :    3423530 :       if (VECTOR_MODE_P (mode) || mode == TImode)
    3846                 :            :         {
    3847                 :            :           /* User-created vectors small enough to fit in EAX.  */
    3848                 :     195635 :           if (size < 8)
    3849                 :            :             return false;
    3850                 :            : 
    3851                 :            :           /* Unless ABI prescibes otherwise,
    3852                 :            :              MMX/3dNow values are returned in MM0 if available.  */
    3853                 :            :              
    3854                 :     195635 :           if (size == 8)
    3855                 :      18480 :             return TARGET_VECT8_RETURNS || !TARGET_MMX;
    3856                 :            : 
    3857                 :            :           /* SSE values are returned in XMM0 if available.  */
    3858                 :     186395 :           if (size == 16)
    3859                 :      78237 :             return !TARGET_SSE;
    3860                 :            : 
    3861                 :            :           /* AVX values are returned in YMM0 if available.  */
    3862                 :     108158 :           if (size == 32)
    3863                 :      52615 :             return !TARGET_AVX;
    3864                 :            : 
    3865                 :            :           /* AVX512F values are returned in ZMM0 if available.  */
    3866                 :      55543 :           if (size == 64)
    3867                 :      55543 :             return !TARGET_AVX512F;
    3868                 :            :         }
    3869                 :            : 
    3870                 :    3227890 :       if (mode == XFmode)
    3871                 :            :         return false;
    3872                 :            : 
    3873                 :    3221320 :       if (size > 12)
    3874                 :            :         return true;
    3875                 :            : 
    3876                 :            :       /* OImode shouldn't be used directly.  */
    3877                 :    2377310 :       gcc_assert (mode != OImode);
    3878                 :            : 
    3879                 :            :       return false;
    3880                 :            :     }
    3881                 :            : #endif
    3882                 :            : }
    3883                 :            : 
    3884                 :            : 
    3885                 :            : /* Create the va_list data type.  */
    3886                 :            : 
    3887                 :            : static tree
    3888                 :     194627 : ix86_build_builtin_va_list_64 (void)
    3889                 :            : {
    3890                 :     194627 :   tree f_gpr, f_fpr, f_ovf, f_sav, record, type_decl;
    3891                 :            : 
    3892                 :     194627 :   record = lang_hooks.types.make_type (RECORD_TYPE);
    3893                 :     194627 :   type_decl = build_decl (BUILTINS_LOCATION,
    3894                 :            :                           TYPE_DECL, get_identifier ("__va_list_tag"), record);
    3895                 :            : 
    3896                 :     194627 :   f_gpr = build_decl (BUILTINS_LOCATION,
    3897                 :            :                       FIELD_DECL, get_identifier ("gp_offset"),
    3898                 :            :                       unsigned_type_node);
    3899                 :     194627 :   f_fpr = build_decl (BUILTINS_LOCATION,
    3900                 :            :                       FIELD_DECL, get_identifier ("fp_offset"),
    3901                 :            :                       unsigned_type_node);
    3902                 :     194627 :   f_ovf = build_decl (BUILTINS_LOCATION,
    3903                 :            :                       FIELD_DECL, get_identifier ("overflow_arg_area"),
    3904                 :            :                       ptr_type_node);
    3905                 :     194627 :   f_sav = build_decl (BUILTINS_LOCATION,
    3906                 :            :                       FIELD_DECL, get_identifier ("reg_save_area"),
    3907                 :            :                       ptr_type_node);
    3908                 :            : 
    3909                 :     194627 :   va_list_gpr_counter_field = f_gpr;
    3910                 :     194627 :   va_list_fpr_counter_field = f_fpr;
    3911                 :            : 
    3912                 :     194627 :   DECL_FIELD_CONTEXT (f_gpr) = record;
    3913                 :     194627 :   DECL_FIELD_CONTEXT (f_fpr) = record;
    3914                 :     194627 :   DECL_FIELD_CONTEXT (f_ovf) = record;
    3915                 :     194627 :   DECL_FIELD_CONTEXT (f_sav) = record;
    3916                 :            : 
    3917                 :     194627 :   TYPE_STUB_DECL (record) = type_decl;
    3918                 :     194627 :   TYPE_NAME (record) = type_decl;
    3919                 :     194627 :   TYPE_FIELDS (record) = f_gpr;
    3920                 :     194627 :   DECL_CHAIN (f_gpr) = f_fpr;
    3921                 :     194627 :   DECL_CHAIN (f_fpr) = f_ovf;
    3922                 :     194627 :   DECL_CHAIN (f_ovf) = f_sav;
    3923                 :            : 
    3924                 :     194627 :   layout_type (record);
    3925                 :            : 
    3926                 :     389254 :   TYPE_ATTRIBUTES (record) = tree_cons (get_identifier ("sysv_abi va_list"),
    3927                 :     194627 :                                         NULL_TREE, TYPE_ATTRIBUTES (record));
    3928                 :            : 
    3929                 :            :   /* The correct type is an array type of one element.  */
    3930                 :     194627 :   return build_array_type (record, build_index_type (size_zero_node));
    3931                 :            : }
    3932                 :            : 
    3933                 :            : /* Setup the builtin va_list data type and for 64-bit the additional
    3934                 :            :    calling convention specific va_list data types.  */
    3935                 :            : 
    3936                 :            : static tree
    3937                 :     200291 : ix86_build_builtin_va_list (void)
    3938                 :            : {
    3939                 :     200291 :   if (TARGET_64BIT)
    3940                 :            :     {
    3941                 :            :       /* Initialize ABI specific va_list builtin types.
    3942                 :            : 
    3943                 :            :          In lto1, we can encounter two va_list types:
    3944                 :            :          - one as a result of the type-merge across TUs, and
    3945                 :            :          - the one constructed here.
    3946                 :            :          These two types will not have the same TYPE_MAIN_VARIANT, and therefore
    3947                 :            :          a type identity check in canonical_va_list_type based on
    3948                 :            :          TYPE_MAIN_VARIANT (which we used to have) will not work.
    3949                 :            :          Instead, we tag each va_list_type_node with its unique attribute, and
    3950                 :            :          look for the attribute in the type identity check in
    3951                 :            :          canonical_va_list_type.
    3952                 :            : 
    3953                 :            :          Tagging sysv_va_list_type_node directly with the attribute is
    3954                 :            :          problematic since it's a array of one record, which will degrade into a
    3955                 :            :          pointer to record when used as parameter (see build_va_arg comments for
    3956                 :            :          an example), dropping the attribute in the process.  So we tag the
    3957                 :            :          record instead.  */
    3958                 :            : 
    3959                 :            :       /* For SYSV_ABI we use an array of one record.  */
    3960                 :     194627 :       sysv_va_list_type_node = ix86_build_builtin_va_list_64 ();
    3961                 :            :         
    3962                 :            :       /* For MS_ABI we use plain pointer to argument area.  */
    3963                 :     194627 :       tree char_ptr_type = build_pointer_type (char_type_node);
    3964                 :     389254 :       tree attr = tree_cons (get_identifier ("ms_abi va_list"), NULL_TREE,
    3965                 :     194627 :                              TYPE_ATTRIBUTES (char_ptr_type));
    3966                 :     194627 :       ms_va_list_type_node = build_type_attribute_variant (char_ptr_type, attr);
    3967                 :            : 
    3968                 :     194627 :       return ((ix86_abi == MS_ABI)
    3969                 :     194627 :               ? ms_va_list_type_node
    3970                 :     194627 :               : sysv_va_list_type_node);
    3971                 :            :     }
    3972                 :            :   else
    3973                 :            :     {
    3974                 :            :       /* For i386 we use plain pointer to argument area.  */
    3975                 :       5664 :       return build_pointer_type (char_type_node);
    3976                 :            :     }
    3977                 :            : }
    3978                 :            : 
    3979                 :            : /* Worker function for TARGET_SETUP_INCOMING_VARARGS.  */
    3980                 :            : 
    3981                 :            : static void
    3982                 :      10200 : setup_incoming_varargs_64 (CUMULATIVE_ARGS *cum)
    3983                 :            : {
    3984                 :      10200 :   rtx save_area, mem;
    3985                 :      10200 :   alias_set_type set;
    3986                 :      10200 :   int i, max;
    3987                 :            : 
    3988                 :            :   /* GPR size of varargs save area.  */
    3989                 :      10200 :   if (cfun->va_list_gpr_size)
    3990                 :       9850 :     ix86_varargs_gpr_size = X86_64_REGPARM_MAX * UNITS_PER_WORD;
    3991                 :            :   else
    3992                 :        350 :     ix86_varargs_gpr_size = 0;
    3993                 :            : 
    3994                 :            :   /* FPR size of varargs save area.  We don't need it if we don't pass
    3995                 :            :      anything in SSE registers.  */
    3996                 :      10200 :   if (TARGET_SSE && cfun->va_list_fpr_size)
    3997                 :       9365 :     ix86_varargs_fpr_size = X86_64_SSE_REGPARM_MAX * 16;
    3998                 :            :   else
    3999                 :        835 :     ix86_varargs_fpr_size = 0;
    4000                 :            : 
    4001                 :      10200 :   if (! ix86_varargs_gpr_size && ! ix86_varargs_fpr_size)
    4002                 :            :     return;
    4003                 :            : 
    4004                 :       9997 :   save_area = frame_pointer_rtx;
    4005                 :       9997 :   set = get_varargs_alias_set ();
    4006                 :            : 
    4007                 :       9997 :   max = cum->regno + cfun->va_list_gpr_size / UNITS_PER_WORD;
    4008                 :       9997 :   if (max > X86_64_REGPARM_MAX)
    4009                 :            :     max = X86_64_REGPARM_MAX;
    4010                 :            : 
    4011                 :      54364 :   for (i = cum->regno; i < max; i++)
    4012                 :            :     {
    4013                 :      44367 :       mem = gen_rtx_MEM (word_mode,
    4014                 :      44367 :                          plus_constant (Pmode, save_area, i * UNITS_PER_WORD));
    4015                 :      44367 :       MEM_NOTRAP_P (mem) = 1;
    4016                 :      44367 :       set_mem_alias_set (mem, set);
    4017                 :      44367 :       emit_move_insn (mem,
    4018                 :            :                       gen_rtx_REG (word_mode,
    4019                 :      44367 :                                    x86_64_int_parameter_registers[i]));
    4020                 :            :     }
    4021                 :            : 
    4022                 :       9997 :   if (ix86_varargs_fpr_size)
    4023                 :            :     {
    4024                 :       9365 :       machine_mode smode;
    4025                 :       9365 :       rtx_code_label *label;
    4026                 :       9365 :       rtx test;
    4027                 :            : 
    4028                 :            :       /* Now emit code to save SSE registers.  The AX parameter contains number
    4029                 :            :          of SSE parameter registers used to call this function, though all we
    4030                 :            :          actually check here is the zero/non-zero status.  */
    4031                 :            : 
    4032                 :       9365 :       label = gen_label_rtx ();
    4033                 :       9365 :       test = gen_rtx_EQ (VOIDmode, gen_rtx_REG (QImode, AX_REG), const0_rtx);
    4034                 :       9365 :       emit_jump_insn (gen_cbranchqi4 (test, XEXP (test, 0), XEXP (test, 1),
    4035                 :            :                                       label));
    4036                 :            : 
    4037                 :            :       /* ??? If !TARGET_SSE_TYPELESS_STORES, would we perform better if
    4038                 :            :          we used movdqa (i.e. TImode) instead?  Perhaps even better would
    4039                 :            :          be if we could determine the real mode of the data, via a hook
    4040                 :            :          into pass_stdarg.  Ignore all that for now.  */
    4041                 :       9365 :       smode = V4SFmode;
    4042                 :       9365 :       if (crtl->stack_alignment_needed < GET_MODE_ALIGNMENT (smode))
    4043                 :       3016 :         crtl->stack_alignment_needed = GET_MODE_ALIGNMENT (smode);
    4044                 :            : 
    4045                 :       9365 :       max = cum->sse_regno + cfun->va_list_fpr_size / 16;
    4046                 :       9365 :       if (max > X86_64_SSE_REGPARM_MAX)
    4047                 :            :         max = X86_64_SSE_REGPARM_MAX;
    4048                 :            : 
    4049                 :      82997 :       for (i = cum->sse_regno; i < max; ++i)
    4050                 :            :         {
    4051                 :      73632 :           mem = plus_constant (Pmode, save_area,
    4052                 :      73632 :                                i * 16 + ix86_varargs_gpr_size);
    4053                 :      73632 :           mem = gen_rtx_MEM (smode, mem);
    4054                 :      73632 :           MEM_NOTRAP_P (mem) = 1;
    4055                 :      73632 :           set_mem_alias_set (mem, set);
    4056                 :      73632 :           set_mem_align (mem, GET_MODE_ALIGNMENT (smode));
    4057                 :            : 
    4058                 :      73632 :           emit_move_insn (mem, gen_rtx_REG (smode, GET_SSE_REGNO (i)));
    4059                 :            :         }
    4060                 :            : 
    4061                 :       9365 :       emit_label (label);
    4062                 :            :     }
    4063                 :            : }
    4064                 :            : 
    4065                 :            : static void
    4066                 :       5652 : setup_incoming_varargs_ms_64 (CUMULATIVE_ARGS *cum)
    4067                 :            : {
    4068                 :       5652 :   alias_set_type set = get_varargs_alias_set ();
    4069                 :       5652 :   int i;
    4070                 :            : 
    4071                 :            :   /* Reset to zero, as there might be a sysv vaarg used
    4072                 :            :      before.  */
    4073                 :       5652 :   ix86_varargs_gpr_size = 0;
    4074                 :       5652 :   ix86_varargs_fpr_size = 0;
    4075                 :            : 
    4076                 :      14154 :   for (i = cum->regno; i < X86_64_MS_REGPARM_MAX; i++)
    4077                 :            :     {
    4078                 :       8502 :       rtx reg, mem;
    4079                 :            : 
    4080                 :       8502 :       mem = gen_rtx_MEM (Pmode,
    4081                 :       8502 :                          plus_constant (Pmode, virtual_incoming_args_rtx,
    4082                 :       8502 :                                         i * UNITS_PER_WORD));
    4083                 :       8502 :       MEM_NOTRAP_P (mem) = 1;
    4084                 :       8502 :       set_mem_alias_set (mem, set);
    4085                 :            : 
    4086                 :       8502 :       reg = gen_rtx_REG (Pmode, x86_64_ms_abi_int_parameter_registers[i]);
    4087                 :       8502 :       emit_move_insn (mem, reg);
    4088                 :            :     }
    4089                 :       5652 : }
    4090                 :            : 
    4091                 :            : static void
    4092                 :      15981 : ix86_setup_incoming_varargs (cumulative_args_t cum_v,
    4093                 :            :                              const function_arg_info &arg,
    4094                 :            :                              int *, int no_rtl)
    4095                 :            : {
    4096                 :      15981 :   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
    4097                 :      15981 :   CUMULATIVE_ARGS next_cum;
    4098                 :      15981 :   tree fntype;
    4099                 :            : 
    4100                 :            :   /* This argument doesn't appear to be used anymore.  Which is good,
    4101                 :            :      because the old code here didn't suppress rtl generation.  */
    4102                 :      15981 :   gcc_assert (!no_rtl);
    4103                 :            : 
    4104                 :      15981 :   if (!TARGET_64BIT)
    4105                 :        129 :     return;
    4106                 :            : 
    4107                 :      15852 :   fntype = TREE_TYPE (current_function_decl);
    4108                 :            : 
    4109                 :            :   /* For varargs, we do not want to skip the dummy va_dcl argument.
    4110                 :            :      For stdargs, we do want to skip the last named argument.  */
    4111                 :      15852 :   next_cum = *cum;
    4112                 :      15852 :   if (stdarg_p (fntype))
    4113                 :      15852 :     ix86_function_arg_advance (pack_cumulative_args (&next_cum), arg);
    4114                 :            : 
    4115                 :      15852 :   if (cum->call_abi == MS_ABI)
    4116                 :       5652 :     setup_incoming_varargs_ms_64 (&next_cum);
    4117                 :            :   else
    4118                 :      10200 :     setup_incoming_varargs_64 (&next_cum);
    4119                 :            : }
    4120                 :            : 
    4121                 :            : /* Checks if TYPE is of kind va_list char *.  */
    4122                 :            : 
    4123                 :            : static bool
    4124                 :      51479 : is_va_list_char_pointer (tree type)
    4125                 :            : {
    4126                 :      51479 :   tree canonic;
    4127                 :            : 
    4128                 :            :   /* For 32-bit it is always true.  */
    4129                 :      51479 :   if (!TARGET_64BIT)
    4130                 :            :     return true;
    4131                 :      51339 :   canonic = ix86_canonical_va_list_type (type);
    4132                 :      51339 :   return (canonic == ms_va_list_type_node
    4133                 :      51339 :           || (ix86_abi == MS_ABI && canonic == va_list_type_node));
    4134                 :            : }
    4135                 :            : 
    4136                 :            : /* Implement va_start.  */
    4137                 :            : 
    4138                 :            : static void
    4139                 :      15655 : ix86_va_start (tree valist, rtx nextarg)
    4140                 :            : {
    4141                 :      15655 :   HOST_WIDE_INT words, n_gpr, n_fpr;
    4142                 :      15655 :   tree f_gpr, f_fpr, f_ovf, f_sav;
    4143                 :      15655 :   tree gpr, fpr, ovf, sav, t;
    4144                 :      15655 :   tree type;
    4145                 :      15655 :   rtx ovf_rtx;
    4146                 :            : 
    4147                 :      15655 :   if (flag_split_stack
    4148                 :         12 :       && cfun->machine->split_stack_varargs_pointer == NULL_RTX)
    4149                 :            :     {
    4150                 :         12 :       unsigned int scratch_regno;
    4151                 :            : 
    4152                 :            :       /* When we are splitting the stack, we can't refer to the stack
    4153                 :            :          arguments using internal_arg_pointer, because they may be on
    4154                 :            :          the old stack.  The split stack prologue will arrange to
    4155                 :            :          leave a pointer to the old stack arguments in a scratch
    4156                 :            :          register, which we here copy to a pseudo-register.  The split
    4157                 :            :          stack prologue can't set the pseudo-register directly because
    4158                 :            :          it (the prologue) runs before any registers have been saved.  */
    4159                 :            : 
    4160                 :         12 :       scratch_regno = split_stack_prologue_scratch_regno ();
    4161                 :         12 :       if (scratch_regno != INVALID_REGNUM)
    4162                 :            :         {
    4163                 :         12 :           rtx reg;
    4164                 :         12 :           rtx_insn *seq;
    4165                 :            : 
    4166                 :         16 :           reg = gen_reg_rtx (Pmode);
    4167                 :         12 :           cfun->machine->split_stack_varargs_pointer = reg;
    4168                 :            : 
    4169                 :         12 :           start_sequence ();
    4170                 :         16 :           emit_move_insn (reg, gen_rtx_REG (Pmode, scratch_regno));
    4171                 :         12 :           seq = get_insns ();
    4172                 :         12 :           end_sequence ();
    4173                 :            : 
    4174                 :         12 :           push_topmost_sequence ();
    4175                 :         12 :           emit_insn_after (seq, entry_of_function ());
    4176                 :         12 :           pop_topmost_sequence ();
    4177                 :            :         }
    4178                 :            :     }
    4179                 :            : 
    4180                 :            :   /* Only 64bit target needs something special.  */
    4181                 :      15655 :   if (is_va_list_char_pointer (TREE_TYPE (valist)))
    4182                 :            :     {
    4183                 :       5656 :       if (cfun->machine->split_stack_varargs_pointer == NULL_RTX)
    4184                 :       5652 :         std_expand_builtin_va_start (valist, nextarg);
    4185                 :            :       else
    4186                 :            :         {
    4187                 :          4 :           rtx va_r, next;
    4188                 :            : 
    4189                 :          4 :           va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
    4190                 :          8 :           next = expand_binop (ptr_mode, add_optab,
    4191                 :          4 :                                cfun->machine->split_stack_varargs_pointer,
    4192                 :            :                                crtl->args.arg_offset_rtx,
    4193                 :            :                                NULL_RTX, 0, OPTAB_LIB_WIDEN);
    4194                 :          4 :           convert_move (va_r, next, 0);
    4195                 :            :         }
    4196                 :       5656 :       return;
    4197                 :            :     }
    4198                 :            : 
    4199                 :       9999 :   f_gpr = TYPE_FIELDS (TREE_TYPE (sysv_va_list_type_node));
    4200                 :       9999 :   f_fpr = DECL_CHAIN (f_gpr);
    4201                 :       9999 :   f_ovf = DECL_CHAIN (f_fpr);
    4202                 :       9999 :   f_sav = DECL_CHAIN (f_ovf);
    4203                 :            : 
    4204                 :       9999 :   valist = build_simple_mem_ref (valist);
    4205                 :       9999 :   TREE_TYPE (valist) = TREE_TYPE (sysv_va_list_type_node);
    4206                 :            :   /* The following should be folded into the MEM_REF offset.  */
    4207                 :       9999 :   gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr), unshare_expr (valist),
    4208                 :            :                 f_gpr, NULL_TREE);
    4209                 :       9999 :   fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), unshare_expr (valist),
    4210                 :            :                 f_fpr, NULL_TREE);
    4211                 :       9999 :   ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), unshare_expr (valist),
    4212                 :            :                 f_ovf, NULL_TREE);
    4213                 :       9999 :   sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), unshare_expr (valist),
    4214                 :            :                 f_sav, NULL_TREE);
    4215                 :            : 
    4216                 :            :   /* Count number of gp and fp argument registers used.  */
    4217                 :       9999 :   words = crtl->args.info.words;
    4218                 :       9999 :   n_gpr = crtl->args.info.regno;
    4219                 :       9999 :   n_fpr = crtl->args.info.sse_regno;
    4220                 :            : 
    4221                 :       9999 :   if (cfun->va_list_gpr_size)
    4222                 :            :     {
    4223                 :       9811 :       type = TREE_TYPE (gpr);
    4224                 :       9811 :       t = build2 (MODIFY_EXPR, type,
    4225                 :       9811 :                   gpr, build_int_cst (type, n_gpr * 8));
    4226                 :       9811 :       TREE_SIDE_EFFECTS (t) = 1;
    4227                 :       9811 :       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
    4228                 :            :     }
    4229                 :            : 
    4230                 :       9999 :   if (TARGET_SSE && cfun->va_list_fpr_size)
    4231                 :            :     {
    4232                 :       9317 :       type = TREE_TYPE (fpr);
    4233                 :       9317 :       t = build2 (MODIFY_EXPR, type, fpr,
    4234                 :       9317 :                   build_int_cst (type, n_fpr * 16 + 8*X86_64_REGPARM_MAX));
    4235                 :       9317 :       TREE_SIDE_EFFECTS (t) = 1;
    4236                 :       9317 :       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
    4237                 :            :     }
    4238                 :            : 
    4239                 :            :   /* Find the overflow area.  */
    4240                 :       9999 :   type = TREE_TYPE (ovf);
    4241                 :       9999 :   if (cfun->machine->split_stack_varargs_pointer == NULL_RTX)
    4242                 :       9991 :     ovf_rtx = crtl->args.internal_arg_pointer;
    4243                 :            :   else
    4244                 :            :     ovf_rtx = cfun->machine->split_stack_varargs_pointer;
    4245                 :       9999 :   t = make_tree (type, ovf_rtx);
    4246                 :       9999 :   if (words != 0)
    4247                 :        408 :     t = fold_build_pointer_plus_hwi (t, words * UNITS_PER_WORD);
    4248                 :            : 
    4249                 :       9999 :   t = build2 (MODIFY_EXPR, type, ovf, t);
    4250                 :       9999 :   TREE_SIDE_EFFECTS (t) = 1;
    4251                 :       9999 :   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
    4252                 :            : 
    4253                 :       9999 :   if (ix86_varargs_gpr_size || ix86_varargs_fpr_size)
    4254                 :            :     {
    4255                 :            :       /* Find the register save area.
    4256                 :            :          Prologue of the function save it right above stack frame.  */
    4257                 :       9958 :       type = TREE_TYPE (sav);
    4258                 :       9958 :       t = make_tree (type, frame_pointer_rtx);
    4259                 :       9958 :       if (!ix86_varargs_gpr_size)
    4260                 :        147 :         t = fold_build_pointer_plus_hwi (t, -8 * X86_64_REGPARM_MAX);
    4261                 :            : 
    4262                 :       9958 :       t = build2 (MODIFY_EXPR, type, sav, t);
    4263                 :       9958 :       TREE_SIDE_EFFECTS (t) = 1;
    4264                 :       9958 :       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
    4265                 :            :     }
    4266                 :            : }
    4267                 :            : 
    4268                 :            : /* Implement va_arg.  */
    4269                 :            : 
    4270                 :            : static tree
    4271                 :      35824 : ix86_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
    4272                 :            :                       gimple_seq *post_p)
    4273                 :            : {
    4274                 :      35824 :   static const int intreg[6] = { 0, 1, 2, 3, 4, 5 };
    4275                 :      35824 :   tree f_gpr, f_fpr, f_ovf, f_sav;
    4276                 :      35824 :   tree gpr, fpr, ovf, sav, t;
    4277                 :      35824 :   int size, rsize;
    4278                 :      35824 :   tree lab_false, lab_over = NULL_TREE;
    4279                 :      35824 :   tree addr, t2;
    4280                 :      35824 :   rtx container;
    4281                 :      35824 :   int indirect_p = 0;
    4282                 :      35824 :   tree ptrtype;
    4283                 :      35824 :   machine_mode nat_mode;
    4284                 :      35824 :   unsigned int arg_boundary;
    4285                 :      35824 :   unsigned int type_align;
    4286                 :            : 
    4287                 :            :   /* Only 64bit target needs something special.  */
    4288                 :      35824 :   if (is_va_list_char_pointer (TREE_TYPE (valist)))
    4289                 :        207 :     return std_gimplify_va_arg_expr (valist, type, pre_p, post_p);
    4290                 :            : 
    4291                 :      35617 :   f_gpr = TYPE_FIELDS (TREE_TYPE (sysv_va_list_type_node));
    4292                 :      35617 :   f_fpr = DECL_CHAIN (f_gpr);
    4293                 :      35617 :   f_ovf = DECL_CHAIN (f_fpr);
    4294                 :      35617 :   f_sav = DECL_CHAIN (f_ovf);
    4295                 :            : 
    4296                 :      35617 :   gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr),
    4297                 :            :                 valist, f_gpr, NULL_TREE);
    4298                 :            : 
    4299                 :      35617 :   fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), valist, f_fpr, NULL_TREE);
    4300                 :      35617 :   ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), valist, f_ovf, NULL_TREE);
    4301                 :      35617 :   sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), valist, f_sav, NULL_TREE);
    4302                 :            : 
    4303                 :      35617 :   indirect_p = pass_va_arg_by_reference (type);
    4304                 :      35617 :   if (indirect_p)
    4305                 :         99 :     type = build_pointer_type (type);
    4306                 :      35617 :   size = arg_int_size_in_bytes (type);
    4307                 :      35617 :   rsize = CEIL (size, UNITS_PER_WORD);
    4308                 :            : 
    4309                 :      35617 :   nat_mode = type_natural_mode (type, NULL, false);
    4310                 :      35617 :   switch (nat_mode)
    4311                 :            :     {
    4312                 :         12 :     case E_V8SFmode:
    4313                 :         12 :     case E_V8SImode:
    4314                 :         12 :     case E_V32QImode:
    4315                 :         12 :     case E_V16HImode:
    4316                 :         12 :     case E_V4DFmode:
    4317                 :         12 :     case E_V4DImode:
    4318                 :         12 :     case E_V16SFmode:
    4319                 :         12 :     case E_V16SImode:
    4320                 :         12 :     case E_V64QImode:
    4321                 :         12 :     case E_V32HImode:
    4322                 :         12 :     case E_V8DFmode:
    4323                 :         12 :     case E_V8DImode:
    4324                 :            :       /* Unnamed 256 and 512bit vector mode parameters are passed on stack.  */
    4325                 :         12 :       if (!TARGET_64BIT_MS_ABI)
    4326                 :            :         {
    4327                 :            :           container = NULL;
    4328                 :            :           break;
    4329                 :            :         }
    4330                 :            :       /* FALLTHRU */
    4331                 :            : 
    4332                 :      35605 :     default:
    4333                 :      35605 :       container = construct_container (nat_mode, TYPE_MODE (type),
    4334                 :            :                                        type, 0, X86_64_REGPARM_MAX,
    4335                 :            :                                        X86_64_SSE_REGPARM_MAX, intreg,
    4336                 :            :                                        0);
    4337                 :      35605 :       break;
    4338                 :            :     }
    4339                 :            : 
    4340                 :            :   /* Pull the value out of the saved registers.  */
    4341                 :            : 
    4342                 :      35617 :   addr = create_tmp_var (ptr_type_node, "addr");
    4343                 :      35617 :   type_align = TYPE_ALIGN (type);
    4344                 :            : 
    4345                 :      35617 :   if (container)
    4346                 :            :     {
    4347                 :      20229 :       int needed_intregs, needed_sseregs;
    4348                 :      20229 :       bool need_temp;
    4349                 :      20229 :       tree int_addr, sse_addr;
    4350                 :            : 
    4351                 :      20229 :       lab_false = create_artificial_label (UNKNOWN_LOCATION);
    4352                 :      20229 :       lab_over = create_artificial_label (UNKNOWN_LOCATION);
    4353                 :            : 
    4354                 :      20229 :       examine_argument (nat_mode, type, 0, &needed_intregs, &needed_sseregs);
    4355                 :            : 
    4356                 :      40036 :       need_temp = (!REG_P (container)
    4357                 :      21361 :                    && ((needed_intregs && TYPE_ALIGN (type) > 64)
    4358                 :        810 :                        || TYPE_ALIGN (type) > 128));
    4359                 :            : 
    4360                 :            :       /* In case we are passing structure, verify that it is consecutive block
    4361                 :            :          on the register save area.  If not we need to do moves.  */
    4362                 :      19807 :       if (!need_temp && !REG_P (container))
    4363                 :            :         {
    4364                 :            :           /* Verify that all registers are strictly consecutive  */
    4365                 :        810 :           if (SSE_REGNO_P (REGNO (XEXP (XVECEXP (container, 0, 0), 0))))
    4366                 :            :             {
    4367                 :            :               int i;
    4368                 :            : 
    4369                 :        646 :               for (i = 0; i < XVECLEN (container, 0) && !need_temp; i++)
    4370                 :            :                 {
    4371                 :        418 :                   rtx slot = XVECEXP (container, 0, i);
    4372                 :        418 :                   if (REGNO (XEXP (slot, 0)) != FIRST_SSE_REG + (unsigned int) i
    4373                 :        418 :                       || INTVAL (XEXP (slot, 1)) != i * 16)
    4374                 :            :                     need_temp = true;
    4375                 :            :                 }
    4376                 :            :             }
    4377                 :            :           else
    4378                 :            :             {
    4379                 :            :               int i;
    4380                 :            : 
    4381                 :       1374 :               for (i = 0; i < XVECLEN (container, 0) && !need_temp; i++)
    4382                 :            :                 {
    4383                 :        792 :                   rtx slot = XVECEXP (container, 0, i);
    4384                 :        792 :                   if (REGNO (XEXP (slot, 0)) != (unsigned int) i
    4385                 :        792 :                       || INTVAL (XEXP (slot, 1)) != i * 8)
    4386                 :            :                     need_temp = true;
    4387                 :            :                 }
    4388                 :            :             }
    4389                 :            :         }
    4390                 :      20229 :       if (!need_temp)
    4391                 :            :         {
    4392                 :            :           int_addr = addr;
    4393                 :            :           sse_addr = addr;
    4394                 :            :         }
    4395                 :            :       else
    4396                 :            :         {
    4397                 :        722 :           int_addr = create_tmp_var (ptr_type_node, "int_addr");
    4398                 :        722 :           sse_addr = create_tmp_var (ptr_type_node, "sse_addr");
    4399                 :            :         }
    4400                 :            : 
    4401                 :            :       /* First ensure that we fit completely in registers.  */
    4402                 :      20229 :       if (needed_intregs)
    4403                 :            :         {
    4404                 :      12920 :           t = build_int_cst (TREE_TYPE (gpr),
    4405                 :      12920 :                              (X86_64_REGPARM_MAX - needed_intregs + 1) * 8);
    4406                 :      12920 :           t = build2 (GE_EXPR, boolean_type_node, gpr, t);
    4407                 :      12920 :           t2 = build1 (GOTO_EXPR, void_type_node, lab_false);
    4408                 :      12920 :           t = build3 (COND_EXPR, void_type_node, t, t2, NULL_TREE);
    4409                 :      12920 :           gimplify_and_add (t, pre_p);
    4410                 :            :         }
    4411                 :      20229 :       if (needed_sseregs)
    4412                 :            :         {
    4413                 :       7611 :           t = build_int_cst (TREE_TYPE (fpr),
    4414                 :            :                              (X86_64_SSE_REGPARM_MAX - needed_sseregs + 1) * 16
    4415                 :       7611 :                              + X86_64_REGPARM_MAX * 8);
    4416                 :       7611 :           t = build2 (GE_EXPR, boolean_type_node, fpr, t);
    4417                 :       7611 :           t2 = build1 (GOTO_EXPR, void_type_node, lab_false);
    4418                 :       7611 :           t = build3 (COND_EXPR, void_type_node, t, t2, NULL_TREE);
    4419                 :       7611 :           gimplify_and_add (t, pre_p);
    4420                 :            :         }
    4421                 :            : 
    4422                 :            :       /* Compute index to start of area used for integer regs.  */
    4423                 :      20229 :       if (needed_intregs)
    4424                 :            :         {
    4425                 :            :           /* int_addr = gpr + sav; */
    4426                 :      12920 :           t = fold_build_pointer_plus (sav, gpr);
    4427                 :      12920 :           gimplify_assign (int_addr, t, pre_p);
    4428                 :            :         }
    4429                 :      20229 :       if (needed_sseregs)
    4430                 :            :         {
    4431                 :            :           /* sse_addr = fpr + sav; */
    4432                 :       7611 :           t = fold_build_pointer_plus (sav, fpr);
    4433                 :       7611 :           gimplify_assign (sse_addr, t, pre_p);
    4434                 :            :         }
    4435                 :      20229 :       if (need_temp)
    4436                 :            :         {
    4437                 :        722 :           int i, prev_size = 0;
    4438                 :        722 :           tree temp = create_tmp_var (type, "va_arg_tmp");
    4439                 :            : 
    4440                 :            :           /* addr = &temp; */
    4441                 :        722 :           t = build1 (ADDR_EXPR, build_pointer_type (type), temp);
    4442                 :        722 :           gimplify_assign (addr, t, pre_p);
    4443                 :            : 
    4444                 :       1826 :           for (i = 0; i < XVECLEN (container, 0); i++)
    4445                 :            :             {
    4446                 :       1104 :               rtx slot = XVECEXP (container, 0, i);
    4447                 :       1104 :               rtx reg = XEXP (slot, 0);
    4448                 :       1104 :               machine_mode mode = GET_MODE (reg);
    4449                 :       1104 :               tree piece_type;
    4450                 :       1104 :               tree addr_type;
    4451                 :       1104 :               tree daddr_type;
    4452                 :       1104 :               tree src_addr, src;
    4453                 :       1104 :               int src_offset;
    4454                 :       1104 :               tree dest_addr, dest;
    4455                 :       1104 :               int cur_size = GET_MODE_SIZE (mode);
    4456                 :            : 
    4457                 :       1104 :               gcc_assert (prev_size <= INTVAL (XEXP (slot, 1)));
    4458                 :       1104 :               prev_size = INTVAL (XEXP (slot, 1));
    4459                 :       1104 :               if (prev_size + cur_size > size)
    4460                 :            :                 {
    4461                 :         28 :                   cur_size = size - prev_size;
    4462                 :         28 :                   unsigned int nbits = cur_size * BITS_PER_UNIT;
    4463                 :         74 :                   if (!int_mode_for_size (nbits, 1).exists (&mode))
    4464                 :         10 :                     mode = QImode;
    4465                 :            :                 }
    4466                 :       1104 :               piece_type = lang_hooks.types.type_for_mode (mode, 1);
    4467                 :       1104 :               if (mode == GET_MODE (reg))
    4468                 :       1076 :                 addr_type = build_pointer_type (piece_type);
    4469                 :            :               else
    4470                 :         28 :                 addr_type = build_pointer_type_for_mode (piece_type, ptr_mode,
    4471                 :            :                                                          true);
    4472                 :       1104 :               daddr_type = build_pointer_type_for_mode (piece_type, ptr_mode,
    4473                 :            :                                                         true);
    4474                 :            : 
    4475                 :       1104 :               if (SSE_REGNO_P (REGNO (reg)))
    4476                 :            :                 {
    4477                 :        428 :                   src_addr = sse_addr;
    4478                 :        428 :                   src_offset = (REGNO (reg) - FIRST_SSE_REG) * 16;
    4479                 :            :                 }
    4480                 :            :               else
    4481                 :            :                 {
    4482                 :        676 :                   src_addr = int_addr;
    4483                 :        676 :                   src_offset = REGNO (reg) * 8;
    4484                 :            :                 }
    4485                 :       1104 :               src_addr = fold_convert (addr_type, src_addr);
    4486                 :       1104 :               src_addr = fold_build_pointer_plus_hwi (src_addr, src_offset);
    4487                 :            : 
    4488                 :       1104 :               dest_addr = fold_convert (daddr_type, addr);
    4489                 :       1104 :               dest_addr = fold_build_pointer_plus_hwi (dest_addr, prev_size);
    4490                 :       2208 :               if (cur_size == GET_MODE_SIZE (mode))
    4491                 :            :                 {
    4492                 :       1094 :                   src = build_va_arg_indirect_ref (src_addr);
    4493                 :       1094 :                   dest = build_va_arg_indirect_ref (dest_addr);
    4494                 :            : 
    4495                 :       1094 :                   gimplify_assign (dest, src, pre_p);
    4496                 :            :                 }
    4497                 :            :               else
    4498                 :            :                 {
    4499                 :         10 :                   tree copy
    4500                 :         20 :                     = build_call_expr (builtin_decl_implicit (BUILT_IN_MEMCPY),
    4501                 :            :                                        3, dest_addr, src_addr,
    4502                 :            :                                        size_int (cur_size));
    4503                 :         10 :                   gimplify_and_add (copy, pre_p);
    4504                 :            :                 }
    4505                 :       1104 :               prev_size += cur_size;
    4506                 :            :             }
    4507                 :            :         }
    4508                 :            : 
    4509                 :      20229 :       if (needed_intregs)
    4510                 :            :         {
    4511                 :      12920 :           t = build2 (PLUS_EXPR, TREE_TYPE (gpr), gpr,
    4512                 :      12920 :                       build_int_cst (TREE_TYPE (gpr), needed_intregs * 8));
    4513                 :      12920 :           gimplify_assign (gpr, t, pre_p);
    4514                 :            :           /* The GPR save area guarantees only 8-byte alignment.  */
    4515                 :      12920 :           if (!need_temp)
    4516                 :      12262 :             type_align = MIN (type_align, 64);
    4517                 :            :         }
    4518                 :            : 
    4519                 :      20229 :       if (needed_sseregs)
    4520                 :            :         {
    4521                 :       7611 :           t = build2 (PLUS_EXPR, TREE_TYPE (fpr), fpr,
    4522                 :       7611 :                       build_int_cst (TREE_TYPE (fpr), needed_sseregs * 16));
    4523                 :       7611 :           gimplify_assign (unshare_expr (fpr), t, pre_p);
    4524                 :            :         }
    4525                 :            : 
    4526                 :      20229 :       gimple_seq_add_stmt (pre_p, gimple_build_goto (lab_over));
    4527                 :            : 
    4528                 :      20229 :       gimple_seq_add_stmt (pre_p, gimple_build_label (lab_false));
    4529                 :            :     }
    4530                 :            : 
    4531                 :            :   /* ... otherwise out of the overflow area.  */
    4532                 :            : 
    4533                 :            :   /* When we align parameter on stack for caller, if the parameter
    4534                 :            :      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
    4535                 :            :      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
    4536                 :            :      here with caller.  */
    4537                 :      35617 :   arg_boundary = ix86_function_arg_boundary (VOIDmode, type);
    4538                 :      35617 :   if ((unsigned int) arg_boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
    4539                 :            :     arg_boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
    4540                 :            : 
    4541                 :            :   /* Care for on-stack alignment if needed.  */
    4542                 :      35617 :   if (arg_boundary <= 64 || size == 0)
    4543                 :      24024 :     t = ovf;
    4544                 :            :  else
    4545                 :            :     {
    4546                 :      11593 :       HOST_WIDE_INT align = arg_boundary / 8;
    4547                 :      11593 :       t = fold_build_pointer_plus_hwi (ovf, align - 1);
    4548                 :      11593 :       t = build2 (BIT_AND_EXPR, TREE_TYPE (t), t,
    4549                 :      11593 :                   build_int_cst (TREE_TYPE (t), -align));
    4550                 :            :     }
    4551                 :            : 
    4552                 :      35617 :   gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue);
    4553                 :      35617 :   gimplify_assign (addr, t, pre_p);
    4554                 :            : 
    4555                 :      35617 :   t = fold_build_pointer_plus_hwi (t, rsize * UNITS_PER_WORD);
    4556                 :      35617 :   gimplify_assign (unshare_expr (ovf), t, pre_p);
    4557                 :            : 
    4558                 :      35617 :   if (container)
    4559                 :      20229 :     gimple_seq_add_stmt (pre_p, gimple_build_label (lab_over));
    4560                 :            : 
    4561                 :      35617 :   type = build_aligned_type (type, type_align);
    4562                 :      35617 :   ptrtype = build_pointer_type_for_mode (type, ptr_mode, true);
    4563                 :      35617 :   addr = fold_convert (ptrtype, addr);
    4564                 :            : 
    4565                 :      35617 :   if (indirect_p)
    4566                 :         99 :     addr = build_va_arg_indirect_ref (addr);
    4567                 :      35617 :   return build_va_arg_indirect_ref (addr);
    4568                 :            : }
    4569                 :            : 
    4570                 :            : /* Return true if OPNUM's MEM should be matched
    4571                 :            :    in movabs* patterns.  */
    4572                 :            : 
    4573                 :            : bool
    4574                 :      18005 : ix86_check_movabs (rtx insn, int opnum)
    4575                 :            : {
    4576                 :      18005 :   rtx set, mem;
    4577                 :            : 
    4578                 :      18005 :   set = PATTERN (insn);
    4579                 :      18005 :   if (GET_CODE (set) == PARALLEL)
    4580                 :          0 :     set = XVECEXP (set, 0, 0);
    4581                 :      18005 :   gcc_assert (GET_CODE (set) == SET);
    4582                 :      18005 :   mem = XEXP (set, opnum);
    4583                 :      18005 :   while (SUBREG_P (mem))
    4584                 :          0 :     mem = SUBREG_REG (mem);
    4585                 :      18005 :   gcc_assert (MEM_P (mem));
    4586                 :      18005 :   return volatile_ok || !MEM_VOLATILE_P (mem);
    4587                 :            : }
    4588                 :            : 
    4589                 :            : /* Return false if INSN contains a MEM with a non-default address space.  */
    4590                 :            : bool
    4591                 :      85425 : ix86_check_no_addr_space (rtx insn)
    4592                 :            : {
    4593                 :      85425 :   subrtx_var_iterator::array_type array;
    4594                 :    1970640 :   FOR_EACH_SUBRTX_VAR (iter, array, PATTERN (insn), ALL)
    4595                 :            :     {
    4596                 :    1885210 :       rtx x = *iter;
    4597                 :    2023010 :       if (MEM_P (x) && !ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (x)))
    4598                 :          0 :         return false;
    4599                 :            :     }
    4600                 :      85425 :   return true;
    4601                 :            : }
    4602                 :            : 
    4603                 :            : /* Initialize the table of extra 80387 mathematical constants.  */
    4604                 :            : 
    4605                 :            : static void
    4606                 :       1797 : init_ext_80387_constants (void)
    4607                 :            : {
    4608                 :       1797 :   static const char * cst[5] =
    4609                 :            :   {
    4610                 :            :     "0.3010299956639811952256464283594894482",  /* 0: fldlg2  */
    4611                 :            :     "0.6931471805599453094286904741849753009",  /* 1: fldln2  */
    4612                 :            :     "1.4426950408889634073876517827983434472",  /* 2: fldl2e  */
    4613                 :            :     "3.3219280948873623478083405569094566090",  /* 3: fldl2t  */
    4614                 :            :     "3.1415926535897932385128089594061862044",  /* 4: fldpi   */
    4615                 :            :   };
    4616                 :       1797 :   int i;
    4617                 :            : 
    4618                 :      10782 :   for (i = 0; i < 5; i++)
    4619                 :            :     {
    4620                 :       8985 :       real_from_string (&ext_80387_constants_table[i], cst[i]);
    4621                 :            :       /* Ensure each constant is rounded to XFmode precision.  */
    4622                 :       8985 :       real_convert (&ext_80387_constants_table[i],
    4623                 :      17970 :                     XFmode, &ext_80387_constants_table[i]);
    4624                 :            :     }
    4625                 :            : 
    4626                 :       1797 :   ext_80387_constants_init = 1;
    4627                 :       1797 : }
    4628                 :            : 
    4629                 :            : /* Return non-zero if the constant is something that
    4630                 :            :    can be loaded with a special instruction.  */
    4631                 :            : 
    4632                 :            : int
    4633                 :    3306820 : standard_80387_constant_p (rtx x)
    4634                 :            : {
    4635                 :    3306820 :   machine_mode mode = GET_MODE (x);
    4636                 :            : 
    4637                 :    3306820 :   const REAL_VALUE_TYPE *r;
    4638                 :            : 
    4639                 :    3306820 :   if (!(CONST_DOUBLE_P (x) && X87_FLOAT_MODE_P (mode)))
    4640                 :            :     return -1;
    4641                 :            : 
    4642                 :    2886680 :   if (x == CONST0_RTX (mode))
    4643                 :            :     return 1;
    4644                 :    2021480 :   if (x == CONST1_RTX (mode))
    4645                 :            :     return 2;
    4646                 :            : 
    4647                 :    1199210 :   r = CONST_DOUBLE_REAL_VALUE (x);
    4648                 :            : 
    4649                 :            :   /* For XFmode constants, try to find a special 80387 instruction when
    4650                 :            :      optimizing for size or on those CPUs that benefit from them.  */
    4651                 :    1199210 :   if (mode == XFmode
    4652                 :    1199210 :       && (optimize_function_for_size_p (cfun) || TARGET_EXT_80387_CONSTANTS))
    4653                 :            :     {
    4654                 :     828358 :       int i;
    4655                 :            : 
    4656                 :     828358 :       if (! ext_80387_constants_init)
    4657                 :       1791 :         init_ext_80387_constants ();
    4658                 :            : 
    4659                 :    4960060 :       for (i = 0; i < 5; i++)
    4660                 :    4140170 :         if (real_identical (r, &ext_80387_constants_table[i]))
    4661                 :       8469 :           return i + 3;
    4662                 :            :     }
    4663                 :            : 
    4664                 :            :   /* Load of the constant -0.0 or -1.0 will be split as
    4665                 :            :      fldz;fchs or fld1;fchs sequence.  */
    4666                 :    1190740 :   if (real_isnegzero (r))
    4667                 :            :     return 8;
    4668                 :    1173380 :   if (real_identical (r, &dconstm1))
    4669                 :     320485 :     return 9;
    4670                 :            : 
    4671                 :            :   return 0;
    4672                 :            : }
    4673                 :            : 
    4674                 :            : /* Return the opcode of the special instruction to be used to load
    4675                 :            :    the constant X.  */
    4676                 :            : 
    4677                 :            : const char *
    4678                 :      47102 : standard_80387_constant_opcode (rtx x)
    4679                 :            : {
    4680                 :      47102 :   switch (standard_80387_constant_p (x))
    4681                 :            :     {
    4682                 :            :     case 1:
    4683                 :            :       return "fldz";
    4684                 :      32038 :     case 2:
    4685                 :      32038 :       return "fld1";
    4686                 :          1 :     case 3:
    4687                 :          1 :       return "fldlg2";
    4688                 :         10 :     case 4:
    4689                 :         10 :       return "fldln2";
    4690                 :         12 :     case 5:
    4691                 :         12 :       return "fldl2e";
    4692                 :          2 :     case 6:
    4693                 :          2 :       return "fldl2t";
    4694                 :        182 :     case 7:
    4695                 :        182 :       return "fldpi";
    4696                 :          0 :     case 8:
    4697                 :          0 :     case 9:
    4698                 :          0 :       return "#";
    4699                 :          0 :     default:
    4700                 :          0 :       gcc_unreachable ();
    4701                 :            :     }
    4702                 :            : }
    4703                 :            : 
    4704                 :            : /* Return the CONST_DOUBLE representing the 80387 constant that is
    4705                 :            :    loaded by the specified special instruction.  The argument IDX
    4706                 :            :    matches the return value from standard_80387_constant_p.  */
    4707                 :            : 
    4708                 :            : rtx
    4709                 :         23 : standard_80387_constant_rtx (int idx)
    4710                 :            : {
    4711                 :         23 :   int i;
    4712                 :            : 
    4713                 :         23 :   if (! ext_80387_constants_init)
    4714                 :          6 :     init_ext_80387_constants ();
    4715                 :            : 
    4716                 :         23 :   switch (idx)
    4717                 :            :     {
    4718                 :         23 :     case 3:
    4719                 :         23 :     case 4:
    4720                 :         23 :     case 5:
    4721                 :         23 :     case 6:
    4722                 :         23 :     case 7:
    4723                 :         23 :       i = idx - 3;
    4724                 :         23 :       break;
    4725                 :            : 
    4726                 :          0 :     default:
    4727                 :          0 :       gcc_unreachable ();
    4728                 :            :     }
    4729                 :            : 
    4730                 :         23 :   return const_double_from_real_value (ext_80387_constants_table[i],
    4731                 :         23 :                                        XFmode);
    4732                 :            : }
    4733                 :            : 
    4734                 :            : /* Return 1 if X is all bits 0 and 2 if X is all bits 1
    4735                 :            :    in supported SSE/AVX vector mode.  */
    4736                 :            : 
    4737                 :            : int
    4738                 :   13966400 : standard_sse_constant_p (rtx x, machine_mode pred_mode)
    4739                 :            : {
    4740                 :   13966400 :   machine_mode mode;
    4741                 :            : 
    4742                 :   13966400 :   if (!TARGET_SSE)
    4743                 :            :     return 0;
    4744                 :            : 
    4745                 :   13861600 :   mode = GET_MODE (x);
    4746                 :            : 
    4747                 :   13861600 :   if (x == const0_rtx || const0_operand (x, mode))
    4748                 :    2304750 :     return 1;
    4749                 :            : 
    4750                 :   11556800 :   if (x == constm1_rtx || vector_all_ones_operand (x, mode))
    4751                 :            :     {
    4752                 :            :       /* VOIDmode integer constant, get mode from the predicate.  */
    4753                 :     128767 :       if (mode == VOIDmode)
    4754                 :      87571 :         mode = pred_mode;
    4755                 :            : 
    4756                 :     257534 :       switch (GET_MODE_SIZE (mode))
    4757                 :            :         {
    4758                 :       4367 :         case 64:
    4759                 :       4367 :           if (TARGET_AVX512F)
    4760                 :       4367 :             return 2;
    4761                 :            :           break;
    4762                 :       4108 :         case 32:
    4763                 :       4108 :           if (TARGET_AVX2)
    4764                 :       4090 :             return 2;
    4765                 :            :           break;
    4766                 :     119543 :         case 16:
    4767                 :     119543 :           if (TARGET_SSE2)
    4768                 :     119496 :             return 2;
    4769                 :            :           break;
    4770                 :          0 :         case 0:
    4771                 :            :           /* VOIDmode */
    4772                 :          0 :           gcc_unreachable ();
    4773                 :            :         default:
    4774                 :            :           break;
    4775                 :            :         }
    4776                 :            :     }
    4777                 :            : 
    4778                 :            :   return 0;
    4779                 :            : }
    4780                 :            : 
    4781                 :            : /* Return the opcode of the special instruction to be used to load
    4782                 :            :    the constant operands[1] into operands[0].  */
    4783                 :            : 
    4784                 :            : const char *
    4785                 :     116501 : standard_sse_constant_opcode (rtx_insn *insn, rtx *operands)
    4786                 :            : {
    4787                 :     116501 :   machine_mode mode;
    4788                 :     116501 :   rtx x = operands[1];
    4789                 :            : 
    4790                 :     116501 :   gcc_assert (TARGET_SSE);
    4791                 :            : 
    4792                 :     116501 :   mode = GET_MODE (x);
    4793                 :            : 
    4794                 :     116501 :   if (x == const0_rtx || const0_operand (x, mode))
    4795                 :            :     {
    4796                 :     114935 :       switch (get_attr_mode (insn))
    4797                 :            :         {
    4798                 :     103958 :         case MODE_TI:
    4799                 :     103958 :           if (!EXT_REX_SSE_REG_P (operands[0]))
    4800                 :            :             return "%vpxor\t%0, %d0";
    4801                 :            :           /* FALLTHRU */
    4802                 :       2373 :         case MODE_XI:
    4803                 :       2373 :         case MODE_OI:
    4804                 :       2373 :           if (EXT_REX_SSE_REG_P (operands[0]))
    4805                 :          6 :             return (TARGET_AVX512VL
    4806                 :            :                     ? "vpxord\t%x0, %x0, %x0"
    4807                 :          6 :                     : "vpxord\t%g0, %g0, %g0");
    4808                 :            :           return "vpxor\t%x0, %x0, %x0";
    4809                 :            : 
    4810                 :       1356 :         case MODE_V2DF:
    4811                 :       1356 :           if (!EXT_REX_SSE_REG_P (operands[0]))
    4812                 :            :             return "%vxorpd\t%0, %d0";
    4813                 :            :           /* FALLTHRU */
    4814                 :        698 :         case MODE_V8DF:
    4815                 :        698 :         case MODE_V4DF:
    4816                 :        698 :           if (!EXT_REX_SSE_REG_P (operands[0]))
    4817                 :            :             return "vxorpd\t%x0, %x0, %x0";
    4818                 :          1 :           else if (TARGET_AVX512DQ)
    4819                 :          0 :             return (TARGET_AVX512VL
    4820                 :            :                     ? "vxorpd\t%x0, %x0, %x0"
    4821                 :          0 :                     : "vxorpd\t%g0, %g0, %g0");
    4822                 :            :           else
    4823                 :          1 :             return (TARGET_AVX512VL
    4824                 :            :                     ? "vpxorq\t%x0, %x0, %x0"
    4825                 :          1 :                     : "vpxorq\t%g0, %g0, %g0");
    4826                 :            : 
    4827                 :       5269 :         case MODE_V4SF:
    4828                 :       5269 :           if (!EXT_REX_SSE_REG_P (operands[0]))
    4829                 :            :             return "%vxorps\t%0, %d0";
    4830                 :            :           /* FALLTHRU */
    4831                 :       1283 :         case MODE_V16SF:
    4832                 :       1283 :         case MODE_V8SF:
    4833                 :       1283 :           if (!EXT_REX_SSE_REG_P (operands[0]))
    4834                 :            :             return "vxorps\t%x0, %x0, %x0";
    4835                 :          2 :           else if (TARGET_AVX512DQ)
    4836                 :          0 :             return (TARGET_AVX512VL
    4837                 :            :                     ? "vxorps\t%x0, %x0, %x0"
    4838                 :          0 :                     : "vxorps\t%g0, %g0, %g0");
    4839                 :            :           else
    4840                 :          2 :             return (TARGET_AVX512VL
    4841                 :            :                     ? "vpxord\t%x0, %x0, %x0"
    4842                 :          2 :                     : "vpxord\t%g0, %g0, %g0");
    4843                 :            : 
    4844                 :          0 :         default:
    4845                 :          0 :           gcc_unreachable ();
    4846                 :            :         }
    4847                 :            :     }
    4848                 :       1566 :   else if (x == constm1_rtx || vector_all_ones_operand (x, mode))
    4849                 :            :     {
    4850                 :       1566 :       enum attr_mode insn_mode = get_attr_mode (insn);
    4851                 :            :       
    4852                 :       1566 :       switch (insn_mode)
    4853                 :            :         {
    4854                 :         78 :         case MODE_XI:
    4855                 :         78 :         case MODE_V8DF:
    4856                 :         78 :         case MODE_V16SF:
    4857                 :         78 :           gcc_assert (TARGET_AVX512F);
    4858                 :            :           return "vpternlogd\t{$0xFF, %g0, %g0, %g0|%g0, %g0, %g0, 0xFF}";
    4859                 :            : 
    4860                 :         86 :         case MODE_OI:
    4861                 :         86 :         case MODE_V4DF:
    4862                 :         86 :         case MODE_V8SF:
    4863                 :         86 :           gcc_assert (TARGET_AVX2);
    4864                 :            :           /* FALLTHRU */
    4865                 :       1488 :         case MODE_TI:
    4866                 :       1488 :         case MODE_V2DF:
    4867                 :       1488 :         case MODE_V4SF:
    4868                 :       1488 :           gcc_assert (TARGET_SSE2);
    4869                 :       1488 :           if (!EXT_REX_SSE_REG_P (operands[0]))
    4870                 :       1486 :             return (TARGET_AVX
    4871                 :       1486 :                     ? "vpcmpeqd\t%0, %0, %0"
    4872                 :       1486 :                     : "pcmpeqd\t%0, %0");
    4873                 :          2 :           else if (TARGET_AVX512VL)
    4874                 :            :             return "vpternlogd\t{$0xFF, %0, %0, %0|%0, %0, %0, 0xFF}";
    4875                 :            :           else
    4876                 :          0 :             return "vpternlogd\t{$0xFF, %g0, %g0, %g0|%g0, %g0, %g0, 0xFF}";
    4877                 :            : 
    4878                 :          0 :         default:
    4879                 :          0 :           gcc_unreachable ();
    4880                 :            :         }
    4881                 :            :    }
    4882                 :            : 
    4883                 :          0 :   gcc_unreachable ();
    4884                 :            : }
    4885                 :            : 
    4886                 :            : /* Returns true if INSN can be transformed from a memory load
    4887                 :            :    to a supported FP constant load.  */
    4888                 :            : 
    4889                 :            : bool
    4890                 :    1468360 : ix86_standard_x87sse_constant_load_p (const rtx_insn *insn, rtx dst)
    4891                 :            : {
    4892                 :    1468360 :   rtx src = find_constant_src (insn);
    4893                 :            : 
    4894                 :    1468360 :   gcc_assert (REG_P (dst));
    4895                 :            : 
    4896                 :    1468360 :   if (src == NULL
    4897                 :     383782 :       || (SSE_REGNO_P (REGNO (dst))
    4898                 :     260948 :           && standard_sse_constant_p (src, GET_MODE (dst)) != 1)
    4899                 :    1622040 :       || (STACK_REGNO_P (REGNO (dst))
    4900                 :     122834 :            && standard_80387_constant_p (src) < 1))
    4901                 :    1392690 :     return false;
    4902                 :            : 
    4903                 :            :   return true;
    4904                 :            : }
    4905                 :            : 
    4906                 :            : /* Predicate for pre-reload splitters with associated instructions,
    4907                 :            :    which can match any time before the split1 pass (usually combine),
    4908                 :            :    then are unconditionally split in that pass and should not be
    4909                 :            :    matched again afterwards.  */
    4910                 :            : 
    4911                 :            : bool
    4912                 :     142695 : ix86_pre_reload_split (void)
    4913                 :            : {
    4914                 :     142695 :   return (can_create_pseudo_p ()
    4915                 :     285390 :           && !(cfun->curr_properties & PROP_rtl_split_insns));
    4916                 :            : }
    4917                 :            : 
    4918                 :            : /* Return the opcode of the TYPE_SSEMOV instruction.  To move from
    4919                 :            :    or to xmm16-xmm31/ymm16-ymm31 registers, we either require
    4920                 :            :    TARGET_AVX512VL or it is a register to register move which can
    4921                 :            :    be done with zmm register move. */
    4922                 :            : 
    4923                 :            : static const char *
    4924                 :    1567880 : ix86_get_ssemov (rtx *operands, unsigned size,
    4925                 :            :                  enum attr_mode insn_mode, machine_mode mode)
    4926                 :            : {
    4927                 :    1567880 :   char buf[128];
    4928                 :    1567880 :   bool misaligned_p = (misaligned_operand (operands[0], mode)
    4929                 :    1567880 :                        || misaligned_operand (operands[1], mode));
    4930                 :    1567880 :   bool evex_reg_p = (size == 64
    4931                 :    1526730 :                      || EXT_REX_SSE_REG_P (operands[0])
    4932                 :    3094260 :                      || EXT_REX_SSE_REG_P (operands[1]));
    4933                 :    1567880 :   machine_mode scalar_mode;
    4934                 :            : 
    4935                 :    1567880 :   const char *opcode = NULL;
    4936                 :    1567880 :   enum
    4937                 :            :     {
    4938                 :            :       opcode_int,
    4939                 :            :       opcode_float,
    4940                 :            :       opcode_double
    4941                 :    1567880 :     } type = opcode_int;
    4942                 :            : 
    4943                 :    1567880 :   switch (insn_mode)
    4944                 :            :     {
    4945                 :            :     case MODE_V16SF:
    4946                 :            :     case MODE_V8SF:
    4947                 :            :     case MODE_V4SF:
    4948                 :            :       scalar_mode = E_SFmode;
    4949                 :            :       type = opcode_float;
    4950                 :            :       break;
    4951                 :      88599 :     case MODE_V8DF:
    4952                 :      88599 :     case MODE_V4DF:
    4953                 :      88599 :     case MODE_V2DF:
    4954                 :      88599 :       scalar_mode = E_DFmode;
    4955                 :      88599 :       type = opcode_double;
    4956                 :      88599 :       break;
    4957                 :     678254 :     case MODE_XI:
    4958                 :     678254 :     case MODE_OI:
    4959                 :     678254 :     case MODE_TI:
    4960                 :     678254 :       scalar_mode = GET_MODE_INNER (mode);
    4961                 :            :       break;
    4962                 :          0 :     default:
    4963                 :          0 :       gcc_unreachable ();
    4964                 :            :     }
    4965                 :            : 
    4966                 :            :   /* NB: To move xmm16-xmm31/ymm16-ymm31 registers without AVX512VL,
    4967                 :            :      we can only use zmm register move without memory operand.  */
    4968                 :    1567880 :   if (evex_reg_p
    4969                 :      41657 :       && !TARGET_AVX512VL
    4970                 :    1588580 :       && GET_MODE_SIZE (mode) < 64)
    4971                 :            :     {
    4972                 :            :       /* NB: Since ix86_hard_regno_mode_ok only allows xmm16-xmm31 or
    4973                 :            :          ymm16-ymm31 in 128/256 bit modes when AVX512VL is enabled,
    4974                 :            :          we get here only for xmm16-xmm31 or ymm16-ymm31 in 32/64 bit
    4975                 :            :          modes.  */
    4976                 :         43 :       if (GET_MODE_SIZE (mode) >= 16
    4977                 :         43 :           || memory_operand (operands[0], mode)
    4978                 :         86 :           || memory_operand (operands[1], mode))
    4979                 :          0 :         gcc_unreachable ();
    4980                 :         43 :       size = 64;
    4981                 :         43 :       switch (type)
    4982                 :            :         {
    4983                 :         11 :         case opcode_int:
    4984                 :         11 :           opcode = misaligned_p ? "vmovdqu32" : "vmovdqa32";
    4985                 :            :           break;
    4986                 :         32 :         case opcode_float:
    4987                 :         32 :           opcode = misaligned_p ? "vmovups" : "vmovaps";
    4988                 :            :           break;
    4989                 :          0 :         case opcode_double:
    4990                 :          0 :           opcode = misaligned_p ? "vmovupd" : "vmovapd";
    4991                 :            :           break;
    4992                 :            :         }
    4993                 :            :     }
    4994                 :    1567830 :   else if (SCALAR_FLOAT_MODE_P (scalar_mode))
    4995                 :            :     {
    4996                 :    1022400 :       switch (scalar_mode)
    4997                 :            :         {
    4998                 :     800990 :         case E_SFmode:
    4999                 :     800990 :           opcode = misaligned_p ? "%vmovups" : "%vmovaps";
    5000                 :            :           break;
    5001                 :      88599 :         case E_DFmode:
    5002                 :      88599 :           opcode = misaligned_p ? "%vmovupd" : "%vmovapd";
    5003                 :            :           break;
    5004                 :     132810 :         case E_TFmode:
    5005                 :     132810 :           if (evex_reg_p)
    5006                 :         14 :             opcode = misaligned_p ? "vmovdqu64" : "vmovdqa64";
    5007                 :            :           else
    5008                 :     132796 :             opcode = misaligned_p ? "%vmovdqu" : "%vmovdqa";
    5009                 :            :           break;
    5010                 :          0 :         default:
    5011                 :          0 :           gcc_unreachable ();
    5012                 :            :         }
    5013                 :            :     }
    5014                 :     545433 :   else if (SCALAR_INT_MODE_P (scalar_mode))
    5015                 :            :     {
    5016                 :     545433 :       switch (scalar_mode)
    5017                 :            :         {
    5018                 :      38092 :         case E_QImode:
    5019                 :      38092 :           if (evex_reg_p)
    5020                 :       1463 :             opcode = (misaligned_p
    5021                 :       1463 :                       ? (TARGET_AVX512BW
    5022                 :         15 :                          ? "vmovdqu8"
    5023                 :            :                          : "vmovdqu64")
    5024                 :            :                       : "vmovdqa64");
    5025                 :            :           else
    5026                 :      36629 :             opcode = (misaligned_p
    5027                 :       6282 :                       ? (TARGET_AVX512BW
    5028                 :            :                          ? "vmovdqu8"
    5029                 :            :                          : "%vmovdqu")
    5030                 :            :                       : "%vmovdqa");
    5031                 :            :           break;
    5032                 :      23528 :         case E_HImode:
    5033                 :      23528 :           if (evex_reg_p)
    5034                 :       2167 :             opcode = (misaligned_p
    5035                 :         21 :                       ? (TARGET_AVX512BW
    5036                 :            :                          ? "vmovdqu16"
    5037                 :            :                          : "vmovdqu64")
    5038                 :            :                       : "vmovdqa64");
    5039                 :            :           else
    5040                 :      21361 :             opcode = (misaligned_p
    5041                 :      21361 :                       ? (TARGET_AVX512BW
    5042                 :       2677 :                          ? "vmovdqu16"
    5043                 :            :                          : "%vmovdqu")
    5044                 :            :                       : "%vmovdqa");
    5045                 :            :           break;
    5046                 :      75849 :         case E_SImode:
    5047                 :      75849 :           if (evex_reg_p)
    5048                 :       4732 :             opcode = misaligned_p ? "vmovdqu32" : "vmovdqa32";
    5049                 :            :           else
    5050                 :      71117 :             opcode = misaligned_p ? "%vmovdqu" : "%vmovdqa";
    5051                 :            :           break;
    5052                 :     407652 :         case E_DImode:
    5053                 :     407652 :         case E_TImode:
    5054                 :     407652 :         case E_OImode:
    5055                 :     407652 :           if (evex_reg_p)
    5056                 :      15963 :             opcode = misaligned_p ? "vmovdqu64" : "vmovdqa64";
    5057                 :            :           else
    5058                 :     391689 :             opcode = misaligned_p ? "%vmovdqu" : "%vmovdqa";
    5059                 :            :           break;
    5060                 :        312 :         case E_XImode:
    5061                 :        312 :           opcode = misaligned_p ? "vmovdqu64" : "vmovdqa64";
    5062                 :            :           break;
    5063                 :          0 :         default:
    5064                 :          0 :           gcc_unreachable ();
    5065                 :            :         }
    5066                 :            :     }
    5067                 :            :   else
    5068                 :          0 :     gcc_unreachable ();
    5069                 :            : 
    5070                 :    1567830 :   switch (size)
    5071                 :            :     {
    5072                 :      41186 :     case 64:
    5073                 :      41186 :       snprintf (buf, sizeof (buf), "%s\t{%%g1, %%g0|%%g0, %%g1}",
    5074                 :            :                 opcode);
    5075                 :      41186 :       break;
    5076                 :      43033 :     case 32:
    5077                 :      43033 :       snprintf (buf, sizeof (buf), "%s\t{%%t1, %%t0|%%t0, %%t1}",
    5078                 :            :                 opcode);
    5079                 :      43033 :       break;
    5080                 :    1483660 :     case 16:
    5081                 :    1483660 :       snprintf (buf, sizeof (buf), "%s\t{%%x1, %%x0|%%x0, %%x1}",
    5082                 :            :                 opcode);
    5083                 :    1483660 :       break;
    5084                 :          0 :     default:
    5085                 :          0 :       gcc_unreachable ();
    5086                 :            :     }
    5087                 :    1567880 :   output_asm_insn (buf, operands);
    5088                 :    1567880 :   return "";
    5089                 :            : }
    5090                 :            : 
    5091                 :            : /* Return the template of the TYPE_SSEMOV instruction to move
    5092                 :            :    operands[1] into operands[0].  */
    5093                 :            : 
    5094                 :            : const char *
    5095                 :    2615860 : ix86_output_ssemov (rtx_insn *insn, rtx *operands)
    5096                 :            : {
    5097                 :    2615860 :   machine_mode mode = GET_MODE (operands[0]);
    5098                 :    2615860 :   if (get_attr_type (insn) != TYPE_SSEMOV
    5099                 :    2615860 :       || mode != GET_MODE (operands[1]))
    5100                 :          0 :     gcc_unreachable ();
    5101                 :            : 
    5102                 :    2615860 :   enum attr_mode insn_mode = get_attr_mode (insn);
    5103                 :            : 
    5104                 :    2615860 :   switch (insn_mode)
    5105                 :            :     {
    5106                 :      41143 :     case MODE_XI:
    5107                 :      41143 :     case MODE_V8DF:
    5108                 :      41143 :     case MODE_V16SF:
    5109                 :      41143 :       return ix86_get_ssemov (operands, 64, insn_mode, mode);
    5110                 :            : 
    5111                 :      43033 :     case MODE_OI:
    5112                 :      43033 :     case MODE_V4DF:
    5113                 :      43033 :     case MODE_V8SF:
    5114                 :      43033 :       return ix86_get_ssemov (operands, 32, insn_mode, mode);
    5115                 :            : 
    5116                 :    1483700 :     case MODE_TI:
    5117                 :    1483700 :     case MODE_V2DF:
    5118                 :    1483700 :     case MODE_V4SF:
    5119                 :    1483700 :       return ix86_get_ssemov (operands, 16, insn_mode, mode);
    5120                 :            : 
    5121                 :     193917 :     case MODE_DI:
    5122                 :            :       /* Handle broken assemblers that require movd instead of movq. */
    5123                 :     193917 :       if (!HAVE_AS_IX86_INTERUNIT_MOVQ
    5124                 :            :           && (GENERAL_REG_P (operands[0])
    5125                 :            :               || GENERAL_REG_P (operands[1])))
    5126                 :            :         return "%vmovd\t{%1, %0|%0, %1}";
    5127                 :            :       else
    5128                 :     193917 :         return "%vmovq\t{%1, %0|%0, %1}";
    5129                 :            : 
    5130                 :            :     case MODE_SI:
    5131                 :            :       return "%vmovd\t{%1, %0|%0, %1}";
    5132                 :            : 
    5133                 :     433665 :     case MODE_DF:
    5134                 :     433665 :       if (TARGET_AVX && REG_P (operands[0]) && REG_P (operands[1]))
    5135                 :            :         return "vmovsd\t{%d1, %0|%0, %d1}";
    5136                 :            :       else
    5137                 :     431672 :         return "%vmovsd\t{%1, %0|%0, %1}";
    5138                 :            : 
    5139                 :     349419 :     case MODE_SF:
    5140                 :     349419 :       if (TARGET_AVX && REG_P (operands[0]) && REG_P (operands[1]))
    5141                 :            :         return "vmovss\t{%d1, %0|%0, %d1}";
    5142                 :            :       else
    5143                 :     349358 :         return "%vmovss\t{%1, %0|%0, %1}";
    5144                 :            : 
    5145                 :         30 :     case MODE_V1DF:
    5146                 :         30 :       gcc_assert (!TARGET_AVX);
    5147                 :            :       return "movlpd\t{%1, %0|%0, %1}";
    5148                 :            : 
    5149                 :        271 :     case MODE_V2SF:
    5150                 :        271 :       if (TARGET_AVX && REG_P (operands[0]))
    5151                 :            :         return "vmovlps\t{%1, %d0|%d0, %1}";
    5152                 :            :       else
    5153                 :        258 :         return "%vmovlps\t{%1, %0|%0, %1}";
    5154                 :            : 
    5155                 :          0 :     default:
    5156                 :          0 :       gcc_unreachable ();
    5157                 :            :     }
    5158                 :            : }
    5159                 :            : 
    5160                 :            : /* Returns true if OP contains a symbol reference */
    5161                 :            : 
    5162                 :            : bool
    5163                 :  371452000 : symbolic_reference_mentioned_p (rtx op)
    5164                 :            : {
    5165                 :  371452000 :   const char *fmt;
    5166                 :  371452000 :   int i;
    5167                 :            : 
    5168                 :  371452000 :   if (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF)
    5169                 :            :     return true;
    5170                 :            : 
    5171                 :  281170000 :   fmt = GET_RTX_FORMAT (GET_CODE (op));
    5172                 :  478616000 :   for (i = GET_RTX_LENGTH (GET_CODE (op)) - 1; i >= 0; i--)
    5173                 :            :     {
    5174                 :  381085000 :       if (fmt[i] == 'E')
    5175                 :            :         {
    5176                 :    1432000 :           int j;
    5177                 :            : 
    5178                 :    2913600 :           for (j = XVECLEN (op, i) - 1; j >= 0; j--)
    5179                 :    2429780 :             if (symbolic_reference_mentioned_p (XVECEXP (op, i, j)))
    5180                 :            :               return true;
    5181                 :            :         }
    5182                 :            : 
    5183                 :  379653000 :       else if (fmt[i] == 'e' && symbolic_reference_mentioned_p (XEXP (op, i)))
    5184                 :            :         return true;
    5185                 :            :     }
    5186                 :            : 
    5187                 :            :   return false;
    5188                 :            : }
    5189                 :            : 
    5190                 :            : /* Return true if it is appropriate to emit `ret' instructions in the
    5191                 :            :    body of a function.  Do this only if the epilogue is simple, needing a
    5192                 :            :    couple of insns.  Prior to reloading, we can't tell how many registers
    5193                 :            :    must be saved, so return false then.  Return false if there is no frame
    5194                 :            :    marker to de-allocate.  */
    5195                 :            : 
    5196                 :            : bool
    5197                 :          0 : ix86_can_use_return_insn_p (void)
    5198                 :            : {
    5199                 :          0 :   if (ix86_function_naked (current_function_decl))
    5200                 :            :     return false;
    5201                 :            : 
    5202                 :            :   /* Don't use `ret' instruction in interrupt handler.  */
    5203                 :          0 :   if (! reload_completed
    5204                 :          0 :       || frame_pointer_needed
    5205                 :          0 :       || cfun->machine->func_type != TYPE_NORMAL)
    5206                 :            :     return 0;
    5207                 :            : 
    5208                 :            :   /* Don't allow more than 32k pop, since that's all we can do
    5209                 :            :      with one instruction.  */
    5210                 :          0 :   if (crtl->args.pops_args && crtl->args.size >= 32768)
    5211                 :            :     return 0;
    5212                 :            : 
    5213                 :          0 :   struct ix86_frame &frame = cfun->machine->frame;
    5214                 :          0 :   return (frame.stack_pointer_offset == UNITS_PER_WORD
    5215                 :          0 :           && (frame.nregs + frame.nsseregs) == 0);
    5216                 :            : }
    5217                 :            : 
    5218                 :            : /* Return stack frame size.  get_frame_size () returns used stack slots
    5219                 :            :    during compilation, which may be optimized out later.  If stack frame
    5220                 :            :    is needed, stack_frame_required should be true.  */
    5221                 :            : 
    5222                 :            : static HOST_WIDE_INT
    5223                 :    6053060 : ix86_get_frame_size (void)
    5224                 :            : {
    5225                 :      39251 :   if (cfun->machine->stack_frame_required)
    5226                 :    6004940 :     return get_frame_size ();
    5227                 :            :   else
    5228                 :            :     return 0;
    5229                 :            : }
    5230                 :            : 
    5231                 :            : /* Value should be nonzero if functions must have frame pointers.
    5232                 :            :    Zero means the frame pointer need not be set up (and parms may
    5233                 :            :    be accessed via the stack pointer) in functions that seem suitable.  */
    5234                 :            : 
    5235                 :            : static bool
    5236                 :     695152 : ix86_frame_pointer_required (void)
    5237                 :            : {
    5238                 :            :   /* If we accessed previous frames, then the generated code expects
    5239                 :            :      to be able to access the saved ebp value in our frame.  */
    5240                 :     695152 :   if (cfun->machine->accesses_prev_frame)
    5241                 :            :     return true;
    5242                 :            : 
    5243                 :            :   /* Several x86 os'es need a frame pointer for other reasons,
    5244                 :            :      usually pertaining to setjmp.  */
    5245                 :     695119 :   if (SUBTARGET_FRAME_POINTER_REQUIRED)
    5246                 :            :     return true;
    5247                 :            : 
    5248                 :            :   /* For older 32-bit runtimes setjmp requires valid frame-pointer.  */
    5249                 :     695119 :   if (TARGET_32BIT_MS_ABI && cfun->calls_setjmp)
    5250                 :            :     return true;
    5251                 :            : 
    5252                 :            :   /* Win64 SEH, very large frames need a frame-pointer as maximum stack
    5253                 :            :      allocation is 4GB.  */
    5254                 :     697728 :   if (TARGET_64BIT_MS_ABI && ix86_get_frame_size () > SEH_MAX_FRAME_SIZE)
    5255                 :            :     return true;
    5256                 :            : 
    5257                 :            :   /* SSE saves require frame-pointer when stack is misaligned.  */
    5258                 :     695116 :   if (TARGET_64BIT_MS_ABI && ix86_incoming_stack_boundary < 128)
    5259                 :            :     return true;
    5260                 :            :   
    5261                 :            :   /* In ix86_option_override_internal, TARGET_OMIT_LEAF_FRAME_POINTER
    5262                 :            :      turns off the frame pointer by default.  Turn it back on now if
    5263                 :            :      we've not got a leaf function.  */
    5264                 :     695114 :   if (TARGET_OMIT_LEAF_FRAME_POINTER
    5265                 :     695114 :       && (!crtl->is_leaf
    5266                 :          0 :           || ix86_current_function_calls_tls_descriptor))
    5267                 :          0 :     return true;
    5268                 :            : 
    5269                 :     695114 :   if (crtl->profile && !flag_fentry)
    5270                 :         14 :     return true;
    5271                 :            : 
    5272                 :            :   return false;
    5273                 :            : }
    5274                 :            : 
    5275                 :            : /* Record that the current function accesses previous call frames.  */
    5276                 :            : 
    5277                 :            : void
    5278                 :       1016 : ix86_setup_frame_addresses (void)
    5279                 :            : {
    5280                 :       1016 :   cfun->machine->accesses_prev_frame = 1;
    5281                 :       1016 : }
    5282                 :            : 
    5283                 :            : #ifndef USE_HIDDEN_LINKONCE
    5284                 :            : # if defined(HAVE_GAS_HIDDEN) && (SUPPORTS_ONE_ONLY - 0)
    5285                 :            : #  define USE_HIDDEN_LINKONCE 1
    5286                 :            : # else
    5287                 :            : #  define USE_HIDDEN_LINKONCE 0
    5288                 :            : # endif
    5289                 :            : #endif
    5290                 :            : 
    5291                 :            : /* Label count for call and return thunks.  It is used to make unique
    5292                 :            :    labels in call and return thunks.  */
    5293                 :            : static int indirectlabelno;
    5294                 :            : 
    5295                 :            : /* True if call thunk function is needed.  */
    5296                 :            : static bool indirect_thunk_needed = false;
    5297                 :            : 
    5298                 :            : /* Bit masks of integer registers, which contain branch target, used
    5299                 :            :    by call thunk functions.  */
    5300                 :            : static int indirect_thunks_used;
    5301                 :            : 
    5302                 :            : /* True if return thunk function is needed.  */
    5303                 :            : static bool indirect_return_needed = false;
    5304                 :            : 
    5305                 :            : /* True if return thunk function via CX is needed.  */
    5306                 :            : static bool indirect_return_via_cx;
    5307                 :            : 
    5308                 :            : #ifndef INDIRECT_LABEL
    5309                 :            : # define INDIRECT_LABEL "LIND"
    5310                 :            : #endif
    5311                 :            : 
    5312                 :            : /* Indicate what prefix is needed for an indirect branch.  */
    5313                 :            : enum indirect_thunk_prefix
    5314                 :            : {
    5315                 :            :   indirect_thunk_prefix_none,
    5316                 :            :   indirect_thunk_prefix_nt
    5317                 :            : };
    5318                 :            : 
    5319                 :            : /* Return the prefix needed for an indirect branch INSN.  */
    5320                 :            : 
    5321                 :            : enum indirect_thunk_prefix
    5322                 :         60 : indirect_thunk_need_prefix (rtx_insn *insn)
    5323                 :            : {
    5324                 :         60 :   enum indirect_thunk_prefix need_prefix;
    5325                 :         60 :   if ((cfun->machine->indirect_branch_type
    5326                 :         60 :             == indirect_branch_thunk_extern)
    5327                 :         60 :            && ix86_notrack_prefixed_insn_p (insn))
    5328                 :            :     {
    5329                 :            :       /* NOTRACK prefix is only used with external thunk so that it
    5330                 :            :          can be properly updated to support CET at run-time.  */
    5331                 :            :       need_prefix = indirect_thunk_prefix_nt;
    5332                 :            :     }
    5333                 :            :   else
    5334                 :            :     need_prefix = indirect_thunk_prefix_none;
    5335                 :         60 :   return need_prefix;
    5336                 :            : }
    5337                 :            : 
    5338                 :            : /* Fills in the label name that should be used for the indirect thunk.  */
    5339                 :            : 
    5340                 :            : static void
    5341                 :         65 : indirect_thunk_name (char name[32], unsigned int regno,
    5342                 :            :                      enum indirect_thunk_prefix need_prefix,
    5343                 :            :                      bool ret_p)
    5344                 :            : {
    5345                 :         65 :   if (regno != INVALID_REGNUM && regno != CX_REG && ret_p)
    5346                 :          0 :     gcc_unreachable ();
    5347                 :            : 
    5348                 :         65 :   if (USE_HIDDEN_LINKONCE)
    5349                 :            :     {
    5350                 :         65 :       const char *prefix;
    5351                 :            : 
    5352                 :         65 :       if (need_prefix == indirect_thunk_prefix_nt
    5353                 :         65 :           && regno != INVALID_REGNUM)
    5354                 :            :         {
    5355                 :            :           /* NOTRACK prefix is only used with external thunk via
    5356                 :            :              register so that NOTRACK prefix can be added to indirect
    5357                 :            :              branch via register to support CET at run-time.  */
    5358                 :            :           prefix = "_nt";
    5359                 :            :         }
    5360                 :            :       else
    5361                 :         63 :         prefix = "";
    5362                 :            : 
    5363                 :         65 :       const char *ret = ret_p ? "return" : "indirect";
    5364                 :            : 
    5365                 :         65 :       if (regno != INVALID_REGNUM)
    5366                 :            :         {
    5367                 :         48 :           const char *reg_prefix;
    5368                 :         48 :           if (LEGACY_INT_REGNO_P (regno))
    5369                 :         48 :             reg_prefix = TARGET_64BIT ? "r" : "e";
    5370                 :            :           else
    5371                 :            :             reg_prefix = "";
    5372                 :         48 :           sprintf (name, "__x86_%s_thunk%s_%s%s",
    5373                 :            :                    ret, prefix, reg_prefix, reg_names[regno]);
    5374                 :            :         }
    5375                 :            :       else
    5376                 :         17 :         sprintf (name, "__x86_%s_thunk%s", ret, prefix);
    5377                 :            :     }
    5378                 :            :   else
    5379                 :            :     {
    5380                 :            :       if (regno != INVALID_REGNUM)
    5381                 :            :         ASM_GENERATE_INTERNAL_LABEL (name, "LITR", regno);
    5382                 :            :       else
    5383                 :            :         {
    5384                 :            :           if (ret_p)
    5385                 :            :             ASM_GENERATE_INTERNAL_LABEL (name, "LRT", 0);
    5386                 :            :           else
    5387                 :            :             ASM_GENERATE_INTERNAL_LABEL (name, "LIT", 0);
    5388                 :            :         }
    5389                 :            :     }
    5390                 :         65 : }
    5391                 :            : 
    5392                 :            : /* Output a call and return thunk for indirect branch.  If REGNO != -1,
    5393                 :            :    the function address is in REGNO and the call and return thunk looks like:
    5394                 :            : 
    5395                 :            :         call    L2
    5396                 :            :    L1:
    5397                 :            :         pause
    5398                 :            :         lfence
    5399                 :            :         jmp     L1
    5400                 :            :    L2:
    5401                 :            :         mov     %REG, (%sp)
    5402                 :            :         ret
    5403                 :            : 
    5404                 :            :    Otherwise, the function address is on the top of stack and the
    5405                 :            :    call and return thunk looks like:
    5406                 :            : 
    5407                 :            :         call L2
    5408                 :            :   L1:
    5409                 :            :         pause
    5410                 :            :         lfence
    5411                 :            :         jmp L1
    5412                 :            :   L2:
    5413                 :            :         lea WORD_SIZE(%sp), %sp
    5414                 :            :         ret
    5415                 :            :  */
    5416                 :            : 
    5417                 :            : static void
    5418                 :         37 : output_indirect_thunk (unsigned int regno)
    5419                 :            : {
    5420                 :         37 :   char indirectlabel1[32];
    5421                 :         37 :   char indirectlabel2[32];
    5422                 :            : 
    5423                 :         37 :   ASM_GENERATE_INTERNAL_LABEL (indirectlabel1, INDIRECT_LABEL,
    5424                 :            :                                indirectlabelno++);
    5425                 :         37 :   ASM_GENERATE_INTERNAL_LABEL (indirectlabel2, INDIRECT_LABEL,
    5426                 :            :                                indirectlabelno++);
    5427                 :            : 
    5428                 :            :   /* Call */
    5429                 :         37 :   fputs ("\tcall\t", asm_out_file);
    5430                 :         37 :   assemble_name_raw (asm_out_file, indirectlabel2);
    5431                 :         37 :   fputc ('\n', asm_out_file);
    5432                 :            : 
    5433                 :         37 :   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, indirectlabel1);
    5434                 :            : 
    5435                 :            :   /* AMD and Intel CPUs prefer each a different instruction as loop filler.
    5436                 :            :      Usage of both pause + lfence is compromise solution.  */
    5437                 :         37 :   fprintf (asm_out_file, "\tpause\n\tlfence\n");
    5438                 :            : 
    5439                 :            :   /* Jump.  */
    5440                 :         37 :   fputs ("\tjmp\t", asm_out_file);
    5441                 :         37 :   assemble_name_raw (asm_out_file, indirectlabel1);
    5442                 :         37 :   fputc ('\n', asm_out_file);
    5443                 :            : 
    5444                 :         37 :   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, indirectlabel2);
    5445                 :            : 
    5446                 :            :   /* The above call insn pushed a word to stack.  Adjust CFI info.  */
    5447                 :         37 :   if (flag_asynchronous_unwind_tables && dwarf2out_do_frame ())
    5448                 :            :     {
    5449                 :         37 :       if (! dwarf2out_do_cfi_asm ())
    5450                 :            :         {
    5451                 :          0 :           dw_cfi_ref xcfi = ggc_cleared_alloc<dw_cfi_node> ();
    5452                 :          0 :           xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
    5453                 :          0 :           xcfi->dw_cfi_oprnd1.dw_cfi_addr = ggc_strdup (indirectlabel2);
    5454                 :          0 :           vec_safe_push (cfun->fde->dw_fde_cfi, xcfi);
    5455                 :            :         }
    5456                 :         37 :       dw_cfi_ref xcfi = ggc_cleared_alloc<dw_cfi_node> ();
    5457                 :         37 :       xcfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
    5458                 :         37 :       xcfi->dw_cfi_oprnd1.dw_cfi_offset = 2 * UNITS_PER_WORD;
    5459                 :         37 :       vec_safe_push (cfun->fde->dw_fde_cfi, xcfi);
    5460                 :         37 :       dwarf2out_emit_cfi (xcfi);
    5461                 :            :     }
    5462                 :            : 
    5463                 :         37 :   if (regno != INVALID_REGNUM)
    5464                 :            :     {
    5465                 :            :       /* MOV.  */
    5466                 :         26 :       rtx xops[2];
    5467                 :         26 :       xops[0] = gen_rtx_MEM (word_mode, stack_pointer_rtx);
    5468                 :         26 :       xops[1] = gen_rtx_REG (word_mode, regno);
    5469                 :         26 :       output_asm_insn ("mov\t{%1, %0|%0, %1}", xops);
    5470                 :            :     }
    5471                 :            :   else
    5472                 :            :     {
    5473                 :            :       /* LEA.  */
    5474                 :         11 :       rtx xops[2];
    5475                 :         11 :       xops[0] = stack_pointer_rtx;
    5476                 :         11 :       xops[1] = plus_constant (Pmode, stack_pointer_rtx, UNITS_PER_WORD);
    5477                 :         11 :       output_asm_insn ("lea\t{%E1, %0|%0, %E1}", xops);
    5478                 :            :     }
    5479                 :            : 
    5480                 :         37 :   fputs ("\tret\n", asm_out_file);
    5481                 :         37 : }
    5482                 :            : 
    5483                 :            : /* Output a funtion with a call and return thunk for indirect branch.
    5484                 :            :    If REGNO != INVALID_REGNUM, the function address is in REGNO.
    5485                 :            :    Otherwise, the function address is on the top of stack.  Thunk is
    5486                 :            :    used for function return if RET_P is true.  */
    5487                 :            : 
    5488                 :            : static void
    5489                 :         21 : output_indirect_thunk_function (enum indirect_thunk_prefix need_prefix,
    5490                 :            :                                 unsigned int regno, bool ret_p)
    5491                 :            : {
    5492                 :         21 :   char name[32];
    5493                 :         21 :   tree decl;
    5494                 :            : 
    5495                 :            :   /* Create __x86_indirect_thunk.  */
    5496                 :         21 :   indirect_thunk_name (name, regno, need_prefix, ret_p);
    5497                 :         21 :   decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
    5498                 :            :                      get_identifier (name),
    5499                 :            :                      build_function_type_list (void_type_node, NULL_TREE));
    5500                 :         21 :   DECL_RESULT (decl) = build_decl (BUILTINS_LOCATION, RESULT_DECL,
    5501                 :            :                                    NULL_TREE, void_type_node);
    5502                 :         21 :   TREE_PUBLIC (decl) = 1;
    5503                 :         21 :   TREE_STATIC (decl) = 1;
    5504                 :         21 :   DECL_IGNORED_P (decl) = 1;
    5505                 :            : 
    5506                 :            : #if TARGET_MACHO
    5507                 :            :   if (TARGET_MACHO)
    5508                 :            :     {
    5509                 :            :       switch_to_section (darwin_sections[picbase_thunk_section]);
    5510                 :            :       fputs ("\t.weak_definition\t", asm_out_file);
    5511                 :            :       assemble_name (asm_out_file, name);
    5512                 :            :       fputs ("\n\t.private_extern\t", asm_out_file);
    5513                 :            :       assemble_name (asm_out_file, name);
    5514                 :            :       putc ('\n', asm_out_file);
    5515                 :            :       ASM_OUTPUT_LABEL (asm_out_file, name);
    5516                 :            :       DECL_WEAK (decl) = 1;
    5517                 :            :     }
    5518                 :            :   else
    5519                 :            : #endif
    5520                 :         21 :     if (USE_HIDDEN_LINKONCE)
    5521                 :            :       {
    5522                 :         21 :         cgraph_node::create (decl)->set_comdat_group (DECL_ASSEMBLER_NAME (decl));
    5523                 :            : 
    5524                 :         21 :         targetm.asm_out.unique_section (decl, 0);
    5525                 :         21 :         switch_to_section (get_named_section (decl, NULL, 0));
    5526                 :            : 
    5527                 :         21 :         targetm.asm_out.globalize_label (asm_out_file, name);
    5528                 :         21 :         fputs ("\t.hidden\t", asm_out_file);
    5529                 :         21 :         assemble_name (asm_out_file, name);
    5530                 :         21 :         putc ('\n', asm_out_file);
    5531                 :         21 :         ASM_DECLARE_FUNCTION_NAME (asm_out_file, name, decl);
    5532                 :            :       }
    5533                 :            :     else
    5534                 :            :       {
    5535                 :            :         switch_to_section (text_section);
    5536                 :            :         ASM_OUTPUT_LABEL (asm_out_file, name);
    5537                 :            :       }
    5538                 :            : 
    5539                 :         21 :   DECL_INITIAL (decl) = make_node (BLOCK);
    5540                 :         21 :   current_function_decl = decl;
    5541                 :         21 :   allocate_struct_function (decl, false);
    5542                 :         21 :   init_function_start (decl);
    5543                 :            :   /* We're about to hide the function body from callees of final_* by
    5544                 :            :      emitting it directly; tell them we're a thunk, if they care.  */
    5545                 :         21 :   cfun->is_thunk = true;
    5546                 :         21 :   first_function_block_is_cold = false;
    5547                 :            :   /* Make sure unwind info is emitted for the thunk if needed.  */
    5548                 :         21 :   final_start_function (emit_barrier (), asm_out_file, 1);
    5549                 :            : 
    5550                 :         21 :   output_indirect_thunk (regno);
    5551                 :            : 
    5552                 :         21 :   final_end_function ();
    5553                 :         21 :   init_insn_lengths ();
    5554                 :         21 :   free_after_compilation (cfun);
    5555                 :         21 :   set_cfun (NULL);
    5556                 :         21 :   current_function_decl = NULL;
    5557                 :         21 : }
    5558                 :            : 
    5559                 :            : static int pic_labels_used;
    5560                 :            : 
    5561                 :            : /* Fills in the label name that should be used for a pc thunk for
    5562                 :            :    the given register.  */
    5563                 :            : 
    5564                 :            : static void
    5565                 :      28159 : get_pc_thunk_name (char name[32], unsigned int regno)
    5566                 :            : {
    5567                 :      28159 :   gcc_assert (!TARGET_64BIT);
    5568                 :            : 
    5569                 :      28159 :   if (USE_HIDDEN_LINKONCE)
    5570                 :      28159 :     sprintf (name, "__x86.get_pc_thunk.%s", reg_names[regno]);
    5571                 :            :   else
    5572                 :            :     ASM_GENERATE_INTERNAL_LABEL (name, "LPR", regno);
    5573                 :      28159 : }
    5574                 :            : 
    5575                 :            : 
    5576                 :            : /* This function generates code for -fpic that loads %ebx with
    5577                 :            :    the return address of the caller and then returns.  */
    5578                 :            : 
    5579                 :            : static void
    5580                 :     163649 : ix86_code_end (void)
    5581                 :            : {
    5582                 :     163649 :   rtx xops[2];
    5583                 :     163649 :   unsigned int regno;
    5584                 :            : 
    5585                 :     163649 :   if (indirect_return_needed)
    5586                 :          6 :     output_indirect_thunk_function (indirect_thunk_prefix_none,
    5587                 :            :                                     INVALID_REGNUM, true);
    5588                 :     163649 :   if (indirect_return_via_cx)
    5589                 :          0 :     output_indirect_thunk_function (indirect_thunk_prefix_none,
    5590                 :            :                                     CX_REG, true);
    5591                 :     163649 :   if (indirect_thunk_needed)
    5592                 :          0 :     output_indirect_thunk_function (indirect_thunk_prefix_none,
    5593                 :            :                                     INVALID_REGNUM, false);
    5594                 :            : 
    5595                 :    1472840 :   for (regno = FIRST_REX_INT_REG; regno <= LAST_REX_INT_REG; regno++)
    5596                 :            :     {
    5597                 :    1309190 :       unsigned int i = regno - FIRST_REX_INT_REG + LAST_INT_REG + 1;
    5598                 :    1309190 :       if ((indirect_thunks_used & (1 << i)))
    5599                 :          0 :         output_indirect_thunk_function (indirect_thunk_prefix_none,
    5600                 :            :                                         regno, false);
    5601                 :            :     }
    5602                 :            : 
    5603                 :    1472840 :   for (regno = FIRST_INT_REG; regno <= LAST_INT_REG; regno++)
    5604                 :            :     {
    5605                 :    1309190 :       char name[32];
    5606                 :    1309190 :       tree decl;
    5607                 :            : 
    5608                 :    1309190 :       if ((indirect_thunks_used & (1 << regno)))
    5609                 :         15 :         output_indirect_thunk_function (indirect_thunk_prefix_none,
    5610                 :            :                                         regno, false);
    5611                 :            : 
    5612                 :    1309190 :       if (!(pic_labels_used & (1 << regno)))
    5613                 :    1306210 :         continue;
    5614                 :            : 
    5615                 :       2984 :       get_pc_thunk_name (name, regno);
    5616                 :            : 
    5617                 :       2984 :       decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
    5618                 :            :                          get_identifier (name),
    5619                 :            :                          build_function_type_list (void_type_node, NULL_TREE));
    5620                 :       2984 :       DECL_RESULT (decl) = build_decl (BUILTINS_LOCATION, RESULT_DECL,
    5621                 :            :                                        NULL_TREE, void_type_node);
    5622                 :       2984 :       TREE_PUBLIC (decl) = 1;
    5623                 :       2984 :       TREE_STATIC (decl) = 1;
    5624                 :       2984 :       DECL_IGNORED_P (decl) = 1;
    5625                 :            : 
    5626                 :            : #if TARGET_MACHO
    5627                 :            :       if (TARGET_MACHO)
    5628                 :            :         {
    5629                 :            :           switch_to_section (darwin_sections[picbase_thunk_section]);
    5630                 :            :           fputs ("\t.weak_definition\t", asm_out_file);
    5631                 :            :           assemble_name (asm_out_file, name);
    5632                 :            :           fputs ("\n\t.private_extern\t", asm_out_file);
    5633                 :            :           assemble_name (asm_out_file, name);
    5634                 :            :           putc ('\n', asm_out_file);
    5635                 :            :           ASM_OUTPUT_LABEL (asm_out_file, name);
    5636                 :            :           DECL_WEAK (decl) = 1;
    5637                 :            :         }
    5638                 :            :       else
    5639                 :            : #endif
    5640                 :       2984 :       if (USE_HIDDEN_LINKONCE)
    5641                 :            :         {
    5642                 :       2984 :           cgraph_node::create (decl)->set_comdat_group (DECL_ASSEMBLER_NAME (decl));
    5643                 :            : 
    5644                 :       2984 :           targetm.asm_out.unique_section (decl, 0);
    5645                 :       2984 :           switch_to_section (get_named_section (decl, NULL, 0));
    5646                 :            : 
    5647                 :       2984 :           targetm.asm_out.globalize_label (asm_out_file, name);
    5648                 :       2984 :           fputs ("\t.hidden\t", asm_out_file);
    5649                 :       2984 :           assemble_name (asm_out_file, name);
    5650                 :       2984 :           putc ('\n', asm_out_file);
    5651                 :       2984 :           ASM_DECLARE_FUNCTION_NAME (asm_out_file, name, decl);
    5652                 :            :         }
    5653                 :            :       else
    5654                 :            :         {
    5655                 :            :           switch_to_section (text_section);
    5656                 :            :           ASM_OUTPUT_LABEL (asm_out_file, name);
    5657                 :            :         }
    5658                 :            : 
    5659                 :       2984 :       DECL_INITIAL (decl) = make_node (BLOCK);
    5660                 :       2984 :       current_function_decl = decl;
    5661                 :       2984 :       allocate_struct_function (decl, false);
    5662                 :       2984 :       init_function_start (decl);
    5663                 :            :       /* We're about to hide the function body from callees of final_* by
    5664                 :            :          emitting it directly; tell them we're a thunk, if they care.  */
    5665                 :       2984 :       cfun->is_thunk = true;
    5666                 :       2984 :       first_function_block_is_cold = false;
    5667                 :            :       /* Make sure unwind info is emitted for the thunk if needed.  */
    5668                 :       2984 :       final_start_function (emit_barrier (), asm_out_file, 1);
    5669                 :            : 
    5670                 :            :       /* Pad stack IP move with 4 instructions (two NOPs count
    5671                 :            :          as one instruction).  */
    5672                 :       2984 :       if (TARGET_PAD_SHORT_FUNCTION)
    5673                 :            :         {
    5674                 :            :           int i = 8;
    5675                 :            : 
    5676                 :          0 :           while (i--)
    5677                 :          0 :             fputs ("\tnop\n", asm_out_file);
    5678                 :            :         }
    5679                 :            : 
    5680                 :       5968 :       xops[0] = gen_rtx_REG (Pmode, regno);
    5681                 :       5968 :       xops[1] = gen_rtx_MEM (Pmode, stack_pointer_rtx);
    5682                 :       2984 :       output_asm_insn ("mov%z0\t{%1, %0|%0, %1}", xops);
    5683                 :       2984 :       output_asm_insn ("%!ret", NULL);
    5684                 :       2984 :       final_end_function ();
    5685                 :       2984 :       init_insn_lengths ();
    5686                 :       2984 :       free_after_compilation (cfun);
    5687                 :       2984 :       set_cfun (NULL);
    5688                 :       2984 :       current_function_decl = NULL;
    5689                 :            :     }
    5690                 :            : 
    5691                 :     163649 :   if (flag_split_stack)
    5692                 :       3578 :     file_end_indicate_split_stack ();
    5693                 :     163649 : }
    5694                 :            : 
    5695                 :            : /* Emit code for the SET_GOT patterns.  */
    5696                 :            : 
    5697                 :            : const char *
    5698                 :      25175 : output_set_got (rtx dest, rtx label)
    5699                 :            : {
    5700                 :      25175 :   rtx xops[3];
    5701                 :            : 
    5702                 :      25175 :   xops[0] = dest;
    5703                 :            : 
    5704                 :      25175 :   if (TARGET_VXWORKS_RTP && flag_pic)
    5705                 :            :     {
    5706                 :            :       /* Load (*VXWORKS_GOTT_BASE) into the PIC register.  */
    5707                 :            :       xops[2] = gen_rtx_MEM (Pmode,
    5708                 :            :                              gen_rtx_SYMBOL_REF (Pmode, VXWORKS_GOTT_BASE));
    5709                 :            :       output_asm_insn ("mov{l}\t{%2, %0|%0, %2}", xops);
    5710                 :            : 
    5711                 :            :       /* Load (*VXWORKS_GOTT_BASE)[VXWORKS_GOTT_INDEX] into the PIC register.
    5712                 :            :          Use %P and a local symbol in order to print VXWORKS_GOTT_INDEX as
    5713                 :            :          an unadorned address.  */
    5714                 :            :       xops[2] = gen_rtx_SYMBOL_REF (Pmode, VXWORKS_GOTT_INDEX);
    5715                 :            :       SYMBOL_REF_FLAGS (xops[2]) |= SYMBOL_FLAG_LOCAL;
    5716                 :            :       output_asm_insn ("mov{l}\t{%P2(%0), %0|%0, DWORD PTR %P2[%0]}", xops);
    5717                 :            :       return "";
    5718                 :            :     }
    5719                 :            : 
    5720                 :      50350 :   xops[1] = gen_rtx_SYMBOL_REF (Pmode, GOT_SYMBOL_NAME);
    5721                 :            : 
    5722                 :      25175 :   if (flag_pic)
    5723                 :            :     {
    5724                 :      25175 :       char name[32];
    5725                 :      25175 :       get_pc_thunk_name (name, REGNO (dest));
    5726                 :      25175 :       pic_labels_used |= 1 << REGNO (dest);
    5727                 :            : 
    5728                 :      50350 :       xops[2] = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (name));
    5729                 :      25175 :       xops[2] = gen_rtx_MEM (QImode, xops[2]);
    5730                 :      25175 :       output_asm_insn ("%!call\t%X2", xops);
    5731                 :            : 
    5732                 :            : #if TARGET_MACHO
    5733                 :            :       /* Output the Mach-O "canonical" pic base label name ("Lxx$pb") here.
    5734                 :            :          This is what will be referenced by the Mach-O PIC subsystem.  */
    5735                 :            :       if (machopic_should_output_picbase_label () || !label)
    5736                 :            :         ASM_OUTPUT_LABEL (asm_out_file, MACHOPIC_FUNCTION_BASE_NAME);
    5737                 :            : 
    5738                 :            :       /* When we are restoring the pic base at the site of a nonlocal label,
    5739                 :            :          and we decided to emit the pic base above, we will still output a
    5740                 :            :          local label used for calculating the correction offset (even though
    5741                 :            :          the offset will be 0 in that case).  */
    5742                 :            :       if (label)
    5743                 :            :         targetm.asm_out.internal_label (asm_out_file, "L",
    5744                 :            :                                            CODE_LABEL_NUMBER (label));
    5745                 :            : #endif
    5746                 :            :     }
    5747                 :            :   else
    5748                 :            :     {
    5749                 :          0 :       if (TARGET_MACHO)
    5750                 :            :         /* We don't need a pic base, we're not producing pic.  */
    5751                 :            :         gcc_unreachable ();
    5752                 :            : 
    5753                 :          0 :       xops[2] = gen_rtx_LABEL_REF (Pmode, label ? label : gen_label_rtx ());
    5754                 :          0 :       output_asm_insn ("mov%z0\t{%2, %0|%0, %2}", xops);
    5755                 :          0 :       targetm.asm_out.internal_label (asm_out_file, "L",
    5756                 :          0 :                                       CODE_LABEL_NUMBER (XEXP (xops[2], 0)));
    5757                 :            :     }
    5758                 :            : 
    5759                 :      25175 :   if (!TARGET_MACHO)
    5760                 :      25175 :     output_asm_insn ("add%z0\t{%1, %0|%0, %1}", xops);
    5761                 :            : 
    5762                 :      25175 :   return "";
    5763                 :            : }
    5764                 :            : 
    5765                 :            : /* Generate an "push" pattern for input ARG.  */
    5766                 :            : 
    5767                 :            : rtx
    5768                 :    1313530 : gen_push (rtx arg)
    5769                 :            : {
    5770                 :    1313530 :   struct machine_function *m = cfun->machine;
    5771                 :            : 
    5772                 :    1313530 :   if (m->fs.cfa_reg == stack_pointer_rtx)
    5773                 :    1173180 :     m->fs.cfa_offset += UNITS_PER_WORD;
    5774                 :    1313530 :   m->fs.sp_offset += UNITS_PER_WORD;
    5775                 :            : 
    5776                 :    1313530 :   if (REG_P (arg) && GET_MODE (arg) != word_mode)
    5777                 :         24 :     arg = gen_rtx_REG (word_mode, REGNO (arg));
    5778                 :            : 
    5779                 :    1656960 :   return gen_rtx_SET (gen_rtx_MEM (word_mode,
    5780                 :            :                                    gen_rtx_PRE_DEC (Pmode,
    5781                 :            :                                                     stack_pointer_rtx)),
    5782                 :            :                       arg);
    5783                 :            : }
    5784                 :            : 
    5785                 :            : /* Generate an "pop" pattern for input ARG.  */
    5786                 :            : 
    5787                 :            : rtx
    5788                 :    1065990 : gen_pop (rtx arg)
    5789                 :            : {
    5790                 :    1065990 :   if (REG_P (arg) && GET_MODE (arg) != word_mode)
    5791                 :         19 :     arg = gen_rtx_REG (word_mode, REGNO (arg));
    5792                 :            : 
    5793                 :    1260960 :   return gen_rtx_SET (arg,
    5794                 :            :                       gen_rtx_MEM (word_mode,
    5795                 :            :                                    gen_rtx_POST_INC (Pmode,
    5796                 :            :                                                      stack_pointer_rtx)));
    5797                 :            : }
    5798                 :            : 
    5799                 :            : /* Return >= 0 if there is an unused call-clobbered register available
    5800                 :            :    for the entire function.  */
    5801                 :            : 
    5802                 :            : static unsigned int
    5803                 :          0 : ix86_select_alt_pic_regnum (void)
    5804                 :            : {
    5805                 :          0 :   if (ix86_use_pseudo_pic_reg ())
    5806                 :            :     return INVALID_REGNUM;
    5807                 :            : 
    5808                 :          0 :   if (crtl->is_leaf
    5809                 :          0 :       && !crtl->profile
    5810                 :          0 :       && !ix86_current_function_calls_tls_descriptor)
    5811                 :            :     {
    5812                 :          0 :       int i, drap;
    5813                 :            :       /* Can't use the same register for both PIC and DRAP.  */
    5814                 :          0 :       if (crtl->drap_reg)
    5815                 :          0 :         drap = REGNO (crtl->drap_reg);
    5816                 :            :       else
    5817                 :            :         drap = -1;
    5818                 :          0 :       for (i = 2; i >= 0; --i)
    5819                 :          0 :         if (i != drap && !df_regs_ever_live_p (i))
    5820                 :          0 :           return i;
    5821                 :            :     }
    5822                 :            : 
    5823                 :            :   return INVALID_REGNUM;
    5824                 :            : }
    5825                 :            : 
    5826                 :            : /* Return true if REGNO is used by the epilogue.  */
    5827                 :            : 
    5828                 :            : bool
    5829                 :  792751000 : ix86_epilogue_uses (int regno)
    5830                 :            : {
    5831                 :            :   /* If there are no caller-saved registers, we preserve all registers,
    5832                 :            :      except for MMX and x87 registers which aren't supported when saving
    5833                 :            :      and restoring registers.  Don't explicitly save SP register since
    5834                 :            :      it is always preserved.  */
    5835                 :  792751000 :   return (epilogue_completed
    5836                 :  140105000 :           && cfun->machine->no_caller_saved_registers
    5837                 :      14440 :           && !fixed_regs[regno]
    5838                 :       2850 :           && !STACK_REGNO_P (regno)
    5839                 :  792753000 :           && !MMX_REGNO_P (regno));
    5840                 :            : }
    5841                 :            : 
    5842                 :            : /* Return nonzero if register REGNO can be used as a scratch register
    5843                 :            :    in peephole2.  */
    5844                 :            : 
    5845                 :            : static bool
    5846                 :     781324 : ix86_hard_regno_scratch_ok (unsigned int regno)
    5847                 :            : {
    5848                 :            :   /* If there are no caller-saved registers, we can't use any register
    5849                 :            :      as a scratch register after epilogue and use REGNO as scratch
    5850                 :            :      register only if it has been used before to avoid saving and
    5851                 :            :      restoring it.  */
    5852                 :     781324 :   return (!cfun->machine->no_caller_saved_registers
    5853                 :     781324 :           || (!epilogue_completed
    5854                 :          0 :               && df_regs_ever_live_p (regno)));
    5855                 :            : }
    5856                 :            : 
    5857                 :            : /* Return TRUE if we need to save REGNO.  */
    5858                 :            : 
    5859                 :            : bool
    5860                 :  118631000 : ix86_save_reg (unsigned int regno, bool maybe_eh_return, bool ignore_outlined)
    5861                 :            : {
    5862                 :            :   /* If there are no caller-saved registers, we preserve all registers,
    5863                 :            :      except for MMX and x87 registers which aren't supported when saving
    5864                 :            :      and restoring registers.  Don't explicitly save SP register since
    5865                 :            :      it is always preserved.  */
    5866                 :  118631000 :   if (cfun->machine->no_caller_saved_registers)
    5867                 :            :     {
    5868                 :            :       /* Don't preserve registers used for function return value.  */
    5869                 :      12096 :       rtx reg = crtl->return_rtx;
    5870                 :      12096 :       if (reg)
    5871                 :            :         {
    5872                 :        256 :           unsigned int i = REGNO (reg);
    5873                 :        256 :           unsigned int nregs = REG_NREGS (reg);
    5874                 :        496 :           while (nregs-- > 0)
    5875                 :        256 :             if ((i + nregs) == regno)
    5876                 :            :               return false;
    5877                 :            :         }
    5878                 :            : 
    5879                 :      12080 :       return (df_regs_ever_live_p (regno)
    5880                 :       3797 :               && !fixed_regs[regno]
    5881                 :       3101 :               && !STACK_REGNO_P (regno)
    5882                 :       3101 :               && !MMX_REGNO_P (regno)
    5883                 :      15181 :               && (regno != HARD_FRAME_POINTER_REGNUM
    5884                 :        178 :                   || !frame_pointer_needed));
    5885                 :            :     }
    5886                 :            : 
    5887                 :  132223000 :   if (regno == REAL_PIC_OFFSET_TABLE_REGNUM
    5888                 :    7211510 :       && pic_offset_table_rtx)
    5889                 :            :     {
    5890                 :     286860 :       if (ix86_use_pseudo_pic_reg ())
    5891                 :            :         {
    5892                 :            :           /* REAL_PIC_OFFSET_TABLE_REGNUM used by call to
    5893                 :            :           _mcount in prologue.  */
    5894                 :     286860 :           if (!TARGET_64BIT && flag_pic && crtl->profile)
    5895                 :            :             return true;
    5896                 :            :         }
    5897                 :          0 :       else if (df_regs_ever_live_p (REAL_PIC_OFFSET_TABLE_REGNUM)
    5898                 :          0 :                || crtl->profile
    5899                 :          0 :                || crtl->calls_eh_return
    5900                 :          0 :                || crtl->uses_const_pool
    5901                 :          0 :                || cfun->has_nonlocal_label)
    5902                 :          0 :         return ix86_select_alt_pic_regnum () == INVALID_REGNUM;
    5903                 :            :     }
    5904                 :            : 
    5905                 :  118619000 :   if (crtl->calls_eh_return && maybe_eh_return)
    5906                 :            :     {
    5907                 :            :       unsigned i;
    5908                 :       6090 :       for (i = 0; ; i++)
    5909                 :            :         {
    5910                 :       9450 :           unsigned test = EH_RETURN_DATA_REGNO (i);
    5911                 :       6510 :           if (test == INVALID_REGNUM)
    5912                 :            :             break;
    5913                 :       6510 :           if (test == regno)
    5914                 :            :             return true;
    5915                 :       6090 :         }
    5916                 :            :     }
    5917                 :            : 
    5918                 :  118619000 :   if (ignore_outlined && cfun->machine->call_ms2sysv)
    5919                 :            :     {
    5920                 :    2220610 :       unsigned count = cfun->machine->call_ms2sysv_extra_regs
    5921                 :            :                        + xlogue_layout::MIN_REGS;
    5922                 :    2220610 :       if (xlogue_layout::is_stub_managed_reg (regno, count))
    5923                 :            :         return false;
    5924                 :            :     }
    5925                 :            : 
    5926                 :  118015000 :   if (crtl->drap_reg
    5927                 :    1234350 :       && regno == REGNO (crtl->drap_reg)
    5928                 :  118062000 :       && !cfun->machine->no_drap_save_restore)
    5929                 :            :     return true;
    5930                 :            : 
    5931                 :  117968000 :   return (df_regs_ever_live_p (regno)
    5932                 :  128988000 :           && !call_used_or_fixed_reg_p (regno)
    5933                 :  128324000 :           && (regno != HARD_FRAME_POINTER_REGNUM || !frame_pointer_needed));
    5934                 :            : }
    5935                 :            : 
    5936                 :            : /* Return number of saved general prupose registers.  */
    5937                 :            : 
    5938                 :            : static int
    5939                 :    6013810 : ix86_nsaved_regs (void)
    5940                 :            : {
    5941                 :    6013810 :   int nregs = 0;
    5942                 :    6013810 :   int regno;
    5943                 :            : 
    5944                 :  463064000 :   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
    5945                 :  457050000 :     if (GENERAL_REGNO_P (regno) && ix86_save_reg (regno, true, true))
    5946                 :    5817670 :       nregs ++;
    5947                 :    6013810 :   return nregs;
    5948                 :            : }
    5949                 :            : 
    5950                 :            : /* Return number of saved SSE registers.  */
    5951                 :            : 
    5952                 :            : static int
    5953                 :    6037960 : ix86_nsaved_sseregs (void)
    5954                 :            : {
    5955                 :    6037960 :   int nregs = 0;
    5956                 :    6037960 :   int regno;
    5957                 :            : 
    5958                 :    6037960 :   if (!TARGET_64BIT_MS_ABI)
    5959                 :    5952940 :     return 0;
    5960                 :    6546230 :   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
    5961                 :    6461220 :     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, true, true))
    5962                 :     423425 :       nregs ++;
    5963                 :            :   return nregs;
    5964                 :            : }
    5965                 :            : 
    5966                 :            : /* Given FROM and TO register numbers, say whether this elimination is
    5967                 :            :    allowed.  If stack alignment is needed, we can only replace argument
    5968                 :            :    pointer with hard frame pointer, or replace frame pointer with stack
    5969                 :            :    pointer.  Otherwise, frame pointer elimination is automatically
    5970                 :            :    handled and all other eliminations are valid.  */
    5971                 :            : 
    5972                 :            : static bool
    5973                 :   36722400 : ix86_can_eliminate (const int from, const int to)
    5974                 :            : {
    5975                 :   36722400 :   if (stack_realign_fp)
    5976                 :    1294650 :     return ((from == ARG_POINTER_REGNUM
    5977                 :    1294650 :              && to == HARD_FRAME_POINTER_REGNUM)
    5978                 :    1294650 :             || (from == FRAME_POINTER_REGNUM
    5979                 :    1941980 :                 && to == STACK_POINTER_REGNUM));
    5980                 :            :   else
    5981                 :   39822200 :     return to == STACK_POINTER_REGNUM ? !frame_pointer_needed : true;
    5982                 :            : }
    5983                 :            : 
    5984                 :            : /* Return the offset between two registers, one to be eliminated, and the other
    5985                 :            :    its replacement, at the start of a routine.  */
    5986                 :            : 
    5987                 :            : HOST_WIDE_INT
    5988                 :  113819000 : ix86_initial_elimination_offset (int from, int to)
    5989                 :            : {
    5990                 :  113819000 :   struct ix86_frame &frame = cfun->machine->frame;
    5991                 :            : 
    5992                 :  113819000 :   if (from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
    5993                 :    7701840 :     return frame.hard_frame_pointer_offset;
    5994                 :  106118000 :   else if (from == FRAME_POINTER_REGNUM
    5995                 :  106118000 :            && to == HARD_FRAME_POINTER_REGNUM)
    5996                 :    5989420 :     return frame.hard_frame_pointer_offset - frame.frame_pointer_offset;
    5997                 :            :   else
    5998                 :            :     {
    5999                 :  100128000 :       gcc_assert (to == STACK_POINTER_REGNUM);
    6000                 :            : 
    6001                 :  100128000 :       if (from == ARG_POINTER_REGNUM)
    6002                 :   94138700 :         return frame.stack_pointer_offset;
    6003                 :            : 
    6004                 :    5989420 :       gcc_assert (from == FRAME_POINTER_REGNUM);
    6005                 :    5989420 :       return frame.stack_pointer_offset - frame.frame_pointer_offset;
    6006                 :            :     }
    6007                 :            : }
    6008                 :            : 
    6009                 :            : /* Emits a warning for unsupported msabi to sysv pro/epilogues.  */
    6010                 :          0 : void warn_once_call_ms2sysv_xlogues (const char *feature)
    6011                 :            : {
    6012                 :          0 :   static bool warned_once = false;
    6013                 :          0 :   if (!warned_once)
    6014                 :            :     {
    6015                 :          0 :       warning (0, "%<-mcall-ms2sysv-xlogues%> is not compatible with %s",
    6016                 :            :                feature);
    6017                 :          0 :       warned_once = true;
    6018                 :            :     }
    6019                 :          0 : }
    6020                 :            : 
    6021                 :            : /* Return the probing interval for -fstack-clash-protection.  */
    6022                 :            : 
    6023                 :            : static HOST_WIDE_INT
    6024                 :        447 : get_probe_interval (void)
    6025                 :            : {
    6026                 :          0 :   if (flag_stack_clash_protection)
    6027                 :        280 :     return (HOST_WIDE_INT_1U
    6028                 :         19 :             << param_stack_clash_protection_probe_interval);
    6029                 :            :   else
    6030                 :            :     return (HOST_WIDE_INT_1U << STACK_CHECK_PROBE_INTERVAL_EXP);
    6031                 :            : }
    6032                 :            : 
    6033                 :            : /* When using -fsplit-stack, the allocation routines set a field in
    6034                 :            :    the TCB to the bottom of the stack plus this much space, measured
    6035                 :            :    in bytes.  */
    6036                 :            : 
    6037                 :            : #define SPLIT_STACK_AVAILABLE 256
    6038                 :            : 
    6039                 :            : /* Fill structure ix86_frame about frame of currently computed function.  */
    6040                 :            : 
    6041                 :            : static void
    6042                 :    6013810 : ix86_compute_frame_layout (void)
    6043                 :            : {
    6044                 :    6013810 :   struct ix86_frame *frame = &cfun->machine->frame;
    6045                 :    6013810 :   struct machine_function *m = cfun->machine;
    6046                 :    6013810 :   unsigned HOST_WIDE_INT stack_alignment_needed;
    6047                 :    6013810 :   HOST_WIDE_INT offset;
    6048                 :    6013810 :   unsigned HOST_WIDE_INT preferred_alignment;
    6049                 :    6013810 :   HOST_WIDE_INT size = ix86_get_frame_size ();
    6050                 :    6013810 :   HOST_WIDE_INT to_allocate;
    6051                 :            : 
    6052                 :            :   /* m->call_ms2sysv is initially enabled in ix86_expand_call for all 64-bit
    6053                 :            :    * ms_abi functions that call a sysv function.  We now need to prune away
    6054                 :            :    * cases where it should be disabled.  */
    6055                 :    6013810 :   if (TARGET_64BIT && m->call_ms2sysv)
    6056                 :            :     {
    6057                 :      42270 :       gcc_assert (TARGET_64BIT_MS_ABI);
    6058                 :      42270 :       gcc_assert (TARGET_CALL_MS2SYSV_XLOGUES);
    6059                 :      42270 :       gcc_assert (!TARGET_SEH);
    6060                 :      42270 :       gcc_assert (TARGET_SSE);
    6061                 :      42270 :       gcc_assert (!ix86_using_red_zone ());
    6062                 :            : 
    6063                 :      42270 :       if (crtl->calls_eh_return)
    6064                 :            :         {
    6065                 :          0 :           gcc_assert (!reload_completed);
    6066                 :          0 :           m->call_ms2sysv = false;
    6067                 :          0 :           warn_once_call_ms2sysv_xlogues ("__builtin_eh_return");
    6068                 :            :         }
    6069                 :            : 
    6070                 :      42270 :       else if (ix86_static_chain_on_stack)
    6071                 :            :         {
    6072                 :          0 :           gcc_assert (!reload_completed);
    6073                 :          0 :           m->call_ms2sysv = false;
    6074                 :          0 :           warn_once_call_ms2sysv_xlogues ("static call chains");
    6075                 :            :         }
    6076                 :            : 
    6077                 :            :       /* Finally, compute which registers the stub will manage.  */
    6078                 :            :       else
    6079                 :            :         {
    6080                 :      42270 :           unsigned count = xlogue_layout::count_stub_managed_regs ();
    6081                 :      42270 :           m->call_ms2sysv_extra_regs = count - xlogue_layout::MIN_REGS;
    6082                 :      42270 :           m->call_ms2sysv_pad_in = 0;
    6083                 :            :         }
    6084                 :            :     }
    6085                 :            : 
    6086                 :    6013810 :   frame->nregs = ix86_nsaved_regs ();
    6087                 :    6013810 :   frame->nsseregs = ix86_nsaved_sseregs ();
    6088                 :            : 
    6089                 :            :   /* 64-bit MS ABI seem to require stack alignment to be always 16,
    6090                 :            :      except for function prologues, leaf functions and when the defult
    6091                 :            :      incoming stack boundary is overriden at command line or via
    6092                 :            :      force_align_arg_pointer attribute.
    6093                 :            : 
    6094                 :            :      Darwin's ABI specifies 128b alignment for both 32 and  64 bit variants
    6095                 :            :      at call sites, including profile function calls.
    6096                 :            :  */
    6097                 :    5326790 :   if (((TARGET_64BIT_MS_ABI || TARGET_MACHO)
    6098                 :      85014 :         && crtl->preferred_stack_boundary < 128)
    6099                 :    6013810 :       && (!crtl->is_leaf || cfun->calls_alloca != 0
    6100                 :          0 :           || ix86_current_function_calls_tls_descriptor
    6101                 :          0 :           || (TARGET_MACHO && crtl->profile)
    6102                 :          0 :           || ix86_incoming_stack_boundary < 128))
    6103                 :            :     {
    6104                 :          0 :       crtl->preferred_stack_boundary = 128;
    6105                 :          0 :       crtl->stack_alignment_needed = 128;
    6106                 :            :     }
    6107                 :            : 
    6108                 :    6013810 :   stack_alignment_needed = crtl->stack_alignment_needed / BITS_PER_UNIT;
    6109                 :    6013810 :   preferred_alignment = crtl->preferred_stack_boundary / BITS_PER_UNIT;
    6110                 :            : 
    6111                 :    6013810 :   gcc_assert (!size || stack_alignment_needed);
    6112                 :    6700840 :   gcc_assert (preferred_alignment >= STACK_BOUNDARY / BITS_PER_UNIT);
    6113                 :    6013810 :   gcc_assert (preferred_alignment <= stack_alignment_needed);
    6114                 :            : 
    6115                 :            :   /* The only ABI saving SSE regs should be 64-bit ms_abi.  */
    6116                 :    6013810 :   gcc_assert (TARGET_64BIT || !frame->nsseregs);
    6117                 :    6013810 :   if (TARGET_64BIT && m->call_ms2sysv)
    6118                 :            :     {
    6119                 :      42270 :       gcc_assert (stack_alignment_needed >= 16);
    6120                 :      42270 :       gcc_assert (!frame->nsseregs);
    6121                 :            :     }
    6122                 :            : 
    6123                 :            :   /* For SEH we have to limit the amount of code movement into the prologue.
    6124                 :            :      At present we do this via a BLOCKAGE, at which point there's very little
    6125                 :            :      scheduling that can be done, which means that there's very little point
    6126                 :            :      in doing anything except PUSHs.  */
    6127                 :    6013810 :   if (TARGET_SEH)
    6128                 :            :     m->use_fast_prologue_epilogue = false;
    6129                 :    6013810 :   else if (!optimize_bb_for_size_p (ENTRY_BLOCK_PTR_FOR_FN (cfun)))
    6130                 :            :     {
    6131                 :    5741700 :       int count = frame->nregs;
    6132                 :    5741700 :       struct cgraph_node *node = cgraph_node::get (current_function_decl);
    6133                 :            : 
    6134                 :            :       /* The fast prologue uses move instead of push to save registers.  This
    6135                 :            :          is significantly longer, but also executes faster as modern hardware
    6136                 :            :          can execute the moves in parallel, but can't do that for push/pop.
    6137                 :            : 
    6138                 :            :          Be careful about choosing what prologue to emit:  When function takes
    6139                 :            :          many instructions to execute we may use slow version as well as in
    6140                 :            :          case function is known to be outside hot spot (this is known with
    6141                 :            :          feedback only).  Weight the size of function by number of registers
    6142                 :            :          to save as it is cheap to use one or two push instructions but very
    6143                 :            :          slow to use many of them.
    6144                 :            : 
    6145                 :            :          Calling this hook multiple times with the same frame requirements
    6146                 :            :          must produce the same layout, since the RA might otherwise be
    6147                 :            :          unable to reach a fixed point or might fail its final sanity checks.
    6148                 :            :          This means that once we've assumed that a function does or doesn't
    6149                 :            :          have a particular size, we have to stick to that assumption
    6150                 :            :          regardless of how the function has changed since.  */
    6151                 :    5741700 :       if (count)
    6152                 :    1707140 :         count = (count - 1) * FAST_PROLOGUE_INSN_COUNT;
    6153                 :    5741700 :       if (node->frequency < NODE_FREQUENCY_NORMAL
    6154                 :    5103250 :           || (flag_branch_probabilities
    6155                 :        864 :               && node->frequency < NODE_FREQUENCY_HOT))
    6156                 :     638713 :         m->use_fast_prologue_epilogue = false;
    6157                 :            :       else
    6158                 :            :         {
    6159                 :    5102980 :           if (count != frame->expensive_count)
    6160                 :            :             {
    6161                 :     190844 :               frame->expensive_count = count;
    6162                 :     190844 :               frame->expensive_p = expensive_function_p (count);
    6163                 :            :             }
    6164                 :    5102980 :           m->use_fast_prologue_epilogue = !frame->expensive_p;
    6165                 :            :         }
    6166                 :            :     }
    6167                 :            : 
    6168                 :    6013810 :   frame->save_regs_using_mov
    6169                 :     339667 :     = (TARGET_PROLOGUE_USING_MOVE && m->use_fast_prologue_epilogue
    6170                 :            :        /* If static stack checking is enabled and done with probes,
    6171                 :            :           the registers need to be saved before allocating the frame.  */
    6172                 :    6352890 :        && flag_stack_check != STATIC_BUILTIN_STACK_CHECK);
    6173                 :            : 
    6174                 :            :   /* Skip return address and error code in exception handler.  */
    6175                 :    6013810 :   offset = INCOMING_FRAME_SP_OFFSET;
    6176                 :            : 
    6177                 :            :   /* Skip pushed static chain.  */
    6178                 :    6013810 :   if (ix86_static_chain_on_stack)
    6179                 :          0 :     offset += UNITS_PER_WORD;
    6180                 :            : 
    6181                 :            :   /* Skip saved base pointer.  */
    6182                 :    6013810 :   if (frame_pointer_needed)
    6183                 :    2006350 :     offset += UNITS_PER_WORD;
    6184                 :    6013810 :   frame->hfp_save_offset = offset;
    6185                 :            : 
    6186                 :            :   /* The traditional frame pointer location is at the top of the frame.  */
    6187                 :    6013810 :   frame->hard_frame_pointer_offset = offset;
    6188                 :            : 
    6189                 :            :   /* Register save area */
    6190                 :    6013810 :   offset += frame->nregs * UNITS_PER_WORD;
    6191                 :    6013810 :   frame->reg_save_offset = offset;
    6192                 :            : 
    6193                 :            :   /* On SEH target, registers are pushed just before the frame pointer
    6194                 :            :      location.  */
    6195                 :    6013810 :   if (TARGET_SEH)
    6196                 :            :     frame->hard_frame_pointer_offset = offset;
    6197                 :            : 
    6198                 :            :   /* Calculate the size of the va-arg area (not including padding, if any).  */
    6199                 :    6013810 :   frame->va_arg_size = ix86_varargs_gpr_size + ix86_varargs_fpr_size;
    6200                 :            : 
    6201                 :            :   /* Also adjust stack_realign_offset for the largest alignment of
    6202                 :            :      stack slot actually used.  */
    6203                 :    6013810 :   if (stack_realign_fp
    6204                 :    5770270 :       || (cfun->machine->max_used_stack_alignment != 0
    6205                 :         86 :           && (offset % cfun->machine->max_used_stack_alignment) != 0))
    6206                 :            :     {
    6207                 :            :       /* We may need a 16-byte aligned stack for the remainder of the
    6208                 :            :          register save area, but the stack frame for the local function
    6209                 :            :          may require a greater alignment if using AVX/2/512.  In order
    6210                 :            :          to avoid wasting space, we first calculate the space needed for
    6211                 :            :          the rest of the register saves, add that to the stack pointer,
    6212                 :            :          and then realign the stack to the boundary of the start of the
    6213                 :            :          frame for the local function.  */
    6214                 :     243556 :       HOST_WIDE_INT space_needed = 0;
    6215                 :     243556 :       HOST_WIDE_INT sse_reg_space_needed = 0;
    6216                 :            : 
    6217                 :     243556 :       if (TARGET_64BIT)
    6218                 :            :         {
    6219                 :     241810 :           if (m->call_ms2sysv)
    6220                 :            :             {
    6221                 :       7692 :               m->call_ms2sysv_pad_in = 0;
    6222                 :       7692 :               space_needed = xlogue_layout::get_instance ().get_stack_space_used ();
    6223                 :            :             }
    6224                 :            : 
    6225                 :     234118 :           else if (frame->nsseregs)
    6226                 :            :             /* The only ABI that has saved SSE registers (Win64) also has a
    6227                 :            :                16-byte aligned default stack.  However, many programs violate
    6228                 :            :                the ABI, and Wine64 forces stack realignment to compensate.  */
    6229                 :       7715 :             space_needed = frame->nsseregs * 16;
    6230                 :            : 
    6231                 :     241810 :           sse_reg_space_needed = space_needed = ROUND_UP (space_needed, 16);
    6232                 :            : 
    6233                 :            :           /* 64-bit frame->va_arg_size should always be a multiple of 16, but
    6234                 :            :              rounding to be pedantic.  */
    6235                 :     241810 :           space_needed = ROUND_UP (space_needed + frame->va_arg_size, 16);
    6236                 :            :         }
    6237                 :            :       else
    6238                 :       1746 :         space_needed = frame->va_arg_size;
    6239                 :            : 
    6240                 :            :       /* Record the allocation size required prior to the realignment AND.  */
    6241                 :     243556 :       frame->stack_realign_allocate = space_needed;
    6242                 :            : 
    6243                 :            :       /* The re-aligned stack starts at frame->stack_realign_offset.  Values
    6244                 :            :          before this point are not directly comparable with values below
    6245                 :            :          this point.  Use sp_valid_at to determine if the stack pointer is
    6246                 :            :          valid for a given offset, fp_valid_at for the frame pointer, or
    6247                 :            :          choose_baseaddr to have a base register chosen for you.
    6248                 :            : 
    6249                 :            :          Note that the result of (frame->stack_realign_offset
    6250                 :            :          & (stack_alignment_needed - 1)) may not equal zero.  */
    6251                 :     243556 :       offset = ROUND_UP (offset + space_needed, stack_alignment_needed);
    6252                 :     243556 :       frame->stack_realign_offset = offset - space_needed;
    6253                 :     243556 :       frame->sse_reg_save_offset = frame->stack_realign_offset
    6254                 :     243556 :                                                         + sse_reg_space_needed;
    6255                 :            :     }
    6256                 :            :   else
    6257                 :            :     {
    6258                 :    5770260 :       frame->stack_realign_offset = offset;
    6259                 :            : 
    6260                 :    5770260 :       if (TARGET_64BIT && m->call_ms2sysv)
    6261                 :            :         {
    6262                 :      34578 :           m->call_ms2sysv_pad_in = !!(offset & UNITS_PER_WORD);
    6263                 :      34578 :           offset += xlogue_layout::get_instance ().get_stack_space_used ();
    6264                 :            :         }
    6265                 :            : 
    6266                 :            :       /* Align and set SSE register save area.  */
    6267                 :    5735680 :       else if (frame->nsseregs)
    6268                 :            :         {
    6269                 :            :           /* If the incoming stack boundary is at least 16 bytes, or DRAP is
    6270                 :            :              required and the DRAP re-alignment boundary is at least 16 bytes,
    6271                 :            :              then we want the SSE register save area properly aligned.  */
    6272                 :      34632 :           if (ix86_incoming_stack_boundary >= 128
    6273                 :       7680 :                   || (stack_realign_drap && stack_alignment_needed >= 16))
    6274                 :      34632 :             offset = ROUND_UP (offset, 16);
    6275                 :      34632 :           offset += frame->nsseregs * 16;
    6276                 :            :         }
    6277                 :    5770260 :       frame->sse_reg_save_offset = offset;
    6278                 :    5770260 :       offset += frame->va_arg_size;
    6279                 :            :     }
    6280                 :            : 
    6281                 :            :   /* Align start of frame for local function.  When a function call
    6282                 :            :      is removed, it may become a leaf function.  But if argument may
    6283                 :            :      be passed on stack, we need to align the stack when there is no
    6284                 :            :      tail call.  */
    6285                 :    6013810 :   if (m->call_ms2sysv
    6286                 :    5971540 :       || frame->va_arg_size != 0
    6287                 :    5909770 :       || size != 0
    6288                 :    3279370 :       || !crtl->is_leaf
    6289                 :    1605980 :       || (!crtl->tail_call_emit
    6290                 :    1312180 :           && cfun->machine->outgoing_args_on_stack)
    6291                 :    1605890 :       || cfun->calls_alloca
    6292                 :    7619340 :       || ix86_current_function_calls_tls_descriptor)
    6293                 :    4408800 :     offset = ROUND_UP (offset, stack_alignment_needed);
    6294                 :            : 
    6295                 :            :   /* Frame pointer points here.  */
    6296                 :    6013810 :   frame->frame_pointer_offset = offset;
    6297                 :            : 
    6298                 :    6013810 :   offset += size;
    6299                 :            : 
    6300                 :            :   /* Add outgoing arguments area.  Can be skipped if we eliminated
    6301                 :            :      all the function calls as dead code.
    6302                 :            :      Skipping is however impossible when function calls alloca.  Alloca
    6303                 :            :      expander assumes that last crtl->outgoing_args_size
    6304                 :            :      of stack frame are unused.  */
    6305                 :    6013810 :   if (ACCUMULATE_OUTGOING_ARGS
    6306                 :    6440510 :       && (!crtl->is_leaf || cfun->calls_alloca
    6307                 :     340970 :           || ix86_current_function_calls_tls_descriptor))
    6308                 :            :     {
    6309                 :      85725 :       offset += crtl->outgoing_args_size;
    6310                 :      85725 :       frame->outgoing_arguments_size = crtl->outgoing_args_size;
    6311                 :            :     }
    6312                 :            :   else
    6313                 :    5928090 :     frame->outgoing_arguments_size = 0;
    6314                 :            : 
    6315                 :            :   /* Align stack boundary.  Only needed if we're calling another function
    6316                 :            :      or using alloca.  */
    6317                 :    2170750 :   if (!crtl->is_leaf || cfun->calls_alloca
    6318                 :    8182760 :       || ix86_current_function_calls_tls_descriptor)
    6319                 :    3846940 :     offset = ROUND_UP (offset, preferred_alignment);
    6320                 :            : 
    6321                 :            :   /* We've reached end of stack frame.  */
    6322                 :    6013810 :   frame->stack_pointer_offset = offset;
    6323                 :            : 
    6324                 :            :   /* Size prologue needs to allocate.  */
    6325                 :    6013810 :   to_allocate = offset - frame->sse_reg_save_offset;
    6326                 :            : 
    6327                 :    2129330 :   if ((!to_allocate && frame->nregs <= 1)
    6328                 :    4020520 :       || (TARGET_64BIT && to_allocate >= HOST_WIDE_INT_C (0x80000000))
    6329                 :            :       /* If stack clash probing needs a loop, then it needs a
    6330                 :            :          scratch register.  But the returned register is only guaranteed
    6331                 :            :          to be safe to use after register saves are complete.  So if
    6332                 :            :          stack clash protections are enabled and the allocated frame is
    6333                 :            :          larger than the probe interval, then use pushes to save
    6334                 :            :          callee saved registers.  */
    6335                 :   10033900 :       || (flag_stack_clash_protection && to_allocate > get_probe_interval ()))
    6336                 :    1993870 :     frame->save_regs_using_mov = false;
    6337                 :            : 
    6338                 :    6013810 :   if (ix86_using_red_zone ()
    6339                 :    5241720 :       && crtl->sp_is_unchanging
    6340                 :    4835040 :       && crtl->is_leaf
    6341                 :    2074980 :       && !ix86_pc_thunk_call_expanded
    6342                 :    8088800 :       && !ix86_current_function_calls_tls_descriptor)
    6343                 :            :     {
    6344                 :    2074980 :       frame->red_zone_size = to_allocate;
    6345                 :    2074980 :       if (frame->save_regs_using_mov)
    6346                 :     119383 :         frame->red_zone_size += frame->nregs * UNITS_PER_WORD;
    6347                 :    2074980 :       if (frame->red_zone_size > RED_ZONE_SIZE - RED_ZONE_RESERVE)
    6348                 :      80686 :         frame->red_zone_size = RED_ZONE_SIZE - RED_ZONE_RESERVE;
    6349                 :            :     }
    6350                 :            :   else
    6351                 :    3938830 :     frame->red_zone_size = 0;
    6352                 :    6013810 :   frame->stack_pointer_offset -= frame->red_zone_size;
    6353                 :            : 
    6354                 :            :   /* The SEH frame pointer location is near the bottom of the frame.
    6355                 :            :      This is enforced by the fact that the difference between the
    6356                 :            :      stack pointer and the frame pointer is limited to 240 bytes in
    6357                 :            :      the unwind data structure.  */
    6358                 :    6013810 :   if (TARGET_SEH)
    6359                 :            :     {
    6360                 :            :       HOST_WIDE_INT diff;
    6361                 :            : 
    6362                 :            :       /* If we can leave the frame pointer where it is, do so.  Also, returns
    6363                 :            :          the establisher frame for __builtin_frame_address (0).  */
    6364                 :            :       diff = frame->stack_pointer_offset - frame->hard_frame_pointer_offset;
    6365                 :            :       if (diff <= SEH_MAX_FRAME_SIZE
    6366                 :            :           && (diff > 240 || (diff & 15) != 0)
    6367                 :            :           && !crtl->accesses_prior_frames)
    6368                 :            :         {
    6369                 :            :           /* Ideally we'd determine what portion of the local stack frame
    6370                 :            :              (within the constraint of the lowest 240) is most heavily used.
    6371                 :            :              But without that complication, simply bias the frame pointer
    6372                 :            :              by 128 bytes so as to maximize the amount of the local stack
    6373                 :            :              frame that is addressable with 8-bit offsets.  */
    6374                 :            :           frame->hard_frame_pointer_offset = frame->stack_pointer_offset - 128;
    6375                 :            :         }
    6376                 :            :     }
    6377                 :    6013810 : }
    6378                 :            : 
    6379                 :            : /* This is semi-inlined memory_address_length, but simplified
    6380                 :            :    since we know that we're always dealing with reg+offset, and
    6381                 :            :    to avoid having to create and discard all that rtl.  */
    6382                 :            : 
    6383                 :            : static inline int
    6384                 :      88289 : choose_baseaddr_len (unsigned int regno, HOST_WIDE_INT offset)
    6385                 :            : {
    6386                 :      88289 :   int len = 4;
    6387                 :            : 
    6388                 :          0 :   if (offset == 0)
    6389                 :            :     {
    6390                 :            :       /* EBP and R13 cannot be encoded without an offset.  */
    6391                 :          0 :       len = (regno == BP_REG || regno == R13_REG);
    6392                 :            :     }
    6393                 :      87498 :   else if (IN_RANGE (offset, -128, 127))
    6394                 :      50798 :     len = 1;
    6395                 :            : 
    6396                 :            :   /* ESP and R12 must be encoded with a SIB byte.  */
    6397                 :          0 :   if (regno == SP_REG || regno == R12_REG)
    6398                 :          0 :     len++;
    6399                 :            : 
    6400                 :      88289 :   return len;
    6401                 :            : }
    6402                 :            : 
    6403                 :            : /* Determine if the stack pointer is valid for accessing the CFA_OFFSET in
    6404                 :            :    the frame save area.  The register is saved at CFA - CFA_OFFSET.  */
    6405                 :            : 
    6406                 :            : static bool
    6407                 :    1506360 : sp_valid_at (HOST_WIDE_INT cfa_offset)
    6408                 :            : {
    6409                 :    1506360 :   const struct machine_frame_state &fs = cfun->machine->fs;
    6410                 :    1506360 :   if (fs.sp_realigned && cfa_offset <= fs.sp_realigned_offset)
    6411                 :            :     {
    6412                 :            :       /* Validate that the cfa_offset isn't in a "no-man's land".  */
    6413                 :      32912 :       gcc_assert (cfa_offset <= fs.sp_realigned_fp_last);
    6414                 :            :       return false;
    6415                 :            :     }
    6416                 :    1473440 :   return fs.sp_valid;
    6417                 :            : }
    6418                 :            : 
    6419                 :            : /* Determine if the frame pointer is valid for accessing the CFA_OFFSET in
    6420                 :            :    the frame save area.  The register is saved at CFA - CFA_OFFSET.  */
    6421                 :            : 
    6422                 :            : static inline bool
    6423                 :     188166 : fp_valid_at (HOST_WIDE_INT cfa_offset)
    6424                 :            : {
    6425                 :     188166 :   const struct machine_frame_state &fs = cfun->machine->fs;
    6426                 :     188166 :   if (fs.sp_realigned && cfa_offset > fs.sp_realigned_fp_last)
    6427                 :            :     {
    6428                 :            :       /* Validate that the cfa_offset isn't in a "no-man's land".  */
    6429                 :      28266 :       gcc_assert (cfa_offset >= fs.sp_realigned_offset);
    6430                 :            :       return false;
    6431                 :            :     }
    6432                 :     159900 :   return fs.fp_valid;
    6433                 :            : }
    6434                 :            : 
    6435                 :            : /* Choose a base register based upon alignment requested, speed and/or
    6436                 :            :    size.  */
    6437                 :            : 
    6438                 :            : static void
    6439                 :     188166 : choose_basereg (HOST_WIDE_INT cfa_offset, rtx &base_reg,
    6440                 :            :                 HOST_WIDE_INT &base_offset,
    6441                 :            :                 unsigned int align_reqested, unsigned int *align)
    6442                 :            : {
    6443                 :     188166 :   const struct machine_function *m = cfun->machine;
    6444                 :     188166 :   unsigned int hfp_align;
    6445                 :     188166 :   unsigned int drap_align;
    6446                 :     188166 :   unsigned int sp_align;
    6447                 :     188166 :   bool hfp_ok  = fp_valid_at (cfa_offset);
    6448                 :     188166 :   bool drap_ok = m->fs.drap_valid;
    6449                 :     188166 :   bool sp_ok   = sp_valid_at (cfa_offset);
    6450                 :            : 
    6451                 :     188166 :   hfp_align = drap_align = sp_align = INCOMING_STACK_BOUNDARY;
    6452                 :            : 
    6453                 :            :   /* Filter out any registers that don't meet the requested alignment
    6454                 :            :      criteria.  */
    6455                 :     188166 :   if (align_reqested)
    6456                 :            :     {
    6457                 :     161623 :       if (m->fs.realigned)
    6458                 :      28160 :         hfp_align = drap_align = sp_align = crtl->stack_alignment_needed;
    6459                 :            :       /* SEH unwind code does do not currently support REG_CFA_EXPRESSION
    6460                 :            :          notes (which we would need to use a realigned stack pointer),
    6461                 :            :          so disable on SEH targets.  */
    6462                 :     133463 :       else if (m->fs.sp_realigned)
    6463                 :      28266 :         sp_align = crtl->stack_alignment_needed;
    6464                 :            : 
    6465                 :     161623 :       hfp_ok = hfp_ok && hfp_align >= align_reqested;
    6466                 :     161623 :       drap_ok = drap_ok && drap_align >= align_reqested;
    6467                 :     161623 :       sp_ok = sp_ok && sp_align >= align_reqested;
    6468                 :            :     }
    6469                 :            : 
    6470                 :     188166 :   if (m->use_fast_prologue_epilogue)
    6471                 :            :     {
    6472                 :            :       /* Choose the base register most likely to allow the most scheduling
    6473                 :            :          opportunities.  Generally FP is valid throughout the function,
    6474                 :            :          while DRAP must be reloaded within the epilogue.  But choose either
    6475                 :            :          over the SP due to increased encoding size.  */
    6476                 :            : 
    6477                 :     128237 :       if (hfp_ok)
    6478                 :            :         {
    6479                 :      82017 :           base_reg = hard_frame_pointer_rtx;
    6480                 :      82017 :           base_offset = m->fs.fp_offset - cfa_offset;
    6481                 :            :         }
    6482                 :      46220 :       else if (drap_ok)
    6483                 :            :         {
    6484                 :          0 :           base_reg = crtl->drap_reg;
    6485                 :          0 :           base_offset = 0 - cfa_offset;
    6486                 :            :         }
    6487                 :      46220 :       else if (sp_ok)
    6488                 :            :         {
    6489                 :      46220 :           base_reg = stack_pointer_rtx;
    6490                 :      46220 :           base_offset = m->fs.sp_offset - cfa_offset;
    6491                 :            :         }
    6492                 :            :     }
    6493                 :            :   else
    6494                 :            :     {
    6495                 :      59929 :       HOST_WIDE_INT toffset;
    6496                 :      59929 :       int len = 16, tlen;
    6497                 :            : 
    6498                 :            :       /* Choose the base register with the smallest address encoding.
    6499                 :            :          With a tie, choose FP > DRAP > SP.  */
    6500                 :      59929 :       if (sp_ok)
    6501                 :            :         {
    6502                 :      42998 :           base_reg = stack_pointer_rtx;
    6503                 :      42998 :           base_offset = m->fs.sp_offset - cfa_offset;
    6504                 :      85205 :           len = choose_baseaddr_len (STACK_POINTER_REGNUM, base_offset);
    6505                 :            :         }
    6506                 :      59929 :       if (drap_ok)
    6507                 :            :         {
    6508                 :          0 :           toffset = 0 - cfa_offset;
    6509                 :          0 :           tlen = choose_baseaddr_len (REGNO (crtl->drap_reg), toffset);
    6510                 :          0 :           if (tlen <= len)
    6511                 :            :             {
    6512                 :          0 :               base_reg = crtl->drap_reg;
    6513                 :          0 :               base_offset = toffset;
    6514                 :          0 :               len = tlen;
    6515                 :            :             }
    6516                 :            :         }
    6517                 :      59929 :       if (hfp_ok)
    6518                 :            :         {
    6519                 :      45291 :           toffset = m->fs.fp_offset - cfa_offset;
    6520                 :      45291 :           tlen = choose_baseaddr_len (HARD_FRAME_POINTER_REGNUM, toffset);
    6521                 :      45291 :           if (tlen <= len)
    6522                 :            :             {
    6523                 :      33249 :               base_reg = hard_frame_pointer_rtx;
    6524                 :      33249 :               base_offset = toffset;
    6525                 :            :             }
    6526                 :            :         }
    6527                 :            :     }
    6528                 :            : 
    6529                 :            :     /* Set the align return value.  */
    6530                 :     188166 :     if (align)
    6531                 :            :       {
    6532                 :     161623 :         if (base_reg == stack_pointer_rtx)
    6533                 :      72868 :           *align = sp_align;
    6534                 :      88755 :         else if (base_reg == crtl->drap_reg)
    6535                 :          0 :           *align = drap_align;
    6536                 :      88755 :         else if (base_reg == hard_frame_pointer_rtx)
    6537                 :      88755 :           *align = hfp_align;
    6538                 :            :       }
    6539                 :     188166 : }
    6540                 :            : 
    6541                 :            : /* Return an RTX that points to CFA_OFFSET within the stack frame and
    6542                 :            :    the alignment of address.  If ALIGN is non-null, it should point to
    6543                 :            :    an alignment value (in bits) that is preferred or zero and will
    6544                 :            :    recieve the alignment of the base register that was selected,
    6545                 :            :    irrespective of rather or not CFA_OFFSET is a multiple of that
    6546                 :            :    alignment value.  If it is possible for the base register offset to be
    6547                 :            :    non-immediate then SCRATCH_REGNO should specify a scratch register to
    6548                 :            :    use.
    6549                 :            : 
    6550                 :            :    The valid base registers are taken from CFUN->MACHINE->FS.  */
    6551                 :            : 
    6552                 :            : static rtx
    6553                 :     188166 : choose_baseaddr (HOST_WIDE_INT cfa_offset, unsigned int *align,
    6554                 :            :                  unsigned int scratch_regno = INVALID_REGNUM)
    6555                 :            : {
    6556                 :     188166 :   rtx base_reg = NULL;
    6557                 :     188166 :   HOST_WIDE_INT base_offset = 0;
    6558                 :            : 
    6559                 :            :   /* If a specific alignment is requested, try to get a base register
    6560                 :            :      with that alignment first.  */
    6561                 :     188166 :   if (align && *align)
    6562                 :     161623 :     choose_basereg (cfa_offset, base_reg, base_offset, *align, align);
    6563                 :            : 
    6564                 :     188166 :   if (!base_reg)
    6565                 :      26543 :     choose_basereg (cfa_offset, base_reg, base_offset, 0, align);
    6566                 :            : 
    6567                 :     188166 :   gcc_assert (base_reg != NULL);
    6568                 :            : 
    6569                 :     188166 :   rtx base_offset_rtx = GEN_INT (base_offset);
    6570                 :            : 
    6571                 :     189667 :   if (!x86_64_immediate_operand (base_offset_rtx, Pmode))
    6572                 :            :     {
    6573                 :          0 :       gcc_assert (scratch_regno != INVALID_REGNUM);
    6574                 :            : 
    6575                 :          0 :       rtx scratch_reg = gen_rtx_REG (Pmode, scratch_regno);
    6576                 :          0 :       emit_move_insn (scratch_reg, base_offset_rtx);
    6577                 :            : 
    6578                 :          0 :       return gen_rtx_PLUS (Pmode, base_reg, scratch_reg);
    6579                 :            :     }
    6580                 :            : 
    6581                 :     189667 :   return plus_constant (Pmode, base_reg, base_offset);
    6582                 :            : }
    6583                 :            : 
    6584                 :            : /* Emit code to save registers in the prologue.  */
    6585                 :            : 
    6586                 :            : static void
    6587                 :     287226 : ix86_emit_save_regs (void)
    6588                 :            : {
    6589                 :     287226 :   unsigned int regno;
    6590                 :     287226 :   rtx_insn *insn;
    6591                 :            : 
    6592                 :   21829200 :   for (regno = FIRST_PSEUDO_REGISTER - 1; regno-- > 0; )
    6593                 :   21542000 :     if (GENERAL_REGNO_P (regno) && ix86_save_reg (regno, true, true))
    6594                 :            :       {
    6595                 :     871630 :         insn = emit_insn (gen_push (gen_rtx_REG (word_mode, regno)));
    6596                 :     871630 :         RTX_FRAME_RELATED_P (insn) = 1;
    6597                 :            :       }
    6598                 :     287226 : }
    6599                 :            : 
    6600                 :            : /* Emit a single register save at CFA - CFA_OFFSET.  */
    6601                 :            : 
    6602                 :            : static void
    6603                 :      70626 : ix86_emit_save_reg_using_mov (machine_mode mode, unsigned int regno,
    6604                 :            :                               HOST_WIDE_INT cfa_offset)
    6605                 :            : {
    6606                 :      70626 :   struct machine_function *m = cfun->machine;
    6607                 :      70626 :   rtx reg = gen_rtx_REG (mode, regno);
    6608                 :      70626 :   rtx mem, addr, base, insn;
    6609                 :      70626 :   unsigned int align = GET_MODE_ALIGNMENT (mode);
    6610                 :            : 
    6611                 :      70626 :   addr = choose_baseaddr (cfa_offset, &align);
    6612                 :      70626 :   mem = gen_frame_mem (mode, addr);
    6613                 :            : 
    6614                 :            :   /* The location aligment depends upon the base register.  */
    6615                 :      70626 :   align = MIN (GET_MODE_ALIGNMENT (mode), align);
    6616                 :      70626 :   gcc_assert (! (cfa_offset & (align / BITS_PER_UNIT - 1)));
    6617                 :      70626 :   set_mem_align (mem, align);
    6618                 :            : 
    6619                 :      70626 :   insn = emit_insn (gen_rtx_SET (mem, reg));
    6620                 :      70626 :   RTX_FRAME_RELATED_P (insn) = 1;
    6621                 :            : 
    6622                 :      70626 :   base = addr;
    6623                 :      70626 :   if (GET_CODE (base) == PLUS)
    6624                 :      69269 :     base = XEXP (base, 0);
    6625                 :      70626 :   gcc_checking_assert (REG_P (base));
    6626                 :            : 
    6627                 :            :   /* When saving registers into a re-aligned local stack frame, avoid
    6628                 :            :      any tricky guessing by dwarf2out.  */
    6629                 :      70626 :   if (m->fs.realigned)
    6630                 :            :     {
    6631                 :      12800 :       gcc_checking_assert (stack_realign_drap);
    6632                 :            : 
    6633                 :      12800 :       if (regno == REGNO (crtl->drap_reg))
    6634                 :            :         {
    6635                 :            :           /* A bit of a hack.  We force the DRAP register to be saved in
    6636                 :            :              the re-aligned stack frame, which provides us with a copy
    6637                 :            :              of the CFA that will last past the prologue.  Install it.  */
    6638                 :          0 :           gcc_checking_assert (cfun->machine->fs.fp_valid);
    6639                 :          0 :           addr = plus_constant (Pmode, hard_frame_pointer_rtx,
    6640                 :          0 :                                 cfun->machine->fs.fp_offset - cfa_offset);
    6641                 :          0 :           mem = gen_rtx_MEM (mode, addr);
    6642                 :          0 :           add_reg_note (insn, REG_CFA_DEF_CFA, mem);
    6643                 :            :         }
    6644                 :            :       else
    6645                 :            :         {
    6646                 :            :           /* The frame pointer is a stable reference within the
    6647                 :            :              aligned frame.  Use it.  */
    6648                 :      12800 :           gcc_checking_assert (cfun->machine->fs.fp_valid);
    6649                 :      12800 :           addr = plus_constant (Pmode, hard_frame_pointer_rtx,
    6650                 :      12800 :                                 cfun->machine->fs.fp_offset - cfa_offset);
    6651                 :      12800 :           mem = gen_rtx_MEM (mode, addr);
    6652                 :      12800 :           add_reg_note (insn, REG_CFA_EXPRESSION, gen_rtx_SET (mem, reg));
    6653                 :            :         }
    6654                 :            :     }
    6655                 :            : 
    6656                 :      57826 :   else if (base == stack_pointer_rtx && m->fs.sp_realigned
    6657                 :      12851 :            && cfa_offset >= m->fs.sp_realigned_offset)
    6658                 :            :     {
    6659                 :      12851 :       gcc_checking_assert (stack_realign_fp);
    6660                 :      12851 :       add_reg_note (insn, REG_CFA_EXPRESSION, gen_rtx_SET (mem, reg));
    6661                 :            :     }
    6662                 :            : 
    6663                 :            :   /* The memory may not be relative to the current CFA register,
    6664                 :            :      which means that we may need to generate a new pattern for
    6665                 :            :      use by the unwind info.  */
    6666                 :      44975 :   else if (base != m->fs.cfa_reg)
    6667                 :            :     {
    6668                 :       5771 :       addr = plus_constant (Pmode, m->fs.cfa_reg,
    6669                 :       5771 :                             m->fs.cfa_offset - cfa_offset);
    6670                 :       5771 :       mem = gen_rtx_MEM (mode, addr);
    6671                 :       5771 :       add_reg_note (insn, REG_CFA_OFFSET, gen_rtx_SET (mem, reg));
    6672                 :            :     }
    6673                 :      70626 : }
    6674                 :            : 
    6675                 :            : /* Emit code to save registers using MOV insns.
    6676                 :            :    First register is stored at CFA - CFA_OFFSET.  */
    6677                 :            : static void
    6678                 :         30 : ix86_emit_save_regs_using_mov (HOST_WIDE_INT cfa_offset)
    6679                 :            : {
    6680                 :         30 :   unsigned int regno;
    6681                 :            : 
    6682                 :       2310 :   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
    6683                 :       2280 :     if (GENERAL_REGNO_P (regno) && ix86_save_reg (regno, true, true))
    6684                 :            :       {
    6685                 :         55 :         ix86_emit_save_reg_using_mov (word_mode, regno, cfa_offset);
    6686                 :         55 :         cfa_offset -= UNITS_PER_WORD;
    6687                 :            :       }
    6688                 :         30 : }
    6689                 :            : 
    6690                 :            : /* Emit code to save SSE registers using MOV insns.
    6691                 :            :    First register is stored at CFA - CFA_OFFSET.  */
    6692                 :            : static void
    6693                 :       7058 : ix86_emit_save_sse_regs_using_mov (HOST_WIDE_INT cfa_offset)
    6694                 :            : {
    6695                 :       7058 :   unsigned int regno;
    6696                 :            : 
    6697                 :     543466 :   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
    6698                 :     536408 :     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, true, true))
    6699                 :            :       {
    6700                 :      70571 :         ix86_emit_save_reg_using_mov (V4SFmode, regno, cfa_offset);
    6701                 :      70571 :         cfa_offset -= GET_MODE_SIZE (V4SFmode);
    6702                 :            :       }
    6703                 :       7058 : }
    6704                 :            : 
    6705                 :            : static GTY(()) rtx queued_cfa_restores;
    6706                 :            : 
    6707                 :            : /* Add a REG_CFA_RESTORE REG note to INSN or queue them until next stack
    6708                 :            :    manipulation insn.  The value is on the stack at CFA - CFA_OFFSET.
    6709                 :            :    Don't add the note if the previously saved value will be left untouched
    6710                 :            :    within stack red-zone till return, as unwinders can find the same value
    6711                 :            :    in the register and on the stack.  */
    6712                 :            : 
    6713                 :            : static void
    6714                 :    1419970 : ix86_add_cfa_restore_note (rtx_insn *insn, rtx reg, HOST_WIDE_INT cfa_offset)
    6715                 :            : {
    6716                 :    1419970 :   if (!crtl->shrink_wrapped
    6717                 :    1409080 :       && cfa_offset <= cfun->machine->fs.red_zone_offset)
    6718                 :            :     return;
    6719                 :            : 
    6720                 :     397959 :   if (insn)
    6721                 :            :     {
    6722                 :     264817 :       add_reg_note (insn, REG_CFA_RESTORE, reg);
    6723                 :     264817 :       RTX_FRAME_RELATED_P (insn) = 1;
    6724                 :            :     }
    6725                 :            :   else
    6726                 :     133142 :     queued_cfa_restores
    6727                 :     133142 :       = alloc_reg_note (REG_CFA_RESTORE, reg, queued_cfa_restores);
    6728                 :            : }
    6729                 :            : 
    6730                 :            : /* Add queued REG_CFA_RESTORE notes if any to INSN.  */
    6731                 :            : 
    6732                 :            : static void
    6733                 :    1592050 : ix86_add_queued_cfa_restore_notes (rtx insn)
    6734                 :            : {
    6735                 :    1592050 :   rtx last;
    6736                 :    1592050 :   if (!queued_cfa_restores)
    6737                 :            :     return;
    6738                 :     133142 :   for (last = queued_cfa_restores; XEXP (last, 1); last = XEXP (last, 1))
    6739                 :            :     ;
    6740                 :      18102 :   XEXP (last, 1) = REG_NOTES (insn);
    6741                 :      18102 :   REG_NOTES (insn) = queued_cfa_restores;
    6742                 :      18102 :   queued_cfa_restores = NULL_RTX;
    6743                 :      18102 :   RTX_FRAME_RELATED_P (insn) = 1;
    6744                 :            : }
    6745                 :            : 
    6746                 :            : /* Expand prologue or epilogue stack adjustment.
    6747                 :            :    The pattern exist to put a dependency on all ebp-based memory accesses.
    6748                 :            :    STYLE should be negative if instructions should be marked as frame related,
    6749                 :            :    zero if %r11 register is live and cannot be freely used and positive
    6750                 :            :    otherwise.  */
    6751                 :            : 
    6752                 :            : static rtx
    6753                 :     918591 : pro_epilogue_adjust_stack (rtx dest, rtx src, rtx offset,
    6754                 :            :                            int style, bool set_cfa)
    6755                 :            : {
    6756                 :     918591 :   struct machine_function *m = cfun->machine;
    6757                 :     918591 :   rtx addend = offset;
    6758                 :     918591 :   rtx insn;
    6759                 :     918591 :   bool add_frame_related_expr = false;
    6760                 :            : 
    6761                 :    1073450 :   if (!x86_64_immediate_operand (offset, Pmode))
    6762                 :            :     {
    6763                 :            :       /* r11 is used by indirect sibcall return as well, set before the
    6764                 :            :          epilogue and used after the epilogue.  */
    6765                 :        149 :       if (style)
    6766                 :        114 :         addend = gen_rtx_REG (Pmode, R11_REG);
    6767                 :            :       else
    6768                 :            :         {
    6769                 :         35 :           gcc_assert (src != hard_frame_pointer_rtx
    6770                 :            :                       && dest != hard_frame_pointer_rtx);
    6771                 :            :           addend = hard_frame_pointer_rtx;
    6772                 :            :         }
    6773                 :        149 :       emit_insn (gen_rtx_SET (addend, offset));
    6774                 :        149 :       if (style < 0)
    6775                 :         56 :         add_frame_related_expr = true;
    6776                 :            :     }
    6777                 :            : 
    6778                 :     918591 :   insn = emit_insn (gen_pro_epilogue_adjust_stack_add
    6779                 :    1073450 :                     (Pmode, dest, src, addend));
    6780                 :     918591 :   if (style >= 0)
    6781                 :     401751 :     ix86_add_queued_cfa_restore_notes (insn);
    6782                 :            : 
    6783                 :     918591 :   if (set_cfa)
    6784                 :            :     {
    6785                 :     706651 :       rtx r;
    6786                 :            : 
    6787                 :     706651 :       gcc_assert (m->fs.cfa_reg == src);
    6788                 :     706651 :       m->fs.cfa_offset += INTVAL (offset);
    6789                 :     706651 :       m->fs.cfa_reg = dest;
    6790                 :            : 
    6791                 :     844729 :       r = gen_rtx_PLUS (Pmode, src, offset);
    6792                 :     706651 :       r = gen_rtx_SET (dest, r);
    6793                 :     706651 :       add_reg_note (insn, REG_CFA_ADJUST_CFA, r);
    6794                 :     706651 :       RTX_FRAME_RELATED_P (insn) = 1;
    6795                 :            :     }
    6796                 :     211940 :   else if (style < 0)
    6797                 :            :     {
    6798                 :     175914 :       RTX_FRAME_RELATED_P (insn) = 1;
    6799                 :     175914 :       if (add_frame_related_expr)
    6800                 :            :         {
    6801                 :         13 :           rtx r = gen_rtx_PLUS (Pmode, src, offset);
    6802                 :         13 :           r = gen_rtx_SET (dest, r);
    6803                 :         13 :           add_reg_note (insn, REG_FRAME_RELATED_EXPR, r);
    6804                 :            :         }
    6805                 :            :     }
    6806                 :            : 
    6807                 :     918591 :   if (dest == stack_pointer_rtx)
    6808                 :            :     {
    6809                 :     918591 :       HOST_WIDE_INT ooffset = m->fs.sp_offset;
    6810                 :     918591 :       bool valid = m->fs.sp_valid;
    6811                 :     918591 :       bool realigned = m->fs.sp_realigned;
    6812                 :            : 
    6813                 :     918591 :       if (src == hard_frame_pointer_rtx)
    6814                 :            :         {
    6815                 :      21417 :           valid = m->fs.fp_valid;
    6816                 :      21417 :           realigned = false;
    6817                 :      21417 :           ooffset = m->fs.fp_offset;
    6818                 :            :         }
    6819                 :     897174 :       else if (src == crtl->drap_reg)
    6820                 :            :         {
    6821                 :          0 :           valid = m->fs.drap_valid;
    6822                 :          0 :           realigned = false;
    6823                 :          0 :           ooffset = 0;
    6824                 :            :         }
    6825                 :            :       else
    6826                 :            :         {
    6827                 :            :           /* Else there are two possibilities: SP itself, which we set
    6828                 :            :              up as the default above.  Or EH_RETURN_STACKADJ_RTX, which is
    6829                 :            :              taken care of this by hand along the eh_return path.  */
    6830                 :     897174 :           gcc_checking_assert (src == stack_pointer_rtx
    6831                 :            :                                || offset == const0_rtx);
    6832                 :            :         }
    6833                 :            : 
    6834                 :     918591 :       m->fs.sp_offset = ooffset - INTVAL (offset);
    6835                 :     918591 :       m->fs.sp_valid = valid;
    6836                 :     918591 :       m->fs.sp_realigned = realigned;
    6837                 :            :     }
    6838                 :     918591 :   return insn;
    6839                 :            : }
    6840                 :            : 
    6841                 :            : /* Find an available register to be used as dynamic realign argument
    6842                 :            :    pointer regsiter.  Such a register will be written in prologue and
    6843                 :            :    used in begin of body, so it must not be
    6844                 :            :         1. parameter passing register.
    6845                 :            :         2. GOT pointer.
    6846                 :            :    We reuse static-chain register if it is available.  Otherwise, we
    6847                 :            :    use DI for i386 and R13 for x86-64.  We chose R13 since it has
    6848                 :            :    shorter encoding.
    6849                 :            : 
    6850                 :            :    Return: the regno of chosen register.  */
    6851                 :            : 
    6852                 :            : static unsigned int
    6853                 :       5617 : find_drap_reg (void)
    6854                 :            : {
    6855                 :       5617 :   tree decl = cfun->decl;
    6856                 :            : 
    6857                 :            :   /* Always use callee-saved register if there are no caller-saved
    6858                 :            :      registers.  */
    6859                 :       5617 :   if (TARGET_64BIT)
    6860                 :            :     {
    6861                 :            :       /* Use R13 for nested function or function need static chain.
    6862                 :            :          Since function with tail call may use any caller-saved
    6863                 :            :          registers in epilogue, DRAP must not use caller-saved
    6864                 :            :          register in such case.  */
    6865                 :       5356 :       if (DECL_STATIC_CHAIN (decl)
    6866                 :       5314 :           || cfun->machine->no_caller_saved_registers
    6867                 :      10670 :           || crtl->tail_call_emit)
    6868                 :        134 :         return R13_REG;
    6869                 :            : 
    6870                 :            :       return R10_REG;
    6871                 :            :     }
    6872                 :            :   else
    6873                 :            :     {
    6874                 :            :       /* Use DI for nested function or function need static chain.
    6875                 :            :          Since function with tail call may use any caller-saved
    6876                 :            :          registers in epilogue, DRAP must not use caller-saved
    6877                 :            :          register in such case.  */
    6878                 :        261 :       if (DECL_STATIC_CHAIN (decl)
    6879                 :        261 :           || cfun->machine->no_caller_saved_registers
    6880                 :        522 :           || crtl->tail_call_emit)
    6881                 :            :         return DI_REG;
    6882                 :            : 
    6883                 :            :       /* Reuse static chain register if it isn't used for parameter
    6884                 :            :          passing.  */
    6885                 :        237 :       if (ix86_function_regparm (TREE_TYPE (decl), decl) <= 2)
    6886                 :            :         {
    6887                 :        237 :           unsigned int ccvt = ix86_get_callcvt (TREE_TYPE (decl));
    6888                 :        237 :           if ((ccvt & (IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL)) == 0)
    6889                 :            :             return CX_REG;
    6890                 :            :         }
    6891                 :          0 :       return DI_REG;
    6892                 :            :     }
    6893                 :            : }
    6894                 :            : 
    6895                 :            : /* Return minimum incoming stack alignment.  */
    6896                 :            : 
    6897                 :            : static unsigned int
    6898                 :    1036790 : ix86_minimum_incoming_stack_boundary (bool sibcall)
    6899                 :            : {
    6900                 :    1036790 :   unsigned int incoming_stack_boundary;
    6901                 :            : 
    6902                 :            :   /* Stack of interrupt handler is aligned to 128 bits in 64bit mode.  */
    6903                 :    1036790 :   if (cfun->machine->func_type != TYPE_NORMAL)
    6904                 :         78 :     incoming_stack_boundary = TARGET_64BIT ? 128 : MIN_STACK_BOUNDARY;
    6905                 :            :   /* Prefer the one specified at command line. */
    6906                 :    1036710 :   else if (ix86_user_incoming_stack_boundary)
    6907                 :            :     incoming_stack_boundary = ix86_user_incoming_stack_boundary;
    6908                 :            :   /* In 32bit, use MIN_STACK_BOUNDARY for incoming stack boundary
    6909                 :            :      if -mstackrealign is used, it isn't used for sibcall check and
    6910                 :            :      estimated stack alignment is 128bit.  */
    6911                 :    1036690 :   else if (!sibcall
    6912                 :     943281 :            && ix86_force_align_arg_pointer
    6913                 :       4526 :            && crtl->stack_alignment_estimated == 128)
    6914                 :        203 :     incoming_stack_boundary = MIN_STACK_BOUNDARY;
    6915                 :            :   else
    6916                 :    1036490 :     incoming_stack_boundary = ix86_default_incoming_stack_boundary;
    6917                 :            : 
    6918                 :            :   /* Incoming stack alignment can be changed on individual functions
    6919                 :            :      via force_align_arg_pointer attribute.  We use the smallest
    6920                 :            :      incoming stack boundary.  */
    6921                 :    1036790 :   if (incoming_stack_boundary > MIN_STACK_BOUNDARY
    6922                 :    2073360 :       && lookup_attribute ("force_align_arg_pointer",
    6923                 :    1036580 :                            TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
    6924                 :       5511 :     incoming_stack_boundary = MIN_STACK_BOUNDARY;
    6925                 :            : 
    6926                 :            :   /* The incoming stack frame has to be aligned at least at
    6927                 :            :      parm_stack_boundary.  */
    6928                 :    1036790 :   if (incoming_stack_boundary < crtl->parm_stack_boundary)
    6929                 :            :     incoming_stack_boundary = crtl->parm_stack_boundary;
    6930                 :            : 
    6931                 :            :   /* Stack at entrance of main is aligned by runtime.  We use the
    6932                 :            :      smallest incoming stack boundary. */
    6933                 :    1036790 :   if (incoming_stack_boundary > MAIN_STACK_BOUNDARY
    6934                 :     107864 :       && DECL_NAME (current_function_decl)
    6935                 :     107864 :       && MAIN_NAME_P (DECL_NAME (current_function_decl))
    6936                 :    1039120 :       && DECL_FILE_SCOPE_P (current_function_decl))
    6937                 :            :     incoming_stack_boundary = MAIN_STACK_BOUNDARY;
    6938                 :            : 
    6939                 :    1036790 :   return incoming_stack_boundary;
    6940                 :            : }
    6941                 :            : 
    6942                 :            : /* Update incoming stack boundary and estimated stack alignment.  */
    6943                 :            : 
    6944                 :            : static void
    6945                 :     943374 : ix86_update_stack_boundary (void)
    6946                 :            : {
    6947                 :     943374 :   ix86_incoming_stack_boundary
    6948                 :     943374 :     = ix86_minimum_incoming_stack_boundary (false);
    6949                 :            : 
    6950                 :            :   /* x86_64 vararg needs 16byte stack alignment for register save area.  */
    6951                 :     943374 :   if (TARGET_64BIT
    6952                 :     848280 :       && cfun->stdarg
    6953                 :      15853 :       && crtl->stack_alignment_estimated < 128)
    6954                 :       8900 :     crtl->stack_alignment_estimated = 128;
    6955                 :            : 
    6956                 :            :   /* __tls_get_addr needs to be called with 16-byte aligned stack.  */
    6957                 :     943374 :   if (ix86_tls_descriptor_calls_expanded_in_cfun
    6958                 :     943374 :       && crtl->preferred_stack_boundary < 128)
    6959                 :        838 :     crtl->preferred_stack_boundary = 128;
    6960                 :     943374 : }
    6961                 :            : 
    6962                 :            : /* Handle the TARGET_GET_DRAP_RTX hook.  Return NULL if no DRAP is
    6963                 :            :    needed or an rtx for DRAP otherwise.  */
    6964                 :            : 
    6965                 :            : static rtx
    6966                 :    1006620 : ix86_get_drap_rtx (void)
    6967                 :            : {
    6968                 :            :   /* We must use DRAP if there are outgoing arguments on stack and
    6969                 :            :      ACCUMULATE_OUTGOING_ARGS is false.  */
    6970                 :    1006620 :   if (ix86_force_drap
    6971                 :    1006620 :       || (cfun->machine->outgoing_args_on_stack
    6972                 :    1004680 :           && !ACCUMULATE_OUTGOING_ARGS))
    6973                 :     188969 :     crtl->need_drap = true;
    6974                 :            : 
    6975                 :    1006620 :   if (stack_realign_drap)
    6976                 :            :     {
    6977                 :            :       /* Assign DRAP to vDRAP and returns vDRAP */
    6978                 :       5617 :       unsigned int regno = find_drap_reg ();
    6979                 :       5617 :       rtx drap_vreg;
    6980                 :       5617 :       rtx arg_ptr;
    6981                 :       5617 :       rtx_insn *seq, *insn;
    6982                 :            : 
    6983                 :       5878 :       arg_ptr = gen_rtx_REG (Pmode, regno);
    6984                 :       5617 :       crtl->drap_reg = arg_ptr;
    6985                 :            : 
    6986                 :       5617 :       start_sequence ();
    6987                 :       5617 :       drap_vreg = copy_to_reg (arg_ptr);
    6988                 :       5617 :       seq = get_insns ();
    6989                 :       5617 :       end_sequence ();
    6990                 :            : 
    6991                 :       5617 :       insn = emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
    6992                 :       5617 :       if (!optimize)
    6993                 :            :         {
    6994                 :       1768 :           add_reg_note (insn, REG_CFA_SET_VDRAP, drap_vreg);
    6995                 :       1768 :           RTX_FRAME_RELATED_P (insn) = 1;
    6996                 :            :         }
    6997                 :       5617 :       return drap_vreg;
    6998                 :            :     }
    6999                 :            :   else
    7000                 :            :     return NULL;
    7001                 :            : }
    7002                 :            : 
    7003                 :            : /* Handle the TARGET_INTERNAL_ARG_POINTER hook.  */
    7004                 :            : 
    7005                 :            : static rtx
    7006                 :     943374 : ix86_internal_arg_pointer (void)
    7007                 :            : {
    7008                 :     943374 :   return virtual_incoming_args_rtx;
    7009                 :            : }
    7010                 :            : 
    7011                 :            : struct scratch_reg {
    7012                 :            :   rtx reg;
    7013                 :            :   bool saved;
    7014                 :            : };
    7015                 :            : 
    7016                 :            : /* Return a short-lived scratch register for use on function entry.
    7017                 :            :    In 32-bit mode, it is valid only after the registers are saved
    7018                 :            :    in the prologue.  This register must be released by means of
    7019                 :            :    release_scratch_register_on_entry once it is dead.  */
    7020                 :            : 
    7021                 :            : static void
    7022                 :         18 : get_scratch_register_on_entry (struct scratch_reg *sr)
    7023                 :            : {
    7024                 :         18 :   int regno;
    7025                 :            : 
    7026                 :         18 :   sr->saved = false;
    7027                 :            : 
    7028                 :         18 :   if (TARGET_64BIT)
    7029                 :            :     {
    7030                 :            :       /* We always use R11 in 64-bit mode.  */
    7031                 :            :       regno = R11_REG;
    7032                 :            :     }
    7033                 :            :   else
    7034                 :            :     {
    7035                 :          0 :       tree decl = current_function_decl, fntype = TREE_TYPE (decl);
    7036                 :          0 :       bool fastcall_p
    7037                 :          0 :         = lookup_attribute ("fastcall", TYPE_ATTRIBUTES (fntype)) != NULL_TREE;
    7038                 :          0 :       bool thiscall_p
    7039                 :          0 :         = lookup_attribute ("thiscall", TYPE_ATTRIBUTES (fntype)) != NULL_TREE;
    7040                 :          0 :       bool static_chain_p = DECL_STATIC_CHAIN (decl);
    7041                 :          0 :       int regparm = ix86_function_regparm (fntype, decl);
    7042                 :          0 :       int drap_regno
    7043                 :          0 :         = crtl->drap_reg ? REGNO (crtl->drap_reg) : INVALID_REGNUM;
    7044                 :            : 
    7045                 :            :       /* 'fastcall' sets regparm to 2, uses ecx/edx for arguments and eax
    7046                 :            :           for the static chain register.  */
    7047                 :          0 :       if ((regparm < 1 || (fastcall_p && !static_chain_p))
    7048                 :          0 :           && drap_regno != AX_REG)
    7049                 :            :         regno = AX_REG;
    7050                 :            :       /* 'thiscall' sets regparm to 1, uses ecx for arguments and edx
    7051                 :            :           for the static chain register.  */
    7052                 :          0 :       else if (thiscall_p && !static_chain_p && drap_regno != AX_REG)
    7053                 :            :         regno = AX_REG;
    7054                 :          0 :       else if (regparm < 2 && !thiscall_p && drap_regno != DX_REG)
    7055                 :            :         regno = DX_REG;
    7056                 :            :       /* ecx is the static chain register.  */
    7057                 :          0 :       else if (regparm < 3 && !fastcall_p && !thiscall_p
    7058                 :          0 :                && !static_chain_p
    7059                 :          0 :                && drap_regno != CX_REG)
    7060                 :            :         regno = CX_REG;
    7061                 :          0 :       else if (ix86_save_reg (BX_REG, true, false))
    7062                 :            :         regno = BX_REG;
    7063                 :            :       /* esi is the static chain register.  */
    7064                 :          0 :       else if (!(regparm == 3 && static_chain_p)
    7065                 :          0 :                && ix86_save_reg (SI_REG, true, false))
    7066                 :            :         regno = SI_REG;
    7067                 :          0 :       else if (ix86_save_reg (DI_REG, true, false))
    7068                 :            :         regno = DI_REG;
    7069                 :            :       else
    7070                 :            :         {
    7071                 :          0 :           regno = (drap_regno == AX_REG ? DX_REG : AX_REG);
    7072                 :          0 :           sr->saved = true;
    7073                 :            :         }
    7074                 :            :     }
    7075                 :            : 
    7076                 :         18 :   sr->reg = gen_rtx_REG (Pmode, regno);
    7077                 :         18 :   if (sr->saved)
    7078                 :            :     {
    7079                 :          0 :       rtx_insn *insn = emit_insn (gen_push (sr->reg));
    7080                 :          0 :       RTX_FRAME_RELATED_P (insn) = 1;
    7081                 :            :     }
    7082                 :         18 : }
    7083                 :            : 
    7084                 :            : /* Release a scratch register obtained from the preceding function.
    7085                 :            : 
    7086                 :            :    If RELEASE_VIA_POP is true, we just pop the register off the stack
    7087                 :            :    to release it.  This is what non-Linux systems use with -fstack-check.
    7088                 :            : 
    7089                 :            :    Otherwise we use OFFSET to locate the saved register and the
    7090                 :            :    allocated stack space becomes part of the local frame and is
    7091                 :            :    deallocated by the epilogue.  */
    7092                 :            : 
    7093                 :            : static void
    7094                 :         18 : release_scratch_register_on_entry (struct scratch_reg *sr, HOST_WIDE_INT offset,
    7095                 :            :                                    bool release_via_pop)
    7096                 :            : {
    7097                 :         18 :   if (sr->saved)
    7098                 :            :     {
    7099                 :          0 :       if (release_via_pop)
    7100                 :            :         {
    7101                 :          0 :           struct machine_function *m = cfun->machine;
    7102                 :          0 :           rtx x, insn = emit_insn (gen_pop (sr->reg));
    7103                 :            : 
    7104                 :            :           /* The RX FRAME_RELATED_P mechanism doesn't know about pop.  */
    7105                 :          0 :           RTX_FRAME_RELATED_P (insn) = 1;
    7106                 :          0 :           x = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (UNITS_PER_WORD));
    7107                 :          0 :           x = gen_rtx_SET (stack_pointer_rtx, x);
    7108                 :          0 :           add_reg_note (insn, REG_FRAME_RELATED_EXPR, x);
    7109                 :          0 :           m->fs.sp_offset -= UNITS_PER_WORD;
    7110                 :            :         }
    7111                 :            :       else
    7112                 :            :         {
    7113                 :          0 :           rtx x = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (offset));
    7114                 :          0 :           x = gen_rtx_SET (sr->reg, gen_rtx_MEM (word_mode, x));
    7115                 :          0 :           emit_insn (x);
    7116                 :            :         }
    7117                 :            :     }
    7118                 :         18 : }
    7119                 :            : 
    7120                 :            : /* Emit code to adjust the stack pointer by SIZE bytes while probing it.
    7121                 :            : 
    7122                 :            :    This differs from the next routine in that it tries hard to prevent
    7123                 :            :    attacks that jump the stack guard.  Thus it is never allowed to allocate
    7124                 :            :    more than PROBE_INTERVAL bytes of stack space without a suitable
    7125                 :            :    probe.
    7126                 :            : 
    7127                 :            :    INT_REGISTERS_SAVED is true if integer registers have already been
    7128                 :            :    pushed on the stack.  */
    7129                 :            : 
    7130                 :            : static void
    7131                 :         63 : ix86_adjust_stack_and_probe_stack_clash (HOST_WIDE_INT size,
    7132                 :            :                                          const bool int_registers_saved)
    7133                 :            : {
    7134                 :         63 :   struct machine_function *m = cfun->machine;
    7135                 :            : 
    7136                 :            :   /* If this function does not statically allocate stack space, then
    7137                 :            :      no probes are needed.  */
    7138                 :         63 :   if (!size)
    7139                 :            :     {
    7140                 :            :       /* However, the allocation of space via pushes for register
    7141                 :            :          saves could be viewed as allocating space, but without the
    7142                 :            :          need to probe.  */
    7143                 :         21 :       if (m->frame.nregs || m->frame.nsseregs || frame_pointer_needed)
    7144                 :         13 :         dump_stack_clash_frame_info (NO_PROBE_SMALL_FRAME, true);
    7145                 :            :       else
    7146                 :          8 :         dump_stack_clash_frame_info (NO_PROBE_NO_FRAME, false);
    7147                 :         21 :       return;
    7148                 :            :     }
    7149                 :            : 
    7150                 :            :   /* If we are a noreturn function, then we have to consider the
    7151                 :            :      possibility that we're called via a jump rather than a call.
    7152                 :            : 
    7153                 :            :      Thus we don't have the implicit probe generated by saving the
    7154                 :            :      return address into the stack at the call.  Thus, the stack
    7155                 :            :      pointer could be anywhere in the guard page.  The safe thing
    7156                 :            :      to do is emit a probe now.
    7157                 :            : 
    7158                 :            :      The probe can be avoided if we have already emitted any callee
    7159                 :            :      register saves into the stack or have a frame pointer (which will
    7160                 :            :      have been saved as well).  Those saves will function as implicit
    7161                 :            :      probes.
    7162                 :            : 
    7163                 :            :      ?!? This should be revamped to work like aarch64 and s390 where
    7164                 :            :      we track the offset from the most recent probe.  Normally that
    7165                 :            :      offset would be zero.  For a noreturn function we would reset
    7166                 :            :      it to PROBE_INTERVAL - (STACK_BOUNDARY / BITS_PER_UNIT).   Then
    7167                 :            :      we just probe when we cross PROBE_INTERVAL.  */
    7168                 :         42 :   if (TREE_THIS_VOLATILE (cfun->decl)
    7169                 :         42 :       && !(m->frame.nregs || m->frame.nsseregs || frame_pointer_needed))
    7170                 :            :     {
    7171                 :            :       /* We can safely use any register here since we're just going to push
    7172                 :            :          its value and immediately pop it back.  But we do try and avoid
    7173                 :            :          argument passing registers so as not to introduce dependencies in
    7174                 :            :          the pipeline.  For 32 bit we use %esi and for 64 bit we use %rax.  */
    7175                 :          8 :       rtx dummy_reg = gen_rtx_REG (word_mode, TARGET_64BIT ? AX_REG : SI_REG);
    7176                 :          8 :       rtx_insn *insn_push = emit_insn (gen_push (dummy_reg));
    7177                 :          8 :       rtx_insn *insn_pop = emit_insn (gen_pop (dummy_reg));
    7178                 :          8 :       m->fs.sp_offset -= UNITS_PER_WORD;
    7179                 :          8 :       if (m->fs.cfa_reg == stack_pointer_rtx)
    7180                 :            :         {
    7181                 :          8 :           m->fs.cfa_offset -= UNITS_PER_WORD;
    7182                 :          8 :           rtx x = plus_constant (Pmode, stack_pointer_rtx, -UNITS_PER_WORD);
    7183                 :          8 :           x = gen_rtx_SET (stack_pointer_rtx, x);
    7184                 :          8 :           add_reg_note (insn_push, REG_CFA_ADJUST_CFA, x);
    7185                 :          8 :           RTX_FRAME_RELATED_P (insn_push) = 1;
    7186                 :          8 :           x = plus_constant (Pmode, stack_pointer_rtx, UNITS_PER_WORD);
    7187                 :          8 :           x = gen_rtx_SET (stack_pointer_rtx, x);
    7188                 :          8 :           add_reg_note (insn_pop, REG_CFA_ADJUST_CFA, x);
    7189                 :          8 :           RTX_FRAME_RELATED_P (insn_pop) = 1;
    7190                 :            :         }
    7191                 :          8 :       emit_insn (gen_blockage ());
    7192                 :            :     }
    7193                 :            : 
    7194                 :            :   /* If we allocate less than the size of the guard statically,
    7195                 :            :      then no probing is necessary, but we do need to allocate
    7196                 :            :      the stack.  */
    7197                 :         42 :   if (size < (1 << param_stack_clash_protection_guard_size))
    7198                 :            :     {
    7199                 :         28 :       pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
    7200                 :            :                                  GEN_INT (-size), -1,
    7201                 :         28 :                                  m->fs.cfa_reg == stack_pointer_rtx);
    7202                 :         28 :       dump_stack_clash_frame_info (NO_PROBE_SMALL_FRAME, true);
    7203                 :         28 :       return;
    7204                 :            :     }
    7205                 :            : 
    7206                 :            :   /* We're allocating a large enough stack frame that we need to
    7207                 :            :      emit probes.  Either emit them inline or in a loop depending
    7208                 :            :      on the size.  */
    7209                 :         14 :   HOST_WIDE_INT probe_interval = get_probe_interval ();
    7210                 :         14 :   if (size <= 4 * probe_interval)
    7211                 :            :     {
    7212                 :            :       HOST_WIDE_INT i;
    7213                 :         25 :       for (i = probe_interval; i <= size; i += probe_interval)
    7214                 :            :         {
    7215                 :            :           /* Allocate PROBE_INTERVAL bytes.  */
    7216                 :         16 :           rtx insn
    7217                 :         16 :             = pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
    7218                 :            :                                          GEN_INT (-probe_interval), -1,
    7219                 :         16 :                                          m->fs.cfa_reg == stack_pointer_rtx);
    7220                 :         16 :           add_reg_note (insn, REG_STACK_CHECK, const0_rtx);
    7221                 :            : 
    7222                 :            :           /* And probe at *sp.  */
    7223                 :         16 :           emit_stack_probe (stack_pointer_rtx);
    7224                 :         16 :           emit_insn (gen_blockage ());
    7225                 :            :         }
    7226                 :            : 
    7227                 :            :       /* We need to allocate space for the residual, but we do not need
    7228                 :            :          to probe the residual.  */
    7229                 :          9 :       HOST_WIDE_INT residual = (i - probe_interval - size);
    7230                 :          9 :       if (residual)
    7231                 :          9 :         pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
    7232                 :            :                                    GEN_INT (residual), -1,
    7233                 :          9 :                                    m->fs.cfa_reg == stack_pointer_rtx);
    7234                 :          9 :       dump_stack_clash_frame_info (PROBE_INLINE, residual != 0);
    7235                 :            :     }
    7236                 :            :   else
    7237                 :            :     {
    7238                 :            :       /* We expect the GP registers to be saved when probes are used
    7239                 :            :          as the probing sequences might need a scratch register and
    7240                 :            :          the routine to allocate one assumes the integer registers
    7241                 :            :          have already been saved.  */
    7242                 :          5 :       gcc_assert (int_registers_saved);
    7243                 :            : 
    7244                 :          5 :       struct scratch_reg sr;
    7245                 :          5 :       get_scratch_register_on_entry (&sr);
    7246                 :            : 
    7247                 :            :       /* If we needed to save a register, then account for any space
    7248                 :            :          that was pushed (we are not going to pop the register when
    7249                 :            :          we do the restore).  */
    7250                 :          5 :       if (sr.saved)
    7251                 :          0 :         size -= UNITS_PER_WORD;
    7252                 :            : 
    7253                 :            :       /* Step 1: round SIZE down to a multiple of the interval.  */
    7254                 :          5 :       HOST_WIDE_INT rounded_size = size & -probe_interval;
    7255                 :            : 
    7256                 :            :       /* Step 2: compute final value of the loop counter.  Use lea if
    7257                 :            :          possible.  */
    7258                 :          5 :       rtx addr = plus_constant (Pmode, stack_pointer_rtx, -rounded_size);
    7259                 :          5 :       rtx insn;
    7260                 :          5 :       if (address_no_seg_operand (addr, Pmode))
    7261                 :          5 :         insn = emit_insn (gen_rtx_SET (sr.reg, addr));
    7262                 :            :       else
    7263                 :            :         {
    7264                 :          0 :           emit_move_insn (sr.reg, GEN_INT (-rounded_size));
    7265                 :          0 :           insn = emit_insn (gen_rtx_SET (sr.reg,
    7266                 :            :                                          gen_rtx_PLUS (Pmode, sr.reg,
    7267                 :            :                                                        stack_pointer_rtx)));
    7268                 :            :         }
    7269                 :          5 :       if (m->fs.cfa_reg == stack_pointer_rtx)
    7270                 :            :         {
    7271                 :          5 :           add_reg_note (insn, REG_CFA_DEF_CFA,
    7272                 :          5 :                         plus_constant (Pmode, sr.reg,
    7273                 :          5 :                                        m->fs.cfa_offset + rounded_size));
    7274                 :          5 :           RTX_FRAME_RELATED_P (insn) = 1;
    7275                 :            :         }
    7276                 :            : 
    7277                 :            :       /* Step 3: the loop.  */
    7278                 :          5 :       rtx size_rtx = GEN_INT (rounded_size);
    7279                 :          5 :       insn = emit_insn (gen_adjust_stack_and_probe (Pmode, sr.reg, sr.reg,
    7280                 :            :                                                     size_rtx));
    7281                 :          5 :       if (m->fs.cfa_reg == stack_pointer_rtx)
    7282                 :            :         {
    7283                 :          5 :           m->fs.cfa_offset += rounded_size;
    7284                 :          5 :           add_reg_note (insn, REG_CFA_DEF_CFA,
    7285                 :          5 :                         plus_constant (Pmode, stack_pointer_rtx,
    7286                 :          5 :                                        m->fs.cfa_offset));
    7287                 :          5 :           RTX_FRAME_RELATED_P (insn) = 1;
    7288                 :            :         }
    7289                 :          5 :       m->fs.sp_offset += rounded_size;
    7290                 :          5 :       emit_insn (gen_blockage ());
    7291                 :            : 
    7292                 :            :       /* Step 4: adjust SP if we cannot assert at compile-time that SIZE
    7293                 :            :          is equal to ROUNDED_SIZE.  */
    7294                 :            : 
    7295                 :          5 :       if (size != rounded_size)
    7296                 :          3 :         pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
    7297                 :            :                                    GEN_INT (rounded_size - size), -1,
    7298                 :          3 :                                    m->fs.cfa_reg == stack_pointer_rtx);
    7299                 :          5 :       dump_stack_clash_frame_info (PROBE_LOOP, size != rounded_size);
    7300                 :            : 
    7301                 :            :       /* This does not deallocate the space reserved for the scratch
    7302                 :            :          register.  That will be deallocated in the epilogue.  */
    7303                 :          5 :       release_scratch_register_on_entry (&sr, size, false);
    7304                 :            :     }
    7305                 :            : 
    7306                 :            :   /* Make sure nothing is scheduled before we are done.  */
    7307                 :         14 :   emit_insn (gen_blockage ());
    7308                 :            : }
    7309                 :            : 
    7310                 :            : /* Emit code to adjust the stack pointer by SIZE bytes while probing it.
    7311                 :            : 
    7312                 :            :    INT_REGISTERS_SAVED is true if integer registers have already been
    7313                 :            :    pushed on the stack.  */
    7314                 :            : 
    7315                 :            : static void
    7316                 :         30 : ix86_adjust_stack_and_probe (HOST_WIDE_INT size,
    7317                 :            :                              const bool int_registers_saved)
    7318                 :            : {
    7319                 :            :   /* We skip the probe for the first interval + a small dope of 4 words and
    7320                 :            :      probe that many bytes past the specified size to maintain a protection
    7321                 :            :      area at the botton of the stack.  */
    7322                 :         30 :   const int dope = 4 * UNITS_PER_WORD;
    7323                 :         30 :   rtx size_rtx = GEN_INT (size), last;
    7324                 :            : 
    7325                 :            :   /* See if we have a constant small number of probes to generate.  If so,
    7326                 :            :      that's the easy case.  The run-time loop is made up of 9 insns in the
    7327                 :            :      generic case while the compile-time loop is made up of 3+2*(n-1) insns
    7328                 :            :      for n # of intervals.  */
    7329                 :         30 :   if (size <= 4 * get_probe_interval ())
    7330                 :            :     {
    7331                 :         17 :       HOST_WIDE_INT i, adjust;
    7332                 :         17 :       bool first_probe = true;
    7333                 :            : 
    7334                 :            :       /* Adjust SP and probe at PROBE_INTERVAL + N * PROBE_INTERVAL for
    7335                 :            :          values of N from 1 until it exceeds SIZE.  If only one probe is
    7336                 :            :          needed, this will not generate any code.  Then adjust and probe
    7337                 :            :          to PROBE_INTERVAL + SIZE.  */
    7338                 :         17 :       for (i = get_probe_interval (); i < size; i += get_probe_interval ())
    7339                 :            :         {
    7340                 :          0 :           if (first_probe)
    7341                 :            :             {
    7342                 :          0 :               adjust = 2 * get_probe_interval () + dope;
    7343                 :          0 :               first_probe = false;
    7344                 :            :             }
    7345                 :            :           else
    7346                 :          0 :             adjust = get_probe_interval ();
    7347                 :            : 
    7348                 :          0 :           emit_insn (gen_rtx_SET (stack_pointer_rtx,
    7349                 :            :                                   plus_constant (Pmode, stack_pointer_rtx,
    7350                 :            :                                                  -adjust)));
    7351                 :          0 :           emit_stack_probe (stack_pointer_rtx);
    7352                 :            :         }
    7353                 :            : 
    7354                 :         17 :       if (first_probe)
    7355                 :         17 :         adjust = size + get_probe_interval () + dope;
    7356                 :            :       else
    7357                 :          0 :         adjust = size + get_probe_interval () - i;
    7358                 :            : 
    7359                 :         17 :       emit_insn (gen_rtx_SET (stack_pointer_rtx,
    7360                 :            :                               plus_constant (Pmode, stack_pointer_rtx,
    7361                 :            :                                              -adjust)));
    7362                 :         17 :       emit_stack_probe (stack_pointer_rtx);
    7363                 :            : 
    7364                 :            :       /* Adjust back to account for the additional first interval.  */
    7365                 :         17 :       last = emit_insn (gen_rtx_SET (stack_pointer_rtx,
    7366                 :            :                                      plus_constant (Pmode, stack_pointer_rtx,
    7367                 :            :                                                     (get_probe_interval ()
    7368                 :            :                                                      + dope))));
    7369                 :            :     }
    7370                 :            : 
    7371                 :            :   /* Otherwise, do the same as above, but in a loop.  Note that we must be
    7372                 :            :      extra careful with variables wrapping around because we might be at
    7373                 :            :      the very top (or the very bottom) of the address space and we have
    7374                 :            :      to be able to handle this case properly; in particular, we use an
    7375                 :            :      equality test for the loop condition.  */
    7376                 :            :   else
    7377                 :            :     {
    7378                 :            :       /* We expect the GP registers to be saved when probes are used
    7379                 :            :          as the probing sequences might need a scratch register and
    7380                 :            :          the routine to allocate one assumes the integer registers
    7381                 :            :          have already been saved.  */
    7382                 :         13 :       gcc_assert (int_registers_saved);
    7383                 :            : 
    7384                 :         13 :       HOST_WIDE_INT rounded_size;
    7385                 :         13 :       struct scratch_reg sr;
    7386                 :            : 
    7387                 :         13 :       get_scratch_register_on_entry (&sr);
    7388                 :            : 
    7389                 :            :       /* If we needed to save a register, then account for any space
    7390                 :            :          that was pushed (we are not going to pop the register when
    7391                 :            :          we do the restore).  */
    7392                 :         13 :       if (sr.saved)
    7393                 :          0 :         size -= UNITS_PER_WORD;
    7394                 :            : 
    7395                 :            :       /* Step 1: round SIZE to the previous multiple of the interval.  */
    7396                 :            : 
    7397                 :         13 :       rounded_size = ROUND_DOWN (size, get_probe_interval ());
    7398                 :            : 
    7399                 :            : 
    7400                 :            :       /* Step 2: compute initial and final value of the loop counter.  */
    7401                 :            : 
    7402                 :            :       /* SP = SP_0 + PROBE_INTERVAL.  */
    7403                 :         13 :       emit_insn (gen_rtx_SET (stack_pointer_rtx,
    7404                 :            :                               plus_constant (Pmode, stack_pointer_rtx,
    7405                 :            :                                              - (get_probe_interval () + dope))));
    7406                 :            : 
    7407                 :            :       /* LAST_ADDR = SP_0 + PROBE_INTERVAL + ROUNDED_SIZE.  */
    7408                 :         13 :       if (rounded_size <= (HOST_WIDE_INT_1 << 31))
    7409                 :          1 :         emit_insn (gen_rtx_SET (sr.reg,
    7410                 :            :                                 plus_constant (Pmode, stack_pointer_rtx,
    7411                 :            :                                                -rounded_size)));
    7412                 :            :       else
    7413                 :            :         {
    7414                 :         12 :           emit_move_insn (sr.reg, GEN_INT (-rounded_size));
    7415                 :         12 :           emit_insn (gen_rtx_SET (sr.reg,
    7416                 :            :                                   gen_rtx_PLUS (Pmode, sr.reg,
    7417                 :            :                                                 stack_pointer_rtx)));
    7418                 :            :         }
    7419                 :            : 
    7420                 :            : 
    7421                 :            :       /* Step 3: the loop
    7422                 :            : 
    7423                 :            :          do
    7424                 :            :            {
    7425                 :            :              SP = SP + PROBE_INTERVAL
    7426                 :            :              probe at SP
    7427                 :            :            }
    7428                 :            :          while (SP != LAST_ADDR)
    7429                 :            : 
    7430                 :            :          adjusts SP and probes to PROBE_INTERVAL + N * PROBE_INTERVAL for
    7431                 :            :          values of N from 1 until it is equal to ROUNDED_SIZE.  */
    7432                 :            : 
    7433                 :         13 :       emit_insn (gen_adjust_stack_and_probe (Pmode, sr.reg, sr.reg, size_rtx));
    7434                 :            : 
    7435                 :            : 
    7436                 :            :       /* Step 4: adjust SP and probe at PROBE_INTERVAL + SIZE if we cannot
    7437                 :            :          assert at compile-time that SIZE is equal to ROUNDED_SIZE.  */
    7438                 :            : 
    7439                 :         13 :       if (size != rounded_size)
    7440                 :            :         {
    7441                 :          9 :           emit_insn (gen_rtx_SET (stack_pointer_rtx,
    7442                 :            :                                   plus_constant (Pmode, stack_pointer_rtx,
    7443                 :            :                                                  rounded_size - size)));
    7444                 :          9 :           emit_stack_probe (stack_pointer_rtx);
    7445                 :            :         }
    7446                 :            : 
    7447                 :            :       /* Adjust back to account for the additional first interval.  */
    7448                 :         13 :       last = emit_insn (gen_rtx_SET (stack_pointer_rtx,
    7449                 :            :                                      plus_constant (Pmode, stack_pointer_rtx,
    7450                 :            :                                                     (get_probe_interval ()
    7451                 :            :                                                      + dope))));
    7452                 :            : 
    7453                 :            :       /* This does not deallocate the space reserved for the scratch
    7454                 :            :          register.  That will be deallocated in the epilogue.  */
    7455                 :         13 :       release_scratch_register_on_entry (&sr, size, false);
    7456                 :            :     }
    7457                 :            : 
    7458                 :            :   /* Even if the stack pointer isn't the CFA register, we need to correctly
    7459                 :            :      describe the adjustments made to it, in particular differentiate the
    7460                 :            :      frame-related ones from the frame-unrelated ones.  */
    7461                 :         30 :   if (size > 0)
    7462                 :            :     {
    7463                 :         25 :       rtx expr = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (2));
    7464                 :         50 :       XVECEXP (expr, 0, 0)
    7465                 :         25 :         = gen_rtx_SET (stack_pointer_rtx,
    7466                 :            :                        plus_constant (Pmode, stack_pointer_rtx, -size));
    7467                 :         25 :       XVECEXP (expr, 0, 1)
    7468                 :         25 :         = gen_rtx_SET (stack_pointer_rtx,
    7469                 :            :                        plus_constant (Pmode, stack_pointer_rtx,
    7470                 :            :                                       get_probe_interval () + dope + size));
    7471                 :         25 :       add_reg_note (last, REG_FRAME_RELATED_EXPR, expr);
    7472                 :         25 :       RTX_FRAME_RELATED_P (last) = 1;
    7473                 :            : 
    7474                 :         25 :       cfun->machine->fs.sp_offset += size;
    7475                 :            :     }
    7476                 :            : 
    7477                 :            :   /* Make sure nothing is scheduled before we are done.  */
    7478                 :         30 :   emit_insn (gen_blockage ());
    7479                 :         30 : }
    7480                 :            : 
    7481                 :            : /* Adjust the stack pointer up to REG while probing it.  */
    7482                 :            : 
    7483                 :            : const char *
    7484                 :         18 : output_adjust_stack_and_probe (rtx reg)
    7485                 :            : {
    7486                 :         18 :   static int labelno = 0;
    7487                 :         18 :   char loop_lab[32];
    7488                 :         18 :   rtx xops[2];
    7489                 :            : 
    7490                 :         18 :   ASM_GENERATE_INTERNAL_LABEL (loop_lab, "LPSRL", labelno++);
    7491                 :            : 
    7492                 :            :   /* Loop.  */
    7493                 :         18 :   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
    7494                 :            : 
    7495                 :            :   /* SP = SP + PROBE_INTERVAL.  */
    7496                 :         18 :   xops[0] = stack_pointer_rtx;
    7497                 :         23 :   xops[1] = GEN_INT (get_probe_interval ());
    7498                 :         18 :   output_asm_insn ("sub%z0\t{%1, %0|%0, %1}", xops);
    7499                 :            : 
    7500                 :            :   /* Probe at SP.  */
    7501                 :         18 :   xops[1] = const0_rtx;
    7502                 :         18 :   output_asm_insn ("or%z0\t{%1, (%0)|DWORD PTR [%0], %1}", xops);
    7503                 :            : 
    7504                 :            :   /* Test if SP == LAST_ADDR.  */
    7505                 :         18 :   xops[0] = stack_pointer_rtx;
    7506                 :         18 :   xops[1] = reg;
    7507                 :         18 :   output_asm_insn ("cmp%z0\t{%1, %0|%0, %1}", xops);
    7508                 :            : 
    7509                 :            :   /* Branch.  */
    7510                 :         18 :   fputs ("\tjne\t", asm_out_file);
    7511                 :         18 :   assemble_name_raw (asm_out_file, loop_lab);
    7512                 :         18 :   fputc ('\n', asm_out_file);
    7513                 :            : 
    7514                 :         18 :   return "";
    7515                 :            : }
    7516                 :            : 
    7517                 :            : /* Emit code to probe a range of stack addresses from FIRST to FIRST+SIZE,
    7518                 :            :    inclusive.  These are offsets from the current stack pointer.
    7519                 :            : 
    7520                 :            :    INT_REGISTERS_SAVED is true if integer registers have already been
    7521                 :            :    pushed on the stack.  */
    7522                 :            : 
    7523                 :            : static void
    7524                 :          0 : ix86_emit_probe_stack_range (HOST_WIDE_INT first, HOST_WIDE_INT size,
    7525                 :            :                              const bool int_registers_saved)
    7526                 :            : {
    7527                 :            :   /* See if we have a constant small number of probes to generate.  If so,
    7528                 :            :      that's the easy case.  The run-time loop is made up of 6 insns in the
    7529                 :            :      generic case while the compile-time loop is made up of n insns for n #
    7530                 :            :      of intervals.  */
    7531                 :          0 :   if (size <= 6 * get_probe_interval ())
    7532                 :            :     {
    7533                 :          0 :       HOST_WIDE_INT i;
    7534                 :            : 
    7535                 :            :       /* Probe at FIRST + N * PROBE_INTERVAL for values of N from 1 until
    7536                 :            :          it exceeds SIZE.  If only one probe is needed, this will not
    7537                 :            :          generate any code.  Then probe at FIRST + SIZE.  */
    7538                 :          0 :       for (i = get_probe_interval (); i < size; i += get_probe_interval ())
    7539                 :          0 :         emit_stack_probe (plus_constant (Pmode, stack_pointer_rtx,
    7540                 :          0 :                                          -(first + i)));
    7541                 :            : 
    7542                 :          0 :       emit_stack_probe (plus_constant (Pmode, stack_pointer_rtx,
    7543                 :          0 :                                        -(first + size)));
    7544                 :            :     }
    7545                 :            : 
    7546                 :            :   /* Otherwise, do the same as above, but in a loop.  Note that we must be
    7547                 :            :      extra careful with variables wrapping around because we might be at
    7548                 :            :      the very top (or the very bottom) of the address space and we have
    7549                 :            :      to be able to handle this case properly; in particular, we use an
    7550                 :            :      equality test for the loop condition.  */
    7551                 :            :   else
    7552                 :            :     {
    7553                 :            :       /* We expect the GP registers to be saved when probes are used
    7554                 :            :          as the probing sequences might need a scratch register and
    7555                 :            :          the routine to allocate one assumes the integer registers
    7556                 :            :          have already been saved.  */
    7557                 :          0 :       gcc_assert (int_registers_saved);
    7558                 :            : 
    7559                 :          0 :       HOST_WIDE_INT rounded_size, last;
    7560                 :          0 :       struct scratch_reg sr;
    7561                 :            : 
    7562                 :          0 :       get_scratch_register_on_entry (&sr);
    7563                 :            : 
    7564                 :            : 
    7565                 :            :       /* Step 1: round SIZE to the previous multiple of the interval.  */
    7566                 :            : 
    7567                 :          0 :       rounded_size = ROUND_DOWN (size, get_probe_interval ());
    7568                 :            : 
    7569                 :            : 
    7570                 :            :       /* Step 2: compute initial and final value of the loop counter.  */
    7571                 :            : 
    7572                 :            :       /* TEST_OFFSET = FIRST.  */
    7573                 :          0 :       emit_move_insn (sr.reg, GEN_INT (-first));
    7574                 :            : 
    7575                 :            :       /* LAST_OFFSET = FIRST + ROUNDED_SIZE.  */
    7576                 :          0 :       last = first + rounded_size;
    7577                 :            : 
    7578                 :            : 
    7579                 :            :       /* Step 3: the loop
    7580                 :            : 
    7581                 :            :          do
    7582                 :            :            {
    7583                 :            :              TEST_ADDR = TEST_ADDR + PROBE_INTERVAL
    7584                 :            :              probe at TEST_ADDR
    7585                 :            :            }
    7586                 :            :          while (TEST_ADDR != LAST_ADDR)
    7587                 :            : 
    7588                 :            :          probes at FIRST + N * PROBE_INTERVAL for values of N from 1
    7589                 :            :          until it is equal to ROUNDED_SIZE.  */
    7590                 :            : 
    7591                 :          0 :       emit_insn
    7592                 :          0 :         (gen_probe_stack_range (Pmode, sr.reg, sr.reg, GEN_INT (-last)));
    7593                 :            : 
    7594                 :            : 
    7595                 :            :       /* Step 4: probe at FIRST + SIZE if we cannot assert at compile-time
    7596                 :            :          that SIZE is equal to ROUNDED_SIZE.  */
    7597                 :            : 
    7598                 :          0 :       if (size != rounded_size)
    7599                 :          0 :         emit_stack_probe (plus_constant (Pmode,
    7600                 :          0 :                                          gen_rtx_PLUS (Pmode,
    7601                 :            :                                                        stack_pointer_rtx,
    7602                 :            :                                                        sr.reg),
    7603                 :          0 :                                          rounded_size - size));
    7604                 :            : 
    7605                 :          0 :       release_scratch_register_on_entry (&sr, size, true);
    7606                 :            :     }
    7607                 :            : 
    7608                 :            :   /* Make sure nothing is scheduled before we are done.  */
    7609                 :          0 :   emit_insn (gen_blockage ());
    7610                 :          0 : }
    7611                 :            : 
    7612                 :            : /* Probe a range of stack addresses from REG to END, inclusive.  These are
    7613                 :            :    offsets from the current stack pointer.  */
    7614                 :            : 
    7615                 :            : const char *
    7616                 :          0 : output_probe_stack_range (rtx reg, rtx end)
    7617                 :            : {
    7618                 :          0 :   static int labelno = 0;
    7619                 :          0 :   char loop_lab[32];
    7620                 :          0 :   rtx xops[3];
    7621                 :            : 
    7622                 :          0 :   ASM_GENERATE_INTERNAL_LABEL (loop_lab, "LPSRL", labelno++);
    7623                 :            : 
    7624                 :            :   /* Loop.  */
    7625                 :          0 :   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
    7626                 :            : 
    7627                 :            :   /* TEST_ADDR = TEST_ADDR + PROBE_INTERVAL.  */
    7628                 :          0 :   xops[0] = reg;
    7629                 :          0 :   xops[1] = GEN_INT (get_probe_interval ());
    7630                 :          0 :   output_asm_insn ("sub%z0\t{%1, %0|%0, %1}", xops);
    7631                 :            : 
    7632                 :            :   /* Probe at TEST_ADDR.  */
    7633                 :          0 :   xops[0] = stack_pointer_rtx;
    7634                 :          0 :   xops[1] = reg;
    7635                 :          0 :   xops[2] = const0_rtx;
    7636                 :          0 :   output_asm_insn ("or%z0\t{%2, (%0,%1)|DWORD PTR [%0+%1], %2}", xops);
    7637                 :            : 
    7638                 :            :   /* Test if TEST_ADDR == LAST_ADDR.  */
    7639                 :          0 :   xops[0] = reg;
    7640                 :          0 :   xops[1] = end;
    7641                 :          0 :   output_asm_insn ("cmp%z0\t{%1, %0|%0, %1}", xops);
    7642                 :            : 
    7643                 :            :   /* Branch.  */
    7644                 :          0 :   fputs ("\tjne\t", asm_out_file);
    7645                 :          0 :   assemble_name_raw (asm_out_file, loop_lab);
    7646                 :          0 :   fputc ('\n', asm_out_file);
    7647                 :            : 
    7648                 :          0 :   return "";
    7649                 :            : }
    7650                 :            : 
    7651                 :            : /* Set stack_frame_required to false if stack frame isn't required.
    7652                 :            :    Update STACK_ALIGNMENT to the largest alignment, in bits, of stack
    7653                 :            :    slot used if stack frame is required and CHECK_STACK_SLOT is true.  */
    7654                 :            : 
    7655                 :            : static void
    7656                 :     942884 : ix86_find_max_used_stack_alignment (unsigned int &stack_alignment,
    7657                 :            :                                     bool check_stack_slot)
    7658                 :            : {
    7659                 :     942884 :   HARD_REG_SET set_up_by_prologue, prologue_used;
    7660                 :     942884 :   basic_block bb;
    7661                 :            : 
    7662                 :     942884 :   CLEAR_HARD_REG_SET (prologue_used);
    7663                 :    2828650 :   CLEAR_HARD_REG_SET (set_up_by_prologue);
    7664                 :    1038030 :   add_to_hard_reg_set (&set_up_by_prologue, Pmode, STACK_POINTER_REGNUM);
    7665                 :     942884 :   add_to_hard_reg_set (&set_up_by_prologue, Pmode, ARG_POINTER_REGNUM);
    7666                 :     942884 :   add_to_hard_reg_set (&set_up_by_prologue, Pmode,
    7667                 :            :                        HARD_FRAME_POINTER_REGNUM);
    7668                 :            : 
    7669                 :            :   /* The preferred stack alignment is the minimum stack alignment.  */
    7670                 :     942884 :   if (stack_alignment > crtl->preferred_stack_boundary)
    7671                 :      91077 :     stack_alignment = crtl->preferred_stack_boundary;
    7672                 :            : 
    7673                 :     942884 :   bool require_stack_frame = false;
    7674                 :            : 
    7675                 :    9975000 :   FOR_EACH_BB_FN (bb, cfun)
    7676                 :            :     {
    7677                 :    9032120 :       rtx_insn *insn;
    7678                 :  202796000 :       FOR_BB_INSNS (bb, insn)
    7679                 :   96882000 :         if (NONDEBUG_INSN_P (insn)
    7680                 :   96882000 :             && requires_stack_frame_p (insn, prologue_used,
    7681                 :            :                                        set_up_by_prologue))
    7682                 :            :           {
    7683                 :   22159200 :             require_stack_frame = true;
    7684                 :            : 
    7685                 :   22159200 :             if (check_stack_slot)
    7686                 :            :               {
    7687                 :            :                 /* Find the maximum stack alignment.  */
    7688                 :   38940500 :                 subrtx_iterator::array_type array;
    7689                 :  135602000 :                 FOR_EACH_SUBRTX (iter, array, PATTERN (insn), ALL)
    7690                 :  116131000 :                   if (MEM_P (*iter)
    7691                 :  116131000 :                       && (reg_mentioned_p (stack_pointer_rtx,
    7692                 :            :                                            *iter)
    7693                 :    8126780 :                           || reg_mentioned_p (frame_pointer_rtx,
    7694                 :            :                                               *iter)))
    7695                 :            :                     {
    7696                 :    7834320 :                       unsigned int alignment = MEM_ALIGN (*iter);
    7697                 :    7834320 :                       if (alignment > stack_alignment)
    7698                 :      16388 :                         stack_alignment = alignment;
    7699                 :            :                     }
    7700                 :            :               }
    7701                 :            :           }
    7702                 :            :     }
    7703                 :            : 
    7704                 :     942884 :   cfun->machine->stack_frame_required = require_stack_frame;
    7705                 :     942884 : }
    7706                 :            : 
    7707                 :            : /* Finalize stack_realign_needed and frame_pointer_needed flags, which
    7708                 :            :    will guide prologue/epilogue to be generated in correct form.  */
    7709                 :            : 
    7710                 :            : static void
    7711                 :    2154620 : ix86_finalize_stack_frame_flags (void)
    7712                 :            : {
    7713                 :            :   /* Check if stack realign is really needed after reload, and
    7714                 :            :      stores result in cfun */
    7715                 :    2154620 :   unsigned int incoming_stack_boundary
    7716                 :    2154620 :     = (crtl->parm_stack_boundary > ix86_incoming_stack_boundary
    7717                 :            :        ? crtl->parm_stack_boundary : ix86_incoming_stack_boundary);
    7718                 :    2154620 :   unsigned int stack_alignment
    7719                 :     780965 :     = (crtl->is_leaf && !ix86_current_function_calls_tls_descriptor
    7720                 :    2935590 :        ? crtl->max_used_stack_slot_alignment
    7721                 :    2154620 :        : crtl->stack_alignment_needed);
    7722                 :    2154620 :   unsigned int stack_realign
    7723                 :    2154620 :     = (incoming_stack_boundary < stack_alignment);
    7724                 :    2154620 :   bool recompute_frame_layout_p = false;
    7725                 :            : 
    7726                 :    2154620 :   if (crtl->stack_realign_finalized)
    7727                 :            :     {
    7728                 :            :       /* After stack_realign_needed is finalized, we can't no longer
    7729                 :            :          change it.  */
    7730                 :    1211740 :       gcc_assert (crtl->stack_realign_needed == stack_realign);
    7731                 :    1211740 :       return;
    7732                 :            :     }
    7733                 :            : 
    7734                 :            :   /* It is always safe to compute max_used_stack_alignment.  We
    7735                 :            :      compute it only if 128-bit aligned load/store may be generated
    7736                 :            :      on misaligned stack slot which will lead to segfault. */
    7737                 :    1885770 :   bool check_stack_slot
    7738                 :     942884 :     = (stack_realign || crtl->max_used_stack_slot_alignment >= 128);
    7739                 :     942884 :   ix86_find_max_used_stack_alignment (stack_alignment,
    7740                 :            :                                       check_stack_slot);
    7741                 :            : 
    7742                 :            :   /* If the only reason for frame_pointer_needed is that we conservatively
    7743                 :            :      assumed stack realignment might be needed or -fno-omit-frame-pointer
    7744                 :            :      is used, but in the end nothing that needed the stack alignment had
    7745                 :            :      been spilled nor stack access, clear frame_pointer_needed and say we
    7746                 :            :      don't need stack realignment.  */
    7747                 :     897560 :   if ((stack_realign || (!flag_omit_frame_pointer && optimize))
    7748                 :      54719 :       && frame_pointer_needed
    7749                 :      54719 :       && crtl->is_leaf
    7750                 :      36679 :       && crtl->sp_is_unchanging
    7751                 :      36640 :       && !ix86_current_function_calls_tls_descriptor
    7752                 :      36640 :       && !crtl->accesses_prior_frames
    7753                 :      36640 :       && !cfun->calls_alloca
    7754                 :      36640 :       && !crtl->calls_eh_return
    7755                 :            :       /* See ira_setup_eliminable_regset for the rationale.  */
    7756                 :      36640 :       && !(STACK_CHECK_MOVING_SP
    7757                 :      36640 :            && flag_stack_check
    7758                 :          0 :            && flag_exceptions
    7759                 :          0 :            && cfun->can_throw_non_call_exceptions)
    7760                 :      36640 :       && !ix86_frame_pointer_required ()
    7761                 :      12655 :       && ix86_get_frame_size () == 0
    7762                 :      24142 :       && ix86_nsaved_sseregs () == 0
    7763                 :     967026 :       && ix86_varargs_gpr_size + ix86_varargs_fpr_size == 0)
    7764                 :            :     {
    7765                 :      24142 :       if (cfun->machine->stack_frame_required)
    7766                 :            :         {
    7767                 :            :           /* Stack frame is required.  If stack alignment needed is less
    7768                 :            :              than incoming stack boundary, don't realign stack.  */
    7769                 :        159 :           stack_realign = incoming_stack_boundary < stack_alignment;
    7770                 :        159 :           if (!stack_realign)
    7771                 :            :             {
    7772                 :        159 :               crtl->max_used_stack_slot_alignment
    7773                 :        159 :                 = incoming_stack_boundary;
    7774                 :        159 :               crtl->stack_alignment_needed
    7775                 :        159 :                 = incoming_stack_boundary;
    7776                 :            :               /* Also update preferred_stack_boundary for leaf
    7777                 :            :                  functions.  */
    7778                 :        159 :               crtl->preferred_stack_boundary
    7779                 :        159 :                 = incoming_stack_boundary;
    7780                 :            :             }
    7781                 :            :         }
    7782                 :            :       else
    7783                 :            :         {
    7784                 :            :           /* If drap has been set, but it actually isn't live at the
    7785                 :            :              start of the function, there is no reason to set it up.  */
    7786                 :      23983 :           if (crtl->drap_reg)
    7787                 :            :             {
    7788                 :         26 :               basic_block bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb;
    7789                 :         52 :               if (! REGNO_REG_SET_P (DF_LR_IN (bb),
    7790                 :            :                                      REGNO (crtl->drap_reg)))
    7791                 :            :                 {
    7792                 :         26 :                   crtl->drap_reg = NULL_RTX;
    7793                 :         26 :                   crtl->need_drap = false;
    7794                 :            :                 }
    7795                 :            :             }
    7796                 :            :           else
    7797                 :      23957 :             cfun->machine->no_drap_save_restore = true;
    7798                 :            : 
    7799                 :      23983 :           frame_pointer_needed = false;
    7800                 :      23983 :           stack_realign = false;
    7801                 :      23983 :           crtl->max_used_stack_slot_alignment = incoming_stack_boundary;
    7802                 :      23983 :           crtl->stack_alignment_needed = incoming_stack_boundary;
    7803                 :      23983 :           crtl->stack_alignment_estimated = incoming_stack_boundary;
    7804                 :      23983 :           if (crtl->preferred_stack_boundary > incoming_stack_boundary)
    7805                 :          0 :             crtl->preferred_stack_boundary = incoming_stack_boundary;
    7806                 :      23983 :           df_finish_pass (true);
    7807                 :      23983 :           df_scan_alloc (NULL);
    7808                 :      23983 :           df_scan_blocks ();
    7809                 :      23983 :           df_compute_regs_ever_live (true);
    7810                 :      23983 :           df_analyze ();
    7811                 :            : 
    7812                 :      23983 :           if (flag_var_tracking)
    7813                 :            :             {
    7814                 :            :               /* Since frame pointer is no longer available, replace it with
    7815                 :            :                  stack pointer - UNITS_PER_WORD in debug insns.  */
    7816                 :       1832 :               df_ref ref, next;
    7817                 :       1832 :               for (ref = DF_REG_USE_CHAIN (HARD_FRAME_POINTER_REGNUM);
    7818                 :       1832 :                    ref; ref = next)
    7819                 :            :                 {
    7820                 :          0 :                   next = DF_REF_NEXT_REG (ref);
    7821                 :          0 :                   if (!DF_REF_INSN_INFO (ref))
    7822                 :          0 :                     continue;
    7823                 :            : 
    7824                 :            :                   /* Make sure the next ref is for a different instruction,
    7825                 :            :                      so that we're not affected by the rescan.  */
    7826                 :          0 :                   rtx_insn *insn = DF_REF_INSN (ref);
    7827                 :          0 :                   while (next && DF_REF_INSN (next) == insn)
    7828