OSDN Git Service

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