OSDN Git Service

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