OSDN Git Service

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