OSDN Git Service

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