OSDN Git Service

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