OSDN Git Service

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