OSDN Git Service

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