OSDN Git Service

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