OSDN Git Service

gcc/:
[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 (define_expand "cmpcc"
1087   [(set (reg:CC FLAGS_REG)
1088         (compare:CC (match_operand 0 "flags_reg_operand" "")
1089                     (match_operand 1 "general_operand" "")))]
1090   ""
1091 {
1092   ix86_compare_op0 = operands[0];
1093   ix86_compare_op1 = operands[1];
1094   DONE;
1095 })
1096
1097 ;; FP compares, step 1:
1098 ;; Set the FP condition codes.
1099 ;;
1100 ;; CCFPmode     compare with exceptions
1101 ;; CCFPUmode    compare with no exceptions
1102
1103 ;; We may not use "#" to split and emit these, since the REG_DEAD notes
1104 ;; used to manage the reg stack popping would not be preserved.
1105
1106 (define_insn "*cmpfp_0"
1107   [(set (match_operand:HI 0 "register_operand" "=a")
1108         (unspec:HI
1109           [(compare:CCFP
1110              (match_operand 1 "register_operand" "f")
1111              (match_operand 2 "const0_operand" ""))]
1112         UNSPEC_FNSTSW))]
1113   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1114    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1115   "* return output_fp_compare (insn, operands, 0, 0);"
1116   [(set_attr "type" "multi")
1117    (set_attr "unit" "i387")
1118    (set (attr "mode")
1119      (cond [(match_operand:SF 1 "" "")
1120               (const_string "SF")
1121             (match_operand:DF 1 "" "")
1122               (const_string "DF")
1123            ]
1124            (const_string "XF")))])
1125
1126 (define_insn_and_split "*cmpfp_0_cc"
1127   [(set (reg:CCFP FLAGS_REG)
1128         (compare:CCFP
1129           (match_operand 1 "register_operand" "f")
1130           (match_operand 2 "const0_operand" "")))
1131    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1132   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1133    && TARGET_SAHF && !TARGET_CMOVE
1134    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1135   "#"
1136   "&& reload_completed"
1137   [(set (match_dup 0)
1138         (unspec:HI
1139           [(compare:CCFP (match_dup 1)(match_dup 2))]
1140         UNSPEC_FNSTSW))
1141    (set (reg:CC FLAGS_REG)
1142         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1143   ""
1144   [(set_attr "type" "multi")
1145    (set_attr "unit" "i387")
1146    (set (attr "mode")
1147      (cond [(match_operand:SF 1 "" "")
1148               (const_string "SF")
1149             (match_operand:DF 1 "" "")
1150               (const_string "DF")
1151            ]
1152            (const_string "XF")))])
1153
1154 (define_insn "*cmpfp_xf"
1155   [(set (match_operand:HI 0 "register_operand" "=a")
1156         (unspec:HI
1157           [(compare:CCFP
1158              (match_operand:XF 1 "register_operand" "f")
1159              (match_operand:XF 2 "register_operand" "f"))]
1160           UNSPEC_FNSTSW))]
1161   "TARGET_80387"
1162   "* return output_fp_compare (insn, operands, 0, 0);"
1163   [(set_attr "type" "multi")
1164    (set_attr "unit" "i387")
1165    (set_attr "mode" "XF")])
1166
1167 (define_insn_and_split "*cmpfp_xf_cc"
1168   [(set (reg:CCFP FLAGS_REG)
1169         (compare:CCFP
1170           (match_operand:XF 1 "register_operand" "f")
1171           (match_operand:XF 2 "register_operand" "f")))
1172    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1173   "TARGET_80387
1174    && TARGET_SAHF && !TARGET_CMOVE"
1175   "#"
1176   "&& reload_completed"
1177   [(set (match_dup 0)
1178         (unspec:HI
1179           [(compare:CCFP (match_dup 1)(match_dup 2))]
1180         UNSPEC_FNSTSW))
1181    (set (reg:CC FLAGS_REG)
1182         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1183   ""
1184   [(set_attr "type" "multi")
1185    (set_attr "unit" "i387")
1186    (set_attr "mode" "XF")])
1187
1188 (define_insn "*cmpfp_<mode>"
1189   [(set (match_operand:HI 0 "register_operand" "=a")
1190         (unspec:HI
1191           [(compare:CCFP
1192              (match_operand:MODEF 1 "register_operand" "f")
1193              (match_operand:MODEF 2 "nonimmediate_operand" "fm"))]
1194           UNSPEC_FNSTSW))]
1195   "TARGET_80387"
1196   "* return output_fp_compare (insn, operands, 0, 0);"
1197   [(set_attr "type" "multi")
1198    (set_attr "unit" "i387")
1199    (set_attr "mode" "<MODE>")])
1200
1201 (define_insn_and_split "*cmpfp_<mode>_cc"
1202   [(set (reg:CCFP FLAGS_REG)
1203         (compare:CCFP
1204           (match_operand:MODEF 1 "register_operand" "f")
1205           (match_operand:MODEF 2 "nonimmediate_operand" "fm")))
1206    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1207   "TARGET_80387
1208    && TARGET_SAHF && !TARGET_CMOVE"
1209   "#"
1210   "&& reload_completed"
1211   [(set (match_dup 0)
1212         (unspec:HI
1213           [(compare:CCFP (match_dup 1)(match_dup 2))]
1214         UNSPEC_FNSTSW))
1215    (set (reg:CC FLAGS_REG)
1216         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1217   ""
1218   [(set_attr "type" "multi")
1219    (set_attr "unit" "i387")
1220    (set_attr "mode" "<MODE>")])
1221
1222 (define_insn "*cmpfp_u"
1223   [(set (match_operand:HI 0 "register_operand" "=a")
1224         (unspec:HI
1225           [(compare:CCFPU
1226              (match_operand 1 "register_operand" "f")
1227              (match_operand 2 "register_operand" "f"))]
1228           UNSPEC_FNSTSW))]
1229   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1230    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1231   "* return output_fp_compare (insn, operands, 0, 1);"
1232   [(set_attr "type" "multi")
1233    (set_attr "unit" "i387")
1234    (set (attr "mode")
1235      (cond [(match_operand:SF 1 "" "")
1236               (const_string "SF")
1237             (match_operand:DF 1 "" "")
1238               (const_string "DF")
1239            ]
1240            (const_string "XF")))])
1241
1242 (define_insn_and_split "*cmpfp_u_cc"
1243   [(set (reg:CCFPU FLAGS_REG)
1244         (compare:CCFPU
1245           (match_operand 1 "register_operand" "f")
1246           (match_operand 2 "register_operand" "f")))
1247    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1248   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1249    && TARGET_SAHF && !TARGET_CMOVE
1250    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1251   "#"
1252   "&& reload_completed"
1253   [(set (match_dup 0)
1254         (unspec:HI
1255           [(compare:CCFPU (match_dup 1)(match_dup 2))]
1256         UNSPEC_FNSTSW))
1257    (set (reg:CC FLAGS_REG)
1258         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1259   ""
1260   [(set_attr "type" "multi")
1261    (set_attr "unit" "i387")
1262    (set (attr "mode")
1263      (cond [(match_operand:SF 1 "" "")
1264               (const_string "SF")
1265             (match_operand:DF 1 "" "")
1266               (const_string "DF")
1267            ]
1268            (const_string "XF")))])
1269
1270 (define_insn "*cmpfp_<mode>"
1271   [(set (match_operand:HI 0 "register_operand" "=a")
1272         (unspec:HI
1273           [(compare:CCFP
1274              (match_operand 1 "register_operand" "f")
1275              (match_operator 3 "float_operator"
1276                [(match_operand:X87MODEI12 2 "memory_operand" "m")]))]
1277           UNSPEC_FNSTSW))]
1278   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1279    && (TARGET_USE_<MODE>MODE_FIOP || optimize_function_for_size_p (cfun))
1280    && (GET_MODE (operands [3]) == GET_MODE (operands[1]))"
1281   "* return output_fp_compare (insn, operands, 0, 0);"
1282   [(set_attr "type" "multi")
1283    (set_attr "unit" "i387")
1284    (set_attr "fp_int_src" "true")
1285    (set_attr "mode" "<MODE>")])
1286
1287 (define_insn_and_split "*cmpfp_<mode>_cc"
1288   [(set (reg:CCFP FLAGS_REG)
1289         (compare:CCFP
1290           (match_operand 1 "register_operand" "f")
1291           (match_operator 3 "float_operator"
1292             [(match_operand:X87MODEI12 2 "memory_operand" "m")])))
1293    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1294   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1295    && TARGET_SAHF && !TARGET_CMOVE
1296    && (TARGET_USE_<MODE>MODE_FIOP || optimize_function_for_size_p (cfun))
1297    && (GET_MODE (operands [3]) == GET_MODE (operands[1]))"
1298   "#"
1299   "&& reload_completed"
1300   [(set (match_dup 0)
1301         (unspec:HI
1302           [(compare:CCFP
1303              (match_dup 1)
1304              (match_op_dup 3 [(match_dup 2)]))]
1305         UNSPEC_FNSTSW))
1306    (set (reg:CC FLAGS_REG)
1307         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1308   ""
1309   [(set_attr "type" "multi")
1310    (set_attr "unit" "i387")
1311    (set_attr "fp_int_src" "true")
1312    (set_attr "mode" "<MODE>")])
1313
1314 ;; FP compares, step 2
1315 ;; Move the fpsw to ax.
1316
1317 (define_insn "x86_fnstsw_1"
1318   [(set (match_operand:HI 0 "register_operand" "=a")
1319         (unspec:HI [(reg:CCFP FPSR_REG)] UNSPEC_FNSTSW))]
1320   "TARGET_80387"
1321   "fnstsw\t%0"
1322   [(set_attr "length" "2")
1323    (set_attr "mode" "SI")
1324    (set_attr "unit" "i387")])
1325
1326 ;; FP compares, step 3
1327 ;; Get ax into flags, general case.
1328
1329 (define_insn "x86_sahf_1"
1330   [(set (reg:CC FLAGS_REG)
1331         (unspec:CC [(match_operand:HI 0 "register_operand" "a")]
1332                    UNSPEC_SAHF))]
1333   "TARGET_SAHF"
1334 {
1335 #ifdef HAVE_AS_IX86_SAHF
1336   return "sahf";
1337 #else
1338   return ".byte\t0x9e";
1339 #endif
1340 }
1341   [(set_attr "length" "1")
1342    (set_attr "athlon_decode" "vector")
1343    (set_attr "amdfam10_decode" "direct")
1344    (set_attr "mode" "SI")])
1345
1346 ;; Pentium Pro can do steps 1 through 3 in one go.
1347 ;; comi*, ucomi*, fcomi*, ficomi*,fucomi* (i387 instructions set condition codes)
1348 (define_insn "*cmpfp_i_mixed"
1349   [(set (reg:CCFP FLAGS_REG)
1350         (compare:CCFP (match_operand 0 "register_operand" "f,x")
1351                       (match_operand 1 "nonimmediate_operand" "f,xm")))]
1352   "TARGET_MIX_SSE_I387
1353    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1354    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1355   "* return output_fp_compare (insn, operands, 1, 0);"
1356   [(set_attr "type" "fcmp,ssecomi")
1357    (set_attr "prefix" "orig,maybe_vex")
1358    (set (attr "mode")
1359      (if_then_else (match_operand:SF 1 "" "")
1360         (const_string "SF")
1361         (const_string "DF")))
1362    (set_attr "athlon_decode" "vector")
1363    (set_attr "amdfam10_decode" "direct")])
1364
1365 (define_insn "*cmpfp_i_sse"
1366   [(set (reg:CCFP FLAGS_REG)
1367         (compare:CCFP (match_operand 0 "register_operand" "x")
1368                       (match_operand 1 "nonimmediate_operand" "xm")))]
1369   "TARGET_SSE_MATH
1370    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1371    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1372   "* return output_fp_compare (insn, operands, 1, 0);"
1373   [(set_attr "type" "ssecomi")
1374    (set_attr "prefix" "maybe_vex")
1375    (set (attr "mode")
1376      (if_then_else (match_operand:SF 1 "" "")
1377         (const_string "SF")
1378         (const_string "DF")))
1379    (set_attr "athlon_decode" "vector")
1380    (set_attr "amdfam10_decode" "direct")])
1381
1382 (define_insn "*cmpfp_i_i387"
1383   [(set (reg:CCFP FLAGS_REG)
1384         (compare:CCFP (match_operand 0 "register_operand" "f")
1385                       (match_operand 1 "register_operand" "f")))]
1386   "X87_FLOAT_MODE_P (GET_MODE (operands[0]))
1387    && TARGET_CMOVE
1388    && !(SSE_FLOAT_MODE_P (GET_MODE (operands[0])) && TARGET_SSE_MATH)
1389    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1390   "* return output_fp_compare (insn, operands, 1, 0);"
1391   [(set_attr "type" "fcmp")
1392    (set (attr "mode")
1393      (cond [(match_operand:SF 1 "" "")
1394               (const_string "SF")
1395             (match_operand:DF 1 "" "")
1396               (const_string "DF")
1397            ]
1398            (const_string "XF")))
1399    (set_attr "athlon_decode" "vector")
1400    (set_attr "amdfam10_decode" "direct")])
1401
1402 (define_insn "*cmpfp_iu_mixed"
1403   [(set (reg:CCFPU FLAGS_REG)
1404         (compare:CCFPU (match_operand 0 "register_operand" "f,x")
1405                        (match_operand 1 "nonimmediate_operand" "f,xm")))]
1406   "TARGET_MIX_SSE_I387
1407    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1408    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1409   "* return output_fp_compare (insn, operands, 1, 1);"
1410   [(set_attr "type" "fcmp,ssecomi")
1411    (set_attr "prefix" "orig,maybe_vex")
1412    (set (attr "mode")
1413      (if_then_else (match_operand:SF 1 "" "")
1414         (const_string "SF")
1415         (const_string "DF")))
1416    (set_attr "athlon_decode" "vector")
1417    (set_attr "amdfam10_decode" "direct")])
1418
1419 (define_insn "*cmpfp_iu_sse"
1420   [(set (reg:CCFPU FLAGS_REG)
1421         (compare:CCFPU (match_operand 0 "register_operand" "x")
1422                        (match_operand 1 "nonimmediate_operand" "xm")))]
1423   "TARGET_SSE_MATH
1424    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1425    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1426   "* return output_fp_compare (insn, operands, 1, 1);"
1427   [(set_attr "type" "ssecomi")
1428    (set_attr "prefix" "maybe_vex")
1429    (set (attr "mode")
1430      (if_then_else (match_operand:SF 1 "" "")
1431         (const_string "SF")
1432         (const_string "DF")))
1433    (set_attr "athlon_decode" "vector")
1434    (set_attr "amdfam10_decode" "direct")])
1435
1436 (define_insn "*cmpfp_iu_387"
1437   [(set (reg:CCFPU FLAGS_REG)
1438         (compare:CCFPU (match_operand 0 "register_operand" "f")
1439                        (match_operand 1 "register_operand" "f")))]
1440   "X87_FLOAT_MODE_P (GET_MODE (operands[0]))
1441    && TARGET_CMOVE
1442    && !(SSE_FLOAT_MODE_P (GET_MODE (operands[0])) && TARGET_SSE_MATH)
1443    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1444   "* return output_fp_compare (insn, operands, 1, 1);"
1445   [(set_attr "type" "fcmp")
1446    (set (attr "mode")
1447      (cond [(match_operand:SF 1 "" "")
1448               (const_string "SF")
1449             (match_operand:DF 1 "" "")
1450               (const_string "DF")
1451            ]
1452            (const_string "XF")))
1453    (set_attr "athlon_decode" "vector")
1454    (set_attr "amdfam10_decode" "direct")])
1455 \f
1456 ;; Move instructions.
1457
1458 ;; General case of fullword move.
1459
1460 (define_expand "movsi"
1461   [(set (match_operand:SI 0 "nonimmediate_operand" "")
1462         (match_operand:SI 1 "general_operand" ""))]
1463   ""
1464   "ix86_expand_move (SImode, operands); DONE;")
1465
1466 ;; Push/pop instructions.  They are separate since autoinc/dec is not a
1467 ;; general_operand.
1468 ;;
1469 ;; %%% We don't use a post-inc memory reference because x86 is not a
1470 ;; general AUTO_INC_DEC host, which impacts how it is treated in flow.
1471 ;; Changing this impacts compiler performance on other non-AUTO_INC_DEC
1472 ;; targets without our curiosities, and it is just as easy to represent
1473 ;; this differently.
1474
1475 (define_insn "*pushsi2"
1476   [(set (match_operand:SI 0 "push_operand" "=<")
1477         (match_operand:SI 1 "general_no_elim_operand" "ri*m"))]
1478   "!TARGET_64BIT"
1479   "push{l}\t%1"
1480   [(set_attr "type" "push")
1481    (set_attr "mode" "SI")])
1482
1483 ;; For 64BIT abi we always round up to 8 bytes.
1484 (define_insn "*pushsi2_rex64"
1485   [(set (match_operand:SI 0 "push_operand" "=X")
1486         (match_operand:SI 1 "nonmemory_no_elim_operand" "ri"))]
1487   "TARGET_64BIT"
1488   "push{q}\t%q1"
1489   [(set_attr "type" "push")
1490    (set_attr "mode" "SI")])
1491
1492 (define_insn "*pushsi2_prologue"
1493   [(set (match_operand:SI 0 "push_operand" "=<")
1494         (match_operand:SI 1 "general_no_elim_operand" "ri*m"))
1495    (clobber (mem:BLK (scratch)))]
1496   "!TARGET_64BIT"
1497   "push{l}\t%1"
1498   [(set_attr "type" "push")
1499    (set_attr "mode" "SI")])
1500
1501 (define_insn "*popsi1_epilogue"
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    (clobber (mem:BLK (scratch)))]
1507   "!TARGET_64BIT"
1508   "pop{l}\t%0"
1509   [(set_attr "type" "pop")
1510    (set_attr "mode" "SI")])
1511
1512 (define_insn "popsi1"
1513   [(set (match_operand:SI 0 "nonimmediate_operand" "=r*m")
1514         (mem:SI (reg:SI SP_REG)))
1515    (set (reg:SI SP_REG)
1516         (plus:SI (reg:SI SP_REG) (const_int 4)))]
1517   "!TARGET_64BIT"
1518   "pop{l}\t%0"
1519   [(set_attr "type" "pop")
1520    (set_attr "mode" "SI")])
1521
1522 (define_insn "*movsi_xor"
1523   [(set (match_operand:SI 0 "register_operand" "=r")
1524         (match_operand:SI 1 "const0_operand" ""))
1525    (clobber (reg:CC FLAGS_REG))]
1526   "reload_completed"
1527   "xor{l}\t%0, %0"
1528   [(set_attr "type" "alu1")
1529    (set_attr "mode" "SI")
1530    (set_attr "length_immediate" "0")])
1531
1532 (define_insn "*movsi_or"
1533   [(set (match_operand:SI 0 "register_operand" "=r")
1534         (match_operand:SI 1 "immediate_operand" "i"))
1535    (clobber (reg:CC FLAGS_REG))]
1536   "reload_completed
1537    && operands[1] == constm1_rtx"
1538 {
1539   operands[1] = constm1_rtx;
1540   return "or{l}\t{%1, %0|%0, %1}";
1541 }
1542   [(set_attr "type" "alu1")
1543    (set_attr "mode" "SI")
1544    (set_attr "length_immediate" "1")])
1545
1546 (define_insn "*movsi_1"
1547   [(set (match_operand:SI 0 "nonimmediate_operand"
1548                         "=r,m ,*y,*y,?rm,?*y,*x,*x,?r ,m ,?*Yi,*x")
1549         (match_operand:SI 1 "general_operand"
1550                         "g ,ri,C ,*y,*y ,rm ,C ,*x,*Yi,*x,r   ,m "))]
1551   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
1552 {
1553   switch (get_attr_type (insn))
1554     {
1555     case TYPE_SSELOG1:
1556       if (get_attr_mode (insn) == MODE_TI)
1557         return "%vpxor\t%0, %d0";
1558       return "%vxorps\t%0, %d0";
1559
1560     case TYPE_SSEMOV:
1561       switch (get_attr_mode (insn))
1562         {
1563         case MODE_TI:
1564           return "%vmovdqa\t{%1, %0|%0, %1}";
1565         case MODE_V4SF:
1566           return "%vmovaps\t{%1, %0|%0, %1}";
1567         case MODE_SI:
1568           return "%vmovd\t{%1, %0|%0, %1}";
1569         case MODE_SF:
1570           return "%vmovss\t{%1, %0|%0, %1}";
1571         default:
1572           gcc_unreachable ();
1573         }
1574
1575     case TYPE_MMX:
1576       return "pxor\t%0, %0";
1577
1578     case TYPE_MMXMOV:
1579       if (get_attr_mode (insn) == MODE_DI)
1580         return "movq\t{%1, %0|%0, %1}";
1581       return "movd\t{%1, %0|%0, %1}";
1582
1583     case TYPE_LEA:
1584       return "lea{l}\t{%1, %0|%0, %1}";
1585
1586     default:
1587       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
1588       return "mov{l}\t{%1, %0|%0, %1}";
1589     }
1590 }
1591   [(set (attr "type")
1592      (cond [(eq_attr "alternative" "2")
1593               (const_string "mmx")
1594             (eq_attr "alternative" "3,4,5")
1595               (const_string "mmxmov")
1596             (eq_attr "alternative" "6")
1597               (const_string "sselog1")
1598             (eq_attr "alternative" "7,8,9,10,11")
1599               (const_string "ssemov")
1600             (match_operand:DI 1 "pic_32bit_operand" "")
1601               (const_string "lea")
1602            ]
1603            (const_string "imov")))
1604    (set (attr "prefix")
1605      (if_then_else (eq_attr "alternative" "0,1,2,3,4,5")
1606        (const_string "orig")
1607        (const_string "maybe_vex")))
1608    (set (attr "mode")
1609      (cond [(eq_attr "alternative" "2,3")
1610               (const_string "DI")
1611             (eq_attr "alternative" "6,7")
1612               (if_then_else
1613                 (eq (symbol_ref "TARGET_SSE2") (const_int 0))
1614                 (const_string "V4SF")
1615                 (const_string "TI"))
1616             (and (eq_attr "alternative" "8,9,10,11")
1617                  (eq (symbol_ref "TARGET_SSE2") (const_int 0)))
1618               (const_string "SF")
1619            ]
1620            (const_string "SI")))])
1621
1622 ;; Stores and loads of ax to arbitrary constant address.
1623 ;; We fake an second form of instruction to force reload to load address
1624 ;; into register when rax is not available
1625 (define_insn "*movabssi_1_rex64"
1626   [(set (mem:SI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
1627         (match_operand:SI 1 "nonmemory_operand" "a,er"))]
1628   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
1629   "@
1630    movabs{l}\t{%1, %P0|%P0, %1}
1631    mov{l}\t{%1, %a0|%a0, %1}"
1632   [(set_attr "type" "imov")
1633    (set_attr "modrm" "0,*")
1634    (set_attr "length_address" "8,0")
1635    (set_attr "length_immediate" "0,*")
1636    (set_attr "memory" "store")
1637    (set_attr "mode" "SI")])
1638
1639 (define_insn "*movabssi_2_rex64"
1640   [(set (match_operand:SI 0 "register_operand" "=a,r")
1641         (mem:SI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
1642   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
1643   "@
1644    movabs{l}\t{%P1, %0|%0, %P1}
1645    mov{l}\t{%a1, %0|%0, %a1}"
1646   [(set_attr "type" "imov")
1647    (set_attr "modrm" "0,*")
1648    (set_attr "length_address" "8,0")
1649    (set_attr "length_immediate" "0")
1650    (set_attr "memory" "load")
1651    (set_attr "mode" "SI")])
1652
1653 (define_insn "*swapsi"
1654   [(set (match_operand:SI 0 "register_operand" "+r")
1655         (match_operand:SI 1 "register_operand" "+r"))
1656    (set (match_dup 1)
1657         (match_dup 0))]
1658   ""
1659   "xchg{l}\t%1, %0"
1660   [(set_attr "type" "imov")
1661    (set_attr "mode" "SI")
1662    (set_attr "pent_pair" "np")
1663    (set_attr "athlon_decode" "vector")
1664    (set_attr "amdfam10_decode" "double")])
1665
1666 (define_expand "movhi"
1667   [(set (match_operand:HI 0 "nonimmediate_operand" "")
1668         (match_operand:HI 1 "general_operand" ""))]
1669   ""
1670   "ix86_expand_move (HImode, operands); DONE;")
1671
1672 (define_insn "*pushhi2"
1673   [(set (match_operand:HI 0 "push_operand" "=X")
1674         (match_operand:HI 1 "nonmemory_no_elim_operand" "rn"))]
1675   "!TARGET_64BIT"
1676   "push{l}\t%k1"
1677   [(set_attr "type" "push")
1678    (set_attr "mode" "SI")])
1679
1680 ;; For 64BIT abi we always round up to 8 bytes.
1681 (define_insn "*pushhi2_rex64"
1682   [(set (match_operand:HI 0 "push_operand" "=X")
1683         (match_operand:HI 1 "nonmemory_no_elim_operand" "rn"))]
1684   "TARGET_64BIT"
1685   "push{q}\t%q1"
1686   [(set_attr "type" "push")
1687    (set_attr "mode" "DI")])
1688
1689 (define_insn "*movhi_1"
1690   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,m")
1691         (match_operand:HI 1 "general_operand" "r,rn,rm,rn"))]
1692   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
1693 {
1694   switch (get_attr_type (insn))
1695     {
1696     case TYPE_IMOVX:
1697       /* movzwl is faster than movw on p2 due to partial word stalls,
1698          though not as fast as an aligned movl.  */
1699       return "movz{wl|x}\t{%1, %k0|%k0, %1}";
1700     default:
1701       if (get_attr_mode (insn) == MODE_SI)
1702         return "mov{l}\t{%k1, %k0|%k0, %k1}";
1703       else
1704         return "mov{w}\t{%1, %0|%0, %1}";
1705     }
1706 }
1707   [(set (attr "type")
1708      (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0))
1709               (const_string "imov")
1710             (and (eq_attr "alternative" "0")
1711                  (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
1712                           (const_int 0))
1713                       (eq (symbol_ref "TARGET_HIMODE_MATH")
1714                           (const_int 0))))
1715               (const_string "imov")
1716             (and (eq_attr "alternative" "1,2")
1717                  (match_operand:HI 1 "aligned_operand" ""))
1718               (const_string "imov")
1719             (and (ne (symbol_ref "TARGET_MOVX")
1720                      (const_int 0))
1721                  (eq_attr "alternative" "0,2"))
1722               (const_string "imovx")
1723            ]
1724            (const_string "imov")))
1725     (set (attr "mode")
1726       (cond [(eq_attr "type" "imovx")
1727                (const_string "SI")
1728              (and (eq_attr "alternative" "1,2")
1729                   (match_operand:HI 1 "aligned_operand" ""))
1730                (const_string "SI")
1731              (and (eq_attr "alternative" "0")
1732                   (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
1733                            (const_int 0))
1734                        (eq (symbol_ref "TARGET_HIMODE_MATH")
1735                            (const_int 0))))
1736                (const_string "SI")
1737             ]
1738             (const_string "HI")))])
1739
1740 ;; Stores and loads of ax to arbitrary constant address.
1741 ;; We fake an second form of instruction to force reload to load address
1742 ;; into register when rax is not available
1743 (define_insn "*movabshi_1_rex64"
1744   [(set (mem:HI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
1745         (match_operand:HI 1 "nonmemory_operand" "a,er"))]
1746   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
1747   "@
1748    movabs{w}\t{%1, %P0|%P0, %1}
1749    mov{w}\t{%1, %a0|%a0, %1}"
1750   [(set_attr "type" "imov")
1751    (set_attr "modrm" "0,*")
1752    (set_attr "length_address" "8,0")
1753    (set_attr "length_immediate" "0,*")
1754    (set_attr "memory" "store")
1755    (set_attr "mode" "HI")])
1756
1757 (define_insn "*movabshi_2_rex64"
1758   [(set (match_operand:HI 0 "register_operand" "=a,r")
1759         (mem:HI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
1760   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
1761   "@
1762    movabs{w}\t{%P1, %0|%0, %P1}
1763    mov{w}\t{%a1, %0|%0, %a1}"
1764   [(set_attr "type" "imov")
1765    (set_attr "modrm" "0,*")
1766    (set_attr "length_address" "8,0")
1767    (set_attr "length_immediate" "0")
1768    (set_attr "memory" "load")
1769    (set_attr "mode" "HI")])
1770
1771 (define_insn "*swaphi_1"
1772   [(set (match_operand:HI 0 "register_operand" "+r")
1773         (match_operand:HI 1 "register_operand" "+r"))
1774    (set (match_dup 1)
1775         (match_dup 0))]
1776   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
1777   "xchg{l}\t%k1, %k0"
1778   [(set_attr "type" "imov")
1779    (set_attr "mode" "SI")
1780    (set_attr "pent_pair" "np")
1781    (set_attr "athlon_decode" "vector")
1782    (set_attr "amdfam10_decode" "double")])
1783
1784 ;; Not added amdfam10_decode since TARGET_PARTIAL_REG_STALL is disabled for AMDFAM10
1785 (define_insn "*swaphi_2"
1786   [(set (match_operand:HI 0 "register_operand" "+r")
1787         (match_operand:HI 1 "register_operand" "+r"))
1788    (set (match_dup 1)
1789         (match_dup 0))]
1790   "TARGET_PARTIAL_REG_STALL"
1791   "xchg{w}\t%1, %0"
1792   [(set_attr "type" "imov")
1793    (set_attr "mode" "HI")
1794    (set_attr "pent_pair" "np")
1795    (set_attr "athlon_decode" "vector")])
1796
1797 (define_expand "movstricthi"
1798   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" ""))
1799         (match_operand:HI 1 "general_operand" ""))]
1800   ""
1801 {
1802   if (TARGET_PARTIAL_REG_STALL && optimize_function_for_speed_p (cfun))
1803     FAIL;
1804   /* Don't generate memory->memory moves, go through a register */
1805   if (MEM_P (operands[0]) && MEM_P (operands[1]))
1806     operands[1] = force_reg (HImode, operands[1]);
1807 })
1808
1809 (define_insn "*movstricthi_1"
1810   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+rm,r"))
1811         (match_operand:HI 1 "general_operand" "rn,m"))]
1812   "(! TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
1813    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1814   "mov{w}\t{%1, %0|%0, %1}"
1815   [(set_attr "type" "imov")
1816    (set_attr "mode" "HI")])
1817
1818 (define_insn "*movstricthi_xor"
1819   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+r"))
1820         (match_operand:HI 1 "const0_operand" ""))
1821    (clobber (reg:CC FLAGS_REG))]
1822   "reload_completed"
1823   "xor{w}\t%0, %0"
1824   [(set_attr "type" "alu1")
1825    (set_attr "mode" "HI")
1826    (set_attr "length_immediate" "0")])
1827
1828 (define_expand "movqi"
1829   [(set (match_operand:QI 0 "nonimmediate_operand" "")
1830         (match_operand:QI 1 "general_operand" ""))]
1831   ""
1832   "ix86_expand_move (QImode, operands); DONE;")
1833
1834 ;; emit_push_insn when it calls move_by_pieces requires an insn to
1835 ;; "push a byte".  But actually we use pushl, which has the effect
1836 ;; of rounding the amount pushed up to a word.
1837
1838 (define_insn "*pushqi2"
1839   [(set (match_operand:QI 0 "push_operand" "=X")
1840         (match_operand:QI 1 "nonmemory_no_elim_operand" "rn"))]
1841   "!TARGET_64BIT"
1842   "push{l}\t%k1"
1843   [(set_attr "type" "push")
1844    (set_attr "mode" "SI")])
1845
1846 ;; For 64BIT abi we always round up to 8 bytes.
1847 (define_insn "*pushqi2_rex64"
1848   [(set (match_operand:QI 0 "push_operand" "=X")
1849         (match_operand:QI 1 "nonmemory_no_elim_operand" "qn"))]
1850   "TARGET_64BIT"
1851   "push{q}\t%q1"
1852   [(set_attr "type" "push")
1853    (set_attr "mode" "DI")])
1854
1855 ;; Situation is quite tricky about when to choose full sized (SImode) move
1856 ;; over QImode moves.  For Q_REG -> Q_REG move we use full size only for
1857 ;; partial register dependency machines (such as AMD Athlon), where QImode
1858 ;; moves issue extra dependency and for partial register stalls machines
1859 ;; that don't use QImode patterns (and QImode move cause stall on the next
1860 ;; instruction).
1861 ;;
1862 ;; For loads of Q_REG to NONQ_REG we use full sized moves except for partial
1863 ;; register stall machines with, where we use QImode instructions, since
1864 ;; partial register stall can be caused there.  Then we use movzx.
1865 (define_insn "*movqi_1"
1866   [(set (match_operand:QI 0 "nonimmediate_operand" "=q,q ,q ,r,r ,?r,m")
1867         (match_operand:QI 1 "general_operand"      " q,qn,qm,q,rn,qm,qn"))]
1868   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
1869 {
1870   switch (get_attr_type (insn))
1871     {
1872     case TYPE_IMOVX:
1873       gcc_assert (ANY_QI_REG_P (operands[1]) || MEM_P (operands[1]));
1874       return "movz{bl|x}\t{%1, %k0|%k0, %1}";
1875     default:
1876       if (get_attr_mode (insn) == MODE_SI)
1877         return "mov{l}\t{%k1, %k0|%k0, %k1}";
1878       else
1879         return "mov{b}\t{%1, %0|%0, %1}";
1880     }
1881 }
1882   [(set (attr "type")
1883      (cond [(and (eq_attr "alternative" "5")
1884                  (not (match_operand:QI 1 "aligned_operand" "")))
1885               (const_string "imovx")
1886             (ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0))
1887               (const_string "imov")
1888             (and (eq_attr "alternative" "3")
1889                  (ior (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
1890                           (const_int 0))
1891                       (eq (symbol_ref "TARGET_QIMODE_MATH")
1892                           (const_int 0))))
1893               (const_string "imov")
1894             (eq_attr "alternative" "3,5")
1895               (const_string "imovx")
1896             (and (ne (symbol_ref "TARGET_MOVX")
1897                      (const_int 0))
1898                  (eq_attr "alternative" "2"))
1899               (const_string "imovx")
1900            ]
1901            (const_string "imov")))
1902    (set (attr "mode")
1903       (cond [(eq_attr "alternative" "3,4,5")
1904                (const_string "SI")
1905              (eq_attr "alternative" "6")
1906                (const_string "QI")
1907              (eq_attr "type" "imovx")
1908                (const_string "SI")
1909              (and (eq_attr "type" "imov")
1910                   (and (eq_attr "alternative" "0,1")
1911                        (and (ne (symbol_ref "TARGET_PARTIAL_REG_DEPENDENCY")
1912                                 (const_int 0))
1913                             (and (eq (symbol_ref "optimize_function_for_size_p (cfun)")
1914                                      (const_int 0))
1915                                  (eq (symbol_ref "TARGET_PARTIAL_REG_STALL")
1916                                      (const_int 0))))))
1917                (const_string "SI")
1918              ;; Avoid partial register stalls when not using QImode arithmetic
1919              (and (eq_attr "type" "imov")
1920                   (and (eq_attr "alternative" "0,1")
1921                        (and (ne (symbol_ref "TARGET_PARTIAL_REG_STALL")
1922                                 (const_int 0))
1923                             (eq (symbol_ref "TARGET_QIMODE_MATH")
1924                                 (const_int 0)))))
1925                (const_string "SI")
1926            ]
1927            (const_string "QI")))])
1928
1929 (define_insn "*swapqi_1"
1930   [(set (match_operand:QI 0 "register_operand" "+r")
1931         (match_operand:QI 1 "register_operand" "+r"))
1932    (set (match_dup 1)
1933         (match_dup 0))]
1934   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
1935   "xchg{l}\t%k1, %k0"
1936   [(set_attr "type" "imov")
1937    (set_attr "mode" "SI")
1938    (set_attr "pent_pair" "np")
1939    (set_attr "athlon_decode" "vector")
1940    (set_attr "amdfam10_decode" "vector")])
1941
1942 ;; Not added amdfam10_decode since TARGET_PARTIAL_REG_STALL is disabled for AMDFAM10
1943 (define_insn "*swapqi_2"
1944   [(set (match_operand:QI 0 "register_operand" "+q")
1945         (match_operand:QI 1 "register_operand" "+q"))
1946    (set (match_dup 1)
1947         (match_dup 0))]
1948   "TARGET_PARTIAL_REG_STALL"
1949   "xchg{b}\t%1, %0"
1950   [(set_attr "type" "imov")
1951    (set_attr "mode" "QI")
1952    (set_attr "pent_pair" "np")
1953    (set_attr "athlon_decode" "vector")])
1954
1955 (define_expand "movstrictqi"
1956   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" ""))
1957         (match_operand:QI 1 "general_operand" ""))]
1958   ""
1959 {
1960   if (TARGET_PARTIAL_REG_STALL && optimize_function_for_speed_p (cfun))
1961     FAIL;
1962   /* Don't generate memory->memory moves, go through a register.  */
1963   if (MEM_P (operands[0]) && MEM_P (operands[1]))
1964     operands[1] = force_reg (QImode, operands[1]);
1965 })
1966
1967 (define_insn "*movstrictqi_1"
1968   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+qm,q"))
1969         (match_operand:QI 1 "general_operand" "*qn,m"))]
1970   "(! TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
1971    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1972   "mov{b}\t{%1, %0|%0, %1}"
1973   [(set_attr "type" "imov")
1974    (set_attr "mode" "QI")])
1975
1976 (define_insn "*movstrictqi_xor"
1977   [(set (strict_low_part (match_operand:QI 0 "q_regs_operand" "+q"))
1978         (match_operand:QI 1 "const0_operand" ""))
1979    (clobber (reg:CC FLAGS_REG))]
1980   "reload_completed"
1981   "xor{b}\t%0, %0"
1982   [(set_attr "type" "alu1")
1983    (set_attr "mode" "QI")
1984    (set_attr "length_immediate" "0")])
1985
1986 (define_insn "*movsi_extv_1"
1987   [(set (match_operand:SI 0 "register_operand" "=R")
1988         (sign_extract:SI (match_operand 1 "ext_register_operand" "Q")
1989                          (const_int 8)
1990                          (const_int 8)))]
1991   ""
1992   "movs{bl|x}\t{%h1, %0|%0, %h1}"
1993   [(set_attr "type" "imovx")
1994    (set_attr "mode" "SI")])
1995
1996 (define_insn "*movhi_extv_1"
1997   [(set (match_operand:HI 0 "register_operand" "=R")
1998         (sign_extract:HI (match_operand 1 "ext_register_operand" "Q")
1999                          (const_int 8)
2000                          (const_int 8)))]
2001   ""
2002   "movs{bl|x}\t{%h1, %k0|%k0, %h1}"
2003   [(set_attr "type" "imovx")
2004    (set_attr "mode" "SI")])
2005
2006 (define_insn "*movqi_extv_1"
2007   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?r")
2008         (sign_extract:QI (match_operand 1 "ext_register_operand" "Q,Q")
2009                          (const_int 8)
2010                          (const_int 8)))]
2011   "!TARGET_64BIT"
2012 {
2013   switch (get_attr_type (insn))
2014     {
2015     case TYPE_IMOVX:
2016       return "movs{bl|x}\t{%h1, %k0|%k0, %h1}";
2017     default:
2018       return "mov{b}\t{%h1, %0|%0, %h1}";
2019     }
2020 }
2021   [(set (attr "type")
2022      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2023                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2024                              (ne (symbol_ref "TARGET_MOVX")
2025                                  (const_int 0))))
2026         (const_string "imovx")
2027         (const_string "imov")))
2028    (set (attr "mode")
2029      (if_then_else (eq_attr "type" "imovx")
2030         (const_string "SI")
2031         (const_string "QI")))])
2032
2033 (define_insn "*movqi_extv_1_rex64"
2034   [(set (match_operand:QI 0 "register_operand" "=Q,?R")
2035         (sign_extract:QI (match_operand 1 "ext_register_operand" "Q,Q")
2036                          (const_int 8)
2037                          (const_int 8)))]
2038   "TARGET_64BIT"
2039 {
2040   switch (get_attr_type (insn))
2041     {
2042     case TYPE_IMOVX:
2043       return "movs{bl|x}\t{%h1, %k0|%k0, %h1}";
2044     default:
2045       return "mov{b}\t{%h1, %0|%0, %h1}";
2046     }
2047 }
2048   [(set (attr "type")
2049      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2050                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2051                              (ne (symbol_ref "TARGET_MOVX")
2052                                  (const_int 0))))
2053         (const_string "imovx")
2054         (const_string "imov")))
2055    (set (attr "mode")
2056      (if_then_else (eq_attr "type" "imovx")
2057         (const_string "SI")
2058         (const_string "QI")))])
2059
2060 ;; Stores and loads of ax to arbitrary constant address.
2061 ;; We fake an second form of instruction to force reload to load address
2062 ;; into register when rax is not available
2063 (define_insn "*movabsqi_1_rex64"
2064   [(set (mem:QI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
2065         (match_operand:QI 1 "nonmemory_operand" "a,er"))]
2066   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
2067   "@
2068    movabs{b}\t{%1, %P0|%P0, %1}
2069    mov{b}\t{%1, %a0|%a0, %1}"
2070   [(set_attr "type" "imov")
2071    (set_attr "modrm" "0,*")
2072    (set_attr "length_address" "8,0")
2073    (set_attr "length_immediate" "0,*")
2074    (set_attr "memory" "store")
2075    (set_attr "mode" "QI")])
2076
2077 (define_insn "*movabsqi_2_rex64"
2078   [(set (match_operand:QI 0 "register_operand" "=a,r")
2079         (mem:QI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
2080   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
2081   "@
2082    movabs{b}\t{%P1, %0|%0, %P1}
2083    mov{b}\t{%a1, %0|%0, %a1}"
2084   [(set_attr "type" "imov")
2085    (set_attr "modrm" "0,*")
2086    (set_attr "length_address" "8,0")
2087    (set_attr "length_immediate" "0")
2088    (set_attr "memory" "load")
2089    (set_attr "mode" "QI")])
2090
2091 (define_insn "*movdi_extzv_1"
2092   [(set (match_operand:DI 0 "register_operand" "=R")
2093         (zero_extract:DI (match_operand 1 "ext_register_operand" "Q")
2094                          (const_int 8)
2095                          (const_int 8)))]
2096   "TARGET_64BIT"
2097   "movz{bl|x}\t{%h1, %k0|%k0, %h1}"
2098   [(set_attr "type" "imovx")
2099    (set_attr "mode" "DI")])
2100
2101 (define_insn "*movsi_extzv_1"
2102   [(set (match_operand:SI 0 "register_operand" "=R")
2103         (zero_extract:SI (match_operand 1 "ext_register_operand" "Q")
2104                          (const_int 8)
2105                          (const_int 8)))]
2106   ""
2107   "movz{bl|x}\t{%h1, %0|%0, %h1}"
2108   [(set_attr "type" "imovx")
2109    (set_attr "mode" "SI")])
2110
2111 (define_insn "*movqi_extzv_2"
2112   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?R")
2113         (subreg:QI (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
2114                                     (const_int 8)
2115                                     (const_int 8)) 0))]
2116   "!TARGET_64BIT"
2117 {
2118   switch (get_attr_type (insn))
2119     {
2120     case TYPE_IMOVX:
2121       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2122     default:
2123       return "mov{b}\t{%h1, %0|%0, %h1}";
2124     }
2125 }
2126   [(set (attr "type")
2127      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2128                         (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2129                              (ne (symbol_ref "TARGET_MOVX")
2130                                  (const_int 0))))
2131         (const_string "imovx")
2132         (const_string "imov")))
2133    (set (attr "mode")
2134      (if_then_else (eq_attr "type" "imovx")
2135         (const_string "SI")
2136         (const_string "QI")))])
2137
2138 (define_insn "*movqi_extzv_2_rex64"
2139   [(set (match_operand:QI 0 "register_operand" "=Q,?R")
2140         (subreg:QI (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
2141                                     (const_int 8)
2142                                     (const_int 8)) 0))]
2143   "TARGET_64BIT"
2144 {
2145   switch (get_attr_type (insn))
2146     {
2147     case TYPE_IMOVX:
2148       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2149     default:
2150       return "mov{b}\t{%h1, %0|%0, %h1}";
2151     }
2152 }
2153   [(set (attr "type")
2154      (if_then_else (ior (not (match_operand:QI 0 "q_regs_operand" ""))
2155                         (ne (symbol_ref "TARGET_MOVX")
2156                             (const_int 0)))
2157         (const_string "imovx")
2158         (const_string "imov")))
2159    (set (attr "mode")
2160      (if_then_else (eq_attr "type" "imovx")
2161         (const_string "SI")
2162         (const_string "QI")))])
2163
2164 (define_insn "movsi_insv_1"
2165   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2166                          (const_int 8)
2167                          (const_int 8))
2168         (match_operand:SI 1 "general_operand" "Qmn"))]
2169   "!TARGET_64BIT"
2170   "mov{b}\t{%b1, %h0|%h0, %b1}"
2171   [(set_attr "type" "imov")
2172    (set_attr "mode" "QI")])
2173
2174 (define_insn "*movsi_insv_1_rex64"
2175   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2176                          (const_int 8)
2177                          (const_int 8))
2178         (match_operand:SI 1 "nonmemory_operand" "Qn"))]
2179   "TARGET_64BIT"
2180   "mov{b}\t{%b1, %h0|%h0, %b1}"
2181   [(set_attr "type" "imov")
2182    (set_attr "mode" "QI")])
2183
2184 (define_insn "movdi_insv_1_rex64"
2185   [(set (zero_extract:DI (match_operand 0 "ext_register_operand" "+Q")
2186                          (const_int 8)
2187                          (const_int 8))
2188         (match_operand:DI 1 "nonmemory_operand" "Qn"))]
2189   "TARGET_64BIT"
2190   "mov{b}\t{%b1, %h0|%h0, %b1}"
2191   [(set_attr "type" "imov")
2192    (set_attr "mode" "QI")])
2193
2194 (define_insn "*movqi_insv_2"
2195   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2196                          (const_int 8)
2197                          (const_int 8))
2198         (lshiftrt:SI (match_operand:SI 1 "register_operand" "Q")
2199                      (const_int 8)))]
2200   ""
2201   "mov{b}\t{%h1, %h0|%h0, %h1}"
2202   [(set_attr "type" "imov")
2203    (set_attr "mode" "QI")])
2204
2205 (define_expand "movdi"
2206   [(set (match_operand:DI 0 "nonimmediate_operand" "")
2207         (match_operand:DI 1 "general_operand" ""))]
2208   ""
2209   "ix86_expand_move (DImode, operands); DONE;")
2210
2211 (define_insn "*pushdi"
2212   [(set (match_operand:DI 0 "push_operand" "=<")
2213         (match_operand:DI 1 "general_no_elim_operand" "riF*m"))]
2214   "!TARGET_64BIT"
2215   "#")
2216
2217 (define_insn "*pushdi2_rex64"
2218   [(set (match_operand:DI 0 "push_operand" "=<,!<")
2219         (match_operand:DI 1 "general_no_elim_operand" "re*m,n"))]
2220   "TARGET_64BIT"
2221   "@
2222    push{q}\t%1
2223    #"
2224   [(set_attr "type" "push,multi")
2225    (set_attr "mode" "DI")])
2226
2227 ;; Convert impossible pushes of immediate to existing instructions.
2228 ;; First try to get scratch register and go through it.  In case this
2229 ;; fails, push sign extended lower part first and then overwrite
2230 ;; upper part by 32bit move.
2231 (define_peephole2
2232   [(match_scratch:DI 2 "r")
2233    (set (match_operand:DI 0 "push_operand" "")
2234         (match_operand:DI 1 "immediate_operand" ""))]
2235   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2236    && !x86_64_immediate_operand (operands[1], DImode)"
2237   [(set (match_dup 2) (match_dup 1))
2238    (set (match_dup 0) (match_dup 2))]
2239   "")
2240
2241 ;; We need to define this as both peepholer and splitter for case
2242 ;; peephole2 pass is not run.
2243 ;; "&& 1" is needed to keep it from matching the previous pattern.
2244 (define_peephole2
2245   [(set (match_operand:DI 0 "push_operand" "")
2246         (match_operand:DI 1 "immediate_operand" ""))]
2247   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2248    && !x86_64_immediate_operand (operands[1], DImode) && 1"
2249   [(set (match_dup 0) (match_dup 1))
2250    (set (match_dup 2) (match_dup 3))]
2251   "split_di (&operands[1], 1, &operands[2], &operands[3]);
2252    operands[1] = gen_lowpart (DImode, operands[2]);
2253    operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx,
2254                                                     GEN_INT (4)));
2255   ")
2256
2257 (define_split
2258   [(set (match_operand:DI 0 "push_operand" "")
2259         (match_operand:DI 1 "immediate_operand" ""))]
2260   "TARGET_64BIT && ((optimize > 0 && flag_peephole2)
2261                     ? epilogue_completed : reload_completed)
2262    && !symbolic_operand (operands[1], DImode)
2263    && !x86_64_immediate_operand (operands[1], DImode)"
2264   [(set (match_dup 0) (match_dup 1))
2265    (set (match_dup 2) (match_dup 3))]
2266   "split_di (&operands[1], 1, &operands[2], &operands[3]);
2267    operands[1] = gen_lowpart (DImode, operands[2]);
2268    operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx,
2269                                                     GEN_INT (4)));
2270   ")
2271
2272 (define_insn "*pushdi2_prologue_rex64"
2273   [(set (match_operand:DI 0 "push_operand" "=<")
2274         (match_operand:DI 1 "general_no_elim_operand" "re*m"))
2275    (clobber (mem:BLK (scratch)))]
2276   "TARGET_64BIT"
2277   "push{q}\t%1"
2278   [(set_attr "type" "push")
2279    (set_attr "mode" "DI")])
2280
2281 (define_insn "*popdi1_epilogue_rex64"
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    (clobber (mem:BLK (scratch)))]
2287   "TARGET_64BIT"
2288   "pop{q}\t%0"
2289   [(set_attr "type" "pop")
2290    (set_attr "mode" "DI")])
2291
2292 (define_insn "popdi1"
2293   [(set (match_operand:DI 0 "nonimmediate_operand" "=r*m")
2294         (mem:DI (reg:DI SP_REG)))
2295    (set (reg:DI SP_REG)
2296         (plus:DI (reg:DI SP_REG) (const_int 8)))]
2297   "TARGET_64BIT"
2298   "pop{q}\t%0"
2299   [(set_attr "type" "pop")
2300    (set_attr "mode" "DI")])
2301
2302 (define_insn "*movdi_xor_rex64"
2303   [(set (match_operand:DI 0 "register_operand" "=r")
2304         (match_operand:DI 1 "const0_operand" ""))
2305    (clobber (reg:CC FLAGS_REG))]
2306   "TARGET_64BIT
2307    && reload_completed"
2308   "xor{l}\t%k0, %k0";
2309   [(set_attr "type" "alu1")
2310    (set_attr "mode" "SI")
2311    (set_attr "length_immediate" "0")])
2312
2313 (define_insn "*movdi_or_rex64"
2314   [(set (match_operand:DI 0 "register_operand" "=r")
2315         (match_operand:DI 1 "const_int_operand" "i"))
2316    (clobber (reg:CC FLAGS_REG))]
2317   "TARGET_64BIT
2318    && reload_completed
2319    && operands[1] == constm1_rtx"
2320 {
2321   operands[1] = constm1_rtx;
2322   return "or{q}\t{%1, %0|%0, %1}";
2323 }
2324   [(set_attr "type" "alu1")
2325    (set_attr "mode" "DI")
2326    (set_attr "length_immediate" "1")])
2327
2328 (define_insn "*movdi_2"
2329   [(set (match_operand:DI 0 "nonimmediate_operand"
2330                         "=r  ,o  ,*y,m*y,*y,*Y2,m  ,*Y2,*Y2,*x,m ,*x,*x")
2331         (match_operand:DI 1 "general_operand"
2332                         "riFo,riF,C ,*y ,m ,C  ,*Y2,*Y2,m  ,C ,*x,*x,m "))]
2333   "!TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2334   "@
2335    #
2336    #
2337    pxor\t%0, %0
2338    movq\t{%1, %0|%0, %1}
2339    movq\t{%1, %0|%0, %1}
2340    %vpxor\t%0, %d0
2341    %vmovq\t{%1, %0|%0, %1}
2342    %vmovdqa\t{%1, %0|%0, %1}
2343    %vmovq\t{%1, %0|%0, %1}
2344    xorps\t%0, %0
2345    movlps\t{%1, %0|%0, %1}
2346    movaps\t{%1, %0|%0, %1}
2347    movlps\t{%1, %0|%0, %1}"
2348   [(set_attr "type" "*,*,mmx,mmxmov,mmxmov,sselog1,ssemov,ssemov,ssemov,sselog1,ssemov,ssemov,ssemov")
2349    (set (attr "prefix")
2350      (if_then_else (eq_attr "alternative" "5,6,7,8")
2351        (const_string "vex")
2352        (const_string "orig")))
2353    (set_attr "mode" "DI,DI,DI,DI,DI,TI,DI,TI,DI,V4SF,V2SF,V4SF,V2SF")])
2354
2355 (define_split
2356   [(set (match_operand:DI 0 "push_operand" "")
2357         (match_operand:DI 1 "general_operand" ""))]
2358   "!TARGET_64BIT && reload_completed
2359    && (! MMX_REG_P (operands[1]) && !SSE_REG_P (operands[1]))"
2360   [(const_int 0)]
2361   "ix86_split_long_move (operands); DONE;")
2362
2363 ;; %%% This multiword shite has got to go.
2364 (define_split
2365   [(set (match_operand:DI 0 "nonimmediate_operand" "")
2366         (match_operand:DI 1 "general_operand" ""))]
2367   "!TARGET_64BIT && reload_completed
2368    && (!MMX_REG_P (operands[0]) && !SSE_REG_P (operands[0]))
2369    && (!MMX_REG_P (operands[1]) && !SSE_REG_P (operands[1]))"
2370   [(const_int 0)]
2371   "ix86_split_long_move (operands); DONE;")
2372
2373 (define_insn "*movdi_1_rex64"
2374   [(set (match_operand:DI 0 "nonimmediate_operand"
2375           "=r,r  ,r,m ,!m,*y,*y,?r ,m ,?*Ym,?*y,*x,*x,?r ,m,?*Yi,*x,?*x,?*Ym")
2376         (match_operand:DI 1 "general_operand"
2377           "Z ,rem,i,re,n ,C ,*y,*Ym,*y,r   ,m  ,C ,*x,*Yi,*x,r  ,m ,*Ym,*x"))]
2378   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2379 {
2380   switch (get_attr_type (insn))
2381     {
2382     case TYPE_SSECVT:
2383       if (SSE_REG_P (operands[0]))
2384         return "movq2dq\t{%1, %0|%0, %1}";
2385       else
2386         return "movdq2q\t{%1, %0|%0, %1}";
2387
2388     case TYPE_SSEMOV:
2389       if (TARGET_AVX)
2390         {
2391           if (get_attr_mode (insn) == MODE_TI)
2392             return "vmovdqa\t{%1, %0|%0, %1}";
2393           else
2394             return "vmovq\t{%1, %0|%0, %1}";
2395         }
2396
2397       if (get_attr_mode (insn) == MODE_TI)
2398         return "movdqa\t{%1, %0|%0, %1}";
2399       /* FALLTHRU */
2400
2401     case TYPE_MMXMOV:
2402       /* Moves from and into integer register is done using movd
2403          opcode with REX prefix.  */
2404       if (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1]))
2405         return "movd\t{%1, %0|%0, %1}";
2406       return "movq\t{%1, %0|%0, %1}";
2407
2408     case TYPE_SSELOG1:
2409       return "%vpxor\t%0, %d0";
2410
2411     case TYPE_MMX:
2412       return "pxor\t%0, %0";
2413
2414     case TYPE_MULTI:
2415       return "#";
2416
2417     case TYPE_LEA:
2418       return "lea{q}\t{%a1, %0|%0, %a1}";
2419
2420     default:
2421       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
2422       if (get_attr_mode (insn) == MODE_SI)
2423         return "mov{l}\t{%k1, %k0|%k0, %k1}";
2424       else if (which_alternative == 2)
2425         return "movabs{q}\t{%1, %0|%0, %1}";
2426       else
2427         return "mov{q}\t{%1, %0|%0, %1}";
2428     }
2429 }
2430   [(set (attr "type")
2431      (cond [(eq_attr "alternative" "5")
2432               (const_string "mmx")
2433             (eq_attr "alternative" "6,7,8,9,10")
2434               (const_string "mmxmov")
2435             (eq_attr "alternative" "11")
2436               (const_string "sselog1")
2437             (eq_attr "alternative" "12,13,14,15,16")
2438               (const_string "ssemov")
2439             (eq_attr "alternative" "17,18")
2440               (const_string "ssecvt")
2441             (eq_attr "alternative" "4")
2442               (const_string "multi")
2443             (match_operand:DI 1 "pic_32bit_operand" "")
2444               (const_string "lea")
2445            ]
2446            (const_string "imov")))
2447    (set_attr "modrm" "*,0,0,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*")
2448    (set_attr "length_immediate" "*,4,8,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*")
2449    (set (attr "prefix")
2450      (if_then_else (eq_attr "alternative" "11,12,13,14,15,16")
2451        (const_string "maybe_vex")
2452        (const_string "orig")))
2453    (set_attr "mode" "SI,DI,DI,DI,SI,DI,DI,DI,DI,DI,DI,TI,TI,DI,DI,DI,DI,DI,DI")])
2454
2455 ;; Stores and loads of ax to arbitrary constant address.
2456 ;; We fake an second form of instruction to force reload to load address
2457 ;; into register when rax is not available
2458 (define_insn "*movabsdi_1_rex64"
2459   [(set (mem:DI (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
2460         (match_operand:DI 1 "nonmemory_operand" "a,er"))]
2461   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
2462   "@
2463    movabs{q}\t{%1, %P0|%P0, %1}
2464    mov{q}\t{%1, %a0|%a0, %1}"
2465   [(set_attr "type" "imov")
2466    (set_attr "modrm" "0,*")
2467    (set_attr "length_address" "8,0")
2468    (set_attr "length_immediate" "0,*")
2469    (set_attr "memory" "store")
2470    (set_attr "mode" "DI")])
2471
2472 (define_insn "*movabsdi_2_rex64"
2473   [(set (match_operand:DI 0 "register_operand" "=a,r")
2474         (mem:DI (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
2475   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
2476   "@
2477    movabs{q}\t{%P1, %0|%0, %P1}
2478    mov{q}\t{%a1, %0|%0, %a1}"
2479   [(set_attr "type" "imov")
2480    (set_attr "modrm" "0,*")
2481    (set_attr "length_address" "8,0")
2482    (set_attr "length_immediate" "0")
2483    (set_attr "memory" "load")
2484    (set_attr "mode" "DI")])
2485
2486 ;; Convert impossible stores of immediate to existing instructions.
2487 ;; First try to get scratch register and go through it.  In case this
2488 ;; fails, move by 32bit parts.
2489 (define_peephole2
2490   [(match_scratch:DI 2 "r")
2491    (set (match_operand:DI 0 "memory_operand" "")
2492         (match_operand:DI 1 "immediate_operand" ""))]
2493   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2494    && !x86_64_immediate_operand (operands[1], DImode)"
2495   [(set (match_dup 2) (match_dup 1))
2496    (set (match_dup 0) (match_dup 2))]
2497   "")
2498
2499 ;; We need to define this as both peepholer and splitter for case
2500 ;; peephole2 pass is not run.
2501 ;; "&& 1" is needed to keep it from matching the previous pattern.
2502 (define_peephole2
2503   [(set (match_operand:DI 0 "memory_operand" "")
2504         (match_operand:DI 1 "immediate_operand" ""))]
2505   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2506    && !x86_64_immediate_operand (operands[1], DImode) && 1"
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_split
2512   [(set (match_operand:DI 0 "memory_operand" "")
2513         (match_operand:DI 1 "immediate_operand" ""))]
2514   "TARGET_64BIT && ((optimize > 0 && flag_peephole2)
2515                     ? epilogue_completed : reload_completed)
2516    && !symbolic_operand (operands[1], DImode)
2517    && !x86_64_immediate_operand (operands[1], DImode)"
2518   [(set (match_dup 2) (match_dup 3))
2519    (set (match_dup 4) (match_dup 5))]
2520   "split_di (&operands[0], 2, &operands[2], &operands[4]);")
2521
2522 (define_insn "*swapdi_rex64"
2523   [(set (match_operand:DI 0 "register_operand" "+r")
2524         (match_operand:DI 1 "register_operand" "+r"))
2525    (set (match_dup 1)
2526         (match_dup 0))]
2527   "TARGET_64BIT"
2528   "xchg{q}\t%1, %0"
2529   [(set_attr "type" "imov")
2530    (set_attr "mode" "DI")
2531    (set_attr "pent_pair" "np")
2532    (set_attr "athlon_decode" "vector")
2533    (set_attr "amdfam10_decode" "double")])
2534
2535 (define_expand "movoi"
2536   [(set (match_operand:OI 0 "nonimmediate_operand" "")
2537         (match_operand:OI 1 "general_operand" ""))]
2538   "TARGET_AVX"
2539   "ix86_expand_move (OImode, operands); DONE;")
2540
2541 (define_insn "*movoi_internal"
2542   [(set (match_operand:OI 0 "nonimmediate_operand" "=x,x,m")
2543         (match_operand:OI 1 "vector_move_operand" "C,xm,x"))]
2544   "TARGET_AVX
2545    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2546 {
2547   switch (which_alternative)
2548     {
2549     case 0:
2550       return "vxorps\t%0, %0, %0";
2551     case 1:
2552     case 2:
2553       if (misaligned_operand (operands[0], OImode)
2554           || misaligned_operand (operands[1], OImode))
2555         return "vmovdqu\t{%1, %0|%0, %1}";
2556       else
2557         return "vmovdqa\t{%1, %0|%0, %1}";
2558     default:
2559       gcc_unreachable ();
2560     }
2561 }
2562   [(set_attr "type" "sselog1,ssemov,ssemov")
2563    (set_attr "prefix" "vex")
2564    (set_attr "mode" "OI")])
2565
2566 (define_expand "movti"
2567   [(set (match_operand:TI 0 "nonimmediate_operand" "")
2568         (match_operand:TI 1 "nonimmediate_operand" ""))]
2569   "TARGET_SSE || TARGET_64BIT"
2570 {
2571   if (TARGET_64BIT)
2572     ix86_expand_move (TImode, operands);
2573   else if (push_operand (operands[0], TImode))
2574     ix86_expand_push (TImode, operands[1]);
2575   else
2576     ix86_expand_vector_move (TImode, operands);
2577   DONE;
2578 })
2579
2580 (define_insn "*movti_internal"
2581   [(set (match_operand:TI 0 "nonimmediate_operand" "=x,x,m")
2582         (match_operand:TI 1 "vector_move_operand" "C,xm,x"))]
2583   "TARGET_SSE && !TARGET_64BIT
2584    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2585 {
2586   switch (which_alternative)
2587     {
2588     case 0:
2589       if (get_attr_mode (insn) == MODE_V4SF)
2590         return "%vxorps\t%0, %d0";
2591       else
2592         return "%vpxor\t%0, %d0";
2593     case 1:
2594     case 2:
2595       /* TDmode values are passed as TImode on the stack.  Moving them
2596          to stack may result in unaligned memory access.  */
2597       if (misaligned_operand (operands[0], TImode)
2598           || misaligned_operand (operands[1], TImode))
2599         {
2600           if (get_attr_mode (insn) == MODE_V4SF)
2601             return "%vmovups\t{%1, %0|%0, %1}";
2602          else
2603            return "%vmovdqu\t{%1, %0|%0, %1}";
2604         }
2605       else
2606         {
2607           if (get_attr_mode (insn) == MODE_V4SF)
2608             return "%vmovaps\t{%1, %0|%0, %1}";
2609          else
2610            return "%vmovdqa\t{%1, %0|%0, %1}";
2611         }
2612     default:
2613       gcc_unreachable ();
2614     }
2615 }
2616   [(set_attr "type" "sselog1,ssemov,ssemov")
2617    (set_attr "prefix" "maybe_vex")
2618    (set (attr "mode")
2619         (cond [(ior (eq (symbol_ref "TARGET_SSE2") (const_int 0))
2620                     (ne (symbol_ref "optimize_function_for_size_p (cfun)") (const_int 0)))
2621                  (const_string "V4SF")
2622                (and (eq_attr "alternative" "2")
2623                     (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
2624                         (const_int 0)))
2625                  (const_string "V4SF")]
2626               (const_string "TI")))])
2627
2628 (define_insn "*movti_rex64"
2629   [(set (match_operand:TI 0 "nonimmediate_operand" "=!r,o,x,x,xm")
2630         (match_operand:TI 1 "general_operand" "riFo,riF,C,xm,x"))]
2631   "TARGET_64BIT
2632    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2633 {
2634   switch (which_alternative)
2635     {
2636     case 0:
2637     case 1:
2638       return "#";
2639     case 2:
2640       if (get_attr_mode (insn) == MODE_V4SF)
2641         return "%vxorps\t%0, %d0";
2642       else
2643         return "%vpxor\t%0, %d0";
2644     case 3:
2645     case 4:
2646       /* TDmode values are passed as TImode on the stack.  Moving them
2647          to stack may result in unaligned memory access.  */
2648       if (misaligned_operand (operands[0], TImode)
2649           || misaligned_operand (operands[1], TImode))
2650         {
2651           if (get_attr_mode (insn) == MODE_V4SF)
2652             return "%vmovups\t{%1, %0|%0, %1}";
2653          else
2654            return "%vmovdqu\t{%1, %0|%0, %1}";
2655         }
2656       else
2657         {
2658           if (get_attr_mode (insn) == MODE_V4SF)
2659             return "%vmovaps\t{%1, %0|%0, %1}";
2660          else
2661            return "%vmovdqa\t{%1, %0|%0, %1}";
2662         }
2663     default:
2664       gcc_unreachable ();
2665     }
2666 }
2667   [(set_attr "type" "*,*,sselog1,ssemov,ssemov")
2668    (set_attr "prefix" "*,*,maybe_vex,maybe_vex,maybe_vex")
2669    (set (attr "mode")
2670         (cond [(eq_attr "alternative" "2,3")
2671                  (if_then_else
2672                    (ne (symbol_ref "optimize_function_for_size_p (cfun)")
2673                        (const_int 0))
2674                    (const_string "V4SF")
2675                    (const_string "TI"))
2676                (eq_attr "alternative" "4")
2677                  (if_then_else
2678                    (ior (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
2679                             (const_int 0))
2680                         (ne (symbol_ref "optimize_function_for_size_p (cfun)")
2681                             (const_int 0)))
2682                    (const_string "V4SF")
2683                    (const_string "TI"))]
2684                (const_string "DI")))])
2685
2686 (define_split
2687   [(set (match_operand:TI 0 "nonimmediate_operand" "")
2688         (match_operand:TI 1 "general_operand" ""))]
2689   "reload_completed && !SSE_REG_P (operands[0])
2690    && !SSE_REG_P (operands[1])"
2691   [(const_int 0)]
2692   "ix86_split_long_move (operands); DONE;")
2693
2694 ;; This expands to what emit_move_complex would generate if we didn't
2695 ;; have a movti pattern.  Having this avoids problems with reload on
2696 ;; 32-bit targets when SSE is present, but doesn't seem to be harmful
2697 ;; to have around all the time.
2698 (define_expand "movcdi"
2699   [(set (match_operand:CDI 0 "nonimmediate_operand" "")
2700         (match_operand:CDI 1 "general_operand" ""))]
2701   ""
2702 {
2703   if (push_operand (operands[0], CDImode))
2704     emit_move_complex_push (CDImode, operands[0], operands[1]);
2705   else
2706     emit_move_complex_parts (operands[0], operands[1]);
2707   DONE;
2708 })
2709
2710 (define_expand "movsf"
2711   [(set (match_operand:SF 0 "nonimmediate_operand" "")
2712         (match_operand:SF 1 "general_operand" ""))]
2713   ""
2714   "ix86_expand_move (SFmode, operands); DONE;")
2715
2716 (define_insn "*pushsf"
2717   [(set (match_operand:SF 0 "push_operand" "=<,<,<")
2718         (match_operand:SF 1 "general_no_elim_operand" "f,rFm,x"))]
2719   "!TARGET_64BIT"
2720 {
2721   /* Anything else should be already split before reg-stack.  */
2722   gcc_assert (which_alternative == 1);
2723   return "push{l}\t%1";
2724 }
2725   [(set_attr "type" "multi,push,multi")
2726    (set_attr "unit" "i387,*,*")
2727    (set_attr "mode" "SF,SI,SF")])
2728
2729 (define_insn "*pushsf_rex64"
2730   [(set (match_operand:SF 0 "push_operand" "=X,X,X")
2731         (match_operand:SF 1 "nonmemory_no_elim_operand" "f,rF,x"))]
2732   "TARGET_64BIT"
2733 {
2734   /* Anything else should be already split before reg-stack.  */
2735   gcc_assert (which_alternative == 1);
2736   return "push{q}\t%q1";
2737 }
2738   [(set_attr "type" "multi,push,multi")
2739    (set_attr "unit" "i387,*,*")
2740    (set_attr "mode" "SF,DI,SF")])
2741
2742 (define_split
2743   [(set (match_operand:SF 0 "push_operand" "")
2744         (match_operand:SF 1 "memory_operand" ""))]
2745   "reload_completed
2746    && MEM_P (operands[1])
2747    && (operands[2] = find_constant_src (insn))"
2748   [(set (match_dup 0)
2749         (match_dup 2))])
2750
2751
2752 ;; %%% Kill this when call knows how to work this out.
2753 (define_split
2754   [(set (match_operand:SF 0 "push_operand" "")
2755         (match_operand:SF 1 "any_fp_register_operand" ""))]
2756   "!TARGET_64BIT"
2757   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int -4)))
2758    (set (mem:SF (reg:SI SP_REG)) (match_dup 1))])
2759
2760 (define_split
2761   [(set (match_operand:SF 0 "push_operand" "")
2762         (match_operand:SF 1 "any_fp_register_operand" ""))]
2763   "TARGET_64BIT"
2764   [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int -8)))
2765    (set (mem:SF (reg:DI SP_REG)) (match_dup 1))])
2766
2767 (define_insn "*movsf_1"
2768   [(set (match_operand:SF 0 "nonimmediate_operand"
2769           "=f,m,f,r  ,m ,x,x,x ,m,!*y,!m,!*y,?Yi,?r,!*Ym,!r")
2770         (match_operand:SF 1 "general_operand"
2771           "fm,f,G,rmF,Fr,C,x,xm,x,m  ,*y,*y ,r  ,Yi,r   ,*Ym"))]
2772   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
2773    && (reload_in_progress || reload_completed
2774        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
2775        || (!TARGET_SSE_MATH && optimize_function_for_size_p (cfun)
2776            && standard_80387_constant_p (operands[1]))
2777        || GET_CODE (operands[1]) != CONST_DOUBLE
2778        || memory_operand (operands[0], SFmode))"
2779 {
2780   switch (which_alternative)
2781     {
2782     case 0:
2783     case 1:
2784       return output_387_reg_move (insn, operands);
2785
2786     case 2:
2787       return standard_80387_constant_opcode (operands[1]);
2788
2789     case 3:
2790     case 4:
2791       return "mov{l}\t{%1, %0|%0, %1}";
2792     case 5:
2793       if (get_attr_mode (insn) == MODE_TI)
2794         return "%vpxor\t%0, %d0";
2795       else
2796         return "%vxorps\t%0, %d0";
2797     case 6:
2798       if (get_attr_mode (insn) == MODE_V4SF)
2799         return "%vmovaps\t{%1, %0|%0, %1}";
2800       else
2801         return "%vmovss\t{%1, %d0|%d0, %1}";
2802     case 7:
2803       if (TARGET_AVX)
2804         return REG_P (operands[1]) ? "vmovss\t{%1, %0, %0|%0, %0, %1}"
2805                                    : "vmovss\t{%1, %0|%0, %1}";
2806       else
2807         return "movss\t{%1, %0|%0, %1}";
2808     case 8:
2809       return "%vmovss\t{%1, %0|%0, %1}";
2810
2811     case 9: case 10: case 14: case 15:
2812       return "movd\t{%1, %0|%0, %1}";
2813     case 12: case 13:
2814       return "%vmovd\t{%1, %0|%0, %1}";
2815
2816     case 11:
2817       return "movq\t{%1, %0|%0, %1}";
2818
2819     default:
2820       gcc_unreachable ();
2821     }
2822 }
2823   [(set_attr "type" "fmov,fmov,fmov,imov,imov,sselog1,ssemov,ssemov,ssemov,mmxmov,mmxmov,mmxmov,ssemov,ssemov,mmxmov,mmxmov")
2824    (set (attr "prefix")
2825      (if_then_else (eq_attr "alternative" "5,6,7,8,12,13")
2826        (const_string "maybe_vex")
2827        (const_string "orig")))
2828    (set (attr "mode")
2829         (cond [(eq_attr "alternative" "3,4,9,10")
2830                  (const_string "SI")
2831                (eq_attr "alternative" "5")
2832                  (if_then_else
2833                    (and (and (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
2834                                  (const_int 0))
2835                              (ne (symbol_ref "TARGET_SSE2")
2836                                  (const_int 0)))
2837                         (eq (symbol_ref "optimize_function_for_size_p (cfun)")
2838                             (const_int 0)))
2839                    (const_string "TI")
2840                    (const_string "V4SF"))
2841                /* For architectures resolving dependencies on
2842                   whole SSE registers use APS move to break dependency
2843                   chains, otherwise use short move to avoid extra work.
2844
2845                   Do the same for architectures resolving dependencies on
2846                   the parts.  While in DF mode it is better to always handle
2847                   just register parts, the SF mode is different due to lack
2848                   of instructions to load just part of the register.  It is
2849                   better to maintain the whole registers in single format
2850                   to avoid problems on using packed logical operations.  */
2851                (eq_attr "alternative" "6")
2852                  (if_then_else
2853                    (ior (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
2854                             (const_int 0))
2855                         (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
2856                             (const_int 0)))
2857                    (const_string "V4SF")
2858                    (const_string "SF"))
2859                (eq_attr "alternative" "11")
2860                  (const_string "DI")]
2861                (const_string "SF")))])
2862
2863 (define_insn "*swapsf"
2864   [(set (match_operand:SF 0 "fp_register_operand" "+f")
2865         (match_operand:SF 1 "fp_register_operand" "+f"))
2866    (set (match_dup 1)
2867         (match_dup 0))]
2868   "reload_completed || TARGET_80387"
2869 {
2870   if (STACK_TOP_P (operands[0]))
2871     return "fxch\t%1";
2872   else
2873     return "fxch\t%0";
2874 }
2875   [(set_attr "type" "fxch")
2876    (set_attr "mode" "SF")])
2877
2878 (define_expand "movdf"
2879   [(set (match_operand:DF 0 "nonimmediate_operand" "")
2880         (match_operand:DF 1 "general_operand" ""))]
2881   ""
2882   "ix86_expand_move (DFmode, operands); DONE;")
2883
2884 ;; Size of pushdf is 3 (for sub) + 2 (for fstp) + memory operand size.
2885 ;; Size of pushdf using integer instructions is 2+2*memory operand size
2886 ;; On the average, pushdf using integers can be still shorter.  Allow this
2887 ;; pattern for optimize_size too.
2888
2889 (define_insn "*pushdf_nointeger"
2890   [(set (match_operand:DF 0 "push_operand" "=<,<,<,<")
2891         (match_operand:DF 1 "general_no_elim_operand" "f,Fo,*r,Y2"))]
2892   "!TARGET_64BIT && !TARGET_INTEGER_DFMODE_MOVES"
2893 {
2894   /* This insn should be already split before reg-stack.  */
2895   gcc_unreachable ();
2896 }
2897   [(set_attr "type" "multi")
2898    (set_attr "unit" "i387,*,*,*")
2899    (set_attr "mode" "DF,SI,SI,DF")])
2900
2901 (define_insn "*pushdf_integer"
2902   [(set (match_operand:DF 0 "push_operand" "=<,<,<")
2903         (match_operand:DF 1 "general_no_elim_operand" "f,rFo,Y2"))]
2904   "TARGET_64BIT || TARGET_INTEGER_DFMODE_MOVES"
2905 {
2906   /* This insn should be already split before reg-stack.  */
2907   gcc_unreachable ();
2908 }
2909   [(set_attr "type" "multi")
2910    (set_attr "unit" "i387,*,*")
2911    (set_attr "mode" "DF,SI,DF")])
2912
2913 ;; %%% Kill this when call knows how to work this out.
2914 (define_split
2915   [(set (match_operand:DF 0 "push_operand" "")
2916         (match_operand:DF 1 "any_fp_register_operand" ""))]
2917   "reload_completed"
2918   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -8)))
2919    (set (mem:DF (reg:P SP_REG)) (match_dup 1))]
2920   "")
2921
2922 (define_split
2923   [(set (match_operand:DF 0 "push_operand" "")
2924         (match_operand:DF 1 "general_operand" ""))]
2925   "reload_completed"
2926   [(const_int 0)]
2927   "ix86_split_long_move (operands); DONE;")
2928
2929 ;; Moving is usually shorter when only FP registers are used. This separate
2930 ;; movdf pattern avoids the use of integer registers for FP operations
2931 ;; when optimizing for size.
2932
2933 (define_insn "*movdf_nointeger"
2934   [(set (match_operand:DF 0 "nonimmediate_operand"
2935                         "=f,m,f,*r  ,o  ,Y2*x,Y2*x,Y2*x ,m  ")
2936         (match_operand:DF 1 "general_operand"
2937                         "fm,f,G,*roF,*Fr,C   ,Y2*x,mY2*x,Y2*x"))]
2938   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
2939    && ((optimize_function_for_size_p (cfun)
2940        || !TARGET_INTEGER_DFMODE_MOVES) && !TARGET_64BIT)
2941    && (reload_in_progress || reload_completed
2942        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
2943        || (!(TARGET_SSE2 && TARGET_SSE_MATH)
2944            && optimize_function_for_size_p (cfun)
2945            && !memory_operand (operands[0], DFmode)
2946            && standard_80387_constant_p (operands[1]))
2947        || GET_CODE (operands[1]) != CONST_DOUBLE
2948        || ((optimize_function_for_size_p (cfun)
2949             || !TARGET_MEMORY_MISMATCH_STALL
2950             || reload_in_progress || reload_completed)
2951            && memory_operand (operands[0], DFmode)))"
2952 {
2953   switch (which_alternative)
2954     {
2955     case 0:
2956     case 1:
2957       return output_387_reg_move (insn, operands);
2958
2959     case 2:
2960       return standard_80387_constant_opcode (operands[1]);
2961
2962     case 3:
2963     case 4:
2964       return "#";
2965     case 5:
2966       switch (get_attr_mode (insn))
2967         {
2968         case MODE_V4SF:
2969           return "%vxorps\t%0, %d0";
2970         case MODE_V2DF:
2971           return "%vxorpd\t%0, %d0";
2972         case MODE_TI:
2973           return "%vpxor\t%0, %d0";
2974         default:
2975           gcc_unreachable ();
2976         }
2977     case 6:
2978     case 7:
2979     case 8:
2980       switch (get_attr_mode (insn))
2981         {
2982         case MODE_V4SF:
2983           return "%vmovaps\t{%1, %0|%0, %1}";
2984         case MODE_V2DF:
2985           return "%vmovapd\t{%1, %0|%0, %1}";
2986         case MODE_TI:
2987           return "%vmovdqa\t{%1, %0|%0, %1}";
2988         case MODE_DI:
2989           return "%vmovq\t{%1, %0|%0, %1}";
2990         case MODE_DF:
2991           if (TARGET_AVX)
2992             {
2993               if (REG_P (operands[0]) && REG_P (operands[1]))
2994                 return "vmovsd\t{%1, %0, %0|%0, %0, %1}";
2995               else
2996                 return "vmovsd\t{%1, %0|%0, %1}";
2997             }
2998           else
2999             return "movsd\t{%1, %0|%0, %1}";
3000         case MODE_V1DF:
3001           if (TARGET_AVX)
3002             {
3003               if (REG_P (operands[0]))
3004                 return "vmovlpd\t{%1, %0, %0|%0, %0, %1}";
3005               else
3006                 return "vmovlpd\t{%1, %0|%0, %1}";
3007             }
3008           else
3009             return "movlpd\t{%1, %0|%0, %1}";
3010         case MODE_V2SF:
3011           if (TARGET_AVX)
3012             {
3013               if (REG_P (operands[0]))
3014                 return "vmovlps\t{%1, %0, %0|%0, %0, %1}";
3015               else
3016                 return "vmovlps\t{%1, %0|%0, %1}";
3017             }
3018           else
3019             return "movlps\t{%1, %0|%0, %1}";
3020         default:
3021           gcc_unreachable ();
3022         }
3023
3024     default:
3025       gcc_unreachable ();
3026     }
3027 }
3028   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov")
3029    (set (attr "prefix")
3030      (if_then_else (eq_attr "alternative" "0,1,2,3,4")
3031        (const_string "orig")
3032        (const_string "maybe_vex")))
3033    (set (attr "mode")
3034         (cond [(eq_attr "alternative" "0,1,2")
3035                  (const_string "DF")
3036                (eq_attr "alternative" "3,4")
3037                  (const_string "SI")
3038
3039                /* For SSE1, we have many fewer alternatives.  */
3040                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
3041                  (cond [(eq_attr "alternative" "5,6")
3042                           (const_string "V4SF")
3043                        ]
3044                    (const_string "V2SF"))
3045
3046                /* xorps is one byte shorter.  */
3047                (eq_attr "alternative" "5")
3048                  (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3049                             (const_int 0))
3050                           (const_string "V4SF")
3051                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3052                             (const_int 0))
3053                           (const_string "TI")
3054                        ]
3055                        (const_string "V2DF"))
3056
3057                /* For architectures resolving dependencies on
3058                   whole SSE registers use APD move to break dependency
3059                   chains, otherwise use short move to avoid extra work.
3060
3061                   movaps encodes one byte shorter.  */
3062                (eq_attr "alternative" "6")
3063                  (cond
3064                    [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3065                         (const_int 0))
3066                       (const_string "V4SF")
3067                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3068                         (const_int 0))
3069                       (const_string "V2DF")
3070                    ]
3071                    (const_string "DF"))
3072                /* For architectures resolving dependencies on register
3073                   parts we may avoid extra work to zero out upper part
3074                   of register.  */
3075                (eq_attr "alternative" "7")
3076                  (if_then_else
3077                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3078                        (const_int 0))
3079                    (const_string "V1DF")
3080                    (const_string "DF"))
3081               ]
3082               (const_string "DF")))])
3083
3084 (define_insn "*movdf_integer_rex64"
3085   [(set (match_operand:DF 0 "nonimmediate_operand"
3086                 "=f,m,f,r  ,m ,Y2*x,Y2*x,Y2*x,m   ,Yi,r ")
3087         (match_operand:DF 1 "general_operand"
3088                 "fm,f,G,rmF,Fr,C   ,Y2*x,m   ,Y2*x,r ,Yi"))]
3089   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3090    && (reload_in_progress || reload_completed
3091        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3092        || (!(TARGET_SSE2 && TARGET_SSE_MATH)
3093            && optimize_function_for_size_p (cfun)
3094            && standard_80387_constant_p (operands[1]))
3095        || GET_CODE (operands[1]) != CONST_DOUBLE
3096        || memory_operand (operands[0], DFmode))"
3097 {
3098   switch (which_alternative)
3099     {
3100     case 0:
3101     case 1:
3102       return output_387_reg_move (insn, operands);
3103
3104     case 2:
3105       return standard_80387_constant_opcode (operands[1]);
3106
3107     case 3:
3108     case 4:
3109       return "#";
3110
3111     case 5:
3112       switch (get_attr_mode (insn))
3113         {
3114         case MODE_V4SF:
3115           return "%vxorps\t%0, %d0";
3116         case MODE_V2DF:
3117           return "%vxorpd\t%0, %d0";
3118         case MODE_TI:
3119           return "%vpxor\t%0, %d0";
3120         default:
3121           gcc_unreachable ();
3122         }
3123     case 6:
3124     case 7:
3125     case 8:
3126       switch (get_attr_mode (insn))
3127         {
3128         case MODE_V4SF:
3129           return "%vmovaps\t{%1, %0|%0, %1}";
3130         case MODE_V2DF:
3131           return "%vmovapd\t{%1, %0|%0, %1}";
3132         case MODE_TI:
3133           return "%vmovdqa\t{%1, %0|%0, %1}";
3134         case MODE_DI:
3135           return "%vmovq\t{%1, %0|%0, %1}";
3136         case MODE_DF:
3137           if (TARGET_AVX)
3138             {
3139               if (REG_P (operands[0]) && REG_P (operands[1]))
3140                 return "vmovsd\t{%1, %0, %0|%0, %0, %1}";
3141               else
3142                 return "vmovsd\t{%1, %0|%0, %1}";
3143             }
3144           else
3145             return "movsd\t{%1, %0|%0, %1}";
3146         case MODE_V1DF:
3147           return "%vmovlpd\t{%1, %d0|%d0, %1}";
3148         case MODE_V2SF:
3149           return "%vmovlps\t{%1, %d0|%d0, %1}";
3150         default:
3151           gcc_unreachable ();
3152         }
3153
3154     case 9:
3155     case 10:
3156     return "%vmovd\t{%1, %0|%0, %1}";
3157
3158     default:
3159       gcc_unreachable();
3160     }
3161 }
3162   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov,ssemov,ssemov")
3163    (set (attr "prefix")
3164      (if_then_else (eq_attr "alternative" "0,1,2,3,4")
3165        (const_string "orig")
3166        (const_string "maybe_vex")))
3167    (set (attr "mode")
3168         (cond [(eq_attr "alternative" "0,1,2")
3169                  (const_string "DF")
3170                (eq_attr "alternative" "3,4,9,10")
3171                  (const_string "DI")
3172
3173                /* For SSE1, we have many fewer alternatives.  */
3174                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
3175                  (cond [(eq_attr "alternative" "5,6")
3176                           (const_string "V4SF")
3177                        ]
3178                    (const_string "V2SF"))
3179
3180                /* xorps is one byte shorter.  */
3181                (eq_attr "alternative" "5")
3182                  (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3183                             (const_int 0))
3184                           (const_string "V4SF")
3185                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3186                             (const_int 0))
3187                           (const_string "TI")
3188                        ]
3189                        (const_string "V2DF"))
3190
3191                /* For architectures resolving dependencies on
3192                   whole SSE registers use APD move to break dependency
3193                   chains, otherwise use short move to avoid extra work.
3194
3195                   movaps encodes one byte shorter.  */
3196                (eq_attr "alternative" "6")
3197                  (cond
3198                    [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3199                         (const_int 0))
3200                       (const_string "V4SF")
3201                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3202                         (const_int 0))
3203                       (const_string "V2DF")
3204                    ]
3205                    (const_string "DF"))
3206                /* For architectures resolving dependencies on register
3207                   parts we may avoid extra work to zero out upper part
3208                   of register.  */
3209                (eq_attr "alternative" "7")
3210                  (if_then_else
3211                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3212                        (const_int 0))
3213                    (const_string "V1DF")
3214                    (const_string "DF"))
3215               ]
3216               (const_string "DF")))])
3217
3218 (define_insn "*movdf_integer"
3219   [(set (match_operand:DF 0 "nonimmediate_operand"
3220                 "=f,m,f,r  ,o ,Y2*x,Y2*x,Y2*x,m   ")
3221         (match_operand:DF 1 "general_operand"
3222                 "fm,f,G,roF,Fr,C   ,Y2*x,m   ,Y2*x"))]
3223   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
3224    && optimize_function_for_speed_p (cfun)
3225    && TARGET_INTEGER_DFMODE_MOVES
3226    && (reload_in_progress || reload_completed
3227        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3228        || (!(TARGET_SSE2 && TARGET_SSE_MATH)
3229            && optimize_function_for_size_p (cfun)
3230            && standard_80387_constant_p (operands[1]))
3231        || GET_CODE (operands[1]) != CONST_DOUBLE
3232        || memory_operand (operands[0], DFmode))"
3233 {
3234   switch (which_alternative)
3235     {
3236     case 0:
3237     case 1:
3238       return output_387_reg_move (insn, operands);
3239
3240     case 2:
3241       return standard_80387_constant_opcode (operands[1]);
3242
3243     case 3:
3244     case 4:
3245       return "#";
3246
3247     case 5:
3248       switch (get_attr_mode (insn))
3249         {
3250         case MODE_V4SF:
3251           return "xorps\t%0, %0";
3252         case MODE_V2DF:
3253           return "xorpd\t%0, %0";
3254         case MODE_TI:
3255           return "pxor\t%0, %0";
3256         default:
3257           gcc_unreachable ();
3258         }
3259     case 6:
3260     case 7:
3261     case 8:
3262       switch (get_attr_mode (insn))
3263         {
3264         case MODE_V4SF:
3265           return "movaps\t{%1, %0|%0, %1}";
3266         case MODE_V2DF:
3267           return "movapd\t{%1, %0|%0, %1}";
3268         case MODE_TI:
3269           return "movdqa\t{%1, %0|%0, %1}";
3270         case MODE_DI:
3271           return "movq\t{%1, %0|%0, %1}";
3272         case MODE_DF:
3273           return "movsd\t{%1, %0|%0, %1}";
3274         case MODE_V1DF:
3275           return "movlpd\t{%1, %0|%0, %1}";
3276         case MODE_V2SF:
3277           return "movlps\t{%1, %0|%0, %1}";
3278         default:
3279           gcc_unreachable ();
3280         }
3281
3282     default:
3283       gcc_unreachable();
3284     }
3285 }
3286   [(set_attr "type" "fmov,fmov,fmov,multi,multi,sselog1,ssemov,ssemov,ssemov")
3287    (set (attr "mode")
3288         (cond [(eq_attr "alternative" "0,1,2")
3289                  (const_string "DF")
3290                (eq_attr "alternative" "3,4")
3291                  (const_string "SI")
3292
3293                /* For SSE1, we have many fewer alternatives.  */
3294                (eq (symbol_ref "TARGET_SSE2") (const_int 0))
3295                  (cond [(eq_attr "alternative" "5,6")
3296                           (const_string "V4SF")
3297                        ]
3298                    (const_string "V2SF"))
3299
3300                /* xorps is one byte shorter.  */
3301                (eq_attr "alternative" "5")
3302                  (cond [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3303                             (const_int 0))
3304                           (const_string "V4SF")
3305                         (ne (symbol_ref "TARGET_SSE_LOAD0_BY_PXOR")
3306                             (const_int 0))
3307                           (const_string "TI")
3308                        ]
3309                        (const_string "V2DF"))
3310
3311                /* For architectures resolving dependencies on
3312                   whole SSE registers use APD move to break dependency
3313                   chains, otherwise use short move to avoid extra work.
3314
3315                   movaps encodes one byte shorter.  */
3316                (eq_attr "alternative" "6")
3317                  (cond
3318                    [(ne (symbol_ref "optimize_function_for_size_p (cfun)")
3319                         (const_int 0))
3320                       (const_string "V4SF")
3321                     (ne (symbol_ref "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3322                         (const_int 0))
3323                       (const_string "V2DF")
3324                    ]
3325                    (const_string "DF"))
3326                /* For architectures resolving dependencies on register
3327                   parts we may avoid extra work to zero out upper part
3328                   of register.  */
3329                (eq_attr "alternative" "7")
3330                  (if_then_else
3331                    (ne (symbol_ref "TARGET_SSE_SPLIT_REGS")
3332                        (const_int 0))
3333                    (const_string "V1DF")
3334                    (const_string "DF"))
3335               ]
3336               (const_string "DF")))])
3337
3338 (define_split
3339   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3340         (match_operand:DF 1 "general_operand" ""))]
3341   "reload_completed
3342    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3343    && ! (ANY_FP_REG_P (operands[0]) ||
3344          (GET_CODE (operands[0]) == SUBREG
3345           && ANY_FP_REG_P (SUBREG_REG (operands[0]))))
3346    && ! (ANY_FP_REG_P (operands[1]) ||
3347          (GET_CODE (operands[1]) == SUBREG
3348           && ANY_FP_REG_P (SUBREG_REG (operands[1]))))"
3349   [(const_int 0)]
3350   "ix86_split_long_move (operands); DONE;")
3351
3352 (define_insn "*swapdf"
3353   [(set (match_operand:DF 0 "fp_register_operand" "+f")
3354         (match_operand:DF 1 "fp_register_operand" "+f"))
3355    (set (match_dup 1)
3356         (match_dup 0))]
3357   "reload_completed || TARGET_80387"
3358 {
3359   if (STACK_TOP_P (operands[0]))
3360     return "fxch\t%1";
3361   else
3362     return "fxch\t%0";
3363 }
3364   [(set_attr "type" "fxch")
3365    (set_attr "mode" "DF")])
3366
3367 (define_expand "movxf"
3368   [(set (match_operand:XF 0 "nonimmediate_operand" "")
3369         (match_operand:XF 1 "general_operand" ""))]
3370   ""
3371   "ix86_expand_move (XFmode, operands); DONE;")
3372
3373 ;; Size of pushdf is 3 (for sub) + 2 (for fstp) + memory operand size.
3374 ;; Size of pushdf using integer instructions is 3+3*memory operand size
3375 ;; Pushing using integer instructions is longer except for constants
3376 ;; and direct memory references.
3377 ;; (assuming that any given constant is pushed only once, but this ought to be
3378 ;;  handled elsewhere).
3379
3380 (define_insn "*pushxf_nointeger"
3381   [(set (match_operand:XF 0 "push_operand" "=X,X,X")
3382         (match_operand:XF 1 "general_no_elim_operand" "f,Fo,*r"))]
3383   "optimize_function_for_size_p (cfun)"
3384 {
3385   /* This insn should be already split before reg-stack.  */
3386   gcc_unreachable ();
3387 }
3388   [(set_attr "type" "multi")
3389    (set_attr "unit" "i387,*,*")
3390    (set_attr "mode" "XF,SI,SI")])
3391
3392 (define_insn "*pushxf_integer"
3393   [(set (match_operand:XF 0 "push_operand" "=<,<")
3394         (match_operand:XF 1 "general_no_elim_operand" "f,ro"))]
3395   "optimize_function_for_speed_p (cfun)"
3396 {
3397   /* This insn should be already split before reg-stack.  */
3398   gcc_unreachable ();
3399 }
3400   [(set_attr "type" "multi")
3401    (set_attr "unit" "i387,*")
3402    (set_attr "mode" "XF,SI")])
3403
3404 (define_split
3405   [(set (match_operand 0 "push_operand" "")
3406         (match_operand 1 "general_operand" ""))]
3407   "reload_completed
3408    && (GET_MODE (operands[0]) == XFmode
3409        || GET_MODE (operands[0]) == DFmode)
3410    && !ANY_FP_REG_P (operands[1])"
3411   [(const_int 0)]
3412   "ix86_split_long_move (operands); DONE;")
3413
3414 (define_split
3415   [(set (match_operand:XF 0 "push_operand" "")
3416         (match_operand:XF 1 "any_fp_register_operand" ""))]
3417   ""
3418   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
3419    (set (mem:XF (reg:P SP_REG)) (match_dup 1))]
3420   "operands[2] = GEN_INT (TARGET_128BIT_LONG_DOUBLE ? -16 : -12);")
3421
3422 ;; Do not use integer registers when optimizing for size
3423 (define_insn "*movxf_nointeger"
3424   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,*r,o")
3425         (match_operand:XF 1 "general_operand" "fm,f,G,*roF,F*r"))]
3426   "optimize_function_for_size_p (cfun)
3427    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3428    && (reload_in_progress || reload_completed
3429        || standard_80387_constant_p (operands[1])
3430        || GET_CODE (operands[1]) != CONST_DOUBLE
3431        || memory_operand (operands[0], XFmode))"
3432 {
3433   switch (which_alternative)
3434     {
3435     case 0:
3436     case 1:
3437       return output_387_reg_move (insn, operands);
3438
3439     case 2:
3440       return standard_80387_constant_opcode (operands[1]);
3441
3442     case 3: case 4:
3443       return "#";
3444     default:
3445       gcc_unreachable ();
3446     }
3447 }
3448   [(set_attr "type" "fmov,fmov,fmov,multi,multi")
3449    (set_attr "mode" "XF,XF,XF,SI,SI")])
3450
3451 (define_insn "*movxf_integer"
3452   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,r,o")
3453         (match_operand:XF 1 "general_operand" "fm,f,G,roF,Fr"))]
3454   "optimize_function_for_speed_p (cfun)
3455    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3456    && (reload_in_progress || reload_completed
3457        || GET_CODE (operands[1]) != CONST_DOUBLE
3458        || memory_operand (operands[0], XFmode))"
3459 {
3460   switch (which_alternative)
3461     {
3462     case 0:
3463     case 1:
3464       return output_387_reg_move (insn, operands);
3465
3466     case 2:
3467       return standard_80387_constant_opcode (operands[1]);
3468
3469     case 3: case 4:
3470       return "#";
3471
3472     default:
3473       gcc_unreachable ();
3474     }
3475 }
3476   [(set_attr "type" "fmov,fmov,fmov,multi,multi")
3477    (set_attr "mode" "XF,XF,XF,SI,SI")])
3478
3479 (define_expand "movtf"
3480   [(set (match_operand:TF 0 "nonimmediate_operand" "")
3481         (match_operand:TF 1 "nonimmediate_operand" ""))]
3482   "TARGET_SSE2"
3483 {
3484   ix86_expand_move (TFmode, operands);
3485   DONE;
3486 })
3487
3488 (define_insn "*movtf_internal"
3489   [(set (match_operand:TF 0 "nonimmediate_operand" "=x,m,x,?r,?o")
3490         (match_operand:TF 1 "general_operand" "xm,x,C,roF,Fr"))]
3491   "TARGET_SSE2
3492    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
3493 {
3494   switch (which_alternative)
3495     {
3496     case 0:
3497     case 1:
3498       if (get_attr_mode (insn) == MODE_V4SF)
3499         return "%vmovaps\t{%1, %0|%0, %1}";
3500       else
3501         return "%vmovdqa\t{%1, %0|%0, %1}";
3502     case 2:
3503       if (get_attr_mode (insn) == MODE_V4SF)
3504         return "%vxorps\t%0, %d0";
3505       else
3506         return "%vpxor\t%0, %d0";
3507     case 3:
3508     case 4:
3509         return "#";
3510     default:
3511       gcc_unreachable ();
3512     }
3513 }
3514   [(set_attr "type" "ssemov,ssemov,sselog1,*,*")
3515    (set_attr "prefix" "maybe_vex,maybe_vex,maybe_vex,*,*")
3516    (set (attr "mode")
3517         (cond [(eq_attr "alternative" "0,2")
3518                  (if_then_else
3519                    (ne (symbol_ref "optimize_function_for_size_p (cfun)")
3520                        (const_int 0))
3521                    (const_string "V4SF")
3522                    (const_string "TI"))
3523                (eq_attr "alternative" "1")
3524                  (if_then_else
3525                    (ior (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
3526                             (const_int 0))
3527                         (ne (symbol_ref "optimize_function_for_size_p (cfun)")
3528                             (const_int 0)))
3529                    (const_string "V4SF")
3530                    (const_string "TI"))]
3531                (const_string "DI")))])
3532
3533 (define_insn "*pushtf_sse"
3534   [(set (match_operand:TF 0 "push_operand" "=<,<,<")
3535         (match_operand:TF 1 "general_no_elim_operand" "x,Fo,*r"))]
3536   "TARGET_SSE2"
3537 {
3538   /* This insn should be already split before reg-stack.  */
3539   gcc_unreachable ();
3540 }
3541   [(set_attr "type" "multi")
3542    (set_attr "unit" "sse,*,*")
3543    (set_attr "mode" "TF,SI,SI")])
3544
3545 (define_split
3546   [(set (match_operand:TF 0 "push_operand" "")
3547         (match_operand:TF 1 "general_operand" ""))]
3548   "TARGET_SSE2 && reload_completed
3549    && !SSE_REG_P (operands[1])"
3550   [(const_int 0)]
3551   "ix86_split_long_move (operands); DONE;")
3552
3553 (define_split
3554   [(set (match_operand:TF 0 "push_operand" "")
3555         (match_operand:TF 1 "any_fp_register_operand" ""))]
3556   "TARGET_SSE2"
3557   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -16)))
3558    (set (mem:TF (reg:P SP_REG)) (match_dup 1))]
3559   "")
3560
3561 (define_split
3562   [(set (match_operand 0 "nonimmediate_operand" "")
3563         (match_operand 1 "general_operand" ""))]
3564   "reload_completed
3565    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3566    && GET_MODE (operands[0]) == XFmode
3567    && ! (ANY_FP_REG_P (operands[0]) ||
3568          (GET_CODE (operands[0]) == SUBREG
3569           && ANY_FP_REG_P (SUBREG_REG (operands[0]))))
3570    && ! (ANY_FP_REG_P (operands[1]) ||
3571          (GET_CODE (operands[1]) == SUBREG
3572           && ANY_FP_REG_P (SUBREG_REG (operands[1]))))"
3573   [(const_int 0)]
3574   "ix86_split_long_move (operands); DONE;")
3575
3576 (define_split
3577   [(set (match_operand 0 "register_operand" "")
3578         (match_operand 1 "memory_operand" ""))]
3579   "reload_completed
3580    && MEM_P (operands[1])
3581    && (GET_MODE (operands[0]) == TFmode
3582        || GET_MODE (operands[0]) == XFmode
3583        || GET_MODE (operands[0]) == SFmode
3584        || GET_MODE (operands[0]) == DFmode)
3585    && (operands[2] = find_constant_src (insn))"
3586   [(set (match_dup 0) (match_dup 2))]
3587 {
3588   rtx c = operands[2];
3589   rtx r = operands[0];
3590
3591   if (GET_CODE (r) == SUBREG)
3592     r = SUBREG_REG (r);
3593
3594   if (SSE_REG_P (r))
3595     {
3596       if (!standard_sse_constant_p (c))
3597         FAIL;
3598     }
3599   else if (FP_REG_P (r))
3600     {
3601       if (!standard_80387_constant_p (c))
3602         FAIL;
3603     }
3604   else if (MMX_REG_P (r))
3605     FAIL;
3606 })
3607
3608 (define_split
3609   [(set (match_operand 0 "register_operand" "")
3610         (float_extend (match_operand 1 "memory_operand" "")))]
3611   "reload_completed
3612    && MEM_P (operands[1])
3613    && (GET_MODE (operands[0]) == TFmode
3614        || GET_MODE (operands[0]) == XFmode
3615        || GET_MODE (operands[0]) == SFmode
3616        || GET_MODE (operands[0]) == DFmode)
3617    && (operands[2] = find_constant_src (insn))"
3618   [(set (match_dup 0) (match_dup 2))]
3619 {
3620   rtx c = operands[2];
3621   rtx r = operands[0];
3622
3623   if (GET_CODE (r) == SUBREG)
3624     r = SUBREG_REG (r);
3625
3626   if (SSE_REG_P (r))
3627     {
3628       if (!standard_sse_constant_p (c))
3629         FAIL;
3630     }
3631   else if (FP_REG_P (r))
3632     {
3633       if (!standard_80387_constant_p (c))
3634         FAIL;
3635     }
3636   else if (MMX_REG_P (r))
3637     FAIL;
3638 })
3639
3640 (define_insn "swapxf"
3641   [(set (match_operand:XF 0 "register_operand" "+f")
3642         (match_operand:XF 1 "register_operand" "+f"))
3643    (set (match_dup 1)
3644         (match_dup 0))]
3645   "TARGET_80387"
3646 {
3647   if (STACK_TOP_P (operands[0]))
3648     return "fxch\t%1";
3649   else
3650     return "fxch\t%0";
3651 }
3652   [(set_attr "type" "fxch")
3653    (set_attr "mode" "XF")])
3654
3655 ;; Split the load of -0.0 or -1.0 into fldz;fchs or fld1;fchs sequence
3656 (define_split
3657   [(set (match_operand:X87MODEF 0 "register_operand" "")
3658         (match_operand:X87MODEF 1 "immediate_operand" ""))]
3659   "reload_completed && FP_REGNO_P (REGNO (operands[0]))
3660    && (standard_80387_constant_p (operands[1]) == 8
3661        || standard_80387_constant_p (operands[1]) == 9)"
3662   [(set (match_dup 0)(match_dup 1))
3663    (set (match_dup 0)
3664         (neg:X87MODEF (match_dup 0)))]
3665 {
3666   REAL_VALUE_TYPE r;
3667
3668   REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
3669   if (real_isnegzero (&r))
3670     operands[1] = CONST0_RTX (<MODE>mode);
3671   else
3672     operands[1] = CONST1_RTX (<MODE>mode);
3673 })
3674
3675 (define_split
3676   [(set (match_operand:TF 0 "nonimmediate_operand" "")
3677         (match_operand:TF 1 "general_operand" ""))]
3678   "reload_completed
3679    && !(SSE_REG_P (operands[0]) || SSE_REG_P (operands[1]))"
3680   [(const_int 0)]
3681   "ix86_split_long_move (operands); DONE;")
3682 \f
3683 ;; Zero extension instructions
3684
3685 (define_expand "zero_extendhisi2"
3686   [(set (match_operand:SI 0 "register_operand" "")
3687      (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "")))]
3688   ""
3689 {
3690   if (TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun))
3691     {
3692       operands[1] = force_reg (HImode, operands[1]);
3693       emit_insn (gen_zero_extendhisi2_and (operands[0], operands[1]));
3694       DONE;
3695     }
3696 })
3697
3698 (define_insn "zero_extendhisi2_and"
3699   [(set (match_operand:SI 0 "register_operand" "=r")
3700      (zero_extend:SI (match_operand:HI 1 "register_operand" "0")))
3701    (clobber (reg:CC FLAGS_REG))]
3702   "TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun)"
3703   "#"
3704   [(set_attr "type" "alu1")
3705    (set_attr "mode" "SI")])
3706
3707 (define_split
3708   [(set (match_operand:SI 0 "register_operand" "")
3709         (zero_extend:SI (match_operand:HI 1 "register_operand" "")))
3710    (clobber (reg:CC FLAGS_REG))]
3711   "reload_completed && TARGET_ZERO_EXTEND_WITH_AND
3712    && optimize_function_for_speed_p (cfun)"
3713   [(parallel [(set (match_dup 0) (and:SI (match_dup 0) (const_int 65535)))
3714               (clobber (reg:CC FLAGS_REG))])]
3715   "")
3716
3717 (define_insn "*zero_extendhisi2_movzwl"
3718   [(set (match_operand:SI 0 "register_operand" "=r")
3719      (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "rm")))]
3720   "!TARGET_ZERO_EXTEND_WITH_AND
3721    || optimize_function_for_size_p (cfun)"
3722   "movz{wl|x}\t{%1, %0|%0, %1}"
3723   [(set_attr "type" "imovx")
3724    (set_attr "mode" "SI")])
3725
3726 (define_expand "zero_extendqihi2"
3727   [(parallel
3728     [(set (match_operand:HI 0 "register_operand" "")
3729        (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "")))
3730      (clobber (reg:CC FLAGS_REG))])]
3731   ""
3732   "")
3733
3734 (define_insn "*zero_extendqihi2_and"
3735   [(set (match_operand:HI 0 "register_operand" "=r,?&q")
3736      (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "0,qm")))
3737    (clobber (reg:CC FLAGS_REG))]
3738   "TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun)"
3739   "#"
3740   [(set_attr "type" "alu1")
3741    (set_attr "mode" "HI")])
3742
3743 (define_insn "*zero_extendqihi2_movzbw_and"
3744   [(set (match_operand:HI 0 "register_operand" "=r,r")
3745      (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "qm,0")))
3746    (clobber (reg:CC FLAGS_REG))]
3747   "!TARGET_ZERO_EXTEND_WITH_AND || optimize_function_for_size_p (cfun)"
3748   "#"
3749   [(set_attr "type" "imovx,alu1")
3750    (set_attr "mode" "HI")])
3751
3752 ; zero extend to SImode here to avoid partial register stalls
3753 (define_insn "*zero_extendqihi2_movzbl"
3754   [(set (match_operand:HI 0 "register_operand" "=r")
3755      (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "qm")))]
3756   "(!TARGET_ZERO_EXTEND_WITH_AND || optimize_function_for_size_p (cfun))
3757    && reload_completed"
3758   "movz{bl|x}\t{%1, %k0|%k0, %1}"
3759   [(set_attr "type" "imovx")
3760    (set_attr "mode" "SI")])
3761
3762 ;; For the movzbw case strip only the clobber
3763 (define_split
3764   [(set (match_operand:HI 0 "register_operand" "")
3765         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "")))
3766    (clobber (reg:CC FLAGS_REG))]
3767   "reload_completed
3768    && (!TARGET_ZERO_EXTEND_WITH_AND
3769        || optimize_function_for_size_p (cfun))
3770    && (!REG_P (operands[1]) || ANY_QI_REG_P (operands[1]))"
3771   [(set (match_operand:HI 0 "register_operand" "")
3772         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "")))])
3773
3774 ;; When source and destination does not overlap, clear destination
3775 ;; first and then do the movb
3776 (define_split
3777   [(set (match_operand:HI 0 "register_operand" "")
3778         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "")))
3779    (clobber (reg:CC FLAGS_REG))]
3780   "reload_completed
3781    && ANY_QI_REG_P (operands[0])
3782    && (TARGET_ZERO_EXTEND_WITH_AND
3783        && optimize_function_for_speed_p (cfun))
3784    && !reg_overlap_mentioned_p (operands[0], operands[1])"
3785   [(set (match_dup 0) (const_int 0))
3786    (set (strict_low_part (match_dup 2)) (match_dup 1))]
3787   "operands[2] = gen_lowpart (QImode, operands[0]);")
3788
3789 ;; Rest is handled by single and.
3790 (define_split
3791   [(set (match_operand:HI 0 "register_operand" "")
3792         (zero_extend:HI (match_operand:QI 1 "register_operand" "")))
3793    (clobber (reg:CC FLAGS_REG))]
3794   "reload_completed
3795    && true_regnum (operands[0]) == true_regnum (operands[1])"
3796   [(parallel [(set (match_dup 0) (and:HI (match_dup 0) (const_int 255)))
3797               (clobber (reg:CC FLAGS_REG))])]
3798   "")
3799
3800 (define_expand "zero_extendqisi2"
3801   [(parallel
3802     [(set (match_operand:SI 0 "register_operand" "")
3803        (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "")))
3804      (clobber (reg:CC FLAGS_REG))])]
3805   ""
3806   "")
3807
3808 (define_insn "*zero_extendqisi2_and"
3809   [(set (match_operand:SI 0 "register_operand" "=r,?&q")
3810      (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "0,qm")))
3811    (clobber (reg:CC FLAGS_REG))]
3812   "TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun)"
3813   "#"
3814   [(set_attr "type" "alu1")
3815    (set_attr "mode" "SI")])
3816
3817 (define_insn "*zero_extendqisi2_movzbw_and"
3818   [(set (match_operand:SI 0 "register_operand" "=r,r")
3819      (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "qm,0")))
3820    (clobber (reg:CC FLAGS_REG))]
3821   "!TARGET_ZERO_EXTEND_WITH_AND || optimize_function_for_size_p (cfun)"
3822   "#"
3823   [(set_attr "type" "imovx,alu1")
3824    (set_attr "mode" "SI")])
3825
3826 (define_insn "*zero_extendqisi2_movzbw"
3827   [(set (match_operand:SI 0 "register_operand" "=r")
3828      (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "qm")))]
3829   "(!TARGET_ZERO_EXTEND_WITH_AND || optimize_function_for_size_p (cfun))
3830    && reload_completed"
3831   "movz{bl|x}\t{%1, %0|%0, %1}"
3832   [(set_attr "type" "imovx")
3833    (set_attr "mode" "SI")])
3834
3835 ;; For the movzbl case strip only the clobber
3836 (define_split
3837   [(set (match_operand:SI 0 "register_operand" "")
3838         (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "")))
3839    (clobber (reg:CC FLAGS_REG))]
3840   "reload_completed
3841    && (!TARGET_ZERO_EXTEND_WITH_AND || optimize_function_for_size_p (cfun))
3842    && (!REG_P (operands[1]) || ANY_QI_REG_P (operands[1]))"
3843   [(set (match_dup 0)
3844         (zero_extend:SI (match_dup 1)))])
3845
3846 ;; When source and destination does not overlap, clear destination
3847 ;; first and then do the movb
3848 (define_split
3849   [(set (match_operand:SI 0 "register_operand" "")
3850         (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "")))
3851    (clobber (reg:CC FLAGS_REG))]
3852   "reload_completed
3853    && ANY_QI_REG_P (operands[0])
3854    && (ANY_QI_REG_P (operands[1]) || MEM_P (operands[1]))
3855    && (TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun))
3856    && !reg_overlap_mentioned_p (operands[0], operands[1])"
3857   [(set (match_dup 0) (const_int 0))
3858    (set (strict_low_part (match_dup 2)) (match_dup 1))]
3859   "operands[2] = gen_lowpart (QImode, operands[0]);")
3860
3861 ;; Rest is handled by single and.
3862 (define_split
3863   [(set (match_operand:SI 0 "register_operand" "")
3864         (zero_extend:SI (match_operand:QI 1 "register_operand" "")))
3865    (clobber (reg:CC FLAGS_REG))]
3866   "reload_completed
3867    && true_regnum (operands[0]) == true_regnum (operands[1])"
3868   [(parallel [(set (match_dup 0) (and:SI (match_dup 0) (const_int 255)))
3869               (clobber (reg:CC FLAGS_REG))])]
3870   "")
3871
3872 ;; %%% Kill me once multi-word ops are sane.
3873 (define_expand "zero_extendsidi2"
3874   [(set (match_operand:DI 0 "register_operand" "")
3875      (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))]
3876   ""
3877 {
3878   if (!TARGET_64BIT)
3879     {
3880       emit_insn (gen_zero_extendsidi2_32 (operands[0], operands[1]));
3881       DONE;
3882     }
3883 })
3884
3885 (define_insn "zero_extendsidi2_32"
3886   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,?r,?o,?*Ym,?*y,?*Yi,*Y2")
3887         (zero_extend:DI
3888          (match_operand:SI 1 "nonimmediate_operand" "0,rm,r ,r   ,m  ,r   ,m")))
3889    (clobber (reg:CC FLAGS_REG))]
3890   "!TARGET_64BIT"