OSDN Git Service

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