OSDN Git Service

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