OSDN Git Service

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