OSDN Git Service

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