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