OSDN Git Service

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