OSDN Git Service

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