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 (ior (not (match_operand:QI 0 "QIreg_operand" ""))
2492                         (ne (symbol_ref "TARGET_MOVX")
2493                             (const_int 0)))
2494         (const_string "imovx")
2495         (const_string "imov")))
2496    (set (attr "mode")
2497      (if_then_else (eq_attr "type" "imovx")
2498         (const_string "SI")
2499         (const_string "QI")))])
2500
2501 (define_insn "*movqi_extv_1"
2502   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?r")
2503         (sign_extract:QI (match_operand 1 "ext_register_operand" "Q,Q")
2504                          (const_int 8)
2505                          (const_int 8)))]
2506   "!TARGET_64BIT"
2507 {
2508   switch (get_attr_type (insn))
2509     {
2510     case TYPE_IMOVX:
2511       return "movs{bl|x}\t{%h1, %k0|%k0, %h1}";
2512     default:
2513       return "mov{b}\t{%h1, %0|%0, %h1}";
2514     }
2515 }
2516   [(set (attr "type")
2517      (if_then_else (ior (not (match_operand:QI 0 "QIreg_operand" ""))
2518                         (ne (symbol_ref "TARGET_MOVX")
2519                             (const_int 0)))
2520         (const_string "imovx")
2521         (const_string "imov")))
2522    (set (attr "mode")
2523      (if_then_else (eq_attr "type" "imovx")
2524         (const_string "SI")
2525         (const_string "QI")))])
2526
2527 (define_insn "*mov<mode>_extzv_1"
2528   [(set (match_operand:SWI48 0 "register_operand" "=R")
2529         (zero_extract:SWI48 (match_operand 1 "ext_register_operand" "Q")
2530                             (const_int 8)
2531                             (const_int 8)))]
2532   ""
2533   "movz{bl|x}\t{%h1, %k0|%k0, %h1}"
2534   [(set_attr "type" "imovx")
2535    (set_attr "mode" "SI")])
2536
2537 (define_insn "*movqi_extzv_2_rex64"
2538   [(set (match_operand:QI 0 "register_operand" "=Q,?R")
2539         (subreg:QI
2540           (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
2541                            (const_int 8)
2542                            (const_int 8)) 0))]
2543   "TARGET_64BIT"
2544 {
2545   switch (get_attr_type (insn))
2546     {
2547     case TYPE_IMOVX:
2548       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2549     default:
2550       return "mov{b}\t{%h1, %0|%0, %h1}";
2551     }
2552 }
2553   [(set (attr "type")
2554      (if_then_else (ior (not (match_operand:QI 0 "QIreg_operand" ""))
2555                         (ne (symbol_ref "TARGET_MOVX")
2556                             (const_int 0)))
2557         (const_string "imovx")
2558         (const_string "imov")))
2559    (set (attr "mode")
2560      (if_then_else (eq_attr "type" "imovx")
2561         (const_string "SI")
2562         (const_string "QI")))])
2563
2564 (define_insn "*movqi_extzv_2"
2565   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?R")
2566         (subreg:QI
2567           (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
2568                            (const_int 8)
2569                            (const_int 8)) 0))]
2570   "!TARGET_64BIT"
2571 {
2572   switch (get_attr_type (insn))
2573     {
2574     case TYPE_IMOVX:
2575       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2576     default:
2577       return "mov{b}\t{%h1, %0|%0, %h1}";
2578     }
2579 }
2580   [(set (attr "type")
2581      (if_then_else (ior (not (match_operand:QI 0 "QIreg_operand" ""))
2582                         (ne (symbol_ref "TARGET_MOVX")
2583                             (const_int 0)))
2584         (const_string "imovx")
2585         (const_string "imov")))
2586    (set (attr "mode")
2587      (if_then_else (eq_attr "type" "imovx")
2588         (const_string "SI")
2589         (const_string "QI")))])
2590
2591 (define_expand "mov<mode>_insv_1"
2592   [(set (zero_extract:SWI48 (match_operand 0 "ext_register_operand" "")
2593                             (const_int 8)
2594                             (const_int 8))
2595         (match_operand:SWI48 1 "nonmemory_operand" ""))])
2596
2597 (define_insn "*mov<mode>_insv_1_rex64"
2598   [(set (zero_extract:SWI48x (match_operand 0 "ext_register_operand" "+Q")
2599                              (const_int 8)
2600                              (const_int 8))
2601         (match_operand:SWI48x 1 "nonmemory_operand" "Qn"))]
2602   "TARGET_64BIT"
2603   "mov{b}\t{%b1, %h0|%h0, %b1}"
2604   [(set_attr "type" "imov")
2605    (set_attr "mode" "QI")])
2606
2607 (define_insn "*movsi_insv_1"
2608   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2609                          (const_int 8)
2610                          (const_int 8))
2611         (match_operand:SI 1 "general_operand" "Qmn"))]
2612   "!TARGET_64BIT"
2613   "mov{b}\t{%b1, %h0|%h0, %b1}"
2614   [(set_attr "type" "imov")
2615    (set_attr "mode" "QI")])
2616
2617 (define_insn "*movqi_insv_2"
2618   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2619                          (const_int 8)
2620                          (const_int 8))
2621         (lshiftrt:SI (match_operand:SI 1 "register_operand" "Q")
2622                      (const_int 8)))]
2623   ""
2624   "mov{b}\t{%h1, %h0|%h0, %h1}"
2625   [(set_attr "type" "imov")
2626    (set_attr "mode" "QI")])
2627 \f
2628 ;; Floating point push instructions.
2629
2630 (define_insn "*pushtf"
2631   [(set (match_operand:TF 0 "push_operand" "=<,<,<")
2632         (match_operand:TF 1 "general_no_elim_operand" "x,Fo,*r"))]
2633   "TARGET_SSE2"
2634 {
2635   /* This insn should be already split before reg-stack.  */
2636   gcc_unreachable ();
2637 }
2638   [(set_attr "type" "multi")
2639    (set_attr "unit" "sse,*,*")
2640    (set_attr "mode" "TF,SI,SI")])
2641
2642 (define_split
2643   [(set (match_operand:TF 0 "push_operand" "")
2644         (match_operand:TF 1 "sse_reg_operand" ""))]
2645   "TARGET_SSE2 && reload_completed"
2646   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -16)))
2647    (set (mem:TF (reg:P SP_REG)) (match_dup 1))])
2648
2649 (define_split
2650   [(set (match_operand:TF 0 "push_operand" "")
2651         (match_operand:TF 1 "general_operand" ""))]
2652   "TARGET_SSE2 && reload_completed
2653    && !SSE_REG_P (operands[1])"
2654   [(const_int 0)]
2655   "ix86_split_long_move (operands); DONE;")
2656
2657 (define_insn "*pushxf"
2658   [(set (match_operand:XF 0 "push_operand" "=<,<")
2659         (match_operand:XF 1 "general_no_elim_operand" "f,ro"))]
2660   "optimize_function_for_speed_p (cfun)"
2661 {
2662   /* This insn should be already split before reg-stack.  */
2663   gcc_unreachable ();
2664 }
2665   [(set_attr "type" "multi")
2666    (set_attr "unit" "i387,*")
2667    (set_attr "mode" "XF,SI")])
2668
2669 ;; Size of pushxf is 3 (for sub) + 2 (for fstp) + memory operand size.
2670 ;; Size of pushxf using integer instructions is 3+3*memory operand size
2671 ;; Pushing using integer instructions is longer except for constants
2672 ;; and direct memory references (assuming that any given constant is pushed
2673 ;; only once, but this ought to be handled elsewhere).
2674
2675 (define_insn "*pushxf_nointeger"
2676   [(set (match_operand:XF 0 "push_operand" "=X,X,X")
2677         (match_operand:XF 1 "general_no_elim_operand" "f,Fo,*r"))]
2678   "optimize_function_for_size_p (cfun)"
2679 {
2680   /* This insn should be already split before reg-stack.  */
2681   gcc_unreachable ();
2682 }
2683   [(set_attr "type" "multi")
2684    (set_attr "unit" "i387,*,*")
2685    (set_attr "mode" "XF,SI,SI")])
2686
2687 (define_split
2688   [(set (match_operand:XF 0 "push_operand" "")
2689         (match_operand:XF 1 "fp_register_operand" ""))]
2690   "reload_completed"
2691   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
2692    (set (mem:XF (reg:P SP_REG)) (match_dup 1))]
2693   "operands[2] = GEN_INT (-GET_MODE_SIZE (XFmode));")
2694
2695 (define_split
2696   [(set (match_operand:XF 0 "push_operand" "")
2697         (match_operand:XF 1 "general_operand" ""))]
2698   "reload_completed
2699    && !FP_REG_P (operands[1])"
2700   [(const_int 0)]
2701   "ix86_split_long_move (operands); DONE;")
2702
2703 ;; Size of pushdf is 3 (for sub) + 2 (for fstp) + memory operand size.
2704 ;; Size of pushdf using integer instructions is 2+2*memory operand size
2705 ;; On the average, pushdf using integers can be still shorter.
2706
2707 (define_insn "*pushdf"
2708   [(set (match_operand:DF 0 "push_operand" "=<,<,<")
2709         (match_operand:DF 1 "general_no_elim_operand" "f,Yd*rFo,Y2"))]
2710   ""
2711 {
2712   /* This insn should be already split before reg-stack.  */
2713   gcc_unreachable ();
2714 }
2715   [(set_attr "type" "multi")
2716    (set_attr "unit" "i387,*,*")
2717    (set_attr "mode" "DF,SI,DF")])
2718
2719 ;; %%% Kill this when call knows how to work this out.
2720 (define_split
2721   [(set (match_operand:DF 0 "push_operand" "")
2722         (match_operand:DF 1 "any_fp_register_operand" ""))]
2723   "reload_completed"
2724   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -8)))
2725    (set (mem:DF (reg:P SP_REG)) (match_dup 1))])
2726
2727 (define_split
2728   [(set (match_operand:DF 0 "push_operand" "")
2729         (match_operand:DF 1 "general_operand" ""))]
2730   "reload_completed
2731    && !ANY_FP_REG_P (operands[1])"
2732   [(const_int 0)]
2733   "ix86_split_long_move (operands); DONE;")
2734
2735 (define_insn "*pushsf_rex64"
2736   [(set (match_operand:SF 0 "push_operand" "=X,X,X")
2737         (match_operand:SF 1 "nonmemory_no_elim_operand" "f,rF,x"))]
2738   "TARGET_64BIT"
2739 {
2740   /* Anything else should be already split before reg-stack.  */
2741   gcc_assert (which_alternative == 1);
2742   return "push{q}\t%q1";
2743 }
2744   [(set_attr "type" "multi,push,multi")
2745    (set_attr "unit" "i387,*,*")
2746    (set_attr "mode" "SF,DI,SF")])
2747
2748 (define_insn "*pushsf"
2749   [(set (match_operand:SF 0 "push_operand" "=<,<,<")
2750         (match_operand:SF 1 "general_no_elim_operand" "f,rFm,x"))]
2751   "!TARGET_64BIT"
2752 {
2753   /* Anything else should be already split before reg-stack.  */
2754   gcc_assert (which_alternative == 1);
2755   return "push{l}\t%1";
2756 }
2757   [(set_attr "type" "multi,push,multi")
2758    (set_attr "unit" "i387,*,*")
2759    (set_attr "mode" "SF,SI,SF")])
2760
2761 (define_split
2762   [(set (match_operand:SF 0 "push_operand" "")
2763         (match_operand:SF 1 "memory_operand" ""))]
2764   "reload_completed
2765    && MEM_P (operands[1])
2766    && (operands[2] = find_constant_src (insn))"
2767   [(set (match_dup 0)
2768         (match_dup 2))])
2769
2770 ;; %%% Kill this when call knows how to work this out.
2771 (define_split
2772   [(set (match_operand:SF 0 "push_operand" "")
2773         (match_operand:SF 1 "any_fp_register_operand" ""))]
2774   "reload_completed"
2775   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
2776    (set (mem:SF (reg:P SP_REG)) (match_dup 1))]
2777   "operands[2] = GEN_INT (-GET_MODE_SIZE (<MODE>mode));")
2778 \f
2779 ;; Floating point move instructions.
2780
2781 (define_expand "movtf"
2782   [(set (match_operand:TF 0 "nonimmediate_operand" "")
2783         (match_operand:TF 1 "nonimmediate_operand" ""))]
2784   "TARGET_SSE2"
2785 {
2786   ix86_expand_move (TFmode, operands);
2787   DONE;
2788 })
2789
2790 (define_expand "mov<mode>"
2791   [(set (match_operand:X87MODEF 0 "nonimmediate_operand" "")
2792         (match_operand:X87MODEF 1 "general_operand" ""))]
2793   ""
2794   "ix86_expand_move (<MODE>mode, operands); DONE;")
2795
2796 (define_insn "*movtf_internal"
2797   [(set (match_operand:TF 0 "nonimmediate_operand" "=x,m,x,?r,?o")
2798         (match_operand:TF 1 "general_operand" "xm,x,C,roF,Fr"))]
2799   "TARGET_SSE2
2800    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2801 {
2802   switch (which_alternative)
2803     {
2804     case 0:
2805     case 1:
2806       if (get_attr_mode (insn) == MODE_V4SF)
2807         return "%vmovaps\t{%1, %0|%0, %1}";
2808       else
2809         return "%vmovdqa\t{%1, %0|%0, %1}";
2810
2811     case 2:
2812       return standard_sse_constant_opcode (insn, operands[1]);
2813
2814     case 3:
2815     case 4:
2816         return "#";
2817
2818     default:
2819       gcc_unreachable ();
2820     }
2821 }
2822   [(set_attr "type" "ssemov,ssemov,sselog1,*,*")
2823    (set_attr "prefix" "maybe_vex,maybe_vex,maybe_vex,*,*")
2824    (set (attr "mode")
2825         (cond [(eq_attr "alternative" "0,2")
2826                  (if_then_else
2827                    (ne (symbol_ref "optimize_function_for_size_p (cfun)")
2828                        (const_int 0))
2829                    (const_string "V4SF")
2830                    (const_string "TI"))
2831                (eq_attr "alternative" "1")
2832                  (if_then_else
2833                    (ior (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
2834                             (const_int 0))
2835                         (ne (symbol_ref "optimize_function_for_size_p (cfun)")
2836                             (const_int 0)))
2837                    (const_string "V4SF")
2838                    (const_string "TI"))]
2839                (const_string "DI")))])
2840
2841 (define_split
2842   [(set (match_operand:TF 0 "nonimmediate_operand" "")
2843         (match_operand:TF 1 "general_operand" ""))]
2844   "reload_completed
2845    && !(SSE_REG_P (operands[0]) || SSE_REG_P (operands[1]))"
2846   [(const_int 0)]
2847   "ix86_split_long_move (operands); DONE;")
2848
2849 (define_insn "*movxf_internal"
2850   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,Yx*r  ,o")
2851         (match_operand:XF 1 "general_operand"      "fm,f,G,Yx*roF,FYx*r"))]
2852   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
2853    && (!can_create_pseudo_p ()
2854        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
2855        || GET_CODE (operands[1]) != CONST_DOUBLE
2856        || (optimize_function_for_size_p (cfun)
2857            && standard_80387_constant_p (operands[1]) > 0)
2858        || memory_operand (operands[0], XFmode))"
2859 {
2860   switch (which_alternative)
2861     {
2862     case 0:
2863     case 1:
2864       return output_387_reg_move (insn, operands);
2865
2866     case 2:
2867       return standard_80387_constant_opcode (operands[1]);
2868
2869     case 3: case 4:
2870       return "#";
2871     default:
2872       gcc_unreachable ();
2873     }
2874 }
2875   [(set_attr "type" "fmov,fmov,fmov,multi,multi")
2876    (set_attr "mode" "XF,XF,XF,SI,SI")])
2877
2878 (define_split
2879   [(set (match_operand:XF 0 "nonimmediate_operand" "")
2880         (match_operand:XF 1 "general_operand" ""))]
2881   "reload_completed
2882    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
2883    && ! (FP_REG_P (operands[0]) ||
2884          (GET_CODE (operands[0]) == SUBREG
2885           && FP_REG_P (SUBREG_REG (operands[0]))))
2886    && ! (FP_REG_P (operands[1]) ||
2887          (GET_CODE (operands[1]) == SUBREG
2888           && FP_REG_P (SUBREG_REG (operands[1]))))"
2889   [(const_int 0)]
2890   "ix86_split_long_move (operands); DONE;")
2891
2892 (define_insn "*movdf_internal_rex64"
2893   [(set (match_operand:DF 0 "nonimmediate_operand"
2894                 "=f,m,f,r ,m,!r,!m,Y2*x,Y2*x,Y2*x,m   ,Yi,r ")
2895         (match_operand:DF 1 "general_operand"
2896                 "fm,f,G,rm,r,F ,F ,C   ,Y2*x,m   ,Y2*x,r ,Yi"))]
2897   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))
2898    && (!can_create_pseudo_p ()
2899        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
2900        || GET_CODE (operands[1]) != CONST_DOUBLE
2901        || (optimize_function_for_size_p (cfun)
2902            && ((!(TARGET_SSE2 && TARGET_SSE_MATH)
2903                 && standard_80387_constant_p (operands[1]) > 0)
2904                || (TARGET_SSE2 && TARGET_SSE_MATH
2905                    && standard_sse_constant_p (operands[1]))))
2906        || memory_operand (operands[0], DFmode))"
2907 {
2908   switch (which_alternative)
2909     {
2910     case 0:
2911     case 1:
2912       return output_387_reg_move (insn, operands);
2913
2914     case 2:
2915       return standard_80387_constant_opcode (operands[1]);
2916
2917     case 3:
2918     case 4:
2919       return "mov{q}\t{%1, %0|%0, %1}";
2920
2921     case 5:
2922       return "movabs{q}\t{%1, %0|%0, %1}";
2923
2924     case 6:
2925       return "#";
2926
2927     case 7:
2928       return standard_sse_constant_opcode (insn, operands[1]);
2929
2930     case 8:
2931     case 9:
2932     case 10:
2933       switch (get_attr_mode (insn))
2934         {
2935         case MODE_V4SF:
2936           return "%vmovaps\t{%1, %0|%0, %1}";
2937         case MODE_V2DF:
2938           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
2939             return "%vmovaps\t{%1, %0|%0, %1}";
2940           else
2941             return "%vmovapd\t{%1, %0|%0, %1}";
2942         case MODE_TI:
2943           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
2944             return "%vmovaps\t{%1, %0|%0, %1}";
2945           else
2946             return "%vmovdqa\t{%1, %0|%0, %1}";
2947         case MODE_DI:
2948           return "%vmovq\t{%1, %0|%0, %1}";
2949         case MODE_DF:
2950           if (TARGET_AVX && REG_P (operands[0]) && REG_P (operands[1]))
2951             return "vmovsd\t{%1, %0, %0|%0, %0, %1}";
2952           else
2953             return "%vmovsd\t{%1, %0|%0, %1}";
2954         case MODE_V1DF:
2955           return "%vmovlpd\t{%1, %d0|%d0, %1}";
2956         case MODE_V2SF:
2957           return "%vmovlps\t{%1, %d0|%d0, %1}";
2958         default:
2959           gcc_unreachable ();
2960         }
2961
2962     case 11:
2963     case 12:
2964       /* Handle broken assemblers that require movd instead of movq.  */
2965       return "%vmovd\t{%1, %0|%0, %1}";
2966
2967     default:
2968       gcc_unreachable();
2969     }
2970 }
2971   [(set_attr "type" "fmov,fmov,fmov,imov,imov,imov,multi,sselog1,ssemov,ssemov,ssemov,ssemov,ssemov")
2972    (set (attr "modrm")
2973      (if_then_else
2974        (and (eq_attr "alternative" "5") (eq_attr "type" "imov"))
2975          (const_string "0")
2976          (const_string "*")))
2977    (set (attr "length_immediate")
2978      (if_then_else
2979        (and (eq_attr "alternative" "5") (eq_attr "type" "imov"))
2980          (const_string "8")
2981          (const_string "*")))
2982    (set (attr "prefix")
2983      (if_then_else (eq_attr "alternative" "0,1,2,3,4,5,6")
2984        (const_string "orig")
2985        (const_string "maybe_vex")))
2986    (set (attr "prefix_data16")
2987      (if_then_else (eq_attr "mode" "V1DF")
2988        (const_string "1")
2989        (const_string "*")))
2990    (set (attr "mode")
2991         (cond [(eq_attr "alternative" "0,1,2")
2992                  (const_string "DF")
2993                (eq_attr "alternative" "3,4,5,6,11,12")
2994                  (const_string "DI")
2995
2996                /* For SSE1, we have many fewer alternatives.  */
2997                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
2998                  (cond [(eq_attr "alternative" "7,8")
2999                           (const_string "V4SF")
3000                        ]
3001                    (const_string "V2SF"))
3002
3003                /* xorps is one byte shorter.  */
3004                (eq_attr "alternative" "7")
3005                  (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3006                             (const_int 0))
3007                           (const_string "V4SF")
3008                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3009                             (const_int 0))
3010                           (const_string "TI")
3011                        ]
3012                        (const_string "V2DF"))
3013
3014                /* For architectures resolving dependencies on
3015                   whole SSE registers use APD move to break dependency
3016                   chains, otherwise use short move to avoid extra work.
3017
3018                   movaps encodes one byte shorter.  */
3019                (eq_attr "alternative" "8")
3020                  (cond
3021                    [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3022                         (const_int 0))
3023                       (const_string "V4SF")
3024                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3025                         (const_int 0))
3026                       (const_string "V2DF")
3027                    ]
3028                    (const_string "DF"))
3029                /* For architectures resolving dependencies on register
3030                   parts we may avoid extra work to zero out upper part
3031                   of register.  */
3032                (eq_attr "alternative" "9")
3033                  (if_then_else
3034                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3035                        (const_int 0))
3036                    (const_string "V1DF")
3037                    (const_string "DF"))
3038               ]
3039               (const_string "DF")))])
3040
3041 ;; Possible store forwarding (partial memory) stall in alternative 4.
3042 (define_insn "*movdf_internal"
3043   [(set (match_operand:DF 0 "nonimmediate_operand"
3044                 "=f,m,f,Yd*r  ,o    ,Y2*x,Y2*x,Y2*x,m  ")
3045         (match_operand:DF 1 "general_operand"
3046                 "fm,f,G,Yd*roF,FYd*r,C   ,Y2*x,m   ,Y2*x"))]
3047   "!TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3048    && (!can_create_pseudo_p ()
3049        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3050        || GET_CODE (operands[1]) != CONST_DOUBLE
3051        || (!TARGET_INTEGER_DFMODE_MOVES
3052            && ((!(TARGET_SSE2 && TARGET_SSE_MATH)
3053                 && standard_80387_constant_p (operands[1]) > 0)
3054                || (TARGET_SSE2 && TARGET_SSE_MATH
3055                    && standard_sse_constant_p (operands[1])))
3056            && !memory_operand (operands[0], DFmode))
3057        || ((TARGET_INTEGER_DFMODE_MOVES
3058             || !TARGET_MEMORY_MISMATCH_STALL)
3059            && memory_operand (operands[0], DFmode)))"
3060 {
3061   switch (which_alternative)
3062     {
3063     case 0:
3064     case 1:
3065       return output_387_reg_move (insn, operands);
3066
3067     case 2:
3068       return standard_80387_constant_opcode (operands[1]);
3069
3070     case 3:
3071     case 4:
3072       return "#";
3073
3074     case 5:
3075       return standard_sse_constant_opcode (insn, operands[1]);
3076
3077     case 6:
3078     case 7:
3079     case 8:
3080       switch (get_attr_mode (insn))
3081         {
3082         case MODE_V4SF:
3083           return "%vmovaps\t{%1, %0|%0, %1}";
3084         case MODE_V2DF:
3085           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
3086             return "%vmovaps\t{%1, %0|%0, %1}";
3087           else
3088             return "%vmovapd\t{%1, %0|%0, %1}";
3089         case MODE_TI:
3090           if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
3091             return "%vmovaps\t{%1, %0|%0, %1}";
3092           else
3093             return "%vmovdqa\t{%1, %0|%0, %1}";
3094         case MODE_DI:
3095           return "%vmovq\t{%1, %0|%0, %1}";
3096         case MODE_DF:
3097           if (TARGET_AVX && REG_P (operands[0]) && REG_P (operands[1]))
3098             return "vmovsd\t{%1, %0, %0|%0, %0, %1}";
3099           else
3100             return "%vmovsd\t{%1, %0|%0, %1}";
3101         case MODE_V1DF:
3102           if (TARGET_AVX && REG_P (operands[0]))
3103             return "vmovlpd\t{%1, %0, %0|%0, %0, %1}";
3104           else
3105             return "%vmovlpd\t{%1, %0|%0, %1}";
3106         case MODE_V2SF:
3107           if (TARGET_AVX && REG_P (operands[0]))
3108             return "vmovlps\t{%1, %0, %0|%0, %0, %1}";
3109           else
3110             return "%vmovlps\t{%1, %0|%0, %1}";
3111         default:
3112           gcc_unreachable ();
3113         }
3114
3115     default:
3116       gcc_unreachable ();
3117     }
3118 }
3119   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov")
3120    (set (attr "prefix")
3121      (if_then_else (eq_attr "alternative" "0,1,2,3,4")
3122        (const_string "orig")
3123        (const_string "maybe_vex")))
3124    (set (attr "prefix_data16")
3125      (if_then_else (eq_attr "mode" "V1DF")
3126        (const_string "1")
3127        (const_string "*")))
3128    (set (attr "mode")
3129         (cond [(eq_attr "alternative" "0,1,2")
3130                  (const_string "DF")
3131                (eq_attr "alternative" "3,4")
3132                  (const_string "SI")
3133
3134                /* For SSE1, we have many fewer alternatives.  */
3135                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
3136                  (cond [(eq_attr "alternative" "5,6")
3137                           (const_string "V4SF")
3138                        ]
3139                    (const_string "V2SF"))
3140
3141                /* xorps is one byte shorter.  */
3142                (eq_attr "alternative" "5")
3143                  (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3144                             (const_int 0))
3145                           (const_string "V4SF")
3146                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3147                             (const_int 0))
3148                           (const_string "TI")
3149                        ]
3150                        (const_string "V2DF"))
3151
3152                /* For architectures resolving dependencies on
3153                   whole SSE registers use APD move to break dependency
3154                   chains, otherwise use short move to avoid extra work.
3155
3156                   movaps encodes one byte shorter.  */
3157                (eq_attr "alternative" "6")
3158                  (cond
3159                    [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3160                         (const_int 0))
3161                       (const_string "V4SF")
3162                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3163                         (const_int 0))
3164                       (const_string "V2DF")
3165                    ]
3166                    (const_string "DF"))
3167                /* For architectures resolving dependencies on register
3168                   parts we may avoid extra work to zero out upper part
3169                   of register.  */
3170                (eq_attr "alternative" "7")
3171                  (if_then_else
3172                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3173                        (const_int 0))
3174                    (const_string "V1DF")
3175                    (const_string "DF"))
3176               ]
3177               (const_string "DF")))])
3178
3179 (define_split
3180   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3181         (match_operand:DF 1 "general_operand" ""))]
3182   "reload_completed
3183    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3184    && ! (ANY_FP_REG_P (operands[0]) ||
3185          (GET_CODE (operands[0]) == SUBREG
3186           && ANY_FP_REG_P (SUBREG_REG (operands[0]))))
3187    && ! (ANY_FP_REG_P (operands[1]) ||
3188          (GET_CODE (operands[1]) == SUBREG
3189           && ANY_FP_REG_P (SUBREG_REG (operands[1]))))"
3190   [(const_int 0)]
3191   "ix86_split_long_move (operands); DONE;")
3192
3193 (define_insn "*movsf_internal"
3194   [(set (match_operand:SF 0 "nonimmediate_operand"
3195           "=f,m,f,r  ,m ,x,x,x ,m,!*y,!m,!*y,?Yi,?r,!*Ym,!r")
3196         (match_operand:SF 1 "general_operand"
3197           "fm,f,G,rmF,Fr,C,x,xm,x,m  ,*y,*y ,r  ,Yi,r   ,*Ym"))]
3198   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
3199    && (!can_create_pseudo_p ()
3200        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3201        || GET_CODE (operands[1]) != CONST_DOUBLE
3202        || (optimize_function_for_size_p (cfun)
3203            && ((!TARGET_SSE_MATH
3204                 && standard_80387_constant_p (operands[1]) > 0)
3205                || (TARGET_SSE_MATH
3206                    && standard_sse_constant_p (operands[1]))))
3207        || memory_operand (operands[0], SFmode))"
3208 {
3209   switch (which_alternative)
3210     {
3211     case 0:
3212     case 1:
3213       return output_387_reg_move (insn, operands);
3214
3215     case 2:
3216       return standard_80387_constant_opcode (operands[1]);
3217
3218     case 3:
3219     case 4:
3220       return "mov{l}\t{%1, %0|%0, %1}";
3221
3222     case 5:
3223       return standard_sse_constant_opcode (insn, operands[1]);
3224
3225     case 6:
3226       if (get_attr_mode (insn) == MODE_V4SF)
3227         return "%vmovaps\t{%1, %0|%0, %1}";
3228       else
3229         return "%vmovss\t{%1, %d0|%d0, %1}";
3230     case 7:
3231       if (TARGET_AVX && REG_P (operands[1]))
3232         return "vmovss\t{%1, %0, %0|%0, %0, %1}";
3233       else
3234         return "%vmovss\t{%1, %0|%0, %1}";
3235     case 8:
3236       return "%vmovss\t{%1, %0|%0, %1}";
3237
3238     case 9: case 10: case 14: case 15:
3239       return "movd\t{%1, %0|%0, %1}";
3240
3241     case 11:
3242       return "movq\t{%1, %0|%0, %1}";
3243
3244     case 12: case 13:
3245       return "%vmovd\t{%1, %0|%0, %1}";
3246
3247     default:
3248       gcc_unreachable ();
3249     }
3250 }
3251   [(set_attr "type" "fmov,fmov,fmov,imov,imov,sselog1,ssemov,ssemov,ssemov,mmxmov,mmxmov,mmxmov,ssemov,ssemov,mmxmov,mmxmov")
3252    (set (attr "prefix")
3253      (if_then_else (eq_attr "alternative" "5,6,7,8,12,13")
3254        (const_string "maybe_vex")
3255        (const_string "orig")))
3256    (set (attr "mode")
3257         (cond [(eq_attr "alternative" "3,4,9,10")
3258                  (const_string "SI")
3259                (eq_attr "alternative" "5")
3260                  (if_then_else
3261                    (and (and (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3262                                  (const_int 0))
3263                              (ne (symbol_ref "TARGET_SSE2")
3264                                  (const_int 0)))
3265                         (eq (symbol_ref "optimize_function_for_size_p (cfun)")
3266                             (const_int 0)))
3267                    (const_string "TI")
3268                    (const_string "V4SF"))
3269                /* For architectures resolving dependencies on
3270                   whole SSE registers use APS move to break dependency
3271                   chains, otherwise use short move to avoid extra work.
3272
3273                   Do the same for architectures resolving dependencies on
3274                   the parts.  While in DF mode it is better to always handle
3275                   just register parts, the SF mode is different due to lack
3276                   of instructions to load just part of the register.  It is
3277                   better to maintain the whole registers in single format
3278                   to avoid problems on using packed logical operations.  */
3279                (eq_attr "alternative" "6")
3280                  (if_then_else
3281                    (ior (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3282                             (const_int 0))
3283                         (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3284                             (const_int 0)))
3285                    (const_string "V4SF")
3286                    (const_string "SF"))
3287                (eq_attr "alternative" "11")
3288                  (const_string "DI")]
3289                (const_string "SF")))])
3290
3291 (define_split
3292   [(set (match_operand 0 "register_operand" "")
3293         (match_operand 1 "memory_operand" ""))]
3294   "reload_completed
3295    && MEM_P (operands[1])
3296    && (GET_MODE (operands[0]) == TFmode
3297        || GET_MODE (operands[0]) == XFmode
3298        || GET_MODE (operands[0]) == DFmode
3299        || GET_MODE (operands[0]) == SFmode)
3300    && (operands[2] = find_constant_src (insn))"
3301   [(set (match_dup 0) (match_dup 2))]
3302 {
3303   rtx c = operands[2];
3304   rtx r = operands[0];
3305
3306   if (GET_CODE (r) == SUBREG)
3307     r = SUBREG_REG (r);
3308
3309   if (SSE_REG_P (r))
3310     {
3311       if (!standard_sse_constant_p (c))
3312         FAIL;
3313     }
3314   else if (FP_REG_P (r))
3315     {
3316       if (standard_80387_constant_p (c) < 1)
3317         FAIL;
3318     }
3319   else if (MMX_REG_P (r))
3320     FAIL;
3321 })
3322
3323 (define_split
3324   [(set (match_operand 0 "register_operand" "")
3325         (float_extend (match_operand 1 "memory_operand" "")))]
3326   "reload_completed
3327    && MEM_P (operands[1])
3328    && (GET_MODE (operands[0]) == TFmode
3329        || GET_MODE (operands[0]) == XFmode
3330        || GET_MODE (operands[0]) == DFmode
3331        || GET_MODE (operands[0]) == SFmode)
3332    && (operands[2] = find_constant_src (insn))"
3333   [(set (match_dup 0) (match_dup 2))]
3334 {
3335   rtx c = operands[2];
3336   rtx r = operands[0];
3337
3338   if (GET_CODE (r) == SUBREG)
3339     r = SUBREG_REG (r);
3340
3341   if (SSE_REG_P (r))
3342     {
3343       if (!standard_sse_constant_p (c))
3344         FAIL;
3345     }
3346   else if (FP_REG_P (r))
3347     {
3348       if (standard_80387_constant_p (c) < 1)
3349         FAIL;
3350     }
3351   else if (MMX_REG_P (r))
3352     FAIL;
3353 })
3354
3355 ;; Split the load of -0.0 or -1.0 into fldz;fchs or fld1;fchs sequence
3356 (define_split
3357   [(set (match_operand:X87MODEF 0 "register_operand" "")
3358         (match_operand:X87MODEF 1 "immediate_operand" ""))]
3359   "reload_completed && FP_REGNO_P (REGNO (operands[0]))
3360    && (standard_80387_constant_p (operands[1]) == 8
3361        || standard_80387_constant_p (operands[1]) == 9)"
3362   [(set (match_dup 0)(match_dup 1))
3363    (set (match_dup 0)
3364         (neg:X87MODEF (match_dup 0)))]
3365 {
3366   REAL_VALUE_TYPE r;
3367
3368   REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
3369   if (real_isnegzero (&r))
3370     operands[1] = CONST0_RTX (<MODE>mode);
3371   else
3372     operands[1] = CONST1_RTX (<MODE>mode);
3373 })
3374
3375 (define_insn "swapxf"
3376   [(set (match_operand:XF 0 "register_operand" "+f")
3377         (match_operand:XF 1 "register_operand" "+f"))
3378    (set (match_dup 1)
3379         (match_dup 0))]
3380   "TARGET_80387"
3381 {
3382   if (STACK_TOP_P (operands[0]))
3383     return "fxch\t%1";
3384   else
3385     return "fxch\t%0";
3386 }
3387   [(set_attr "type" "fxch")
3388    (set_attr "mode" "XF")])
3389
3390 (define_insn "*swap<mode>"
3391   [(set (match_operand:MODEF 0 "fp_register_operand" "+f")
3392         (match_operand:MODEF 1 "fp_register_operand" "+f"))
3393    (set (match_dup 1)
3394         (match_dup 0))]
3395   "TARGET_80387 || reload_completed"
3396 {
3397   if (STACK_TOP_P (operands[0]))
3398     return "fxch\t%1";
3399   else
3400     return "fxch\t%0";
3401 }
3402   [(set_attr "type" "fxch")
3403    (set_attr "mode" "<MODE>")])
3404 \f
3405 ;; Zero extension instructions
3406
3407 (define_expand "zero_extendsidi2"
3408   [(set (match_operand:DI 0 "nonimmediate_operand" "")
3409         (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))]
3410   ""
3411 {
3412   if (!TARGET_64BIT)
3413     {
3414       emit_insn (gen_zero_extendsidi2_1 (operands[0], operands[1]));
3415       DONE;
3416     }
3417 })
3418
3419 (define_insn "*zero_extendsidi2_rex64"
3420   [(set (match_operand:DI 0 "nonimmediate_operand"  "=r,o,?*Ym,?*y,?*Yi,*Y2")
3421         (zero_extend:DI
3422          (match_operand:SI 1 "nonimmediate_operand" "rm,0,r   ,m  ,r   ,m")))]
3423   "TARGET_64BIT"
3424   "@
3425    mov\t{%k1, %k0|%k0, %k1}
3426    #
3427    movd\t{%1, %0|%0, %1}
3428    movd\t{%1, %0|%0, %1}
3429    %vmovd\t{%1, %0|%0, %1}
3430    %vmovd\t{%1, %0|%0, %1}"
3431   [(set_attr "type" "imovx,imov,mmxmov,mmxmov,ssemov,ssemov")
3432    (set_attr "prefix" "orig,*,orig,orig,maybe_vex,maybe_vex")
3433    (set_attr "prefix_0f" "0,*,*,*,*,*")
3434    (set_attr "mode" "SI,DI,DI,DI,TI,TI")])
3435
3436 (define_split
3437   [(set (match_operand:DI 0 "memory_operand" "")
3438         (zero_extend:DI (match_dup 0)))]
3439   "TARGET_64BIT"
3440   [(set (match_dup 4) (const_int 0))]
3441   "split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);")
3442
3443 ;; %%% Kill me once multi-word ops are sane.
3444 (define_insn "zero_extendsidi2_1"
3445   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,?r,?o,?*Ym,?*y,?*Yi,*Y2")
3446         (zero_extend:DI
3447          (match_operand:SI 1 "nonimmediate_operand" "0,rm,r ,r   ,m  ,r   ,m")))
3448    (clobber (reg:CC FLAGS_REG))]
3449   "!TARGET_64BIT"
3450   "@
3451    #
3452    #
3453    #
3454    movd\t{%1, %0|%0, %1}
3455    movd\t{%1, %0|%0, %1}
3456    %vmovd\t{%1, %0|%0, %1}
3457    %vmovd\t{%1, %0|%0, %1}"
3458   [(set_attr "type" "multi,multi,multi,mmxmov,mmxmov,ssemov,ssemov")
3459    (set_attr "prefix" "*,*,*,orig,orig,maybe_vex,maybe_vex")
3460    (set_attr "mode" "SI,SI,SI,DI,DI,TI,TI")])
3461
3462 (define_split
3463   [(set (match_operand:DI 0 "register_operand" "")
3464         (zero_extend:DI (match_operand:SI 1 "register_operand" "")))
3465    (clobber (reg:CC FLAGS_REG))]
3466   "!TARGET_64BIT && reload_completed
3467    && true_regnum (operands[0]) == true_regnum (operands[1])"
3468   [(set (match_dup 4) (const_int 0))]
3469   "split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);")
3470
3471 (define_split
3472   [(set (match_operand:DI 0 "nonimmediate_operand" "")
3473         (zero_extend:DI (match_operand:SI 1 "general_operand" "")))
3474    (clobber (reg:CC FLAGS_REG))]
3475   "!TARGET_64BIT && reload_completed
3476    && !(MMX_REG_P (operands[0]) || SSE_REG_P (operands[0]))"
3477   [(set (match_dup 3) (match_dup 1))
3478    (set (match_dup 4) (const_int 0))]
3479   "split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);")
3480
3481 (define_insn "zero_extend<mode>di2"
3482   [(set (match_operand:DI 0 "register_operand" "=r")
3483         (zero_extend:DI
3484          (match_operand:SWI12 1 "nonimmediate_operand" "<r>m")))]
3485   "TARGET_64BIT"
3486   "movz{<imodesuffix>l|x}\t{%1, %k0|%k0, %1}"
3487   [(set_attr "type" "imovx")
3488    (set_attr "mode" "SI")])
3489
3490 (define_expand "zero_extendhisi2"
3491   [(set (match_operand:SI 0 "register_operand" "")
3492         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "")))]
3493   ""
3494 {
3495   if (TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun))
3496     {
3497       operands[1] = force_reg (HImode, operands[1]);
3498       emit_insn (gen_zero_extendhisi2_and (operands[0], operands[1]));
3499       DONE;
3500     }
3501 })
3502
3503 (define_insn_and_split "zero_extendhisi2_and"
3504   [(set (match_operand:SI 0 "register_operand" "=r")
3505         (zero_extend:SI (match_operand:HI 1 "register_operand" "0")))
3506    (clobber (reg:CC FLAGS_REG))]
3507   "TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun)"
3508   "#"
3509   "&& reload_completed"
3510   [(parallel [(set (match_dup 0) (and:SI (match_dup 0) (const_int 65535)))
3511               (clobber (reg:CC FLAGS_REG))])]
3512   ""
3513   [(set_attr "type" "alu1")
3514    (set_attr "mode" "SI")])
3515
3516 (define_insn "*zero_extendhisi2_movzwl"
3517   [(set (match_operand:SI 0 "register_operand" "=r")
3518         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "rm")))]
3519   "!TARGET_ZERO_EXTEND_WITH_AND
3520    || optimize_function_for_size_p (cfun)"
3521   "movz{wl|x}\t{%1, %0|%0, %1}"
3522   [(set_attr "type" "imovx")
3523    (set_attr "mode" "SI")])
3524
3525 (define_expand "zero_extendqi<mode>2"
3526   [(parallel
3527     [(set (match_operand:SWI24 0 "register_operand" "")
3528           (zero_extend:SWI24 (match_operand:QI 1 "nonimmediate_operand" "")))
3529      (clobber (reg:CC FLAGS_REG))])])
3530
3531 (define_insn "*zero_extendqi<mode>2_and"
3532   [(set (match_operand:SWI24 0 "register_operand" "=r,?&q")
3533         (zero_extend:SWI24 (match_operand:QI 1 "nonimmediate_operand" "0,qm")))
3534    (clobber (reg:CC FLAGS_REG))]
3535   "TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun)"
3536   "#"
3537   [(set_attr "type" "alu1")
3538    (set_attr "mode" "<MODE>")])
3539
3540 ;; When source and destination does not overlap, clear destination
3541 ;; first and then do the movb
3542 (define_split
3543   [(set (match_operand:SWI24 0 "register_operand" "")
3544         (zero_extend:SWI24 (match_operand:QI 1 "nonimmediate_operand" "")))
3545    (clobber (reg:CC FLAGS_REG))]
3546   "reload_completed
3547    && (TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun))
3548    && ANY_QI_REG_P (operands[0])
3549    && (ANY_QI_REG_P (operands[1]) || MEM_P (operands[1]))
3550    && !reg_overlap_mentioned_p (operands[0], operands[1])"
3551   [(set (strict_low_part (match_dup 2)) (match_dup 1))]
3552 {
3553   operands[2] = gen_lowpart (QImode, operands[0]);
3554   ix86_expand_clear (operands[0]);
3555 })
3556
3557 (define_insn "*zero_extendqi<mode>2_movzbl_and"
3558   [(set (match_operand:SWI24 0 "register_operand" "=r,r")
3559         (zero_extend:SWI24 (match_operand:QI 1 "nonimmediate_operand" "qm,0")))
3560    (clobber (reg:CC FLAGS_REG))]
3561   "!TARGET_ZERO_EXTEND_WITH_AND || optimize_function_for_size_p (cfun)"
3562   "#"
3563   [(set_attr "type" "imovx,alu1")
3564    (set_attr "mode" "<MODE>")])
3565
3566 ;; For the movzbl case strip only the clobber
3567 (define_split
3568   [(set (match_operand:SWI24 0 "register_operand" "")
3569         (zero_extend:SWI24 (match_operand:QI 1 "nonimmediate_operand" "")))
3570    (clobber (reg:CC FLAGS_REG))]
3571   "reload_completed
3572    && (!TARGET_ZERO_EXTEND_WITH_AND || optimize_function_for_size_p (cfun))
3573    && (!REG_P (operands[1]) || ANY_QI_REG_P (operands[1]))"
3574   [(set (match_dup 0)
3575         (zero_extend:SWI24 (match_dup 1)))])
3576
3577 ; zero extend to SImode to avoid partial register stalls
3578 (define_insn "*zero_extendqi<mode>2_movzbl"
3579   [(set (match_operand:SWI24 0 "register_operand" "=r")
3580         (zero_extend:SWI24 (match_operand:QI 1 "nonimmediate_operand" "qm")))]
3581   "reload_completed
3582    && (!TARGET_ZERO_EXTEND_WITH_AND || optimize_function_for_size_p (cfun))"
3583   "movz{bl|x}\t{%1, %k0|%k0, %1}"
3584   [(set_attr "type" "imovx")
3585    (set_attr "mode" "SI")])
3586
3587 ;; Rest is handled by single and.
3588 (define_split
3589   [(set (match_operand:SWI24 0 "register_operand" "")
3590         (zero_extend:SWI24 (match_operand:QI 1 "register_operand" "")))
3591    (clobber (reg:CC FLAGS_REG))]
3592   "reload_completed
3593    && true_regnum (operands[0]) == true_regnum (operands[1])"
3594   [(parallel [(set (match_dup 0) (and:SWI24 (match_dup 0) (const_int 255)))
3595               (clobber (reg:CC FLAGS_REG))])])
3596 \f
3597 ;; Sign extension instructions
3598
3599 (define_expand "extendsidi2"
3600   [(set (match_operand:DI 0 "register_operand" "")
3601         (sign_extend:DI (match_operand:SI 1 "register_operand" "")))]
3602   ""
3603 {
3604   if (!TARGET_64BIT)
3605     {
3606       emit_insn (gen_extendsidi2_1 (operands[0], operands[1]));
3607       DONE;
3608     }
3609 })
3610
3611 (define_insn "*extendsidi2_rex64"
3612   [(set (match_operand:DI 0 "register_operand" "=*a,r")
3613         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "*0,rm")))]
3614   "TARGET_64BIT"
3615   "@
3616    {cltq|cdqe}
3617    movs{lq|x}\t{%1, %0|%0, %1}"
3618   [(set_attr "type" "imovx")
3619    (set_attr "mode" "DI")
3620    (set_attr "prefix_0f" "0")
3621    (set_attr "modrm" "0,1")])
3622
3623 (define_insn "extendsidi2_1"
3624   [(set (match_operand:DI 0 "nonimmediate_operand" "=*A,r,?r,?*o")
3625         (sign_extend:DI (match_operand:SI 1 "register_operand" "0,0,r,r")))
3626    (clobber (reg:CC FLAGS_REG))
3627    (clobber (match_scratch:SI 2 "=X,X,X,&r"))]
3628   "!TARGET_64BIT"
3629   "#")
3630
3631 ;; Extend to memory case when source register does die.
3632 (define_split
3633   [(set (match_operand:DI 0 "memory_operand" "")
3634         (sign_extend:DI (match_operand:SI 1 "register_operand" "")))
3635    (clobber (reg:CC FLAGS_REG))
3636    (clobber (match_operand:SI 2 "register_operand" ""))]
3637   "(reload_completed
3638     && dead_or_set_p (insn, operands[1])
3639     && !reg_mentioned_p (operands[1], operands[0]))"
3640   [(set (match_dup 3) (match_dup 1))
3641    (parallel [(set (match_dup 1) (ashiftrt:SI (match_dup 1) (const_int 31)))
3642               (clobber (reg:CC FLAGS_REG))])
3643    (set (match_dup 4) (match_dup 1))]
3644   "split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);")
3645
3646 ;; Extend to memory case when source register does not die.
3647 (define_split
3648   [(set (match_operand:DI 0 "memory_operand" "")
3649         (sign_extend:DI (match_operand:SI 1 "register_operand" "")))
3650    (clobber (reg:CC FLAGS_REG))
3651    (clobber (match_operand:SI 2 "register_operand" ""))]
3652   "reload_completed"
3653   [(const_int 0)]
3654 {
3655   split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);
3656
3657   emit_move_insn (operands[3], operands[1]);
3658
3659   /* Generate a cltd if possible and doing so it profitable.  */
3660   if ((optimize_function_for_size_p (cfun) || TARGET_USE_CLTD)
3661       && true_regnum (operands[1]) == AX_REG
3662       && true_regnum (operands[2]) == DX_REG)
3663     {
3664       emit_insn (gen_ashrsi3_cvt (operands[2], operands[1], GEN_INT (31)));
3665     }
3666   else
3667     {
3668       emit_move_insn (operands[2], operands[1]);
3669       emit_insn (gen_ashrsi3_cvt (operands[2], operands[2], GEN_INT (31)));
3670     }
3671   emit_move_insn (operands[4], operands[2]);
3672   DONE;
3673 })
3674
3675 ;; Extend to register case.  Optimize case where source and destination
3676 ;; registers match and cases where we can use cltd.
3677 (define_split
3678   [(set (match_operand:DI 0 "register_operand" "")
3679         (sign_extend:DI (match_operand:SI 1 "register_operand" "")))
3680    (clobber (reg:CC FLAGS_REG))
3681    (clobber (match_scratch:SI 2 ""))]
3682   "reload_completed"
3683   [(const_int 0)]
3684 {
3685   split_double_mode (DImode, &operands[0], 1, &operands[3], &operands[4]);
3686
3687   if (true_regnum (operands[3]) != true_regnum (operands[1]))
3688     emit_move_insn (operands[3], operands[1]);
3689
3690   /* Generate a cltd if possible and doing so it profitable.  */
3691   if ((optimize_function_for_size_p (cfun) || TARGET_USE_CLTD)
3692       && true_regnum (operands[3]) == AX_REG
3693       && true_regnum (operands[4]) == DX_REG)
3694     {
3695       emit_insn (gen_ashrsi3_cvt (operands[4], operands[3], GEN_INT (31)));
3696       DONE;
3697     }
3698
3699   if (true_regnum (operands[4]) != true_regnum (operands[1]))
3700     emit_move_insn (operands[4], operands[1]);
3701
3702   emit_insn (gen_ashrsi3_cvt (operands[4], operands[4], GEN_INT (31)));
3703   DONE;
3704 })
3705
3706 (define_insn "extend<mode>di2"
3707   [(set (match_operand:DI 0 "register_operand" "=r")
3708         (sign_extend:DI
3709          (match_operand:SWI12 1 "nonimmediate_operand" "<r>m")))]
3710   "TARGET_64BIT"
3711   "movs{<imodesuffix>q|x}\t{%1, %0|%0, %1}"
3712   [(set_attr "type" "imovx")
3713    (set_attr "mode" "DI")])
3714
3715 (define_insn "extendhisi2"
3716   [(set (match_operand:SI 0 "register_operand" "=*a,r")
3717         (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "*0,rm")))]
3718   ""
3719 {
3720   switch (get_attr_prefix_0f (insn))
3721     {
3722     case 0:
3723       return "{cwtl|cwde}";
3724     default:
3725       return "movs{wl|x}\t{%1, %0|%0, %1}";
3726     }
3727 }
3728   [(set_attr "type" "imovx")
3729    (set_attr "mode" "SI")
3730    (set (attr "prefix_0f")
3731      ;; movsx is short decodable while cwtl is vector decoded.
3732      (if_then_else (and (eq_attr "cpu" "!k6")
3733                         (eq_attr "alternative" "0"))
3734         (const_string "0")
3735         (const_string "1")))
3736    (set (attr "modrm")
3737      (if_then_else (eq_attr "prefix_0f" "0")
3738         (const_string "0")
3739         (const_string "1")))])
3740
3741 (define_insn "*extendhisi2_zext"
3742   [(set (match_operand:DI 0 "register_operand" "=*a,r")
3743         (zero_extend:DI
3744          (sign_extend:SI
3745           (match_operand:HI 1 "nonimmediate_operand" "*0,rm"))))]
3746   "TARGET_64BIT"
3747 {
3748   switch (get_attr_prefix_0f (insn))
3749     {
3750     case 0:
3751       return "{cwtl|cwde}";
3752     default:
3753       return "movs{wl|x}\t{%1, %k0|%k0, %1}";
3754     }
3755 }
3756   [(set_attr "type" "imovx")
3757    (set_attr "mode" "SI")
3758    (set (attr "prefix_0f")
3759      ;; movsx is short decodable while cwtl is vector decoded.
3760      (if_then_else (and (eq_attr "cpu" "!k6")
3761                         (eq_attr "alternative" "0"))
3762         (const_string "0")
3763         (const_string "1")))
3764    (set (attr "modrm")
3765      (if_then_else (eq_attr "prefix_0f" "0")
3766         (const_string "0")
3767         (const_string "1")))])
3768
3769 (define_insn "extendqisi2"
3770   [(set (match_operand:SI 0 "register_operand" "=r")
3771         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "qm")))]
3772   ""
3773   "movs{bl|x}\t{%1, %0|%0, %1}"
3774    [(set_attr "type" "imovx")
3775     (set_attr "mode" "SI")])
3776
3777 (define_insn "*extendqisi2_zext"
3778   [(set (match_operand:DI 0 "register_operand" "=r")
3779         (zero_extend:DI
3780           (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "qm"))))]
3781   "TARGET_64BIT"
3782   "movs{bl|x}\t{%1, %k0|%k0, %1}"
3783    [(set_attr "type" "imovx")
3784     (set_attr "mode" "SI")])
3785
3786 (define_insn "extendqihi2"
3787   [(set (match_operand:HI 0 "register_operand" "=*a,r")
3788         (sign_extend:HI (match_operand:QI 1 "nonimmediate_operand" "*0,qm")))]
3789   ""
3790 {
3791   switch (get_attr_prefix_0f (insn))
3792     {
3793     case 0:
3794       return "{cbtw|cbw}";
3795     default:
3796       return "movs{bw|x}\t{%1, %0|%0, %1}";
3797     }
3798 }
3799   [(set_attr "type" "imovx")
3800    (set_attr "mode" "HI")
3801    (set (attr "prefix_0f")
3802      ;; movsx is short decodable while cwtl is vector decoded.
3803      (if_then_else (and (eq_attr "cpu" "!k6")
3804                         (eq_attr "alternative" "0"))
3805         (const_string "0")
3806         (const_string "1")))
3807    (set (attr "modrm")
3808      (if_then_else (eq_attr "prefix_0f" "0")
3809         (const_string "0")
3810         (const_string "1")))])
3811 \f
3812 ;; Conversions between float and double.
3813
3814 ;; These are all no-ops in the model used for the 80387.
3815 ;; So just emit moves.
3816
3817 ;; %%% Kill these when call knows how to work out a DFmode push earlier.
3818 (define_split
3819   [(set (match_operand:DF 0 "push_operand" "")
3820         (float_extend:DF (match_operand:SF 1 "fp_register_operand" "")))]
3821   "reload_completed"
3822   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -8)))
3823    (set (mem:DF (reg:P SP_REG)) (float_extend:DF (match_dup 1)))])
3824
3825 (define_split
3826   [(set (match_operand:XF 0 "push_operand" "")
3827         (float_extend:XF (match_operand:MODEF 1 "fp_register_operand" "")))]
3828   "reload_completed"
3829   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
3830    (set (mem:XF (reg:P SP_REG)) (float_extend:XF (match_dup 1)))]
3831   "operands[2] = GEN_INT (-GET_MODE_SIZE (XFmode));")
3832
3833 (define_expand "extendsfdf2"
3834   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3835         (float_extend:DF (match_operand:SF 1 "general_operand" "")))]
3836   "TARGET_80387 || (TARGET_SSE2 && TARGET_SSE_MATH)"
3837 {
3838   /* ??? Needed for compress_float_constant since all fp constants
3839      are TARGET_LEGITIMATE_CONSTANT_P.  */
3840   if (GET_CODE (operands[1]) == CONST_DOUBLE)
3841     {
3842       if ((!TARGET_SSE2 || TARGET_MIX_SSE_I387)
3843           && standard_80387_constant_p (operands[1]) > 0)
3844         {
3845           operands[1] = simplify_const_unary_operation
3846             (FLOAT_EXTEND, DFmode, operands[1], SFmode);
3847           emit_move_insn_1 (operands[0], operands[1]);
3848           DONE;
3849         }
3850       operands[1] = validize_mem (force_const_mem (SFmode, operands[1]));
3851     }
3852 })
3853
3854 /* For converting SF(xmm2) to DF(xmm1), use the following code instead of
3855    cvtss2sd:
3856       unpcklps xmm2,xmm2   ; packed conversion might crash on signaling NaNs
3857       cvtps2pd xmm2,xmm1
3858    We do the conversion post reload to avoid producing of 128bit spills
3859    that might lead to ICE on 32bit target.  The sequence unlikely combine
3860    anyway.  */
3861 (define_split
3862   [(set (match_operand:DF 0 "register_operand" "")
3863         (float_extend:DF
3864           (match_operand:SF 1 "nonimmediate_operand" "")))]
3865   "TARGET_USE_VECTOR_FP_CONVERTS
3866    && optimize_insn_for_speed_p ()
3867    && reload_completed && SSE_REG_P (operands[0])"
3868    [(set (match_dup 2)
3869          (float_extend:V2DF
3870            (vec_select:V2SF
3871              (match_dup 3)
3872              (parallel [(const_int 0) (const_int 1)]))))]
3873 {
3874   operands[2] = simplify_gen_subreg (V2DFmode, operands[0], DFmode, 0);
3875   operands[3] = simplify_gen_subreg (V4SFmode, operands[0], DFmode, 0);
3876   /* Use movss for loading from memory, unpcklps reg, reg for registers.
3877      Try to avoid move when unpacking can be done in source.  */
3878   if (REG_P (operands[1]))
3879     {
3880       /* If it is unsafe to overwrite upper half of source, we need
3881          to move to destination and unpack there.  */
3882       if ((ORIGINAL_REGNO (operands[1]) < FIRST_PSEUDO_REGISTER
3883            || PSEUDO_REGNO_BYTES (ORIGINAL_REGNO (operands[1])) > 4)
3884           && true_regnum (operands[0]) != true_regnum (operands[1]))
3885         {
3886           rtx tmp = gen_rtx_REG (SFmode, true_regnum (operands[0]));
3887           emit_move_insn (tmp, operands[1]);
3888         }
3889       else
3890         operands[3] = simplify_gen_subreg (V4SFmode, operands[1], SFmode, 0);
3891       emit_insn (gen_vec_interleave_lowv4sf (operands[3], operands[3],
3892                                              operands[3]));
3893     }
3894   else
3895     emit_insn (gen_vec_setv4sf_0 (operands[3],
3896                                   CONST0_RTX (V4SFmode), operands[1]));
3897 })
3898
3899 (define_insn "*extendsfdf2_mixed"
3900   [(set (match_operand:DF 0 "nonimmediate_operand" "=f,m,x")
3901         (float_extend:DF
3902           (match_operand:SF 1 "nonimmediate_operand" "fm,f,xm")))]
3903   "TARGET_SSE2 && TARGET_MIX_SSE_I387"
3904 {
3905   switch (which_alternative)
3906     {
3907     case 0:
3908     case 1:
3909       return output_387_reg_move (insn, operands);
3910
3911     case 2:
3912       return "%vcvtss2sd\t{%1, %d0|%d0, %1}";
3913
3914     default:
3915       gcc_unreachable ();
3916     }
3917 }
3918   [(set_attr "type" "fmov,fmov,ssecvt")
3919    (set_attr "prefix" "orig,orig,maybe_vex")
3920    (set_attr "mode" "SF,XF,DF")])
3921
3922 (define_insn "*extendsfdf2_sse"
3923   [(set (match_operand:DF 0 "nonimmediate_operand" "=x")