OSDN Git Service

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