OSDN Git Service

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