OSDN Git Service

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