OSDN Git Service

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