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