OSDN Git Service

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