OSDN Git Service

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