gcc/config/i386/i386.md

   1 ;; GCC machine description for IA-32 and x86-64.
   2 ;; Copyright (C) 1988, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3 ;; 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   4 ;; Free Software Foundation, Inc.
   5 ;; Mostly by William Schelter.
   6 ;; x86_64 support added by Jan Hubicka
   7 ;;
   8 ;; This file is part of GCC.
   9 ;;
  10 ;; GCC is free software; you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation; either version 3, or (at your option)
  13 ;; any later version.
  14 ;;
  15 ;; GCC is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19 ;;
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GCC; see the file COPYING3.  If not see
  22 ;; <http://www.gnu.org/licenses/>.  */
  23 ;;
  24 ;; The original PO technology requires these to be ordered by speed,
  25 ;; so that assigner will pick the fastest.
  26 ;;
  27 ;; See file "rtl.def" for documentation on define_insn, match_*, et. al.
  28 ;;
  29 ;; The special asm out single letter directives following a '%' are:
  30 ;; L,W,B,Q,S,T -- print the opcode suffix for specified size of operand.
  31 ;; C -- print opcode suffix for set/cmov insn.
  32 ;; c -- like C, but print reversed condition
  33 ;; F,f -- likewise, but for floating-point.
  34 ;; O -- if HAVE_AS_IX86_CMOV_SUN_SYNTAX, expand to "w.", "l." or "q.",
  35 ;;      otherwise nothing
  36 ;; R -- print the prefix for register names.
  37 ;; z -- print the opcode suffix for the size of the current operand.
  38 ;; Z -- likewise, with special suffixes for x87 instructions.
  39 ;; * -- print a star (in certain assembler syntax)
  40 ;; A -- print an absolute memory reference.
  41 ;; w -- print the operand as if it's a "word" (HImode) even if it isn't.
  42 ;; s -- print a shift double count, followed by the assemblers argument
  43 ;;      delimiter.
  44 ;; b -- print the QImode name of the register for the indicated operand.
  45 ;;      %b0 would print %al if operands[0] is reg 0.
  46 ;; w --  likewise, print the HImode name of the register.
  47 ;; k --  likewise, print the SImode name of the register.
  48 ;; q --  likewise, print the DImode name of the register.
  49 ;; x --  likewise, print the V4SFmode name of the register.
  50 ;; t --  likewise, print the V8SFmode name of the register.
  51 ;; h -- print the QImode name for a "high" register, either ah, bh, ch or dh.
  52 ;; y -- print "st(0)" instead of "st" as a register.
  53 ;; d -- print duplicated register operand for AVX instruction.
  54 ;; D -- print condition for SSE cmp instruction.
  55 ;; P -- if PIC, print an @PLT suffix.
  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 ;; Y -- print condition for XOP pcom* instruction.
  60 ;; + -- print a branch hint as 'cs' or 'ds' prefix
  61 ;; ; -- print a semicolon (after prefixes due to bug in older gas).
  62 ;; @ -- print a segment register of thread base pointer load
  63
  64 ;; UNSPEC usage:
  65
  66 (define_c_enum "unspec" [
  67   ;; Relocation specifiers
  68   UNSPEC_GOT
  69   UNSPEC_GOTOFF
  70   UNSPEC_GOTPCREL
  71   UNSPEC_GOTTPOFF
  72   UNSPEC_TPOFF
  73   UNSPEC_NTPOFF
  74   UNSPEC_DTPOFF
  75   UNSPEC_GOTNTPOFF
  76   UNSPEC_INDNTPOFF
  77   UNSPEC_PLTOFF
  78   UNSPEC_MACHOPIC_OFFSET
  79   UNSPEC_PCREL
  80
  81   ;; Prologue support
  82   UNSPEC_STACK_ALLOC
  83   UNSPEC_SET_GOT
  84   UNSPEC_REG_SAVE
  85   UNSPEC_DEF_CFA
  86   UNSPEC_SET_RIP
  87   UNSPEC_SET_GOT_OFFSET
  88   UNSPEC_MEMORY_BLOCKAGE
  89   UNSPEC_STACK_CHECK
  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_PARITY
 103   UNSPEC_FSTCW
 104   UNSPEC_ADD_CARRY
 105   UNSPEC_FLDCW
 106   UNSPEC_REP
 107   UNSPEC_LD_MPIC        ; load_macho_picbase
 108   UNSPEC_TRUNC_NOOP
 109   UNSPEC_DIV_ALREADY_SPLIT
 110   UNSPEC_CALL_NEEDS_VZEROUPPER
 111   UNSPEC_PAUSE
 112
 113   ;; For SSE/MMX support:
 114   UNSPEC_FIX_NOTRUNC
 115   UNSPEC_MASKMOV
 116   UNSPEC_MOVMSK
 117   UNSPEC_MOVNT
 118   UNSPEC_MOVU
 119   UNSPEC_RCP
 120   UNSPEC_RSQRT
 121   UNSPEC_SFENCE
 122   UNSPEC_PFRCP
 123   UNSPEC_PFRCPIT1
 124   UNSPEC_PFRCPIT2
 125   UNSPEC_PFRSQRT
 126   UNSPEC_PFRSQIT1
 127   UNSPEC_MFENCE
 128   UNSPEC_LFENCE
 129   UNSPEC_PSADBW
 130   UNSPEC_LDDQU
 131   UNSPEC_MS_TO_SYSV_CALL
 132
 133   ;; Generic math support
 134   UNSPEC_COPYSIGN
 135   UNSPEC_IEEE_MIN       ; not commutative
 136   UNSPEC_IEEE_MAX       ; not commutative
 137
 138   ;; x87 Floating point
 139   UNSPEC_SIN
 140   UNSPEC_COS
 141   UNSPEC_FPATAN
 142   UNSPEC_FYL2X
 143   UNSPEC_FYL2XP1
 144   UNSPEC_FRNDINT
 145   UNSPEC_FIST
 146   UNSPEC_F2XM1
 147   UNSPEC_TAN
 148   UNSPEC_FXAM
 149
 150   ;; x87 Rounding
 151   UNSPEC_FRNDINT_FLOOR
 152   UNSPEC_FRNDINT_CEIL
 153   UNSPEC_FRNDINT_TRUNC
 154   UNSPEC_FRNDINT_MASK_PM
 155   UNSPEC_FIST_FLOOR
 156   UNSPEC_FIST_CEIL
 157
 158   ;; x87 Double output FP
 159   UNSPEC_SINCOS_COS
 160   UNSPEC_SINCOS_SIN
 161   UNSPEC_XTRACT_FRACT
 162   UNSPEC_XTRACT_EXP
 163   UNSPEC_FSCALE_FRACT
 164   UNSPEC_FSCALE_EXP
 165   UNSPEC_FPREM_F
 166   UNSPEC_FPREM_U
 167   UNSPEC_FPREM1_F
 168   UNSPEC_FPREM1_U
 169
 170   UNSPEC_C2_FLAG
 171   UNSPEC_FXAM_MEM
 172
 173   ;; SSP patterns
 174   UNSPEC_SP_SET
 175   UNSPEC_SP_TEST
 176   UNSPEC_SP_TLS_SET
 177   UNSPEC_SP_TLS_TEST
 178
 179   ;; SSSE3
 180   UNSPEC_PSHUFB
 181   UNSPEC_PSIGN
 182   UNSPEC_PALIGNR
 183
 184   ;; For SSE4A support
 185   UNSPEC_EXTRQI
 186   UNSPEC_EXTRQ
 187   UNSPEC_INSERTQI
 188   UNSPEC_INSERTQ
 189
 190   ;; For SSE4.1 support
 191   UNSPEC_BLENDV
 192   UNSPEC_INSERTPS
 193   UNSPEC_DP
 194   UNSPEC_MOVNTDQA
 195   UNSPEC_MPSADBW
 196   UNSPEC_PHMINPOSUW
 197   UNSPEC_PTEST
 198   UNSPEC_ROUND
 199
 200   ;; For SSE4.2 support
 201   UNSPEC_CRC32
 202   UNSPEC_PCMPESTR
 203   UNSPEC_PCMPISTR
 204
 205   ;; For FMA4 support
 206   UNSPEC_FMADDSUB
 207   UNSPEC_XOP_UNSIGNED_CMP
 208   UNSPEC_XOP_TRUEFALSE
 209   UNSPEC_XOP_PERMUTE
 210   UNSPEC_FRCZ
 211
 212   ;; For AES support
 213   UNSPEC_AESENC
 214   UNSPEC_AESENCLAST
 215   UNSPEC_AESDEC
 216   UNSPEC_AESDECLAST
 217   UNSPEC_AESIMC
 218   UNSPEC_AESKEYGENASSIST
 219
 220   ;; For PCLMUL support
 221   UNSPEC_PCLMUL
 222
 223   ;; For AVX support
 224   UNSPEC_PCMP
 225   UNSPEC_VPERMIL
 226   UNSPEC_VPERMIL2
 227   UNSPEC_VPERMIL2F128
 228   UNSPEC_CAST
 229   UNSPEC_VTESTP
 230   UNSPEC_VCVTPH2PS
 231   UNSPEC_VCVTPS2PH
 232
 233   ;; For BMI support
 234   UNSPEC_BEXTR
 235
 236   ;; For RDRAND support
 237   UNSPEC_RDRAND
 238 ])
 239
 240 (define_c_enum "unspecv" [
 241   UNSPECV_BLOCKAGE
 242   UNSPECV_STACK_PROBE
 243   UNSPECV_PROBE_STACK_RANGE
 244   UNSPECV_EMMS
 245   UNSPECV_LDMXCSR
 246   UNSPECV_STMXCSR
 247   UNSPECV_FEMMS
 248   UNSPECV_CLFLUSH
 249   UNSPECV_ALIGN
 250   UNSPECV_MONITOR
 251   UNSPECV_MWAIT
 252   UNSPECV_CMPXCHG
 253   UNSPECV_XCHG
 254   UNSPECV_LOCK
 255   UNSPECV_PROLOGUE_USE
 256   UNSPECV_CLD
 257   UNSPECV_NOPS
 258   UNSPECV_VZEROALL
 259   UNSPECV_VZEROUPPER
 260   UNSPECV_RDTSC
 261   UNSPECV_RDTSCP
 262   UNSPECV_RDPMC
 263   UNSPECV_LLWP_INTRINSIC
 264   UNSPECV_SLWP_INTRINSIC
 265   UNSPECV_LWPVAL_INTRINSIC
 266   UNSPECV_LWPINS_INTRINSIC
 267   UNSPECV_RDFSBASE
 268   UNSPECV_RDGSBASE
 269   UNSPECV_WRFSBASE
 270   UNSPECV_WRGSBASE
 271   UNSPECV_SPLIT_STACK_RETURN
 272 ])
 273
 274 ;; Constants to represent rounding modes in the ROUND instruction
 275 (define_constants
 276   [(ROUND_FLOOR                 0x1)
 277    (ROUND_CEIL                  0x2)
 278    (ROUND_TRUNC                 0x3)
 279    (ROUND_MXCSR                 0x4)
 280    (ROUND_NO_EXC                0x8)
 281   ])
 282
 283 ;; Constants to represent pcomtrue/pcomfalse variants
 284 (define_constants
 285   [(PCOM_FALSE                  0)
 286    (PCOM_TRUE                   1)
 287    (COM_FALSE_S                 2)
 288    (COM_FALSE_P                 3)
 289    (COM_TRUE_S                  4)
 290    (COM_TRUE_P                  5)
 291   ])
 292
 293 ;; Constants used in the XOP pperm instruction
 294 (define_constants
 295   [(PPERM_SRC                   0x00)   /* copy source */
 296    (PPERM_INVERT                0x20)   /* invert source */
 297    (PPERM_REVERSE               0x40)   /* bit reverse source */
 298    (PPERM_REV_INV               0x60)   /* bit reverse & invert src */
 299    (PPERM_ZERO                  0x80)   /* all 0's */
 300    (PPERM_ONES                  0xa0)   /* all 1's */
 301    (PPERM_SIGN                  0xc0)   /* propagate sign bit */
 302    (PPERM_INV_SIGN              0xe0)   /* invert & propagate sign */
 303    (PPERM_SRC1                  0x00)   /* use first source byte */
 304    (PPERM_SRC2                  0x10)   /* use second source byte */
 305    ])
 306
 307 ;; Registers by name.
 308 (define_constants
 309   [(AX_REG                       0)
 310    (DX_REG                       1)
 311    (CX_REG                       2)
 312    (BX_REG                       3)
 313    (SI_REG                       4)
 314    (DI_REG                       5)
 315    (BP_REG                       6)
 316    (SP_REG                       7)
 317    (ST0_REG                      8)
 318    (ST1_REG                      9)
 319    (ST2_REG                     10)
 320    (ST3_REG                     11)
 321    (ST4_REG                     12)
 322    (ST5_REG                     13)
 323    (ST6_REG                     14)
 324    (ST7_REG                     15)
 325    (FLAGS_REG                   17)
 326    (FPSR_REG                    18)
 327    (FPCR_REG                    19)
 328    (XMM0_REG                    21)
 329    (XMM1_REG                    22)
 330    (XMM2_REG                    23)
 331    (XMM3_REG                    24)
 332    (XMM4_REG                    25)
 333    (XMM5_REG                    26)
 334    (XMM6_REG                    27)
 335    (XMM7_REG                    28)
 336    (MM0_REG                     29)
 337    (MM1_REG                     30)
 338    (MM2_REG                     31)
 339    (MM3_REG                     32)
 340    (MM4_REG                     33)
 341    (MM5_REG                     34)
 342    (MM6_REG                     35)
 343    (MM7_REG                     36)
 344    (R8_REG                      37)
 345    (R9_REG                      38)
 346    (R10_REG                     39)
 347    (R11_REG                     40)
 348    (R12_REG                     41)
 349    (R13_REG                     42)
 350    (XMM8_REG                    45)
 351    (XMM9_REG                    46)
 352    (XMM10_REG                   47)
 353    (XMM11_REG                   48)
 354    (XMM12_REG                   49)
 355    (XMM13_REG                   50)
 356    (XMM14_REG                   51)
 357    (XMM15_REG                   52)
 358   ])
 359
 360 ;; Insns whose names begin with "x86_" are emitted by gen_FOO calls
 361 ;; from i386.c.
 362
 363 ;; In C guard expressions, put expressions which may be compile-time
 364 ;; constants first.  This allows for better optimization.  For
 365 ;; example, write "TARGET_64BIT && reload_completed", not
 366 ;; "reload_completed && TARGET_64BIT".
 367
 368 \f
 369 ;; Processor type.
 370 (define_attr "cpu" "none,pentium,pentiumpro,geode,k6,athlon,k8,core2,corei7,
 371                     atom,generic64,amdfam10,bdver1,btver1"
 372   (const (symbol_ref "ix86_schedule")))
 373
 374 ;; A basic instruction type.  Refinements due to arguments to be
 375 ;; provided in other attributes.
 376 (define_attr "type"
 377   "other,multi,
 378    alu,alu1,negnot,imov,imovx,lea,
 379    incdec,ishift,ishift1,rotate,rotate1,imul,idiv,
 380    icmp,test,ibr,setcc,icmov,
 381    push,pop,call,callv,leave,
 382    str,bitmanip,
 383    fmov,fop,fsgn,fmul,fdiv,fpspc,fcmov,fcmp,fxch,fistp,fisttp,frndint,
 384    sselog,sselog1,sseiadd,sseiadd1,sseishft,sseishft1,sseimul,
 385    sse,ssemov,sseadd,ssemul,ssecmp,ssecomi,ssecvt,ssecvt1,sseicvt,ssediv,sseins,
 386    ssemuladd,sse4arg,lwp,
 387    mmx,mmxmov,mmxadd,mmxmul,mmxcmp,mmxcvt,mmxshft"
 388   (const_string "other"))
 389
 390 ;; Main data type used by the insn
 391 (define_attr "mode"
 392   "unknown,none,QI,HI,SI,DI,TI,OI,SF,DF,XF,TF,V8SF,V4DF,V4SF,V2DF,V2SF,V1DF"
 393   (const_string "unknown"))
 394
 395 ;; The CPU unit operations uses.
 396 (define_attr "unit" "integer,i387,sse,mmx,unknown"
 397   (cond [(eq_attr "type" "fmov,fop,fsgn,fmul,fdiv,fpspc,fcmov,fcmp,fxch,fistp,fisttp,frndint")
 398            (const_string "i387")
 399          (eq_attr "type" "sselog,sselog1,sseiadd,sseiadd1,sseishft,sseishft1,sseimul,
 400                           sse,ssemov,sseadd,ssemul,ssecmp,ssecomi,ssecvt,
 401                           ssecvt1,sseicvt,ssediv,sseins,ssemuladd,sse4arg")
 402            (const_string "sse")
 403          (eq_attr "type" "mmx,mmxmov,mmxadd,mmxmul,mmxcmp,mmxcvt,mmxshft")
 404            (const_string "mmx")
 405          (eq_attr "type" "other")
 406            (const_string "unknown")]
 407          (const_string "integer")))
 408
 409 ;; The (bounding maximum) length of an instruction immediate.
 410 (define_attr "length_immediate" ""
 411   (cond [(eq_attr "type" "incdec,setcc,icmov,str,lea,other,multi,idiv,leave,
 412                           bitmanip")
 413            (const_int 0)
 414          (eq_attr "unit" "i387,sse,mmx")
 415            (const_int 0)
 416          (eq_attr "type" "alu,alu1,negnot,imovx,ishift,rotate,ishift1,rotate1,
 417                           imul,icmp,push,pop")
 418            (symbol_ref "ix86_attr_length_immediate_default (insn, true)")
 419          (eq_attr "type" "imov,test")
 420            (symbol_ref "ix86_attr_length_immediate_default (insn, false)")
 421          (eq_attr "type" "call")
 422            (if_then_else (match_operand 0 "constant_call_address_operand" "")
 423              (const_int 4)
 424              (const_int 0))
 425          (eq_attr "type" "callv")
 426            (if_then_else (match_operand 1 "constant_call_address_operand" "")
 427              (const_int 4)
 428              (const_int 0))
 429          ;; We don't know the size before shorten_branches.  Expect
 430          ;; the instruction to fit for better scheduling.
 431          (eq_attr "type" "ibr")
 432            (const_int 1)
 433          ]
 434          (symbol_ref "/* Update immediate_length and other attributes! */
 435                       gcc_unreachable (),1")))
 436
 437 ;; The (bounding maximum) length of an instruction address.
 438 (define_attr "length_address" ""
 439   (cond [(eq_attr "type" "str,other,multi,fxch")
 440            (const_int 0)
 441          (and (eq_attr "type" "call")
 442               (match_operand 0 "constant_call_address_operand" ""))
 443              (const_int 0)
 444          (and (eq_attr "type" "callv")
 445               (match_operand 1 "constant_call_address_operand" ""))
 446              (const_int 0)
 447          ]
 448          (symbol_ref "ix86_attr_length_address_default (insn)")))
 449
 450 ;; Set when length prefix is used.
 451 (define_attr "prefix_data16" ""
 452   (cond [(eq_attr "type" "ssemuladd,sse4arg,sseiadd1,ssecvt1")
 453            (const_int 0)
 454          (eq_attr "mode" "HI")
 455            (const_int 1)
 456          (and (eq_attr "unit" "sse") (eq_attr "mode" "V2DF,TI"))
 457            (const_int 1)
 458         ]
 459         (const_int 0)))
 460
 461 ;; Set when string REP prefix is used.
 462 (define_attr "prefix_rep" ""
 463   (cond [(eq_attr "type" "ssemuladd,sse4arg,sseiadd1,ssecvt1")
 464            (const_int 0)
 465          (and (eq_attr "unit" "sse") (eq_attr "mode" "SF,DF"))
 466            (const_int 1)
 467         ]
 468         (const_int 0)))
 469
 470 ;; Set when 0f opcode prefix is used.
 471 (define_attr "prefix_0f" ""
 472   (if_then_else
 473     (ior (eq_attr "type" "imovx,setcc,icmov,bitmanip")
 474          (eq_attr "unit" "sse,mmx"))
 475     (const_int 1)
 476     (const_int 0)))
 477
 478 ;; Set when REX opcode prefix is used.
 479 (define_attr "prefix_rex" ""
 480   (cond [(eq (symbol_ref "TARGET_64BIT") (const_int 0))
 481            (const_int 0)
 482          (and (eq_attr "mode" "DI")
 483               (and (eq_attr "type" "!push,pop,call,callv,leave,ibr")
 484                    (eq_attr "unit" "!mmx")))
 485            (const_int 1)
 486          (and (eq_attr "mode" "QI")
 487               (ne (symbol_ref "x86_extended_QIreg_mentioned_p (insn)")
 488                   (const_int 0)))
 489            (const_int 1)
 490          (ne (symbol_ref "x86_extended_reg_mentioned_p (insn)")
 491              (const_int 0))
 492            (const_int 1)
 493          (and (eq_attr "type" "imovx")
 494               (match_operand:QI 1 "ext_QIreg_operand" ""))
 495            (const_int 1)
 496         ]
 497         (const_int 0)))
 498
 499 ;; There are also additional prefixes in 3DNOW, SSSE3.
 500 ;; ssemuladd,sse4arg default to 0f24/0f25 and DREX byte,
 501 ;; sseiadd1,ssecvt1 to 0f7a with no DREX byte.
 502 ;; 3DNOW has 0f0f prefix, SSSE3 and SSE4_{1,2} 0f38/0f3a.
 503 (define_attr "prefix_extra" ""
 504   (cond [(eq_attr "type" "ssemuladd,sse4arg")
 505            (const_int 2)
 506          (eq_attr "type" "sseiadd1,ssecvt1")
 507            (const_int 1)
 508         ]
 509         (const_int 0)))
 510
 511 ;; Prefix used: original, VEX or maybe VEX.
 512 (define_attr "prefix" "orig,vex,maybe_vex"
 513   (if_then_else (eq_attr "mode" "OI,V8SF,V4DF")
 514     (const_string "vex")
 515     (const_string "orig")))
 516
 517 ;; VEX W bit is used.
 518 (define_attr "prefix_vex_w" "" (const_int 0))
 519
 520 ;; The length of VEX prefix
 521 ;; Only instructions with 0f prefix can have 2 byte VEX prefix,
 522 ;; 0f38/0f3a prefixes can't.  In i386.md 0f3[8a] is
 523 ;; still prefix_0f 1, with prefix_extra 1.
 524 (define_attr "length_vex" ""
 525   (if_then_else (and (eq_attr "prefix_0f" "1")
 526                      (eq_attr "prefix_extra" "0"))
 527     (if_then_else (eq_attr "prefix_vex_w" "1")
 528       (symbol_ref "ix86_attr_length_vex_default (insn, true, true)")
 529       (symbol_ref "ix86_attr_length_vex_default (insn, true, false)"))
 530     (if_then_else (eq_attr "prefix_vex_w" "1")
 531       (symbol_ref "ix86_attr_length_vex_default (insn, false, true)")
 532       (symbol_ref "ix86_attr_length_vex_default (insn, false, false)"))))
 533
 534 ;; Set when modrm byte is used.
 535 (define_attr "modrm" ""
 536   (cond [(eq_attr "type" "str,leave")
 537            (const_int 0)
 538          (eq_attr "unit" "i387")
 539            (const_int 0)
 540          (and (eq_attr "type" "incdec")
 541               (and (eq (symbol_ref "TARGET_64BIT") (const_int 0))
 542                    (ior (match_operand:SI 1 "register_operand" "")
 543                         (match_operand:HI 1 "register_operand" ""))))
 544            (const_int 0)
 545          (and (eq_attr "type" "push")
 546               (not (match_operand 1 "memory_operand" "")))
 547            (const_int 0)
 548          (and (eq_attr "type" "pop")
 549               (not (match_operand 0 "memory_operand" "")))
 550            (const_int 0)
 551          (and (eq_attr "type" "imov")
 552               (and (not (eq_attr "mode" "DI"))
 553                    (ior (and (match_operand 0 "register_operand" "")
 554                              (match_operand 1 "immediate_operand" ""))
 555                         (ior (and (match_operand 0 "ax_reg_operand" "")
 556                                   (match_operand 1 "memory_displacement_only_operand" ""))
 557                              (and (match_operand 0 "memory_displacement_only_operand" "")
 558                                   (match_operand 1 "ax_reg_operand" ""))))))
 559            (const_int 0)
 560          (and (eq_attr "type" "call")
 561               (match_operand 0 "constant_call_address_operand" ""))
 562              (const_int 0)
 563          (and (eq_attr "type" "callv")
 564               (match_operand 1 "constant_call_address_operand" ""))
 565              (const_int 0)
 566          (and (eq_attr "type" "alu,alu1,icmp,test")
 567               (match_operand 0 "ax_reg_operand" ""))
 568              (symbol_ref "(get_attr_length_immediate (insn) <= (get_attr_mode (insn) != MODE_QI))")
 569          ]
 570          (const_int 1)))
 571
 572 ;; The (bounding maximum) length of an instruction in bytes.
 573 ;; ??? fistp and frndint are in fact fldcw/{fistp,frndint}/fldcw sequences.
 574 ;; Later we may want to split them and compute proper length as for
 575 ;; other insns.
 576 (define_attr "length" ""
 577   (cond [(eq_attr "type" "other,multi,fistp,frndint")
 578            (const_int 16)
 579          (eq_attr "type" "fcmp")
 580            (const_int 4)
 581          (eq_attr "unit" "i387")
 582            (plus (const_int 2)
 583                  (plus (attr "prefix_data16")
 584                        (attr "length_address")))
 585          (ior (eq_attr "prefix" "vex")
 586               (and (eq_attr "prefix" "maybe_vex")
 587                     (ne (symbol_ref "TARGET_AVX") (const_int 0))))
 588            (plus (attr "length_vex")
 589                  (plus (attr "length_immediate")
 590                        (plus (attr "modrm")
 591                              (attr "length_address"))))]
 592          (plus (plus (attr "modrm")
 593                      (plus (attr "prefix_0f")
 594                            (plus (attr "prefix_rex")
 595                                  (plus (attr "prefix_extra")
 596                                        (const_int 1)))))
 597                (plus (attr "prefix_rep")
 598                      (plus (attr "prefix_data16")
 599                            (plus (attr "length_immediate")
 600                                  (attr "length_address")))))))
 601
 602 ;; The `memory' attribute is `none' if no memory is referenced, `load' or
 603 ;; `store' if there is a simple memory reference therein, or `unknown'
 604 ;; if the instruction is complex.
 605
 606 (define_attr "memory" "none,load,store,both,unknown"
 607   (cond [(eq_attr "type" "other,multi,str,lwp")
 608            (const_string "unknown")
 609          (eq_attr "type" "lea,fcmov,fpspc")
 610            (const_string "none")
 611          (eq_attr "type" "fistp,leave")
 612            (const_string "both")
 613          (eq_attr "type" "frndint")
 614            (const_string "load")
 615          (eq_attr "type" "push")
 616            (if_then_else (match_operand 1 "memory_operand" "")
 617              (const_string "both")
 618              (const_string "store"))
 619          (eq_attr "type" "pop")
 620            (if_then_else (match_operand 0 "memory_operand" "")
 621              (const_string "both")
 622              (const_string "load"))
 623          (eq_attr "type" "setcc")
 624            (if_then_else (match_operand 0 "memory_operand" "")
 625              (const_string "store")
 626              (const_string "none"))
 627          (eq_attr "type" "icmp,test,ssecmp,ssecomi,mmxcmp,fcmp")
 628            (if_then_else (ior (match_operand 0 "memory_operand" "")
 629                               (match_operand 1 "memory_operand" ""))
 630              (const_string "load")
 631              (const_string "none"))
 632          (eq_attr "type" "ibr")
 633            (if_then_else (match_operand 0 "memory_operand" "")
 634              (const_string "load")
 635              (const_string "none"))
 636          (eq_attr "type" "call")
 637            (if_then_else (match_operand 0 "constant_call_address_operand" "")
 638              (const_string "none")
 639              (const_string "load"))
 640          (eq_attr "type" "callv")
 641            (if_then_else (match_operand 1 "constant_call_address_operand" "")
 642              (const_string "none")
 643              (const_string "load"))
 644          (and (eq_attr "type" "alu1,negnot,ishift1,sselog1")
 645               (match_operand 1 "memory_operand" ""))
 646            (const_string "both")
 647          (and (match_operand 0 "memory_operand" "")
 648               (match_operand 1 "memory_operand" ""))
 649            (const_string "both")
 650          (match_operand 0 "memory_operand" "")
 651            (const_string "store")
 652          (match_operand 1 "memory_operand" "")
 653            (const_string "load")
 654          (and (eq_attr "type"
 655                  "!alu1,negnot,ishift1,
 656                    imov,imovx,icmp,test,bitmanip,
 657                    fmov,fcmp,fsgn,
 658                    sse,ssemov,ssecmp,ssecomi,ssecvt,ssecvt1,sseicvt,sselog1,
 659                    sseiadd1,mmx,mmxmov,mmxcmp,mmxcvt")
 660               (match_operand 2 "memory_operand" ""))
 661            (const_string "load")
 662          (and (eq_attr "type" "icmov,ssemuladd,sse4arg")
 663               (match_operand 3 "memory_operand" ""))
 664            (const_string "load")
 665         ]
 666         (const_string "none")))
 667
 668 ;; Indicates if an instruction has both an immediate and a displacement.
 669
 670 (define_attr "imm_disp" "false,true,unknown"
 671   (cond [(eq_attr "type" "other,multi")
 672            (const_string "unknown")
 673          (and (eq_attr "type" "icmp,test,imov,alu1,ishift1,rotate1")
 674               (and (match_operand 0 "memory_displacement_operand" "")
 675                    (match_operand 1 "immediate_operand" "")))
 676            (const_string "true")
 677          (and (eq_attr "type" "alu,ishift,rotate,imul,idiv")
 678               (and (match_operand 0 "memory_displacement_operand" "")
 679                    (match_operand 2 "immediate_operand" "")))
 680            (const_string "true")
 681         ]
 682         (const_string "false")))
 683
 684 ;; Indicates if an FP operation has an integer source.
 685
 686 (define_attr "fp_int_src" "false,true"
 687   (const_string "false"))
 688
 689 ;; Defines rounding mode of an FP operation.
 690
 691 (define_attr "i387_cw" "trunc,floor,ceil,mask_pm,uninitialized,any"
 692   (const_string "any"))
 693
 694 ;; Define attribute to classify add/sub insns that consumes carry flag (CF)
 695 (define_attr "use_carry" "0,1" (const_string "0"))
 696
 697 ;; Define attribute to indicate unaligned ssemov insns
 698 (define_attr "movu" "0,1" (const_string "0"))
 699
 700 ;; Used to control the "enabled" attribute on a per-instruction basis.
 701 (define_attr "isa" "base,noavx,avx"
 702   (const_string "base"))
 703
 704 (define_attr "enabled" ""
 705   (cond [(eq_attr "isa" "noavx") (symbol_ref "!TARGET_AVX")
 706          (eq_attr "isa" "avx") (symbol_ref "TARGET_AVX")
 707         ]
 708         (const_int 1)))
 709
 710 ;; Describe a user's asm statement.
 711 (define_asm_attributes
 712   [(set_attr "length" "128")
 713    (set_attr "type" "multi")])
 714
 715 (define_code_iterator plusminus [plus minus])
 716
 717 (define_code_iterator sat_plusminus [ss_plus us_plus ss_minus us_minus])
 718
 719 ;; Base name for define_insn
 720 (define_code_attr plusminus_insn
 721   [(plus "add") (ss_plus "ssadd") (us_plus "usadd")
 722    (minus "sub") (ss_minus "sssub") (us_minus "ussub")])
 723
 724 ;; Base name for insn mnemonic.
 725 (define_code_attr plusminus_mnemonic
 726   [(plus "add") (ss_plus "adds") (us_plus "addus")
 727    (minus "sub") (ss_minus "subs") (us_minus "subus")])
 728 (define_code_attr plusminus_carry_mnemonic
 729   [(plus "adc") (minus "sbb")])
 730
 731 ;; Mark commutative operators as such in constraints.
 732 (define_code_attr comm [(plus "%") (ss_plus "%") (us_plus "%")
 733                         (minus "") (ss_minus "") (us_minus "")])
 734
 735 ;; Mapping of signed max and min
 736 (define_code_iterator smaxmin [smax smin])
 737
 738 ;; Mapping of unsigned max and min
 739 (define_code_iterator umaxmin [umax umin])
 740
 741 ;; Base name for integer and FP insn mnemonic
 742 (define_code_attr maxmin_int [(smax "maxs") (smin "mins")
 743                               (umax "maxu") (umin "minu")])
 744 (define_code_attr maxmin_float [(smax "max") (smin "min")])
 745
 746 ;; Mapping of logic operators
 747 (define_code_iterator any_logic [and ior xor])
 748 (define_code_iterator any_or [ior xor])
 749
 750 ;; Base name for insn mnemonic.
 751 (define_code_attr logic [(and "and") (ior "or") (xor "xor")])
 752
 753 ;; Mapping of shift-right operators
 754 (define_code_iterator any_shiftrt [lshiftrt ashiftrt])
 755
 756 ;; Base name for define_insn
 757 (define_code_attr shiftrt_insn [(lshiftrt "lshr") (ashiftrt "ashr")])
 758
 759 ;; Base name for insn mnemonic.
 760 (define_code_attr shiftrt [(lshiftrt "shr") (ashiftrt "sar")])
 761
 762 ;; Mapping of rotate operators
 763 (define_code_iterator any_rotate [rotate rotatert])
 764
 765 ;; Base name for define_insn
 766 (define_code_attr rotate_insn [(rotate "rotl") (rotatert "rotr")])
 767
 768 ;; Base name for insn mnemonic.
 769 (define_code_attr rotate [(rotate "rol") (rotatert "ror")])
 770
 771 ;; Mapping of abs neg operators
 772 (define_code_iterator absneg [abs neg])
 773
 774 ;; Base name for x87 insn mnemonic.
 775 (define_code_attr absneg_mnemonic [(abs "abs") (neg "chs")])
 776
 777 ;; Used in signed and unsigned widening multiplications.
 778 (define_code_iterator any_extend [sign_extend zero_extend])
 779
 780 ;; Various insn prefixes for signed and unsigned operations.
 781 (define_code_attr u [(sign_extend "") (zero_extend "u")
 782                      (div "") (udiv "u")])
 783 (define_code_attr s [(sign_extend "s") (zero_extend "u")])
 784
 785 ;; Used in signed and unsigned divisions.
 786 (define_code_iterator any_div [div udiv])
 787
 788 ;; Instruction prefix for signed and unsigned operations.
 789 (define_code_attr sgnprefix [(sign_extend "i") (zero_extend "")
 790                              (div "i") (udiv "")])
 791
 792 ;; 64bit single word integer modes.
 793 (define_mode_iterator SWI1248x [QI HI SI DI])
 794
 795 ;; 64bit single word integer modes without QImode and HImode.
 796 (define_mode_iterator SWI48x [SI DI])
 797
 798 ;; Single word integer modes.
 799 (define_mode_iterator SWI [QI HI SI (DI "TARGET_64BIT")])
 800
 801 ;; Single word integer modes without SImode and DImode.
 802 (define_mode_iterator SWI12 [QI HI])
 803
 804 ;; Single word integer modes without DImode.
 805 (define_mode_iterator SWI124 [QI HI SI])
 806
 807 ;; Single word integer modes without QImode and DImode.
 808 (define_mode_iterator SWI24 [HI SI])
 809
 810 ;; Single word integer modes without QImode.
 811 (define_mode_iterator SWI248 [HI SI (DI "TARGET_64BIT")])
 812
 813 ;; Single word integer modes without QImode and HImode.
 814 (define_mode_iterator SWI48 [SI (DI "TARGET_64BIT")])
 815
 816 ;; All math-dependant single and double word integer modes.
 817 (define_mode_iterator SDWIM [(QI "TARGET_QIMODE_MATH")
 818                              (HI "TARGET_HIMODE_MATH")
 819                              SI DI (TI "TARGET_64BIT")])
 820
 821 ;; Math-dependant single word integer modes.
 822 (define_mode_iterator SWIM [(QI "TARGET_QIMODE_MATH")
 823                             (HI "TARGET_HIMODE_MATH")
 824                             SI (DI "TARGET_64BIT")])
 825
 826 ;; Math-dependant single word integer modes without DImode.
 827 (define_mode_iterator SWIM124 [(QI "TARGET_QIMODE_MATH")
 828                                (HI "TARGET_HIMODE_MATH")
 829                                SI])
 830
 831 ;; Math-dependant single word integer modes without QImode.
 832 (define_mode_iterator SWIM248 [(HI "TARGET_HIMODE_MATH")
 833                                SI (DI "TARGET_64BIT")])
 834
 835 ;; Double word integer modes.
 836 (define_mode_iterator DWI [(DI "!TARGET_64BIT")
 837                            (TI "TARGET_64BIT")])
 838
 839 ;; Double word integer modes as mode attribute.
 840 (define_mode_attr DWI [(SI "DI") (DI "TI")])
 841 (define_mode_attr dwi [(SI "di") (DI "ti")])
 842
 843 ;; Half mode for double word integer modes.
 844 (define_mode_iterator DWIH [(SI "!TARGET_64BIT")
 845                             (DI "TARGET_64BIT")])
 846
 847 ;; Instruction suffix for integer modes.
 848 (define_mode_attr imodesuffix [(QI "b") (HI "w") (SI "l") (DI "q")])
 849
 850 ;; Pointer size prefix for integer modes (Intel asm dialect)
 851 (define_mode_attr iptrsize [(QI "BYTE")
 852                             (HI "WORD")
 853                             (SI "DWORD")
 854                             (DI "QWORD")])
 855
 856 ;; Register class for integer modes.
 857 (define_mode_attr r [(QI "q") (HI "r") (SI "r") (DI "r")])
 858
 859 ;; Immediate operand constraint for integer modes.
 860 (define_mode_attr i [(QI "n") (HI "n") (SI "i") (DI "e")])
 861
 862 ;; General operand constraint for word modes.
 863 (define_mode_attr g [(QI "qmn") (HI "rmn") (SI "g") (DI "rme")])
 864
 865 ;; Immediate operand constraint for double integer modes.
 866 (define_mode_attr di [(SI "iF") (DI "e")])
 867
 868 ;; Immediate operand constraint for shifts.
 869 (define_mode_attr S [(QI "I") (HI "I") (SI "I") (DI "J") (TI "O")])
 870
 871 ;; General operand predicate for integer modes.
 872 (define_mode_attr general_operand
 873         [(QI "general_operand")
 874          (HI "general_operand")
 875          (SI "general_operand")
 876          (DI "x86_64_general_operand")
 877          (TI "x86_64_general_operand")])
 878
 879 ;; General sign/zero extend operand predicate for integer modes.
 880 (define_mode_attr general_szext_operand
 881         [(QI "general_operand")
 882          (HI "general_operand")
 883          (SI "general_operand")
 884          (DI "x86_64_szext_general_operand")])
 885
 886 ;; Immediate operand predicate for integer modes.
 887 (define_mode_attr immediate_operand
 888         [(QI "immediate_operand")
 889          (HI "immediate_operand")
 890          (SI "immediate_operand")
 891          (DI "x86_64_immediate_operand")])
 892
 893 ;; Nonmemory operand predicate for integer modes.
 894 (define_mode_attr nonmemory_operand
 895         [(QI "nonmemory_operand")
 896          (HI "nonmemory_operand")
 897          (SI "nonmemory_operand")
 898          (DI "x86_64_nonmemory_operand")])
 899
 900 ;; Operand predicate for shifts.
 901 (define_mode_attr shift_operand
 902         [(QI "nonimmediate_operand")
 903          (HI "nonimmediate_operand")
 904          (SI "nonimmediate_operand")
 905          (DI "shiftdi_operand")
 906          (TI "register_operand")])
 907
 908 ;; Operand predicate for shift argument.
 909 (define_mode_attr shift_immediate_operand
 910         [(QI "const_1_to_31_operand")
 911          (HI "const_1_to_31_operand")
 912          (SI "const_1_to_31_operand")
 913          (DI "const_1_to_63_operand")])
 914
 915 ;; Input operand predicate for arithmetic left shifts.
 916 (define_mode_attr ashl_input_operand
 917         [(QI "nonimmediate_operand")
 918          (HI "nonimmediate_operand")
 919          (SI "nonimmediate_operand")
 920          (DI "ashldi_input_operand")
 921          (TI "reg_or_pm1_operand")])
 922
 923 ;; SSE and x87 SFmode and DFmode floating point modes
 924 (define_mode_iterator MODEF [SF DF])
 925
 926 ;; All x87 floating point modes
 927 (define_mode_iterator X87MODEF [SF DF XF])
 928
 929 ;; All integer modes handled by x87 fisttp operator.
 930 (define_mode_iterator X87MODEI [HI SI DI])
 931
 932 ;; All integer modes handled by integer x87 operators.
 933 (define_mode_iterator X87MODEI12 [HI SI])
 934
 935 ;; All integer modes handled by SSE cvtts?2si* operators.
 936 (define_mode_iterator SSEMODEI24 [SI DI])
 937
 938 ;; SSE instruction suffix for various modes
 939 (define_mode_attr ssemodesuffix
 940   [(SF "ss") (DF "sd")
 941    (V8SF "ps") (V4DF "pd")
 942    (V4SF "ps") (V2DF "pd")
 943    (V16QI "b") (V8HI "w") (V4SI "d") (V2DI "q")
 944    (V8SI "si")])
 945
 946 ;; SSE vector suffix for floating point modes
 947 (define_mode_attr ssevecmodesuffix [(SF "ps") (DF "pd")])
 948
 949 ;; SSE vector mode corresponding to a scalar mode
 950 (define_mode_attr ssevecmode
 951   [(QI "V16QI") (HI "V8HI") (SI "V4SI") (DI "V2DI") (SF "V4SF") (DF "V2DF")])
 952
 953 ;; Instruction suffix for REX 64bit operators.
 954 (define_mode_attr rex64suffix [(SI "") (DI "{q}")])
 955
 956 ;; This mode iterator allows :P to be used for patterns that operate on
 957 ;; pointer-sized quantities.  Exactly one of the two alternatives will match.
 958 (define_mode_iterator P [(SI "Pmode == SImode") (DI "Pmode == DImode")])
 959 \f
 960 ;; Scheduling descriptions
 961
 962 (include "pentium.md")
 963 (include "ppro.md")
 964 (include "k6.md")
 965 (include "athlon.md")
 966 (include "bdver1.md")
 967 (include "geode.md")
 968 (include "atom.md")
 969 (include "core2.md")
 970
 971 \f
 972 ;; Operand and operator predicates and constraints
 973
 974 (include "predicates.md")
 975 (include "constraints.md")
 976
 977 \f
 978 ;; Compare and branch/compare and store instructions.
 979
 980 (define_expand "cbranch<mode>4"
 981   [(set (reg:CC FLAGS_REG)
 982         (compare:CC (match_operand:SDWIM 1 "nonimmediate_operand" "")
 983                     (match_operand:SDWIM 2 "<general_operand>" "")))
 984    (set (pc) (if_then_else
 985                (match_operator 0 "ordered_comparison_operator"
 986                 [(reg:CC FLAGS_REG) (const_int 0)])
 987                (label_ref (match_operand 3 "" ""))
 988                (pc)))]
 989   ""
 990 {
 991   if (MEM_P (operands[1]) && MEM_P (operands[2]))
 992     operands[1] = force_reg (<MODE>mode, operands[1]);
 993   ix86_expand_branch (GET_CODE (operands[0]),
 994                       operands[1], operands[2], operands[3]);
 995   DONE;
 996 })
 997
 998 (define_expand "cstore<mode>4"
 999   [(set (reg:CC FLAGS_REG)
1000         (compare:CC (match_operand:SWIM 2 "nonimmediate_operand" "")
1001                     (match_operand:SWIM 3 "<general_operand>" "")))
1002    (set (match_operand:QI 0 "register_operand" "")
1003         (match_operator 1 "ordered_comparison_operator"
1004           [(reg:CC FLAGS_REG) (const_int 0)]))]
1005   ""
1006 {
1007   if (MEM_P (operands[2]) && MEM_P (operands[3]))
1008     operands[2] = force_reg (<MODE>mode, operands[2]);
1009   ix86_expand_setcc (operands[0], GET_CODE (operands[1]),
1010                      operands[2], operands[3]);
1011   DONE;
1012 })
1013
1014 (define_expand "cmp<mode>_1"
1015   [(set (reg:CC FLAGS_REG)
1016         (compare:CC (match_operand:SWI48 0 "nonimmediate_operand" "")
1017                     (match_operand:SWI48 1 "<general_operand>" "")))])
1018
1019 (define_insn "*cmp<mode>_ccno_1"
1020   [(set (reg FLAGS_REG)
1021         (compare (match_operand:SWI 0 "nonimmediate_operand" "<r>,?m<r>")
1022                  (match_operand:SWI 1 "const0_operand" "")))]
1023   "ix86_match_ccmode (insn, CCNOmode)"
1024   "@
1025    test{<imodesuffix>}\t%0, %0
1026    cmp{<imodesuffix>}\t{%1, %0|%0, %1}"
1027   [(set_attr "type" "test,icmp")
1028    (set_attr "length_immediate" "0,1")
1029    (set_attr "mode" "<MODE>")])
1030
1031 (define_insn "*cmp<mode>_1"
1032   [(set (reg FLAGS_REG)
1033         (compare (match_operand:SWI 0 "nonimmediate_operand" "<r>m,<r>")
1034                  (match_operand:SWI 1 "<general_operand>" "<r><i>,<r>m")))]
1035   "ix86_match_ccmode (insn, CCmode)"
1036   "cmp{<imodesuffix>}\t{%1, %0|%0, %1}"
1037   [(set_attr "type" "icmp")
1038    (set_attr "mode" "<MODE>")])
1039
1040 (define_insn "*cmp<mode>_minus_1"
1041   [(set (reg FLAGS_REG)
1042         (compare
1043           (minus:SWI (match_operand:SWI 0 "nonimmediate_operand" "<r>m,<r>")
1044                      (match_operand:SWI 1 "<general_operand>" "<r><i>,<r>m"))
1045           (const_int 0)))]
1046   "ix86_match_ccmode (insn, CCGOCmode)"
1047   "cmp{<imodesuffix>}\t{%1, %0|%0, %1}"
1048   [(set_attr "type" "icmp")
1049    (set_attr "mode" "<MODE>")])
1050
1051 (define_insn "*cmpqi_ext_1"
1052   [(set (reg FLAGS_REG)
1053         (compare
1054           (match_operand:QI 0 "general_operand" "Qm")
1055           (subreg:QI
1056             (zero_extract:SI
1057               (match_operand 1 "ext_register_operand" "Q")
1058               (const_int 8)
1059               (const_int 8)) 0)))]
1060   "!TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1061   "cmp{b}\t{%h1, %0|%0, %h1}"
1062   [(set_attr "type" "icmp")
1063    (set_attr "mode" "QI")])
1064
1065 (define_insn "*cmpqi_ext_1_rex64"
1066   [(set (reg FLAGS_REG)
1067         (compare
1068           (match_operand:QI 0 "register_operand" "Q")
1069           (subreg:QI
1070             (zero_extract:SI
1071               (match_operand 1 "ext_register_operand" "Q")
1072               (const_int 8)
1073               (const_int 8)) 0)))]
1074   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1075   "cmp{b}\t{%h1, %0|%0, %h1}"
1076   [(set_attr "type" "icmp")
1077    (set_attr "mode" "QI")])
1078
1079 (define_insn "*cmpqi_ext_2"
1080   [(set (reg FLAGS_REG)
1081         (compare
1082           (subreg:QI
1083             (zero_extract:SI
1084               (match_operand 0 "ext_register_operand" "Q")
1085               (const_int 8)
1086               (const_int 8)) 0)
1087           (match_operand:QI 1 "const0_operand" "")))]
1088   "ix86_match_ccmode (insn, CCNOmode)"
1089   "test{b}\t%h0, %h0"
1090   [(set_attr "type" "test")
1091    (set_attr "length_immediate" "0")
1092    (set_attr "mode" "QI")])
1093
1094 (define_expand "cmpqi_ext_3"
1095   [(set (reg:CC FLAGS_REG)
1096         (compare:CC
1097           (subreg:QI
1098             (zero_extract:SI
1099               (match_operand 0 "ext_register_operand" "")
1100               (const_int 8)
1101               (const_int 8)) 0)
1102           (match_operand:QI 1 "immediate_operand" "")))])
1103
1104 (define_insn "*cmpqi_ext_3_insn"
1105   [(set (reg FLAGS_REG)
1106         (compare
1107           (subreg:QI
1108             (zero_extract:SI
1109               (match_operand 0 "ext_register_operand" "Q")
1110               (const_int 8)
1111               (const_int 8)) 0)
1112           (match_operand:QI 1 "general_operand" "Qmn")))]
1113   "!TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1114   "cmp{b}\t{%1, %h0|%h0, %1}"
1115   [(set_attr "type" "icmp")
1116    (set_attr "modrm" "1")
1117    (set_attr "mode" "QI")])
1118
1119 (define_insn "*cmpqi_ext_3_insn_rex64"
1120   [(set (reg FLAGS_REG)
1121         (compare
1122           (subreg:QI
1123             (zero_extract:SI
1124               (match_operand 0 "ext_register_operand" "Q")
1125               (const_int 8)
1126               (const_int 8)) 0)
1127           (match_operand:QI 1 "nonmemory_operand" "Qn")))]
1128   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1129   "cmp{b}\t{%1, %h0|%h0, %1}"
1130   [(set_attr "type" "icmp")
1131    (set_attr "modrm" "1")
1132    (set_attr "mode" "QI")])
1133
1134 (define_insn "*cmpqi_ext_4"
1135   [(set (reg FLAGS_REG)
1136         (compare
1137           (subreg:QI
1138             (zero_extract:SI
1139               (match_operand 0 "ext_register_operand" "Q")
1140               (const_int 8)
1141               (const_int 8)) 0)
1142           (subreg:QI
1143             (zero_extract:SI
1144               (match_operand 1 "ext_register_operand" "Q")
1145               (const_int 8)
1146               (const_int 8)) 0)))]
1147   "ix86_match_ccmode (insn, CCmode)"
1148   "cmp{b}\t{%h1, %h0|%h0, %h1}"
1149   [(set_attr "type" "icmp")
1150    (set_attr "mode" "QI")])
1151
1152 ;; These implement float point compares.
1153 ;; %%% See if we can get away with VOIDmode operands on the actual insns,
1154 ;; which would allow mix and match FP modes on the compares.  Which is what
1155 ;; the old patterns did, but with many more of them.
1156
1157 (define_expand "cbranchxf4"
1158   [(set (reg:CC FLAGS_REG)
1159         (compare:CC (match_operand:XF 1 "nonmemory_operand" "")
1160                     (match_operand:XF 2 "nonmemory_operand" "")))
1161    (set (pc) (if_then_else
1162               (match_operator 0 "ix86_fp_comparison_operator"
1163                [(reg:CC FLAGS_REG)
1164                 (const_int 0)])
1165               (label_ref (match_operand 3 "" ""))
1166               (pc)))]
1167   "TARGET_80387"
1168 {
1169   ix86_expand_branch (GET_CODE (operands[0]),
1170                       operands[1], operands[2], operands[3]);
1171   DONE;
1172 })
1173
1174 (define_expand "cstorexf4"
1175   [(set (reg:CC FLAGS_REG)
1176         (compare:CC (match_operand:XF 2 "nonmemory_operand" "")
1177                     (match_operand:XF 3 "nonmemory_operand" "")))
1178    (set (match_operand:QI 0 "register_operand" "")
1179               (match_operator 1 "ix86_fp_comparison_operator"
1180                [(reg:CC FLAGS_REG)
1181                 (const_int 0)]))]
1182   "TARGET_80387"
1183 {
1184   ix86_expand_setcc (operands[0], GET_CODE (operands[1]),
1185                      operands[2], operands[3]);
1186   DONE;
1187 })
1188
1189 (define_expand "cbranch<mode>4"
1190   [(set (reg:CC FLAGS_REG)
1191         (compare:CC (match_operand:MODEF 1 "cmp_fp_expander_operand" "")
1192                     (match_operand:MODEF 2 "cmp_fp_expander_operand" "")))
1193    (set (pc) (if_then_else
1194               (match_operator 0 "ix86_fp_comparison_operator"
1195                [(reg:CC FLAGS_REG)
1196                 (const_int 0)])
1197               (label_ref (match_operand 3 "" ""))
1198               (pc)))]
1199   "TARGET_80387 || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH)"
1200 {
1201   ix86_expand_branch (GET_CODE (operands[0]),
1202                       operands[1], operands[2], operands[3]);
1203   DONE;
1204 })
1205
1206 (define_expand "cstore<mode>4"
1207   [(set (reg:CC FLAGS_REG)
1208         (compare:CC (match_operand:MODEF 2 "cmp_fp_expander_operand" "")
1209                     (match_operand:MODEF 3 "cmp_fp_expander_operand" "")))
1210    (set (match_operand:QI 0 "register_operand" "")
1211               (match_operator 1 "ix86_fp_comparison_operator"
1212                [(reg:CC FLAGS_REG)
1213                 (const_int 0)]))]
1214   "TARGET_80387 || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH)"
1215 {
1216   ix86_expand_setcc (operands[0], GET_CODE (operands[1]),
1217                      operands[2], operands[3]);
1218   DONE;
1219 })
1220
1221 (define_expand "cbranchcc4"
1222   [(set (pc) (if_then_else
1223               (match_operator 0 "comparison_operator"
1224                [(match_operand 1 "flags_reg_operand" "")
1225                 (match_operand 2 "const0_operand" "")])
1226               (label_ref (match_operand 3 "" ""))
1227               (pc)))]
1228   ""
1229 {
1230   ix86_expand_branch (GET_CODE (operands[0]),
1231                       operands[1], operands[2], operands[3]);
1232   DONE;
1233 })
1234
1235 (define_expand "cstorecc4"
1236   [(set (match_operand:QI 0 "register_operand" "")
1237               (match_operator 1 "comparison_operator"
1238                [(match_operand 2 "flags_reg_operand" "")
1239                 (match_operand 3 "const0_operand" "")]))]
1240   ""
1241 {
1242   ix86_expand_setcc (operands[0], GET_CODE (operands[1]),
1243                      operands[2], operands[3]);
1244   DONE;
1245 })
1246
1247
1248 ;; FP compares, step 1:
1249 ;; Set the FP condition codes.
1250 ;;
1251 ;; CCFPmode     compare with exceptions
1252 ;; CCFPUmode    compare with no exceptions
1253
1254 ;; We may not use "#" to split and emit these, since the REG_DEAD notes
1255 ;; used to manage the reg stack popping would not be preserved.
1256
1257 (define_insn "*cmpfp_0"
1258   [(set (match_operand:HI 0 "register_operand" "=a")
1259         (unspec:HI
1260           [(compare:CCFP
1261              (match_operand 1 "register_operand" "f")
1262              (match_operand 2 "const0_operand" ""))]
1263         UNSPEC_FNSTSW))]
1264   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1265    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1266   "* return output_fp_compare (insn, operands, false, false);"
1267   [(set_attr "type" "multi")
1268    (set_attr "unit" "i387")
1269    (set (attr "mode")
1270      (cond [(match_operand:SF 1 "" "")
1271               (const_string "SF")
1272             (match_operand:DF 1 "" "")
1273               (const_string "DF")
1274            ]
1275            (const_string "XF")))])
1276
1277 (define_insn_and_split "*cmpfp_0_cc"
1278   [(set (reg:CCFP FLAGS_REG)
1279         (compare:CCFP
1280           (match_operand 1 "register_operand" "f")
1281           (match_operand 2 "const0_operand" "")))
1282    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1283   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1284    && TARGET_SAHF && !TARGET_CMOVE
1285    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1286   "#"
1287   "&& reload_completed"
1288   [(set (match_dup 0)
1289         (unspec:HI
1290           [(compare:CCFP (match_dup 1)(match_dup 2))]
1291         UNSPEC_FNSTSW))
1292    (set (reg:CC FLAGS_REG)
1293         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1294   ""
1295   [(set_attr "type" "multi")
1296    (set_attr "unit" "i387")
1297    (set (attr "mode")
1298      (cond [(match_operand:SF 1 "" "")
1299               (const_string "SF")
1300             (match_operand:DF 1 "" "")
1301               (const_string "DF")
1302            ]
1303            (const_string "XF")))])
1304
1305 (define_insn "*cmpfp_xf"
1306   [(set (match_operand:HI 0 "register_operand" "=a")
1307         (unspec:HI
1308           [(compare:CCFP
1309              (match_operand:XF 1 "register_operand" "f")
1310              (match_operand:XF 2 "register_operand" "f"))]
1311           UNSPEC_FNSTSW))]
1312   "TARGET_80387"
1313   "* return output_fp_compare (insn, operands, false, false);"
1314   [(set_attr "type" "multi")
1315    (set_attr "unit" "i387")
1316    (set_attr "mode" "XF")])
1317
1318 (define_insn_and_split "*cmpfp_xf_cc"
1319   [(set (reg:CCFP FLAGS_REG)
1320         (compare:CCFP
1321           (match_operand:XF 1 "register_operand" "f")
1322           (match_operand:XF 2 "register_operand" "f")))
1323    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1324   "TARGET_80387
1325    && TARGET_SAHF && !TARGET_CMOVE"
1326   "#"
1327   "&& reload_completed"
1328   [(set (match_dup 0)
1329         (unspec:HI
1330           [(compare:CCFP (match_dup 1)(match_dup 2))]
1331         UNSPEC_FNSTSW))
1332    (set (reg:CC FLAGS_REG)
1333         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1334   ""
1335   [(set_attr "type" "multi")
1336    (set_attr "unit" "i387")
1337    (set_attr "mode" "XF")])
1338
1339 (define_insn "*cmpfp_<mode>"
1340   [(set (match_operand:HI 0 "register_operand" "=a")
1341         (unspec:HI
1342           [(compare:CCFP
1343              (match_operand:MODEF 1 "register_operand" "f")
1344              (match_operand:MODEF 2 "nonimmediate_operand" "fm"))]
1345           UNSPEC_FNSTSW))]
1346   "TARGET_80387"
1347   "* return output_fp_compare (insn, operands, false, false);"
1348   [(set_attr "type" "multi")
1349    (set_attr "unit" "i387")
1350    (set_attr "mode" "<MODE>")])
1351
1352 (define_insn_and_split "*cmpfp_<mode>_cc"
1353   [(set (reg:CCFP FLAGS_REG)
1354         (compare:CCFP
1355           (match_operand:MODEF 1 "register_operand" "f")
1356           (match_operand:MODEF 2 "nonimmediate_operand" "fm")))
1357    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1358   "TARGET_80387
1359    && TARGET_SAHF && !TARGET_CMOVE"
1360   "#"
1361   "&& reload_completed"
1362   [(set (match_dup 0)
1363         (unspec:HI
1364           [(compare:CCFP (match_dup 1)(match_dup 2))]
1365         UNSPEC_FNSTSW))
1366    (set (reg:CC FLAGS_REG)
1367         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1368   ""
1369   [(set_attr "type" "multi")
1370    (set_attr "unit" "i387")
1371    (set_attr "mode" "<MODE>")])
1372
1373 (define_insn "*cmpfp_u"
1374   [(set (match_operand:HI 0 "register_operand" "=a")
1375         (unspec:HI
1376           [(compare:CCFPU
1377              (match_operand 1 "register_operand" "f")
1378              (match_operand 2 "register_operand" "f"))]
1379           UNSPEC_FNSTSW))]
1380   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1381    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1382   "* return output_fp_compare (insn, operands, false, true);"
1383   [(set_attr "type" "multi")
1384    (set_attr "unit" "i387")
1385    (set (attr "mode")
1386      (cond [(match_operand:SF 1 "" "")
1387               (const_string "SF")
1388             (match_operand:DF 1 "" "")
1389               (const_string "DF")
1390            ]
1391            (const_string "XF")))])
1392
1393 (define_insn_and_split "*cmpfp_u_cc"
1394   [(set (reg:CCFPU FLAGS_REG)
1395         (compare:CCFPU
1396           (match_operand 1 "register_operand" "f")
1397           (match_operand 2 "register_operand" "f")))
1398    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1399   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1400    && TARGET_SAHF && !TARGET_CMOVE
1401    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1402   "#"
1403   "&& reload_completed"
1404   [(set (match_dup 0)
1405         (unspec:HI
1406           [(compare:CCFPU (match_dup 1)(match_dup 2))]
1407         UNSPEC_FNSTSW))
1408    (set (reg:CC FLAGS_REG)
1409         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1410   ""
1411   [(set_attr "type" "multi")
1412    (set_attr "unit" "i387")
1413    (set (attr "mode")
1414      (cond [(match_operand:SF 1 "" "")
1415               (const_string "SF")
1416             (match_operand:DF 1 "" "")
1417               (const_string "DF")
1418            ]
1419            (const_string "XF")))])
1420
1421 (define_insn "*cmpfp_<mode>"
1422   [(set (match_operand:HI 0 "register_operand" "=a")
1423         (unspec:HI
1424           [(compare:CCFP
1425              (match_operand 1 "register_operand" "f")
1426              (match_operator 3 "float_operator"
1427                [(match_operand:X87MODEI12 2 "memory_operand" "m")]))]
1428           UNSPEC_FNSTSW))]
1429   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1430    && (TARGET_USE_<MODE>MODE_FIOP || optimize_function_for_size_p (cfun))
1431    && (GET_MODE (operands [3]) == GET_MODE (operands[1]))"
1432   "* return output_fp_compare (insn, operands, false, false);"
1433   [(set_attr "type" "multi")
1434    (set_attr "unit" "i387")
1435    (set_attr "fp_int_src" "true")
1436    (set_attr "mode" "<MODE>")])
1437
1438 (define_insn_and_split "*cmpfp_<mode>_cc"
1439   [(set (reg:CCFP FLAGS_REG)
1440         (compare:CCFP
1441           (match_operand 1 "register_operand" "f")
1442           (match_operator 3 "float_operator"
1443             [(match_operand:X87MODEI12 2 "memory_operand" "m")])))
1444    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1445   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1446    && TARGET_SAHF && !TARGET_CMOVE
1447    && (TARGET_USE_<MODE>MODE_FIOP || optimize_function_for_size_p (cfun))
1448    && (GET_MODE (operands [3]) == GET_MODE (operands[1]))"
1449   "#"
1450   "&& reload_completed"
1451   [(set (match_dup 0)
1452         (unspec:HI
1453           [(compare:CCFP
1454              (match_dup 1)
1455              (match_op_dup 3 [(match_dup 2)]))]
1456         UNSPEC_FNSTSW))
1457    (set (reg:CC FLAGS_REG)
1458         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1459   ""
1460   [(set_attr "type" "multi")
1461    (set_attr "unit" "i387")
1462    (set_attr "fp_int_src" "true")
1463    (set_attr "mode" "<MODE>")])
1464
1465 ;; FP compares, step 2
1466 ;; Move the fpsw to ax.
1467
1468 (define_insn "x86_fnstsw_1"
1469   [(set (match_operand:HI 0 "register_operand" "=a")
1470         (unspec:HI [(reg:CCFP FPSR_REG)] UNSPEC_FNSTSW))]
1471   "TARGET_80387"
1472   "fnstsw\t%0"
1473   [(set (attr "length") (symbol_ref "ix86_attr_length_address_default (insn) + 2"))
1474    (set_attr "mode" "SI")
1475    (set_attr "unit" "i387")])
1476
1477 ;; FP compares, step 3
1478 ;; Get ax into flags, general case.
1479
1480 (define_insn "x86_sahf_1"
1481   [(set (reg:CC FLAGS_REG)
1482         (unspec:CC [(match_operand:HI 0 "register_operand" "a")]
1483                    UNSPEC_SAHF))]
1484   "TARGET_SAHF"
1485 {
1486 #ifndef HAVE_AS_IX86_SAHF
1487   if (TARGET_64BIT)
1488     return ASM_BYTE "0x9e";
1489   else
1490 #endif
1491   return "sahf";
1492 }
1493   [(set_attr "length" "1")
1494    (set_attr "athlon_decode" "vector")
1495    (set_attr "amdfam10_decode" "direct")
1496    (set_attr "bdver1_decode" "direct")
1497    (set_attr "mode" "SI")])
1498
1499 ;; Pentium Pro can do steps 1 through 3 in one go.
1500 ;; comi*, ucomi*, fcomi*, ficomi*,fucomi* (i387 instructions set condition codes)
1501 (define_insn "*cmpfp_i_mixed"
1502   [(set (reg:CCFP FLAGS_REG)
1503         (compare:CCFP (match_operand 0 "register_operand" "f,x")
1504                       (match_operand 1 "nonimmediate_operand" "f,xm")))]
1505   "TARGET_MIX_SSE_I387
1506    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1507    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1508   "* return output_fp_compare (insn, operands, true, false);"
1509   [(set_attr "type" "fcmp,ssecomi")
1510    (set_attr "prefix" "orig,maybe_vex")
1511    (set (attr "mode")
1512      (if_then_else (match_operand:SF 1 "" "")
1513         (const_string "SF")
1514         (const_string "DF")))
1515    (set (attr "prefix_rep")
1516         (if_then_else (eq_attr "type" "ssecomi")
1517                       (const_string "0")
1518                       (const_string "*")))
1519    (set (attr "prefix_data16")
1520         (cond [(eq_attr "type" "fcmp")
1521                  (const_string "*")
1522                (eq_attr "mode" "DF")
1523                  (const_string "1")
1524               ]
1525               (const_string "0")))
1526    (set_attr "athlon_decode" "vector")
1527    (set_attr "amdfam10_decode" "direct")
1528    (set_attr "bdver1_decode" "double")])
1529
1530 (define_insn "*cmpfp_i_sse"
1531   [(set (reg:CCFP FLAGS_REG)
1532         (compare:CCFP (match_operand 0 "register_operand" "x")
1533                       (match_operand 1 "nonimmediate_operand" "xm")))]
1534   "TARGET_SSE_MATH
1535    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1536    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1537   "* return output_fp_compare (insn, operands, true, false);"
1538   [(set_attr "type" "ssecomi")
1539    (set_attr "prefix" "maybe_vex")
1540    (set (attr "mode")
1541      (if_then_else (match_operand:SF 1 "" "")
1542         (const_string "SF")
1543         (const_string "DF")))
1544    (set_attr "prefix_rep" "0")
1545    (set (attr "prefix_data16")
1546         (if_then_else (eq_attr "mode" "DF")
1547                       (const_string "1")
1548                       (const_string "0")))
1549    (set_attr "athlon_decode" "vector")
1550    (set_attr "amdfam10_decode" "direct")
1551    (set_attr "bdver1_decode" "double")])
1552
1553 (define_insn "*cmpfp_i_i387"
1554   [(set (reg:CCFP FLAGS_REG)
1555         (compare:CCFP (match_operand 0 "register_operand" "f")
1556                       (match_operand 1 "register_operand" "f")))]
1557   "X87_FLOAT_MODE_P (GET_MODE (operands[0]))
1558    && TARGET_CMOVE
1559    && !(SSE_FLOAT_MODE_P (GET_MODE (operands[0])) && TARGET_SSE_MATH)
1560    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1561   "* return output_fp_compare (insn, operands, true, false);"
1562   [(set_attr "type" "fcmp")
1563    (set (attr "mode")
1564      (cond [(match_operand:SF 1 "" "")
1565               (const_string "SF")
1566             (match_operand:DF 1 "" "")
1567               (const_string "DF")
1568            ]
1569            (const_string "XF")))
1570    (set_attr "athlon_decode" "vector")
1571    (set_attr "amdfam10_decode" "direct")
1572    (set_attr "bdver1_decode" "double")])
1573
1574 (define_insn "*cmpfp_iu_mixed"
1575   [(set (reg:CCFPU FLAGS_REG)
1576         (compare:CCFPU (match_operand 0 "register_operand" "f,x")
1577                        (match_operand 1 "nonimmediate_operand" "f,xm")))]
1578   "TARGET_MIX_SSE_I387
1579    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1580    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1581   "* return output_fp_compare (insn, operands, true, true);"
1582   [(set_attr "type" "fcmp,ssecomi")
1583    (set_attr "prefix" "orig,maybe_vex")
1584    (set (attr "mode")
1585      (if_then_else (match_operand:SF 1 "" "")
1586         (const_string "SF")
1587         (const_string "DF")))
1588    (set (attr "prefix_rep")
1589         (if_then_else (eq_attr "type" "ssecomi")
1590                       (const_string "0")
1591                       (const_string "*")))
1592    (set (attr "prefix_data16")
1593         (cond [(eq_attr "type" "fcmp")
1594                  (const_string "*")
1595                (eq_attr "mode" "DF")
1596                  (const_string "1")
1597               ]
1598               (const_string "0")))
1599    (set_attr "athlon_decode" "vector")
1600    (set_attr "amdfam10_decode" "direct")
1601    (set_attr "bdver1_decode" "double")])
1602
1603 (define_insn "*cmpfp_iu_sse"
1604   [(set (reg:CCFPU FLAGS_REG)
1605         (compare:CCFPU (match_operand 0 "register_operand" "x")
1606                        (match_operand 1 "nonimmediate_operand" "xm")))]
1607   "TARGET_SSE_MATH
1608    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1609    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1610   "* return output_fp_compare (insn, operands, true, true);"
1611   [(set_attr "type" "ssecomi")
1612    (set_attr "prefix" "maybe_vex")
1613    (set (attr "mode")
1614      (if_then_else (match_operand:SF 1 "" "")
1615         (const_string "SF")
1616         (const_string "DF")))
1617    (set_attr "prefix_rep" "0")
1618    (set (attr "prefix_data16")
1619         (if_then_else (eq_attr "mode" "DF")
1620                       (const_string "1")
1621                       (const_string "0")))
1622    (set_attr "athlon_decode" "vector")
1623    (set_attr "amdfam10_decode" "direct")
1624    (set_attr "bdver1_decode" "double")])
1625
1626 (define_insn "*cmpfp_iu_387"
1627   [(set (reg:CCFPU FLAGS_REG)
1628         (compare:CCFPU (match_operand 0 "register_operand" "f")
1629                        (match_operand 1 "register_operand" "f")))]
1630   "X87_FLOAT_MODE_P (GET_MODE (operands[0]))
1631    && TARGET_CMOVE
1632    && !(SSE_FLOAT_MODE_P (GET_MODE (operands[0])) && TARGET_SSE_MATH)
1633    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1634   "* return output_fp_compare (insn, operands, true, true);"
1635   [(set_attr "type" "fcmp")
1636    (set (attr "mode")
1637      (cond [(match_operand:SF 1 "" "")
1638               (const_string "SF")
1639             (match_operand:DF 1 "" "")
1640               (const_string "DF")
1641            ]
1642            (const_string "XF")))
1643    (set_attr "athlon_decode" "vector")
1644    (set_attr "amdfam10_decode" "direct")
1645    (set_attr "bdver1_decode" "direct")])
1646 \f
1647 ;; Push/pop instructions.
1648
1649 (define_insn "*push<mode>2"
1650   [(set (match_operand:DWI 0 "push_operand" "=<")
1651         (match_operand:DWI 1 "general_no_elim_operand" "riF*m"))]
1652   ""
1653   "#")
1654
1655 (define_split
1656   [(set (match_operand:TI 0 "push_operand" "")
1657         (match_operand:TI 1 "general_operand" ""))]
1658   "TARGET_64BIT && reload_completed
1659    && !SSE_REG_P (operands[1])"
1660   [(const_int 0)]
1661   "ix86_split_long_move (operands); DONE;")
1662
1663 (define_insn "*pushdi2_rex64"
1664   [(set (match_operand:DI 0 "push_operand" "=<,!<")
1665         (match_operand:DI 1 "general_no_elim_operand" "re*m,n"))]
1666   "TARGET_64BIT"
1667   "@
1668    push{q}\t%1
1669    #"
1670   [(set_attr "type" "push,multi")
1671    (set_attr "mode" "DI")])
1672
1673 ;; Convert impossible pushes of immediate to existing instructions.
1674 ;; First try to get scratch register and go through it.  In case this
1675 ;; fails, push sign extended lower part first and then overwrite
1676 ;; upper part by 32bit move.
1677 (define_peephole2
1678   [(match_scratch:DI 2 "r")
1679    (set (match_operand:DI 0 "push_operand" "")
1680         (match_operand:DI 1 "immediate_operand" ""))]
1681   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
1682    && !x86_64_immediate_operand (operands[1], DImode)"
1683   [(set (match_dup 2) (match_dup 1))
1684    (set (match_dup 0) (match_dup 2))])
1685
1686 ;; We need to define this as both peepholer and splitter for case
1687 ;; peephole2 pass is not run.
1688 ;; "&& 1" is needed to keep it from matching the previous pattern.
1689 (define_peephole2
1690   [(set (match_operand:DI 0 "push_operand" "")
1691         (match_operand:DI 1 "immediate_operand" ""))]
1692   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
1693    && !x86_64_immediate_operand (operands[1], DImode) && 1"
1694   [(set (match_dup 0) (match_dup 1))
1695    (set (match_dup 2) (match_dup 3))]
1696 {
1697   split_double_mode (DImode, &operands[1], 1, &operands[2], &operands[3]);
1698
1699   operands[1] = gen_lowpart (DImode, operands[2]);
1700   operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx,
1701                                                    GEN_INT (4)));
1702 })
1703
1704 (define_split
1705   [(set (match_operand:DI 0 "push_operand" "")
1706         (match_operand:DI 1 "immediate_operand" ""))]
1707   "TARGET_64BIT && ((optimize > 0 && flag_peephole2)
1708                     ? epilogue_completed : reload_completed)
1709    && !symbolic_operand (operands[1], DImode)
1710    && !x86_64_immediate_operand (operands[1], DImode)"
1711   [(set (match_dup 0) (match_dup 1))
1712    (set (match_dup 2) (match_dup 3))]
1713 {
1714   split_double_mode (DImode, &operands[1], 1, &operands[2], &operands[3]);
1715
1716   operands[1] = gen_lowpart (DImode, operands[2]);
1717   operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx,
1718                                                    GEN_INT (4)));
1719 })
1720
1721 (define_split
1722   [(set (match_operand:DI 0 "push_operand" "")
1723         (match_operand:DI 1 "general_operand" ""))]
1724   "!TARGET_64BIT && reload_completed
1725    && !(MMX_REG_P (operands[1]) || SSE_REG_P (operands[1]))"
1726   [(const_int 0)]
1727   "ix86_split_long_move (operands); DONE;")
1728
1729 (define_insn "*pushsi2"
1730   [(set (match_operand:SI 0 "push_operand" "=<")
1731         (match_operand:SI 1 "general_no_elim_operand" "ri*m"))]
1732   "!TARGET_64BIT"
1733   "push{l}\t%1"
1734   [(set_attr "type" "push")
1735    (set_attr "mode" "SI")])
1736
1737 ;; emit_push_insn when it calls move_by_pieces requires an insn to
1738 ;; "push a byte/word".  But actually we use pushl, which has the effect
1739 ;; of rounding the amount pushed up to a word.
1740
1741 ;; For TARGET_64BIT we always round up to 8 bytes.
1742 (define_insn "*push<mode>2_rex64"
1743   [(set (match_operand:SWI124 0 "push_operand" "=X")
1744         (match_operand:SWI124 1 "nonmemory_no_elim_operand" "r<i>"))]
1745   "TARGET_64BIT"
1746   "push{q}\t%q1"
1747   [(set_attr "type" "push")
1748    (set_attr "mode" "DI")])
1749
1750 (define_insn "*push<mode>2"
1751   [(set (match_operand:SWI12 0 "push_operand" "=X")
1752         (match_operand:SWI12 1 "nonmemory_no_elim_operand" "rn"))]
1753   "!TARGET_64BIT"
1754   "push{l}\t%k1"
1755   [(set_attr "type" "push")
1756    (set_attr "mode" "SI")])
1757
1758 (define_insn "*push<mode>2_prologue"
1759   [(set (match_operand:P 0 "push_operand" "=<")
1760         (match_operand:P 1 "general_no_elim_operand" "r<i>*m"))
1761    (clobber (mem:BLK (scratch)))]
1762   ""
1763   "push{<imodesuffix>}\t%1"
1764   [(set_attr "type" "push")
1765    (set_attr "mode" "<MODE>")])
1766
1767 (define_insn "*pop<mode>1"
1768   [(set (match_operand:P 0 "nonimmediate_operand" "=r*m")
1769         (match_operand:P 1 "pop_operand" ">"))]
1770   ""
1771   "pop{<imodesuffix>}\t%0"
1772   [(set_attr "type" "pop")
1773    (set_attr "mode" "<MODE>")])
1774
1775 (define_insn "*pop<mode>1_epilogue"
1776   [(set (match_operand:P 0 "nonimmediate_operand" "=r*m")
1777         (match_operand:P 1 "pop_operand" ">"))
1778    (clobber (mem:BLK (scratch)))]
1779   ""
1780   "pop{<imodesuffix>}\t%0"
1781   [(set_attr "type" "pop")
1782    (set_attr "mode" "<MODE>")])
1783 \f
1784 ;; Move instructions.
1785
1786 (define_expand "movoi"
1787   [(set (match_operand:OI 0 "nonimmediate_operand" "")
1788         (match_operand:OI 1 "general_operand" ""))]
1789   "TARGET_AVX"
1790   "ix86_expand_move (OImode, operands); DONE;")
1791
1792 (define_expand "movti"
1793   [(set (match_operand:TI 0 "nonimmediate_operand" "")
1794         (match_operand:TI 1 "nonimmediate_operand" ""))]
1795   "TARGET_64BIT || TARGET_SSE"
1796 {
1797   if (TARGET_64BIT)
1798     ix86_expand_move (TImode, operands);
1799   else if (push_operand (operands[0], TImode))
1800     ix86_expand_push (TImode, operands[1]);
1801   else
1802     ix86_expand_vector_move (TImode, operands);
1803   DONE;
1804 })
1805
1806 ;; This expands to what emit_move_complex would generate if we didn't
1807 ;; have a movti pattern.  Having this avoids problems with reload on
1808 ;; 32-bit targets when SSE is present, but doesn't seem to be harmful
1809 ;; to have around all the time.
1810 (define_expand "movcdi"
1811   [(set (match_operand:CDI 0 "nonimmediate_operand" "")
1812         (match_operand:CDI 1 "general_operand" ""))]
1813   ""
1814 {
1815   if (push_operand (operands[0], CDImode))
1816     emit_move_complex_push (CDImode, operands[0], operands[1]);
1817   else
1818     emit_move_complex_parts (operands[0], operands[1]);
1819   DONE;
1820 })
1821
1822 (define_expand "mov<mode>"
1823   [(set (match_operand:SWI1248x 0 "nonimmediate_operand" "")
1824         (match_operand:SWI1248x 1 "general_operand" ""))]
1825   ""
1826   "ix86_expand_move (<MODE>mode, operands); DONE;")
1827
1828 (define_insn "*mov<mode>_xor"
1829   [(set (match_operand:SWI48 0 "register_operand" "=r")
1830         (match_operand:SWI48 1 "const0_operand" ""))
1831    (clobber (reg:CC FLAGS_REG))]
1832   "reload_completed"
1833   "xor{l}\t%k0, %k0"
1834   [(set_attr "type" "alu1")
1835    (set_attr "mode" "SI")
1836    (set_attr "length_immediate" "0")])
1837
1838 (define_insn "*mov<mode>_or"
1839   [(set (match_operand:SWI48 0 "register_operand" "=r")
1840         (match_operand:SWI48 1 "const_int_operand" ""))
1841    (clobber (reg:CC FLAGS_REG))]
1842   "reload_completed
1843    && operands[1] == constm1_rtx"
1844   "or{<imodesuffix>}\t{%1, %0|%0, %1}"
1845   [(set_attr "type" "alu1")
1846    (set_attr "mode" "<MODE>")
1847    (set_attr "length_immediate" "1")])
1848
1849 (define_insn "*movoi_internal_avx"
1850   [(set (match_operand:OI 0 "nonimmediate_operand" "=x,x,m")
1851         (match_operand:OI 1 "vector_move_operand" "C,xm,x"))]
1852   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1853 {
1854   switch (which_alternative)
1855     {
1856     case 0:
1857       return "vxorps\t%0, %0, %0";
1858     case 1:
1859     case 2:
1860       if (misaligned_operand (operands[0], OImode)
1861           || misaligned_operand (operands[1], OImode))
1862         return "vmovdqu\t{%1, %0|%0, %1}";
1863       else
1864         return "vmovdqa\t{%1, %0|%0, %1}";
1865     default:
1866       gcc_unreachable ();
1867     }
1868 }
1869   [(set_attr "type" "sselog1,ssemov,ssemov")
1870    (set_attr "prefix" "vex")
1871    (set_attr "mode" "OI")])
1872
1873 (define_insn "*movti_internal_rex64"
1874   [(set (match_operand:TI 0 "nonimmediate_operand" "=!r,o,x,x,xm")
1875         (match_operand:TI 1 "general_operand" "riFo,riF,C,xm,x"))]
1876   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1877 {
1878   switch (which_alternative)
1879     {
1880     case 0:
1881     case 1:
1882       return "#";
1883     case 2:
1884       if (get_attr_mode (insn) == MODE_V4SF)
1885         return "%vxorps\t%0, %d0";
1886       else
1887         return "%vpxor\t%0, %d0";
1888     case 3:
1889     case 4:
1890       /* TDmode values are passed as TImode on the stack.  Moving them
1891          to stack may result in unaligned memory access.  */
1892       if (misaligned_operand (operands[0], TImode)
1893           || misaligned_operand (operands[1], TImode))
1894         {
1895           if (get_attr_mode (insn) == MODE_V4SF)
1896             return "%vmovups\t{%1, %0|%0, %1}";
1897           else
1898             return "%vmovdqu\t{%1, %0|%0, %1}";
1899         }
1900       else
1901         {
1902           if (get_attr_mode (insn) == MODE_V4SF)
1903             return "%vmovaps\t{%1, %0|%0, %1}";
1904           else
1905             return "%vmovdqa\t{%1, %0|%0, %1}";
1906         }
1907     default:
1908       gcc_unreachable ();
1909     }
1910 }
1911   [(set_attr "type" "*,*,sselog1,ssemov,ssemov")
1912    (set_attr "prefix" "*,*,maybe_vex,maybe_vex,maybe_vex")
1913    (set (attr "mode")
1914         (cond [(eq_attr "alternative" "2,3")
1915                  (if_then_else
1916                    (ne (symbol_ref "optimize_function_for_size_p (cfun)")
1917                        (const_int 0))
1918                    (const_string "V4SF")
1919                    (const_string "TI"))
1920                (eq_attr "alternative" "4")
1921                  (if_then_else
1922                    (ior (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
1923                             (const_int 0))
1924                         (ne (symbol_ref "optimize_function_for_size_p (cfun)")
1925                             (const_int 0)))
1926                    (const_string "V4SF")
1927                    (const_string "TI"))]
1928                (const_string "DI")))])
1929
1930 (define_split
1931   [(set (match_operand:TI 0 "nonimmediate_operand" "")
1932         (match_operand:TI 1 "general_operand" ""))]
1933   "reload_completed
1934    && !SSE_REG_P (operands[0]) && !SSE_REG_P (operands[1])"
1935   [(const_int 0)]
1936   "ix86_split_long_move (operands); DONE;")
1937
1938 (define_insn "*movti_internal_sse"
1939   [(set (match_operand:TI 0 "nonimmediate_operand" "=x,x,m")
1940         (match_operand:TI 1 "vector_move_operand" "C,xm,x"))]
1941   "TARGET_SSE && !TARGET_64BIT
1942    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1943 {
1944   switch (which_alternative)
1945     {
1946     case 0:
1947       if (get_attr_mode (insn) == MODE_V4SF)
1948         return "%vxorps\t%0, %d0";
1949       else
1950         return "%vpxor\t%0, %d0";
1951     case 1:
1952     case 2:
1953       /* TDmode values are passed as TImode on the stack.  Moving them
1954          to stack may result in unaligned memory access.  */
1955       if (misaligned_operand (operands[0], TImode)
1956           || misaligned_operand (operands[1], TImode))
1957         {
1958           if (get_attr_mode (insn) == MODE_V4SF)
1959             return "%vmovups\t{%1, %0|%0, %1}";
1960           else
1961             return "%vmovdqu\t{%1, %0|%0, %1}";
1962         }
1963       else
1964         {
1965           if (get_attr_mode (insn) == MODE_V4SF)
1966             return "%vmovaps\t{%1, %0|%0, %1}";
1967           else
1968             return "%vmovdqa\t{%1, %0|%0, %1}";
1969         }
1970     default:
1971       gcc_unreachable ();
1972     }
1973 }
1974   [(set_attr "type" "sselog1,ssemov,ssemov")
1975    (set_attr "prefix" "maybe_vex")
1976    (set (attr "mode")
1977         (cond [(ior (eq (symbol_ref "TARGET_SSE2") (const_int 0))
1978                     (ne (symbol_ref "optimize_function_for_size_p (cfun)")
1979                         (const_int 0)))
1980                  (const_string "V4SF")
1981                (and (eq_attr "alternative" "2")
1982                     (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
1983                         (const_int 0)))
1984                  (const_string "V4SF")]
1985               (const_string "TI")))])
1986
1987 (define_insn "*movdi_internal_rex64"
1988   [(set (match_operand:DI 0 "nonimmediate_operand"
1989           "=r,r  ,r,m ,!m,*y,*y,?r ,m ,?*Ym,?*y,*x,*x,?r ,m,?*Yi,*x,?*x,?*Ym")
1990         (match_operand:DI 1 "general_operand"
1991           "Z ,rem,i,re,n ,C ,*y,*Ym,*y,r   ,m  ,C ,*x,*Yi,*x,r  ,m ,*Ym,*x"))]
1992   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1993 {
1994   switch (get_attr_type (insn))
1995     {
1996     case TYPE_SSECVT:
1997       if (SSE_REG_P (operands[0]))
1998         return "movq2dq\t{%1, %0|%0, %1}";
1999       else
2000         return "movdq2q\t{%1, %0|%0, %1}";
2001
2002     case TYPE_SSEMOV:
2003       if (get_attr_mode (insn) == MODE_TI)
2004         return "%vmovdqa\t{%1, %0|%0, %1}";
2005       /* Handle broken assemblers that require movd instead of movq.  */
2006       if (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1]))
2007         return "%vmovd\t{%1, %0|%0, %1}";
2008       else
2009         return "%vmovq\t{%1, %0|%0, %1}";
2010
2011     case TYPE_MMXMOV:
2012       /* Handle broken assemblers that require movd instead of movq.  */
2013       if (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1]))
2014         return "movd\t{%1, %0|%0, %1}";
2015       else
2016         return "movq\t{%1, %0|%0, %1}";
2017
2018     case TYPE_SSELOG1:
2019       return "%vpxor\t%0, %d0";
2020
2021     case TYPE_MMX:
2022       return "pxor\t%0, %0";
2023
2024     case TYPE_MULTI:
2025       return "#";
2026
2027     case TYPE_LEA:
2028       return "lea{q}\t{%a1, %0|%0, %a1}";
2029
2030     default:
2031       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
2032       if (get_attr_mode (insn) == MODE_SI)
2033         return "mov{l}\t{%k1, %k0|%k0, %k1}";
2034       else if (which_alternative == 2)
2035         return "movabs{q}\t{%1, %0|%0, %1}";
2036       else
2037         return "mov{q}\t{%1, %0|%0, %1}";
2038     }
2039 }
2040   [(set (attr "type")
2041      (cond [(eq_attr "alternative" "5")
2042               (const_string "mmx")
2043             (eq_attr "alternative" "6,7,8,9,10")
2044               (const_string "mmxmov")
2045             (eq_attr "alternative" "11")
2046               (const_string "sselog1")
2047             (eq_attr "alternative" "12,13,14,15,16")
2048               (const_string "ssemov")
2049             (eq_attr "alternative" "17,18")
2050               (const_string "ssecvt")
2051             (eq_attr "alternative" "4")
2052               (const_string "multi")
2053             (match_operand:DI 1 "pic_32bit_operand" "")
2054               (const_string "lea")
2055            ]
2056            (const_string "imov")))
2057    (set (attr "modrm")
2058      (if_then_else
2059        (and (eq_attr "alternative" "2") (eq_attr "type" "imov"))
2060          (const_string "0")
2061          (const_string "*")))
2062    (set (attr "length_immediate")
2063      (if_then_else
2064        (and (eq_attr "alternative" "2") (eq_attr "type" "imov"))
2065          (const_string "8")
2066          (const_string "*")))
2067    (set_attr "prefix_rex" "*,*,*,*,*,*,*,1,*,1,*,*,*,*,*,*,*,*,*")
2068    (set_attr "prefix_data16" "*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,1,*,*,*")
2069    (set (attr "prefix")
2070      (if_then_else (eq_attr "alternative" "11,12,13,14,15,16")
2071        (const_string "maybe_vex")
2072        (const_string "orig")))
2073    (set_attr "mode" "SI,DI,DI,DI,SI,DI,DI,DI,DI,DI,DI,TI,TI,DI,DI,DI,DI,DI,DI")])
2074
2075 ;; Convert impossible stores of immediate to existing instructions.
2076 ;; First try to get scratch register and go through it.  In case this
2077 ;; fails, move by 32bit parts.
2078 (define_peephole2
2079   [(match_scratch:DI 2 "r")
2080    (set (match_operand:DI 0 "memory_operand" "")
2081         (match_operand:DI 1 "immediate_operand" ""))]
2082   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2083    && !x86_64_immediate_operand (operands[1], DImode)"
2084   [(set (match_dup 2) (match_dup 1))
2085    (set (match_dup 0) (match_dup 2))])
2086
2087 ;; We need to define this as both peepholer and splitter for case
2088 ;; peephole2 pass is not run.
2089 ;; "&& 1" is needed to keep it from matching the previous pattern.
2090 (define_peephole2
2091   [(set (match_operand:DI 0 "memory_operand" "")
2092         (match_operand:DI 1 "immediate_operand" ""))]
2093   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2094    && !x86_64_immediate_operand (operands[1], DImode) && 1"
2095   [(set (match_dup 2) (match_dup 3))
2096    (set (match_dup 4) (match_dup 5))]
2097   "split_double_mode (DImode, &operands[0], 2, &operands[2], &operands[4]);")
2098
2099 (define_split
2100   [(set (match_operand:DI 0 "memory_operand" "")
2101         (match_operand:DI 1 "immediate_operand" ""))]
2102   "TARGET_64BIT && ((optimize > 0 && flag_peephole2)
2103                     ? epilogue_completed : reload_completed)
2104    && !symbolic_operand (operands[1], DImode)
2105    && !x86_64_immediate_operand (operands[1], DImode)"
2106   [(set (match_dup 2) (match_dup 3))
2107    (set (match_dup 4) (match_dup 5))]
2108   "split_double_mode (DImode, &operands[0], 2, &operands[2], &operands[4]);")
2109
2110 (define_insn "*movdi_internal"
2111   [(set (match_operand:DI 0 "nonimmediate_operand"
2112                         "=r  ,o  ,*y,m*y,*y,*Y2,m  ,*Y2,*Y2,*x,m ,*x,*x")
2113         (match_operand:DI 1 "general_operand"
2114                         "riFo,riF,C ,*y ,m ,C  ,*Y2,*Y2,m  ,C ,*x,*x,m "))]
2115   "!TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2116   "@
2117    #
2118    #
2119    pxor\t%0, %0
2120    movq\t{%1, %0|%0, %1}
2121    movq\t{%1, %0|%0, %1}
2122    %vpxor\t%0, %d0
2123    %vmovq\t{%1, %0|%0, %1}
2124    %vmovdqa\t{%1, %0|%0, %1}
2125    %vmovq\t{%1, %0|%0, %1}
2126    xorps\t%0, %0
2127    movlps\t{%1, %0|%0, %1}
2128    movaps\t{%1, %0|%0, %1}
2129    movlps\t{%1, %0|%0, %1}"
2130   [(set (attr "isa")
2131      (if_then_else (eq_attr "alternative" "9,10,11,12")
2132        (const_string "noavx")
2133        (const_string "base")))
2134    (set_attr "type" "*,*,mmx,mmxmov,mmxmov,sselog1,ssemov,ssemov,ssemov,sselog1,ssemov,ssemov,ssemov")
2135    (set (attr "prefix")
2136      (if_then_else (eq_attr "alternative" "5,6,7,8")
2137        (const_string "maybe_vex")
2138        (const_string "orig")))
2139    (set_attr "mode" "DI,DI,DI,DI,DI,TI,DI,TI,DI,V4SF,V2SF,V4SF,V2SF")])
2140
2141 (define_split
2142   [(set (match_operand:DI 0 "nonimmediate_operand" "")
2143         (match_operand:DI 1 "general_operand" ""))]
2144   "!TARGET_64BIT && reload_completed
2145    && !(MMX_REG_P (operands[0]) || SSE_REG_P (operands[0]))
2146    && !(MMX_REG_P (operands[1]) || SSE_REG_P (operands[1]))"
2147   [(const_int 0)]
2148   "ix86_split_long_move (operands); DONE;")
2149
2150 (define_insn "*movsi_internal"
2151   [(set (match_operand:SI 0 "nonimmediate_operand"
2152                         "=r,m ,*y,*y,?rm,?*y,*x,*x,?r ,m ,?*Yi,*x")
2153         (match_operand:SI 1 "general_operand"
2154                         "g ,ri,C ,*y,*y ,rm ,C ,*x,*Yi,*x,r   ,m "))]
2155   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
2156 {
2157   switch (get_attr_type (insn))
2158     {
2159     case TYPE_SSELOG1:
2160       if (get_attr_mode (insn) == MODE_TI)
2161         return "%vpxor\t%0, %d0";
2162       return "%vxorps\t%0, %d0";
2163
2164     case TYPE_SSEMOV:
2165       switch (get_attr_mode (insn))
2166         {
2167         case MODE_TI:
2168           return "%vmovdqa\t{%1, %0|%0, %1}";
2169         case MODE_V4SF:
2170           return "%vmovaps\t{%1, %0|%0, %1}";
2171         case MODE_SI:
2172           return "%vmovd\t{%1, %0|%0, %1}";
2173         case MODE_SF:
2174           return "%vmovss\t{%1, %0|%0, %1}";
2175         default:
2176           gcc_unreachable ();
2177         }
2178
2179     case TYPE_MMX:
2180       return "pxor\t%0, %0";
2181
2182     case TYPE_MMXMOV:
2183       if (get_attr_mode (insn) == MODE_DI)
2184         return "movq\t{%1, %0|%0, %1}";
2185       return "movd\t{%1, %0|%0, %1}";
2186
2187     case TYPE_LEA:
2188       return "lea{l}\t{%a1, %0|%0, %a1}";
2189
2190     default:
2191       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
2192       return "mov{l}\t{%1, %0|%0, %1}";
2193     }
2194 }
2195   [(set (attr "type")
2196      (cond [(eq_attr "alternative" "2")
2197               (const_string "mmx")
2198             (eq_attr "alternative" "3,4,5")
2199               (const_string "mmxmov")
2200             (eq_attr "alternative" "6")
2201               (const_string "sselog1")
2202             (eq_attr "alternative" "7,8,9,10,11")
2203               (const_string "ssemov")
2204             (match_operand:DI 1 "pic_32bit_operand" "")
2205               (const_string "lea")
2206            ]
2207            (const_string "imov")))
2208    (set (attr "prefix")
2209      (if_then_else (eq_attr "alternative" "0,1,2,3,4,5")
2210        (const_string "orig")
2211        (const_string "maybe_vex")))
2212    (set (attr "prefix_data16")
2213      (if_then_else (and (eq_attr "type" "ssemov") (eq_attr "mode" "SI"))
2214        (const_string "1")
2215        (const_string "*")))
2216    (set (attr "mode")
2217      (cond [(eq_attr "alternative" "2,3")
2218               (const_string "DI")
2219             (eq_attr "alternative" "6,7")
2220               (if_then_else
2221                 (eq (symbol_ref "TARGET_SSE2") (const_int 0))
2222                 (const_string "V4SF")
2223                 (const_string "TI"))
2224             (and (eq_attr "alternative" "8,9,10,11")
2225                  (eq (symbol_ref "TARGET_SSE2") (const_int 0)))
2226               (const_string "SF")
2227            ]
2228            (const_string "SI")))])
2229
2230 (define_insn "*movhi_internal"
2231   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,m")
2232         (match_operand:HI 1 "general_operand" "r,rn,rm,rn"))]
2233   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
2234 {
2235   switch (get_attr_type (insn))
2236     {
2237     case TYPE_IMOVX:
2238       /* movzwl is faster than movw on p2 due to partial word stalls,
2239          though not as fast as an aligned movl.  */
2240       return "movz{wl|x}\t{%1, %k0|%k0, %1}";
2241     default:
2242       if (get_attr_mode (insn) == MODE_SI)
2243         return "mov{l}\t{%k1, %k0|%k0, %k1}";
2244       else
2245         return "mov{w}\t{%1, %0|%0, %1}";
2246     }
2247 }
2248   [(set (attr "type")
2249      (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
2250                 (const_int 0))
2251               (const_string "imov")
2252             (and (eq_attr "alternative" "0")
2253                  (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
2254                           (const_int 0))
2255                       (eq (symbol_ref "TARGET_HIMODE_MATH")
2256                           (const_int 0))))
2257               (const_string "imov")
2258             (and (eq_attr "alternative" "1,2")
2259                  (match_operand:HI 1 "aligned_operand" ""))
2260               (const_string "imov")
2261             (and (ne (symbol_ref "TARGET_MOVX")
2262                      (const_int 0))
2263                  (eq_attr "alternative" "0,2"))
2264               (const_string "imovx")
2265            ]
2266            (const_string "imov")))
2267     (set (attr "mode")
2268       (cond [(eq_attr "type" "imovx")
2269                (const_string "SI")
2270              (and (eq_attr "alternative" "1,2")
2271                   (match_operand:HI 1 "aligned_operand" ""))
2272                (const_string "SI")
2273              (and (eq_attr "alternative" "0")
2274                   (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
2275                            (const_int 0))
2276                        (eq (symbol_ref "TARGET_HIMODE_MATH")
2277                            (const_int 0))))
2278                (const_string "SI")
2279             ]
2280             (const_string "HI")))])
2281
2282 ;; Situation is quite tricky about when to choose full sized (SImode) move
2283 ;; over QImode moves.  For Q_REG -> Q_REG move we use full size only for
2284 ;; partial register dependency machines (such as AMD Athlon), where QImode
2285 ;; moves issue extra dependency and for partial register stalls machines
2286 ;; that don't use QImode patterns (and QImode move cause stall on the next
2287 ;; instruction).
2288 ;;
2289 ;; For loads of Q_REG to NONQ_REG we use full sized moves except for partial
2290 ;; register stall machines with, where we use QImode instructions, since
2291 ;; partial register stall can be caused there.  Then we use movzx.
2292 (define_insn "*movqi_internal"
2293   [(set (match_operand:QI 0 "nonimmediate_operand" "=q,q ,q ,r,r ,?r,m")
2294         (match_operand:QI 1 "general_operand"      " q,qn,qm,q,rn,qm,qn"))]
2295   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
2296 {
2297   switch (get_attr_type (insn))
2298     {
2299     case TYPE_IMOVX:
2300       gcc_assert (ANY_QI_REG_P (operands[1]) || MEM_P (operands[1]));
2301       return "movz{bl|x}\t{%1, %k0|%k0, %1}";
2302     default:
2303       if (get_attr_mode (insn) == MODE_SI)
2304         return "mov{l}\t{%k1, %k0|%k0, %k1}";
2305       else
2306         return "mov{b}\t{%1, %0|%0, %1}";
2307     }
2308 }
2309   [(set (attr "type")
2310      (cond [(and (eq_attr "alternative" "5")
2311                  (not (match_operand:QI 1 "aligned_operand" "")))
2312               (const_string "imovx")
2313             (ne (symbol_ref "optimize_function_for_size_p (cfun)")
2314                 (const_int 0))
2315               (const_string "imov")
2316             (and (eq_attr "alternative" "3")
2317                  (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
2318                           (const_int 0))
2319                       (eq (symbol_ref "TARGET_QIMODE_MATH")
2320                           (const_int 0))))
2321               (const_string "imov")
2322             (eq_attr "alternative" "3,5")
2323               (const_string "imovx")
2324             (and (ne (symbol_ref "TARGET_MOVX")
2325                      (const_int 0))
2326                  (eq_attr "alternative" "2"))
2327               (const_string "imovx")
2328            ]
2329            (const_string "imov")))
2330    (set (attr "mode")
2331       (cond [(eq_attr "alternative" "3,4,5")
2332                (const_string "SI")
2333              (eq_attr "alternative" "6")
2334                (const_string "QI")
2335              (eq_attr "type" "imovx")
2336                (const_string "SI")
2337              (and (eq_attr "type" "imov")
2338                   (and (eq_attr "alternative" "0,1")
2339                        (and (ne (symbol_ref "TARGET_PARTIAL_REG_DEPENDENCY")
2340                                 (const_int 0))
2341                             (and (eq (symbol_ref "optimize_function_for_size_p (cfun)")
2342                                      (const_int 0))
2343                                  (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
2344                                      (const_int 0))))))
2345                (const_string "SI")
2346              ;; Avoid partial register stalls when not using QImode arithmetic
2347              (and (eq_attr "type" "imov")
2348                   (and (eq_attr "alternative" "0,1")
2349                        (and (ne (symbol_ref "TARGET_PARTIAL_REG_STALL")
2350                                 (const_int 0))
2351                             (eq (symbol_ref "TARGET_QIMODE_MATH")
2352                                 (const_int 0)))))
2353                (const_string "SI")
2354            ]
2355            (const_string "QI")))])
2356
2357 ;; Stores and loads of ax to arbitrary constant address.
2358 ;; We fake an second form of instruction to force reload to load address
2359 ;; into register when rax is not available
2360 (define_insn "*movabs<mode>_1"
2361   [(set (mem:SWI1248x (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
2362         (match_operand:SWI1248x 1 "nonmemory_operand" "a,er"))]
2363   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
2364   "@
2365    movabs{<imodesuffix>}\t{%1, %P0|%P0, %1}
2366    mov{<imodesuffix>}\t{%1, %a0|%a0, %1}"
2367   [(set_attr "type" "imov")
2368    (set_attr "modrm" "0,*")
2369    (set_attr "length_address" "8,0")
2370    (set_attr "length_immediate" "0,*")
2371    (set_attr "memory" "store")
2372    (set_attr "mode" "<MODE>")])
2373
2374 (define_insn "*movabs<mode>_2"
2375   [(set (match_operand:SWI1248x 0 "register_operand" "=a,r")
2376         (mem:SWI1248x (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
2377   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
2378   "@
2379    movabs{<imodesuffix>}\t{%P1, %0|%0, %P1}
2380    mov{<imodesuffix>}\t{%a1, %0|%0, %a1}"
2381   [(set_attr "type" "imov")
2382    (set_attr "modrm" "0,*")
2383    (set_attr "length_address" "8,0")
2384    (set_attr "length_immediate" "0")
2385    (set_attr "memory" "load")
2386    (set_attr "mode" "<MODE>")])
2387
2388 (define_insn "*swap<mode>"
2389   [(set (match_operand:SWI48 0 "register_operand" "+r")
2390         (match_operand:SWI48 1 "register_operand" "+r"))
2391    (set (match_dup 1)
2392         (match_dup 0))]
2393   ""
2394   "xchg{<imodesuffix>}\t%1, %0"
2395   [(set_attr "type" "imov")
2396    (set_attr "mode" "<MODE>")
2397    (set_attr "pent_pair" "np")
2398    (set_attr "athlon_decode" "vector")
2399    (set_attr "amdfam10_decode" "double")
2400    (set_attr "bdver1_decode" "double")])
2401
2402 (define_insn "*swap<mode>_1"
2403   [(set (match_operand:SWI12 0 "register_operand" "+r")
2404         (match_operand:SWI12 1 "register_operand" "+r"))
2405    (set (match_dup 1)
2406         (match_dup 0))]
2407   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
2408   "xchg{l}\t%k1, %k0"
2409   [(set_attr "type" "imov")
2410    (set_attr "mode" "SI")
2411    (set_attr "pent_pair" "np")
2412    (set_attr "athlon_decode" "vector")
2413    (set_attr "amdfam10_decode" "double")
2414    (set_attr "bdver1_decode" "double")])
2415
2416 ;; Not added amdfam10_decode since TARGET_PARTIAL_REG_STALL
2417 ;; is disabled for AMDFAM10
2418 (define_insn "*swap<mode>_2"
2419   [(set (match_operand:SWI12 0 "register_operand" "+<r>")
2420         (match_operand:SWI12 1 "register_operand" "+<r>"))
2421    (set (match_dup 1)
2422         (match_dup 0))]
2423   "TARGET_PARTIAL_REG_STALL"
2424   "xchg{<imodesuffix>}\t%1, %0"
2425   [(set_attr "type" "imov")
2426    (set_attr "mode" "<MODE>")
2427    (set_attr "pent_pair" "np")
2428    (set_attr "athlon_decode" "vector")])
2429
2430 (define_expand "movstrict<mode>"
2431   [(set (strict_low_part (match_operand:SWI12 0 "nonimmediate_operand" ""))
2432         (match_operand:SWI12 1 "general_operand" ""))]
2433   ""
2434 {
2435   if (TARGET_PARTIAL_REG_STALL && optimize_function_for_speed_p (cfun))
2436     FAIL;
2437   if (GET_CODE (operands[0]) == SUBREG
2438       && GET_MODE_CLASS (GET_MODE (SUBREG_REG (operands[0]))) != MODE_INT)
2439     FAIL;
2440   /* Don't generate memory->memory moves, go through a register */
2441   if (MEM_P (operands[0]) && MEM_P (operands[1]))
2442     operands[1] = force_reg (<MODE>mode, operands[1]);
2443 })
2444
2445 (define_insn "*movstrict<mode>_1"
2446   [(set (strict_low_part
2447           (match_operand:SWI12 0 "nonimmediate_operand" "+<r>m,<r>"))
2448         (match_operand:SWI12 1 "general_operand" "<r>n,m"))]
2449   "(!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
2450    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2451   "mov{<imodesuffix>}\t{%1, %0|%0, %1}"
2452   [(set_attr "type" "imov")
2453    (set_attr "mode" "<MODE>")])
2454
2455 (define_insn "*movstrict<mode>_xor"
2456   [(set (strict_low_part (match_operand:SWI12 0 "register_operand" "+<r>"))
2457         (match_operand:SWI12 1 "const0_operand" ""))
2458    (clobber (reg:CC FLAGS_REG))]
2459   "reload_completed"
2460   "xor{<imodesuffix>}\t%0, %0"
2461   [(set_attr "type" "alu1")
2462    (set_attr "mode" "<MODE>")
2463    (set_attr "length_immediate" "0")])
2464
2465 (define_insn "*mov<mode>_extv_1"
2466   [(set (match_operand:SWI24 0 "register_operand" "=R")
2467         (sign_extract:SWI24 (match_operand 1 "ext_register_operand" "Q")
2468                             (const_int 8)
2469                             (const_int 8)))]
2470   ""
2471   "movs{bl|x}\t{%h1, %k0|%k0, %h1}"
2472   [(set_attr "type" "imovx")
2473    (set_attr "mode" "SI")])
2474
2475 (define_insn "*movqi_extv_1_rex64"
2476   [(set (match_operand:QI 0 "register_operand" "=Q,?R")
2477         (sign_extract:QI (match_operand 1 "ext_register_operand" "Q,Q")
2478                          (const_int 8)
2479                          (const_int 8)))]
2480   "TARGET_64BIT"
2481 {
2482   switch (get_attr_type (insn))
2483     {
2484     case TYPE_IMOVX:
2485       return "movs{bl|x}\t{%h1, %k0|%k0, %h1}";
2486     default:
2487       return "mov{b}\t{%h1, %0|%0, %h1}";
2488     }
2489 }
2490   [(set (attr "type")
2491      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2492                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2493                              (ne (symbol_ref "TARGET_MOVX")
2494                                  (const_int 0))))
2495         (const_string "imovx")
2496         (const_string "imov")))
2497    (set (attr "mode")
2498      (if_then_else (eq_attr "type" "imovx")
2499         (const_string "SI")
2500         (const_string "QI")))])
2501
2502 (define_insn "*movqi_extv_1"
2503   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?r")
2504         (sign_extract:QI (match_operand 1 "ext_register_operand" "Q,Q")
2505                          (const_int 8)
2506                          (const_int 8)))]
2507   "!TARGET_64BIT"
2508 {
2509   switch (get_attr_type (insn))
2510     {
2511     case TYPE_IMOVX:
2512       return "movs{bl|x}\t{%h1, %k0|%k0, %h1}";
2513     default:
2514       return "mov{b}\t{%h1, %0|%0, %h1}";
2515     }
2516 }
2517   [(set (attr "type")
2518      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2519                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2520                              (ne (symbol_ref "TARGET_MOVX")
2521                                  (const_int 0))))
2522         (const_string "imovx")
2523         (const_string "imov")))
2524    (set (attr "mode")
2525      (if_then_else (eq_attr "type" "imovx")
2526         (const_string "SI")
2527         (const_string "QI")))])
2528
2529 (define_insn "*mov<mode>_extzv_1"
2530   [(set (match_operand:SWI48 0 "register_operand" "=R")
2531         (zero_extract:SWI48 (match_operand 1 "ext_register_operand" "Q")
2532                             (const_int 8)
2533                             (const_int 8)))]
2534   ""
2535   "movz{bl|x}\t{%h1, %k0|%k0, %h1}"
2536   [(set_attr "type" "imovx")
2537    (set_attr "mode" "SI")])
2538
2539 (define_insn "*movqi_extzv_2_rex64"
2540   [(set (match_operand:QI 0 "register_operand" "=Q,?R")
2541         (subreg:QI
2542           (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
2543                            (const_int 8)
2544                            (const_int 8)) 0))]
2545   "TARGET_64BIT"
2546 {
2547   switch (get_attr_type (insn))
2548     {
2549     case TYPE_IMOVX:
2550       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2551     default:
2552       return "mov{b}\t{%h1, %0|%0, %h1}";
2553     }
2554 }
2555   [(set (attr "type")
2556      (if_then_else (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2557                         (ne (symbol_ref "TARGET_MOVX")
2558                             (const_int 0)))
2559         (const_string "imovx")
2560         (const_string "imov")))
2561    (set (attr "mode")
2562      (if_then_else (eq_attr "type" "imovx")
2563         (const_string "SI")
2564         (const_string "QI")))])
2565
2566 (define_insn "*movqi_extzv_2"
2567   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?R")
2568         (subreg:QI
2569           (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
2570                            (const_int 8)
2571                            (const_int 8)) 0))]
2572   "!TARGET_64BIT"
2573 {
2574   switch (get_attr_type (insn))
2575     {
2576     case TYPE_IMOVX:
2577       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2578     default:
2579       return "mov{b}\t{%h1, %0|%0, %h1}";
2580     }
2581 }
2582   [(set (attr "type")
2583      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2584                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2585                              (ne (symbol_ref "TARGET_MOVX")
2586                                  (const_int 0))))
2587         (const_string "imovx")
2588         (const_string "imov")))
2589    (set (attr "mode")
2590      (if_then_else (eq_attr "type" "imovx")
2591         (const_string "SI")
2592         (const_string "QI")))])
2593
2594 (define_expand "mov<mode>_insv_1"
2595   [(set (zero_extract:SWI48 (match_operand 0 "ext_register_operand" "")
2596                             (const_int 8)
2597                             (const_int 8))
2598         (match_operand:SWI48 1 "nonmemory_operand" ""))])
2599
2600 (define_insn "*mov<mode>_insv_1_rex64"
2601   [(set (zero_extract:SWI48x (match_operand 0 "ext_register_operand" "+Q")
2602                              (const_int 8)
2603                              (const_int 8))
2604         (match_operand:SWI48x 1 "nonmemory_operand" "Qn"))]
2605   "TARGET_64BIT"
2606   "mov{b}\t{%b1, %h0|%h0, %b1}"
2607   [(set_attr "type" "imov")
2608    (set_attr "mode" "QI")])
2609
2610 (define_insn "*movsi_insv_1"
2611   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2612                          (const_int 8)
2613                          (const_int 8))
2614         (match_operand:SI 1 "general_operand" "Qmn"))]
2615   "!TARGET_64BIT"
2616   "mov{b}\t{%b1, %h0|%h0, %b1}"
2617   [(set_attr "type" "imov")
2618    (set_attr "mode" "QI")])
2619
2620 (define_insn "*movqi_insv_2"
2621   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2622                          (const_int 8)
2623                          (const_int 8))
2624         (lshiftrt:SI (match_operand:SI 1 "register_operand" "Q")
2625                      (const_int 8)))]
2626   ""
2627   "mov{b}\t{%h1, %h0|%h0, %h1}"
2628   [(set_attr "type" "imov")
2629    (set_attr "mode" "QI")])
2630 \f
2631 ;; Floating point push instructions.
2632
2633 (define_insn "*pushtf"
2634   [(set (match_operand:TF 0 "push_operand" "=<,<,<")
2635         (match_operand:TF 1 "general_no_elim_operand" "x,Fo,*r"))]
2636   "TARGET_SSE2"
2637 {
2638   /* This insn should be already split before reg-stack.  */
2639   gcc_unreachable ();
2640 }
2641   [(set_attr "type" "multi")
2642    (set_attr "unit" "sse,*,*")
2643    (set_attr "mode" "TF,SI,SI")])
2644
2645 (define_split
2646   [(set (match_operand:TF 0 "push_operand" "")
2647         (match_operand:TF 1 "sse_reg_operand" ""))]
2648   "TARGET_SSE2 && reload_completed"
2649   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -16)))
2650    (set (mem:TF (reg:P SP_REG)) (match_dup 1))])
2651
2652 (define_split
2653   [(set (match_operand:TF 0 "push_operand" "")
2654         (match_operand:TF 1 "general_operand" ""))]
2655   "TARGET_SSE2 && reload_completed
2656    && !SSE_REG_P (operands[1])"
2657   [(const_int 0)]
2658   "ix86_split_long_move (operands); DONE;")
2659
2660 (define_insn "*pushxf"
2661   [(set (match_operand:XF 0 "push_operand" "=<,<")
2662         (match_operand:XF 1 "general_no_elim_operand" "f,ro"))]
2663   "optimize_function_for_speed_p (cfun)"
2664 {
2665   /* This insn should be already split before reg-stack.  */
2666   gcc_unreachable ();
2667 }
2668   [(set_attr "type" "multi")
2669    (set_attr "unit" "i387,*")
2670    (set_attr "mode" "XF,SI")])
2671
2672 ;; Size of pushxf is 3 (for sub) + 2 (for fstp) + memory operand size.
2673 ;; Size of pushxf using integer instructions is 3+3*memory operand size
2674 ;; Pushing using integer instructions is longer except for constants
2675 ;; and direct memory references (assuming that any given constant is pushed
2676 ;; only once, but this ought to be handled elsewhere).
2677
2678 (define_insn "*pushxf_nointeger"
2679   [(set (match_operand:XF 0 "push_operand" "=X,X,X")
2680         (match_operand:XF 1 "general_no_elim_operand" "f,Fo,*r"))]
2681   "optimize_function_for_size_p (cfun)"
2682 {
2683   /* This insn should be already split before reg-stack.  */
2684   gcc_unreachable ();
2685 }
2686   [(set_attr "type" "multi")
2687    (set_attr "unit" "i387,*,*")
2688    (set_attr "mode" "XF,SI,SI")])
2689
2690 (define_split
2691   [(set (match_operand:XF 0 "push_operand" "")
2692         (match_operand:XF 1 "fp_register_operand" ""))]
2693   "reload_completed"
2694   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
2695    (set (mem:XF (reg:P SP_REG)) (match_dup 1))]
2696   "operands[2] = GEN_INT (-GET_MODE_SIZE (XFmode));")
2697
2698 (define_split
2699   [(set (match_operand:XF 0 "push_operand" "")
2700         (match_operand:XF 1 "general_operand" ""))]
2701   "reload_completed
2702    && !FP_REG_P (operands[1])"
2703   [(const_int 0)]
2704   "ix86_split_long_move (operands); DONE;")
2705
2706 ;; Size of pushdf is 3 (for sub) + 2 (for fstp) + memory operand size.
2707 ;; Size of pushdf using integer instructions is 2+2*memory operand size
2708 ;; On the average, pushdf using integers can be still shorter.
2709
2710 (define_insn "*pushdf"
2711   [(set (match_operand:DF 0 "push_operand" "=<,<,<")
2712         (match_operand:DF 1 "general_no_elim_operand" "f,Yd*rFo,Y2"))]
2713   ""
2714 {
2715   /* This insn should be already split before reg-stack.  */
2716   gcc_unreachable ();
2717 }
2718   [(set_attr "type" "multi")
2719    (set_attr "unit" "i387,*,*")
2720    (set_attr "mode" "DF,SI,DF")])
2721
2722 ;; %%% Kill this when call knows how to work this out.
2723 (define_split
2724   [(set (match_operand:DF 0 "push_operand" "")
2725         (match_operand:DF 1 "any_fp_register_operand" ""))]
2726   "reload_completed"
2727   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -8)))
2728    (set (mem:DF (reg:P SP_REG)) (match_dup 1))])
2729
2730 (define_split
2731   [(set (match_operand:DF 0 "push_operand" "")
2732         (match_operand:DF 1 "general_operand" ""))]
2733   "reload_completed
2734    && !ANY_FP_REG_P (operands[1])"
2735   [(const_int 0)]
2736   "ix86_split_long_move (operands); DONE;")
2737
2738 (define_insn "*pushsf_rex64"
2739   [(set (match_operand:SF 0 "push_operand" "=X,X,X")
2740         (match_operand:SF 1 "nonmemory_no_elim_operand" "f,rF,x"))]
2741   "TARGET_64BIT"
2742 {
2743   /* Anything else should be already split before reg-stack.  */
2744   gcc_assert (which_alternative == 1);
2745   return "push{q}\t%q1";
2746 }
2747   [(set_attr "type" "multi,push,multi")
2748    (set_attr "unit" "i387,*,*")
2749    (set_attr "mode" "SF,DI,SF")])
2750
2751 (define_insn "*pushsf"
2752   [(set (match_operand:SF 0 "push_operand" "=<,<,<")
2753         (match_operand:SF 1 "general_no_elim_operand" "f,rFm,x"))]
2754   "!TARGET_64BIT"
2755 {
2756   /* Anything else should be already split before reg-stack.  */
2757   gcc_assert (which_alternative == 1);
2758   return "push{l}\t%1";
2759 }
2760   [(set_attr "type" "multi,push,multi")
2761    (set_attr "unit" "i387,*,*")
2762    (set_attr "mode" "SF,SI,SF")])
2763
2764 (define_split
2765   [(set (match_operand:SF 0 "push_operand" "")
2766         (match_operand:SF 1 "memory_operand" ""))]
2767   "reload_completed
2768    && MEM_P (operands[1])
2769    && (operands[2] = find_constant_src (insn))"
2770   [(set (match_dup 0)
2771         (match_dup 2))])
2772
2773 ;; %%% Kill this when call knows how to work this out.
2774 (define_split
2775   [(set (match_operand:SF 0 "push_operand" "")
2776         (match_operand:SF 1 "any_fp_register_operand" ""))]
2777   "reload_completed"
2778   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
2779    (set (mem:SF (reg:P SP_REG)) (match_dup 1))]
2780   "operands[2] = GEN_INT (-GET_MODE_SIZE (<MODE>mode));")
2781 \f
2782 ;; Floating point move instructions.
2783
2784 (define_expand "movtf"
2785   [(set (match_operand:TF 0 "nonimmediate_operand" "")
2786         (match_operand:TF 1 "nonimmediate_operand" ""))]
2787   "TARGET_SSE2"
2788 {
2789   ix86_expand_move (TFmode, operands);
2790   DONE;
2791 })
2792
2793 (define_expand "mov<mode>"
2794   [(set (match_operand:X87MODEF 0 "nonimmediate_operand" "")
2795         (match_operand:X87MODEF 1 "general_operand" ""))]
2796   ""
2797   "ix86_expand_move (<MODE>mode, operands); DONE;")
2798
2799 (define_insn "*movtf_internal"
2800   [(set (match_operand:TF 0 "nonimmediate_operand" "=x,m,x,?r,?o")
2801         (match_operand:TF 1 "general_operand" "xm,x,C,roF,Fr"))]
2802   "TARGET_SSE2
2803    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2804 {
2805   switch (which_alternative)
2806     {
2807     case 0:
2808     case 1:
2809       if (get_attr_mode (insn) == MODE_V4SF)
2810         return "%vmovaps\t{%1, %0|%0, %1}";
2811       else
2812         return "%vmovdqa\t{%1, %0|%0, %1}";
2813
2814     case 2:
2815       return standard_sse_constant_opcode (insn, operands[1]);
2816
2817     case 3:
2818     case 4:
2819         return "#";
2820
2821     default:
2822       gcc_unreachable ();
2823     }
2824 }
2825   [(set_attr "type" "ssemov,ssemov,sselog1,*,*")
2826    (set_attr "prefix" "maybe_vex,maybe_vex,maybe_vex,*,*")
2827    (set (attr "mode")
2828         (cond [(eq_attr "alternative" "0,2")
2829                  (if_then_else
2830                    (ne (symbol_ref "optimize_function_for_size_p (cfun)")
2831                        (const_int 0))
2832                    (const_string "V4SF")
2833                    (const_string "TI"))
2834                (eq_attr "alternative" "1")
2835                  (if_then_else
2836                    (ior (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
2837                             (const_int 0))
2838                         (ne (symbol_ref "optimize_function_for_size_p (cfun)")
2839                             (const_int 0)))
2840                    (const_string "V4SF")
2841                    (const_string "TI"))]
2842                (const_string "DI")))])
2843
2844 (define_split
2845   [(set (match_operand:TF 0 "nonimmediate_operand" "")
2846         (match_operand:TF 1 "general_operand" ""))]
2847   "reload_completed
2848    && !(SSE_REG_P (operands[0]) || SSE_REG_P (operands[1]))"
2849   [(const_int 0)]
2850   "ix86_split_long_move (operands); DONE;")
2851
2852 (define_insn "*movxf_internal"
2853   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,Yx*r  ,o")
2854         (match_operand:XF 1 "general_operand"      "fm,f,G,Yx*roF,FYx*r"))]
2855   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
2856    && (!can_create_pseudo_p ()
2857        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
2858        || GET_CODE (operands[1]) != CONST_DOUBLE
2859        || (optimize_function_for_size_p (cfun)
2860            && standard_80387_constant_p (operands[1]) > 0)
2861        || memory_operand (operands[0], XFmode))"
2862 {
2863   switch (which_alternative)
2864     {
2865     case 0:
2866     case 1:
2867       return output_387_reg_move (insn, operands);
2868
2869     case 2:
2870       return standard_80387_constant_opcode (operands[1]);
2871
2872     case 3: case 4:
2873       return "#";
2874     default:
2875       gcc_unreachable ();
2876     }
2877 }
2878   [(set_attr "type" "fmov,fmov,fmov,multi,multi")
2879    (set_attr "mode" "XF,XF,XF,SI,SI")])
2880
2881 (define_split
2882   [(set (match_operand:XF 0 "nonimmediate_operand" "")
2883         (match_operand:XF 1 "general_operand" ""))]
2884   "reload_completed
2885    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
2886    && ! (FP_REG_P (operands[0]) ||
2887          (GET_CODE (operands[0]) == SUBREG
2888           && FP_REG_P (SUBREG_REG (operands[0]))))
2889    && ! (FP_REG_P (operands[1]) ||
2890          (GET_CODE (operands[1]) == SUBREG
2891           && FP_REG_P (SUBREG_REG (operands[1]))))"
2892   [(const_int 0)]
2893   "ix86_split_long_move (operands); DONE;")
2894
2895 (define_insn "*movdf_internal_rex64"
2896   [(set (match_operand:DF 0 "nonimmediate_operand"
2897                 "=f,m,f,r ,m,!r,!m,Y2*x,Y2*x,Y2*x,m   ,Yi,r ")
2898         (match_operand:DF 1 "general_operand"
2899                 "fm,f,G,rm,r,F ,F ,C   ,Y2*x,m   ,Y2*x,r ,Yi"))]
2900   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))
2901    && (!can_create_pseudo_p ()
2902        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
2903        || GET_CODE (operands[1]) != CONST_DOUBLE
2904        || (optimize_function_for_size_p (cfun)
2905            && ((!(TARGET_SSE2 && TARGET_SSE_MATH)
2906                 && standard_80387_constant_p (operands[1]) > 0)
2907                || (TARGET_SSE2 && TARGET_SSE_MATH
2908                    && standard_sse_constant_p (operands[1]))))
2909        || memory_operand (operands[0], DFmode))"
2910 {
2911   switch (which_alternative)
2912     {
2913     case 0:
2914     case 1:
2915       return output_387_reg_move (insn, operands);
2916
2917     case 2:
2918       return standard_80387_constant_opcode (operands[1]);
2919
2920     case 3:
2921     case 4:
2922       return "mov{q}\t{%1, %0|%0, %1}";
2923
2924     case 5:
2925       return "movabs{q}\t{%1, %0|%0, %1}";
2926
2927     case 6:
2928       return "#";
2929
2930     case 7:
2931       return standard_sse_constant_opcode (insn, operands[1]);
2932
2933     case 8:
2934     case 9:
2935     case 10:
2936       switch (get_attr_mode (insn))
2937         {
2938         case MODE_V4SF:
2939           return "%vmovaps\t{%1, %0|%0, %1}";
2940         case MODE_V2DF:
2941           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
2942             return "%vmovaps\t{%1, %0|%0, %1}";
2943           else
2944             return "%vmovapd\t{%1, %0|%0, %1}";
2945         case MODE_TI:
2946           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
2947             return "%vmovaps\t{%1, %0|%0, %1}";
2948           else
2949             return "%vmovdqa\t{%1, %0|%0, %1}";
2950         case MODE_DI:
2951           return "%vmovq\t{%1, %0|%0, %1}";
2952         case MODE_DF:
2953           if (TARGET_AVX && REG_P (operands[0]) && REG_P (operands[1]))
2954             return "vmovsd\t{%1, %0, %0|%0, %0, %1}";
2955           else
2956             return "%vmovsd\t{%1, %0|%0, %1}";
2957         case MODE_V1DF:
2958           return "%vmovlpd\t{%1, %d0|%d0, %1}";
2959         case MODE_V2SF:
2960           return "%vmovlps\t{%1, %d0|%d0, %1}";
2961         default:
2962           gcc_unreachable ();
2963         }
2964
2965     case 11:
2966     case 12:
2967       /* Handle broken assemblers that require movd instead of movq.  */
2968       return "%vmovd\t{%1, %0|%0, %1}";
2969
2970     default:
2971       gcc_unreachable();
2972     }
2973 }
2974   [(set_attr "type" "fmov,fmov,fmov,imov,imov,imov,multi,sselog1,ssemov,ssemov,ssemov,ssemov,ssemov")
2975    (set (attr "modrm")
2976      (if_then_else
2977        (and (eq_attr "alternative" "5") (eq_attr "type" "imov"))
2978          (const_string "0")
2979          (const_string "*")))
2980    (set (attr "length_immediate")
2981      (if_then_else
2982        (and (eq_attr "alternative" "5") (eq_attr "type" "imov"))
2983          (const_string "8")
2984          (const_string "*")))
2985    (set (attr "prefix")
2986      (if_then_else (eq_attr "alternative" "0,1,2,3,4,5,6")
2987        (const_string "orig")
2988        (const_string "maybe_vex")))
2989    (set (attr "prefix_data16")
2990      (if_then_else (eq_attr "mode" "V1DF")
2991        (const_string "1")
2992        (const_string "*")))
2993    (set (attr "mode")
2994         (cond [(eq_attr "alternative" "0,1,2")
2995                  (const_string "DF")
2996                (eq_attr "alternative" "3,4,5,6,11,12")
2997                  (const_string "DI")
2998
2999                /* For SSE1, we have many fewer alternatives.  */
3000                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
3001                  (cond [(eq_attr "alternative" "7,8")
3002                           (const_string "V4SF")
3003                        ]
3004                    (const_string "V2SF"))
3005
3006                /* xorps is one byte shorter.  */
3007                (eq_attr "alternative" "7")
3008                  (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3009                             (const_int 0))
3010                           (const_string "V4SF")
3011                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3012                             (const_int 0))
3013                           (const_string "TI")
3014                        ]
3015                        (const_string "V2DF"))
3016
3017                /* For architectures resolving dependencies on
3018                   whole SSE registers use APD move to break dependency
3019                   chains, otherwise use short move to avoid extra work.
3020
3021                   movaps encodes one byte shorter.  */
3022                (eq_attr "alternative" "8")
3023                  (cond
3024                    [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3025                         (const_int 0))
3026                       (const_string "V4SF")
3027                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3028                         (const_int 0))
3029                       (const_string "V2DF")
3030                    ]
3031                    (const_string "DF"))
3032                /* For architectures resolving dependencies on register
3033                   parts we may avoid extra work to zero out upper part
3034                   of register.  */
3035                (eq_attr "alternative" "9")
3036                  (if_then_else
3037                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3038                        (const_int 0))
3039                    (const_string "V1DF")
3040                    (const_string "DF"))
3041               ]
3042               (const_string "DF")))])
3043
3044 ;; Possible store forwarding (partial memory) stall in alternative 4.
3045 (define_insn "*movdf_internal"
3046   [(set (match_operand:DF 0 "nonimmediate_operand"
3047                 "=f,m,f,Yd*r  ,o    ,Y2*x,Y2*x,Y2*x,m  ")
3048         (match_operand:DF 1 "general_operand"
3049                 "fm,f,G,Yd*roF,FYd*r,C   ,Y2*x,m   ,Y2*x"))]
3050   "!TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3051    && (!can_create_pseudo_p ()
3052        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3053        || GET_CODE (operands[1]) != CONST_DOUBLE
3054        || (!TARGET_INTEGER_DFMODE_MOVES
3055            && ((!(TARGET_SSE2 && TARGET_SSE_MATH)
3056                 && standard_80387_constant_p (operands[1]) > 0)
3057                || (TARGET_SSE2 && TARGET_SSE_MATH
3058                    && standard_sse_constant_p (operands[1])))
3059            && !memory_operand (operands[0], DFmode))
3060        || ((TARGET_INTEGER_DFMODE_MOVES
3061             || !TARGET_MEMORY_MISMATCH_STALL)
3062            && memory_operand (operands[0], DFmode)))"
3063 {
3064   switch (which_alternative)
3065     {
3066     case 0:
3067     case 1:
3068       return output_387_reg_move (insn, operands);
3069
3070     case 2:
3071       return standard_80387_constant_opcode (operands[1]);
3072
3073     case 3:
3074     case 4:
3075       return "#";
3076
3077     case 5:
3078       return standard_sse_constant_opcode (insn, operands[1]);
3079
3080     case 6:
3081     case 7:
3082     case 8:
3083       switch (get_attr_mode (insn))
3084         {
3085         case MODE_V4SF:
3086           return "%vmovaps\t{%1, %0|%0, %1}";
3087         case MODE_V2DF:
3088           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
3089             return "%vmovaps\t{%1, %0|%0, %1}";
3090           else
3091             return "%vmovapd\t{%1, %0|%0, %1}";
3092         case MODE_TI:
3093           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
3094             return "%vmovaps\t{%1, %0|%0, %1}";
3095           else
3096             return "%vmovdqa\t{%1, %0|%0, %1}";
3097         case MODE_DI:
3098           return "%vmovq\t{%1, %0|%0, %1}";
3099         case MODE_DF:
3100           if (TARGET_AVX && REG_P (operands[0]) && REG_P (operands[1]))
3101             return "vmovsd\t{%1, %0, %0|%0, %0, %1}";
3102           else
3103             return "%vmovsd\t{%1, %0|%0, %1}";
3104         case MODE_V1DF:
3105           if (TARGET_AVX && REG_P (operands[0]))
3106             return "vmovlpd\t{%1, %0, %0|%0, %0, %1}";
3107           else
3108             return "%vmovlpd\t{%1, %0|%0, %1}";
3109         case MODE_V2SF:
3110           if (TARGET_AVX && REG_P (operands[0]))
3111             return "vmovlps\t{%1, %0, %0|%0, %0, %1}";
3112           else
3113             return "%vmovlps\t{%1, %0|%0, %1}";
3114         default:
3115           gcc_unreachable ();
3116         }
3117
3118     default:
3119       gcc_unreachable ();
3120     }
3121 }
3122   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov")
3123    (set (attr "prefix")
3124      (if_then_else (eq_attr "alternative" "0,1,2,3,4")
3125        (const_string "orig")
3126        (const_string "maybe_vex")))
3127    (set (attr "prefix_data16")
3128      (if_then_else (eq_attr "mode" "V1DF")
3129        (const_string "1")
3130        (const_string "*")))
3131    (set (attr "mode")
3132         (cond [(eq_attr "alternative" "0,1,2")
3133                  (const_string "DF")
3134                (eq_attr "alternative" "3,4")
3135                  (const_string "SI")
3136
3137                /* For SSE1, we have many fewer alternatives.  */
3138                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
3139                  (cond [(eq_attr "alternative" "5,6")
3140                           (const_string "V4SF")
3141                        ]
3142                    (const_string "V2SF"))
3143
3144                /* xorps is one byte shorter.  */
3145                (eq_attr "alternative" "5")
3146                  (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3147                             (const_int 0))
3148                           (const_string "V4SF")
3149                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3150                             (const_int 0))
3151                           (const_string "TI")
3152                        ]
3153                        (const_string "V2DF"))
3154
3155                /* For architectures resolving dependencies on
3156                   whole SSE registers use APD move to break dependency
3157                   chains, otherwise use short move to avoid extra work.
3158
3159                   movaps encodes one byte shorter.  */
3160                (eq_attr "alternative" "6")
3161                  (cond
3162                    [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3163                         (const_int 0))
3164                       (const_string "V4SF")
3165                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3166                         (const_int 0))
3167                       (const_string "V2DF")
3168                    ]
3169                    (const_string "DF"))
3170                /* For architectures resolving dependencies on register
3171                   parts we may avoid extra work to zero out upper part
3172                   of register.  */
3173                (eq_attr "alternative" "7")
3174                  (if_then_else
3175                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3176                        (const_int 0))
3177                    (const_string "V1DF")
3178                    (const_string "DF"))
3179               ]
3180               (const_string "DF")))])
3181
3182 (define_split
3183   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3184         (match_operand:DF 1 "general_operand" ""))]
3185   "reload_completed
3186    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3187    && ! (ANY_FP_REG_P (operands[0]) ||
3188          (GET_CODE (operands[0]) == SUBREG
3189           && ANY_FP_REG_P (SUBREG_REG (operands[0]))))
3190    && ! (ANY_FP_REG_P (operands[1]) ||
3191          (GET_CODE (operands[1]) == SUBREG
3192           && ANY_FP_REG_P (SUBREG_REG (operands[1]))))"
3193   [(const_int 0)]
3194   "ix86_split_long_move (operands); DONE;")
3195
3196 (define_insn "*movsf_internal"
3197   [(set (match_operand:SF 0 "nonimmediate_operand"
3198           "=f,m,f,r  ,m ,x,x,x ,m,!*y,!m,!*y,?Yi,?r,!*Ym,!r")
3199         (match_operand:SF 1 "general_operand"
3200           "fm,f,G,rmF,Fr,C,x,xm,x,m  ,*y,*y ,r  ,Yi,r   ,*Ym"))]
3201   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
3202    && (!can_create_pseudo_p ()
3203        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3204        || GET_CODE (operands[1]) != CONST_DOUBLE
3205        || (optimize_function_for_size_p (cfun)
3206            && ((!TARGET_SSE_MATH
3207                 && standard_80387_constant_p (operands[1]) > 0)
3208                || (TARGET_SSE_MATH
3209                    && standard_sse_constant_p (operands[1]))))
3210        || memory_operand (operands[0], SFmode))"
3211 {
3212   switch (which_alternative)
3213     {
3214     case 0:
3215     case 1:
3216       return output_387_reg_move (insn, operands);
3217
3218     case 2:
3219       return standard_80387_constant_opcode (operands[1]);
3220
3221     case 3:
3222     case 4:
3223       return "mov{l}\t{%1, %0|%0, %1}";
3224
3225     case 5:
3226       return standard_sse_constant_opcode (insn, operands[1]);
3227
3228     case 6:
3229       if (get_attr_mode (insn) == MODE_V4SF)
3230         return "%vmovaps\t{%1, %0|%0, %1}";
3231       else
3232         return "%vmovss\t{%1, %d0|%d0, %1}";
3233     case 7:
3234       if (TARGET_AVX && REG_P (operands[1]))
3235         return "vmovss\t{%1, %0, %0|%0, %0, %1}";
3236       else
3237         return "%vmovss\t{%1, %0|%0, %1}";
3238     case 8:
3239       return "%vmovss\t{%1, %0|%0, %1}";
3240
3241     case 9: case 10: case 14: case 15:
3242       return "movd\t{%1, %0|%0, %1}";
3243
3244     case 11:
3245       return "movq\t{%1, %0|%0, %1}";
3246
3247     case 12: case 13:
3248       return "%vmovd\t{%1, %0|%0, %1}";
3249
3250     default:
3251       gcc_unreachable ();
3252     }
3253 }
3254   [(set_attr "type" "fmov,fmov,fmov,imov,imov,sselog1,ssemov,ssemov,ssemov,mmxmov,mmxmov,mmxmov,ssemov,ssemov,mmxmov,mmxmov")
3255    (set (attr "prefix")
3256      (if_then_else (eq_attr "alternative" "5,6,7,8,12,13")
3257        (const_string "maybe_vex")
3258        (const_string "orig")))
3259    (set (attr "mode")
3260         (cond [(eq_attr "alternative" "3,4,9,10")
3261                  (const_string "SI")
3262                (eq_attr "alternative" "5")
3263                  (if_then_else
3264                    (and (and (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3265                                  (const_int 0))
3266                              (ne (symbol_ref "TARGET_SSE2")
3267                                  (const_int 0)))
3268                         (eq (symbol_ref "optimize_function_for_size_p (cfun)")
3269                             (const_int 0)))
3270                    (const_string "TI")
3271                    (const_string "V4SF"))
3272                /* For architectures resolving dependencies on
3273                   whole SSE registers use APS move to break dependency
3274                   chains, otherwise use short move to avoid extra work.
3275
3276                   Do the same for architectures resolving dependencies on
3277                   the parts.  While in DF mode it is better to always handle
3278                   just register parts, the SF mode is different due to lack
3279                   of instructions to load just part of the register.  It is
3280                   better to maintain the whole registers in single format
3281                   to avoid problems on using packed logical operations.  */
3282                (eq_attr "alternative" "6")
3283                  (if_then_else
3284                    (ior (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3285                             (const_int 0))
3286                         (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3287                             (const_int 0)))
3288                    (const_string "V4SF")
3289                    (const_string "SF"))
3290                (eq_attr "alternative" "11")
3291                  (const_string "DI")]
3292                (const_string "SF")))])
3293
3294 (define_split
3295   [(set (match_operand 0 "register_operand" "")
3296         (match_operand 1 "memory_operand" ""))]
3297   "reload_completed
3298    && MEM_P (operands[1])
3299    && (GET_MODE (operands[0]) == TFmode
3300        || GET_MODE (operands[0]) == XFmode
3301        || GET_MODE (operands[0]) == DFmode
3302        || GET_MODE (operands[0]) == SFmode)
3303    && (operands[2] = find_constant_src (insn))"
3304   [(set (match_dup 0) (match_dup 2))]
3305 {
3306   rtx c = operands[2];
3307   rtx r = operands[0];
3308
3309   if (GET_CODE (r) == SUBREG)
3310     r = SUBREG_REG (r);
3311
3312   if (SSE_REG_P (r))
3313     {
3314       if (!standard_sse_constant_p (c))
3315         FAIL;
3316     }
3317   else if (FP_REG_P (r))
3318     {
3319       if (standard_80387_constant_p (c) < 1)
3320         FAIL;
3321     }
3322   else if (MMX_REG_P (r))
3323     FAIL;
3324 })
3325
3326 (define_split
3327   [(set (match_operand 0 "register_operand" "")
3328         (float_extend (match_operand 1 "memory_operand" "")))]
3329   "reload_completed
3330    && MEM_P (operands[1])
3331    && (GET_MODE (operands[0]) == TFmode
3332        || GET_MODE (operands[0]) == XFmode
3333        || GET_MODE (operands[0]) == DFmode
3334        || GET_MODE (operands[0]) == SFmode)
3335    && (operands[2] = find_constant_src (insn))"
3336   [(set (match_dup 0) (match_dup 2))]
3337 {
3338   rtx c = operands[2];
3339   rtx r = operands[0];
3340
3341   if (GET_CODE (r) == SUBREG)
3342     r = SUBREG_REG (r);
3343
3344   if (SSE_REG_P (r))
3345     {
3346       if (!standard_sse_constant_p (c))
3347         FAIL;
3348     }
3349   else if (FP_REG_P (r))
3350     {
3351       if (standard_80387_constant_p (c) < 1)
3352         FAIL;
3353     }
3354   else if (MMX_REG_P (r))
3355     FAIL;
3356 })
3357
3358 ;; Split the load of -0.0 or -1.0 into fldz;fchs or fld1;fchs sequence
3359 (define_split
3360   [(set (match_operand:X87MODEF 0 "register_operand" "")
3361         (match_operand:X87MODEF 1 "immediate_operand" ""))]
3362   "reload_completed && FP_REGNO_P (REGNO (operands[0]))
3363    && (standard_80387_constant_p (operands[1]) == 8
3364        || standard_80387_constant_p (operands[1]) == 9)"
3365   [(set (match_dup 0)(match_dup 1))
3366    (set (match_dup 0)
3367         (neg:X87MODEF (match_dup 0)))]
3368 {
3369   REAL_VALUE_TYPE r;
3370
3371   REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
3372   if (real_isnegzero (&r))
3373     operands[1] = CONST0_RTX (<MODE>mode);
3374   else
3375     operands[1] = CONST1_RTX (<MODE>mode);
3376 })
3377
3378 (define_insn "swapxf"
3379   [(set (match_operand:XF 0 "register_operand" "+f")
3380         (match_operand:XF 1 "register_operand" "+f"))
3381    (set (match_dup 1)
3382         (match_dup 0))]
3383   "TARGET_80387"
3384 {
3385   if (STACK_TOP_P (operands[0]))
3386     return "fxch\t%1";
3387   else
3388     return "fxch\t%0";
3389 }
3390   [(set_attr "type" "fxch")
3391    (set_attr "mode" "XF")])
3392
3393 (define_insn "*swap<mode>"
3394   [(set (match_operand:MODEF 0 "fp_register_operand" "+f")
3395         (match_operand:MODEF 1 "fp_register_operand" "+f"))
3396    (set (match_dup 1)
3397         (match_dup 0))]
3398   "TARGET_80387 || reload_completed"
3399 {
3400   if (STACK_TOP_P (operands[0]))
3401     return "fxch\t%1";
3402   else
3403     return "fxch\t%0";
3404 }
3405   [(set_attr "type" "fxch")
3406    (set_attr "mode" "<MODE>")])
3407 \f
3408 ;; Zero extension instructions
3409
3410 (define_expand "zero_extendsidi2"
3411   [(set (match_operand:DI 0 "nonimmediate_operand" "")
3412         (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))]
3413   ""
3414 {
3415   if (!TARGET_64BIT)
3416     {
3417       emit_insn (gen_zero_extendsidi2_1 (operands[0], operands[1]));
3418       DONE;
3419     }
3420 })
3421
3422 (define_insn "*zero_extendsidi2_rex64"
3423   [(set (match_operand:DI 0 "nonimmediate_operand"  "=r,o,?*Ym,?*y,?*Yi,*Y2")
3424         (zero_extend:DI
3425          (match_operand:SI 1 "nonimmediate_operand" "rm,0,r   ,m  ,r   ,m")))]
3426   "TARGET_64BIT"
3427   "@
3428    mov\t{%k1, %k0|%k0, %k1}
3429    #
3430    movd\t{%1, %0|%0, %1}
3431    movd\t{%1, %0|%0, %1}
3432    %vmovd\t{%1, %0|%0, %1}
3433    %vmovd\t{%1, %0|%0, %1}"
3434   [(set_attr "type" "imovx,imov,mmxmov,mmxmov,ssemov,ssemov")
3435    (set_attr "prefix" "orig,*,orig,orig,maybe_vex,maybe_vex")
3436    (set_attr "prefix_0f" "0,*,*,*,*,*")
3437    (set_attr "mode" "SI,DI,DI,DI,TI,TI")])
3438
3439 (define_split
3440   [(set (match_operand:DI 0 "memory_operand" "")
3441         (zero_extend:DI (match_dup 0)))]
3442   "TARGET_64BIT"
3443   [(set (match_dup 4) (const_int 0))]
3444   "split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);")
3445
3446 ;; %%% Kill me once multi-word ops are sane.
3447 (define_insn "zero_extendsidi2_1"
3448   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,?r,?o,?*Ym,?*y,?*Yi,*Y2")
3449         (zero_extend:DI
3450          (match_operand:SI 1 "nonimmediate_operand" "0,rm,r ,r   ,m  ,r   ,m")))
3451    (clobber (reg:CC FLAGS_REG))]
3452   "!TARGET_64BIT"
3453   "@
3454    #
3455    #
3456    #
3457    movd\t{%1, %0|%0, %1}
3458    movd\t{%1, %0|%0, %1}
3459    %vmovd\t{%1, %0|%0, %1}
3460    %vmovd\t{%1, %0|%0, %1}"
3461   [(set_attr "type" "multi,multi,multi,mmxmov,mmxmov,ssemov,ssemov")
3462    (set_attr "prefix" "*,*,*,orig,orig,maybe_vex,maybe_vex")
3463    (set_attr "mode" "SI,SI,SI,DI,DI,TI,TI")])
3464
3465 (define_split
3466   [(set (match_operand:DI 0 "register_operand" "")
3467         (zero_extend:DI (match_operand:SI 1 "register_operand" "")))
3468    (clobber (reg:CC FLAGS_REG))]
3469   "!TARGET_64BIT && reload_completed
3470    && true_regnum (operands[0]) == true_regnum (operands[1])"
3471   [(set (match_dup 4) (const_int 0))]
3472   "split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);")
3473
3474 (define_split
3475   [(set (match_operand:DI 0 "nonimmediate_operand" "")
3476         (zero_extend:DI (match_operand:SI 1 "general_operand" "")))
3477    (clobber (reg:CC FLAGS_REG))]
3478   "!TARGET_64BIT && reload_completed
3479    && !(MMX_REG_P (operands[0]) || SSE_REG_P (operands[0]))"
3480   [(set (match_dup 3) (match_dup 1))
3481    (set (match_dup 4) (const_int 0))]
3482   "split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);")
3483
3484 (define_insn "zero_extend<mode>di2"
3485   [(set (match_operand:DI 0 "register_operand" "=r")
3486         (zero_extend:DI
3487          (match_operand:SWI12 1 "nonimmediate_operand" "<r>m")))]
3488   "TARGET_64BIT"
3489   "movz{<imodesuffix>l|x}\t{%1, %k0|%k0, %1}"
3490   [(set_attr "type" "imovx")
3491    (set_attr "mode" "SI")])
3492
3493 (define_expand "zero_extendhisi2"
3494   [(set (match_operand:SI 0 "register_operand" "")
3495         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "")))]
3496   ""
3497 {
3498   if (TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun))
3499     {
3500       operands[1] = force_reg (HImode, operands[1]);
3501       emit_insn (gen_zero_extendhisi2_and (operands[0], operands[1]));
3502       DONE;
3503     }
3504 })
3505
3506 (define_insn_and_split "zero_extendhisi2_and"
3507   [(set (match_operand:SI 0 "register_operand" "=r")
3508         (zero_extend:SI (match_operand:HI 1 "register_operand" "0")))
3509    (clobber (reg:CC FLAGS_REG))]
3510   "TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun)"
3511   "#"
3512   "&& reload_completed"
3513   [(parallel [(set (match_dup 0) (and:SI (match_dup 0) (const_int 65535)))
3514               (clobber (reg:CC FLAGS_REG))])]
3515   ""
3516   [(set_attr "type" "alu1")
3517    (set_attr "mode" "SI")])
3518
3519 (define_insn "*zero_extendhisi2_movzwl"
3520   [(set (match_operand:SI 0 "register_operand" "=r")
3521         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "rm")))]
3522   "!TARGET_ZERO_EXTEND_WITH_AND
3523    || optimize_function_for_size_p (cfun)"
3524   "movz{wl|x}\t{%1, %0|%0, %1}"
3525   [(set_attr "type" "imovx")
3526    (set_attr "mode" "SI")])
3527
3528 (define_expand "zero_extendqi<mode>2"
3529   [(parallel
3530     [(set (match_operand:SWI24 0 "register_operand" "")
3531           (zero_extend:SWI24 (match_operand:QI 1 "nonimmediate_operand" "")))
3532      (clobber (reg:CC FLAGS_REG))])])
3533
3534 (define_insn "*zero_extendqi<mode>2_and"
3535   [(set (match_operand:SWI24 0 "register_operand" "=r,?&q")
3536         (zero_extend:SWI24 (match_operand:QI 1 "nonimmediate_operand" "0,qm")))
3537    (clobber (reg:CC FLAGS_REG))]
3538   "TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun)"
3539   "#"
3540   [(set_attr "type" "alu1")
3541    (set_attr "mode" "<MODE>")])
3542
3543 ;; When source and destination does not overlap, clear destination
3544 ;; first and then do the movb
3545 (define_split
3546   [(set (match_operand:SWI24 0 "register_operand" "")
3547         (zero_extend:SWI24 (match_operand:QI 1 "nonimmediate_operand" "")))
3548    (clobber (reg:CC FLAGS_REG))]
3549   "reload_completed
3550    && (TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun))
3551    && ANY_QI_REG_P (operands[0])
3552    && (ANY_QI_REG_P (operands[1]) || MEM_P (operands[1]))
3553    && !reg_overlap_mentioned_p (operands[0], operands[1])"
3554   [(set (strict_low_part (match_dup 2)) (match_dup 1))]
3555 {
3556   operands[2] = gen_lowpart (QImode, operands[0]);
3557   ix86_expand_clear (operands[0]);
3558 })
3559
3560 (define_insn "*zero_extendqi<mode>2_movzbl_and"
3561   [(set (match_operand:SWI24 0 "register_operand" "=r,r")
3562         (zero_extend:SWI24 (match_operand:QI 1 "nonimmediate_operand" "qm,0")))
3563    (clobber (reg:CC FLAGS_REG))]
3564   "!TARGET_ZERO_EXTEND_WITH_AND || optimize_function_for_size_p (cfun)"
3565   "#"
3566   [(set_attr "type" "imovx,alu1")
3567    (set_attr "mode" "<MODE>")])
3568
3569 ;; For the movzbl case strip only the clobber
3570 (define_split
3571   [(set (match_operand:SWI24 0 "register_operand" "")
3572         (zero_extend:SWI24 (match_operand:QI 1 "nonimmediate_operand" "")))
3573    (clobber (reg:CC FLAGS_REG))]
3574   "reload_completed
3575    && (!TARGET_ZERO_EXTEND_WITH_AND || optimize_function_for_size_p (cfun))
3576    && (!REG_P (operands[1]) || ANY_QI_REG_P (operands[1]))"
3577   [(set (match_dup 0)
3578         (zero_extend:SWI24 (match_dup 1)))])
3579
3580 ; zero extend to SImode to avoid partial register stalls
3581 (define_insn "*zero_extendqi<mode>2_movzbl"
3582   [(set (match_operand:SWI24 0 "register_operand" "=r")
3583         (zero_extend:SWI24 (match_operand:QI 1 "nonimmediate_operand" "qm")))]
3584   "reload_completed
3585    && (!TARGET_ZERO_EXTEND_WITH_AND || optimize_function_for_size_p (cfun))"
3586   "movz{bl|x}\t{%1, %k0|%k0, %1}"
3587   [(set_attr "type" "imovx")
3588    (set_attr "mode" "SI")])
3589
3590 ;; Rest is handled by single and.
3591 (define_split
3592   [(set (match_operand:SWI24 0 "register_operand" "")
3593         (zero_extend:SWI24 (match_operand:QI 1 "register_operand" "")))
3594    (clobber (reg:CC FLAGS_REG))]
3595   "reload_completed
3596    && true_regnum (operands[0]) == true_regnum (operands[1])"
3597   [(parallel [(set (match_dup 0) (and:SWI24 (match_dup 0) (const_int 255)))
3598               (clobber (reg:CC FLAGS_REG))])])
3599 \f
3600 ;; Sign extension instructions
3601
3602 (define_expand "extendsidi2"
3603   [(set (match_operand:DI 0 "register_operand" "")
3604         (sign_extend:DI (match_operand:SI 1 "register_operand" "")))]
3605   ""
3606 {
3607   if (!TARGET_64BIT)
3608     {
3609       emit_insn (gen_extendsidi2_1 (operands[0], operands[1]));
3610       DONE;
3611     }
3612 })
3613
3614 (define_insn "*extendsidi2_rex64"
3615   [(set (match_operand:DI 0 "register_operand" "=*a,r")
3616         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "*0,rm")))]
3617   "TARGET_64BIT"
3618   "@
3619    {cltq|cdqe}
3620    movs{lq|x}\t{%1, %0|%0, %1}"
3621   [(set_attr "type" "imovx")
3622    (set_attr "mode" "DI")
3623    (set_attr "prefix_0f" "0")
3624    (set_attr "modrm" "0,1")])
3625
3626 (define_insn "extendsidi2_1"
3627   [(set (match_operand:DI 0 "nonimmediate_operand" "=*A,r,?r,?*o")
3628         (sign_extend:DI (match_operand:SI 1 "register_operand" "0,0,r,r")))
3629    (clobber (reg:CC FLAGS_REG))
3630    (clobber (match_scratch:SI 2 "=X,X,X,&r"))]
3631   "!TARGET_64BIT"
3632   "#")
3633
3634 ;; Extend to memory case when source register does die.
3635 (define_split
3636   [(set (match_operand:DI 0 "memory_operand" "")
3637         (sign_extend:DI (match_operand:SI 1 "register_operand" "")))
3638    (clobber (reg:CC FLAGS_REG))
3639    (clobber (match_operand:SI 2 "register_operand" ""))]
3640   "(reload_completed
3641     && dead_or_set_p (insn, operands[1])
3642     && !reg_mentioned_p (operands[1], operands[0]))"
3643   [(set (match_dup 3) (match_dup 1))
3644    (parallel [(set (match_dup 1) (ashiftrt:SI (match_dup 1) (const_int 31)))
3645               (clobber (reg:CC FLAGS_REG))])
3646    (set (match_dup 4) (match_dup 1))]
3647   "split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);")
3648
3649 ;; Extend to memory case when source register does not die.
3650 (define_split
3651   [(set (match_operand:DI 0 "memory_operand" "")
3652         (sign_extend:DI (match_operand:SI 1 "register_operand" "")))
3653    (clobber (reg:CC FLAGS_REG))
3654    (clobber (match_operand:SI 2 "register_operand" ""))]
3655   "reload_completed"
3656   [(const_int 0)]
3657 {
3658   split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);
3659
3660   emit_move_insn (operands[3], operands[1]);
3661
3662   /* Generate a cltd if possible and doing so it profitable.  */
3663   if ((optimize_function_for_size_p (cfun) || TARGET_USE_CLTD)
3664       && true_regnum (operands[1]) == AX_REG
3665       && true_regnum (operands[2]) == DX_REG)
3666     {
3667       emit_insn (gen_ashrsi3_cvt (operands[2], operands[1], GEN_INT (31)));
3668     }
3669   else
3670     {
3671       emit_move_insn (operands[2], operands[1]);
3672       emit_insn (gen_ashrsi3_cvt (operands[2], operands[2], GEN_INT (31)));
3673     }
3674   emit_move_insn (operands[4], operands[2]);
3675   DONE;
3676 })
3677
3678 ;; Extend to register case.  Optimize case where source and destination
3679 ;; registers match and cases where we can use cltd.
3680 (define_split
3681   [(set (match_operand:DI 0 "register_operand" "")
3682         (sign_extend:DI (match_operand:SI 1 "register_operand" "")))
3683    (clobber (reg:CC FLAGS_REG))
3684    (clobber (match_scratch:SI 2 ""))]
3685   "reload_completed"
3686   [(const_int 0)]
3687 {
3688   split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);
3689
3690   if (true_regnum (operands[3]) != true_regnum (operands[1]))
3691     emit_move_insn (operands[3], operands[1]);
3692
3693   /* Generate a cltd if possible and doing so it profitable.  */
3694   if ((optimize_function_for_size_p (cfun) || TARGET_USE_CLTD)
3695       && true_regnum (operands[3]) == AX_REG
3696       && true_regnum (operands[4]) == DX_REG)
3697     {
3698       emit_insn (gen_ashrsi3_cvt (operands[4], operands[3], GEN_INT (31)));
3699       DONE;
3700     }
3701
3702   if (true_regnum (operands[4]) != true_regnum (operands[1]))
3703     emit_move_insn (operands[4], operands[1]);
3704
3705   emit_insn (gen_ashrsi3_cvt (operands[4], operands[4], GEN_INT (31)));
3706   DONE;
3707 })
3708
3709 (define_insn "extend<mode>di2"
3710   [(set (match_operand:DI 0 "register_operand" "=r")
3711         (sign_extend:DI
3712          (match_operand:SWI12 1 "nonimmediate_operand" "<r>m")))]
3713   "TARGET_64BIT"
3714   "movs{<imodesuffix>q|x}\t{%1, %0|%0, %1}"
3715   [(set_attr "type" "imovx")
3716    (set_attr "mode" "DI")])
3717
3718 (define_insn "extendhisi2"
3719   [(set (match_operand:SI 0 "register_operand" "=*a,r")
3720         (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "*0,rm")))]
3721   ""
3722 {
3723   switch (get_attr_prefix_0f (insn))
3724     {
3725     case 0:
3726       return "{cwtl|cwde}";
3727     default:
3728       return "movs{wl|x}\t{%1, %0|%0, %1}";
3729     }
3730 }
3731   [(set_attr "type" "imovx")
3732    (set_attr "mode" "SI")
3733    (set (attr "prefix_0f")
3734      ;; movsx is short decodable while cwtl is vector decoded.
3735      (if_then_else (and (eq_attr "cpu" "!k6")
3736                         (eq_attr "alternative" "0"))
3737         (const_string "0")
3738         (const_string "1")))
3739    (set (attr "modrm")
3740      (if_then_else (eq_attr "prefix_0f" "0")
3741         (const_string "0")
3742         (const_string "1")))])
3743
3744 (define_insn "*extendhisi2_zext"
3745   [(set (match_operand:DI 0 "register_operand" "=*a,r")
3746         (zero_extend:DI
3747          (sign_extend:SI
3748           (match_operand:HI 1 "nonimmediate_operand" "*0,rm"))))]
3749   "TARGET_64BIT"
3750 {
3751   switch (get_attr_prefix_0f (insn))
3752     {
3753     case 0:
3754       return "{cwtl|cwde}";
3755     default:
3756       return "movs{wl|x}\t{%1, %k0|%k0, %1}";
3757     }
3758 }
3759   [(set_attr "type" "imovx")
3760    (set_attr "mode" "SI")
3761    (set (attr "prefix_0f")
3762      ;; movsx is short decodable while cwtl is vector decoded.
3763      (if_then_else (and (eq_attr "cpu" "!k6")
3764                         (eq_attr "alternative" "0"))
3765         (const_string "0")
3766         (const_string "1")))
3767    (set (attr "modrm")
3768      (if_then_else (eq_attr "prefix_0f" "0")
3769         (const_string "0")
3770         (const_string "1")))])
3771
3772 (define_insn "extendqisi2"
3773   [(set (match_operand:SI 0 "register_operand" "=r")
3774         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "qm")))]
3775   ""
3776   "movs{bl|x}\t{%1, %0|%0, %1}"
3777    [(set_attr "type" "imovx")
3778     (set_attr "mode" "SI")])
3779
3780 (define_insn "*extendqisi2_zext"
3781   [(set (match_operand:DI 0 "register_operand" "=r")
3782         (zero_extend:DI
3783           (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "qm"))))]
3784   "TARGET_64BIT"
3785   "movs{bl|x}\t{%1, %k0|%k0, %1}"
3786    [(set_attr "type" "imovx")
3787     (set_attr "mode" "SI")])
3788
3789 (define_insn "extendqihi2"
3790   [(set (match_operand:HI 0 "register_operand" "=*a,r")
3791         (sign_extend:HI (match_operand:QI 1 "nonimmediate_operand" "*0,qm")))]
3792   ""
3793 {
3794   switch (get_attr_prefix_0f (insn))
3795     {
3796     case 0:
3797       return "{cbtw|cbw}";
3798     default:
3799       return "movs{bw|x}\t{%1, %0|%0, %1}";
3800     }
3801 }
3802   [(set_attr "type" "imovx")
3803    (set_attr "mode" "HI")
3804    (set (attr "prefix_0f")
3805      ;; movsx is short decodable while cwtl is vector decoded.
3806      (if_then_else (and (eq_attr "cpu" "!k6")
3807                         (eq_attr "alternative" "0"))
3808         (const_string "0")
3809         (const_string "1")))
3810    (set (attr "modrm")
3811      (if_then_else (eq_attr "prefix_0f" "0")
3812         (const_string "0")
3813         (const_string "1")))])
3814 \f
3815 ;; Conversions between float and double.
3816
3817 ;; These are all no-ops in the model used for the 80387.
3818 ;; So just emit moves.
3819
3820 ;; %%% Kill these when call knows how to work out a DFmode push earlier.
3821 (define_split
3822   [(set (match_operand:DF 0 "push_operand" "")
3823         (float_extend:DF (match_operand:SF 1 "fp_register_operand" "")))]
3824   "reload_completed"
3825   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -8)))
3826    (set (mem:DF (reg:P SP_REG)) (float_extend:DF (match_dup 1)))])
3827
3828 (define_split
3829   [(set (match_operand:XF 0 "push_operand" "")
3830         (float_extend:XF (match_operand:MODEF 1 "fp_register_operand" "")))]
3831   "reload_completed"
3832   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
3833    (set (mem:XF (reg:P SP_REG)) (float_extend:XF (match_dup 1)))]
3834   "operands[2] = GEN_INT (-GET_MODE_SIZE (XFmode));")
3835
3836 (define_expand "extendsfdf2"
3837   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3838         (float_extend:DF (match_operand:SF 1 "general_operand" "")))]
3839   "TARGET_80387 || (TARGET_SSE2 && TARGET_SSE_MATH)"
3840 {
3841   /* ??? Needed for compress_float_constant since all fp constants
3842      are TARGET_LEGITIMATE_CONSTANT_P.  */
3843   if (GET_CODE (operands[1]) == CONST_DOUBLE)
3844     {
3845       if ((!TARGET_SSE2 || TARGET_MIX_SSE_I387)
3846           && standard_80387_constant_p (operands[1]) > 0)
3847         {
3848           operands[1] = simplify_const_unary_operation
3849             (FLOAT_EXTEND, DFmode, operands[1], SFmode);
3850           emit_move_insn_1 (operands[0], operands[1]);
3851           DONE;
3852         }
3853       operands[1] = validize_mem (force_const_mem (SFmode, operands[1]));
3854     }
3855 })
3856
3857 /* For converting SF(xmm2) to DF(xmm1), use the following code instead of
3858    cvtss2sd:
3859       unpcklps xmm2,xmm2   ; packed conversion might crash on signaling NaNs
3860       cvtps2pd xmm2,xmm1
3861    We do the conversion post reload to avoid producing of 128bit spills
3862    that might lead to ICE on 32bit target.  The sequence unlikely combine
3863    anyway.  */
3864 (define_split
3865   [(set (match_operand:DF 0 "register_operand" "")
3866         (float_extend:DF
3867           (match_operand:SF 1 "nonimmediate_operand" "")))]
3868   "TARGET_USE_VECTOR_FP_CONVERTS
3869    && optimize_insn_for_speed_p ()
3870    && reload_completed && SSE_REG_P (operands[0])"
3871    [(set (match_dup 2)
3872          (float_extend:V2DF
3873            (vec_select:V2SF
3874              (match_dup 3)
3875              (parallel [(const_int 0) (const_int 1)]))))]
3876 {
3877   operands[2] = simplify_gen_subreg (V2DFmode, operands[0], DFmode, 0);
3878   operands[3] = simplify_gen_subreg (V4SFmode, operands[0], DFmode, 0);
3879   /* Use movss for loading from memory, unpcklps reg, reg for registers.
3880      Try to avoid move when unpacking can be done in source.  */
3881   if (REG_P (operands[1]))
3882     {
3883       /* If it is unsafe to overwrite upper half of source, we need
3884          to move to destination and unpack there.  */
3885       if ((ORIGINAL_REGNO (operands[1]) < FIRST_PSEUDO_REGISTER
3886            || PSEUDO_REGNO_BYTES (ORIGINAL_REGNO (operands[1])) > 4)
3887           && true_regnum (operands[0]) != true_regnum (operands[1]))
3888         {
3889           rtx tmp = gen_rtx_REG (SFmode, true_regnum (operands[0]));
3890           emit_move_insn (tmp, operands[1]);
3891         }
3892       else
3893         operands[3] = simplify_gen_subreg (V4SFmode, operands[1], SFmode, 0);
3894       emit_insn (gen_vec_interleave_lowv4sf (operands[3], operands[3],
3895                                              operands[3]));
3896     }
3897   else
3898     emit_insn (gen_vec_setv4sf_0 (operands[3],
3899                                   CONST0_RTX (V4SFmode), operands[1]));
3900 })
3901
3902 (define_insn "*extendsfdf2_mixed"
3903   [(set (match_operand:DF 0 "nonimmediate_operand" "=f,m,x")
3904         (float_extend:DF
3905           (match_operand:SF 1 "nonimmediate_operand" "fm,f,xm")))]
3906   "TARGET_SSE2 && TARGET_MIX_SSE_I387"
3907 {
3908   switch (which_alternative)
3909     {
3910     case 0:
3911     case 1:
3912       return output_387_reg_move (insn, operands);
3913
3914     case 2:
3915       return "%vcvtss2sd\t{%1, %d0|%d0, %1}";
3916
3917     default:
3918       gcc_unreachable ();
3919     }
3920 }