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