OSDN Git Service

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