OSDN Git Service

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