OSDN Git Service

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