OSDN Git Service

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