OSDN Git Service

* config/i386/i386.md (any_div): New code iterator.
[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 without QImode.
735 (define_mode_iterator SWIM248 [(HI "TARGET_HIMODE_MATH")
736                                SI (DI "TARGET_64BIT")])
737
738 ;; Half mode for double word integer modes.
739 (define_mode_iterator DWIH [(SI "!TARGET_64BIT")
740                             (DI "TARGET_64BIT")])
741
742 ;; Double word integer modes.
743 (define_mode_attr DWI [(SI "DI") (DI "TI")])
744 (define_mode_attr dwi [(SI "di") (DI "ti")])
745
746 ;; Instruction suffix for integer modes.
747 (define_mode_attr imodesuffix [(QI "b") (HI "w") (SI "l") (DI "q")])
748
749 ;; Register class for integer modes.
750 (define_mode_attr r [(QI "q") (HI "r") (SI "r") (DI "r")])
751
752 ;; Immediate operand constraint for integer modes.
753 (define_mode_attr i [(QI "n") (HI "n") (SI "i") (DI "e")])
754
755 ;; General operand constraint for word modes.
756 (define_mode_attr g [(SI "g") (DI "rme")])
757
758 ;; Immediate operand constraint for double integer modes.
759 (define_mode_attr di [(SI "iF") (DI "e")])
760
761 ;; General operand predicate for integer modes.
762 (define_mode_attr general_operand
763         [(QI "general_operand")
764          (HI "general_operand")
765          (SI "general_operand")
766          (DI "x86_64_general_operand")
767          (TI "x86_64_general_operand")])
768
769 ;; SSE and x87 SFmode and DFmode floating point modes
770 (define_mode_iterator MODEF [SF DF])
771
772 ;; All x87 floating point modes
773 (define_mode_iterator X87MODEF [SF DF XF])
774
775 ;; All integer modes handled by x87 fisttp operator.
776 (define_mode_iterator X87MODEI [HI SI DI])
777
778 ;; All integer modes handled by integer x87 operators.
779 (define_mode_iterator X87MODEI12 [HI SI])
780
781 ;; All integer modes handled by SSE cvtts?2si* operators.
782 (define_mode_iterator SSEMODEI24 [SI DI])
783
784 ;; SSE asm suffix for floating point modes
785 (define_mode_attr ssemodefsuffix [(SF "s") (DF "d")])
786
787 ;; SSE vector mode corresponding to a scalar mode
788 (define_mode_attr ssevecmode
789   [(QI "V16QI") (HI "V8HI") (SI "V4SI") (DI "V2DI") (SF "V4SF") (DF "V2DF")])
790
791 ;; Instruction suffix for REX 64bit operators.
792 (define_mode_attr rex64suffix [(SI "") (DI "{q}")])
793
794 ;; This mode iterator allows :P to be used for patterns that operate on
795 ;; pointer-sized quantities.  Exactly one of the two alternatives will match.
796 (define_mode_iterator P [(SI "Pmode == SImode") (DI "Pmode == DImode")])
797 \f
798 ;; Scheduling descriptions
799
800 (include "pentium.md")
801 (include "ppro.md")
802 (include "k6.md")
803 (include "athlon.md")
804 (include "geode.md")
805 (include "atom.md")
806
807 \f
808 ;; Operand and operator predicates and constraints
809
810 (include "predicates.md")
811 (include "constraints.md")
812
813 \f
814 ;; Compare and branch/compare and store instructions.
815
816 (define_expand "cbranchti4"
817   [(set (reg:CC FLAGS_REG)
818         (compare:CC (match_operand:TI 1 "nonimmediate_operand" "")
819                     (match_operand:TI 2 "x86_64_general_operand" "")))
820    (set (pc) (if_then_else
821               (match_operator 0 "comparison_operator"
822                [(reg:CC FLAGS_REG)
823                 (const_int 0)])
824               (label_ref (match_operand 3 "" ""))
825               (pc)))]
826   "TARGET_64BIT"
827 {
828   if (MEM_P (operands[1]) && MEM_P (operands[2]))
829     operands[1] = force_reg (TImode, operands[1]);
830   ix86_compare_op0 = operands[1];
831   ix86_compare_op1 = operands[2];
832   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
833   DONE;
834 })
835
836 (define_expand "cbranchdi4"
837   [(set (reg:CC FLAGS_REG)
838         (compare:CC (match_operand:DI 1 "nonimmediate_operand" "")
839                     (match_operand:DI 2 "x86_64_general_operand" "")))
840    (set (pc) (if_then_else
841               (match_operator 0 "comparison_operator"
842                [(reg:CC FLAGS_REG)
843                 (const_int 0)])
844               (label_ref (match_operand 3 "" ""))
845               (pc)))]
846   ""
847 {
848   if (MEM_P (operands[1]) && MEM_P (operands[2]))
849     operands[1] = force_reg (DImode, operands[1]);
850   ix86_compare_op0 = operands[1];
851   ix86_compare_op1 = operands[2];
852   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
853   DONE;
854 })
855
856 (define_expand "cstoredi4"
857   [(set (reg:CC FLAGS_REG)
858         (compare:CC (match_operand:DI 2 "nonimmediate_operand" "")
859                     (match_operand:DI 3 "x86_64_general_operand" "")))
860    (set (match_operand:QI 0 "register_operand" "")
861               (match_operator 1 "comparison_operator"
862                [(reg:CC FLAGS_REG)
863                 (const_int 0)]))]
864   "TARGET_64BIT"
865 {
866   if (MEM_P (operands[2]) && MEM_P (operands[3]))
867     operands[2] = force_reg (DImode, operands[2]);
868   ix86_compare_op0 = operands[2];
869   ix86_compare_op1 = operands[3];
870   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
871   DONE;
872 })
873
874 (define_expand "cbranchsi4"
875   [(set (reg:CC FLAGS_REG)
876         (compare:CC (match_operand:SI 1 "cmpsi_operand" "")
877                     (match_operand:SI 2 "general_operand" "")))
878    (set (pc) (if_then_else
879               (match_operator 0 "comparison_operator"
880                [(reg:CC FLAGS_REG)
881                 (const_int 0)])
882               (label_ref (match_operand 3 "" ""))
883               (pc)))]
884   ""
885 {
886   if (MEM_P (operands[1]) && MEM_P (operands[2]))
887     operands[1] = force_reg (SImode, operands[1]);
888   ix86_compare_op0 = operands[1];
889   ix86_compare_op1 = operands[2];
890   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
891   DONE;
892 })
893
894 (define_expand "cstoresi4"
895   [(set (reg:CC FLAGS_REG)
896         (compare:CC (match_operand:SI 2 "cmpsi_operand" "")
897                     (match_operand:SI 3 "general_operand" "")))
898    (set (match_operand:QI 0 "register_operand" "")
899               (match_operator 1 "comparison_operator"
900                [(reg:CC FLAGS_REG)
901                 (const_int 0)]))]
902   ""
903 {
904   if (MEM_P (operands[2]) && MEM_P (operands[3]))
905     operands[2] = force_reg (SImode, operands[2]);
906   ix86_compare_op0 = operands[2];
907   ix86_compare_op1 = operands[3];
908   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
909   DONE;
910 })
911
912 (define_expand "cbranchhi4"
913   [(set (reg:CC FLAGS_REG)
914         (compare:CC (match_operand:HI 1 "nonimmediate_operand" "")
915                     (match_operand:HI 2 "general_operand" "")))
916    (set (pc) (if_then_else
917               (match_operator 0 "comparison_operator"
918                [(reg:CC FLAGS_REG)
919                 (const_int 0)])
920               (label_ref (match_operand 3 "" ""))
921               (pc)))]
922   ""
923 {
924   if (MEM_P (operands[1]) && MEM_P (operands[2]))
925     operands[1] = force_reg (HImode, operands[1]);
926   ix86_compare_op0 = operands[1];
927   ix86_compare_op1 = operands[2];
928   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
929   DONE;
930 })
931
932 (define_expand "cstorehi4"
933   [(set (reg:CC FLAGS_REG)
934         (compare:CC (match_operand:HI 2 "nonimmediate_operand" "")
935                     (match_operand:HI 3 "general_operand" "")))
936    (set (match_operand:QI 0 "register_operand" "")
937               (match_operator 1 "comparison_operator"
938                [(reg:CC FLAGS_REG)
939                 (const_int 0)]))]
940   ""
941 {
942   if (MEM_P (operands[2]) && MEM_P (operands[3]))
943     operands[2] = force_reg (HImode, operands[2]);
944   ix86_compare_op0 = operands[2];
945   ix86_compare_op1 = operands[3];
946   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
947   DONE;
948 })
949
950
951 (define_expand "cbranchqi4"
952   [(set (reg:CC FLAGS_REG)
953         (compare:CC (match_operand:QI 1 "nonimmediate_operand" "")
954                     (match_operand:QI 2 "general_operand" "")))
955    (set (pc) (if_then_else
956               (match_operator 0 "comparison_operator"
957                [(reg:CC FLAGS_REG)
958                 (const_int 0)])
959               (label_ref (match_operand 3 "" ""))
960               (pc)))]
961   ""
962 {
963   if (MEM_P (operands[1]) && MEM_P (operands[2]))
964     operands[1] = force_reg (QImode, operands[1]);
965   ix86_compare_op0 = operands[1];
966   ix86_compare_op1 = operands[2];
967   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
968   DONE;
969 })
970
971
972 (define_expand "cstoreqi4"
973   [(set (reg:CC FLAGS_REG)
974         (compare:CC (match_operand:QI 2 "nonimmediate_operand" "")
975                     (match_operand:QI 3 "general_operand" "")))
976    (set (match_operand:QI 0 "register_operand" "")
977               (match_operator 1 "comparison_operator"
978                [(reg:CC FLAGS_REG)
979                 (const_int 0)]))]
980   ""
981 {
982   if (MEM_P (operands[2]) && MEM_P (operands[3]))
983     operands[2] = force_reg (QImode, operands[2]);
984   ix86_compare_op0 = operands[2];
985   ix86_compare_op1 = operands[3];
986   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
987   DONE;
988 })
989
990
991 (define_insn "cmpdi_ccno_1_rex64"
992   [(set (reg FLAGS_REG)
993         (compare (match_operand:DI 0 "nonimmediate_operand" "r,?mr")
994                  (match_operand:DI 1 "const0_operand" "")))]
995   "TARGET_64BIT && ix86_match_ccmode (insn, CCNOmode)"
996   "@
997    test{q}\t%0, %0
998    cmp{q}\t{%1, %0|%0, %1}"
999   [(set_attr "type" "test,icmp")
1000    (set_attr "length_immediate" "0,1")
1001    (set_attr "mode" "DI")])
1002
1003 (define_insn "*cmpdi_minus_1_rex64"
1004   [(set (reg FLAGS_REG)
1005         (compare (minus:DI (match_operand:DI 0 "nonimmediate_operand" "rm,r")
1006                            (match_operand:DI 1 "x86_64_general_operand" "re,mr"))
1007                  (const_int 0)))]
1008   "TARGET_64BIT && ix86_match_ccmode (insn, CCGOCmode)"
1009   "cmp{q}\t{%1, %0|%0, %1}"
1010   [(set_attr "type" "icmp")
1011    (set_attr "mode" "DI")])
1012
1013 (define_expand "cmpdi_1_rex64"
1014   [(set (reg:CC FLAGS_REG)
1015         (compare:CC (match_operand:DI 0 "nonimmediate_operand" "")
1016                     (match_operand:DI 1 "general_operand" "")))]
1017   "TARGET_64BIT"
1018   "")
1019
1020 (define_insn "cmpdi_1_insn_rex64"
1021   [(set (reg FLAGS_REG)
1022         (compare (match_operand:DI 0 "nonimmediate_operand" "mr,r")
1023                  (match_operand:DI 1 "x86_64_general_operand" "re,mr")))]
1024   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1025   "cmp{q}\t{%1, %0|%0, %1}"
1026   [(set_attr "type" "icmp")
1027    (set_attr "mode" "DI")])
1028
1029
1030 (define_insn "*cmpsi_ccno_1"
1031   [(set (reg FLAGS_REG)
1032         (compare (match_operand:SI 0 "nonimmediate_operand" "r,?mr")
1033                  (match_operand:SI 1 "const0_operand" "")))]
1034   "ix86_match_ccmode (insn, CCNOmode)"
1035   "@
1036    test{l}\t%0, %0
1037    cmp{l}\t{%1, %0|%0, %1}"
1038   [(set_attr "type" "test,icmp")
1039    (set_attr "length_immediate" "0,1")
1040    (set_attr "mode" "SI")])
1041
1042 (define_insn "*cmpsi_minus_1"
1043   [(set (reg FLAGS_REG)
1044         (compare (minus:SI (match_operand:SI 0 "nonimmediate_operand" "rm,r")
1045                            (match_operand:SI 1 "general_operand" "ri,mr"))
1046                  (const_int 0)))]
1047   "ix86_match_ccmode (insn, CCGOCmode)"
1048   "cmp{l}\t{%1, %0|%0, %1}"
1049   [(set_attr "type" "icmp")
1050    (set_attr "mode" "SI")])
1051
1052 (define_expand "cmpsi_1"
1053   [(set (reg:CC FLAGS_REG)
1054         (compare:CC (match_operand:SI 0 "nonimmediate_operand" "")
1055                     (match_operand:SI 1 "general_operand" "")))]
1056   ""
1057   "")
1058
1059 (define_insn "*cmpsi_1_insn"
1060   [(set (reg FLAGS_REG)
1061         (compare (match_operand:SI 0 "nonimmediate_operand" "rm,r")
1062                  (match_operand:SI 1 "general_operand" "ri,mr")))]
1063   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
1064     && ix86_match_ccmode (insn, CCmode)"
1065   "cmp{l}\t{%1, %0|%0, %1}"
1066   [(set_attr "type" "icmp")
1067    (set_attr "mode" "SI")])
1068
1069 (define_insn "*cmphi_ccno_1"
1070   [(set (reg FLAGS_REG)
1071         (compare (match_operand:HI 0 "nonimmediate_operand" "r,?mr")
1072                  (match_operand:HI 1 "const0_operand" "")))]
1073   "ix86_match_ccmode (insn, CCNOmode)"
1074   "@
1075    test{w}\t%0, %0
1076    cmp{w}\t{%1, %0|%0, %1}"
1077   [(set_attr "type" "test,icmp")
1078    (set_attr "length_immediate" "0,1")
1079    (set_attr "mode" "HI")])
1080
1081 (define_insn "*cmphi_minus_1"
1082   [(set (reg FLAGS_REG)
1083         (compare (minus:HI (match_operand:HI 0 "nonimmediate_operand" "rm,r")
1084                            (match_operand:HI 1 "general_operand" "rn,mr"))
1085                  (const_int 0)))]
1086   "ix86_match_ccmode (insn, CCGOCmode)"
1087   "cmp{w}\t{%1, %0|%0, %1}"
1088   [(set_attr "type" "icmp")
1089    (set_attr "mode" "HI")])
1090
1091 (define_insn "*cmphi_1"
1092   [(set (reg FLAGS_REG)
1093         (compare (match_operand:HI 0 "nonimmediate_operand" "rm,r")
1094                  (match_operand:HI 1 "general_operand" "rn,mr")))]
1095   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
1096    && ix86_match_ccmode (insn, CCmode)"
1097   "cmp{w}\t{%1, %0|%0, %1}"
1098   [(set_attr "type" "icmp")
1099    (set_attr "mode" "HI")])
1100
1101 (define_insn "*cmpqi_ccno_1"
1102   [(set (reg FLAGS_REG)
1103         (compare (match_operand:QI 0 "nonimmediate_operand" "q,?mq")
1104                  (match_operand:QI 1 "const0_operand" "")))]
1105   "ix86_match_ccmode (insn, CCNOmode)"
1106   "@
1107    test{b}\t%0, %0
1108    cmp{b}\t{$0, %0|%0, 0}"
1109   [(set_attr "type" "test,icmp")
1110    (set_attr "length_immediate" "0,1")
1111    (set_attr "mode" "QI")])
1112
1113 (define_insn "*cmpqi_1"
1114   [(set (reg FLAGS_REG)
1115         (compare (match_operand:QI 0 "nonimmediate_operand" "qm,q")
1116                  (match_operand:QI 1 "general_operand" "qn,mq")))]
1117   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
1118     && ix86_match_ccmode (insn, CCmode)"
1119   "cmp{b}\t{%1, %0|%0, %1}"
1120   [(set_attr "type" "icmp")
1121    (set_attr "mode" "QI")])
1122
1123 (define_insn "*cmpqi_minus_1"
1124   [(set (reg FLAGS_REG)
1125         (compare (minus:QI (match_operand:QI 0 "nonimmediate_operand" "qm,q")
1126                            (match_operand:QI 1 "general_operand" "qn,mq"))
1127                  (const_int 0)))]
1128   "ix86_match_ccmode (insn, CCGOCmode)"
1129   "cmp{b}\t{%1, %0|%0, %1}"
1130   [(set_attr "type" "icmp")
1131    (set_attr "mode" "QI")])
1132
1133 (define_insn "*cmpqi_ext_1"
1134   [(set (reg FLAGS_REG)
1135         (compare
1136           (match_operand:QI 0 "general_operand" "Qm")
1137           (subreg:QI
1138             (zero_extract:SI
1139               (match_operand 1 "ext_register_operand" "Q")
1140               (const_int 8)
1141               (const_int 8)) 0)))]
1142   "!TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1143   "cmp{b}\t{%h1, %0|%0, %h1}"
1144   [(set_attr "type" "icmp")
1145    (set_attr "mode" "QI")])
1146
1147 (define_insn "*cmpqi_ext_1_rex64"
1148   [(set (reg FLAGS_REG)
1149         (compare
1150           (match_operand:QI 0 "register_operand" "Q")
1151           (subreg:QI
1152             (zero_extract:SI
1153               (match_operand 1 "ext_register_operand" "Q")
1154               (const_int 8)
1155               (const_int 8)) 0)))]
1156   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1157   "cmp{b}\t{%h1, %0|%0, %h1}"
1158   [(set_attr "type" "icmp")
1159    (set_attr "mode" "QI")])
1160
1161 (define_insn "*cmpqi_ext_2"
1162   [(set (reg FLAGS_REG)
1163         (compare
1164           (subreg:QI
1165             (zero_extract:SI
1166               (match_operand 0 "ext_register_operand" "Q")
1167               (const_int 8)
1168               (const_int 8)) 0)
1169           (match_operand:QI 1 "const0_operand" "")))]
1170   "ix86_match_ccmode (insn, CCNOmode)"
1171   "test{b}\t%h0, %h0"
1172   [(set_attr "type" "test")
1173    (set_attr "length_immediate" "0")
1174    (set_attr "mode" "QI")])
1175
1176 (define_expand "cmpqi_ext_3"
1177   [(set (reg:CC FLAGS_REG)
1178         (compare:CC
1179           (subreg:QI
1180             (zero_extract:SI
1181               (match_operand 0 "ext_register_operand" "")
1182               (const_int 8)
1183               (const_int 8)) 0)
1184           (match_operand:QI 1 "general_operand" "")))]
1185   ""
1186   "")
1187
1188 (define_insn "cmpqi_ext_3_insn"
1189   [(set (reg FLAGS_REG)
1190         (compare
1191           (subreg:QI
1192             (zero_extract:SI
1193               (match_operand 0 "ext_register_operand" "Q")
1194               (const_int 8)
1195               (const_int 8)) 0)
1196           (match_operand:QI 1 "general_operand" "Qmn")))]
1197   "!TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1198   "cmp{b}\t{%1, %h0|%h0, %1}"
1199   [(set_attr "type" "icmp")
1200    (set_attr "modrm" "1")
1201    (set_attr "mode" "QI")])
1202
1203 (define_insn "cmpqi_ext_3_insn_rex64"
1204   [(set (reg FLAGS_REG)
1205         (compare
1206           (subreg:QI
1207             (zero_extract:SI
1208               (match_operand 0 "ext_register_operand" "Q")
1209               (const_int 8)
1210               (const_int 8)) 0)
1211           (match_operand:QI 1 "nonmemory_operand" "Qn")))]
1212   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1213   "cmp{b}\t{%1, %h0|%h0, %1}"
1214   [(set_attr "type" "icmp")
1215    (set_attr "modrm" "1")
1216    (set_attr "mode" "QI")])
1217
1218 (define_insn "*cmpqi_ext_4"
1219   [(set (reg FLAGS_REG)
1220         (compare
1221           (subreg:QI
1222             (zero_extract:SI
1223               (match_operand 0 "ext_register_operand" "Q")
1224               (const_int 8)
1225               (const_int 8)) 0)
1226           (subreg:QI
1227             (zero_extract:SI
1228               (match_operand 1 "ext_register_operand" "Q")
1229               (const_int 8)
1230               (const_int 8)) 0)))]
1231   "ix86_match_ccmode (insn, CCmode)"
1232   "cmp{b}\t{%h1, %h0|%h0, %h1}"
1233   [(set_attr "type" "icmp")
1234    (set_attr "mode" "QI")])
1235
1236 ;; These implement float point compares.
1237 ;; %%% See if we can get away with VOIDmode operands on the actual insns,
1238 ;; which would allow mix and match FP modes on the compares.  Which is what
1239 ;; the old patterns did, but with many more of them.
1240
1241 (define_expand "cbranchxf4"
1242   [(set (reg:CC FLAGS_REG)
1243         (compare:CC (match_operand:XF 1 "nonmemory_operand" "")
1244                     (match_operand:XF 2 "nonmemory_operand" "")))
1245    (set (pc) (if_then_else
1246               (match_operator 0 "ix86_fp_comparison_operator"
1247                [(reg:CC FLAGS_REG)
1248                 (const_int 0)])
1249               (label_ref (match_operand 3 "" ""))
1250               (pc)))]
1251   "TARGET_80387"
1252 {
1253   ix86_compare_op0 = operands[1];
1254   ix86_compare_op1 = operands[2];
1255   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
1256   DONE;
1257 })
1258
1259 (define_expand "cstorexf4"
1260   [(set (reg:CC FLAGS_REG)
1261         (compare:CC (match_operand:XF 2 "nonmemory_operand" "")
1262                     (match_operand:XF 3 "nonmemory_operand" "")))
1263    (set (match_operand:QI 0 "register_operand" "")
1264               (match_operator 1 "ix86_fp_comparison_operator"
1265                [(reg:CC FLAGS_REG)
1266                 (const_int 0)]))]
1267   "TARGET_80387"
1268 {
1269   ix86_compare_op0 = operands[2];
1270   ix86_compare_op1 = operands[3];
1271   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
1272   DONE;
1273 })
1274
1275 (define_expand "cbranch<mode>4"
1276   [(set (reg:CC FLAGS_REG)
1277         (compare:CC (match_operand:MODEF 1 "cmp_fp_expander_operand" "")
1278                     (match_operand:MODEF 2 "cmp_fp_expander_operand" "")))
1279    (set (pc) (if_then_else
1280               (match_operator 0 "ix86_fp_comparison_operator"
1281                [(reg:CC FLAGS_REG)
1282                 (const_int 0)])
1283               (label_ref (match_operand 3 "" ""))
1284               (pc)))]
1285   "TARGET_80387 || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH)"
1286 {
1287   ix86_compare_op0 = operands[1];
1288   ix86_compare_op1 = operands[2];
1289   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
1290   DONE;
1291 })
1292
1293 (define_expand "cstore<mode>4"
1294   [(set (reg:CC FLAGS_REG)
1295         (compare:CC (match_operand:MODEF 2 "cmp_fp_expander_operand" "")
1296                     (match_operand:MODEF 3 "cmp_fp_expander_operand" "")))
1297    (set (match_operand:QI 0 "register_operand" "")
1298               (match_operator 1 "ix86_fp_comparison_operator"
1299                [(reg:CC FLAGS_REG)
1300                 (const_int 0)]))]
1301   "TARGET_80387 || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH)"
1302 {
1303   ix86_compare_op0 = operands[2];
1304   ix86_compare_op1 = operands[3];
1305   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
1306   DONE;
1307 })
1308
1309 (define_expand "cbranchcc4"
1310   [(set (pc) (if_then_else
1311               (match_operator 0 "comparison_operator"
1312                [(match_operand 1 "flags_reg_operand" "")
1313                 (match_operand 2 "const0_operand" "")])
1314               (label_ref (match_operand 3 "" ""))
1315               (pc)))]
1316   ""
1317 {
1318   ix86_compare_op0 = operands[1];
1319   ix86_compare_op1 = operands[2];
1320   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
1321   DONE;
1322 })
1323
1324 (define_expand "cstorecc4"
1325   [(set (match_operand:QI 0 "register_operand" "")
1326               (match_operator 1 "comparison_operator"
1327                [(match_operand 2 "flags_reg_operand" "")
1328                 (match_operand 3 "const0_operand" "")]))]
1329   ""
1330 {
1331   ix86_compare_op0 = operands[2];
1332   ix86_compare_op1 = operands[3];
1333   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
1334   DONE;
1335 })
1336
1337
1338 ;; FP compares, step 1:
1339 ;; Set the FP condition codes.
1340 ;;
1341 ;; CCFPmode     compare with exceptions
1342 ;; CCFPUmode    compare with no exceptions
1343
1344 ;; We may not use "#" to split and emit these, since the REG_DEAD notes
1345 ;; used to manage the reg stack popping would not be preserved.
1346
1347 (define_insn "*cmpfp_0"
1348   [(set (match_operand:HI 0 "register_operand" "=a")
1349         (unspec:HI
1350           [(compare:CCFP
1351              (match_operand 1 "register_operand" "f")
1352              (match_operand 2 "const0_operand" ""))]
1353         UNSPEC_FNSTSW))]
1354   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1355    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1356   "* return output_fp_compare (insn, operands, 0, 0);"
1357   [(set_attr "type" "multi")
1358    (set_attr "unit" "i387")
1359    (set (attr "mode")
1360      (cond [(match_operand:SF 1 "" "")
1361               (const_string "SF")
1362             (match_operand:DF 1 "" "")
1363               (const_string "DF")
1364            ]
1365            (const_string "XF")))])
1366
1367 (define_insn_and_split "*cmpfp_0_cc"
1368   [(set (reg:CCFP FLAGS_REG)
1369         (compare:CCFP
1370           (match_operand 1 "register_operand" "f")
1371           (match_operand 2 "const0_operand" "")))
1372    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1373   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1374    && TARGET_SAHF && !TARGET_CMOVE
1375    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1376   "#"
1377   "&& reload_completed"
1378   [(set (match_dup 0)
1379         (unspec:HI
1380           [(compare:CCFP (match_dup 1)(match_dup 2))]
1381         UNSPEC_FNSTSW))
1382    (set (reg:CC FLAGS_REG)
1383         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1384   ""
1385   [(set_attr "type" "multi")
1386    (set_attr "unit" "i387")
1387    (set (attr "mode")
1388      (cond [(match_operand:SF 1 "" "")
1389               (const_string "SF")
1390             (match_operand:DF 1 "" "")
1391               (const_string "DF")
1392            ]
1393            (const_string "XF")))])
1394
1395 (define_insn "*cmpfp_xf"
1396   [(set (match_operand:HI 0 "register_operand" "=a")
1397         (unspec:HI
1398           [(compare:CCFP
1399              (match_operand:XF 1 "register_operand" "f")
1400              (match_operand:XF 2 "register_operand" "f"))]
1401           UNSPEC_FNSTSW))]
1402   "TARGET_80387"
1403   "* return output_fp_compare (insn, operands, 0, 0);"
1404   [(set_attr "type" "multi")
1405    (set_attr "unit" "i387")
1406    (set_attr "mode" "XF")])
1407
1408 (define_insn_and_split "*cmpfp_xf_cc"
1409   [(set (reg:CCFP FLAGS_REG)
1410         (compare:CCFP
1411           (match_operand:XF 1 "register_operand" "f")
1412           (match_operand:XF 2 "register_operand" "f")))
1413    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1414   "TARGET_80387
1415    && TARGET_SAHF && !TARGET_CMOVE"
1416   "#"
1417   "&& reload_completed"
1418   [(set (match_dup 0)
1419         (unspec:HI
1420           [(compare:CCFP (match_dup 1)(match_dup 2))]
1421         UNSPEC_FNSTSW))
1422    (set (reg:CC FLAGS_REG)
1423         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1424   ""
1425   [(set_attr "type" "multi")
1426    (set_attr "unit" "i387")
1427    (set_attr "mode" "XF")])
1428
1429 (define_insn "*cmpfp_<mode>"
1430   [(set (match_operand:HI 0 "register_operand" "=a")
1431         (unspec:HI
1432           [(compare:CCFP
1433              (match_operand:MODEF 1 "register_operand" "f")
1434              (match_operand:MODEF 2 "nonimmediate_operand" "fm"))]
1435           UNSPEC_FNSTSW))]
1436   "TARGET_80387"
1437   "* return output_fp_compare (insn, operands, 0, 0);"
1438   [(set_attr "type" "multi")
1439    (set_attr "unit" "i387")
1440    (set_attr "mode" "<MODE>")])
1441
1442 (define_insn_and_split "*cmpfp_<mode>_cc"
1443   [(set (reg:CCFP FLAGS_REG)
1444         (compare:CCFP
1445           (match_operand:MODEF 1 "register_operand" "f")
1446           (match_operand:MODEF 2 "nonimmediate_operand" "fm")))
1447    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1448   "TARGET_80387
1449    && TARGET_SAHF && !TARGET_CMOVE"
1450   "#"
1451   "&& reload_completed"
1452   [(set (match_dup 0)
1453         (unspec:HI
1454           [(compare:CCFP (match_dup 1)(match_dup 2))]
1455         UNSPEC_FNSTSW))
1456    (set (reg:CC FLAGS_REG)
1457         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1458   ""
1459   [(set_attr "type" "multi")
1460    (set_attr "unit" "i387")
1461    (set_attr "mode" "<MODE>")])
1462
1463 (define_insn "*cmpfp_u"
1464   [(set (match_operand:HI 0 "register_operand" "=a")
1465         (unspec:HI
1466           [(compare:CCFPU
1467              (match_operand 1 "register_operand" "f")
1468              (match_operand 2 "register_operand" "f"))]
1469           UNSPEC_FNSTSW))]
1470   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1471    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1472   "* return output_fp_compare (insn, operands, 0, 1);"
1473   [(set_attr "type" "multi")
1474    (set_attr "unit" "i387")
1475    (set (attr "mode")
1476      (cond [(match_operand:SF 1 "" "")
1477               (const_string "SF")
1478             (match_operand:DF 1 "" "")
1479               (const_string "DF")
1480            ]
1481            (const_string "XF")))])
1482
1483 (define_insn_and_split "*cmpfp_u_cc"
1484   [(set (reg:CCFPU FLAGS_REG)
1485         (compare:CCFPU
1486           (match_operand 1 "register_operand" "f")
1487           (match_operand 2 "register_operand" "f")))
1488    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1489   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1490    && TARGET_SAHF && !TARGET_CMOVE
1491    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1492   "#"
1493   "&& reload_completed"
1494   [(set (match_dup 0)
1495         (unspec:HI
1496           [(compare:CCFPU (match_dup 1)(match_dup 2))]
1497         UNSPEC_FNSTSW))
1498    (set (reg:CC FLAGS_REG)
1499         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1500   ""
1501   [(set_attr "type" "multi")
1502    (set_attr "unit" "i387")
1503    (set (attr "mode")
1504      (cond [(match_operand:SF 1 "" "")
1505               (const_string "SF")
1506             (match_operand:DF 1 "" "")
1507               (const_string "DF")
1508            ]
1509            (const_string "XF")))])
1510
1511 (define_insn "*cmpfp_<mode>"
1512   [(set (match_operand:HI 0 "register_operand" "=a")
1513         (unspec:HI
1514           [(compare:CCFP
1515              (match_operand 1 "register_operand" "f")
1516              (match_operator 3 "float_operator"
1517                [(match_operand:X87MODEI12 2 "memory_operand" "m")]))]
1518           UNSPEC_FNSTSW))]
1519   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1520    && (TARGET_USE_<MODE>MODE_FIOP || optimize_function_for_size_p (cfun))
1521    && (GET_MODE (operands [3]) == GET_MODE (operands[1]))"
1522   "* return output_fp_compare (insn, operands, 0, 0);"
1523   [(set_attr "type" "multi")
1524    (set_attr "unit" "i387")
1525    (set_attr "fp_int_src" "true")
1526    (set_attr "mode" "<MODE>")])
1527
1528 (define_insn_and_split "*cmpfp_<mode>_cc"
1529   [(set (reg:CCFP FLAGS_REG)
1530         (compare:CCFP
1531           (match_operand 1 "register_operand" "f")
1532           (match_operator 3 "float_operator"
1533             [(match_operand:X87MODEI12 2 "memory_operand" "m")])))
1534    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1535   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1536    && TARGET_SAHF && !TARGET_CMOVE
1537    && (TARGET_USE_<MODE>MODE_FIOP || optimize_function_for_size_p (cfun))
1538    && (GET_MODE (operands [3]) == GET_MODE (operands[1]))"
1539   "#"
1540   "&& reload_completed"
1541   [(set (match_dup 0)
1542         (unspec:HI
1543           [(compare:CCFP
1544              (match_dup 1)
1545              (match_op_dup 3 [(match_dup 2)]))]
1546         UNSPEC_FNSTSW))
1547    (set (reg:CC FLAGS_REG)
1548         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1549   ""
1550   [(set_attr "type" "multi")
1551    (set_attr "unit" "i387")
1552    (set_attr "fp_int_src" "true")
1553    (set_attr "mode" "<MODE>")])
1554
1555 ;; FP compares, step 2
1556 ;; Move the fpsw to ax.
1557
1558 (define_insn "x86_fnstsw_1"
1559   [(set (match_operand:HI 0 "register_operand" "=a")
1560         (unspec:HI [(reg:CCFP FPSR_REG)] UNSPEC_FNSTSW))]
1561   "TARGET_80387"
1562   "fnstsw\t%0"
1563   [(set (attr "length") (symbol_ref "ix86_attr_length_address_default (insn) + 2"))
1564    (set_attr "mode" "SI")
1565    (set_attr "unit" "i387")])
1566
1567 ;; FP compares, step 3
1568 ;; Get ax into flags, general case.
1569
1570 (define_insn "x86_sahf_1"
1571   [(set (reg:CC FLAGS_REG)
1572         (unspec:CC [(match_operand:HI 0 "register_operand" "a")]
1573                    UNSPEC_SAHF))]
1574   "TARGET_SAHF"
1575 {
1576 #ifdef HAVE_AS_IX86_SAHF
1577   return "sahf";
1578 #else
1579   return ASM_BYTE "0x9e";
1580 #endif
1581 }
1582   [(set_attr "length" "1")
1583    (set_attr "athlon_decode" "vector")
1584    (set_attr "amdfam10_decode" "direct")
1585    (set_attr "mode" "SI")])
1586
1587 ;; Pentium Pro can do steps 1 through 3 in one go.
1588 ;; comi*, ucomi*, fcomi*, ficomi*,fucomi* (i387 instructions set condition codes)
1589 (define_insn "*cmpfp_i_mixed"
1590   [(set (reg:CCFP FLAGS_REG)
1591         (compare:CCFP (match_operand 0 "register_operand" "f,x")
1592                       (match_operand 1 "nonimmediate_operand" "f,xm")))]
1593   "TARGET_MIX_SSE_I387
1594    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1595    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1596   "* return output_fp_compare (insn, operands, 1, 0);"
1597   [(set_attr "type" "fcmp,ssecomi")
1598    (set_attr "prefix" "orig,maybe_vex")
1599    (set (attr "mode")
1600      (if_then_else (match_operand:SF 1 "" "")
1601         (const_string "SF")
1602         (const_string "DF")))
1603    (set (attr "prefix_rep")
1604         (if_then_else (eq_attr "type" "ssecomi")
1605                       (const_string "0")
1606                       (const_string "*")))
1607    (set (attr "prefix_data16")
1608         (cond [(eq_attr "type" "fcmp")
1609                  (const_string "*")
1610                (eq_attr "mode" "DF")
1611                  (const_string "1")
1612               ]
1613               (const_string "0")))
1614    (set_attr "athlon_decode" "vector")
1615    (set_attr "amdfam10_decode" "direct")])
1616
1617 (define_insn "*cmpfp_i_sse"
1618   [(set (reg:CCFP FLAGS_REG)
1619         (compare:CCFP (match_operand 0 "register_operand" "x")
1620                       (match_operand 1 "nonimmediate_operand" "xm")))]
1621   "TARGET_SSE_MATH
1622    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1623    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1624   "* return output_fp_compare (insn, operands, 1, 0);"
1625   [(set_attr "type" "ssecomi")
1626    (set_attr "prefix" "maybe_vex")
1627    (set (attr "mode")
1628      (if_then_else (match_operand:SF 1 "" "")
1629         (const_string "SF")
1630         (const_string "DF")))
1631    (set_attr "prefix_rep" "0")
1632    (set (attr "prefix_data16")
1633         (if_then_else (eq_attr "mode" "DF")
1634                       (const_string "1")
1635                       (const_string "0")))
1636    (set_attr "athlon_decode" "vector")
1637    (set_attr "amdfam10_decode" "direct")])
1638
1639 (define_insn "*cmpfp_i_i387"
1640   [(set (reg:CCFP FLAGS_REG)
1641         (compare:CCFP (match_operand 0 "register_operand" "f")
1642                       (match_operand 1 "register_operand" "f")))]
1643   "X87_FLOAT_MODE_P (GET_MODE (operands[0]))
1644    && TARGET_CMOVE
1645    && !(SSE_FLOAT_MODE_P (GET_MODE (operands[0])) && TARGET_SSE_MATH)
1646    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1647   "* return output_fp_compare (insn, operands, 1, 0);"
1648   [(set_attr "type" "fcmp")
1649    (set (attr "mode")
1650      (cond [(match_operand:SF 1 "" "")
1651               (const_string "SF")
1652             (match_operand:DF 1 "" "")
1653               (const_string "DF")
1654            ]
1655            (const_string "XF")))
1656    (set_attr "athlon_decode" "vector")
1657    (set_attr "amdfam10_decode" "direct")])
1658
1659 (define_insn "*cmpfp_iu_mixed"
1660   [(set (reg:CCFPU FLAGS_REG)
1661         (compare:CCFPU (match_operand 0 "register_operand" "f,x")
1662                        (match_operand 1 "nonimmediate_operand" "f,xm")))]
1663   "TARGET_MIX_SSE_I387
1664    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1665    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1666   "* return output_fp_compare (insn, operands, 1, 1);"
1667   [(set_attr "type" "fcmp,ssecomi")
1668    (set_attr "prefix" "orig,maybe_vex")
1669    (set (attr "mode")
1670      (if_then_else (match_operand:SF 1 "" "")
1671         (const_string "SF")
1672         (const_string "DF")))
1673    (set (attr "prefix_rep")
1674         (if_then_else (eq_attr "type" "ssecomi")
1675                       (const_string "0")
1676                       (const_string "*")))
1677    (set (attr "prefix_data16")
1678         (cond [(eq_attr "type" "fcmp")
1679                  (const_string "*")
1680                (eq_attr "mode" "DF")
1681                  (const_string "1")
1682               ]
1683               (const_string "0")))
1684    (set_attr "athlon_decode" "vector")
1685    (set_attr "amdfam10_decode" "direct")])
1686
1687 (define_insn "*cmpfp_iu_sse"
1688   [(set (reg:CCFPU FLAGS_REG)
1689         (compare:CCFPU (match_operand 0 "register_operand" "x")
1690                        (match_operand 1 "nonimmediate_operand" "xm")))]
1691   "TARGET_SSE_MATH
1692    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1693    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1694   "* return output_fp_compare (insn, operands, 1, 1);"
1695   [(set_attr "type" "ssecomi")
1696    (set_attr "prefix" "maybe_vex")
1697    (set (attr "mode")
1698      (if_then_else (match_operand:SF 1 "" "")
1699         (const_string "SF")
1700         (const_string "DF")))
1701    (set_attr "prefix_rep" "0")
1702    (set (attr "prefix_data16")
1703         (if_then_else (eq_attr "mode" "DF")
1704                       (const_string "1")
1705                       (const_string "0")))
1706    (set_attr "athlon_decode" "vector")
1707    (set_attr "amdfam10_decode" "direct")])
1708
1709 (define_insn "*cmpfp_iu_387"
1710   [(set (reg:CCFPU FLAGS_REG)
1711         (compare:CCFPU (match_operand 0 "register_operand" "f")
1712                        (match_operand 1 "register_operand" "f")))]
1713   "X87_FLOAT_MODE_P (GET_MODE (operands[0]))
1714    && TARGET_CMOVE
1715    && !(SSE_FLOAT_MODE_P (GET_MODE (operands[0])) && TARGET_SSE_MATH)
1716    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1717   "* return output_fp_compare (insn, operands, 1, 1);"
1718   [(set_attr "type" "fcmp")
1719    (set (attr "mode")
1720      (cond [(match_operand:SF 1 "" "")
1721               (const_string "SF")
1722             (match_operand:DF 1 "" "")
1723               (const_string "DF")
1724            ]
1725            (const_string "XF")))
1726    (set_attr "athlon_decode" "vector")
1727    (set_attr "amdfam10_decode" "direct")])
1728 \f
1729 ;; Move instructions.
1730
1731 ;; General case of fullword move.
1732
1733 (define_expand "movsi"
1734   [(set (match_operand:SI 0 "nonimmediate_operand" "")
1735         (match_operand:SI 1 "general_operand" ""))]
1736   ""
1737   "ix86_expand_move (SImode, operands); DONE;")
1738
1739 ;; Push/pop instructions.  They are separate since autoinc/dec is not a
1740 ;; general_operand.
1741 ;;
1742 ;; %%% We don't use a post-inc memory reference because x86 is not a
1743 ;; general AUTO_INC_DEC host, which impacts how it is treated in flow.
1744 ;; Changing this impacts compiler performance on other non-AUTO_INC_DEC
1745 ;; targets without our curiosities, and it is just as easy to represent
1746 ;; this differently.
1747
1748 (define_insn "*pushsi2"
1749   [(set (match_operand:SI 0 "push_operand" "=<")
1750         (match_operand:SI 1 "general_no_elim_operand" "ri*m"))]
1751   "!TARGET_64BIT"
1752   "push{l}\t%1"
1753   [(set_attr "type" "push")
1754    (set_attr "mode" "SI")])
1755
1756 ;; For 64BIT abi we always round up to 8 bytes.
1757 (define_insn "*pushsi2_rex64"
1758   [(set (match_operand:SI 0 "push_operand" "=X")
1759         (match_operand:SI 1 "nonmemory_no_elim_operand" "ri"))]
1760   "TARGET_64BIT"
1761   "push{q}\t%q1"
1762   [(set_attr "type" "push")
1763    (set_attr "mode" "SI")])
1764
1765 (define_insn "*pushsi2_prologue"
1766   [(set (match_operand:SI 0 "push_operand" "=<")
1767         (match_operand:SI 1 "general_no_elim_operand" "ri*m"))
1768    (clobber (mem:BLK (scratch)))]
1769   "!TARGET_64BIT"
1770   "push{l}\t%1"
1771   [(set_attr "type" "push")
1772    (set_attr "mode" "SI")])
1773
1774 (define_insn "*popsi1_epilogue"
1775   [(set (match_operand:SI 0 "nonimmediate_operand" "=r*m")
1776         (mem:SI (reg:SI SP_REG)))
1777    (set (reg:SI SP_REG)
1778         (plus:SI (reg:SI SP_REG) (const_int 4)))
1779    (clobber (mem:BLK (scratch)))]
1780   "!TARGET_64BIT"
1781   "pop{l}\t%0"
1782   [(set_attr "type" "pop")
1783    (set_attr "mode" "SI")])
1784
1785 (define_insn "popsi1"
1786   [(set (match_operand:SI 0 "nonimmediate_operand" "=r*m")
1787         (mem:SI (reg:SI SP_REG)))
1788    (set (reg:SI SP_REG)
1789         (plus:SI (reg:SI SP_REG) (const_int 4)))]
1790   "!TARGET_64BIT"
1791   "pop{l}\t%0"
1792   [(set_attr "type" "pop")
1793    (set_attr "mode" "SI")])
1794
1795 (define_insn "*movsi_xor"
1796   [(set (match_operand:SI 0 "register_operand" "=r")
1797         (match_operand:SI 1 "const0_operand" ""))
1798    (clobber (reg:CC FLAGS_REG))]
1799   "reload_completed"
1800   "xor{l}\t%0, %0"
1801   [(set_attr "type" "alu1")
1802    (set_attr "mode" "SI")
1803    (set_attr "length_immediate" "0")])
1804
1805 (define_insn "*movsi_or"
1806   [(set (match_operand:SI 0 "register_operand" "=r")
1807         (match_operand:SI 1 "immediate_operand" "i"))
1808    (clobber (reg:CC FLAGS_REG))]
1809   "reload_completed
1810    && operands[1] == constm1_rtx"
1811 {
1812   operands[1] = constm1_rtx;
1813   return "or{l}\t{%1, %0|%0, %1}";
1814 }
1815   [(set_attr "type" "alu1")
1816    (set_attr "mode" "SI")
1817    (set_attr "length_immediate" "1")])
1818
1819 (define_insn "*movsi_1"
1820   [(set (match_operand:SI 0 "nonimmediate_operand"
1821                         "=r,m ,*y,*y,?rm,?*y,*x,*x,?r ,m ,?*Yi,*x")
1822         (match_operand:SI 1 "general_operand"
1823                         "g ,ri,C ,*y,*y ,rm ,C ,*x,*Yi,*x,r   ,m "))]
1824   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
1825 {
1826   switch (get_attr_type (insn))
1827     {
1828     case TYPE_SSELOG1:
1829       if (get_attr_mode (insn) == MODE_TI)
1830         return "%vpxor\t%0, %d0";
1831       return "%vxorps\t%0, %d0";
1832
1833     case TYPE_SSEMOV:
1834       switch (get_attr_mode (insn))
1835         {
1836         case MODE_TI:
1837           return "%vmovdqa\t{%1, %0|%0, %1}";
1838         case MODE_V4SF:
1839           return "%vmovaps\t{%1, %0|%0, %1}";
1840         case MODE_SI:
1841           return "%vmovd\t{%1, %0|%0, %1}";
1842         case MODE_SF:
1843           return "%vmovss\t{%1, %0|%0, %1}";
1844         default:
1845           gcc_unreachable ();
1846         }
1847
1848     case TYPE_MMX:
1849       return "pxor\t%0, %0";
1850
1851     case TYPE_MMXMOV:
1852       if (get_attr_mode (insn) == MODE_DI)
1853         return "movq\t{%1, %0|%0, %1}";
1854       return "movd\t{%1, %0|%0, %1}";
1855
1856     case TYPE_LEA:
1857       return "lea{l}\t{%1, %0|%0, %1}";
1858
1859     default:
1860       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
1861       return "mov{l}\t{%1, %0|%0, %1}";
1862     }
1863 }
1864   [(set (attr "type")
1865      (cond [(eq_attr "alternative" "2")
1866               (const_string "mmx")
1867             (eq_attr "alternative" "3,4,5")
1868               (const_string "mmxmov")
1869             (eq_attr "alternative" "6")
1870               (const_string "sselog1")
1871             (eq_attr "alternative" "7,8,9,10,11")
1872               (const_string "ssemov")
1873             (match_operand:DI 1 "pic_32bit_operand" "")
1874               (const_string "lea")
1875            ]
1876            (const_string "imov")))
1877    (set (attr "prefix")
1878      (if_then_else (eq_attr "alternative" "0,1,2,3,4,5")
1879        (const_string "orig")
1880        (const_string "maybe_vex")))
1881    (set (attr "prefix_data16")
1882      (if_then_else (and (eq_attr "type" "ssemov") (eq_attr "mode" "SI"))
1883        (const_string "1")
1884        (const_string "*")))
1885    (set (attr "mode")
1886      (cond [(eq_attr "alternative" "2,3")
1887               (const_string "DI")
1888             (eq_attr "alternative" "6,7")
1889               (if_then_else
1890                 (eq (symbol_ref "TARGET_SSE2") (const_int 0))
1891                 (const_string "V4SF")
1892                 (const_string "TI"))
1893             (and (eq_attr "alternative" "8,9,10,11")
1894                  (eq (symbol_ref "TARGET_SSE2") (const_int 0)))
1895               (const_string "SF")
1896            ]
1897            (const_string "SI")))])
1898
1899 ;; Stores and loads of ax to arbitrary constant address.
1900 ;; We fake an second form of instruction to force reload to load address
1901 ;; into register when rax is not available
1902 (define_insn "*movabssi_1_rex64"
1903   [(set (mem:SI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
1904         (match_operand:SI 1 "nonmemory_operand" "a,er"))]
1905   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
1906   "@
1907    movabs{l}\t{%1, %P0|%P0, %1}
1908    mov{l}\t{%1, %a0|%a0, %1}"
1909   [(set_attr "type" "imov")
1910    (set_attr "modrm" "0,*")
1911    (set_attr "length_address" "8,0")
1912    (set_attr "length_immediate" "0,*")
1913    (set_attr "memory" "store")
1914    (set_attr "mode" "SI")])
1915
1916 (define_insn "*movabssi_2_rex64"
1917   [(set (match_operand:SI 0 "register_operand" "=a,r")
1918         (mem:SI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
1919   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
1920   "@
1921    movabs{l}\t{%P1, %0|%0, %P1}
1922    mov{l}\t{%a1, %0|%0, %a1}"
1923   [(set_attr "type" "imov")
1924    (set_attr "modrm" "0,*")
1925    (set_attr "length_address" "8,0")
1926    (set_attr "length_immediate" "0")
1927    (set_attr "memory" "load")
1928    (set_attr "mode" "SI")])
1929
1930 (define_insn "*swapsi"
1931   [(set (match_operand:SI 0 "register_operand" "+r")
1932         (match_operand:SI 1 "register_operand" "+r"))
1933    (set (match_dup 1)
1934         (match_dup 0))]
1935   ""
1936   "xchg{l}\t%1, %0"
1937   [(set_attr "type" "imov")
1938    (set_attr "mode" "SI")
1939    (set_attr "pent_pair" "np")
1940    (set_attr "athlon_decode" "vector")
1941    (set_attr "amdfam10_decode" "double")])
1942
1943 (define_expand "movhi"
1944   [(set (match_operand:HI 0 "nonimmediate_operand" "")
1945         (match_operand:HI 1 "general_operand" ""))]
1946   ""
1947   "ix86_expand_move (HImode, operands); DONE;")
1948
1949 (define_insn "*pushhi2"
1950   [(set (match_operand:HI 0 "push_operand" "=X")
1951         (match_operand:HI 1 "nonmemory_no_elim_operand" "rn"))]
1952   "!TARGET_64BIT"
1953   "push{l}\t%k1"
1954   [(set_attr "type" "push")
1955    (set_attr "mode" "SI")])
1956
1957 ;; For 64BIT abi we always round up to 8 bytes.
1958 (define_insn "*pushhi2_rex64"
1959   [(set (match_operand:HI 0 "push_operand" "=X")
1960         (match_operand:HI 1 "nonmemory_no_elim_operand" "rn"))]
1961   "TARGET_64BIT"
1962   "push{q}\t%q1"
1963   [(set_attr "type" "push")
1964    (set_attr "mode" "DI")])
1965
1966 (define_insn "*movhi_1"
1967   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,m")
1968         (match_operand:HI 1 "general_operand" "r,rn,rm,rn"))]
1969   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
1970 {
1971   switch (get_attr_type (insn))
1972     {
1973     case TYPE_IMOVX:
1974       /* movzwl is faster than movw on p2 due to partial word stalls,
1975          though not as fast as an aligned movl.  */
1976       return "movz{wl|x}\t{%1, %k0|%k0, %1}";
1977     default:
1978       if (get_attr_mode (insn) == MODE_SI)
1979         return "mov{l}\t{%k1, %k0|%k0, %k1}";
1980       else
1981         return "mov{w}\t{%1, %0|%0, %1}";
1982     }
1983 }
1984   [(set (attr "type")
1985      (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0))
1986               (const_string "imov")
1987             (and (eq_attr "alternative" "0")
1988                  (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
1989                           (const_int 0))
1990                       (eq (symbol_ref "TARGET_HIMODE_MATH")
1991                           (const_int 0))))
1992               (const_string "imov")
1993             (and (eq_attr "alternative" "1,2")
1994                  (match_operand:HI 1 "aligned_operand" ""))
1995               (const_string "imov")
1996             (and (ne (symbol_ref "TARGET_MOVX")
1997                      (const_int 0))
1998                  (eq_attr "alternative" "0,2"))
1999               (const_string "imovx")
2000            ]
2001            (const_string "imov")))
2002     (set (attr "mode")
2003       (cond [(eq_attr "type" "imovx")
2004                (const_string "SI")
2005              (and (eq_attr "alternative" "1,2")
2006                   (match_operand:HI 1 "aligned_operand" ""))
2007                (const_string "SI")
2008              (and (eq_attr "alternative" "0")
2009                   (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
2010                            (const_int 0))
2011                        (eq (symbol_ref "TARGET_HIMODE_MATH")
2012                            (const_int 0))))
2013                (const_string "SI")
2014             ]
2015             (const_string "HI")))])
2016
2017 ;; Stores and loads of ax to arbitrary constant address.
2018 ;; We fake an second form of instruction to force reload to load address
2019 ;; into register when rax is not available
2020 (define_insn "*movabshi_1_rex64"
2021   [(set (mem:HI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
2022         (match_operand:HI 1 "nonmemory_operand" "a,er"))]
2023   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
2024   "@
2025    movabs{w}\t{%1, %P0|%P0, %1}
2026    mov{w}\t{%1, %a0|%a0, %1}"
2027   [(set_attr "type" "imov")
2028    (set_attr "modrm" "0,*")
2029    (set_attr "length_address" "8,0")
2030    (set_attr "length_immediate" "0,*")
2031    (set_attr "memory" "store")
2032    (set_attr "mode" "HI")])
2033
2034 (define_insn "*movabshi_2_rex64"
2035   [(set (match_operand:HI 0 "register_operand" "=a,r")
2036         (mem:HI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
2037   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
2038   "@
2039    movabs{w}\t{%P1, %0|%0, %P1}
2040    mov{w}\t{%a1, %0|%0, %a1}"
2041   [(set_attr "type" "imov")
2042    (set_attr "modrm" "0,*")
2043    (set_attr "length_address" "8,0")
2044    (set_attr "length_immediate" "0")
2045    (set_attr "memory" "load")
2046    (set_attr "mode" "HI")])
2047
2048 (define_insn "*swaphi_1"
2049   [(set (match_operand:HI 0 "register_operand" "+r")
2050         (match_operand:HI 1 "register_operand" "+r"))
2051    (set (match_dup 1)
2052         (match_dup 0))]
2053   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
2054   "xchg{l}\t%k1, %k0"
2055   [(set_attr "type" "imov")
2056    (set_attr "mode" "SI")
2057    (set_attr "pent_pair" "np")
2058    (set_attr "athlon_decode" "vector")
2059    (set_attr "amdfam10_decode" "double")])
2060
2061 ;; Not added amdfam10_decode since TARGET_PARTIAL_REG_STALL is disabled for AMDFAM10
2062 (define_insn "*swaphi_2"
2063   [(set (match_operand:HI 0 "register_operand" "+r")
2064         (match_operand:HI 1 "register_operand" "+r"))
2065    (set (match_dup 1)
2066         (match_dup 0))]
2067   "TARGET_PARTIAL_REG_STALL"
2068   "xchg{w}\t%1, %0"
2069   [(set_attr "type" "imov")
2070    (set_attr "mode" "HI")
2071    (set_attr "pent_pair" "np")
2072    (set_attr "athlon_decode" "vector")])
2073
2074 (define_expand "movstricthi"
2075   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" ""))
2076         (match_operand:HI 1 "general_operand" ""))]
2077   ""
2078 {
2079   if (TARGET_PARTIAL_REG_STALL && optimize_function_for_speed_p (cfun))
2080     FAIL;
2081   /* Don't generate memory->memory moves, go through a register */
2082   if (MEM_P (operands[0]) && MEM_P (operands[1]))
2083     operands[1] = force_reg (HImode, operands[1]);
2084 })
2085
2086 (define_insn "*movstricthi_1"
2087   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+rm,r"))
2088         (match_operand:HI 1 "general_operand" "rn,m"))]
2089   "(! TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
2090    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2091   "mov{w}\t{%1, %0|%0, %1}"
2092   [(set_attr "type" "imov")
2093    (set_attr "mode" "HI")])
2094
2095 (define_insn "*movstricthi_xor"
2096   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+r"))
2097         (match_operand:HI 1 "const0_operand" ""))
2098    (clobber (reg:CC FLAGS_REG))]
2099   "reload_completed"
2100   "xor{w}\t%0, %0"
2101   [(set_attr "type" "alu1")
2102    (set_attr "mode" "HI")
2103    (set_attr "length_immediate" "0")])
2104
2105 (define_expand "movqi"
2106   [(set (match_operand:QI 0 "nonimmediate_operand" "")
2107         (match_operand:QI 1 "general_operand" ""))]
2108   ""
2109   "ix86_expand_move (QImode, operands); DONE;")
2110
2111 ;; emit_push_insn when it calls move_by_pieces requires an insn to
2112 ;; "push a byte".  But actually we use pushl, which has the effect
2113 ;; of rounding the amount pushed up to a word.
2114
2115 (define_insn "*pushqi2"
2116   [(set (match_operand:QI 0 "push_operand" "=X")
2117         (match_operand:QI 1 "nonmemory_no_elim_operand" "rn"))]
2118   "!TARGET_64BIT"
2119   "push{l}\t%k1"
2120   [(set_attr "type" "push")
2121    (set_attr "mode" "SI")])
2122
2123 ;; For 64BIT abi we always round up to 8 bytes.
2124 (define_insn "*pushqi2_rex64"
2125   [(set (match_operand:QI 0 "push_operand" "=X")
2126         (match_operand:QI 1 "nonmemory_no_elim_operand" "qn"))]
2127   "TARGET_64BIT"
2128   "push{q}\t%q1"
2129   [(set_attr "type" "push")
2130    (set_attr "mode" "DI")])
2131
2132 ;; Situation is quite tricky about when to choose full sized (SImode) move
2133 ;; over QImode moves.  For Q_REG -> Q_REG move we use full size only for
2134 ;; partial register dependency machines (such as AMD Athlon), where QImode
2135 ;; moves issue extra dependency and for partial register stalls machines
2136 ;; that don't use QImode patterns (and QImode move cause stall on the next
2137 ;; instruction).
2138 ;;
2139 ;; For loads of Q_REG to NONQ_REG we use full sized moves except for partial
2140 ;; register stall machines with, where we use QImode instructions, since
2141 ;; partial register stall can be caused there.  Then we use movzx.
2142 (define_insn "*movqi_1"
2143   [(set (match_operand:QI 0 "nonimmediate_operand" "=q,q ,q ,r,r ,?r,m")
2144         (match_operand:QI 1 "general_operand"      " q,qn,qm,q,rn,qm,qn"))]
2145   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
2146 {
2147   switch (get_attr_type (insn))
2148     {
2149     case TYPE_IMOVX:
2150       gcc_assert (ANY_QI_REG_P (operands[1]) || MEM_P (operands[1]));
2151       return "movz{bl|x}\t{%1, %k0|%k0, %1}";
2152     default:
2153       if (get_attr_mode (insn) == MODE_SI)
2154         return "mov{l}\t{%k1, %k0|%k0, %k1}";
2155       else
2156         return "mov{b}\t{%1, %0|%0, %1}";
2157     }
2158 }
2159   [(set (attr "type")
2160      (cond [(and (eq_attr "alternative" "5")
2161                  (not (match_operand:QI 1 "aligned_operand" "")))
2162               (const_string "imovx")
2163             (ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0))
2164               (const_string "imov")
2165             (and (eq_attr "alternative" "3")
2166                  (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
2167                           (const_int 0))
2168                       (eq (symbol_ref "TARGET_QIMODE_MATH")
2169                           (const_int 0))))
2170               (const_string "imov")
2171             (eq_attr "alternative" "3,5")
2172               (const_string "imovx")
2173             (and (ne (symbol_ref "TARGET_MOVX")
2174                      (const_int 0))
2175                  (eq_attr "alternative" "2"))
2176               (const_string "imovx")
2177            ]
2178            (const_string "imov")))
2179    (set (attr "mode")
2180       (cond [(eq_attr "alternative" "3,4,5")
2181                (const_string "SI")
2182              (eq_attr "alternative" "6")
2183                (const_string "QI")
2184              (eq_attr "type" "imovx")
2185                (const_string "SI")
2186              (and (eq_attr "type" "imov")
2187                   (and (eq_attr "alternative" "0,1")
2188                        (and (ne (symbol_ref "TARGET_PARTIAL_REG_DEPENDENCY")
2189                                 (const_int 0))
2190                             (and (eq (symbol_ref "optimize_function_for_size_p (cfun)")
2191                                      (const_int 0))
2192                                  (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
2193                                      (const_int 0))))))
2194                (const_string "SI")
2195              ;; Avoid partial register stalls when not using QImode arithmetic
2196              (and (eq_attr "type" "imov")
2197                   (and (eq_attr "alternative" "0,1")
2198                        (and (ne (symbol_ref "TARGET_PARTIAL_REG_STALL")
2199                                 (const_int 0))
2200                             (eq (symbol_ref "TARGET_QIMODE_MATH")
2201                                 (const_int 0)))))
2202                (const_string "SI")
2203            ]
2204            (const_string "QI")))])
2205
2206 (define_insn "*swapqi_1"
2207   [(set (match_operand:QI 0 "register_operand" "+r")
2208         (match_operand:QI 1 "register_operand" "+r"))
2209    (set (match_dup 1)
2210         (match_dup 0))]
2211   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
2212   "xchg{l}\t%k1, %k0"
2213   [(set_attr "type" "imov")
2214    (set_attr "mode" "SI")
2215    (set_attr "pent_pair" "np")
2216    (set_attr "athlon_decode" "vector")
2217    (set_attr "amdfam10_decode" "vector")])
2218
2219 ;; Not added amdfam10_decode since TARGET_PARTIAL_REG_STALL is disabled for AMDFAM10
2220 (define_insn "*swapqi_2"
2221   [(set (match_operand:QI 0 "register_operand" "+q")
2222         (match_operand:QI 1 "register_operand" "+q"))
2223    (set (match_dup 1)
2224         (match_dup 0))]
2225   "TARGET_PARTIAL_REG_STALL"
2226   "xchg{b}\t%1, %0"
2227   [(set_attr "type" "imov")
2228    (set_attr "mode" "QI")
2229    (set_attr "pent_pair" "np")
2230    (set_attr "athlon_decode" "vector")])
2231
2232 (define_expand "movstrictqi"
2233   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" ""))
2234         (match_operand:QI 1 "general_operand" ""))]
2235   ""
2236 {
2237   if (TARGET_PARTIAL_REG_STALL && optimize_function_for_speed_p (cfun))
2238     FAIL;
2239   /* Don't generate memory->memory moves, go through a register.  */
2240   if (MEM_P (operands[0]) && MEM_P (operands[1]))
2241     operands[1] = force_reg (QImode, operands[1]);
2242 })
2243
2244 (define_insn "*movstrictqi_1"
2245   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+qm,q"))
2246         (match_operand:QI 1 "general_operand" "*qn,m"))]
2247   "(! TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
2248    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2249   "mov{b}\t{%1, %0|%0, %1}"
2250   [(set_attr "type" "imov")
2251    (set_attr "mode" "QI")])
2252
2253 (define_insn "*movstrictqi_xor"
2254   [(set (strict_low_part (match_operand:QI 0 "q_regs_operand" "+q"))
2255         (match_operand:QI 1 "const0_operand" ""))
2256    (clobber (reg:CC FLAGS_REG))]
2257   "reload_completed"
2258   "xor{b}\t%0, %0"
2259   [(set_attr "type" "alu1")
2260    (set_attr "mode" "QI")
2261    (set_attr "length_immediate" "0")])
2262
2263 (define_insn "*movsi_extv_1"
2264   [(set (match_operand:SI 0 "register_operand" "=R")
2265         (sign_extract:SI (match_operand 1 "ext_register_operand" "Q")
2266                          (const_int 8)
2267                          (const_int 8)))]
2268   ""
2269   "movs{bl|x}\t{%h1, %0|%0, %h1}"
2270   [(set_attr "type" "imovx")
2271    (set_attr "mode" "SI")])
2272
2273 (define_insn "*movhi_extv_1"
2274   [(set (match_operand:HI 0 "register_operand" "=R")
2275         (sign_extract:HI (match_operand 1 "ext_register_operand" "Q")
2276                          (const_int 8)
2277                          (const_int 8)))]
2278   ""
2279   "movs{bl|x}\t{%h1, %k0|%k0, %h1}"
2280   [(set_attr "type" "imovx")
2281    (set_attr "mode" "SI")])
2282
2283 (define_insn "*movqi_extv_1"
2284   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?r")
2285         (sign_extract:QI (match_operand 1 "ext_register_operand" "Q,Q")
2286                          (const_int 8)
2287                          (const_int 8)))]
2288   "!TARGET_64BIT"
2289 {
2290   switch (get_attr_type (insn))
2291     {
2292     case TYPE_IMOVX:
2293       return "movs{bl|x}\t{%h1, %k0|%k0, %h1}";
2294     default:
2295       return "mov{b}\t{%h1, %0|%0, %h1}";
2296     }
2297 }
2298   [(set (attr "type")
2299      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2300                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2301                              (ne (symbol_ref "TARGET_MOVX")
2302                                  (const_int 0))))
2303         (const_string "imovx")
2304         (const_string "imov")))
2305    (set (attr "mode")
2306      (if_then_else (eq_attr "type" "imovx")
2307         (const_string "SI")
2308         (const_string "QI")))])
2309
2310 (define_insn "*movqi_extv_1_rex64"
2311   [(set (match_operand:QI 0 "register_operand" "=Q,?R")
2312         (sign_extract:QI (match_operand 1 "ext_register_operand" "Q,Q")
2313                          (const_int 8)
2314                          (const_int 8)))]
2315   "TARGET_64BIT"
2316 {
2317   switch (get_attr_type (insn))
2318     {
2319     case TYPE_IMOVX:
2320       return "movs{bl|x}\t{%h1, %k0|%k0, %h1}";
2321     default:
2322       return "mov{b}\t{%h1, %0|%0, %h1}";
2323     }
2324 }
2325   [(set (attr "type")
2326      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2327                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2328                              (ne (symbol_ref "TARGET_MOVX")
2329                                  (const_int 0))))
2330         (const_string "imovx")
2331         (const_string "imov")))
2332    (set (attr "mode")
2333      (if_then_else (eq_attr "type" "imovx")
2334         (const_string "SI")
2335         (const_string "QI")))])
2336
2337 ;; Stores and loads of ax to arbitrary constant address.
2338 ;; We fake an second form of instruction to force reload to load address
2339 ;; into register when rax is not available
2340 (define_insn "*movabsqi_1_rex64"
2341   [(set (mem:QI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
2342         (match_operand:QI 1 "nonmemory_operand" "a,er"))]
2343   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
2344   "@
2345    movabs{b}\t{%1, %P0|%P0, %1}
2346    mov{b}\t{%1, %a0|%a0, %1}"
2347   [(set_attr "type" "imov")
2348    (set_attr "modrm" "0,*")
2349    (set_attr "length_address" "8,0")
2350    (set_attr "length_immediate" "0,*")
2351    (set_attr "memory" "store")
2352    (set_attr "mode" "QI")])
2353
2354 (define_insn "*movabsqi_2_rex64"
2355   [(set (match_operand:QI 0 "register_operand" "=a,r")
2356         (mem:QI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
2357   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
2358   "@
2359    movabs{b}\t{%P1, %0|%0, %P1}
2360    mov{b}\t{%a1, %0|%0, %a1}"
2361   [(set_attr "type" "imov")
2362    (set_attr "modrm" "0,*")
2363    (set_attr "length_address" "8,0")
2364    (set_attr "length_immediate" "0")
2365    (set_attr "memory" "load")
2366    (set_attr "mode" "QI")])
2367
2368 (define_insn "*movdi_extzv_1"
2369   [(set (match_operand:DI 0 "register_operand" "=R")
2370         (zero_extract:DI (match_operand 1 "ext_register_operand" "Q")
2371                          (const_int 8)
2372                          (const_int 8)))]
2373   "TARGET_64BIT"
2374   "movz{bl|x}\t{%h1, %k0|%k0, %h1}"
2375   [(set_attr "type" "imovx")
2376    (set_attr "mode" "SI")])
2377
2378 (define_insn "*movsi_extzv_1"
2379   [(set (match_operand:SI 0 "register_operand" "=R")
2380         (zero_extract:SI (match_operand 1 "ext_register_operand" "Q")
2381                          (const_int 8)
2382                          (const_int 8)))]
2383   ""
2384   "movz{bl|x}\t{%h1, %0|%0, %h1}"
2385   [(set_attr "type" "imovx")
2386    (set_attr "mode" "SI")])
2387
2388 (define_insn "*movqi_extzv_2"
2389   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?R")
2390         (subreg:QI (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
2391                                     (const_int 8)
2392                                     (const_int 8)) 0))]
2393   "!TARGET_64BIT"
2394 {
2395   switch (get_attr_type (insn))
2396     {
2397     case TYPE_IMOVX:
2398       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2399     default:
2400       return "mov{b}\t{%h1, %0|%0, %h1}";
2401     }
2402 }
2403   [(set (attr "type")
2404      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2405                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2406                              (ne (symbol_ref "TARGET_MOVX")
2407                                  (const_int 0))))
2408         (const_string "imovx")
2409         (const_string "imov")))
2410    (set (attr "mode")
2411      (if_then_else (eq_attr "type" "imovx")
2412         (const_string "SI")
2413         (const_string "QI")))])
2414
2415 (define_insn "*movqi_extzv_2_rex64"
2416   [(set (match_operand:QI 0 "register_operand" "=Q,?R")
2417         (subreg:QI (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
2418                                     (const_int 8)
2419                                     (const_int 8)) 0))]
2420   "TARGET_64BIT"
2421 {
2422   switch (get_attr_type (insn))
2423     {
2424     case TYPE_IMOVX:
2425       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2426     default:
2427       return "mov{b}\t{%h1, %0|%0, %h1}";
2428     }
2429 }
2430   [(set (attr "type")
2431      (if_then_else (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2432                         (ne (symbol_ref "TARGET_MOVX")
2433                             (const_int 0)))
2434         (const_string "imovx")
2435         (const_string "imov")))
2436    (set (attr "mode")
2437      (if_then_else (eq_attr "type" "imovx")
2438         (const_string "SI")
2439         (const_string "QI")))])
2440
2441 (define_insn "movsi_insv_1"
2442   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2443                          (const_int 8)
2444                          (const_int 8))
2445         (match_operand:SI 1 "general_operand" "Qmn"))]
2446   "!TARGET_64BIT"
2447   "mov{b}\t{%b1, %h0|%h0, %b1}"
2448   [(set_attr "type" "imov")
2449    (set_attr "mode" "QI")])
2450
2451 (define_insn "*movsi_insv_1_rex64"
2452   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2453                          (const_int 8)
2454                          (const_int 8))
2455         (match_operand:SI 1 "nonmemory_operand" "Qn"))]
2456   "TARGET_64BIT"
2457   "mov{b}\t{%b1, %h0|%h0, %b1}"
2458   [(set_attr "type" "imov")
2459    (set_attr "mode" "QI")])
2460
2461 (define_insn "movdi_insv_1_rex64"
2462   [(set (zero_extract:DI (match_operand 0 "ext_register_operand" "+Q")
2463                          (const_int 8)
2464                          (const_int 8))
2465         (match_operand:DI 1 "nonmemory_operand" "Qn"))]
2466   "TARGET_64BIT"
2467   "mov{b}\t{%b1, %h0|%h0, %b1}"
2468   [(set_attr "type" "imov")
2469    (set_attr "mode" "QI")])
2470
2471 (define_insn "*movqi_insv_2"
2472   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2473                          (const_int 8)
2474                          (const_int 8))
2475         (lshiftrt:SI (match_operand:SI 1 "register_operand" "Q")
2476                      (const_int 8)))]
2477   ""
2478   "mov{b}\t{%h1, %h0|%h0, %h1}"
2479   [(set_attr "type" "imov")
2480    (set_attr "mode" "QI")])
2481
2482 (define_expand "movdi"
2483   [(set (match_operand:DI 0 "nonimmediate_operand" "")
2484         (match_operand:DI 1 "general_operand" ""))]
2485   ""
2486   "ix86_expand_move (DImode, operands); DONE;")
2487
2488 (define_insn "*pushdi"
2489   [(set (match_operand:DI 0 "push_operand" "=<")
2490         (match_operand:DI 1 "general_no_elim_operand" "riF*m"))]
2491   "!TARGET_64BIT"
2492   "#")
2493
2494 (define_insn "*pushdi2_rex64"
2495   [(set (match_operand:DI 0 "push_operand" "=<,!<")
2496         (match_operand:DI 1 "general_no_elim_operand" "re*m,n"))]
2497   "TARGET_64BIT"
2498   "@
2499    push{q}\t%1
2500    #"
2501   [(set_attr "type" "push,multi")
2502    (set_attr "mode" "DI")])
2503
2504 ;; Convert impossible pushes of immediate to existing instructions.
2505 ;; First try to get scratch register and go through it.  In case this
2506 ;; fails, push sign extended lower part first and then overwrite
2507 ;; upper part by 32bit move.
2508 (define_peephole2
2509   [(match_scratch:DI 2 "r")
2510    (set (match_operand:DI 0 "push_operand" "")
2511         (match_operand:DI 1 "immediate_operand" ""))]
2512   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2513    && !x86_64_immediate_operand (operands[1], DImode)"
2514   [(set (match_dup 2) (match_dup 1))
2515    (set (match_dup 0) (match_dup 2))]
2516   "")
2517
2518 ;; We need to define this as both peepholer and splitter for case
2519 ;; peephole2 pass is not run.
2520 ;; "&& 1" is needed to keep it from matching the previous pattern.
2521 (define_peephole2
2522   [(set (match_operand:DI 0 "push_operand" "")
2523         (match_operand:DI 1 "immediate_operand" ""))]
2524   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2525    && !x86_64_immediate_operand (operands[1], DImode) && 1"
2526   [(set (match_dup 0) (match_dup 1))
2527    (set (match_dup 2) (match_dup 3))]
2528   "split_di (&operands[1], 1, &operands[2], &operands[3]);
2529    operands[1] = gen_lowpart (DImode, operands[2]);
2530    operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx,
2531                                                     GEN_INT (4)));
2532   ")
2533
2534 (define_split
2535   [(set (match_operand:DI 0 "push_operand" "")
2536         (match_operand:DI 1 "immediate_operand" ""))]
2537   "TARGET_64BIT && ((optimize > 0 && flag_peephole2)
2538                     ? epilogue_completed : reload_completed)
2539    && !symbolic_operand (operands[1], DImode)
2540    && !x86_64_immediate_operand (operands[1], DImode)"
2541   [(set (match_dup 0) (match_dup 1))
2542    (set (match_dup 2) (match_dup 3))]
2543   "split_di (&operands[1], 1, &operands[2], &operands[3]);
2544    operands[1] = gen_lowpart (DImode, operands[2]);
2545    operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx,
2546                                                     GEN_INT (4)));
2547   ")
2548
2549 (define_insn "*pushdi2_prologue_rex64"
2550   [(set (match_operand:DI 0 "push_operand" "=<")
2551         (match_operand:DI 1 "general_no_elim_operand" "re*m"))
2552    (clobber (mem:BLK (scratch)))]
2553   "TARGET_64BIT"
2554   "push{q}\t%1"
2555   [(set_attr "type" "push")
2556    (set_attr "mode" "DI")])
2557
2558 (define_insn "*popdi1_epilogue_rex64"
2559   [(set (match_operand:DI 0 "nonimmediate_operand" "=r*m")
2560         (mem:DI (reg:DI SP_REG)))
2561    (set (reg:DI SP_REG)
2562         (plus:DI (reg:DI SP_REG) (const_int 8)))
2563    (clobber (mem:BLK (scratch)))]
2564   "TARGET_64BIT"
2565   "pop{q}\t%0"
2566   [(set_attr "type" "pop")
2567    (set_attr "mode" "DI")])
2568
2569 (define_insn "popdi1"
2570   [(set (match_operand:DI 0 "nonimmediate_operand" "=r*m")
2571         (mem:DI (reg:DI SP_REG)))
2572    (set (reg:DI SP_REG)
2573         (plus:DI (reg:DI SP_REG) (const_int 8)))]
2574   "TARGET_64BIT"
2575   "pop{q}\t%0"
2576   [(set_attr "type" "pop")
2577    (set_attr "mode" "DI")])
2578
2579 (define_insn "*movdi_xor_rex64"
2580   [(set (match_operand:DI 0 "register_operand" "=r")
2581         (match_operand:DI 1 "const0_operand" ""))
2582    (clobber (reg:CC FLAGS_REG))]
2583   "TARGET_64BIT
2584    && reload_completed"
2585   "xor{l}\t%k0, %k0";
2586   [(set_attr "type" "alu1")
2587    (set_attr "mode" "SI")
2588    (set_attr "length_immediate" "0")])
2589
2590 (define_insn "*movdi_or_rex64"
2591   [(set (match_operand:DI 0 "register_operand" "=r")
2592         (match_operand:DI 1 "const_int_operand" "i"))
2593    (clobber (reg:CC FLAGS_REG))]
2594   "TARGET_64BIT
2595    && reload_completed
2596    && operands[1] == constm1_rtx"
2597 {
2598   operands[1] = constm1_rtx;
2599   return "or{q}\t{%1, %0|%0, %1}";
2600 }
2601   [(set_attr "type" "alu1")
2602    (set_attr "mode" "DI")
2603    (set_attr "length_immediate" "1")])
2604
2605 (define_insn "*movdi_2"
2606   [(set (match_operand:DI 0 "nonimmediate_operand"
2607                         "=r  ,o  ,*y,m*y,*y,*Y2,m  ,*Y2,*Y2,*x,m ,*x,*x")
2608         (match_operand:DI 1 "general_operand"
2609                         "riFo,riF,C ,*y ,m ,C  ,*Y2,*Y2,m  ,C ,*x,*x,m "))]
2610   "!TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2611   "@
2612    #
2613    #
2614    pxor\t%0, %0
2615    movq\t{%1, %0|%0, %1}
2616    movq\t{%1, %0|%0, %1}
2617    %vpxor\t%0, %d0
2618    %vmovq\t{%1, %0|%0, %1}
2619    %vmovdqa\t{%1, %0|%0, %1}
2620    %vmovq\t{%1, %0|%0, %1}
2621    xorps\t%0, %0
2622    movlps\t{%1, %0|%0, %1}
2623    movaps\t{%1, %0|%0, %1}
2624    movlps\t{%1, %0|%0, %1}"
2625   [(set_attr "type" "*,*,mmx,mmxmov,mmxmov,sselog1,ssemov,ssemov,ssemov,sselog1,ssemov,ssemov,ssemov")
2626    (set (attr "prefix")
2627      (if_then_else (eq_attr "alternative" "5,6,7,8")
2628        (const_string "vex")
2629        (const_string "orig")))
2630    (set_attr "mode" "DI,DI,DI,DI,DI,TI,DI,TI,DI,V4SF,V2SF,V4SF,V2SF")])
2631
2632 (define_split
2633   [(set (match_operand:DI 0 "push_operand" "")
2634         (match_operand:DI 1 "general_operand" ""))]
2635   "!TARGET_64BIT && reload_completed
2636    && (! MMX_REG_P (operands[1]) && !SSE_REG_P (operands[1]))"
2637   [(const_int 0)]
2638   "ix86_split_long_move (operands); DONE;")
2639
2640 ;; %%% This multiword shite has got to go.
2641 (define_split
2642   [(set (match_operand:DI 0 "nonimmediate_operand" "")
2643         (match_operand:DI 1 "general_operand" ""))]
2644   "!TARGET_64BIT && reload_completed
2645    && (!MMX_REG_P (operands[0]) && !SSE_REG_P (operands[0]))
2646    && (!MMX_REG_P (operands[1]) && !SSE_REG_P (operands[1]))"
2647   [(const_int 0)]
2648   "ix86_split_long_move (operands); DONE;")
2649
2650 (define_insn "*movdi_1_rex64"
2651   [(set (match_operand:DI 0 "nonimmediate_operand"
2652           "=r,r  ,r,m ,!m,*y,*y,?r ,m ,?*Ym,?*y,*x,*x,?r ,m,?*Yi,*x,?*x,?*Ym")
2653         (match_operand:DI 1 "general_operand"
2654           "Z ,rem,i,re,n ,C ,*y,*Ym,*y,r   ,m  ,C ,*x,*Yi,*x,r  ,m ,*Ym,*x"))]
2655   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2656 {
2657   switch (get_attr_type (insn))
2658     {
2659     case TYPE_SSECVT:
2660       if (SSE_REG_P (operands[0]))
2661         return "movq2dq\t{%1, %0|%0, %1}";
2662       else
2663         return "movdq2q\t{%1, %0|%0, %1}";
2664
2665     case TYPE_SSEMOV:
2666       if (TARGET_AVX)
2667         {
2668           if (get_attr_mode (insn) == MODE_TI)
2669             return "vmovdqa\t{%1, %0|%0, %1}";
2670           else
2671             return "vmovq\t{%1, %0|%0, %1}";
2672         }
2673
2674       if (get_attr_mode (insn) == MODE_TI)
2675         return "movdqa\t{%1, %0|%0, %1}";
2676       /* FALLTHRU */
2677
2678     case TYPE_MMXMOV:
2679       /* Moves from and into integer register is done using movd
2680          opcode with REX prefix.  */
2681       if (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1]))
2682         return "movd\t{%1, %0|%0, %1}";
2683       return "movq\t{%1, %0|%0, %1}";
2684
2685     case TYPE_SSELOG1:
2686       return "%vpxor\t%0, %d0";
2687
2688     case TYPE_MMX:
2689       return "pxor\t%0, %0";
2690
2691     case TYPE_MULTI:
2692       return "#";
2693
2694     case TYPE_LEA:
2695       return "lea{q}\t{%a1, %0|%0, %a1}";
2696
2697     default:
2698       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
2699       if (get_attr_mode (insn) == MODE_SI)
2700         return "mov{l}\t{%k1, %k0|%k0, %k1}";
2701       else if (which_alternative == 2)
2702         return "movabs{q}\t{%1, %0|%0, %1}";
2703       else
2704         return "mov{q}\t{%1, %0|%0, %1}";
2705     }
2706 }
2707   [(set (attr "type")
2708      (cond [(eq_attr "alternative" "5")
2709               (const_string "mmx")
2710             (eq_attr "alternative" "6,7,8,9,10")
2711               (const_string "mmxmov")
2712             (eq_attr "alternative" "11")
2713               (const_string "sselog1")
2714             (eq_attr "alternative" "12,13,14,15,16")
2715               (const_string "ssemov")
2716             (eq_attr "alternative" "17,18")
2717               (const_string "ssecvt")
2718             (eq_attr "alternative" "4")
2719               (const_string "multi")
2720             (match_operand:DI 1 "pic_32bit_operand" "")
2721               (const_string "lea")
2722            ]
2723            (const_string "imov")))
2724    (set (attr "modrm")
2725      (if_then_else
2726        (and (eq_attr "alternative" "2") (eq_attr "type" "imov"))
2727          (const_string "0")
2728          (const_string "*")))
2729    (set (attr "length_immediate")
2730      (if_then_else
2731        (and (eq_attr "alternative" "2") (eq_attr "type" "imov"))
2732          (const_string "8")
2733          (const_string "*")))
2734    (set_attr "prefix_rex" "*,*,*,*,*,*,*,1,*,1,*,*,*,*,*,*,*,*,*")
2735    (set_attr "prefix_data16" "*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,1,*,*,*")
2736    (set (attr "prefix")
2737      (if_then_else (eq_attr "alternative" "11,12,13,14,15,16")
2738        (const_string "maybe_vex")
2739        (const_string "orig")))
2740    (set_attr "mode" "SI,DI,DI,DI,SI,DI,DI,DI,DI,DI,DI,TI,TI,DI,DI,DI,DI,DI,DI")])
2741
2742 ;; Stores and loads of ax to arbitrary constant address.
2743 ;; We fake an second form of instruction to force reload to load address
2744 ;; into register when rax is not available
2745 (define_insn "*movabsdi_1_rex64"
2746   [(set (mem:DI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
2747         (match_operand:DI 1 "nonmemory_operand" "a,er"))]
2748   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
2749   "@
2750    movabs{q}\t{%1, %P0|%P0, %1}
2751    mov{q}\t{%1, %a0|%a0, %1}"
2752   [(set_attr "type" "imov")
2753    (set_attr "modrm" "0,*")
2754    (set_attr "length_address" "8,0")
2755    (set_attr "length_immediate" "0,*")
2756    (set_attr "memory" "store")
2757    (set_attr "mode" "DI")])
2758
2759 (define_insn "*movabsdi_2_rex64"
2760   [(set (match_operand:DI 0 "register_operand" "=a,r")
2761         (mem:DI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
2762   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
2763   "@
2764    movabs{q}\t{%P1, %0|%0, %P1}
2765    mov{q}\t{%a1, %0|%0, %a1}"
2766   [(set_attr "type" "imov")
2767    (set_attr "modrm" "0,*")
2768    (set_attr "length_address" "8,0")
2769    (set_attr "length_immediate" "0")
2770    (set_attr "memory" "load")
2771    (set_attr "mode" "DI")])
2772
2773 ;; Convert impossible stores of immediate to existing instructions.
2774 ;; First try to get scratch register and go through it.  In case this
2775 ;; fails, move by 32bit parts.
2776 (define_peephole2
2777   [(match_scratch:DI 2 "r")
2778    (set (match_operand:DI 0 "memory_operand" "")
2779         (match_operand:DI 1 "immediate_operand" ""))]
2780   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2781    && !x86_64_immediate_operand (operands[1], DImode)"
2782   [(set (match_dup 2) (match_dup 1))
2783    (set (match_dup 0) (match_dup 2))]
2784   "")
2785
2786 ;; We need to define this as both peepholer and splitter for case
2787 ;; peephole2 pass is not run.
2788 ;; "&& 1" is needed to keep it from matching the previous pattern.
2789 (define_peephole2
2790   [(set (match_operand:DI 0 "memory_operand" "")
2791         (match_operand:DI 1 "immediate_operand" ""))]
2792   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2793    && !x86_64_immediate_operand (operands[1], DImode) && 1"
2794   [(set (match_dup 2) (match_dup 3))
2795    (set (match_dup 4) (match_dup 5))]
2796   "split_di (&operands[0], 2, &operands[2], &operands[4]);")
2797
2798 (define_split
2799   [(set (match_operand:DI 0 "memory_operand" "")
2800         (match_operand:DI 1 "immediate_operand" ""))]
2801   "TARGET_64BIT && ((optimize > 0 && flag_peephole2)
2802                     ? epilogue_completed : reload_completed)
2803    && !symbolic_operand (operands[1], DImode)
2804    && !x86_64_immediate_operand (operands[1], DImode)"
2805   [(set (match_dup 2) (match_dup 3))
2806    (set (match_dup 4) (match_dup 5))]
2807   "split_di (&operands[0], 2, &operands[2], &operands[4]);")
2808
2809 (define_insn "*swapdi_rex64"
2810   [(set (match_operand:DI 0 "register_operand" "+r")
2811         (match_operand:DI 1 "register_operand" "+r"))
2812    (set (match_dup 1)
2813         (match_dup 0))]
2814   "TARGET_64BIT"
2815   "xchg{q}\t%1, %0"
2816   [(set_attr "type" "imov")
2817    (set_attr "mode" "DI")
2818    (set_attr "pent_pair" "np")
2819    (set_attr "athlon_decode" "vector")
2820    (set_attr "amdfam10_decode" "double")])
2821
2822 (define_expand "movoi"
2823   [(set (match_operand:OI 0 "nonimmediate_operand" "")
2824         (match_operand:OI 1 "general_operand" ""))]
2825   "TARGET_AVX"
2826   "ix86_expand_move (OImode, operands); DONE;")
2827
2828 (define_insn "*movoi_internal"
2829   [(set (match_operand:OI 0 "nonimmediate_operand" "=x,x,m")
2830         (match_operand:OI 1 "vector_move_operand" "C,xm,x"))]
2831   "TARGET_AVX
2832    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2833 {
2834   switch (which_alternative)
2835     {
2836     case 0:
2837       return "vxorps\t%0, %0, %0";
2838     case 1:
2839     case 2:
2840       if (misaligned_operand (operands[0], OImode)
2841           || misaligned_operand (operands[1], OImode))
2842         return "vmovdqu\t{%1, %0|%0, %1}";
2843       else
2844         return "vmovdqa\t{%1, %0|%0, %1}";
2845     default:
2846       gcc_unreachable ();
2847     }
2848 }
2849   [(set_attr "type" "sselog1,ssemov,ssemov")
2850    (set_attr "prefix" "vex")
2851    (set_attr "mode" "OI")])
2852
2853 (define_expand "movti"
2854   [(set (match_operand:TI 0 "nonimmediate_operand" "")
2855         (match_operand:TI 1 "nonimmediate_operand" ""))]
2856   "TARGET_SSE || TARGET_64BIT"
2857 {
2858   if (TARGET_64BIT)
2859     ix86_expand_move (TImode, operands);
2860   else if (push_operand (operands[0], TImode))
2861     ix86_expand_push (TImode, operands[1]);
2862   else
2863     ix86_expand_vector_move (TImode, operands);
2864   DONE;
2865 })
2866
2867 (define_insn "*movti_internal"
2868   [(set (match_operand:TI 0 "nonimmediate_operand" "=x,x,m")
2869         (match_operand:TI 1 "vector_move_operand" "C,xm,x"))]
2870   "TARGET_SSE && !TARGET_64BIT
2871    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2872 {
2873   switch (which_alternative)
2874     {
2875     case 0:
2876       if (get_attr_mode (insn) == MODE_V4SF)
2877         return "%vxorps\t%0, %d0";
2878       else
2879         return "%vpxor\t%0, %d0";
2880     case 1:
2881     case 2:
2882       /* TDmode values are passed as TImode on the stack.  Moving them
2883          to stack may result in unaligned memory access.  */
2884       if (misaligned_operand (operands[0], TImode)
2885           || misaligned_operand (operands[1], TImode))
2886         {
2887           if (get_attr_mode (insn) == MODE_V4SF)
2888             return "%vmovups\t{%1, %0|%0, %1}";
2889          else
2890            return "%vmovdqu\t{%1, %0|%0, %1}";
2891         }
2892       else
2893         {
2894           if (get_attr_mode (insn) == MODE_V4SF)
2895             return "%vmovaps\t{%1, %0|%0, %1}";
2896          else
2897            return "%vmovdqa\t{%1, %0|%0, %1}";
2898         }
2899     default:
2900       gcc_unreachable ();
2901     }
2902 }
2903   [(set_attr "type" "sselog1,ssemov,ssemov")
2904    (set_attr "prefix" "maybe_vex")
2905    (set (attr "mode")
2906         (cond [(ior (eq (symbol_ref "TARGET_SSE2") (const_int 0))
2907                     (ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0)))
2908                  (const_string "V4SF")
2909                (and (eq_attr "alternative" "2")
2910                     (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
2911                         (const_int 0)))
2912                  (const_string "V4SF")]
2913               (const_string "TI")))])
2914
2915 (define_insn "*movti_rex64"
2916   [(set (match_operand:TI 0 "nonimmediate_operand" "=!r,o,x,x,xm")
2917         (match_operand:TI 1 "general_operand" "riFo,riF,C,xm,x"))]
2918   "TARGET_64BIT
2919    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2920 {
2921   switch (which_alternative)
2922     {
2923     case 0:
2924     case 1:
2925       return "#";
2926     case 2:
2927       if (get_attr_mode (insn) == MODE_V4SF)
2928         return "%vxorps\t%0, %d0";
2929       else
2930         return "%vpxor\t%0, %d0";
2931     case 3:
2932     case 4:
2933       /* TDmode values are passed as TImode on the stack.  Moving them
2934          to stack may result in unaligned memory access.  */
2935       if (misaligned_operand (operands[0], TImode)
2936           || misaligned_operand (operands[1], TImode))
2937         {
2938           if (get_attr_mode (insn) == MODE_V4SF)
2939             return "%vmovups\t{%1, %0|%0, %1}";
2940          else
2941            return "%vmovdqu\t{%1, %0|%0, %1}";
2942         }
2943       else
2944         {
2945           if (get_attr_mode (insn) == MODE_V4SF)
2946             return "%vmovaps\t{%1, %0|%0, %1}";
2947          else
2948            return "%vmovdqa\t{%1, %0|%0, %1}";
2949         }
2950     default:
2951       gcc_unreachable ();
2952     }
2953 }
2954   [(set_attr "type" "*,*,sselog1,ssemov,ssemov")
2955    (set_attr "prefix" "*,*,maybe_vex,maybe_vex,maybe_vex")
2956    (set (attr "mode")
2957         (cond [(eq_attr "alternative" "2,3")
2958                  (if_then_else
2959                    (ne (symbol_ref "optimize_function_for_size_p (cfun)")
2960                        (const_int 0))
2961                    (const_string "V4SF")
2962                    (const_string "TI"))
2963                (eq_attr "alternative" "4")
2964                  (if_then_else
2965                    (ior (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
2966                             (const_int 0))
2967                         (ne (symbol_ref "optimize_function_for_size_p (cfun)")
2968                             (const_int 0)))
2969                    (const_string "V4SF")
2970                    (const_string "TI"))]
2971                (const_string "DI")))])
2972
2973 (define_split
2974   [(set (match_operand:TI 0 "nonimmediate_operand" "")
2975         (match_operand:TI 1 "general_operand" ""))]
2976   "reload_completed && !SSE_REG_P (operands[0])
2977    && !SSE_REG_P (operands[1])"
2978   [(const_int 0)]
2979   "ix86_split_long_move (operands); DONE;")
2980
2981 ;; This expands to what emit_move_complex would generate if we didn't
2982 ;; have a movti pattern.  Having this avoids problems with reload on
2983 ;; 32-bit targets when SSE is present, but doesn't seem to be harmful
2984 ;; to have around all the time.
2985 (define_expand "movcdi"
2986   [(set (match_operand:CDI 0 "nonimmediate_operand" "")
2987         (match_operand:CDI 1 "general_operand" ""))]
2988   ""
2989 {
2990   if (push_operand (operands[0], CDImode))
2991     emit_move_complex_push (CDImode, operands[0], operands[1]);
2992   else
2993     emit_move_complex_parts (operands[0], operands[1]);
2994   DONE;
2995 })
2996
2997 (define_expand "movsf"
2998   [(set (match_operand:SF 0 "nonimmediate_operand" "")
2999         (match_operand:SF 1 "general_operand" ""))]
3000   ""
3001   "ix86_expand_move (SFmode, operands); DONE;")
3002
3003 (define_insn "*pushsf"
3004   [(set (match_operand:SF 0 "push_operand" "=<,<,<")
3005         (match_operand:SF 1 "general_no_elim_operand" "f,rFm,x"))]
3006   "!TARGET_64BIT"
3007 {
3008   /* Anything else should be already split before reg-stack.  */
3009   gcc_assert (which_alternative == 1);
3010   return "push{l}\t%1";
3011 }
3012   [(set_attr "type" "multi,push,multi")
3013    (set_attr "unit" "i387,*,*")
3014    (set_attr "mode" "SF,SI,SF")])
3015
3016 (define_insn "*pushsf_rex64"
3017   [(set (match_operand:SF 0 "push_operand" "=X,X,X")
3018         (match_operand:SF 1 "nonmemory_no_elim_operand" "f,rF,x"))]
3019   "TARGET_64BIT"
3020 {
3021   /* Anything else should be already split before reg-stack.  */
3022   gcc_assert (which_alternative == 1);
3023   return "push{q}\t%q1";
3024 }
3025   [(set_attr "type" "multi,push,multi")
3026    (set_attr "unit" "i387,*,*")
3027    (set_attr "mode" "SF,DI,SF")])
3028
3029 (define_split
3030   [(set (match_operand:SF 0 "push_operand" "")
3031         (match_operand:SF 1 "memory_operand" ""))]
3032   "reload_completed
3033    && MEM_P (operands[1])
3034    && (operands[2] = find_constant_src (insn))"
3035   [(set (match_dup 0)
3036         (match_dup 2))])
3037
3038 ;; %%% Kill this when call knows how to work this out.
3039 (define_split
3040   [(set (match_operand:SF 0 "push_operand" "")
3041         (match_operand:SF 1 "any_fp_register_operand" ""))]
3042   "!TARGET_64BIT"
3043   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int -4)))
3044    (set (mem:SF (reg:SI SP_REG)) (match_dup 1))])
3045
3046 (define_split
3047   [(set (match_operand:SF 0 "push_operand" "")
3048         (match_operand:SF 1 "any_fp_register_operand" ""))]
3049   "TARGET_64BIT"
3050   [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int -8)))
3051    (set (mem:SF (reg:DI SP_REG)) (match_dup 1))])
3052
3053 (define_insn "*movsf_1"
3054   [(set (match_operand:SF 0 "nonimmediate_operand"
3055           "=f,m,f,r  ,m ,x,x,x ,m,!*y,!m,!*y,?Yi,?r,!*Ym,!r")
3056         (match_operand:SF 1 "general_operand"
3057           "fm,f,G,rmF,Fr,C,x,xm,x,m  ,*y,*y ,r  ,Yi,r   ,*Ym"))]
3058   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
3059    && (reload_in_progress || reload_completed
3060        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3061        || (!TARGET_SSE_MATH && optimize_function_for_size_p (cfun)
3062            && standard_80387_constant_p (operands[1]))
3063        || GET_CODE (operands[1]) != CONST_DOUBLE
3064        || memory_operand (operands[0], SFmode))"
3065 {
3066   switch (which_alternative)
3067     {
3068     case 0:
3069     case 1:
3070       return output_387_reg_move (insn, operands);
3071
3072     case 2:
3073       return standard_80387_constant_opcode (operands[1]);
3074
3075     case 3:
3076     case 4:
3077       return "mov{l}\t{%1, %0|%0, %1}";
3078     case 5:
3079       if (get_attr_mode (insn) == MODE_TI)
3080         return "%vpxor\t%0, %d0";
3081       else
3082         return "%vxorps\t%0, %d0";
3083     case 6:
3084       if (get_attr_mode (insn) == MODE_V4SF)
3085         return "%vmovaps\t{%1, %0|%0, %1}";
3086       else
3087         return "%vmovss\t{%1, %d0|%d0, %1}";
3088     case 7:
3089       if (TARGET_AVX)
3090         return REG_P (operands[1]) ? "vmovss\t{%1, %0, %0|%0, %0, %1}"
3091                                    : "vmovss\t{%1, %0|%0, %1}";
3092       else
3093         return "movss\t{%1, %0|%0, %1}";
3094     case 8:
3095       return "%vmovss\t{%1, %0|%0, %1}";
3096
3097     case 9: case 10: case 14: case 15:
3098       return "movd\t{%1, %0|%0, %1}";
3099     case 12: case 13:
3100       return "%vmovd\t{%1, %0|%0, %1}";
3101
3102     case 11:
3103       return "movq\t{%1, %0|%0, %1}";
3104
3105     default:
3106       gcc_unreachable ();
3107     }
3108 }
3109   [(set_attr "type" "fmov,fmov,fmov,imov,imov,sselog1,ssemov,ssemov,ssemov,mmxmov,mmxmov,mmxmov,ssemov,ssemov,mmxmov,mmxmov")
3110    (set (attr "prefix")
3111      (if_then_else (eq_attr "alternative" "5,6,7,8,12,13")
3112        (const_string "maybe_vex")
3113        (const_string "orig")))
3114    (set (attr "mode")
3115         (cond [(eq_attr "alternative" "3,4,9,10")
3116                  (const_string "SI")
3117                (eq_attr "alternative" "5")
3118                  (if_then_else
3119                    (and (and (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3120                                  (const_int 0))
3121                              (ne (symbol_ref "TARGET_SSE2")
3122                                  (const_int 0)))
3123                         (eq (symbol_ref "optimize_function_for_size_p (cfun)")
3124                             (const_int 0)))
3125                    (const_string "TI")
3126                    (const_string "V4SF"))
3127                /* For architectures resolving dependencies on
3128                   whole SSE registers use APS move to break dependency
3129                   chains, otherwise use short move to avoid extra work.
3130
3131                   Do the same for architectures resolving dependencies on
3132                   the parts.  While in DF mode it is better to always handle
3133                   just register parts, the SF mode is different due to lack
3134                   of instructions to load just part of the register.  It is
3135                   better to maintain the whole registers in single format
3136                   to avoid problems on using packed logical operations.  */
3137                (eq_attr "alternative" "6")
3138                  (if_then_else
3139                    (ior (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3140                             (const_int 0))
3141                         (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3142                             (const_int 0)))
3143                    (const_string "V4SF")
3144                    (const_string "SF"))
3145                (eq_attr "alternative" "11")
3146                  (const_string "DI")]
3147                (const_string "SF")))])
3148
3149 (define_insn "*swapsf"
3150   [(set (match_operand:SF 0 "fp_register_operand" "+f")
3151         (match_operand:SF 1 "fp_register_operand" "+f"))
3152    (set (match_dup 1)
3153         (match_dup 0))]
3154   "reload_completed || TARGET_80387"
3155 {
3156   if (STACK_TOP_P (operands[0]))
3157     return "fxch\t%1";
3158   else
3159     return "fxch\t%0";
3160 }
3161   [(set_attr "type" "fxch")
3162    (set_attr "mode" "SF")])
3163
3164 (define_expand "movdf"
3165   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3166         (match_operand:DF 1 "general_operand" ""))]
3167   ""
3168   "ix86_expand_move (DFmode, operands); DONE;")
3169
3170 ;; Size of pushdf is 3 (for sub) + 2 (for fstp) + memory operand size.
3171 ;; Size of pushdf using integer instructions is 2+2*memory operand size
3172 ;; On the average, pushdf using integers can be still shorter.  Allow this
3173 ;; pattern for optimize_size too.
3174
3175 (define_insn "*pushdf_nointeger"
3176   [(set (match_operand:DF 0 "push_operand" "=<,<,<,<")
3177         (match_operand:DF 1 "general_no_elim_operand" "f,Fo,*r,Y2"))]
3178   "!TARGET_64BIT && !TARGET_INTEGER_DFMODE_MOVES"
3179 {
3180   /* This insn should be already split before reg-stack.  */
3181   gcc_unreachable ();
3182 }
3183   [(set_attr "type" "multi")
3184    (set_attr "unit" "i387,*,*,*")
3185    (set_attr "mode" "DF,SI,SI,DF")])
3186
3187 (define_insn "*pushdf_integer"
3188   [(set (match_operand:DF 0 "push_operand" "=<,<,<")
3189         (match_operand:DF 1 "general_no_elim_operand" "f,rFo,Y2"))]
3190   "TARGET_64BIT || TARGET_INTEGER_DFMODE_MOVES"
3191 {
3192   /* This insn should be already split before reg-stack.  */
3193   gcc_unreachable ();
3194 }
3195   [(set_attr "type" "multi")
3196    (set_attr "unit" "i387,*,*")
3197    (set_attr "mode" "DF,SI,DF")])
3198
3199 ;; %%% Kill this when call knows how to work this out.
3200 (define_split
3201   [(set (match_operand:DF 0 "push_operand" "")
3202         (match_operand:DF 1 "any_fp_register_operand" ""))]
3203   "reload_completed"
3204   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -8)))
3205    (set (mem:DF (reg:P SP_REG)) (match_dup 1))]
3206   "")
3207
3208 (define_split
3209   [(set (match_operand:DF 0 "push_operand" "")
3210         (match_operand:DF 1 "general_operand" ""))]
3211   "reload_completed"
3212   [(const_int 0)]
3213   "ix86_split_long_move (operands); DONE;")
3214
3215 ;; Moving is usually shorter when only FP registers are used. This separate
3216 ;; movdf pattern avoids the use of integer registers for FP operations
3217 ;; when optimizing for size.
3218
3219 (define_insn "*movdf_nointeger"
3220   [(set (match_operand:DF 0 "nonimmediate_operand"
3221                         "=f,m,f,*r  ,o  ,Y2*x,Y2*x,Y2*x ,m  ")
3222         (match_operand:DF 1 "general_operand"
3223                         "fm,f,G,*roF,*Fr,C   ,Y2*x,mY2*x,Y2*x"))]
3224   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
3225    && ((optimize_function_for_size_p (cfun)
3226        || !TARGET_INTEGER_DFMODE_MOVES) && !TARGET_64BIT)
3227    && (reload_in_progress || reload_completed
3228        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3229        || (!(TARGET_SSE2 && TARGET_SSE_MATH)
3230            && optimize_function_for_size_p (cfun)
3231            && !memory_operand (operands[0], DFmode)
3232            && standard_80387_constant_p (operands[1]))
3233        || GET_CODE (operands[1]) != CONST_DOUBLE
3234        || ((optimize_function_for_size_p (cfun)
3235             || !TARGET_MEMORY_MISMATCH_STALL
3236             || reload_in_progress || reload_completed)
3237            && memory_operand (operands[0], DFmode)))"
3238 {
3239   switch (which_alternative)
3240     {
3241     case 0:
3242     case 1:
3243       return output_387_reg_move (insn, operands);
3244
3245     case 2:
3246       return standard_80387_constant_opcode (operands[1]);
3247
3248     case 3:
3249     case 4:
3250       return "#";
3251     case 5:
3252       switch (get_attr_mode (insn))
3253         {
3254         case MODE_V4SF:
3255           return "%vxorps\t%0, %d0";
3256         case MODE_V2DF:
3257           return "%vxorpd\t%0, %d0";
3258         case MODE_TI:
3259           return "%vpxor\t%0, %d0";
3260         default:
3261           gcc_unreachable ();
3262         }
3263     case 6:
3264     case 7:
3265     case 8:
3266       switch (get_attr_mode (insn))
3267         {
3268         case MODE_V4SF:
3269           return "%vmovaps\t{%1, %0|%0, %1}";
3270         case MODE_V2DF:
3271           return "%vmovapd\t{%1, %0|%0, %1}";
3272         case MODE_TI:
3273           return "%vmovdqa\t{%1, %0|%0, %1}";
3274         case MODE_DI:
3275           return "%vmovq\t{%1, %0|%0, %1}";
3276         case MODE_DF:
3277           if (TARGET_AVX)
3278             {
3279               if (REG_P (operands[0]) && REG_P (operands[1]))
3280                 return "vmovsd\t{%1, %0, %0|%0, %0, %1}";
3281               else
3282                 return "vmovsd\t{%1, %0|%0, %1}";
3283             }
3284           else
3285             return "movsd\t{%1, %0|%0, %1}";
3286         case MODE_V1DF:
3287           if (TARGET_AVX)
3288             {
3289               if (REG_P (operands[0]))
3290                 return "vmovlpd\t{%1, %0, %0|%0, %0, %1}";
3291               else
3292                 return "vmovlpd\t{%1, %0|%0, %1}";
3293             }
3294           else
3295             return "movlpd\t{%1, %0|%0, %1}";
3296         case MODE_V2SF:
3297           if (TARGET_AVX)
3298             {
3299               if (REG_P (operands[0]))
3300                 return "vmovlps\t{%1, %0, %0|%0, %0, %1}";
3301               else
3302                 return "vmovlps\t{%1, %0|%0, %1}";
3303             }
3304           else
3305             return "movlps\t{%1, %0|%0, %1}";
3306         default:
3307           gcc_unreachable ();
3308         }
3309
3310     default:
3311       gcc_unreachable ();
3312     }
3313 }
3314   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov")
3315    (set (attr "prefix")
3316      (if_then_else (eq_attr "alternative" "0,1,2,3,4")
3317        (const_string "orig")
3318        (const_string "maybe_vex")))
3319    (set (attr "prefix_data16")
3320      (if_then_else (eq_attr "mode" "V1DF")
3321        (const_string "1")
3322        (const_string "*")))
3323    (set (attr "mode")
3324         (cond [(eq_attr "alternative" "0,1,2")
3325                  (const_string "DF")
3326                (eq_attr "alternative" "3,4")
3327                  (const_string "SI")
3328
3329                /* For SSE1, we have many fewer alternatives.  */
3330                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
3331                  (cond [(eq_attr "alternative" "5,6")
3332                           (const_string "V4SF")
3333                        ]
3334                    (const_string "V2SF"))
3335
3336                /* xorps is one byte shorter.  */
3337                (eq_attr "alternative" "5")
3338                  (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3339                             (const_int 0))
3340                           (const_string "V4SF")
3341                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3342                             (const_int 0))
3343                           (const_string "TI")
3344                        ]
3345                        (const_string "V2DF"))
3346
3347                /* For architectures resolving dependencies on
3348                   whole SSE registers use APD move to break dependency
3349                   chains, otherwise use short move to avoid extra work.
3350
3351                   movaps encodes one byte shorter.  */
3352                (eq_attr "alternative" "6")
3353                  (cond
3354                    [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3355                         (const_int 0))
3356                       (const_string "V4SF")
3357                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3358                         (const_int 0))
3359                       (const_string "V2DF")
3360                    ]
3361                    (const_string "DF"))
3362                /* For architectures resolving dependencies on register
3363                   parts we may avoid extra work to zero out upper part
3364                   of register.  */
3365                (eq_attr "alternative" "7")
3366                  (if_then_else
3367                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3368                        (const_int 0))
3369                    (const_string "V1DF")
3370                    (const_string "DF"))
3371               ]
3372               (const_string "DF")))])
3373
3374 (define_insn "*movdf_integer_rex64"
3375   [(set (match_operand:DF 0 "nonimmediate_operand"
3376                 "=f,m,f,r  ,m ,Y2*x,Y2*x,Y2*x,m   ,Yi,r ")
3377         (match_operand:DF 1 "general_operand"
3378                 "fm,f,G,rmF,Fr,C   ,Y2*x,m   ,Y2*x,r ,Yi"))]
3379   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3380    && (reload_in_progress || reload_completed
3381        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3382        || (!(TARGET_SSE2 && TARGET_SSE_MATH)
3383            && optimize_function_for_size_p (cfun)
3384            && standard_80387_constant_p (operands[1]))
3385        || GET_CODE (operands[1]) != CONST_DOUBLE
3386        || memory_operand (operands[0], DFmode))"
3387 {
3388   switch (which_alternative)
3389     {
3390     case 0:
3391     case 1:
3392       return output_387_reg_move (insn, operands);
3393
3394     case 2:
3395       return standard_80387_constant_opcode (operands[1]);
3396
3397     case 3:
3398     case 4:
3399       return "#";
3400
3401     case 5:
3402       switch (get_attr_mode (insn))
3403         {
3404         case MODE_V4SF:
3405           return "%vxorps\t%0, %d0";
3406         case MODE_V2DF:
3407           return "%vxorpd\t%0, %d0";
3408         case MODE_TI:
3409           return "%vpxor\t%0, %d0";
3410         default:
3411           gcc_unreachable ();
3412         }
3413     case 6:
3414     case 7:
3415     case 8:
3416       switch (get_attr_mode (insn))
3417         {
3418         case MODE_V4SF:
3419           return "%vmovaps\t{%1, %0|%0, %1}";
3420         case MODE_V2DF:
3421           return "%vmovapd\t{%1, %0|%0, %1}";
3422         case MODE_TI:
3423           return "%vmovdqa\t{%1, %0|%0, %1}";
3424         case MODE_DI:
3425           return "%vmovq\t{%1, %0|%0, %1}";
3426         case MODE_DF:
3427           if (TARGET_AVX)
3428             {
3429               if (REG_P (operands[0]) && REG_P (operands[1]))
3430                 return "vmovsd\t{%1, %0, %0|%0, %0, %1}";
3431               else
3432                 return "vmovsd\t{%1, %0|%0, %1}";
3433             }
3434           else
3435             return "movsd\t{%1, %0|%0, %1}";
3436         case MODE_V1DF:
3437           return "%vmovlpd\t{%1, %d0|%d0, %1}";
3438         case MODE_V2SF:
3439           return "%vmovlps\t{%1, %d0|%d0, %1}";
3440         default:
3441           gcc_unreachable ();
3442         }
3443
3444     case 9:
3445     case 10:
3446     return "%vmovd\t{%1, %0|%0, %1}";
3447
3448     default:
3449       gcc_unreachable();
3450     }
3451 }
3452   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov,ssemov,ssemov")
3453    (set (attr "prefix")
3454      (if_then_else (eq_attr "alternative" "0,1,2,3,4")
3455        (const_string "orig")
3456        (const_string "maybe_vex")))
3457    (set (attr "prefix_data16")
3458      (if_then_else (eq_attr "mode" "V1DF")
3459        (const_string "1")
3460        (const_string "*")))
3461    (set (attr "mode")
3462         (cond [(eq_attr "alternative" "0,1,2")
3463                  (const_string "DF")
3464                (eq_attr "alternative" "3,4,9,10")
3465                  (const_string "DI")
3466
3467                /* For SSE1, we have many fewer alternatives.  */
3468                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
3469                  (cond [(eq_attr "alternative" "5,6")
3470                           (const_string "V4SF")
3471                        ]
3472                    (const_string "V2SF"))
3473
3474                /* xorps is one byte shorter.  */
3475                (eq_attr "alternative" "5")
3476                  (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3477                             (const_int 0))
3478                           (const_string "V4SF")
3479                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3480                             (const_int 0))
3481                           (const_string "TI")
3482                        ]
3483                        (const_string "V2DF"))
3484
3485                /* For architectures resolving dependencies on
3486                   whole SSE registers use APD move to break dependency
3487                   chains, otherwise use short move to avoid extra work.
3488
3489                   movaps encodes one byte shorter.  */
3490                (eq_attr "alternative" "6")
3491                  (cond
3492                    [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3493                         (const_int 0))
3494                       (const_string "V4SF")
3495                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3496                         (const_int 0))
3497                       (const_string "V2DF")
3498                    ]
3499                    (const_string "DF"))
3500                /* For architectures resolving dependencies on register
3501                   parts we may avoid extra work to zero out upper part
3502                   of register.  */
3503                (eq_attr "alternative" "7")
3504                  (if_then_else
3505                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3506                        (const_int 0))
3507                    (const_string "V1DF")
3508                    (const_string "DF"))
3509               ]
3510               (const_string "DF")))])
3511
3512 (define_insn "*movdf_integer"
3513   [(set (match_operand:DF 0 "nonimmediate_operand"
3514                 "=f,m,f,r  ,o ,Y2*x,Y2*x,Y2*x,m   ")
3515         (match_operand:DF 1 "general_operand"
3516                 "fm,f,G,roF,Fr,C   ,Y2*x,m   ,Y2*x"))]
3517   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
3518    && optimize_function_for_speed_p (cfun)
3519    && TARGET_INTEGER_DFMODE_MOVES
3520    && (reload_in_progress || reload_completed
3521        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3522        || (!(TARGET_SSE2 && TARGET_SSE_MATH)
3523            && optimize_function_for_size_p (cfun)
3524            && standard_80387_constant_p (operands[1]))
3525        || GET_CODE (operands[1]) != CONST_DOUBLE
3526        || memory_operand (operands[0], DFmode))"
3527 {
3528   switch (which_alternative)
3529     {
3530     case 0:
3531     case 1:
3532       return output_387_reg_move (insn, operands);
3533
3534     case 2:
3535       return standard_80387_constant_opcode (operands[1]);
3536
3537     case 3:
3538     case 4:
3539       return "#";
3540
3541     case 5:
3542       switch (get_attr_mode (insn))
3543         {
3544         case MODE_V4SF:
3545           return "xorps\t%0, %0";
3546         case MODE_V2DF:
3547           return "xorpd\t%0, %0";
3548         case MODE_TI:
3549           return "pxor\t%0, %0";
3550         default:
3551           gcc_unreachable ();
3552         }
3553     case 6:
3554     case 7:
3555     case 8:
3556       switch (get_attr_mode (insn))
3557         {
3558         case MODE_V4SF:
3559           return "movaps\t{%1, %0|%0, %1}";
3560         case MODE_V2DF:
3561           return "movapd\t{%1, %0|%0, %1}";
3562         case MODE_TI:
3563           return "movdqa\t{%1, %0|%0, %1}";
3564         case MODE_DI:
3565           return "movq\t{%1, %0|%0, %1}";
3566         case MODE_DF:
3567           return "movsd\t{%1, %0|%0, %1}";
3568         case MODE_V1DF:
3569           return "movlpd\t{%1, %0|%0, %1}";
3570         case MODE_V2SF:
3571           return "movlps\t{%1, %0|%0, %1}";
3572         default:
3573           gcc_unreachable ();
3574         }
3575
3576     default:
3577       gcc_unreachable();
3578     }
3579 }
3580   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov")
3581    (set (attr "prefix_data16")
3582      (if_then_else (eq_attr "mode" "V1DF")
3583        (const_string "1")
3584        (const_string "*")))
3585    (set (attr "mode")
3586         (cond [(eq_attr "alternative" "0,1,2")
3587                  (const_string "DF")
3588                (eq_attr "alternative" "3,4")
3589                  (const_string "SI")
3590
3591                /* For SSE1, we have many fewer alternatives.  */
3592                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
3593                  (cond [(eq_attr "alternative" "5,6")
3594                           (const_string "V4SF")
3595                        ]
3596                    (const_string "V2SF"))
3597
3598                /* xorps is one byte shorter.  */
3599                (eq_attr "alternative" "5")
3600                  (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3601                             (const_int 0))
3602                           (const_string "V4SF")
3603                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3604                             (const_int 0))
3605                           (const_string "TI")
3606                        ]
3607                        (const_string "V2DF"))
3608
3609                /* For architectures resolving dependencies on
3610                   whole SSE registers use APD move to break dependency
3611                   chains, otherwise use short move to avoid extra work.
3612
3613                   movaps encodes one byte shorter.  */
3614                (eq_attr "alternative" "6")
3615                  (cond
3616                    [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3617                         (const_int 0))
3618                       (const_string "V4SF")
3619                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3620                         (const_int 0))
3621                       (const_string "V2DF")
3622                    ]
3623                    (const_string "DF"))
3624                /* For architectures resolving dependencies on register
3625                   parts we may avoid extra work to zero out upper part
3626                   of register.  */
3627                (eq_attr "alternative" "7")
3628                  (if_then_else
3629                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3630                        (const_int 0))
3631                    (const_string "V1DF")
3632                    (const_string "DF"))
3633               ]
3634               (const_string "DF")))])
3635
3636 (define_split
3637   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3638         (match_operand:DF 1 "general_operand" ""))]
3639   "reload_completed
3640    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3641    && ! (ANY_FP_REG_P (operands[0]) ||
3642          (GET_CODE (operands[0]) == SUBREG
3643           && ANY_FP_REG_P (SUBREG_REG (operands[0]))))
3644    && ! (ANY_FP_REG_P (operands[1]) ||
3645          (GET_CODE (operands[1]) == SUBREG
3646           && ANY_FP_REG_P (SUBREG_REG (operands[1]))))"
3647   [(const_int 0)]
3648   "ix86_split_long_move (operands); DONE;")
3649
3650 (define_insn "*swapdf"
3651   [(set (match_operand:DF 0 "fp_register_operand" "+f")
3652         (match_operand:DF 1 "fp_register_operand" "+f"))
3653    (set (match_dup 1)
3654         (match_dup 0))]
3655   "reload_completed || TARGET_80387"
3656 {
3657   if (STACK_TOP_P (operands[0]))
3658     return "fxch\t%1";
3659   else
3660     return "fxch\t%0";
3661 }
3662   [(set_attr "type" "fxch")
3663    (set_attr "mode" "DF")])
3664
3665 (define_expand "movxf"
3666   [(set (match_operand:XF 0 "nonimmediate_operand" "")
3667         (match_operand:XF 1 "general_operand" ""))]
3668   ""
3669   "ix86_expand_move (XFmode, operands); DONE;")
3670
3671 ;; Size of pushdf is 3 (for sub) + 2 (for fstp) + memory operand size.
3672 ;; Size of pushdf using integer instructions is 3+3*memory operand size
3673 ;; Pushing using integer instructions is longer except for constants
3674 ;; and direct memory references.
3675 ;; (assuming that any given constant is pushed only once, but this ought to be
3676 ;;  handled elsewhere).
3677
3678 (define_insn "*pushxf_nointeger"
3679   [(set (match_operand:XF 0 "push_operand" "=X,X,X")
3680         (match_operand:XF 1 "general_no_elim_operand" "f,Fo,*r"))]
3681   "optimize_function_for_size_p (cfun)"
3682 {
3683   /* This insn should be already split before reg-stack.  */
3684   gcc_unreachable ();
3685 }
3686   [(set_attr "type" "multi")
3687    (set_attr "unit" "i387,*,*")
3688    (set_attr "mode" "XF,SI,SI")])
3689
3690 (define_insn "*pushxf_integer"
3691   [(set (match_operand:XF 0 "push_operand" "=<,<")
3692         (match_operand:XF 1 "general_no_elim_operand" "f,ro"))]
3693   "optimize_function_for_speed_p (cfun)"
3694 {
3695   /* This insn should be already split before reg-stack.  */
3696   gcc_unreachable ();
3697 }
3698   [(set_attr "type" "multi")
3699    (set_attr "unit" "i387,*")
3700    (set_attr "mode" "XF,SI")])
3701
3702 (define_split
3703   [(set (match_operand 0 "push_operand" "")
3704         (match_operand 1 "general_operand" ""))]
3705   "reload_completed
3706    && (GET_MODE (operands[0]) == XFmode
3707        || GET_MODE (operands[0]) == DFmode)
3708    && !ANY_FP_REG_P (operands[1])"
3709   [(const_int 0)]
3710   "ix86_split_long_move (operands); DONE;")
3711
3712 (define_split
3713   [(set (match_operand:XF 0 "push_operand" "")
3714         (match_operand:XF 1 "any_fp_register_operand" ""))]
3715   ""
3716   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
3717    (set (mem:XF (reg:P SP_REG)) (match_dup 1))]
3718   "operands[2] = GEN_INT (TARGET_128BIT_LONG_DOUBLE ? -16 : -12);")
3719
3720 ;; Do not use integer registers when optimizing for size
3721 (define_insn "*movxf_nointeger"
3722   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,*r,o")
3723         (match_operand:XF 1 "general_operand" "fm,f,G,*roF,F*r"))]
3724   "optimize_function_for_size_p (cfun)
3725    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3726    && (reload_in_progress || reload_completed
3727        || standard_80387_constant_p (operands[1])
3728        || GET_CODE (operands[1]) != CONST_DOUBLE
3729        || memory_operand (operands[0], XFmode))"
3730 {
3731   switch (which_alternative)
3732     {
3733     case 0:
3734     case 1:
3735       return output_387_reg_move (insn, operands);
3736
3737     case 2:
3738       return standard_80387_constant_opcode (operands[1]);
3739
3740     case 3: case 4:
3741       return "#";
3742     default:
3743       gcc_unreachable ();
3744     }
3745 }
3746   [(set_attr "type" "fmov,fmov,fmov,multi,multi")
3747    (set_attr "mode" "XF,XF,XF,SI,SI")])
3748
3749 (define_insn "*movxf_integer"
3750   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,r,o")
3751         (match_operand:XF 1 "general_operand" "fm,f,G,roF,Fr"))]
3752   "optimize_function_for_speed_p (cfun)
3753    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3754    && (reload_in_progress || reload_completed
3755        || GET_CODE (operands[1]) != CONST_DOUBLE
3756        || memory_operand (operands[0], XFmode))"
3757 {
3758   switch (which_alternative)
3759     {
3760     case 0:
3761     case 1:
3762       return output_387_reg_move (insn, operands);
3763
3764     case 2:
3765       return standard_80387_constant_opcode (operands[1]);
3766
3767     case 3: case 4:
3768       return "#";
3769
3770     default:
3771       gcc_unreachable ();
3772     }
3773 }
3774   [(set_attr "type" "fmov,fmov,fmov,multi,multi")
3775    (set_attr "mode" "XF,XF,XF,SI,SI")])
3776
3777 (define_expand "movtf"
3778   [(set (match_operand:TF 0 "nonimmediate_operand" "")
3779         (match_operand:TF 1 "nonimmediate_operand" ""))]
3780   "TARGET_SSE2"
3781 {
3782   ix86_expand_move (TFmode, operands);
3783   DONE;
3784 })
3785
3786 (define_insn "*movtf_internal"
3787   [(set (match_operand:TF 0 "nonimmediate_operand" "=x,m,x,?r,?o")
3788         (match_operand:TF 1 "general_operand" "xm,x,C,roF,Fr"))]
3789   "TARGET_SSE2
3790    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
3791 {
3792   switch (which_alternative)
3793     {
3794     case 0:
3795     case 1:
3796       if (get_attr_mode (insn) == MODE_V4SF)
3797         return "%vmovaps\t{%1, %0|%0, %1}";
3798       else
3799         return "%vmovdqa\t{%1, %0|%0, %1}";
3800     case 2:
3801       if (get_attr_mode (insn) == MODE_V4SF)
3802         return "%vxorps\t%0, %d0";
3803       else
3804         return "%vpxor\t%0, %d0";
3805     case 3:
3806     case 4:
3807         return "#";
3808     default:
3809       gcc_unreachable ();
3810     }
3811 }
3812   [(set_attr "type" "ssemov,ssemov,sselog1,*,*")
3813    (set_attr "prefix" "maybe_vex,maybe_vex,maybe_vex,*,*")
3814    (set (attr "mode")
3815         (cond [(eq_attr "alternative" "0,2")
3816                  (if_then_else
3817                    (ne (symbol_ref "optimize_function_for_size_p (cfun)")
3818                        (const_int 0))
3819                    (const_string "V4SF")
3820                    (const_string "TI"))
3821                (eq_attr "alternative" "1")
3822                  (if_then_else
3823                    (ior (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
3824                             (const_int 0))
3825                         (ne (symbol_ref "optimize_function_for_size_p (cfun)")
3826                             (const_int 0)))
3827                    (const_string "V4SF")
3828                    (const_string "TI"))]
3829                (const_string "DI")))])
3830
3831 (define_insn "*pushtf_sse"
3832   [(set (match_operand:TF 0 "push_operand" "=<,<,<")
3833         (match_operand:TF 1 "general_no_elim_operand" "x,Fo,*r"))]
3834   "TARGET_SSE2"
3835 {
3836   /* This insn should be already split before reg-stack.  */
3837   gcc_unreachable ();
3838 }
3839   [(set_attr "type" "multi")
3840    (set_attr "unit" "sse,*,*")
3841    (set_attr "mode" "TF,SI,SI")])
3842
3843 (define_split
3844   [(set (match_operand:TF 0 "push_operand" "")
3845         (match_operand:TF 1 "general_operand" ""))]
3846   "TARGET_SSE2 && reload_completed
3847    && !SSE_REG_P (operands[1])"
3848   [(const_int 0)]
3849   "ix86_split_long_move (operands); DONE;")
3850
3851 (define_split
3852   [(set (match_operand:TF 0 "push_operand" "")
3853         (match_operand:TF 1 "any_fp_register_operand" ""))]
3854   "TARGET_SSE2"
3855   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -16)))
3856    (set (mem:TF (reg:P SP_REG)) (match_dup 1))]
3857   "")
3858
3859 (define_split