OSDN Git Service

* config/i386/i386.md (any_extend): New code iterator.
[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 ;; Used in signed and unsigned widening multiplications.
706 (define_code_iterator any_extend [sign_extend zero_extend])
707
708 ;; Various insn prefixes for widening operations.
709 (define_code_attr u [(sign_extend "") (zero_extend "u")])
710 (define_code_attr s [(sign_extend "s") (zero_extend "u")])
711
712 ;; Instruction prefix for widening operations.
713 (define_code_attr sgnprefix [(sign_extend "i") (zero_extend "")])
714
715 ;; All single word integer modes.
716 (define_mode_iterator SWI [QI HI SI (DI "TARGET_64BIT")])
717
718 ;; Single word integer modes without QImode.
719 (define_mode_iterator SWI248 [HI SI (DI "TARGET_64BIT")])
720
721 ;; Single word integer modes without QImode and HImode.
722 (define_mode_iterator SWI48 [SI (DI "TARGET_64BIT")])
723
724 ;; All math-dependant single and double word integer modes.
725 (define_mode_iterator SDWIM [(QI "TARGET_QIMODE_MATH")
726                              (HI "TARGET_HIMODE_MATH")
727                              SI DI (TI "TARGET_64BIT")])
728
729 ;; Math-dependant single word integer modes without QImode.
730 (define_mode_iterator SWIM248 [(HI "TARGET_HIMODE_MATH")
731                                SI (DI "TARGET_64BIT")])
732
733 ;; Half mode for double word integer modes.
734 (define_mode_iterator DWIH [(SI "!TARGET_64BIT")
735                             (DI "TARGET_64BIT")])
736
737 ;; Double word integer modes.
738 (define_mode_attr DWI [(SI "DI") (DI "TI")])
739 (define_mode_attr dwi [(SI "di") (DI "ti")])
740
741 ;; Instruction suffix for integer modes.
742 (define_mode_attr imodesuffix [(QI "b") (HI "w") (SI "l") (DI "q")])
743
744 ;; Register class for integer modes.
745 (define_mode_attr r [(QI "q") (HI "r") (SI "r") (DI "r")])
746
747 ;; Immediate operand constraint for integer modes.
748 (define_mode_attr i [(QI "n") (HI "n") (SI "i") (DI "e")])
749
750 ;; General operand constraint for word modes.
751 (define_mode_attr g [(SI "g") (DI "rme")])
752
753 ;; Immediate operand constraint for double integer modes.
754 (define_mode_attr di [(SI "iF") (DI "e")])
755
756 ;; General operand predicate for integer modes.
757 (define_mode_attr general_operand
758         [(QI "general_operand")
759          (HI "general_operand")
760          (SI "general_operand")
761          (DI "x86_64_general_operand")
762          (TI "x86_64_general_operand")])
763
764 ;; SSE and x87 SFmode and DFmode floating point modes
765 (define_mode_iterator MODEF [SF DF])
766
767 ;; All x87 floating point modes
768 (define_mode_iterator X87MODEF [SF DF XF])
769
770 ;; All integer modes handled by x87 fisttp operator.
771 (define_mode_iterator X87MODEI [HI SI DI])
772
773 ;; All integer modes handled by integer x87 operators.
774 (define_mode_iterator X87MODEI12 [HI SI])
775
776 ;; All integer modes handled by SSE cvtts?2si* operators.
777 (define_mode_iterator SSEMODEI24 [SI DI])
778
779 ;; SSE asm suffix for floating point modes
780 (define_mode_attr ssemodefsuffix [(SF "s") (DF "d")])
781
782 ;; SSE vector mode corresponding to a scalar mode
783 (define_mode_attr ssevecmode
784   [(QI "V16QI") (HI "V8HI") (SI "V4SI") (DI "V2DI") (SF "V4SF") (DF "V2DF")])
785
786 ;; Instruction suffix for REX 64bit operators.
787 (define_mode_attr rex64suffix [(SI "") (DI "{q}")])
788
789 ;; This mode iterator allows :P to be used for patterns that operate on
790 ;; pointer-sized quantities.  Exactly one of the two alternatives will match.
791 (define_mode_iterator P [(SI "Pmode == SImode") (DI "Pmode == DImode")])
792 \f
793 ;; Scheduling descriptions
794
795 (include "pentium.md")
796 (include "ppro.md")
797 (include "k6.md")
798 (include "athlon.md")
799 (include "geode.md")
800 (include "atom.md")
801
802 \f
803 ;; Operand and operator predicates and constraints
804
805 (include "predicates.md")
806 (include "constraints.md")
807
808 \f
809 ;; Compare and branch/compare and store instructions.
810
811 (define_expand "cbranchti4"
812   [(set (reg:CC FLAGS_REG)
813         (compare:CC (match_operand:TI 1 "nonimmediate_operand" "")
814                     (match_operand:TI 2 "x86_64_general_operand" "")))
815    (set (pc) (if_then_else
816               (match_operator 0 "comparison_operator"
817                [(reg:CC FLAGS_REG)
818                 (const_int 0)])
819               (label_ref (match_operand 3 "" ""))
820               (pc)))]
821   "TARGET_64BIT"
822 {
823   if (MEM_P (operands[1]) && MEM_P (operands[2]))
824     operands[1] = force_reg (TImode, operands[1]);
825   ix86_compare_op0 = operands[1];
826   ix86_compare_op1 = operands[2];
827   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
828   DONE;
829 })
830
831 (define_expand "cbranchdi4"
832   [(set (reg:CC FLAGS_REG)
833         (compare:CC (match_operand:DI 1 "nonimmediate_operand" "")
834                     (match_operand:DI 2 "x86_64_general_operand" "")))
835    (set (pc) (if_then_else
836               (match_operator 0 "comparison_operator"
837                [(reg:CC FLAGS_REG)
838                 (const_int 0)])
839               (label_ref (match_operand 3 "" ""))
840               (pc)))]
841   ""
842 {
843   if (MEM_P (operands[1]) && MEM_P (operands[2]))
844     operands[1] = force_reg (DImode, operands[1]);
845   ix86_compare_op0 = operands[1];
846   ix86_compare_op1 = operands[2];
847   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
848   DONE;
849 })
850
851 (define_expand "cstoredi4"
852   [(set (reg:CC FLAGS_REG)
853         (compare:CC (match_operand:DI 2 "nonimmediate_operand" "")
854                     (match_operand:DI 3 "x86_64_general_operand" "")))
855    (set (match_operand:QI 0 "register_operand" "")
856               (match_operator 1 "comparison_operator"
857                [(reg:CC FLAGS_REG)
858                 (const_int 0)]))]
859   "TARGET_64BIT"
860 {
861   if (MEM_P (operands[2]) && MEM_P (operands[3]))
862     operands[2] = force_reg (DImode, operands[2]);
863   ix86_compare_op0 = operands[2];
864   ix86_compare_op1 = operands[3];
865   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
866   DONE;
867 })
868
869 (define_expand "cbranchsi4"
870   [(set (reg:CC FLAGS_REG)
871         (compare:CC (match_operand:SI 1 "cmpsi_operand" "")
872                     (match_operand:SI 2 "general_operand" "")))
873    (set (pc) (if_then_else
874               (match_operator 0 "comparison_operator"
875                [(reg:CC FLAGS_REG)
876                 (const_int 0)])
877               (label_ref (match_operand 3 "" ""))
878               (pc)))]
879   ""
880 {
881   if (MEM_P (operands[1]) && MEM_P (operands[2]))
882     operands[1] = force_reg (SImode, operands[1]);
883   ix86_compare_op0 = operands[1];
884   ix86_compare_op1 = operands[2];
885   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
886   DONE;
887 })
888
889 (define_expand "cstoresi4"
890   [(set (reg:CC FLAGS_REG)
891         (compare:CC (match_operand:SI 2 "cmpsi_operand" "")
892                     (match_operand:SI 3 "general_operand" "")))
893    (set (match_operand:QI 0 "register_operand" "")
894               (match_operator 1 "comparison_operator"
895                [(reg:CC FLAGS_REG)
896                 (const_int 0)]))]
897   ""
898 {
899   if (MEM_P (operands[2]) && MEM_P (operands[3]))
900     operands[2] = force_reg (SImode, operands[2]);
901   ix86_compare_op0 = operands[2];
902   ix86_compare_op1 = operands[3];
903   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
904   DONE;
905 })
906
907 (define_expand "cbranchhi4"
908   [(set (reg:CC FLAGS_REG)
909         (compare:CC (match_operand:HI 1 "nonimmediate_operand" "")
910                     (match_operand:HI 2 "general_operand" "")))
911    (set (pc) (if_then_else
912               (match_operator 0 "comparison_operator"
913                [(reg:CC FLAGS_REG)
914                 (const_int 0)])
915               (label_ref (match_operand 3 "" ""))
916               (pc)))]
917   ""
918 {
919   if (MEM_P (operands[1]) && MEM_P (operands[2]))
920     operands[1] = force_reg (HImode, operands[1]);
921   ix86_compare_op0 = operands[1];
922   ix86_compare_op1 = operands[2];
923   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
924   DONE;
925 })
926
927 (define_expand "cstorehi4"
928   [(set (reg:CC FLAGS_REG)
929         (compare:CC (match_operand:HI 2 "nonimmediate_operand" "")
930                     (match_operand:HI 3 "general_operand" "")))
931    (set (match_operand:QI 0 "register_operand" "")
932               (match_operator 1 "comparison_operator"
933                [(reg:CC FLAGS_REG)
934                 (const_int 0)]))]
935   ""
936 {
937   if (MEM_P (operands[2]) && MEM_P (operands[3]))
938     operands[2] = force_reg (HImode, operands[2]);
939   ix86_compare_op0 = operands[2];
940   ix86_compare_op1 = operands[3];
941   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
942   DONE;
943 })
944
945
946 (define_expand "cbranchqi4"
947   [(set (reg:CC FLAGS_REG)
948         (compare:CC (match_operand:QI 1 "nonimmediate_operand" "")
949                     (match_operand:QI 2 "general_operand" "")))
950    (set (pc) (if_then_else
951               (match_operator 0 "comparison_operator"
952                [(reg:CC FLAGS_REG)
953                 (const_int 0)])
954               (label_ref (match_operand 3 "" ""))
955               (pc)))]
956   ""
957 {
958   if (MEM_P (operands[1]) && MEM_P (operands[2]))
959     operands[1] = force_reg (QImode, operands[1]);
960   ix86_compare_op0 = operands[1];
961   ix86_compare_op1 = operands[2];
962   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
963   DONE;
964 })
965
966
967 (define_expand "cstoreqi4"
968   [(set (reg:CC FLAGS_REG)
969         (compare:CC (match_operand:QI 2 "nonimmediate_operand" "")
970                     (match_operand:QI 3 "general_operand" "")))
971    (set (match_operand:QI 0 "register_operand" "")
972               (match_operator 1 "comparison_operator"
973                [(reg:CC FLAGS_REG)
974                 (const_int 0)]))]
975   ""
976 {
977   if (MEM_P (operands[2]) && MEM_P (operands[3]))
978     operands[2] = force_reg (QImode, operands[2]);
979   ix86_compare_op0 = operands[2];
980   ix86_compare_op1 = operands[3];
981   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
982   DONE;
983 })
984
985
986 (define_insn "cmpdi_ccno_1_rex64"
987   [(set (reg FLAGS_REG)
988         (compare (match_operand:DI 0 "nonimmediate_operand" "r,?mr")
989                  (match_operand:DI 1 "const0_operand" "")))]
990   "TARGET_64BIT && ix86_match_ccmode (insn, CCNOmode)"
991   "@
992    test{q}\t%0, %0
993    cmp{q}\t{%1, %0|%0, %1}"
994   [(set_attr "type" "test,icmp")
995    (set_attr "length_immediate" "0,1")
996    (set_attr "mode" "DI")])
997
998 (define_insn "*cmpdi_minus_1_rex64"
999   [(set (reg FLAGS_REG)
1000         (compare (minus:DI (match_operand:DI 0 "nonimmediate_operand" "rm,r")
1001                            (match_operand:DI 1 "x86_64_general_operand" "re,mr"))
1002                  (const_int 0)))]
1003   "TARGET_64BIT && ix86_match_ccmode (insn, CCGOCmode)"
1004   "cmp{q}\t{%1, %0|%0, %1}"
1005   [(set_attr "type" "icmp")
1006    (set_attr "mode" "DI")])
1007
1008 (define_expand "cmpdi_1_rex64"
1009   [(set (reg:CC FLAGS_REG)
1010         (compare:CC (match_operand:DI 0 "nonimmediate_operand" "")
1011                     (match_operand:DI 1 "general_operand" "")))]
1012   "TARGET_64BIT"
1013   "")
1014
1015 (define_insn "cmpdi_1_insn_rex64"
1016   [(set (reg FLAGS_REG)
1017         (compare (match_operand:DI 0 "nonimmediate_operand" "mr,r")
1018                  (match_operand:DI 1 "x86_64_general_operand" "re,mr")))]
1019   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1020   "cmp{q}\t{%1, %0|%0, %1}"
1021   [(set_attr "type" "icmp")
1022    (set_attr "mode" "DI")])
1023
1024
1025 (define_insn "*cmpsi_ccno_1"
1026   [(set (reg FLAGS_REG)
1027         (compare (match_operand:SI 0 "nonimmediate_operand" "r,?mr")
1028                  (match_operand:SI 1 "const0_operand" "")))]
1029   "ix86_match_ccmode (insn, CCNOmode)"
1030   "@
1031    test{l}\t%0, %0
1032    cmp{l}\t{%1, %0|%0, %1}"
1033   [(set_attr "type" "test,icmp")
1034    (set_attr "length_immediate" "0,1")
1035    (set_attr "mode" "SI")])
1036
1037 (define_insn "*cmpsi_minus_1"
1038   [(set (reg FLAGS_REG)
1039         (compare (minus:SI (match_operand:SI 0 "nonimmediate_operand" "rm,r")
1040                            (match_operand:SI 1 "general_operand" "ri,mr"))
1041                  (const_int 0)))]
1042   "ix86_match_ccmode (insn, CCGOCmode)"
1043   "cmp{l}\t{%1, %0|%0, %1}"
1044   [(set_attr "type" "icmp")
1045    (set_attr "mode" "SI")])
1046
1047 (define_expand "cmpsi_1"
1048   [(set (reg:CC FLAGS_REG)
1049         (compare:CC (match_operand:SI 0 "nonimmediate_operand" "")
1050                     (match_operand:SI 1 "general_operand" "")))]
1051   ""
1052   "")
1053
1054 (define_insn "*cmpsi_1_insn"
1055   [(set (reg FLAGS_REG)
1056         (compare (match_operand:SI 0 "nonimmediate_operand" "rm,r")
1057                  (match_operand:SI 1 "general_operand" "ri,mr")))]
1058   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
1059     && ix86_match_ccmode (insn, CCmode)"
1060   "cmp{l}\t{%1, %0|%0, %1}"
1061   [(set_attr "type" "icmp")
1062    (set_attr "mode" "SI")])
1063
1064 (define_insn "*cmphi_ccno_1"
1065   [(set (reg FLAGS_REG)
1066         (compare (match_operand:HI 0 "nonimmediate_operand" "r,?mr")
1067                  (match_operand:HI 1 "const0_operand" "")))]
1068   "ix86_match_ccmode (insn, CCNOmode)"
1069   "@
1070    test{w}\t%0, %0
1071    cmp{w}\t{%1, %0|%0, %1}"
1072   [(set_attr "type" "test,icmp")
1073    (set_attr "length_immediate" "0,1")
1074    (set_attr "mode" "HI")])
1075
1076 (define_insn "*cmphi_minus_1"
1077   [(set (reg FLAGS_REG)
1078         (compare (minus:HI (match_operand:HI 0 "nonimmediate_operand" "rm,r")
1079                            (match_operand:HI 1 "general_operand" "rn,mr"))
1080                  (const_int 0)))]
1081   "ix86_match_ccmode (insn, CCGOCmode)"
1082   "cmp{w}\t{%1, %0|%0, %1}"
1083   [(set_attr "type" "icmp")
1084    (set_attr "mode" "HI")])
1085
1086 (define_insn "*cmphi_1"
1087   [(set (reg FLAGS_REG)
1088         (compare (match_operand:HI 0 "nonimmediate_operand" "rm,r")
1089                  (match_operand:HI 1 "general_operand" "rn,mr")))]
1090   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
1091    && ix86_match_ccmode (insn, CCmode)"
1092   "cmp{w}\t{%1, %0|%0, %1}"
1093   [(set_attr "type" "icmp")
1094    (set_attr "mode" "HI")])
1095
1096 (define_insn "*cmpqi_ccno_1"
1097   [(set (reg FLAGS_REG)
1098         (compare (match_operand:QI 0 "nonimmediate_operand" "q,?mq")
1099                  (match_operand:QI 1 "const0_operand" "")))]
1100   "ix86_match_ccmode (insn, CCNOmode)"
1101   "@
1102    test{b}\t%0, %0
1103    cmp{b}\t{$0, %0|%0, 0}"
1104   [(set_attr "type" "test,icmp")
1105    (set_attr "length_immediate" "0,1")
1106    (set_attr "mode" "QI")])
1107
1108 (define_insn "*cmpqi_1"
1109   [(set (reg FLAGS_REG)
1110         (compare (match_operand:QI 0 "nonimmediate_operand" "qm,q")
1111                  (match_operand:QI 1 "general_operand" "qn,mq")))]
1112   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
1113     && ix86_match_ccmode (insn, CCmode)"
1114   "cmp{b}\t{%1, %0|%0, %1}"
1115   [(set_attr "type" "icmp")
1116    (set_attr "mode" "QI")])
1117
1118 (define_insn "*cmpqi_minus_1"
1119   [(set (reg FLAGS_REG)
1120         (compare (minus:QI (match_operand:QI 0 "nonimmediate_operand" "qm,q")
1121                            (match_operand:QI 1 "general_operand" "qn,mq"))
1122                  (const_int 0)))]
1123   "ix86_match_ccmode (insn, CCGOCmode)"
1124   "cmp{b}\t{%1, %0|%0, %1}"
1125   [(set_attr "type" "icmp")
1126    (set_attr "mode" "QI")])
1127
1128 (define_insn "*cmpqi_ext_1"
1129   [(set (reg FLAGS_REG)
1130         (compare
1131           (match_operand:QI 0 "general_operand" "Qm")
1132           (subreg:QI
1133             (zero_extract:SI
1134               (match_operand 1 "ext_register_operand" "Q")
1135               (const_int 8)
1136               (const_int 8)) 0)))]
1137   "!TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1138   "cmp{b}\t{%h1, %0|%0, %h1}"
1139   [(set_attr "type" "icmp")
1140    (set_attr "mode" "QI")])
1141
1142 (define_insn "*cmpqi_ext_1_rex64"
1143   [(set (reg FLAGS_REG)
1144         (compare
1145           (match_operand:QI 0 "register_operand" "Q")
1146           (subreg:QI
1147             (zero_extract:SI
1148               (match_operand 1 "ext_register_operand" "Q")
1149               (const_int 8)
1150               (const_int 8)) 0)))]
1151   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1152   "cmp{b}\t{%h1, %0|%0, %h1}"
1153   [(set_attr "type" "icmp")
1154    (set_attr "mode" "QI")])
1155
1156 (define_insn "*cmpqi_ext_2"
1157   [(set (reg FLAGS_REG)
1158         (compare
1159           (subreg:QI
1160             (zero_extract:SI
1161               (match_operand 0 "ext_register_operand" "Q")
1162               (const_int 8)
1163               (const_int 8)) 0)
1164           (match_operand:QI 1 "const0_operand" "")))]
1165   "ix86_match_ccmode (insn, CCNOmode)"
1166   "test{b}\t%h0, %h0"
1167   [(set_attr "type" "test")
1168    (set_attr "length_immediate" "0")
1169    (set_attr "mode" "QI")])
1170
1171 (define_expand "cmpqi_ext_3"
1172   [(set (reg:CC FLAGS_REG)
1173         (compare:CC
1174           (subreg:QI
1175             (zero_extract:SI
1176               (match_operand 0 "ext_register_operand" "")
1177               (const_int 8)
1178               (const_int 8)) 0)
1179           (match_operand:QI 1 "general_operand" "")))]
1180   ""
1181   "")
1182
1183 (define_insn "cmpqi_ext_3_insn"
1184   [(set (reg FLAGS_REG)
1185         (compare
1186           (subreg:QI
1187             (zero_extract:SI
1188               (match_operand 0 "ext_register_operand" "Q")
1189               (const_int 8)
1190               (const_int 8)) 0)
1191           (match_operand:QI 1 "general_operand" "Qmn")))]
1192   "!TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1193   "cmp{b}\t{%1, %h0|%h0, %1}"
1194   [(set_attr "type" "icmp")
1195    (set_attr "modrm" "1")
1196    (set_attr "mode" "QI")])
1197
1198 (define_insn "cmpqi_ext_3_insn_rex64"
1199   [(set (reg FLAGS_REG)
1200         (compare
1201           (subreg:QI
1202             (zero_extract:SI
1203               (match_operand 0 "ext_register_operand" "Q")
1204               (const_int 8)
1205               (const_int 8)) 0)
1206           (match_operand:QI 1 "nonmemory_operand" "Qn")))]
1207   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1208   "cmp{b}\t{%1, %h0|%h0, %1}"
1209   [(set_attr "type" "icmp")
1210    (set_attr "modrm" "1")
1211    (set_attr "mode" "QI")])
1212
1213 (define_insn "*cmpqi_ext_4"
1214   [(set (reg FLAGS_REG)
1215         (compare
1216           (subreg:QI
1217             (zero_extract:SI
1218               (match_operand 0 "ext_register_operand" "Q")
1219               (const_int 8)
1220               (const_int 8)) 0)
1221           (subreg:QI
1222             (zero_extract:SI
1223               (match_operand 1 "ext_register_operand" "Q")
1224               (const_int 8)
1225               (const_int 8)) 0)))]
1226   "ix86_match_ccmode (insn, CCmode)"
1227   "cmp{b}\t{%h1, %h0|%h0, %h1}"
1228   [(set_attr "type" "icmp")
1229    (set_attr "mode" "QI")])
1230
1231 ;; These implement float point compares.
1232 ;; %%% See if we can get away with VOIDmode operands on the actual insns,
1233 ;; which would allow mix and match FP modes on the compares.  Which is what
1234 ;; the old patterns did, but with many more of them.
1235
1236 (define_expand "cbranchxf4"
1237   [(set (reg:CC FLAGS_REG)
1238         (compare:CC (match_operand:XF 1 "nonmemory_operand" "")
1239                     (match_operand:XF 2 "nonmemory_operand" "")))
1240    (set (pc) (if_then_else
1241               (match_operator 0 "ix86_fp_comparison_operator"
1242                [(reg:CC FLAGS_REG)
1243                 (const_int 0)])
1244               (label_ref (match_operand 3 "" ""))
1245               (pc)))]
1246   "TARGET_80387"
1247 {
1248   ix86_compare_op0 = operands[1];
1249   ix86_compare_op1 = operands[2];
1250   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
1251   DONE;
1252 })
1253
1254 (define_expand "cstorexf4"
1255   [(set (reg:CC FLAGS_REG)
1256         (compare:CC (match_operand:XF 2 "nonmemory_operand" "")
1257                     (match_operand:XF 3 "nonmemory_operand" "")))
1258    (set (match_operand:QI 0 "register_operand" "")
1259               (match_operator 1 "ix86_fp_comparison_operator"
1260                [(reg:CC FLAGS_REG)
1261                 (const_int 0)]))]
1262   "TARGET_80387"
1263 {
1264   ix86_compare_op0 = operands[2];
1265   ix86_compare_op1 = operands[3];
1266   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
1267   DONE;
1268 })
1269
1270 (define_expand "cbranch<mode>4"
1271   [(set (reg:CC FLAGS_REG)
1272         (compare:CC (match_operand:MODEF 1 "cmp_fp_expander_operand" "")
1273                     (match_operand:MODEF 2 "cmp_fp_expander_operand" "")))
1274    (set (pc) (if_then_else
1275               (match_operator 0 "ix86_fp_comparison_operator"
1276                [(reg:CC FLAGS_REG)
1277                 (const_int 0)])
1278               (label_ref (match_operand 3 "" ""))
1279               (pc)))]
1280   "TARGET_80387 || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH)"
1281 {
1282   ix86_compare_op0 = operands[1];
1283   ix86_compare_op1 = operands[2];
1284   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
1285   DONE;
1286 })
1287
1288 (define_expand "cstore<mode>4"
1289   [(set (reg:CC FLAGS_REG)
1290         (compare:CC (match_operand:MODEF 2 "cmp_fp_expander_operand" "")
1291                     (match_operand:MODEF 3 "cmp_fp_expander_operand" "")))
1292    (set (match_operand:QI 0 "register_operand" "")
1293               (match_operator 1 "ix86_fp_comparison_operator"
1294                [(reg:CC FLAGS_REG)
1295                 (const_int 0)]))]
1296   "TARGET_80387 || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH)"
1297 {
1298   ix86_compare_op0 = operands[2];
1299   ix86_compare_op1 = operands[3];
1300   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
1301   DONE;
1302 })
1303
1304 (define_expand "cbranchcc4"
1305   [(set (pc) (if_then_else
1306               (match_operator 0 "comparison_operator"
1307                [(match_operand 1 "flags_reg_operand" "")
1308                 (match_operand 2 "const0_operand" "")])
1309               (label_ref (match_operand 3 "" ""))
1310               (pc)))]
1311   ""
1312 {
1313   ix86_compare_op0 = operands[1];
1314   ix86_compare_op1 = operands[2];
1315   ix86_expand_branch (GET_CODE (operands[0]), operands[3]);
1316   DONE;
1317 })
1318
1319 (define_expand "cstorecc4"
1320   [(set (match_operand:QI 0 "register_operand" "")
1321               (match_operator 1 "comparison_operator"
1322                [(match_operand 2 "flags_reg_operand" "")
1323                 (match_operand 3 "const0_operand" "")]))]
1324   ""
1325 {
1326   ix86_compare_op0 = operands[2];
1327   ix86_compare_op1 = operands[3];
1328   ix86_expand_setcc (GET_CODE (operands[1]), operands[0]);
1329   DONE;
1330 })
1331
1332
1333 ;; FP compares, step 1:
1334 ;; Set the FP condition codes.
1335 ;;
1336 ;; CCFPmode     compare with exceptions
1337 ;; CCFPUmode    compare with no exceptions
1338
1339 ;; We may not use "#" to split and emit these, since the REG_DEAD notes
1340 ;; used to manage the reg stack popping would not be preserved.
1341
1342 (define_insn "*cmpfp_0"
1343   [(set (match_operand:HI 0 "register_operand" "=a")
1344         (unspec:HI
1345           [(compare:CCFP
1346              (match_operand 1 "register_operand" "f")
1347              (match_operand 2 "const0_operand" ""))]
1348         UNSPEC_FNSTSW))]
1349   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1350    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1351   "* return output_fp_compare (insn, operands, 0, 0);"
1352   [(set_attr "type" "multi")
1353    (set_attr "unit" "i387")
1354    (set (attr "mode")
1355      (cond [(match_operand:SF 1 "" "")
1356               (const_string "SF")
1357             (match_operand:DF 1 "" "")
1358               (const_string "DF")
1359            ]
1360            (const_string "XF")))])
1361
1362 (define_insn_and_split "*cmpfp_0_cc"
1363   [(set (reg:CCFP FLAGS_REG)
1364         (compare:CCFP
1365           (match_operand 1 "register_operand" "f")
1366           (match_operand 2 "const0_operand" "")))
1367    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1368   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1369    && TARGET_SAHF && !TARGET_CMOVE
1370    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1371   "#"
1372   "&& reload_completed"
1373   [(set (match_dup 0)
1374         (unspec:HI
1375           [(compare:CCFP (match_dup 1)(match_dup 2))]
1376         UNSPEC_FNSTSW))
1377    (set (reg:CC FLAGS_REG)
1378         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1379   ""
1380   [(set_attr "type" "multi")
1381    (set_attr "unit" "i387")
1382    (set (attr "mode")
1383      (cond [(match_operand:SF 1 "" "")
1384               (const_string "SF")
1385             (match_operand:DF 1 "" "")
1386               (const_string "DF")
1387            ]
1388            (const_string "XF")))])
1389
1390 (define_insn "*cmpfp_xf"
1391   [(set (match_operand:HI 0 "register_operand" "=a")
1392         (unspec:HI
1393           [(compare:CCFP
1394              (match_operand:XF 1 "register_operand" "f")
1395              (match_operand:XF 2 "register_operand" "f"))]
1396           UNSPEC_FNSTSW))]
1397   "TARGET_80387"
1398   "* return output_fp_compare (insn, operands, 0, 0);"
1399   [(set_attr "type" "multi")
1400    (set_attr "unit" "i387")
1401    (set_attr "mode" "XF")])
1402
1403 (define_insn_and_split "*cmpfp_xf_cc"
1404   [(set (reg:CCFP FLAGS_REG)
1405         (compare:CCFP
1406           (match_operand:XF 1 "register_operand" "f")
1407           (match_operand:XF 2 "register_operand" "f")))
1408    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1409   "TARGET_80387
1410    && TARGET_SAHF && !TARGET_CMOVE"
1411   "#"
1412   "&& reload_completed"
1413   [(set (match_dup 0)
1414         (unspec:HI
1415           [(compare:CCFP (match_dup 1)(match_dup 2))]
1416         UNSPEC_FNSTSW))
1417    (set (reg:CC FLAGS_REG)
1418         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1419   ""
1420   [(set_attr "type" "multi")
1421    (set_attr "unit" "i387")
1422    (set_attr "mode" "XF")])
1423
1424 (define_insn "*cmpfp_<mode>"
1425   [(set (match_operand:HI 0 "register_operand" "=a")
1426         (unspec:HI
1427           [(compare:CCFP
1428              (match_operand:MODEF 1 "register_operand" "f")
1429              (match_operand:MODEF 2 "nonimmediate_operand" "fm"))]
1430           UNSPEC_FNSTSW))]
1431   "TARGET_80387"
1432   "* return output_fp_compare (insn, operands, 0, 0);"
1433   [(set_attr "type" "multi")
1434    (set_attr "unit" "i387")
1435    (set_attr "mode" "<MODE>")])
1436
1437 (define_insn_and_split "*cmpfp_<mode>_cc"
1438   [(set (reg:CCFP FLAGS_REG)
1439         (compare:CCFP
1440           (match_operand:MODEF 1 "register_operand" "f")
1441           (match_operand:MODEF 2 "nonimmediate_operand" "fm")))
1442    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1443   "TARGET_80387
1444    && TARGET_SAHF && !TARGET_CMOVE"
1445   "#"
1446   "&& reload_completed"
1447   [(set (match_dup 0)
1448         (unspec:HI
1449           [(compare:CCFP (match_dup 1)(match_dup 2))]
1450         UNSPEC_FNSTSW))
1451    (set (reg:CC FLAGS_REG)
1452         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1453   ""
1454   [(set_attr "type" "multi")
1455    (set_attr "unit" "i387")
1456    (set_attr "mode" "<MODE>")])
1457
1458 (define_insn "*cmpfp_u"
1459   [(set (match_operand:HI 0 "register_operand" "=a")
1460         (unspec:HI
1461           [(compare:CCFPU
1462              (match_operand 1 "register_operand" "f")
1463              (match_operand 2 "register_operand" "f"))]
1464           UNSPEC_FNSTSW))]
1465   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1466    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1467   "* return output_fp_compare (insn, operands, 0, 1);"
1468   [(set_attr "type" "multi")
1469    (set_attr "unit" "i387")
1470    (set (attr "mode")
1471      (cond [(match_operand:SF 1 "" "")
1472               (const_string "SF")
1473             (match_operand:DF 1 "" "")
1474               (const_string "DF")
1475            ]
1476            (const_string "XF")))])
1477
1478 (define_insn_and_split "*cmpfp_u_cc"
1479   [(set (reg:CCFPU FLAGS_REG)
1480         (compare:CCFPU
1481           (match_operand 1 "register_operand" "f")
1482           (match_operand 2 "register_operand" "f")))
1483    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1484   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1485    && TARGET_SAHF && !TARGET_CMOVE
1486    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1487   "#"
1488   "&& reload_completed"
1489   [(set (match_dup 0)
1490         (unspec:HI
1491           [(compare:CCFPU (match_dup 1)(match_dup 2))]
1492         UNSPEC_FNSTSW))
1493    (set (reg:CC FLAGS_REG)
1494         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1495   ""
1496   [(set_attr "type" "multi")
1497    (set_attr "unit" "i387")
1498    (set (attr "mode")
1499      (cond [(match_operand:SF 1 "" "")
1500               (const_string "SF")
1501             (match_operand:DF 1 "" "")
1502               (const_string "DF")
1503            ]
1504            (const_string "XF")))])
1505
1506 (define_insn "*cmpfp_<mode>"
1507   [(set (match_operand:HI 0 "register_operand" "=a")
1508         (unspec:HI
1509           [(compare:CCFP
1510              (match_operand 1 "register_operand" "f")
1511              (match_operator 3 "float_operator"
1512                [(match_operand:X87MODEI12 2 "memory_operand" "m")]))]
1513           UNSPEC_FNSTSW))]
1514   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1515    && (TARGET_USE_<MODE>MODE_FIOP || optimize_function_for_size_p (cfun))
1516    && (GET_MODE (operands [3]) == GET_MODE (operands[1]))"
1517   "* return output_fp_compare (insn, operands, 0, 0);"
1518   [(set_attr "type" "multi")
1519    (set_attr "unit" "i387")
1520    (set_attr "fp_int_src" "true")
1521    (set_attr "mode" "<MODE>")])
1522
1523 (define_insn_and_split "*cmpfp_<mode>_cc"
1524   [(set (reg:CCFP FLAGS_REG)
1525         (compare:CCFP
1526           (match_operand 1 "register_operand" "f")
1527           (match_operator 3 "float_operator"
1528             [(match_operand:X87MODEI12 2 "memory_operand" "m")])))
1529    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1530   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1531    && TARGET_SAHF && !TARGET_CMOVE
1532    && (TARGET_USE_<MODE>MODE_FIOP || optimize_function_for_size_p (cfun))
1533    && (GET_MODE (operands [3]) == GET_MODE (operands[1]))"
1534   "#"
1535   "&& reload_completed"
1536   [(set (match_dup 0)
1537         (unspec:HI
1538           [(compare:CCFP
1539              (match_dup 1)
1540              (match_op_dup 3 [(match_dup 2)]))]
1541         UNSPEC_FNSTSW))
1542    (set (reg:CC FLAGS_REG)
1543         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1544   ""
1545   [(set_attr "type" "multi")
1546    (set_attr "unit" "i387")
1547    (set_attr "fp_int_src" "true")
1548    (set_attr "mode" "<MODE>")])
1549
1550 ;; FP compares, step 2
1551 ;; Move the fpsw to ax.
1552
1553 (define_insn "x86_fnstsw_1"
1554   [(set (match_operand:HI 0 "register_operand" "=a")
1555         (unspec:HI [(reg:CCFP FPSR_REG)] UNSPEC_FNSTSW))]
1556   "TARGET_80387"
1557   "fnstsw\t%0"
1558   [(set (attr "length") (symbol_ref "ix86_attr_length_address_default (insn) + 2"))
1559    (set_attr "mode" "SI")
1560    (set_attr "unit" "i387")])
1561
1562 ;; FP compares, step 3
1563 ;; Get ax into flags, general case.
1564
1565 (define_insn "x86_sahf_1"
1566   [(set (reg:CC FLAGS_REG)
1567         (unspec:CC [(match_operand:HI 0 "register_operand" "a")]
1568                    UNSPEC_SAHF))]
1569   "TARGET_SAHF"
1570 {
1571 #ifdef HAVE_AS_IX86_SAHF
1572   return "sahf";
1573 #else
1574   return ASM_BYTE "0x9e";
1575 #endif
1576 }
1577   [(set_attr "length" "1")
1578    (set_attr "athlon_decode" "vector")
1579    (set_attr "amdfam10_decode" "direct")
1580    (set_attr "mode" "SI")])
1581
1582 ;; Pentium Pro can do steps 1 through 3 in one go.
1583 ;; comi*, ucomi*, fcomi*, ficomi*,fucomi* (i387 instructions set condition codes)
1584 (define_insn "*cmpfp_i_mixed"
1585   [(set (reg:CCFP FLAGS_REG)
1586         (compare:CCFP (match_operand 0 "register_operand" "f,x")
1587                       (match_operand 1 "nonimmediate_operand" "f,xm")))]
1588   "TARGET_MIX_SSE_I387
1589    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1590    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1591   "* return output_fp_compare (insn, operands, 1, 0);"
1592   [(set_attr "type" "fcmp,ssecomi")
1593    (set_attr "prefix" "orig,maybe_vex")
1594    (set (attr "mode")
1595      (if_then_else (match_operand:SF 1 "" "")
1596         (const_string "SF")
1597         (const_string "DF")))
1598    (set (attr "prefix_rep")
1599         (if_then_else (eq_attr "type" "ssecomi")
1600                       (const_string "0")
1601                       (const_string "*")))
1602    (set (attr "prefix_data16")
1603         (cond [(eq_attr "type" "fcmp")
1604                  (const_string "*")
1605                (eq_attr "mode" "DF")
1606                  (const_string "1")
1607               ]
1608               (const_string "0")))
1609    (set_attr "athlon_decode" "vector")
1610    (set_attr "amdfam10_decode" "direct")])
1611
1612 (define_insn "*cmpfp_i_sse"
1613   [(set (reg:CCFP FLAGS_REG)
1614         (compare:CCFP (match_operand 0 "register_operand" "x")
1615                       (match_operand 1 "nonimmediate_operand" "xm")))]
1616   "TARGET_SSE_MATH
1617    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1618    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1619   "* return output_fp_compare (insn, operands, 1, 0);"
1620   [(set_attr "type" "ssecomi")
1621    (set_attr "prefix" "maybe_vex")
1622    (set (attr "mode")
1623      (if_then_else (match_operand:SF 1 "" "")
1624         (const_string "SF")
1625         (const_string "DF")))
1626    (set_attr "prefix_rep" "0")
1627    (set (attr "prefix_data16")
1628         (if_then_else (eq_attr "mode" "DF")
1629                       (const_string "1")
1630                       (const_string "0")))
1631    (set_attr "athlon_decode" "vector")
1632    (set_attr "amdfam10_decode" "direct")])
1633
1634 (define_insn "*cmpfp_i_i387"
1635   [(set (reg:CCFP FLAGS_REG)
1636         (compare:CCFP (match_operand 0 "register_operand" "f")
1637                       (match_operand 1 "register_operand" "f")))]
1638   "X87_FLOAT_MODE_P (GET_MODE (operands[0]))
1639    && TARGET_CMOVE
1640    && !(SSE_FLOAT_MODE_P (GET_MODE (operands[0])) && TARGET_SSE_MATH)
1641    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1642   "* return output_fp_compare (insn, operands, 1, 0);"
1643   [(set_attr "type" "fcmp")
1644    (set (attr "mode")
1645      (cond [(match_operand:SF 1 "" "")
1646               (const_string "SF")
1647             (match_operand:DF 1 "" "")
1648               (const_string "DF")
1649            ]
1650            (const_string "XF")))
1651    (set_attr "athlon_decode" "vector")
1652    (set_attr "amdfam10_decode" "direct")])
1653
1654 (define_insn "*cmpfp_iu_mixed"
1655   [(set (reg:CCFPU FLAGS_REG)
1656         (compare:CCFPU (match_operand 0 "register_operand" "f,x")
1657                        (match_operand 1 "nonimmediate_operand" "f,xm")))]
1658   "TARGET_MIX_SSE_I387
1659    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1660    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1661   "* return output_fp_compare (insn, operands, 1, 1);"
1662   [(set_attr "type" "fcmp,ssecomi")
1663    (set_attr "prefix" "orig,maybe_vex")
1664    (set (attr "mode")
1665      (if_then_else (match_operand:SF 1 "" "")
1666         (const_string "SF")
1667         (const_string "DF")))
1668    (set (attr "prefix_rep")
1669         (if_then_else (eq_attr "type" "ssecomi")
1670                       (const_string "0")
1671                       (const_string "*")))
1672    (set (attr "prefix_data16")
1673         (cond [(eq_attr "type" "fcmp")
1674                  (const_string "*")
1675                (eq_attr "mode" "DF")
1676                  (const_string "1")
1677               ]
1678               (const_string "0")))
1679    (set_attr "athlon_decode" "vector")
1680    (set_attr "amdfam10_decode" "direct")])
1681
1682 (define_insn "*cmpfp_iu_sse"
1683   [(set (reg:CCFPU FLAGS_REG)
1684         (compare:CCFPU (match_operand 0 "register_operand" "x")
1685                        (match_operand 1 "nonimmediate_operand" "xm")))]
1686   "TARGET_SSE_MATH
1687    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1688    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1689   "* return output_fp_compare (insn, operands, 1, 1);"
1690   [(set_attr "type" "ssecomi")
1691    (set_attr "prefix" "maybe_vex")
1692    (set (attr "mode")
1693      (if_then_else (match_operand:SF 1 "" "")
1694         (const_string "SF")
1695         (const_string "DF")))
1696    (set_attr "prefix_rep" "0")
1697    (set (attr "prefix_data16")
1698         (if_then_else (eq_attr "mode" "DF")
1699                       (const_string "1")
1700                       (const_string "0")))
1701    (set_attr "athlon_decode" "vector")
1702    (set_attr "amdfam10_decode" "direct")])
1703
1704 (define_insn "*cmpfp_iu_387"
1705   [(set (reg:CCFPU FLAGS_REG)
1706         (compare:CCFPU (match_operand 0 "register_operand" "f")
1707                        (match_operand 1 "register_operand" "f")))]
1708   "X87_FLOAT_MODE_P (GET_MODE (operands[0]))
1709    && TARGET_CMOVE
1710    && !(SSE_FLOAT_MODE_P (GET_MODE (operands[0])) && TARGET_SSE_MATH)
1711    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1712   "* return output_fp_compare (insn, operands, 1, 1);"
1713   [(set_attr "type" "fcmp")
1714    (set (attr "mode")
1715      (cond [(match_operand:SF 1 "" "")
1716               (const_string "SF")
1717             (match_operand:DF 1 "" "")
1718               (const_string "DF")
1719            ]
1720            (const_string "XF")))
1721    (set_attr "athlon_decode" "vector")
1722    (set_attr "amdfam10_decode" "direct")])
1723 \f
1724 ;; Move instructions.
1725
1726 ;; General case of fullword move.
1727
1728 (define_expand "movsi"
1729   [(set (match_operand:SI 0 "nonimmediate_operand" "")
1730         (match_operand:SI 1 "general_operand" ""))]
1731   ""
1732   "ix86_expand_move (SImode, operands); DONE;")
1733
1734 ;; Push/pop instructions.  They are separate since autoinc/dec is not a
1735 ;; general_operand.
1736 ;;
1737 ;; %%% We don't use a post-inc memory reference because x86 is not a
1738 ;; general AUTO_INC_DEC host, which impacts how it is treated in flow.
1739 ;; Changing this impacts compiler performance on other non-AUTO_INC_DEC
1740 ;; targets without our curiosities, and it is just as easy to represent
1741 ;; this differently.
1742
1743 (define_insn "*pushsi2"
1744   [(set (match_operand:SI 0 "push_operand" "=<")
1745         (match_operand:SI 1 "general_no_elim_operand" "ri*m"))]
1746   "!TARGET_64BIT"
1747   "push{l}\t%1"
1748   [(set_attr "type" "push")
1749    (set_attr "mode" "SI")])
1750
1751 ;; For 64BIT abi we always round up to 8 bytes.
1752 (define_insn "*pushsi2_rex64"
1753   [(set (match_operand:SI 0 "push_operand" "=X")
1754         (match_operand:SI 1 "nonmemory_no_elim_operand" "ri"))]
1755   "TARGET_64BIT"
1756   "push{q}\t%q1"
1757   [(set_attr "type" "push")
1758    (set_attr "mode" "SI")])
1759
1760 (define_insn "*pushsi2_prologue"
1761   [(set (match_operand:SI 0 "push_operand" "=<")
1762         (match_operand:SI 1 "general_no_elim_operand" "ri*m"))
1763    (clobber (mem:BLK (scratch)))]
1764   "!TARGET_64BIT"
1765   "push{l}\t%1"
1766   [(set_attr "type" "push")
1767    (set_attr "mode" "SI")])
1768
1769 (define_insn "*popsi1_epilogue"
1770   [(set (match_operand:SI 0 "nonimmediate_operand" "=r*m")
1771         (mem:SI (reg:SI SP_REG)))
1772    (set (reg:SI SP_REG)
1773         (plus:SI (reg:SI SP_REG) (const_int 4)))
1774    (clobber (mem:BLK (scratch)))]
1775   "!TARGET_64BIT"
1776   "pop{l}\t%0"
1777   [(set_attr "type" "pop")
1778    (set_attr "mode" "SI")])
1779
1780 (define_insn "popsi1"
1781   [(set (match_operand:SI 0 "nonimmediate_operand" "=r*m")
1782         (mem:SI (reg:SI SP_REG)))
1783    (set (reg:SI SP_REG)
1784         (plus:SI (reg:SI SP_REG) (const_int 4)))]
1785   "!TARGET_64BIT"
1786   "pop{l}\t%0"
1787   [(set_attr "type" "pop")
1788    (set_attr "mode" "SI")])
1789
1790 (define_insn "*movsi_xor"
1791   [(set (match_operand:SI 0 "register_operand" "=r")
1792         (match_operand:SI 1 "const0_operand" ""))
1793    (clobber (reg:CC FLAGS_REG))]
1794   "reload_completed"
1795   "xor{l}\t%0, %0"
1796   [(set_attr "type" "alu1")
1797    (set_attr "mode" "SI")
1798    (set_attr "length_immediate" "0")])
1799
1800 (define_insn "*movsi_or"
1801   [(set (match_operand:SI 0 "register_operand" "=r")
1802         (match_operand:SI 1 "immediate_operand" "i"))
1803    (clobber (reg:CC FLAGS_REG))]
1804   "reload_completed
1805    && operands[1] == constm1_rtx"
1806 {
1807   operands[1] = constm1_rtx;
1808   return "or{l}\t{%1, %0|%0, %1}";
1809 }
1810   [(set_attr "type" "alu1")
1811    (set_attr "mode" "SI")
1812    (set_attr "length_immediate" "1")])
1813
1814 (define_insn "*movsi_1"
1815   [(set (match_operand:SI 0 "nonimmediate_operand"
1816                         "=r,m ,*y,*y,?rm,?*y,*x,*x,?r ,m ,?*Yi,*x")
1817         (match_operand:SI 1 "general_operand"
1818                         "g ,ri,C ,*y,*y ,rm ,C ,*x,*Yi,*x,r   ,m "))]
1819   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
1820 {
1821   switch (get_attr_type (insn))
1822     {
1823     case TYPE_SSELOG1:
1824       if (get_attr_mode (insn) == MODE_TI)
1825         return "%vpxor\t%0, %d0";
1826       return "%vxorps\t%0, %d0";
1827
1828     case TYPE_SSEMOV:
1829       switch (get_attr_mode (insn))
1830         {
1831         case MODE_TI:
1832           return "%vmovdqa\t{%1, %0|%0, %1}";
1833         case MODE_V4SF:
1834           return "%vmovaps\t{%1, %0|%0, %1}";
1835         case MODE_SI:
1836           return "%vmovd\t{%1, %0|%0, %1}";
1837         case MODE_SF:
1838           return "%vmovss\t{%1, %0|%0, %1}";
1839         default:
1840           gcc_unreachable ();
1841         }
1842
1843     case TYPE_MMX:
1844       return "pxor\t%0, %0";
1845
1846     case TYPE_MMXMOV:
1847       if (get_attr_mode (insn) == MODE_DI)
1848         return "movq\t{%1, %0|%0, %1}";
1849       return "movd\t{%1, %0|%0, %1}";
1850
1851     case TYPE_LEA:
1852       return "lea{l}\t{%1, %0|%0, %1}";
1853
1854     default:
1855       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
1856       return "mov{l}\t{%1, %0|%0, %1}";
1857     }
1858 }
1859   [(set (attr "type")
1860      (cond [(eq_attr "alternative" "2")
1861               (const_string "mmx")
1862             (eq_attr "alternative" "3,4,5")
1863               (const_string "mmxmov")
1864             (eq_attr "alternative" "6")
1865               (const_string "sselog1")
1866             (eq_attr "alternative" "7,8,9,10,11")
1867               (const_string "ssemov")
1868             (match_operand:DI 1 "pic_32bit_operand" "")
1869               (const_string "lea")
1870            ]
1871            (const_string "imov")))
1872    (set (attr "prefix")
1873      (if_then_else (eq_attr "alternative" "0,1,2,3,4,5")
1874        (const_string "orig")
1875        (const_string "maybe_vex")))
1876    (set (attr "prefix_data16")
1877      (if_then_else (and (eq_attr "type" "ssemov") (eq_attr "mode" "SI"))
1878        (const_string "1")
1879        (const_string "*")))
1880    (set (attr "mode")
1881      (cond [(eq_attr "alternative" "2,3")
1882               (const_string "DI")
1883             (eq_attr "alternative" "6,7")
1884               (if_then_else
1885                 (eq (symbol_ref "TARGET_SSE2") (const_int 0))
1886                 (const_string "V4SF")
1887                 (const_string "TI"))
1888             (and (eq_attr "alternative" "8,9,10,11")
1889                  (eq (symbol_ref "TARGET_SSE2") (const_int 0)))
1890               (const_string "SF")
1891            ]
1892            (const_string "SI")))])
1893
1894 ;; Stores and loads of ax to arbitrary constant address.
1895 ;; We fake an second form of instruction to force reload to load address
1896 ;; into register when rax is not available
1897 (define_insn "*movabssi_1_rex64"
1898   [(set (mem:SI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
1899         (match_operand:SI 1 "nonmemory_operand" "a,er"))]
1900   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
1901   "@
1902    movabs{l}\t{%1, %P0|%P0, %1}
1903    mov{l}\t{%1, %a0|%a0, %1}"
1904   [(set_attr "type" "imov")
1905    (set_attr "modrm" "0,*")
1906    (set_attr "length_address" "8,0")
1907    (set_attr "length_immediate" "0,*")
1908    (set_attr "memory" "store")
1909    (set_attr "mode" "SI")])
1910
1911 (define_insn "*movabssi_2_rex64"
1912   [(set (match_operand:SI 0 "register_operand" "=a,r")
1913         (mem:SI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
1914   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
1915   "@
1916    movabs{l}\t{%P1, %0|%0, %P1}
1917    mov{l}\t{%a1, %0|%0, %a1}"
1918   [(set_attr "type" "imov")
1919    (set_attr "modrm" "0,*")
1920    (set_attr "length_address" "8,0")
1921    (set_attr "length_immediate" "0")
1922    (set_attr "memory" "load")
1923    (set_attr "mode" "SI")])
1924
1925 (define_insn "*swapsi"
1926   [(set (match_operand:SI 0 "register_operand" "+r")
1927         (match_operand:SI 1 "register_operand" "+r"))
1928    (set (match_dup 1)
1929         (match_dup 0))]
1930   ""
1931   "xchg{l}\t%1, %0"
1932   [(set_attr "type" "imov")
1933    (set_attr "mode" "SI")
1934    (set_attr "pent_pair" "np")
1935    (set_attr "athlon_decode" "vector")
1936    (set_attr "amdfam10_decode" "double")])
1937
1938 (define_expand "movhi"
1939   [(set (match_operand:HI 0 "nonimmediate_operand" "")
1940         (match_operand:HI 1 "general_operand" ""))]
1941   ""
1942   "ix86_expand_move (HImode, operands); DONE;")
1943
1944 (define_insn "*pushhi2"
1945   [(set (match_operand:HI 0 "push_operand" "=X")
1946         (match_operand:HI 1 "nonmemory_no_elim_operand" "rn"))]
1947   "!TARGET_64BIT"
1948   "push{l}\t%k1"
1949   [(set_attr "type" "push")
1950    (set_attr "mode" "SI")])
1951
1952 ;; For 64BIT abi we always round up to 8 bytes.
1953 (define_insn "*pushhi2_rex64"
1954   [(set (match_operand:HI 0 "push_operand" "=X")
1955         (match_operand:HI 1 "nonmemory_no_elim_operand" "rn"))]
1956   "TARGET_64BIT"
1957   "push{q}\t%q1"
1958   [(set_attr "type" "push")
1959    (set_attr "mode" "DI")])
1960
1961 (define_insn "*movhi_1"
1962   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,m")
1963         (match_operand:HI 1 "general_operand" "r,rn,rm,rn"))]
1964   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
1965 {
1966   switch (get_attr_type (insn))
1967     {
1968     case TYPE_IMOVX:
1969       /* movzwl is faster than movw on p2 due to partial word stalls,
1970          though not as fast as an aligned movl.  */
1971       return "movz{wl|x}\t{%1, %k0|%k0, %1}";
1972     default:
1973       if (get_attr_mode (insn) == MODE_SI)
1974         return "mov{l}\t{%k1, %k0|%k0, %k1}";
1975       else
1976         return "mov{w}\t{%1, %0|%0, %1}";
1977     }
1978 }
1979   [(set (attr "type")
1980      (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0))
1981               (const_string "imov")
1982             (and (eq_attr "alternative" "0")
1983                  (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
1984                           (const_int 0))
1985                       (eq (symbol_ref "TARGET_HIMODE_MATH")
1986                           (const_int 0))))
1987               (const_string "imov")
1988             (and (eq_attr "alternative" "1,2")
1989                  (match_operand:HI 1 "aligned_operand" ""))
1990               (const_string "imov")
1991             (and (ne (symbol_ref "TARGET_MOVX")
1992                      (const_int 0))
1993                  (eq_attr "alternative" "0,2"))
1994               (const_string "imovx")
1995            ]
1996            (const_string "imov")))
1997     (set (attr "mode")
1998       (cond [(eq_attr "type" "imovx")
1999                (const_string "SI")
2000              (and (eq_attr "alternative" "1,2")
2001                   (match_operand:HI 1 "aligned_operand" ""))
2002                (const_string "SI")
2003              (and (eq_attr "alternative" "0")
2004                   (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
2005                            (const_int 0))
2006                        (eq (symbol_ref "TARGET_HIMODE_MATH")
2007                            (const_int 0))))
2008                (const_string "SI")
2009             ]
2010             (const_string "HI")))])
2011
2012 ;; Stores and loads of ax to arbitrary constant address.
2013 ;; We fake an second form of instruction to force reload to load address
2014 ;; into register when rax is not available
2015 (define_insn "*movabshi_1_rex64"
2016   [(set (mem:HI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
2017         (match_operand:HI 1 "nonmemory_operand" "a,er"))]
2018   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
2019   "@
2020    movabs{w}\t{%1, %P0|%P0, %1}
2021    mov{w}\t{%1, %a0|%a0, %1}"
2022   [(set_attr "type" "imov")
2023    (set_attr "modrm" "0,*")
2024    (set_attr "length_address" "8,0")
2025    (set_attr "length_immediate" "0,*")
2026    (set_attr "memory" "store")
2027    (set_attr "mode" "HI")])
2028
2029 (define_insn "*movabshi_2_rex64"
2030   [(set (match_operand:HI 0 "register_operand" "=a,r")
2031         (mem:HI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
2032   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
2033   "@
2034    movabs{w}\t{%P1, %0|%0, %P1}
2035    mov{w}\t{%a1, %0|%0, %a1}"
2036   [(set_attr "type" "imov")
2037    (set_attr "modrm" "0,*")
2038    (set_attr "length_address" "8,0")
2039    (set_attr "length_immediate" "0")
2040    (set_attr "memory" "load")
2041    (set_attr "mode" "HI")])
2042
2043 (define_insn "*swaphi_1"
2044   [(set (match_operand:HI 0 "register_operand" "+r")
2045         (match_operand:HI 1 "register_operand" "+r"))
2046    (set (match_dup 1)
2047         (match_dup 0))]
2048   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
2049   "xchg{l}\t%k1, %k0"
2050   [(set_attr "type" "imov")
2051    (set_attr "mode" "SI")
2052    (set_attr "pent_pair" "np")
2053    (set_attr "athlon_decode" "vector")
2054    (set_attr "amdfam10_decode" "double")])
2055
2056 ;; Not added amdfam10_decode since TARGET_PARTIAL_REG_STALL is disabled for AMDFAM10
2057 (define_insn "*swaphi_2"
2058   [(set (match_operand:HI 0 "register_operand" "+r")
2059         (match_operand:HI 1 "register_operand" "+r"))
2060    (set (match_dup 1)
2061         (match_dup 0))]
2062   "TARGET_PARTIAL_REG_STALL"
2063   "xchg{w}\t%1, %0"
2064   [(set_attr "type" "imov")
2065    (set_attr "mode" "HI")
2066    (set_attr "pent_pair" "np")
2067    (set_attr "athlon_decode" "vector")])
2068
2069 (define_expand "movstricthi"
2070   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" ""))
2071         (match_operand:HI 1 "general_operand" ""))]
2072   ""
2073 {
2074   if (TARGET_PARTIAL_REG_STALL && optimize_function_for_speed_p (cfun))
2075     FAIL;
2076   /* Don't generate memory->memory moves, go through a register */
2077   if (MEM_P (operands[0]) && MEM_P (operands[1]))
2078     operands[1] = force_reg (HImode, operands[1]);
2079 })
2080
2081 (define_insn "*movstricthi_1"
2082   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+rm,r"))
2083         (match_operand:HI 1 "general_operand" "rn,m"))]
2084   "(! TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
2085    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2086   "mov{w}\t{%1, %0|%0, %1}"
2087   [(set_attr "type" "imov")
2088    (set_attr "mode" "HI")])
2089
2090 (define_insn "*movstricthi_xor"
2091   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+r"))
2092         (match_operand:HI 1 "const0_operand" ""))
2093    (clobber (reg:CC FLAGS_REG))]
2094   "reload_completed"
2095   "xor{w}\t%0, %0"
2096   [(set_attr "type" "alu1")
2097    (set_attr "mode" "HI")
2098    (set_attr "length_immediate" "0")])
2099
2100 (define_expand "movqi"
2101   [(set (match_operand:QI 0 "nonimmediate_operand" "")
2102         (match_operand:QI 1 "general_operand" ""))]
2103   ""
2104   "ix86_expand_move (QImode, operands); DONE;")
2105
2106 ;; emit_push_insn when it calls move_by_pieces requires an insn to
2107 ;; "push a byte".  But actually we use pushl, which has the effect
2108 ;; of rounding the amount pushed up to a word.
2109
2110 (define_insn "*pushqi2"
2111   [(set (match_operand:QI 0 "push_operand" "=X")
2112         (match_operand:QI 1 "nonmemory_no_elim_operand" "rn"))]
2113   "!TARGET_64BIT"
2114   "push{l}\t%k1"
2115   [(set_attr "type" "push")
2116    (set_attr "mode" "SI")])
2117
2118 ;; For 64BIT abi we always round up to 8 bytes.
2119 (define_insn "*pushqi2_rex64"
2120   [(set (match_operand:QI 0 "push_operand" "=X")
2121         (match_operand:QI 1 "nonmemory_no_elim_operand" "qn"))]
2122   "TARGET_64BIT"
2123   "push{q}\t%q1"
2124   [(set_attr "type" "push")
2125    (set_attr "mode" "DI")])
2126
2127 ;; Situation is quite tricky about when to choose full sized (SImode) move
2128 ;; over QImode moves.  For Q_REG -> Q_REG move we use full size only for
2129 ;; partial register dependency machines (such as AMD Athlon), where QImode
2130 ;; moves issue extra dependency and for partial register stalls machines
2131 ;; that don't use QImode patterns (and QImode move cause stall on the next
2132 ;; instruction).
2133 ;;
2134 ;; For loads of Q_REG to NONQ_REG we use full sized moves except for partial
2135 ;; register stall machines with, where we use QImode instructions, since
2136 ;; partial register stall can be caused there.  Then we use movzx.
2137 (define_insn "*movqi_1"
2138   [(set (match_operand:QI 0 "nonimmediate_operand" "=q,q ,q ,r,r ,?r,m")
2139         (match_operand:QI 1 "general_operand"      " q,qn,qm,q,rn,qm,qn"))]
2140   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
2141 {
2142   switch (get_attr_type (insn))
2143     {
2144     case TYPE_IMOVX:
2145       gcc_assert (ANY_QI_REG_P (operands[1]) || MEM_P (operands[1]));
2146       return "movz{bl|x}\t{%1, %k0|%k0, %1}";
2147     default:
2148       if (get_attr_mode (insn) == MODE_SI)
2149         return "mov{l}\t{%k1, %k0|%k0, %k1}";
2150       else
2151         return "mov{b}\t{%1, %0|%0, %1}";
2152     }
2153 }
2154   [(set (attr "type")
2155      (cond [(and (eq_attr "alternative" "5")
2156                  (not (match_operand:QI 1 "aligned_operand" "")))
2157               (const_string "imovx")
2158             (ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0))
2159               (const_string "imov")
2160             (and (eq_attr "alternative" "3")
2161                  (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
2162                           (const_int 0))
2163                       (eq (symbol_ref "TARGET_QIMODE_MATH")
2164                           (const_int 0))))
2165               (const_string "imov")
2166             (eq_attr "alternative" "3,5")
2167               (const_string "imovx")
2168             (and (ne (symbol_ref "TARGET_MOVX")
2169                      (const_int 0))
2170                  (eq_attr "alternative" "2"))
2171               (const_string "imovx")
2172            ]
2173            (const_string "imov")))
2174    (set (attr "mode")
2175       (cond [(eq_attr "alternative" "3,4,5")
2176                (const_string "SI")
2177              (eq_attr "alternative" "6")
2178                (const_string "QI")
2179              (eq_attr "type" "imovx")
2180                (const_string "SI")
2181              (and (eq_attr "type" "imov")
2182                   (and (eq_attr "alternative" "0,1")
2183                        (and (ne (symbol_ref "TARGET_PARTIAL_REG_DEPENDENCY")
2184                                 (const_int 0))
2185                             (and (eq (symbol_ref "optimize_function_for_size_p (cfun)")
2186                                      (const_int 0))
2187                                  (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
2188                                      (const_int 0))))))
2189                (const_string "SI")
2190              ;; Avoid partial register stalls when not using QImode arithmetic
2191              (and (eq_attr "type" "imov")
2192                   (and (eq_attr "alternative" "0,1")
2193                        (and (ne (symbol_ref "TARGET_PARTIAL_REG_STALL")
2194                                 (const_int 0))
2195                             (eq (symbol_ref "TARGET_QIMODE_MATH")
2196                                 (const_int 0)))))
2197                (const_string "SI")
2198            ]
2199            (const_string "QI")))])
2200
2201 (define_insn "*swapqi_1"
2202   [(set (match_operand:QI 0 "register_operand" "+r")
2203         (match_operand:QI 1 "register_operand" "+r"))
2204    (set (match_dup 1)
2205         (match_dup 0))]
2206   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
2207   "xchg{l}\t%k1, %k0"
2208   [(set_attr "type" "imov")
2209    (set_attr "mode" "SI")
2210    (set_attr "pent_pair" "np")
2211    (set_attr "athlon_decode" "vector")
2212    (set_attr "amdfam10_decode" "vector")])
2213
2214 ;; Not added amdfam10_decode since TARGET_PARTIAL_REG_STALL is disabled for AMDFAM10
2215 (define_insn "*swapqi_2"
2216   [(set (match_operand:QI 0 "register_operand" "+q")
2217         (match_operand:QI 1 "register_operand" "+q"))
2218    (set (match_dup 1)
2219         (match_dup 0))]
2220   "TARGET_PARTIAL_REG_STALL"
2221   "xchg{b}\t%1, %0"
2222   [(set_attr "type" "imov")
2223    (set_attr "mode" "QI")
2224    (set_attr "pent_pair" "np")
2225    (set_attr "athlon_decode" "vector")])
2226
2227 (define_expand "movstrictqi"
2228   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" ""))
2229         (match_operand:QI 1 "general_operand" ""))]
2230   ""
2231 {
2232   if (TARGET_PARTIAL_REG_STALL && optimize_function_for_speed_p (cfun))
2233     FAIL;
2234   /* Don't generate memory->memory moves, go through a register.  */
2235   if (MEM_P (operands[0]) && MEM_P (operands[1]))
2236     operands[1] = force_reg (QImode, operands[1]);
2237 })
2238
2239 (define_insn "*movstrictqi_1"
2240   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+qm,q"))
2241         (match_operand:QI 1 "general_operand" "*qn,m"))]
2242   "(! TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
2243    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2244   "mov{b}\t{%1, %0|%0, %1}"
2245   [(set_attr "type" "imov")
2246    (set_attr "mode" "QI")])
2247
2248 (define_insn "*movstrictqi_xor"
2249   [(set (strict_low_part (match_operand:QI 0 "q_regs_operand" "+q"))
2250         (match_operand:QI 1 "const0_operand" ""))
2251    (clobber (reg:CC FLAGS_REG))]
2252   "reload_completed"
2253   "xor{b}\t%0, %0"
2254   [(set_attr "type" "alu1")
2255    (set_attr "mode" "QI")
2256    (set_attr "length_immediate" "0")])
2257
2258 (define_insn "*movsi_extv_1"
2259   [(set (match_operand:SI 0 "register_operand" "=R")
2260         (sign_extract:SI (match_operand 1 "ext_register_operand" "Q")
2261                          (const_int 8)
2262                          (const_int 8)))]
2263   ""
2264   "movs{bl|x}\t{%h1, %0|%0, %h1}"
2265   [(set_attr "type" "imovx")
2266    (set_attr "mode" "SI")])
2267
2268 (define_insn "*movhi_extv_1"
2269   [(set (match_operand:HI 0 "register_operand" "=R")
2270         (sign_extract:HI (match_operand 1 "ext_register_operand" "Q")
2271                          (const_int 8)
2272                          (const_int 8)))]
2273   ""
2274   "movs{bl|x}\t{%h1, %k0|%k0, %h1}"
2275   [(set_attr "type" "imovx")
2276    (set_attr "mode" "SI")])
2277
2278 (define_insn "*movqi_extv_1"
2279   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?r")
2280         (sign_extract:QI (match_operand 1 "ext_register_operand" "Q,Q")
2281                          (const_int 8)
2282                          (const_int 8)))]
2283   "!TARGET_64BIT"
2284 {
2285   switch (get_attr_type (insn))
2286     {
2287     case TYPE_IMOVX:
2288       return "movs{bl|x}\t{%h1, %k0|%k0, %h1}";
2289     default:
2290       return "mov{b}\t{%h1, %0|%0, %h1}";
2291     }
2292 }
2293   [(set (attr "type")
2294      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2295                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2296                              (ne (symbol_ref "TARGET_MOVX")
2297                                  (const_int 0))))
2298         (const_string "imovx")
2299         (const_string "imov")))
2300    (set (attr "mode")
2301      (if_then_else (eq_attr "type" "imovx")
2302         (const_string "SI")
2303         (const_string "QI")))])
2304
2305 (define_insn "*movqi_extv_1_rex64"
2306   [(set (match_operand:QI 0 "register_operand" "=Q,?R")
2307         (sign_extract:QI (match_operand 1 "ext_register_operand" "Q,Q")
2308                          (const_int 8)
2309                          (const_int 8)))]
2310   "TARGET_64BIT"
2311 {
2312   switch (get_attr_type (insn))
2313     {
2314     case TYPE_IMOVX:
2315       return "movs{bl|x}\t{%h1, %k0|%k0, %h1}";
2316     default:
2317       return "mov{b}\t{%h1, %0|%0, %h1}";
2318     }
2319 }
2320   [(set (attr "type")
2321      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2322                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2323                              (ne (symbol_ref "TARGET_MOVX")
2324                                  (const_int 0))))
2325         (const_string "imovx")
2326         (const_string "imov")))
2327    (set (attr "mode")
2328      (if_then_else (eq_attr "type" "imovx")
2329         (const_string "SI")
2330         (const_string "QI")))])
2331
2332 ;; Stores and loads of ax to arbitrary constant address.
2333 ;; We fake an second form of instruction to force reload to load address
2334 ;; into register when rax is not available
2335 (define_insn "*movabsqi_1_rex64"
2336   [(set (mem:QI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
2337         (match_operand:QI 1 "nonmemory_operand" "a,er"))]
2338   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
2339   "@
2340    movabs{b}\t{%1, %P0|%P0, %1}
2341    mov{b}\t{%1, %a0|%a0, %1}"
2342   [(set_attr "type" "imov")
2343    (set_attr "modrm" "0,*")
2344    (set_attr "length_address" "8,0")
2345    (set_attr "length_immediate" "0,*")
2346    (set_attr "memory" "store")
2347    (set_attr "mode" "QI")])
2348
2349 (define_insn "*movabsqi_2_rex64"
2350   [(set (match_operand:QI 0 "register_operand" "=a,r")
2351         (mem:QI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
2352   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
2353   "@
2354    movabs{b}\t{%P1, %0|%0, %P1}
2355    mov{b}\t{%a1, %0|%0, %a1}"
2356   [(set_attr "type" "imov")
2357    (set_attr "modrm" "0,*")
2358    (set_attr "length_address" "8,0")
2359    (set_attr "length_immediate" "0")
2360    (set_attr "memory" "load")
2361    (set_attr "mode" "QI")])
2362
2363 (define_insn "*movdi_extzv_1"
2364   [(set (match_operand:DI 0 "register_operand" "=R")
2365         (zero_extract:DI (match_operand 1 "ext_register_operand" "Q")
2366                          (const_int 8)
2367                          (const_int 8)))]
2368   "TARGET_64BIT"
2369   "movz{bl|x}\t{%h1, %k0|%k0, %h1}"
2370   [(set_attr "type" "imovx")
2371    (set_attr "mode" "SI")])
2372
2373 (define_insn "*movsi_extzv_1"
2374   [(set (match_operand:SI 0 "register_operand" "=R")
2375         (zero_extract:SI (match_operand 1 "ext_register_operand" "Q")
2376                          (const_int 8)
2377                          (const_int 8)))]
2378   ""
2379   "movz{bl|x}\t{%h1, %0|%0, %h1}"
2380   [(set_attr "type" "imovx")
2381    (set_attr "mode" "SI")])
2382
2383 (define_insn "*movqi_extzv_2"
2384   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?R")
2385         (subreg:QI (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
2386                                     (const_int 8)
2387                                     (const_int 8)) 0))]
2388   "!TARGET_64BIT"
2389 {
2390   switch (get_attr_type (insn))
2391     {
2392     case TYPE_IMOVX:
2393       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2394     default:
2395       return "mov{b}\t{%h1, %0|%0, %h1}";
2396     }
2397 }
2398   [(set (attr "type")
2399      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2400                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2401                              (ne (symbol_ref "TARGET_MOVX")
2402                                  (const_int 0))))
2403         (const_string "imovx")
2404         (const_string "imov")))
2405    (set (attr "mode")
2406      (if_then_else (eq_attr "type" "imovx")
2407         (const_string "SI")
2408         (const_string "QI")))])
2409
2410 (define_insn "*movqi_extzv_2_rex64"
2411   [(set (match_operand:QI 0 "register_operand" "=Q,?R")
2412         (subreg:QI (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
2413                                     (const_int 8)
2414                                     (const_int 8)) 0))]
2415   "TARGET_64BIT"
2416 {
2417   switch (get_attr_type (insn))
2418     {
2419     case TYPE_IMOVX:
2420       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2421     default:
2422       return "mov{b}\t{%h1, %0|%0, %h1}";
2423     }
2424 }
2425   [(set (attr "type")
2426      (if_then_else (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2427                         (ne (symbol_ref "TARGET_MOVX")
2428                             (const_int 0)))
2429         (const_string "imovx")
2430         (const_string "imov")))
2431    (set (attr "mode")
2432      (if_then_else (eq_attr "type" "imovx")
2433         (const_string "SI")
2434         (const_string "QI")))])
2435
2436 (define_insn "movsi_insv_1"
2437   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2438                          (const_int 8)
2439                          (const_int 8))
2440         (match_operand:SI 1 "general_operand" "Qmn"))]
2441   "!TARGET_64BIT"
2442   "mov{b}\t{%b1, %h0|%h0, %b1}"
2443   [(set_attr "type" "imov")
2444    (set_attr "mode" "QI")])
2445
2446 (define_insn "*movsi_insv_1_rex64"
2447   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2448                          (const_int 8)
2449                          (const_int 8))
2450         (match_operand:SI 1 "nonmemory_operand" "Qn"))]
2451   "TARGET_64BIT"
2452   "mov{b}\t{%b1, %h0|%h0, %b1}"
2453   [(set_attr "type" "imov")
2454    (set_attr "mode" "QI")])
2455
2456 (define_insn "movdi_insv_1_rex64"
2457   [(set (zero_extract:DI (match_operand 0 "ext_register_operand" "+Q")
2458                          (const_int 8)
2459                          (const_int 8))
2460         (match_operand:DI 1 "nonmemory_operand" "Qn"))]
2461   "TARGET_64BIT"
2462   "mov{b}\t{%b1, %h0|%h0, %b1}"
2463   [(set_attr "type" "imov")
2464    (set_attr "mode" "QI")])
2465
2466 (define_insn "*movqi_insv_2"
2467   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2468                          (const_int 8)
2469                          (const_int 8))
2470         (lshiftrt:SI (match_operand:SI 1 "register_operand" "Q")
2471                      (const_int 8)))]
2472   ""
2473   "mov{b}\t{%h1, %h0|%h0, %h1}"
2474   [(set_attr "type" "imov")
2475    (set_attr "mode" "QI")])
2476
2477 (define_expand "movdi"
2478   [(set (match_operand:DI 0 "nonimmediate_operand" "")
2479         (match_operand:DI 1 "general_operand" ""))]
2480   ""
2481   "ix86_expand_move (DImode, operands); DONE;")
2482
2483 (define_insn "*pushdi"
2484   [(set (match_operand:DI 0 "push_operand" "=<")
2485         (match_operand:DI 1 "general_no_elim_operand" "riF*m"))]
2486   "!TARGET_64BIT"
2487   "#")
2488
2489 (define_insn "*pushdi2_rex64"
2490   [(set (match_operand:DI 0 "push_operand" "=<,!<")
2491         (match_operand:DI 1 "general_no_elim_operand" "re*m,n"))]
2492   "TARGET_64BIT"
2493   "@
2494    push{q}\t%1
2495    #"
2496   [(set_attr "type" "push,multi")
2497    (set_attr "mode" "DI")])
2498
2499 ;; Convert impossible pushes of immediate to existing instructions.
2500 ;; First try to get scratch register and go through it.  In case this
2501 ;; fails, push sign extended lower part first and then overwrite
2502 ;; upper part by 32bit move.
2503 (define_peephole2
2504   [(match_scratch:DI 2 "r")
2505    (set (match_operand:DI 0 "push_operand" "")
2506         (match_operand:DI 1 "immediate_operand" ""))]
2507   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2508    && !x86_64_immediate_operand (operands[1], DImode)"
2509   [(set (match_dup 2) (match_dup 1))
2510    (set (match_dup 0) (match_dup 2))]
2511   "")
2512
2513 ;; We need to define this as both peepholer and splitter for case
2514 ;; peephole2 pass is not run.
2515 ;; "&& 1" is needed to keep it from matching the previous pattern.
2516 (define_peephole2
2517   [(set (match_operand:DI 0 "push_operand" "")
2518         (match_operand:DI 1 "immediate_operand" ""))]
2519   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2520    && !x86_64_immediate_operand (operands[1], DImode) && 1"
2521   [(set (match_dup 0) (match_dup 1))
2522    (set (match_dup 2) (match_dup 3))]
2523   "split_di (&operands[1], 1, &operands[2], &operands[3]);
2524    operands[1] = gen_lowpart (DImode, operands[2]);
2525    operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx,
2526                                                     GEN_INT (4)));
2527   ")
2528
2529 (define_split
2530   [(set (match_operand:DI 0 "push_operand" "")
2531         (match_operand:DI 1 "immediate_operand" ""))]
2532   "TARGET_64BIT && ((optimize > 0 && flag_peephole2)
2533                     ? epilogue_completed : reload_completed)
2534    && !symbolic_operand (operands[1], DImode)
2535    && !x86_64_immediate_operand (operands[1], DImode)"
2536   [(set (match_dup 0) (match_dup 1))
2537    (set (match_dup 2) (match_dup 3))]
2538   "split_di (&operands[1], 1, &operands[2], &operands[3]);
2539    operands[1] = gen_lowpart (DImode, operands[2]);
2540    operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx,
2541                                                     GEN_INT (4)));
2542   ")
2543
2544 (define_insn "*pushdi2_prologue_rex64"
2545   [(set (match_operand:DI 0 "push_operand" "=<")
2546         (match_operand:DI 1 "general_no_elim_operand" "re*m"))
2547    (clobber (mem:BLK (scratch)))]
2548   "TARGET_64BIT"
2549   "push{q}\t%1"
2550   [(set_attr "type" "push")
2551    (set_attr "mode" "DI")])
2552
2553 (define_insn "*popdi1_epilogue_rex64"
2554   [(set (match_operand:DI 0 "nonimmediate_operand" "=r*m")
2555         (mem:DI (reg:DI SP_REG)))
2556    (set (reg:DI SP_REG)
2557         (plus:DI (reg:DI SP_REG) (const_int 8)))
2558    (clobber (mem:BLK (scratch)))]
2559   "TARGET_64BIT"
2560   "pop{q}\t%0"
2561   [(set_attr "type" "pop")
2562    (set_attr "mode" "DI")])
2563
2564 (define_insn "popdi1"
2565   [(set (match_operand:DI 0 "nonimmediate_operand" "=r*m")
2566         (mem:DI (reg:DI SP_REG)))
2567    (set (reg:DI SP_REG)
2568         (plus:DI (reg:DI SP_REG) (const_int 8)))]
2569   "TARGET_64BIT"
2570   "pop{q}\t%0"
2571   [(set_attr "type" "pop")
2572    (set_attr "mode" "DI")])
2573
2574 (define_insn "*movdi_xor_rex64"
2575   [(set (match_operand:DI 0 "register_operand" "=r")
2576         (match_operand:DI 1 "const0_operand" ""))
2577    (clobber (reg:CC FLAGS_REG))]
2578   "TARGET_64BIT
2579    && reload_completed"
2580   "xor{l}\t%k0, %k0";
2581   [(set_attr "type" "alu1")
2582    (set_attr "mode" "SI")
2583    (set_attr "length_immediate" "0")])
2584
2585 (define_insn "*movdi_or_rex64"
2586   [(set (match_operand:DI 0 "register_operand" "=r")
2587         (match_operand:DI 1 "const_int_operand" "i"))
2588    (clobber (reg:CC FLAGS_REG))]
2589   "TARGET_64BIT
2590    && reload_completed
2591    && operands[1] == constm1_rtx"
2592 {
2593   operands[1] = constm1_rtx;
2594   return "or{q}\t{%1, %0|%0, %1}";
2595 }
2596   [(set_attr "type" "alu1")
2597    (set_attr "mode" "DI")
2598    (set_attr "length_immediate" "1")])
2599
2600 (define_insn "*movdi_2"
2601   [(set (match_operand:DI 0 "nonimmediate_operand"
2602                         "=r  ,o  ,*y,m*y,*y,*Y2,m  ,*Y2,*Y2,*x,m ,*x,*x")
2603         (match_operand:DI 1 "general_operand"
2604                         "riFo,riF,C ,*y ,m ,C  ,*Y2,*Y2,m  ,C ,*x,*x,m "))]
2605   "!TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2606   "@
2607    #
2608    #
2609    pxor\t%0, %0
2610    movq\t{%1, %0|%0, %1}
2611    movq\t{%1, %0|%0, %1}
2612    %vpxor\t%0, %d0
2613    %vmovq\t{%1, %0|%0, %1}
2614    %vmovdqa\t{%1, %0|%0, %1}
2615    %vmovq\t{%1, %0|%0, %1}
2616    xorps\t%0, %0
2617    movlps\t{%1, %0|%0, %1}
2618    movaps\t{%1, %0|%0, %1}
2619    movlps\t{%1, %0|%0, %1}"
2620   [(set_attr "type" "*,*,mmx,mmxmov,mmxmov,sselog1,ssemov,ssemov,ssemov,sselog1,ssemov,ssemov,ssemov")
2621    (set (attr "prefix")
2622      (if_then_else (eq_attr "alternative" "5,6,7,8")
2623        (const_string "vex")
2624        (const_string "orig")))
2625    (set_attr "mode" "DI,DI,DI,DI,DI,TI,DI,TI,DI,V4SF,V2SF,V4SF,V2SF")])
2626
2627 (define_split
2628   [(set (match_operand:DI 0 "push_operand" "")
2629         (match_operand:DI 1 "general_operand" ""))]
2630   "!TARGET_64BIT && reload_completed
2631    && (! MMX_REG_P (operands[1]) && !SSE_REG_P (operands[1]))"
2632   [(const_int 0)]
2633   "ix86_split_long_move (operands); DONE;")
2634
2635 ;; %%% This multiword shite has got to go.
2636 (define_split
2637   [(set (match_operand:DI 0 "nonimmediate_operand" "")
2638         (match_operand:DI 1 "general_operand" ""))]
2639   "!TARGET_64BIT && reload_completed
2640    && (!MMX_REG_P (operands[0]) && !SSE_REG_P (operands[0]))
2641    && (!MMX_REG_P (operands[1]) && !SSE_REG_P (operands[1]))"
2642   [(const_int 0)]
2643   "ix86_split_long_move (operands); DONE;")
2644
2645 (define_insn "*movdi_1_rex64"
2646   [(set (match_operand:DI 0 "nonimmediate_operand"
2647           "=r,r  ,r,m ,!m,*y,*y,?r ,m ,?*Ym,?*y,*x,*x,?r ,m,?*Yi,*x,?*x,?*Ym")
2648         (match_operand:DI 1 "general_operand"
2649           "Z ,rem,i,re,n ,C ,*y,*Ym,*y,r   ,m  ,C ,*x,*Yi,*x,r  ,m ,*Ym,*x"))]
2650   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2651 {
2652   switch (get_attr_type (insn))
2653     {
2654     case TYPE_SSECVT:
2655       if (SSE_REG_P (operands[0]))
2656         return "movq2dq\t{%1, %0|%0, %1}";
2657       else
2658         return "movdq2q\t{%1, %0|%0, %1}";
2659
2660     case TYPE_SSEMOV:
2661       if (TARGET_AVX)
2662         {
2663           if (get_attr_mode (insn) == MODE_TI)
2664             return "vmovdqa\t{%1, %0|%0, %1}";
2665           else
2666             return "vmovq\t{%1, %0|%0, %1}";
2667         }
2668
2669       if (get_attr_mode (insn) == MODE_TI)
2670         return "movdqa\t{%1, %0|%0, %1}";
2671       /* FALLTHRU */
2672
2673     case TYPE_MMXMOV:
2674       /* Moves from and into integer register is done using movd
2675          opcode with REX prefix.  */
2676       if (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1]))
2677         return "movd\t{%1, %0|%0, %1}";
2678       return "movq\t{%1, %0|%0, %1}";
2679
2680     case TYPE_SSELOG1:
2681       return "%vpxor\t%0, %d0";
2682
2683     case TYPE_MMX:
2684       return "pxor\t%0, %0";
2685
2686     case TYPE_MULTI:
2687       return "#";
2688
2689     case TYPE_LEA:
2690       return "lea{q}\t{%a1, %0|%0, %a1}";
2691
2692     default:
2693       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
2694       if (get_attr_mode (insn) == MODE_SI)
2695         return "mov{l}\t{%k1, %k0|%k0, %k1}";
2696       else if (which_alternative == 2)
2697         return "movabs{q}\t{%1, %0|%0, %1}";
2698       else
2699         return "mov{q}\t{%1, %0|%0, %1}";
2700     }
2701 }
2702   [(set (attr "type")
2703      (cond [(eq_attr "alternative" "5")
2704               (const_string "mmx")
2705             (eq_attr "alternative" "6,7,8,9,10")
2706               (const_string "mmxmov")
2707             (eq_attr "alternative" "11")
2708               (const_string "sselog1")
2709             (eq_attr "alternative" "12,13,14,15,16")
2710               (const_string "ssemov")
2711             (eq_attr "alternative" "17,18")
2712               (const_string "ssecvt")
2713             (eq_attr "alternative" "4")
2714               (const_string "multi")
2715             (match_operand:DI 1 "pic_32bit_operand" "")
2716               (const_string "lea")
2717            ]
2718            (const_string "imov")))
2719    (set (attr "modrm")
2720      (if_then_else
2721        (and (eq_attr "alternative" "2") (eq_attr "type" "imov"))
2722          (const_string "0")
2723          (const_string "*")))
2724    (set (attr "length_immediate")
2725      (if_then_else
2726        (and (eq_attr "alternative" "2") (eq_attr "type" "imov"))
2727          (const_string "8")
2728          (const_string "*")))
2729    (set_attr "prefix_rex" "*,*,*,*,*,*,*,1,*,1,*,*,*,*,*,*,*,*,*")
2730    (set_attr "prefix_data16" "*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,1,*,*,*")
2731    (set (attr "prefix")
2732      (if_then_else (eq_attr "alternative" "11,12,13,14,15,16")
2733        (const_string "maybe_vex")
2734        (const_string "orig")))
2735    (set_attr "mode" "SI,DI,DI,DI,SI,DI,DI,DI,DI,DI,DI,TI,TI,DI,DI,DI,DI,DI,DI")])
2736
2737 ;; Stores and loads of ax to arbitrary constant address.
2738 ;; We fake an second form of instruction to force reload to load address
2739 ;; into register when rax is not available
2740 (define_insn "*movabsdi_1_rex64"
2741   [(set (mem:DI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
2742         (match_operand:DI 1 "nonmemory_operand" "a,er"))]
2743   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
2744   "@
2745    movabs{q}\t{%1, %P0|%P0, %1}
2746    mov{q}\t{%1, %a0|%a0, %1}"
2747   [(set_attr "type" "imov")
2748    (set_attr "modrm" "0,*")
2749    (set_attr "length_address" "8,0")
2750    (set_attr "length_immediate" "0,*")
2751    (set_attr "memory" "store")
2752    (set_attr "mode" "DI")])
2753
2754 (define_insn "*movabsdi_2_rex64"
2755   [(set (match_operand:DI 0 "register_operand" "=a,r")
2756         (mem:DI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
2757   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
2758   "@
2759    movabs{q}\t{%P1, %0|%0, %P1}
2760    mov{q}\t{%a1, %0|%0, %a1}"
2761   [(set_attr "type" "imov")
2762    (set_attr "modrm" "0,*")
2763    (set_attr "length_address" "8,0")
2764    (set_attr "length_immediate" "0")
2765    (set_attr "memory" "load")
2766    (set_attr "mode" "DI")])
2767
2768 ;; Convert impossible stores of immediate to existing instructions.
2769 ;; First try to get scratch register and go through it.  In case this
2770 ;; fails, move by 32bit parts.
2771 (define_peephole2
2772   [(match_scratch:DI 2 "r")
2773    (set (match_operand:DI 0 "memory_operand" "")
2774         (match_operand:DI 1 "immediate_operand" ""))]
2775   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2776    && !x86_64_immediate_operand (operands[1], DImode)"
2777   [(set (match_dup 2) (match_dup 1))
2778    (set (match_dup 0) (match_dup 2))]
2779   "")
2780
2781 ;; We need to define this as both peepholer and splitter for case
2782 ;; peephole2 pass is not run.
2783 ;; "&& 1" is needed to keep it from matching the previous pattern.
2784 (define_peephole2
2785   [(set (match_operand:DI 0 "memory_operand" "")
2786         (match_operand:DI 1 "immediate_operand" ""))]
2787   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2788    && !x86_64_immediate_operand (operands[1], DImode) && 1"
2789   [(set (match_dup 2) (match_dup 3))
2790    (set (match_dup 4) (match_dup 5))]
2791   "split_di (&operands[0], 2, &operands[2], &operands[4]);")
2792
2793 (define_split
2794   [(set (match_operand:DI 0 "memory_operand" "")
2795         (match_operand:DI 1 "immediate_operand" ""))]
2796   "TARGET_64BIT && ((optimize > 0 && flag_peephole2)
2797                     ? epilogue_completed : reload_completed)
2798    && !symbolic_operand (operands[1], DImode)
2799    && !x86_64_immediate_operand (operands[1], DImode)"
2800   [(set (match_dup 2) (match_dup 3))
2801    (set (match_dup 4) (match_dup 5))]
2802   "split_di (&operands[0], 2, &operands[2], &operands[4]);")
2803
2804 (define_insn "*swapdi_rex64"
2805   [(set (match_operand:DI 0 "register_operand" "+r")
2806         (match_operand:DI 1 "register_operand" "+r"))
2807    (set (match_dup 1)
2808         (match_dup 0))]
2809   "TARGET_64BIT"
2810   "xchg{q}\t%1, %0"
2811   [(set_attr "type" "imov")
2812    (set_attr "mode" "DI")
2813    (set_attr "pent_pair" "np")
2814    (set_attr "athlon_decode" "vector")
2815    (set_attr "amdfam10_decode" "double")])
2816
2817 (define_expand "movoi"
2818   [(set (match_operand:OI 0 "nonimmediate_operand" "")
2819         (match_operand:OI 1 "general_operand" ""))]
2820   "TARGET_AVX"
2821   "ix86_expand_move (OImode, operands); DONE;")
2822
2823 (define_insn "*movoi_internal"
2824   [(set (match_operand:OI 0 "nonimmediate_operand" "=x,x,m")
2825         (match_operand:OI 1 "vector_move_operand" "C,xm,x"))]
2826   "TARGET_AVX
2827    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2828 {
2829   switch (which_alternative)
2830     {
2831     case 0:
2832       return "vxorps\t%0, %0, %0";
2833     case 1:
2834     case 2:
2835       if (misaligned_operand (operands[0], OImode)
2836           || misaligned_operand (operands[1], OImode))
2837         return "vmovdqu\t{%1, %0|%0, %1}";
2838       else
2839         return "vmovdqa\t{%1, %0|%0, %1}";
2840     default:
2841       gcc_unreachable ();
2842     }
2843 }
2844   [(set_attr "type" "sselog1,ssemov,ssemov")
2845    (set_attr "prefix" "vex")
2846    (set_attr "mode" "OI")])
2847
2848 (define_expand "movti"
2849   [(set (match_operand:TI 0 "nonimmediate_operand" "")
2850         (match_operand:TI 1 "nonimmediate_operand" ""))]
2851   "TARGET_SSE || TARGET_64BIT"
2852 {
2853   if (TARGET_64BIT)
2854     ix86_expand_move (TImode, operands);
2855   else if (push_operand (operands[0], TImode))
2856     ix86_expand_push (TImode, operands[1]);
2857   else
2858     ix86_expand_vector_move (TImode, operands);
2859   DONE;
2860 })
2861
2862 (define_insn "*movti_internal"
2863   [(set (match_operand:TI 0 "nonimmediate_operand" "=x,x,m")
2864         (match_operand:TI 1 "vector_move_operand" "C,xm,x"))]
2865   "TARGET_SSE && !TARGET_64BIT
2866    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2867 {
2868   switch (which_alternative)
2869     {
2870     case 0:
2871       if (get_attr_mode (insn) == MODE_V4SF)
2872         return "%vxorps\t%0, %d0";
2873       else
2874         return "%vpxor\t%0, %d0";
2875     case 1:
2876     case 2:
2877       /* TDmode values are passed as TImode on the stack.  Moving them
2878          to stack may result in unaligned memory access.  */
2879       if (misaligned_operand (operands[0], TImode)
2880           || misaligned_operand (operands[1], TImode))
2881         {
2882           if (get_attr_mode (insn) == MODE_V4SF)
2883             return "%vmovups\t{%1, %0|%0, %1}";
2884          else
2885            return "%vmovdqu\t{%1, %0|%0, %1}";
2886         }
2887       else
2888         {
2889           if (get_attr_mode (insn) == MODE_V4SF)
2890             return "%vmovaps\t{%1, %0|%0, %1}";
2891          else
2892            return "%vmovdqa\t{%1, %0|%0, %1}";
2893         }
2894     default:
2895       gcc_unreachable ();
2896     }
2897 }
2898   [(set_attr "type" "sselog1,ssemov,ssemov")
2899    (set_attr "prefix" "maybe_vex")
2900    (set (attr "mode")
2901         (cond [(ior (eq (symbol_ref "TARGET_SSE2") (const_int 0))
2902                     (ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0)))
2903                  (const_string "V4SF")
2904                (and (eq_attr "alternative" "2")
2905                     (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
2906                         (const_int 0)))
2907                  (const_string "V4SF")]
2908               (const_string "TI")))])
2909
2910 (define_insn "*movti_rex64"
2911   [(set (match_operand:TI 0 "nonimmediate_operand" "=!r,o,x,x,xm")
2912         (match_operand:TI 1 "general_operand" "riFo,riF,C,xm,x"))]
2913   "TARGET_64BIT
2914    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2915 {
2916   switch (which_alternative)
2917     {
2918     case 0:
2919     case 1:
2920       return "#";
2921     case 2:
2922       if (get_attr_mode (insn) == MODE_V4SF)
2923         return "%vxorps\t%0, %d0";
2924       else
2925         return "%vpxor\t%0, %d0";
2926     case 3:
2927     case 4:
2928       /* TDmode values are passed as TImode on the stack.  Moving them
2929          to stack may result in unaligned memory access.  */
2930       if (misaligned_operand (operands[0], TImode)
2931           || misaligned_operand (operands[1], TImode))
2932         {
2933           if (get_attr_mode (insn) == MODE_V4SF)
2934             return "%vmovups\t{%1, %0|%0, %1}";
2935          else
2936            return "%vmovdqu\t{%1, %0|%0, %1}";
2937         }
2938       else
2939         {
2940           if (get_attr_mode (insn) == MODE_V4SF)
2941             return "%vmovaps\t{%1, %0|%0, %1}";
2942          else
2943            return "%vmovdqa\t{%1, %0|%0, %1}";
2944         }
2945     default:
2946       gcc_unreachable ();
2947     }
2948 }
2949   [(set_attr "type" "*,*,sselog1,ssemov,ssemov")
2950    (set_attr "prefix" "*,*,maybe_vex,maybe_vex,maybe_vex")
2951    (set (attr "mode")
2952         (cond [(eq_attr "alternative" "2,3")
2953                  (if_then_else
2954                    (ne (symbol_ref "optimize_function_for_size_p (cfun)")
2955                        (const_int 0))
2956                    (const_string "V4SF")
2957                    (const_string "TI"))
2958                (eq_attr "alternative" "4")
2959                  (if_then_else
2960                    (ior (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
2961                             (const_int 0))
2962                         (ne (symbol_ref "optimize_function_for_size_p (cfun)")
2963                             (const_int 0)))
2964                    (const_string "V4SF")
2965                    (const_string "TI"))]
2966                (const_string "DI")))])
2967
2968 (define_split
2969   [(set (match_operand:TI 0 "nonimmediate_operand" "")
2970         (match_operand:TI 1 "general_operand" ""))]
2971   "reload_completed && !SSE_REG_P (operands[0])
2972    && !SSE_REG_P (operands[1])"
2973   [(const_int 0)]
2974   "ix86_split_long_move (operands); DONE;")
2975
2976 ;; This expands to what emit_move_complex would generate if we didn't
2977 ;; have a movti pattern.  Having this avoids problems with reload on
2978 ;; 32-bit targets when SSE is present, but doesn't seem to be harmful
2979 ;; to have around all the time.
2980 (define_expand "movcdi"
2981   [(set (match_operand:CDI 0 "nonimmediate_operand" "")
2982         (match_operand:CDI 1 "general_operand" ""))]
2983   ""
2984 {
2985   if (push_operand (operands[0], CDImode))
2986     emit_move_complex_push (CDImode, operands[0], operands[1]);
2987   else
2988     emit_move_complex_parts (operands[0], operands[1]);
2989   DONE;
2990 })
2991
2992 (define_expand "movsf"
2993   [(set (match_operand:SF 0 "nonimmediate_operand" "")
2994         (match_operand:SF 1 "general_operand" ""))]
2995   ""
2996   "ix86_expand_move (SFmode, operands); DONE;")
2997
2998 (define_insn "*pushsf"
2999   [(set (match_operand:SF 0 "push_operand" "=<,<,<")
3000         (match_operand:SF 1 "general_no_elim_operand" "f,rFm,x"))]
3001   "!TARGET_64BIT"
3002 {
3003   /* Anything else should be already split before reg-stack.  */
3004   gcc_assert (which_alternative == 1);
3005   return "push{l}\t%1";
3006 }
3007   [(set_attr "type" "multi,push,multi")
3008    (set_attr "unit" "i387,*,*")
3009    (set_attr "mode" "SF,SI,SF")])
3010
3011 (define_insn "*pushsf_rex64"
3012   [(set (match_operand:SF 0 "push_operand" "=X,X,X")
3013         (match_operand:SF 1 "nonmemory_no_elim_operand" "f,rF,x"))]
3014   "TARGET_64BIT"
3015 {
3016   /* Anything else should be already split before reg-stack.  */
3017   gcc_assert (which_alternative == 1);
3018   return "push{q}\t%q1";
3019 }
3020   [(set_attr "type" "multi,push,multi")
3021    (set_attr "unit" "i387,*,*")
3022    (set_attr "mode" "SF,DI,SF")])
3023
3024 (define_split
3025   [(set (match_operand:SF 0 "push_operand" "")
3026         (match_operand:SF 1 "memory_operand" ""))]
3027   "reload_completed
3028    && MEM_P (operands[1])
3029    && (operands[2] = find_constant_src (insn))"
3030   [(set (match_dup 0)
3031         (match_dup 2))])
3032
3033 ;; %%% Kill this when call knows how to work this out.
3034 (define_split
3035   [(set (match_operand:SF 0 "push_operand" "")
3036         (match_operand:SF 1 "any_fp_register_operand" ""))]
3037   "!TARGET_64BIT"
3038   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int -4)))
3039    (set (mem:SF (reg:SI SP_REG)) (match_dup 1))])
3040
3041 (define_split
3042   [(set (match_operand:SF 0 "push_operand" "")
3043         (match_operand:SF 1 "any_fp_register_operand" ""))]
3044   "TARGET_64BIT"
3045   [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int -8)))
3046    (set (mem:SF (reg:DI SP_REG)) (match_dup 1))])
3047
3048 (define_insn "*movsf_1"
3049   [(set (match_operand:SF 0 "nonimmediate_operand"
3050           "=f,m,f,r  ,m ,x,x,x ,m,!*y,!m,!*y,?Yi,?r,!*Ym,!r")
3051         (match_operand:SF 1 "general_operand"
3052           "fm,f,G,rmF,Fr,C,x,xm,x,m  ,*y,*y ,r  ,Yi,r   ,*Ym"))]
3053   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
3054    && (reload_in_progress || reload_completed
3055        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3056        || (!TARGET_SSE_MATH && optimize_function_for_size_p (cfun)
3057            && standard_80387_constant_p (operands[1]))
3058        || GET_CODE (operands[1]) != CONST_DOUBLE
3059        || memory_operand (operands[0], SFmode))"
3060 {
3061   switch (which_alternative)
3062     {
3063     case 0:
3064     case 1:
3065       return output_387_reg_move (insn, operands);
3066
3067     case 2:
3068       return standard_80387_constant_opcode (operands[1]);
3069
3070     case 3:
3071     case 4:
3072       return "mov{l}\t{%1, %0|%0, %1}";
3073     case 5:
3074       if (get_attr_mode (insn) == MODE_TI)
3075         return "%vpxor\t%0, %d0";
3076       else
3077         return "%vxorps\t%0, %d0";
3078     case 6:
3079       if (get_attr_mode (insn) == MODE_V4SF)
3080         return "%vmovaps\t{%1, %0|%0, %1}";
3081       else
3082         return "%vmovss\t{%1, %d0|%d0, %1}";
3083     case 7:
3084       if (TARGET_AVX)
3085         return REG_P (operands[1]) ? "vmovss\t{%1, %0, %0|%0, %0, %1}"
3086                                    : "vmovss\t{%1, %0|%0, %1}";
3087       else
3088         return "movss\t{%1, %0|%0, %1}";
3089     case 8:
3090       return "%vmovss\t{%1, %0|%0, %1}";
3091
3092     case 9: case 10: case 14: case 15:
3093       return "movd\t{%1, %0|%0, %1}";
3094     case 12: case 13:
3095       return "%vmovd\t{%1, %0|%0, %1}";
3096
3097     case 11:
3098       return "movq\t{%1, %0|%0, %1}";
3099
3100     default:
3101       gcc_unreachable ();
3102     }
3103 }
3104   [(set_attr "type" "fmov,fmov,fmov,imov,imov,sselog1,ssemov,ssemov,ssemov,mmxmov,mmxmov,mmxmov,ssemov,ssemov,mmxmov,mmxmov")
3105    (set (attr "prefix")
3106      (if_then_else (eq_attr "alternative" "5,6,7,8,12,13")
3107        (const_string "maybe_vex")
3108        (const_string "orig")))
3109    (set (attr "mode")
3110         (cond [(eq_attr "alternative" "3,4,9,10")
3111                  (const_string "SI")
3112                (eq_attr "alternative" "5")
3113                  (if_then_else
3114                    (and (and (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3115                                  (const_int 0))
3116                              (ne (symbol_ref "TARGET_SSE2")
3117                                  (const_int 0)))
3118                         (eq (symbol_ref "optimize_function_for_size_p (cfun)")
3119                             (const_int 0)))
3120                    (const_string "TI")
3121                    (const_string "V4SF"))
3122                /* For architectures resolving dependencies on
3123                   whole SSE registers use APS move to break dependency
3124                   chains, otherwise use short move to avoid extra work.
3125
3126                   Do the same for architectures resolving dependencies on
3127                   the parts.  While in DF mode it is better to always handle
3128                   just register parts, the SF mode is different due to lack
3129                   of instructions to load just part of the register.  It is
3130                   better to maintain the whole registers in single format
3131                   to avoid problems on using packed logical operations.  */
3132                (eq_attr "alternative" "6")
3133                  (if_then_else
3134                    (ior (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3135                             (const_int 0))
3136                         (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3137                             (const_int 0)))
3138                    (const_string "V4SF")
3139                    (const_string "SF"))
3140                (eq_attr "alternative" "11")
3141                  (const_string "DI")]
3142                (const_string "SF")))])
3143
3144 (define_insn "*swapsf"
3145   [(set (match_operand:SF 0 "fp_register_operand" "+f")
3146         (match_operand:SF 1 "fp_register_operand" "+f"))
3147    (set (match_dup 1)
3148         (match_dup 0))]
3149   "reload_completed || TARGET_80387"
3150 {
3151   if (STACK_TOP_P (operands[0]))
3152     return "fxch\t%1";
3153   else
3154     return "fxch\t%0";
3155 }
3156   [(set_attr "type" "fxch")
3157    (set_attr "mode" "SF")])
3158
3159 (define_expand "movdf"
3160   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3161         (match_operand:DF 1 "general_operand" ""))]
3162   ""
3163   "ix86_expand_move (DFmode, operands); DONE;")
3164
3165 ;; Size of pushdf is 3 (for sub) + 2 (for fstp) + memory operand size.
3166 ;; Size of pushdf using integer instructions is 2+2*memory operand size
3167 ;; On the average, pushdf using integers can be still shorter.  Allow this
3168 ;; pattern for optimize_size too.
3169
3170 (define_insn "*pushdf_nointeger"
3171   [(set (match_operand:DF 0 "push_operand" "=<,<,<,<")
3172         (match_operand:DF 1 "general_no_elim_operand" "f,Fo,*r,Y2"))]
3173   "!TARGET_64BIT && !TARGET_INTEGER_DFMODE_MOVES"
3174 {
3175   /* This insn should be already split before reg-stack.  */
3176   gcc_unreachable ();
3177 }
3178   [(set_attr "type" "multi")
3179    (set_attr "unit" "i387,*,*,*")
3180    (set_attr "mode" "DF,SI,SI,DF")])
3181
3182 (define_insn "*pushdf_integer"
3183   [(set (match_operand:DF 0 "push_operand" "=<,<,<")
3184         (match_operand:DF 1 "general_no_elim_operand" "f,rFo,Y2"))]
3185   "TARGET_64BIT || TARGET_INTEGER_DFMODE_MOVES"
3186 {
3187   /* This insn should be already split before reg-stack.  */
3188   gcc_unreachable ();
3189 }
3190   [(set_attr "type" "multi")
3191    (set_attr "unit" "i387,*,*")
3192    (set_attr "mode" "DF,SI,DF")])
3193
3194 ;; %%% Kill this when call knows how to work this out.
3195 (define_split
3196   [(set (match_operand:DF 0 "push_operand" "")
3197         (match_operand:DF 1 "any_fp_register_operand" ""))]
3198   "reload_completed"
3199   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -8)))
3200    (set (mem:DF (reg:P SP_REG)) (match_dup 1))]
3201   "")
3202
3203 (define_split
3204   [(set (match_operand:DF 0 "push_operand" "")
3205         (match_operand:DF 1 "general_operand" ""))]
3206   "reload_completed"
3207   [(const_int 0)]
3208   "ix86_split_long_move (operands); DONE;")
3209
3210 ;; Moving is usually shorter when only FP registers are used. This separate
3211 ;; movdf pattern avoids the use of integer registers for FP operations
3212 ;; when optimizing for size.
3213
3214 (define_insn "*movdf_nointeger"
3215   [(set (match_operand:DF 0 "nonimmediate_operand"
3216                         "=f,m,f,*r  ,o  ,Y2*x,Y2*x,Y2*x ,m  ")
3217         (match_operand:DF 1 "general_operand"
3218                         "fm,f,G,*roF,*Fr,C   ,Y2*x,mY2*x,Y2*x"))]
3219   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
3220    && ((optimize_function_for_size_p (cfun)
3221        || !TARGET_INTEGER_DFMODE_MOVES) && !TARGET_64BIT)
3222    && (reload_in_progress || reload_completed
3223        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3224        || (!(TARGET_SSE2 && TARGET_SSE_MATH)
3225            && optimize_function_for_size_p (cfun)
3226            && !memory_operand (operands[0], DFmode)
3227            && standard_80387_constant_p (operands[1]))
3228        || GET_CODE (operands[1]) != CONST_DOUBLE
3229        || ((optimize_function_for_size_p (cfun)
3230             || !TARGET_MEMORY_MISMATCH_STALL
3231             || reload_in_progress || reload_completed)
3232            && memory_operand (operands[0], DFmode)))"
3233 {
3234   switch (which_alternative)
3235     {
3236     case 0:
3237     case 1:
3238       return output_387_reg_move (insn, operands);
3239
3240     case 2:
3241       return standard_80387_constant_opcode (operands[1]);
3242
3243     case 3:
3244     case 4:
3245       return "#";
3246     case 5:
3247       switch (get_attr_mode (insn))
3248         {
3249         case MODE_V4SF:
3250           return "%vxorps\t%0, %d0";
3251         case MODE_V2DF:
3252           return "%vxorpd\t%0, %d0";
3253         case MODE_TI:
3254           return "%vpxor\t%0, %d0";
3255         default:
3256           gcc_unreachable ();
3257         }
3258     case 6:
3259     case 7:
3260     case 8:
3261       switch (get_attr_mode (insn))
3262         {
3263         case MODE_V4SF:
3264           return "%vmovaps\t{%1, %0|%0, %1}";
3265         case MODE_V2DF:
3266           return "%vmovapd\t{%1, %0|%0, %1}";
3267         case MODE_TI:
3268           return "%vmovdqa\t{%1, %0|%0, %1}";
3269         case MODE_DI:
3270           return "%vmovq\t{%1, %0|%0, %1}";
3271         case MODE_DF:
3272           if (TARGET_AVX)
3273             {
3274               if (REG_P (operands[0]) && REG_P (operands[1]))
3275                 return "vmovsd\t{%1, %0, %0|%0, %0, %1}";
3276               else
3277                 return "vmovsd\t{%1, %0|%0, %1}";
3278             }
3279           else
3280             return "movsd\t{%1, %0|%0, %1}";
3281         case MODE_V1DF:
3282           if (TARGET_AVX)
3283             {
3284               if (REG_P (operands[0]))
3285                 return "vmovlpd\t{%1, %0, %0|%0, %0, %1}";
3286               else
3287                 return "vmovlpd\t{%1, %0|%0, %1}";
3288             }
3289           else
3290             return "movlpd\t{%1, %0|%0, %1}";
3291         case MODE_V2SF:
3292           if (TARGET_AVX)
3293             {
3294               if (REG_P (operands[0]))
3295                 return "vmovlps\t{%1, %0, %0|%0, %0, %1}";
3296               else
3297                 return "vmovlps\t{%1, %0|%0, %1}";
3298             }
3299           else
3300             return "movlps\t{%1, %0|%0, %1}";
3301         default:
3302           gcc_unreachable ();
3303         }
3304
3305     default:
3306       gcc_unreachable ();
3307     }
3308 }
3309   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov")
3310    (set (attr "prefix")
3311      (if_then_else (eq_attr "alternative" "0,1,2,3,4")
3312        (const_string "orig")
3313        (const_string "maybe_vex")))
3314    (set (attr "prefix_data16")
3315      (if_then_else (eq_attr "mode" "V1DF")
3316        (const_string "1")
3317        (const_string "*")))
3318    (set (attr "mode")
3319         (cond [(eq_attr "alternative" "0,1,2")
3320                  (const_string "DF")
3321                (eq_attr "alternative" "3,4")
3322                  (const_string "SI")
3323
3324                /* For SSE1, we have many fewer alternatives.  */
3325                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
3326                  (cond [(eq_attr "alternative" "5,6")
3327                           (const_string "V4SF")
3328                        ]
3329                    (const_string "V2SF"))
3330
3331                /* xorps is one byte shorter.  */
3332                (eq_attr "alternative" "5")
3333                  (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3334                             (const_int 0))
3335                           (const_string "V4SF")
3336                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3337                             (const_int 0))
3338                           (const_string "TI")
3339                        ]
3340                        (const_string "V2DF"))
3341
3342                /* For architectures resolving dependencies on
3343                   whole SSE registers use APD move to break dependency
3344                   chains, otherwise use short move to avoid extra work.
3345
3346                   movaps encodes one byte shorter.  */
3347                (eq_attr "alternative" "6")
3348                  (cond
3349                    [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3350                         (const_int 0))
3351                       (const_string "V4SF")
3352                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3353                         (const_int 0))
3354                       (const_string "V2DF")
3355                    ]
3356                    (const_string "DF"))
3357                /* For architectures resolving dependencies on register
3358                   parts we may avoid extra work to zero out upper part
3359                   of register.  */
3360                (eq_attr "alternative" "7")
3361                  (if_then_else
3362                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3363                        (const_int 0))
3364                    (const_string "V1DF")
3365                    (const_string "DF"))
3366               ]
3367               (const_string "DF")))])
3368
3369 (define_insn "*movdf_integer_rex64"
3370   [(set (match_operand:DF 0 "nonimmediate_operand"
3371                 "=f,m,f,r  ,m ,Y2*x,Y2*x,Y2*x,m   ,Yi,r ")
3372         (match_operand:DF 1 "general_operand"
3373                 "fm,f,G,rmF,Fr,C   ,Y2*x,m   ,Y2*x,r ,Yi"))]
3374   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3375    && (reload_in_progress || reload_completed
3376        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3377        || (!(TARGET_SSE2 && TARGET_SSE_MATH)
3378            && optimize_function_for_size_p (cfun)
3379            && standard_80387_constant_p (operands[1]))
3380        || GET_CODE (operands[1]) != CONST_DOUBLE
3381        || memory_operand (operands[0], DFmode))"
3382 {
3383   switch (which_alternative)
3384     {
3385     case 0:
3386     case 1:
3387       return output_387_reg_move (insn, operands);
3388
3389     case 2:
3390       return standard_80387_constant_opcode (operands[1]);
3391
3392     case 3:
3393     case 4:
3394       return "#";
3395
3396     case 5:
3397       switch (get_attr_mode (insn))
3398         {
3399         case MODE_V4SF:
3400           return "%vxorps\t%0, %d0";
3401         case MODE_V2DF:
3402           return "%vxorpd\t%0, %d0";
3403         case MODE_TI:
3404           return "%vpxor\t%0, %d0";
3405         default:
3406           gcc_unreachable ();
3407         }
3408     case 6:
3409     case 7:
3410     case 8:
3411       switch (get_attr_mode (insn))
3412         {
3413         case MODE_V4SF:
3414           return "%vmovaps\t{%1, %0|%0, %1}";
3415         case MODE_V2DF:
3416           return "%vmovapd\t{%1, %0|%0, %1}";
3417         case MODE_TI:
3418           return "%vmovdqa\t{%1, %0|%0, %1}";
3419         case MODE_DI:
3420           return "%vmovq\t{%1, %0|%0, %1}";
3421         case MODE_DF:
3422           if (TARGET_AVX)
3423             {
3424               if (REG_P (operands[0]) && REG_P (operands[1]))
3425                 return "vmovsd\t{%1, %0, %0|%0, %0, %1}";
3426               else
3427                 return "vmovsd\t{%1, %0|%0, %1}";
3428             }
3429           else
3430             return "movsd\t{%1, %0|%0, %1}";
3431         case MODE_V1DF:
3432           return "%vmovlpd\t{%1, %d0|%d0, %1}";
3433         case MODE_V2SF:
3434           return "%vmovlps\t{%1, %d0|%d0, %1}";
3435         default:
3436           gcc_unreachable ();
3437         }
3438
3439     case 9:
3440     case 10:
3441     return "%vmovd\t{%1, %0|%0, %1}";
3442
3443     default:
3444       gcc_unreachable();
3445     }
3446 }
3447   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov,ssemov,ssemov")
3448    (set (attr "prefix")
3449      (if_then_else (eq_attr "alternative" "0,1,2,3,4")
3450        (const_string "orig")
3451        (const_string "maybe_vex")))
3452    (set (attr "prefix_data16")
3453      (if_then_else (eq_attr "mode" "V1DF")
3454        (const_string "1")
3455        (const_string "*")))
3456    (set (attr "mode")
3457         (cond [(eq_attr "alternative" "0,1,2")
3458                  (const_string "DF")
3459                (eq_attr "alternative" "3,4,9,10")
3460                  (const_string "DI")
3461
3462                /* For SSE1, we have many fewer alternatives.  */
3463                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
3464                  (cond [(eq_attr "alternative" "5,6")
3465                           (const_string "V4SF")
3466                        ]
3467                    (const_string "V2SF"))
3468
3469                /* xorps is one byte shorter.  */
3470                (eq_attr "alternative" "5")
3471                  (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3472                             (const_int 0))
3473                           (const_string "V4SF")
3474                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3475                             (const_int 0))
3476                           (const_string "TI")
3477                        ]
3478                        (const_string "V2DF"))
3479
3480                /* For architectures resolving dependencies on
3481                   whole SSE registers use APD move to break dependency
3482                   chains, otherwise use short move to avoid extra work.
3483
3484                   movaps encodes one byte shorter.  */
3485                (eq_attr "alternative" "6")
3486                  (cond
3487                    [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3488                         (const_int 0))
3489                       (const_string "V4SF")
3490                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3491                         (const_int 0))
3492                       (const_string "V2DF")
3493                    ]
3494                    (const_string "DF"))
3495                /* For architectures resolving dependencies on register
3496                   parts we may avoid extra work to zero out upper part
3497                   of register.  */
3498                (eq_attr "alternative" "7")
3499                  (if_then_else
3500                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3501                        (const_int 0))
3502                    (const_string "V1DF")
3503                    (const_string "DF"))
3504               ]
3505               (const_string "DF")))])
3506
3507 (define_insn "*movdf_integer"
3508   [(set (match_operand:DF 0 "nonimmediate_operand"
3509                 "=f,m,f,r  ,o ,Y2*x,Y2*x,Y2*x,m   ")
3510         (match_operand:DF 1 "general_operand"
3511                 "fm,f,G,roF,Fr,C   ,Y2*x,m   ,Y2*x"))]
3512   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
3513    && optimize_function_for_speed_p (cfun)
3514    && TARGET_INTEGER_DFMODE_MOVES
3515    && (reload_in_progress || reload_completed
3516        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3517        || (!(TARGET_SSE2 && TARGET_SSE_MATH)
3518            && optimize_function_for_size_p (cfun)
3519            && standard_80387_constant_p (operands[1]))
3520        || GET_CODE (operands[1]) != CONST_DOUBLE
3521        || memory_operand (operands[0], DFmode))"
3522 {
3523   switch (which_alternative)
3524     {
3525     case 0:
3526     case 1:
3527       return output_387_reg_move (insn, operands);
3528
3529     case 2:
3530       return standard_80387_constant_opcode (operands[1]);
3531
3532     case 3:
3533     case 4:
3534       return "#";
3535
3536     case 5:
3537       switch (get_attr_mode (insn))
3538         {
3539         case MODE_V4SF:
3540           return "xorps\t%0, %0";
3541         case MODE_V2DF:
3542           return "xorpd\t%0, %0";
3543         case MODE_TI:
3544           return "pxor\t%0, %0";
3545         default:
3546           gcc_unreachable ();
3547         }
3548     case 6:
3549     case 7:
3550     case 8:
3551       switch (get_attr_mode (insn))
3552         {
3553         case MODE_V4SF:
3554           return "movaps\t{%1, %0|%0, %1}";
3555         case MODE_V2DF:
3556           return "movapd\t{%1, %0|%0, %1}";
3557         case MODE_TI:
3558           return "movdqa\t{%1, %0|%0, %1}";
3559         case MODE_DI:
3560           return "movq\t{%1, %0|%0, %1}";
3561         case MODE_DF:
3562           return "movsd\t{%1, %0|%0, %1}";
3563         case MODE_V1DF:
3564           return "movlpd\t{%1, %0|%0, %1}";
3565         case MODE_V2SF:
3566           return "movlps\t{%1, %0|%0, %1}";
3567         default:
3568           gcc_unreachable ();
3569         }
3570
3571     default:
3572       gcc_unreachable();
3573     }
3574 }
3575   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov")
3576    (set (attr "prefix_data16")
3577      (if_then_else (eq_attr "mode" "V1DF")
3578        (const_string "1")
3579        (const_string "*")))
3580    (set (attr "mode")
3581         (cond [(eq_attr "alternative" "0,1,2")
3582                  (const_string "DF")
3583                (eq_attr "alternative" "3,4")
3584                  (const_string "SI")
3585
3586                /* For SSE1, we have many fewer alternatives.  */
3587                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
3588                  (cond [(eq_attr "alternative" "5,6")
3589                           (const_string "V4SF")
3590                        ]
3591                    (const_string "V2SF"))
3592
3593                /* xorps is one byte shorter.  */
3594                (eq_attr "alternative" "5")
3595                  (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3596                             (const_int 0))
3597                           (const_string "V4SF")
3598                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3599                             (const_int 0))
3600                           (const_string "TI")
3601                        ]
3602                        (const_string "V2DF"))
3603
3604                /* For architectures resolving dependencies on
3605                   whole SSE registers use APD move to break dependency
3606                   chains, otherwise use short move to avoid extra work.
3607
3608                   movaps encodes one byte shorter.  */
3609                (eq_attr "alternative" "6")
3610                  (cond
3611                    [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3612                         (const_int 0))
3613                       (const_string "V4SF")
3614                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3615                         (const_int 0))
3616                       (const_string "V2DF")
3617                    ]
3618                    (const_string "DF"))
3619                /* For architectures resolving dependencies on register
3620                   parts we may avoid extra work to zero out upper part
3621                   of register.  */
3622                (eq_attr "alternative" "7")
3623                  (if_then_else
3624                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3625                        (const_int 0))
3626                    (const_string "V1DF")
3627                    (const_string "DF"))
3628               ]
3629               (const_string "DF")))])
3630
3631 (define_split
3632   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3633         (match_operand:DF 1 "general_operand" ""))]
3634   "reload_completed
3635    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3636    && ! (ANY_FP_REG_P (operands[0]) ||
3637          (GET_CODE (operands[0]) == SUBREG
3638           && ANY_FP_REG_P (SUBREG_REG (operands[0]))))
3639    && ! (ANY_FP_REG_P (operands[1]) ||
3640          (GET_CODE (operands[1]) == SUBREG
3641           && ANY_FP_REG_P (SUBREG_REG (operands[1]))))"
3642   [(const_int 0)]
3643   "ix86_split_long_move (operands); DONE;")
3644
3645 (define_insn "*swapdf"
3646   [(set (match_operand:DF 0 "fp_register_operand" "+f")
3647         (match_operand:DF 1 "fp_register_operand" "+f"))
3648    (set (match_dup 1)
3649         (match_dup 0))]
3650   "reload_completed || TARGET_80387"
3651 {
3652   if (STACK_TOP_P (operands[0]))
3653     return "fxch\t%1";
3654   else
3655     return "fxch\t%0";
3656 }
3657   [(set_attr "type" "fxch")
3658    (set_attr "mode" "DF")])
3659
3660 (define_expand "movxf"
3661   [(set (match_operand:XF 0 "nonimmediate_operand" "")
3662         (match_operand:XF 1 "general_operand" ""))]
3663   ""
3664   "ix86_expand_move (XFmode, operands); DONE;")
3665
3666 ;; Size of pushdf is 3 (for sub) + 2 (for fstp) + memory operand size.
3667 ;; Size of pushdf using integer instructions is 3+3*memory operand size
3668 ;; Pushing using integer instructions is longer except for constants
3669 ;; and direct memory references.
3670 ;; (assuming that any given constant is pushed only once, but this ought to be
3671 ;;  handled elsewhere).
3672
3673 (define_insn "*pushxf_nointeger"
3674   [(set (match_operand:XF 0 "push_operand" "=X,X,X")
3675         (match_operand:XF 1 "general_no_elim_operand" "f,Fo,*r"))]
3676   "optimize_function_for_size_p (cfun)"
3677 {
3678   /* This insn should be already split before reg-stack.  */
3679   gcc_unreachable ();
3680 }
3681   [(set_attr "type" "multi")
3682    (set_attr "unit" "i387,*,*")
3683    (set_attr "mode" "XF,SI,SI")])
3684
3685 (define_insn "*pushxf_integer"
3686   [(set (match_operand:XF 0 "push_operand" "=<,<")
3687         (match_operand:XF 1 "general_no_elim_operand" "f,ro"))]
3688   "optimize_function_for_speed_p (cfun)"
3689 {
3690   /* This insn should be already split before reg-stack.  */
3691   gcc_unreachable ();
3692 }
3693   [(set_attr "type" "multi")
3694    (set_attr "unit" "i387,*")
3695    (set_attr "mode" "XF,SI")])
3696
3697 (define_split
3698   [(set (match_operand 0 "push_operand" "")
3699         (match_operand 1 "general_operand" ""))]
3700   "reload_completed
3701    && (GET_MODE (operands[0]) == XFmode
3702        || GET_MODE (operands[0]) == DFmode)
3703    && !ANY_FP_REG_P (operands[1])"
3704   [(const_int 0)]
3705   "ix86_split_long_move (operands); DONE;")
3706
3707 (define_split
3708   [(set (match_operand:XF 0 "push_operand" "")
3709         (match_operand:XF 1 "any_fp_register_operand" ""))]
3710   ""
3711   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
3712    (set (mem:XF (reg:P SP_REG)) (match_dup 1))]
3713   "operands[2] = GEN_INT (TARGET_128BIT_LONG_DOUBLE ? -16 : -12);")
3714
3715 ;; Do not use integer registers when optimizing for size
3716 (define_insn "*movxf_nointeger"
3717   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,*r,o")
3718         (match_operand:XF 1 "general_operand" "fm,f,G,*roF,F*r"))]
3719   "optimize_function_for_size_p (cfun)
3720    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3721    && (reload_in_progress || reload_completed
3722        || standard_80387_constant_p (operands[1])
3723        || GET_CODE (operands[1]) != CONST_DOUBLE
3724        || memory_operand (operands[0], XFmode))"
3725 {
3726   switch (which_alternative)
3727     {
3728     case 0:
3729     case 1:
3730       return output_387_reg_move (insn, operands);
3731
3732     case 2:
3733       return standard_80387_constant_opcode (operands[1]);
3734
3735     case 3: case 4:
3736       return "#";
3737     default:
3738       gcc_unreachable ();
3739     }
3740 }
3741   [(set_attr "type" "fmov,fmov,fmov,multi,multi")
3742    (set_attr "mode" "XF,XF,XF,SI,SI")])
3743
3744 (define_insn "*movxf_integer"
3745   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,r,o")
3746         (match_operand:XF 1 "general_operand" "fm,f,G,roF,Fr"))]
3747   "optimize_function_for_speed_p (cfun)
3748    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3749    && (reload_in_progress || reload_completed
3750        || GET_CODE (operands[1]) != CONST_DOUBLE
3751        || memory_operand (operands[0], XFmode))"
3752 {
3753   switch (which_alternative)
3754     {
3755     case 0:
3756     case 1:
3757       return output_387_reg_move (insn, operands);
3758
3759     case 2:
3760       return standard_80387_constant_opcode (operands[1]);
3761
3762     case 3: case 4:
3763       return "#";
3764
3765     default:
3766       gcc_unreachable ();
3767     }
3768 }
3769   [(set_attr "type" "fmov,fmov,fmov,multi,multi")
3770    (set_attr "mode" "XF,XF,XF,SI,SI")])
3771
3772 (define_expand "movtf"
3773   [(set (match_operand:TF 0 "nonimmediate_operand" "")
3774         (match_operand:TF 1 "nonimmediate_operand" ""))]
3775   "TARGET_SSE2"
3776 {
3777   ix86_expand_move (TFmode, operands);
3778   DONE;
3779 })
3780
3781 (define_insn "*movtf_internal"
3782   [(set (match_operand:TF 0 "nonimmediate_operand" "=x,m,x,?r,?o")
3783         (match_operand:TF 1 "general_operand" "xm,x,C,roF,Fr"))]
3784   "TARGET_SSE2
3785    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
3786 {
3787   switch (which_alternative)
3788     {
3789     case 0:
3790     case 1:
3791       if (get_attr_mode (insn) == MODE_V4SF)
3792         return "%vmovaps\t{%1, %0|%0, %1}";
3793       else
3794         return "%vmovdqa\t{%1, %0|%0, %1}";
3795     case 2:
3796       if (get_attr_mode (insn) == MODE_V4SF)
3797         return "%vxorps\t%0, %d0";
3798       else
3799         return "%vpxor\t%0, %d0";
3800     case 3:
3801     case 4:
3802         return "#";
3803     default:
3804       gcc_unreachable ();
3805     }
3806 }
3807   [(set_attr "type" "ssemov,ssemov,sselog1,*,*")
3808    (set_attr "prefix" "maybe_vex,maybe_vex,maybe_vex,*,*")
3809    (set (attr "mode")
3810         (cond [(eq_attr "alternative" "0,2")
3811                  (if_then_else
3812                    (ne (symbol_ref "optimize_function_for_size_p (cfun)")
3813                        (const_int 0))
3814                    (const_string "V4SF")
3815                    (const_string "TI"))
3816                (eq_attr "alternative" "1")
3817                  (if_then_else
3818                    (ior (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
3819                             (const_int 0))
3820                         (ne (symbol_ref "optimize_function_for_size_p (cfun)")
3821                             (const_int 0)))
3822                    (const_string "V4SF")
3823                    (const_string "TI"))]
3824                (const_string "DI")))])
3825
3826 (define_insn "*pushtf_sse"
3827   [(set (match_operand:TF 0 "push_operand" "=<,<,<")
3828         (match_operand:TF 1 "general_no_elim_operand" "x,Fo,*r"))]
3829   "TARGET_SSE2"
3830 {
3831   /* This insn should be already split before reg-stack.  */
3832   gcc_unreachable ();
3833 }
3834   [(set_attr "type" "multi")
3835    (set_attr "unit" "sse,*,*")
3836    (set_attr "mode" "TF,SI,SI")])
3837
3838 (define_split
3839   [(set (match_operand:TF 0 "push_operand" "")
3840         (match_operand:TF 1 "general_operand" ""))]
3841   "TARGET_SSE2 && reload_completed
3842    && !SSE_REG_P (operands[1])"
3843   [(const_int 0)]
3844   "ix86_split_long_move (operands); DONE;")
3845
3846 (define_split
3847   [(set (match_operand:TF 0 "push_operand" "")
3848         (match_operand:TF 1 "any_fp_register_operand" ""))]
3849   "TARGET_SSE2"
3850   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -16)))
3851    (set (mem:TF (reg:P SP_REG)) (match_dup 1))]
3852   "")
3853
3854 (define_split
3855   [(set (match_operand 0 "nonimmediate_operand" "")
3856         (match_operand 1 "general_operand" ""))]
3857   "reload_completed
3858    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3859    && GET_MODE (operands[0]) == XFmode
3860    && ! (ANY_FP_REG_P (operands[0])&n