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
   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 ;; 'z' mov%z1 would be movl, movw, or movb depending on the mode of
  31 ;;     operands[1].
  32 ;; 'L' Print the opcode suffix for a 32-bit integer opcode.
  33 ;; 'W' Print the opcode suffix for a 16-bit integer opcode.
  34 ;; 'B' Print the opcode suffix for an 8-bit integer opcode.
  35 ;; 'Q' Print the opcode suffix for a 64-bit float opcode.
  36 ;; 'S' Print the opcode suffix for a 32-bit float opcode.
  37 ;; 'T' Print the opcode suffix for an 80-bit extended real XFmode float opcode.
  38 ;; 'J' Print the appropriate jump operand.
  39 ;;
  40 ;; 'b' Print the QImode name of the register for the indicated operand.
  41 ;;     %b0 would print %al if operands[0] is reg 0.
  42 ;; 'w' Likewise, print the HImode name of the register.
  43 ;; 'k' Likewise, print the SImode name of the register.
  44 ;; 'h' Print the QImode name for a "high" register, either ah, bh, ch or dh.
  45 ;; 'y' Print "st(0)" instead of "st" as a register.
  46
  47 ;; UNSPEC usage:
  48
  49 (define_constants
  50   [; Relocation specifiers
  51    (UNSPEC_GOT                  0)
  52    (UNSPEC_GOTOFF               1)
  53    (UNSPEC_GOTPCREL             2)
  54    (UNSPEC_GOTTPOFF             3)
  55    (UNSPEC_TPOFF                4)
  56    (UNSPEC_NTPOFF               5)
  57    (UNSPEC_DTPOFF               6)
  58    (UNSPEC_GOTNTPOFF            7)
  59    (UNSPEC_INDNTPOFF            8)
  60    (UNSPEC_PLTOFF               9)
  61
  62    ; Prologue support
  63    (UNSPEC_STACK_ALLOC          11)
  64    (UNSPEC_SET_GOT              12)
  65    (UNSPEC_SSE_PROLOGUE_SAVE    13)
  66    (UNSPEC_REG_SAVE             14)
  67    (UNSPEC_DEF_CFA              15)
  68    (UNSPEC_SET_RIP              16)
  69    (UNSPEC_SET_GOT_OFFSET       17)
  70
  71    ; TLS support
  72    (UNSPEC_TP                   18)
  73    (UNSPEC_TLS_GD               19)
  74    (UNSPEC_TLS_LD_BASE          20)
  75    (UNSPEC_TLSDESC              21)
  76
  77    ; Other random patterns
  78    (UNSPEC_SCAS                 30)
  79    (UNSPEC_FNSTSW               31)
  80    (UNSPEC_SAHF                 32)
  81    (UNSPEC_FSTCW                33)
  82    (UNSPEC_ADD_CARRY            34)
  83    (UNSPEC_FLDCW                35)
  84    (UNSPEC_REP                  36)
  85    (UNSPEC_EH_RETURN            37)
  86    (UNSPEC_LD_MPIC              38)     ; load_macho_picbase
  87    (UNSPEC_TRUNC_NOOP           39)
  88
  89    ; For SSE/MMX support:
  90    (UNSPEC_FIX_NOTRUNC          40)
  91    (UNSPEC_MASKMOV              41)
  92    (UNSPEC_MOVMSK               42)
  93    (UNSPEC_MOVNT                43)
  94    (UNSPEC_MOVU                 44)
  95    (UNSPEC_RCP                  45)
  96    (UNSPEC_RSQRT                46)
  97    (UNSPEC_SFENCE               47)
  98    (UNSPEC_PFRCP                49)
  99    (UNSPEC_PFRCPIT1             40)
 100    (UNSPEC_PFRCPIT2             41)
 101    (UNSPEC_PFRSQRT              42)
 102    (UNSPEC_PFRSQIT1             43)
 103    (UNSPEC_MFENCE               44)
 104    (UNSPEC_LFENCE               45)
 105    (UNSPEC_PSADBW               46)
 106    (UNSPEC_LDDQU                47)
 107
 108    ; Generic math support
 109    (UNSPEC_COPYSIGN             50)
 110    (UNSPEC_IEEE_MIN             51)     ; not commutative
 111    (UNSPEC_IEEE_MAX             52)     ; not commutative
 112
 113    ; x87 Floating point
 114    (UNSPEC_SIN                  60)
 115    (UNSPEC_COS                  61)
 116    (UNSPEC_FPATAN               62)
 117    (UNSPEC_FYL2X                63)
 118    (UNSPEC_FYL2XP1              64)
 119    (UNSPEC_FRNDINT              65)
 120    (UNSPEC_FIST                 66)
 121    (UNSPEC_F2XM1                67)
 122    (UNSPEC_TAN                  68)
 123    (UNSPEC_FXAM                 69)
 124
 125    ; x87 Rounding
 126    (UNSPEC_FRNDINT_FLOOR        70)
 127    (UNSPEC_FRNDINT_CEIL         71)
 128    (UNSPEC_FRNDINT_TRUNC        72)
 129    (UNSPEC_FRNDINT_MASK_PM      73)
 130    (UNSPEC_FIST_FLOOR           74)
 131    (UNSPEC_FIST_CEIL            75)
 132
 133    ; x87 Double output FP
 134    (UNSPEC_SINCOS_COS           80)
 135    (UNSPEC_SINCOS_SIN           81)
 136    (UNSPEC_XTRACT_FRACT         84)
 137    (UNSPEC_XTRACT_EXP           85)
 138    (UNSPEC_FSCALE_FRACT         86)
 139    (UNSPEC_FSCALE_EXP           87)
 140    (UNSPEC_FPREM_F              88)
 141    (UNSPEC_FPREM_U              89)
 142    (UNSPEC_FPREM1_F             90)
 143    (UNSPEC_FPREM1_U             91)
 144
 145    (UNSPEC_C2_FLAG              95)
 146
 147    ; SSP patterns
 148    (UNSPEC_SP_SET               100)
 149    (UNSPEC_SP_TEST              101)
 150    (UNSPEC_SP_TLS_SET           102)
 151    (UNSPEC_SP_TLS_TEST          103)
 152
 153    ; SSSE3
 154    (UNSPEC_PSHUFB               120)
 155    (UNSPEC_PSIGN                121)
 156    (UNSPEC_PALIGNR              122)
 157
 158    ; For SSE4A support
 159    (UNSPEC_EXTRQI               130)
 160    (UNSPEC_EXTRQ                131)
 161    (UNSPEC_INSERTQI             132)
 162    (UNSPEC_INSERTQ              133)
 163
 164    ; For SSE4.1 support
 165    (UNSPEC_BLENDV               134)
 166    (UNSPEC_INSERTPS             135)
 167    (UNSPEC_DP                   136)
 168    (UNSPEC_MOVNTDQA             137)
 169    (UNSPEC_MPSADBW              138)
 170    (UNSPEC_PHMINPOSUW           139)
 171    (UNSPEC_PTEST                140)
 172    (UNSPEC_ROUND                141)
 173
 174    ; For SSE4.2 support
 175    (UNSPEC_CRC32                143)
 176    (UNSPEC_PCMPESTR             144)
 177    (UNSPEC_PCMPISTR             145)
 178
 179    ;; For SSE5
 180    (UNSPEC_SSE5_INTRINSIC       150)
 181    (UNSPEC_SSE5_UNSIGNED_CMP    151)
 182    (UNSPEC_SSE5_TRUEFALSE       152)
 183    (UNSPEC_SSE5_PERMUTE         153)
 184    (UNSPEC_FRCZ                 154)
 185    (UNSPEC_CVTPH2PS             155)
 186    (UNSPEC_CVTPS2PH             156)
 187
 188    ; For AES support
 189    (UNSPEC_AESENC               159)
 190    (UNSPEC_AESENCLAST           160)
 191    (UNSPEC_AESDEC               161)
 192    (UNSPEC_AESDECLAST           162)
 193    (UNSPEC_AESIMC               163)
 194    (UNSPEC_AESKEYGENASSIST      164)
 195
 196    ; For PCLMUL support
 197    (UNSPEC_PCLMUL               165)
 198   ])
 199
 200 (define_constants
 201   [(UNSPECV_BLOCKAGE            0)
 202    (UNSPECV_STACK_PROBE         1)
 203    (UNSPECV_EMMS                2)
 204    (UNSPECV_LDMXCSR             3)
 205    (UNSPECV_STMXCSR             4)
 206    (UNSPECV_FEMMS               5)
 207    (UNSPECV_CLFLUSH             6)
 208    (UNSPECV_ALIGN               7)
 209    (UNSPECV_MONITOR             8)
 210    (UNSPECV_MWAIT               9)
 211    (UNSPECV_CMPXCHG_1           10)
 212    (UNSPECV_CMPXCHG_2           11)
 213    (UNSPECV_XCHG                12)
 214    (UNSPECV_LOCK                13)
 215    (UNSPECV_PROLOGUE_USE        14)
 216    (UNSPECV_CLD                 15)
 217   ])
 218
 219 ;; Constants to represent pcomtrue/pcomfalse variants
 220 (define_constants
 221   [(PCOM_FALSE                  0)
 222    (PCOM_TRUE                   1)
 223    (COM_FALSE_S                 2)
 224    (COM_FALSE_P                 3)
 225    (COM_TRUE_S                  4)
 226    (COM_TRUE_P                  5)
 227   ])
 228
 229 ;; Constants used in the SSE5 pperm instruction
 230 (define_constants
 231   [(PPERM_SRC                   0x00)   /* copy source */
 232    (PPERM_INVERT                0x20)   /* invert source */
 233    (PPERM_REVERSE               0x40)   /* bit reverse source */
 234    (PPERM_REV_INV               0x60)   /* bit reverse & invert src */
 235    (PPERM_ZERO                  0x80)   /* all 0's */
 236    (PPERM_ONES                  0xa0)   /* all 1's */
 237    (PPERM_SIGN                  0xc0)   /* propagate sign bit */
 238    (PPERM_INV_SIGN              0xe0)   /* invert & propagate sign */
 239    (PPERM_SRC1                  0x00)   /* use first source byte */
 240    (PPERM_SRC2                  0x10)   /* use second source byte */
 241    ])
 242
 243 ;; Registers by name.
 244 (define_constants
 245   [(AX_REG                       0)
 246    (DX_REG                       1)
 247    (CX_REG                       2)
 248    (SI_REG                       4)
 249    (DI_REG                       5)
 250    (BP_REG                       6)
 251    (SP_REG                       7)
 252    (FLAGS_REG                   17)
 253    (FPSR_REG                    18)
 254    (FPCR_REG                    19)
 255    (R10_REG                     39)
 256    (R11_REG                     40)
 257   ])
 258
 259 ;; Insns whose names begin with "x86_" are emitted by gen_FOO calls
 260 ;; from i386.c.
 261
 262 ;; In C guard expressions, put expressions which may be compile-time
 263 ;; constants first.  This allows for better optimization.  For
 264 ;; example, write "TARGET_64BIT && reload_completed", not
 265 ;; "reload_completed && TARGET_64BIT".
 266
 267 \f
 268 ;; Processor type.  This attribute must exactly match the processor_type
 269 ;; enumeration in i386.h.
 270 (define_attr "cpu" "i386,i486,pentium,pentiumpro,geode,k6,athlon,pentium4,k8,
 271                     nocona,core2,generic32,generic64,amdfam10"
 272   (const (symbol_ref "ix86_tune")))
 273
 274 ;; A basic instruction type.  Refinements due to arguments to be
 275 ;; provided in other attributes.
 276 (define_attr "type"
 277   "other,multi,
 278    alu,alu1,negnot,imov,imovx,lea,
 279    incdec,ishift,ishift1,rotate,rotate1,imul,idiv,
 280    icmp,test,ibr,setcc,icmov,
 281    push,pop,call,callv,leave,
 282    str,bitmanip,
 283    fmov,fop,fsgn,fmul,fdiv,fpspc,fcmov,fcmp,fxch,fistp,fisttp,frndint,
 284    sselog,sselog1,sseiadd,sseiadd1,sseishft,sseimul,
 285    sse,ssemov,sseadd,ssemul,ssecmp,ssecomi,ssecvt,ssecvt1,sseicvt,ssediv,sseins,
 286    ssemuladd,sse4arg,
 287    mmx,mmxmov,mmxadd,mmxmul,mmxcmp,mmxcvt,mmxshft"
 288   (const_string "other"))
 289
 290 ;; Main data type used by the insn
 291 (define_attr "mode"
 292   "unknown,none,QI,HI,SI,DI,SF,DF,XF,TI,V4SF,V2DF,V2SF,V1DF"
 293   (const_string "unknown"))
 294
 295 ;; The CPU unit operations uses.
 296 (define_attr "unit" "integer,i387,sse,mmx,unknown"
 297   (cond [(eq_attr "type" "fmov,fop,fsgn,fmul,fdiv,fpspc,fcmov,fcmp,fxch,fistp,fisttp,frndint")
 298            (const_string "i387")
 299          (eq_attr "type" "sselog,sselog1,sseiadd,sseiadd1,sseishft,sseimul,
 300                           sse,ssemov,sseadd,ssemul,ssecmp,ssecomi,ssecvt,
 301                           ssecvt1,sseicvt,ssediv,sseins,ssemuladd,sse4arg")
 302            (const_string "sse")
 303          (eq_attr "type" "mmx,mmxmov,mmxadd,mmxmul,mmxcmp,mmxcvt,mmxshft")
 304            (const_string "mmx")
 305          (eq_attr "type" "other")
 306            (const_string "unknown")]
 307          (const_string "integer")))
 308
 309 ;; The (bounding maximum) length of an instruction immediate.
 310 (define_attr "length_immediate" ""
 311   (cond [(eq_attr "type" "incdec,setcc,icmov,str,lea,other,multi,idiv,leave,
 312                           bitmanip")
 313            (const_int 0)
 314          (eq_attr "unit" "i387,sse,mmx")
 315            (const_int 0)
 316          (eq_attr "type" "alu,alu1,negnot,imovx,ishift,rotate,ishift1,rotate1,
 317                           imul,icmp,push,pop")
 318            (symbol_ref "ix86_attr_length_immediate_default(insn,1)")
 319          (eq_attr "type" "imov,test")
 320            (symbol_ref "ix86_attr_length_immediate_default(insn,0)")
 321          (eq_attr "type" "call")
 322            (if_then_else (match_operand 0 "constant_call_address_operand" "")
 323              (const_int 4)
 324              (const_int 0))
 325          (eq_attr "type" "callv")
 326            (if_then_else (match_operand 1 "constant_call_address_operand" "")
 327              (const_int 4)
 328              (const_int 0))
 329          ;; We don't know the size before shorten_branches.  Expect
 330          ;; the instruction to fit for better scheduling.
 331          (eq_attr "type" "ibr")
 332            (const_int 1)
 333          ]
 334          (symbol_ref "/* Update immediate_length and other attributes! */
 335                       gcc_unreachable (),1")))
 336
 337 ;; The (bounding maximum) length of an instruction address.
 338 (define_attr "length_address" ""
 339   (cond [(eq_attr "type" "str,other,multi,fxch")
 340            (const_int 0)
 341          (and (eq_attr "type" "call")
 342               (match_operand 0 "constant_call_address_operand" ""))
 343              (const_int 0)
 344          (and (eq_attr "type" "callv")
 345               (match_operand 1 "constant_call_address_operand" ""))
 346              (const_int 0)
 347          ]
 348          (symbol_ref "ix86_attr_length_address_default (insn)")))
 349
 350 ;; Set when length prefix is used.
 351 (define_attr "prefix_data16" ""
 352   (if_then_else (ior (eq_attr "mode" "HI")
 353                      (and (eq_attr "unit" "sse") (eq_attr "mode" "V2DF")))
 354     (const_int 1)
 355     (const_int 0)))
 356
 357 ;; Set when string REP prefix is used.
 358 (define_attr "prefix_rep" ""
 359   (if_then_else (and (eq_attr "unit" "sse") (eq_attr "mode" "SF,DF"))
 360     (const_int 1)
 361     (const_int 0)))
 362
 363 ;; Set when 0f opcode prefix is used.
 364 (define_attr "prefix_0f" ""
 365   (if_then_else
 366     (ior (eq_attr "type" "imovx,setcc,icmov,bitmanip")
 367          (eq_attr "unit" "sse,mmx"))
 368     (const_int 1)
 369     (const_int 0)))
 370
 371 ;; Set when REX opcode prefix is used.
 372 (define_attr "prefix_rex" ""
 373   (cond [(and (eq_attr "mode" "DI")
 374               (eq_attr "type" "!push,pop,call,callv,leave,ibr"))
 375            (const_int 1)
 376          (and (eq_attr "mode" "QI")
 377               (ne (symbol_ref "x86_extended_QIreg_mentioned_p (insn)")
 378                   (const_int 0)))
 379            (const_int 1)
 380          (ne (symbol_ref "x86_extended_reg_mentioned_p (insn)")
 381              (const_int 0))
 382            (const_int 1)
 383         ]
 384         (const_int 0)))
 385
 386 ;; There are also additional prefixes in SSSE3.
 387 (define_attr "prefix_extra" "" (const_int 0))
 388
 389 ;; Set when modrm byte is used.
 390 (define_attr "modrm" ""
 391   (cond [(eq_attr "type" "str,leave")
 392            (const_int 0)
 393          (eq_attr "unit" "i387")
 394            (const_int 0)
 395          (and (eq_attr "type" "incdec")
 396               (ior (match_operand:SI 1 "register_operand" "")
 397                    (match_operand:HI 1 "register_operand" "")))
 398            (const_int 0)
 399          (and (eq_attr "type" "push")
 400               (not (match_operand 1 "memory_operand" "")))
 401            (const_int 0)
 402          (and (eq_attr "type" "pop")
 403               (not (match_operand 0 "memory_operand" "")))
 404            (const_int 0)
 405          (and (eq_attr "type" "imov")
 406               (ior (and (match_operand 0 "register_operand" "")
 407                         (match_operand 1 "immediate_operand" ""))
 408                    (ior (and (match_operand 0 "ax_reg_operand" "")
 409                              (match_operand 1 "memory_displacement_only_operand" ""))
 410                         (and (match_operand 0 "memory_displacement_only_operand" "")
 411                              (match_operand 1 "ax_reg_operand" "")))))
 412            (const_int 0)
 413          (and (eq_attr "type" "call")
 414               (match_operand 0 "constant_call_address_operand" ""))
 415              (const_int 0)
 416          (and (eq_attr "type" "callv")
 417               (match_operand 1 "constant_call_address_operand" ""))
 418              (const_int 0)
 419          ]
 420          (const_int 1)))
 421
 422 ;; The (bounding maximum) length of an instruction in bytes.
 423 ;; ??? fistp and frndint are in fact fldcw/{fistp,frndint}/fldcw sequences.
 424 ;; Later we may want to split them and compute proper length as for
 425 ;; other insns.
 426 (define_attr "length" ""
 427   (cond [(eq_attr "type" "other,multi,fistp,frndint")
 428            (const_int 16)
 429          (eq_attr "type" "fcmp")
 430            (const_int 4)
 431          (eq_attr "unit" "i387")
 432            (plus (const_int 2)
 433                  (plus (attr "prefix_data16")
 434                        (attr "length_address")))]
 435          (plus (plus (attr "modrm")
 436                      (plus (attr "prefix_0f")
 437                            (plus (attr "prefix_rex")
 438                                  (plus (attr "prefix_extra")
 439                                        (const_int 1)))))
 440                (plus (attr "prefix_rep")
 441                      (plus (attr "prefix_data16")
 442                            (plus (attr "length_immediate")
 443                                  (attr "length_address")))))))
 444
 445 ;; The `memory' attribute is `none' if no memory is referenced, `load' or
 446 ;; `store' if there is a simple memory reference therein, or `unknown'
 447 ;; if the instruction is complex.
 448
 449 (define_attr "memory" "none,load,store,both,unknown"
 450   (cond [(eq_attr "type" "other,multi,str")
 451            (const_string "unknown")
 452          (eq_attr "type" "lea,fcmov,fpspc")
 453            (const_string "none")
 454          (eq_attr "type" "fistp,leave")
 455            (const_string "both")
 456          (eq_attr "type" "frndint")
 457            (const_string "load")
 458          (eq_attr "type" "push")
 459            (if_then_else (match_operand 1 "memory_operand" "")
 460              (const_string "both")
 461              (const_string "store"))
 462          (eq_attr "type" "pop")
 463            (if_then_else (match_operand 0 "memory_operand" "")
 464              (const_string "both")
 465              (const_string "load"))
 466          (eq_attr "type" "setcc")
 467            (if_then_else (match_operand 0 "memory_operand" "")
 468              (const_string "store")
 469              (const_string "none"))
 470          (eq_attr "type" "icmp,test,ssecmp,ssecomi,mmxcmp,fcmp")
 471            (if_then_else (ior (match_operand 0 "memory_operand" "")
 472                               (match_operand 1 "memory_operand" ""))
 473              (const_string "load")
 474              (const_string "none"))
 475          (eq_attr "type" "ibr")
 476            (if_then_else (match_operand 0 "memory_operand" "")
 477              (const_string "load")
 478              (const_string "none"))
 479          (eq_attr "type" "call")
 480            (if_then_else (match_operand 0 "constant_call_address_operand" "")
 481              (const_string "none")
 482              (const_string "load"))
 483          (eq_attr "type" "callv")
 484            (if_then_else (match_operand 1 "constant_call_address_operand" "")
 485              (const_string "none")
 486              (const_string "load"))
 487          (and (eq_attr "type" "alu1,negnot,ishift1,sselog1")
 488               (match_operand 1 "memory_operand" ""))
 489            (const_string "both")
 490          (and (match_operand 0 "memory_operand" "")
 491               (match_operand 1 "memory_operand" ""))
 492            (const_string "both")
 493          (match_operand 0 "memory_operand" "")
 494            (const_string "store")
 495          (match_operand 1 "memory_operand" "")
 496            (const_string "load")
 497          (and (eq_attr "type"
 498                  "!alu1,negnot,ishift1,
 499                    imov,imovx,icmp,test,bitmanip,
 500                    fmov,fcmp,fsgn,
 501                    sse,ssemov,ssecmp,ssecomi,ssecvt,ssecvt1,sseicvt,sselog1,
 502                    sseiadd1,mmx,mmxmov,mmxcmp,mmxcvt")
 503               (match_operand 2 "memory_operand" ""))
 504            (const_string "load")
 505          (and (eq_attr "type" "icmov,ssemuladd,sse4arg")
 506               (match_operand 3 "memory_operand" ""))
 507            (const_string "load")
 508         ]
 509         (const_string "none")))
 510
 511 ;; Indicates if an instruction has both an immediate and a displacement.
 512
 513 (define_attr "imm_disp" "false,true,unknown"
 514   (cond [(eq_attr "type" "other,multi")
 515            (const_string "unknown")
 516          (and (eq_attr "type" "icmp,test,imov,alu1,ishift1,rotate1")
 517               (and (match_operand 0 "memory_displacement_operand" "")
 518                    (match_operand 1 "immediate_operand" "")))
 519            (const_string "true")
 520          (and (eq_attr "type" "alu,ishift,rotate,imul,idiv")
 521               (and (match_operand 0 "memory_displacement_operand" "")
 522                    (match_operand 2 "immediate_operand" "")))
 523            (const_string "true")
 524         ]
 525         (const_string "false")))
 526
 527 ;; Indicates if an FP operation has an integer source.
 528
 529 (define_attr "fp_int_src" "false,true"
 530   (const_string "false"))
 531
 532 ;; Defines rounding mode of an FP operation.
 533
 534 (define_attr "i387_cw" "trunc,floor,ceil,mask_pm,uninitialized,any"
 535   (const_string "any"))
 536
 537 ;; Describe a user's asm statement.
 538 (define_asm_attributes
 539   [(set_attr "length" "128")
 540    (set_attr "type" "multi")])
 541
 542 ;; All integer comparison codes.
 543 (define_code_iterator int_cond [ne eq ge gt le lt geu gtu leu ltu ])
 544
 545 ;; All floating-point comparison codes.
 546 (define_code_iterator fp_cond [unordered ordered
 547                                uneq unge ungt unle unlt ltgt ])
 548
 549 (define_code_iterator plusminus [plus minus])
 550
 551 (define_code_iterator sat_plusminus [ss_plus us_plus ss_minus us_minus])
 552
 553 ;; Base name for define_insn
 554 (define_code_attr plusminus_insn
 555   [(plus "add") (ss_plus "ssadd") (us_plus "usadd")
 556    (minus "sub") (ss_minus "sssub") (us_minus "ussub")])
 557
 558 ;; Base name for insn mnemonic.
 559 (define_code_attr plusminus_mnemonic
 560   [(plus "add") (ss_plus "adds") (us_plus "addus")
 561    (minus "sub") (ss_minus "subs") (us_minus "subus")])
 562
 563 ;; Mark commutative operators as such in constraints.
 564 (define_code_attr comm [(plus "%") (ss_plus "%") (us_plus "%")
 565                         (minus "") (ss_minus "") (us_minus "")])
 566
 567 ;; Mapping of signed max and min
 568 (define_code_iterator smaxmin [smax smin])
 569
 570 ;; Mapping of unsigned max and min
 571 (define_code_iterator umaxmin [umax umin])
 572
 573 ;; Base name for integer and FP insn mnemonic
 574 (define_code_attr maxminiprefix [(smax "maxs") (smin "mins")
 575                                  (umax "maxu") (umin "minu")])
 576 (define_code_attr maxminfprefix [(smax "max") (smin "min")])
 577
 578 ;; Mapping of parallel logic operators
 579 (define_code_iterator plogic [and ior xor])
 580
 581 ;; Base name for insn mnemonic.
 582 (define_code_attr plogicprefix [(and "and") (ior "or") (xor "xor")])
 583
 584 ;; Mapping of abs neg operators
 585 (define_code_iterator absneg [abs neg])
 586
 587 ;; Base name for x87 insn mnemonic.
 588 (define_code_attr absnegprefix [(abs "abs") (neg "chs")])
 589
 590 ;; All single word integer modes.
 591 (define_mode_iterator SWI [QI HI SI (DI "TARGET_64BIT")])
 592
 593 ;; Instruction suffix for integer modes.
 594 (define_mode_attr imodesuffix [(QI "b") (HI "w") (SI "l") (DI "q")])
 595
 596 ;; Register class for integer modes.
 597 (define_mode_attr r [(QI "q") (HI "r") (SI "r") (DI "r")])
 598
 599 ;; Immediate operand constraint for integer modes.
 600 (define_mode_attr i [(QI "i") (HI "i") (SI "i") (DI "e")])
 601
 602 ;; General operand predicate for integer modes.
 603 (define_mode_attr general_operand
 604         [(QI "general_operand")
 605          (HI "general_operand")
 606          (SI "general_operand")
 607          (DI "x86_64_general_operand")])
 608
 609 ;; SSE and x87 SFmode and DFmode floating point modes
 610 (define_mode_iterator MODEF [SF DF])
 611
 612 ;; All x87 floating point modes
 613 (define_mode_iterator X87MODEF [SF DF XF])
 614
 615 ;; All integer modes handled by x87 fisttp operator.
 616 (define_mode_iterator X87MODEI [HI SI DI])
 617
 618 ;; All integer modes handled by integer x87 operators.
 619 (define_mode_iterator X87MODEI12 [HI SI])
 620
 621 ;; All integer modes handled by SSE cvtts?2si* operators.
 622 (define_mode_iterator SSEMODEI24 [SI DI])
 623
 624 ;; SSE asm suffix for floating point modes
 625 (define_mode_attr ssemodefsuffix [(SF "s") (DF "d")])
 626
 627 ;; SSE vector mode corresponding to a scalar mode
 628 (define_mode_attr ssevecmode
 629   [(QI "V16QI") (HI "V8HI") (SI "V4SI") (DI "V2DI") (SF "V4SF") (DF "V2DF")])
 630
 631 ;; Instruction suffix for REX 64bit operators.
 632 (define_mode_attr rex64suffix [(SI "") (DI "{q}")])
 633 \f
 634 ;; Scheduling descriptions
 635
 636 (include "pentium.md")
 637 (include "ppro.md")
 638 (include "k6.md")
 639 (include "athlon.md")
 640 (include "geode.md")
 641
 642 \f
 643 ;; Operand and operator predicates and constraints
 644
 645 (include "predicates.md")
 646 (include "constraints.md")
 647
 648 \f
 649 ;; Compare instructions.
 650
 651 ;; All compare insns have expanders that save the operands away without
 652 ;; actually generating RTL.  The bCOND or sCOND (emitted immediately
 653 ;; after the cmp) will actually emit the cmpM.
 654
 655 (define_expand "cmpti"
 656   [(set (reg:CC FLAGS_REG)
 657         (compare:CC (match_operand:TI 0 "nonimmediate_operand" "")
 658                     (match_operand:TI 1 "x86_64_general_operand" "")))]
 659   "TARGET_64BIT"
 660 {
 661   if (MEM_P (operands[0]) && MEM_P (operands[1]))
 662     operands[0] = force_reg (TImode, operands[0]);
 663   ix86_compare_op0 = operands[0];
 664   ix86_compare_op1 = operands[1];
 665   DONE;
 666 })
 667
 668 (define_expand "cmpdi"
 669   [(set (reg:CC FLAGS_REG)
 670         (compare:CC (match_operand:DI 0 "nonimmediate_operand" "")
 671                     (match_operand:DI 1 "x86_64_general_operand" "")))]
 672   ""
 673 {
 674   if (MEM_P (operands[0]) && MEM_P (operands[1]))
 675     operands[0] = force_reg (DImode, operands[0]);
 676   ix86_compare_op0 = operands[0];
 677   ix86_compare_op1 = operands[1];
 678   DONE;
 679 })
 680
 681 (define_expand "cmpsi"
 682   [(set (reg:CC FLAGS_REG)
 683         (compare:CC (match_operand:SI 0 "cmpsi_operand" "")
 684                     (match_operand:SI 1 "general_operand" "")))]
 685   ""
 686 {
 687   if (MEM_P (operands[0]) && MEM_P (operands[1]))
 688     operands[0] = force_reg (SImode, operands[0]);
 689   ix86_compare_op0 = operands[0];
 690   ix86_compare_op1 = operands[1];
 691   DONE;
 692 })
 693
 694 (define_expand "cmphi"
 695   [(set (reg:CC FLAGS_REG)
 696         (compare:CC (match_operand:HI 0 "nonimmediate_operand" "")
 697                     (match_operand:HI 1 "general_operand" "")))]
 698   ""
 699 {
 700   if (MEM_P (operands[0]) && MEM_P (operands[1]))
 701     operands[0] = force_reg (HImode, operands[0]);
 702   ix86_compare_op0 = operands[0];
 703   ix86_compare_op1 = operands[1];
 704   DONE;
 705 })
 706
 707 (define_expand "cmpqi"
 708   [(set (reg:CC FLAGS_REG)
 709         (compare:CC (match_operand:QI 0 "nonimmediate_operand" "")
 710                     (match_operand:QI 1 "general_operand" "")))]
 711   "TARGET_QIMODE_MATH"
 712 {
 713   if (MEM_P (operands[0]) && MEM_P (operands[1]))
 714     operands[0] = force_reg (QImode, operands[0]);
 715   ix86_compare_op0 = operands[0];
 716   ix86_compare_op1 = operands[1];
 717   DONE;
 718 })
 719
 720 (define_insn "cmpdi_ccno_1_rex64"
 721   [(set (reg FLAGS_REG)
 722         (compare (match_operand:DI 0 "nonimmediate_operand" "r,?mr")
 723                  (match_operand:DI 1 "const0_operand" "n,n")))]
 724   "TARGET_64BIT && ix86_match_ccmode (insn, CCNOmode)"
 725   "@
 726    test{q}\t%0, %0
 727    cmp{q}\t{%1, %0|%0, %1}"
 728   [(set_attr "type" "test,icmp")
 729    (set_attr "length_immediate" "0,1")
 730    (set_attr "mode" "DI")])
 731
 732 (define_insn "*cmpdi_minus_1_rex64"
 733   [(set (reg FLAGS_REG)
 734         (compare (minus:DI (match_operand:DI 0 "nonimmediate_operand" "rm,r")
 735                            (match_operand:DI 1 "x86_64_general_operand" "re,mr"))
 736                  (const_int 0)))]
 737   "TARGET_64BIT && ix86_match_ccmode (insn, CCGOCmode)"
 738   "cmp{q}\t{%1, %0|%0, %1}"
 739   [(set_attr "type" "icmp")
 740    (set_attr "mode" "DI")])
 741
 742 (define_expand "cmpdi_1_rex64"
 743   [(set (reg:CC FLAGS_REG)
 744         (compare:CC (match_operand:DI 0 "nonimmediate_operand" "")
 745                     (match_operand:DI 1 "general_operand" "")))]
 746   "TARGET_64BIT"
 747   "")
 748
 749 (define_insn "cmpdi_1_insn_rex64"
 750   [(set (reg FLAGS_REG)
 751         (compare (match_operand:DI 0 "nonimmediate_operand" "mr,r")
 752                  (match_operand:DI 1 "x86_64_general_operand" "re,mr")))]
 753   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
 754   "cmp{q}\t{%1, %0|%0, %1}"
 755   [(set_attr "type" "icmp")
 756    (set_attr "mode" "DI")])
 757
 758
 759 (define_insn "*cmpsi_ccno_1"
 760   [(set (reg FLAGS_REG)
 761         (compare (match_operand:SI 0 "nonimmediate_operand" "r,?mr")
 762                  (match_operand:SI 1 "const0_operand" "n,n")))]
 763   "ix86_match_ccmode (insn, CCNOmode)"
 764   "@
 765    test{l}\t%0, %0
 766    cmp{l}\t{%1, %0|%0, %1}"
 767   [(set_attr "type" "test,icmp")
 768    (set_attr "length_immediate" "0,1")
 769    (set_attr "mode" "SI")])
 770
 771 (define_insn "*cmpsi_minus_1"
 772   [(set (reg FLAGS_REG)
 773         (compare (minus:SI (match_operand:SI 0 "nonimmediate_operand" "rm,r")
 774                            (match_operand:SI 1 "general_operand" "ri,mr"))
 775                  (const_int 0)))]
 776   "ix86_match_ccmode (insn, CCGOCmode)"
 777   "cmp{l}\t{%1, %0|%0, %1}"
 778   [(set_attr "type" "icmp")
 779    (set_attr "mode" "SI")])
 780
 781 (define_expand "cmpsi_1"
 782   [(set (reg:CC FLAGS_REG)
 783         (compare:CC (match_operand:SI 0 "nonimmediate_operand" "")
 784                     (match_operand:SI 1 "general_operand" "")))]
 785   ""
 786   "")
 787
 788 (define_insn "*cmpsi_1_insn"
 789   [(set (reg FLAGS_REG)
 790         (compare (match_operand:SI 0 "nonimmediate_operand" "rm,r")
 791                  (match_operand:SI 1 "general_operand" "ri,mr")))]
 792   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
 793     && ix86_match_ccmode (insn, CCmode)"
 794   "cmp{l}\t{%1, %0|%0, %1}"
 795   [(set_attr "type" "icmp")
 796    (set_attr "mode" "SI")])
 797
 798 (define_insn "*cmphi_ccno_1"
 799   [(set (reg FLAGS_REG)
 800         (compare (match_operand:HI 0 "nonimmediate_operand" "r,?mr")
 801                  (match_operand:HI 1 "const0_operand" "n,n")))]
 802   "ix86_match_ccmode (insn, CCNOmode)"
 803   "@
 804    test{w}\t%0, %0
 805    cmp{w}\t{%1, %0|%0, %1}"
 806   [(set_attr "type" "test,icmp")
 807    (set_attr "length_immediate" "0,1")
 808    (set_attr "mode" "HI")])
 809
 810 (define_insn "*cmphi_minus_1"
 811   [(set (reg FLAGS_REG)
 812         (compare (minus:HI (match_operand:HI 0 "nonimmediate_operand" "rm,r")
 813                            (match_operand:HI 1 "general_operand" "ri,mr"))
 814                  (const_int 0)))]
 815   "ix86_match_ccmode (insn, CCGOCmode)"
 816   "cmp{w}\t{%1, %0|%0, %1}"
 817   [(set_attr "type" "icmp")
 818    (set_attr "mode" "HI")])
 819
 820 (define_insn "*cmphi_1"
 821   [(set (reg FLAGS_REG)
 822         (compare (match_operand:HI 0 "nonimmediate_operand" "rm,r")
 823                  (match_operand:HI 1 "general_operand" "ri,mr")))]
 824   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
 825    && ix86_match_ccmode (insn, CCmode)"
 826   "cmp{w}\t{%1, %0|%0, %1}"
 827   [(set_attr "type" "icmp")
 828    (set_attr "mode" "HI")])
 829
 830 (define_insn "*cmpqi_ccno_1"
 831   [(set (reg FLAGS_REG)
 832         (compare (match_operand:QI 0 "nonimmediate_operand" "q,?mq")
 833                  (match_operand:QI 1 "const0_operand" "n,n")))]
 834   "ix86_match_ccmode (insn, CCNOmode)"
 835   "@
 836    test{b}\t%0, %0
 837    cmp{b}\t{$0, %0|%0, 0}"
 838   [(set_attr "type" "test,icmp")
 839    (set_attr "length_immediate" "0,1")
 840    (set_attr "mode" "QI")])
 841
 842 (define_insn "*cmpqi_1"
 843   [(set (reg FLAGS_REG)
 844         (compare (match_operand:QI 0 "nonimmediate_operand" "qm,q")
 845                  (match_operand:QI 1 "general_operand" "qi,mq")))]
 846   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
 847     && ix86_match_ccmode (insn, CCmode)"
 848   "cmp{b}\t{%1, %0|%0, %1}"
 849   [(set_attr "type" "icmp")
 850    (set_attr "mode" "QI")])
 851
 852 (define_insn "*cmpqi_minus_1"
 853   [(set (reg FLAGS_REG)
 854         (compare (minus:QI (match_operand:QI 0 "nonimmediate_operand" "qm,q")
 855                            (match_operand:QI 1 "general_operand" "qi,mq"))
 856                  (const_int 0)))]
 857   "ix86_match_ccmode (insn, CCGOCmode)"
 858   "cmp{b}\t{%1, %0|%0, %1}"
 859   [(set_attr "type" "icmp")
 860    (set_attr "mode" "QI")])
 861
 862 (define_insn "*cmpqi_ext_1"
 863   [(set (reg FLAGS_REG)
 864         (compare
 865           (match_operand:QI 0 "general_operand" "Qm")
 866           (subreg:QI
 867             (zero_extract:SI
 868               (match_operand 1 "ext_register_operand" "Q")
 869               (const_int 8)
 870               (const_int 8)) 0)))]
 871   "!TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
 872   "cmp{b}\t{%h1, %0|%0, %h1}"
 873   [(set_attr "type" "icmp")
 874    (set_attr "mode" "QI")])
 875
 876 (define_insn "*cmpqi_ext_1_rex64"
 877   [(set (reg FLAGS_REG)
 878         (compare
 879           (match_operand:QI 0 "register_operand" "Q")
 880           (subreg:QI
 881             (zero_extract:SI
 882               (match_operand 1 "ext_register_operand" "Q")
 883               (const_int 8)
 884               (const_int 8)) 0)))]
 885   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
 886   "cmp{b}\t{%h1, %0|%0, %h1}"
 887   [(set_attr "type" "icmp")
 888    (set_attr "mode" "QI")])
 889
 890 (define_insn "*cmpqi_ext_2"
 891   [(set (reg FLAGS_REG)
 892         (compare
 893           (subreg:QI
 894             (zero_extract:SI
 895               (match_operand 0 "ext_register_operand" "Q")
 896               (const_int 8)
 897               (const_int 8)) 0)
 898           (match_operand:QI 1 "const0_operand" "n")))]
 899   "ix86_match_ccmode (insn, CCNOmode)"
 900   "test{b}\t%h0, %h0"
 901   [(set_attr "type" "test")
 902    (set_attr "length_immediate" "0")
 903    (set_attr "mode" "QI")])
 904
 905 (define_expand "cmpqi_ext_3"
 906   [(set (reg:CC FLAGS_REG)
 907         (compare:CC
 908           (subreg:QI
 909             (zero_extract:SI
 910               (match_operand 0 "ext_register_operand" "")
 911               (const_int 8)
 912               (const_int 8)) 0)
 913           (match_operand:QI 1 "general_operand" "")))]
 914   ""
 915   "")
 916
 917 (define_insn "cmpqi_ext_3_insn"
 918   [(set (reg FLAGS_REG)
 919         (compare
 920           (subreg:QI
 921             (zero_extract:SI
 922               (match_operand 0 "ext_register_operand" "Q")
 923               (const_int 8)
 924               (const_int 8)) 0)
 925           (match_operand:QI 1 "general_operand" "Qmn")))]
 926   "!TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
 927   "cmp{b}\t{%1, %h0|%h0, %1}"
 928   [(set_attr "type" "icmp")
 929    (set_attr "mode" "QI")])
 930
 931 (define_insn "cmpqi_ext_3_insn_rex64"
 932   [(set (reg FLAGS_REG)
 933         (compare
 934           (subreg:QI
 935             (zero_extract:SI
 936               (match_operand 0 "ext_register_operand" "Q")
 937               (const_int 8)
 938               (const_int 8)) 0)
 939           (match_operand:QI 1 "nonmemory_operand" "Qn")))]
 940   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
 941   "cmp{b}\t{%1, %h0|%h0, %1}"
 942   [(set_attr "type" "icmp")
 943    (set_attr "mode" "QI")])
 944
 945 (define_insn "*cmpqi_ext_4"
 946   [(set (reg FLAGS_REG)
 947         (compare
 948           (subreg:QI
 949             (zero_extract:SI
 950               (match_operand 0 "ext_register_operand" "Q")
 951               (const_int 8)
 952               (const_int 8)) 0)
 953           (subreg:QI
 954             (zero_extract:SI
 955               (match_operand 1 "ext_register_operand" "Q")
 956               (const_int 8)
 957               (const_int 8)) 0)))]
 958   "ix86_match_ccmode (insn, CCmode)"
 959   "cmp{b}\t{%h1, %h0|%h0, %h1}"
 960   [(set_attr "type" "icmp")
 961    (set_attr "mode" "QI")])
 962
 963 ;; These implement float point compares.
 964 ;; %%% See if we can get away with VOIDmode operands on the actual insns,
 965 ;; which would allow mix and match FP modes on the compares.  Which is what
 966 ;; the old patterns did, but with many more of them.
 967
 968 (define_expand "cmpxf"
 969   [(set (reg:CC FLAGS_REG)
 970         (compare:CC (match_operand:XF 0 "nonmemory_operand" "")
 971                     (match_operand:XF 1 "nonmemory_operand" "")))]
 972   "TARGET_80387"
 973 {
 974   ix86_compare_op0 = operands[0];
 975   ix86_compare_op1 = operands[1];
 976   DONE;
 977 })
 978
 979 (define_expand "cmp<mode>"
 980   [(set (reg:CC FLAGS_REG)
 981         (compare:CC (match_operand:MODEF 0 "cmp_fp_expander_operand" "")
 982                     (match_operand:MODEF 1 "cmp_fp_expander_operand" "")))]
 983   "TARGET_80387 || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH)"
 984 {
 985   ix86_compare_op0 = operands[0];
 986   ix86_compare_op1 = operands[1];
 987   DONE;
 988 })
 989
 990 ;; FP compares, step 1:
 991 ;; Set the FP condition codes.
 992 ;;
 993 ;; CCFPmode     compare with exceptions
 994 ;; CCFPUmode    compare with no exceptions
 995
 996 ;; We may not use "#" to split and emit these, since the REG_DEAD notes
 997 ;; used to manage the reg stack popping would not be preserved.
 998
 999 (define_insn "*cmpfp_0"
1000   [(set (match_operand:HI 0 "register_operand" "=a")
1001         (unspec:HI
1002           [(compare:CCFP
1003              (match_operand 1 "register_operand" "f")
1004              (match_operand 2 "const0_operand" "X"))]
1005         UNSPEC_FNSTSW))]
1006   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1007    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1008   "* return output_fp_compare (insn, operands, 0, 0);"
1009   [(set_attr "type" "multi")
1010    (set_attr "unit" "i387")
1011    (set (attr "mode")
1012      (cond [(match_operand:SF 1 "" "")
1013               (const_string "SF")
1014             (match_operand:DF 1 "" "")
1015               (const_string "DF")
1016            ]
1017            (const_string "XF")))])
1018
1019 (define_insn_and_split "*cmpfp_0_cc"
1020   [(set (reg:CCFP FLAGS_REG)
1021         (compare:CCFP
1022           (match_operand 1 "register_operand" "f")
1023           (match_operand 2 "const0_operand" "X")))
1024    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1025   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1026    && TARGET_SAHF && !TARGET_CMOVE
1027    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1028   "#"
1029   "&& reload_completed"
1030   [(set (match_dup 0)
1031         (unspec:HI
1032           [(compare:CCFP (match_dup 1)(match_dup 2))]
1033         UNSPEC_FNSTSW))
1034    (set (reg:CC FLAGS_REG)
1035         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1036   ""
1037   [(set_attr "type" "multi")
1038    (set_attr "unit" "i387")
1039    (set (attr "mode")
1040      (cond [(match_operand:SF 1 "" "")
1041               (const_string "SF")
1042             (match_operand:DF 1 "" "")
1043               (const_string "DF")
1044            ]
1045            (const_string "XF")))])
1046
1047 (define_insn "*cmpfp_xf"
1048   [(set (match_operand:HI 0 "register_operand" "=a")
1049         (unspec:HI
1050           [(compare:CCFP
1051              (match_operand:XF 1 "register_operand" "f")
1052              (match_operand:XF 2 "register_operand" "f"))]
1053           UNSPEC_FNSTSW))]
1054   "TARGET_80387"
1055   "* return output_fp_compare (insn, operands, 0, 0);"
1056   [(set_attr "type" "multi")
1057    (set_attr "unit" "i387")
1058    (set_attr "mode" "XF")])
1059
1060 (define_insn_and_split "*cmpfp_xf_cc"
1061   [(set (reg:CCFP FLAGS_REG)
1062         (compare:CCFP
1063           (match_operand:XF 1 "register_operand" "f")
1064           (match_operand:XF 2 "register_operand" "f")))
1065    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1066   "TARGET_80387
1067    && TARGET_SAHF && !TARGET_CMOVE"
1068   "#"
1069   "&& reload_completed"
1070   [(set (match_dup 0)
1071         (unspec:HI
1072           [(compare:CCFP (match_dup 1)(match_dup 2))]
1073         UNSPEC_FNSTSW))
1074    (set (reg:CC FLAGS_REG)
1075         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1076   ""
1077   [(set_attr "type" "multi")
1078    (set_attr "unit" "i387")
1079    (set_attr "mode" "XF")])
1080
1081 (define_insn "*cmpfp_<mode>"
1082   [(set (match_operand:HI 0 "register_operand" "=a")
1083         (unspec:HI
1084           [(compare:CCFP
1085              (match_operand:MODEF 1 "register_operand" "f")
1086              (match_operand:MODEF 2 "nonimmediate_operand" "fm"))]
1087           UNSPEC_FNSTSW))]
1088   "TARGET_80387"
1089   "* return output_fp_compare (insn, operands, 0, 0);"
1090   [(set_attr "type" "multi")
1091    (set_attr "unit" "i387")
1092    (set_attr "mode" "<MODE>")])
1093
1094 (define_insn_and_split "*cmpfp_<mode>_cc"
1095   [(set (reg:CCFP FLAGS_REG)
1096         (compare:CCFP
1097           (match_operand:MODEF 1 "register_operand" "f")
1098           (match_operand:MODEF 2 "nonimmediate_operand" "fm")))
1099    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1100   "TARGET_80387
1101    && TARGET_SAHF && !TARGET_CMOVE"
1102   "#"
1103   "&& reload_completed"
1104   [(set (match_dup 0)
1105         (unspec:HI
1106           [(compare:CCFP (match_dup 1)(match_dup 2))]
1107         UNSPEC_FNSTSW))
1108    (set (reg:CC FLAGS_REG)
1109         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1110   ""
1111   [(set_attr "type" "multi")
1112    (set_attr "unit" "i387")
1113    (set_attr "mode" "<MODE>")])
1114
1115 (define_insn "*cmpfp_u"
1116   [(set (match_operand:HI 0 "register_operand" "=a")
1117         (unspec:HI
1118           [(compare:CCFPU
1119              (match_operand 1 "register_operand" "f")
1120              (match_operand 2 "register_operand" "f"))]
1121           UNSPEC_FNSTSW))]
1122   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1123    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1124   "* return output_fp_compare (insn, operands, 0, 1);"
1125   [(set_attr "type" "multi")
1126    (set_attr "unit" "i387")
1127    (set (attr "mode")
1128      (cond [(match_operand:SF 1 "" "")
1129               (const_string "SF")
1130             (match_operand:DF 1 "" "")
1131               (const_string "DF")
1132            ]
1133            (const_string "XF")))])
1134
1135 (define_insn_and_split "*cmpfp_u_cc"
1136   [(set (reg:CCFPU FLAGS_REG)
1137         (compare:CCFPU
1138           (match_operand 1 "register_operand" "f")
1139           (match_operand 2 "register_operand" "f")))
1140    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1141   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1142    && TARGET_SAHF && !TARGET_CMOVE
1143    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1144   "#"
1145   "&& reload_completed"
1146   [(set (match_dup 0)
1147         (unspec:HI
1148           [(compare:CCFPU (match_dup 1)(match_dup 2))]
1149         UNSPEC_FNSTSW))
1150    (set (reg:CC FLAGS_REG)
1151         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1152   ""
1153   [(set_attr "type" "multi")
1154    (set_attr "unit" "i387")
1155    (set (attr "mode")
1156      (cond [(match_operand:SF 1 "" "")
1157               (const_string "SF")
1158             (match_operand:DF 1 "" "")
1159               (const_string "DF")
1160            ]
1161            (const_string "XF")))])
1162
1163 (define_insn "*cmpfp_<mode>"
1164   [(set (match_operand:HI 0 "register_operand" "=a")
1165         (unspec:HI
1166           [(compare:CCFP
1167              (match_operand 1 "register_operand" "f")
1168              (match_operator 3 "float_operator"
1169                [(match_operand:X87MODEI12 2 "memory_operand" "m")]))]
1170           UNSPEC_FNSTSW))]
1171   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1172    && TARGET_USE_<MODE>MODE_FIOP
1173    && (GET_MODE (operands [3]) == GET_MODE (operands[1]))"
1174   "* return output_fp_compare (insn, operands, 0, 0);"
1175   [(set_attr "type" "multi")
1176    (set_attr "unit" "i387")
1177    (set_attr "fp_int_src" "true")
1178    (set_attr "mode" "<MODE>")])
1179
1180 (define_insn_and_split "*cmpfp_<mode>_cc"
1181   [(set (reg:CCFP FLAGS_REG)
1182         (compare:CCFP
1183           (match_operand 1 "register_operand" "f")
1184           (match_operator 3 "float_operator"
1185             [(match_operand:X87MODEI12 2 "memory_operand" "m")])))
1186    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1187   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1188    && TARGET_SAHF && !TARGET_CMOVE
1189    && TARGET_USE_<MODE>MODE_FIOP
1190    && (GET_MODE (operands [3]) == GET_MODE (operands[1]))"
1191   "#"
1192   "&& reload_completed"
1193   [(set (match_dup 0)
1194         (unspec:HI
1195           [(compare:CCFP
1196              (match_dup 1)
1197              (match_op_dup 3 [(match_dup 2)]))]
1198         UNSPEC_FNSTSW))
1199    (set (reg:CC FLAGS_REG)
1200         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1201   ""
1202   [(set_attr "type" "multi")
1203    (set_attr "unit" "i387")
1204    (set_attr "fp_int_src" "true")
1205    (set_attr "mode" "<MODE>")])
1206
1207 ;; FP compares, step 2
1208 ;; Move the fpsw to ax.
1209
1210 (define_insn "x86_fnstsw_1"
1211   [(set (match_operand:HI 0 "register_operand" "=a")
1212         (unspec:HI [(reg:CCFP FPSR_REG)] UNSPEC_FNSTSW))]
1213   "TARGET_80387"
1214   "fnstsw\t%0"
1215   [(set_attr "length" "2")
1216    (set_attr "mode" "SI")
1217    (set_attr "unit" "i387")])
1218
1219 ;; FP compares, step 3
1220 ;; Get ax into flags, general case.
1221
1222 (define_insn "x86_sahf_1"
1223   [(set (reg:CC FLAGS_REG)
1224         (unspec:CC [(match_operand:HI 0 "register_operand" "a")]
1225                    UNSPEC_SAHF))]
1226   "TARGET_SAHF"
1227 {
1228 #ifdef HAVE_AS_IX86_SAHF
1229   return "sahf";
1230 #else
1231   return ".byte\t0x9e";
1232 #endif
1233 }
1234   [(set_attr "length" "1")
1235    (set_attr "athlon_decode" "vector")
1236    (set_attr "amdfam10_decode" "direct")
1237    (set_attr "mode" "SI")])
1238
1239 ;; Pentium Pro can do steps 1 through 3 in one go.
1240 ;; comi*, ucomi*, fcomi*, ficomi*,fucomi* (i387 instructions set condition codes)
1241 (define_insn "*cmpfp_i_mixed"
1242   [(set (reg:CCFP FLAGS_REG)
1243         (compare:CCFP (match_operand 0 "register_operand" "f,x")
1244                       (match_operand 1 "nonimmediate_operand" "f,xm")))]
1245   "TARGET_MIX_SSE_I387
1246    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1247    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1248   "* return output_fp_compare (insn, operands, 1, 0);"
1249   [(set_attr "type" "fcmp,ssecomi")
1250    (set (attr "mode")
1251      (if_then_else (match_operand:SF 1 "" "")
1252         (const_string "SF")
1253         (const_string "DF")))
1254    (set_attr "athlon_decode" "vector")
1255    (set_attr "amdfam10_decode" "direct")])
1256
1257 (define_insn "*cmpfp_i_sse"
1258   [(set (reg:CCFP FLAGS_REG)
1259         (compare:CCFP (match_operand 0 "register_operand" "x")
1260                       (match_operand 1 "nonimmediate_operand" "xm")))]
1261   "TARGET_SSE_MATH
1262    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1263    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1264   "* return output_fp_compare (insn, operands, 1, 0);"
1265   [(set_attr "type" "ssecomi")
1266    (set (attr "mode")
1267      (if_then_else (match_operand:SF 1 "" "")
1268         (const_string "SF")
1269         (const_string "DF")))
1270    (set_attr "athlon_decode" "vector")
1271    (set_attr "amdfam10_decode" "direct")])
1272
1273 (define_insn "*cmpfp_i_i387"
1274   [(set (reg:CCFP FLAGS_REG)
1275         (compare:CCFP (match_operand 0 "register_operand" "f")
1276                       (match_operand 1 "register_operand" "f")))]
1277   "X87_FLOAT_MODE_P (GET_MODE (operands[0]))
1278    && TARGET_CMOVE
1279    && !(SSE_FLOAT_MODE_P (GET_MODE (operands[0])) && TARGET_SSE_MATH)
1280    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1281   "* return output_fp_compare (insn, operands, 1, 0);"
1282   [(set_attr "type" "fcmp")
1283    (set (attr "mode")
1284      (cond [(match_operand:SF 1 "" "")
1285               (const_string "SF")
1286             (match_operand:DF 1 "" "")
1287               (const_string "DF")
1288            ]
1289            (const_string "XF")))
1290    (set_attr "athlon_decode" "vector")
1291    (set_attr "amdfam10_decode" "direct")])
1292
1293 (define_insn "*cmpfp_iu_mixed"
1294   [(set (reg:CCFPU FLAGS_REG)
1295         (compare:CCFPU (match_operand 0 "register_operand" "f,x")
1296                        (match_operand 1 "nonimmediate_operand" "f,xm")))]
1297   "TARGET_MIX_SSE_I387
1298    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1299    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1300   "* return output_fp_compare (insn, operands, 1, 1);"
1301   [(set_attr "type" "fcmp,ssecomi")
1302    (set (attr "mode")
1303      (if_then_else (match_operand:SF 1 "" "")
1304         (const_string "SF")
1305         (const_string "DF")))
1306    (set_attr "athlon_decode" "vector")
1307    (set_attr "amdfam10_decode" "direct")])
1308
1309 (define_insn "*cmpfp_iu_sse"
1310   [(set (reg:CCFPU FLAGS_REG)
1311         (compare:CCFPU (match_operand 0 "register_operand" "x")
1312                        (match_operand 1 "nonimmediate_operand" "xm")))]
1313   "TARGET_SSE_MATH
1314    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1315    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1316   "* return output_fp_compare (insn, operands, 1, 1);"
1317   [(set_attr "type" "ssecomi")
1318    (set (attr "mode")
1319      (if_then_else (match_operand:SF 1 "" "")
1320         (const_string "SF")
1321         (const_string "DF")))
1322    (set_attr "athlon_decode" "vector")
1323    (set_attr "amdfam10_decode" "direct")])
1324
1325 (define_insn "*cmpfp_iu_387"
1326   [(set (reg:CCFPU FLAGS_REG)
1327         (compare:CCFPU (match_operand 0 "register_operand" "f")
1328                        (match_operand 1 "register_operand" "f")))]
1329   "X87_FLOAT_MODE_P (GET_MODE (operands[0]))
1330    && TARGET_CMOVE
1331    && !(SSE_FLOAT_MODE_P (GET_MODE (operands[0])) && TARGET_SSE_MATH)
1332    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1333   "* return output_fp_compare (insn, operands, 1, 1);"
1334   [(set_attr "type" "fcmp")
1335    (set (attr "mode")
1336      (cond [(match_operand:SF 1 "" "")
1337               (const_string "SF")
1338             (match_operand:DF 1 "" "")
1339               (const_string "DF")
1340            ]
1341            (const_string "XF")))
1342    (set_attr "athlon_decode" "vector")
1343    (set_attr "amdfam10_decode" "direct")])
1344 \f
1345 ;; Move instructions.
1346
1347 ;; General case of fullword move.
1348
1349 (define_expand "movsi"
1350   [(set (match_operand:SI 0 "nonimmediate_operand" "")
1351         (match_operand:SI 1 "general_operand" ""))]
1352   ""
1353   "ix86_expand_move (SImode, operands); DONE;")
1354
1355 ;; Push/pop instructions.  They are separate since autoinc/dec is not a
1356 ;; general_operand.
1357 ;;
1358 ;; %%% We don't use a post-inc memory reference because x86 is not a
1359 ;; general AUTO_INC_DEC host, which impacts how it is treated in flow.
1360 ;; Changing this impacts compiler performance on other non-AUTO_INC_DEC
1361 ;; targets without our curiosities, and it is just as easy to represent
1362 ;; this differently.
1363
1364 (define_insn "*pushsi2"
1365   [(set (match_operand:SI 0 "push_operand" "=<")
1366         (match_operand:SI 1 "general_no_elim_operand" "ri*m"))]
1367   "!TARGET_64BIT"
1368   "push{l}\t%1"
1369   [(set_attr "type" "push")
1370    (set_attr "mode" "SI")])
1371
1372 ;; For 64BIT abi we always round up to 8 bytes.
1373 (define_insn "*pushsi2_rex64"
1374   [(set (match_operand:SI 0 "push_operand" "=X")
1375         (match_operand:SI 1 "nonmemory_no_elim_operand" "ri"))]
1376   "TARGET_64BIT"
1377   "push{q}\t%q1"
1378   [(set_attr "type" "push")
1379    (set_attr "mode" "SI")])
1380
1381 (define_insn "*pushsi2_prologue"
1382   [(set (match_operand:SI 0 "push_operand" "=<")
1383         (match_operand:SI 1 "general_no_elim_operand" "ri*m"))
1384    (clobber (mem:BLK (scratch)))]
1385   "!TARGET_64BIT"
1386   "push{l}\t%1"
1387   [(set_attr "type" "push")
1388    (set_attr "mode" "SI")])
1389
1390 (define_insn "*popsi1_epilogue"
1391   [(set (match_operand:SI 0 "nonimmediate_operand" "=r*m")
1392         (mem:SI (reg:SI SP_REG)))
1393    (set (reg:SI SP_REG)
1394         (plus:SI (reg:SI SP_REG) (const_int 4)))
1395    (clobber (mem:BLK (scratch)))]
1396   "!TARGET_64BIT"
1397   "pop{l}\t%0"
1398   [(set_attr "type" "pop")
1399    (set_attr "mode" "SI")])
1400
1401 (define_insn "popsi1"
1402   [(set (match_operand:SI 0 "nonimmediate_operand" "=r*m")
1403         (mem:SI (reg:SI SP_REG)))
1404    (set (reg:SI SP_REG)
1405         (plus:SI (reg:SI SP_REG) (const_int 4)))]
1406   "!TARGET_64BIT"
1407   "pop{l}\t%0"
1408   [(set_attr "type" "pop")
1409    (set_attr "mode" "SI")])
1410
1411 (define_insn "*movsi_xor"
1412   [(set (match_operand:SI 0 "register_operand" "=r")
1413         (match_operand:SI 1 "const0_operand" "i"))
1414    (clobber (reg:CC FLAGS_REG))]
1415   "reload_completed && (!TARGET_USE_MOV0 || optimize_size)"
1416   "xor{l}\t%0, %0"
1417   [(set_attr "type" "alu1")
1418    (set_attr "mode" "SI")
1419    (set_attr "length_immediate" "0")])
1420
1421 (define_insn "*movsi_or"
1422   [(set (match_operand:SI 0 "register_operand" "=r")
1423         (match_operand:SI 1 "immediate_operand" "i"))
1424    (clobber (reg:CC FLAGS_REG))]
1425   "reload_completed
1426    && operands[1] == constm1_rtx
1427    && (TARGET_MOVE_M1_VIA_OR || optimize_size)"
1428 {
1429   operands[1] = constm1_rtx;
1430   return "or{l}\t{%1, %0|%0, %1}";
1431 }
1432   [(set_attr "type" "alu1")
1433    (set_attr "mode" "SI")
1434    (set_attr "length_immediate" "1")])
1435
1436 (define_insn "*movsi_1"
1437   [(set (match_operand:SI 0 "nonimmediate_operand"
1438                         "=r  ,m  ,*y,*y,?rm,?*y,*x,*x,?r ,m ,?*Yi,*x")
1439         (match_operand:SI 1 "general_operand"
1440                         "rinm,rin,C ,*y,*y ,rm ,C ,*x,*Yi,*x,r   ,m "))]
1441   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
1442 {
1443   switch (get_attr_type (insn))
1444     {
1445     case TYPE_SSELOG1:
1446       if (get_attr_mode (insn) == MODE_TI)
1447         return "pxor\t%0, %0";
1448       return "xorps\t%0, %0";
1449
1450     case TYPE_SSEMOV:
1451       switch (get_attr_mode (insn))
1452         {
1453         case MODE_TI:
1454           return "movdqa\t{%1, %0|%0, %1}";
1455         case MODE_V4SF:
1456           return "movaps\t{%1, %0|%0, %1}";
1457         case MODE_SI:
1458           return "movd\t{%1, %0|%0, %1}";
1459         case MODE_SF:
1460           return "movss\t{%1, %0|%0, %1}";
1461         default:
1462           gcc_unreachable ();
1463         }
1464
1465     case TYPE_MMXADD:
1466       return "pxor\t%0, %0";
1467
1468     case TYPE_MMXMOV:
1469       if (get_attr_mode (insn) == MODE_DI)
1470         return "movq\t{%1, %0|%0, %1}";
1471       return "movd\t{%1, %0|%0, %1}";
1472
1473     case TYPE_LEA:
1474       return "lea{l}\t{%1, %0|%0, %1}";
1475
1476     default:
1477       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
1478       return "mov{l}\t{%1, %0|%0, %1}";
1479     }
1480 }
1481   [(set (attr "type")
1482      (cond [(eq_attr "alternative" "2")
1483               (const_string "mmxadd")
1484             (eq_attr "alternative" "3,4,5")
1485               (const_string "mmxmov")
1486             (eq_attr "alternative" "6")
1487               (const_string "sselog1")
1488             (eq_attr "alternative" "7,8,9,10,11")
1489               (const_string "ssemov")
1490             (match_operand:DI 1 "pic_32bit_operand" "")
1491               (const_string "lea")
1492            ]
1493            (const_string "imov")))
1494    (set (attr "mode")
1495      (cond [(eq_attr "alternative" "2,3")
1496               (const_string "DI")
1497             (eq_attr "alternative" "6,7")
1498               (if_then_else
1499                 (eq (symbol_ref "TARGET_SSE2") (const_int 0))
1500                 (const_string "V4SF")
1501                 (const_string "TI"))
1502             (and (eq_attr "alternative" "8,9,10,11")
1503                  (eq (symbol_ref "TARGET_SSE2") (const_int 0)))
1504               (const_string "SF")
1505            ]
1506            (const_string "SI")))])
1507
1508 ;; Stores and loads of ax to arbitrary constant address.
1509 ;; We fake an second form of instruction to force reload to load address
1510 ;; into register when rax is not available
1511 (define_insn "*movabssi_1_rex64"
1512   [(set (mem:SI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
1513         (match_operand:SI 1 "nonmemory_operand" "a,er"))]
1514   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
1515   "@
1516    movabs{l}\t{%1, %P0|%P0, %1}
1517    mov{l}\t{%1, %a0|%a0, %1}"
1518   [(set_attr "type" "imov")
1519    (set_attr "modrm" "0,*")
1520    (set_attr "length_address" "8,0")
1521    (set_attr "length_immediate" "0,*")
1522    (set_attr "memory" "store")
1523    (set_attr "mode" "SI")])
1524
1525 (define_insn "*movabssi_2_rex64"
1526   [(set (match_operand:SI 0 "register_operand" "=a,r")
1527         (mem:SI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
1528   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
1529   "@
1530    movabs{l}\t{%P1, %0|%0, %P1}
1531    mov{l}\t{%a1, %0|%0, %a1}"
1532   [(set_attr "type" "imov")
1533    (set_attr "modrm" "0,*")
1534    (set_attr "length_address" "8,0")
1535    (set_attr "length_immediate" "0")
1536    (set_attr "memory" "load")
1537    (set_attr "mode" "SI")])
1538
1539 (define_insn "*swapsi"
1540   [(set (match_operand:SI 0 "register_operand" "+r")
1541         (match_operand:SI 1 "register_operand" "+r"))
1542    (set (match_dup 1)
1543         (match_dup 0))]
1544   ""
1545   "xchg{l}\t%1, %0"
1546   [(set_attr "type" "imov")
1547    (set_attr "mode" "SI")
1548    (set_attr "pent_pair" "np")
1549    (set_attr "athlon_decode" "vector")
1550    (set_attr "amdfam10_decode" "double")])
1551
1552 (define_expand "movhi"
1553   [(set (match_operand:HI 0 "nonimmediate_operand" "")
1554         (match_operand:HI 1 "general_operand" ""))]
1555   ""
1556   "ix86_expand_move (HImode, operands); DONE;")
1557
1558 (define_insn "*pushhi2"
1559   [(set (match_operand:HI 0 "push_operand" "=X")
1560         (match_operand:HI 1 "nonmemory_no_elim_operand" "rn"))]
1561   "!TARGET_64BIT"
1562   "push{l}\t%k1"
1563   [(set_attr "type" "push")
1564    (set_attr "mode" "SI")])
1565
1566 ;; For 64BIT abi we always round up to 8 bytes.
1567 (define_insn "*pushhi2_rex64"
1568   [(set (match_operand:HI 0 "push_operand" "=X")
1569         (match_operand:HI 1 "nonmemory_no_elim_operand" "ri"))]
1570   "TARGET_64BIT"
1571   "push{q}\t%q1"
1572   [(set_attr "type" "push")
1573    (set_attr "mode" "DI")])
1574
1575 (define_insn "*movhi_1"
1576   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,m")
1577         (match_operand:HI 1 "general_operand" "r,rn,rm,rn"))]
1578   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
1579 {
1580   switch (get_attr_type (insn))
1581     {
1582     case TYPE_IMOVX:
1583       /* movzwl is faster than movw on p2 due to partial word stalls,
1584          though not as fast as an aligned movl.  */
1585       return "movz{wl|x}\t{%1, %k0|%k0, %1}";
1586     default:
1587       if (get_attr_mode (insn) == MODE_SI)
1588         return "mov{l}\t{%k1, %k0|%k0, %k1}";
1589       else
1590         return "mov{w}\t{%1, %0|%0, %1}";
1591     }
1592 }
1593   [(set (attr "type")
1594      (cond [(ne (symbol_ref "optimize_size") (const_int 0))
1595               (const_string "imov")
1596             (and (eq_attr "alternative" "0")
1597                  (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
1598                           (const_int 0))
1599                       (eq (symbol_ref "TARGET_HIMODE_MATH")
1600                           (const_int 0))))
1601               (const_string "imov")
1602             (and (eq_attr "alternative" "1,2")
1603                  (match_operand:HI 1 "aligned_operand" ""))
1604               (const_string "imov")
1605             (and (ne (symbol_ref "TARGET_MOVX")
1606                      (const_int 0))
1607                  (eq_attr "alternative" "0,2"))
1608               (const_string "imovx")
1609            ]
1610            (const_string "imov")))
1611     (set (attr "mode")
1612       (cond [(eq_attr "type" "imovx")
1613                (const_string "SI")
1614              (and (eq_attr "alternative" "1,2")
1615                   (match_operand:HI 1 "aligned_operand" ""))
1616                (const_string "SI")
1617              (and (eq_attr "alternative" "0")
1618                   (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
1619                            (const_int 0))
1620                        (eq (symbol_ref "TARGET_HIMODE_MATH")
1621                            (const_int 0))))
1622                (const_string "SI")
1623             ]
1624             (const_string "HI")))])
1625
1626 ;; Stores and loads of ax to arbitrary constant address.
1627 ;; We fake an second form of instruction to force reload to load address
1628 ;; into register when rax is not available
1629 (define_insn "*movabshi_1_rex64"
1630   [(set (mem:HI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
1631         (match_operand:HI 1 "nonmemory_operand" "a,er"))]
1632   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
1633   "@
1634    movabs{w}\t{%1, %P0|%P0, %1}
1635    mov{w}\t{%1, %a0|%a0, %1}"
1636   [(set_attr "type" "imov")
1637    (set_attr "modrm" "0,*")
1638    (set_attr "length_address" "8,0")
1639    (set_attr "length_immediate" "0,*")
1640    (set_attr "memory" "store")
1641    (set_attr "mode" "HI")])
1642
1643 (define_insn "*movabshi_2_rex64"
1644   [(set (match_operand:HI 0 "register_operand" "=a,r")
1645         (mem:HI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
1646   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
1647   "@
1648    movabs{w}\t{%P1, %0|%0, %P1}
1649    mov{w}\t{%a1, %0|%0, %a1}"
1650   [(set_attr "type" "imov")
1651    (set_attr "modrm" "0,*")
1652    (set_attr "length_address" "8,0")
1653    (set_attr "length_immediate" "0")
1654    (set_attr "memory" "load")
1655    (set_attr "mode" "HI")])
1656
1657 (define_insn "*swaphi_1"
1658   [(set (match_operand:HI 0 "register_operand" "+r")
1659         (match_operand:HI 1 "register_operand" "+r"))
1660    (set (match_dup 1)
1661         (match_dup 0))]
1662   "!TARGET_PARTIAL_REG_STALL || optimize_size"
1663   "xchg{l}\t%k1, %k0"
1664   [(set_attr "type" "imov")
1665    (set_attr "mode" "SI")
1666    (set_attr "pent_pair" "np")
1667    (set_attr "athlon_decode" "vector")
1668    (set_attr "amdfam10_decode" "double")])
1669
1670 ;; Not added amdfam10_decode since TARGET_PARTIAL_REG_STALL is disabled for AMDFAM10
1671 (define_insn "*swaphi_2"
1672   [(set (match_operand:HI 0 "register_operand" "+r")
1673         (match_operand:HI 1 "register_operand" "+r"))
1674    (set (match_dup 1)
1675         (match_dup 0))]
1676   "TARGET_PARTIAL_REG_STALL"
1677   "xchg{w}\t%1, %0"
1678   [(set_attr "type" "imov")
1679    (set_attr "mode" "HI")
1680    (set_attr "pent_pair" "np")
1681    (set_attr "athlon_decode" "vector")])
1682
1683 (define_expand "movstricthi"
1684   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" ""))
1685         (match_operand:HI 1 "general_operand" ""))]
1686   "! TARGET_PARTIAL_REG_STALL || optimize_size"
1687 {
1688   /* Don't generate memory->memory moves, go through a register */
1689   if (MEM_P (operands[0]) && MEM_P (operands[1]))
1690     operands[1] = force_reg (HImode, operands[1]);
1691 })
1692
1693 (define_insn "*movstricthi_1"
1694   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+rm,r"))
1695         (match_operand:HI 1 "general_operand" "rn,m"))]
1696   "(! TARGET_PARTIAL_REG_STALL || optimize_size)
1697    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1698   "mov{w}\t{%1, %0|%0, %1}"
1699   [(set_attr "type" "imov")
1700    (set_attr "mode" "HI")])
1701
1702 (define_insn "*movstricthi_xor"
1703   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+r"))
1704         (match_operand:HI 1 "const0_operand" "i"))
1705    (clobber (reg:CC FLAGS_REG))]
1706   "reload_completed
1707    && ((!TARGET_USE_MOV0 && !TARGET_PARTIAL_REG_STALL) || optimize_size)"
1708   "xor{w}\t%0, %0"
1709   [(set_attr "type" "alu1")
1710    (set_attr "mode" "HI")
1711    (set_attr "length_immediate" "0")])
1712
1713 (define_expand "movqi"
1714   [(set (match_operand:QI 0 "nonimmediate_operand" "")
1715         (match_operand:QI 1 "general_operand" ""))]
1716   ""
1717   "ix86_expand_move (QImode, operands); DONE;")
1718
1719 ;; emit_push_insn when it calls move_by_pieces requires an insn to
1720 ;; "push a byte".  But actually we use pushl, which has the effect
1721 ;; of rounding the amount pushed up to a word.
1722
1723 (define_insn "*pushqi2"
1724   [(set (match_operand:QI 0 "push_operand" "=X")
1725         (match_operand:QI 1 "nonmemory_no_elim_operand" "rn"))]
1726   "!TARGET_64BIT"
1727   "push{l}\t%k1"
1728   [(set_attr "type" "push")
1729    (set_attr "mode" "SI")])
1730
1731 ;; For 64BIT abi we always round up to 8 bytes.
1732 (define_insn "*pushqi2_rex64"
1733   [(set (match_operand:QI 0 "push_operand" "=X")
1734         (match_operand:QI 1 "nonmemory_no_elim_operand" "qi"))]
1735   "TARGET_64BIT"
1736   "push{q}\t%q1"
1737   [(set_attr "type" "push")
1738    (set_attr "mode" "DI")])
1739
1740 ;; Situation is quite tricky about when to choose full sized (SImode) move
1741 ;; over QImode moves.  For Q_REG -> Q_REG move we use full size only for
1742 ;; partial register dependency machines (such as AMD Athlon), where QImode
1743 ;; moves issue extra dependency and for partial register stalls machines
1744 ;; that don't use QImode patterns (and QImode move cause stall on the next
1745 ;; instruction).
1746 ;;
1747 ;; For loads of Q_REG to NONQ_REG we use full sized moves except for partial
1748 ;; register stall machines with, where we use QImode instructions, since
1749 ;; partial register stall can be caused there.  Then we use movzx.
1750 (define_insn "*movqi_1"
1751   [(set (match_operand:QI 0 "nonimmediate_operand" "=q,q ,q ,r,r ,?r,m")
1752         (match_operand:QI 1 "general_operand"      " q,qn,qm,q,rn,qm,qn"))]
1753   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
1754 {
1755   switch (get_attr_type (insn))
1756     {
1757     case TYPE_IMOVX:
1758       gcc_assert (ANY_QI_REG_P (operands[1]) || MEM_P (operands[1]));
1759       return "movz{bl|x}\t{%1, %k0|%k0, %1}";
1760     default:
1761       if (get_attr_mode (insn) == MODE_SI)
1762         return "mov{l}\t{%k1, %k0|%k0, %k1}";
1763       else
1764         return "mov{b}\t{%1, %0|%0, %1}";
1765     }
1766 }
1767   [(set (attr "type")
1768      (cond [(and (eq_attr "alternative" "5")
1769                  (not (match_operand:QI 1 "aligned_operand" "")))
1770               (const_string "imovx")
1771             (ne (symbol_ref "optimize_size") (const_int 0))
1772               (const_string "imov")
1773             (and (eq_attr "alternative" "3")
1774                  (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
1775                           (const_int 0))
1776                       (eq (symbol_ref "TARGET_QIMODE_MATH")
1777                           (const_int 0))))
1778               (const_string "imov")
1779             (eq_attr "alternative" "3,5")
1780               (const_string "imovx")
1781             (and (ne (symbol_ref "TARGET_MOVX")
1782                      (const_int 0))
1783                  (eq_attr "alternative" "2"))
1784               (const_string "imovx")
1785            ]
1786            (const_string "imov")))
1787    (set (attr "mode")
1788       (cond [(eq_attr "alternative" "3,4,5")
1789                (const_string "SI")
1790              (eq_attr "alternative" "6")
1791                (const_string "QI")
1792              (eq_attr "type" "imovx")
1793                (const_string "SI")
1794              (and (eq_attr "type" "imov")
1795                   (and (eq_attr "alternative" "0,1")
1796                        (and (ne (symbol_ref "TARGET_PARTIAL_REG_DEPENDENCY")
1797                                 (const_int 0))
1798                             (and (eq (symbol_ref "optimize_size")
1799                                      (const_int 0))
1800                                  (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
1801                                      (const_int 0))))))
1802                (const_string "SI")
1803              ;; Avoid partial register stalls when not using QImode arithmetic
1804              (and (eq_attr "type" "imov")
1805                   (and (eq_attr "alternative" "0,1")
1806                        (and (ne (symbol_ref "TARGET_PARTIAL_REG_STALL")
1807                                 (const_int 0))
1808                             (eq (symbol_ref "TARGET_QIMODE_MATH")
1809                                 (const_int 0)))))
1810                (const_string "SI")
1811            ]
1812            (const_string "QI")))])
1813
1814 (define_insn "*swapqi_1"
1815   [(set (match_operand:QI 0 "register_operand" "+r")
1816         (match_operand:QI 1 "register_operand" "+r"))
1817    (set (match_dup 1)
1818         (match_dup 0))]
1819   "!TARGET_PARTIAL_REG_STALL || optimize_size"
1820   "xchg{l}\t%k1, %k0"
1821   [(set_attr "type" "imov")
1822    (set_attr "mode" "SI")
1823    (set_attr "pent_pair" "np")
1824    (set_attr "athlon_decode" "vector")
1825    (set_attr "amdfam10_decode" "vector")])
1826
1827 ;; Not added amdfam10_decode since TARGET_PARTIAL_REG_STALL is disabled for AMDFAM10
1828 (define_insn "*swapqi_2"
1829   [(set (match_operand:QI 0 "register_operand" "+q")
1830         (match_operand:QI 1 "register_operand" "+q"))
1831    (set (match_dup 1)
1832         (match_dup 0))]
1833   "TARGET_PARTIAL_REG_STALL"
1834   "xchg{b}\t%1, %0"
1835   [(set_attr "type" "imov")
1836    (set_attr "mode" "QI")
1837    (set_attr "pent_pair" "np")
1838    (set_attr "athlon_decode" "vector")])
1839
1840 (define_expand "movstrictqi"
1841   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" ""))
1842         (match_operand:QI 1 "general_operand" ""))]
1843   "! TARGET_PARTIAL_REG_STALL || optimize_size"
1844 {
1845   /* Don't generate memory->memory moves, go through a register.  */
1846   if (MEM_P (operands[0]) && MEM_P (operands[1]))
1847     operands[1] = force_reg (QImode, operands[1]);
1848 })
1849
1850 (define_insn "*movstrictqi_1"
1851   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+qm,q"))
1852         (match_operand:QI 1 "general_operand" "*qn,m"))]
1853   "(! TARGET_PARTIAL_REG_STALL || optimize_size)
1854    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1855   "mov{b}\t{%1, %0|%0, %1}"
1856   [(set_attr "type" "imov")
1857    (set_attr "mode" "QI")])
1858
1859 (define_insn "*movstrictqi_xor"
1860   [(set (strict_low_part (match_operand:QI 0 "q_regs_operand" "+q"))
1861         (match_operand:QI 1 "const0_operand" "i"))
1862    (clobber (reg:CC FLAGS_REG))]
1863   "reload_completed && (!TARGET_USE_MOV0 || optimize_size)"
1864   "xor{b}\t%0, %0"
1865   [(set_attr "type" "alu1")
1866    (set_attr "mode" "QI")
1867    (set_attr "length_immediate" "0")])
1868
1869 (define_insn "*movsi_extv_1"
1870   [(set (match_operand:SI 0 "register_operand" "=R")
1871         (sign_extract:SI (match_operand 1 "ext_register_operand" "Q")
1872                          (const_int 8)
1873                          (const_int 8)))]
1874   ""
1875   "movs{bl|x}\t{%h1, %0|%0, %h1}"
1876   [(set_attr "type" "imovx")
1877    (set_attr "mode" "SI")])
1878
1879 (define_insn "*movhi_extv_1"
1880   [(set (match_operand:HI 0 "register_operand" "=R")
1881         (sign_extract:HI (match_operand 1 "ext_register_operand" "Q")
1882                          (const_int 8)
1883                          (const_int 8)))]
1884   ""
1885   "movs{bl|x}\t{%h1, %k0|%k0, %h1}"
1886   [(set_attr "type" "imovx")
1887    (set_attr "mode" "SI")])
1888
1889 (define_insn "*movqi_extv_1"
1890   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?r")
1891         (sign_extract:QI (match_operand 1 "ext_register_operand" "Q,Q")
1892                          (const_int 8)
1893                          (const_int 8)))]
1894   "!TARGET_64BIT"
1895 {
1896   switch (get_attr_type (insn))
1897     {
1898     case TYPE_IMOVX:
1899       return "movs{bl|x}\t{%h1, %k0|%k0, %h1}";
1900     default:
1901       return "mov{b}\t{%h1, %0|%0, %h1}";
1902     }
1903 }
1904   [(set (attr "type")
1905      (if_then_else (and (match_operand:QI 0 "register_operand" "")
1906                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
1907                              (ne (symbol_ref "TARGET_MOVX")
1908                                  (const_int 0))))
1909         (const_string "imovx")
1910         (const_string "imov")))
1911    (set (attr "mode")
1912      (if_then_else (eq_attr "type" "imovx")
1913         (const_string "SI")
1914         (const_string "QI")))])
1915
1916 (define_insn "*movqi_extv_1_rex64"
1917   [(set (match_operand:QI 0 "register_operand" "=Q,?R")
1918         (sign_extract:QI (match_operand 1 "ext_register_operand" "Q,Q")
1919                          (const_int 8)
1920                          (const_int 8)))]
1921   "TARGET_64BIT"
1922 {
1923   switch (get_attr_type (insn))
1924     {
1925     case TYPE_IMOVX:
1926       return "movs{bl|x}\t{%h1, %k0|%k0, %h1}";
1927     default:
1928       return "mov{b}\t{%h1, %0|%0, %h1}";
1929     }
1930 }
1931   [(set (attr "type")
1932      (if_then_else (and (match_operand:QI 0 "register_operand" "")
1933                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
1934                              (ne (symbol_ref "TARGET_MOVX")
1935                                  (const_int 0))))
1936         (const_string "imovx")
1937         (const_string "imov")))
1938    (set (attr "mode")
1939      (if_then_else (eq_attr "type" "imovx")
1940         (const_string "SI")
1941         (const_string "QI")))])
1942
1943 ;; Stores and loads of ax to arbitrary constant address.
1944 ;; We fake an second form of instruction to force reload to load address
1945 ;; into register when rax is not available
1946 (define_insn "*movabsqi_1_rex64"
1947   [(set (mem:QI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
1948         (match_operand:QI 1 "nonmemory_operand" "a,er"))]
1949   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
1950   "@
1951    movabs{b}\t{%1, %P0|%P0, %1}
1952    mov{b}\t{%1, %a0|%a0, %1}"
1953   [(set_attr "type" "imov")
1954    (set_attr "modrm" "0,*")
1955    (set_attr "length_address" "8,0")
1956    (set_attr "length_immediate" "0,*")
1957    (set_attr "memory" "store")
1958    (set_attr "mode" "QI")])
1959
1960 (define_insn "*movabsqi_2_rex64"
1961   [(set (match_operand:QI 0 "register_operand" "=a,r")
1962         (mem:QI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
1963   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
1964   "@
1965    movabs{b}\t{%P1, %0|%0, %P1}
1966    mov{b}\t{%a1, %0|%0, %a1}"
1967   [(set_attr "type" "imov")
1968    (set_attr "modrm" "0,*")
1969    (set_attr "length_address" "8,0")
1970    (set_attr "length_immediate" "0")
1971    (set_attr "memory" "load")
1972    (set_attr "mode" "QI")])
1973
1974 (define_insn "*movdi_extzv_1"
1975   [(set (match_operand:DI 0 "register_operand" "=R")
1976         (zero_extract:DI (match_operand 1 "ext_register_operand" "Q")
1977                          (const_int 8)
1978                          (const_int 8)))]
1979   "TARGET_64BIT"
1980   "movz{bl|x}\t{%h1, %k0|%k0, %h1}"
1981   [(set_attr "type" "imovx")
1982    (set_attr "mode" "DI")])
1983
1984 (define_insn "*movsi_extzv_1"
1985   [(set (match_operand:SI 0 "register_operand" "=R")
1986         (zero_extract:SI (match_operand 1 "ext_register_operand" "Q")
1987                          (const_int 8)
1988                          (const_int 8)))]
1989   ""
1990   "movz{bl|x}\t{%h1, %0|%0, %h1}"
1991   [(set_attr "type" "imovx")
1992    (set_attr "mode" "SI")])
1993
1994 (define_insn "*movqi_extzv_2"
1995   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?R")
1996         (subreg:QI (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
1997                                     (const_int 8)
1998                                     (const_int 8)) 0))]
1999   "!TARGET_64BIT"
2000 {
2001   switch (get_attr_type (insn))
2002     {
2003     case TYPE_IMOVX:
2004       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2005     default:
2006       return "mov{b}\t{%h1, %0|%0, %h1}";
2007     }
2008 }
2009   [(set (attr "type")
2010      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2011                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2012                              (ne (symbol_ref "TARGET_MOVX")
2013                                  (const_int 0))))
2014         (const_string "imovx")
2015         (const_string "imov")))
2016    (set (attr "mode")
2017      (if_then_else (eq_attr "type" "imovx")
2018         (const_string "SI")
2019         (const_string "QI")))])
2020
2021 (define_insn "*movqi_extzv_2_rex64"
2022   [(set (match_operand:QI 0 "register_operand" "=Q,?R")
2023         (subreg:QI (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
2024                                     (const_int 8)
2025                                     (const_int 8)) 0))]
2026   "TARGET_64BIT"
2027 {
2028   switch (get_attr_type (insn))
2029     {
2030     case TYPE_IMOVX:
2031       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2032     default:
2033       return "mov{b}\t{%h1, %0|%0, %h1}";
2034     }
2035 }
2036   [(set (attr "type")
2037      (if_then_else (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2038                         (ne (symbol_ref "TARGET_MOVX")
2039                             (const_int 0)))
2040         (const_string "imovx")
2041         (const_string "imov")))
2042    (set (attr "mode")
2043      (if_then_else (eq_attr "type" "imovx")
2044         (const_string "SI")
2045         (const_string "QI")))])
2046
2047 (define_insn "movsi_insv_1"
2048   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2049                          (const_int 8)
2050                          (const_int 8))
2051         (match_operand:SI 1 "general_operand" "Qmn"))]
2052   "!TARGET_64BIT"
2053   "mov{b}\t{%b1, %h0|%h0, %b1}"
2054   [(set_attr "type" "imov")
2055    (set_attr "mode" "QI")])
2056
2057 (define_insn "*movsi_insv_1_rex64"
2058   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2059                          (const_int 8)
2060                          (const_int 8))
2061         (match_operand:SI 1 "nonmemory_operand" "Qn"))]
2062   "TARGET_64BIT"
2063   "mov{b}\t{%b1, %h0|%h0, %b1}"
2064   [(set_attr "type" "imov")
2065    (set_attr "mode" "QI")])
2066
2067 (define_insn "movdi_insv_1_rex64"
2068   [(set (zero_extract:DI (match_operand 0 "ext_register_operand" "+Q")
2069                          (const_int 8)
2070                          (const_int 8))
2071         (match_operand:DI 1 "nonmemory_operand" "Qn"))]
2072   "TARGET_64BIT"
2073   "mov{b}\t{%b1, %h0|%h0, %b1}"
2074   [(set_attr "type" "imov")
2075    (set_attr "mode" "QI")])
2076
2077 (define_insn "*movqi_insv_2"
2078   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2079                          (const_int 8)
2080                          (const_int 8))
2081         (lshiftrt:SI (match_operand:SI 1 "register_operand" "Q")
2082                      (const_int 8)))]
2083   ""
2084   "mov{b}\t{%h1, %h0|%h0, %h1}"
2085   [(set_attr "type" "imov")
2086    (set_attr "mode" "QI")])
2087
2088 (define_expand "movdi"
2089   [(set (match_operand:DI 0 "nonimmediate_operand" "")
2090         (match_operand:DI 1 "general_operand" ""))]
2091   ""
2092   "ix86_expand_move (DImode, operands); DONE;")
2093
2094 (define_insn "*pushdi"
2095   [(set (match_operand:DI 0 "push_operand" "=<")
2096         (match_operand:DI 1 "general_no_elim_operand" "riF*m"))]
2097   "!TARGET_64BIT"
2098   "#")
2099
2100 (define_insn "*pushdi2_rex64"
2101   [(set (match_operand:DI 0 "push_operand" "=<,!<")
2102         (match_operand:DI 1 "general_no_elim_operand" "re*m,n"))]
2103   "TARGET_64BIT"
2104   "@
2105    push{q}\t%1
2106    #"
2107   [(set_attr "type" "push,multi")
2108    (set_attr "mode" "DI")])
2109
2110 ;; Convert impossible pushes of immediate to existing instructions.
2111 ;; First try to get scratch register and go through it.  In case this
2112 ;; fails, push sign extended lower part first and then overwrite
2113 ;; upper part by 32bit move.
2114 (define_peephole2
2115   [(match_scratch:DI 2 "r")
2116    (set (match_operand:DI 0 "push_operand" "")
2117         (match_operand:DI 1 "immediate_operand" ""))]
2118   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2119    && !x86_64_immediate_operand (operands[1], DImode)"
2120   [(set (match_dup 2) (match_dup 1))
2121    (set (match_dup 0) (match_dup 2))]
2122   "")
2123
2124 ;; We need to define this as both peepholer and splitter for case
2125 ;; peephole2 pass is not run.
2126 ;; "&& 1" is needed to keep it from matching the previous pattern.
2127 (define_peephole2
2128   [(set (match_operand:DI 0 "push_operand" "")
2129         (match_operand:DI 1 "immediate_operand" ""))]
2130   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2131    && !x86_64_immediate_operand (operands[1], DImode) && 1"
2132   [(set (match_dup 0) (match_dup 1))
2133    (set (match_dup 2) (match_dup 3))]
2134   "split_di (&operands[1], 1, &operands[2], &operands[3]);
2135    operands[1] = gen_lowpart (DImode, operands[2]);
2136    operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx,
2137                                                     GEN_INT (4)));
2138   ")
2139
2140 (define_split
2141   [(set (match_operand:DI 0 "push_operand" "")
2142         (match_operand:DI 1 "immediate_operand" ""))]
2143   "TARGET_64BIT && ((optimize > 0 && flag_peephole2)
2144                     ? epilogue_completed : reload_completed)
2145    && !symbolic_operand (operands[1], DImode)
2146    && !x86_64_immediate_operand (operands[1], DImode)"
2147   [(set (match_dup 0) (match_dup 1))
2148    (set (match_dup 2) (match_dup 3))]
2149   "split_di (&operands[1], 1, &operands[2], &operands[3]);
2150    operands[1] = gen_lowpart (DImode, operands[2]);
2151    operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx,
2152                                                     GEN_INT (4)));
2153   ")
2154
2155 (define_insn "*pushdi2_prologue_rex64"
2156   [(set (match_operand:DI 0 "push_operand" "=<")
2157         (match_operand:DI 1 "general_no_elim_operand" "re*m"))
2158    (clobber (mem:BLK (scratch)))]
2159   "TARGET_64BIT"
2160   "push{q}\t%1"
2161   [(set_attr "type" "push")
2162    (set_attr "mode" "DI")])
2163
2164 (define_insn "*popdi1_epilogue_rex64"
2165   [(set (match_operand:DI 0 "nonimmediate_operand" "=r*m")
2166         (mem:DI (reg:DI SP_REG)))
2167    (set (reg:DI SP_REG)
2168         (plus:DI (reg:DI SP_REG) (const_int 8)))
2169    (clobber (mem:BLK (scratch)))]
2170   "TARGET_64BIT"
2171   "pop{q}\t%0"
2172   [(set_attr "type" "pop")
2173    (set_attr "mode" "DI")])
2174
2175 (define_insn "popdi1"
2176   [(set (match_operand:DI 0 "nonimmediate_operand" "=r*m")
2177         (mem:DI (reg:DI SP_REG)))
2178    (set (reg:DI SP_REG)
2179         (plus:DI (reg:DI SP_REG) (const_int 8)))]
2180   "TARGET_64BIT"
2181   "pop{q}\t%0"
2182   [(set_attr "type" "pop")
2183    (set_attr "mode" "DI")])
2184
2185 (define_insn "*movdi_xor_rex64"
2186   [(set (match_operand:DI 0 "register_operand" "=r")
2187         (match_operand:DI 1 "const0_operand" "i"))
2188    (clobber (reg:CC FLAGS_REG))]
2189   "TARGET_64BIT && (!TARGET_USE_MOV0 || optimize_size)
2190    && reload_completed"
2191   "xor{l}\t%k0, %k0";
2192   [(set_attr "type" "alu1")
2193    (set_attr "mode" "SI")
2194    (set_attr "length_immediate" "0")])
2195
2196 (define_insn "*movdi_or_rex64"
2197   [(set (match_operand:DI 0 "register_operand" "=r")
2198         (match_operand:DI 1 "const_int_operand" "i"))
2199    (clobber (reg:CC FLAGS_REG))]
2200   "TARGET_64BIT && (TARGET_MOVE_M1_VIA_OR || optimize_size)
2201    && reload_completed
2202    && operands[1] == constm1_rtx"
2203 {
2204   operands[1] = constm1_rtx;
2205   return "or{q}\t{%1, %0|%0, %1}";
2206 }
2207   [(set_attr "type" "alu1")
2208    (set_attr "mode" "DI")
2209    (set_attr "length_immediate" "1")])
2210
2211 (define_insn "*movdi_2"
2212   [(set (match_operand:DI 0 "nonimmediate_operand"
2213                         "=r  ,o  ,*y,m*y,*y,*Y2,m  ,*Y2,*Y2,*x,m ,*x,*x")
2214         (match_operand:DI 1 "general_operand"
2215                         "riFo,riF,C ,*y ,m ,C  ,*Y2,*Y2,m  ,C ,*x,*x,m "))]
2216   "!TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2217   "@
2218    #
2219    #
2220    pxor\t%0, %0
2221    movq\t{%1, %0|%0, %1}
2222    movq\t{%1, %0|%0, %1}
2223    pxor\t%0, %0
2224    movq\t{%1, %0|%0, %1}
2225    movdqa\t{%1, %0|%0, %1}
2226    movq\t{%1, %0|%0, %1}
2227    xorps\t%0, %0
2228    movlps\t{%1, %0|%0, %1}
2229    movaps\t{%1, %0|%0, %1}
2230    movlps\t{%1, %0|%0, %1}"
2231   [(set_attr "type" "*,*,mmx,mmxmov,mmxmov,sselog1,ssemov,ssemov,ssemov,sselog1,ssemov,ssemov,ssemov")
2232    (set_attr "mode" "DI,DI,DI,DI,DI,TI,DI,TI,DI,V4SF,V2SF,V4SF,V2SF")])
2233
2234 (define_split
2235   [(set (match_operand:DI 0 "push_operand" "")
2236         (match_operand:DI 1 "general_operand" ""))]
2237   "!TARGET_64BIT && reload_completed
2238    && (! MMX_REG_P (operands[1]) && !SSE_REG_P (operands[1]))"
2239   [(const_int 0)]
2240   "ix86_split_long_move (operands); DONE;")
2241
2242 ;; %%% This multiword shite has got to go.
2243 (define_split
2244   [(set (match_operand:DI 0 "nonimmediate_operand" "")
2245         (match_operand:DI 1 "general_operand" ""))]
2246   "!TARGET_64BIT && reload_completed
2247    && (!MMX_REG_P (operands[0]) && !SSE_REG_P (operands[0]))
2248    && (!MMX_REG_P (operands[1]) && !SSE_REG_P (operands[1]))"
2249   [(const_int 0)]
2250   "ix86_split_long_move (operands); DONE;")
2251
2252 (define_insn "*movdi_1_rex64"
2253   [(set (match_operand:DI 0 "nonimmediate_operand"
2254           "=r,r  ,r,m ,!m,*y,*y,?r ,m ,?*Ym,?*y,*x,*x,?r ,m,?*Yi,*x,?*x,?*Ym")
2255         (match_operand:DI 1 "general_operand"
2256           "Z ,rem,i,re,n ,C ,*y,*Ym,*y,r   ,m  ,C ,*x,*Yi,*x,r  ,m ,*Ym,*x"))]
2257   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2258 {
2259   switch (get_attr_type (insn))
2260     {
2261     case TYPE_SSECVT:
2262       if (SSE_REG_P (operands[0]))
2263         return "movq2dq\t{%1, %0|%0, %1}";
2264       else
2265         return "movdq2q\t{%1, %0|%0, %1}";
2266
2267     case TYPE_SSEMOV:
2268       if (get_attr_mode (insn) == MODE_TI)
2269         return "movdqa\t{%1, %0|%0, %1}";
2270       /* FALLTHRU */
2271
2272     case TYPE_MMXMOV:
2273       /* Moves from and into integer register is done using movd
2274          opcode with REX prefix.  */
2275       if (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1]))
2276         return "movd\t{%1, %0|%0, %1}";
2277       return "movq\t{%1, %0|%0, %1}";
2278
2279     case TYPE_SSELOG1:
2280     case TYPE_MMXADD:
2281       return "pxor\t%0, %0";
2282
2283     case TYPE_MULTI:
2284       return "#";
2285
2286     case TYPE_LEA:
2287       return "lea{q}\t{%a1, %0|%0, %a1}";
2288
2289     default:
2290       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
2291       if (get_attr_mode (insn) == MODE_SI)
2292         return "mov{l}\t{%k1, %k0|%k0, %k1}";
2293       else if (which_alternative == 2)
2294         return "movabs{q}\t{%1, %0|%0, %1}";
2295       else
2296         return "mov{q}\t{%1, %0|%0, %1}";
2297     }
2298 }
2299   [(set (attr "type")
2300      (cond [(eq_attr "alternative" "5")
2301               (const_string "mmxadd")
2302             (eq_attr "alternative" "6,7,8,9,10")
2303               (const_string "mmxmov")
2304             (eq_attr "alternative" "11")
2305               (const_string "sselog1")
2306             (eq_attr "alternative" "12,13,14,15,16")
2307               (const_string "ssemov")
2308             (eq_attr "alternative" "17,18")
2309               (const_string "ssecvt")
2310             (eq_attr "alternative" "4")
2311               (const_string "multi")
2312             (match_operand:DI 1 "pic_32bit_operand" "")
2313               (const_string "lea")
2314            ]
2315            (const_string "imov")))
2316    (set_attr "modrm" "*,0,0,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*")
2317    (set_attr "length_immediate" "*,4,8,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*")
2318    (set_attr "mode" "SI,DI,DI,DI,SI,DI,DI,DI,DI,DI,DI,TI,TI,DI,DI,DI,DI,DI,DI")])
2319
2320 ;; Stores and loads of ax to arbitrary constant address.
2321 ;; We fake an second form of instruction to force reload to load address
2322 ;; into register when rax is not available
2323 (define_insn "*movabsdi_1_rex64"
2324   [(set (mem:DI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
2325         (match_operand:DI 1 "nonmemory_operand" "a,er"))]
2326   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
2327   "@
2328    movabs{q}\t{%1, %P0|%P0, %1}
2329    mov{q}\t{%1, %a0|%a0, %1}"
2330   [(set_attr "type" "imov")
2331    (set_attr "modrm" "0,*")
2332    (set_attr "length_address" "8,0")
2333    (set_attr "length_immediate" "0,*")
2334    (set_attr "memory" "store")
2335    (set_attr "mode" "DI")])
2336
2337 (define_insn "*movabsdi_2_rex64"
2338   [(set (match_operand:DI 0 "register_operand" "=a,r")
2339         (mem:DI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
2340   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
2341   "@
2342    movabs{q}\t{%P1, %0|%0, %P1}
2343    mov{q}\t{%a1, %0|%0, %a1}"
2344   [(set_attr "type" "imov")
2345    (set_attr "modrm" "0,*")
2346    (set_attr "length_address" "8,0")
2347    (set_attr "length_immediate" "0")
2348    (set_attr "memory" "load")
2349    (set_attr "mode" "DI")])
2350
2351 ;; Convert impossible stores of immediate to existing instructions.
2352 ;; First try to get scratch register and go through it.  In case this
2353 ;; fails, move by 32bit parts.
2354 (define_peephole2
2355   [(match_scratch:DI 2 "r")
2356    (set (match_operand:DI 0 "memory_operand" "")
2357         (match_operand:DI 1 "immediate_operand" ""))]
2358   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2359    && !x86_64_immediate_operand (operands[1], DImode)"
2360   [(set (match_dup 2) (match_dup 1))
2361    (set (match_dup 0) (match_dup 2))]
2362   "")
2363
2364 ;; We need to define this as both peepholer and splitter for case
2365 ;; peephole2 pass is not run.
2366 ;; "&& 1" is needed to keep it from matching the previous pattern.
2367 (define_peephole2
2368   [(set (match_operand:DI 0 "memory_operand" "")
2369         (match_operand:DI 1 "immediate_operand" ""))]
2370   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2371    && !x86_64_immediate_operand (operands[1], DImode) && 1"
2372   [(set (match_dup 2) (match_dup 3))
2373    (set (match_dup 4) (match_dup 5))]
2374   "split_di (&operands[0], 2, &operands[2], &operands[4]);")
2375
2376 (define_split
2377   [(set (match_operand:DI 0 "memory_operand" "")
2378         (match_operand:DI 1 "immediate_operand" ""))]
2379   "TARGET_64BIT && ((optimize > 0 && flag_peephole2)
2380                     ? epilogue_completed : reload_completed)
2381    && !symbolic_operand (operands[1], DImode)
2382    && !x86_64_immediate_operand (operands[1], DImode)"
2383   [(set (match_dup 2) (match_dup 3))
2384    (set (match_dup 4) (match_dup 5))]
2385   "split_di (&operands[0], 2, &operands[2], &operands[4]);")
2386
2387 (define_insn "*swapdi_rex64"
2388   [(set (match_operand:DI 0 "register_operand" "+r")
2389         (match_operand:DI 1 "register_operand" "+r"))
2390    (set (match_dup 1)
2391         (match_dup 0))]
2392   "TARGET_64BIT"
2393   "xchg{q}\t%1, %0"
2394   [(set_attr "type" "imov")
2395    (set_attr "mode" "DI")
2396    (set_attr "pent_pair" "np")
2397    (set_attr "athlon_decode" "vector")
2398    (set_attr "amdfam10_decode" "double")])
2399
2400 (define_expand "movti"
2401   [(set (match_operand:TI 0 "nonimmediate_operand" "")
2402         (match_operand:TI 1 "nonimmediate_operand" ""))]
2403   "TARGET_SSE || TARGET_64BIT"
2404 {
2405   if (TARGET_64BIT)
2406     ix86_expand_move (TImode, operands);
2407   else if (push_operand (operands[0], TImode))
2408     ix86_expand_push (TImode, operands[1]);
2409   else
2410     ix86_expand_vector_move (TImode, operands);
2411   DONE;
2412 })
2413
2414 (define_insn "*movti_internal"
2415   [(set (match_operand:TI 0 "nonimmediate_operand" "=x,x,m")
2416         (match_operand:TI 1 "vector_move_operand" "C,xm,x"))]
2417   "TARGET_SSE && !TARGET_64BIT
2418    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2419 {
2420   switch (which_alternative)
2421     {
2422     case 0:
2423       if (get_attr_mode (insn) == MODE_V4SF)
2424         return "xorps\t%0, %0";
2425       else
2426         return "pxor\t%0, %0";
2427     case 1:
2428     case 2:
2429       /* TDmode values are passed as TImode on the stack.  Moving them
2430          to stack may result in unaligned memory access.  */
2431       if (misaligned_operand (operands[0], TImode)
2432           || misaligned_operand (operands[1], TImode))
2433         {
2434           if (get_attr_mode (insn) == MODE_V4SF)
2435             return "movups\t{%1, %0|%0, %1}";
2436          else
2437            return "movdqu\t{%1, %0|%0, %1}";
2438         }
2439       else
2440         {
2441           if (get_attr_mode (insn) == MODE_V4SF)
2442             return "movaps\t{%1, %0|%0, %1}";
2443          else
2444            return "movdqa\t{%1, %0|%0, %1}";
2445         }
2446     default:
2447       gcc_unreachable ();
2448     }
2449 }
2450   [(set_attr "type" "sselog1,ssemov,ssemov")
2451    (set (attr "mode")
2452         (cond [(ior (eq (symbol_ref "TARGET_SSE2") (const_int 0))
2453                     (ne (symbol_ref "optimize_size") (const_int 0)))
2454                  (const_string "V4SF")
2455                (and (eq_attr "alternative" "2")
2456                     (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
2457                         (const_int 0)))
2458                  (const_string "V4SF")]
2459               (const_string "TI")))])
2460
2461 (define_insn "*movti_rex64"
2462   [(set (match_operand:TI 0 "nonimmediate_operand" "=r,o,x,x,xm")
2463         (match_operand:TI 1 "general_operand" "riFo,riF,C,xm,x"))]
2464   "TARGET_64BIT
2465    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2466 {
2467   switch (which_alternative)
2468     {
2469     case 0:
2470     case 1:
2471       return "#";
2472     case 2:
2473       if (get_attr_mode (insn) == MODE_V4SF)
2474         return "xorps\t%0, %0";
2475       else
2476         return "pxor\t%0, %0";
2477     case 3:
2478     case 4:
2479       /* TDmode values are passed as TImode on the stack.  Moving them
2480          to stack may result in unaligned memory access.  */
2481       if (misaligned_operand (operands[0], TImode)
2482           || misaligned_operand (operands[1], TImode))
2483         {
2484           if (get_attr_mode (insn) == MODE_V4SF)
2485             return "movups\t{%1, %0|%0, %1}";
2486          else
2487            return "movdqu\t{%1, %0|%0, %1}";
2488         }
2489       else
2490         {
2491           if (get_attr_mode (insn) == MODE_V4SF)
2492             return "movaps\t{%1, %0|%0, %1}";
2493          else
2494            return "movdqa\t{%1, %0|%0, %1}";
2495         }
2496     default:
2497       gcc_unreachable ();
2498     }
2499 }
2500   [(set_attr "type" "*,*,sselog1,ssemov,ssemov")
2501    (set (attr "mode")
2502         (cond [(eq_attr "alternative" "2,3")
2503                  (if_then_else
2504                    (ne (symbol_ref "optimize_size")
2505                        (const_int 0))
2506                    (const_string "V4SF")
2507                    (const_string "TI"))
2508                (eq_attr "alternative" "4")
2509                  (if_then_else
2510                    (ior (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
2511                             (const_int 0))
2512                         (ne (symbol_ref "optimize_size")
2513                             (const_int 0)))
2514                    (const_string "V4SF")
2515                    (const_string "TI"))]
2516                (const_string "DI")))])
2517
2518 (define_split
2519   [(set (match_operand:TI 0 "nonimmediate_operand" "")
2520         (match_operand:TI 1 "general_operand" ""))]
2521   "reload_completed && !SSE_REG_P (operands[0])
2522    && !SSE_REG_P (operands[1])"
2523   [(const_int 0)]
2524   "ix86_split_long_move (operands); DONE;")
2525
2526 ;; This expands to what emit_move_complex would generate if we didn't
2527 ;; have a movti pattern.  Having this avoids problems with reload on
2528 ;; 32-bit targets when SSE is present, but doesn't seem to be harmful
2529 ;; to have around all the time.
2530 (define_expand "movcdi"
2531   [(set (match_operand:CDI 0 "nonimmediate_operand" "")
2532         (match_operand:CDI 1 "general_operand" ""))]
2533   ""
2534 {
2535   if (push_operand (operands[0], CDImode))
2536     emit_move_complex_push (CDImode, operands[0], operands[1]);
2537   else
2538     emit_move_complex_parts (operands[0], operands[1]);
2539   DONE;
2540 })
2541
2542 (define_expand "movsf"
2543   [(set (match_operand:SF 0 "nonimmediate_operand" "")
2544         (match_operand:SF 1 "general_operand" ""))]
2545   ""
2546   "ix86_expand_move (SFmode, operands); DONE;")
2547
2548 (define_insn "*pushsf"
2549   [(set (match_operand:SF 0 "push_operand" "=<,<,<")
2550         (match_operand:SF 1 "general_no_elim_operand" "f,rFm,x"))]
2551   "!TARGET_64BIT"
2552 {
2553   /* Anything else should be already split before reg-stack.  */
2554   gcc_assert (which_alternative == 1);
2555   return "push{l}\t%1";
2556 }
2557   [(set_attr "type" "multi,push,multi")
2558    (set_attr "unit" "i387,*,*")
2559    (set_attr "mode" "SF,SI,SF")])
2560
2561 (define_insn "*pushsf_rex64"
2562   [(set (match_operand:SF 0 "push_operand" "=X,X,X")
2563         (match_operand:SF 1 "nonmemory_no_elim_operand" "f,rF,x"))]
2564   "TARGET_64BIT"
2565 {
2566   /* Anything else should be already split before reg-stack.  */
2567   gcc_assert (which_alternative == 1);
2568   return "push{q}\t%q1";
2569 }
2570   [(set_attr "type" "multi,push,multi")
2571    (set_attr "unit" "i387,*,*")
2572    (set_attr "mode" "SF,DI,SF")])
2573
2574 (define_split
2575   [(set (match_operand:SF 0 "push_operand" "")
2576         (match_operand:SF 1 "memory_operand" ""))]
2577   "reload_completed
2578    && MEM_P (operands[1])
2579    && (operands[2] = find_constant_src (insn))"
2580   [(set (match_dup 0)
2581         (match_dup 2))])
2582
2583
2584 ;; %%% Kill this when call knows how to work this out.
2585 (define_split
2586   [(set (match_operand:SF 0 "push_operand" "")
2587         (match_operand:SF 1 "any_fp_register_operand" ""))]
2588   "!TARGET_64BIT"
2589   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int -4)))
2590    (set (mem:SF (reg:SI SP_REG)) (match_dup 1))])
2591
2592 (define_split
2593   [(set (match_operand:SF 0 "push_operand" "")
2594         (match_operand:SF 1 "any_fp_register_operand" ""))]
2595   "TARGET_64BIT"
2596   [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int -8)))
2597    (set (mem:SF (reg:DI SP_REG)) (match_dup 1))])
2598
2599 (define_insn "*movsf_1"
2600   [(set (match_operand:SF 0 "nonimmediate_operand"
2601           "=f,m,f,r  ,m ,x,x,x ,m,!*y,!m,!*y,?Yi,?r,!*Ym,!r")
2602         (match_operand:SF 1 "general_operand"
2603           "fm,f,G,rmF,Fr,C,x,xm,x,m  ,*y,*y ,r  ,Yi,r   ,*Ym"))]
2604   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
2605    && (reload_in_progress || reload_completed
2606        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
2607        || (!TARGET_SSE_MATH && optimize_size
2608            && standard_80387_constant_p (operands[1]))
2609        || GET_CODE (operands[1]) != CONST_DOUBLE
2610        || memory_operand (operands[0], SFmode))"
2611 {
2612   switch (which_alternative)
2613     {
2614     case 0:
2615     case 1:
2616       return output_387_reg_move (insn, operands);
2617
2618     case 2:
2619       return standard_80387_constant_opcode (operands[1]);
2620
2621     case 3:
2622     case 4:
2623       return "mov{l}\t{%1, %0|%0, %1}";
2624     case 5:
2625       if (get_attr_mode (insn) == MODE_TI)
2626         return "pxor\t%0, %0";
2627       else
2628         return "xorps\t%0, %0";
2629     case 6:
2630       if (get_attr_mode (insn) == MODE_V4SF)
2631         return "movaps\t{%1, %0|%0, %1}";
2632       else
2633         return "movss\t{%1, %0|%0, %1}";
2634     case 7: case 8:
2635       return "movss\t{%1, %0|%0, %1}";
2636
2637     case 9: case 10:
2638     case 12: case 13: case 14: case 15:
2639       return "movd\t{%1, %0|%0, %1}";
2640
2641     case 11:
2642       return "movq\t{%1, %0|%0, %1}";
2643
2644     default:
2645       gcc_unreachable ();
2646     }
2647 }
2648   [(set_attr "type" "fmov,fmov,fmov,imov,imov,sselog1,ssemov,ssemov,ssemov,mmxmov,mmxmov,mmxmov,ssemov,ssemov,mmxmov,mmxmov")
2649    (set (attr "mode")
2650         (cond [(eq_attr "alternative" "3,4,9,10")
2651                  (const_string "SI")
2652                (eq_attr "alternative" "5")
2653                  (if_then_else
2654                    (and (and (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
2655                                  (const_int 0))
2656                              (ne (symbol_ref "TARGET_SSE2")
2657                                  (const_int 0)))
2658                         (eq (symbol_ref "optimize_size")
2659                             (const_int 0)))
2660                    (const_string "TI")
2661                    (const_string "V4SF"))
2662                /* For architectures resolving dependencies on
2663                   whole SSE registers use APS move to break dependency
2664                   chains, otherwise use short move to avoid extra work.
2665
2666                   Do the same for architectures resolving dependencies on
2667                   the parts.  While in DF mode it is better to always handle
2668                   just register parts, the SF mode is different due to lack
2669                   of instructions to load just part of the register.  It is
2670                   better to maintain the whole registers in single format
2671                   to avoid problems on using packed logical operations.  */
2672                (eq_attr "alternative" "6")
2673                  (if_then_else
2674                    (ior (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
2675                             (const_int 0))
2676                         (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
2677                             (const_int 0)))
2678                    (const_string "V4SF")
2679                    (const_string "SF"))
2680                (eq_attr "alternative" "11")
2681                  (const_string "DI")]
2682                (const_string "SF")))])
2683
2684 (define_insn "*swapsf"
2685   [(set (match_operand:SF 0 "fp_register_operand" "+f")
2686         (match_operand:SF 1 "fp_register_operand" "+f"))
2687    (set (match_dup 1)
2688         (match_dup 0))]
2689   "reload_completed || TARGET_80387"
2690 {
2691   if (STACK_TOP_P (operands[0]))
2692     return "fxch\t%1";
2693   else
2694     return "fxch\t%0";
2695 }
2696   [(set_attr "type" "fxch")
2697    (set_attr "mode" "SF")])
2698
2699 (define_expand "movdf"
2700   [(set (match_operand:DF 0 "nonimmediate_operand" "")
2701         (match_operand:DF 1 "general_operand" ""))]
2702   ""
2703   "ix86_expand_move (DFmode, operands); DONE;")
2704
2705 ;; Size of pushdf is 3 (for sub) + 2 (for fstp) + memory operand size.
2706 ;; Size of pushdf using integer instructions is 2+2*memory operand size
2707 ;; On the average, pushdf using integers can be still shorter.  Allow this
2708 ;; pattern for optimize_size too.
2709
2710 (define_insn "*pushdf_nointeger"
2711   [(set (match_operand:DF 0 "push_operand" "=<,<,<,<")
2712         (match_operand:DF 1 "general_no_elim_operand" "f,Fo,*r,Y2"))]
2713   "!TARGET_64BIT && !TARGET_INTEGER_DFMODE_MOVES"
2714 {
2715   /* This insn should be already split before reg-stack.  */
2716   gcc_unreachable ();
2717 }
2718   [(set_attr "type" "multi")
2719    (set_attr "unit" "i387,*,*,*")
2720    (set_attr "mode" "DF,SI,SI,DF")])
2721
2722 (define_insn "*pushdf_integer"
2723   [(set (match_operand:DF 0 "push_operand" "=<,<,<")
2724         (match_operand:DF 1 "general_no_elim_operand" "f,rFo,Y2"))]
2725   "TARGET_64BIT || TARGET_INTEGER_DFMODE_MOVES"
2726 {
2727   /* This insn should be already split before reg-stack.  */
2728   gcc_unreachable ();
2729 }
2730   [(set_attr "type" "multi")
2731    (set_attr "unit" "i387,*,*")
2732    (set_attr "mode" "DF,SI,DF")])
2733
2734 ;; %%% Kill this when call knows how to work this out.
2735 (define_split
2736   [(set (match_operand:DF 0 "push_operand" "")
2737         (match_operand:DF 1 "any_fp_register_operand" ""))]
2738   "!TARGET_64BIT && reload_completed"
2739   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int -8)))
2740    (set (mem:DF (reg:SI SP_REG)) (match_dup 1))]
2741   "")
2742
2743 (define_split
2744   [(set (match_operand:DF 0 "push_operand" "")
2745         (match_operand:DF 1 "any_fp_register_operand" ""))]
2746   "TARGET_64BIT && reload_completed"
2747   [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int -8)))
2748    (set (mem:DF (reg:DI SP_REG)) (match_dup 1))]
2749   "")
2750
2751 (define_split
2752   [(set (match_operand:DF 0 "push_operand" "")
2753         (match_operand:DF 1 "general_operand" ""))]
2754   "reload_completed"
2755   [(const_int 0)]
2756   "ix86_split_long_move (operands); DONE;")
2757
2758 ;; Moving is usually shorter when only FP registers are used. This separate
2759 ;; movdf pattern avoids the use of integer registers for FP operations
2760 ;; when optimizing for size.
2761
2762 (define_insn "*movdf_nointeger"
2763   [(set (match_operand:DF 0 "nonimmediate_operand"
2764                         "=f,m,f,*r  ,o  ,Y2*x,Y2*x,Y2*x ,m  ")
2765         (match_operand:DF 1 "general_operand"
2766                         "fm,f,G,*roF,*Fr,C   ,Y2*x,mY2*x,Y2*x"))]
2767   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
2768    && ((optimize_size || !TARGET_INTEGER_DFMODE_MOVES) && !TARGET_64BIT)
2769    && (reload_in_progress || reload_completed
2770        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
2771        || (!(TARGET_SSE2 && TARGET_SSE_MATH) && optimize_size
2772            && !memory_operand (operands[0], DFmode)
2773            && standard_80387_constant_p (operands[1]))
2774        || GET_CODE (operands[1]) != CONST_DOUBLE
2775        || ((optimize_size
2776             || !TARGET_MEMORY_MISMATCH_STALL
2777             || reload_in_progress || reload_completed)
2778            && memory_operand (operands[0], DFmode)))"
2779 {
2780   switch (which_alternative)
2781     {
2782     case 0:
2783     case 1:
2784       return output_387_reg_move (insn, operands);
2785
2786     case 2:
2787       return standard_80387_constant_opcode (operands[1]);
2788
2789     case 3:
2790     case 4:
2791       return "#";
2792     case 5:
2793       switch (get_attr_mode (insn))
2794         {
2795         case MODE_V4SF:
2796           return "xorps\t%0, %0";
2797         case MODE_V2DF:
2798           return "xorpd\t%0, %0";
2799         case MODE_TI:
2800           return "pxor\t%0, %0";
2801         default:
2802           gcc_unreachable ();
2803         }
2804     case 6:
2805     case 7:
2806     case 8:
2807       switch (get_attr_mode (insn))
2808         {
2809         case MODE_V4SF:
2810           return "movaps\t{%1, %0|%0, %1}";
2811         case MODE_V2DF:
2812           return "movapd\t{%1, %0|%0, %1}";
2813         case MODE_TI:
2814           return "movdqa\t{%1, %0|%0, %1}";
2815         case MODE_DI:
2816           return "movq\t{%1, %0|%0, %1}";
2817         case MODE_DF:
2818           return "movsd\t{%1, %0|%0, %1}";
2819         case MODE_V1DF:
2820           return "movlpd\t{%1, %0|%0, %1}";
2821         case MODE_V2SF:
2822           return "movlps\t{%1, %0|%0, %1}";
2823         default:
2824           gcc_unreachable ();
2825         }
2826
2827     default:
2828       gcc_unreachable ();
2829     }
2830 }
2831   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov")
2832    (set (attr "mode")
2833         (cond [(eq_attr "alternative" "0,1,2")
2834                  (const_string "DF")
2835                (eq_attr "alternative" "3,4")
2836                  (const_string "SI")
2837
2838                /* For SSE1, we have many fewer alternatives.  */
2839                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
2840                  (cond [(eq_attr "alternative" "5,6")
2841                           (const_string "V4SF")
2842                        ]
2843                    (const_string "V2SF"))
2844
2845                /* xorps is one byte shorter.  */
2846                (eq_attr "alternative" "5")
2847                  (cond [(ne (symbol_ref "optimize_size")
2848                             (const_int 0))
2849                           (const_string "V4SF")
2850                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
2851                             (const_int 0))
2852                           (const_string "TI")
2853                        ]
2854                        (const_string "V2DF"))
2855
2856                /* For architectures resolving dependencies on
2857                   whole SSE registers use APD move to break dependency
2858                   chains, otherwise use short move to avoid extra work.
2859
2860                   movaps encodes one byte shorter.  */
2861                (eq_attr "alternative" "6")
2862                  (cond
2863                    [(ne (symbol_ref "optimize_size")
2864                         (const_int 0))
2865                       (const_string "V4SF")
2866                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
2867                         (const_int 0))
2868                       (const_string "V2DF")
2869                    ]
2870                    (const_string "DF"))
2871                /* For architectures resolving dependencies on register
2872                   parts we may avoid extra work to zero out upper part
2873                   of register.  */
2874                (eq_attr "alternative" "7")
2875                  (if_then_else
2876                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
2877                        (const_int 0))
2878                    (const_string "V1DF")
2879                    (const_string "DF"))
2880               ]
2881               (const_string "DF")))])
2882
2883 (define_insn "*movdf_integer_rex64"
2884   [(set (match_operand:DF 0 "nonimmediate_operand"
2885                 "=f,m,f,r  ,m ,Y2*x,Y2*x,Y2*x,m   ,Yi,r ")
2886         (match_operand:DF 1 "general_operand"
2887                 "fm,f,G,rmF,Fr,C   ,Y2*x,m   ,Y2*x,r ,Yi"))]
2888   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))
2889    && (reload_in_progress || reload_completed
2890        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
2891        || (!(TARGET_SSE2 && TARGET_SSE_MATH) && optimize_size
2892            && standard_80387_constant_p (operands[1]))
2893        || GET_CODE (operands[1]) != CONST_DOUBLE
2894        || memory_operand (operands[0], DFmode))"
2895 {
2896   switch (which_alternative)
2897     {
2898     case 0:
2899     case 1:
2900       return output_387_reg_move (insn, operands);
2901
2902     case 2:
2903       return standard_80387_constant_opcode (operands[1]);
2904
2905     case 3:
2906     case 4:
2907       return "#";
2908
2909     case 5:
2910       switch (get_attr_mode (insn))
2911         {
2912         case MODE_V4SF:
2913           return "xorps\t%0, %0";
2914         case MODE_V2DF:
2915           return "xorpd\t%0, %0";
2916         case MODE_TI:
2917           return "pxor\t%0, %0";
2918         default:
2919           gcc_unreachable ();
2920         }
2921     case 6:
2922     case 7:
2923     case 8:
2924       switch (get_attr_mode (insn))
2925         {
2926         case MODE_V4SF:
2927           return "movaps\t{%1, %0|%0, %1}";
2928         case MODE_V2DF:
2929           return "movapd\t{%1, %0|%0, %1}";
2930         case MODE_TI:
2931           return "movdqa\t{%1, %0|%0, %1}";
2932         case MODE_DI:
2933           return "movq\t{%1, %0|%0, %1}";
2934         case MODE_DF:
2935           return "movsd\t{%1, %0|%0, %1}";
2936         case MODE_V1DF:
2937           return "movlpd\t{%1, %0|%0, %1}";
2938         case MODE_V2SF:
2939           return "movlps\t{%1, %0|%0, %1}";
2940         default:
2941           gcc_unreachable ();
2942         }
2943
2944     case 9:
2945     case 10:
2946       return "movd\t{%1, %0|%0, %1}";
2947
2948     default:
2949       gcc_unreachable();
2950     }
2951 }
2952   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov,ssemov,ssemov")
2953    (set (attr "mode")
2954         (cond [(eq_attr "alternative" "0,1,2")
2955                  (const_string "DF")
2956                (eq_attr "alternative" "3,4,9,10")
2957                  (const_string "DI")
2958
2959                /* For SSE1, we have many fewer alternatives.  */
2960                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
2961                  (cond [(eq_attr "alternative" "5,6")
2962                           (const_string "V4SF")
2963                        ]
2964                    (const_string "V2SF"))
2965
2966                /* xorps is one byte shorter.  */
2967                (eq_attr "alternative" "5")
2968                  (cond [(ne (symbol_ref "optimize_size")
2969                             (const_int 0))
2970                           (const_string "V4SF")
2971                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
2972                             (const_int 0))
2973                           (const_string "TI")
2974                        ]
2975                        (const_string "V2DF"))
2976
2977                /* For architectures resolving dependencies on
2978                   whole SSE registers use APD move to break dependency
2979                   chains, otherwise use short move to avoid extra work.
2980
2981                   movaps encodes one byte shorter.  */
2982                (eq_attr "alternative" "6")
2983                  (cond
2984                    [(ne (symbol_ref "optimize_size")
2985                         (const_int 0))
2986                       (const_string "V4SF")
2987                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
2988                         (const_int 0))
2989                       (const_string "V2DF")
2990                    ]
2991                    (const_string "DF"))
2992                /* For architectures resolving dependencies on register
2993                   parts we may avoid extra work to zero out upper part
2994                   of register.  */
2995                (eq_attr "alternative" "7")
2996                  (if_then_else
2997                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
2998                        (const_int 0))
2999                    (const_string "V1DF")
3000                    (const_string "DF"))
3001               ]
3002               (const_string "DF")))])
3003
3004 (define_insn "*movdf_integer"
3005   [(set (match_operand:DF 0 "nonimmediate_operand"
3006                 "=f,m,f,r  ,o ,Y2*x,Y2*x,Y2*x,m   ")
3007         (match_operand:DF 1 "general_operand"
3008                 "fm,f,G,roF,Fr,C   ,Y2*x,m   ,Y2*x"))]
3009   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
3010    && !optimize_size && TARGET_INTEGER_DFMODE_MOVES
3011    && (reload_in_progress || reload_completed
3012        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3013        || (!(TARGET_SSE2 && TARGET_SSE_MATH) && optimize_size
3014            && standard_80387_constant_p (operands[1]))
3015        || GET_CODE (operands[1]) != CONST_DOUBLE
3016        || memory_operand (operands[0], DFmode))"
3017 {
3018   switch (which_alternative)
3019     {
3020     case 0:
3021     case 1:
3022       return output_387_reg_move (insn, operands);
3023
3024     case 2:
3025       return standard_80387_constant_opcode (operands[1]);
3026
3027     case 3:
3028     case 4:
3029       return "#";
3030
3031     case 5:
3032       switch (get_attr_mode (insn))
3033         {
3034         case MODE_V4SF:
3035           return "xorps\t%0, %0";
3036         case MODE_V2DF:
3037           return "xorpd\t%0, %0";
3038         case MODE_TI:
3039           return "pxor\t%0, %0";
3040         default:
3041           gcc_unreachable ();
3042         }
3043     case 6:
3044     case 7:
3045     case 8:
3046       switch (get_attr_mode (insn))
3047         {
3048         case MODE_V4SF:
3049           return "movaps\t{%1, %0|%0, %1}";
3050         case MODE_V2DF:
3051           return "movapd\t{%1, %0|%0, %1}";
3052         case MODE_TI:
3053           return "movdqa\t{%1, %0|%0, %1}";
3054         case MODE_DI:
3055           return "movq\t{%1, %0|%0, %1}";
3056         case MODE_DF:
3057           return "movsd\t{%1, %0|%0, %1}";
3058         case MODE_V1DF:
3059           return "movlpd\t{%1, %0|%0, %1}";
3060         case MODE_V2SF:
3061           return "movlps\t{%1, %0|%0, %1}";
3062         default:
3063           gcc_unreachable ();
3064         }
3065
3066     default:
3067       gcc_unreachable();
3068     }
3069 }
3070   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov")
3071    (set (attr "mode")
3072         (cond [(eq_attr "alternative" "0,1,2")
3073                  (const_string "DF")
3074                (eq_attr "alternative" "3,4")
3075                  (const_string "SI")
3076
3077                /* For SSE1, we have many fewer alternatives.  */
3078                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
3079                  (cond [(eq_attr "alternative" "5,6")
3080                           (const_string "V4SF")
3081                        ]
3082                    (const_string "V2SF"))
3083
3084                /* xorps is one byte shorter.  */
3085                (eq_attr "alternative" "5")
3086                  (cond [(ne (symbol_ref "optimize_size")
3087                             (const_int 0))
3088                           (const_string "V4SF")
3089                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3090                             (const_int 0))
3091                           (const_string "TI")
3092                        ]
3093                        (const_string "V2DF"))
3094
3095                /* For architectures resolving dependencies on
3096                   whole SSE registers use APD move to break dependency
3097                   chains, otherwise use short move to avoid extra work.
3098
3099                   movaps encodes one byte shorter.  */
3100                (eq_attr "alternative" "6")
3101                  (cond
3102                    [(ne (symbol_ref "optimize_size")
3103                         (const_int 0))
3104                       (const_string "V4SF")
3105                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3106                         (const_int 0))
3107                       (const_string "V2DF")
3108                    ]
3109                    (const_string "DF"))
3110                /* For architectures resolving dependencies on register
3111                   parts we may avoid extra work to zero out upper part
3112                   of register.  */
3113                (eq_attr "alternative" "7")
3114                  (if_then_else
3115                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3116                        (const_int 0))
3117                    (const_string "V1DF")
3118                    (const_string "DF"))
3119               ]
3120               (const_string "DF")))])
3121
3122 (define_split
3123   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3124         (match_operand:DF 1 "general_operand" ""))]
3125   "reload_completed
3126    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3127    && ! (ANY_FP_REG_P (operands[0]) ||
3128          (GET_CODE (operands[0]) == SUBREG
3129           && ANY_FP_REG_P (SUBREG_REG (operands[0]))))
3130    && ! (ANY_FP_REG_P (operands[1]) ||
3131          (GET_CODE (operands[1]) == SUBREG
3132           && ANY_FP_REG_P (SUBREG_REG (operands[1]))))"
3133   [(const_int 0)]
3134   "ix86_split_long_move (operands); DONE;")
3135
3136 (define_insn "*swapdf"
3137   [(set (match_operand:DF 0 "fp_register_operand" "+f")
3138         (match_operand:DF 1 "fp_register_operand" "+f"))
3139    (set (match_dup 1)
3140         (match_dup 0))]
3141   "reload_completed || TARGET_80387"
3142 {
3143   if (STACK_TOP_P (operands[0]))
3144     return "fxch\t%1";
3145   else
3146     return "fxch\t%0";
3147 }
3148   [(set_attr "type" "fxch")
3149    (set_attr "mode" "DF")])
3150
3151 (define_expand "movxf"
3152   [(set (match_operand:XF 0 "nonimmediate_operand" "")
3153         (match_operand:XF 1 "general_operand" ""))]
3154   ""
3155   "ix86_expand_move (XFmode, operands); DONE;")
3156
3157 ;; Size of pushdf is 3 (for sub) + 2 (for fstp) + memory operand size.
3158 ;; Size of pushdf using integer instructions is 3+3*memory operand size
3159 ;; Pushing using integer instructions is longer except for constants
3160 ;; and direct memory references.
3161 ;; (assuming that any given constant is pushed only once, but this ought to be
3162 ;;  handled elsewhere).
3163
3164 (define_insn "*pushxf_nointeger"
3165   [(set (match_operand:XF 0 "push_operand" "=X,X,X")
3166         (match_operand:XF 1 "general_no_elim_operand" "f,Fo,*r"))]
3167   "optimize_size"
3168 {
3169   /* This insn should be already split before reg-stack.  */
3170   gcc_unreachable ();
3171 }
3172   [(set_attr "type" "multi")
3173    (set_attr "unit" "i387,*,*")
3174    (set_attr "mode" "XF,SI,SI")])
3175
3176 (define_insn "*pushxf_integer"
3177   [(set (match_operand:XF 0 "push_operand" "=<,<")
3178         (match_operand:XF 1 "general_no_elim_operand" "f,ro"))]
3179   "!optimize_size"
3180 {
3181   /* This insn should be already split before reg-stack.  */
3182   gcc_unreachable ();
3183 }
3184   [(set_attr "type" "multi")
3185    (set_attr "unit" "i387,*")
3186    (set_attr "mode" "XF,SI")])
3187
3188 (define_split
3189   [(set (match_operand 0 "push_operand" "")
3190         (match_operand 1 "general_operand" ""))]
3191   "reload_completed
3192    && (GET_MODE (operands[0]) == XFmode
3193        || GET_MODE (operands[0]) == DFmode)
3194    && !ANY_FP_REG_P (operands[1])"
3195   [(const_int 0)]
3196   "ix86_split_long_move (operands); DONE;")
3197
3198 (define_split
3199   [(set (match_operand:XF 0 "push_operand" "")
3200         (match_operand:XF 1 "any_fp_register_operand" ""))]
3201   "!TARGET_64BIT"
3202   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (match_dup 2)))
3203    (set (mem:XF (reg:SI SP_REG)) (match_dup 1))]
3204   "operands[2] = GEN_INT (TARGET_128BIT_LONG_DOUBLE ? -16 : -12);")
3205
3206 (define_split
3207   [(set (match_operand:XF 0 "push_operand" "")
3208         (match_operand:XF 1 "any_fp_register_operand" ""))]
3209   "TARGET_64BIT"
3210   [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (match_dup 2)))
3211    (set (mem:XF (reg:DI SP_REG)) (match_dup 1))]
3212   "operands[2] = GEN_INT (TARGET_128BIT_LONG_DOUBLE ? -16 : -12);")
3213
3214 ;; Do not use integer registers when optimizing for size
3215 (define_insn "*movxf_nointeger"
3216   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,*r,o")
3217         (match_operand:XF 1 "general_operand" "fm,f,G,*roF,F*r"))]
3218   "optimize_size
3219    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3220    && (reload_in_progress || reload_completed
3221        || (optimize_size && standard_80387_constant_p (operands[1]))
3222        || GET_CODE (operands[1]) != CONST_DOUBLE
3223        || memory_operand (operands[0], XFmode))"
3224 {
3225   switch (which_alternative)
3226     {
3227     case 0:
3228     case 1:
3229       return output_387_reg_move (insn, operands);
3230
3231     case 2:
3232       return standard_80387_constant_opcode (operands[1]);
3233
3234     case 3: case 4:
3235       return "#";
3236     default:
3237       gcc_unreachable ();
3238     }
3239 }
3240   [(set_attr "type" "fmov,fmov,fmov,multi,multi")
3241    (set_attr "mode" "XF,XF,XF,SI,SI")])
3242
3243 (define_insn "*movxf_integer"
3244   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,r,o")
3245         (match_operand:XF 1 "general_operand" "fm,f,G,roF,Fr"))]
3246   "!optimize_size
3247    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3248    && (reload_in_progress || reload_completed
3249        || (optimize_size && standard_80387_constant_p (operands[1]))
3250        || GET_CODE (operands[1]) != CONST_DOUBLE
3251        || memory_operand (operands[0], XFmode))"
3252 {
3253   switch (which_alternative)
3254     {
3255     case 0:
3256     case 1:
3257       return output_387_reg_move (insn, operands);
3258
3259     case 2:
3260       return standard_80387_constant_opcode (operands[1]);
3261
3262     case 3: case 4:
3263       return "#";
3264
3265     default:
3266       gcc_unreachable ();
3267     }
3268 }
3269   [(set_attr "type" "fmov,fmov,fmov,multi,multi")
3270    (set_attr "mode" "XF,XF,XF,SI,SI")])
3271
3272 (define_expand "movtf"
3273   [(set (match_operand:TF 0 "nonimmediate_operand" "")
3274         (match_operand:TF 1 "nonimmediate_operand" ""))]
3275   "TARGET_64BIT"
3276 {
3277   ix86_expand_move (TFmode, operands);
3278   DONE;
3279 })
3280
3281 (define_insn "*movtf_internal"
3282   [(set (match_operand:TF 0 "nonimmediate_operand" "=x,m,x,?r,?o")
3283         (match_operand:TF 1 "general_operand" "xm,x,C,roF,Fr"))]
3284   "TARGET_64BIT
3285    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
3286 {
3287   switch (which_alternative)
3288     {
3289     case 0:
3290     case 1:
3291       if (get_attr_mode (insn) == MODE_V4SF)
3292         return "movaps\t{%1, %0|%0, %1}";
3293       else
3294         return "movdqa\t{%1, %0|%0, %1}";
3295     case 2:
3296       if (get_attr_mode (insn) == MODE_V4SF)
3297         return "xorps\t%0, %0";
3298       else
3299         return "pxor\t%0, %0";
3300     case 3:
3301     case 4:
3302         return "#";
3303     default:
3304       gcc_unreachable ();
3305     }
3306 }
3307   [(set_attr "type" "ssemov,ssemov,sselog1,*,*")
3308    (set (attr "mode")
3309         (cond [(eq_attr "alternative" "0,2")
3310                  (if_then_else
3311                    (ne (symbol_ref "optimize_size")
3312                        (const_int 0))
3313                    (const_string "V4SF")
3314                    (const_string "TI"))
3315                (eq_attr "alternative" "1")
3316                  (if_then_else
3317                    (ior (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
3318                             (const_int 0))
3319                         (ne (symbol_ref "optimize_size")
3320                             (const_int 0)))
3321                    (const_string "V4SF")
3322                    (const_string "TI"))]
3323                (const_string "DI")))])
3324
3325 (define_split
3326   [(set (match_operand 0 "nonimmediate_operand" "")
3327         (match_operand 1 "general_operand" ""))]
3328   "reload_completed
3329    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3330    && GET_MODE (operands[0]) == XFmode
3331    && ! (ANY_FP_REG_P (operands[0]) ||
3332          (GET_CODE (operands[0]) == SUBREG
3333           && ANY_FP_REG_P (SUBREG_REG (operands[0]))))
3334    && ! (ANY_FP_REG_P (operands[1]) ||
3335          (GET_CODE (operands[1]) == SUBREG
3336           && ANY_FP_REG_P (SUBREG_REG (operands[1]))))"
3337   [(const_int 0)]
3338   "ix86_split_long_move (operands); DONE;")
3339
3340 (define_split
3341   [(set (match_operand 0 "register_operand" "")