OSDN Git Service

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