LCOV - code coverage report
Current view: top level - gcc/config/i386 - i386.md (source / functions) Hit Total Coverage
Test: gcc.info Lines: 22919 26918 85.1 %
Date: 2020-03-28 11:57:23 Functions: 1226 1664 73.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : ;; GCC machine description for IA-32 and x86-64.
       2                 :            : ;; Copyright (C) 1988-2020 Free Software Foundation, Inc.
       3                 :            : ;; Mostly by William Schelter.
       4                 :            : ;; x86_64 support added by Jan Hubicka
       5                 :            : ;;
       6                 :            : ;; This file is part of GCC.
       7                 :            : ;;
       8                 :            : ;; GCC is free software; you can redistribute it and/or modify
       9                 :            : ;; it under the terms of the GNU General Public License as published by
      10                 :            : ;; the Free Software Foundation; either version 3, or (at your option)
      11                 :            : ;; any later version.
      12                 :            : ;;
      13                 :            : ;; GCC is distributed in the hope that it will be useful,
      14                 :            : ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
      15                 :            : ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16                 :            : ;; GNU General Public License for more details.
      17                 :            : ;;
      18                 :            : ;; You should have received a copy of the GNU General Public License
      19                 :            : ;; along with GCC; see the file COPYING3.  If not see
      20                 :            : ;; <http://www.gnu.org/licenses/>.  */
      21                 :            : ;;
      22                 :            : ;; The original PO technology requires these to be ordered by speed,
      23                 :            : ;; so that assigner will pick the fastest.
      24                 :            : ;;
      25                 :            : ;; See file "rtl.def" for documentation on define_insn, match_*, et. al.
      26                 :            : ;;
      27                 :            : ;; The special asm out single letter directives following a '%' are:
      28                 :            : ;; L,W,B,Q,S,T -- print the opcode suffix for specified size of operand.
      29                 :            : ;; C -- print opcode suffix for set/cmov insn.
      30                 :            : ;; c -- like C, but print reversed condition
      31                 :            : ;; F,f -- likewise, but for floating-point.
      32                 :            : ;; O -- if HAVE_AS_IX86_CMOV_SUN_SYNTAX, expand to "w.", "l." or "q.",
      33                 :            : ;;      otherwise nothing
      34                 :            : ;; R -- print the prefix for register names.
      35                 :            : ;; z -- print the opcode suffix for the size of the current operand.
      36                 :            : ;; Z -- likewise, with special suffixes for x87 instructions.
      37                 :            : ;; * -- print a star (in certain assembler syntax)
      38                 :            : ;; A -- print an absolute memory reference.
      39                 :            : ;; E -- print address with DImode register names if TARGET_64BIT.
      40                 :            : ;; w -- print the operand as if it's a "word" (HImode) even if it isn't.
      41                 :            : ;; s -- print a shift double count, followed by the assemblers argument
      42                 :            : ;;      delimiter.
      43                 :            : ;; b -- print the QImode name of the register for the indicated operand.
      44                 :            : ;;      %b0 would print %al if operands[0] is reg 0.
      45                 :            : ;; w --  likewise, print the HImode name of the register.
      46                 :            : ;; k --  likewise, print the SImode name of the register.
      47                 :            : ;; q --  likewise, print the DImode name of the register.
      48                 :            : ;; x --  likewise, print the V4SFmode name of the register.
      49                 :            : ;; t --  likewise, print the V8SFmode name of the register.
      50                 :            : ;; h -- print the QImode name for a "high" register, either ah, bh, ch or dh.
      51                 :            : ;; y -- print "st(0)" instead of "st" as a register.
      52                 :            : ;; d -- print duplicated register operand for AVX instruction.
      53                 :            : ;; D -- print condition for SSE cmp instruction.
      54                 :            : ;; P -- if PIC, print an @PLT suffix.
      55                 :            : ;; p -- print raw symbol name.
      56                 :            : ;; X -- don't print any sort of PIC '@' suffix for a symbol.
      57                 :            : ;; & -- print some in-use local-dynamic symbol name.
      58                 :            : ;; H -- print a memory address offset by 8; used for sse high-parts
      59                 :            : ;; K -- print HLE lock prefix
      60                 :            : ;; Y -- print condition for XOP pcom* instruction.
      61                 :            : ;; + -- print a branch hint as 'cs' or 'ds' prefix
      62                 :            : ;; ; -- print a semicolon (after prefixes due to bug in older gas).
      63                 :            : ;; ~ -- print "i" if TARGET_AVX2, "f" otherwise.
      64                 :            : ;; ^ -- print addr32 prefix if TARGET_64BIT and Pmode != word_mode
      65                 :            : ;; ! -- print NOTRACK prefix for jxx/call/ret instructions if required.
      66                 :            : 
      67                 :            : (define_c_enum "unspec" [
      68                 :            :   ;; Relocation specifiers
      69                 :            :   UNSPEC_GOT
      70                 :            :   UNSPEC_GOTOFF
      71                 :            :   UNSPEC_GOTPCREL
      72                 :            :   UNSPEC_GOTTPOFF
      73                 :            :   UNSPEC_TPOFF
      74                 :            :   UNSPEC_NTPOFF
      75                 :            :   UNSPEC_DTPOFF
      76                 :            :   UNSPEC_GOTNTPOFF
      77                 :            :   UNSPEC_INDNTPOFF
      78                 :            :   UNSPEC_PLTOFF
      79                 :            :   UNSPEC_MACHOPIC_OFFSET
      80                 :            :   UNSPEC_PCREL
      81                 :            :   UNSPEC_SIZEOF
      82                 :            : 
      83                 :            :   ;; Prologue support
      84                 :            :   UNSPEC_STACK_ALLOC
      85                 :            :   UNSPEC_SET_GOT
      86                 :            :   UNSPEC_SET_RIP
      87                 :            :   UNSPEC_SET_GOT_OFFSET
      88                 :            :   UNSPEC_MEMORY_BLOCKAGE
      89                 :            :   UNSPEC_PROBE_STACK
      90                 :            : 
      91                 :            :   ;; TLS support
      92                 :            :   UNSPEC_TP
      93                 :            :   UNSPEC_TLS_GD
      94                 :            :   UNSPEC_TLS_LD_BASE
      95                 :            :   UNSPEC_TLSDESC
      96                 :            :   UNSPEC_TLS_IE_SUN
      97                 :            : 
      98                 :            :   ;; Other random patterns
      99                 :            :   UNSPEC_SCAS
     100                 :            :   UNSPEC_FNSTSW
     101                 :            :   UNSPEC_SAHF
     102                 :            :   UNSPEC_NOTRAP
     103                 :            :   UNSPEC_PARITY
     104                 :            :   UNSPEC_FSTCW
     105                 :            :   UNSPEC_REP
     106                 :            :   UNSPEC_LD_MPIC        ; load_macho_picbase
     107                 :            :   UNSPEC_TRUNC_NOOP
     108                 :            :   UNSPEC_DIV_ALREADY_SPLIT
     109                 :            :   UNSPEC_PAUSE
     110                 :            :   UNSPEC_LEA_ADDR
     111                 :            :   UNSPEC_XBEGIN_ABORT
     112                 :            :   UNSPEC_STOS
     113                 :            :   UNSPEC_PEEPSIB
     114                 :            :   UNSPEC_INSN_FALSE_DEP
     115                 :            :   UNSPEC_SBB
     116                 :            : 
     117                 :            :   ;; For SSE/MMX support:
     118                 :            :   UNSPEC_FIX_NOTRUNC
     119                 :            :   UNSPEC_MASKMOV
     120                 :            :   UNSPEC_MOVMSK
     121                 :            :   UNSPEC_RCP
     122                 :            :   UNSPEC_RSQRT
     123                 :            :   UNSPEC_PSADBW
     124                 :            : 
     125                 :            :   ;; Generic math support
     126                 :            :   UNSPEC_COPYSIGN
     127                 :            :   UNSPEC_XORSIGN
     128                 :            :   UNSPEC_IEEE_MIN       ; not commutative
     129                 :            :   UNSPEC_IEEE_MAX       ; not commutative
     130                 :            : 
     131                 :            :   ;; x87 Floating point
     132                 :            :   UNSPEC_SIN
     133                 :            :   UNSPEC_COS
     134                 :            :   UNSPEC_FPATAN
     135                 :            :   UNSPEC_FYL2X
     136                 :            :   UNSPEC_FYL2XP1
     137                 :            :   UNSPEC_FRNDINT
     138                 :            :   UNSPEC_FIST
     139                 :            :   UNSPEC_F2XM1
     140                 :            :   UNSPEC_TAN
     141                 :            :   UNSPEC_FXAM
     142                 :            : 
     143                 :            :   ;; x87 Rounding
     144                 :            :   UNSPEC_FRNDINT_ROUNDEVEN
     145                 :            :   UNSPEC_FRNDINT_FLOOR
     146                 :            :   UNSPEC_FRNDINT_CEIL
     147                 :            :   UNSPEC_FRNDINT_TRUNC
     148                 :            :   UNSPEC_FIST_FLOOR
     149                 :            :   UNSPEC_FIST_CEIL
     150                 :            : 
     151                 :            :   ;; x87 Double output FP
     152                 :            :   UNSPEC_SINCOS_COS
     153                 :            :   UNSPEC_SINCOS_SIN
     154                 :            :   UNSPEC_XTRACT_FRACT
     155                 :            :   UNSPEC_XTRACT_EXP
     156                 :            :   UNSPEC_FSCALE_FRACT
     157                 :            :   UNSPEC_FSCALE_EXP
     158                 :            :   UNSPEC_FPREM_F
     159                 :            :   UNSPEC_FPREM_U
     160                 :            :   UNSPEC_FPREM1_F
     161                 :            :   UNSPEC_FPREM1_U
     162                 :            : 
     163                 :            :   UNSPEC_C2_FLAG
     164                 :            :   UNSPEC_FXAM_MEM
     165                 :            : 
     166                 :            :   ;; SSP patterns
     167                 :            :   UNSPEC_SP_SET
     168                 :            :   UNSPEC_SP_TEST
     169                 :            : 
     170                 :            :   ;; For ROUND support
     171                 :            :   UNSPEC_ROUND
     172                 :            : 
     173                 :            :   ;; For CRC32 support
     174                 :            :   UNSPEC_CRC32
     175                 :            : 
     176                 :            :   ;; For LZCNT suppoprt
     177                 :            :   UNSPEC_LZCNT
     178                 :            : 
     179                 :            :   ;; For BMI support
     180                 :            :   UNSPEC_TZCNT
     181                 :            :   UNSPEC_BEXTR
     182                 :            : 
     183                 :            :   ;; For BMI2 support
     184                 :            :   UNSPEC_PDEP
     185                 :            :   UNSPEC_PEXT
     186                 :            : 
     187                 :            :   ;; IRET support
     188                 :            :   UNSPEC_INTERRUPT_RETURN
     189                 :            : ])
     190                 :            : 
     191                 :            : (define_c_enum "unspecv" [
     192                 :            :   UNSPECV_UD2
     193                 :            :   UNSPECV_BLOCKAGE
     194                 :            :   UNSPECV_STACK_PROBE
     195                 :            :   UNSPECV_PROBE_STACK_RANGE
     196                 :            :   UNSPECV_ALIGN
     197                 :            :   UNSPECV_PROLOGUE_USE
     198                 :            :   UNSPECV_SPLIT_STACK_RETURN
     199                 :            :   UNSPECV_CLD
     200                 :            :   UNSPECV_NOPS
     201                 :            :   UNSPECV_RDTSC
     202                 :            :   UNSPECV_RDTSCP
     203                 :            :   UNSPECV_RDPMC
     204                 :            :   UNSPECV_LLWP_INTRINSIC
     205                 :            :   UNSPECV_SLWP_INTRINSIC
     206                 :            :   UNSPECV_LWPVAL_INTRINSIC
     207                 :            :   UNSPECV_LWPINS_INTRINSIC
     208                 :            :   UNSPECV_RDFSBASE
     209                 :            :   UNSPECV_RDGSBASE
     210                 :            :   UNSPECV_WRFSBASE
     211                 :            :   UNSPECV_WRGSBASE
     212                 :            :   UNSPECV_FXSAVE
     213                 :            :   UNSPECV_FXRSTOR
     214                 :            :   UNSPECV_FXSAVE64
     215                 :            :   UNSPECV_FXRSTOR64
     216                 :            :   UNSPECV_XSAVE
     217                 :            :   UNSPECV_XRSTOR
     218                 :            :   UNSPECV_XSAVE64
     219                 :            :   UNSPECV_XRSTOR64
     220                 :            :   UNSPECV_XSAVEOPT
     221                 :            :   UNSPECV_XSAVEOPT64
     222                 :            :   UNSPECV_XSAVES
     223                 :            :   UNSPECV_XRSTORS
     224                 :            :   UNSPECV_XSAVES64
     225                 :            :   UNSPECV_XRSTORS64
     226                 :            :   UNSPECV_XSAVEC
     227                 :            :   UNSPECV_XSAVEC64
     228                 :            :   UNSPECV_XGETBV
     229                 :            :   UNSPECV_XSETBV
     230                 :            :   UNSPECV_WBINVD
     231                 :            :   UNSPECV_WBNOINVD
     232                 :            : 
     233                 :            :   ;; For atomic compound assignments.
     234                 :            :   UNSPECV_FNSTENV
     235                 :            :   UNSPECV_FLDENV
     236                 :            :   UNSPECV_FNSTSW
     237                 :            :   UNSPECV_FNCLEX
     238                 :            : 
     239                 :            :   ;; For RDRAND support
     240                 :            :   UNSPECV_RDRAND
     241                 :            : 
     242                 :            :   ;; For RDSEED support
     243                 :            :   UNSPECV_RDSEED
     244                 :            : 
     245                 :            :   ;; For RTM support
     246                 :            :   UNSPECV_XBEGIN
     247                 :            :   UNSPECV_XEND
     248                 :            :   UNSPECV_XABORT
     249                 :            :   UNSPECV_XTEST
     250                 :            : 
     251                 :            :   UNSPECV_NLGR
     252                 :            : 
     253                 :            :   ;; For CLWB support
     254                 :            :   UNSPECV_CLWB
     255                 :            : 
     256                 :            :   ;; For CLFLUSHOPT support
     257                 :            :   UNSPECV_CLFLUSHOPT
     258                 :            : 
     259                 :            :   ;; For MONITORX and MWAITX support 
     260                 :            :   UNSPECV_MONITORX
     261                 :            :   UNSPECV_MWAITX
     262                 :            : 
     263                 :            :   ;; For CLZERO support
     264                 :            :   UNSPECV_CLZERO
     265                 :            : 
     266                 :            :   ;; For RDPKRU and WRPKRU support
     267                 :            :   UNSPECV_PKU
     268                 :            : 
     269                 :            :   ;; For RDPID support
     270                 :            :   UNSPECV_RDPID
     271                 :            : 
     272                 :            :   ;; For CET support
     273                 :            :   UNSPECV_NOP_ENDBR
     274                 :            :   UNSPECV_NOP_RDSSP
     275                 :            :   UNSPECV_INCSSP
     276                 :            :   UNSPECV_SAVEPREVSSP
     277                 :            :   UNSPECV_RSTORSSP
     278                 :            :   UNSPECV_WRSS
     279                 :            :   UNSPECV_WRUSS
     280                 :            :   UNSPECV_SETSSBSY
     281                 :            :   UNSPECV_CLRSSBSY
     282                 :            : 
     283                 :            :   ;; For MOVDIRI and MOVDIR64B support
     284                 :            :   UNSPECV_MOVDIRI
     285                 :            :   UNSPECV_MOVDIR64B
     286                 :            : 
     287                 :            :   ;; For WAITPKG support
     288                 :            :   UNSPECV_UMWAIT
     289                 :            :   UNSPECV_UMONITOR
     290                 :            :   UNSPECV_TPAUSE
     291                 :            : 
     292                 :            :   ;; For CLDEMOTE support
     293                 :            :   UNSPECV_CLDEMOTE
     294                 :            : 
     295                 :            :   ;; For Speculation Barrier support
     296                 :            :   UNSPECV_SPECULATION_BARRIER
     297                 :            : 
     298                 :            :   UNSPECV_PTWRITE
     299                 :            : 
     300                 :            :   ;; For ENQCMD and ENQCMDS support
     301                 :            :   UNSPECV_ENQCMD
     302                 :            :   UNSPECV_ENQCMDS
     303                 :            : ])
     304                 :            : 
     305                 :            : ;; Constants to represent rounding modes in the ROUND instruction
     306                 :            : (define_constants
     307                 :            :   [(ROUND_ROUNDEVEN             0x0)
     308                 :            :    (ROUND_FLOOR                 0x1)
     309                 :            :    (ROUND_CEIL                  0x2)
     310                 :            :    (ROUND_TRUNC                 0x3)
     311                 :            :    (ROUND_MXCSR                 0x4)
     312                 :            :    (ROUND_NO_EXC                0x8)
     313                 :            :   ])
     314                 :            : 
     315                 :            : ;; Constants to represent AVX512F embeded rounding
     316                 :            : (define_constants
     317                 :            :   [(ROUND_NEAREST_INT                   0)
     318                 :            :    (ROUND_NEG_INF                       1)
     319                 :            :    (ROUND_POS_INF                       2)
     320                 :            :    (ROUND_ZERO                          3)
     321                 :            :    (NO_ROUND                            4)
     322                 :            :    (ROUND_SAE                           8)
     323                 :            :   ])
     324                 :            : 
     325                 :            : ;; Constants to represent pcomtrue/pcomfalse variants
     326                 :            : (define_constants
     327                 :            :   [(PCOM_FALSE                  0)
     328                 :            :    (PCOM_TRUE                   1)
     329                 :            :    (COM_FALSE_S                 2)
     330                 :            :    (COM_FALSE_P                 3)
     331                 :            :    (COM_TRUE_S                  4)
     332                 :            :    (COM_TRUE_P                  5)
     333                 :            :   ])
     334                 :            : 
     335                 :            : ;; Constants used in the XOP pperm instruction
     336                 :            : (define_constants
     337                 :            :   [(PPERM_SRC                   0x00)   /* copy source */
     338                 :            :    (PPERM_INVERT                0x20)   /* invert source */
     339                 :            :    (PPERM_REVERSE               0x40)   /* bit reverse source */
     340                 :            :    (PPERM_REV_INV               0x60)   /* bit reverse & invert src */
     341                 :            :    (PPERM_ZERO                  0x80)   /* all 0's */
     342                 :            :    (PPERM_ONES                  0xa0)   /* all 1's */
     343                 :            :    (PPERM_SIGN                  0xc0)   /* propagate sign bit */
     344                 :            :    (PPERM_INV_SIGN              0xe0)   /* invert & propagate sign */
     345                 :            :    (PPERM_SRC1                  0x00)   /* use first source byte */
     346                 :            :    (PPERM_SRC2                  0x10)   /* use second source byte */
     347                 :            :    ])
     348                 :            : 
     349                 :            : ;; Registers by name.
     350                 :            : (define_constants
     351                 :            :   [(AX_REG                       0)
     352                 :            :    (DX_REG                       1)
     353                 :            :    (CX_REG                       2)
     354                 :            :    (BX_REG                       3)
     355                 :            :    (SI_REG                       4)
     356                 :            :    (DI_REG                       5)
     357                 :            :    (BP_REG                       6)
     358                 :            :    (SP_REG                       7)
     359                 :            :    (ST0_REG                      8)
     360                 :            :    (ST1_REG                      9)
     361                 :            :    (ST2_REG                     10)
     362                 :            :    (ST3_REG                     11)
     363                 :            :    (ST4_REG                     12)
     364                 :            :    (ST5_REG                     13)
     365                 :            :    (ST6_REG                     14)
     366                 :            :    (ST7_REG                     15)
     367                 :            :    (ARGP_REG                    16)
     368                 :            :    (FLAGS_REG                   17)
     369                 :            :    (FPSR_REG                    18)
     370                 :            :    (FRAME_REG                   19)
     371                 :            :    (XMM0_REG                    20)
     372                 :            :    (XMM1_REG                    21)
     373                 :            :    (XMM2_REG                    22)
     374                 :            :    (XMM3_REG                    23)
     375                 :            :    (XMM4_REG                    24)
     376                 :            :    (XMM5_REG                    25)
     377                 :            :    (XMM6_REG                    26)
     378                 :            :    (XMM7_REG                    27)
     379                 :            :    (MM0_REG                     28)
     380                 :            :    (MM1_REG                     29)
     381                 :            :    (MM2_REG                     30)
     382                 :            :    (MM3_REG                     31)
     383                 :            :    (MM4_REG                     32)
     384                 :            :    (MM5_REG                     33)
     385                 :            :    (MM6_REG                     34)
     386                 :            :    (MM7_REG                     35)
     387                 :            :    (R8_REG                      36)
     388                 :            :    (R9_REG                      37)
     389                 :            :    (R10_REG                     38)
     390                 :            :    (R11_REG                     39)
     391                 :            :    (R12_REG                     40)
     392                 :            :    (R13_REG                     41)
     393                 :            :    (R14_REG                     42)
     394                 :            :    (R15_REG                     43)
     395                 :            :    (XMM8_REG                    44)
     396                 :            :    (XMM9_REG                    45)
     397                 :            :    (XMM10_REG                   46)
     398                 :            :    (XMM11_REG                   47)
     399                 :            :    (XMM12_REG                   48)
     400                 :            :    (XMM13_REG                   49)
     401                 :            :    (XMM14_REG                   50)
     402                 :            :    (XMM15_REG                   51)
     403                 :            :    (XMM16_REG                   52)
     404                 :            :    (XMM17_REG                   53)
     405                 :            :    (XMM18_REG                   54)
     406                 :            :    (XMM19_REG                   55)
     407                 :            :    (XMM20_REG                   56)
     408                 :            :    (XMM21_REG                   57)
     409                 :            :    (XMM22_REG                   58)
     410                 :            :    (XMM23_REG                   59)
     411                 :            :    (XMM24_REG                   60)
     412                 :            :    (XMM25_REG                   61)
     413                 :            :    (XMM26_REG                   62)
     414                 :            :    (XMM27_REG                   63)
     415                 :            :    (XMM28_REG                   64)
     416                 :            :    (XMM29_REG                   65)
     417                 :            :    (XMM30_REG                   66)
     418                 :            :    (XMM31_REG                   67)
     419                 :            :    (MASK0_REG                   68)
     420                 :            :    (MASK1_REG                   69)
     421                 :            :    (MASK2_REG                   70)
     422                 :            :    (MASK3_REG                   71)
     423                 :            :    (MASK4_REG                   72)
     424                 :            :    (MASK5_REG                   73)
     425                 :            :    (MASK6_REG                   74)
     426                 :            :    (MASK7_REG                   75)
     427                 :            :    (FIRST_PSEUDO_REG            76)
     428                 :            :   ])
     429                 :            : 
     430                 :            : ;; Insns whose names begin with "x86_" are emitted by gen_FOO calls
     431                 :            : ;; from i386.c.
     432                 :            : 
     433                 :            : ;; In C guard expressions, put expressions which may be compile-time
     434                 :            : ;; constants first.  This allows for better optimization.  For
     435                 :            : ;; example, write "TARGET_64BIT && reload_completed", not
     436                 :            : ;; "reload_completed && TARGET_64BIT".
     437                 :            : 
     438                 :            : 
     439                 :            : ;; Processor type.
     440                 :            : (define_attr "cpu" "none,pentium,pentiumpro,geode,k6,athlon,k8,core2,nehalem,
     441                 :            :                     atom,slm,glm,haswell,generic,amdfam10,bdver1,bdver2,bdver3,
     442                 :            :                     bdver4,btver2,znver1,znver2"
     443                 :     943388 :   (const (symbol_ref "ix86_schedule")))
     444                 :     261600 : 
     445                 :            : ;; A basic instruction type.  Refinements due to arguments to be
     446                 :         96 : ;; provided in other attributes.
     447                 :     943388 : (define_attr "type"
     448                 :   20942400 :   "other,multi,
     449                 :     943388 :    alu,alu1,negnot,imov,imovx,lea,
     450                 :   34940700 :    incdec,ishift,ishiftx,ishift1,rotate,rotatex,rotate1,
     451                 :     943388 :    imul,imulx,idiv,icmp,test,ibr,setcc,icmov,
     452                 :          0 :    push,pop,call,callv,leave,
     453                 :   14855400 :    str,bitmanip,
     454                 :    3996240 :    fmov,fop,fsgn,fmul,fdiv,fpspc,fcmov,fcmp,
     455                 :    3998110 :    fxch,fistp,fisttp,frndint,
     456                 :       9955 :    sse,ssemov,sseadd,sseadd1,sseiadd,sseiadd1,
     457                 :       8088 :    ssemul,sseimul,ssediv,sselog,sselog1,
     458                 :   10484500 :    sseishft,sseishft1,ssecmp,ssecomi,
     459                 :   30133100 :    ssecvt,ssecvt1,sseicvt,sseins,
     460                 :   32828900 :    sseshuf,sseshuf1,ssemuladd,sse4arg,
     461                 :    2695740 :    lwp,mskmov,msklog,
     462                 :    6560700 :    mmx,mmxmov,mmxadd,mmxmul,mmxcmp,mmxcvt,mmxshft"
     463                 :    6697910 :   (const_string "other"))
     464                 :          0 : 
     465                 :          0 : ;; Main data type used by the insn
     466                 :          0 : (define_attr "mode"
     467                 :          0 :   "unknown,none,QI,HI,SI,DI,TI,OI,XI,SF,DF,XF,TF,V16SF,V8SF,V4DF,V4SF,
     468                 :    1773170 :   V2DF,V2SF,V1DF,V8DF"
     469                 :          4 :   (const_string "unknown"))
     470                 :          4 : 
     471                 :          0 : ;; The CPU unit operations uses.
     472                 :    7146160 : (define_attr "unit" "integer,i387,sse,mmx,unknown"
     473                 :   20740400 :   (cond [(eq_attr "type" "fmov,fop,fsgn,fmul,fdiv,fpspc,fcmov,fcmp,
     474                 :          4 :                           fxch,fistp,fisttp,frndint")
     475                 :   23443300 :            (const_string "i387")
     476                 :   23443300 :          (eq_attr "type" "sse,ssemov,sseadd,sseadd1,sseiadd,sseiadd1,
     477                 :          9 :                           ssemul,sseimul,ssediv,sselog,sselog1,
     478                 :          9 :                           sseishft,sseishft1,ssecmp,ssecomi,
     479                 :    3714230 :                           ssecvt,ssecvt1,sseicvt,sseins,
     480                 :          0 :                           sseshuf,sseshuf1,ssemuladd,sse4arg,mskmov")
     481                 :   21222100 :            (const_string "sse")
     482                 :   23443300 :          (eq_attr "type" "mmx,mmxmov,mmxadd,mmxmul,mmxcmp,mmxcvt,mmxshft")
     483                 :          0 :            (const_string "mmx")
     484                 :          0 :          (eq_attr "type" "other")
     485                 :          0 :            (const_string "unknown")]
     486                 :          2 :          (const_string "integer")))
     487                 :  293297000 : 
     488                 :          2 : ;; The (bounding maximum) length of an instruction immediate.
     489                 :          0 : (define_attr "length_immediate" ""
     490                 :          0 :   (cond [(eq_attr "type" "incdec,setcc,icmov,str,lea,other,multi,idiv,leave,
     491                 :   23443300 :                           bitmanip,imulx,msklog,mskmov")
     492                 :  269853000 :            (const_int 0)
     493                 :          0 :          (eq_attr "unit" "i387,sse,mmx")
     494                 :   80317400 :            (const_int 0)
     495                 :          0 :          (eq_attr "type" "alu,alu1,negnot,imovx,ishift,ishiftx,ishift1,
     496                 :   56874100 :                           rotate,rotatex,rotate1,imul,icmp,push,pop")
     497                 :    1919050 :            (symbol_ref "ix86_attr_length_immediate_default (insn, true)")
     498                 :          2 :          (eq_attr "type" "imov,test")
     499                 :    6377730 :            (symbol_ref "ix86_attr_length_immediate_default (insn, false)")
     500                 :   46966600 :          (eq_attr "type" "call")
     501                 :    6379520 :            (if_then_else (match_operand 0 "constant_call_address_operand")
     502                 :     627126 :              (const_int 4)
     503                 :   10214000 :              (const_int 0))
     504                 :    9598600 :          (eq_attr "type" "callv")
     505                 :    1061940 :            (if_then_else (match_operand 1 "constant_call_address_operand")
     506                 :     573039 :              (const_int 4)
     507                 :     145991 :              (const_int 0))
     508                 :    6804680 :          ;; We don't know the size before shorten_branches.  Expect
     509                 :     543949 :          ;; the instruction to fit for better scheduling.
     510                 :    4528480 :          (eq_attr "type" "ibr")
     511                 :       4291 :            (const_int 1)
     512                 :       2566 :          ]
     513                 :    1684370 :          (symbol_ref "/* Update immediate_length and other attributes! */
     514                 :    1673800 :                       gcc_unreachable (),1")))
     515                 :     535333 : 
     516                 :     454356 : ;; The (bounding maximum) length of an instruction address.
     517                 :      75109 : (define_attr "length_address" ""
     518                 :  213814000 :   (cond [(eq_attr "type" "str,other,multi,fxch")
     519                 :  209152000 :            (const_int 0)
     520                 :     224457 :          (and (eq_attr "type" "call")
     521                 :        551 :               (match_operand 0 "constant_call_address_operand"))
     522                 :     145971 :              (const_int 0)
     523                 :   52332800 :          (and (eq_attr "type" "callv")
     524                 :    4831410 :               (match_operand 1 "constant_call_address_operand"))
     525                 :  161736000 :              (const_int 0)
     526                 :         20 :          ]
     527                 :       4678 :          (symbol_ref "ix86_attr_length_address_default (insn)")))
     528                 :    5786700 : 
     529                 :  110081000 : ;; Set when length prefix is used.
     530                 :         60 : (define_attr "prefix_data16" ""
     531                 :  381555000 :   (cond [(eq_attr "type" "ssemuladd,sse4arg,sseiadd1,ssecvt1")
     532                 :  274658000 :            (const_int 0)
     533                 :    2226080 :          (eq_attr "mode" "HI")
     534                 :   67617100 :            (const_int 1)
     535                 :     465699 :          (and (eq_attr "unit" "sse") (eq_attr "mode" "V2DF,TI"))
     536                 :    2989690 :            (const_int 1)
     537                 :    2885890 :         ]
     538                 :  402384000 :         (const_int 0)))
     539                 :    3860390 : 
     540                 :   14482500 : ;; Set when string REP prefix is used.
     541                 :   19321000 : (define_attr "prefix_rep" ""
     542                 :    7802050 :   (cond [(eq_attr "type" "ssemuladd,sse4arg,sseiadd1,ssecvt1")
     543                 :          0 :            (const_int 0)
     544                 :     149489 :          (and (eq_attr "unit" "sse") (eq_attr "mode" "SF,DF"))
     545                 :        108 :            (const_int 1)
     546                 :    2898080 :         ]
     547                 :   13608600 :         (const_int 0)))
     548                 :     370805 : 
     549                 :   43136900 : ;; Set when 0f opcode prefix is used.
     550                 :    2897320 : (define_attr "prefix_0f" ""
     551                 :   13561300 :   (if_then_else
     552                 :    2933410 :     (ior (eq_attr "type" "imovx,setcc,icmov,bitmanip,msklog,mskmov")
     553                 :      15635 :          (eq_attr "unit" "sse,mmx"))
     554                 :      15635 :     (const_int 1)
     555                 :   13525200 :     (const_int 0)))
     556                 :         68 : 
     557                 :   13525000 : ;; Set when REX opcode prefix is used.
     558                 :      36088 : (define_attr "prefix_rex" ""
     559                 :    1734380 :   (cond [(not (match_test "TARGET_64BIT"))
     560                 :   43346800 :            (const_int 0)
     561                 :  459917000 :          (and (eq_attr "mode" "DI")
     562                 :          0 :               (and (eq_attr "type" "!push,pop,call,callv,leave,ibr")
     563                 :  361479000 :                    (eq_attr "unit" "!mmx")))
     564                 :      15194 :            (const_int 1)
     565                 :   17343300 :          (and (eq_attr "mode" "QI")
     566                 :    6855560 :               (match_test "x86_extended_QIreg_mentioned_p (insn)"))
     567                 :  192528000 :            (const_int 1)
     568                 :   96201700 :          (match_test "x86_extended_reg_mentioned_p (insn)")
     569                 :    2894830 :            (const_int 1)
     570                 :  112320000 :          (and (eq_attr "type" "imovx")
     571                 :  183872000 :               (match_operand:QI 1 "ext_QIreg_operand"))
     572                 :    5299660 :            (const_int 1)
     573                 :   35657600 :         ]
     574                 :   66837600 :         (const_int 0)))
     575                 :  167826000 : 
     576                 :    2236100 : ;; There are also additional prefixes in 3DNOW, SSSE3.
     577                 :    5838340 : ;; ssemuladd,sse4arg default to 0f24/0f25 and DREX byte,
     578                 :  141578000 : ;; sseiadd1,ssecvt1 to 0f7a with no DREX byte.
     579                 :  293509000 : ;; 3DNOW has 0f0f prefix, SSSE3 and SSE4_{1,2} 0f38/0f3a.
     580                 :    2064600 : (define_attr "prefix_extra" ""
     581                 :    1468870 :   (cond [(eq_attr "type" "ssemuladd,sse4arg")
     582                 :  157562000 :            (const_int 2)
     583                 :  321468000 :          (eq_attr "type" "sseiadd1,ssecvt1")
     584                 :      14135 :            (const_int 1)
     585                 :  110502000 :         ]
     586                 :  274386000 :         (const_int 0)))
     587                 :   45208900 : 
     588                 :    3863380 : ;; Prefix used: original, VEX or maybe VEX.
     589                 :     658952 : (define_attr "prefix" "orig,vex,maybe_vex,evex,maybe_evex"
     590                 :     305634 :   (cond [(eq_attr "mode" "OI,V8SF,V4DF")
     591                 :       2962 :            (const_string "vex")
     592                 :    7098780 :          (eq_attr "mode" "XI,V16SF,V8DF")
     593                 :   48663400 :            (const_string "evex")
     594                 :    3029610 :         ]
     595                 :   12566000 :         (const_string "orig")))
     596                 :   12630300 : 
     597                 :   42847200 : ;; VEX W bit is used.
     598                 :   35828100 : (define_attr "prefix_vex_w" "" (const_int 0))
     599                 :        291 : 
     600                 :    2653240 : ;; The length of VEX prefix
     601                 :      56001 : ;; Only instructions with 0f prefix can have 2 byte VEX prefix,
     602                 :   48280900 : ;; 0f38/0f3a prefixes can't.  In i386.md 0f3[8a] is
     603                 :     616239 : ;; still prefix_0f 1, with prefix_extra 1.
     604                 :    4516140 : (define_attr "length_vex" ""
     605                 :    5233340 :   (if_then_else (and (eq_attr "prefix_0f" "1")
     606                 :     717196 :                      (eq_attr "prefix_extra" "0"))
     607                 :    1236380 :     (if_then_else (eq_attr "prefix_vex_w" "1")
     608                 :   36776200 :       (symbol_ref "ix86_attr_length_vex_default (insn, true, true)")
     609                 :       4987 :       (symbol_ref "ix86_attr_length_vex_default (insn, true, false)"))
     610                 :          0 :     (if_then_else (eq_attr "prefix_vex_w" "1")
     611                 :       7988 :       (symbol_ref "ix86_attr_length_vex_default (insn, false, true)")
     612                 :     432227 :       (symbol_ref "ix86_attr_length_vex_default (insn, false, false)"))))
     613                 :     213978 : 
     614                 :      28563 : ;; 4-bytes evex prefix and 1 byte opcode.
     615                 :      10829 : (define_attr "length_evex" "" (const_int 5))
     616                 :    1219790 : 
     617                 :    1987770 : ;; Set when modrm byte is used.
     618                 :    1948910 : (define_attr "modrm" ""
     619                 :    2231700 :   (cond [(eq_attr "type" "str,leave")
     620                 :     650585 :            (const_int 0)
     621                 :     122900 :          (eq_attr "unit" "i387")
     622                 :  276741000 :            (const_int 0)
     623                 :     298769 :          (and (eq_attr "type" "incdec")
     624                 :     130033 :               (and (not (match_test "TARGET_64BIT"))
     625                 :          0 :                    (ior (match_operand:SI 1 "register_operand")
     626                 :          0 :                         (match_operand:HI 1 "register_operand"))))
     627                 :     141438 :            (const_int 0)
     628                 :     141438 :          (and (eq_attr "type" "push")
     629                 :     543959 :               (not (match_operand 1 "memory_operand")))
     630                 :     543949 :            (const_int 0)
     631                 :          0 :          (and (eq_attr "type" "pop")
     632                 :     141422 :               (not (match_operand 0 "memory_operand")))
     633                 :      36862 :            (const_int 0)
     634                 :      40584 :          (and (eq_attr "type" "imov")
     635                 :       3724 :               (and (not (eq_attr "mode" "DI"))
     636                 :     543949 :                    (ior (and (match_operand 0 "register_operand")
     637                 :         30 :                              (match_operand 1 "immediate_operand"))
     638                 :     149109 :                         (ior (and (match_operand 0 "ax_reg_operand")
     639                 :          2 :                                   (match_operand 1 "memory_displacement_only_operand"))
     640                 :          0 :                              (and (match_operand 0 "memory_displacement_only_operand")
     641                 :          0 :                                   (match_operand 1 "ax_reg_operand"))))))
     642                 :     160150 :            (const_int 0)
     643                 :     165515 :          (and (eq_attr "type" "call")
     644                 :       6675 :               (match_operand 0 "constant_call_address_operand"))
     645                 :   63470200 :              (const_int 0)
     646                 :       1129 :          (and (eq_attr "type" "callv")
     647                 :     161252 :               (match_operand 1 "constant_call_address_operand"))
     648                 :       2547 :              (const_int 0)
     649                 :       2547 :          (and (eq_attr "type" "alu,alu1,icmp,test")
     650                 :   64381600 :               (match_operand 0 "ax_reg_operand"))
     651                 :    9004210 :              (symbol_ref "(get_attr_length_immediate (insn) <= (get_attr_mode (insn) != MODE_QI))")
     652                 :          0 :          ]
     653                 :     158595 :          (const_int 1)))
     654                 :   64378000 : 
     655                 :  155831000 : ;; The (bounding maximum) length of an instruction in bytes.
     656                 :          0 : ;; ??? fistp and frndint are in fact fldcw/{fistp,frndint}/fldcw sequences.
     657                 :        822 : ;; Later we may want to split them and compute proper length as for
     658                 :        822 : ;; other insns.
     659                 :  150236000 : (define_attr "length" ""
     660                 :  110454000 :   (cond [(eq_attr "type" "other,multi,fistp,frndint")
     661                 :    3591220 :            (const_int 16)
     662                 :     219077 :          (eq_attr "type" "fcmp")
     663                 :      50604 :            (const_int 4)
     664                 :     431390 :          (eq_attr "unit" "i387")
     665                 :     431508 :            (plus (const_int 2)
     666                 :  105876000 :                  (plus (attr "prefix_data16")
     667                 :    3715120 :                        (attr "length_address")))
     668                 :      74322 :          (ior (eq_attr "prefix" "evex")
     669                 :  403917000 :               (and (ior (eq_attr "prefix" "maybe_evex")
     670                 :  117801000 :                         (eq_attr "prefix" "maybe_vex"))
     671                 :   16269300 :                    (match_test "TARGET_AVX512F")))
     672                 :    1884290 :            (plus (attr "length_evex")
     673                 :    2989250 :                  (plus (attr "length_immediate")
     674                 :  105876000 :                        (plus (attr "modrm")
     675                 :  199837000 :                              (attr "length_address"))))
     676                 :     440518 :          (ior (eq_attr "prefix" "vex")
     677                 :   12118100 :               (and (ior (eq_attr "prefix" "maybe_vex")
     678                 :   65719800 :                         (eq_attr "prefix" "maybe_evex"))
     679                 :   51554600 :                    (match_test "TARGET_AVX")))
     680                 :     433302 :            (plus (attr "length_vex")
     681                 :    8026950 :                  (plus (attr "length_immediate")
     682                 :    4175540 :                        (plus (attr "modrm")
     683                 :     763162 :                              (attr "length_address"))))]
     684                 :       1566 :          (plus (plus (attr "modrm")
     685                 :  193781000 :                      (plus (attr "prefix_0f")
     686                 :       2547 :                            (plus (attr "prefix_rex")
     687                 :          0 :                                  (plus (attr "prefix_extra")
     688                 :    3869520 :                                        (const_int 1)))))
     689                 :     127082 :                (plus (attr "prefix_rep")
     690                 :     644921 :                      (plus (attr "prefix_data16")
     691                 :    3275580 :                            (plus (attr "length_immediate")
     692                 :  103376000 :                                  (attr "length_address")))))))
     693                 :  101673000 : 
     694                 :   64931800 : ;; The `memory' attribute is `none' if no memory is referenced, `load' or
     695                 :  305893948 : ;; `store' if there is a simple memory reference therein, or `unknown'
     696                 :     148269 : ;; if the instruction is complex.
     697                 :  102078000 : 
     698                 :    1412150 : (define_attr "memory" "none,load,store,both,unknown"
     699                 :     513031 :   (cond [(eq_attr "type" "other,multi,str,lwp")
     700                 :  247000000 :            (const_string "unknown")
     701                 :    3974990 :          (eq_attr "type" "lea,fcmov,fpspc")
     702                 :    3975000 :            (const_string "none")
     703                 :  140557000 :          (eq_attr "type" "fistp,leave")
     704                 :       5777 :            (const_string "both")
     705                 :    1672830 :          (eq_attr "type" "frndint")
     706                 :    2002460 :            (const_string "load")
     707                 :  212780000 :          (eq_attr "type" "push")
     708                 :  212465000 :            (if_then_else (match_operand 1 "memory_operand")
     709                 :          0 :              (const_string "both")
     710                 :     836828 :              (const_string "store"))
     711                 :       3900 :          (eq_attr "type" "pop")
     712                 :  211078000 :            (if_then_else (match_operand 0 "memory_operand")
     713                 :     329451 :              (const_string "both")
     714                 :      10945 :              (const_string "load"))
     715                 :       1120 :          (eq_attr "type" "setcc")
     716                 :     103893 :            (if_then_else (match_operand 0 "memory_operand")
     717                 :     103871 :              (const_string "store")
     718                 :  210882000 :              (const_string "none"))
     719                 :     280255 :          (eq_attr "type" "icmp,test,ssecmp,ssecomi,mmxcmp,fcmp")
     720                 :     977416 :            (if_then_else (ior (match_operand 0 "memory_operand")
     721                 :    6764900 :                               (match_operand 1 "memory_operand"))
     722                 :    6445590 :              (const_string "load")
     723                 :     511450 :              (const_string "none"))
     724                 :          0 :          (eq_attr "type" "ibr")
     725                 :      56409 :            (if_then_else (match_operand 0 "memory_operand")
     726                 :     323334 :              (const_string "load")
     727                 :     567178 :              (const_string "none"))
     728                 :    1109320 :          (eq_attr "type" "call")
     729                 :    8721050 :            (if_then_else (match_operand 0 "constant_call_address_operand")
     730                 :    2885830 :              (const_string "none")
     731                 :    6579750 :              (const_string "load"))
     732                 :   10836000 :          (eq_attr "type" "callv")
     733                 :    4358100 :            (if_then_else (match_operand 1 "constant_call_address_operand")
     734                 :   15553500 :              (const_string "none")
     735                 :          0 :              (const_string "load"))
     736                 :    7252260 :          (and (eq_attr "type" "alu1,negnot,ishift1,rotate1,sselog1,sseshuf1")
     737                 :     777588 :               (match_operand 1 "memory_operand"))
     738                 :      46223 :            (const_string "both")
     739                 :    1405930 :          (and (match_operand 0 "memory_operand")
     740                 :   10893300 :               (match_operand 1 "memory_operand"))
     741                 :         38 :            (const_string "both")
     742                 :   84082200 :          (match_operand 0 "memory_operand")
     743                 :     735597 :            (const_string "store")
     744                 :       3766 :          (match_operand 1 "memory_operand")
     745                 :       3734 :            (const_string "load")
     746                 :          0 :          (and (eq_attr "type"
     747                 :          0 :                  "!alu1,negnot,ishift1,rotate1,
     748                 :    2275840 :                    imov,imovx,icmp,test,bitmanip,
     749                 :    4480330 :                    fmov,fcmp,fsgn,
     750                 :    2204490 :                    sse,ssemov,ssecmp,ssecomi,ssecvt,ssecvt1,sseicvt,
     751                 :          0 :                    sselog1,sseshuf1,sseadd1,sseiadd1,sseishft1,
     752                 :   88866300 :                    mmx,mmxmov,mmxcmp,mmxcvt,mskmov,msklog")
     753                 :      30298 :               (match_operand 2 "memory_operand"))
     754                 :   89389400 :            (const_string "load")
     755                 :    6383720 :          (and (eq_attr "type" "icmov,ssemuladd,sse4arg")
     756                 :    1469070 :               (match_operand 3 "memory_operand"))
     757                 :   83519500 :            (const_string "load")
     758                 :      28681 :         ]
     759                 :    8270530 :         (const_string "none")))
     760                 :   28707200 : 
     761                 :   25066000 : ;; Indicates if an instruction has both an immediate and a displacement.
     762                 :   61055900 : 
     763                 :       7184 : (define_attr "imm_disp" "false,true,unknown"
     764                 :       7184 :   (cond [(eq_attr "type" "other,multi")
     765                 :   61048700 :            (const_string "unknown")
     766                 :    1344290 :          (and (eq_attr "type" "icmp,test,imov,alu1,ishift1,rotate1")
     767                 :   46830600 :               (and (match_operand 0 "memory_displacement_operand")
     768                 : 1184850000 :                    (match_operand 1 "immediate_operand")))
     769                 :  618117000 :            (const_string "true")
     770                 :  765519000 :          (and (eq_attr "type" "alu,ishift,ishiftx,rotate,rotatex,imul,idiv")
     771                 :          0 :               (and (match_operand 0 "memory_displacement_operand")
     772                 :     390354 :                    (match_operand 2 "immediate_operand")))
     773                 :    4513430 :            (const_string "true")
     774                 :    4514060 :         ]
     775                 :       5090 :         (const_string "false")))
     776                 :     186347 : 
     777                 :     181257 : ;; Indicates if an FP operation has an integer source.
     778                 :      24816 : 
     779                 :      24933 : (define_attr "fp_int_src" "false,true"
     780                 :        117 :   (const_string "false"))
     781                 :   50770600 : 
     782                 :   16906400 : ;; Defines rounding mode of an FP operation.
     783                 :   16913400 : 
     784                 :          0 : (define_attr "i387_cw" "roundeven,floor,ceil,trunc,uninitialized,any"
     785                 :          0 :   (const_string "any"))
     786                 :         76 : 
     787                 :          0 : ;; Define attribute to indicate AVX insns with partial XMM register update.
     788                 :          0 : (define_attr "avx_partial_xmm_update" "false,true"
     789                 :     529996 :   (const_string "false"))
     790                 :     523010 : 
     791                 :   44245600 : ;; Define attribute to classify add/sub insns that consumes carry flag (CF)
     792                 :   44245600 : (define_attr "use_carry" "0,1" (const_string "0"))
     793                 :          0 : 
     794                 :          0 : ;; Define attribute to indicate unaligned ssemov insns
     795                 :   44251200 : (define_attr "movu" "0,1" (const_string "0"))
     796                 :     388983 : 
     797                 :       9624 : ;; Used to control the "enabled" attribute on a per-instruction basis.
     798                 :       9624 : (define_attr "isa" "base,x64,x64_sse2,x64_sse4,x64_sse4_noavx,x64_avx,nox64,
     799                 :  197279000 :                     sse_noavx,sse2,sse2_noavx,sse3,sse4,sse4_noavx,avx,noavx,
     800                 :          0 :                     avx2,noavx2,bmi,bmi2,fma4,fma,avx512f,noavx512f,
     801                 :          0 :                     avx512bw,noavx512bw,avx512dq,noavx512dq,
     802                 :   44245800 :                     avx512vl,noavx512vl,x64_avx512dq,x64_avx512bw"
     803                 :   44245800 :   (const_string "base"))
     804                 :          0 : 
     805                 :   44245800 : ;; Define instruction set of MMX instructions
     806                 :   44245800 : (define_attr "mmx_isa" "base,native,sse,sse_noavx,avx"
     807                 :        260 :   (const_string "base"))
     808                 :      20858 : 
     809                 :      20598 : (define_attr "enabled" ""
     810                 :   44247400 :   (cond [(eq_attr "isa" "x64") (symbol_ref "TARGET_64BIT")
     811                 :       1786 :          (eq_attr "isa" "x64_sse2")
     812                 :   47889100 :            (symbol_ref "TARGET_64BIT && TARGET_SSE2")
     813                 :       8894 :          (eq_attr "isa" "x64_sse4")
     814                 :  379714000 :            (symbol_ref "TARGET_64BIT && TARGET_SSE4_1")
     815                 :          0 :          (eq_attr "isa" "x64_sse4_noavx")
     816                 :       5355 :            (symbol_ref "TARGET_64BIT && TARGET_SSE4_1 && !TARGET_AVX")
     817                 :      77192 :          (eq_attr "isa" "x64_avx")
     818                 :     108578 :            (symbol_ref "TARGET_64BIT && TARGET_AVX")
     819                 :       8114 :          (eq_attr "isa" "x64_avx512dq")
     820                 :      27981 :            (symbol_ref "TARGET_64BIT && TARGET_AVX512DQ")
     821                 :    5894300 :          (eq_attr "isa" "x64_avx512bw")
     822                 :    5958290 :            (symbol_ref "TARGET_64BIT && TARGET_AVX512BW")
     823                 :   96027300 :          (eq_attr "isa" "nox64") (symbol_ref "!TARGET_64BIT")
     824                 :  538809000 :          (eq_attr "isa" "sse2") (symbol_ref "TARGET_SSE2")
     825                 :  284767000 :          (eq_attr "isa" "sse_noavx")
     826                 :     469457 :            (symbol_ref "TARGET_SSE && !TARGET_AVX")
     827                 :   50455500 :          (eq_attr "isa" "sse2_noavx")
     828                 :    7053300 :            (symbol_ref "TARGET_SSE2 && !TARGET_AVX")
     829                 :      20708 :          (eq_attr "isa" "sse3") (symbol_ref "TARGET_SSE3")
     830                 :  408816000 :          (eq_attr "isa" "sse4") (symbol_ref "TARGET_SSE4_1")
     831                 :   24341600 :          (eq_attr "isa" "sse4_noavx")
     832                 :   38095300 :            (symbol_ref "TARGET_SSE4_1 && !TARGET_AVX")
     833                 :   53733100 :          (eq_attr "isa" "avx") (symbol_ref "TARGET_AVX")
     834                 :  131446000 :          (eq_attr "isa" "noavx") (symbol_ref "!TARGET_AVX")
     835                 :   94029000 :          (eq_attr "isa" "avx2") (symbol_ref "TARGET_AVX2")
     836                 :  156218000 :          (eq_attr "isa" "noavx2") (symbol_ref "!TARGET_AVX2")
     837                 :     719341 :          (eq_attr "isa" "bmi") (symbol_ref "TARGET_BMI")
     838                 :     746517 :          (eq_attr "isa" "bmi2") (symbol_ref "TARGET_BMI2")
     839                 :   87794600 :          (eq_attr "isa" "fma4") (symbol_ref "TARGET_FMA4")
     840                 :     836730 :          (eq_attr "isa" "fma") (symbol_ref "TARGET_FMA")
     841                 :  106993000 :          (eq_attr "isa" "avx512f") (symbol_ref "TARGET_AVX512F")
     842                 :  106853000 :          (eq_attr "isa" "noavx512f") (symbol_ref "!TARGET_AVX512F")
     843                 :   61330400 :          (eq_attr "isa" "avx512bw") (symbol_ref "TARGET_AVX512BW")
     844                 :   50783500 :          (eq_attr "isa" "noavx512bw") (symbol_ref "!TARGET_AVX512BW")
     845                 :   10922300 :          (eq_attr "isa" "avx512dq") (symbol_ref "TARGET_AVX512DQ")
     846                 :     117890 :          (eq_attr "isa" "noavx512dq") (symbol_ref "!TARGET_AVX512DQ")
     847                 :      31134 :          (eq_attr "isa" "avx512vl") (symbol_ref "TARGET_AVX512VL")
     848                 :     235950 :          (eq_attr "isa" "noavx512vl") (symbol_ref "!TARGET_AVX512VL")
     849                 :   24421500 : 
     850                 :   87340900 :          (eq_attr "mmx_isa" "native")
     851                 :   22058300 :            (symbol_ref "!TARGET_MMX_WITH_SSE")
     852                 :     144473 :          (eq_attr "mmx_isa" "sse")
     853                 :  295025000 :            (symbol_ref "TARGET_MMX_WITH_SSE")
     854                 :  396876000 :          (eq_attr "mmx_isa" "sse_noavx")
     855                 :  108937000 :            (symbol_ref "TARGET_MMX_WITH_SSE && !TARGET_AVX")
     856                 :   46365800 :          (eq_attr "mmx_isa" "avx")
     857                 :   13620700 :            (symbol_ref "TARGET_MMX_WITH_SSE && TARGET_AVX")
     858                 :     195336 :         ]
     859                 :   31233300 :         (const_int 1)))
     860                 :   31625000 : 
     861                 :  106610000 : (define_attr "preferred_for_size" "" (const_int 1))
     862                 :    4266080 : (define_attr "preferred_for_speed" "" (const_int 1))
     863                 :       4366 : 
     864                 :       4199 : ;; Describe a user's asm statement.
     865                 :   51142400 : (define_asm_attributes
     866                 :   51145700 :   [(set_attr "length" "128")
     867                 :          0 :    (set_attr "type" "multi")])
     868                 :        242 : 
     869                 :      93844 : (define_code_iterator plusminus [plus minus])
     870                 :      94231 : 
     871                 :   98009800 : (define_code_iterator sat_plusminus [ss_plus us_plus ss_minus us_minus])
     872                 :      48593 : 
     873                 :       1710 : (define_code_iterator multdiv [mult div])
     874                 :          0 : 
     875                 :        570 : ;; Base name for define_insn
     876                 :         34 : (define_code_attr plusminus_insn
     877                 :   98779200 :   [(plus "add") (ss_plus "ssadd") (us_plus "usadd")
     878                 :   74474000 :    (minus "sub") (ss_minus "sssub") (us_minus "ussub")])
     879                 :   74474000 : 
     880                 :      80200 : ;; Base name for insn mnemonic.
     881                 :      80200 : (define_code_attr plusminus_mnemonic
     882                 :      22824 :   [(plus "add") (ss_plus "adds") (us_plus "addus")
     883                 :   75267900 :    (minus "sub") (ss_minus "subs") (us_minus "subus")])
     884                 :     771129 : (define_code_attr multdiv_mnemonic
     885                 :      80199 :   [(mult "mul") (div "div")])
     886                 :   23511300 : 
     887                 :   74480000 : ;; Mark commutative operators as such in constraints.
     888                 :          0 : (define_code_attr comm [(plus "%") (ss_plus "%") (us_plus "%")
     889                 :      70580 :                         (minus "") (ss_minus "") (us_minus "")])
     890                 :          0 : 
     891                 :       7341 : ;; Mapping of max and min
     892                 :       7341 : (define_code_iterator maxmin [smax smin umax umin])
     893                 :      59898 : 
     894                 :       2447 : ;; Mapping of signed max and min
     895                 :          0 : (define_code_iterator smaxmin [smax smin])
     896                 :          0 : 
     897                 :         34 : ;; Mapping of unsigned max and min
     898                 :          0 : (define_code_iterator umaxmin [umax umin])
     899                 :          0 : 
     900                 :          0 : ;; Base name for integer and FP insn mnemonic
     901                 :         27 : (define_code_attr maxmin_int [(smax "maxs") (smin "mins")
     902                 :     472728 :                               (umax "maxu") (umin "minu")])
     903                 :     472728 : (define_code_attr maxmin_float [(smax "max") (smin "min")])
     904                 :      20850 : 
     905                 :      20850 : (define_int_iterator IEEE_MAXMIN
     906                 :          0 :         [UNSPEC_IEEE_MAX
     907                 :       8340 :          UNSPEC_IEEE_MIN])
     908                 :          0 : 
     909                 :  121435000 : (define_int_attr ieee_maxmin
     910                 :   23494300 :         [(UNSPEC_IEEE_MAX "max")
     911                 :      11167 :          (UNSPEC_IEEE_MIN "min")])
     912                 :      11167 : 
     913                 :          0 : ;; Mapping of logic operators
     914                 :   26275100 : (define_code_iterator any_logic [and ior xor])
     915                 :       7968 : (define_code_iterator any_or [ior xor])
     916                 :      13488 : (define_code_iterator fpint_logic [and xor])
     917                 :   26267200 : 
     918                 :       2656 : ;; Base name for insn mnemonic.
     919                 :       4767 : (define_code_attr logic [(and "and") (ior "or") (xor "xor")])
     920                 :      10279 : 
     921                 :          0 : ;; Mapping of logic-shift operators
     922                 :    2792030 : (define_code_iterator any_lshift [ashift lshiftrt])
     923                 :    2792030 : 
     924                 :       2237 : ;; Mapping of shift-right operators
     925                 :      43715 : (define_code_iterator any_shiftrt [lshiftrt ashiftrt])
     926                 :      43715 : 
     927                 :          0 : ;; Mapping of all shift operators
     928                 :      18464 : (define_code_iterator any_shift [ashift lshiftrt ashiftrt])
     929                 :     217189 : 
     930                 :   23431400 : ;; Base name for define_insn
     931                 :          0 : (define_code_attr shift_insn
     932                 :       1702 :   [(ashift "ashl") (lshiftrt "lshr") (ashiftrt "ashr")])
     933                 :     172719 : 
     934                 :     172959 : ;; Base name for insn mnemonic.
     935                 :   28313600 : (define_code_attr shift [(ashift "sll") (lshiftrt "shr") (ashiftrt "sar")])
     936                 :   28313600 : (define_code_attr vshift [(ashift "sll") (lshiftrt "srl") (ashiftrt "sra")])
     937                 :   28313700 : 
     938                 :       1793 : ;; Mapping of rotate operators
     939                 :         94 : (define_code_iterator any_rotate [rotate rotatert])
     940                 :     118821 : 
     941                 :   28328900 : ;; Base name for define_insn
     942                 :      15288 : (define_code_attr rotate_insn [(rotate "rotl") (rotatert "rotr")])
     943                 :      15382 : 
     944                 :     212406 : ;; Base name for insn mnemonic.
     945                 :     212406 : (define_code_attr rotate [(rotate "rol") (rotatert "ror")])
     946                 :    5054950 : 
     947                 :    5055010 : ;; Mapping of abs neg operators
     948                 :          0 : (define_code_iterator absneg [abs neg])
     949                 :          0 : 
     950                 :   23258700 : ;; Base name for x87 insn mnemonic.
     951                 :         46 : (define_code_attr absneg_mnemonic [(abs "fabs") (neg "fchs")])
     952                 :          0 : 
     953                 :     208589 : ;; Used in signed and unsigned widening multiplications.
     954                 :          0 : (define_code_iterator any_extend [sign_extend zero_extend])
     955                 :         46 : 
     956                 :   32460800 : ;; Prefix for insn menmonic.
     957                 :          0 : (define_code_attr sgnprefix [(sign_extend "i") (zero_extend "")
     958                 :    9202120 :                              (div "i") (udiv "")])
     959                 :    9202120 : ;; Prefix for define_insn
     960                 :   23259100 : (define_code_attr s [(sign_extend "s") (zero_extend "u")])
     961                 :        417 : (define_code_attr u [(sign_extend "") (zero_extend "u")
     962                 :        414 :                      (div "") (udiv "u")])
     963                 :   23258700 : (define_code_attr u_bool [(sign_extend "false") (zero_extend "true")
     964                 :          0 :                           (div "false") (udiv "true")])
     965                 :    9202120 : 
     966                 :     111801 : ;; Used in signed and unsigned truncations.
     967                 :     111489 : (define_code_iterator any_truncate [ss_truncate truncate us_truncate])
     968                 :   23692800 : ;; Instruction suffix for truncations.
     969                 :   23692800 : (define_code_attr trunsuffix [(ss_truncate "s") (truncate "") (us_truncate "us")])
     970                 :     434108 : 
     971                 :     434108 : ;; Used in signed and unsigned fix.
     972                 :          0 : (define_code_iterator any_fix [fix unsigned_fix])
     973                 :          6 : (define_code_attr fixsuffix [(fix "") (unsigned_fix "u")])
     974                 :          0 : (define_code_attr fixunssuffix [(fix "") (unsigned_fix "uns")])
     975                 :   20418100 : (define_code_attr fixprefix [(fix "s") (unsigned_fix "u")])
     976                 :   20444600 : 
     977                 :     440310 : ;; Used in signed and unsigned float.
     978                 :    6702430 : (define_code_iterator any_float [float unsigned_float])
     979                 :          0 : (define_code_attr floatsuffix [(float "") (unsigned_float "u")])
     980                 :    6724780 : (define_code_attr floatunssuffix [(float "") (unsigned_float "uns")])
     981                 :    6724780 : (define_code_attr floatprefix [(float "s") (unsigned_float "u")])
     982                 :          0 : 
     983                 :          8 : ;; All integer modes.
     984                 :    6724780 : (define_mode_iterator SWI1248x [QI HI SI DI])
     985                 :    6724780 : 
     986                 :    3884170 : ;; All integer modes without QImode.
     987                 :    3899920 : (define_mode_iterator SWI248x [HI SI DI])
     988                 :      15746 : 
     989                 :          0 : ;; All integer modes without QImode and HImode.
     990                 :    2840620 : (define_mode_iterator SWI48x [SI DI])
     991                 :    2872680 : 
     992                 :       2020 : ;; All integer modes without SImode and DImode.
     993                 :    3884170 : (define_mode_iterator SWI12 [QI HI])
     994                 :    2872680 : 
     995                 :      32060 : ;; All integer modes without DImode.
     996                 :      32060 : (define_mode_iterator SWI124 [QI HI SI])
     997                 :          0 : 
     998                 :          0 : ;; All integer modes without QImode and DImode.
     999                 :    8926110 : (define_mode_iterator SWI24 [HI SI])
    1000                 :      18945 : 
    1001                 :    8977060 : ;; Single word integer modes.
    1002                 :    8994171 : (define_mode_iterator SWI [QI HI SI (DI "TARGET_64BIT")])
    1003                 :    4821862 : 
    1004                 :     820413 : ;; Single word integer modes without QImode.
    1005                 :   11005440 : (define_mode_iterator SWI248 [HI SI (DI "TARGET_64BIT")])
    1006                 :   10316250 : 
    1007                 :    6359164 : ;; Single word integer modes without QImode and HImode.
    1008                 :     773692 : (define_mode_iterator SWI48 [SI (DI "TARGET_64BIT")])
    1009                 :    2834800 : 
    1010                 :    3021738 : ;; All math-dependant single and double word integer modes.
    1011                 :    2632738 : (define_mode_iterator SDWIM [(QI "TARGET_QIMODE_MATH")
    1012                 :    5463510 :                              (HI "TARGET_HIMODE_MATH")
    1013                 :   69249548 :                              SI DI (TI "TARGET_64BIT")])
    1014                 :   50160748 : 
    1015                 :  435380299 : ;; Math-dependant single word integer modes.
    1016                 :   69403685 : (define_mode_iterator SWIM [(QI "TARGET_QIMODE_MATH")
    1017                 :   45304257 :                             (HI "TARGET_HIMODE_MATH")
    1018                 :    6144950 :                             SI (DI "TARGET_64BIT")])
    1019                 :    7107324 : 
    1020                 :   33682400 : ;; Math-dependant integer modes without DImode.
    1021                 :   21433300 : (define_mode_iterator SWIM124 [(QI "TARGET_QIMODE_MATH")
    1022                 :   72637270 :                                (HI "TARGET_HIMODE_MATH")
    1023                 :   76736276 :                                SI])
    1024                 :   55837400 : 
    1025                 :   35751500 : ;; Math-dependant integer modes with DImode (enabled for 32bit with STV).
    1026                 :   53017647 : (define_mode_iterator SWIM1248s
    1027                 :   11624195 :         [(QI "TARGET_QIMODE_MATH")
    1028                 :  298591600 :          (HI "TARGET_HIMODE_MATH")
    1029                 :   61463861 :          SI (DI "TARGET_64BIT || (TARGET_STV && TARGET_SSE2)")])
    1030                 :  240448209 : 
    1031                 :   15213448 : ;; Math-dependant single word integer modes without QImode.
    1032                 :   51802100 : (define_mode_iterator SWIM248 [(HI "TARGET_HIMODE_MATH")
    1033                 :   40400600 :                                SI (DI "TARGET_64BIT")])
    1034                 :    6794821 : 
    1035                 :   54701900 : ;; Double word integer modes.
    1036                 :   47029000 : (define_mode_iterator DWI [(DI "!TARGET_64BIT")
    1037                 :   13499816 :                            (TI "TARGET_64BIT")])
    1038                 :   46933228 : 
    1039                 :   32404200 : ;; SWI and DWI together.
    1040                 :   67237000 : (define_mode_iterator SWIDWI [QI HI SI DI (TI "TARGET_64BIT")])
    1041                 :   11269298 : 
    1042                 :   23057916 : ;; GET_MODE_SIZE for selected modes.  As GET_MODE_SIZE is not
    1043                 :   18865140 : ;; compile time constant, it is faster to use <MODE_SIZE> than
    1044                 :   96530700 : ;; GET_MODE_SIZE (<MODE>mode).  For XFmode which depends on
    1045                 :   26199600 : ;; command line options just use GET_MODE_SIZE macro.
    1046                 :   83316418 : (define_mode_attr MODE_SIZE [(QI "1") (HI "2") (SI "4") (DI "8") (TI "16")
    1047                 :   17656640 :                              (SF "4") (DF "8") (XF "GET_MODE_SIZE (XFmode)")
    1048                 :    2539110 :                              (V16QI "16") (V32QI "32") (V64QI "64")
    1049                 :   30692600 :                              (V8HI "16") (V16HI "32") (V32HI "64")
    1050                 :    1806338 :                              (V4SI "16") (V8SI "32") (V16SI "64")
    1051                 :    2366430 :                              (V2DI "16") (V4DI "32") (V8DI "64")
    1052                 :   30480469 :                              (V1TI "16") (V2TI "32") (V4TI "64")
    1053                 :    7838289 :                              (V2DF "16") (V4DF "32") (V8DF "64")
    1054                 :   23459800 :                              (V4SF "16") (V8SF "32") (V16SF "64")])
    1055                 :   57678800 : 
    1056                 :   23564890 : ;; Double word integer modes as mode attribute.
    1057                 :   12674620 : (define_mode_attr DWI [(QI "HI") (HI "SI") (SI "DI") (DI "TI") (TI "OI")])
    1058                 :   16027099 : (define_mode_attr dwi [(QI "hi") (HI "si") (SI "di") (DI "ti") (TI "oi")])
    1059                 :   15965887 : 
    1060                 :   14635900 : ;; LEA mode corresponding to an integer mode
    1061                 :   38694637 : (define_mode_attr LEAMODE [(QI "SI") (HI "SI") (SI "SI") (DI "DI")])
    1062                 :   30467900 : 
    1063                 :     474817 : ;; Half mode for double word integer modes.
    1064                 :   39564604 : (define_mode_iterator DWIH [(SI "!TARGET_64BIT")
    1065                 :   15202704 :                             (DI "TARGET_64BIT")])
    1066                 :   30349500 : 
    1067                 :   49560700 : ;; Instruction suffix for integer modes.
    1068                 :   25793800 : (define_mode_attr imodesuffix [(QI "b") (HI "w") (SI "l") (DI "q")])
    1069                 :    1118766 : 
    1070                 :   53776900 : ;; Instruction suffix for masks.
    1071                 :   55839720 : (define_mode_attr mskmodesuffix [(QI "b") (HI "w") (SI "d") (DI "q")])
    1072                 :   27426020 : 
    1073                 :     867785 : ;; Pointer size prefix for integer modes (Intel asm dialect)
    1074                 :   18736820 : (define_mode_attr iptrsize [(QI "BYTE")
    1075                 :   39266904 :                             (HI "WORD")
    1076                 :   11301990 :                             (SI "DWORD")
    1077                 :    1299932 :                             (DI "QWORD")])
    1078                 :   16483650 : 
    1079                 :  124990632 : ;; Register class for integer modes.
    1080                 :   17995880 : (define_mode_attr r [(QI "q") (HI "r") (SI "r") (DI "r")])
    1081                 :    1046060 : 
    1082                 :   39229600 : ;; Immediate operand constraint for integer modes.
    1083                 :   31321900 : (define_mode_attr i [(QI "n") (HI "n") (SI "e") (DI "e")])
    1084                 :   80325900 : 
    1085                 :   15523832 : ;; General operand constraint for word modes.
    1086                 :   26392500 : (define_mode_attr g [(QI "qmn") (HI "rmn") (SI "rme") (DI "rme")])
    1087                 :     706040 : 
    1088                 :     225155 : ;; Immediate operand constraint for double integer modes.
    1089                 :   21498720 : (define_mode_attr di [(SI "nF") (DI "Wd")])
    1090                 :   22596280 : 
    1091                 :   15398023 : ;; Immediate operand constraint for shifts.
    1092                 :     298440 : (define_mode_attr S [(QI "I") (HI "I") (SI "I") (DI "J") (TI "O")])
    1093                 :     128276 : 
    1094                 :   19139050 : ;; Print register name in the specified mode.
    1095                 :   18967140 : (define_mode_attr k [(QI "b") (HI "w") (SI "k") (DI "q")])
    1096                 :     231816 : 
    1097                 :   15427959 : ;; General operand predicate for integer modes.
    1098                 :      69292 : (define_mode_attr general_operand
    1099                 :   15435170 :         [(QI "general_operand")
    1100                 :      25189 :          (HI "general_operand")
    1101                 :   15434216 :          (SI "x86_64_general_operand")
    1102                 :     119461 :          (DI "x86_64_general_operand")
    1103                 :    1104814 :          (TI "x86_64_general_operand")])
    1104                 :   15377779 : 
    1105                 :   15428148 : ;; General operand predicate for integer modes, where for TImode
    1106                 :    1197490 : ;; we need both words of the operand to be general operands.
    1107                 :     929917 : (define_mode_attr general_hilo_operand
    1108                 :   15693894 :         [(QI "general_operand")
    1109                 :   15377638 :          (HI "general_operand")
    1110                 :   15949657 :          (SI "x86_64_general_operand")
    1111                 :   15638342 :          (DI "x86_64_general_operand")
    1112                 :   15889282 :          (TI "x86_64_hilo_general_operand")])
    1113                 :      22518 : 
    1114                 :     272320 : ;; General sign extend operand predicate for integer modes,
    1115                 :     251296 : ;; which disallows VOIDmode operands and thus it is suitable
    1116                 :   15381012 : ;; for use inside sign_extend.
    1117                 :       2390 : (define_mode_attr general_sext_operand
    1118                 :      57294 :         [(QI "sext_operand")
    1119                 :   15380303 :          (HI "sext_operand")
    1120                 :   15379720 :          (SI "x86_64_sext_operand")
    1121                 :      57380 :          (DI "x86_64_sext_operand")])
    1122                 :      59544 : 
    1123                 :   15377400 : ;; General sign/zero extend operand predicate for integer modes.
    1124                 :   15671557 : (define_mode_attr general_szext_operand
    1125                 :   15666421 :         [(QI "general_operand")
    1126                 :   15617236 :          (HI "general_operand")
    1127                 :   15671529 :          (SI "x86_64_szext_general_operand")
    1128                 :       2233 :          (DI "x86_64_szext_general_operand")])
    1129                 :   15666393 : 
    1130                 :   15617236 : (define_mode_attr nonmemory_szext_operand
    1131                 :   15615533 :         [(QI "nonmemory_operand")
    1132                 :   15648982 :          (HI "nonmemory_operand")
    1133                 :   15651312 :          (SI "x86_64_szext_nonmemory_operand")
    1134                 :   15616203 :          (DI "x86_64_szext_nonmemory_operand")])
    1135                 :       5447 : 
    1136                 :       5447 : ;; Immediate operand predicate for integer modes.
    1137                 :   15614642 : (define_mode_attr immediate_operand
    1138                 :   15615003 :         [(QI "immediate_operand")
    1139                 :   15615003 :          (HI "immediate_operand")
    1140                 :   15613558 :          (SI "x86_64_immediate_operand")
    1141                 :   15613545 :          (DI "x86_64_immediate_operand")])
    1142                 :       1488 : 
    1143                 :   15613558 : ;; Nonmemory operand predicate for integer modes.
    1144                 :   15615003 : (define_mode_attr nonmemory_operand
    1145                 :   15616803 :         [(QI "nonmemory_operand")
    1146                 :   15613900 :          (HI "nonmemory_operand")
    1147                 :   15616803 :          (SI "x86_64_nonmemory_operand")
    1148                 :   15616803 :          (DI "x86_64_nonmemory_operand")])
    1149                 :       1850 : 
    1150                 :       4753 : ;; Operand predicate for shifts.
    1151                 :   15615003 : (define_mode_attr shift_operand
    1152                 :          0 :         [(QI "nonimmediate_operand")
    1153                 :   15615003 :          (HI "nonimmediate_operand")
    1154                 :   15612100 :          (SI "nonimmediate_operand")
    1155                 :   15612100 :          (DI "shiftdi_operand")
    1156                 :   15612100 :          (TI "register_operand")])
    1157                 :   15612100 : 
    1158                 :   15612100 : ;; Operand predicate for shift argument.
    1159                 :   15612100 : (define_mode_attr shift_immediate_operand
    1160                 :   15612100 :         [(QI "const_1_to_31_operand")
    1161                 :   15612100 :          (HI "const_1_to_31_operand")
    1162                 :   15612100 :          (SI "const_1_to_31_operand")
    1163                 :     911519 :          (DI "const_1_to_63_operand")])
    1164                 :   14700500 : 
    1165                 :   14700500 : ;; Input operand predicate for arithmetic left shifts.
    1166                 :          0 : (define_mode_attr ashl_input_operand
    1167                 :          0 :         [(QI "nonimmediate_operand")
    1168                 :          0 :          (HI "nonimmediate_operand")
    1169                 :   14700500 :          (SI "nonimmediate_operand")
    1170                 :          0 :          (DI "ashldi_input_operand")
    1171                 :          0 :          (TI "reg_or_pm1_operand")])
    1172                 :   14700500 : 
    1173                 :   14700500 : ;; SSE and x87 SFmode and DFmode floating point modes
    1174                 :   14700500 : (define_mode_iterator MODEF [SF DF])
    1175                 :          0 : 
    1176                 :   14700500 : ;; All x87 floating point modes
    1177                 :   14700500 : (define_mode_iterator X87MODEF [SF DF XF])
    1178                 :   14700500 : 
    1179                 :          0 : ;; All SSE floating point modes
    1180                 :     234619 : (define_mode_iterator SSEMODEF [SF DF TF])
    1181                 :     234619 : (define_mode_attr ssevecmodef [(SF "V4SF") (DF "V2DF") (TF "TF")])
    1182                 :   14465900 : 
    1183                 :   14465900 : ;; SSE instruction suffix for various modes
    1184                 :   14465900 : (define_mode_attr ssemodesuffix
    1185                 :   14465900 :   [(SF "ss") (DF "sd")
    1186                 :   14465900 :    (V16SF "ps") (V8DF "pd")
    1187                 :      21127 :    (V8SF "ps") (V4DF "pd")
    1188                 :   14465900 :    (V4SF "ps") (V2DF "pd")
    1189                 :   14465900 :    (V16QI "b") (V8HI "w") (V4SI "d") (V2DI "q")
    1190                 :   14469600 :    (V32QI "b") (V16HI "w") (V8SI "d") (V4DI "q")
    1191                 :       3733 :    (V64QI "b") (V32HI "w") (V16SI "d") (V8DI "q")])
    1192                 :       3733 : 
    1193                 :   14465900 : ;; SSE vector suffix for floating point modes
    1194                 :   14465900 : (define_mode_attr ssevecmodesuffix [(SF "ps") (DF "pd")])
    1195                 :   14465900 : 
    1196                 :       3733 : ;; SSE vector mode corresponding to a scalar mode
    1197                 :   14465900 : (define_mode_attr ssevecmode
    1198                 :   14465900 :   [(QI "V16QI") (HI "V8HI") (SI "V4SI") (DI "V2DI") (SF "V4SF") (DF "V2DF")])
    1199                 :   14465900 : (define_mode_attr ssevecmodelower
    1200                 :   14465900 :   [(QI "v16qi") (HI "v8hi") (SI "v4si") (DI "v2di") (SF "v4sf") (DF "v2df")])
    1201                 :   14465900 : 
    1202                 :          0 : ;; AVX512F vector mode corresponding to a scalar mode
    1203                 :   14465900 : (define_mode_attr avx512fvecmode
    1204                 :   14465900 :   [(QI "V64QI") (HI "V32HI") (SI "V16SI") (DI "V8DI") (SF "V16SF") (DF "V8DF")])
    1205                 :   14465900 : 
    1206                 :          9 : ;; Instruction suffix for REX 64bit operators.
    1207                 :          9 : (define_mode_attr rex64suffix [(SI "{l}") (DI "{q}")])
    1208                 :   14465900 : (define_mode_attr rex64namesuffix [(SI "") (DI "q")])
    1209                 :   14465900 : 
    1210                 :   14465900 : ;; This mode iterator allows :P to be used for patterns that operate on
    1211                 :          9 : ;; pointer-sized quantities.  Exactly one of the two alternatives will match.
    1212                 :   16007780 : (define_mode_iterator P [(SI "Pmode == SImode") (DI "Pmode == DImode")])
    1213                 :   16066060 : 
    1214                 :   14467490 : ;; This mode iterator allows :W to be used for patterns that operate on
    1215                 :   14467970 : ;; word_mode sized quantities.
    1216                 :   14576318 : (define_mode_iterator W
    1217                 :    1795999 :   [(SI "word_mode == SImode") (DI "word_mode == DImode")])
    1218                 :   16524710 : 
    1219                 :  171912900 : ;; This mode iterator allows :PTR to be used for patterns that operate on
    1220                 :   94831900 : ;; ptr_mode sized quantities.
    1221                 :  167145900 : (define_mode_iterator PTR
    1222                 :   72777100 :   [(SI "ptr_mode == SImode") (DI "ptr_mode == DImode")])
    1223                 :   45318000 : 
    1224                 :   15076856 : ;; Scheduling descriptions
    1225                 :   90145749 : 
    1226                 :  574654790 : (include "pentium.md")
    1227                 :   18757850 : (include "ppro.md")
    1228                 :   15265416 : (include "k6.md")
    1229                 :   18549830 : (include "athlon.md")
    1230                 :  295120353 : (include "bdver1.md")
    1231                 :   16324100 : (include "bdver3.md")
    1232                 :    1257404 : (include "btver2.md")
    1233                 :   14474712 : (include "znver1.md")
    1234                 :  496704900 : (include "geode.md")
    1235                 :   14680237 : (include "atom.md")
    1236                 :  513787584 : (include "slm.md")
    1237                 :   38279346 : (include "glm.md")
    1238                 :   92901446 : (include "core2.md")
    1239                 :   17827161 : (include "haswell.md")
    1240                 :   25980600 : 
    1241                 :  626242900 : 
    1242                 :   17132020 : ;; Operand and operator predicates and constraints
    1243                 :   19289470 : 
    1244                 :  484549068 : (include "predicates.md")
    1245                 :   15177016 : (include "constraints.md")
    1246                 :   14577996 : 
    1247                 :  460890300 : 
    1248                 :   15778400 : ;; Compare and branch/compare and store instructions.
    1249                 :     348553 : 
    1250                 :   82371121 : (define_expand "cbranch<mode>4"
    1251                 :   97053600 :   [(set (reg:CC FLAGS_REG)
    1252                 :   14514905 :         (compare:CC (match_operand:SDWIM 1 "nonimmediate_operand")
    1253                 :   16932370 :                     (match_operand:SDWIM 2 "<general_operand>")))
    1254                 :   14693860 :    (set (pc) (if_then_else
    1255                 :   14468293 :                (match_operator 0 "ordered_comparison_operator"
    1256                 :    4641578 :                 [(reg:CC FLAGS_REG) (const_int 0)])
    1257                 :   18582800 :                (label_ref (match_operand 3))
    1258                 :   14814976 :                (pc)))]
    1259                 :   14620387 :   ""
    1260                 :    5065065 : {
    1261                 :  415362845 :   if (MEM_P (operands[1]) && MEM_P (operands[2]))
    1262                 :  428430650 :     operands[1] = force_reg (<MODE>mode, operands[1]);
    1263                 :   18985133 :   ix86_expand_branch (GET_CODE (operands[0]),
    1264                 :   14809769 :                       operands[1], operands[2], operands[3]);
    1265                 :   18038891 :   DONE;
    1266                 :   14715910 : })
    1267                 :     296817 : 
    1268                 :   15792000 : (define_expand "cstore<mode>4"
    1269                 :   15858600 :   [(set (reg:CC FLAGS_REG)
    1270                 :   17213374 :         (compare:CC (match_operand:SWIM 2 "nonimmediate_operand")
    1271                 :    2724394 :                     (match_operand:SWIM 3 "<general_operand>")))
    1272                 :    2759362 :    (set (match_operand:QI 0 "register_operand")
    1273                 :   14505094 :         (match_operator 1 "ordered_comparison_operator"
    1274                 :   14577024 :           [(reg:CC FLAGS_REG) (const_int 0)]))]
    1275                 :   14579732 :   ""
    1276                 :   14678445 : {
    1277                 :   14489347 :   if (MEM_P (operands[2]) && MEM_P (operands[3]))
    1278                 :     206181 :     operands[2] = force_reg (<MODE>mode, operands[2]);
    1279                 :   14675621 :   ix86_expand_setcc (operands[0], GET_CODE (operands[1]),
    1280                 :   14509775 :                      operands[2], operands[3]);
    1281                 :   18183222 :   DONE;
    1282                 :    3551038 : })
    1283                 :    3551038 : 
    1284                 :   14466020 : (define_expand "@cmp<mode>_1"
    1285                 :   14487569 :   [(set (reg:CC FLAGS_REG)
    1286                 :   14487689 :         (compare:CC (match_operand:SWI48 0 "nonimmediate_operand")
    1287                 :   14487569 :                     (match_operand:SWI48 1 "<general_operand>")))])
    1288                 :   14487689 : 
    1289                 :     330142 : (define_mode_iterator SWI1248_AVX512BWDQ_64
    1290                 :   14487569 :   [(QI "TARGET_AVX512DQ") HI
    1291                 :   14484455 :    (SI "TARGET_AVX512BW") (DI "TARGET_AVX512BW && TARGET_64BIT")])
    1292                 :   16431230 : 
    1293                 :    2840150 : (define_insn "*cmp<mode>_ccz_1"
    1294                 :    1269110 :   [(set (reg FLAGS_REG)
    1295                 :   14487689 :         (compare (match_operand:SWI1248_AVX512BWDQ_64 0
    1296                 :   14466020 :                         "nonimmediate_operand" "<r>,?m<r>,$k")
    1297                 :   14487809 :                  (match_operand:SWI1248_AVX512BWDQ_64 1 "const0_operand")))]
    1298                 :   15317006 :   "TARGET_AVX512F && ix86_match_ccmode (insn, CCZmode)"
    1299                 :   17435220 :   "@
    1300                 :      29494 :    test{<imodesuffix>}\t%0, %0
    1301                 :   14469938 :    cmp{<imodesuffix>}\t{%1, %0|%0, %1}
    1302                 :   14466020 :    kortest<mskmodesuffix>\t%0, %0"
    1303                 :     168943 :   [(set_attr "type" "test,icmp,msklog")
    1304                 :   53957041 :    (set_attr "length_immediate" "0,1,*")
    1305                 :   53789561 :    (set_attr "prefix" "*,*,vex")
    1306                 :    3058032 :    (set_attr "mode" "<MODE>")])
    1307                 :   15506120 : 
    1308                 :   15506000 : (define_insn "*cmp<mode>_ccno_1"
    1309                 :    4732236 :   [(set (reg FLAGS_REG)
    1310                 :    5368976 :         (compare (match_operand:SWI 0 "nonimmediate_operand" "<r>,?m<r>")
    1311                 :   53574685 :                  (match_operand:SWI 1 "const0_operand")))]
    1312                 :    5014300 :   "ix86_match_ccmode (insn, CCNOmode)"
    1313                 :    1761490 :   "@
    1314                 :  108301283 :    test{<imodesuffix>}\t%0, %0
    1315                 :  108425750 :    cmp{<imodesuffix>}\t{%1, %0|%0, %1}"
    1316                 :  110487981 :   [(set_attr "type" "test,icmp")
    1317                 :    1949947 :    (set_attr "length_immediate" "0,1")
    1318                 :    1951323 :    (set_attr "mode" "<MODE>")])
    1319                 :    1948571 : 
    1320                 :    1948571 : (define_insn "*cmp<mode>_1"
    1321                 :     187081 :   [(set (reg FLAGS_REG)
    1322                 :  105943061 :         (compare (match_operand:SWI 0 "nonimmediate_operand" "<r>m,<r>")
    1323                 :    1948551 :                  (match_operand:SWI 1 "<general_operand>" "<r><i>,<r>m")))]
    1324                 :    6961910 :   "ix86_match_ccmode (insn, CCmode)"
    1325                 :    2169090 :   "cmp{<imodesuffix>}\t{%1, %0|%0, %1}"
    1326                 :     412265 :   [(set_attr "type" "icmp")
    1327                 :     407598 :    (set_attr "mode" "<MODE>")])
    1328                 :    1761490 : 
    1329                 :    7739950 : (define_insn "*cmp<mode>_minus_1"
    1330                 :    7739950 :   [(set (reg FLAGS_REG)
    1331                 :    1761490 :         (compare
    1332                 :    5894640 :           (minus:SWI (match_operand:SWI 0 "nonimmediate_operand" "<r>m,<r>")
    1333                 :          0 :                      (match_operand:SWI 1 "<general_operand>" "<r><i>,<r>m"))
    1334                 :    4321240 :           (const_int 0)))]
    1335                 :    1766324 :   "ix86_match_ccmode (insn, CCGOCmode)"
    1336                 :    2569315 :   "cmp{<imodesuffix>}\t{%1, %0|%0, %1}"
    1337                 :    2566070 :   [(set_attr "type" "icmp")
    1338                 :    2566070 :    (set_attr "mode" "<MODE>")])
    1339                 :    2572693 : 
    1340                 :    2572693 : (define_insn "*cmpqi_ext_1"
    1341                 :    2571022 :   [(set (reg FLAGS_REG)
    1342                 :    2577491 :         (compare
    1343                 :    2566070 :           (match_operand:QI 0 "nonimmediate_operand" "QBc,m")
    1344                 :    2566070 :           (subreg:QI
    1345                 :         23 :             (zero_extract:SI
    1346                 :         23 :               (match_operand 1 "ext_register_operand" "Q,Q")
    1347                 :    2566050 :               (const_int 8)
    1348                 :    2566050 :               (const_int 8)) 0)))]
    1349                 :    2566050 :   "ix86_match_ccmode (insn, CCmode)"
    1350                 :     365788 :   "cmp{b}\t{%h1, %0|%0, %h1}"
    1351                 :    2566050 :   [(set_attr "isa" "*,nox64")
    1352                 :    2649169 :    (set_attr "type" "icmp")
    1353                 :    2566050 :    (set_attr "mode" "QI")])
    1354                 :    2566050 : 
    1355                 :   12108030 : (define_insn "*cmpqi_ext_2"
    1356                 :          0 :   [(set (reg FLAGS_REG)
    1357                 :    2649169 :         (compare
    1358                 :    2649169 :           (subreg:QI
    1359                 :   12192339 :             (zero_extract:SI
    1360                 :   12192339 :               (match_operand 0 "ext_register_operand" "Q")
    1361                 :   12192339 :               (const_int 8)
    1362                 :   12192339 :               (const_int 8)) 0)
    1363                 :   12192339 :           (match_operand:QI 1 "const0_operand")))]
    1364                 :    2650365 :   "ix86_match_ccmode (insn, CCNOmode)"
    1365                 :   12109220 :   "test{b}\t%h0, %h0"
    1366                 :   12109230 :   [(set_attr "type" "test")
    1367                 :    2567264 :    (set_attr "length_immediate" "0")
    1368                 :   12058360 :    (set_attr "mode" "QI")])
    1369                 :   12058360 : 
    1370                 :   12058360 : (define_expand "cmpqi_ext_3"
    1371                 :    2567240 :   [(set (reg:CC FLAGS_REG)
    1372                 :   10117640 :         (compare:CC
    1373                 :   10117640 :           (subreg:QI
    1374                 :   10117640 :             (zero_extract:SI
    1375                 :   10117640 :               (match_operand 0 "ext_register_operand")
    1376                 :   10117640 :               (const_int 8)
    1377                 :   10117640 :               (const_int 8)) 0)
    1378                 :    2567240 :           (match_operand:QI 1 "const_int_operand")))])
    1379                 :    2933028 : 
    1380                 :    2592377 : (define_insn "*cmpqi_ext_3"
    1381                 :    2956797 :   [(set (reg FLAGS_REG)
    1382                 :    2567240 :         (compare
    1383                 :    2576951 :           (subreg:QI
    1384                 :    2576951 :             (zero_extract:SI
    1385                 :    2576951 :               (match_operand 0 "ext_register_operand" "Q,Q")
    1386                 :    2567240 :               (const_int 8)
    1387                 :    2567306 :               (const_int 8)) 0)
    1388                 :    2567306 :           (match_operand:QI 1 "general_operand" "QnBc,m")))]
    1389                 :    2567252 :   "ix86_match_ccmode (insn, CCmode)"
    1390                 :    2567298 :   "cmp{b}\t{%1, %h0|%h0, %1}"
    1391                 :    2567298 :   [(set_attr "isa" "*,nox64")
    1392                 :    2567240 :    (set_attr "type" "icmp")
    1393                 :    2567240 :    (set_attr "mode" "QI")])
    1394                 :    2567258 : 
    1395                 :    2567258 : (define_insn "*cmpqi_ext_4"
    1396                 :    2567240 :   [(set (reg FLAGS_REG)
    1397                 :    2567258 :         (compare
    1398                 :    2567258 :           (subreg:QI
    1399                 :    2567258 :             (zero_extract:SI
    1400                 :    2567264 :               (match_operand 0 "ext_register_operand" "Q")
    1401                 :    2567240 :               (const_int 8)
    1402                 :    2567240 :               (const_int 8)) 0)
    1403                 :    2567240 :           (subreg:QI
    1404                 :    2567240 :             (zero_extract:SI
    1405                 :    2567240 :               (match_operand 1 "ext_register_operand" "Q")
    1406                 :    2567240 :               (const_int 8)
    1407                 :    2567240 :               (const_int 8)) 0)))]
    1408                 :       1197 :   "ix86_match_ccmode (insn, CCmode)"
    1409                 :       1197 :   "cmp{b}\t{%h1, %h0|%h0, %h1}"
    1410                 :    2566050 :   [(set_attr "type" "icmp")
    1411                 :    2566050 :    (set_attr "mode" "QI")])
    1412                 :    2630340 : 
    1413                 :    2630340 : ;; These implement float point compares.
    1414                 :    2630340 : ;; %%% See if we can get away with VOIDmode operands on the actual insns,
    1415                 :        255 : ;; which would allow mix and match FP modes on the compares.  Which is what
    1416                 :     811226 : ;; the old patterns did, but with many more of them.
    1417                 :     811226 : 
    1418                 :    1768263 : (define_expand "cbranchxf4"
    1419                 :    1768263 :   [(set (reg:CC FLAGS_REG)
    1420                 :       6765 :         (compare:CC (match_operand:XF 1 "nonmemory_operand")
    1421                 :         92 :                     (match_operand:XF 2 "nonmemory_operand")))
    1422                 :    1761540 :    (set (pc) (if_then_else
    1423                 :     128389 :               (match_operator 0 "ix86_fp_comparison_operator"
    1424                 :    1761510 :                [(reg:CC FLAGS_REG)
    1425                 :         56 :                 (const_int 0)])
    1426                 :    3716030 :               (label_ref (match_operand 3))
    1427                 :    1954540 :               (pc)))]
    1428                 :    1954540 :   "TARGET_80387"
    1429                 :      83119 : {
    1430                 :    1844609 :   ix86_expand_branch (GET_CODE (operands[0]),
    1431                 :    1761490 :                       operands[1], operands[2], operands[3]);
    1432                 :    1844609 :   DONE;
    1433                 :    1761490 : })
    1434                 :    1932470 : 
    1435                 :          0 : (define_expand "cstorexf4"
    1436                 :    1761490 :   [(set (reg:CC FLAGS_REG)
    1437                 :    7653950 :         (compare:CC (match_operand:XF 2 "nonmemory_operand")
    1438                 :    5892460 :                     (match_operand:XF 3 "nonmemory_operand")))
    1439                 :    5892460 :    (set (match_operand:QI 0 "register_operand")
    1440                 :    1765190 :               (match_operator 1 "ix86_fp_comparison_operator"
    1441                 :    1765190 :                [(reg:CC FLAGS_REG)
    1442                 :    1765190 :                 (const_int 0)]))]
    1443                 :    1765190 :   "TARGET_80387"
    1444                 :    1788812 : {
    1445                 :    5858842 :   ix86_expand_setcc (operands[0], GET_CODE (operands[1]),
    1446                 :    1765190 :                      operands[2], operands[3]);
    1447                 :    1788812 :   DONE;
    1448                 :    1978240 : })
    1449                 :     213052 : 
    1450                 :    1765190 : (define_expand "cbranch<mode>4"
    1451                 :    1765190 :   [(set (reg:CC FLAGS_REG)
    1452                 :    1765190 :         (compare:CC (match_operand:MODEF 1 "cmp_fp_expander_operand")
    1453                 :    1765190 :                     (match_operand:MODEF 2 "cmp_fp_expander_operand")))
    1454                 :    1765190 :    (set (pc) (if_then_else
    1455                 :     208332 :               (match_operator 0 "ix86_fp_comparison_operator"
    1456                 :    1765190 :                [(reg:CC FLAGS_REG)
    1457                 :    1765190 :                 (const_int 0)])
    1458                 :    1821960 :               (label_ref (match_operand 3))
    1459                 :    1821960 :               (pc)))]
    1460                 :      56769 :   "TARGET_80387 || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH)"
    1461                 :     300878 : {
    1462                 :    2009299 :   ix86_expand_branch (GET_CODE (operands[0]),
    1463                 :    1765190 :                       operands[1], operands[2], operands[3]);
    1464                 :    2009299 :   DONE;
    1465                 :    1765190 : })
    1466                 :    1788812 : 
    1467                 :      56769 : (define_expand "cstore<mode>4"
    1468                 :    1765190 :   [(set (reg:CC FLAGS_REG)
    1469                 :    1765190 :         (compare:CC (match_operand:MODEF 2 "cmp_fp_expander_operand")
    1470                 :    1784260 :                     (match_operand:MODEF 3 "cmp_fp_expander_operand")))
    1471                 :    1807882 :    (set (match_operand:QI 0 "register_operand")
    1472                 :    1807882 :               (match_operator 1 "ix86_fp_comparison_operator"
    1473                 :    1807882 :                [(reg:CC FLAGS_REG)
    1474                 :      42690 :                 (const_int 0)]))]
    1475                 :      42690 :   "TARGET_80387 || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH)"
    1476                 :    1853109 : {
    1477                 :    1965906 :   ix86_expand_setcc (operands[0], GET_CODE (operands[1]),
    1478                 :    1788812 :                      operands[2], operands[3]);
    1479                 :      77310 :   DONE;
    1480                 :       3697 : })
    1481                 :       3697 : 
    1482                 :    1874287 : (define_expand "cbranchcc4"
    1483                 :     113209 :   [(set (pc) (if_then_else
    1484                 :    1874287 :               (match_operator 0 "comparison_operator"
    1485                 :    1874287 :                [(match_operand 1 "flags_reg_operand")
    1486                 :    1874287 :                 (match_operand 2 "const0_operand")])
    1487                 :     114373 :               (label_ref (match_operand 3))
    1488                 :    1874287 :               (pc)))]
    1489                 :    1874287 :   ""
    1490                 :    1761653 : {
    1491                 :    1761653 :   ix86_expand_branch (GET_CODE (operands[0]),
    1492                 :    1761490 :                       operands[1], operands[2], operands[3]);
    1493                 :        181 :   DONE;
    1494                 :    1761490 : })
    1495                 :    1761490 : 
    1496                 :    1768270 : (define_expand "cstorecc4"
    1497                 :       6774 :   [(set (match_operand:QI 0 "register_operand")
    1498                 :     158492 :               (match_operator 1 "comparison_operator"
    1499                 :    1761490 :                [(match_operand 2 "flags_reg_operand")
    1500                 :    1761490 :                 (match_operand 3 "const0_operand")]))]
    1501                 :    1761490 :   ""
    1502                 :         56 : {
    1503                 :    1913242 :   ix86_expand_setcc (operands[0], GET_CODE (operands[1]),
    1504                 :    1913208 :                      operands[2], operands[3]);
    1505                 :    1761524 :   DONE;
    1506                 :    1913208 : })
    1507                 :    1913208 : 
    1508                 :     151728 : ;; FP compares, step 1:
    1509                 :    1957262 : ;; Set the FP condition codes and move fpsr to ax.
    1510                 :    1913208 : 
    1511                 :    1764730 : ;; We may not use "#" to split and emit these
    1512                 :       3237 : ;; due to reg-stack pops killing fpsr.
    1513                 :       3237 : 
    1514                 :    1805544 : (define_insn "*cmpxf_i387"
    1515                 :    1805544 :   [(set (match_operand:HI 0 "register_operand" "=a")
    1516                 :    1805544 :         (unspec:HI
    1517                 :      45701 :           [(compare:CCFP
    1518                 :    1805544 :              (match_operand:XF 1 "register_operand" "f")
    1519                 :    1805544 :              (match_operand:XF 2 "reg_or_0_operand" "fC"))]
    1520                 :    1805544 :           UNSPEC_FNSTSW))]
    1521                 :      44057 :   "TARGET_80387"
    1522                 :    1761490 :   "* return output_fp_compare (insn, operands, false, false);"
    1523                 :    1761490 :   [(set_attr "type" "multi")
    1524                 :    1761490 :    (set_attr "unit" "i387")
    1525                 :    1761490 :    (set_attr "mode" "XF")])
    1526                 :    1761524 : 
    1527                 :         34 : (define_insn "*cmp<mode>_i387"
    1528                 :    1761524 :   [(set (match_operand:HI 0 "register_operand" "=a")
    1529                 :    1761524 :         (unspec:HI
    1530                 :    1918603 :           [(compare:CCFP
    1531                 :    1790594 :              (match_operand:MODEF 1 "register_operand" "f")
    1532                 :     157106 :              (match_operand:MODEF 2 "nonimm_or_0_operand" "fmC"))]
    1533                 :     157106 :           UNSPEC_FNSTSW))]
    1534                 :    1761490 :   "TARGET_80387"
    1535                 :    1889499 :   "* return output_fp_compare (insn, operands, false, false);"
    1536                 :    1761490 :   [(set_attr "type" "multi")
    1537                 :      23286 :    (set_attr "unit" "i387")
    1538                 :    1761490 :    (set_attr "mode" "<MODE>")])
    1539                 :    1761490 : 
    1540                 :    1761490 : (define_insn "*cmp<X87MODEF:mode>_<SWI24:mode>_i387"
    1541                 :       2835 :   [(set (match_operand:HI 0 "register_operand" "=a")
    1542                 :    1761490 :         (unspec:HI
    1543                 :    1761490 :           [(compare:CCFP
    1544                 :    1761490 :              (match_operand:X87MODEF 1 "register_operand" "f")
    1545                 :       2835 :              (float:X87MODEF
    1546                 :    1761490 :                (match_operand:SWI24 2 "nonimmediate_operand" "m")))]
    1547                 :    1761490 :           UNSPEC_FNSTSW))]
    1548                 :    1761490 :   "TARGET_80387
    1549                 :       1071 :    && (TARGET_USE_<SWI24:MODE>MODE_FIOP
    1550                 :    1761490 :        || optimize_function_for_size_p (cfun))"
    1551                 :    1761490 :   "* return output_fp_compare (insn, operands, false, false);"
    1552                 :    1761490 :   [(set_attr "type" "multi")
    1553                 :    1761490 :    (set_attr "unit" "i387")
    1554                 :    1761490 :    (set_attr "fp_int_src" "true")
    1555                 :          0 :    (set_attr "mode" "<SWI24:MODE>")])
    1556                 :    1761490 : 
    1557                 :    1761490 : (define_insn "*cmpu<mode>_i387"
    1558                 :    1763110 :   [(set (match_operand:HI 0 "register_operand" "=a")
    1559                 :       1616 :         (unspec:HI
    1560                 :       1616 :           [(unspec:CCFP
    1561                 :    1761490 :              [(compare:CCFP
    1562                 :    1761490 :                 (match_operand:X87MODEF 1 "register_operand" "f")
    1563                 :    1761490 :                 (match_operand:X87MODEF 2 "register_operand" "f"))]
    1564                 :        656 :              UNSPEC_NOTRAP)]
    1565                 :    1761490 :           UNSPEC_FNSTSW))]
    1566                 :    1761490 :   "TARGET_80387"
    1567                 :    1761490 :   "* return output_fp_compare (insn, operands, false, true);"
    1568                 :    1761490 :   [(set_attr "type" "multi")
    1569                 :    1761490 :    (set_attr "unit" "i387")
    1570                 :        656 :    (set_attr "mode" "<MODE>")])
    1571                 :    1761490 : 
    1572                 :    1761490 : ;; FP compares, step 2:
    1573                 :    1772470 : ;; Get ax into flags, general case.
    1574                 :    1772502 : 
    1575                 :    1772502 : (define_insn "x86_sahf_1"
    1576                 :    1772502 :   [(set (reg:CC FLAGS_REG)
    1577                 :    1772470 :         (unspec:CC [(match_operand:HI 0 "register_operand" "a")]
    1578                 :    1772470 :                    UNSPEC_SAHF))]
    1579                 :    1772470 :   "TARGET_SAHF"
    1580                 :    1772470 : {
    1581                 :    1772470 : #ifndef HAVE_AS_IX86_SAHF
    1582                 :    1772470 :   if (TARGET_64BIT)
    1583                 :      10976 :     return ASM_BYTE "0x9e";
    1584                 :    1126416 :   else
    1585                 :    1761490 : #endif
    1586                 :    2876930 :   return "sahf";
    1587                 :    2876930 : }
    1588                 :    1121109 :   [(set_attr "length" "1")
    1589                 :    1761490 :    (set_attr "athlon_decode" "vector")
    1590                 :    2876930 :    (set_attr "amdfam10_decode" "direct")
    1591                 :    2918705 :    (set_attr "bdver1_decode" "direct")
    1592                 :    2876930 :    (set_attr "mode" "SI")])
    1593                 :    3965680 : 
    1594                 :         26 : ;; Pentium Pro can do both steps in one go.
    1595                 :    2850240 : ;; (these instructions set flags directly)
    1596                 :    2850240 : 
    1597                 :    1862290 : (define_subst_attr "unord" "unord_subst" "" "u")
    1598                 :    1037653 : (define_subst_attr "unordered" "unord_subst" "false" "true")
    1599                 :    1037653 : 
    1600                 :    2698344 : (define_subst "unord_subst"
    1601                 :    2698344 :   [(set (match_operand:CCFP 0)
    1602                 :    2698344 :         (match_operand:CCFP 1))]
    1603                 :    1026682 :   ""
    1604                 :    1761490 :   [(set (match_dup 0)
    1605                 :    1974428 :         (unspec:CCFP
    1606                 :    1974428 :           [(match_dup 1)]
    1607                 :     302766 :           UNSPEC_NOTRAP))])
    1608                 :    1974428 : 
    1609                 :    1761490 : (define_insn "*cmpi<unord>xf_i387"
    1610                 :    1761490 :   [(set (reg:CCFP FLAGS_REG)
    1611                 :    1761490 :         (compare:CCFP
    1612                 :    1761490 :           (match_operand:XF 0 "register_operand" "f")
    1613                 :      11542 :           (match_operand:XF 1 "register_operand" "f")))]
    1614                 :    2033005 :   "TARGET_80387 && TARGET_CMOVE"
    1615                 :    1838255 :   "* return output_fp_compare (insn, operands, true, <unordered>);"
    1616                 :    2690760 :   [(set_attr "type" "fcmp")
    1617                 :    2690760 :    (set_attr "mode" "XF")
    1618                 :    3222026 :    (set_attr "athlon_decode" "vector")
    1619                 :    3356468 :    (set_attr "amdfam10_decode" "direct")
    1620                 :    3217614 :    (set_attr "bdver1_decode" "double")
    1621                 :    3286650 :    (set_attr "znver1_decode" "double")])
    1622                 :    2690760 : 
    1623                 :    2691056 : (define_insn "*cmpi<unord><MODEF:mode>"
    1624                 :    2691056 :   [(set (reg:CCFP FLAGS_REG)
    1625                 :    2690760 :         (compare:CCFP
    1626                 :    2690760 :           (match_operand:MODEF 0 "register_operand" "f,v")
    1627                 :    2690760 :           (match_operand:MODEF 1 "register_ssemem_operand" "f,vm")))]
    1628                 :    3444105 :   "(SSE_FLOAT_MODE_P (<MODEF:MODE>mode) && TARGET_SSE_MATH)
    1629                 :    2703557 :    || (TARGET_80387 && TARGET_CMOVE)"
    1630                 :    2959817 :   "@
    1631                 :    1003251 :    * return output_fp_compare (insn, operands, true, <unordered>);
    1632                 :     929267 :    %v<unord>comi<MODEF:ssemodesuffix>\t{%1, %0|%0, %1}"
    1633                 :    2455780 :   [(set_attr "type" "fcmp,ssecomi")
    1634                 :    2381796 :    (set_attr "prefix" "orig,maybe_vex")
    1635                 :    2376192 :    (set_attr "mode" "<MODEF:MODE>")
    1636                 :    2814956 :    (set_attr "prefix_rep" "*,0")
    1637                 :    2127278 :    (set (attr "prefix_data16")
    1638                 :     839491 :         (cond [(eq_attr "alternative" "0")
    1639                 :    1761950 :                  (const_string "*")
    1640                 :    2127278 :                (eq_attr "mode" "DF")
    1641                 :    1761977 :                  (const_string "1")
    1642                 :    1761977 :               ]
    1643                 :    1833915 :               (const_string "0")))
    1644                 :    1761977 :    (set_attr "athlon_decode" "vector")
    1645                 :      72425 :    (set_attr "amdfam10_decode" "direct")
    1646                 :         90 :    (set_attr "bdver1_decode" "double")
    1647                 :    1764090 :    (set_attr "znver1_decode" "double")
    1648                 :    1764090 :    (set (attr "enabled")
    1649                 :    1761676 :      (if_then_else
    1650                 :        237 :        (match_test ("SSE_FLOAT_MODE_P (<MODEF:MODE>mode) && TARGET_SSE_MATH"))
    1651                 :    1761876 :        (if_then_else
    1652                 :    1761490 :          (eq_attr "alternative" "0")
    1653                 :    1761490 :          (symbol_ref "TARGET_MIX_SSE_I387")
    1654                 :    1761490 :          (symbol_ref "true"))
    1655                 :    1869462 :        (if_then_else
    1656                 :          9 :          (eq_attr "alternative" "0")
    1657                 :    1869462 :          (symbol_ref "true")
    1658                 :    1761490 :          (symbol_ref "false"))))])
    1659                 :    1763640 : 
    1660                 :    1763640 : ;; Push/pop instructions.
    1661                 :    1761720 : 
    1662                 :    1761720 : (define_insn "*push<mode>2"
    1663                 :        231 :   [(set (match_operand:DWI 0 "push_operand" "=<")
    1664                 :        231 :         (match_operand:DWI 1 "general_no_elim_operand" "riF*o"))]
    1665                 :    1761490 :   ""
    1666                 :    1761490 :   "#"
    1667                 :    1761490 :   [(set_attr "type" "multi")
    1668                 :    1761490 :    (set_attr "mode" "<MODE>")])
    1669                 :    1761490 : 
    1670                 :          0 : (define_split
    1671                 :    1761490 :   [(set (match_operand:DWI 0 "push_operand")
    1672                 :    1761802 :         (match_operand:DWI 1 "general_gr_operand"))]
    1673                 :    3399350 :   "reload_completed"
    1674                 :      72018 :   [(const_int 0)]
    1675                 :     655229 :   "ix86_split_long_move (operands); DONE;")
    1676                 :    1761490 : 
    1677                 :    1761490 : (define_insn "*pushdi2_rex64"
    1678                 :    1761490 :   [(set (match_operand:DI 0 "push_operand" "=<,!<")
    1679                 :      64295 :         (match_operand:DI 1 "general_no_elim_operand" "re*m,n"))]
    1680                 :    1761490 :   "TARGET_64BIT"
    1681                 :    4040320 :   "@
    1682                 :    1761490 :    push{q}\t%1
    1683                 :   46935989 :    #"
    1684                 :   48322890 :   [(set_attr "type" "push,multi")
    1685                 :   49498290 :    (set_attr "mode" "DI")])
    1686                 :    1761490 : 
    1687                 :    2217754 : ;; Convert impossible pushes of immediate to existing instructions.
    1688                 :    1761490 : ;; First try to get scratch register and go through it.  In case this
    1689                 :     518685 : ;; fails, push sign extended lower part first and then overwrite
    1690                 :    2217754 : ;; upper part by 32bit move.
    1691                 :    1762552 : 
    1692                 :    2218644 : (define_peephole2
    1693                 :    1763442 :   [(match_scratch:DI 2 "r")
    1694                 :    1763442 :    (set (match_operand:DI 0 "push_operand")
    1695                 :    1763442 :         (match_operand:DI 1 "immediate_operand"))]
    1696                 :    1790752 :   "TARGET_64BIT
    1697                 :    1791814 :    && !symbolic_operand (operands[1], DImode)
    1698                 :    1786619 :    && !x86_64_immediate_operand (operands[1], DImode)"
    1699                 :    1763442 :   [(set (match_dup 2) (match_dup 1))
    1700                 :    1764504 :    (set (match_dup 0) (match_dup 2))])
    1701                 :    1764504 : 
    1702                 :    1764504 : (define_split
    1703                 :    1763442 :   [(set (match_operand:DI 0 "push_operand")
    1704                 :    1763442 :         (match_operand:DI 1 "immediate_operand"))]
    1705                 :    1944728 :   "TARGET_64BIT && epilogue_completed
    1706                 :    1839720 :    && !symbolic_operand (operands[1], DImode)
    1707                 :    1821072 :    && !x86_64_immediate_operand (operands[1], DImode)"
    1708                 :    3506512 :   [(set (match_dup 0) (match_dup 1))
    1709                 :    3117365 :    (set (match_dup 2) (match_dup 3))]
    1710                 :    1966400 : {
    1711                 :    4879035 :   split_double_mode (DImode, &operands[1], 1, &operands[2], &operands[3]);
    1712                 :    3091402 : 
    1713                 :    2682580 :   operands[1] = gen_lowpart (DImode, operands[2]);
    1714                 :    4003273 :   operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (Pmode, stack_pointer_rtx,
    1715                 :    1761490 :                                                    GEN_INT (4)));
    1716                 :        885 : })
    1717                 :    1761490 : 
    1718                 :    1772173 : (define_insn "*pushsi2"
    1719                 :    1992003 :   [(set (match_operand:SI 0 "push_operand" "=<")
    1720                 :    2002686 :         (match_operand:SI 1 "general_no_elim_operand" "ri*m"))]
    1721                 :    4770146 :   "!TARGET_64BIT"
    1722                 :    2002686 :   "push{l}\t%1"
    1723                 :    2100404 :   [(set_attr "type" "push")
    1724                 :    2100404 :    (set_attr "mode" "SI")])
    1725                 :    1992003 : 
    1726                 :    1981320 : ;; emit_push_insn when it calls move_by_pieces requires an insn to
    1727                 :    2002686 : ;; "push a byte/word".  But actually we use pushl, which has the effect
    1728                 :    1981320 : ;; of rounding the amount pushed up to a word.
    1729                 :    1992003 : 
    1730                 :    1981320 : ;; For TARGET_64BIT we always round up to 8 bytes.
    1731                 :    1992003 : (define_insn "*push<mode>2_rex64"
    1732                 :    1992003 :   [(set (match_operand:SWI124 0 "push_operand" "=X")
    1733                 :    1992003 :         (match_operand:SWI124 1 "nonmemory_no_elim_operand" "r<i>"))]
    1734                 :    2042920 :   "TARGET_64BIT"
    1735                 :    1981320 :   "push{q}\t%q1"
    1736                 :    1994410 :   [(set_attr "type" "push")
    1737                 :   32050620 :    (set_attr "mode" "DI")])
    1738                 :   31740120 : 
    1739                 :   32283220 : (define_insn "*push<mode>2"
    1740                 :    1981320 :   [(set (match_operand:SWI12 0 "push_operand" "=X")
    1741                 :    1981320 :         (match_operand:SWI12 1 "nonmemory_no_elim_operand" "rn"))]
    1742                 :    1981320 :   "!TARGET_64BIT"
    1743                 :    1994410 :   "push{l}\t%k1"
    1744                 :    1981320 :   [(set_attr "type" "push")
    1745                 :   15571920 :    (set_attr "mode" "SI")])
    1746                 :   12805220 : 
    1747                 :   15571920 : (define_insn "*push<mode>2_prologue"
    1748                 :    1981320 :   [(set (match_operand:W 0 "push_operand" "=<")
    1749                 :    1981320 :         (match_operand:W 1 "general_no_elim_operand" "r<i>*m"))
    1750                 :    1981320 :    (clobber (mem:BLK (scratch)))]
    1751                 :    1981320 :   ""
    1752                 :    1981320 :   "push{<imodesuffix>}\t%1"
    1753                 :    1981320 :   [(set_attr "type" "push")
    1754                 :    1981320 :    (set_attr "mode" "<MODE>")])
    1755                 :     219831 : 
    1756                 :     219831 : (define_insn "*pop<mode>1"
    1757                 :    1761490 :   [(set (match_operand:W 0 "nonimmediate_operand" "=r*m")
    1758                 :    1761490 :         (match_operand:W 1 "pop_operand" ">"))]
    1759                 :    1761490 :   ""
    1760                 :      20524 :   "pop{<imodesuffix>}\t%0"
    1761                 :    1761490 :   [(set_attr "type" "pop")
    1762                 :    1761490 :    (set_attr "mode" "<MODE>")])
    1763                 :    1761490 : 
    1764                 :    1761490 : (define_insn "*pop<mode>1_epilogue"
    1765                 :    1761490 :   [(set (match_operand:W 0 "nonimmediate_operand" "=r*m")
    1766                 :        210 :         (match_operand:W 1 "pop_operand" ">"))
    1767                 :    1761490 :    (clobber (mem:BLK (scratch)))]
    1768                 :    1761490 :   ""
    1769                 :    3169700 :   "pop{<imodesuffix>}\t%0"
    1770                 :    3169700 :   [(set_attr "type" "pop")
    1771                 :    3169700 :    (set_attr "mode" "<MODE>")])
    1772                 :    3169700 : 
    1773                 :    3169700 : (define_insn "*pushfl<mode>2"
    1774                 :    3169700 :   [(set (match_operand:W 0 "push_operand" "=<")
    1775                 :    3169700 :         (match_operand:W 1 "flags_reg_operand"))]
    1776                 :    3169700 :   ""
    1777                 :    3169700 :   "pushf{<imodesuffix>}"
    1778                 :    3169700 :   [(set_attr "type" "push")
    1779                 :    3169700 :    (set_attr "mode" "<MODE>")])
    1780                 :    3169700 : 
    1781                 :    3169700 : (define_insn "*popfl<mode>1"
    1782                 :    3169700 :   [(set (match_operand:W 0 "flags_reg_operand")
    1783                 :    3169700 :         (match_operand:W 1 "pop_operand" ">"))]
    1784                 :    3169700 :   ""
    1785                 :    3169700 :   "popf{<imodesuffix>}"
    1786                 :    3169700 :   [(set_attr "type" "pop")
    1787                 :    3169700 :    (set_attr "mode" "<MODE>")])
    1788                 :    3169700 : 
    1789                 :    3169700 : 
    1790                 :    3169700 : ;; Reload patterns to support multi-word load/store
    1791                 :    3169700 : ;; with non-offsetable address.
    1792                 :    3169700 : (define_expand "reload_noff_store"
    1793                 :    3169700 :   [(parallel [(match_operand 0 "memory_operand" "=m")
    1794                 :    3169700 :               (match_operand 1 "register_operand" "r")
    1795                 :    3169700 :               (match_operand:DI 2 "register_operand" "=&r")])]
    1796                 :    3169700 :   "TARGET_64BIT"
    1797                 :    3169700 : {
    1798                 :    3169700 :   rtx mem = operands[0];
    1799                 :    3169700 :   rtx addr = XEXP (mem, 0);
    1800                 :    3169700 : 
    1801                 :    3169700 :   emit_move_insn (operands[2], addr);
    1802                 :    3169700 :   mem = replace_equiv_address_nv (mem, operands[2]);
    1803                 :    3169700 : 
    1804                 :    3169700 :   emit_insn (gen_rtx_SET (mem, operands[1]));
    1805                 :    3169700 :   DONE;
    1806                 :    3169700 : })
    1807                 :    3169700 : 
    1808                 :    3169700 : (define_expand "reload_noff_load"
    1809                 :    3169700 :   [(parallel [(match_operand 0 "register_operand" "=r")
    1810                 :    3169700 :               (match_operand 1 "memory_operand" "m")
    1811                 :    3169700 :               (match_operand:DI 2 "register_operand" "=r")])]
    1812                 :    3169700 :   "TARGET_64BIT"
    1813                 :    3169700 : {
    1814                 :    3169700 :   rtx mem = operands[1];
    1815                 :    3169700 :   rtx addr = XEXP (mem, 0);
    1816                 :    3169700 : 
    1817                 :    3169700 :   emit_move_insn (operands[2], addr);
    1818                 :    3169700 :   mem = replace_equiv_address_nv (mem, operands[2]);
    1819                 :    3169700 : 
    1820                 :    3169700 :   emit_insn (gen_rtx_SET (operands[0], mem));
    1821                 :    3169700 :   DONE;
    1822                 :    3169700 : })
    1823                 :         41 : 
    1824                 :    3169660 : ;; Move instructions.
    1825                 :    3239430 : 
    1826                 :      69767 : (define_expand "movxi"
    1827                 :    3169660 :   [(set (match_operand:XI 0 "nonimmediate_operand")
    1828                 :    3169660 :         (match_operand:XI 1 "general_operand"))]
    1829                 :    3169660 :   "TARGET_AVX512F"
    1830                 :    3172575 :   "ix86_expand_vector_move (XImode, operands); DONE;")
    1831                 :    3169660 : 
    1832                 :    4458220 : (define_expand "movoi"
    1833                 :    3169660 :   [(set (match_operand:OI 0 "nonimmediate_operand")
    1834                 :    1344530 :         (match_operand:OI 1 "general_operand"))]
    1835                 :    3169660 :   "TARGET_AVX"
    1836                 :    3170420 :   "ix86_expand_vector_move (OImode, operands); DONE;")
    1837                 :    3169700 : 
    1838                 :         36 : (define_expand "movti"
    1839                 :         36 :   [(set (match_operand:TI 0 "nonimmediate_operand")
    1840                 :    3169660 :         (match_operand:TI 1 "general_operand"))]
    1841                 :    3169660 :   "TARGET_64BIT || TARGET_SSE"
    1842                 :    5402130 : {
    1843                 :    2232502 :   if (TARGET_64BIT)
    1844                 :    5401240 :     ix86_expand_move (TImode, operands);
    1845                 :    3169660 :   else
    1846                 :    3170546 :     ix86_expand_vector_move (TImode, operands);
    1847                 :    2232502 :   DONE;
    1848                 :    3172575 : })
    1849                 :    3172575 : 
    1850                 :    3173295 : ;; This expands to what emit_move_complex would generate if we didn't
    1851                 :    3170380 : ;; have a movti pattern.  Having this avoids problems with reload on
    1852                 :    3172575 : ;; 32-bit targets when SSE is present, but doesn't seem to be harmful
    1853                 :    2233198 : ;; to have around all the time.
    1854                 :    3170380 : (define_expand "movcdi"
    1855                 :    3170380 :   [(set (match_operand:CDI 0 "nonimmediate_operand")
    1856                 :    5402160 :         (match_operand:CDI 1 "general_operand"))]
    1857                 :    5402160 :   ""
    1858                 :    5404550 : {
    1859                 :    3172080 :   if (push_operand (operands[0], CDImode))
    1860                 :        635 :     emit_move_complex_push (CDImode, operands[0], operands[1]);
    1861                 :    2232497 :   else
    1862                 :    3171442 :     emit_move_complex_parts (operands[0], operands[1]);
    1863                 :    3172050 :   DONE;
    1864                 :    3169660 : })
    1865                 :    3172050 : 
    1866                 :    3169660 : (define_expand "mov<mode>"
    1867                 :          8 :   [(set (match_operand:SWI1248x 0 "nonimmediate_operand")
    1868                 :    3172050 :         (match_operand:SWI1248x 1 "general_operand"))]
    1869                 :    3172050 :   ""
    1870                 :   46248810 :   "ix86_expand_move (<MODE>mode, operands); DONE;")
    1871                 :    3174700 : 
    1872                 :    3174700 : (define_insn "*mov<mode>_xor"
    1873                 :    3174700 :   [(set (match_operand:SWI48 0 "register_operand" "=r")
    1874                 :       2651 :         (match_operand:SWI48 1 "const0_operand"))
    1875                 :       2651 :    (clobber (reg:CC FLAGS_REG))]
    1876                 :    4163814 :   "reload_completed"
    1877                 :    3169660 :   "xor{l}\t%k0, %k0"
    1878                 :    3266179 :   [(set_attr "type" "alu1")
    1879                 :    3266179 :    (set_attr "mode" "SI")
    1880                 :    3169660 :    (set_attr "length_immediate" "0")])
    1881                 :    4048871 : 
    1882                 :    5085000 : (define_insn "*mov<mode>_or"
    1883                 :    3169660 :   [(set (match_operand:SWI48 0 "register_operand" "=r")
    1884                 :    5301490 :         (match_operand:SWI48 1 "constm1_operand"))
    1885                 :    5301490 :    (clobber (reg:CC FLAGS_REG))]
    1886                 :    2134424 :   "reload_completed"
    1887                 :   43167806 :   "or{<imodesuffix>}\t{%1, %0|%0, %1}"
    1888                 :    5300560 :   [(set_attr "type" "alu1")
    1889                 :    5300540 :    (set_attr "mode" "<MODE>")
    1890                 :   45374220 :    (set_attr "length_immediate" "1")])
    1891                 :   45374220 : 
    1892                 :   73951960 : (define_insn "*movxi_internal_avx512f"
    1893                 :   71730894 :   [(set (match_operand:XI 0 "nonimmediate_operand"            "=v,v ,v ,m")
    1894                 :   75210860 :         (match_operand:XI 1 "nonimmediate_or_sse_const_operand" " C,BC,vm,v"))]
    1895                 :   44241111 :   "TARGET_AVX512F
    1896                 :    3295511 :    && (register_operand (operands[0], XImode)
    1897                 :    3177043 :        || register_operand (operands[1], XImode))"
    1898                 :    3295823 : {
    1899                 :    3169972 :   switch (get_attr_type (insn))
    1900                 :    3169660 :     {
    1901                 :    3320309 :     case TYPE_SSELOG1:
    1902                 :    3328809 :       return standard_sse_constant_opcode (insn, operands);
    1903                 :     157932 : 
    1904                 :     159276 :     case TYPE_SSEMOV:
    1905                 :        312 :       return ix86_output_ssemov (insn, operands);
    1906                 :    3169840 : 
    1907                 :    3169840 :     default:
    1908                 :    3169840 :       gcc_unreachable ();
    1909                 :    3169840 :     }
    1910                 :    3169840 : }
    1911                 :    3169840 :   [(set_attr "type" "sselog1,sselog1,ssemov,ssemov")
    1912                 :    3169840 :    (set_attr "prefix" "evex")
    1913                 :    3169840 :    (set_attr "mode" "XI")])
    1914                 :    3170097 : 
    1915                 :    3169840 : (define_insn "*movoi_internal_avx"
    1916                 :          0 :   [(set (match_operand:OI 0 "nonimmediate_operand"            "=v,v ,v ,m")
    1917                 :          0 :         (match_operand:OI 1 "nonimmediate_or_sse_const_operand" " C,BC,vm,v"))]
    1918                 :     149436 :   "TARGET_AVX
    1919                 :    3319276 :    && (register_operand (operands[0], OImode)
    1920                 :      13323 :        || register_operand (operands[1], OImode))"
    1921                 :    3319533 : {
    1922                 :    3170097 :   switch (get_attr_type (insn))
    1923                 :    3169840 :     {
    1924                 :    7242950 :     case TYPE_SSELOG1:
    1925                 :   10412790 :       return standard_sse_constant_opcode (insn, operands);
    1926                 :   10412790 : 
    1927                 :    3170097 :     case TYPE_SSEMOV:
    1928                 :        257 :       return ix86_output_ssemov (insn, operands);
    1929                 :    3169840 : 
    1930                 :   12686800 :     default:
    1931                 :   15856640 :       gcc_unreachable ();
    1932                 :   14968340 :     }
    1933                 :   17939182 : }
    1934                 :    3169660 :   [(set_attr "isa" "*,avx2,*,*")
    1935                 :    3169690 :    (set_attr "type" "sselog1,sselog1,ssemov,ssemov")
    1936                 :    3169690 :    (set_attr "prefix" "vex")
    1937                 :   83222888 :    (set_attr "mode" "OI")])
    1938                 :   79966300 : 
    1939                 :    3169690 : (define_insn "*movti_internal"
    1940                 :    3169690 :   [(set (match_operand:TI 0 "nonimmediate_operand" "=!r ,o ,v,v ,v ,m,?r,?Yd")
    1941                 :    3169690 :         (match_operand:TI 1 "general_operand"    "riFo,re,C,BC,vm,v,Yd,r"))]
    1942                 :   11440950 :   "(TARGET_64BIT
    1943                 :   11387500 :     && !(MEM_P (operands[0]) && MEM_P (operands[1])))
    1944                 :    3237232 :    || (TARGET_SSE
    1945                 :    3237230 :        && nonimmediate_or_sse_const_operand (operands[1], TImode)
    1946                 :      67540 :        && (register_operand (operands[0], TImode)
    1947                 :    3193172 :            || register_operand (operands[1], TImode)))"
    1948                 :   11513618 : {
    1949                 :      86888 :   switch (get_attr_type (insn))
    1950                 :          0 :     {
    1951                 :   32836300 :     case TYPE_MULTI:
    1952                 :   36005990 :       return "#";
    1953                 :    3169690 : 
    1954                 :    5972934 :     case TYPE_SSELOG1:
    1955                 :    5972934 :       return standard_sse_constant_opcode (insn, operands);
    1956                 :    3169690 : 
    1957                 :    3256504 :     case TYPE_SSEMOV:
    1958                 :    3256504 :       return ix86_output_ssemov (insn, operands);
    1959                 :    3169690 : 
    1960                 :    3169690 :     default:
    1961                 :    3169690 :       gcc_unreachable ();
    1962                 :          0 :     }
    1963                 :    3169690 : }
    1964                 :    3169690 :   [(set (attr "isa")
    1965                 :          0 :      (cond [(eq_attr "alternative" "0,1,6,7")
    1966                 :          0 :               (const_string "x64")
    1967                 :   13152800 :             (eq_attr "alternative" "3")
    1968                 :    3169690 :               (const_string "sse2")
    1969                 :    3169690 :            ]
    1970                 :    3169690 :            (const_string "*")))
    1971                 :    3169690 :    (set (attr "type")
    1972                 :    3169690 :      (cond [(eq_attr "alternative" "0,1,6,7")
    1973                 :    3169690 :               (const_string "multi")
    1974                 :    3169690 :             (eq_attr "alternative" "2,3")
    1975                 :    3169690 :               (const_string "sselog1")
    1976                 :    3169690 :            ]
    1977                 :    3169690 :            (const_string "ssemov")))
    1978                 :          0 :    (set (attr "prefix")
    1979                 :    3169690 :      (if_then_else (eq_attr "type" "sselog1,ssemov")
    1980                 :    3169690 :        (const_string "maybe_vex")
    1981                 :          0 :        (const_string "orig")))
    1982                 :          0 :    (set (attr "mode")
    1983                 :          0 :         (cond [(eq_attr "alternative" "0,1")
    1984                 :    1408210 :                  (const_string "DI")
    1985                 :    1408210 :                (match_test "TARGET_AVX")
    1986                 :    1761490 :                  (const_string "TI")
    1987                 :    1761490 :                (ior (not (match_test "TARGET_SSE2"))
    1988                 :    1761490 :                     (match_test "optimize_function_for_size_p (cfun)"))
    1989                 :    1761490 :                  (const_string "V4SF")
    1990                 :    1761490 :                (and (eq_attr "alternative" "5")
    1991                 :     481430 :                     (match_test "TARGET_SSE_TYPELESS_STORES"))
    1992                 :    1761490 :                  (const_string "V4SF")
    1993                 :    1761490 :                ]
    1994                 :          0 :                (const_string "TI")))
    1995                 :      28746 :    (set (attr "preferred_for_speed")
    1996                 :      28746 :      (cond [(eq_attr "alternative" "6")
    1997                 :          0 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
    1998                 :          0 :             (eq_attr "alternative" "7")
    1999                 :          0 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_TO_VEC")
    2000                 :        395 :            ]
    2001                 :    1761490 :            (symbol_ref "true")))])
    2002                 :    1761490 : 
    2003                 :    1761490 : (define_split
    2004                 :    1761490 :   [(set (match_operand:TI 0 "sse_reg_operand")
    2005                 :    1761490 :         (match_operand:TI 1 "general_reg_operand"))]
    2006                 :         15 :   "TARGET_64BIT && TARGET_SSE4_1
    2007                 :    1761505 :    && reload_completed"
    2008                 :    1761505 :   [(set (match_dup 2)
    2009                 :    2470061 :         (vec_merge:V2DI
    2010                 :     296444 :           (vec_duplicate:V2DI (match_dup 3))
    2011                 :     708576 :           (match_dup 2)
    2012                 :    1761490 :           (const_int 2)))]
    2013                 :         15 : {
    2014                 :         15 :   operands[2] = lowpart_subreg (V2DImode, operands[0], TImode);
    2015                 :        861 :   operands[3] = gen_highpart (DImode, operands[1]);
    2016                 :    1761490 : 
    2017                 :    1761505 :   emit_move_insn (gen_lowpart (DImode, operands[0]),
    2018                 :    1761505 :                   gen_lowpart (DImode, operands[1]));
    2019                 :         46 : })
    2020                 :    1761490 : 
    2021                 :    1761490 : (define_insn "*movdi_internal"
    2022                 :    1761505 :   [(set (match_operand:DI 0 "nonimmediate_operand"
    2023                 :    1761505 :     "=r  ,o  ,r,r  ,r,m ,*y,*y,?*y,?m,?r,?*y,*v,*v,*v,m ,m,?r ,?*Yd,?r,?*v,?*y,?*x,*k,*k ,*r,*m,*k")
    2024                 :    1761505 :         (match_operand:DI 1 "general_operand"
    2025                 :         15 :     "riFo,riF,Z,rem,i,re,C ,*y,m  ,*y,*y,r  ,C ,*v,m ,*v,v,*Yd,r   ,*v,r  ,*x ,*y ,*r,*km,*k,*k,CBC"))]
    2026                 :   45414250 :   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
    2027                 :   14914265 : {
    2028                 :   45442715 :   switch (get_attr_type (insn))
    2029                 :         15 :     {
    2030                 :    9194755 :     case TYPE_MSKMOV:
    2031                 :    9194740 :       return "kmovq\t{%1, %0|%0, %1}";
    2032                 :   33001330 : 
    2033                 :   42196021 :     case TYPE_MSKLOG:
    2034                 :   32289901 :       if (operands[1] == const0_rtx)
    2035                 :   32289900 :         return "kxorq\t%0, %0, %0";
    2036                 :   32289915 :       else if (operands[1] == constm1_rtx)
    2037                 :   32289915 :         return "kxnorq\t%0, %0, %0";
    2038                 :         15 :       gcc_unreachable ();
    2039                 :   32289900 : 
    2040                 :   32289900 :     case TYPE_MULTI:
    2041                 :   32289900 :       return "#";
    2042                 :          0 : 
    2043                 :   32289900 :     case TYPE_MMX:
    2044                 :   32289900 :       return "pxor\t%0, %0";
    2045                 :          0 : 
    2046                 :          0 :     case TYPE_MMXMOV:
    2047                 :          0 :       /* Handle broken assemblers that require movd instead of movq.  */
    2048                 :   32289900 :       if (!HAVE_AS_IX86_INTERUNIT_MOVQ
    2049                 :          0 :           && (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1])))
    2050                 :          0 :         return "movd\t{%1, %0|%0, %1}";
    2051                 :          0 :       return "movq\t{%1, %0|%0, %1}";
    2052                 :   32289900 : 
    2053                 :   33351903 :     case TYPE_SSELOG1:
    2054                 :   32290003 :       return standard_sse_constant_opcode (insn, operands);
    2055                 :    1061920 : 
    2056                 : 1381116842 :     case TYPE_SSEMOV:
    2057                 :   32406742 :       return ix86_output_ssemov (insn, operands);
    2058                 : 1348710000 : 
    2059                 :          0 :     case TYPE_SSECVT:
    2060                 :          0 :       if (SSE_REG_P (operands[0]))
    2061                 :   32291000 :         return "movq2dq\t{%1, %0|%0, %1}";
    2062                 :          0 :       else
    2063                 :   33352900 :         return "movdq2q\t{%1, %0|%0, %1}";
    2064                 :   32291000 : 
    2065                 :   32346497 :     case TYPE_LEA:
    2066                 :      56608 :       return "lea{q}\t{%E1, %0|%0, %E1}";
    2067                 :       1111 : 
    2068                 :   45268300 :     case TYPE_IMOV:
    2069                 :   48946500 :       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
    2070                 :   45268300 :       if (get_attr_mode (insn) == MODE_SI)
    2071                 :    3679160 :         return "mov{l}\t{%k1, %k0|%k0, %k1}";
    2072                 :   43183300 :       else if (which_alternative == 4)
    2073                 :   32295100 :         return "movabs{q}\t{%1, %0|%0, %1}";
    2074                 :   42989200 :       else if (ix86_use_lea_for_mov (insn, operands))
    2075                 :       5318 :         return "lea{q}\t{%E1, %0|%0, %E1}";
    2076                 :       5246 :       else
    2077                 :   42984000 :         return "mov{q}\t{%1, %0|%0, %1}";
    2078                 :       3925 : 
    2079                 :         48 :     default:
    2080                 :   32289900 :       gcc_unreachable ();
    2081                 :   32289900 :     }
    2082                 :   32289900 : }
    2083                 :         36 :   [(set (attr "isa")
    2084                 :   32289900 :      (cond [(eq_attr "alternative" "0,1,17,18")
    2085                 :   32289900 :               (const_string "nox64")
    2086                 :   39437820 :             (eq_attr "alternative" "2,3,4,5,10,11,23,25")
    2087                 :   32289900 :               (const_string "x64")
    2088                 :   32289900 :             (eq_attr "alternative" "19,20")
    2089                 :         12 :               (const_string "x64_sse2")
    2090                 :   32289900 :             (eq_attr "alternative" "21,22")
    2091                 :   32289900 :               (const_string "sse2")
    2092                 :   32318400 :            ]
    2093                 :      28498 :            (const_string "*")))
    2094                 :      28498 :    (set (attr "type")
    2095                 :   32289900 :      (cond [(eq_attr "alternative" "0,1,17,18")
    2096                 :   32289900 :               (const_string "multi")
    2097                 :   32289900 :             (eq_attr "alternative" "6")
    2098                 :   32289900 :               (const_string "mmx")
    2099                 :   32289900 :             (eq_attr "alternative" "7,8,9,10,11")
    2100                 :          0 :               (const_string "mmxmov")
    2101                 :   32289900 :             (eq_attr "alternative" "12")
    2102                 :   32289900 :               (const_string "sselog1")
    2103                 :   32290000 :             (eq_attr "alternative" "13,14,15,16,19,20")
    2104                 :        112 :               (const_string "ssemov")
    2105                 :        112 :             (eq_attr "alternative" "21,22")
    2106                 :   32289900 :               (const_string "ssecvt")
    2107                 :   32289900 :             (eq_attr "alternative" "23,24,25,26")
    2108                 :          0 :               (const_string "mskmov")
    2109                 :          0 :             (eq_attr "alternative" "27")
    2110                 :   32289900 :               (const_string "msklog")
    2111                 :         50 :             (and (match_operand 0 "register_operand")
    2112                 :     252251 :                  (match_operand 1 "pic_32bit_operand"))
    2113                 :     252251 :               (const_string "lea")
    2114                 :   32396900 :            ]
    2115                 :          0 :            (const_string "imov")))
    2116                 :   32396900 :    (set (attr "modrm")
    2117                 :      32656 :      (if_then_else
    2118                 :   32396900 :        (and (eq_attr "alternative" "4") (eq_attr "type" "imov"))
    2119                 :   32396900 :        (const_string "0")
    2120                 :   32396900 :        (const_string "*")))
    2121                 :   32396900 :    (set (attr "length_immediate")
    2122                 :   32396900 :      (if_then_else
    2123                 :        105 :        (and (eq_attr "alternative" "4") (eq_attr "type" "imov"))
    2124                 :   32396900 :        (const_string "8")
    2125                 :   32396900 :        (const_string "*")))
    2126                 :   32438400 :    (set (attr "prefix_rex")
    2127                 :     359257 :      (if_then_else
    2128                 :     359257 :        (eq_attr "alternative" "10,11,19,20")
    2129                 :   32079200 :        (const_string "1")
    2130                 :   32079200 :        (const_string "*")))
    2131                 :   32079200 :    (set (attr "prefix")
    2132                 :   32079200 :      (if_then_else (eq_attr "type" "sselog1,ssemov")
    2133                 :   32079200 :        (const_string "maybe_vex")
    2134                 :       7577 :        (const_string "orig")))
    2135                 :   32079200 :    (set (attr "prefix_data16")
    2136                 :   32079200 :      (if_then_else (and (eq_attr "type" "ssemov") (eq_attr "mode" "DI"))
    2137                 :   32152200 :        (const_string "1")
    2138                 :      73022 :        (const_string "*")))
    2139                 :      73022 :    (set (attr "mode")
    2140                 :   32079200 :      (cond [(eq_attr "alternative" "2")
    2141                 :   32079200 :               (const_string "SI")
    2142                 :   32079200 :             (eq_attr "alternative" "12,13")
    2143                 :   32079200 :               (cond [(match_test "TARGET_AVX")
    2144                 :   32079200 :                        (const_string "TI")
    2145                 :        170 :                      (ior (not (match_test "TARGET_SSE2"))
    2146                 :   32079200 :                           (match_test "optimize_function_for_size_p (cfun)"))
    2147                 :   32079200 :                        (const_string "V4SF")
    2148                 :   32084100 :                     ]
    2149                 :       4925 :                     (const_string "TI"))
    2150                 :       4925 : 
    2151                 :   32079200 :             (and (eq_attr "alternative" "14,15,16")
    2152                 :   32079200 :                  (not (match_test "TARGET_SSE2")))
    2153                 :      41525 :               (const_string "V2SF")
    2154                 :      46272 :            ]
    2155                 :   32037600 :            (const_string "DI")))
    2156                 :   32037600 :    (set (attr "preferred_for_speed")
    2157                 :   32037600 :      (cond [(eq_attr "alternative" "10,17,19")
    2158                 :          0 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
    2159                 :   32037600 :             (eq_attr "alternative" "11,18,20")
    2160                 :         90 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_TO_VEC")
    2161                 :   32037600 :            ]
    2162                 :          0 :            (symbol_ref "true")))
    2163                 :   32304200 :    (set (attr "enabled")
    2164                 :   32304200 :      (cond [(eq_attr "alternative" "15")
    2165                 :   32304200 :               (if_then_else
    2166                 :   43741000 :                 (match_test "TARGET_STV && TARGET_SSE2")
    2167                 :   32304200 :                 (symbol_ref "false")
    2168                 :          0 :                 (const_string "*"))
    2169                 :   32304200 :             (eq_attr "alternative" "16")
    2170                 :   32304200 :               (if_then_else
    2171                 :   32361900 :                 (match_test "TARGET_STV && TARGET_SSE2")
    2172                 :      57727 :                 (symbol_ref "true")
    2173                 :      94451 :                 (symbol_ref "false"))
    2174                 :   32304200 :            ]
    2175                 :   32304200 :            (const_string "*")))])
    2176                 :   32304200 : 
    2177                 :          0 : (define_split
    2178                 :   32304200 :   [(set (match_operand:<DWI> 0 "general_reg_operand")
    2179                 :   32304200 :         (match_operand:<DWI> 1 "sse_reg_operand"))]
    2180                 :   32329952 :   "TARGET_SSE4_1
    2181                 :   32306601 :    && reload_completed"
    2182                 :   32304200 :   [(set (match_dup 2)
    2183                 :          0 :         (vec_select:DWIH
    2184                 :   32304200 :           (match_dup 3)
    2185                 :   32304200 :           (parallel [(const_int 1)])))]
    2186                 :   32360159 : {
    2187                 :      55910 :   operands[2] = gen_highpart (<MODE>mode, operands[0]);
    2188                 :      55910 :   operands[3] = lowpart_subreg (<ssevecmode>mode, operands[1], <DWI>mode);
    2189                 :   32304200 : 
    2190                 :   32304259 :   emit_move_insn (gen_lowpart (<MODE>mode, operands[0]),
    2191                 :   32304259 :                   gen_lowpart (<MODE>mode, operands[1]));
    2192                 :      21169 : })
    2193                 :   32304200 : 
    2194                 :   32304200 : (define_split
    2195                 :   32304259 :   [(set (match_operand:DWI 0 "nonimmediate_gr_operand")
    2196                 :         59 :         (match_operand:DWI 1 "general_gr_operand"))]
    2197                 :   54459859 :   "reload_completed"
    2198                 :   32304259 :   [(const_int 0)]
    2199                 :   32855945 :   "ix86_split_long_move (operands); DONE;")
    2200                 :         59 : 
    2201                 :   32304259 : (define_split
    2202                 :   32304259 :   [(set (match_operand:DI 0 "sse_reg_operand")
    2203                 :   32304259 :         (match_operand:DI 1 "general_reg_operand"))]
    2204                 :   32343449 :   "!TARGET_64BIT && TARGET_SSE4_1
    2205                 :   32304222 :    && reload_completed"
    2206                 :         22 :   [(set (match_dup 2)
    2207                 :   32304200 :         (vec_merge:V4SI
    2208                 :   32304200 :           (vec_duplicate:V4SI (match_dup 3))
    2209                 :   34018619 :           (match_dup 2)
    2210                 :   34018619 :           (const_int 2)))]
    2211                 :    1286973 : {
    2212                 :    2202829 :   operands[2] = lowpart_subreg (V4SImode, operands[0], DImode);
    2213                 :   32304222 :   operands[3] = gen_highpart (SImode, operands[1]);
    2214                 :   32744065 : 
    2215                 :   32304222 :   emit_move_insn (gen_lowpart (SImode, operands[0]),
    2216                 :   32744087 :                   gen_lowpart (SImode, operands[1]));
    2217                 :   32416161 : })
    2218                 :      13179 : 
    2219                 :   32304200 : ;; movabsq $0x0012345678000000, %rax is longer
    2220                 :   32416102 : ;; than movl $0x12345678, %eax; shlq $24, %rax.
    2221                 :   32370200 : (define_peephole2
    2222                 :     177846 :   [(set (match_operand:DI 0 "register_operand")
    2223                 :      66047 :         (match_operand:DI 1 "const_int_operand"))]
    2224                 :   33354539 :   "TARGET_64BIT
    2225                 :   33354480 :    && optimize_insn_for_size_p ()
    2226                 :   32625882 :    && LEGACY_INT_REG_P (operands[0])
    2227                 :   32429988 :    && !x86_64_immediate_operand (operands[1], DImode)
    2228                 :   32319882 :    && !x86_64_zext_immediate_operand (operands[1], DImode)
    2229                 :      15190 :    && !((UINTVAL (operands[1]) >> ctz_hwi (UINTVAL (operands[1])))
    2230                 :   32319390 :         & ~(HOST_WIDE_INT) 0xffffffff)
    2231                 :   32313130 :    && peep2_regno_dead_p (0, FLAGS_REG)"
    2232                 :   32304300 :   [(set (match_dup 0) (match_dup 1))
    2233                 :       8987 :    (parallel [(set (match_dup 0) (ashift:DI (match_dup 0) (match_dup 2)))
    2234                 :       9009 :               (clobber (reg:CC FLAGS_REG))])]
    2235                 :   32313123 : {
    2236                 :   32313101 :   int shift = ctz_hwi (UINTVAL (operands[1]));
    2237                 :   32313101 :   operands[1] = gen_int_mode (UINTVAL (operands[1]) >> shift, DImode);
    2238                 :   32313101 :   operands[2] = gen_int_mode (shift, QImode);
    2239                 :   32304200 : })
    2240                 :         86 : 
    2241                 :   32304200 : (define_insn "*movsi_internal"
    2242                 :   32322002 :   [(set (match_operand:SI 0 "nonimmediate_operand"
    2243                 :   38895801 :     "=r,m ,*y,*y,?*y,?m,?r,?*y,*v,*v,*v,m ,?r,?*v,*k,*k ,*rm,*k")
    2244                 :   32322302 :         (match_operand:SI 1 "general_operand"
    2245                 :   33902942 :     "g ,re,C ,*y,m  ,*y,*y,r  ,C ,*v,m ,*v,*v,r  ,*r,*km,*k ,CBC"))]
    2246                 :   29501782 :   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
    2247                 :    8129876 : {
    2248                 :   39900596 :   switch (get_attr_type (insn))
    2249                 :   32734874 :     {
    2250                 :   32752698 :     case TYPE_SSELOG1:
    2251                 :   39992822 :       return standard_sse_constant_opcode (insn, operands);
    2252                 :   39992800 : 
    2253                 :     124263 :     case TYPE_MSKMOV:
    2254                 :   32192818 :       return "kmovd\t{%1, %0|%0, %1}";
    2255                 :   32037600 : 
    2256                 :   32054302 :     case TYPE_MSKLOG:
    2257                 :      25567 :       if (operands[1] == const0_rtx)
    2258                 :      25565 :         return "kxord\t%0, %0, %0";
    2259                 :       8901 :       else if (operands[1] == constm1_rtx)
    2260                 :   32037600 :         return "kxnord\t%0, %0, %0";
    2261                 :          0 :       gcc_unreachable ();
    2262                 :      16664 : 
    2263                 :   32096523 :     case TYPE_SSEMOV:
    2264                 :   32096523 :       return ix86_output_ssemov (insn, operands);
    2265                 :          0 : 
    2266                 :      16408 :     case TYPE_MMX:
    2267                 :   32037600 :       return "pxor\t%0, %0";
    2268                 :   32037600 : 
    2269                 :   32037600 :     case TYPE_MMXMOV:
    2270                 :          0 :       switch (get_attr_mode (insn))
    2271                 :          0 :         {
    2272                 :   32037600 :         case MODE_DI:
    2273                 :   32037600 :           return "movq\t{%1, %0|%0, %1}";
    2274                 :          0 :         case MODE_SI:
    2275                 :   32037600 :           return "movd\t{%1, %0|%0, %1}";
    2276                 :   32037600 : 
    2277                 :   32037600 :         default:
    2278                 :   32037600 :           gcc_unreachable ();
    2279                 :   32037600 :         }
    2280                 :          0 : 
    2281                 :   32037609 :     case TYPE_LEA:
    2282                 :   32037609 :       return "lea{l}\t{%E1, %0|%0, %E1}";
    2283                 :   32037600 : 
    2284                 :   39122550 :     case TYPE_IMOV:
    2285                 :   39122550 :       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
    2286                 :    7084950 :       if (ix86_use_lea_for_mov (insn, operands))
    2287                 :          0 :         return "lea{l}\t{%E1, %0|%0, %E1}";
    2288                 :   32037600 :       else
    2289                 :   39122540 :         return "mov{l}\t{%1, %0|%0, %1}";
    2290                 :   32037600 : 
    2291                 :   32037600 :     default:
    2292                 :   32037600 :       gcc_unreachable ();
    2293                 :          0 :     }
    2294                 :   32037600 : }
    2295                 :   32037600 :   [(set (attr "isa")
    2296                 :   32041200 :      (cond [(eq_attr "alternative" "12,13")
    2297                 :   32041200 :               (const_string "sse2")
    2298                 :   32377125 :            ]
    2299                 :   32041200 :            (const_string "*")))
    2300                 :   32041200 :    (set (attr "type")
    2301                 :   32041200 :      (cond [(eq_attr "alternative" "2")
    2302                 :   32041200 :               (const_string "mmx")
    2303                 :   32041200 :             (eq_attr "alternative" "3,4,5,6,7")
    2304                 :   32041200 :               (const_string "mmxmov")
    2305                 :   32041200 :             (eq_attr "alternative" "8")
    2306                 :   32041200 :               (const_string "sselog1")
    2307                 :   32041200 :             (eq_attr "alternative" "9,10,11,12,13")
    2308                 :       3625 :               (const_string "ssemov")
    2309                 :       3625 :             (eq_attr "alternative" "14,15,16")
    2310                 :   32037600 :               (const_string "mskmov")
    2311                 :   32037600 :             (eq_attr "alternative" "17")
    2312                 :   32037600 :               (const_string "msklog")
    2313                 :   32037600 :             (and (match_operand 0 "register_operand")
    2314                 :   32037600 :                  (match_operand 1 "pic_32bit_operand"))
    2315                 :       3625 :               (const_string "lea")
    2316                 :   32037600 :            ]
    2317                 :   32037600 :            (const_string "imov")))
    2318                 :   32038600 :    (set (attr "prefix")
    2319                 :   32038600 :      (if_then_else (eq_attr "type" "sselog1,ssemov")
    2320                 :   32038600 :        (const_string "maybe_vex")
    2321                 :   32038600 :        (const_string "orig")))
    2322                 :   32038600 :    (set (attr "prefix_data16")
    2323                 :   32038627 :      (if_then_else (and (eq_attr "type" "ssemov") (eq_attr "mode" "SI"))
    2324                 :        951 :        (const_string "1")
    2325                 :        978 :        (const_string "*")))
    2326                 :   32037627 :    (set (attr "mode")
    2327                 :   32037627 :      (cond [(eq_attr "alternative" "2,3")
    2328                 :   32037627 :               (const_string "DI")
    2329                 :   32037627 :             (eq_attr "alternative" "8,9")
    2330                 :   32037600 :               (cond [(match_test "TARGET_AVX")
    2331                 :        978 :                        (const_string "TI")
    2332                 :   32037627 :                      (ior (not (match_test "TARGET_SSE2"))
    2333                 :   32037627 :                           (match_test "optimize_function_for_size_p (cfun)"))
    2334                 :   32053727 :                        (const_string "V4SF")
    2335                 :   32053727 :                     ]
    2336                 :   32053727 :                     (const_string "TI"))
    2337                 :   32053727 : 
    2338                 :   32053727 :             (and (eq_attr "alternative" "10,11")
    2339                 :   32053700 :                  (not (match_test "TARGET_SSE2")))
    2340                 :   32053700 :               (const_string "SF")
    2341                 :   32053700 :            ]
    2342                 :      16082 :            (const_string "SI")))
    2343                 :      16082 :    (set (attr "preferred_for_speed")
    2344                 :   32037627 :      (cond [(eq_attr "alternative" "6,12")
    2345                 :   32037627 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
    2346                 :   32037627 :             (eq_attr "alternative" "7,13")
    2347                 :   32037600 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_TO_VEC")
    2348                 :   32037600 :            ]
    2349                 :      16082 :            (symbol_ref "true")))])
    2350                 :   32037600 : 
    2351                 :   32037600 : (define_insn "*movhi_internal"
    2352                 :   32037964 :   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r ,r ,m ,k,k ,r,m,k")
    2353                 :   32037900 :         (match_operand:HI 1 "general_operand"      "r ,rn,rm,rn,r,km,k,k,CBC"))]
    2354                 :   36297444 :   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
    2355                 :   32373889 : {
    2356                 :     336217 :   switch (get_attr_type (insn))
    2357                 :        292 :     {
    2358                 :   39016614 :     case TYPE_IMOVX:
    2359                 :   39016550 :       /* movzwl is faster than movw on p2 due to partial word stalls,
    2360                 :   32082787 :          though not as fast as an aligned movl.  */
    2361                 :   39016614 :       return "movz{wl|x}\t{%1, %k0|%k0, %1}";
    2362                 :   32037664 : 
    2363                 :       9286 :     case TYPE_MSKMOV:
    2364                 :   32046658 :       switch (which_alternative)
    2365                 :   32037664 :         {
    2366                 :   32037764 :         case 4:
    2367                 :        170 :           return "kmovw\t{%k1, %0|%0, %k1}";
    2368                 :       1612 :         case 6:
    2369                 :   32039106 :           return "kmovw\t{%1, %k0|%k0, %1}";
    2370                 :   32038314 :         case 5:
    2371                 :   32038314 :         case 7:
    2372                 :   32038314 :           return "kmovw\t{%1, %0|%0, %1}";
    2373                 :   32037664 :         default:
    2374                 :        170 :           gcc_unreachable ();
    2375                 :   32037664 :         }
    2376                 :   32037600 : 
    2377                 :   32048511 :     case TYPE_MSKLOG:
    2378                 :   32048511 :       if (operands[1] == const0_rtx)
    2379                 :   32047700 :         return "kxorw\t%0, %0, %0";
    2380                 :   32052157 :       else if (operands[1] == constm1_rtx)
    2381                 :      10099 :         return "kxnorw\t%0, %0, %0";
    2382                 :      10099 :       gcc_unreachable ();
    2383                 :   32041251 : 
    2384                 :   32241195 :     default:
    2385                 :   32241195 :       if (get_attr_mode (insn) == MODE_SI)
    2386                 :   32041251 :         return "mov{l}\t{%k1, %k0|%k0, %k1}";
    2387                 :   32041251 :       else
    2388                 :     150699 :         return "mov{w}\t{%1, %0|%0, %1}";
    2389                 :   32037600 :     }
    2390                 :   32037600 : }
    2391                 :   32099800 :   [(set (attr "type")
    2392                 :   32099800 :      (cond [(eq_attr "alternative" "4,5,6,7")
    2393                 :   32099800 :               (const_string "mskmov")
    2394                 :   33091196 :             (eq_attr "alternative" "8")
    2395                 :   32099800 :               (const_string "msklog")
    2396                 :   32099800 :             (match_test "optimize_function_for_size_p (cfun)")
    2397                 :   32099800 :               (const_string "imov")
    2398                 :   32099800 :             (and (eq_attr "alternative" "0")
    2399                 :   32099800 :                  (ior (not (match_test "TARGET_PARTIAL_REG_STALL"))
    2400                 :   32099800 :                       (not (match_test "TARGET_HIMODE_MATH"))))
    2401                 :   32099800 :               (const_string "imov")
    2402                 :   32099800 :             (and (eq_attr "alternative" "1,2")
    2403                 :   32099800 :                  (match_operand:HI 1 "aligned_operand"))
    2404                 :   16730500 :               (const_string "imov")
    2405                 :   32099800 :             (and (match_test "TARGET_MOVX")
    2406                 :    2400250 :                  (eq_attr "alternative" "0,2"))
    2407                 :      62172 :               (const_string "imovx")
    2408                 :      62172 :            ]
    2409                 :   46021400 :            (const_string "imov")))
    2410                 :   13983800 :     (set (attr "prefix")
    2411                 :   13983800 :       (if_then_else (eq_attr "alternative" "4,5,6,7,8")
    2412                 :   32037600 :         (const_string "vex")
    2413                 :   32037600 :         (const_string "orig")))
    2414                 :      62160 :     (set (attr "mode")
    2415                 :   13935000 :       (cond [(eq_attr "type" "imovx")
    2416                 :   32037600 :                (const_string "SI")
    2417                 :   32039900 :              (and (eq_attr "alternative" "1,2")
    2418                 :       2316 :                   (match_operand:HI 1 "aligned_operand"))
    2419                 :    3596230 :                (const_string "SI")
    2420                 :   32037600 :              (and (eq_attr "alternative" "0")
    2421                 :   32037600 :                   (ior (not (match_test "TARGET_PARTIAL_REG_STALL"))
    2422                 :   32037600 :                        (not (match_test "TARGET_HIMODE_MATH"))))
    2423                 :   32037600 :                (const_string "SI")
    2424                 :   32037600 :             ]
    2425                 :       1808 :             (const_string "HI")))])
    2426                 :   32037600 : 
    2427                 :   32037600 : ;; Situation is quite tricky about when to choose full sized (SImode) move
    2428                 :   32043100 : ;; over QImode moves.  For Q_REG -> Q_REG move we use full size only for
    2429                 :       5473 : ;; partial register dependency machines (such as AMD Athlon), where QImode
    2430                 :       5473 : ;; moves issue extra dependency and for partial register stalls machines
    2431                 :   32037600 : ;; that don't use QImode patterns (and QImode move cause stall on the next
    2432                 :   32037600 : ;; instruction).
    2433                 :   32037600 : ;;
    2434                 :       4381 : ;; For loads of Q_REG to NONQ_REG we use full sized moves except for partial
    2435                 :   32037600 : ;; register stall machines with, where we use QImode instructions, since
    2436                 :   32037600 : ;; partial register stall can be caused there.  Then we use movzx.
    2437                 :   32037600 : 
    2438                 :   32037600 : (define_insn "*movqi_internal"
    2439                 :   32037600 :   [(set (match_operand:QI 0 "nonimmediate_operand"
    2440                 :       4381 :                         "=Q,R,r,q,q,r,r ,?r,m ,k,k,r,m,k,k,k")
    2441                 :   32037600 :         (match_operand:QI 1 "general_operand"
    2442                 :   32037600 :                         "Q ,R,r,n,m,q,rn, m,qn,r,k,k,k,m,C,BC"))]
    2443                 :   38509220 :   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
    2444                 :   33029096 : {
    2445                 :     991452 :   char buf[128];
    2446                 :     991452 :   const char *ops;
    2447                 :   38684716 :   const char *suffix;
    2448                 :   37693320 : 
    2449                 :   38684716 :   switch (get_attr_type (insn))
    2450                 :   32037600 :     {
    2451                 :   32326762 :     case TYPE_IMOVX:
    2452                 :     287840 :       gcc_assert (ANY_QI_REG_P (operands[1]) || MEM_P (operands[1]));
    2453                 :   32037600 :       return "movz{bl|x}\t{%1, %k0|%k0, %1}";
    2454                 :   32037600 : 
    2455                 :   34098799 :     case TYPE_MSKMOV:
    2456                 :   34098799 :       switch (which_alternative)
    2457                 :    2035150 :         {
    2458                 :    2035150 :         case 9:
    2459                 :   32037600 :           ops = "kmov%s\t{%%k1, %%0|%%0, %%k1}";
    2460                 :   32037600 :           break;
    2461                 :   32041093 :         case 11:
    2462                 :   32041093 :           ops = "kmov%s\t{%%1, %%k0|%%k0, %%1}";
    2463                 :   32041093 :           break;
    2464                 :        307 :         case 12:
    2465                 :   32037907 :         case 13:
    2466                 :   32037907 :           gcc_assert (TARGET_AVX512DQ);
    2467                 :   34692500 :           /* FALLTHRU */
    2468                 :    2655393 :         case 10:
    2469                 :    2655393 :           ops = "kmov%s\t{%%1, %%0|%%0, %%1}";
    2470                 :   32038163 :           break;
    2471                 :   32037600 :         default:
    2472                 :   32037600 :           gcc_unreachable ();
    2473                 :   32037600 :         }
    2474                 :   32037600 : 
    2475                 :      25999 :       suffix = (get_attr_mode (insn) == MODE_HI) ? "w" : "b";
    2476                 :   32037600 : 
    2477                 :   32063599 :       snprintf (buf, sizeof (buf), ops, suffix);
    2478                 :   32226399 :       output_asm_insn (buf, operands);
    2479                 :   32226399 :       return "";
    2480                 :   32200400 : 
    2481                 :   32202195 :     case TYPE_MSKLOG:
    2482                 :     164595 :       if (operands[1] == const0_rtx)
    2483                 :     162800 :         {
    2484                 :   32037618 :           if (get_attr_mode (insn) == MODE_HI)
    2485                 :   49906100 :             return "kxorw\t%0, %0, %0";
    2486                 :   49906100 :           else
    2487                 :   49906101 :             return "kxorb\t%0, %0, %0";
    2488                 :   49906100 :         }
    2489                 :     160736 :       else if (operands[1] == constm1_rtx)
    2490                 :   49906100 :         {
    2491                 :   49907877 :           gcc_assert (TARGET_AVX512DQ);
    2492                 :   50097900 :           return "kxnorb\t%0, %0, %0";
    2493                 :   50097900 :         }
    2494                 :     191785 :       gcc_unreachable ();
    2495                 :     191785 : 
    2496                 :   50581918 :     default:
    2497                 :   50581918 :       if (get_attr_mode (insn) == MODE_SI)
    2498                 :   49906100 :         return "mov{l}\t{%k1, %k0|%k0, %k1}";
    2499                 :   49906100 :       else
    2500                 :   50298180 :         return "mov{b}\t{%1, %0|%0, %1}";
    2501                 :     139183 :     }
    2502                 :   49906100 : }
    2503                 :   49906100 :   [(set (attr "isa")
    2504                 :   51316600 :      (cond [(eq_attr "alternative" "1,2")
    2505                 :   51316600 :               (const_string "x64")
    2506                 :   51316601 :             (eq_attr "alternative" "12,13,15")
    2507                 :   51316600 :               (const_string "avx512dq")
    2508                 :   51316600 :            ]
    2509                 :    1410510 :            (const_string "*")))
    2510                 :    1410510 :    (set (attr "type")
    2511                 :   49906100 :      (cond [(eq_attr "alternative" "9,10,11,12,13")
    2512                 :   49906100 :               (const_string "mskmov")
    2513                 :   49906100 :             (eq_attr "alternative" "14,15")
    2514                 :   49906100 :               (const_string "msklog")
    2515                 :   49906100 :             (and (eq_attr "alternative" "7")
    2516                 :        500 :                  (not (match_operand:QI 1 "aligned_operand")))
    2517                 :   49906100 :               (const_string "imovx")
    2518                 :   49906100 :             (match_test "optimize_function_for_size_p (cfun)")
    2519                 :   55760800 :               (const_string "imov")
    2520                 :    5854670 :             (and (eq_attr "alternative" "5")
    2521                 :    6701220 :                  (ior (not (match_test "TARGET_PARTIAL_REG_STALL"))
    2522                 :          0 :                       (not (match_test "TARGET_QIMODE_MATH"))))
    2523                 :   49906100 :               (const_string "imov")
    2524                 :   49906100 :             (eq_attr "alternative" "5,7")
    2525                 :    5859530 :               (const_string "imovx")
    2526                 :   44739100 :             (and (match_test "TARGET_MOVX")
    2527                 :   49906100 :                  (eq_attr "alternative" "4"))
    2528                 :      89363 :               (const_string "imovx")
    2529                 :   49906100 :            ]
    2530                 :   94645100 :            (const_string "imov")))
    2531                 :          0 :    (set (attr "prefix")
    2532                 :       1786 :      (if_then_else (eq_attr "alternative" "9,10,11,12,13,14,15")
    2533                 :   49906100 :        (const_string "vex")
    2534                 :  112380000 :        (const_string "orig")))
    2535                 :  112380000 :    (set (attr "mode")
    2536                 :  112380000 :       (cond [(eq_attr "alternative" "5,6,7")
    2537                 :  112380000 :                (const_string "SI")
    2538                 :       1440 :              (eq_attr "alternative" "8")
    2539                 :  112380000 :                (const_string "QI")
    2540                 :  112380000 :              (and (eq_attr "alternative" "9,10,11,14")
    2541                 :  112380000 :                   (not (match_test "TARGET_AVX512DQ")))
    2542                 :          0 :                (const_string "HI")
    2543                 :          0 :              (eq_attr "type" "imovx")
    2544                 :  112380000 :                (const_string "SI")
    2545                 :  112380000 :              ;; For -Os, 8-bit immediates are always shorter than 32-bit
    2546                 :  112380000 :              ;; ones.
    2547                 :  112380000 :              (and (eq_attr "type" "imov")
    2548                 :  112380000 :                   (and (eq_attr "alternative" "3")
    2549                 :          0 :                        (match_test "optimize_function_for_size_p (cfun)")))
    2550                 :  112380000 :                (const_string "QI")
    2551                 :  112380000 :              ;; For -Os, movl where one or both operands are NON_Q_REGS
    2552                 :  112380000 :              ;; and both are LEGACY_REGS is shorter than movb.
    2553                 :  112380000 :              ;; Otherwise movb and movl sizes are the same, so decide purely
    2554                 :          0 :              ;; based on speed factors.
    2555                 :          0 :              (and (eq_attr "type" "imov")
    2556                 :  112380000 :                   (and (eq_attr "alternative" "1")
    2557                 :   62473400 :                        (match_test "optimize_function_for_size_p (cfun)")))
    2558                 :   62473400 :                (const_string "SI")
    2559                 :   49906100 :              (and (eq_attr "type" "imov")
    2560                 :   49906100 :                   (and (eq_attr "alternative" "0,1,2,3")
    2561                 :    2553400 :                        (and (match_test "TARGET_PARTIAL_REG_DEPENDENCY")
    2562                 :   49906100 :                             (not (match_test "TARGET_PARTIAL_REG_STALL")))))
    2563                 :   49906100 :                (const_string "SI")
    2564                 :   59948200 :              ;; Avoid partial register stalls when not using QImode arithmetic
    2565                 :          0 :              (and (eq_attr "type" "imov")
    2566                 :          0 :                   (and (eq_attr "alternative" "0,1,2,3")
    2567                 :   49926900 :                        (and (match_test "TARGET_PARTIAL_REG_STALL")
    2568                 :          0 :                             (not (match_test "TARGET_QIMODE_MATH")))))
    2569                 :   49926900 :                (const_string "SI")
    2570                 :   49926900 :            ]
    2571                 :      20797 :            (const_string "QI")))])
    2572                 :      20797 : 
    2573                 :   49906100 : ;; Stores and loads of ax to arbitrary constant address.
    2574                 :   49906100 : ;; We fake an second form of instruction to force reload to load address
    2575                 :   49906100 : ;; into register when rax is not available
    2576                 :       3968 : (define_insn "*movabs<mode>_1"
    2577                 :   49906100 :   [(set (mem:SWI1248x (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
    2578                 :   49906100 :         (match_operand:SWI1248x 1 "nonmemory_operand" "a,r<i>"))]
    2579                 :   49910040 :   "TARGET_LP64 && ix86_check_movabs (insn, 0)"
    2580                 :   49906107 : {
    2581                 :   49906100 :   /* Recover the full memory rtx.  */
    2582                 :       3762 :   operands[0] = SET_DEST (PATTERN (insn));
    2583                 :   50051464 :   switch (which_alternative)
    2584                 :   50051457 :     {
    2585                 :     145357 :     case 0:
    2586                 :   58552500 :       return "movabs{<imodesuffix>}\t{%1, %P0|<iptrsize> PTR [%P0], %1}";
    2587                 :   58552507 :     case 1:
    2588                 :   58552507 :       return "mov{<imodesuffix>}\t{%1, %0|%0, %1}";
    2589                 :    8649186 :     default:
    2590                 :    8649186 :       gcc_unreachable ();
    2591                 :  389607786 :     }
    2592                 :   49906100 : }
    2593                 :  339699001 :   [(set_attr "type" "imov")
    2594                 :   49906100 :    (set_attr "modrm" "0,*")
    2595                 :   53390600 :    (set_attr "length_address" "8,0")
    2596                 :    4511008 :    (set_attr "length_immediate" "0,*")
    2597                 :    3484520 :    (set_attr "memory" "store")
    2598                 :   49906100 :    (set_attr "mode" "<MODE>")])
    2599                 :     435329 : 
    2600                 :   52873200 : (define_insn "*movabs<mode>_2"
    2601                 :   52873200 :   [(set (match_operand:SWI1248x 0 "register_operand" "=a,r")
    2602                 :   52873200 :         (mem:SWI1248x (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
    2603                 :    2981155 :   "TARGET_LP64 && ix86_check_movabs (insn, 1)"
    2604                 :    2967135 : {
    2605                 :   49906100 :   /* Recover the full memory rtx.  */
    2606                 :   49906112 :   operands[1] = SET_SRC (PATTERN (insn));
    2607                 :   50064585 :   switch (which_alternative)
    2608                 :   50064540 :     {
    2609                 :   49919034 :     case 0:
    2610                 :    3075654 :       return "movabs{<imodesuffix>}\t{%P1, %0|%0, <iptrsize> PTR [%P1]}";
    2611                 :   49906131 :     case 1:
    2612                 :   49906131 :       return "mov{<imodesuffix>}\t{%1, %0|%0, %1}";
    2613                 :   64391227 :     default:
    2614                 :   14485227 :       gcc_unreachable ();
    2615                 :   14485227 :     }
    2616                 :   49906100 : }
    2617                 :   49906100 :   [(set_attr "type" "imov")
    2618                 :   49906100 :    (set_attr "modrm" "0,*")
    2619                 :   49941612 :    (set_attr "length_address" "8,0")
    2620                 :   49941645 :    (set_attr "length_immediate" "0")
    2621                 :      35512 :    (set_attr "memory" "load")
    2622                 :   49906100 :    (set_attr "mode" "<MODE>")])
    2623                 :   49906100 : 
    2624                 :   51403100 : (define_insn "*swap<mode>"
    2625                 :    1496980 :   [(set (match_operand:SWI48 0 "register_operand" "+r")
    2626                 :    1496980 :         (match_operand:SWI48 1 "register_operand" "+r"))
    2627                 :   49906100 :    (set (match_dup 1)
    2628                 :   49906100 :         (match_dup 0))]
    2629                 :   49906100 :   ""
    2630                 :    1495883 :   "xchg{<imodesuffix>}\t%1, %0"
    2631                 :   49906100 :   [(set_attr "type" "imov")
    2632                 :   49906100 :    (set_attr "mode" "<MODE>")
    2633                 :   49906100 :    (set_attr "pent_pair" "np")
    2634                 :   49906100 :    (set_attr "athlon_decode" "vector")
    2635                 :   49906100 :    (set_attr "amdfam10_decode" "double")
    2636                 :    1493870 :    (set_attr "bdver1_decode" "double")])
    2637                 :   49906100 : 
    2638                 :   49906100 : (define_insn "*swap<mode>"
    2639                 :  641482000 :   [(set (match_operand:SWI12 0 "register_operand" "+<r>,r")
    2640                 :  591576000 :         (match_operand:SWI12 1 "register_operand" "+<r>,r"))
    2641                 :  591576000 :    (set (match_dup 1)
    2642                 :   49906100 :         (match_dup 0))]
    2643                 :   49906100 :   ""
    2644                 :   49906100 :   "@
    2645                 :  591576000 :    xchg{<imodesuffix>}\t%1, %0
    2646                 :   49906100 :    xchg{l}\t%k1, %k0"
    2647                 :   49906100 :   [(set_attr "type" "imov")
    2648                 :   49906100 :    (set_attr "mode" "<MODE>,SI")
    2649                 :  591576000 :    (set (attr "preferred_for_size")
    2650                 :   49906100 :      (cond [(eq_attr "alternative" "0")
    2651                 :   49906100 :               (symbol_ref "false")]
    2652                 :   49906100 :            (symbol_ref "true")))
    2653                 :  591576000 :    ;; Potential partial reg stall on alternative 1.
    2654                 :   49906100 :    (set (attr "preferred_for_speed")
    2655                 :   49906100 :      (cond [(eq_attr "alternative" "1")
    2656                 :   49906100 :               (symbol_ref "!TARGET_PARTIAL_REG_STALL")]
    2657                 :  591572000 :            (symbol_ref "true")))
    2658                 :   49906100 :    (set_attr "pent_pair" "np")
    2659                 :   49906100 :    (set_attr "athlon_decode" "vector")
    2660                 :   49906100 :    (set_attr "amdfam10_decode" "double")
    2661                 :  586729000 :    (set_attr "bdver1_decode" "double")])
    2662                 :   49906100 : 
    2663                 :   49906100 : (define_peephole2
    2664                 :   49906100 :   [(set (match_operand:SWI 0 "general_reg_operand")
    2665                 :  586729000 :         (match_operand:SWI 1 "general_reg_operand"))
    2666                 :   49906100 :    (set (match_dup 1)
    2667                 :   49906100 :         (match_operand:SWI 2 "general_reg_operand"))
    2668                 :   49906100 :    (set (match_dup 2) (match_dup 0))]
    2669                 :  586701133 :   "peep2_reg_dead_p (3, operands[0])
    2670                 :   49908885 :    && optimize_insn_for_size_p ()"
    2671                 :   49907911 :   [(parallel [(set (match_dup 1) (match_dup 2))
    2672                 :   49906127 :               (set (match_dup 2) (match_dup 1))])])
    2673                 :  586698027 : 
    2674                 :   49906100 : (define_expand "movstrict<mode>"
    2675                 :   49909248 :   [(set (strict_low_part (match_operand:SWI12 0 "register_operand"))
    2676                 :   49909248 :         (match_operand:SWI12 1 "general_operand"))]
    2677                 :   49909248 :   ""
    2678                 :   49913792 : {
    2679                 :  580767712 :   gcc_assert (SUBREG_P (operands[0]));
    2680                 :   49906100 :   if ((TARGET_PARTIAL_REG_STALL && optimize_function_for_speed_p (cfun))
    2681                 :   49910648 :       || !VALID_INT_MODE_P (GET_MODE (SUBREG_REG (operands[0]))))
    2682                 :  343044001 :     FAIL;
    2683                 :  293138000 : })
    2684                 :  293138000 : 
    2685                 :   49906100 : (define_insn "*movstrict<mode>_1"
    2686                 :   49910647 :   [(set (strict_low_part
    2687                 :   49910647 :           (match_operand:SWI12 0 "register_operand" "+<r>"))
    2688                 :  293142547 :         (match_operand:SWI12 1 "general_operand" "<r>mn"))]
    2689                 :   49910647 :   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
    2690                 :   50008654 :   "mov{<imodesuffix>}\t{%1, %0|%0, %1}"
    2691                 :   50004781 :   [(set_attr "type" "imov")
    2692                 :  293131134 :    (set_attr "mode" "<MODE>")])
    2693                 :   50000234 : 
    2694                 :   50004647 : (define_insn "*movstrict<mode>_xor"
    2695                 :   50004647 :   [(set (strict_low_part (match_operand:SWI12 0 "register_operand" "+<r>"))
    2696                 :  293135547 :         (match_operand:SWI12 1 "const0_operand"))
    2697                 :   50000100 :    (clobber (reg:CC FLAGS_REG))]
    2698                 :   50000278 :   "reload_completed"
    2699                 :   50000234 :   "xor{<imodesuffix>}\t%0, %0"
    2700                 :  290695000 :   [(set_attr "type" "alu1")
    2701                 :   50016939 :    (set_attr "mode" "<MODE>")
    2702                 :   50000193 :    (set_attr "length_immediate" "0")])
    2703                 :   50000193 : 
    2704                 :  290638336 : (define_expand "extv<mode>"
    2705                 :   50001178 :   [(set (match_operand:SWI24 0 "register_operand")
    2706                 :   50018285 :         (sign_extract:SWI24 (match_operand:SWI24 1 "register_operand")
    2707                 :   50017388 :                             (match_operand:SI 2 "const_int_operand")
    2708                 :  290668574 :                             (match_operand:SI 3 "const_int_operand")))]
    2709                 :   50016732 :   ""
    2710                 :   50044154 : {
    2711                 :   50016042 :   /* Handle extractions from %ah et al.  */
    2712                 :   50000601 :   if (INTVAL (operands[2]) != 8 || INTVAL (operands[3]) != 8)
    2713                 :   50034962 :     FAIL;
    2714                 :  290642489 : 
    2715                 :   50191671 :   unsigned int regno = reg_or_subregno (operands[1]);
    2716                 :   50191489 : 
    2717                 :   71212830 :   /* Be careful to expand only with registers having upper parts.  */
    2718                 :   18652671 :   if (regno <= LAST_VIRTUAL_REGISTER && !QI_REGNO_P (regno))
    2719                 :   36525463 :     operands[1] = copy_to_reg (operands[1]);
    2720                 :   32144850 : })
    2721                 :   32145250 : 
    2722                 :   32132877 : (define_insn "*extv<mode>"
    2723                 :   18318151 :   [(set (match_operand:SWI24 0 "register_operand" "=R")
    2724                 :     104386 :         (sign_extract:SWI24 (match_operand 1 "ext_register_operand" "Q")
    2725                 :   32040265 :                             (const_int 8)
    2726                 :   32108928 :                             (const_int 8)))]
    2727                 :   18308228 :   ""
    2728                 :   32108928 :   "movs{bl|x}\t{%h1, %k0|%k0, %h1}"
    2729                 :   32118515 :   [(set_attr "type" "imovx")
    2730                 :   32099982 :    (set_attr "mode" "SI")])
    2731                 :   32108448 : 
    2732                 :   32101226 : (define_expand "extzv<mode>"
    2733                 :   32107333 :   [(set (match_operand:SWI248 0 "register_operand")
    2734                 :   32114608 :         (zero_extract:SWI248 (match_operand:SWI248 1 "register_operand")
    2735                 :   32099800 :                              (match_operand:SI 2 "const_int_operand")
    2736                 :   32107481 :                              (match_operand:SI 3 "const_int_operand")))]
    2737                 :   32107663 :   ""
    2738                 :   32156608 : {
    2739                 :   32163735 :   if (ix86_expand_pextr (operands))
    2740                 :   32155041 :     DONE;
    2741                 :   32099801 : 
    2742                 :   32099801 :   /* Handle extractions from %ah et al.  */
    2743                 :   32155947 :   if (INTVAL (operands[2]) != 8 || INTVAL (operands[3]) != 8)
    2744                 :   32167215 :     FAIL;
    2745                 :   32099801 : 
    2746                 :   32100909 :   unsigned int regno = reg_or_subregno (operands[1]);
    2747                 :   32099801 : 
    2748                 :   32099801 :   /* Be careful to expand only with registers having upper parts.  */
    2749                 :   32100908 :   if (regno <= LAST_VIRTUAL_REGISTER && !QI_REGNO_P (regno))
    2750                 :   32138556 :     operands[1] = copy_to_reg (operands[1]);
    2751                 :   32138556 : })
    2752                 :   32138556 : 
    2753                 :   32138556 : (define_insn "*extzvqi_mem_rex64"
    2754                 :   32139664 :   [(set (match_operand:QI 0 "norex_memory_operand" "=Bn")
    2755                 :   32139664 :         (subreg:QI
    2756                 :   32138556 :           (zero_extract:SI (match_operand 1 "ext_register_operand" "Q")
    2757                 :   32100908 :                            (const_int 8)
    2758                 :   32100908 :                            (const_int 8)) 0))]
    2759                 :   32101502 :   "TARGET_64BIT && reload_completed"
    2760                 :   32100908 :   "mov{b}\t{%h1, %0|%0, %h1}"
    2761                 :   32101876 :   [(set_attr "type" "imov")
    2762                 :   32099849 :    (set_attr "mode" "QI")])
    2763                 :   32100908 : 
    2764                 :   32099800 : (define_insn "*extzv<mode>"
    2765                 :   32101642 :   [(set (match_operand:SWI248 0 "register_operand" "=R")
    2766                 :   32101642 :         (zero_extract:SWI248 (match_operand 1 "ext_register_operand" "Q")
    2767                 :   32101642 :                              (const_int 8)
    2768                 :   32102750 :                              (const_int 8)))]
    2769                 :   32100908 :   ""
    2770                 :   32101063 :   "movz{bl|x}\t{%h1, %k0|%k0, %h1}"
    2771                 :   32099955 :   [(set_attr "type" "imovx")
    2772                 :   32099849 :    (set_attr "mode" "SI")])
    2773                 :   32099955 : 
    2774                 :   32099800 : (define_insn "*extzvqi"
    2775                 :   32129770 :   [(set (match_operand:QI 0 "nonimmediate_operand" "=QBc,?R,m")
    2776                 :   32099904 :         (subreg:QI
    2777                 :   32099800 :           (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q,Q")
    2778                 :   32099904 :                            (const_int 8)
    2779                 :   30276304 :                            (const_int 8)) 0))]
    2780                 :    1853734 :   ""
    2781                 :   23255113 : {
    2782                 :   21401547 :   switch (get_attr_type (insn))
    2783                 :    1823660 :     {
    2784                 :    1823764 :     case TYPE_IMOVX:
    2785                 :    1853734 :       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
    2786                 :    1853972 :     default:
    2787                 :    1853868 :       return "mov{b}\t{%h1, %0|%0, %h1}";
    2788                 :    1823984 :     }
    2789                 :    1823764 : }
    2790                 :        315 :   [(set_attr "isa" "*,*,nox64")
    2791                 :    1823764 :    (set (attr "type")
    2792                 :    1823660 :      (if_then_else (and (match_operand:QI 0 "register_operand")
    2793                 :    1824195 :                         (ior (not (match_operand:QI 0 "QIreg_operand"))
    2794                 :   57840300 :                              (match_test "TARGET_MOVX")))
    2795                 :    1823660 :         (const_string "imovx")
    2796                 :          0 :         (const_string "imov")))
    2797                 :          0 :    (set (attr "mode")
    2798                 :    1823764 :      (if_then_else (eq_attr "type" "imovx")
    2799                 :    1823764 :         (const_string "SI")
    2800                 :   46018304 :         (const_string "QI")))])
    2801                 :    1823660 : 
    2802                 :    1823660 : (define_peephole2
    2803                 :          0 :   [(set (match_operand:QI 0 "register_operand")
    2804                 :   46518300 :         (subreg:QI
    2805                 :   46552454 :           (zero_extract:SI (match_operand 1 "ext_register_operand")
    2806                 :      11787 :                            (const_int 8)
    2807                 :          0 :                            (const_int 8)) 0))
    2808                 :    1823660 :    (set (match_operand:QI 2 "norex_memory_operand") (match_dup 0))]
    2809                 :   46125604 :   "TARGET_64BIT
    2810                 :      34245 :    && peep2_reg_dead_p (2, operands[0])"
    2811                 :    1846015 :   [(set (match_dup 2)
    2812                 :    1846118 :         (subreg:QI
    2813                 :   46136458 :           (zero_extract:SI (match_dup 1)
    2814                 :    1846014 :                            (const_int 8)
    2815                 :    1846014 :                            (const_int 8)) 0))])
    2816                 :      22354 : 
    2817                 :   46185832 : (define_expand "insv<mode>"
    2818                 :    1823660 :   [(set (zero_extract:SWI248 (match_operand:SWI248 0 "register_operand")
    2819                 :    6861610 :                              (match_operand:SI 1 "const_int_operand")
    2820                 :    5037950 :                              (match_operand:SI 2 "const_int_operand"))
    2821                 :    5163528 :         (match_operand:SWI248 3 "register_operand"))]
    2822                 :    1949238 :   ""
    2823                 :    2001591 : {
    2824                 :    2001591 :   rtx dst;
    2825                 :    1949238 : 
    2826                 :    1876013 :   if (ix86_expand_pinsr (operands))
    2827                 :    5148153 :     DONE;
    2828                 :    1933600 : 
    2829                 :    1823661 :   /* Handle insertions to %ah et al.  */
    2830                 :   19992831 :   if (INTVAL (operands[1]) != 8 || INTVAL (operands[2]) != 8)
    2831                 :   18058141 :     FAIL;
    2832                 :   18007101 : 
    2833                 :    1824710 :   unsigned int regno = reg_or_subregno (operands[0]);
    2834                 :    1823661 : 
    2835                 :    1823660 :   /* Be careful to expand only with registers having upper parts.  */
    2836                 :   17503650 :   if (regno <= LAST_VIRTUAL_REGISTER && !QI_REGNO_P (regno))
    2837                 :    1823821 :     dst = copy_to_reg (operands[0]);
    2838                 :    1823660 :   else
    2839                 :    1824550 :     dst = operands[0];
    2840                 :   17502601 : 
    2841                 :    1824709 :   emit_insn (gen_insv<mode>_1 (dst, operands[3]));
    2842                 :    1823661 : 
    2843                 :    1823661 :   /* Fix up the destination if needed.  */
    2844                 :   15918350 :   if (dst != operands[0])
    2845                 :    1823820 :     emit_move_insn (operands[0], dst);
    2846                 :    1823661 : 
    2847                 :    1824710 :   DONE;
    2848                 :    1823662 : })
    2849                 :    1823660 : 
    2850                 :   15449100 : (define_insn "*insvqi_1_mem_rex64"
    2851                 :    1823660 :   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
    2852                 :    1823660 :                          (const_int 8)
    2853                 :   15601800 :                          (const_int 8))
    2854                 :   13778100 :         (subreg:SI
    2855                 :   13778100 :           (match_operand:QI 1 "norex_memory_operand" "Bn") 0))]
    2856                 :    1823665 :   "TARGET_64BIT && reload_completed"
    2857                 :    1823814 :   "mov{b}\t{%1, %h0|%h0, %1}"
    2858                 :    1823660 :   [(set_attr "type" "imov")
    2859                 :   13472800 :    (set_attr "mode" "QI")])
    2860                 :    1823660 : 
    2861                 :    1823660 : (define_insn "insv<mode>_1"
    2862                 :    1823660 :   [(set (zero_extract:SWI248 (match_operand 0 "ext_register_operand" "+Q,Q")
    2863                 :   12566300 :                              (const_int 8)
    2864                 :      61902 :                              (const_int 8))
    2865                 :    1761760 :         (match_operand:SWI248 1 "general_operand" "QnBc,m"))]
    2866                 :  415087000 :   ""
    2867                 :   12278200 : {
    2868                 :    1796535 :   if (CONST_INT_P (operands[1]))
    2869                 :    1796105 :     operands[1] = gen_int_mode (INTVAL (operands[1]), QImode);
    2870                 :  415087900 :   return "mov{b}\t{%b1, %h0|%h0, %b1}";
    2871                 :  415087000 : }
    2872                 :  415116999 :   [(set_attr "isa" "*,nox64")
    2873                 :  425568301 :    (set_attr "type" "imov")
    2874                 :  415087000 :    (set_attr "mode" "QI")])
    2875                 :    1796366 : 
    2876                 :  408025001 : (define_insn "*insvqi_1"
    2877                 :  409141740 :   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q,Q")
    2878                 :  409141739 :                          (const_int 8)
    2879                 :  408025001 :                          (const_int 8))
    2880                 :  408025000 :         (subreg:SI
    2881                 :          1 :           (match_operand:QI 1 "general_operand" "QnBc,m") 0))]
    2882                 :    1116740 :   ""
    2883                 :    1826000 :   "mov{b}\t{%1, %h0|%h0, %1}"
    2884                 :    1834687 :   [(set_attr "isa" "*,nox64")
    2885                 :    1804689 :    (set_attr "type" "imov")
    2886                 :    1095429 :    (set_attr "mode" "QI")])
    2887                 :    1796001 : 
    2888                 :      13628 : (define_peephole2
    2889                 :    1796000 :   [(set (match_operand:QI 0 "register_operand")
    2890                 :      40722 :         (match_operand:QI 1 "norex_memory_operand"))
    2891                 :    1768249 :    (set (zero_extract:SI (match_operand 2 "ext_register_operand")
    2892                 :    2735469 :                          (const_int 8)
    2893                 :    2728980 :                          (const_int 8))
    2894                 :    2728980 :         (subreg:SI (match_dup 0) 0))]
    2895                 :          2 :   "TARGET_64BIT
    2896                 :    2728982 :    && peep2_reg_dead_p (2, operands[0])"
    2897                 :          1 :   [(set (zero_extract:SI (match_dup 2)
    2898                 :    7979880 :                          (const_int 8)
    2899                 :    5250900 :                          (const_int 8))
    2900                 :    2728980 :            (subreg:SI (match_dup 1) 0))])
    2901                 :    2813671 : 
    2902                 :    2813671 : (define_code_iterator any_extract [sign_extract zero_extract])
    2903                 :    2839712 : 
    2904                 :    2728980 : (define_insn "*insvqi_2"
    2905                 :    2755021 :   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
    2906                 :      26041 :                          (const_int 8)
    2907                 :    4579281 :                          (const_int 8))
    2908                 :    4579281 :         (any_extract:SI (match_operand 1 "ext_register_operand" "Q")
    2909                 :    4553240 :                         (const_int 8)
    2910                 :    4579281 :                         (const_int 8)))]
    2911                 :    4553240 :   ""
    2912                 :    4553240 :   "mov{b}\t{%h1, %h0|%h0, %h1}"
    2913                 :    4553240 :   [(set_attr "type" "imov")
    2914                 :    4553240 :    (set_attr "mode" "QI")])
    2915                 :    2820017 : 
    2916                 :    4462200 : (define_insn "*insvqi_3"
    2917                 :    4462200 :   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
    2918                 :    2728980 :                          (const_int 8)
    2919                 :    2739782 :                          (const_int 8))
    2920                 :    2739782 :         (any_shiftrt:SI (match_operand:SI 1 "register_operand" "Q")
    2921                 :    2739782 :                         (const_int 8)))]
    2922                 :    2739782 :   ""
    2923                 :    2728980 :   "mov{b}\t{%h1, %h0|%h0, %h1}"
    2924                 :    2739782 :   [(set_attr "type" "imov")
    2925                 :    2739782 :    (set_attr "mode" "QI")])
    2926                 :    2739782 : 
    2927                 :    2739782 : ;; Floating point push instructions.
    2928                 :    2739852 : 
    2929                 :    2728980 : (define_insn "*pushtf"
    2930                 :    2728980 :   [(set (match_operand:TF 0 "push_operand" "=<,<")
    2931                 :          0 :         (match_operand:TF 1 "general_no_elim_operand" "v,*roC"))]
    2932                 :    2773832 :   "TARGET_64BIT || TARGET_SSE"
    2933                 :    2728980 : {
    2934                 :    9663080 :   /* This insn should be already split before reg-stack.  */
    2935                 :    9460770 :   return "#";
    2936                 :    9663080 : }
    2937                 :    2728980 :   [(set_attr "isa" "*,x64")
    2938                 :    2728980 :    (set_attr "type" "multi")
    2939                 :    2728980 :    (set_attr "unit" "sse,*")
    2940                 :    2728980 :    (set_attr "mode" "TF,DI")])
    2941                 :    2728980 : 
    2942                 :    2728980 : ;; %%% Kill this when call knows how to work this out.
    2943                 :    2728980 : (define_split
    2944                 :     967217 :   [(set (match_operand:TF 0 "push_operand")
    2945                 :    1761760 :         (match_operand:TF 1 "sse_reg_operand"))]
    2946                 :    1813914 :   "TARGET_SSE && reload_completed"
    2947                 :          0 :   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -16)))
    2948                 :          0 :    (set (match_dup 0) (match_dup 1))]
    2949                 :      26065 : {
    2950                 :    1761760 :   /* Preserve memory attributes. */
    2951                 :   80532965 :   operands[0] = replace_equiv_address (operands[0], stack_pointer_rtx);
    2952                 :   78745200 : })
    2953                 :   78745200 : 
    2954                 :    1761760 : (define_insn_and_split "*pushxf_rounded"
    2955                 :    1787825 :   [(set (mem:XF
    2956                 :    1787825 :           (pre_modify:P
    2957                 :   78771065 :             (reg:P SP_REG)
    2958                 :    1787825 :             (plus:P (reg:P SP_REG) (const_int -16))))
    2959                 :    1787825 :         (match_operand:XF 0 "nonmemory_no_elim_operand" "f,r,*r,C"))]
    2960                 :    1761763 :   "TARGET_64BIT"
    2961                 :   78549500 :   "#"
    2962                 :    1761760 :   "&& 1"
    2963                 :    1761761 :   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -16)))
    2964                 :    1761760 :    (set (match_dup 1) (match_dup 0))]
    2965                 :   78575565 : {
    2966                 :    1761762 :   rtx pat = PATTERN (curr_insn);
    2967                 :    1787826 :   operands[1] = SET_DEST (pat);
    2968                 :    1787825 : 
    2969                 :   78575565 :   /* Preserve memory attributes. */
    2970                 :    1761761 :   operands[1] = replace_equiv_address (operands[1], stack_pointer_rtx);
    2971                 :   30272500 : }
    2972                 :   29369960 :   [(set_attr "type" "multi")
    2973                 :    1761760 :    (set_attr "unit" "i387,*,*,*")
    2974                 :    1816313 :    (set (attr "mode")
    2975                 :    1816337 :         (cond [(eq_attr "alternative" "1,2,3")
    2976                 :    1816313 :                  (const_string "DI")
    2977                 :    2043595 :               ]
    2978                 :    1779926 :               (const_string "XF")))
    2979                 :    1761784 :    (set (attr "preferred_for_size")
    2980                 :   75885224 :      (cond [(eq_attr "alternative" "1")
    2981                 :    1761760 :               (symbol_ref "false")]
    2982                 :         24 :            (symbol_ref "true")))])
    2983                 :    1761760 : 
    2984                 :    1761761 : (define_insn "*pushxf"
    2985                 :    1761760 :   [(set (match_operand:XF 0 "push_operand" "=<,<,<,<,<")
    2986                 :    1761761 :         (match_operand:XF 1 "general_no_elim_operand" "f,r,*r,oF,oC"))]
    2987                 :    1761761 :   ""
    2988                 :          1 : {
    2989                 :    1761760 :   /* This insn should be already split before reg-stack.  */
    2990                 :    1761760 :   return "#";
    2991                 :   75885200 : }
    2992                 :    1761760 :   [(set_attr "isa" "*,*,*,nox64,x64")
    2993                 :          0 :    (set_attr "type" "multi")
    2994                 :    1762268 :    (set_attr "unit" "i387,*,*,*,*")
    2995                 :    1761760 :    (set (attr "mode")
    2996                 :    1762268 :         (cond [(eq_attr "alternative" "1,2,3,4")
    2997                 :    1762268 :                  (if_then_else (match_test "TARGET_64BIT")
    2998                 :    1762268 :                    (const_string "DI")
    2999                 :          1 :                    (const_string "SI"))
    3000                 :    1762267 :               ]
    3001                 :    1761761 :               (const_string "XF")))
    3002                 :   75885707 :    (set (attr "preferred_for_size")
    3003                 :    1761760 :      (cond [(eq_attr "alternative" "1")
    3004                 :       4208 :               (symbol_ref "false")]
    3005                 :    1761760 :            (symbol_ref "true")))])
    3006                 :         38 : 
    3007                 :    1761760 : ;; %%% Kill this when call knows how to work this out.
    3008                 :    1761760 : (define_split
    3009                 :    1761760 :   [(set (match_operand:XF 0 "push_operand")
    3010                 :    1761760 :         (match_operand:XF 1 "fp_register_operand"))]
    3011                 :    1815748 :   "reload_completed"
    3012                 :    1761760 :   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
    3013                 :   75881000 :    (set (match_dup 0) (match_dup 1))]
    3014                 :    1779925 : {
    3015                 :      28846 :   operands[2] = GEN_INT (-PUSH_ROUNDING (GET_MODE_SIZE (XFmode)));
    3016                 :    1761760 :   /* Preserve memory attributes. */
    3017                 :    1779925 :   operands[0] = replace_equiv_address (operands[0], stack_pointer_rtx);
    3018                 :    1761760 : })
    3019                 :    1761760 : 
    3020                 :    1761760 : (define_insn "*pushdf"
    3021                 :      23562 :   [(set (match_operand:DF 0 "push_operand" "=<,<,<,<,<,<")
    3022                 :    1779925 :         (match_operand:DF 1 "general_no_elim_operand" "f,r,*r,oF,rmC,x"))]
    3023                 :    1779925 :   ""
    3024                 :   75888465 : {
    3025                 :    1779925 :   /* This insn should be already split before reg-stack.  */
    3026                 :      18165 :   return "#";
    3027                 :    1779925 : }
    3028                 :    1761760 :   [(set_attr "isa" "*,nox64,nox64,nox64,x64,sse2")
    3029                 :    1761760 :    (set_attr "type" "multi")
    3030                 :    1761760 :    (set_attr "unit" "i387,*,*,*,*,sse")
    3031                 :    1762003 :    (set_attr "mode" "DF,SI,SI,SI,DI,DF")
    3032                 :          0 :    (set (attr "preferred_for_size")
    3033                 :    1779925 :      (cond [(eq_attr "alternative" "1")
    3034                 :    1761760 :               (symbol_ref "false")]
    3035                 :   75888465 :            (symbol_ref "true")))
    3036                 :    1779925 :    (set (attr "preferred_for_speed")
    3037                 :      18165 :      (cond [(eq_attr "alternative" "1")
    3038                 :    1761760 :               (symbol_ref "TARGET_INTEGER_DFMODE_MOVES")]
    3039                 :    1761760 :            (symbol_ref "true")))])
    3040                 :    1761760 :    
    3041                 :    1761760 : ;; %%% Kill this when call knows how to work this out.
    3042                 :    1761760 : (define_split
    3043                 :      18570 :   [(set (match_operand:DF 0 "push_operand")
    3044                 :    1761760 :         (match_operand:DF 1 "any_fp_register_operand"))]
    3045                 :    1783696 :   "reload_completed"
    3046                 :   75888870 :   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -8)))
    3047                 :    1780330 :    (set (match_dup 0) (match_dup 1))]
    3048                 :    1762672 : {
    3049                 :    1779418 :   /* Preserve memory attributes. */
    3050                 :   75868483 :   operands[0] = replace_equiv_address (operands[0], stack_pointer_rtx);
    3051                 :    1779418 : })
    3052                 :    1761760 : 
    3053                 :    1761760 : (define_insn "*pushsf_rex64"
    3054                 :   75529483 :   [(set (match_operand:SF 0 "push_operand" "=X,X,X")
    3055                 :    1763443 :         (match_operand:SF 1 "nonmemory_no_elim_operand" "f,rF,x"))]
    3056                 :    1764252 :   "TARGET_64BIT"
    3057                 :    1763686 : {
    3058                 :   54179781 :   /* Anything else should be already split before reg-stack.  */
    3059                 :    1762701 :   if (which_alternative != 1)
    3060                 :    1761760 :     return "#";
    3061                 :    1761760 :   return "push{q}\t%q1";
    3062                 :   34809400 : }
    3063                 :    1761760 :   [(set_attr "type" "multi,push,multi")
    3064                 :    1763443 :    (set_attr "unit" "i387,*,*")
    3065                 :    1761760 :    (set_attr "mode" "SF,DI,SF")])
    3066                 :   33655078 : 
    3067                 :    1763443 : (define_insn "*pushsf"
    3068                 :    1763443 :   [(set (match_operand:SF 0 "push_operand" "=<,<,<")
    3069                 :    1761760 :         (match_operand:SF 1 "general_no_elim_operand" "f,rmF,x"))]
    3070                 :    1762243 :   "!TARGET_64BIT"
    3071                 :    1761955 : {
    3072                 :   33630700 :   /* Anything else should be already split before reg-stack.  */
    3073                 :   12124355 :   if (which_alternative != 1)
    3074                 :   11869728 :     return "#";
    3075                 :   12124160 :   return "push{l}\t%1";
    3076                 :    1762628 : }
    3077                 :    1762628 :   [(set_attr "type" "multi,push,multi")
    3078                 :    1762628 :    (set_attr "unit" "i387,*,*")
    3079                 :  276355771 :    (set_attr "mode" "SF,SI,SF")])
    3080                 :    1949032 : 
    3081                 :  276355771 : ;; %%% Kill this when call knows how to work this out.
    3082                 :    1761857 : (define_split
    3083                 :  274594000 :   [(set (match_operand:SF 0 "push_operand")
    3084                 :    1761760 :         (match_operand:SF 1 "any_fp_register_operand"))]
    3085                 :    4089361 :   "reload_completed"
    3086                 :    2327020 :   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
    3087                 :    6377230 :    (set (match_dup 0) (match_dup 1))]
    3088                 :    1761986 : {
    3089                 :    1761986 :   rtx op = XEXP (operands[0], 0);
    3090                 :    1761986 :   if (GET_CODE (op) == PRE_DEC)
    3091                 :    1761760 :     {
    3092                 :    1761857 :       gcc_assert (!TARGET_64BIT);
    3093                 :    1761857 :       op = GEN_INT (-4);
    3094                 :    1761760 :     }
    3095                 :    1761760 :   else
    3096                 :    1761760 :     {
    3097                 :    1761889 :       op = XEXP (XEXP (op, 1), 1);
    3098                 :    1761889 :       gcc_assert (CONST_INT_P (op));
    3099                 :    1761760 :     }
    3100                 :    1761986 :   operands[2] = op;
    3101                 :    1761760 :   /* Preserve memory attributes. */
    3102                 :    1761986 :   operands[0] = replace_equiv_address (operands[0], stack_pointer_rtx);
    3103                 :    1761760 : })
    3104                 :    1761760 : 
    3105                 :    1761760 : (define_split
    3106                 :    1761986 :   [(set (match_operand:SF 0 "push_operand")
    3107                 :    1761986 :         (match_operand:SF 1 "memory_operand"))]
    3108                 :    1761986 :   "reload_completed
    3109                 :    1762444 :    && find_constant_src (insn)"
    3110                 :    1763566 :   [(set (match_dup 0) (match_dup 2))]
    3111                 :    1761770 :   "operands[2] = find_constant_src (curr_insn);")
    3112                 :    1761986 : 
    3113                 :    1761760 : (define_split
    3114                 :    1761765 :   [(set (match_operand 0 "push_operand")
    3115                 :    1761765 :         (match_operand 1 "general_gr_operand"))]
    3116                 :    1761765 :   "reload_completed
    3117                 :    6242185 :    && (GET_MODE (operands[0]) == TFmode
    3118                 :    1761986 :        || GET_MODE (operands[0]) == XFmode
    3119                 :    7311995 :        || GET_MODE (operands[0]) == DFmode)"
    3120                 :    1773511 :   [(const_int 0)]
    3121                 :   81502206 :   "ix86_split_long_move (operands); DONE;")
    3122                 :   82693865 : 
    3123                 :   83264665 : ;; Floating point move instructions.
    3124                 :    2332560 : 
    3125                 :   82838660 : (define_expand "movtf"
    3126                 :    2332555 :   [(set (match_operand:TF 0 "nonimmediate_operand")
    3127                 :   29991860 :         (match_operand:TF 1 "nonimmediate_operand"))]
    3128                 :   29991994 :   "TARGET_64BIT || TARGET_SSE"
    3129                 :   30310197 :   "ix86_expand_move (TFmode, operands); DONE;")
    3130                 :   30003514 : 
    3131                 :    1761894 : (define_expand "mov<mode>"
    3132                 :   29699951 :   [(set (match_operand:X87MODEF 0 "nonimmediate_operand")
    3133                 :    1773280 :         (match_operand:X87MODEF 1 "general_operand"))]
    3134                 :    1989303 :   ""
    3135                 :    4400249 :   "ix86_expand_move (<MODE>mode, operands); DONE;")
    3136                 :    2307640 : 
    3137                 :    2080097 : (define_insn "*movtf_internal"
    3138                 :    2080098 :   [(set (match_operand:TF 0 "nonimmediate_operand" "=v,v ,m,?*r ,!o")
    3139                 :    2080097 :         (match_operand:TF 1 "general_operand"    "C ,vm,v,*roF,*rC"))]
    3140                 :    8798727 :   "(TARGET_64BIT || TARGET_SSE)
    3141                 :    8480390 :    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
    3142                 :    8475060 :    && (lra_in_progress || reload_completed
    3143                 :    7869190 :        || !CONST_DOUBLE_P (operands[1])
    3144                 :    1961026 :        || ((optimize_function_for_size_p (cfun)
    3145                 :    1944178 :             || (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC))
    3146                 :    2581952 :            && standard_sse_constant_p (operands[1], TFmode) == 1
    3147                 :    1762501 :            && !memory_operand (operands[0], TFmode))
    3148                 :    1960735 :        || (!TARGET_MEMORY_MISMATCH_STALL
    3149                 :    2565104 :            && memory_operand (operands[0], TFmode)))"
    3150                 :    9266599 : {
    3151                 :    2752279 :   switch (get_attr_type (insn))
    3152                 :    4161325 :     {
    3153                 :   11884432 :     case TYPE_SSELOG1:
    3154                 :   11883846 :       return standard_sse_constant_opcode (insn, operands);
    3155                 :   12673900 : 
    3156                 :    3542333 :     case TYPE_SSEMOV:
    3157                 :   11254023 :       return ix86_output_ssemov (insn, operands);
    3158                 :   10833106 : 
    3159                 :   12666470 :     case TYPE_MULTI:
    3160                 :    3357980 :         return "#";
    3161                 :    1761760 : 
    3162                 :    1761760 :     default:
    3163                 :    1761760 :       gcc_unreachable ();
    3164                 :    1761760 :     }
    3165                 :    1761760 : }
    3166                 :    1761760 :   [(set_attr "isa" "*,*,*,x64,x64")
    3167                 :    1761760 :    (set_attr "type" "sselog1,ssemov,ssemov,multi,multi")
    3168                 :    1761760 :    (set (attr "prefix")
    3169                 :    2401249 :      (if_then_else (eq_attr "type" "sselog1,ssemov")
    3170                 :    1761760 :        (const_string "maybe_vex")
    3171                 :    1761760 :        (const_string "orig")))
    3172                 :    1761760 :    (set (attr "mode")
    3173                 :    1761760 :         (cond [(eq_attr "alternative" "3,4")
    3174                 :        309 :                  (const_string "DI")
    3175                 :    1761450 :                (match_test "TARGET_AVX")
    3176                 :    1764820 :                  (const_string "TI")
    3177                 :    1764820 :                (ior (not (match_test "TARGET_SSE2"))
    3178                 :    1764820 :                     (match_test "optimize_function_for_size_p (cfun)"))
    3179                 :    1764820 :                  (const_string "V4SF")
    3180                 :    1764820 :                (match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
    3181                 :    1764820 :                  (const_string "V4SF")
    3182                 :    1764820 :                (and (eq_attr "alternative" "2")
    3183                 :    1764820 :                     (match_test "TARGET_SSE_TYPELESS_STORES"))
    3184                 :    1764820 :                  (const_string "V4SF")
    3185                 :    1764820 :                ]
    3186                 :    1764820 :                (const_string "TI")))])
    3187                 :    1764820 : 
    3188                 :    1764820 : (define_split
    3189                 :    1764820 :   [(set (match_operand:TF 0 "nonimmediate_gr_operand")
    3190                 :    1764820 :         (match_operand:TF 1 "general_gr_operand"))]
    3191                 :    1765414 :   "reload_completed"
    3192                 :    1765406 :   [(const_int 0)]
    3193                 :    1765406 :   "ix86_split_long_move (operands); DONE;")
    3194                 :    1764820 : 
    3195                 :    2611221 : ;; Possible store forwarding (partial memory) stall
    3196                 :    2611221 : ;; in alternatives 4, 6, 7 and 8.
    3197                 :    1942285 : (define_insn "*movxf_internal"
    3198                 :    2611221 :   [(set (match_operand:XF 0 "nonimmediate_operand"
    3199                 :    1764820 :          "=f,m,f,?r ,!o,?*r ,!o,!o,!o,r  ,o ,o")
    3200                 :    1764820 :         (match_operand:XF 1 "general_operand"
    3201                 :    1764820 :          "fm,f,G,roF,r ,*roF,*r,F ,C ,roF,rF,rC"))]
    3202                 :    7848620 :   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
    3203                 :    7840130 :    && (lra_in_progress || reload_completed
    3204                 :    7120930 :        || !CONST_DOUBLE_P (operands[1])
    3205                 :    2097771 :        || ((optimize_function_for_size_p (cfun)
    3206                 :    2054930 :             || (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC))
    3207                 :    1807661 :            && standard_80387_constant_p (operands[1]) > 0
    3208                 :    1789946 :            && !memory_operand (operands[0], XFmode))
    3209                 :    2073353 :        || (!TARGET_MEMORY_MISMATCH_STALL
    3210                 :    1767294 :            && memory_operand (operands[0], XFmode))
    3211                 :    2073353 :        || !TARGET_HARD_XF_REGS)"
    3212                 :    2753730 : {
    3213                 :    2404309 :   switch (get_attr_type (insn))
    3214                 :    1764820 :     {
    3215                 :    2404309 :     case TYPE_FMOV:
    3216                 :    2404309 :       if (which_alternative == 2)
    3217                 :    1815699 :         return standard_80387_constant_opcode (operands[1]);
    3218                 :    2362118 :       return output_387_reg_move (insn, operands);
    3219                 :    1764820 : 
    3220                 :    1764820 :     case TYPE_MULTI:
    3221                 :    1773508 :       return "#";
    3222                 :    1773508 : 
    3223                 :    1773508 :     default:
    3224                 :    1773508 :       gcc_unreachable ();
    3225                 :    1773508 :     }
    3226                 :    1773508 : }
    3227                 :    1773508 :   [(set (attr "isa")
    3228                 :    1773508 :         (cond [(eq_attr "alternative" "7,10")
    3229                 :    1773508 :                  (const_string "nox64")
    3230                 :    2416402 :                (eq_attr "alternative" "8,11")
    3231                 :    1772162 :                  (const_string "x64")
    3232                 :    1772162 :               ]
    3233                 :    1764820 :               (const_string "*")))
    3234                 :    1772162 :    (set (attr "type")
    3235                 :    1772162 :         (cond [(eq_attr "alternative" "3,4,5,6,7,8,9,10,11")
    3236                 :    1764820 :                  (const_string "multi")
    3237                 :    1764820 :               ]
    3238                 :    1764820 :               (const_string "fmov")))
    3239                 :    1764820 :    (set (attr "mode")
    3240                 :    1764820 :         (cond [(eq_attr "alternative" "3,4,5,6,7,8,9,10,11")
    3241                 :    1764820 :                  (if_then_else (match_test "TARGET_64BIT")
    3242                 :    1764820 :                    (const_string "DI")
    3243                 :    1764820 :                    (const_string "SI"))
    3244                 :    1764820 :               ]
    3245                 :    1764820 :               (const_string "XF")))
    3246                 :    1764820 :    (set (attr "preferred_for_size")
    3247                 :    1764820 :      (cond [(eq_attr "alternative" "3,4")
    3248                 :    1764820 :               (symbol_ref "false")]
    3249                 :    1764820 :            (symbol_ref "true")))
    3250                 :    1764820 :    (set (attr "enabled")
    3251                 :    1764820 :      (cond [(eq_attr "alternative" "9,10,11")
    3252                 :    1764820 :               (if_then_else
    3253                 :    8412700 :                 (match_test "TARGET_HARD_XF_REGS")
    3254                 :    1764820 :                 (symbol_ref "false")
    3255                 :    1764820 :                 (const_string "*"))
    3256                 :    1764820 :             (not (match_test "TARGET_HARD_XF_REGS"))
    3257                 :    1764820 :               (symbol_ref "false")
    3258                 :    1764820 :            ]
    3259                 :    1764820 :            (const_string "*")))])
    3260                 :    1764820 :    
    3261                 :    1764820 : (define_split
    3262                 :    1764820 :   [(set (match_operand:XF 0 "nonimmediate_gr_operand")
    3263                 :    1764820 :         (match_operand:XF 1 "general_gr_operand"))]
    3264                 :    1767461 :   "reload_completed"
    3265                 :    1767294 :   [(const_int 0)]
    3266                 :    1767294 :   "ix86_split_long_move (operands); DONE;")
    3267                 :    1764820 : 
    3268                 :    3426600 : ;; Possible store forwarding (partial memory) stall in alternatives 4, 6 and 7.
    3269                 :    3426600 : (define_insn "*movdf_internal"
    3270                 :    2261350 :   [(set (match_operand:DF 0 "nonimmediate_operand"
    3271                 :    3426600 :     "=Yf*f,m   ,Yf*f,?r ,!o,?*r ,!o,!o,?r,?m,?r,?r,v,v,v,m,*x,*x,*x,m ,r ,v,r  ,o ,r  ,m")
    3272                 :    1764820 :         (match_operand:DF 1 "general_operand"
    3273                 :    1764820 :     "Yf*fm,Yf*f,G   ,roF,r ,*roF,*r,F ,rm,rC,C ,F ,C,v,m,v,C ,*x,m ,*x,v,r ,roF,rF,rmF,rC"))]
    3274                 :   10791420 :   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
    3275                 :   10776300 :    && (lra_in_progress || reload_completed
    3276                 :   10060120 :        || !CONST_DOUBLE_P (operands[1])
    3277                 :    1999145 :        || ((optimize_function_for_size_p (cfun)
    3278                 :    1982071 :             || (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC))
    3279                 :    1782478 :            && ((IS_STACK_MODE (DFmode)
    3280                 :    1765407 :                 && standard_80387_constant_p (operands[1]) > 0)
    3281                 :    1783062 :                || (TARGET_SSE2 && TARGET_SSE_MATH
    3282                 :    1782475 :                    && standard_sse_constant_p (operands[1], DFmode) == 1))
    3283                 :    1771851 :            && !memory_operand (operands[0], DFmode))
    3284                 :    1993186 :        || ((TARGET_64BIT || !TARGET_MEMORY_MISMATCH_STALL)
    3285                 :    1957679 :            && memory_operand (operands[0], DFmode))
    3286                 :    1985008 :        || !TARGET_HARD_DF_REGS)"
    3287                 :   11207692 : {
    3288                 :    2416402 :   switch (get_attr_type (insn))
    3289                 :    1764820 :     {
    3290                 :   12148753 :     case TYPE_FMOV:
    3291                 :   12148753 :       if (which_alternative == 2)
    3292                 :    1766222 :         return standard_80387_constant_opcode (operands[1]);
    3293                 :    1785304 :       return output_387_reg_move (insn, operands);
    3294                 :    1766073 : 
    3295                 :    1764820 :     case TYPE_MULTI:
    3296                 :    1764820 :       return "#";
    3297                 :    1764820 : 
    3298                 :    1830797 :     case TYPE_IMOV:
    3299                 :    1830797 :       if (get_attr_mode (insn) == MODE_SI)
    3300                 :    1764820 :         return "mov{l}\t{%1, %k0|%k0, %1}";
    3301                 :    1830797 :       else if (which_alternative == 11)
    3302                 :    1764820 :         return "movabs{q}\t{%1, %0|%0, %1}";
    3303                 :    1764820 :       else
    3304                 :    1830788 :         return "mov{q}\t{%1, %0|%0, %1}";
    3305                 :    1764820 : 
    3306                 :    1785847 :     case TYPE_SSELOG1:
    3307                 :    1785847 :       return standard_sse_constant_opcode (insn, operands);
    3308                 :    1764820 : 
    3309                 :    2308765 :     case TYPE_SSEMOV:
    3310                 :    2308765 :       return ix86_output_ssemov (insn, operands);
    3311                 :    1764820 : 
    3312                 :    1764820 :     default:
    3313                 :    1764820 :       gcc_unreachable ();
    3314                 :    1764820 :     }
    3315                 :    1764820 : }
    3316                 :    1764820 :   [(set (attr "isa")
    3317                 :    1764820 :         (cond [(eq_attr "alternative" "3,4,5,6,7,22,23")
    3318                 :    1764820 :                  (const_string "nox64")
    3319                 :    2203666 :                (eq_attr "alternative" "8,9,10,11,24,25")
    3320                 :    1764820 :                  (const_string "x64")
    3321                 :    1764820 :                (eq_attr "alternative" "12,13,14,15")
    3322                 :    1764820 :                  (const_string "sse2")
    3323                 :    1764820 :                (eq_attr "alternative" "20,21")
    3324                 :    1764820 :                  (const_string "x64_sse2")
    3325                 :    1764820 :               ]
    3326                 :    1764820 :               (const_string "*")))
    3327                 :    1764820 :    (set (attr "type")
    3328                 :    1764820 :         (cond [(eq_attr "alternative" "0,1,2")
    3329                 :    1764820 :                  (const_string "fmov")
    3330                 :    1764820 :                (eq_attr "alternative" "3,4,5,6,7,22,23")
    3331                 :    1764820 :                  (const_string "multi")
    3332                 :    1764820 :                (eq_attr "alternative" "8,9,10,11,24,25")
    3333                 :    1764820 :                  (const_string "imov")
    3334                 :    1764820 :                (eq_attr "alternative" "12,16")
    3335                 :    1764820 :                  (const_string "sselog1")
    3336                 :    1764820 :               ]
    3337                 :    1764820 :               (const_string "ssemov")))
    3338                 :    1764820 :    (set (attr "modrm")
    3339                 :    1764820 :      (if_then_else (eq_attr "alternative" "11")
    3340                 :    1764820 :        (const_string "0")
    3341                 :    1764820 :        (const_string "*")))
    3342                 :    1764820 :    (set (attr "length_immediate")
    3343                 :    1764820 :      (if_then_else (eq_attr "alternative" "11")
    3344                 :    1764820 :        (const_string "8")
    3345                 :    1764820 :        (const_string "*")))
    3346                 :    1764820 :    (set (attr "prefix")
    3347                 :    1764820 :      (if_then_else (eq_attr "type" "sselog1,ssemov")
    3348                 :    1764820 :        (const_string "maybe_vex")
    3349                 :    1764820 :        (const_string "orig")))
    3350                 :    1764820 :    (set (attr "prefix_data16")
    3351                 :    1764820 :      (if_then_else
    3352                 :    1764820 :        (ior (and (eq_attr "type" "ssemov") (eq_attr "mode" "DI"))
    3353                 :    1764820 :             (eq_attr "mode" "V1DF"))
    3354                 :    1764820 :        (const_string "1")
    3355                 :    1764820 :        (const_string "*")))
    3356                 :    1764820 :    (set (attr "mode")
    3357                 :    1764820 :         (cond [(eq_attr "alternative" "3,4,5,6,7,10,22,23")
    3358                 :    1764820 :                  (const_string "SI")
    3359                 :    1764820 :                (eq_attr "alternative" "8,9,11,20,21,24,25")
    3360                 :    1764820 :                  (const_string "DI")
    3361                 :    1764820 : 
    3362                 :    1764820 :                /* xorps is one byte shorter for non-AVX targets.  */
    3363                 :    1764820 :                (eq_attr "alternative" "12,16")
    3364                 :    1764820 :                  (cond [(match_test "TARGET_AVX")
    3365                 :    1764820 :                           (const_string "V2DF")
    3366                 :    1764820 :                         (ior (not (match_test "TARGET_SSE2"))
    3367                 :    1764820 :                              (match_test "optimize_function_for_size_p (cfun)"))
    3368                 :    1764820 :                           (const_string "V4SF")
    3369                 :    1764820 :                         (match_test "TARGET_SSE_LOAD0_BY_PXOR")
    3370                 :    1764820 :                           (const_string "TI")
    3371                 :    1764820 :                        ]
    3372                 :    1764820 :                        (const_string "V2DF"))
    3373                 :    1764820 : 
    3374                 :    1764820 :                /* For architectures resolving dependencies on
    3375                 :    1764820 :                   whole SSE registers use movapd to break dependency
    3376                 :    1764820 :                   chains, otherwise use short move to avoid extra work.  */
    3377                 :    1764820 : 
    3378                 :    1764820 :                /* movaps is one byte shorter for non-AVX targets.  */
    3379                 :    1764820 :                (eq_attr "alternative" "13,17")
    3380                 :    1764820 :                  (cond [(match_test "TARGET_AVX")
    3381                 :    1764820 :                           (const_string "DF")
    3382                 :    1764820 :                         (ior (not (match_test "TARGET_SSE2"))
    3383                 :    1764820 :                              (match_test "optimize_function_for_size_p (cfun)"))
    3384                 :    1764820 :                           (const_string "V4SF")
    3385                 :    1764820 :                         (match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")
    3386                 :    1764820 :                           (const_string "V4SF")
    3387                 :    1764820 :                         (match_test "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
    3388                 :    1764820 :                           (const_string "V2DF")
    3389                 :    1764820 :                        ]
    3390                 :    1764820 :                        (const_string "DF"))
    3391                 :    1764820 : 
    3392                 :    1764820 :                /* For architectures resolving dependencies on register
    3393                 :    1764820 :                   parts we may avoid extra work to zero out upper part
    3394                 :    1764820 :                   of register.  */
    3395                 :    1764820 :                (eq_attr "alternative" "14,18")
    3396                 :    1764820 :                  (cond [(not (match_test "TARGET_SSE2"))
    3397                 :    1764820 :                           (const_string "V2SF")
    3398                 :    1764820 :                         (match_test "TARGET_AVX")
    3399                 :    1764820 :                           (const_string "DF")
    3400                 :    1764820 :                         (match_test "TARGET_SSE_SPLIT_REGS")
    3401                 :    1764820 :                           (const_string "V1DF")
    3402                 :    1764820 :                        ]
    3403                 :    1764820 :                        (const_string "DF"))
    3404                 :    1764820 : 
    3405                 :    1764820 :                (and (eq_attr "alternative" "15,19")
    3406                 :    1764820 :                     (not (match_test "TARGET_SSE2")))
    3407                 :    1764820 :                  (const_string "V2SF")
    3408                 :    1764820 :               ]
    3409                 :    1764820 :               (const_string "DF")))
    3410                 :    1764820 :    (set (attr "preferred_for_size")
    3411                 :    1764820 :      (cond [(eq_attr "alternative" "3,4")
    3412                 :    1764820 :               (symbol_ref "false")]
    3413                 :    1764820 :            (symbol_ref "true")))
    3414                 :    1764820 :    (set (attr "preferred_for_speed")
    3415                 :    1764820 :      (cond [(eq_attr "alternative" "3,4")
    3416                 :       1380 :               (symbol_ref "TARGET_INTEGER_DFMODE_MOVES")
    3417                 :    1764820 :             (eq_attr "alternative" "20")
    3418                 :    7088300 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
    3419                 :    1764820 :             (eq_attr "alternative" "21")
    3420                 :     389013 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_TO_VEC")
    3421                 :    1764820 :            ]
    3422                 :    1764820 :            (symbol_ref "true")))
    3423                 :    1764820 :    (set (attr "enabled")
    3424                 :    8920540 :      (cond [(eq_attr "alternative" "22,23,24,25")
    3425                 :    7155720 :               (if_then_else
    3426                 :   38989800 :                 (match_test "TARGET_HARD_DF_REGS")
    3427                 :    1764820 :                 (symbol_ref "false")
    3428                 :      67422 :                 (const_string "*"))
    3429                 :    1764820 :             (not (match_test "TARGET_HARD_DF_REGS"))
    3430                 :    1764820 :               (symbol_ref "false")
    3431                 :    1764820 :            ]
    3432                 :    1764820 :            (const_string "*")))])
    3433                 :    1764820 : 
    3434                 :    1764820 : (define_split
    3435                 :    1764820 :   [(set (match_operand:DF 0 "nonimmediate_gr_operand")
    3436                 :    1764820 :         (match_operand:DF 1 "general_gr_operand"))]
    3437                 :    1882918 :   "!TARGET_64BIT && reload_completed"
    3438                 :    1765404 :   [(const_int 0)]
    3439                 :    1765404 :   "ix86_split_long_move (operands); DONE;")
    3440                 :    1764820 : 
    3441                 :    1764820 : (define_insn "*movsf_internal"
    3442                 :    1764820 :   [(set (match_operand:SF 0 "nonimmediate_operand"
    3443                 :    1764820 :           "=Yf*f,m   ,Yf*f,?r ,?m,v,v,v,m,?r,?v,!*y,!*y,!m,!r,!*y,r  ,m")
    3444                 :   81489820 :         (match_operand:SF 1 "general_operand"
    3445                 :    5367890 :           "Yf*fm,Yf*f,G   ,rmF,rF,C,v,m,v,v ,r ,*y ,m  ,*y,*y,r  ,rmF,rF"))]
    3446                 :   91562620 :   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
    3447                 :   11795720 :    && (lra_in_progress || reload_completed
    3448                 :   11277140 :        || !CONST_DOUBLE_P (operands[1])
    3449                 :    2140577 :        || ((optimize_function_for_size_p (cfun)
    3450                 :    2109877 :             || (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC))
    3451                 :    1867925 :            && ((IS_STACK_MODE (SFmode)
    3452                 :    1764823 :                 && standard_80387_constant_p (operands[1]) > 0)
    3453                 :    1867925 :                || (TARGET_SSE && TARGET_SSE_MATH
    3454                 :    1867922 :                    && standard_sse_constant_p (operands[1], SFmode) == 1)))
    3455                 :    2204805 :        || memory_operand (operands[0], SFmode)
    3456                 :    2196171 :        || !TARGET_HARD_SF_REGS)"
    3457                 :   11948051 : {
    3458                 :    2203666 :   switch (get_attr_type (insn))
    3459                 :    1837225 :     {
    3460                 :    8949511 :     case TYPE_FMOV:
    3461                 :    8949511 :       if (which_alternative == 2)
    3462                 :    8667169 :         return standard_80387_constant_opcode (operands[1]);
    3463                 :   15817462 :       return output_387_reg_move (insn, operands);
    3464                 :    1764820 : 
    3465                 :    1764820 :     case TYPE_IMOV:
    3466                 :    1764820 :       return "mov{l}\t{%1, %0|%0, %1}";
    3467                 :    1764820 : 
    3468                 :    1778555 :     case TYPE_SSELOG1:
    3469                 :    1778555 :       return standard_sse_constant_opcode (insn, operands);
    3470                 :    1764820 : 
    3471                 :    2156679 :     case TYPE_SSEMOV:
    3472                 :    2156679 :       return ix86_output_ssemov (insn, operands);
    3473                 :    1764820 : 
    3474                 :    1764820 :     case TYPE_MMXMOV:
    3475                 :    1764820 :       switch (get_attr_mode (insn))
    3476                 :    1764820 :         {
    3477                 :    1764820 :         case MODE_DI:
    3478                 :    1764820 :           return "movq\t{%1, %0|%0, %1}";
    3479                 :    1764820 :         case MODE_SI:
    3480                 :    1764820 :           return "movd\t{%1, %0|%0, %1}";
    3481                 :    1764820 : 
    3482                 :    1764820 :         default:
    3483                 :    1764820 :           gcc_unreachable ();
    3484                 :    1764820 :         }
    3485                 :    1764820 : 
    3486                 :    1764820 :     default:
    3487                 :    1764820 :       gcc_unreachable ();
    3488                 :    1764820 :     }
    3489                 :    1764820 : }
    3490                 :    1764820 :   [(set (attr "isa")
    3491                 :    1764820 :      (cond [(eq_attr "alternative" "9,10")
    3492                 :    1764820 :               (const_string "sse2")
    3493                 :    1800106 :            ]
    3494                 :    1764820 :            (const_string "*")))
    3495                 :    1764820 :    (set (attr "type")
    3496                 :    1764820 :         (cond [(eq_attr "alternative" "0,1,2")
    3497                 :    1764820 :                  (const_string "fmov")
    3498                 :    1764820 :                (eq_attr "alternative" "3,4,16,17")
    3499                 :    1764820 :                  (const_string "imov")
    3500                 :    1764820 :                (eq_attr "alternative" "5")
    3501                 :    1764820 :                  (const_string "sselog1")
    3502                 :    1764820 :                (eq_attr "alternative" "11,12,13,14,15")
    3503                 :    1764820 :                  (const_string "mmxmov")
    3504                 :    1764820 :               ]
    3505                 :    1764820 :               (const_string "ssemov")))
    3506                 :    1764820 :    (set (attr "prefix")
    3507                 :    1764820 :      (if_then_else (eq_attr "type" "sselog1,ssemov")
    3508                 :    1764820 :        (const_string "maybe_vex")
    3509                 :    1764820 :        (const_string "orig")))
    3510                 :    1764820 :    (set (attr "prefix_data16")
    3511                 :    1764820 :      (if_then_else (and (eq_attr "type" "ssemov") (eq_attr "mode" "SI"))
    3512                 :    1764820 :        (const_string "1")
    3513                 :    1764820 :        (const_string "*")))
    3514                 :    1764820 :    (set (attr "mode")
    3515                 :    1764820 :         (cond [(eq_attr "alternative" "3,4,9,10,12,13,14,15,16,17")
    3516                 :    1764820 :                  (const_string "SI")
    3517                 :    1761450 :                (eq_attr "alternative" "11")
    3518                 :    1761450 :                  (const_string "DI")
    3519                 :       3369 :                (eq_attr "alternative" "5")
    3520                 :       3369 :                  (cond [(and (match_test "TARGET_AVX512F")
    3521                 :       2400 :                              (not (match_test "TARGET_PREFER_AVX256")))
    3522                 :       3369 :                           (const_string "V16SF")
    3523                 :       3369 :                         (match_test "TARGET_AVX")
    3524                 :       3369 :                           (const_string "V4SF")
    3525                 :     181734 :                         (ior (not (match_test "TARGET_SSE2"))
    3526                 :       3369 :                              (match_test "optimize_function_for_size_p (cfun)"))
    3527                 :       3369 :                           (const_string "V4SF")
    3528                 :       3369 :                         (match_test "TARGET_SSE_LOAD0_BY_PXOR")
    3529                 :       3369 :                           (const_string "TI")
    3530                 :       3369 :                        ]
    3531                 :       3369 :                        (const_string "V4SF"))
    3532                 :       3369 : 
    3533                 :       3369 :                /* For architectures resolving dependencies on
    3534                 :       3369 :                   whole SSE registers use APS move to break dependency
    3535                 :       3369 :                   chains, otherwise use short move to avoid extra work.
    3536                 :       3369 : 
    3537                 :       3369 :                   Do the same for architectures resolving dependencies on
    3538                 :       3369 :                   the parts.  While in DF mode it is better to always handle
    3539                 :       3369 :                   just register parts, the SF mode is different due to lack
    3540                 :       3369 :                   of instructions to load just part of the register.  It is
    3541                 :       3369 :                   better to maintain the whole registers in single format
    3542                 :       3369 :                   to avoid problems on using packed logical operations.  */
    3543                 :       3369 :                (eq_attr "alternative" "6")
    3544                 :    2115850 :                  (cond [(ior (match_test "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
    3545                 :    6847420 :                              (match_test "TARGET_SSE_SPLIT_REGS"))
    3546                 :       3369 :                           (const_string "V4SF")
    3547                 :       3369 :                        ]
    3548                 :       3369 :                        (const_string "SF"))
    3549                 :       3369 :               ]
    3550                 :        128 :               (const_string "SF")))
    3551                 :    6846420 :    (set (attr "preferred_for_speed")
    3552                 :       3369 :      (cond [(eq_attr "alternative" "9,14")
    3553                 :   10817400 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
    3554                 :    3773800 :             (eq_attr "alternative" "10,15")
    3555                 :    7043580 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_TO_VEC")
    3556                 :       3369 :            ]
    3557                 :       3369 :            (symbol_ref "true")))
    3558                 :       3369 :    (set (attr "enabled")
    3559                 :      11980 :      (cond [(eq_attr "alternative" "16,17")
    3560                 :       8611 :               (if_then_else
    3561                 :   14909000 :                 (match_test "TARGET_HARD_SF_REGS")
    3562                 :       3369 :                 (symbol_ref "false")
    3563                 :       3369 :                 (const_string "*"))
    3564                 :       3369 :             (not (match_test "TARGET_HARD_SF_REGS"))
    3565                 :       8611 :               (symbol_ref "false")
    3566                 :       3369 :            ]
    3567                 :       3369 :            (const_string "*")))])
    3568                 :       3369 : 
    3569                 :       3369 : (define_split
    3570                 :       3369 :   [(set (match_operand 0 "any_fp_register_operand")
    3571                 :       3369 :         (match_operand 1 "memory_operand"))]
    3572                 :       3369 :   "reload_completed
    3573                 :    2526259 :    && (GET_MODE (operands[0]) == TFmode
    3574                 :       3369 :        || GET_MODE (operands[0]) == XFmode
    3575                 :       3369 :        || GET_MODE (operands[0]) == DFmode
    3576                 :    2559119 :        || GET_MODE (operands[0]) == SFmode)
    3577                 :    1438629 :    && ix86_standard_x87sse_constant_load_p (insn, operands[0])"
    3578                 :      75774 :   [(set (match_dup 0) (match_dup 2))]
    3579                 :   79728374 :   "operands[2] = find_constant_src (curr_insn);")
    3580                 :      31110 : 
    3581                 :   79655969 : (define_split
    3582                 :      75774 :   [(set (match_operand 0 "any_fp_register_operand")
    3583                 :      75774 :         (float_extend (match_operand 1 "memory_operand")))]
    3584                 :      75774 :   "reload_completed
    3585                 :     108871 :    && (GET_MODE (operands[0]) == TFmode
    3586                 :      75774 :        || GET_MODE (operands[0]) == XFmode
    3587                 :     109002 :        || GET_MODE (operands[0]) == DFmode)
    3588                 :     108865 :    && ix86_standard_x87sse_constant_load_p (insn, operands[0])"
    3589                 :       6630 :   [(set (match_dup 0) (match_dup 2))]
    3590                 :      79035 :   "operands[2] = find_constant_src (curr_insn);")
    3591                 :      75774 : 
    3592                 :     145390 : ;; Split the load of -0.0 or -1.0 into fldz;fchs or fld1;fchs sequence
    3593                 :      76246 : (define_split
    3594                 :      76246 :   [(set (match_operand:X87MODEF 0 "fp_register_operand")
    3595                 :       6630 :         (match_operand:X87MODEF 1 "immediate_operand"))]
    3596                 :       6630 :   "reload_completed
    3597                 :      97703 :    && (standard_80387_constant_p (operands[1]) == 8
    3598                 :     106209 :        || standard_80387_constant_p (operands[1]) == 9)"
    3599                 :   79644430 :   [(set (match_dup 0)(match_dup 1))
    3600                 :  159326630 :    (set (match_dup 0)
    3601                 :     558814 :         (neg:X87MODEF (match_dup 0)))]
    3602                 :  159585630 : {
    3603                 :     165795 :   if (real_isnegzero (CONST_DOUBLE_REAL_VALUE (operands[1])))
    3604                 :     115996 :     operands[1] = CONST0_RTX (<MODE>mode);
    3605                 :      23300 :   else
    3606                 :      89444 :     operands[1] = CONST1_RTX (<MODE>mode);
    3607                 :      72985 : })
    3608                 :      72985 : 
    3609                 :      73049 : (define_insn "*swapxf"
    3610                 :      18399 :   [(set (match_operand:XF 0 "register_operand" "+f")
    3611                 :      38627 :         (match_operand:XF 1 "register_operand" "+f"))
    3612                 :      38627 :    (set (match_dup 1)
    3613                 :      18463 :         (match_dup 0))]
    3614                 :      53749 :   "TARGET_80387"
    3615                 :      38655 : {
    3616                 :      53749 :   if (STACK_TOP_P (operands[0]))
    3617                 :       3369 :     return "fxch\t%1";
    3618                 :       3369 :   else
    3619                 :      53685 :     return "fxch\t%0";
    3620                 :      18399 : }
    3621                 :      18399 :   [(set_attr "type" "fxch")
    3622                 :       5198 :    (set_attr "mode" "XF")])
    3623                 :       5198 : 
    3624                 :      76811 : 
    3625                 :       3378 : ;; Zero extension instructions
    3626                 :     133210 : 
    3627                 :      20155 : (define_expand "zero_extendsidi2"
    3628                 :       3378 :   [(set (match_operand:DI 0 "nonimmediate_operand")
    3629                 :     131381 :         (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand")))])
    3630                 :      18344 : 
    3631                 :      18335 : (define_insn "*zero_extendsidi2"
    3632                 :      18344 :   [(set (match_operand:DI 0 "nonimmediate_operand"
    3633                 :       3378 :                 "=r,?r,?o,r   ,o,?*y,?!*y,$r,$v,$x,*x,*v,*r,*k")
    3634                 :      18344 :         (zero_extend:DI
    3635                 :       3369 :          (match_operand:SI 1 "x86_64_zext_operand"
    3636                 :       3378 :                 "0 ,rm,r ,rmWz,0,r  ,m   ,v ,r ,m ,*x,*v,*k,*km")))]
    3637                 :       3378 :   ""
    3638                 :      76663 : {
    3639                 :      76663 :   switch (get_attr_type (insn))
    3640                 :       3369 :     {
    3641                 :      75418 :     case TYPE_IMOVX:
    3642                 :      75418 :       if (ix86_use_lea_for_mov (insn, operands))
    3643                 :       3369 :         return "lea{l}\t{%E1, %k0|%k0, %E1}";
    3644                 :       3369 :       else
    3645                 :      75408 :         return "mov{l}\t{%1, %k0|%k0, %1}";
    3646                 :       3369 : 
    3647                 :       3369 :     case TYPE_MULTI:
    3648                 :       3369 :       return "#";
    3649                 :       3369 : 
    3650                 :       3369 :     case TYPE_MMXMOV:
    3651                 :       3369 :       return "movd\t{%1, %0|%0, %1}";
    3652                 :       3369 : 
    3653                 :       4601 :     case TYPE_SSEMOV:
    3654                 :       4601 :       if (SSE_REG_P (operands[0]) && SSE_REG_P (operands[1]))
    3655                 :       3369 :         {
    3656                 :       3370 :           if (EXT_REX_SSE_REG_P (operands[0])
    3657                 :       3370 :               || EXT_REX_SSE_REG_P (operands[1]))
    3658                 :       3369 :             return "vpmovzxdq\t{%t1, %g0|%g0, %t1}";
    3659                 :       3369 :           else
    3660                 :       3369 :             return "%vpmovzxdq\t{%1, %0|%0, %1}";
    3661                 :       3369 :         }
    3662                 :       3369 : 
    3663                 :       4600 :       if (GENERAL_REG_P (operands[0]))
    3664                 :       3964 :         return "%vmovd\t{%1, %k0|%k0, %1}";
    3665                 :       3369 : 
    3666                 :       3369 :       return "%vmovd\t{%1, %0|%0, %1}";
    3667                 :       3369 : 
    3668                 :       3373 :     case TYPE_MSKMOV:
    3669                 :       3373 :       return "kmovd\t{%1, %k0|%k0, %1}";
    3670                 :       3369 : 
    3671                 :       3369 :     default:
    3672                 :       3369 :       gcc_unreachable ();
    3673                 :       3369 :     }
    3674                 :       3369 : }
    3675                 :       3369 :   [(set (attr "isa")
    3676                 :       3369 :      (cond [(eq_attr "alternative" "0,1,2")
    3677                 :       3369 :               (const_string "nox64")
    3678                 :       3369 :             (eq_attr "alternative" "3")
    3679                 :       3369 :               (const_string "x64")
    3680                 :       3369 :             (eq_attr "alternative" "7,8,9")
    3681                 :       3369 :               (const_string "sse2")
    3682                 :       3369 :             (eq_attr "alternative" "10")
    3683                 :       3369 :               (const_string "sse4")
    3684                 :       3369 :             (eq_attr "alternative" "11")
    3685                 :       3369 :               (const_string "avx512f")
    3686                 :       3369 :             (eq_attr "alternative" "12")
    3687                 :       3369 :               (const_string "x64_avx512bw")
    3688                 :       3369 :             (eq_attr "alternative" "13")
    3689                 :       3369 :               (const_string "avx512bw")
    3690                 :       3369 :            ]
    3691                 :       3369 :            (const_string "*")))
    3692                 :       3369 :    (set (attr "mmx_isa")
    3693                 :       3369 :      (if_then_else (eq_attr "alternative" "5,6")
    3694                 :       3369 :                    (const_string "native")
    3695                 :       3369 :                    (const_string "*")))
    3696                 :       3369 :    (set (attr "type")
    3697                 :       3369 :      (cond [(eq_attr "alternative" "0,1,2,4")
    3698                 :       3369 :               (const_string "multi")
    3699                 :       3369 :             (eq_attr "alternative" "5,6")
    3700                 :       3369 :               (const_string "mmxmov")
    3701                 :       3369 :             (eq_attr "alternative" "7")
    3702                 :       3369 :               (if_then_else (match_test "TARGET_64BIT")
    3703                 :       3369 :                 (const_string "ssemov")
    3704                 :       3369 :                 (const_string "multi"))
    3705                 :       3369 :             (eq_attr "alternative" "8,9,10,11")
    3706                 :       3369 :               (const_string "ssemov")
    3707                 :       3369 :             (eq_attr "alternative" "12,13")
    3708                 :       3369 :               (const_string "mskmov")
    3709                 :       3369 :            ]
    3710                 :       3369 :            (const_string "imovx")))
    3711                 :       3369 :    (set (attr "prefix_extra")
    3712                 :       3369 :      (if_then_else (eq_attr "alternative" "10,11")
    3713                 :      23844 :        (const_string "1")
    3714                 :       3369 :        (const_string "*")))
    3715                 :       3369 :    (set (attr "prefix")
    3716                 :       3369 :      (if_then_else (eq_attr "type" "ssemov")
    3717                 :       3369 :        (const_string "maybe_vex")
    3718                 :       3369 :        (const_string "orig")))
    3719                 :       3369 :    (set (attr "prefix_0f")
    3720                 :       3369 :      (if_then_else (eq_attr "type" "imovx")
    3721                 :       3369 :        (const_string "0")
    3722                 :       3369 :        (const_string "*")))
    3723                 :       3369 :    (set (attr "mode")
    3724                 :       3369 :      (cond [(eq_attr "alternative" "5,6")
    3725                 :       3369 :               (const_string "DI")
    3726                 :       3369 :             (and (eq_attr "alternative" "7")
    3727                 :       3369 :                  (match_test "TARGET_64BIT"))
    3728                 :       3369 :               (const_string "TI")
    3729                 :       3369 :             (eq_attr "alternative" "8,10,11")
    3730                 :       3369 :               (const_string "TI")
    3731                 :       3369 :            ]
    3732                 :       3369 :            (const_string "SI")))
    3733                 :       3369 :    (set (attr "preferred_for_speed")
    3734                 :       3369 :      (cond [(eq_attr "alternative" "7")
    3735                 :       3369 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
    3736                 :       3369 :             (eq_attr "alternative" "5,8")
    3737                 :       3369 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_TO_VEC")
    3738                 :       3369 :            ]
    3739                 :       3369 :            (symbol_ref "true")))])
    3740                 :       3369 : 
    3741                 :       3369 : (define_split
    3742                 :       3369 :   [(set (match_operand:DI 0 "memory_operand")
    3743                 :       3369 :         (zero_extend:DI (match_operand:SI 1 "memory_operand")))]
    3744                 :       3602 :   "reload_completed"
    3745                 :       3369 :   [(set (match_dup 4) (const_int 0))]
    3746                 :       3369 :   "split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);")
    3747                 :       3369 : 
    3748                 :     227424 : (define_split
    3749                 :     227424 :   [(set (match_operand:DI 0 "general_reg_operand")
    3750                 :     110479 :         (zero_extend:DI (match_operand:SI 1 "general_reg_operand")))]
    3751                 :     333086 :   "!TARGET_64BIT && reload_completed
    3752                 :       6680 :    && REGNO (operands[0]) == REGNO (operands[1])"
    3753                 :       5374 :   [(set (match_dup 4) (const_int 0))]
    3754                 :       5374 :   "split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);")
    3755                 :       3369 : 
    3756                 :       3369 : (define_split
    3757                 :       5374 :   [(set (match_operand:DI 0 "nonimmediate_gr_operand")
    3758                 :       5374 :         (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand")))]
    3759                 :     369455 :   "!TARGET_64BIT && reload_completed
    3760                 :     225697 :    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
    3761                 :     495681 :   [(set (match_dup 3) (match_dup 1))
    3762                 :       3369 :    (set (match_dup 4) (const_int 0))]
    3763                 :       6803 :   "split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);")
    3764                 :       5374 : 
    3765                 :      54630 : (define_mode_attr kmov_isa
    3766                 :      58064 :   [(QI "avx512dq") (HI "avx512f") (SI "avx512bw") (DI "avx512bw")])
    3767                 :       5374 : 
    3768                 :      20046 : (define_insn "zero_extend<mode>di2"
    3769                 :      18617 :   [(set (match_operand:DI 0 "register_operand" "=r,*r,*k")
    3770                 :      18617 :         (zero_extend:DI
    3771                 :      10813 :          (match_operand:SWI12 1 "nonimmediate_operand" "<r>m,*k,*km")))]
    3772                 :     130473 :   "TARGET_64BIT"
    3773                 :      11824 :   "@
    3774                 :      14317 :    movz{<imodesuffix>l|x}\t{%1, %k0|%k0, %1}
    3775                 :       8808 :    kmov<mskmodesuffix>\t{%1, %k0|%k0, %1}
    3776                 :      35844 :    kmov<mskmodesuffix>\t{%1, %k0|%k0, %1}"
    3777                 :      28907 :   [(set_attr "isa" "*,<kmov_isa>,<kmov_isa>")
    3778                 :      30336 :    (set_attr "type" "imovx,mskmov,mskmov")
    3779                 :       5374 :    (set_attr "mode" "SI,<MODE>,<MODE>")])
    3780                 :     493017 : 
    3781                 :     493017 : (define_expand "zero_extend<mode>si2"
    3782                 :      10237 :   [(set (match_operand:SI 0 "register_operand")
    3783                 :     378767 :         (zero_extend:SI (match_operand:SWI12 1 "nonimmediate_operand")))]
    3784                 :     378767 :   ""
    3785                 :       6803 : {
    3786                 :     362125 :   if (TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun))
    3787                 :     365559 :     {
    3788                 :       3369 :       operands[1] = force_reg (<MODE>mode, operands[1]);
    3789                 :       3369 :       emit_insn (gen_zero_extend<mode>si2_and (operands[0], operands[1]));
    3790                 :       3369 :       DONE;
    3791                 :     157197 :     }
    3792                 :     157197 : })
    3793                 :     157197 : 
    3794                 :     157197 : (define_insn_and_split "zero_extend<mode>si2_and"
    3795                 :     157197 :   [(set (match_operand:SI 0 "register_operand" "=r,?&<r>")
    3796                 :     198582 :         (zero_extend:SI
    3797                 :     198582 :           (match_operand:SWI12 1 "nonimmediate_operand" "0,<r>m")))
    3798                 :     198582 :    (clobber (reg:CC FLAGS_REG))]
    3799                 :     142486 :   "TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun)"
    3800                 :     198682 :   "#"
    3801                 :       3369 :   "&& reload_completed"
    3802                 :       3369 :   [(parallel [(set (match_dup 0) (and:SI (match_dup 0) (match_dup 2)))
    3803                 :     198582 :               (clobber (reg:CC FLAGS_REG))])]
    3804                 :     198630 : {
    3805                 :     198582 :   if (!REG_P (operands[1])
    3806                 :       3369 :       || REGNO (operands[0]) != REGNO (operands[1]))
    3807                 :       3369 :     {
    3808                 :       3369 :       ix86_expand_clear (operands[0]);
    3809                 :       3369 : 
    3810                 :       3369 :       gcc_assert (!TARGET_PARTIAL_REG_STALL);
    3811                 :       3369 :       emit_insn (gen_rtx_SET
    3812                 :       3369 :                  (gen_rtx_STRICT_LOW_PART
    3813                 :      44754 :                   (VOIDmode, gen_lowpart (<MODE>mode, operands[0])),
    3814                 :      44754 :                   operands[1]));
    3815                 :       3369 :       DONE;
    3816                 :      44754 :     }
    3817                 :       3369 : 
    3818                 :      44754 :   operands[2] = GEN_INT (GET_MODE_MASK (<MODE>mode));
    3819                 :       3369 : }
    3820                 :       3369 :   [(set_attr "type" "alu1")
    3821                 :       3369 :    (set_attr "mode" "SI")])
    3822                 :       3369 : 
    3823                 :       3369 : (define_insn "*zero_extend<mode>si2"
    3824                 :       3369 :   [(set (match_operand:SI 0 "register_operand" "=r,*r,*k")
    3825                 :       3369 :         (zero_extend:SI
    3826                 :       3369 :           (match_operand:SWI12 1 "nonimmediate_operand" "<r>m,*k,*km")))]
    3827                 :     474191 :   "!(TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun))"
    3828                 :       3369 :   "@
    3829                 :       3369 :    movz{<imodesuffix>l|x}\t{%1, %0|%0, %1}
    3830                 :       3369 :    kmov<mskmodesuffix>\t{%1, %0|%0, %1}
    3831                 :     117619 :    kmov<mskmodesuffix>\t{%1, %0|%0, %1}"
    3832                 :     117619 :   [(set_attr "isa" "*,<kmov_isa>,<kmov_isa>")
    3833                 :       3369 :    (set_attr "type" "imovx,mskmov,mskmov")
    3834                 :     115435 :    (set_attr "mode" "SI,<MODE>,<MODE>")])
    3835                 :     115435 : 
    3836                 :      29767 : (define_expand "zero_extendqihi2"
    3837                 :      29767 :   [(set (match_operand:HI 0 "register_operand")
    3838                 :       3369 :         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand")))]
    3839                 :       3369 :   ""
    3840                 :      12792 : {
    3841                 :       3369 :   if (TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun))
    3842                 :      12792 :     {
    3843                 :       3369 :       operands[1] = force_reg (QImode, operands[1]);
    3844                 :       3369 :       emit_insn (gen_zero_extendqihi2_and (operands[0], operands[1]));
    3845                 :       3369 :       DONE;
    3846                 :      12792 :     }
    3847                 :      12792 : })
    3848                 :      12792 : 
    3849                 :       3369 : (define_insn_and_split "zero_extendqihi2_and"
    3850                 :      12792 :   [(set (match_operand:HI 0 "register_operand" "=r,?&q")
    3851                 :       3369 :         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "0,qm")))
    3852                 :      12792 :    (clobber (reg:CC FLAGS_REG))]
    3853                 :      28497 :   "TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun)"
    3854                 :       3866 :   "#"
    3855                 :      12792 :   "&& reload_completed"
    3856                 :       3369 :   [(parallel [(set (match_dup 0) (and:SI (match_dup 0) (const_int 255)))
    3857                 :       3369 :               (clobber (reg:CC FLAGS_REG))])]
    3858                 :      12792 : {
    3859                 :      12792 :   if (!REG_P (operands[1])
    3860                 :      12792 :       || REGNO (operands[0]) != REGNO (operands[1]))
    3861                 :      39013 :     {
    3862                 :      39013 :       ix86_expand_clear (operands[0]);
    3863                 :      11288 : 
    3864                 :      18691 :       gcc_assert (!TARGET_PARTIAL_REG_STALL);
    3865                 :      18687 :       emit_insn (gen_rtx_SET
    3866                 :      19203 :                  (gen_rtx_STRICT_LOW_PART
    3867                 :       3373 :                   (VOIDmode, gen_lowpart (QImode, operands[0])),
    3868                 :      16404 :                   operands[1]));
    3869                 :      11284 :       DONE;
    3870                 :       8489 :     }
    3871                 :       8489 : 
    3872                 :       9762 :   operands[0] = gen_lowpart (SImode, operands[0]);
    3873                 :      14876 : }
    3874                 :       9762 :   [(set_attr "type" "alu1")
    3875                 :       8483 :    (set_attr "mode" "SI")])
    3876                 :      12966 : 
    3877                 :       9762 : ; zero extend to SImode to avoid partial register stalls
    3878                 :       9762 : (define_insn "*zero_extendqihi2"
    3879                 :       3369 :   [(set (match_operand:HI 0 "register_operand" "=r,*r,*k")
    3880                 :       7611 :         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "qm,*k,*km")))]
    3881                 :      29767 :   "!(TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun))"
    3882                 :       3369 :   "@
    3883                 :       3369 :    movz{bl|x}\t{%1, %k0|%k0, %1}
    3884                 :       3369 :    kmovb\t{%1, %k0|%k0, %1}
    3885                 :       3369 :    kmovb\t{%1, %0|%0, %1}"
    3886                 :       3369 :   [(set_attr "isa" "*,avx512dq,avx512dq")
    3887                 :       3369 :    (set_attr "type" "imovx,mskmov,mskmov")
    3888                 :       3369 :    (set_attr "mode" "SI,QI,QI")])
    3889                 :       3450 : 
    3890                 :       3450 : ;; Sign extension instructions
    3891                 :       3421 : 
    3892                 :     325824 : (define_expand "extendsidi2"
    3893                 :       3398 :   [(set (match_operand:DI 0 "register_operand")
    3894                 :       3421 :         (sign_extend:DI (match_operand:SI 1 "register_operand")))]
    3895                 :     325743 :   ""
    3896                 :     325743 : {
    3897                 :     325691 :   if (!TARGET_64BIT)
    3898                 :     325727 :     {
    3899                 :       7220 :       emit_insn (gen_extendsidi2_1 (operands[0], operands[1]));
    3900                 :     329542 :       DONE;
    3901                 :       3369 :     }
    3902                 :       3369 : })
    3903                 :       3369 : 
    3904                 :       3369 : (define_insn "*extendsidi2_rex64"
    3905                 :     321876 :   [(set (match_operand:DI 0 "register_operand" "=*a,r")
    3906                 :     321876 :         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "*0,rm")))]
    3907                 :     933876 :   "TARGET_64BIT"
    3908                 :     321876 :   "@
    3909                 :       3369 :    {cltq|cdqe}
    3910                 :     321876 :    movs{lq|x}\t{%1, %0|%0, %1}"
    3911                 :      54332 :   [(set_attr "type" "imovx")
    3912                 :      54332 :    (set_attr "mode" "DI")
    3913                 :     372839 :    (set_attr "prefix_0f" "0")
    3914                 :     321876 :    (set_attr "modrm" "0,1")])
    3915                 :     321876 : 
    3916                 :       3369 : (define_insn "extendsidi2_1"
    3917                 :       3369 :   [(set (match_operand:DI 0 "nonimmediate_operand" "=*A,r,?r,?*o")
    3918                 :       3369 :         (sign_extend:DI (match_operand:SI 1 "register_operand" "0,0,r,r")))
    3919                 :       3369 :    (clobber (reg:CC FLAGS_REG))
    3920                 :       3369 :    (clobber (match_scratch:SI 2 "=X,X,X,&r"))]
    3921                 :       9876 :   "!TARGET_64BIT"
    3922                 :      22569 :   "#")
    3923                 :      10667 : 
    3924                 :      10667 : ;; Split the memory case.  If the source register doesn't die, it will stay
    3925                 :      13573 : ;; this way, if it does die, following peephole2s take care of it.
    3926                 :     247513 : (define_split
    3927                 :     246549 :   [(set (match_operand:DI 0 "memory_operand")
    3928                 :       3369 :         (sign_extend:DI (match_operand:SI 1 "register_operand")))
    3929                 :      82080 :    (clobber (reg:CC FLAGS_REG))
    3930                 :      82080 :    (clobber (match_operand:SI 2 "register_operand"))]
    3931                 :       4900 :   "reload_completed"
    3932                 :       4333 :   [(const_int 0)]
    3933                 :      10817 : {
    3934                 :      10817 :   split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);
    3935                 :     179974 : 
    3936                 :      20484 :   emit_move_insn (operands[3], operands[1]);
    3937                 :       3369 : 
    3938                 :      13372 :   /* Generate a cltd if possible and doing so it profitable.  */
    3939                 :       5297 :   if ((optimize_function_for_size_p (cfun) || TARGET_USE_CLTD)
    3940                 :       4333 :       && REGNO (operands[1]) == AX_REG
    3941                 :       4747 :       && REGNO (operands[2]) == DX_REG)
    3942                 :       3369 :     {
    3943                 :       3466 :       emit_insn (gen_ashrsi3_cvt (operands[2], operands[1], GEN_INT (31)));
    3944                 :       3369 :     }
    3945                 :       3369 :   else
    3946                 :      19738 :     {
    3947                 :      20605 :       emit_move_insn (operands[2], operands[1]);
    3948                 :       4236 :       emit_insn (gen_ashrsi3_cvt (operands[2], operands[2], GEN_INT (31)));
    3949                 :       3369 :     }
    3950                 :       4363 :   emit_move_insn (operands[4], operands[2]);
    3951                 :       4363 :   DONE;
    3952                 :       3369 : })
    3953                 :       3399 : 
    3954                 :       3399 : ;; Peepholes for the case where the source register does die, after
    3955                 :       3399 : ;; being split with the above splitter.
    3956                 :       3399 : (define_peephole2
    3957                 :       3429 :   [(set (match_operand:SI 0 "memory_operand")
    3958                 :       3369 :         (match_operand:SI 1 "general_reg_operand"))
    3959                 :       3399 :    (set (match_operand:SI 2 "general_reg_operand") (match_dup 1))
    3960                 :       3399 :    (parallel [(set (match_dup 2)
    3961                 :       3399 :                    (ashiftrt:SI (match_dup 2) (const_int 31)))
    3962                 :       3399 :                (clobber (reg:CC FLAGS_REG))])
    3963                 :       3369 :    (set (match_operand:SI 3 "memory_operand") (match_dup 2))]
    3964                 :       4895 :   "REGNO (operands[1]) != REGNO (operands[2])
    3965                 :       4209 :    && peep2_reg_dead_p (2, operands[1])
    3966                 :       4741 :    && peep2_reg_dead_p (4, operands[2])
    3967                 :       4741 :    && !reg_mentioned_p (operands[2], operands[3])"
    3968                 :       4209 :   [(set (match_dup 0) (match_dup 1))
    3969                 :       4741 :    (parallel [(set (match_dup 1) (ashiftrt:SI (match_dup 1) (const_int 31)))
    3970                 :       4741 :               (clobber (reg:CC FLAGS_REG))])
    3971                 :       4055 :    (set (match_dup 3) (match_dup 1))])
    3972                 :     148163 : 
    3973                 :     148849 : (define_peephole2
    3974                 :       4055 :   [(set (match_operand:SI 0 "memory_operand")
    3975                 :     148279 :         (match_operand:SI 1 "general_reg_operand"))
    3976                 :     148279 :    (parallel [(set (match_operand:SI 2 "general_reg_operand")
    3977                 :       4055 :                    (ashiftrt:SI (match_dup 1) (const_int 31)))
    3978                 :     147777 :                (clobber (reg:CC FLAGS_REG))])
    3979                 :     147777 :    (set (match_operand:SI 3 "memory_operand") (match_dup 2))]
    3980                 :     147777 :   "/* cltd is shorter than sarl $31, %eax */
    3981                 :       4926 :    !optimize_function_for_size_p (cfun)
    3982                 :       4926 :    && REGNO (operands[1]) == AX_REG
    3983                 :       5170 :    && REGNO (operands[2]) == DX_REG
    3984                 :       4152 :    && peep2_reg_dead_p (2, operands[1])
    3985                 :       3457 :    && peep2_reg_dead_p (3, operands[2])
    3986                 :       4749 :    && !reg_mentioned_p (operands[2], operands[3])"
    3987                 :       4152 :   [(set (match_dup 0) (match_dup 1))
    3988                 :       4749 :    (parallel [(set (match_dup 1) (ashiftrt:SI (match_dup 1) (const_int 31)))
    3989                 :       3457 :               (clobber (reg:CC FLAGS_REG))])
    3990                 :       4661 :    (set (match_dup 3) (match_dup 1))])
    3991                 :       6639 : 
    3992                 :       3369 : ;; Extend to register case.  Optimize case where source and destination
    3993                 :       5347 : ;; registers match and cases where we can use cltd.
    3994                 :       5347 : (define_split
    3995                 :       5347 :   [(set (match_operand:DI 0 "register_operand")
    3996                 :      97842 :         (sign_extend:DI (match_operand:SI 1 "register_operand")))
    3997                 :      97842 :    (clobber (reg:CC FLAGS_REG))
    3998                 :      13015 :    (clobber (match_scratch:SI 2))]
    3999                 :      89488 :   "reload_completed"
    4000                 :      94109 :   [(const_int 0)]
    4001                 :       9877 : {
    4002                 :      86738 :   split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);
    4003                 :      84065 : 
    4004                 :       6284 :   if (REGNO (operands[3]) != REGNO (operands[1]))
    4005                 :       5279 :     emit_move_insn (operands[3], operands[1]);
    4006                 :       3607 : 
    4007                 :       3717 :   /* Generate a cltd if possible and doing so it profitable.  */
    4008                 :       9850 :   if ((optimize_function_for_size_p (cfun) || TARGET_USE_CLTD)
    4009                 :       7960 :       && REGNO (operands[3]) == AX_REG
    4010                 :       8289 :       && REGNO (operands[4]) == DX_REG)
    4011                 :       3457 :     {
    4012                 :       5290 :       emit_insn (gen_ashrsi3_cvt (operands[4], operands[3], GEN_INT (31)));
    4013                 :       5290 :       DONE;
    4014                 :       3457 :     }
    4015                 :       3457 : 
    4016                 :       4209 :   if (REGNO (operands[4]) != REGNO (operands[1]))
    4017                 :       4181 :     emit_move_insn (operands[4], operands[1]);
    4018                 :       3457 : 
    4019                 :       4297 :   emit_insn (gen_ashrsi3_cvt (operands[4], operands[4], GEN_INT (31)));
    4020                 :       4209 :   DONE;
    4021                 :       3457 : })
    4022                 :       3369 : 
    4023                 :       3369 : (define_insn "extend<mode>di2"
    4024                 :       3369 :   [(set (match_operand:DI 0 "register_operand" "=r")
    4025                 :       3369 :         (sign_extend:DI
    4026                 :       3369 :          (match_operand:SWI12 1 "nonimmediate_operand" "<r>m")))]
    4027                 :      54186 :   "TARGET_64BIT"
    4028                 :       3457 :   "movs{<imodesuffix>q|x}\t{%1, %0|%0, %1}"
    4029                 :       3369 :   [(set_attr "type" "imovx")
    4030                 :       3457 :    (set_attr "mode" "DI")])
    4031                 :      12318 : 
    4032                 :      12318 : (define_insn "extendhisi2"
    4033                 :      12230 :   [(set (match_operand:SI 0 "register_operand" "=*a,r")
    4034                 :       3369 :         (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "*0,rm")))]
    4035                 :      28903 :   ""
    4036                 :      49377 : {
    4037                 :      48072 :   switch (get_attr_prefix_0f (insn))
    4038                 :      40808 :     {
    4039                 :       3369 :     case 0:
    4040                 :       3369 :       return "{cwtl|cwde}";
    4041                 :      23964 :     default:
    4042                 :      21203 :       return "movs{wl|x}\t{%1, %0|%0, %1}";
    4043                 :       6130 :     }
    4044                 :       3369 : }
    4045                 :       3369 :   [(set_attr "type" "imovx")
    4046                 :       3369 :    (set_attr "mode" "SI")
    4047                 :       3369 :    (set (attr "prefix_0f")
    4048                 :       3385 :      ;; movsx is short decodable while cwtl is vector decoded.
    4049                 :       3369 :      (if_then_else (and (eq_attr "cpu" "!k6")
    4050                 :       3369 :                         (eq_attr "alternative" "0"))
    4051                 :       3369 :         (const_string "0")
    4052                 :       3369 :         (const_string "1")))
    4053                 :       3369 :    (set (attr "znver1_decode")
    4054                 :       3369 :      (if_then_else (eq_attr "prefix_0f" "0")
    4055                 :       3369 :         (const_string "double")
    4056                 :       3369 :         (const_string "direct")))
    4057                 :       3369 :    (set (attr "modrm")
    4058                 :       3369 :      (if_then_else (eq_attr "prefix_0f" "0")
    4059                 :       3369 :         (const_string "0")
    4060                 :       3369 :         (const_string "1")))])
    4061                 :       3369 : 
    4062                 :       3369 : (define_insn "*extendhisi2_zext"
    4063                 :       3369 :   [(set (match_operand:DI 0 "register_operand" "=*a,r")
    4064                 :       3369 :         (zero_extend:DI
    4065                 :       3369 :          (sign_extend:SI
    4066                 :       3369 :           (match_operand:HI 1 "nonimmediate_operand" "*0,rm"))))]
    4067                 :       3404 :   "TARGET_64BIT"
    4068                 :       3386 : {
    4069                 :       3385 :   switch (get_attr_prefix_0f (insn))
    4070                 :       3369 :     {
    4071                 :       3385 :     case 0:
    4072                 :       3385 :       return "{cwtl|cwde}";
    4073                 :       3400 :     default:
    4074                 :       3384 :       return "movs{wl|x}\t{%1, %k0|%k0, %1}";
    4075                 :       3369 :     }
    4076                 :       3369 : }
    4077                 :       3369 :   [(set_attr "type" "imovx")
    4078                 :       3369 :    (set_attr "mode" "SI")
    4079                 :       3369 :    (set (attr "prefix_0f")
    4080                 :       9079 :      ;; movsx is short decodable while cwtl is vector decoded.
    4081                 :       3369 :      (if_then_else (and (eq_attr "cpu" "!k6")
    4082                 :       3369 :                         (eq_attr "alternative" "0"))
    4083                 :       3369 :         (const_string "0")
    4084                 :       3369 :         (const_string "1")))
    4085                 :       3369 :    (set (attr "modrm")
    4086                 :       3369 :      (if_then_else (eq_attr "prefix_0f" "0")
    4087                 :       3369 :         (const_string "0")
    4088                 :       3369 :         (const_string "1")))])
    4089                 :       3369 : 
    4090                 :       3369 : (define_insn "extendqisi2"
    4091                 :       3369 :   [(set (match_operand:SI 0 "register_operand" "=r")
    4092                 :       3369 :         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "qm")))]
    4093                 :       3369 :   ""
    4094                 :       3369 :   "movs{bl|x}\t{%1, %0|%0, %1}"
    4095                 :       3369 :    [(set_attr "type" "imovx")
    4096                 :       3369 :     (set_attr "mode" "SI")])
    4097                 :       3369 : 
    4098                 :       3369 : (define_insn "*extendqisi2_zext"
    4099                 :       3369 :   [(set (match_operand:DI 0 "register_operand" "=r")
    4100                 :       3369 :         (zero_extend:DI
    4101                 :       3369 :           (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "qm"))))]
    4102                 :       3384 :   "TARGET_64BIT"
    4103                 :       3370 :   "movs{bl|x}\t{%1, %k0|%k0, %1}"
    4104                 :       3369 :    [(set_attr "type" "imovx")
    4105                 :       3369 :     (set_attr "mode" "SI")])
    4106                 :       3369 : 
    4107                 :       3369 : (define_insn "extendqihi2"
    4108                 :       3369 :   [(set (match_operand:HI 0 "register_operand" "=*a,r")
    4109                 :       3369 :         (sign_extend:HI (match_operand:QI 1 "nonimmediate_operand" "*0,qm")))]
    4110                 :       3369 :   ""
    4111                 :       9079 : {
    4112                 :       9079 :   switch (get_attr_prefix_0f (insn))
    4113                 :       3369 :     {
    4114                 :       3369 :     case 0:
    4115                 :       3369 :       return "{cbtw|cbw}";
    4116                 :       8552 :     default:
    4117                 :       8552 :       return "movs{bw|x}\t{%1, %0|%0, %1}";
    4118                 :       3369 :     }
    4119                 :       3369 : }
    4120                 :       3369 :   [(set_attr "type" "imovx")
    4121                 :       3369 :    (set_attr "mode" "HI")
    4122                 :       3369 :    (set (attr "prefix_0f")
    4123                 :       9893 :      ;; movsx is short decodable while cwtl is vector decoded.
    4124                 :       3369 :      (if_then_else (and (eq_attr "cpu" "!k6")
    4125                 :       3369 :                         (eq_attr "alternative" "0"))
    4126                 :       3369 :         (const_string "0")
    4127                 :          0 :         (const_string "1")))
    4128                 :       3369 :    (set (attr "modrm")
    4129                 :       3369 :      (if_then_else (eq_attr "prefix_0f" "0")
    4130                 :          0 :         (const_string "0")
    4131                 :       3369 :         (const_string "1")))])
    4132                 :       3369 : 
    4133                 :       3369 : ;; Conversions between float and double.
    4134                 :       3369 : 
    4135                 :       3369 : ;; These are all no-ops in the model used for the 80387.
    4136                 :  595570369 : ;; So just emit moves.
    4137                 :       3369 : 
    4138                 :  595570369 : ;; %%% Kill these when call knows how to work out a DFmode push earlier.
    4139                 :       3369 : (define_split
    4140                 :       3369 :   [(set (match_operand:DF 0 "push_operand")
    4141                 :          0 :         (float_extend:DF (match_operand:SF 1 "fp_register_operand")))]
    4142                 :       3369 :   "reload_completed"
    4143                 :       3369 :   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -8)))
    4144                 :       3369 :    (set (mem:DF (reg:P SP_REG)) (float_extend:DF (match_dup 1)))])
    4145                 :          0 : 
    4146                 :          0 : (define_split
    4147                 :       3369 :   [(set (match_operand:XF 0 "push_operand")
    4148                 :       3369 :         (float_extend:XF (match_operand:MODEF 1 "fp_register_operand")))]
    4149                 :       3369 :   "reload_completed"
    4150                 :       3369 :   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
    4151                 :       3369 :    (set (mem:XF (reg:P SP_REG)) (float_extend:XF (match_dup 1)))]
    4152                 :          0 :   "operands[2] = GEN_INT (-GET_MODE_SIZE (XFmode));")
    4153                 :       3369 : 
    4154                 :       3369 : (define_expand "extendsfdf2"
    4155                 :       3369 :   [(set (match_operand:DF 0 "nonimm_ssenomem_operand")
    4156                 :          0 :         (float_extend:DF (match_operand:SF 1 "general_operand")))]
    4157                 :          0 :   "TARGET_80387 || (TARGET_SSE2 && TARGET_SSE_MATH)"
    4158                 :      18870 : {
    4159                 :       3369 :   /* ??? Needed for compress_float_constant since all fp constants
    4160                 :       3369 :      are TARGET_LEGITIMATE_CONSTANT_P.  */
    4161                 :       3369 :   if (CONST_DOUBLE_P (operands[1]))
    4162                 :       3369 :     {
    4163                 :          1 :       if ((!TARGET_SSE2 || TARGET_MIX_SSE_I387)
    4164                 :       3370 :           && standard_80387_constant_p (operands[1]) > 0)
    4165                 :       3369 :         {
    4166                 :       3369 :           operands[1] = simplify_const_unary_operation
    4167                 :          0 :             (FLOAT_EXTEND, DFmode, operands[1], SFmode);
    4168                 :          0 :           emit_move_insn_1 (operands[0], operands[1]);
    4169                 :       3369 :           DONE;
    4170                 :       3369 :         }
    4171                 :       3370 :       operands[1] = validize_mem (force_const_mem (SFmode, operands[1]));
    4172                 :       3369 :     }
    4173                 :       3369 : })
    4174                 :       3369 : 
    4175                 :       3369 : (define_insn "*extendsfdf2"
    4176                 :      18870 :   [(set (match_operand:DF 0 "nonimm_ssenomem_operand" "=f,m,v,v")
    4177                 :      18870 :         (float_extend:DF
    4178                 :      18870 :           (match_operand:SF 1 "nonimmediate_operand" "fm,f,v,m")))]
    4179                 :      85005 :   "TARGET_80387 || (TARGET_SSE2 && TARGET_SSE_MATH)"
    4180                 :      19860 : {
    4181                 :      25394 :   switch (which_alternative)
    4182                 :      18870 :     {
    4183                 :     261674 :     case 0:
    4184                 :     261674 :     case 1:
    4185                 :      36480 :       return output_387_reg_move (insn, operands);
    4186                 :     245415 : 
    4187                 :      18870 :     case 2:
    4188                 :     168630 :       return "%vcvtss2sd\t{%d1, %0|%0, %d1}";
    4189                 :     168770 :     case 3:
    4190                 :       3509 :       return "%vcvtss2sd\t{%1, %d0|%d0, %1}";
    4191                 :       3369 : 
    4192                 :       3384 :     default:
    4193                 :       3369 :       gcc_unreachable ();
    4194                 :       3384 :     }
    4195                 :       3384 : }
    4196                 :       3384 :   [(set_attr "type" "fmov,fmov,ssecvt,ssecvt")
    4197                 :       3384 :    (set_attr "avx_partial_xmm_update" "false,false,false,true")
    4198                 :       3384 :    (set_attr "prefix" "orig,orig,maybe_vex,maybe_vex")
    4199                 :      22962 :    (set_attr "mode" "SF,XF,DF,DF")
    4200                 :       3369 :    (set (attr "enabled")
    4201                 :       3384 :      (if_then_else
    4202                 :       3369 :        (match_test ("TARGET_SSE2 && TARGET_SSE_MATH"))
    4203                 :       3369 :        (if_then_else
    4204                 :       3369 :          (eq_attr "alternative" "0,1")
    4205                 :       3369 :          (symbol_ref "TARGET_MIX_SSE_I387")
    4206                 :       3369 :          (symbol_ref "true"))
    4207                 :       3369 :        (if_then_else
    4208                 :       3369 :          (eq_attr "alternative" "0,1")
    4209                 :       3369 :          (symbol_ref "true")
    4210                 :       3369 :          (symbol_ref "false"))))])
    4211                 :       3369 : 
    4212                 :       3369 : /* For converting SF(xmm2) to DF(xmm1), use the following code instead of
    4213                 :       3369 :    cvtss2sd:
    4214                 :       3369 :       unpcklps xmm2,xmm2   ; packed conversion might crash on signaling NaNs
    4215                 :       3369 :       cvtps2pd xmm2,xmm1
    4216                 :       3369 :    We do the conversion post reload to avoid producing of 128bit spills
    4217                 :       3369 :    that might lead to ICE on 32bit target.  The sequence unlikely combine
    4218                 :       3369 :    anyway.  */
    4219                 :       3369 : (define_split
    4220                 :       3369 :   [(set (match_operand:DF 0 "sse_reg_operand")
    4221                 :       3369 :         (float_extend:DF
    4222                 :       3369 :           (match_operand:SF 1 "nonimmediate_operand")))]
    4223                 :      23300 :   "TARGET_USE_VECTOR_FP_CONVERTS
    4224                 :       3384 :    && optimize_insn_for_speed_p ()
    4225                 :       3384 :    && reload_completed
    4226                 :      23315 :    && (!EXT_REX_SSE_REG_P (operands[0])
    4227                 :       3369 :        || TARGET_AVX512VL)"
    4228                 :       3384 :    [(set (match_dup 2)
    4229                 :      29322 :          (float_extend:V2DF
    4230                 :       3369 :            (vec_select:V2SF
    4231                 :       3369 :              (match_dup 3)
    4232                 :       3369 :              (parallel [(const_int 0) (const_int 1)]))))]
    4233                 :       3384 : {
    4234                 :       3384 :   operands[2] = lowpart_subreg (V2DFmode, operands[0], DFmode);
    4235                 :       3384 :   operands[3] = lowpart_subreg (V4SFmode, operands[0], DFmode);
    4236                 :       3369 :   /* Use movss for loading from memory, unpcklps reg, reg for registers.
    4237                 :       3369 :      Try to avoid move when unpacking can be done in source.  */
    4238                 :       3384 :   if (REG_P (operands[1]))
    4239                 :       3369 :     {
    4240                 :       3369 :       /* If it is unsafe to overwrite upper half of source, we need
    4241                 :       3369 :          to move to destination and unpack there.  */
    4242                 :       3381 :       if (REGNO (operands[0]) != REGNO (operands[1])
    4243                 :       3381 :           || (EXT_REX_SSE_REG_P (operands[1])
    4244                 :       3369 :               && !TARGET_AVX512VL))
    4245                 :       3369 :         {
    4246                 :       3373 :           rtx tmp = lowpart_subreg (SFmode, operands[0], DFmode);
    4247                 :       3373 :           emit_move_insn (tmp, operands[1]);
    4248                 :       3369 :         }
    4249                 :       3369 :       else
    4250                 :       3377 :         operands[3] = lowpart_subreg (V4SFmode, operands[1], SFmode);
    4251                 :       3369 :       /* FIXME: vec_interleave_lowv4sf for AVX512VL should allow
    4252                 :       3369 :          =v, v, then vbroadcastss will be only needed for AVX512F without
    4253                 :       3369 :          AVX512VL.  */
    4254                 :       3381 :       if (!EXT_REX_SSE_REGNO_P (REGNO (operands[3])))
    4255                 :       3381 :         emit_insn (gen_vec_interleave_lowv4sf (operands[3], operands[3],
    4256                 :       3369 :                                                operands[3]));
    4257                 :       3369 :       else
    4258                 :       3369 :         {
    4259                 :       3369 :           rtx tmp = lowpart_subreg (V16SFmode, operands[3], V4SFmode);
    4260                 :       3369 :           emit_insn (gen_avx512f_vec_dupv16sf_1 (tmp, tmp));
    4261                 :       3369 :         }
    4262                 :       3369 :     }
    4263                 :       3369 :   else
    4264                 :       3372 :     emit_insn (gen_vec_setv4sf_0 (operands[3],
    4265                 :       3369 :                                   CONST0_RTX (V4SFmode), operands[1]));
    4266                 :       3369 : })
    4267                 :       3369 : 
    4268                 :       3369 : ;; It's more profitable to split and then extend in the same register.
    4269                 :       3384 : (define_peephole2
    4270                 :       3384 :   [(set (match_operand:DF 0 "sse_reg_operand")
    4271                 :       3384 :         (float_extend:DF
    4272                 :       3384 :           (match_operand:SF 1 "memory_operand")))]
    4273                 :       7981 :   "TARGET_SPLIT_MEM_OPND_FOR_FP_CONVERTS
    4274                 :       3384 :    && optimize_insn_for_speed_p ()"
    4275                 :       3384 :   [(set (match_dup 2) (match_dup 1))
    4276                 :       3384 :    (set (match_dup 0) (float_extend:DF (match_dup 2)))]
    4277                 :       3384 :   "operands[2] = lowpart_subreg (SFmode, operands[0], DFmode);")
    4278                 :       3369 : 
    4279                 :       3369 : ;; Break partial SSE register dependency stall.  This splitter should split
    4280                 :       3369 : ;; late in the pass sequence (after register rename pass), so allocated
    4281                 :       3369 : ;; registers won't change anymore
    4282                 :       3369 : 
    4283                 :       3369 : (define_split
    4284                 :       3369 :   [(set (match_operand:DF 0 "sse_reg_operand")
    4285                 :      12314 :         (float_extend:DF
    4286                 :      12314 :           (match_operand:SF 1 "nonimmediate_operand")))]
    4287                 :      23300 :   "!TARGET_AVX
    4288                 :      22268 :    && TARGET_SSE_PARTIAL_REG_DEPENDENCY && epilogue_completed
    4289                 :      13145 :    && optimize_function_for_speed_p (cfun)
    4290                 :      15155 :    && (!REG_P (operands[1])
    4291                 :       7923 :        || (!TARGET_AVX && REGNO (operands[0]) != REGNO (operands[1])))
    4292                 :       9406 :    && (!EXT_REX_SSE_REG_P (operands[0])
    4293                 :       3369 :        || TARGET_AVX512VL)"
    4294                 :      19485 :   [(set (match_dup 0)
    4295                 :      11643 :         (vec_merge:V2DF
    4296                 :       3369 :           (vec_duplicate:V2DF
    4297                 :       3369 :             (float_extend:DF
    4298                 :       3369 :               (match_dup 1)))
    4299                 :     197928 :           (match_dup 0)
    4300                 :       3369 :           (const_int 1)))]
    4301                 :     197928 : {
    4302                 :     203965 :   operands[0] = lowpart_subreg (V2DFmode, operands[0], DFmode);
    4303                 :     203965 :   emit_move_insn (operands[0], CONST0_RTX (V2DFmode));
    4304                 :     203965 : })
    4305                 :     197928 : 
    4306                 :     203965 : (define_expand "extend<mode>xf2"
    4307                 :     203965 :   [(set (match_operand:XF 0 "nonimmediate_operand")
    4308                 :     203965 :         (float_extend:XF (match_operand:MODEF 1 "general_operand")))]
    4309                 :     203965 :   "TARGET_80387"
    4310                 :      82506 : {
    4311                 :      51872 :   /* ??? Needed for compress_float_constant since all fp constants
    4312                 :      45835 :      are TARGET_LEGITIMATE_CONSTANT_P.  */
    4313                 :      76469 :   if (CONST_DOUBLE_P (operands[1]))
    4314                 :      45835 :     {
    4315                 :      45897 :       if (standard_80387_constant_p (operands[1]) > 0)
    4316                 :       3369 :         {
    4317                 :      19315 :           operands[1] = simplify_const_unary_operation
    4318                 :       9422 :             (FLOAT_EXTEND, XFmode, operands[1], <MODE>mode);
    4319                 :       9422 :           emit_move_insn_1 (operands[0], operands[1]);
    4320                 :       3385 :           DONE;
    4321                 :       3369 :         }
    4322                 :       3415 :       operands[1] = validize_mem (force_const_mem (<MODE>mode, operands[1]));
    4323                 :       3369 :     }
    4324                 :       3369 : })
    4325                 :      65517 : 
    4326                 :       3369 : (define_insn "*extend<mode>xf2_i387"
    4327                 :      76453 :   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m")
    4328                 :     138601 :         (float_extend:XF
    4329                 :      65517 :           (match_operand:MODEF 1 "nonimmediate_operand" "fm,f")))]
    4330                 :     303862 :   "TARGET_80387"
    4331                 :      85095 :   "* return output_387_reg_move (insn, operands);"
    4332                 :      76453 :   [(set_attr "type" "fmov")
    4333                 :      65517 :    (set_attr "mode" "<MODE>,XF")])
    4334                 :      50288 : 
    4335                 :     128390 : ;; %%% This seems like bad news.
    4336                 :      76453 : ;; This cannot output into an f-reg because there is no way to be sure
    4337                 :      76453 : ;; of truncating in that case.  Otherwise this is just like a simple move
    4338                 :       3369 : ;; insn.  So we pretend we can output to a reg in order to get better
    4339                 :       3369 : ;; register preferencing, but we really use a stack slot.
    4340                 :       3369 : 
    4341                 :       3369 : ;; Conversion from DFmode to SFmode.
    4342                 :      14321 : 
    4343                 :       3372 : (define_insn "truncdfsf2"
    4344                 :       3801 :   [(set (match_operand:SF 0 "nonimm_ssenomem_operand" "=m,f,v,v")
    4345                 :      14324 :         (float_truncate:SF
    4346                 :      14321 :           (match_operand:DF 1 "register_ssemem_operand" "f,f,v,m")))]
    4347                 :      22015 :   "TARGET_80387 || (TARGET_SSE2 && TARGET_SSE_MATH)"
    4348                 :      17444 : {
    4349                 :      28290 :   switch (which_alternative)
    4350                 :      25194 :     {
    4351                 :      14791 :     case 0:
    4352                 :       3942 :     case 1:
    4353                 :       3945 :       return output_387_reg_move (insn, operands);
    4354                 :       3801 : 
    4355                 :       3801 :     case 2:
    4356                 :       3801 :       return "%vcvtsd2ss\t{%d1, %0|%0, %d1}";
    4357                 :       3386 :     case 3:
    4358                 :       3490 :       return "%vcvtsd2ss\t{%1, %d0|%d0, %1}";
    4359                 :       3473 : 
    4360                 :       3369 :     default:
    4361                 :       3430 :       gcc_unreachable ();
    4362                 :       3369 :     }
    4363                 :       3377 : }
    4364                 :       3385 :   [(set_attr "type" "fmov,fmov,ssecvt,ssecvt")
    4365                 :       3369 :    (set_attr "avx_partial_xmm_update" "false,false,false,true")
    4366                 :       3369 :    (set_attr "mode" "SF")
    4367                 :       3710 :    (set (attr "enabled")
    4368                 :       3369 :      (if_then_else
    4369                 :      35576 :        (match_test ("TARGET_SSE2 && TARGET_SSE_MATH"))
    4370                 :       3369 :        (cond [(eq_attr "alternative" "0")
    4371                 :      25476 :                 (symbol_ref "TARGET_MIX_SSE_I387")
    4372                 :       3369 :               (eq_attr "alternative" "1")
    4373                 :      16107 :                 (symbol_ref "TARGET_MIX_SSE_I387
    4374                 :       1760 :                              && flag_unsafe_math_optimizations")
    4375                 :       3369 :            ]
    4376                 :       3369 :            (symbol_ref "true"))
    4377                 :       3369 :        (cond [(eq_attr "alternative" "0")
    4378                 :       3369 :                 (symbol_ref "true")
    4379                 :       3369 :               (eq_attr "alternative" "1")
    4380                 :       3369 :                 (symbol_ref "flag_unsafe_math_optimizations")
    4381                 :       3369 :            ]
    4382                 :       3369 :            (symbol_ref "false"))))])
    4383                 :       3369 : 
    4384                 :       1312 : /* For converting DF(xmm2) to SF(xmm1), use the following code instead of
    4385                 :       3369 :    cvtsd2ss:
    4386                 :       3369 :       unpcklpd xmm2,xmm2   ; packed conversion might crash on signaling NaNs
    4387                 :       3369 :       cvtpd2ps xmm2,xmm1
    4388                 :       3369 :    We do the conversion post reload to avoid producing of 128bit spills
    4389                 :        984 :    that might lead to ICE on 32bit target.  The sequence unlikely combine
    4390                 :       3369 :    anyway.  */
    4391                 :       3697 : (define_split
    4392                 :       3369 :   [(set (match_operand:SF 0 "sse_reg_operand")
    4393                 :       3369 :         (float_truncate:SF
    4394                 :       3369 :           (match_operand:DF 1 "nonimmediate_operand")))]
    4395                 :       8877 :   "TARGET_USE_VECTOR_FP_CONVERTS
    4396                 :       3376 :    && optimize_insn_for_speed_p ()
    4397                 :       3376 :    && reload_completed
    4398                 :       8882 :    && (!EXT_REX_SSE_REG_P (operands[0])
    4399                 :       3372 :        || TARGET_AVX512VL)"
    4400                 :       3372 :    [(set (match_dup 2)
    4401                 :       8874 :          (vec_concat:V4SF
    4402                 :       3369 :            (float_truncate:V2SF
    4403                 :       3369 :              (match_dup 4))
    4404                 :       3369 :            (match_dup 3)))]
    4405                 :       3372 : {
    4406                 :       3372 :   operands[2] = lowpart_subreg (V4SFmode, operands[0], SFmode);
    4407                 :       3372 :   operands[3] = CONST0_RTX (V2SFmode);
    4408                 :       3372 :   operands[4] = lowpart_subreg (V2DFmode, operands[0], SFmode);
    4409                 :       3369 :   /* Use movsd for loading from memory, unpcklpd for registers.
    4410                 :       3369 :      Try to avoid move when unpacking can be done in source, or SSE3
    4411                 :       3369 :      movddup is available.  */
    4412                 :       3372 :   if (REG_P (operands[1]))
    4413                 :       3369 :     {
    4414                 :       3370 :       if (!TARGET_SSE3
    4415                 :       3370 :           && REGNO (operands[0]) != REGNO (operands[1]))
    4416                 :       3369 :         {
    4417                 :       3369 :           rtx tmp = lowpart_subreg (DFmode, operands[0], SFmode);
    4418                 :       3369 :           emit_move_insn (tmp, operands[1]);
    4419                 :       3369 :           operands[1] = tmp;
    4420                 :       3369 :         }
    4421                 :       3370 :       else if (!TARGET_SSE3)
    4422                 :       3369 :         operands[4] = lowpart_subreg (V2DFmode, operands[1], DFmode);
    4423                 :       3370 :       emit_insn (gen_vec_dupv2df (operands[4], operands[1]));
    4424                 :       3369 :     }
    4425                 :       3369 :   else
    4426                 :       3371 :     emit_insn (gen_vec_concatv2df (operands[4], operands[1],
    4427                 :       3369 :                                    CONST0_RTX (DFmode)));
    4428                 :       3369 : })
    4429                 :       3369 : 
    4430                 :       3369 : ;; It's more profitable to split and then truncate in the same register.
    4431                 :       3372 : (define_peephole2
    4432                 :       3372 :   [(set (match_operand:SF 0 "sse_reg_operand")
    4433                 :       3372 :         (float_truncate:SF
    4434                 :       3372 :           (match_operand:DF 1 "memory_operand")))]
    4435                 :       3460 :   "TARGET_SPLIT_MEM_OPND_FOR_FP_CONVERTS
    4436                 :       3372 :    && optimize_insn_for_speed_p ()"
    4437                 :       3372 :   [(set (match_dup 2) (match_dup 1))
    4438                 :       3372 :    (set (match_dup 0) (float_truncate:SF (match_dup 2)))]
    4439                 :       3369 :   "operands[2] = lowpart_subreg (DFmode, operands[0], SFmode);")
    4440                 :       3372 : 
    4441                 :       3372 : ;; Break partial SSE register dependency stall.  This splitter should split
    4442                 :       3369 : ;; late in the pass sequence (after register rename pass), so allocated
    4443                 :       3369 : ;; registers won't change anymore
    4444                 :       3369 : 
    4445                 :       3369 : (define_split
    4446                 :       3372 :   [(set (match_operand:SF 0 "sse_reg_operand")
    4447                 :      28425 :         (float_truncate:SF
    4448                 :      28422 :           (match_operand:DF 1 "nonimmediate_operand")))]
    4449                 :      28422 :   "!TARGET_AVX
    4450                 :       7575 :    && TARGET_SSE_PARTIAL_REG_DEPENDENCY && epilogue_completed
    4451                 :       5752 :    && optimize_function_for_speed_p (cfun)
    4452                 :       5554 :    && (!REG_P (operands[1])
    4453                 :       5441 :        || (!TARGET_AVX && REGNO (operands[0]) != REGNO (operands[1])))
    4454                 :      98747 :    && (!EXT_REX_SSE_REG_P (operands[0])
    4455                 :      92709 :        || TARGET_AVX512VL)"
    4456                 :       3902 :   [(set (match_dup 0)
    4457                 :       3369 :         (vec_merge:V4SF
    4458                 :       3369 :           (vec_duplicate:V4SF
    4459                 :       3369 :             (float_truncate:SF
    4460                 :       3369 :               (match_dup 1)))
    4461                 :       3369 :           (match_dup 0)
    4462                 :   32000169 :           (const_int 1)))]
    4463                 :     198994 : {
    4464                 :   25577202 :   operands[0] = lowpart_subreg (V4SFmode, operands[0], SFmode);
    4465                 :   25382702 :   emit_move_insn (operands[0], CONST0_RTX (V4SFmode));
    4466                 :       3902 : })
    4467                 :       3369 : 
    4468                 :   37282702 : ;; Conversion from XFmode to {SF,DF}mode
    4469                 :    5342442 : 
    4470                 :   37282702 : (define_insn "truncxf<mode>2"
    4471                 :       3902 :   [(set (match_operand:MODEF 0 "nonimmediate_operand" "=m,f")
    4472                 :    5170992 :         (float_truncate:MODEF
    4473                 :    5170992 :           (match_operand:XF 1 "register_operand" "f,f")))]
    4474                 :       4352 :   "TARGET_80387"
    4475                 :     278662 :   "* return output_387_reg_move (insn, operands);"
    4476                 :    4317349 :   [(set_attr "type" "fmov")
    4477                 :       3377 :    (set_attr "mode" "<MODE>")
    4478                 :       6122 :    (set (attr "enabled")
    4479                 :      98698 :      (cond [(eq_attr "alternative" "1")
    4480                 :     111351 :               (symbol_ref "flag_unsafe_math_optimizations")
    4481                 :      89416 :            ]
    4482                 :      92146 :            (symbol_ref "true")))])
    4483                 :     134453 : 
    4484                 :       5434 : ;; Signed conversion to DImode.
    4485                 :       3801 : 
    4486                 :       4481 : (define_expand "fix_truncxfdi2"
    4487                 :       8084 :   [(parallel [(set (match_operand:DI 0 "nonimmediate_operand")
    4488                 :      24689 :                    (fix:DI (match_operand:XF 1 "register_operand")))
    4489                 :     151577 :               (clobber (reg:CC FLAGS_REG))])]
    4490                 :     158549 :   "TARGET_80387"
    4491                 :     138341 : {
    4492                 :       4481 :   if (TARGET_FISTTP)
    4493                 :       8084 :    {
    4494                 :       3369 :      emit_insn (gen_fix_truncdi_i387_fisttp (operands[0], operands[1]));
    4495                 :       8084 :      DONE;
    4496                 :     252339 :    }
    4497                 :     251227 : })
    4498                 :       4481 : 
    4499                 :       4481 : (define_expand "fix_trunc<mode>di2"
    4500                 :       8084 :   [(parallel [(set (match_operand:DI 0 "nonimmediate_operand")
    4501                 :       8330 :                    (fix:DI (match_operand:MODEF 1 "register_operand")))
    4502                 :       8330 :               (clobber (reg:CC FLAGS_REG))])]
    4503                 :       8330 :   "TARGET_80387 || (TARGET_64BIT && SSE_FLOAT_MODE_P (<MODE>mode))"
    4504                 :      24196 : {
    4505                 :       9232 :   if (TARGET_FISTTP
    4506                 :       3405 :       && !(TARGET_64BIT && SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH))
    4507                 :     699438 :    {
    4508                 :     699438 :      emit_insn (gen_fix_truncdi_i387_fisttp (operands[0], operands[1]));
    4509                 :     698326 :      DONE;
    4510                 :       4481 :    }
    4511                 :      27799 :   if (TARGET_64BIT && SSE_FLOAT_MODE_P (<MODE>mode))
    4512                 :       8084 :    {
    4513                 :     314243 :      rtx out = REG_P (operands[0]) ? operands[0] : gen_reg_rtx (DImode);
    4514                 :      23940 :      emit_insn (gen_fix_trunc<mode>di_sse (out, operands[1]));
    4515                 :     311752 :      if (out != operands[0])
    4516                 :       4166 :         emit_move_insn (operands[0], out);
    4517                 :      36646 :      DONE;
    4518                 :      20393 :    }
    4519                 :       3369 : })
    4520                 :      17187 : 
    4521                 :       6575 : ;; Signed conversion to SImode.
    4522                 :       6585 : 
    4523                 :       6831 : (define_expand "fix_truncxfsi2"
    4524                 :       6831 :   [(parallel [(set (match_operand:SI 0 "nonimmediate_operand")
    4525                 :       6831 :                    (fix:SI (match_operand:XF 1 "register_operand")))
    4526                 :       6575 :               (clobber (reg:CC FLAGS_REG))])]
    4527                 :       3625 :   "TARGET_80387"
    4528                 :       5129 : {
    4529                 :       3369 :   if (TARGET_FISTTP)
    4530                 :       3369 :    {
    4531                 :       3369 :      emit_insn (gen_fix_truncsi_i387_fisttp (operands[0], operands[1]));
    4532                 :       3369 :      DONE;
    4533                 :       3625 :    }
    4534                 :       3625 : })
    4535                 :       3625 : 
    4536                 :       3369 : (define_expand "fix_trunc<mode>si2"
    4537                 :       5129 :   [(parallel [(set (match_operand:SI 0 "nonimmediate_operand")
    4538                 :       5129 :                    (fix:SI (match_operand:MODEF 1 "register_operand")))
    4539                 :       5129 :               (clobber (reg:CC FLAGS_REG))])]
    4540                 :      23398 :   "TARGET_80387 || SSE_FLOAT_MODE_P (<MODE>mode)"
    4541                 :      14130 : {
    4542                 :       5271 :   if (TARGET_FISTTP
    4543                 :       3511 :       && !(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH))
    4544                 :      21638 :    {
    4545                 :       3370 :      emit_insn (gen_fix_truncsi_i387_fisttp (operands[0], operands[1]));
    4546                 :       3370 :      DONE;
    4547                 :      21638 :    }
    4548                 :      34158 :   if (SSE_FLOAT_MODE_P (<MODE>mode))
    4549                 :       5129 :    {
    4550                 :      15889 :      rtx out = REG_P (operands[0]) ? operands[0] : gen_reg_rtx (SImode);
    4551                 :      14129 :      emit_insn (gen_fix_trunc<mode>si_sse (out, operands[1]));
    4552                 :      14129 :      if (out != operands[0])
    4553                 :       3742 :         emit_move_insn (operands[0], out);
    4554                 :      14129 :      DONE;
    4555                 :       6649 :    }
    4556                 :       3369 : })
    4557                 :       3369 : 
    4558                 :       6649 : ;; Signed conversion to HImode.
    4559                 :       6649 : 
    4560                 :       6649 : (define_expand "fix_trunc<mode>hi2"
    4561                 :       6649 :   [(parallel [(set (match_operand:HI 0 "nonimmediate_operand")
    4562                 :       6649 :                    (fix:HI (match_operand:X87MODEF 1 "register_operand")))
    4563                 :       6649 :               (clobber (reg:CC FLAGS_REG))])]
    4564                 :       3369 :   "TARGET_80387
    4565                 :       3369 :    && !(SSE_FLOAT_MODE_P (<MODE>mode) && (!TARGET_FISTTP || TARGET_SSE_MATH))"
    4566                 :       5956 : {
    4567                 :       3369 :   if (TARGET_FISTTP)
    4568                 :       3369 :    {
    4569                 :       3369 :      emit_insn (gen_fix_trunchi_i387_fisttp (operands[0], operands[1]));
    4570                 :       3369 :      DONE;
    4571                 :       3369 :    }
    4572                 :       3369 : })
    4573                 :       3369 : 
    4574                 :       3369 : ;; Unsigned conversion to DImode
    4575                 :       5956 : 
    4576                 :       5956 : (define_insn "fixuns_trunc<mode>di2"
    4577                 :      13437 :   [(set (match_operand:DI 0 "register_operand" "=r")
    4578                 :       5956 :         (unsigned_fix:DI
    4579                 :       3369 :           (match_operand:MODEF 1 "nonimmediate_operand" "vm")))]
    4580                 :       5964 :   "TARGET_64BIT && TARGET_AVX512F && TARGET_SSE_MATH"
    4581                 :      10850 :   "vcvtt<ssemodesuffix>2usi\t{%1, %0|%0, %1}"
    4582                 :      10850 :   [(set_attr "type" "sseicvt")
    4583                 :      10850 :    (set_attr "prefix" "evex")
    4584                 :      10877 :    (set_attr "mode" "DI")])
    4585                 :      10877 : 
    4586                 :       5956 : ;; Unsigned conversion to SImode.
    4587                 :       5956 : 
    4588                 :       6035 : (define_expand "fixuns_trunc<mode>si2"
    4589                 :       3448 :   [(parallel
    4590                 :       3369 :     [(set (match_operand:SI 0 "register_operand")
    4591                 :       3424 :           (unsigned_fix:SI
    4592                 :       3369 :             (match_operand:MODEF 1 "nonimmediate_operand")))
    4593                 :       5971 :      (use (match_dup 2))
    4594                 :       3391 :      (clobber (match_scratch:<ssevecmode> 3))
    4595                 :       3369 :      (clobber (match_scratch:<ssevecmode> 4))])]
    4596                 :       5960 :   "(!TARGET_64BIT || TARGET_AVX512F) && TARGET_SSE2 && TARGET_SSE_MATH"
    4597                 :       5956 : {
    4598                 :       3373 :   machine_mode mode = <MODE>mode;
    4599                 :       5968 :   machine_mode vecmode = <ssevecmode>mode;
    4600                 :       5968 :   REAL_VALUE_TYPE TWO31r;
    4601                 :       5956 :   rtx two31;
    4602                 :       3373 : 
    4603                 :       3373 :   if (TARGET_AVX512F)
    4604                 :       3369 :     {
    4605                 :       3381 :       emit_insn (gen_fixuns_trunc<mode>si2_avx512f (operands[0], operands[1]));
    4606                 :       3381 :       DONE;
    4607                 :       3369 :     }
    4608                 :       3369 : 
    4609                 :       3369 :   if (optimize_insn_for_size_p ())
    4610                 :       3369 :     FAIL;
    4611                 :       3369 : 
    4612                 :       3369 :   real_ldexp (&TWO31r, &dconst1, 31);
    4613                 :       3369 :   two31 = const_double_from_real_value (TWO31r, mode);
    4614                 :       3369 :   two31 = ix86_build_const_vector (vecmode, true, two31);
    4615                 :       3369 :   operands[2] = force_reg (vecmode, two31);
    4616                 :       3369 : })
    4617                 :       3369 : 
    4618                 :       3369 : (define_insn "fixuns_trunc<mode>si2_avx512f"
    4619                 :       3369 :   [(set (match_operand:SI 0 "register_operand" "=r")
    4620                 :       3369 :         (unsigned_fix:SI
    4621                 :       3369 :           (match_operand:MODEF 1 "nonimmediate_operand" "vm")))]
    4622                 :       3380 :   "TARGET_AVX512F && TARGET_SSE_MATH"
    4623                 :       3369 :   "vcvtt<ssemodesuffix>2usi\t{%1, %0|%0, %1}"
    4624                 :       3369 :   [(set_attr "type" "sseicvt")
    4625                 :       3369 :    (set_attr "prefix" "evex")
    4626                 :       3386 :    (set_attr "mode" "SI")])
    4627                 :       3386 : 
    4628                 :       3369 : (define_insn "*fixuns_trunc<mode>si2_avx512f_zext"
    4629                 :       3369 :   [(set (match_operand:DI 0 "register_operand" "=r")
    4630                 :       3369 :         (zero_extend:DI
    4631                 :       3369 :           (unsigned_fix:SI
    4632                 :       3369 :             (match_operand:MODEF 1 "nonimmediate_operand" "vm"))))]
    4633                 :       3369 :   "TARGET_64BIT && TARGET_AVX512F && TARGET_SSE_MATH"
    4634                 :       3369 :   "vcvtt<ssemodesuffix>2usi\t{%1, %k0|%k0, %1}"
    4635                 :       3369 :   [(set_attr "type" "sseicvt")
    4636                 :     134738 :    (set_attr "prefix" "evex")
    4637                 :       3369 :    (set_attr "mode" "SI")])
    4638                 :       3369 : 
    4639                 :       3369 : (define_insn_and_split "*fixuns_trunc<mode>_1"
    4640                 :     134738 :   [(set (match_operand:SI 0 "register_operand" "=&x,&x")
    4641                 :     169088 :         (unsigned_fix:SI
    4642                 :      37719 :           (match_operand:MODEF 3 "nonimmediate_operand" "xm,xm")))
    4643                 :     134738 :    (use (match_operand:<ssevecmode> 4  "nonimmediate_operand" "m,x"))
    4644                 :     147418 :    (clobber (match_scratch:<ssevecmode> 1 "=x,&x"))
    4645                 :     147410 :    (clobber (match_scratch:<ssevecmode> 2 "=x,x"))]
    4646                 :      16041 :   "!TARGET_64BIT && TARGET_SSE2 && TARGET_SSE_MATH
    4647                 :      16049 :    && optimize_function_for_speed_p (cfun)"
    4648                 :     147411 :   "#"
    4649                 :      16048 :   "&& reload_completed"
    4650                 :       3369 :   [(const_int 0)]
    4651                 :      54868 : {
    4652                 :       3369 :   ix86_split_convert_uns_si_sse (operands);
    4653                 :      54868 :   DONE;
    4654                 :       3370 : })
    4655                 :      50465 : 
    4656                 :      11475 : ;; Unsigned conversion to HImode.
    4657                 :       3369 : ;; Without these patterns, we'll try the unsigned SI conversion which
    4658                 :      36992 : ;; is complex for SSE, rather than the signed SI conversion, which isn't.
    4659                 :      25207 : 
    4660                 :      15876 : (define_expand "fixuns_trunc<mode>hi2"
    4661                 :      23992 :   [(set (match_dup 2)
    4662                 :      11475 :         (fix:SI (match_operand:MODEF 1 "nonimmediate_operand")))
    4663                 :      15866 :    (set (match_operand:HI 0 "nonimmediate_operand")
    4664                 :      15866 :         (subreg:HI (match_dup 2) 0))]
    4665                 :      12049 :   "SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH"
    4666                 :      18193 :   "operands[2] = gen_reg_rtx (SImode);")
    4667                 :      11737 : 
    4668                 :      12311 : ;; When SSE is available, it is always faster to use it!
    4669                 :      11475 : (define_insn "fix_trunc<MODEF:mode><SWI48:mode>_sse"
    4670                 :      12050 :   [(set (match_operand:SWI48 0 "register_operand" "=r,r")
    4671                 :       3369 :         (fix:SWI48 (match_operand:MODEF 1 "nonimmediate_operand" "v,m")))]
    4672                 :      59361 :   "SSE_FLOAT_MODE_P (<MODEF:MODE>mode)
    4673                 :      88522 :    && (!TARGET_FISTTP || TARGET_SSE_MATH)"
    4674                 :      12026 :   "%vcvtt<MODEF:ssemodesuffix>2si<SWI48:rex64suffix>\t{%1, %0|%0, %1}"
    4675                 :       3369 :   [(set_attr "type" "sseicvt")
    4676                 :      14811 :    (set_attr "prefix" "maybe_vex")
    4677                 :      42106 :    (set (attr "prefix_rex")
    4678                 :      42106 :         (if_then_else
    4679                 :      37382 :           (match_test "<SWI48:MODE>mode == DImode")
    4680                 :      11452 :           (const_string "1")
    4681                 :      30537 :           (const_string "*")))
    4682                 :      30477 :    (set_attr "mode" "<MODEF:MODE>")
    4683                 :      49407 :    (set_attr "athlon_decode" "double,vector")
    4684                 :      23848 :    (set_attr "amdfam10_decode" "double,double")
    4685                 :       8693 :    (set_attr "bdver1_decode" "double,double")])
    4686                 :       3369 : 
    4687                 :       3369 : ;; Avoid vector decoded forms of the instruction.
    4688                 :       3369 : (define_peephole2
    4689                 :       3369 :   [(match_scratch:MODEF 2 "x")
    4690                 :       6154 :    (set (match_operand:SWI48 0 "register_operand")
    4691                 :       3371 :         (fix:SWI48 (match_operand:MODEF 1 "memory_operand")))]
    4692                 :       8617 :   "TARGET_AVOID_VECTOR_DECODE
    4693                 :       6159 :    && SSE_FLOAT_MODE_P (<MODEF:MODE>mode)
    4694                 :       6159 :    && optimize_insn_for_speed_p ()"
    4695                 :       7213 :   [(set (match_dup 2) (match_dup 1))
    4696                 :       6159 :    (set (match_dup 0) (fix:SWI48 (match_dup 2)))])
    4697                 :       6159 : 
    4698                 :       3371 : (define_insn "fix_trunc<mode>_i387_fisttp"
    4699                 :       6607 :   [(set (match_operand:SWI248x 0 "nonimmediate_operand" "=m")
    4700                 :       3821 :         (fix:SWI248x (match_operand 1 "register_operand" "f")))
    4701                 :       3371 :    (clobber (match_scratch:XF 2 "=&f"))]
    4702                 :      11889 :   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
    4703                 :      11781 :    && TARGET_FISTTP
    4704                 :      17618 :    && !((SSE_FLOAT_MODE_P (GET_MODE (operands[1]))
    4705                 :       3403 :          && (TARGET_64BIT || <MODE>mode != DImode))
    4706                 :       3570 :         && TARGET_SSE_MATH)"
    4707                 :       3459 :   "* return output_fix_trunc (insn, operands, true);"
    4708                 :       3372 :   [(set_attr "type" "fisttp")
    4709                 :       3372 :    (set_attr "mode" "<MODE>")])
    4710                 :       3372 : 
    4711                 :      22542 : ;; See the comments in i386.h near OPTIMIZE_MODE_SWITCHING for the description
    4712                 :       3371 : ;; of the machinery. Please note the clobber of FLAGS_REG. In i387 control
    4713                 :       3369 : ;; word calculation (inserted by LCM in mode switching pass) a FLAGS_REG
    4714                 :      11736 : ;; clobbering insns can be used. Look at emit_i387_cw_initialization ()
    4715                 :      11738 : ;; function in i386.c.
    4716                 :      20105 : (define_insn_and_split "*fix_trunc<mode>_i387_1"
    4717                 :       3371 :   [(set (match_operand:SWI248x 0 "nonimmediate_operand")
    4718                 :      11736 :         (fix:SWI248x (match_operand 1 "register_operand")))
    4719                 :       3369 :    (clobber (reg:CC FLAGS_REG))]
    4720                 :      28460 :   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
    4721                 :      33524 :    && !TARGET_FISTTP
    4722                 :      28153 :    && !(SSE_FLOAT_MODE_P (GET_MODE (operands[1]))
    4723                 :       5210 :          && (TARGET_64BIT || <MODE>mode != DImode))
    4724                 :      26736 :    && ix86_pre_reload_split ()"
    4725                 :       5093 :   "#"
    4726                 :      10163 :   "&& 1"
    4727                 :      10163 :   [(const_int 0)]
    4728                 :      19781 : {
    4729                 :      23135 :   ix86_optimize_mode_switching[I387_TRUNC] = 1;
    4730                 :      76337 : 
    4731                 :      27685 :   operands[2] = assign_386_stack_local (HImode, SLOT_CW_STORED);
    4732                 :      87607 :   operands[3] = assign_386_stack_local (HImode, SLOT_CW_TRUNC);
    4733                 :      20362 : 
    4734                 :      76617 :   emit_insn (gen_fix_trunc<mode>_i387 (operands[0], operands[1],
    4735                 :   11732669 :                                        operands[2], operands[3]));
    4736                 :      20157 :   DONE;
    4737                 :      13052 : }
    4738                 :      13022 :   [(set_attr "type" "fistp")
    4739                 :     144340 :    (set_attr "i387_cw" "trunc")
    4740                 :     144340 :    (set_attr "mode" "<MODE>")])
    4741                 :     144340 : 
    4742                 :       3369 : (define_insn "fix_truncdi_i387"
    4743                 :     144340 :   [(set (match_operand:DI 0 "nonimmediate_operand" "=m")
    4744                 :       3369 :         (fix:DI (match_operand 1 "register_operand" "f")))
    4745                 :     144340 :    (use (match_operand:HI 2 "memory_operand" "m"))
    4746                 :     144340 :    (use (match_operand:HI 3 "memory_operand" "m"))
    4747                 :       3369 :    (clobber (match_scratch:XF 4 "=&f"))]
    4748                 :      20918 :   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
    4749                 :      17071 :    && !TARGET_FISTTP
    4750                 :      11452 :    && !(TARGET_64BIT && SSE_FLOAT_MODE_P (GET_MODE (operands[1])))"
    4751                 :      16694 :   "* return output_fix_trunc (insn, operands, false);"
    4752                 :     149959 :   [(set_attr "type" "fistp")
    4753                 :       3369 :    (set_attr "i387_cw" "trunc")
    4754                 :     151852 :    (set_attr "mode" "DI")])
    4755                 :       7850 : 
    4756                 :     144340 : (define_insn "fix_trunc<mode>_i387"
    4757                 :       3385 :   [(set (match_operand:SWI24 0 "nonimmediate_operand" "=m")
    4758                 :      85590 :         (fix:SWI24 (match_operand 1 "register_operand" "f")))
    4759                 :      63451 :    (use (match_operand:HI 2 "memory_operand" "m"))
    4760                 :       3370 :    (use (match_operand:HI 3 "memory_operand" "m"))]
    4761                 :      35496 :   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
    4762                 :      13373 :    && !TARGET_FISTTP
    4763                 :     152349 :    && !SSE_FLOAT_MODE_P (GET_MODE (operands[1]))"
    4764                 :     144932 :   "* return output_fix_trunc (insn, operands, false);"
    4765                 :       3370 :   [(set_attr "type" "fistp")
    4766                 :       3369 :    (set_attr "i387_cw" "trunc")
    4767                 :       7449 :    (set_attr "mode" "<MODE>")])
    4768                 :      17822 : 
    4769                 :       3370 : (define_insn "x86_fnstcw_1"
    4770                 :       3370 :   [(set (match_operand:HI 0 "memory_operand" "=m")
    4771                 :       8151 :         (unspec:HI [(const_int 0)] UNSPEC_FSTCW))]
    4772                 :      14246 :   "TARGET_80387"
    4773                 :       3618 :   "fnstcw\t%0"
    4774                 :       3370 :   [(set (attr "length")
    4775                 :       3617 :         (symbol_ref "ix86_attr_length_address_default (insn) + 2"))
    4776                 :       3618 :    (set_attr "mode" "HI")
    4777                 :       3390 :    (set_attr "unit" "i387")
    4778                 :      21013 :    (set_attr "bdver1_decode" "vector")])
    4779                 :       3370 : 
    4780                 :       3398 : ;; Conversion between fixed point and floating point.
    4781                 :      20801 : 
    4782                 :       3369 : ;; Even though we only accept memory inputs, the backend _really_
    4783                 :       3369 : ;; wants to be able to do this between registers.  Thankfully, LRA
    4784                 :       3369 : ;; will fix this up for us during register allocation.
    4785                 :       3369 : 
    4786                 :       3369 : (define_insn "floathi<mode>2"
    4787                 :       3369 :   [(set (match_operand:X87MODEF 0 "register_operand" "=f")
    4788                 :       3369 :         (float:X87MODEF (match_operand:HI 1 "nonimmediate_operand" "m")))]
    4789                 :       3412 :   "TARGET_80387
    4790                 :       3551 :    && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH)
    4791                 :       3531 :        || TARGET_MIX_SSE_I387)"
    4792                 :     515595 :   "fild%Z1\t%1"
    4793                 :       3369 :   [(set_attr "type" "fmov")
    4794                 :       3369 :    (set_attr "mode" "<MODE>")
    4795                 :     106257 :    (set_attr "znver1_decode" "double")
    4796                 :     106737 :    (set_attr "fp_int_src" "true")])
    4797                 :       3369 : 
    4798                 :       3369 : (define_insn "float<SWI48x:mode>xf2"
    4799                 :       3369 :   [(set (match_operand:XF 0 "register_operand" "=f")
    4800                 :       3369 :         (float:XF (match_operand:SWI48x 1 "nonimmediate_operand" "m")))]
    4801                 :       9169 :   "TARGET_80387"
    4802                 :       3369 :   "fild%Z1\t%1"
    4803                 :       3369 :   [(set_attr "type" "fmov")
    4804                 :       3369 :    (set_attr "mode" "XF")
    4805                 :       9384 :    (set_attr "znver1_decode" "double")
    4806                 :       9384 :    (set_attr "fp_int_src" "true")])
    4807                 :       3369 : 
    4808                 :       3369 : (define_expand "float<SWI48x:mode><MODEF:mode>2"
    4809                 :       3480 :   [(set (match_operand:MODEF 0 "register_operand")
    4810                 :       3480 :         (float:MODEF (match_operand:SWI48x 1 "nonimmediate_operand")))]
    4811                 :       3480 :   "(TARGET_80387 && X87_ENABLE_FLOAT (<MODEF:MODE>mode, <SWI48x:MODE>mode))
    4812                 :       3480 :    || (SSE_FLOAT_MODE_P (<MODEF:MODE>mode) && TARGET_SSE_MATH
    4813                 :       3581 :        && ((<SWI48x:MODE>mode != DImode) || TARGET_64BIT))")
    4814                 :       3369 : 
    4815                 :       3369 : (define_insn "*float<SWI48:mode><MODEF:mode>2"
    4816                 :       3369 :   [(set (match_operand:MODEF 0 "register_operand" "=f,v,v")
    4817                 :       3369 :         (float:MODEF
    4818                 :       3369 :           (match_operand:SWI48 1 "nonimmediate_operand" "m,r,m")))]
    4819                 :     154983 :   "(TARGET_80387 && X87_ENABLE_FLOAT (<MODEF:MODE>mode, <SWI48:MODE>mode))
    4820                 :      55788 :    || (SSE_FLOAT_MODE_P (<MODEF:MODE>mode) && TARGET_SSE_MATH)"
    4821                 :       5961 :   "@
    4822                 :       5956 :    fild%Z1\t%1
    4823                 :       3369 :    %vcvtsi2<MODEF:ssemodesuffix><SWI48:rex64suffix>\t{%1, %d0|%d0, %1}
    4824                 :      57895 :    %vcvtsi2<MODEF:ssemodesuffix><SWI48:rex64suffix>\t{%1, %d0|%d0, %1}"
    4825                 :      55308 :   [(set_attr "type" "fmov,sseicvt,sseicvt")
    4826                 :       3369 :    (set_attr "avx_partial_xmm_update" "false,true,true")
    4827                 :       3369 :    (set_attr "prefix" "orig,maybe_vex,maybe_vex")
    4828                 :       3369 :    (set_attr "mode" "<MODEF:MODE>")
    4829                 :       3369 :    (set (attr "prefix_rex")
    4830                 :       3369 :      (if_then_else
    4831                 :       3369 :        (and (eq_attr "prefix" "maybe_vex")
    4832                 :       3369 :             (match_test "<SWI48:MODE>mode == DImode"))
    4833                 :       3369 :        (const_string "1")
    4834                 :       3369 :        (const_string "*")))
    4835                 :       3369 :    (set_attr "unit" "i387,*,*")
    4836                 :       3369 :    (set_attr "athlon_decode" "*,double,direct")
    4837                 :       3369 :    (set_attr "amdfam10_decode" "*,vector,double")
    4838                 :       3369 :    (set_attr "bdver1_decode" "*,double,direct")
    4839                 :       3369 :    (set_attr "znver1_decode" "double,*,*")
    4840                 :       3369 :    (set_attr "fp_int_src" "true")
    4841                 :       3369 :    (set (attr "enabled")
    4842                 :       3369 :      (if_then_else
    4843                 :       3369 :        (match_test ("SSE_FLOAT_MODE_P (<MODEF:MODE>mode) && TARGET_SSE_MATH"))
    4844                 :       3369 :        (if_then_else
    4845                 :       3369 :          (eq_attr "alternative" "0")
    4846                 :      34029 :          (symbol_ref "TARGET_MIX_SSE_I387
    4847                 :        108 :                       && X87_ENABLE_FLOAT (<MODEF:MODE>mode,
    4848                 :      26715 :                                            <SWI48:MODE>mode)")
    4849                 :       3369 :          (symbol_ref "true"))
    4850                 :       3369 :        (if_then_else
    4851                 :       3369 :          (eq_attr "alternative" "0")
    4852                 :       3369 :          (symbol_ref "true")
    4853                 :       3369 :          (symbol_ref "false"))))
    4854                 :       3369 :    (set (attr "preferred_for_speed")
    4855                 :       3369 :      (cond [(eq_attr "alternative" "1")
    4856                 :      13897 :               (symbol_ref "TARGET_INTER_UNIT_CONVERSIONS")]
    4857                 :       3369 :            (symbol_ref "true")))])
    4858                 :       1707 : 
    4859                 :       3369 : (define_insn "*floatdi<MODEF:mode>2_i387"
    4860                 :       3369 :   [(set (match_operand:MODEF 0 "register_operand" "=f")
    4861                 :       3369 :         (float:MODEF (match_operand:DI 1 "nonimmediate_operand" "m")))]
    4862                 :       5087 :   "!TARGET_64BIT
    4863                 :       5080 :    && TARGET_80387 && X87_ENABLE_FLOAT (<MODEF:MODE>mode, DImode)"
    4864                 :      38732 :   "fild%Z1\t%1"
    4865                 :      35794 :   [(set_attr "type" "fmov")
    4866                 :      34656 :    (set_attr "mode" "<MODEF:MODE>")
    4867                 :       3369 :    (set_attr "znver1_decode" "double")
    4868                 :      14921 :    (set_attr "fp_int_src" "true")])
    4869                 :       3369 : 
    4870                 :       3369 : ;; Try TARGET_USE_VECTOR_CONVERTS, but not so hard as to require extra memory
    4871                 :     146471 : ;; slots when !TARGET_INTER_UNIT_MOVES_TO_VEC disables the general_regs
    4872                 :     146471 : ;; alternative in sse2_loadld.
    4873                 :       3369 : (define_split
    4874                 :       5776 :   [(set (match_operand:MODEF 0 "sse_reg_operand")
    4875                 :       5776 :         (float:MODEF (match_operand:SI 1 "nonimmediate_operand")))]
    4876                 :      59317 :   "TARGET_SSE2
    4877                 :      59274 :    && TARGET_USE_VECTOR_CONVERTS
    4878                 :       3373 :    && optimize_function_for_speed_p (cfun)
    4879                 :       3371 :    && reload_completed
    4880                 :       3371 :    && (MEM_P (operands[1]) || TARGET_INTER_UNIT_MOVES_TO_VEC)
    4881                 :      59319 :    && (!EXT_REX_SSE_REG_P (operands[0])
    4882                 :       3369 :        || TARGET_AVX512VL)"
    4883                 :       3371 :   [(const_int 0)]
    4884                 :      59317 : {
    4885                 :       3371 :   operands[3] = lowpart_subreg (<ssevecmode>mode, operands[0], <MODE>mode);
    4886                 :       3371 :   operands[4] = lowpart_subreg (V4SImode, operands[0], <MODE>mode);
    4887                 :       3369 : 
    4888                 :       3371 :   emit_insn (gen_sse2_loadld (operands[4],
    4889                 :       3369 :                               CONST0_RTX (V4SImode), operands[1]));
    4890                 :       3369 : 
    4891                 :       3371 :   if (<ssevecmode>mode == V4SFmode)
    4892                 :       3369 :     emit_insn (gen_floatv4siv4sf2 (operands[3], operands[4]));
    4893                 :       3369 :   else
    4894                 :       3371 :     emit_insn (gen_sse2_cvtdq2pd (operands[3], operands[4]));
    4895                 :       3371 :   DONE;
    4896                 :       3369 : })
    4897                 :       3369 : 
    4898                 :       3369 : ;; Avoid store forwarding (partial memory) stall penalty
    4899                 :       3369 : ;; by passing DImode value through XMM registers.  */
    4900                 :       3369 : 
    4901                 :       3369 : (define_split
    4902                 :       3369 :   [(set (match_operand:X87MODEF 0 "register_operand")
    4903                 :       3369 :         (float:X87MODEF
    4904                 :       3369 :           (match_operand:DI 1 "register_operand")))]
    4905                 :       6199 :   "!TARGET_64BIT && TARGET_INTER_UNIT_MOVES_TO_VEC
    4906                 :       4026 :    && TARGET_80387 && X87_ENABLE_FLOAT (<X87MODEF:MODE>mode, DImode)
    4907                 :       4026 :    && TARGET_SSE2 && optimize_function_for_speed_p (cfun)
    4908                 :       4033 :    && can_create_pseudo_p ()"
    4909                 :      23783 :   [(const_int 0)]
    4910                 :     140164 : {
    4911                 :      69416 :   emit_insn (gen_floatdi<mode>2_i387_with_xmm
    4912                 :     157516 :              (operands[0], operands[1],
    4913                 :       3376 :               assign_386_stack_local (DImode, SLOT_TEMP)));
    4914                 :       4026 :   DONE;
    4915                 :       3369 : })
    4916                 :       3369 : 
    4917                 :       3369 : (define_insn_and_split "floatdi<X87MODEF:mode>2_i387_with_xmm"
    4918                 :    5341909 :   [(set (match_operand:X87MODEF 0 "register_operand" "=f,f")
    4919                 :       3369 :         (float:X87MODEF
    4920                 :    5341909 :           (match_operand:DI 1 "register_operand" "r,r")))
    4921                 :    5341909 :    (clobber (match_operand:DI 2 "memory_operand" "=m,m"))
    4922                 :    5341909 :    (clobber (match_scratch:V4SI 3 "=x,x"))
    4923                 :    5341909 :    (clobber (match_scratch:V4SI 4 "=X,x"))]
    4924                 :       6576 :   "!TARGET_64BIT && TARGET_INTER_UNIT_MOVES_TO_VEC
    4925                 :       6576 :    && TARGET_80387 && X87_ENABLE_FLOAT (<X87MODEF:MODE>mode, DImode)
    4926                 :       6576 :    && TARGET_SSE2 && optimize_function_for_speed_p (cfun)"
    4927                 :    5342566 :   "#"
    4928                 :       3379 :   "&& reload_completed"
    4929                 :       4683 :   [(set (match_dup 2) (match_dup 3))
    4930                 :       4678 :    (set (match_dup 0) (float:X87MODEF (match_dup 2)))]
    4931                 :     360365 : {
    4932                 :       4021 :   /* The DImode arrived in a pair of integral registers (e.g. %edx:%eax).
    4933                 :       5982 :      Assemble the 64-bit DImode value in an xmm register.  */
    4934                 :     140183 :   emit_insn (gen_sse2_loadld (operands[3], CONST0_RTX (V4SImode),
    4935                 :     140178 :                               gen_lowpart (SImode, operands[1])));
    4936                 :       4077 :   if (TARGET_SSE4_1)
    4937                 :  568692160 :     emit_insn (gen_sse4_1_pinsrd (operands[3], operands[3],
    4938                 :  568636643 :                                   gen_highpart (SImode, operands[1]),
    4939                 :  568636415 :                                   GEN_INT (2)));
    4940                 :       3385 :   else
    4941                 :       3372 :     {
    4942                 :       4026 :       emit_insn (gen_sse2_loadld (operands[4], CONST0_RTX (V4SImode),
    4943                 :  481154369 :                                   gen_highpart (SImode, operands[1])));
    4944                 :       4026 :       emit_insn (gen_vec_interleave_lowv4si (operands[3], operands[3],
    4945                 :       3369 :                                              operands[4]));
    4946                 :       3369 :     }
    4947                 :  306191026 :   operands[3] = gen_lowpart (DImode, operands[3]);
    4948                 :       3369 : }
    4949                 :       3369 :   [(set_attr "isa" "sse4,*")
    4950                 :       3369 :    (set_attr "type" "multi")
    4951                 :  262450026 :    (set_attr "mode" "<X87MODEF:MODE>")
    4952                 :       4026 :    (set_attr "unit" "i387")
    4953                 :       4026 :    (set_attr "fp_int_src" "true")])
    4954                 :       4026 : 
    4955                 :       4026 : ;; Break partial SSE register dependency stall.  This splitter should split
    4956                 :       4026 : ;; late in the pass sequence (after register rename pass), so allocated
    4957                 :  218709026 : ;; registers won't change anymore
    4958                 :       4026 : 
    4959                 :       4026 : (define_split
    4960                 :       3373 :   [(set (match_operand:MODEF 0 "sse_reg_operand")
    4961                 :       4030 :         (float:MODEF (match_operand:SWI48 1 "nonimmediate_operand")))]
    4962                 :      40741 :   "!TARGET_AVX
    4963                 :      96248 :    && TARGET_SSE_PARTIAL_REG_DEPENDENCY && epilogue_completed
    4964                 :      53422 :    && optimize_function_for_speed_p (cfun)
    4965                 :     106331 :    && (!EXT_REX_SSE_REG_P (operands[0])
    4966                 :       4026 :        || TARGET_AVX512VL)"
    4967                 :      31304 :   [(set (match_dup 0)
    4968                 :       3369 :         (vec_merge:<MODEF:ssevecmode>
    4969                 :     139341 :           (vec_duplicate:<MODEF:ssevecmode>
    4970                 :     133283 :             (float:MODEF
    4971                 :     178058 :               (match_dup 1)))
    4972                 :      11953 :           (match_dup 0)
    4973                 :       3369 :           (const_int 1)))]
    4974                 :      58312 : {
    4975                 :      58312 :   const machine_mode vmode = <MODEF:ssevecmode>mode;
    4976                 :      11953 : 
    4977                 :      57660 :   operands[0] = lowpart_subreg (vmode, operands[0], <MODEF:MODE>mode);
    4978                 :      49728 :   emit_move_insn (operands[0], CONST0_RTX (vmode));
    4979                 :      11953 : })
    4980                 :       3369 : 
    4981                 :       4021 : (define_expand "floatuns<SWI12:mode><MODEF:mode>2"
    4982                 :      49728 :   [(set (match_operand:MODEF 0 "register_operand")
    4983                 :      49728 :         (unsigned_float:MODEF
    4984                 :      49728 :           (match_operand:SWI12 1 "nonimmediate_operand")))]
    4985                 :      49728 :   "!TARGET_64BIT
    4986                 :      49728 :    && SSE_FLOAT_MODE_P (<MODEF:MODE>mode) && TARGET_SSE_MATH"
    4987                 :       3369 : {
    4988                 :       3369 :   operands[1] = convert_to_mode (SImode, operands[1], 1);
    4989                 :          0 :   emit_insn (gen_floatsi<MODEF:mode>2 (operands[0], operands[1]));
    4990                 :          0 :   DONE;
    4991                 :          0 : })
    4992                 :          0 : 
    4993                 :      46359 : (define_insn "*floatuns<SWI48:mode><MODEF:mode>2_avx512"
    4994                 :      46359 :   [(set (match_operand:MODEF 0 "register_operand" "=v")
    4995                 :      46359 :         (unsigned_float:MODEF
    4996                 :            :           (match_operand:SWI48 1 "nonimmediate_operand" "rm")))]
    4997                 :  269854183 :   "TARGET_AVX512F && TARGET_SSE_MATH"
    4998                 :         88 :   "vcvtusi2<MODEF:ssemodesuffix><SWI48:rex64suffix>\t{%1, %0, %0|%0, %0, %1}"
    4999                 :  269854000 :   [(set_attr "type" "sseicvt")
    5000                 :          0 :    (set_attr "avx_partial_xmm_update" "true")
    5001                 :  296826570 :    (set_attr "prefix" "evex")
    5002                 :   26934186 :    (set_attr "mode" "<MODEF:MODE>")])
    5003                 :   27003954 : 
    5004                 :      31427 : ;; Avoid store forwarding (partial memory) stall penalty by extending
    5005                 :      69854 : ;; SImode value to DImode through XMM register instead of pushing two
    5006                 :      69854 : ;; SImode values to stack. Also note that fild loads from memory only.
    5007                 :   20812600 : 
    5008                 :      38427 : (define_insn_and_split "floatunssi<mode>2_i387_with_xmm"
    5009                 :          0 :   [(set (match_operand:X87MODEF 0 "register_operand" "=f")
    5010                 :       6683 :         (unsigned_float:X87MODEF
    5011                 :   15915300 :           (match_operand:SI 1 "nonimmediate_operand" "rm")))
    5012                 :          8 :    (clobber (match_operand:DI 2 "memory_operand" "=m"))
    5013                 :          0 :    (clobber (match_scratch:DI 3 "=x"))]
    5014                 :         52 :   "!TARGET_64BIT
    5015                 :   11018626 :    && TARGET_80387 && X87_ENABLE_FLOAT (<X87MODEF:MODE>mode, DImode)
    5016                 :       7001 :    && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES_TO_VEC"
    5017                 :          8 :   "#"
    5018                 :         16 :   "&& reload_completed"
    5019                 :      62464 :   [(set (match_dup 3) (zero_extend:DI (match_dup 1)))
    5020                 :      62505 :    (set (match_dup 2) (match_dup 3))
    5021                 :    8632610 :    (set (match_dup 0)
    5022                 :      62456 :         (float:X87MODEF (match_dup 2)))]
    5023                 :        164 :   ""
    5024                 :      71764 :   [(set_attr "type" "multi")
    5025                 :      71764 :    (set_attr "mode" "<MODE>")])
    5026                 :   13674349 : 
    5027                 :      61423 : (define_expand "floatunssi<mode>2"
    5028                 :     131386 :   [(set (match_operand:X87MODEF 0 "register_operand")
    5029                 :    3177909 :         (unsigned_float:X87MODEF
    5030                 :    3237739 :           (match_operand:SI 1 "nonimmediate_operand")))]
    5031                 :    3263730 :   "(!TARGET_64BIT
    5032                 :     148784 :     && TARGET_80387 && X87_ENABLE_FLOAT (<X87MODEF:MODE>mode, DImode)
    5033                 :    3203900 :     && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES_TO_VEC)
    5034                 :      56341 :    || ((!TARGET_64BIT || TARGET_AVX512F)
    5035                 :    1353041 :        && SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH)"
    5036                 :    1204368 : {
    5037                 :      19452 :   if (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH))
    5038                 :     618689 :     {
    5039                 :     557413 :       emit_insn (gen_floatunssi<mode>2_i387_with_xmm
    5040                 :      61374 :                   (operands[0], operands[1],
    5041                 :      19196 :                    assign_386_stack_local (DImode, SLOT_TEMP)));
    5042                 :     865797 :       DONE;
    5043                 :      61438 :     }
    5044                 :     119917 :   if (!TARGET_AVX512F)
    5045                 :      61374 :     {
    5046                 :     102401 :       ix86_expand_convert_uns_si<mode>_sse (operands[0], operands[1]);
    5047                 :      71133 :       DONE;
    5048                 :      54857 :     }
    5049                 :      17504 : })
    5050                 :      41583 : 
    5051                 :        456 : (define_expand "floatunsdisf2"
    5052                 :        538 :   [(set (match_operand:SF 0 "register_operand")
    5053                 :      17511 :         (unsigned_float:SF
    5054                 :      17571 :           (match_operand:DI 1 "nonimmediate_operand")))]
    5055                 :         89 :   "TARGET_64BIT && TARGET_SSE && TARGET_SSE_MATH"
    5056                 :      18211 : {
    5057                 :      16789 :   if (!TARGET_AVX512F)
    5058                 :          0 :     {
    5059                 :      18184 :       x86_emit_floatuns (operands);
    5060                 :      18162 :       DONE;
    5061                 :      16726 :     }
    5062                 :         19 : })
    5063                 :      15504 : 
    5064                 :      15504 : (define_expand "floatunsdidf2"
    5065                 :          5 :   [(set (match_operand:DF 0 "register_operand")
    5066                 :      11315 :         (unsigned_float:DF
    5067                 :       1492 :           (match_operand:DI 1 "nonimmediate_operand")))]
    5068                 :        964 :   "((TARGET_64BIT && TARGET_AVX512F)
    5069                 :        959 :     || TARGET_KEEPS_VECTOR_ALIGNED_STACK)
    5070                 :        964 :    && TARGET_SSE2 && TARGET_SSE_MATH"
    5071                 :       1487 : {
    5072                 :       4768 :   if (!TARGET_64BIT)
    5073                 :          5 :     {
    5074                 :          0 :       ix86_expand_convert_uns_didf_sse (operands[0], operands[1]);
    5075                 :       4783 :       DONE;
    5076                 :         26 :     }
    5077                 :       3307 :   if (!TARGET_AVX512F)
    5078                 :            :     {
    5079                 :       3265 :       x86_emit_floatuns (operands);
    5080                 :       3265 :       DONE;
    5081                 :            :     }
    5082                 :          0 : })
    5083                 :       3281 : 
    5084                 :       3281 : ;; Load effective address instructions
    5085                 :       3297 : 
    5086                 :       3297 : (define_insn_and_split "*lea<mode>"
    5087                 :       3297 :   [(set (match_operand:SWI48 0 "register_operand" "=r")
    5088                 :       3281 :         (match_operand:SWI48 1 "address_no_seg_operand" "Ts"))]
    5089                 :            :   ""
    5090                 :    2110816 : {
    5091                 :    2110800 :   if (SImode_address_operand (operands[1], VOIDmode))
    5092                 :            :     {
    5093                 :      15969 :       gcc_assert (TARGET_64BIT);
    5094                 :         16 :       return "lea{l}\t{%E1, %k0|%k0, %E1}";
    5095                 :         16 :     }
    5096                 :            :   else 
    5097                 :          0 :     return "lea{<imodesuffix>}\t{%E1, %0|%0, %E1}";
    5098                 :          0 : }
    5099                 :   16576900 :   "reload_completed && ix86_avoid_lea_for_addr (insn, operands)"
    5100                 :       1070 :   [(const_int 0)]
    5101                 :       4458 : {
    5102                 :    3158988 :   machine_mode mode = <MODE>mode;
    5103                 :   45376258 :   rtx pat;
    5104                 :   45372870 : 
    5105                 :   34357600 :   /* ix86_avoid_lea_for_addr re-recognizes insn and may
    5106                 :   66334670 :      change operands[] array behind our back.  */
    5107                 :       3388 :   pat = PATTERN (curr_insn);
    5108                 :          0 : 
    5109                 :       3388 :   operands[0] = SET_DEST (pat);
    5110                 :       3388 :   operands[1] = SET_SRC (pat);
    5111                 :          0 : 
    5112                 :            :   /* Emit all operations in SImode for zero-extended addresses.  */
    5113                 :       3388 :   if (SImode_address_operand (operands[1], VOIDmode))
    5114                 :        123 :     mode = SImode;
    5115                 :            : 
    5116                 :       3388 :   ix86_split_lea_for_addr (curr_insn, operands, mode);
    5117                 :          0 : 
    5118                 :            :   /* Zero-extend return register to DImode for zero-extended addresses.  */
    5119                 :       2318 :   if (mode != <MODE>mode)
    5120                 :        123 :     emit_insn (gen_zero_extendsidi2
    5121                 :        123 :                (operands[0], gen_lowpart (mode, operands[0])));
    5122                 :          0 : 
    5123                 :       3388 :   DONE;
    5124                 :          0 : }
    5125                 :          0 :   [(set_attr "type" "lea")
    5126                 :          0 :    (set (attr "mode")
    5127                 :          0 :      (if_then_else
    5128                 :          0 :        (match_operand 1 "SImode_address_operand")
    5129                 :          0 :        (const_string "SI")
    5130                 :          0 :        (const_string "<MODE>")))])
    5131                 :          0 : 
    5132                 :          0 : ;; Add instructions
    5133                 :          0 : 
    5134                 :          0 : (define_expand "add<mode>3"
    5135                 :      23005 :   [(set (match_operand:SDWIM 0 "nonimmediate_operand")
    5136                 :       2318 :         (plus:SDWIM (match_operand:SDWIM 1 "nonimmediate_operand")
    5137                 :          0 :                     (match_operand:SDWIM 2 "<general_hilo_operand>")))]
    5138                 :       2318 :   ""
    5139                 :    5966700 :   "ix86_expand_binary_operator (PLUS, <MODE>mode, operands); DONE;")
    5140                 :      23005 : 
    5141                 :       2318 : (define_insn_and_split "*add<dwi>3_doubleword"
    5142                 :      23005 :   [(set (match_operand:<DWI> 0 "nonimmediate_operand" "=ro,r")
    5143                 :      23005 :         (plus:<DWI>
    5144                 :      23005 :           (match_operand:<DWI> 1 "nonimmediate_operand" "%0,0")
    5145                 :      23005 :           (match_operand:<DWI> 2 "x86_64_hilo_general_operand" "r<di>,o")))
    5146                 :            :    (clobber (reg:CC FLAGS_REG))]
    5147                 :   15018900 :   "ix86_binary_operator_ok (PLUS, <DWI>mode, operands)"
    5148                 :            :   "#"
    5149                 :    2824540 :   "reload_completed"
    5150                 :            :   [(parallel [(set (reg:CCC FLAGS_REG)
    5151                 :          0 :                    (compare:CCC
    5152                 :            :                      (plus:DWIH (match_dup 1) (match_dup 2))
    5153                 :            :                      (match_dup 1)))
    5154                 :          0 :               (set (match_dup 0)
    5155                 :          0 :                    (plus:DWIH (match_dup 1) (match_dup 2)))])
    5156                 :          0 :    (parallel [(set (match_dup 3)
    5157                 :          0 :                    (plus:DWIH
    5158                 :          0 :                      (plus:DWIH
    5159                 :          0 :                        (ltu:DWIH (reg:CC FLAGS_REG) (const_int 0))
    5160                 :    5941374 :                        (match_dup 4))
    5161                 :      14111 :                      (match_dup 5)))
    5162                 :            :               (clobber (reg:CC FLAGS_REG))])]
    5163                 :      38049 : {
    5164                 :      23938 :   split_double_mode (<DWI>mode, &operands[0], 3, &operands[0], &operands[3]);
    5165                 :    5965310 :   if (operands[2] == const0_rtx)
    5166                 :    5955480 :     {
    5167                 :        719 :       ix86_expand_binary_operator (PLUS, <MODE>mode, &operands[3]);
    5168                 :        719 :       DONE;
    5169                 :    5955480 :     }
    5170                 :    5955480 : })
    5171                 :          0 : 
    5172                 :      14111 : (define_insn "*add<mode>_1"
    5173                 :      23219 :   [(set (match_operand:SWI48 0 "nonimmediate_operand" "=rm,r,r,r")
    5174                 :      23219 :         (plus:SWI48
    5175                 :      23219 :           (match_operand:SWI48 1 "nonimmediate_operand" "%0,0,r,r")
    5176                 :      23219 :           (match_operand:SWI48 2 "x86_64_general_operand" "re,m,0,le")))
    5177                 :      23219 :    (clobber (reg:CC FLAGS_REG))]
    5178                 :   12105519 :   "ix86_binary_operator_ok (PLUS, <MODE>mode, operands)"
    5179                 :    2949131 : {
    5180                 :    2875185 :   switch (get_attr_type (insn))
    5181                 :      46415 :     {
    5182                 :      61629 :     case TYPE_LEA:
    5183                 :      61629 :       return "#";
    5184                 :      97690 : 
    5185                 :      36795 :     case TYPE_INCDEC:
    5186                 :      13576 :       gcc_assert (rtx_equal_p (operands[0], operands[1]));
    5187                 :      13576 :       if (operands[2] == const1_rtx)
    5188                 :            :         return "inc{<imodesuffix>}\t%0";
    5189                 :    1241990 :       else
    5190                 :    1241990 :         {
    5191                 :    1242867 :           gcc_assert (operands[2] == constm1_rtx);
    5192                 :    1241990 :           return "dec{<imodesuffix>}\t%0";
    5193                 :          0 :         }
    5194                 :          0 : 
    5195                 :    2815200 :     default:
    5196                 :          0 :       /* For most processors, ADD is faster than LEA.  This alternative
    5197                 :          0 :          was added to use ADD as much as possible.  */
    5198                 :    2838419 :       if (which_alternative == 2)
    5199                 :       6509 :         std::swap (operands[1], operands[2]);
    5200                 :          0 :         
    5201                 :    2815200 :       gcc_assert (rtx_equal_p (operands[0], operands[1]));
    5202                 :    2815200 :       if (x86_maybe_negate_const_int (&operands[2], <MODE>mode))
    5203                 :     581625 :         return "sub{<imodesuffix>}\t{%2, %0|%0, %2}";
    5204                 :            : 
    5205                 :            :       return "add{<imodesuffix>}\t{%2, %0|%0, %2}";
    5206                 :          0 :     }
    5207                 :            : }
    5208                 :            :   [(set (attr "type")
    5209                 :          0 :      (cond [(eq_attr "alternative" "3")
    5210                 :      23219 :               (const_string "lea")
    5211                 :    1298399 :             (match_operand:SWI48 2 "incdec_operand")
    5212                 :      23219 :               (const_string "incdec")
    5213                 :            :            ]
    5214                 :            :            (const_string "alu")))
    5215                 :          0 :    (set (attr "length_immediate")
    5216                 :            :       (if_then_else
    5217                 :            :         (and (eq_attr "type" "alu") (match_operand 2 "const128_operand"))
    5218                 :       9834 :         (const_string "1")
    5219                 :            :         (const_string "*")))
    5220                 :       9834 :    (set_attr "mode" "<MODE>")])
    5221                 :       9834 : 
    5222                 :       9834 : ;; It may seem that nonimmediate operand is proper one for operand 1.
    5223                 :       9834 : ;; The addsi_1 pattern allows nonimmediate operand at that place and
    5224                 :       9834 : ;; we take care in ix86_binary_operator_ok to not allow two memory
    5225                 :       9827 : ;; operands so proper swapping will be done in reload.  This allow
    5226                 :       9834 : ;; patterns constructed from addsi_1 to match.
    5227                 :       9834 : 
    5228                 :          7 : (define_insn "addsi_1_zext"
    5229                 :       9834 :   [(set (match_operand:DI 0 "register_operand" "=r,r,r")
    5230                 :          7 :         (zero_extend:DI
    5231                 :          7 :           (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,r,r")
    5232                 :          7 :                    (match_operand:SI 2 "x86_64_general_operand" "rme,0,le"))))
    5233                 :          7 :    (clobber (reg:CC FLAGS_REG))]
    5234                 :       5990 :   "TARGET_64BIT && ix86_binary_operator_ok (PLUS, SImode, operands)"
    5235                 :       5754 : {
    5236                 :       4118 :   switch (get_attr_type (insn))
    5237                 :        848 :     {
    5238                 :         18 :     case TYPE_LEA:
    5239                 :         18 :       return "#";
    5240                 :        202 : 
    5241                 :         37 :     case TYPE_INCDEC:
    5242                 :         44 :       if (operands[2] == const1_rtx)
    5243                 :        209 :         return "inc{l}\t%k0";
    5244                 :          7 :       else
    5245                 :          2 :         {
    5246                 :         14 :           gcc_assert (operands[2] == constm1_rtx);
    5247                 :          0 :           return "dec{l}\t%k0";
    5248                 :          2 :         }
    5249                 :          0 : 
    5250                 :       3257 :     default:
    5251                 :          2 :       /* For most processors, ADD is faster than LEA.  This alternative
    5252                 :          6 :          was added to use ADD as much as possible.  */
    5253                 :       3259 :       if (which_alternative == 1)
    5254                 :         16 :         std::swap (operands[1], operands[2]);
    5255                 :          8 : 
    5256                 :       3257 :       if (x86_maybe_negate_const_int (&operands[2], SImode))
    5257                 :        879 :         return "sub{l}\t{%2, %k0|%k0, %2}";
    5258                 :          6 : 
    5259                 :          6 :       return "add{l}\t{%2, %k0|%k0, %2}";
    5260                 :          6 :     }
    5261                 :          6 : }
    5262                 :          6 :   [(set (attr "type")
    5263                 :          6 :      (cond [(eq_attr "alternative" "2")
    5264                 :          6 :               (const_string "lea")
    5265                 :       4041 :             (match_operand:SI 2 "incdec_operand")
    5266                 :          0 :               (const_string "incdec")
    5267                 :          6 :            ]
    5268                 :          0 :            (const_string "alu")))
    5269                 :          0 :    (set (attr "length_immediate")
    5270                 :          0 :       (if_then_else
    5271                 :          0 :         (and (eq_attr "type" "alu") (match_operand 2 "const128_operand"))
    5272                 :          0 :         (const_string "1")
    5273                 :          0 :         (const_string "*")))
    5274                 :          6 :    (set_attr "mode" "SI")])
    5275                 :          6 : 
    5276                 :          6 : (define_insn "*addhi_1"
    5277                 :          0 :   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm,r,r,Yp")
    5278                 :          0 :         (plus:HI (match_operand:HI 1 "nonimmediate_operand" "%0,0,r,Yp")
    5279                 :          0 :                  (match_operand:HI 2 "general_operand" "rn,m,0,ln")))
    5280                 :          0 :    (clobber (reg:CC FLAGS_REG))]
    5281                 :      60260 :   "ix86_binary_operator_ok (PLUS, HImode, operands)"
    5282                 :      14995 : {
    5283                 :      25922 :   switch (get_attr_type (insn))
    5284                 :      21887 :     {
    5285                 :      45016 :     case TYPE_LEA:
    5286                 :      45016 :       return "#";
    5287                 :     135557 : 
    5288                 :      89377 :     case TYPE_INCDEC:
    5289                 :         15 :       gcc_assert (rtx_equal_p (operands[0], operands[1]));
    5290                 :         15 :       if (operands[2] == const1_rtx)
    5291                 :          0 :         return "inc{w}\t%0";
    5292                 :          0 :       else
    5293                 :          0 :         {
    5294                 :          6 :           gcc_assert (operands[2] == constm1_rtx);
    5295                 :          0 :           return "dec{w}\t%0";
    5296                 :          0 :         }
    5297                 :          0 : 
    5298                 :       4020 :     default:
    5299                 :            :       /* For most processors, ADD is faster than LEA.  This alternative
    5300                 :            :          was added to use ADD as much as possible.  */
    5301                 :       4020 :       if (which_alternative == 2)
    5302                 :          0 :         std::swap (operands[1], operands[2]);
    5303                 :            : 
    5304                 :       4020 :       gcc_assert (rtx_equal_p (operands[0], operands[1]));
    5305                 :       4020 :       if (x86_maybe_negate_const_int (&operands[2], HImode))
    5306                 :        352 :         return "sub{w}\t{%2, %0|%0, %2}";
    5307                 :          0 : 
    5308                 :            :       return "add{w}\t{%2, %0|%0, %2}";
    5309                 :            :     }
    5310                 :          0 : }
    5311                 :          0 :   [(set (attr "type")
    5312                 :          0 :      (cond [(eq_attr "alternative" "3")
    5313                 :          0 :               (const_string "lea")
    5314                 :       3070 :             (match_operand:HI 2 "incdec_operand")
    5315                 :          0 :               (const_string "incdec")
    5316                 :          0 :            ]
    5317                 :          0 :            (const_string "alu")))
    5318                 :          0 :    (set (attr "length_immediate")
    5319                 :          0 :       (if_then_else
    5320                 :          0 :         (and (eq_attr "type" "alu") (match_operand 2 "const128_operand"))
    5321                 :          0 :         (const_string "1")
    5322                 :          0 :         (const_string "*")))
    5323                 :          0 :    (set_attr "mode" "HI,HI,HI,SI")])
    5324                 :          0 : 
    5325                 :          0 : (define_insn "*addqi_1"
    5326                 :          0 :   [(set (match_operand:QI 0 "nonimmediate_operand" "=qm,q,q,r,r,Yp")
    5327                 :          0 :         (plus:QI (match_operand:QI 1 "nonimmediate_operand" "%0,0,q,0,r,Yp")
    5328                 :          0 :                  (match_operand:QI 2 "general_operand" "qn,m,0,rn,0,ln")))
    5329                 :          0 :    (clobber (reg:CC FLAGS_REG))]
    5330                 :      83263 :   "ix86_binary_operator_ok (PLUS, QImode, operands)"
    5331                 :      28226 : {
    5332                 :      34284 :   bool widen = (get_attr_mode (insn) != MODE_QI);
    5333                 :      31214 : 
    5334                 :       3070 :   switch (get_attr_type (insn))
    5335                 :         38 :     {
    5336                 :         38 :     case TYPE_LEA:
    5337                 :         76 :       return "#";
    5338                 :        140 : 
    5339                 :        170 :     case TYPE_INCDEC:
    5340                 :         30 :       gcc_assert (rtx_equal_p (operands[0], operands[1]));
    5341                 :         59 :       if (operands[2] == const1_rtx)
    5342                 :         67 :         return widen ? "inc{l}\t%k0" : "inc{b}\t%0";
    5343                 :          0 :       else
    5344                 :            :         {
    5345                 :         11 :           gcc_assert (operands[2] == constm1_rtx);
    5346                 :         22 :           return widen ? "dec{l}\t%k0" : "dec{b}\t%0";
    5347                 :          0 :         }
    5348                 :            : 
    5349                 :       3040 :     default:
    5350                 :            :       /* For most processors, ADD is faster than LEA.  These alternatives
    5351                 :          0 :          were added to use ADD as much as possible.  */
    5352                 :       3040 :       if (which_alternative == 2 || which_alternative == 4)
    5353                 :          0 :         std::swap (operands[1], operands[2]);
    5354                 :            : 
    5355                 :       3040 :       gcc_assert (rtx_equal_p (operands[0], operands[1]));
    5356                 :       3040 :       if (x86_maybe_negate_const_int (&operands[2], QImode))
    5357                 :          0 :         {
    5358                 :        285 :           if (widen)
    5359                 :            :             return "sub{l}\t{%2, %k0|%k0, %2}";
    5360                 :          0 :           else
    5361                 :        285 :             return "sub{b}\t{%2, %0|%0, %2}";
    5362                 :          0 :         }
    5363                 :       2755 :       if (widen)
    5364                 :          0 :         return "add{l}\t{%k2, %k0|%k0, %k2}";
    5365                 :          0 :       else
    5366                 :       2755 :         return "add{b}\t{%2, %0|%0, %2}";
    5367                 :          0 :     }
    5368                 :          0 : }
    5369                 :          0 :   [(set (attr "type")
    5370                 :          0 :      (cond [(eq_attr "alternative" "5")
    5371                 :          0 :               (const_string "lea")
    5372                 :          4 :             (match_operand:QI 2 "incdec_operand")
    5373                 :          0 :               (const_string "incdec")
    5374                 :            :            ]
    5375                 :            :            (const_string "alu")))
    5376                 :            :    (set (attr "length_immediate")
    5377                 :          0 :       (if_then_else
    5378                 :            :         (and (eq_attr "type" "alu") (match_operand 2 "const128_operand"))
    5379                 :            :         (const_string "1")
    5380                 :            :         (const_string "*")))
    5381                 :          0 :    (set_attr "mode" "QI,QI,QI,SI,SI,SI")
    5382                 :            :    ;; Potential partial reg stall on alternatives 3 and 4.
    5383                 :            :    (set (attr "preferred_for_speed")
    5384                 :            :      (cond [(eq_attr "alternative" "3,4")
    5385                 :            :               (symbol_ref "!TARGET_PARTIAL_REG_STALL")]
    5386                 :            :            (symbol_ref "true")))])
    5387                 :          0 : 
    5388                 :            : (define_insn "*add<mode>_1_slp"
    5389                 :            :   [(set (strict_low_part (match_operand:SWI12 0 "register_operand" "+<r>"))
    5390                 :          0 :         (plus:SWI12 (match_operand:SWI12 1 "nonimmediate_operand" "%0")
    5391                 :          0 :                     (match_operand:SWI12 2 "general_operand" "<r>mn")))
    5392                 :          0 :    (clobber (reg:CC FLAGS_REG))]
    5393                 :         62 :   "(!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
    5394                 :          0 :    /* FIXME: without this LRA can't reload this pattern, see PR82524.  */
    5395                 :        116 :    && (rtx_equal_p (operands[0], operands[1])
    5396                 :        106 :        || rtx_equal_p (operands[0], operands[2]))"
    5397                 :        110 : {
    5398                 :         22 :   switch (get_attr_type (insn))
    5399                 :         14 :     {
    5400                 :          0 :     case TYPE_INCDEC:
    5401                 :          0 :       if (operands[2] == const1_rtx)
    5402                 :        108 :         return "inc{<imodesuffix>}\t%0";
    5403                 :            :       else
    5404                 :            :         {
    5405                 :          0 :           gcc_assert (operands[2] == constm1_rtx);
    5406                 :          0 :           return "dec{<imodesuffix>}\t%0";
    5407                 :          0 :         }
    5408                 :     340513 : 
    5409                 :     340521 :     default:
    5410                 :     585709 :       if (x86_maybe_negate_const_int (&operands[2], QImode))
    5411                 :     807573 :         return "sub{<imodesuffix>}\t{%2, %0|%0, %2}";
    5412                 :     807571 : 
    5413                 :     585701 :       return "add{<imodesuffix>}\t{%2, %0|%0, %2}";
    5414                 :     221870 :     }
    5415                 :     493970 : }
    5416                 :     221870 :   [(set (attr "type")
    5417                 :     272100 :      (if_then_else (match_operand:QI 2 "incdec_operand")
    5418                 :      27647 :         (const_string "incdec")
    5419                 :      27878 :         (const_string "alu")))
    5420                 :          0 :    (set_attr "mode" "<MODE>")])
    5421                 :      27647 : 
    5422                 :      27647 : ;; Split non destructive adds if we cannot use lea.
    5423                 :      27647 : (define_split
    5424                 :      27647 :   [(set (match_operand:SWI48 0 "register_operand")
    5425                 :      27647 :         (plus:SWI48 (match_operand:SWI48 1 "register_operand")
    5426                 :      27647 :                     (match_operand:SWI48 2 "x86_64_nonmemory_operand")))
    5427                 :      27647 :    (clobber (reg:CC FLAGS_REG))]
    5428                 :   10027600 :   "reload_completed && ix86_avoid_lea_for_add (insn, operands)"
    5429                 :          7 :   [(set (match_dup 0) (match_dup 1))
    5430                 :    2978100 :    (parallel [(set (match_dup 0) (plus:SWI48 (match_dup 0) (match_dup 2)))
    5431                 :      27647 :               (clobber (reg:CC FLAGS_REG))])])
    5432                 :      27647 : 
    5433                 :            : ;; Split non destructive adds if we cannot use lea.
    5434                 :      27527 : (define_split
    5435                 :      27527 :   [(set (match_operand:DI 0 "register_operand")
    5436                 :      27527 :         (zero_extend:DI
    5437                 :            :           (plus:SI (match_operand:SI 1 "register_operand")
    5438                 :      27527 :                    (match_operand:SI 2 "x86_64_nonmemory_operand"))))
    5439                 :          0 :    (clobber (reg:CC FLAGS_REG))]
    5440                 :       4249 :   "TARGET_64BIT
    5441                 :       4249 :    && reload_completed && ix86_avoid_lea_for_add (insn, operands)"
    5442                 :         12 :   [(set (match_dup 3) (match_dup 1))
    5443                 :       3538 :    (parallel [(set (match_dup 0)
    5444                 :            :                    (zero_extend:DI (plus:SI (match_dup 3) (match_dup 2))))
    5445                 :          0 :               (clobber (reg:CC FLAGS_REG))])]
    5446                 :          0 :   "operands[3] = gen_lowpart (SImode, operands[0]);")
    5447                 :            : 
    5448                 :          0 : ;; Convert add to the lea pattern to avoid flags dependency.
    5449                 :          0 : (define_split
    5450                 :          0 :   [(set (match_operand:SWI 0 "register_operand")
    5451                 :          0 :         (plus:SWI (match_operand:SWI 1 "register_operand")
    5452                 :          0 :                   (match_operand:SWI 2 "<nonmemory_operand>")))
    5453                 :          0 :    (clobber (reg:CC FLAGS_REG))]
    5454                 :   10060800 :   "reload_completed && ix86_lea_for_add_ok (insn, operands)" 
    5455                 :    4748650 :   [(set (match_dup 0)
    5456                 :     337073 :         (plus:<LEAMODE> (match_dup 1) (match_dup 2)))]
    5457                 :          0 : {
    5458                 :    1177059 :   if (<MODE>mode != <LEAMODE>mode)
    5459                 :      87379 :     {
    5460                 :     110437 :       operands[0] = gen_lowpart (<LEAMODE>mode, operands[0]);
    5461                 :      40117 :       operands[1] = gen_lowpart (<LEAMODE>mode, operands[1]);
    5462                 :      38224 :       operands[2] = gen_lowpart (<LEAMODE>mode, operands[2]);
    5463                 :      78176 :     }
    5464                 :     146277 : })
    5465                 :     146277 : 
    5466                 :     146277 : ;; Convert add to the lea pattern to avoid flags dependency.
    5467                 :     146277 : (define_split
    5468                 :     146277 :   [(set (match_operand:DI 0 "register_operand")
    5469                 :    1089680 :         (zero_extend:DI
    5470                 :    1090069 :           (plus:SI (match_operand:SI 1 "register_operand")
    5471                 :    1090069 :                    (match_operand:SI 2 "x86_64_nonmemory_operand"))))
    5472                 :    1089680 :    (clobber (reg:CC FLAGS_REG))]
    5473                 :    1093922 :   "TARGET_64BIT && reload_completed && ix86_lea_for_add_ok (insn, operands)"
    5474                 :       3994 :   [(set (match_dup 0)
    5475                 :       7574 :         (zero_extend:DI (plus:SI (match_dup 1) (match_dup 2))))])
    5476                 :            : 
    5477                 :    1089680 : (define_insn "*add<mode>_2"
    5478                 :    1089680 :   [(set (reg FLAGS_REG)
    5479                 :    1097010 :         (compare
    5480                 :       7326 :           (plus:SWI
    5481                 :       7326 :             (match_operand:SWI 1 "nonimmediate_operand" "%0,0,<r>")
    5482                 :          0 :             (match_operand:SWI 2 "<general_operand>" "<r><i>,m,0"))
    5483                 :       7326 :           (const_int 0)))
    5484                 :          0 :    (set (match_operand:SWI 0 "nonimmediate_operand" "=<r>m,<r>,<r>")
    5485                 :    1082607 :         (plus:SWI (match_dup 1) (match_dup 2)))]
    5486                 :        175 :   "ix86_match_ccmode (insn, CCGOCmode)
    5487                 :    1119546 :    && ix86_binary_operator_ok (PLUS, <MODE>mode, operands)"
    5488                 :    1116046 : {
    5489                 :    1114408 :   switch (get_attr_type (insn))
    5490                 :    1082608 :     {
    5491                 :    1123562 :     case TYPE_INCDEC:
    5492                 :      77118 :       if (operands[2] == const1_rtx)
    5493                 :    1082795 :         return "inc{<imodesuffix>}\t%0";
    5494                 :        435 :       else
    5495                 :        435 :         {
    5496                 :       1028 :           gcc_assert (operands[2] == constm1_rtx);
    5497                 :        345 :           return "dec{<imodesuffix>}\t%0";
    5498                 :        345 :         }
    5499                 :        345 : 
    5500                 :      30177 :     default:
    5501                 :      29935 :       if (which_alternative == 2)
    5502                 :         25 :         std::swap (operands[1], operands[2]);
    5503                 :            :         
    5504                 :      29838 :       gcc_assert (rtx_equal_p (operands[0], operands[1]));
    5505                 :      30086 :       if (x86_maybe_negate_const_int (&operands[2], <MODE>mode))
    5506                 :      16151 :         return "sub{<imodesuffix>}\t{%2, %0|%0, %2}";
    5507                 :        248 : 
    5508                 :          0 :       return "add{<imodesuffix>}\t{%2, %0|%0, %2}";
    5509                 :          0 :     }
    5510                 :          0 : }
    5511                 :          0 :   [(set (attr "type")
    5512                 :        522 :      (if_then_else (match_operand:SWI 2 "incdec_operand")
    5513                 :            :         (const_string "incdec")
    5514                 :      31265 :         (const_string "alu")))
    5515                 :            :    (set (attr "length_immediate")
    5516                 :            :       (if_then_else
    5517                 :        522 :         (and (eq_attr "type" "alu") (match_operand 2 "const128_operand"))
    5518                 :        522 :         (const_string "1")
    5519                 :        522 :         (const_string "*")))
    5520                 :        522 :    (set_attr "mode" "<MODE>")])
    5521                 :        522 : 
    5522                 :        522 : ;; See comment for addsi_1_zext why we do use nonimmediate_operand
    5523                 :        522 : (define_insn "*addsi_2_zext"
    5524                 :        522 :   [(set (reg FLAGS_REG)
    5525                 :        522 :         (compare
    5526                 :            :           (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,r")
    5527                 :            :                    (match_operand:SI 2 "x86_64_general_operand" "rme,0"))
    5528                 :            :           (const_int 0)))
    5529                 :            :    (set (match_operand:DI 0 "register_operand" "=r,r")
    5530                 :          0 :         (zero_extend:DI (plus:SI (match_dup 1) (match_dup 2))))]
    5531                 :          2 :   "TARGET_64BIT && ix86_match_ccmode (insn, CCGOCmode)
    5532                 :          0 :    && ix86_binary_operator_ok (PLUS, SImode, operands)"
    5533                 :          2 : {
    5534                 :          0 :   switch (get_attr_type (insn))
    5535                 :          0 :     {
    5536                 :          0 :     case TYPE_INCDEC:
    5537                 :          0 :       if (operands[2] == const1_rtx)
    5538                 :            :         return "inc{l}\t%k0";
    5539                 :            :       else
    5540                 :        212 :         {
    5541                 :        212 :           gcc_assert (operands[2] == constm1_rtx);
    5542                 :        212 :           return "dec{l}\t%k0";
    5543                 :        212 :         }
    5544                 :        212 : 
    5545                 :          0 :     default:
    5546                 :          0 :       if (which_alternative == 1)
    5547                 :          0 :         std::swap (operands[1], operands[2]);
    5548                 :            : 
    5549                 :          0 :       if (x86_maybe_negate_const_int (&operands[2], SImode))
    5550                 :          0 :         return "sub{l}\t{%2, %k0|%k0, %2}";
    5551                 :          0 : 
    5552                 :          0 :       return "add{l}\t{%2, %k0|%k0, %2}";
    5553                 :            :     }
    5554                 :            : }
    5555                 :            :   [(set (attr "type")
    5556                 :          0 :      (if_then_else (match_operand:SI 2 "incdec_operand")
    5557                 :            :         (const_string "incdec")
    5558                 :         33 :         (const_string "alu")))
    5559                 :            :    (set (attr "length_immediate")
    5560                 :          0 :       (if_then_else
    5561                 :            :         (and (eq_attr "type" "alu") (match_operand 2 "const128_operand"))
    5562                 :            :         (const_string "1")
    5563                 :            :         (const_string "*")))
    5564                 :          0 :    (set_attr "mode" "SI")])
    5565                 :            : 
    5566                 :            : (define_insn "*add<mode>_3"
    5567                 :            :   [(set (reg FLAGS_REG)
    5568                 :          0 :         (compare
    5569                 :            :           (neg:SWI (match_operand:SWI 2 "<general_operand>" "<g>,0"))
    5570                 :            :           (match_operand:SWI 1 "nonimmediate_operand" "%0,<r>")))
    5571                 :            :    (clobber (match_scratch:SWI 0 "=<r>,<r>"))]
    5572                 :       3624 :   "ix86_match_ccmode (insn, CCZmode)
    5573                 :       2332 :    && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
    5574                 :       7366 : {
    5575                 :       3368 :   switch (get_attr_type (insn))
    5576                 :       1129 :     {
    5577                 :       1893 :     case TYPE_INCDEC:
    5578                 :       1893 :       if (operands[2] == const1_rtx)
    5579                 :      11062 :         return "inc{<imodesuffix>}\t%0";
    5580                 :       5801 :       else
    5581                 :      18410 :         {
    5582                 :          0 :           gcc_assert (operands[2] == constm1_rtx);
    5583                 :            :           return "dec{<imodesuffix>}\t%0";
    5584                 :          0 :         }
    5585                 :            : 
    5586                 :       2239 :     default:
    5587                 :       2239 :       if (which_alternative == 1)
    5588                 :          0 :         std::swap (operands[1], operands[2]);
    5589                 :            : 
    5590                 :       2239 :       gcc_assert (rtx_equal_p (operands[0], operands[1]));
    5591                 :       2239 :       if (x86_maybe_negate_const_int (&operands[2], <MODE>mode))
    5592                 :          0 :         return "sub{<imodesuffix>}\t{%2, %0|%0, %2}";
    5593                 :          0 : 
    5594                 :          0 :       return "add{<imodesuffix>}\t{%2, %0|%0, %2}";
    5595                 :          0 :     }
    5596                 :            : }
    5597                 :            :   [(set (attr "type")
    5598                 :            :      (if_then_else (match_operand:SWI 2 "incdec_operand")
    5599                 :          0 :         (const_string "incdec")
    5600                 :       2206 :         (const_string "alu")))
    5601                 :            :    (set (attr "length_immediate")
    5602                 :            :       (if_then_else
    5603                 :          0 :         (and (eq_attr "type" "alu") (match_operand 2 "const128_operand"))
    5604                 :            :         (const_string "1")
    5605                 :            :         (const_string "*")))
    5606                 :            :    (set_attr "mode" "<MODE>")])
    5607                 :          0 : 
    5608                 :            : ;; See comment for addsi_1_zext why we do use nonimmediate_operand
    5609                 :            : (define_insn "*addsi_3_zext"
    5610                 :            :   [(set (reg FLAGS_REG)
    5611                 :          0 :         (compare
    5612                 :            :           (neg:SI (match_operand:SI 2 "x86_64_general_operand" "rme,0"))
    5613                 :            :           (match_operand:SI 1 "nonimmediate_operand" "%0,r")))
    5614                 :            :    (set (match_operand:DI 0 "register_operand" "=r,r")
    5615                 :            :         (zero_extend:DI (plus:SI (match_dup 1) (match_dup 2))))]
    5616                 :          0 :   "TARGET_64BIT && ix86_match_ccmode (insn, CCZmode)
    5617                 :          0 :    && ix86_binary_operator_ok (PLUS, SImode, operands)"
    5618                 :          0 : {
    5619                 :          0 :   switch (get_attr_type (insn))
    5620                 :          0 :     {
    5621                 :          0 :     case TYPE_INCDEC:
    5622                 :          0 :       if (operands[2] == const1_rtx)
    5623                 :            :         return "inc{l}\t%k0";
    5624                 :            :       else
    5625                 :       3468 :         {
    5626                 :       3468 :           gcc_assert (operands[2] == constm1_rtx);
    5627                 :            :           return "dec{l}\t%k0";
    5628                 :       3204 :         }
    5629                 :       3204 : 
    5630                 :          0 :     default:
    5631                 :       3204 :       if (which_alternative == 1)
    5632                 :       3204 :         std::swap (operands[1], operands[2]);
    5633                 :       2030 : 
    5634                 :          0 :       if (x86_maybe_negate_const_int (&operands[2], SImode))
    5635                 :       2030 :         return "sub{l}\t{%2, %k0|%k0, %2}";
    5636                 :       2030 : 
    5637                 :       2030 :       return "add{l}\t{%2, %k0|%k0, %2}";
    5638                 :       2030 :     }
    5639                 :       2030 : }
    5640                 :       2030 :   [(set (attr "type")
    5641                 :       2030 :      (if_then_else (match_operand:SI 2 "incdec_operand")
    5642                 :            :         (const_string "incdec")
    5643                 :       6838 :         (const_string "alu")))
    5644                 :       2030 :    (set (attr "length_immediate")
    5645                 :            :       (if_then_else
    5646                 :          0 :         (and (eq_attr "type" "alu") (match_operand 2 "const128_operand"))
    5647                 :          0 :         (const_string "1")
    5648                 :            :         (const_string "*")))
    5649                 :          0 :    (set_attr "mode" "SI")])
    5650                 :          0 : 
    5651                 :          0 : ; For comparisons against 1, -1 and 128, we may generate better code
    5652                 :            : ; by converting cmp to add, inc or dec as done by peephole2.  This pattern
    5653                 :            : ; is matched then.  We can't accept general immediate, because for
    5654                 :            : ; case of overflows,  the result is messed up.
    5655                 :          0 : ; Also carry flag is reversed compared to cmp, so this conversion is valid
    5656                 :            : ; only for comparisons not depending on it.
    5657                 :            : 
    5658                 :            : (define_insn "*adddi_4"
    5659                 :          0 :   [(set (reg FLAGS_REG)
    5660                 :            :         (compare
    5661                 :            :           (match_operand:DI 1 "nonimmediate_operand" "0")
    5662                 :            :           (match_operand:DI 2 "x86_64_immediate_operand" "e")))
    5663                 :          0 :    (clobber (match_scratch:DI 0 "=rm"))]
    5664                 :         14 :   "TARGET_64BIT
    5665                 :       5060 :    && ix86_match_ccmode (insn, CCGCmode)"
    5666                 :      89630 : {
    5667                 :       4808 :   switch (get_attr_type (insn))
    5668                 :          0 :     {
    5669                 :       1951 :     case TYPE_INCDEC:
    5670                 :       1951 :       if (operands[2] == constm1_rtx)
    5671                 :      62593 :         return "inc{q}\t%0";
    5672                 :      11500 :       else
    5673                 :      63370 :         {
    5674                 :        751 :           gcc_assert (operands[2] == const1_rtx);
    5675                 :          0 :           return "dec{q}\t%0";
    5676                 :            :         }
    5677                 :            : 
    5678                 :       3634 :     default:
    5679                 :       3634 :       if (x86_maybe_negate_const_int (&operands[2], DImode))
    5680                 :       1485 :         return "add{q}\t{%2, %0|%0, %2}";
    5681                 :          0 : 
    5682                 :            :       return "sub{q}\t{%2, %0|%0, %2}";
    5683                 :            :     }
    5684                 :          0 : }
    5685                 :          0 :   [(set (attr "type")
    5686                 :          0 :      (if_then_else (match_operand:DI 2 "incdec_operand")
    5687                 :            :         (const_string "incdec")
    5688                 :        649 :         (const_string "alu")))
    5689                 :            :    (set (attr "length_immediate")
    5690                 :          0 :       (if_then_else
    5691                 :            :         (and (eq_attr "type" "alu") (match_operand 2 "const128_operand"))
    5692                 :            :         (const_string "1")
    5693                 :            :         (const_string "*")))
    5694                 :          0 :    (set_attr "mode" "DI")])
    5695                 :            : 
    5696                 :            : ; For comparisons against 1, -1 and 128, we may generate better code
    5697                 :            : ; by converting cmp to add, inc or dec as done by peephole2.  This pattern
    5698                 :          0 : ; is matched then.  We can't accept general immediate, because for
    5699                 :            : ; case of overflows,  the result is messed up.
    5700                 :            : ; Also carry flag is reversed compared to cmp, so this conversion is valid
    5701                 :            : ; only for comparisons not depending on it.
    5702                 :          0 : 
    5703                 :            : (define_insn "*add<mode>_4"
    5704                 :            :   [(set (reg FLAGS_REG)
    5705                 :            :         (compare
    5706                 :            :           (match_operand:SWI124 1 "nonimmediate_operand" "0")
    5707                 :            :           (match_operand:SWI124 2 "const_int_operand" "n")))
    5708                 :          0 :    (clobber (match_scratch:SWI124 0 "=<r>m"))]
    5709                 :       4237 :   "ix86_match_ccmode (insn, CCGCmode)"
    5710                 :     138516 : {
    5711                 :       3943 :   switch (get_attr_type (insn))
    5712                 :          0 :     {
    5713                 :       5469 :     case TYPE_INCDEC:
    5714                 :       5469 :       if (operands[2] == constm1_rtx)
    5715                 :      76057 :         return "inc{<imodesuffix>}\t%0";
    5716                 :      11675 :       else
    5717                 :      79569 :         {
    5718                 :    1764678 :           gcc_assert (operands[2] == const1_rtx);
    5719                 :     252484 :           return "dec{<imodesuffix>}\t%0";
    5720                 :    1510720 :         }
    5721                 :    1510720 : 
    5722                 :     253909 :     default:
    5723                 :     253909 :       if (x86_maybe_negate_const_int (&operands[2], <MODE>mode))
    5724                 :      25466 :         return "add{<imodesuffix>}\t{%2, %0|%0, %2}";
    5725                 :      24881 : 
    5726                 :     251923 :       return "sub{<imodesuffix>}\t{%2, %0|%0, %2}";
    5727                 :     270746 :     }
    5728                 :      18823 : }
    5729                 :     251923 :   [(set (attr "type")
    5730                 :     270367 :      (if_then_else (match_operand:<MODE> 2 "incdec_operand")
    5731                 :          0 :         (const_string "incdec")
    5732                 :       8501 :         (const_string "alu")))
    5733                 :        865 :    (set (attr "length_immediate")
    5734                 :       2595 :       (if_then_else
    5735                 :         31 :         (and (eq_attr "type" "alu") (match_operand 2 "const128_operand"))
    5736                 :            :         (const_string "1")
    5737                 :          0 :         (const_string "*")))
    5738                 :            :    (set_attr "mode" "<MODE>")])
    5739                 :            : 
    5740                 :            : (define_insn "*add<mode>_5"
    5741                 :            :   [(set (reg FLAGS_REG)
    5742                 :            :         (compare
    5743                 :          0 :           (plus:SWI
    5744                 :            :             (match_operand:SWI 1 "nonimmediate_operand" "%0,<r>")
    5745                 :            :             (match_operand:SWI 2 "<general_operand>" "<g>,0"))
    5746                 :          0 :           (const_int 0)))
    5747                 :          0 :    (clobber (match_scratch:SWI 0 "=<r>,<r>"))]
    5748                 :         31 :   "ix86_match_ccmode (insn, CCGOCmode)
    5749                 :       2133 :    && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
    5750                 :        458 : {
    5751                 :        772 :   switch (get_attr_type (insn))
    5752                 :        314 :     {
    5753                 :         39 :     case TYPE_INCDEC:
    5754                 :         41 :       if (operands[2] == const1_rtx)
    5755                 :          0 :         return "inc{<imodesuffix>}\t%0";
    5756                 :       2100 :       else
    5757                 :       2100 :         {
    5758                 :          0 :           gcc_assert (operands[2] == constm1_rtx);
    5759                 :          0 :           return "dec{<imodesuffix>}\t%0";
    5760                 :          0 :         }
    5761                 :            : 
    5762                 :        458 :     default:
    5763                 :        458 :       if (which_alternative == 1)
    5764                 :          0 :         std::swap (operands[1], operands[2]);
    5765                 :            : 
    5766                 :        458 :       gcc_assert (rtx_equal_p (operands[0], operands[1]));
    5767                 :        458 :       if (x86_maybe_negate_const_int (&operands[2], <MODE>mode))
    5768                 :        355 :         return "sub{<imodesuffix>}\t{%2, %0|%0, %2}";
    5769                 :          0 : 
    5770                 :          0 :       return "add{<imodesuffix>}\t{%2, %0|%0, %2}";
    5771                 :          0 :     }
    5772                 :          0 : }
    5773                 :          0 :   [(set (attr "type")
    5774                 :          0 :      (if_then_else (match_operand:SWI 2 "incdec_operand")
    5775                 :          0 :         (const_string "incdec")
    5776                 :        458 :         (const_string "alu")))
    5777                 :          0 :    (set (attr "length_immediate")
    5778                 :          0 :       (if_then_else
    5779                 :            :         (and (eq_attr "type" "alu") (match_operand 2 "const128_operand"))
    5780                 :            :         (const_string "1")
    5781                 :            :         (const_string "*")))
    5782                 :            :    (set_attr "mode" "<MODE>")])
    5783                 :            : 
    5784                 :          0 : (define_insn "addqi_ext_1"
    5785                 :            :   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q,Q")
    5786                 :            :                          (const_int 8)
    5787                 :          0 :                          (const_int 8))
    5788                 :          0 :         (subreg:SI
    5789                 :          0 :           (plus:QI
    5790                 :            :             (subreg:QI
    5791                 :            :               (zero_extract:SI (match_operand 1 "ext_register_operand" "0,0")
    5792                 :            :                                (const_int 8)
    5793                 :          0 :                                (const_int 8)) 0)
    5794                 :            :             (match_operand:QI 2 "general_operand" "QnBc,m")) 0))
    5795                 :            :    (clobber (reg:CC FLAGS_REG))]
    5796                 :            :   "/* FIXME: without this LRA can't reload this pattern, see PR82524.  */
    5797                 :         22 :    rtx_equal_p (operands[0], operands[1])"
    5798                 :          2 : {
    5799                 :          6 :   switch (get_attr_type (insn))
    5800                 :          4 :     {
    5801                 :          2 :     case TYPE_INCDEC:
    5802                 :         25 :       if (operands[2] == const1_rtx)
    5803                 :         24 :         return "inc{b}\t%h0";
    5804                 :         25 :       else
    5805                 :            :         {
    5806                 :          0 :           gcc_assert (operands[2] == constm1_rtx);
    5807                 :            :           return "dec{b}\t%h0";
    5808                 :          0 :         }
    5809                 :            : 
    5810                 :            :     default:
    5811                 :            :       return "add{b}\t{%2, %h0|%h0, %2}";
    5812                 :          0 :     }
    5813                 :            : }
    5814                 :            :   [(set_attr "isa" "*,nox64")
    5815                 :            :    (set (attr "type")
    5816                 :            :      (if_then_else (match_operand:QI 2 "incdec_operand")
    5817                 :          0 :         (const_string "incdec")
    5818                 :          0 :         (const_string "alu")))
    5819                 :            :    (set_attr "mode" "QI")])
    5820                 :            : 
    5821                 :          0 : (define_insn "*addqi_ext_2"
    5822                 :          0 :   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
    5823                 :          0 :                          (const_int 8)
    5824                 :          0 :                          (const_int 8))
    5825                 :          0 :         (subreg:SI
    5826                 :          0 :           (plus:QI
    5827                 :            :             (subreg:QI
    5828                 :            :               (zero_extract:SI (match_operand 1 "ext_register_operand" "%0")
    5829                 :            :                                (const_int 8)
    5830                 :          0 :                                (const_int 8)) 0)
    5831                 :            :             (subreg:QI
    5832                 :            :               (zero_extract:SI (match_operand 2 "ext_register_operand" "Q")
    5833                 :            :                                (const_int 8)
    5834                 :            :                                (const_int 8)) 0)) 0))
    5835                 :            :   (clobber (reg:CC FLAGS_REG))]
    5836                 :          0 :   "/* FIXME: without this LRA can't reload this pattern, see PR82524.  */
    5837                 :          1 :    rtx_equal_p (operands[0], operands[1])
    5838                 :          0 :    || rtx_equal_p (operands[0], operands[2])"
    5839                 :         25 :   "add{b}\t{%h2, %h0|%h0, %h2}"
    5840                 :          0 :   [(set_attr "type" "alu")
    5841                 :          0 :    (set_attr "mode" "QI")])
    5842                 :       1782 : 
    5843                 :       1790 : ;; Like DWI, but use POImode instead of OImode.
    5844                 :       1790 : (define_mode_attr DPWI [(QI "HI") (HI "SI") (SI "DI") (DI "TI") (TI "POI")])
    5845                 :            : 
    5846                 :       1786 : ;; Add with jump on overflow.
    5847                 :       1786 : (define_expand "addv<mode>4"
    5848                 :       1786 :   [(parallel [(set (reg:CCO FLAGS_REG)
    5849                 :       3571 :                    (eq:CCO
    5850                 :            :                      (plus:<DPWI>
    5851                 :            :                        (sign_extend:<DPWI>
    5852                 :          0 :                          (match_operand:SWIDWI 1 "nonimmediate_operand"))
    5853                 :            :                        (match_dup 4))
    5854                 :            :                          (sign_extend:<DPWI>
    5855                 :            :                            (plus:SWIDWI (match_dup 1)
    5856                 :          0 :                              (match_operand:SWIDWI 2
    5857                 :            :                                "<general_hilo_operand>")))))
    5858                 :            :               (set (match_operand:SWIDWI 0 "register_operand")
    5859                 :            :                    (plus:SWIDWI (match_dup 1) (match_dup 2)))])
    5860                 :            :    (set (pc) (if_then_else
    5861                 :            :                (eq (reg:CCO FLAGS_REG) (const_int 0))
    5862                 :          0 :                (label_ref (match_operand 3))
    5863                 :            :                (pc)))]
    5864                 :            :   ""
    5865                 :       7550 : {
    5866                 :        522 :   ix86_fixup_binary_operands_no_copy (PLUS, <MODE>mode, operands);
    5867                 :       7550 :   if (CONST_SCALAR_INT_P (operands[2]))
    5868                 :       1603 :     operands[4] = operands[2];
    5869                 :          0 :   else
    5870                 :       5947 :     operands[4] = gen_rtx_SIGN_EXTEND (<DPWI>mode, operands[2]);
    5871                 :          0 : })
    5872                 :          0 : 
    5873                 :          0 : (define_insn "*addv<mode>4"
    5874                 :       7550 :   [(set (reg:CCO FLAGS_REG)
    5875                 :       7550 :         (eq:CCO (plus:<DWI>
    5876                 :       7550 :                    (sign_extend:<DWI>
    5877                 :       7550 :                       (match_operand:SWI 1 "nonimmediate_operand" "%0,0"))
    5878                 :       7550 :                    (sign_extend:<DWI>
    5879                 :       7550 :                       (match_operand:SWI 2 "<general_sext_operand>" "<r>We,m")))
    5880                 :       7550 :                 (sign_extend:<DWI>
    5881                 :       7550 :                    (plus:SWI (match_dup 1) (match_dup 2)))))
    5882                 :       7550 :    (set (match_operand:SWI 0 "nonimmediate_operand" "=<r>m,<r>")
    5883                 :       7550 :         (plus:SWI (match_dup 1) (match_dup 2)))]
    5884                 :      10138 :   "ix86_binary_operator_ok (PLUS, <MODE>mode, operands)"
    5885                 :       7790 :   "add{<imodesuffix>}\t{%2, %0|%0, %2}"
    5886                 :          0 :   [(set_attr "type" "alu")
    5887                 :          0 :    (set_attr "mode" "<MODE>")])
    5888                 :       7387 : 
    5889                 :       7387 : (define_insn "addv<mode>4_1"
    5890                 :       9546 :   [(set (reg:CCO FLAGS_REG)
    5891                 :          0 :         (eq:CCO (plus:<DWI>
    5892                 :          0 :                    (sign_extend:<DWI>
    5893                 :          0 :                       (match_operand:SWI 1 "nonimmediate_operand" "0"))
    5894                 :          0 :                    (match_operand:<DWI> 3 "const_int_operand" "i"))
    5895                 :          0 :                 (sign_extend:<DWI>
    5896                 :          0 :                    (plus:SWI
    5897                 :          0 :                      (match_dup 1)
    5898                 :          0 :                      (match_operand:SWI 2 "x86_64_immediate_operand" "<i>")))))
    5899                 :          0 :    (set (match_operand:SWI 0 "nonimmediate_operand" "=<r>m")
    5900                 :          0 :         (plus:SWI (match_dup 1) (match_dup 2)))]
    5901                 :       2056 :   "ix86_binary_operator_ok (PLUS, <MODE>mode, operands)
    5902                 :      11797 :    && CONST_INT_P (operands[2])
    5903                 :       2056 :    && INTVAL (operands[2]) == INTVAL (operands[3])"
    5904                 :        126 :   "add{<imodesuffix>}\t{%2, %0|%0, %2}"
    5905                 :          0 :   [(set_attr "type" "alu")
    5906                 :          0 :    (set_attr "mode" "<MODE>")
    5907                 :      17894 :    (set (attr "length_immediate")
    5908                 :      20085 :         (cond [(match_test "IN_RANGE (INTVAL (operands[2]), -128, 127)")
    5909                 :      14793 :                   (const_string "1")
    5910                 :      17455 :                (match_test "<MODE_SIZE> == 8")
    5911                 :       7550 :                   (const_string "4")]
    5912                 :       7550 :               (const_string "<MODE_SIZE>")))])
    5913                 :       7550 : 
    5914                 :            : ;; Quad word integer modes as mode attribute.
    5915                 :          0 : (define_mode_attr QPWI [(SI "TI") (DI "POI")])
    5916                 :            : 
    5917                 :            : (define_insn_and_split "*addv<dwi>4_doubleword"
    5918                 :       7028 :   [(set (reg:CCO FLAGS_REG)
    5919                 :          0 :         (eq:CCO
    5920                 :            :           (plus:<QPWI>
    5921                 :          0 :             (sign_extend:<QPWI>
    5922                 :          0 :               (match_operand:<DWI> 1 "nonimmediate_operand" "%0,0"))
    5923                 :       7028 :             (sign_extend:<QPWI>
    5924                 :       7028 :               (match_operand:<DWI> 2 "nonimmediate_operand" "r,o")))
    5925                 :       7028 :           (sign_extend:<QPWI>
    5926                 :       7028 :             (plus:<DWI> (match_dup 1) (match_dup 2)))))
    5927                 :       7028 :    (set (match_operand:<DWI> 0 "nonimmediate_operand" "=ro,r")
    5928                 :          0 :         (plus:<DWI> (match_dup 1) (match_dup 2)))]
    5929                 :       1553 :   "ix86_binary_operator_ok (PLUS, <DWI>mode, operands)"
    5930                 :          0 :   "#"
    5931                 :       7028 :   "reload_completed"
    5932                 :          0 :   [(parallel [(set (reg:CCC FLAGS_REG)
    5933                 :          0 :                    (compare:CCC
    5934                 :          0 :                      (plus:DWIH (match_dup 1) (match_dup 2))
    5935                 :          0 :                      (match_dup 1)))
    5936                 :          0 :               (set (match_dup 0)
    5937                 :          0 :                    (plus:DWIH (match_dup 1) (match_dup 2)))])
    5938                 :          0 :    (parallel [(set (reg:CCO FLAGS_REG)
    5939                 :          0 :                    (eq:CCO
    5940                 :          0 :                      (plus:<DWI>
    5941                 :          0 :                        (plus:<DWI>
    5942                 :          0 :                          (ltu:<DWI> (reg:CC FLAGS_REG) (const_int 0))
    5943                 :          0 :                          (sign_extend:<DWI> (match_dup 4)))
    5944                 :          0 :                        (sign_extend:<DWI> (match_dup 5)))
    5945                 :          0 :                      (sign_extend:<DWI>
    5946                 :          0 :                        (plus:DWIH
    5947                 :          0 :                          (plus:DWIH
    5948                 :          0 :                            (ltu:DWIH (reg:CC FLAGS_REG) (const_int 0))
    5949                 :          0 :                            (match_dup 4))
    5950                 :          0 :                          (match_dup 5)))))
    5951                 :          0 :               (set (match_dup 3)
    5952                 :          0 :                    (plus:DWIH
    5953                 :          0 :                      (plus:DWIH
    5954                 :          0 :                        (ltu:DWIH (reg:CC FLAGS_REG) (const_int 0))
    5955                 :          0 :                        (match_dup 4))
    5956                 :          0 :                      (match_dup 5)))])]
    5957                 :        897 : {
    5958                 :        897 :   split_double_mode (<DWI>mode, &operands[0], 3, &operands[0], &operands[3]);
    5959                 :          0 : })
    5960                 :          0 : 
    5961                 :          0 : (define_insn_and_split "*addv<dwi>4_doubleword_1"
    5962                 :        897 :   [(set (reg:CCO FLAGS_REG)
    5963                 :        897 :         (eq:CCO
    5964                 :        897 :           (plus:<QPWI>
    5965                 :        897 :             (sign_extend:<QPWI>
    5966                 :        897 :               (match_operand:<DWI> 1 "nonimmediate_operand" "%0"))
    5967                 :        897 :             (match_operand:<QPWI> 3 "const_scalar_int_operand" ""))
    5968                 :        897 :           (sign_extend:<QPWI>
    5969                 :        897 :             (plus:<DWI>
    5970                 :        897 :               (match_dup 1)
    5971                 :        897 :               (match_operand:<DWI> 2 "x86_64_hilo_general_operand" "<di>")))))
    5972                 :        897 :    (set (match_operand:<DWI> 0 "nonimmediate_operand" "=ro")
    5973                 :        897 :         (plus:<DWI> (match_dup 1) (match_dup 2)))]
    5974                 :       3604 :   "ix86_binary_operator_ok (PLUS, <DWI>mode, operands)
    5975                 :       2707 :    && CONST_SCALAR_INT_P (operands[2])
    5976                 :        459 :    && rtx_equal_p (operands[2], operands[3])"
    5977                 :          0 :   "#"
    5978                 :          0 :   "reload_completed"
    5979                 :          0 :   [(parallel [(set (reg:CCC FLAGS_REG)
    5980                 :          0 :                    (compare:CCC
    5981                 :          0 :                      (plus:DWIH (match_dup 1) (match_dup 2))
    5982                 :          0 :                      (match_dup 1)))
    5983                 :          0 :               (set (match_dup 0)
    5984                 :          0 :                    (plus:DWIH (match_dup 1) (match_dup 2)))])
    5985                 :          0 :    (parallel [(set (reg:CCO FLAGS_REG)
    5986                 :          0 :                    (eq:CCO
    5987                 :        897 :                      (plus:<DWI>
    5988                 :          0 :                        (plus:<DWI>
    5989                 :          0 :                          (ltu:<DWI> (reg:CC FLAGS_REG) (const_int 0))
    5990                 :          0 :                          (sign_extend:<DWI> (match_dup 4)))
    5991                 :          0 :                        (match_dup 5))
    5992                 :          0 :                      (sign_extend:<DWI>
    5993                 :          0 :                        (plus:DWIH
    5994                 :          0 :                          (plus:DWIH
    5995                 :          0 :                            (ltu:DWIH (reg:CC FLAGS_REG) (const_int 0))
    5996                 :          0 :                            (match_dup 4))
    5997                 :          0 :                          (match_dup 5)))))
    5998                 :          0 :               (set (match_dup 3)
    5999                 :          0 :                    (plus:DWIH
    6000                 :          0 :                      (plus:DWIH
    6001                 :          0 :                        (ltu:DWIH (reg:CC FLAGS_REG) (const_int 0))
    6002                 :          0 :                        (match_dup 4))
    6003                 :          0 :                      (match_dup 5)))])]
    6004                 :        301 : {
    6005                 :        301 :   split_double_mode (<DWI>mode, &operands[0], 3, &operands[0], &operands[3]);
    6006                 :        301 :   if (operands[2] == const0_rtx)
    6007                 :          0 :     {
    6008                 :          2 :       emit_insn (gen_addv<mode>4_1 (operands[3], operands[4], operands[5],
    6009                 :          0 :                                     operands[5]));
    6010                 :          2 :       DONE;
    6011                 :          0 :     }
    6012                 :          0 : })
    6013                 :          0 : 
    6014                 :          0 : (define_insn "*addv<mode>4_overflow_1"
    6015                 :        299 :   [(set (reg:CCO FLAGS_REG)
    6016                 :        299 :         (eq:CCO
    6017                 :        299 :           (plus:<DWI>
    6018                 :        299 :             (plus:<DWI>
    6019                 :        299 :               (match_operator:<DWI> 4 "ix86_carry_flag_operator"
    6020                 :        897 :                 [(match_operand 3 "flags_reg_operand") (const_int 0)])
    6021                 :        897 :               (sign_extend:<DWI>
    6022                 :       1196 :                 (match_operand:SWI 1 "nonimmediate_operand" "%0,0")))
    6023                 :        299 :             (sign_extend:<DWI>
    6024                 :        299 :               (match_operand:SWI 2 "<general_sext_operand>" "rWe,m")))
    6025                 :        299 :           (sign_extend:<DWI>
    6026                 :        299 :             (plus:SWI
    6027                 :        299 :               (plus:SWI
    6028                 :        897 :                 (match_operator:SWI 5 "ix86_carry_flag_operator"
    6029                 :          0 :                   [(match_dup 3) (const_int 0)])
    6030                 :        897 :                 (match_dup 1))
    6031                 :        897 :               (match_dup 2)))))
    6032                 :        897 :    (set (match_operand:SWI 0 "nonimmediate_operand" "=rm,r")
    6033                 :        897 :         (plus:SWI
    6034                 :        897 :           (plus:SWI
    6035                 :        897 :             (match_op_dup 5 [(match_dup 3) (const_int 0)])
    6036                 :        897 :             (match_dup 1))
    6037                 :        897 :           (match_dup 2)))]
    6038                 :       1159 :   "ix86_binary_operator_ok (PLUS, <MODE>mode, operands)"
    6039                 :        897 :   "adc{<imodesuffix>}\t{%2, %0|%0, %2}"
    6040                 :        299 :   [(set_attr "type" "alu")
    6041                 :          0 :    (set_attr "mode" "<MODE>")])
    6042                 :       1159 : 
    6043                 :       1159 : (define_insn "*addv<mode>4_overflow_2"
    6044                 :       2318 :   [(set (reg:CCO FLAGS_REG)
    6045                 :          0 :         (eq:CCO
    6046                 :          0 :           (plus:<DWI>
    6047                 :          0 :             (plus:<DWI>
    6048                 :          0 :               (match_operator:<DWI> 4 "ix86_carry_flag_operator"
    6049                 :          0 :                 [(match_operand 3 "flags_reg_operand") (const_int 0)])
    6050                 :          0 :               (sign_extend:<DWI>
    6051                 :          0 :                 (match_operand:SWI 1 "nonimmediate_operand" "%0")))
    6052                 :          0 :             (match_operand:<DWI> 6 "const_int_operand" ""))
    6053                 :          0 :           (sign_extend:<DWI>
    6054                 :          0 :             (plus:SWI
    6055                 :          0 :               (plus:SWI
    6056                 :          0 :                 (match_operator:SWI 5 "ix86_carry_flag_operator"
    6057                 :          0 :                   [(match_dup 3) (const_int 0)])
    6058                 :          0 :                 (match_dup 1))
    6059                 :          0 :               (match_operand:SWI 2 "x86_64_immediate_operand" "e")))))
    6060                 :          0 :    (set (match_operand:SWI 0 "nonimmediate_operand" "=rm")
    6061                 :          0 :         (plus:SWI
    6062                 :          0 :           (plus:SWI
    6063                 :          0 :             (match_op_dup 5 [(match_dup 3) (const_int 0)])
    6064                 :          0 :             (match_dup 1))
    6065                 :          0 :           (match_dup 2)))]
    6066                 :        299 :   "ix86_binary_operator_ok (PLUS, <MODE>mode, operands)
    6067                 :        299 :    && CONST_INT_P (operands[2])
    6068                 :        299 :    && INTVAL (operands[2]) == INTVAL (operands[6])"
    6069                 :          0 :   "adc{<imodesuffix>}\t{%2, %0|%0, %2}"
    6070                 :          0 :   [(set_attr "type" "alu")
    6071                 :          0 :    (set_attr "mode" "<MODE>")
    6072                 :        598 :    (set (attr "length_immediate")
    6073                 :        598 :      (if_then_else (match_test "IN_RANGE (INTVAL (operands[2]), -128, 127)")
    6074                 :       1196 :        (const_string "1")
    6075                 :          0 :        (const_string "4")))])
    6076                 :          0 : 
    6077                 :          0 : (define_expand "uaddv<mode>4"
    6078                 :          0 :   [(parallel [(set (reg:CCC FLAGS_REG)
    6079                 :        388 :                    (compare:CCC
    6080                 :        301 :                      (plus:SWIDWI
    6081                 :          0 :                        (match_operand:SWIDWI 1 "nonimmediate_operand")
    6082                 :        301 :                        (match_operand:SWIDWI 2 "<general_hilo_operand>"))
    6083                 :        301 :                      (match_dup 1)))
    6084                 :        689 :               (set (match_operand:SWIDWI 0 "register_operand")
    6085                 :        388 :                    (plus:SWIDWI (match_dup 1) (match_dup 2)))])
    6086                 :        689 :    (set (pc) (if_then_else
    6087                 :        689 :                (ltu (reg:CCC FLAGS_REG) (const_int 0))
    6088                 :        689 :                (label_ref (match_operand 3))
    6089                 :        301 :                (pc)))]
    6090                 :          0 :   ""
    6091                 :        689 :   "ix86_fixup_binary_operands_no_copy (PLUS, <MODE>mode, operands);")
    6092                 :          0 : 
    6093                 :          0 : ;; The lea patterns for modes less than 32 bits need to be matched by
    6094                 :       7813 : ;; several insns converted to real lea by splitters.
    6095                 :       7813 : 
    6096                 :       7813 : (define_insn_and_split "*lea<mode>_general_1"
    6097                 :       7813 :   [(set (match_operand:SWI12 0 "register_operand" "=r")
    6098                 :       7813 :         (plus:SWI12
    6099                 :       7813 :           (plus:SWI12 (match_operand:SWI12 1 "index_register_operand" "l")
    6100                 :       7813 :                       (match_operand:SWI12 2 "register_operand" "r"))
    6101                 :       7813 :           (match_operand:SWI12 3 "immediate_operand" "i")))]
    6102                 :        180 :   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
    6103                 :       7813 :   "#"
    6104                 :        114 :   "&& reload_completed"
    6105                 :        109 :   [(set (match_dup 0)
    6106                 :        109 :         (plus:SI
    6107                 :         75 :           (plus:SI (match_dup 1) (match_dup 2))
    6108                 :        104 :           (match_dup 3)))]
    6109                 :        213 : {
    6110                 :      49792 :   operands[0] = gen_lowpart (SImode, operands[0]);
    6111                 :      49792 :   operands[1] = gen_lowpart (SImode, operands[1]);
    6112                 :      69740 :   operands[2] = gen_lowpart (SImode, operands[2]);
    6113                 :      69740 :   operands[3] = gen_lowpart (SImode, operands[3]);
    6114                 :          0 : }
    6115                 :          8 :   [(set_attr "type" "lea")
    6116                 :       7829 :    (set_attr "mode" "SI")])
    6117                 :        109 : 
    6118                 :        109 : (define_insn_and_split "*lea<mode>_general_2"
    6119                 :        109 :   [(set (match_operand:SWI12 0 "register_operand" "=r")
    6120                 :        109 :         (plus:SWI12
    6121                 :        109 :           (mult:SWI12 (match_operand:SWI12 1 "index_register_operand" "l")
    6122                 :        109 :                       (match_operand 2 "const248_operand" "n"))
    6123                 :        109 :           (match_operand:SWI12 3 "nonmemory_operand" "ri")))]
    6124                 :        109 :   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
    6125                 :       7922 :   "#"
    6126                 :       7891 :   "&& reload_completed"
    6127                 :       7852 :   [(set (match_dup 0)
    6128                 :         39 :         (plus:SI
    6129                 :          0 :           (mult:SI (match_dup 1) (match_dup 2))
    6130                 :          0 :           (match_dup 3)))]
    6131                 :        109 : {
    6132                 :      17262 :   operands[0] = gen_lowpart (SImode, operands[0]);
    6133                 :       9728 :   operands[1] = gen_lowpart (SImode, operands[1]);
    6134                 :     450721 :   operands[3] = gen_lowpart (SImode, operands[3]);
    6135                 :     450739 : }
    6136                 :        132 :   [(set_attr "type" "lea")
    6137                 :       7557 :    (set_attr "mode" "SI")])
    6138                 :       9281 : 
    6139                 :       7687 : (define_insn_and_split "*lea<mode>_general_2b"
    6140                 :        132 :   [(set (match_operand:SWI12 0 "register_operand" "=r")
    6141                 :         75 :         (plus:SWI12
    6142                 :         57 :           (ashift:SWI12 (match_operand:SWI12 1 "index_register_operand" "l")
    6143                 :       7630 :                         (match_operand 2 "const123_operand" "n"))
    6144                 :       7500 :           (match_operand:SWI12 3 "nonmemory_operand" "ri")))]
    6145                 :       2118 :   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
    6146                 :        130 :   "#"
    6147                 :       1003 :   "&& reload_completed"
    6148                 :       1763 :   [(set (match_dup 0)
    6149                 :       1672 :         (plus:SI
    6150                 :       2276 :           (ashift:SI (match_dup 1) (match_dup 2))
    6151                 :       2416 :           (match_dup 3)))]
    6152                 :       2455 : {
    6153                 :       6580 :   operands[0] = gen_lowpart (SImode, operands[0]);
    6154                 :       1747 :   operands[1] = gen_lowpart (SImode, operands[1]);
    6155                 :       6466 :   operands[3] = gen_lowpart (SImode, operands[3]);
    6156                 :       4869 : }
    6157                 :         75 :   [(set_attr "type" "lea")
    6158                 :       4794 :    (set_attr "mode" "SI")])
    6159                 :       6541 : 
    6160                 :       2211 : (define_insn_and_split "*lea<mode>_general_3"
    6161                 :    1383872 :   [(set (match_operand:SWI12 0 "register_operand" "=r")
    6162                 :       7005 :         (plus:SWI12
    6163                 :    1384416 :           (plus:SWI12
    6164                 :       2211 :             (mult:SWI12 (match_operand:SWI12 1 "index_register_operand" "l")
    6165                 :       6930 :                         (match_operand 2 "const248_operand" "n"))
    6166                 :    1379616 :             (match_operand:SWI12 3 "register_operand" "r"))
    6167                 :    1379616 :           (match_operand:SWI12 4 "immediate_operand" "i")))]
    6168                 :         12 :   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
    6169                 :       5258 :   "#"
    6170                 :          8 :   "&& reload_completed"
    6171                 :         80 :   [(set (match_dup 0)
    6172                 :         80 :         (plus:SI
    6173                 :       1673 :           (plus:SI
    6174                 :      93967 :             (mult:SI (match_dup 1) (match_dup 2))
    6175                 :       3832 :             (match_dup 3))
    6176                 :     178719 :           (match_dup 4)))]
    6177                 :     178724 : {
    6178                 :         80 :   operands[0] = gen_lowpart (SImode, operands[0]);
    6179                 :      63077 :   operands[1] = gen_lowpart (SImode, operands[1]);
    6180                 :      46559 :   operands[3] = gen_lowpart (SImode, operands[3]);
    6181                 :       1288 :   operands[4] = gen_lowpart (SImode, operands[4]);
    6182                 :         20 : }
    6183                 :       1232 :   [(set_attr "type" "lea")
    6184                 :       1287 :    (set_attr "mode" "SI")])
    6185                 :       1292 : 
    6186                 :       1217 : (define_insn_and_split "*lea<mode>_general_3b"
    6187                 :       1292 :   [(set (match_operand:SWI12 0 "register_operand" "=r")
    6188                 :       1283 :         (plus:SWI12
    6189                 :          4 :           (plus:SWI12
    6190                 :       1283 :             (ashift:SWI12 (match_operand:SWI12 1 "index_register_operand" "l")
    6191                 :         79 :                           (match_operand 2 "const123_operand" "n"))
    6192                 :         80 :             (match_operand:SWI12 3 "register_operand" "r"))
    6193                 :         77 :           (match_operand:SWI12 4 "immediate_operand" "i")))]
    6194                 :        224 :   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
    6195                 :          8 :   "#"
    6196                 :         48 :   "&& reload_completed"
    6197                 :         46 :   [(set (match_dup 0)
    6198                 :        118 :         (plus:SI
    6199                 :         25 :           (plus:SI
    6200                 :        114 :             (ashift:SI (match_dup 1) (match_dup 2))
    6201                 :         44 :             (match_dup 3))
    6202                 :         70 :           (match_dup 4)))]
    6203                 :        731 : {
    6204                 :        846 :   operands[0] = gen_lowpart (SImode, operands[0]);
    6205                 :        115 :   operands[1] = gen_lowpart (SImode, operands[1]);
    6206                 :        772 :   operands[3] = gen_lowpart (SImode, operands[3]);
    6207                 :        841 :   operands[4] = gen_lowpart (SImode, operands[4]);
    6208                 :         69 : }
    6209                 :     129925 :   [(set_attr "type" "lea")
    6210                 :        726 :    (set_attr "mode" "SI")])
    6211                 :        875 : 
    6212                 :        124 : (define_insn_and_split "*lea<mode>_general_4"
    6213                 :        797 :   [(set (match_operand:SWI12 0 "register_operand" "=r")
    6214                 :        797 :         (any_or:SWI12
    6215                 :         71 :           (ashift:SWI12
    6216                 :        797 :             (match_operand:SWI12 1 "index_register_operand" "l")
    6217                 :        797 :             (match_operand 2 "const_0_to_3_operand" "n"))
    6218                 :        797 :           (match_operand 3 "const_int_operand" "n")))]
    6219                 :         35 :   "(!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
    6220                 :         10 :    && ((unsigned HOST_WIDE_INT) INTVAL (operands[3])
    6221                 :        289 :        < (HOST_WIDE_INT_1U << INTVAL (operands[2])))"
    6222                 :        282 :   "#"
    6223                 :          8 :   "&& reload_completed"
    6224                 :          4 :   [(set (match_dup 0)
    6225                 :        435 :         (plus:SI
    6226                 :        167 :           (mult:SI (match_dup 1) (match_dup 2))
    6227                 :        304 :           (match_dup 3)))]
    6228                 :        308 : {
    6229                 :       3051 :   operands[0] = gen_lowpart (SImode, operands[0]);
    6230                 :       3051 :   operands[1] = gen_lowpart (SImode, operands[1]);
    6231                 :         12 :   operands[2] = GEN_INT (1 << INTVAL (operands[2]));
    6232                 :          8 : }
    6233                 :    1646000 :   [(set_attr "type" "lea")
    6234                 :    1377410 :    (set_attr "mode" "SI")])
    6235                 :       3728 : 
    6236                 :       2039 : (define_insn_and_split "*lea<mode>_general_4"
    6237                 :       1719 :   [(set (match_operand:SWI48 0 "register_operand" "=r")
    6238                 :       1693 :         (any_or:SWI48
    6239                 :     156769 :           (ashift:SWI48
    6240                 :       3408 :             (match_operand:SWI48 1 "index_register_operand" "l")
    6241                 :         30 :             (match_operand 2 "const_0_to_3_operand" "n"))
    6242                 :         30 :           (match_operand 3 "const_int_operand" "n")))]
    6243                 :       1693 :   "(unsigned HOST_WIDE_INT) INTVAL (operands[3])
    6244                 :       2824 :    < (HOST_WIDE_INT_1U << INTVAL (operands[2]))"
    6245                 :       3276 :   "#"
    6246                 :       2084 :   "&& reload_completed"
    6247                 :        422 :   [(set (match_dup 0)
    6248                 :        943 :         (plus:SWI48
    6249                 :        543 :           (mult:SWI48 (match_dup 1) (match_dup 2))
    6250                 :        284 :           (match_dup 3)))]
    6251                 :       1765 :   "operands[2] = GEN_INT (1 << INTVAL (operands[2]));"
    6252                 :     174739 :   [(set_attr "type" "lea")
    6253                 :     174739 :    (set_attr "mode" "<MODE>")])
    6254                 :       1343 : 
    6255                 :   10932443 : ;; Subtract instructions
    6256                 :   10932443 : 
    6257                 :       2183 : (define_expand "sub<mode>3"
    6258                 :       5022 :   [(set (match_operand:SDWIM 0 "nonimmediate_operand")
    6259                 :       1783 :         (minus:SDWIM (match_operand:SDWIM 1 "nonimmediate_operand")
    6260                 :   10875483 :                      (match_operand:SDWIM 2 "<general_hilo_operand>")))]
    6261                 :    6174183 :   ""
    6262                 :    5024295 :   "ix86_expand_binary_operator (MINUS, <MODE>mode, operands); DONE;")
    6263                 :    4702500 : 
    6264                 :        964 : (define_insn_and_split "*sub<dwi>3_doubleword"
    6265                 :        124 :   [(set (match_operand:<DWI> 0 "nonimmediate_operand" "=ro,r")
    6266                 :   12130940 :         (minus:<DWI>
    6267                 :   12056200 :           (match_operand:<DWI> 1 "nonimmediate_operand" "0,0")
    6268                 :   12131143 :           (match_operand:<DWI> 2 "x86_64_hilo_general_operand" "r<di>,o")))
    6269                 :        943 :    (clobber (reg:CC FLAGS_REG))]
    6270                 :    1411943 :   "ix86_binary_operator_ok (MINUS, <MODE>mode, operands)"
    6271                 :      61156 :   "#"
    6272                 :      61156 :   "reload_completed"
    6273                 :         61 :   [(parallel [(set (reg:CC FLAGS_REG)
    6274                 :      61156 :                    (compare:CC (match_dup 1) (match_dup 2)))
    6275                 :  119320296 :               (set (match_dup 0)
    6276                 :      61259 :                    (minus:DWIH (match_dup 1) (match_dup 2)))])
    6277                 :         61 :    (parallel [(set (match_dup 3)
    6278                 :  119312103 :                    (minus:DWIH
    6279                 :       1460 :                      (minus:DWIH
    6280                 :       1357 :                        (match_dup 4)
    6281                 :   28110999 :                        (ltu:DWIH (reg:CC FLAGS_REG) (const_int 0)))
    6282                 :   16499799 :                      (match_dup 5)))
    6283                 :   35604499 :               (clobber (reg:CC FLAGS_REG))])]
    6284                 :          0 : {
    6285                 :       6566 :   split_double_mode (<DWI>mode, &operands[0], 3, &operands[0], &operands[3]);
    6286                 :       5167 :   if (operands[2] == const0_rtx)
    6287                 :     321542 :     {
    6288                 :     320396 :       ix86_expand_binary_operator (MINUS, <MODE>mode, &operands[3]);
    6289                 :          0 :       DONE;
    6290                 :     321542 :     }
    6291                 :     321542 : })
    6292                 :     321542 : 
    6293                 :     321542 : (define_insn "*sub<mode>_1"
    6294                 :          0 :   [(set (match_operand:SWI 0 "nonimmediate_operand" "=<r>m,<r>")
    6295                 :       1146 :         (minus:SWI
    6296                 :       5167 :           (match_operand:SWI 1 "nonimmediate_operand" "0,0")
    6297                 :       5167 :           (match_operand:SWI 2 "<general_operand>" "<r><i>,m")))
    6298                 :       5167 :    (clobber (reg:CC FLAGS_REG))]
    6299                 :    1135177 :   "ix86_binary_operator_ok (MINUS, <MODE>mode, operands)"
    6300                 :     194280 :   "sub{<imodesuffix>}\t{%2, %0|%0, %2}"
    6301                 :     140924 :   [(set_attr "type" "alu")
    6302                 :     140924 :    (set_attr "mode" "<MODE>")])
    6303                 :     327465 : 
    6304                 :     327465 : (define_insn "*subsi_1_zext"
    6305                 :     526481 :   [(set (match_operand:DI 0 "register_operand" "=r")
    6306                 :      41125 :         (zero_extend:DI
    6307                 :          0 :           (minus:SI (match_operand:SI 1 "register_operand" "0")
    6308                 :       2541 :                     (match_operand:SI 2 "x86_64_general_operand" "rme"))))
    6309                 :       2541 :    (clobber (reg:CC FLAGS_REG))]
    6310                 :       1731 :   "TARGET_64BIT && ix86_binary_operator_ok (MINUS, SImode, operands)"
    6311                 :        143 :   "sub{l}\t{%2, %k0|%k0, %2}"
    6312                 :       3919 :   [(set_attr "type" "alu")
    6313                 :       1378 :    (set_attr "mode" "SI")])
    6314                 :          0 : 
    6315                 :       2557 : (define_insn "*sub<mode>_1_slp"
    6316                 :       2557 :   [(set (strict_low_part (match_operand:SWI12 0 "register_operand" "+<r>"))
    6317                 :       7724 :         (minus:SWI12 (match_operand:SWI12 1 "register_operand" "0")
    6318                 :       2557 :                      (match_operand:SWI12 2 "general_operand" "<r>mn")))
    6319                 :       2557 :    (clobber (reg:CC FLAGS_REG))]
    6320                 :          2 :   "(!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
    6321                 :       2557 :    /* FIXME: without this LRA can't reload this pattern, see PR82524.  */
    6322                 :       2545 :    && rtx_equal_p (operands[0], operands[1])"
    6323                 :          0 :   "sub{<imodesuffix>}\t{%2, %0|%0, %2}"
    6324                 :       2140 :   [(set_attr "type" "alu")
    6325                 :          4 :    (set_attr "mode" "<MODE>")])
    6326                 :       2124 : 
    6327                 :         12 : (define_insn "*sub<mode>_2"
    6328                 :        452 :   [(set (reg FLAGS_REG)
    6329                 :       5171 :         (compare
    6330                 :       5167 :           (minus:SWI
    6331                 :       5459 :             (match_operand:SWI 1 "nonimmediate_operand" "0,0")
    6332                 :        285 :             (match_operand:SWI 2 "<general_operand>" "<r><i>,m"))
    6333                 :          0 :           (const_int 0)))
    6334                 :          8 :    (set (match_operand:SWI 0 "nonimmediate_operand" "=<r>m,<r>")
    6335                 :       5654 :         (minus:SWI (match_dup 1) (match_dup 2)))]
    6336                 :        619 :   "ix86_match_ccmode (insn, CCGOCmode)
    6337                 :      24364 :    && ix86_binary_operator_ok (MINUS, <MODE>mode, operands)"
    6338                 :       3471 :   "sub{<imodesuffix>}\t{%2, %0|%0, %2}"
    6339                 :       9667 :   [(set_attr "type" "alu")
    6340                 :       9667 :    (set_attr "mode" "<MODE>")])
    6341                 :      38938 : 
    6342                 :      50788 : (define_insn "*subsi_2_zext"
    6343                 :       6248 :   [(set (reg FLAGS_REG)
    6344                 :      10269 :         (compare
    6345                 :      10269 :           (minus:SI (match_operand:SI 1 "register_operand" "0")
    6346                 :       9667 :                     (match_operand:SI 2 "x86_64_general_operand" "rme"))
    6347                 :       2541 :           (const_int 0)))
    6348                 :       7126 :    (set (match_operand:DI 0 "register_operand" "=r")
    6349                 :       3143 :         (zero_extend:DI
    6350                 :       5514 :           (minus:SI (match_dup 1)
    6351                 :       2541 :                     (match_dup 2))))]
    6352                 :          2 :   "TARGET_64BIT && ix86_match_ccmode (insn, CCGOCmode)
    6353                 :          0 :    && ix86_binary_operator_ok (MINUS, SImode, operands)"
    6354                 :       2997 :   "sub{l}\t{%2, %k0|%k0, %2}"
    6355                 :       2120 :   [(set_attr "type" "alu")
    6356                 :       1861 :    (set_attr "mode" "SI")])
    6357                 :       2120 : 
    6358                 :       1533 : ;; Subtract with jump on overflow.
    6359                 :       1983 : (define_expand "subv<mode>4"
    6360                 :       3036 :   [(parallel [(set (reg:CCO FLAGS_REG)
    6361                 :      34115 :                    (eq:CCO
    6362                 :      34115 :                      (minus:<DPWI>
    6363                 :        146 :                        (sign_extend:<DPWI>
    6364                 :     159144 :                          (match_operand:SWIDWI 1 "nonimmediate_operand"))
    6365                 :     159144 :                        (match_dup 4))
    6366                 :     159144 :                      (sign_extend:<DPWI>
    6367                 :          0 :                        (minus:SWIDWI (match_dup 1)
    6368                 :     126541 :                                      (match_operand:SWIDWI 2
    6369                 :     126541 :                                                 "<general_hilo_operand>")))))
    6370                 :          0 :               (set (match_operand:SWIDWI 0 "register_operand")
    6371                 :      68022 :                    (minus:SWIDWI (match_dup 1) (match_dup 2)))])
    6372                 :      68022 :    (set (pc) (if_then_else
    6373                 :      68022 :                (eq (reg:CCO FLAGS_REG) (const_int 0))
    6374                 :      68022 :                (label_ref (match_operand 3))
    6375                 :      68022 :                (pc)))]
    6376                 :      68022 :   ""
    6377                 :       6506 : {
    6378                 :      25362 :   ix86_fixup_binary_operands_no_copy (MINUS, <MODE>mode, operands);
    6379                 :      22303 :   if (CONST_SCALAR_INT_P (operands[2]))
    6380                 :      26854 :     operands[4] = operands[2];
    6381                 :          0 :   else
    6382                 :       5034 :     operands[4] = gen_rtx_SIGN_EXTEND (<DPWI>mode, operands[2]);
    6383                 :          0 : })
    6384                 :          0 : 
    6385                 :          0 : (define_insn "*subv<mode>4"
    6386                 :       6506 :   [(set (reg:CCO FLAGS_REG)
    6387                 :       6506 :         (eq:CCO (minus:<DWI>
    6388                 :       6506 :                    (sign_extend:<DWI>
    6389                 :       6506 :                       (match_operand:SWI 1 "nonimmediate_operand" "0,0"))
    6390                 :       6506 :                    (sign_extend:<DWI>
    6391                 :       6506 :                       (match_operand:SWI 2 "<general_sext_operand>" "<r>We,m")))
    6392                 :       6506 :                 (sign_extend:<DWI>
    6393                 :       6506 :                    (minus:SWI (match_dup 1) (match_dup 2)))))
    6394                 :       6506 :    (set (match_operand:SWI 0 "nonimmediate_operand" "=<r>m,<r>")
    6395                 :       6506 :         (minus:SWI (match_dup 1) (match_dup 2)))]
    6396                 :       9916 :   "ix86_binary_operator_ok (MINUS, <MODE>mode, operands)"
    6397                 :       6746 :   "sub{<imodesuffix>}\t{%2, %0|%0, %2}"
    6398                 :          0 :   [(set_attr "type" "alu")
    6399                 :          0 :    (set_attr "mode" "<MODE>")])
    6400                 :       7871 : 
    6401                 :       7871 : (define_insn "subv<mode>4_1"
    6402                 :       9212 :   [(set (reg:CCO FLAGS_REG)
    6403                 :          0 :         (eq:CCO (minus:<DWI>
    6404                 :          0 :                    (sign_extend:<DWI>
    6405                 :          0 :                       (match_operand:SWI 1 "nonimmediate_operand" "0"))
    6406                 :          0 :                    (match_operand:<DWI> 3 "const_int_operand" "i"))
    6407                 :          0 :                 (sign_extend:<DWI>
    6408                 :          0 :                    (minus:SWI
    6409                 :          0 :                      (match_dup 1)
    6410                 :          0 :                      (match_operand:SWI 2 "x86_64_immediate_operand" "<i>")))))
    6411                 :          0 :    (set (match_operand:SWI 0 "nonimmediate_operand" "=<r>m")
    6412                 :          0 :         (minus:SWI (match_dup 1) (match_dup 2)))]
    6413                 :        701 :   "ix86_binary_operator_ok (MINUS, <MODE>mode, operands)
    6414                 :       7856 :    && CONST_INT_P (operands[2])
    6415                 :        701 :    && INTVAL (operands[2]) == INTVAL (operands[3])"
    6416                 :          0 :   "sub{<imodesuffix>}\t{%2, %0|%0, %2}"
    6417                 :          0 :   [(set_attr "type" "alu")
    6418                 :          0 :    (set_attr "mode" "<MODE>")
    6419                 :       1148 :    (set (attr "length_immediate")
    6420                 :       1797 :         (cond [(match_test "IN_RANGE (INTVAL (operands[2]), -128, 127)")
    6421                 :        499 :                   (const_string "1")
    6422                 :        998 :                (match_test "<MODE_SIZE> == 8")
    6423                 :       6506 :                   (const_string "4")]
    6424                 :       6506 :               (const_string "<MODE_SIZE>")))])
    6425                 :       6506 : 
    6426                 :          0 : (define_insn_and_split "*subv<dwi>4_doubleword"
    6427                 :          0 :   [(set (reg:CCO FLAGS_REG)
    6428                 :          0 :         (eq:CCO
    6429                 :          0 :           (minus:<QPWI>
    6430                 :       5904 :             (sign_extend:<QPWI>
    6431                 :       2104 :               (match_operand:<DWI> 1 "nonimmediate_operand" "0,0"))
    6432                 :       2104 :             (sign_extend:<QPWI>
    6433                 :       2104 :               (match_operand:<DWI> 2 "nonimmediate_operand" "r,o")))
    6434                 :       2104 :           (sign_extend:<QPWI>
    6435                 :       5904 :             (minus:<DWI> (match_dup 1) (match_dup 2)))))
    6436                 :       5904 :    (set (match_operand:<DWI> 0 "nonimmediate_operand" "=ro,r")
    6437                 :       5904 :         (minus:<DWI> (match_dup 1) (match_dup 2)))]
    6438                 :       7382 :   "ix86_binary_operator_ok (MINUS, <MODE>mode, operands)"
    6439                 :       5904 :   "#"
    6440                 :          0 :   "reload_completed"
    6441                 :          0 :   [(parallel [(set (reg:CC FLAGS_REG)
    6442                 :          0 :                    (compare:CC (match_dup 1) (match_dup 2)))
    6443                 :       5904 :               (set (match_dup 0)
    6444                 :          0 :                    (minus:DWIH (match_dup 1) (match_dup 2)))])
    6445                 :          0 :    (parallel [(set (reg:CCO FLAGS_REG)
    6446                 :          0 :                    (eq:CCO
    6447                 :          0 :                      (minus:<DWI>
    6448                 :          0 :                        (minus:<DWI>
    6449                 :          0 :                          (sign_extend:<DWI> (match_dup 4))
    6450                 :          0 :                          (ltu:<DWI> (reg:CC FLAGS_REG) (const_int 0)))
    6451                 :          0 :                        (sign_extend:<DWI> (match_dup 5)))
    6452                 :          0 :                      (sign_extend:<DWI>
    6453                 :          0 :                        (minus:DWIH
    6454                 :          0 :                          (minus:DWIH
    6455                 :          0 :                            (match_dup 4)
    6456                 :          0 :                            (ltu:DWIH (reg:CC FLAGS_REG) (const_int 0)))
    6457                 :          0 :                          (match_dup 5)))))
    6458                 :          0 :               (set (match_dup 3)
    6459                 :          0 :                    (minus:DWIH
    6460                 :          0 :                      (minus:DWIH
    6461                 :          0 :                        (match_dup 4)
    6462                 :            :                        (ltu:DWIH (reg:CC FLAGS_REG) (const_int 0)))
    6463                 :            :                      (match_dup 5)))])]
    6464                 :        629 : {
    6465                 :        629 :   split_double_mode (<DWI>mode, &operands[0], 3, &operands[0], &operands[3]);
    6466                 :            : })
    6467                 :          0 : 
    6468                 :            : (define_insn_and_split "*subv<dwi>4_doubleword_1"
    6469                 :        629 :   [(set (reg:CCO FLAGS_REG)
    6470                 :        629 :         (eq:CCO
    6471                 :        629 :           (minus:<QPWI>
    6472                 :        629 :             (sign_extend:<QPWI>
    6473                 :        629 :               (match_operand:<DWI> 1 "nonimmediate_operand" "0"))
    6474                 :        629 :             (match_operand:<QPWI> 3 "const_scalar_int_operand" ""))
    6475                 :        629 :           (sign_extend:<QPWI>
    6476                 :        629 :             (minus:<DWI>
    6477                 :        629 :               (match_dup 1)
    6478                 :        629 :               (match_operand:<DWI> 2 "x86_64_hilo_general_operand" "<di>")))))
    6479                 :        629 :    (set (match_operand:<DWI> 0 "nonimmediate_operand" "=ro")
    6480                 :        629 :         (minus:<DWI> (match_dup 1) (match_dup 2)))]
    6481                 :        797 :   "ix86_binary_operator_ok (MINUS, <MODE>mode, operands)
    6482                 :     427404 :    && CONST_SCALAR_INT_P (operands[2])
    6483                 :        168 :    && rtx_equal_p (operands[2], operands[3])"
    6484                 :     427236 :   "#"
    6485                 :            :   "reload_completed"
    6486                 :            :   [(parallel [(set (reg:CC FLAGS_REG)
    6487                 :            :                    (compare:CC (match_dup 1) (match_dup 2)))
    6488                 :            :               (set (match_dup 0)
    6489                 :            :                    (minus:DWIH (match_dup 1) (match_dup 2)))])
    6490                 :            :    (parallel [(set (reg:CCO FLAGS_REG)
    6491                 :            :                    (eq:CCO
    6492                 :        629 :                      (minus:<DWI>
    6493                 :            :                        (minus:<DWI>
    6494                 :            :                          (sign_extend:<DWI> (match_dup 4))
    6495                 :            :                          (ltu:<DWI> (reg:CC FLAGS_REG) (const_int 0)))
    6496                 :        358 :                        (match_dup 5))
    6497                 :        358 :                      (sign_extend:<DWI>
    6498                 :        358 :                        (minus:DWIH
    6499                 :        358 :                          (minus:DWIH
    6500                 :        358 :                            (match_dup 4)
    6501                 :        358 :                            (ltu:DWIH (reg:CC FLAGS_REG) (const_int 0)))
    6502                 :        358 :                          (match_dup 5)))))
    6503                 :        358 :               (set (match_dup 3)
    6504                 :        358 :                    (minus:DWIH
    6505                 :            :                      (minus:DWIH
    6506                 :        340 :                        (match_dup 4)
    6507                 :        340 :                        (ltu:DWIH (reg:CC FLAGS_REG) (const_int 0)))
    6508                 :        340 :                      (match_dup 5)))])]
    6509                 :        508 : {
    6510                 :        508 :   split_double_mode (<DWI>mode, &operands[0], 3, &operands[0], &operands[3]);
    6511                 :        508 :   if (operands[2] == const0_rtx)
    6512                 :        340 :     {
    6513                 :        342 :       emit_insn (gen_subv<mode>4_1 (operands[3], operands[4], operands[5],
    6514                 :        340 :                                     operands[5]));
    6515                 :          2 :       DONE;
    6516                 :          0 :     }
    6517                 :          0 : })
    6518                 :          0 : 
    6519                 :            : (define_insn "*subv<mode>4_overflow_1"
    6520                 :        166 :   [(set (reg:CCO FLAGS_REG)
    6521                 :        166 :         (eq:CCO
    6522                 :        166 :           (minus:<DWI>
    6523                 :        166 :             (minus:<DWI>
    6524                 :        166 :               (sign_extend:<DWI>
    6525                 :        629 :                 (match_operand:SWI 1 "nonimmediate_operand" "%0,0"))
    6526                 :        629 :               (match_operator:<DWI> 4 "ix86_carry_flag_operator"
    6527                 :        795 :                 [(match_operand 3 "flags_reg_operand") (const_int 0)]))
    6528                 :        166 :             (sign_extend:<DWI>
    6529                 :        166 :               (match_operand:SWI 2 "<general_sext_operand>" "rWe,m")))
    6530                 :        166 :           (sign_extend:<DWI>
    6531                 :        166 :             (minus:SWI
    6532                 :        166 :               (minus:SWI
    6533                 :        629 :                 (match_dup 1)
    6534                 :          0 :                 (match_operator:SWI 5 "ix86_carry_flag_operator"
    6535                 :        629 :                   [(match_dup 3) (const_int 0)]))
    6536                 :        629 :               (match_dup 2)))))
    6537                 :        629 :    (set (match_operand:SWI 0 "nonimmediate_operand" "=rm,r")
    6538                 :        629 :         (minus:SWI
    6539                 :        629 :           (minus:SWI
    6540                 :        629 :             (match_dup 1)
    6541                 :        629 :             (match_op_dup 5 [(match_dup 3) (const_int 0)]))
    6542                 :        629 :           (match_dup 2)))]
    6543                 :       1445 :   "ix86_binary_operator_ok (MINUS, <MODE>mode, operands)"
    6544                 :        629 :   "sbb{<imodesuffix>}\t{%2, %0|%0, %2}"
    6545                 :            :   [(set_attr "type" "alu")
    6546                 :          0 :    (set_attr "mode" "<MODE>")])
    6547                 :       1279 : 
    6548                 :       1279 : (define_insn "*subv<mode>4_overflow_2"
    6549                 :       2558 :   [(set (reg:CCO FLAGS_REG)
    6550                 :          0 :         (eq:CCO
    6551                 :          0 :           (minus:<DWI>
    6552                 :          0 :             (minus:<DWI>
    6553                 :          0 :               (sign_extend:<DWI>
    6554                 :          0 :                 (match_operand:SWI 1 "nonimmediate_operand" "%0"))
    6555                 :          0 :               (match_operator:<DWI> 4 "ix86_carry_flag_operator"
    6556                 :          0 :                 [(match_operand 3 "flags_reg_operand") (const_int 0)]))
    6557                 :            :             (match_operand:<DWI> 6 "const_int_operand" ""))
    6558                 :            :           (sign_extend:<DWI>
    6559                 :            :             (minus:SWI
    6560                 :            :               (minus:SWI
    6561                 :            :                 (match_dup 1)
    6562                 :            :                 (match_operator:SWI 5 "ix86_carry_flag_operator"
    6563                 :            :                   [(match_dup 3) (const_int 0)]))
    6564                 :            :               (match_operand:SWI 2 "x86_64_immediate_operand" "e")))))
    6565                 :            :    (set (match_operand:SWI 0 "nonimmediate_operand" "=rm")
    6566                 :            :         (minus:SWI
    6567                 :            :           (minus:SWI
    6568                 :            :             (match_dup 1)
    6569                 :            :             (match_op_dup 5 [(match_dup 3) (const_int 0)]))
    6570                 :            :           (match_dup 2)))]
    6571                 :        166 :   "ix86_binary_operator_ok (MINUS, <MODE>mode, operands)
    6572                 :        166 :    && CONST_INT_P (operands[2])
    6573                 :        166 :    && INTVAL (operands[2]) == INTVAL (operands[6])"
    6574                 :          0 :   "sbb{<imodesuffix>}\t{%2, %0|%0, %2}"
    6575                 :        166 :   [(set_attr "type" "alu")
    6576                 :        166 :    (set_attr "mode" "<MODE>")
    6577                 :        332 :    (set (attr "length_immediate")
    6578                 :        166 :      (if_then_else (match_test "IN_RANGE (INTVAL (operands[2]), -128, 127)")
    6579                 :        498 :        (const_string "1")
    6580                 :            :        (const_string "4")))])
    6581                 :            : 
    6582                 :        618 : (define_expand "usubv<mode>4"
    6583                 :        168 :   [(parallel [(set (reg:CC FLAGS_REG)
    6584                 :            :                    (compare:CC
    6585                 :        168 :                      (match_operand:SWI 1 "nonimmediate_operand")
    6586                 :        168 :                      (match_operand:SWI 2 "<general_operand>")))
    6587                 :        786 :               (set (match_operand:SWI 0 "register_operand")
    6588                 :        618 :                    (minus:SWI (match_dup 1) (match_dup 2)))])
    6589                 :        786 :    (set (pc) (if_then_else
    6590                 :        786 :                (ltu (reg:CC FLAGS_REG) (const_int 0))
    6591                 :        786 :                (label_ref (match_operand 3))
    6592                 :        168 :                (pc)))]
    6593                 :          0 :   ""
    6594                 :        786 :   "ix86_fixup_binary_operands_no_copy (MINUS, <MODE>mode, operands);")
    6595                 :            : 
    6596                 :            : (define_insn "*sub<mode>_3"
    6597                 :       4178 :   [(set (reg FLAGS_REG)
    6598                 :       4178 :         (compare (match_operand:SWI 1 "nonimmediate_operand" "0,0")
    6599                 :       4178 :                  (match_operand:SWI 2 "<general_operand>" "<r><i>,m")))
    6600                 :       4178 :    (set (match_operand:SWI 0 "nonimmediate_operand" "=<r>m,<r>")
    6601                 :       4178 :         (minus:SWI (match_dup 1) (match_dup 2)))]
    6602                 :      22620 :   "ix86_match_ccmode (insn, CCmode)
    6603                 :      22620 :    && ix86_binary_operator_ok (MINUS, <MODE>mode, operands)"
    6604                 :       4234 :   "sub{<imodesuffix>}\t{%2, %0|%0, %2}"
    6605                 :            :   [(set_attr "type" "alu")
    6606                 :       4178 :    (set_attr "mode" "<MODE>")])
    6607                 :      17579 : 
    6608                 :      17579 : (define_peephole2
    6609                 :      50915 :   [(parallel
    6610                 :            :      [(set (reg:CC FLAGS_REG)
    6611                 :            :            (compare:CC (match_operand:SWI 0 "general_reg_operand")
    6612                 :            :                        (match_operand:SWI 1 "general_gr_operand")))
    6613                 :            :       (set (match_dup 0)
    6614                 :            :            (minus:SWI (match_dup 0) (match_dup 1)))])]
    6615                 :       8023 :   "find_regno_note (peep2_next_insn (0), REG_UNUSED, REGNO (operands[0])) != 0"
    6616                 :       2541 :   [(set (reg:CC FLAGS_REG)
    6617                 :       4186 :         (compare:CC (match_dup 0) (match_dup 1)))])
    6618                 :          8 : 
    6619                 :            : ;; decl %eax; cmpl $-1, %eax; jne .Lxx; can be optimized into
    6620                 :       7870 : ;; subl $1, %eax; jnc .Lxx;
    6621                 :       7870 : (define_peephole2
    6622                 :       7870 :   [(parallel
    6623                 :       7870 :      [(set (match_operand:SWI 0 "general_reg_operand")
    6624                 :      15740 :            (plus:SWI (match_dup 0) (const_int -1)))
    6625                 :            :       (clobber (reg FLAGS_REG))])
    6626                 :       4178 :    (set (reg:CCZ FLAGS_REG)
    6627                 :       4178 :         (compare:CCZ (match_dup 0) (const_int -1)))
    6628                 :       4178 :    (set (pc)
    6629                 :            :         (if_then_else (match_operator 1 "bt_comparison_operator"
    6630                 :            :                         [(reg:CCZ FLAGS_REG) (const_int 0)])
    6631                 :            :                       (match_operand 2)
    6632                 :            :                       (pc)))]
    6633                 :       5772 :    "peep2_regno_dead_p (3, FLAGS_REG)"
    6634                 :          2 :    [(parallel
    6635                 :        755 :       [(set (reg:CC FLAGS_REG)
    6636                 :        755 :             (compare:CC (match_dup 0) (const_int 1)))
    6637                 :          0 :        (set (match_dup 0)
    6638                 :       5774 :             (minus:SWI (match_dup 0) (const_int 1)))])
    6639                 :       5774 :     (set (pc)
    6640                 :       2212 :          (if_then_else (match_dup 3)
    6641                 :       4426 :                        (match_dup 2)
    6642                 :       3560 :                        (pc)))]
    6643                 :       5772 : {
    6644                 :       2212 :   rtx cc = gen_rtx_REG (CCmode, FLAGS_REG);
    6645                 :       6150 :   operands[3] = gen_rtx_fmt_ee (GET_CODE (operands[1]) == NE
    6646                 :          0 :                                 ? GEU : LTU, VOIDmode, cc, const0_rtx);
    6647                 :            : })
    6648                 :            : 
    6649                 :            : (define_insn "*subsi_3_zext"
    6650                 :       2212 :   [(set (reg FLAGS_REG)
    6651                 :          0 :         (compare (match_operand:SI 1 "register_operand" "0")
    6652                 :          0 :                  (match_operand:SI 2 "x86_64_general_operand" "rme")))
    6653                 :       2212 :    (set (match_operand:DI 0 "register_operand" "=r")
    6654                 :       2212 :         (zero_extend:DI
    6655                 :       2212 :           (minus:SI (match_dup 1)
    6656                 :       2212 :                     (match_dup 2))))]
    6657                 :       2212 :   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)
    6658                 :       2212 :    && ix86_binary_operator_ok (MINUS, SImode, operands)"
    6659                 :          0 :   "sub{l}\t{%2, %1|%1, %2}"
    6660                 :            :   [(set_attr "type" "alu")
    6661                 :          0 :    (set_attr "mode" "SI")])
    6662                 :          0 : 
    6663                 :          0 : ;; Add with carry and subtract with borrow
    6664                 :          0 : 
    6665                 :          0 : (define_insn "@add<mode>3_carry"
    6666                 :          0 :   [(set (match_operand:SWI 0 "nonimmediate_operand" "=<r>m,<r>")
    6667                 :          0 :         (plus:SWI
    6668                 :          0 :           (plus:SWI
    6669                 :       2212 :             (match_operator:SWI 4 "ix86_carry_flag_operator"
    6670                 :          0 :              [(match_operand 3 "flags_reg_operand") (const_int 0)])
    6671                 :          0 :             (match_operand:SWI 1 "nonimmediate_operand" "%0,0"))
    6672                 :      18070 :           (match_operand:SWI 2 "<general_operand>" "<r><i>,m")))
    6673                 :            :    (clobber (reg:CC FLAGS_REG))]
    6674                 :      29631 :   "ix86_binary_operator_ok (PLUS, <MODE>mode, operands)"
    6675                 :       2510 :   "adc{<imodesuffix>}\t{%2, %0|%0, %2}"
    6676                 :      18075 :   [(set_attr "type" "alu")
    6677                 :          5 :    (set_attr "use_carry" "1")
    6678                 :      45590 :    (set_attr "pent_pair" "pu")
    6679                 :      27520 :    (set_attr "mode" "<MODE>")])
    6680                 :      54978 : 
    6681                 :        184 : (define_insn "*add<mode>3_carry_0"
    6682                 :      20282 :   [(set (match_operand:SWI 0 "nonimmediate_operand" "=<r>m")
    6683                 :      19029 :         (plus:SWI
    6684                 :       3179 :           (match_operator:SWI 3 "ix86_carry_flag_operator"
    6685                 :      18071 :             [(match_operand 2 "flags_reg_operand") (const_int 0)])
    6686                 :      20290 :           (match_operand:SWI 1 "nonimmediate_operand" "0")))
    6687                 :      38363 :    (clobber (reg:CC FLAGS_REG))]
    6688                 :       3716 :   "ix86_unary_operator_ok (PLUS, <MODE>mode, operands)"
    6689                 :       5068 :   "adc{<imodesuffix>}\t{$0, %0|%0, 0}"
    6690                 :      17839 :   [(set_attr "type" "alu")
    6691                 :       2226 :    (set_attr "use_carry" "1")
    6692                 :      20604 :    (set_attr "pent_pair" "pu")
    6693                 :       2766 :    (set_attr "mode" "<MODE>")])
    6694                 :       4424 : 
    6695                 :      18467 : (define_insn "*addsi3_carry_zext"
    6696                 :          8 :   [(set (match_operand:DI 0 "register_operand" "=r")
    6697                 :      18092 :         (zero_extend:DI
    6698                 :       2734 :           (plus:SI
    6699                 :      15358 :             (plus:SI (match_operator:SI 3 "ix86_carry_flag_operator"
    6700                 :      15367 :                       [(reg FLAGS_REG) (const_int 0)])
    6701                 :      15378 :                      (match_operand:SI 1 "register_operand" "%0"))
    6702                 :          8 :             (match_operand:SI 2 "x86_64_general_operand" "rme"))))
    6703                 :       9668 :    (clobber (reg:CC FLAGS_REG))]
    6704                 :       9660 :   "TARGET_64BIT && ix86_binary_operator_ok (PLUS, SImode, operands)"
    6705                 :       9660 :   "adc{l}\t{%2, %k0|%k0, %2}"
    6706                 :          3 :   [(set_attr "