OSDN Git Service

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