OSDN Git Service

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