OSDN Git Service

* config/i386/i386.md (shift_insn): Rename code attribute from
[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_VPERMTI
239   UNSPEC_GATHER
240   UNSPEC_VSIBADDR
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 max and min
755 (define_code_iterator maxmin [smax smin umax umin])
756
757 ;; Mapping of signed max and min
758 (define_code_iterator smaxmin [smax smin])
759
760 ;; Mapping of unsigned max and min
761 (define_code_iterator umaxmin [umax umin])
762
763 ;; Base name for integer and FP insn mnemonic
764 (define_code_attr maxmin_int [(smax "maxs") (smin "mins")
765                               (umax "maxu") (umin "minu")])
766 (define_code_attr maxmin_float [(smax "max") (smin "min")])
767
768 ;; Mapping of logic operators
769 (define_code_iterator any_logic [and ior xor])
770 (define_code_iterator any_or [ior xor])
771
772 ;; Base name for insn mnemonic.
773 (define_code_attr logic [(and "and") (ior "or") (xor "xor")])
774
775 ;; Mapping of logic-shift operators
776 (define_code_iterator any_lshift [ashift lshiftrt])
777
778 ;; Mapping of shift-right operators
779 (define_code_iterator any_shiftrt [lshiftrt ashiftrt])
780
781 ;; Base name for define_insn
782 (define_code_attr shift_insn
783   [(ashift "ashl") (lshiftrt "lshr") (ashiftrt "ashr")])
784
785 ;; Base name for insn mnemonic.
786 (define_code_attr shift [(ashift "sll") (lshiftrt "shr") (ashiftrt "sar")])
787 (define_code_attr vshift [(ashift "sll") (lshiftrt "srl") (ashiftrt "sra")])
788
789 ;; Mapping of rotate operators
790 (define_code_iterator any_rotate [rotate rotatert])
791
792 ;; Base name for define_insn
793 (define_code_attr rotate_insn [(rotate "rotl") (rotatert "rotr")])
794
795 ;; Base name for insn mnemonic.
796 (define_code_attr rotate [(rotate "rol") (rotatert "ror")])
797
798 ;; Mapping of abs neg operators
799 (define_code_iterator absneg [abs neg])
800
801 ;; Base name for x87 insn mnemonic.
802 (define_code_attr absneg_mnemonic [(abs "abs") (neg "chs")])
803
804 ;; Used in signed and unsigned widening multiplications.
805 (define_code_iterator any_extend [sign_extend zero_extend])
806
807 ;; Prefix for insn menmonic.
808 (define_code_attr sgnprefix [(sign_extend "i") (zero_extend "")])
809
810 ;; Prefix for define_insn
811 (define_code_attr u [(sign_extend "") (zero_extend "u")])
812 (define_code_attr s [(sign_extend "s") (zero_extend "u")])
813
814 ;; All integer modes.
815 (define_mode_iterator SWI1248x [QI HI SI DI])
816
817 ;; All integer modes without QImode.
818 (define_mode_iterator SWI248x [HI SI DI])
819
820 ;; All integer modes without QImode and HImode.
821 (define_mode_iterator SWI48x [SI DI])
822
823 ;; All integer modes without SImode and DImode.
824 (define_mode_iterator SWI12 [QI HI])
825
826 ;; All integer modes without DImode.
827 (define_mode_iterator SWI124 [QI HI SI])
828
829 ;; All integer modes without QImode and DImode.
830 (define_mode_iterator SWI24 [HI SI])
831
832 ;; Single word integer modes.
833 (define_mode_iterator SWI [QI HI SI (DI "TARGET_64BIT")])
834
835 ;; Single word integer modes without QImode.
836 (define_mode_iterator SWI248 [HI SI (DI "TARGET_64BIT")])
837
838 ;; Single word integer modes without QImode and HImode.
839 (define_mode_iterator SWI48 [SI (DI "TARGET_64BIT")])
840
841 ;; All math-dependant single and double word integer modes.
842 (define_mode_iterator SDWIM [(QI "TARGET_QIMODE_MATH")
843                              (HI "TARGET_HIMODE_MATH")
844                              SI DI (TI "TARGET_64BIT")])
845
846 ;; Math-dependant single word integer modes.
847 (define_mode_iterator SWIM [(QI "TARGET_QIMODE_MATH")
848                             (HI "TARGET_HIMODE_MATH")
849                             SI (DI "TARGET_64BIT")])
850
851 ;; Math-dependant integer modes without DImode.
852 (define_mode_iterator SWIM124 [(QI "TARGET_QIMODE_MATH")
853                                (HI "TARGET_HIMODE_MATH")
854                                SI])
855
856 ;; Math-dependant single word integer modes without QImode.
857 (define_mode_iterator SWIM248 [(HI "TARGET_HIMODE_MATH")
858                                SI (DI "TARGET_64BIT")])
859
860 ;; Double word integer modes.
861 (define_mode_iterator DWI [(DI "!TARGET_64BIT")
862                            (TI "TARGET_64BIT")])
863
864 ;; Double word integer modes as mode attribute.
865 (define_mode_attr DWI [(SI "DI") (DI "TI")])
866 (define_mode_attr dwi [(SI "di") (DI "ti")])
867
868 ;; Half mode for double word integer modes.
869 (define_mode_iterator DWIH [(SI "!TARGET_64BIT")
870                             (DI "TARGET_64BIT")])
871
872 ;; Instruction suffix for integer modes.
873 (define_mode_attr imodesuffix [(QI "b") (HI "w") (SI "l") (DI "q")])
874
875 ;; Pointer size prefix for integer modes (Intel asm dialect)
876 (define_mode_attr iptrsize [(QI "BYTE")
877                             (HI "WORD")
878                             (SI "DWORD")
879                             (DI "QWORD")])
880
881 ;; Register class for integer modes.
882 (define_mode_attr r [(QI "q") (HI "r") (SI "r") (DI "r")])
883
884 ;; Immediate operand constraint for integer modes.
885 (define_mode_attr i [(QI "n") (HI "n") (SI "e") (DI "e")])
886
887 ;; General operand constraint for word modes.
888 (define_mode_attr g [(QI "qmn") (HI "rmn") (SI "rme") (DI "rme")])
889
890 ;; Immediate operand constraint for double integer modes.
891 (define_mode_attr di [(SI "nF") (DI "e")])
892
893 ;; Immediate operand constraint for shifts.
894 (define_mode_attr S [(QI "I") (HI "I") (SI "I") (DI "J") (TI "O")])
895
896 ;; General operand predicate for integer modes.
897 (define_mode_attr general_operand
898         [(QI "general_operand")
899          (HI "general_operand")
900          (SI "x86_64_general_operand")
901          (DI "x86_64_general_operand")
902          (TI "x86_64_general_operand")])
903
904 ;; General sign/zero extend operand predicate for integer modes.
905 (define_mode_attr general_szext_operand
906         [(QI "general_operand")
907          (HI "general_operand")
908          (SI "x86_64_szext_general_operand")
909          (DI "x86_64_szext_general_operand")])
910
911 ;; Immediate operand predicate for integer modes.
912 (define_mode_attr immediate_operand
913         [(QI "immediate_operand")
914          (HI "immediate_operand")
915          (SI "x86_64_immediate_operand")
916          (DI "x86_64_immediate_operand")])
917
918 ;; Nonmemory operand predicate for integer modes.
919 (define_mode_attr nonmemory_operand
920         [(QI "nonmemory_operand")
921          (HI "nonmemory_operand")
922          (SI "x86_64_nonmemory_operand")
923          (DI "x86_64_nonmemory_operand")])
924
925 ;; Operand predicate for shifts.
926 (define_mode_attr shift_operand
927         [(QI "nonimmediate_operand")
928          (HI "nonimmediate_operand")
929          (SI "nonimmediate_operand")
930          (DI "shiftdi_operand")
931          (TI "register_operand")])
932
933 ;; Operand predicate for shift argument.
934 (define_mode_attr shift_immediate_operand
935         [(QI "const_1_to_31_operand")
936          (HI "const_1_to_31_operand")
937          (SI "const_1_to_31_operand")
938          (DI "const_1_to_63_operand")])
939
940 ;; Input operand predicate for arithmetic left shifts.
941 (define_mode_attr ashl_input_operand
942         [(QI "nonimmediate_operand")
943          (HI "nonimmediate_operand")
944          (SI "nonimmediate_operand")
945          (DI "ashldi_input_operand")
946          (TI "reg_or_pm1_operand")])
947
948 ;; SSE and x87 SFmode and DFmode floating point modes
949 (define_mode_iterator MODEF [SF DF])
950
951 ;; All x87 floating point modes
952 (define_mode_iterator X87MODEF [SF DF XF])
953
954 ;; SSE instruction suffix for various modes
955 (define_mode_attr ssemodesuffix
956   [(SF "ss") (DF "sd")
957    (V8SF "ps") (V4DF "pd")
958    (V4SF "ps") (V2DF "pd")
959    (V16QI "b") (V8HI "w") (V4SI "d") (V2DI "q")
960    (V32QI "b") (V16HI "w") (V8SI "d") (V4DI "q")])
961
962 ;; SSE vector suffix for floating point modes
963 (define_mode_attr ssevecmodesuffix [(SF "ps") (DF "pd")])
964
965 ;; SSE vector mode corresponding to a scalar mode
966 (define_mode_attr ssevecmode
967   [(QI "V16QI") (HI "V8HI") (SI "V4SI") (DI "V2DI") (SF "V4SF") (DF "V2DF")])
968
969 ;; Instruction suffix for REX 64bit operators.
970 (define_mode_attr rex64suffix [(SI "") (DI "{q}")])
971
972 ;; This mode iterator allows :P to be used for patterns that operate on
973 ;; pointer-sized quantities.  Exactly one of the two alternatives will match.
974 (define_mode_iterator P [(SI "Pmode == SImode") (DI "Pmode == DImode")])
975
976 ;; This mode iterator allows :PTR to be used for patterns that operate on
977 ;; ptr_mode sized quantities.
978 (define_mode_iterator PTR
979   [(SI "ptr_mode == SImode") (DI "ptr_mode == DImode")])
980 \f
981 ;; Scheduling descriptions
982
983 (include "pentium.md")
984 (include "ppro.md")
985 (include "k6.md")
986 (include "athlon.md")
987 (include "bdver1.md")
988 (include "geode.md")
989 (include "atom.md")
990 (include "core2.md")
991
992 \f
993 ;; Operand and operator predicates and constraints
994
995 (include "predicates.md")
996 (include "constraints.md")
997
998 \f
999 ;; Compare and branch/compare and store instructions.
1000
1001 (define_expand "cbranch<mode>4"
1002   [(set (reg:CC FLAGS_REG)
1003         (compare:CC (match_operand:SDWIM 1 "nonimmediate_operand" "")
1004                     (match_operand:SDWIM 2 "<general_operand>" "")))
1005    (set (pc) (if_then_else
1006                (match_operator 0 "ordered_comparison_operator"
1007                 [(reg:CC FLAGS_REG) (const_int 0)])
1008                (label_ref (match_operand 3 "" ""))
1009                (pc)))]
1010   ""
1011 {
1012   if (MEM_P (operands[1]) && MEM_P (operands[2]))
1013     operands[1] = force_reg (<MODE>mode, operands[1]);
1014   ix86_expand_branch (GET_CODE (operands[0]),
1015                       operands[1], operands[2], operands[3]);
1016   DONE;
1017 })
1018
1019 (define_expand "cstore<mode>4"
1020   [(set (reg:CC FLAGS_REG)
1021         (compare:CC (match_operand:SWIM 2 "nonimmediate_operand" "")
1022                     (match_operand:SWIM 3 "<general_operand>" "")))
1023    (set (match_operand:QI 0 "register_operand" "")
1024         (match_operator 1 "ordered_comparison_operator"
1025           [(reg:CC FLAGS_REG) (const_int 0)]))]
1026   ""
1027 {
1028   if (MEM_P (operands[2]) && MEM_P (operands[3]))
1029     operands[2] = force_reg (<MODE>mode, operands[2]);
1030   ix86_expand_setcc (operands[0], GET_CODE (operands[1]),
1031                      operands[2], operands[3]);
1032   DONE;
1033 })
1034
1035 (define_expand "cmp<mode>_1"
1036   [(set (reg:CC FLAGS_REG)
1037         (compare:CC (match_operand:SWI48 0 "nonimmediate_operand" "")
1038                     (match_operand:SWI48 1 "<general_operand>" "")))])
1039
1040 (define_insn "*cmp<mode>_ccno_1"
1041   [(set (reg FLAGS_REG)
1042         (compare (match_operand:SWI 0 "nonimmediate_operand" "<r>,?m<r>")
1043                  (match_operand:SWI 1 "const0_operand" "")))]
1044   "ix86_match_ccmode (insn, CCNOmode)"
1045   "@
1046    test{<imodesuffix>}\t%0, %0
1047    cmp{<imodesuffix>}\t{%1, %0|%0, %1}"
1048   [(set_attr "type" "test,icmp")
1049    (set_attr "length_immediate" "0,1")
1050    (set_attr "mode" "<MODE>")])
1051
1052 (define_insn "*cmp<mode>_1"
1053   [(set (reg FLAGS_REG)
1054         (compare (match_operand:SWI 0 "nonimmediate_operand" "<r>m,<r>")
1055                  (match_operand:SWI 1 "<general_operand>" "<r><i>,<r>m")))]
1056   "ix86_match_ccmode (insn, CCmode)"
1057   "cmp{<imodesuffix>}\t{%1, %0|%0, %1}"
1058   [(set_attr "type" "icmp")
1059    (set_attr "mode" "<MODE>")])
1060
1061 (define_insn "*cmp<mode>_minus_1"
1062   [(set (reg FLAGS_REG)
1063         (compare
1064           (minus:SWI (match_operand:SWI 0 "nonimmediate_operand" "<r>m,<r>")
1065                      (match_operand:SWI 1 "<general_operand>" "<r><i>,<r>m"))
1066           (const_int 0)))]
1067   "ix86_match_ccmode (insn, CCGOCmode)"
1068   "cmp{<imodesuffix>}\t{%1, %0|%0, %1}"
1069   [(set_attr "type" "icmp")
1070    (set_attr "mode" "<MODE>")])
1071
1072 (define_insn "*cmpqi_ext_1"
1073   [(set (reg FLAGS_REG)
1074         (compare
1075           (match_operand:QI 0 "general_operand" "Qm")
1076           (subreg:QI
1077             (zero_extract:SI
1078               (match_operand 1 "ext_register_operand" "Q")
1079               (const_int 8)
1080               (const_int 8)) 0)))]
1081   "!TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1082   "cmp{b}\t{%h1, %0|%0, %h1}"
1083   [(set_attr "type" "icmp")
1084    (set_attr "mode" "QI")])
1085
1086 (define_insn "*cmpqi_ext_1_rex64"
1087   [(set (reg FLAGS_REG)
1088         (compare
1089           (match_operand:QI 0 "register_operand" "Q")
1090           (subreg:QI
1091             (zero_extract:SI
1092               (match_operand 1 "ext_register_operand" "Q")
1093               (const_int 8)
1094               (const_int 8)) 0)))]
1095   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1096   "cmp{b}\t{%h1, %0|%0, %h1}"
1097   [(set_attr "type" "icmp")
1098    (set_attr "mode" "QI")])
1099
1100 (define_insn "*cmpqi_ext_2"
1101   [(set (reg FLAGS_REG)
1102         (compare
1103           (subreg:QI
1104             (zero_extract:SI
1105               (match_operand 0 "ext_register_operand" "Q")
1106               (const_int 8)
1107               (const_int 8)) 0)
1108           (match_operand:QI 1 "const0_operand" "")))]
1109   "ix86_match_ccmode (insn, CCNOmode)"
1110   "test{b}\t%h0, %h0"
1111   [(set_attr "type" "test")
1112    (set_attr "length_immediate" "0")
1113    (set_attr "mode" "QI")])
1114
1115 (define_expand "cmpqi_ext_3"
1116   [(set (reg:CC FLAGS_REG)
1117         (compare:CC
1118           (subreg:QI
1119             (zero_extract:SI
1120               (match_operand 0 "ext_register_operand" "")
1121               (const_int 8)
1122               (const_int 8)) 0)
1123           (match_operand:QI 1 "immediate_operand" "")))])
1124
1125 (define_insn "*cmpqi_ext_3_insn"
1126   [(set (reg FLAGS_REG)
1127         (compare
1128           (subreg:QI
1129             (zero_extract:SI
1130               (match_operand 0 "ext_register_operand" "Q")
1131               (const_int 8)
1132               (const_int 8)) 0)
1133           (match_operand:QI 1 "general_operand" "Qmn")))]
1134   "!TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1135   "cmp{b}\t{%1, %h0|%h0, %1}"
1136   [(set_attr "type" "icmp")
1137    (set_attr "modrm" "1")
1138    (set_attr "mode" "QI")])
1139
1140 (define_insn "*cmpqi_ext_3_insn_rex64"
1141   [(set (reg FLAGS_REG)
1142         (compare
1143           (subreg:QI
1144             (zero_extract:SI
1145               (match_operand 0 "ext_register_operand" "Q")
1146               (const_int 8)
1147               (const_int 8)) 0)
1148           (match_operand:QI 1 "nonmemory_operand" "Qn")))]
1149   "TARGET_64BIT && ix86_match_ccmode (insn, CCmode)"
1150   "cmp{b}\t{%1, %h0|%h0, %1}"
1151   [(set_attr "type" "icmp")
1152    (set_attr "modrm" "1")
1153    (set_attr "mode" "QI")])
1154
1155 (define_insn "*cmpqi_ext_4"
1156   [(set (reg FLAGS_REG)
1157         (compare
1158           (subreg:QI
1159             (zero_extract:SI
1160               (match_operand 0 "ext_register_operand" "Q")
1161               (const_int 8)
1162               (const_int 8)) 0)
1163           (subreg:QI
1164             (zero_extract:SI
1165               (match_operand 1 "ext_register_operand" "Q")
1166               (const_int 8)
1167               (const_int 8)) 0)))]
1168   "ix86_match_ccmode (insn, CCmode)"
1169   "cmp{b}\t{%h1, %h0|%h0, %h1}"
1170   [(set_attr "type" "icmp")
1171    (set_attr "mode" "QI")])
1172
1173 ;; These implement float point compares.
1174 ;; %%% See if we can get away with VOIDmode operands on the actual insns,
1175 ;; which would allow mix and match FP modes on the compares.  Which is what
1176 ;; the old patterns did, but with many more of them.
1177
1178 (define_expand "cbranchxf4"
1179   [(set (reg:CC FLAGS_REG)
1180         (compare:CC (match_operand:XF 1 "nonmemory_operand" "")
1181                     (match_operand:XF 2 "nonmemory_operand" "")))
1182    (set (pc) (if_then_else
1183               (match_operator 0 "ix86_fp_comparison_operator"
1184                [(reg:CC FLAGS_REG)
1185                 (const_int 0)])
1186               (label_ref (match_operand 3 "" ""))
1187               (pc)))]
1188   "TARGET_80387"
1189 {
1190   ix86_expand_branch (GET_CODE (operands[0]),
1191                       operands[1], operands[2], operands[3]);
1192   DONE;
1193 })
1194
1195 (define_expand "cstorexf4"
1196   [(set (reg:CC FLAGS_REG)
1197         (compare:CC (match_operand:XF 2 "nonmemory_operand" "")
1198                     (match_operand:XF 3 "nonmemory_operand" "")))
1199    (set (match_operand:QI 0 "register_operand" "")
1200               (match_operator 1 "ix86_fp_comparison_operator"
1201                [(reg:CC FLAGS_REG)
1202                 (const_int 0)]))]
1203   "TARGET_80387"
1204 {
1205   ix86_expand_setcc (operands[0], GET_CODE (operands[1]),
1206                      operands[2], operands[3]);
1207   DONE;
1208 })
1209
1210 (define_expand "cbranch<mode>4"
1211   [(set (reg:CC FLAGS_REG)
1212         (compare:CC (match_operand:MODEF 1 "cmp_fp_expander_operand" "")
1213                     (match_operand:MODEF 2 "cmp_fp_expander_operand" "")))
1214    (set (pc) (if_then_else
1215               (match_operator 0 "ix86_fp_comparison_operator"
1216                [(reg:CC FLAGS_REG)
1217                 (const_int 0)])
1218               (label_ref (match_operand 3 "" ""))
1219               (pc)))]
1220   "TARGET_80387 || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH)"
1221 {
1222   ix86_expand_branch (GET_CODE (operands[0]),
1223                       operands[1], operands[2], operands[3]);
1224   DONE;
1225 })
1226
1227 (define_expand "cstore<mode>4"
1228   [(set (reg:CC FLAGS_REG)
1229         (compare:CC (match_operand:MODEF 2 "cmp_fp_expander_operand" "")
1230                     (match_operand:MODEF 3 "cmp_fp_expander_operand" "")))
1231    (set (match_operand:QI 0 "register_operand" "")
1232               (match_operator 1 "ix86_fp_comparison_operator"
1233                [(reg:CC FLAGS_REG)
1234                 (const_int 0)]))]
1235   "TARGET_80387 || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH)"
1236 {
1237   ix86_expand_setcc (operands[0], GET_CODE (operands[1]),
1238                      operands[2], operands[3]);
1239   DONE;
1240 })
1241
1242 (define_expand "cbranchcc4"
1243   [(set (pc) (if_then_else
1244               (match_operator 0 "comparison_operator"
1245                [(match_operand 1 "flags_reg_operand" "")
1246                 (match_operand 2 "const0_operand" "")])
1247               (label_ref (match_operand 3 "" ""))
1248               (pc)))]
1249   ""
1250 {
1251   ix86_expand_branch (GET_CODE (operands[0]),
1252                       operands[1], operands[2], operands[3]);
1253   DONE;
1254 })
1255
1256 (define_expand "cstorecc4"
1257   [(set (match_operand:QI 0 "register_operand" "")
1258               (match_operator 1 "comparison_operator"
1259                [(match_operand 2 "flags_reg_operand" "")
1260                 (match_operand 3 "const0_operand" "")]))]
1261   ""
1262 {
1263   ix86_expand_setcc (operands[0], GET_CODE (operands[1]),
1264                      operands[2], operands[3]);
1265   DONE;
1266 })
1267
1268
1269 ;; FP compares, step 1:
1270 ;; Set the FP condition codes.
1271 ;;
1272 ;; CCFPmode     compare with exceptions
1273 ;; CCFPUmode    compare with no exceptions
1274
1275 ;; We may not use "#" to split and emit these, since the REG_DEAD notes
1276 ;; used to manage the reg stack popping would not be preserved.
1277
1278 (define_insn "*cmpfp_0"
1279   [(set (match_operand:HI 0 "register_operand" "=a")
1280         (unspec:HI
1281           [(compare:CCFP
1282              (match_operand 1 "register_operand" "f")
1283              (match_operand 2 "const0_operand" ""))]
1284         UNSPEC_FNSTSW))]
1285   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1286    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1287   "* return output_fp_compare (insn, operands, false, false);"
1288   [(set_attr "type" "multi")
1289    (set_attr "unit" "i387")
1290    (set (attr "mode")
1291      (cond [(match_operand:SF 1 "" "")
1292               (const_string "SF")
1293             (match_operand:DF 1 "" "")
1294               (const_string "DF")
1295            ]
1296            (const_string "XF")))])
1297
1298 (define_insn_and_split "*cmpfp_0_cc"
1299   [(set (reg:CCFP FLAGS_REG)
1300         (compare:CCFP
1301           (match_operand 1 "register_operand" "f")
1302           (match_operand 2 "const0_operand" "")))
1303    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1304   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1305    && TARGET_SAHF && !TARGET_CMOVE
1306    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1307   "#"
1308   "&& reload_completed"
1309   [(set (match_dup 0)
1310         (unspec:HI
1311           [(compare:CCFP (match_dup 1)(match_dup 2))]
1312         UNSPEC_FNSTSW))
1313    (set (reg:CC FLAGS_REG)
1314         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1315   ""
1316   [(set_attr "type" "multi")
1317    (set_attr "unit" "i387")
1318    (set (attr "mode")
1319      (cond [(match_operand:SF 1 "" "")
1320               (const_string "SF")
1321             (match_operand:DF 1 "" "")
1322               (const_string "DF")
1323            ]
1324            (const_string "XF")))])
1325
1326 (define_insn "*cmpfp_xf"
1327   [(set (match_operand:HI 0 "register_operand" "=a")
1328         (unspec:HI
1329           [(compare:CCFP
1330              (match_operand:XF 1 "register_operand" "f")
1331              (match_operand:XF 2 "register_operand" "f"))]
1332           UNSPEC_FNSTSW))]
1333   "TARGET_80387"
1334   "* return output_fp_compare (insn, operands, false, false);"
1335   [(set_attr "type" "multi")
1336    (set_attr "unit" "i387")
1337    (set_attr "mode" "XF")])
1338
1339 (define_insn_and_split "*cmpfp_xf_cc"
1340   [(set (reg:CCFP FLAGS_REG)
1341         (compare:CCFP
1342           (match_operand:XF 1 "register_operand" "f")
1343           (match_operand:XF 2 "register_operand" "f")))
1344    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1345   "TARGET_80387
1346    && TARGET_SAHF && !TARGET_CMOVE"
1347   "#"
1348   "&& reload_completed"
1349   [(set (match_dup 0)
1350         (unspec:HI
1351           [(compare:CCFP (match_dup 1)(match_dup 2))]
1352         UNSPEC_FNSTSW))
1353    (set (reg:CC FLAGS_REG)
1354         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1355   ""
1356   [(set_attr "type" "multi")
1357    (set_attr "unit" "i387")
1358    (set_attr "mode" "XF")])
1359
1360 (define_insn "*cmpfp_<mode>"
1361   [(set (match_operand:HI 0 "register_operand" "=a")
1362         (unspec:HI
1363           [(compare:CCFP
1364              (match_operand:MODEF 1 "register_operand" "f")
1365              (match_operand:MODEF 2 "nonimmediate_operand" "fm"))]
1366           UNSPEC_FNSTSW))]
1367   "TARGET_80387"
1368   "* return output_fp_compare (insn, operands, false, false);"
1369   [(set_attr "type" "multi")
1370    (set_attr "unit" "i387")
1371    (set_attr "mode" "<MODE>")])
1372
1373 (define_insn_and_split "*cmpfp_<mode>_cc"
1374   [(set (reg:CCFP FLAGS_REG)
1375         (compare:CCFP
1376           (match_operand:MODEF 1 "register_operand" "f")
1377           (match_operand:MODEF 2 "nonimmediate_operand" "fm")))
1378    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1379   "TARGET_80387
1380    && TARGET_SAHF && !TARGET_CMOVE"
1381   "#"
1382   "&& reload_completed"
1383   [(set (match_dup 0)
1384         (unspec:HI
1385           [(compare:CCFP (match_dup 1)(match_dup 2))]
1386         UNSPEC_FNSTSW))
1387    (set (reg:CC FLAGS_REG)
1388         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1389   ""
1390   [(set_attr "type" "multi")
1391    (set_attr "unit" "i387")
1392    (set_attr "mode" "<MODE>")])
1393
1394 (define_insn "*cmpfp_u"
1395   [(set (match_operand:HI 0 "register_operand" "=a")
1396         (unspec:HI
1397           [(compare:CCFPU
1398              (match_operand 1 "register_operand" "f")
1399              (match_operand 2 "register_operand" "f"))]
1400           UNSPEC_FNSTSW))]
1401   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1402    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1403   "* return output_fp_compare (insn, operands, false, true);"
1404   [(set_attr "type" "multi")
1405    (set_attr "unit" "i387")
1406    (set (attr "mode")
1407      (cond [(match_operand:SF 1 "" "")
1408               (const_string "SF")
1409             (match_operand:DF 1 "" "")
1410               (const_string "DF")
1411            ]
1412            (const_string "XF")))])
1413
1414 (define_insn_and_split "*cmpfp_u_cc"
1415   [(set (reg:CCFPU FLAGS_REG)
1416         (compare:CCFPU
1417           (match_operand 1 "register_operand" "f")
1418           (match_operand 2 "register_operand" "f")))
1419    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1420   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1421    && TARGET_SAHF && !TARGET_CMOVE
1422    && GET_MODE (operands[1]) == GET_MODE (operands[2])"
1423   "#"
1424   "&& reload_completed"
1425   [(set (match_dup 0)
1426         (unspec:HI
1427           [(compare:CCFPU (match_dup 1)(match_dup 2))]
1428         UNSPEC_FNSTSW))
1429    (set (reg:CC FLAGS_REG)
1430         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1431   ""
1432   [(set_attr "type" "multi")
1433    (set_attr "unit" "i387")
1434    (set (attr "mode")
1435      (cond [(match_operand:SF 1 "" "")
1436               (const_string "SF")
1437             (match_operand:DF 1 "" "")
1438               (const_string "DF")
1439            ]
1440            (const_string "XF")))])
1441
1442 (define_insn "*cmpfp_<mode>"
1443   [(set (match_operand:HI 0 "register_operand" "=a")
1444         (unspec:HI
1445           [(compare:CCFP
1446              (match_operand 1 "register_operand" "f")
1447              (match_operator 3 "float_operator"
1448                [(match_operand:SWI24 2 "memory_operand" "m")]))]
1449           UNSPEC_FNSTSW))]
1450   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1451    && (TARGET_USE_<MODE>MODE_FIOP || optimize_function_for_size_p (cfun))
1452    && (GET_MODE (operands [3]) == GET_MODE (operands[1]))"
1453   "* return output_fp_compare (insn, operands, false, false);"
1454   [(set_attr "type" "multi")
1455    (set_attr "unit" "i387")
1456    (set_attr "fp_int_src" "true")
1457    (set_attr "mode" "<MODE>")])
1458
1459 (define_insn_and_split "*cmpfp_<mode>_cc"
1460   [(set (reg:CCFP FLAGS_REG)
1461         (compare:CCFP
1462           (match_operand 1 "register_operand" "f")
1463           (match_operator 3 "float_operator"
1464             [(match_operand:SWI24 2 "memory_operand" "m")])))
1465    (clobber (match_operand:HI 0 "register_operand" "=a"))]
1466   "X87_FLOAT_MODE_P (GET_MODE (operands[1]))
1467    && TARGET_SAHF && !TARGET_CMOVE
1468    && (TARGET_USE_<MODE>MODE_FIOP || optimize_function_for_size_p (cfun))
1469    && (GET_MODE (operands [3]) == GET_MODE (operands[1]))"
1470   "#"
1471   "&& reload_completed"
1472   [(set (match_dup 0)
1473         (unspec:HI
1474           [(compare:CCFP
1475              (match_dup 1)
1476              (match_op_dup 3 [(match_dup 2)]))]
1477         UNSPEC_FNSTSW))
1478    (set (reg:CC FLAGS_REG)
1479         (unspec:CC [(match_dup 0)] UNSPEC_SAHF))]
1480   ""
1481   [(set_attr "type" "multi")
1482    (set_attr "unit" "i387")
1483    (set_attr "fp_int_src" "true")
1484    (set_attr "mode" "<MODE>")])
1485
1486 ;; FP compares, step 2
1487 ;; Move the fpsw to ax.
1488
1489 (define_insn "x86_fnstsw_1"
1490   [(set (match_operand:HI 0 "register_operand" "=a")
1491         (unspec:HI [(reg:CCFP FPSR_REG)] UNSPEC_FNSTSW))]
1492   "TARGET_80387"
1493   "fnstsw\t%0"
1494   [(set (attr "length")
1495         (symbol_ref "ix86_attr_length_address_default (insn) + 2"))
1496    (set_attr "mode" "SI")
1497    (set_attr "unit" "i387")])
1498
1499 ;; FP compares, step 3
1500 ;; Get ax into flags, general case.
1501
1502 (define_insn "x86_sahf_1"
1503   [(set (reg:CC FLAGS_REG)
1504         (unspec:CC [(match_operand:HI 0 "register_operand" "a")]
1505                    UNSPEC_SAHF))]
1506   "TARGET_SAHF"
1507 {
1508 #ifndef HAVE_AS_IX86_SAHF
1509   if (TARGET_64BIT)
1510     return ASM_BYTE "0x9e";
1511   else
1512 #endif
1513   return "sahf";
1514 }
1515   [(set_attr "length" "1")
1516    (set_attr "athlon_decode" "vector")
1517    (set_attr "amdfam10_decode" "direct")
1518    (set_attr "bdver1_decode" "direct")
1519    (set_attr "mode" "SI")])
1520
1521 ;; Pentium Pro can do steps 1 through 3 in one go.
1522 ;; comi*, ucomi*, fcomi*, ficomi*, fucomi*
1523 ;; (these i387 instructions set flags directly)
1524 (define_insn "*cmpfp_i_mixed"
1525   [(set (reg:CCFP FLAGS_REG)
1526         (compare:CCFP (match_operand 0 "register_operand" "f,x")
1527                       (match_operand 1 "nonimmediate_operand" "f,xm")))]
1528   "TARGET_MIX_SSE_I387
1529    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1530    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1531   "* return output_fp_compare (insn, operands, true, false);"
1532   [(set_attr "type" "fcmp,ssecomi")
1533    (set_attr "prefix" "orig,maybe_vex")
1534    (set (attr "mode")
1535      (if_then_else (match_operand:SF 1 "" "")
1536         (const_string "SF")
1537         (const_string "DF")))
1538    (set (attr "prefix_rep")
1539         (if_then_else (eq_attr "type" "ssecomi")
1540                       (const_string "0")
1541                       (const_string "*")))
1542    (set (attr "prefix_data16")
1543         (cond [(eq_attr "type" "fcmp")
1544                  (const_string "*")
1545                (eq_attr "mode" "DF")
1546                  (const_string "1")
1547               ]
1548               (const_string "0")))
1549    (set_attr "athlon_decode" "vector")
1550    (set_attr "amdfam10_decode" "direct")
1551    (set_attr "bdver1_decode" "double")])
1552
1553 (define_insn "*cmpfp_i_sse"
1554   [(set (reg:CCFP FLAGS_REG)
1555         (compare:CCFP (match_operand 0 "register_operand" "x")
1556                       (match_operand 1 "nonimmediate_operand" "xm")))]
1557   "TARGET_SSE_MATH
1558    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1559    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1560   "* return output_fp_compare (insn, operands, true, false);"
1561   [(set_attr "type" "ssecomi")
1562    (set_attr "prefix" "maybe_vex")
1563    (set (attr "mode")
1564      (if_then_else (match_operand:SF 1 "" "")
1565         (const_string "SF")
1566         (const_string "DF")))
1567    (set_attr "prefix_rep" "0")
1568    (set (attr "prefix_data16")
1569         (if_then_else (eq_attr "mode" "DF")
1570                       (const_string "1")
1571                       (const_string "0")))
1572    (set_attr "athlon_decode" "vector")
1573    (set_attr "amdfam10_decode" "direct")
1574    (set_attr "bdver1_decode" "double")])
1575
1576 (define_insn "*cmpfp_i_i387"
1577   [(set (reg:CCFP FLAGS_REG)
1578         (compare:CCFP (match_operand 0 "register_operand" "f")
1579                       (match_operand 1 "register_operand" "f")))]
1580   "X87_FLOAT_MODE_P (GET_MODE (operands[0]))
1581    && TARGET_CMOVE
1582    && !(SSE_FLOAT_MODE_P (GET_MODE (operands[0])) && TARGET_SSE_MATH)
1583    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1584   "* return output_fp_compare (insn, operands, true, false);"
1585   [(set_attr "type" "fcmp")
1586    (set (attr "mode")
1587      (cond [(match_operand:SF 1 "" "")
1588               (const_string "SF")
1589             (match_operand:DF 1 "" "")
1590               (const_string "DF")
1591            ]
1592            (const_string "XF")))
1593    (set_attr "athlon_decode" "vector")
1594    (set_attr "amdfam10_decode" "direct")
1595    (set_attr "bdver1_decode" "double")])
1596
1597 (define_insn "*cmpfp_iu_mixed"
1598   [(set (reg:CCFPU FLAGS_REG)
1599         (compare:CCFPU (match_operand 0 "register_operand" "f,x")
1600                        (match_operand 1 "nonimmediate_operand" "f,xm")))]
1601   "TARGET_MIX_SSE_I387
1602    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1603    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1604   "* return output_fp_compare (insn, operands, true, true);"
1605   [(set_attr "type" "fcmp,ssecomi")
1606    (set_attr "prefix" "orig,maybe_vex")
1607    (set (attr "mode")
1608      (if_then_else (match_operand:SF 1 "" "")
1609         (const_string "SF")
1610         (const_string "DF")))
1611    (set (attr "prefix_rep")
1612         (if_then_else (eq_attr "type" "ssecomi")
1613                       (const_string "0")
1614                       (const_string "*")))
1615    (set (attr "prefix_data16")
1616         (cond [(eq_attr "type" "fcmp")
1617                  (const_string "*")
1618                (eq_attr "mode" "DF")
1619                  (const_string "1")
1620               ]
1621               (const_string "0")))
1622    (set_attr "athlon_decode" "vector")
1623    (set_attr "amdfam10_decode" "direct")
1624    (set_attr "bdver1_decode" "double")])
1625
1626 (define_insn "*cmpfp_iu_sse"
1627   [(set (reg:CCFPU FLAGS_REG)
1628         (compare:CCFPU (match_operand 0 "register_operand" "x")
1629                        (match_operand 1 "nonimmediate_operand" "xm")))]
1630   "TARGET_SSE_MATH
1631    && SSE_FLOAT_MODE_P (GET_MODE (operands[0]))
1632    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1633   "* return output_fp_compare (insn, operands, true, true);"
1634   [(set_attr "type" "ssecomi")
1635    (set_attr "prefix" "maybe_vex")
1636    (set (attr "mode")
1637      (if_then_else (match_operand:SF 1 "" "")
1638         (const_string "SF")
1639         (const_string "DF")))
1640    (set_attr "prefix_rep" "0")
1641    (set (attr "prefix_data16")
1642         (if_then_else (eq_attr "mode" "DF")
1643                       (const_string "1")
1644                       (const_string "0")))
1645    (set_attr "athlon_decode" "vector")
1646    (set_attr "amdfam10_decode" "direct")
1647    (set_attr "bdver1_decode" "double")])
1648
1649 (define_insn "*cmpfp_iu_387"
1650   [(set (reg:CCFPU FLAGS_REG)
1651         (compare:CCFPU (match_operand 0 "register_operand" "f")
1652                        (match_operand 1 "register_operand" "f")))]
1653   "X87_FLOAT_MODE_P (GET_MODE (operands[0]))
1654    && TARGET_CMOVE
1655    && !(SSE_FLOAT_MODE_P (GET_MODE (operands[0])) && TARGET_SSE_MATH)
1656    && GET_MODE (operands[0]) == GET_MODE (operands[1])"
1657   "* return output_fp_compare (insn, operands, true, true);"
1658   [(set_attr "type" "fcmp")
1659    (set (attr "mode")
1660      (cond [(match_operand:SF 1 "" "")
1661               (const_string "SF")
1662             (match_operand:DF 1 "" "")
1663               (const_string "DF")
1664            ]
1665            (const_string "XF")))
1666    (set_attr "athlon_decode" "vector")
1667    (set_attr "amdfam10_decode" "direct")
1668    (set_attr "bdver1_decode" "direct")])
1669 \f
1670 ;; Push/pop instructions.
1671
1672 (define_insn "*push<mode>2"
1673   [(set (match_operand:DWI 0 "push_operand" "=<")
1674         (match_operand:DWI 1 "general_no_elim_operand" "riF*o"))]
1675   ""
1676   "#"
1677   [(set_attr "type" "multi")
1678    (set_attr "mode" "<MODE>")])
1679
1680 (define_split
1681   [(set (match_operand:TI 0 "push_operand" "")
1682         (match_operand:TI 1 "general_operand" ""))]
1683   "TARGET_64BIT && reload_completed
1684    && !SSE_REG_P (operands[1])"
1685   [(const_int 0)]
1686   "ix86_split_long_move (operands); DONE;")
1687
1688 (define_insn "*pushdi2_rex64"
1689   [(set (match_operand:DI 0 "push_operand" "=<,!<")
1690         (match_operand:DI 1 "general_no_elim_operand" "re*m,n"))]
1691   "TARGET_64BIT"
1692   "@
1693    push{q}\t%1
1694    #"
1695   [(set_attr "type" "push,multi")
1696    (set_attr "mode" "DI")])
1697
1698 ;; Convert impossible pushes of immediate to existing instructions.
1699 ;; First try to get scratch register and go through it.  In case this
1700 ;; fails, push sign extended lower part first and then overwrite
1701 ;; upper part by 32bit move.
1702 (define_peephole2
1703   [(match_scratch:DI 2 "r")
1704    (set (match_operand:DI 0 "push_operand" "")
1705         (match_operand:DI 1 "immediate_operand" ""))]
1706   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
1707    && !x86_64_immediate_operand (operands[1], DImode)"
1708   [(set (match_dup 2) (match_dup 1))
1709    (set (match_dup 0) (match_dup 2))])
1710
1711 ;; We need to define this as both peepholer and splitter for case
1712 ;; peephole2 pass is not run.
1713 ;; "&& 1" is needed to keep it from matching the previous pattern.
1714 (define_peephole2
1715   [(set (match_operand:DI 0 "push_operand" "")
1716         (match_operand:DI 1 "immediate_operand" ""))]
1717   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
1718    && !x86_64_immediate_operand (operands[1], DImode) && 1"
1719   [(set (match_dup 0) (match_dup 1))
1720    (set (match_dup 2) (match_dup 3))]
1721 {
1722   split_double_mode (DImode, &operands[1], 1, &operands[2], &operands[3]);
1723
1724   operands[1] = gen_lowpart (DImode, operands[2]);
1725   operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx,
1726                                                    GEN_INT (4)));
1727 })
1728
1729 (define_split
1730   [(set (match_operand:DI 0 "push_operand" "")
1731         (match_operand:DI 1 "immediate_operand" ""))]
1732   "TARGET_64BIT && ((optimize > 0 && flag_peephole2)
1733                     ? epilogue_completed : reload_completed)
1734    && !symbolic_operand (operands[1], DImode)
1735    && !x86_64_immediate_operand (operands[1], DImode)"
1736   [(set (match_dup 0) (match_dup 1))
1737    (set (match_dup 2) (match_dup 3))]
1738 {
1739   split_double_mode (DImode, &operands[1], 1, &operands[2], &operands[3]);
1740
1741   operands[1] = gen_lowpart (DImode, operands[2]);
1742   operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx,
1743                                                    GEN_INT (4)));
1744 })
1745
1746 (define_split
1747   [(set (match_operand:DI 0 "push_operand" "")
1748         (match_operand:DI 1 "general_operand" ""))]
1749   "!TARGET_64BIT && reload_completed
1750    && !(MMX_REG_P (operands[1]) || SSE_REG_P (operands[1]))"
1751   [(const_int 0)]
1752   "ix86_split_long_move (operands); DONE;")
1753
1754 (define_insn "*pushsi2"
1755   [(set (match_operand:SI 0 "push_operand" "=<")
1756         (match_operand:SI 1 "general_no_elim_operand" "ri*m"))]
1757   "!TARGET_64BIT"
1758   "push{l}\t%1"
1759   [(set_attr "type" "push")
1760    (set_attr "mode" "SI")])
1761
1762 ;; emit_push_insn when it calls move_by_pieces requires an insn to
1763 ;; "push a byte/word".  But actually we use pushl, which has the effect
1764 ;; of rounding the amount pushed up to a word.
1765
1766 ;; For TARGET_64BIT we always round up to 8 bytes.
1767 (define_insn "*push<mode>2_rex64"
1768   [(set (match_operand:SWI124 0 "push_operand" "=X")
1769         (match_operand:SWI124 1 "nonmemory_no_elim_operand" "r<i>"))]
1770   "TARGET_64BIT"
1771   "push{q}\t%q1"
1772   [(set_attr "type" "push")
1773    (set_attr "mode" "DI")])
1774
1775 (define_insn "*push<mode>2"
1776   [(set (match_operand:SWI12 0 "push_operand" "=X")
1777         (match_operand:SWI12 1 "nonmemory_no_elim_operand" "rn"))]
1778   "!TARGET_64BIT"
1779   "push{l}\t%k1"
1780   [(set_attr "type" "push")
1781    (set_attr "mode" "SI")])
1782
1783 (define_insn "*push<mode>2_prologue"
1784   [(set (match_operand:P 0 "push_operand" "=<")
1785         (match_operand:P 1 "general_no_elim_operand" "r<i>*m"))
1786    (clobber (mem:BLK (scratch)))]
1787   ""
1788   "push{<imodesuffix>}\t%1"
1789   [(set_attr "type" "push")
1790    (set_attr "mode" "<MODE>")])
1791
1792 (define_insn "*pop<mode>1"
1793   [(set (match_operand:P 0 "nonimmediate_operand" "=r*m")
1794         (match_operand:P 1 "pop_operand" ">"))]
1795   ""
1796   "pop{<imodesuffix>}\t%0"
1797   [(set_attr "type" "pop")
1798    (set_attr "mode" "<MODE>")])
1799
1800 (define_insn "*pop<mode>1_epilogue"
1801   [(set (match_operand:P 0 "nonimmediate_operand" "=r*m")
1802         (match_operand:P 1 "pop_operand" ">"))
1803    (clobber (mem:BLK (scratch)))]
1804   ""
1805   "pop{<imodesuffix>}\t%0"
1806   [(set_attr "type" "pop")
1807    (set_attr "mode" "<MODE>")])
1808 \f
1809 ;; Move instructions.
1810
1811 (define_expand "movoi"
1812   [(set (match_operand:OI 0 "nonimmediate_operand" "")
1813         (match_operand:OI 1 "general_operand" ""))]
1814   "TARGET_AVX"
1815   "ix86_expand_move (OImode, operands); DONE;")
1816
1817 (define_expand "movti"
1818   [(set (match_operand:TI 0 "nonimmediate_operand" "")
1819         (match_operand:TI 1 "nonimmediate_operand" ""))]
1820   "TARGET_64BIT || TARGET_SSE"
1821 {
1822   if (TARGET_64BIT)
1823     ix86_expand_move (TImode, operands);
1824   else if (push_operand (operands[0], TImode))
1825     ix86_expand_push (TImode, operands[1]);
1826   else
1827     ix86_expand_vector_move (TImode, operands);
1828   DONE;
1829 })
1830
1831 ;; This expands to what emit_move_complex would generate if we didn't
1832 ;; have a movti pattern.  Having this avoids problems with reload on
1833 ;; 32-bit targets when SSE is present, but doesn't seem to be harmful
1834 ;; to have around all the time.
1835 (define_expand "movcdi"
1836   [(set (match_operand:CDI 0 "nonimmediate_operand" "")
1837         (match_operand:CDI 1 "general_operand" ""))]
1838   ""
1839 {
1840   if (push_operand (operands[0], CDImode))
1841     emit_move_complex_push (CDImode, operands[0], operands[1]);
1842   else
1843     emit_move_complex_parts (operands[0], operands[1]);
1844   DONE;
1845 })
1846
1847 (define_expand "mov<mode>"
1848   [(set (match_operand:SWI1248x 0 "nonimmediate_operand" "")
1849         (match_operand:SWI1248x 1 "general_operand" ""))]
1850   ""
1851   "ix86_expand_move (<MODE>mode, operands); DONE;")
1852
1853 (define_insn "*mov<mode>_xor"
1854   [(set (match_operand:SWI48 0 "register_operand" "=r")
1855         (match_operand:SWI48 1 "const0_operand" ""))
1856    (clobber (reg:CC FLAGS_REG))]
1857   "reload_completed"
1858   "xor{l}\t%k0, %k0"
1859   [(set_attr "type" "alu1")
1860    (set_attr "mode" "SI")
1861    (set_attr "length_immediate" "0")])
1862
1863 (define_insn "*mov<mode>_or"
1864   [(set (match_operand:SWI48 0 "register_operand" "=r")
1865         (match_operand:SWI48 1 "const_int_operand" ""))
1866    (clobber (reg:CC FLAGS_REG))]
1867   "reload_completed
1868    && operands[1] == constm1_rtx"
1869   "or{<imodesuffix>}\t{%1, %0|%0, %1}"
1870   [(set_attr "type" "alu1")
1871    (set_attr "mode" "<MODE>")
1872    (set_attr "length_immediate" "1")])
1873
1874 (define_insn "*movoi_internal_avx"
1875   [(set (match_operand:OI 0 "nonimmediate_operand" "=x,x,m")
1876         (match_operand:OI 1 "vector_move_operand" "C,xm,x"))]
1877   "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1878 {
1879   switch (which_alternative)
1880     {
1881     case 0:
1882       return standard_sse_constant_opcode (insn, operands[1]);
1883     case 1:
1884     case 2:
1885       if (misaligned_operand (operands[0], OImode)
1886           || misaligned_operand (operands[1], OImode))
1887         return "vmovdqu\t{%1, %0|%0, %1}";
1888       else
1889         return "vmovdqa\t{%1, %0|%0, %1}";
1890     default:
1891       gcc_unreachable ();
1892     }
1893 }
1894   [(set_attr "type" "sselog1,ssemov,ssemov")
1895    (set_attr "prefix" "vex")
1896    (set_attr "mode" "OI")])
1897
1898 (define_insn "*movti_internal_rex64"
1899   [(set (match_operand:TI 0 "nonimmediate_operand" "=!r,o,x,x,xm")
1900         (match_operand:TI 1 "general_operand" "riFo,riF,C,xm,x"))]
1901   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1902 {
1903   switch (which_alternative)
1904     {
1905     case 0:
1906     case 1:
1907       return "#";
1908     case 2:
1909       return standard_sse_constant_opcode (insn, operands[1]);
1910     case 3:
1911     case 4:
1912       /* TDmode values are passed as TImode on the stack.  Moving them
1913          to stack may result in unaligned memory access.  */
1914       if (misaligned_operand (operands[0], TImode)
1915           || misaligned_operand (operands[1], TImode))
1916         {
1917           if (get_attr_mode (insn) == MODE_V4SF)
1918             return "%vmovups\t{%1, %0|%0, %1}";
1919           else
1920             return "%vmovdqu\t{%1, %0|%0, %1}";
1921         }
1922       else
1923         {
1924           if (get_attr_mode (insn) == MODE_V4SF)
1925             return "%vmovaps\t{%1, %0|%0, %1}";
1926           else
1927             return "%vmovdqa\t{%1, %0|%0, %1}";
1928         }
1929     default:
1930       gcc_unreachable ();
1931     }
1932 }
1933   [(set_attr "type" "*,*,sselog1,ssemov,ssemov")
1934    (set_attr "prefix" "*,*,maybe_vex,maybe_vex,maybe_vex")
1935    (set (attr "mode")
1936         (cond [(eq_attr "alternative" "2,3")
1937                  (if_then_else
1938                    (match_test "optimize_function_for_size_p (cfun)")
1939                    (const_string "V4SF")
1940                    (const_string "TI"))
1941                (eq_attr "alternative" "4")
1942                  (if_then_else
1943                    (ior (match_test "TARGET_SSE_TYPELESS_STORES")
1944                         (match_test "optimize_function_for_size_p (cfun)"))
1945                    (const_string "V4SF")
1946                    (const_string "TI"))]
1947                (const_string "DI")))])
1948
1949 (define_split
1950   [(set (match_operand:TI 0 "nonimmediate_operand" "")
1951         (match_operand:TI 1 "general_operand" ""))]
1952   "reload_completed
1953    && !SSE_REG_P (operands[0]) && !SSE_REG_P (operands[1])"
1954   [(const_int 0)]
1955   "ix86_split_long_move (operands); DONE;")
1956
1957 (define_insn "*movti_internal_sse"
1958   [(set (match_operand:TI 0 "nonimmediate_operand" "=x,x,m")
1959         (match_operand:TI 1 "vector_move_operand" "C,xm,x"))]
1960   "TARGET_SSE && !TARGET_64BIT
1961    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1962 {
1963   switch (which_alternative)
1964     {
1965     case 0:
1966       return standard_sse_constant_opcode (insn, operands[1]);
1967     case 1:
1968     case 2:
1969       /* TDmode values are passed as TImode on the stack.  Moving them
1970          to stack may result in unaligned memory access.  */
1971       if (misaligned_operand (operands[0], TImode)
1972           || misaligned_operand (operands[1], TImode))
1973         {
1974           if (get_attr_mode (insn) == MODE_V4SF)
1975             return "%vmovups\t{%1, %0|%0, %1}";
1976           else
1977             return "%vmovdqu\t{%1, %0|%0, %1}";
1978         }
1979       else
1980         {
1981           if (get_attr_mode (insn) == MODE_V4SF)
1982             return "%vmovaps\t{%1, %0|%0, %1}";
1983           else
1984             return "%vmovdqa\t{%1, %0|%0, %1}";
1985         }
1986     default:
1987       gcc_unreachable ();
1988     }
1989 }
1990   [(set_attr "type" "sselog1,ssemov,ssemov")
1991    (set_attr "prefix" "maybe_vex")
1992    (set (attr "mode")
1993         (cond [(ior (not (match_test "TARGET_SSE2"))
1994                     (match_test "optimize_function_for_size_p (cfun)"))
1995                  (const_string "V4SF")
1996                (and (eq_attr "alternative" "2")
1997                     (match_test "TARGET_SSE_TYPELESS_STORES"))
1998                  (const_string "V4SF")]
1999               (const_string "TI")))])
2000
2001 (define_insn "*movdi_internal_rex64"
2002   [(set (match_operand:DI 0 "nonimmediate_operand"
2003           "=r,r  ,r,m ,!o,*y,m*y,?*y,?r ,?*Ym,*x,m ,*x,*x,?r ,?*Yi,?*x,?*Ym")
2004         (match_operand:DI 1 "general_operand"
2005           "Z ,rem,i,re,n ,C ,*y ,m  ,*Ym,r   ,C ,*x,*x,m ,*Yi,r   ,*Ym,*x"))]
2006   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2007 {
2008   switch (get_attr_type (insn))
2009     {
2010     case TYPE_SSECVT:
2011       if (SSE_REG_P (operands[0]))
2012         return "movq2dq\t{%1, %0|%0, %1}";
2013       else
2014         return "movdq2q\t{%1, %0|%0, %1}";
2015
2016     case TYPE_SSEMOV:
2017       if (get_attr_mode (insn) == MODE_TI)
2018         return "%vmovdqa\t{%1, %0|%0, %1}";
2019       /* Handle broken assemblers that require movd instead of movq.  */
2020       if (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1]))
2021         return "%vmovd\t{%1, %0|%0, %1}";
2022       else
2023         return "%vmovq\t{%1, %0|%0, %1}";
2024
2025     case TYPE_MMXMOV:
2026       /* Handle broken assemblers that require movd instead of movq.  */
2027       if (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1]))
2028         return "movd\t{%1, %0|%0, %1}";
2029       else
2030         return "movq\t{%1, %0|%0, %1}";
2031
2032     case TYPE_SSELOG1:
2033       return standard_sse_constant_opcode (insn, operands[1]);
2034
2035     case TYPE_MMX:
2036       return "pxor\t%0, %0";
2037
2038     case TYPE_MULTI:
2039       return "#";
2040
2041     case TYPE_LEA:
2042       return "lea{q}\t{%a1, %0|%0, %a1}";
2043
2044     default:
2045       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
2046       if (get_attr_mode (insn) == MODE_SI)
2047         return "mov{l}\t{%k1, %k0|%k0, %k1}";
2048       else if (which_alternative == 2)
2049         return "movabs{q}\t{%1, %0|%0, %1}";
2050       else
2051         return "mov{q}\t{%1, %0|%0, %1}";
2052     }
2053 }
2054   [(set (attr "type")
2055      (cond [(eq_attr "alternative" "4")
2056               (const_string "multi")
2057             (eq_attr "alternative" "5")
2058               (const_string "mmx")
2059             (eq_attr "alternative" "6,7,8,9")
2060               (const_string "mmxmov")
2061             (eq_attr "alternative" "10")
2062               (const_string "sselog1")
2063             (eq_attr "alternative" "11,12,13,14,15")
2064               (const_string "ssemov")
2065             (eq_attr "alternative" "16,17")
2066               (const_string "ssecvt")
2067             (match_operand 1 "pic_32bit_operand" "")
2068               (const_string "lea")
2069            ]
2070            (const_string "imov")))
2071    (set (attr "modrm")
2072      (if_then_else
2073        (and (eq_attr "alternative" "2") (eq_attr "type" "imov"))
2074          (const_string "0")
2075          (const_string "*")))
2076    (set (attr "length_immediate")
2077      (if_then_else
2078        (and (eq_attr "alternative" "2") (eq_attr "type" "imov"))
2079          (const_string "8")
2080          (const_string "*")))
2081    (set (attr "prefix_rex")
2082      (if_then_else (eq_attr "alternative" "8,9")
2083        (const_string "1")
2084        (const_string "*")))
2085    (set (attr "prefix_data16")
2086      (if_then_else (eq_attr "alternative" "11")
2087        (const_string "1")
2088        (const_string "*")))
2089    (set (attr "prefix")
2090      (if_then_else (eq_attr "alternative" "10,11,12,13,14,15")
2091        (const_string "maybe_vex")
2092        (const_string "orig")))
2093    (set_attr "mode" "SI,DI,DI,DI,SI,DI,DI,DI,DI,DI,TI,DI,TI,DI,DI,DI,DI,DI")])
2094
2095 ;; Reload patterns to support multi-word load/store
2096 ;; with non-offsetable address.
2097 (define_expand "reload_noff_store"
2098   [(parallel [(match_operand 0 "memory_operand" "=m")
2099               (match_operand 1 "register_operand" "r")
2100               (match_operand:DI 2 "register_operand" "=&r")])]
2101   "TARGET_64BIT"
2102 {
2103   rtx mem = operands[0];
2104   rtx addr = XEXP (mem, 0);
2105
2106   emit_move_insn (operands[2], addr);
2107   mem = replace_equiv_address_nv (mem, operands[2]);
2108
2109   emit_insn (gen_rtx_SET (VOIDmode, mem, operands[1]));
2110   DONE;
2111 })
2112
2113 (define_expand "reload_noff_load"
2114   [(parallel [(match_operand 0 "register_operand" "=r")
2115               (match_operand 1 "memory_operand" "m")
2116               (match_operand:DI 2 "register_operand" "=r")])]
2117   "TARGET_64BIT"
2118 {
2119   rtx mem = operands[1];
2120   rtx addr = XEXP (mem, 0);
2121
2122   emit_move_insn (operands[2], addr);
2123   mem = replace_equiv_address_nv (mem, operands[2]);
2124
2125   emit_insn (gen_rtx_SET (VOIDmode, operands[0], mem));
2126   DONE;
2127 })
2128
2129 ;; Convert impossible stores of immediate to existing instructions.
2130 ;; First try to get scratch register and go through it.  In case this
2131 ;; fails, move by 32bit parts.
2132 (define_peephole2
2133   [(match_scratch:DI 2 "r")
2134    (set (match_operand:DI 0 "memory_operand" "")
2135         (match_operand:DI 1 "immediate_operand" ""))]
2136   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2137    && !x86_64_immediate_operand (operands[1], DImode)"
2138   [(set (match_dup 2) (match_dup 1))
2139    (set (match_dup 0) (match_dup 2))])
2140
2141 ;; We need to define this as both peepholer and splitter for case
2142 ;; peephole2 pass is not run.
2143 ;; "&& 1" is needed to keep it from matching the previous pattern.
2144 (define_peephole2
2145   [(set (match_operand:DI 0 "memory_operand" "")
2146         (match_operand:DI 1 "immediate_operand" ""))]
2147   "TARGET_64BIT && !symbolic_operand (operands[1], DImode)
2148    && !x86_64_immediate_operand (operands[1], DImode) && 1"
2149   [(set (match_dup 2) (match_dup 3))
2150    (set (match_dup 4) (match_dup 5))]
2151   "split_double_mode (DImode, &operands[0], 2, &operands[2], &operands[4]);")
2152
2153 (define_split
2154   [(set (match_operand:DI 0 "memory_operand" "")
2155         (match_operand:DI 1 "immediate_operand" ""))]
2156   "TARGET_64BIT && ((optimize > 0 && flag_peephole2)
2157                     ? epilogue_completed : reload_completed)
2158    && !symbolic_operand (operands[1], DImode)
2159    && !x86_64_immediate_operand (operands[1], DImode)"
2160   [(set (match_dup 2) (match_dup 3))
2161    (set (match_dup 4) (match_dup 5))]
2162   "split_double_mode (DImode, &operands[0], 2, &operands[2], &operands[4]);")
2163
2164 (define_insn "*movdi_internal"
2165   [(set (match_operand:DI 0 "nonimmediate_operand"
2166           "=r  ,o  ,*y,m*y,*y,*x,m ,*x,*x,*x,m ,*x,*x,?*x,?*Ym")
2167         (match_operand:DI 1 "general_operand"
2168           "riFo,riF,C ,*y ,m ,C ,*x,*x,m ,C ,*x,*x,m ,*Ym,*x"))]
2169   "!TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2170 {
2171   switch (get_attr_type (insn))
2172     {
2173     case TYPE_SSECVT:
2174       if (SSE_REG_P (operands[0]))
2175         return "movq2dq\t{%1, %0|%0, %1}";
2176       else
2177         return "movdq2q\t{%1, %0|%0, %1}";
2178
2179     case TYPE_SSEMOV:
2180       switch (get_attr_mode (insn))
2181         {
2182         case MODE_TI:
2183           return "%vmovdqa\t{%1, %0|%0, %1}";
2184         case MODE_DI:
2185            return "%vmovq\t{%1, %0|%0, %1}";
2186         case MODE_V4SF:
2187           return "movaps\t{%1, %0|%0, %1}";
2188         case MODE_V2SF:
2189           return "movlps\t{%1, %0|%0, %1}";
2190         default:
2191           gcc_unreachable ();
2192         }
2193
2194     case TYPE_MMXMOV:
2195       return "movq\t{%1, %0|%0, %1}";
2196
2197     case TYPE_SSELOG1:
2198       return standard_sse_constant_opcode (insn, operands[1]);
2199
2200     case TYPE_MMX:
2201       return "pxor\t%0, %0";
2202
2203     case TYPE_MULTI:
2204       return "#";
2205
2206     default:
2207       gcc_unreachable ();
2208     }
2209 }
2210   [(set (attr "isa")
2211      (cond [(eq_attr "alternative" "5,6,7,8,13,14")
2212               (const_string "sse2")
2213             (eq_attr "alternative" "9,10,11,12")
2214               (const_string "noavx")
2215            ]
2216            (const_string "*")))
2217    (set (attr "type")
2218      (cond [(eq_attr "alternative" "0,1")
2219               (const_string "multi")
2220             (eq_attr "alternative" "2")
2221               (const_string "mmx")
2222             (eq_attr "alternative" "3,4")
2223               (const_string "mmxmov")
2224             (eq_attr "alternative" "5,9")
2225               (const_string "sselog1")
2226             (eq_attr "alternative" "13,14")
2227               (const_string "ssecvt")
2228            ]
2229            (const_string "ssemov")))
2230    (set (attr "prefix")
2231      (if_then_else (eq_attr "alternative" "5,6,7,8")
2232        (const_string "maybe_vex")
2233        (const_string "orig")))
2234    (set_attr "mode" "DI,DI,DI,DI,DI,TI,DI,TI,DI,V4SF,V2SF,V4SF,V2SF,DI,DI")])
2235
2236 (define_split
2237   [(set (match_operand:DI 0 "nonimmediate_operand" "")
2238         (match_operand:DI 1 "general_operand" ""))]
2239   "!TARGET_64BIT && reload_completed
2240    && !(MMX_REG_P (operands[0]) || SSE_REG_P (operands[0]))
2241    && !(MMX_REG_P (operands[1]) || SSE_REG_P (operands[1]))"
2242   [(const_int 0)]
2243   "ix86_split_long_move (operands); DONE;")
2244
2245 (define_insn "*movsi_internal"
2246   [(set (match_operand:SI 0 "nonimmediate_operand"
2247                         "=r,m ,*y,*y,?rm,?*y,*x,*x,?r ,m ,?*Yi,*x")
2248         (match_operand:SI 1 "general_operand"
2249                         "g ,re,C ,*y,*y ,rm ,C ,*x,*Yi,*x,r   ,m "))]
2250   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
2251 {
2252   switch (get_attr_type (insn))
2253     {
2254     case TYPE_SSELOG1:
2255       return standard_sse_constant_opcode (insn, operands[1]);
2256
2257     case TYPE_SSEMOV:
2258       switch (get_attr_mode (insn))
2259         {
2260         case MODE_TI:
2261           return "%vmovdqa\t{%1, %0|%0, %1}";
2262         case MODE_V4SF:
2263           return "%vmovaps\t{%1, %0|%0, %1}";
2264         case MODE_SI:
2265           return "%vmovd\t{%1, %0|%0, %1}";
2266         case MODE_SF:
2267           return "%vmovss\t{%1, %0|%0, %1}";
2268         default:
2269           gcc_unreachable ();
2270         }
2271
2272     case TYPE_MMX:
2273       return "pxor\t%0, %0";
2274
2275     case TYPE_MMXMOV:
2276       if (get_attr_mode (insn) == MODE_DI)
2277         return "movq\t{%1, %0|%0, %1}";
2278       return "movd\t{%1, %0|%0, %1}";
2279
2280     case TYPE_LEA:
2281       return "lea{l}\t{%a1, %0|%0, %a1}";
2282
2283     default:
2284       gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1]));
2285       return "mov{l}\t{%1, %0|%0, %1}";
2286     }
2287 }
2288   [(set (attr "type")
2289      (cond [(eq_attr "alternative" "2")
2290               (const_string "mmx")
2291             (eq_attr "alternative" "3,4,5")
2292               (const_string "mmxmov")
2293             (eq_attr "alternative" "6")
2294               (const_string "sselog1")
2295             (eq_attr "alternative" "7,8,9,10,11")
2296               (const_string "ssemov")
2297             (match_operand 1 "pic_32bit_operand" "")
2298               (const_string "lea")
2299            ]
2300            (const_string "imov")))
2301    (set (attr "prefix")
2302      (if_then_else (eq_attr "alternative" "0,1,2,3,4,5")
2303        (const_string "orig")
2304        (const_string "maybe_vex")))
2305    (set (attr "prefix_data16")
2306      (if_then_else (and (eq_attr "type" "ssemov") (eq_attr "mode" "SI"))
2307        (const_string "1")
2308        (const_string "*")))
2309    (set (attr "mode")
2310      (cond [(eq_attr "alternative" "2,3")
2311               (const_string "DI")
2312             (eq_attr "alternative" "6,7")
2313               (if_then_else
2314                 (not (match_test "TARGET_SSE2"))
2315                 (const_string "V4SF")
2316                 (const_string "TI"))
2317             (and (eq_attr "alternative" "8,9,10,11")
2318                  (not (match_test "TARGET_SSE2")))
2319               (const_string "SF")
2320            ]
2321            (const_string "SI")))])
2322
2323 (define_insn "*movhi_internal"
2324   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,m")
2325         (match_operand:HI 1 "general_operand" "r,rn,rm,rn"))]
2326   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
2327 {
2328   switch (get_attr_type (insn))
2329     {
2330     case TYPE_IMOVX:
2331       /* movzwl is faster than movw on p2 due to partial word stalls,
2332          though not as fast as an aligned movl.  */
2333       return "movz{wl|x}\t{%1, %k0|%k0, %1}";
2334     default:
2335       if (get_attr_mode (insn) == MODE_SI)
2336         return "mov{l}\t{%k1, %k0|%k0, %k1}";
2337       else
2338         return "mov{w}\t{%1, %0|%0, %1}";
2339     }
2340 }
2341   [(set (attr "type")
2342      (cond [(match_test "optimize_function_for_size_p (cfun)")
2343               (const_string "imov")
2344             (and (eq_attr "alternative" "0")
2345                  (ior (not (match_test "TARGET_PARTIAL_REG_STALL"))
2346                       (not (match_test "TARGET_HIMODE_MATH"))))
2347               (const_string "imov")
2348             (and (eq_attr "alternative" "1,2")
2349                  (match_operand:HI 1 "aligned_operand" ""))
2350               (const_string "imov")
2351             (and (match_test "TARGET_MOVX")
2352                  (eq_attr "alternative" "0,2"))
2353               (const_string "imovx")
2354            ]
2355            (const_string "imov")))
2356     (set (attr "mode")
2357       (cond [(eq_attr "type" "imovx")
2358                (const_string "SI")
2359              (and (eq_attr "alternative" "1,2")
2360                   (match_operand:HI 1 "aligned_operand" ""))
2361                (const_string "SI")
2362              (and (eq_attr "alternative" "0")
2363                   (ior (not (match_test "TARGET_PARTIAL_REG_STALL"))
2364                        (not (match_test "TARGET_HIMODE_MATH"))))
2365                (const_string "SI")
2366             ]
2367             (const_string "HI")))])
2368
2369 ;; Situation is quite tricky about when to choose full sized (SImode) move
2370 ;; over QImode moves.  For Q_REG -> Q_REG move we use full size only for
2371 ;; partial register dependency machines (such as AMD Athlon), where QImode
2372 ;; moves issue extra dependency and for partial register stalls machines
2373 ;; that don't use QImode patterns (and QImode move cause stall on the next
2374 ;; instruction).
2375 ;;
2376 ;; For loads of Q_REG to NONQ_REG we use full sized moves except for partial
2377 ;; register stall machines with, where we use QImode instructions, since
2378 ;; partial register stall can be caused there.  Then we use movzx.
2379 (define_insn "*movqi_internal"
2380   [(set (match_operand:QI 0 "nonimmediate_operand" "=q,q ,q ,r,r ,?r,m")
2381         (match_operand:QI 1 "general_operand"      " q,qn,qm,q,rn,qm,qn"))]
2382   "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
2383 {
2384   switch (get_attr_type (insn))
2385     {
2386     case TYPE_IMOVX:
2387       gcc_assert (ANY_QI_REG_P (operands[1]) || MEM_P (operands[1]));
2388       return "movz{bl|x}\t{%1, %k0|%k0, %1}";
2389     default:
2390       if (get_attr_mode (insn) == MODE_SI)
2391         return "mov{l}\t{%k1, %k0|%k0, %k1}";
2392       else
2393         return "mov{b}\t{%1, %0|%0, %1}";
2394     }
2395 }
2396   [(set (attr "type")
2397      (cond [(and (eq_attr "alternative" "5")
2398                  (not (match_operand:QI 1 "aligned_operand" "")))
2399               (const_string "imovx")
2400             (match_test "optimize_function_for_size_p (cfun)")
2401               (const_string "imov")
2402             (and (eq_attr "alternative" "3")
2403                  (ior (not (match_test "TARGET_PARTIAL_REG_STALL"))
2404                       (not (match_test "TARGET_QIMODE_MATH"))))
2405               (const_string "imov")
2406             (eq_attr "alternative" "3,5")
2407               (const_string "imovx")
2408             (and (match_test "TARGET_MOVX")
2409                  (eq_attr "alternative" "2"))
2410               (const_string "imovx")
2411            ]
2412            (const_string "imov")))
2413    (set (attr "mode")
2414       (cond [(eq_attr "alternative" "3,4,5")
2415                (const_string "SI")
2416              (eq_attr "alternative" "6")
2417                (const_string "QI")
2418              (eq_attr "type" "imovx")
2419                (const_string "SI")
2420              (and (eq_attr "type" "imov")
2421                   (and (eq_attr "alternative" "0,1")
2422                        (and (match_test "TARGET_PARTIAL_REG_DEPENDENCY")
2423                             (and (not (match_test "optimize_function_for_size_p (cfun)"))
2424                                  (not (match_test "TARGET_PARTIAL_REG_STALL"))))))
2425                (const_string "SI")
2426              ;; Avoid partial register stalls when not using QImode arithmetic
2427              (and (eq_attr "type" "imov")
2428                   (and (eq_attr "alternative" "0,1")
2429                        (and (match_test "TARGET_PARTIAL_REG_STALL")
2430                             (not (match_test "TARGET_QIMODE_MATH")))))
2431                (const_string "SI")
2432            ]
2433            (const_string "QI")))])
2434
2435 ;; Stores and loads of ax to arbitrary constant address.
2436 ;; We fake an second form of instruction to force reload to load address
2437 ;; into register when rax is not available
2438 (define_insn "*movabs<mode>_1"
2439   [(set (mem:SWI1248x (match_operand:DI 0 "x86_64_movabs_operand" "i,r"))
2440         (match_operand:SWI1248x 1 "nonmemory_operand" "a,er"))]
2441   "TARGET_64BIT && ix86_check_movabs (insn, 0)"
2442   "@
2443    movabs{<imodesuffix>}\t{%1, %P0|%P0, %1}
2444    mov{<imodesuffix>}\t{%1, %a0|%a0, %1}"
2445   [(set_attr "type" "imov")
2446    (set_attr "modrm" "0,*")
2447    (set_attr "length_address" "8,0")
2448    (set_attr "length_immediate" "0,*")
2449    (set_attr "memory" "store")
2450    (set_attr "mode" "<MODE>")])
2451
2452 (define_insn "*movabs<mode>_2"
2453   [(set (match_operand:SWI1248x 0 "register_operand" "=a,r")
2454         (mem:SWI1248x (match_operand:DI 1 "x86_64_movabs_operand" "i,r")))]
2455   "TARGET_64BIT && ix86_check_movabs (insn, 1)"
2456   "@
2457    movabs{<imodesuffix>}\t{%P1, %0|%0, %P1}
2458    mov{<imodesuffix>}\t{%a1, %0|%0, %a1}"
2459   [(set_attr "type" "imov")
2460    (set_attr "modrm" "0,*")
2461    (set_attr "length_address" "8,0")
2462    (set_attr "length_immediate" "0")
2463    (set_attr "memory" "load")
2464    (set_attr "mode" "<MODE>")])
2465
2466 (define_insn "*swap<mode>"
2467   [(set (match_operand:SWI48 0 "register_operand" "+r")
2468         (match_operand:SWI48 1 "register_operand" "+r"))
2469    (set (match_dup 1)
2470         (match_dup 0))]
2471   ""
2472   "xchg{<imodesuffix>}\t%1, %0"
2473   [(set_attr "type" "imov")
2474    (set_attr "mode" "<MODE>")
2475    (set_attr "pent_pair" "np")
2476    (set_attr "athlon_decode" "vector")
2477    (set_attr "amdfam10_decode" "double")
2478    (set_attr "bdver1_decode" "double")])
2479
2480 (define_insn "*swap<mode>_1"
2481   [(set (match_operand:SWI12 0 "register_operand" "+r")
2482         (match_operand:SWI12 1 "register_operand" "+r"))
2483    (set (match_dup 1)
2484         (match_dup 0))]
2485   "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
2486   "xchg{l}\t%k1, %k0"
2487   [(set_attr "type" "imov")
2488    (set_attr "mode" "SI")
2489    (set_attr "pent_pair" "np")
2490    (set_attr "athlon_decode" "vector")
2491    (set_attr "amdfam10_decode" "double")
2492    (set_attr "bdver1_decode" "double")])
2493
2494 ;; Not added amdfam10_decode since TARGET_PARTIAL_REG_STALL
2495 ;; is disabled for AMDFAM10
2496 (define_insn "*swap<mode>_2"
2497   [(set (match_operand:SWI12 0 "register_operand" "+<r>")
2498         (match_operand:SWI12 1 "register_operand" "+<r>"))
2499    (set (match_dup 1)
2500         (match_dup 0))]
2501   "TARGET_PARTIAL_REG_STALL"
2502   "xchg{<imodesuffix>}\t%1, %0"
2503   [(set_attr "type" "imov")
2504    (set_attr "mode" "<MODE>")
2505    (set_attr "pent_pair" "np")
2506    (set_attr "athlon_decode" "vector")])
2507
2508 (define_expand "movstrict<mode>"
2509   [(set (strict_low_part (match_operand:SWI12 0 "nonimmediate_operand" ""))
2510         (match_operand:SWI12 1 "general_operand" ""))]
2511   ""
2512 {
2513   if (TARGET_PARTIAL_REG_STALL && optimize_function_for_speed_p (cfun))
2514     FAIL;
2515   if (GET_CODE (operands[0]) == SUBREG
2516       && GET_MODE_CLASS (GET_MODE (SUBREG_REG (operands[0]))) != MODE_INT)
2517     FAIL;
2518   /* Don't generate memory->memory moves, go through a register */
2519   if (MEM_P (operands[0]) && MEM_P (operands[1]))
2520     operands[1] = force_reg (<MODE>mode, operands[1]);
2521 })
2522
2523 (define_insn "*movstrict<mode>_1"
2524   [(set (strict_low_part
2525           (match_operand:SWI12 0 "nonimmediate_operand" "+<r>m,<r>"))
2526         (match_operand:SWI12 1 "general_operand" "<r>n,m"))]
2527   "(!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
2528    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2529   "mov{<imodesuffix>}\t{%1, %0|%0, %1}"
2530   [(set_attr "type" "imov")
2531    (set_attr "mode" "<MODE>")])
2532
2533 (define_insn "*movstrict<mode>_xor"
2534   [(set (strict_low_part (match_operand:SWI12 0 "register_operand" "+<r>"))
2535         (match_operand:SWI12 1 "const0_operand" ""))
2536    (clobber (reg:CC FLAGS_REG))]
2537   "reload_completed"
2538   "xor{<imodesuffix>}\t%0, %0"
2539   [(set_attr "type" "alu1")
2540    (set_attr "mode" "<MODE>")
2541    (set_attr "length_immediate" "0")])
2542
2543 (define_insn "*mov<mode>_extv_1"
2544   [(set (match_operand:SWI24 0 "register_operand" "=R")
2545         (sign_extract:SWI24 (match_operand 1 "ext_register_operand" "Q")
2546                             (const_int 8)
2547                             (const_int 8)))]
2548   ""
2549   "movs{bl|x}\t{%h1, %k0|%k0, %h1}"
2550   [(set_attr "type" "imovx")
2551    (set_attr "mode" "SI")])
2552
2553 (define_insn "*movqi_extv_1_rex64"
2554   [(set (match_operand:QI 0 "register_operand" "=Q,?R")
2555         (sign_extract:QI (match_operand 1 "ext_register_operand" "Q,Q")
2556                          (const_int 8)
2557                          (const_int 8)))]
2558   "TARGET_64BIT"
2559 {
2560   switch (get_attr_type (insn))
2561     {
2562     case TYPE_IMOVX:
2563       return "movs{bl|x}\t{%h1, %k0|%k0, %h1}";
2564     default:
2565       return "mov{b}\t{%h1, %0|%0, %h1}";
2566     }
2567 }
2568   [(set (attr "type")
2569      (if_then_else (ior (not (match_operand:QI 0 "QIreg_operand" ""))
2570                         (match_test "TARGET_MOVX"))
2571         (const_string "imovx")
2572         (const_string "imov")))
2573    (set (attr "mode")
2574      (if_then_else (eq_attr "type" "imovx")
2575         (const_string "SI")
2576         (const_string "QI")))])
2577
2578 (define_insn "*movqi_extv_1"
2579   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?r")
2580         (sign_extract:QI (match_operand 1 "ext_register_operand" "Q,Q")
2581                          (const_int 8)
2582                          (const_int 8)))]
2583   "!TARGET_64BIT"
2584 {
2585   switch (get_attr_type (insn))
2586     {
2587     case TYPE_IMOVX:
2588       return "movs{bl|x}\t{%h1, %k0|%k0, %h1}";
2589     default:
2590       return "mov{b}\t{%h1, %0|%0, %h1}";
2591     }
2592 }
2593   [(set (attr "type")
2594      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2595                         (ior (not (match_operand:QI 0 "QIreg_operand" ""))
2596                              (match_test "TARGET_MOVX")))
2597         (const_string "imovx")
2598         (const_string "imov")))
2599    (set (attr "mode")
2600      (if_then_else (eq_attr "type" "imovx")
2601         (const_string "SI")
2602         (const_string "QI")))])
2603
2604 (define_insn "*mov<mode>_extzv_1"
2605   [(set (match_operand:SWI48 0 "register_operand" "=R")
2606         (zero_extract:SWI48 (match_operand 1 "ext_register_operand" "Q")
2607                             (const_int 8)
2608                             (const_int 8)))]
2609   ""
2610   "movz{bl|x}\t{%h1, %k0|%k0, %h1}"
2611   [(set_attr "type" "imovx")
2612    (set_attr "mode" "SI")])
2613
2614 (define_insn "*movqi_extzv_2_rex64"
2615   [(set (match_operand:QI 0 "register_operand" "=Q,?R")
2616         (subreg:QI
2617           (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
2618                            (const_int 8)
2619                            (const_int 8)) 0))]
2620   "TARGET_64BIT"
2621 {
2622   switch (get_attr_type (insn))
2623     {
2624     case TYPE_IMOVX:
2625       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2626     default:
2627       return "mov{b}\t{%h1, %0|%0, %h1}";
2628     }
2629 }
2630   [(set (attr "type")
2631      (if_then_else (ior (not (match_operand:QI 0 "QIreg_operand" ""))
2632                         (match_test "TARGET_MOVX"))
2633         (const_string "imovx")
2634         (const_string "imov")))
2635    (set (attr "mode")
2636      (if_then_else (eq_attr "type" "imovx")
2637         (const_string "SI")
2638         (const_string "QI")))])
2639
2640 (define_insn "*movqi_extzv_2"
2641   [(set (match_operand:QI 0 "nonimmediate_operand" "=Qm,?R")
2642         (subreg:QI
2643           (zero_extract:SI (match_operand 1 "ext_register_operand" "Q,Q")
2644                            (const_int 8)
2645                            (const_int 8)) 0))]
2646   "!TARGET_64BIT"
2647 {
2648   switch (get_attr_type (insn))
2649     {
2650     case TYPE_IMOVX:
2651       return "movz{bl|x}\t{%h1, %k0|%k0, %h1}";
2652     default:
2653       return "mov{b}\t{%h1, %0|%0, %h1}";
2654     }
2655 }
2656   [(set (attr "type")
2657      (if_then_else (and (match_operand:QI 0 "register_operand" "")
2658                         (ior (not (match_operand:QI 0 "QIreg_operand" ""))
2659                              (match_test "TARGET_MOVX")))
2660         (const_string "imovx")
2661         (const_string "imov")))
2662    (set (attr "mode")
2663      (if_then_else (eq_attr "type" "imovx")
2664         (const_string "SI")
2665         (const_string "QI")))])
2666
2667 (define_expand "mov<mode>_insv_1"
2668   [(set (zero_extract:SWI48 (match_operand 0 "ext_register_operand" "")
2669                             (const_int 8)
2670                             (const_int 8))
2671         (match_operand:SWI48 1 "nonmemory_operand" ""))])
2672
2673 (define_insn "*mov<mode>_insv_1_rex64"
2674   [(set (zero_extract:SWI48x (match_operand 0 "ext_register_operand" "+Q")
2675                              (const_int 8)
2676                              (const_int 8))
2677         (match_operand:SWI48x 1 "nonmemory_operand" "Qn"))]
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 "*movsi_insv_1"
2684   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2685                          (const_int 8)
2686                          (const_int 8))
2687         (match_operand:SI 1 "general_operand" "Qmn"))]
2688   "!TARGET_64BIT"
2689   "mov{b}\t{%b1, %h0|%h0, %b1}"
2690   [(set_attr "type" "imov")
2691    (set_attr "mode" "QI")])
2692
2693 (define_insn "*movqi_insv_2"
2694   [(set (zero_extract:SI (match_operand 0 "ext_register_operand" "+Q")
2695                          (const_int 8)
2696                          (const_int 8))
2697         (lshiftrt:SI (match_operand:SI 1 "register_operand" "Q")
2698                      (const_int 8)))]
2699   ""
2700   "mov{b}\t{%h1, %h0|%h0, %h1}"
2701   [(set_attr "type" "imov")
2702    (set_attr "mode" "QI")])
2703 \f
2704 ;; Floating point push instructions.
2705
2706 (define_insn "*pushtf"
2707   [(set (match_operand:TF 0 "push_operand" "=<,<,<")
2708         (match_operand:TF 1 "general_no_elim_operand" "x,Fo,*r"))]
2709   "TARGET_SSE2"
2710 {
2711   /* This insn should be already split before reg-stack.  */
2712   gcc_unreachable ();
2713 }
2714   [(set_attr "type" "multi")
2715    (set_attr "unit" "sse,*,*")
2716    (set_attr "mode" "TF,SI,SI")])
2717
2718 ;; %%% Kill this when call knows how to work this out.
2719 (define_split
2720   [(set (match_operand:TF 0 "push_operand" "")
2721         (match_operand:TF 1 "sse_reg_operand" ""))]
2722   "TARGET_SSE2 && reload_completed"
2723   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -16)))
2724    (set (mem:TF (reg:P SP_REG)) (match_dup 1))])
2725
2726 (define_insn "*pushxf"
2727   [(set (match_operand:XF 0 "push_operand" "=<,<")
2728         (match_operand:XF 1 "general_no_elim_operand" "f,ro"))]
2729   "optimize_function_for_speed_p (cfun)"
2730 {
2731   /* This insn should be already split before reg-stack.  */
2732   gcc_unreachable ();
2733 }
2734   [(set_attr "type" "multi")
2735    (set_attr "unit" "i387,*")
2736    (set_attr "mode" "XF,SI")])
2737
2738 ;; Size of pushxf is 3 (for sub) + 2 (for fstp) + memory operand size.
2739 ;; Size of pushxf using integer instructions is 3+3*memory operand size
2740 ;; Pushing using integer instructions is longer except for constants
2741 ;; and direct memory references (assuming that any given constant is pushed
2742 ;; only once, but this ought to be handled elsewhere).
2743
2744 (define_insn "*pushxf_nointeger"
2745   [(set (match_operand:XF 0 "push_operand" "=<,<")
2746         (match_operand:XF 1 "general_no_elim_operand" "f,*rFo"))]
2747   "optimize_function_for_size_p (cfun)"
2748 {
2749   /* This insn should be already split before reg-stack.  */
2750   gcc_unreachable ();
2751 }
2752   [(set_attr "type" "multi")
2753    (set_attr "unit" "i387,*")
2754    (set_attr "mode" "XF,SI")])
2755
2756 ;; %%% Kill this when call knows how to work this out.
2757 (define_split
2758   [(set (match_operand:XF 0 "push_operand" "")
2759         (match_operand:XF 1 "fp_register_operand" ""))]
2760   "reload_completed"
2761   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
2762    (set (mem:XF (reg:P SP_REG)) (match_dup 1))]
2763   "operands[2] = GEN_INT (-GET_MODE_SIZE (XFmode));")
2764
2765 (define_insn "*pushdf_rex64"
2766   [(set (match_operand:DF 0 "push_operand" "=<,<,<")
2767         (match_operand:DF 1 "general_no_elim_operand" "f,Yd*rFm,x"))]
2768   "TARGET_64BIT"
2769 {
2770   /* This insn should be already split before reg-stack.  */
2771   gcc_unreachable ();
2772 }
2773   [(set_attr "type" "multi")
2774    (set_attr "unit" "i387,*,*")
2775    (set_attr "mode" "DF,DI,DF")])
2776
2777 ;; Size of pushdf is 3 (for sub) + 2 (for fstp) + memory operand size.
2778 ;; Size of pushdf using integer instructions is 2+2*memory operand size
2779 ;; On the average, pushdf using integers can be still shorter.
2780
2781 (define_insn "*pushdf"
2782   [(set (match_operand:DF 0 "push_operand" "=<,<,<")
2783         (match_operand:DF 1 "general_no_elim_operand" "f,Yd*rFo,x"))]
2784   "!TARGET_64BIT"
2785 {
2786   /* This insn should be already split before reg-stack.  */
2787   gcc_unreachable ();
2788 }
2789   [(set_attr "isa" "*,*,sse2")
2790    (set_attr "type" "multi")
2791    (set_attr "unit" "i387,*,*")
2792    (set_attr "mode" "DF,DI,DF")])
2793
2794 ;; %%% Kill this when call knows how to work this out.
2795 (define_split
2796   [(set (match_operand:DF 0 "push_operand" "")
2797         (match_operand:DF 1 "any_fp_register_operand" ""))]
2798   "reload_completed"
2799   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (const_int -8)))
2800    (set (mem:DF (reg:P SP_REG)) (match_dup 1))])
2801
2802 (define_insn "*pushsf_rex64"
2803   [(set (match_operand:SF 0 "push_operand" "=X,X,X")
2804         (match_operand:SF 1 "nonmemory_no_elim_operand" "f,rF,x"))]
2805   "TARGET_64BIT"
2806 {
2807   /* Anything else should be already split before reg-stack.  */
2808   gcc_assert (which_alternative == 1);
2809   return "push{q}\t%q1";
2810 }
2811   [(set_attr "type" "multi,push,multi")
2812    (set_attr "unit" "i387,*,*")
2813    (set_attr "mode" "SF,DI,SF")])
2814
2815 (define_insn "*pushsf"
2816   [(set (match_operand:SF 0 "push_operand" "=<,<,<")
2817         (match_operand:SF 1 "general_no_elim_operand" "f,rFm,x"))]
2818   "!TARGET_64BIT"
2819 {
2820   /* Anything else should be already split before reg-stack.  */
2821   gcc_assert (which_alternative == 1);
2822   return "push{l}\t%1";
2823 }
2824   [(set_attr "type" "multi,push,multi")
2825    (set_attr "unit" "i387,*,*")
2826    (set_attr "mode" "SF,SI,SF")])
2827
2828 ;; %%% Kill this when call knows how to work this out.
2829 (define_split
2830   [(set (match_operand:SF 0 "push_operand" "")
2831         (match_operand:SF 1 "any_fp_register_operand" ""))]
2832   "reload_completed"
2833   [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
2834    (set (mem:SF (reg:P SP_REG)) (match_dup 1))]
2835   "operands[2] = GEN_INT (-GET_MODE_SIZE (<P:MODE>mode));")
2836
2837 (define_split
2838   [(set (match_operand:SF 0 "push_operand" "")
2839         (match_operand:SF 1 "memory_operand" ""))]
2840   "reload_completed
2841    && (operands[2] = find_constant_src (insn))"
2842   [(set (match_dup 0) (match_dup 2))])
2843
2844 (define_split
2845   [(set (match_operand 0 "push_operand" "")
2846         (match_operand 1 "general_operand" ""))]
2847   "reload_completed
2848    && (GET_MODE (operands[0]) == TFmode
2849        || GET_MODE (operands[0]) == XFmode
2850        || GET_MODE (operands[0]) == DFmode)
2851    && !ANY_FP_REG_P (operands[1])"
2852   [(const_int 0)]
2853   "ix86_split_long_move (operands); DONE;")
2854 \f
2855 ;; Floating point move instructions.
2856
2857 (define_expand "movtf"
2858   [(set (match_operand:TF 0 "nonimmediate_operand" "")
2859         (match_operand:TF 1 "nonimmediate_operand" ""))]
2860   "TARGET_SSE2"
2861 {
2862   ix86_expand_move (TFmode, operands);
2863   DONE;
2864 })
2865
2866 (define_expand "mov<mode>"
2867   [(set (match_operand:X87MODEF 0 "nonimmediate_operand" "")
2868         (match_operand:X87MODEF 1 "general_operand" ""))]
2869   ""
2870   "ix86_expand_move (<MODE>mode, operands); DONE;")
2871
2872 (define_insn "*movtf_internal"
2873   [(set (match_operand:TF 0 "nonimmediate_operand" "=x,m,x,?*r ,!o")
2874         (match_operand:TF 1 "general_operand"      "xm,x,C,*roF,F*r"))]
2875   "TARGET_SSE2
2876    && !(MEM_P (operands[0]) && MEM_P (operands[1]))
2877    && (!can_create_pseudo_p ()
2878        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
2879        || GET_CODE (operands[1]) != CONST_DOUBLE
2880        || (optimize_function_for_size_p (cfun)
2881            && standard_sse_constant_p (operands[1])
2882            && !memory_operand (operands[0], TFmode))
2883        || (!TARGET_MEMORY_MISMATCH_STALL
2884            && memory_operand (operands[0], TFmode)))"
2885 {
2886   switch (which_alternative)
2887     {
2888     case 0:
2889     case 1:
2890       /* Handle misaligned load/store since we
2891          don't have movmisaligntf pattern. */
2892       if (misaligned_operand (operands[0], TFmode)
2893           || misaligned_operand (operands[1], TFmode))
2894         {
2895           if (get_attr_mode (insn) == MODE_V4SF)
2896             return "%vmovups\t{%1, %0|%0, %1}";
2897           else
2898             return "%vmovdqu\t{%1, %0|%0, %1}";
2899         }
2900       else
2901         {
2902           if (get_attr_mode (insn) == MODE_V4SF)
2903             return "%vmovaps\t{%1, %0|%0, %1}";
2904           else
2905             return "%vmovdqa\t{%1, %0|%0, %1}";
2906         }
2907
2908     case 2:
2909       return standard_sse_constant_opcode (insn, operands[1]);
2910
2911     case 3:
2912     case 4:
2913         return "#";
2914
2915     default:
2916       gcc_unreachable ();
2917     }
2918 }
2919   [(set_attr "type" "ssemov,ssemov,sselog1,*,*")
2920    (set_attr "prefix" "maybe_vex,maybe_vex,maybe_vex,*,*")
2921    (set (attr "mode")
2922         (cond [(eq_attr "alternative" "0,2")
2923                  (if_then_else
2924                    (match_test "optimize_function_for_size_p (cfun)")
2925                    (const_string "V4SF")
2926                    (const_string "TI"))
2927                (eq_attr "alternative" "1")
2928                  (if_then_else
2929                    (ior (match_test "TARGET_SSE_TYPELESS_STORES")
2930                         (match_test "optimize_function_for_size_p (cfun)"))
2931                    (const_string "V4SF")
2932                    (const_string "TI"))]
2933                (const_string "DI")))])
2934
2935 ;; Possible store forwarding (partial memory) stall in alternative 4.
2936 (define_insn "*movxf_internal"
2937   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,?Yx*r ,!o")
2938         (match_operand:XF 1 "general_operand"      "fm,f,G,Yx*roF,FYx*r"))]
2939   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
2940    && (!can_create_pseudo_p ()
2941        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
2942        || GET_CODE (operands[1]) != CONST_DOUBLE
2943        || (optimize_function_for_size_p (cfun)
2944            && standard_80387_constant_p (operands[1]) > 0
2945            && !memory_operand (operands[0], XFmode))
2946        || (!TARGET_MEMORY_MISMATCH_STALL
2947            && memory_operand (operands[0], XFmode)))"
2948 {
2949   switch (which_alternative)
2950     {
2951     case 0:
2952     case 1:
2953       return output_387_reg_move (insn, operands);
2954
2955     case 2:
2956       return standard_80387_constant_opcode (operands[1]);
2957
2958     case 3:
2959     case 4:
2960       return "#";
2961
2962     default:
2963       gcc_unreachable ();
2964     }
2965 }
2966   [(set_attr "type" "fmov,fmov,fmov,multi,multi")
2967    (set_attr "mode" "XF,XF,XF,SI,SI")])
2968
2969 (define_insn "*movdf_internal_rex64"
2970   [(set (match_operand:DF 0 "nonimmediate_operand"
2971                 "=f,m,f,?r,?m,?r,!o,x,x,x,m,Yi,r ")
2972         (match_operand:DF 1 "general_operand"
2973                 "fm,f,G,rm,r ,F ,F ,C,x,m,x,r ,Yi"))]
2974   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))
2975    && (!can_create_pseudo_p ()
2976        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
2977        || GET_CODE (operands[1]) != CONST_DOUBLE
2978        || (optimize_function_for_size_p (cfun)
2979            && ((!(TARGET_SSE2 && TARGET_SSE_MATH)
2980                 && standard_80387_constant_p (operands[1]) > 0)
2981                || (TARGET_SSE2 && TARGET_SSE_MATH
2982                    && standard_sse_constant_p (operands[1]))))
2983        || memory_operand (operands[0], DFmode))"
2984 {
2985   switch (which_alternative)
2986     {
2987     case 0:
2988     case 1:
2989       return output_387_reg_move (insn, operands);
2990
2991     case 2:
2992       return standard_80387_constant_opcode (operands[1]);
2993
2994     case 3:
2995     case 4:
2996       return "mov{q}\t{%1, %0|%0, %1}";
2997
2998     case 5:
2999       return "movabs{q}\t{%1, %0|%0, %1}";
3000
3001     case 6:
3002       return "#";
3003
3004     case 7:
3005       return standard_sse_constant_opcode (insn, operands[1]);
3006
3007     case 8:
3008     case 9:
3009     case 10:
3010       switch (get_attr_mode (insn))
3011         {
3012         case MODE_V2DF:
3013           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
3014             return "%vmovapd\t{%1, %0|%0, %1}";
3015         case MODE_V4SF:
3016           return "%vmovaps\t{%1, %0|%0, %1}";
3017
3018         case MODE_DI:
3019           return "%vmovq\t{%1, %0|%0, %1}";
3020         case MODE_DF:
3021           if (TARGET_AVX && REG_P (operands[0]) && REG_P (operands[1]))
3022             return "vmovsd\t{%1, %0, %0|%0, %0, %1}";
3023           return "%vmovsd\t{%1, %0|%0, %1}";
3024         case MODE_V1DF:
3025           return "%vmovlpd\t{%1, %d0|%d0, %1}";
3026         case MODE_V2SF:
3027           return "%vmovlps\t{%1, %d0|%d0, %1}";
3028         default:
3029           gcc_unreachable ();
3030         }
3031
3032     case 11:
3033     case 12:
3034       /* Handle broken assemblers that require movd instead of movq.  */
3035       return "%vmovd\t{%1, %0|%0, %1}";
3036
3037     default:
3038       gcc_unreachable();
3039     }
3040 }
3041   [(set (attr "type")
3042         (cond [(eq_attr "alternative" "0,1,2")
3043                  (const_string "fmov")
3044                (eq_attr "alternative" "3,4,5")
3045                  (const_string "imov")
3046                (eq_attr "alternative" "6")
3047                  (const_string "multi")
3048                (eq_attr "alternative" "7")
3049                  (const_string "sselog1")
3050               ]
3051               (const_string "ssemov")))
3052    (set (attr "modrm")
3053      (if_then_else
3054        (and (eq_attr "alternative" "5") (eq_attr "type" "imov"))
3055          (const_string "0")
3056          (const_string "*")))
3057    (set (attr "length_immediate")
3058      (if_then_else
3059        (and (eq_attr "alternative" "5") (eq_attr "type" "imov"))
3060          (const_string "8")
3061          (const_string "*")))
3062    (set (attr "prefix")
3063      (if_then_else (eq_attr "alternative" "0,1,2,3,4,5,6")
3064        (const_string "orig")
3065        (const_string "maybe_vex")))
3066    (set (attr "prefix_data16")
3067      (if_then_else (eq_attr "mode" "V1DF")
3068        (const_string "1")
3069        (const_string "*")))
3070    (set (attr "mode")
3071         (cond [(eq_attr "alternative" "0,1,2")
3072                  (const_string "DF")
3073                (eq_attr "alternative" "3,4,5,6,11,12")
3074                  (const_string "DI")
3075
3076                /* xorps is one byte shorter.  */
3077                (eq_attr "alternative" "7")
3078                  (cond [(match_test "optimize_function_for_size_p (cfun)")
3079                           (const_string "V4SF")
3080                         (match_test "TARGET_SSE_LOAD0_BY_PXOR")
3081                           (const_string "TI")
3082                        ]
3083                        (const_string "V2DF"))
3084
3085                /* For architectures resolving dependencies on
3086                   whole SSE registers use APD move to break dependency
3087                   chains, otherwise use short move to avoid extra work.
3088
3089                   movaps encodes one byte shorter.  */
3090                (eq_attr "alternative" "8")
3091                  (cond
3092                    [(match_test "optimize_function_for_size_p (cfun)")
3093                       (const_string "V4SF")
3094                     (match_test "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3095                       (const_string "V2DF")
3096                    ]
3097                    (const_string "DF"))
3098                /* For architectures resolving dependencies on register
3099                   parts we may avoid extra work to zero out upper part
3100                   of register.  */
3101                (eq_attr "alternative" "9")
3102                  (if_then_else
3103                    (match_test "TARGET_SSE_SPLIT_REGS")
3104                    (const_string "V1DF")
3105                    (const_string "DF"))
3106               ]
3107               (const_string "DF")))])
3108
3109 ;; Possible store forwarding (partial memory) stall in alternative 4.
3110 (define_insn "*movdf_internal"
3111   [(set (match_operand:DF 0 "nonimmediate_operand"
3112                 "=f,m,f,?Yd*r ,!o   ,x,x,x,m,*x,*x,*x,m")
3113         (match_operand:DF 1 "general_operand"
3114                 "fm,f,G,Yd*roF,FYd*r,C,x,m,x,C ,*x,m ,*x"))]
3115   "!TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))
3116    && (!can_create_pseudo_p ()
3117        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3118        || GET_CODE (operands[1]) != CONST_DOUBLE
3119        || (optimize_function_for_size_p (cfun)
3120            && ((!(TARGET_SSE2 && TARGET_SSE_MATH)
3121                 && standard_80387_constant_p (operands[1]) > 0)
3122                || (TARGET_SSE2 && TARGET_SSE_MATH
3123                    && standard_sse_constant_p (operands[1])))
3124            && !memory_operand (operands[0], DFmode))
3125        || (!TARGET_MEMORY_MISMATCH_STALL
3126            && memory_operand (operands[0], DFmode)))"
3127 {
3128   switch (which_alternative)
3129     {
3130     case 0:
3131     case 1:
3132       return output_387_reg_move (insn, operands);
3133
3134     case 2:
3135       return standard_80387_constant_opcode (operands[1]);
3136
3137     case 3:
3138     case 4:
3139       return "#";
3140
3141     case 5:
3142     case 9:
3143       return standard_sse_constant_opcode (insn, operands[1]);
3144
3145     case 6:
3146     case 7:
3147     case 8:
3148     case 10:
3149     case 11:
3150     case 12:
3151       switch (get_attr_mode (insn))
3152         {
3153         case MODE_V2DF:
3154           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
3155             return "%vmovapd\t{%1, %0|%0, %1}";
3156         case MODE_V4SF:
3157           return "%vmovaps\t{%1, %0|%0, %1}";
3158
3159         case MODE_DI:
3160           return "%vmovq\t{%1, %0|%0, %1}";
3161         case MODE_DF:
3162           if (TARGET_AVX && REG_P (operands[0]) && REG_P (operands[1]))
3163             return "vmovsd\t{%1, %0, %0|%0, %0, %1}";
3164           return "%vmovsd\t{%1, %0|%0, %1}";
3165         case MODE_V1DF:
3166           return "%vmovlpd\t{%1, %d0|%d0, %1}";
3167         case MODE_V2SF:
3168           return "%vmovlps\t{%1, %d0|%d0, %1}";
3169         default:
3170           gcc_unreachable ();
3171         }
3172
3173     default:
3174       gcc_unreachable ();
3175     }
3176 }
3177   [(set (attr "isa")
3178      (if_then_else (eq_attr "alternative" "5,6,7,8")
3179        (const_string "sse2")
3180        (const_string "*")))
3181    (set (attr "type")
3182         (cond [(eq_attr "alternative" "0,1,2")
3183                  (const_string "fmov")
3184                (eq_attr "alternative" "3,4")
3185                  (const_string "multi")
3186                (eq_attr "alternative" "5,9")
3187                  (const_string "sselog1")
3188               ]
3189               (const_string "ssemov")))
3190    (set (attr "prefix")
3191      (if_then_else (eq_attr "alternative" "0,1,2,3,4")
3192        (const_string "orig")
3193        (const_string "maybe_vex")))
3194    (set (attr "prefix_data16")
3195      (if_then_else (eq_attr "mode" "V1DF")
3196        (const_string "1")
3197        (const_string "*")))
3198    (set (attr "mode")
3199         (cond [(eq_attr "alternative" "0,1,2")
3200                  (const_string "DF")
3201                (eq_attr "alternative" "3,4")
3202                  (const_string "SI")
3203
3204                /* For SSE1, we have many fewer alternatives.  */
3205                (not (match_test "TARGET_SSE2"))
3206                  (if_then_else
3207                    (eq_attr "alternative" "5,6,9,10")
3208                    (const_string "V4SF")
3209                    (const_string "V2SF"))
3210
3211                /* xorps is one byte shorter.  */
3212                (eq_attr "alternative" "5,9")
3213                  (cond [(match_test "optimize_function_for_size_p (cfun)")
3214                           (const_string "V4SF")
3215                         (match_test "TARGET_SSE_LOAD0_BY_PXOR")
3216                           (const_string "TI")
3217                        ]
3218                        (const_string "V2DF"))
3219
3220                /* For architectures resolving dependencies on
3221                   whole SSE registers use APD move to break dependency
3222                   chains, otherwise use short move to avoid extra work.
3223
3224                   movaps encodes one byte shorter.  */
3225                (eq_attr "alternative" "6,10")
3226                  (cond
3227                    [(match_test "optimize_function_for_size_p (cfun)")
3228                       (const_string "V4SF")
3229                     (match_test "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3230                       (const_string "V2DF")
3231                    ]
3232                    (const_string "DF"))
3233                /* For architectures resolving dependencies on register
3234                   parts we may avoid extra work to zero out upper part
3235                   of register.  */
3236                (eq_attr "alternative" "7,11")
3237                  (if_then_else
3238                    (match_test "TARGET_SSE_SPLIT_REGS")
3239                    (const_string "V1DF")
3240                    (const_string "DF"))
3241               ]
3242               (const_string "DF")))])
3243
3244 (define_insn "*movsf_internal"
3245   [(set (match_operand:SF 0 "nonimmediate_operand"
3246           "=f,m,f,?r ,?m,x,x,x,m,!*y,!m,!*y,?Yi,?r,!*Ym,!r")
3247         (match_operand:SF 1 "general_operand"
3248           "fm,f,G,rmF,Fr,C,x,m,x,m  ,*y,*y ,r  ,Yi,r   ,*Ym"))]
3249   "!(MEM_P (operands[0]) && MEM_P (operands[1]))
3250    && (!can_create_pseudo_p ()
3251        || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
3252        || GET_CODE (operands[1]) != CONST_DOUBLE
3253        || (optimize_function_for_size_p (cfun)
3254            && ((!TARGET_SSE_MATH
3255                 && standard_80387_constant_p (operands[1]) > 0)
3256                || (TARGET_SSE_MATH
3257                    && standard_sse_constant_p (operands[1]))))
3258        || memory_operand (operands[0], SFmode))"
3259 {
3260   switch (which_alternative)
3261     {
3262     case 0:
3263     case 1:
3264       return output_387_reg_move (insn, operands);
3265
3266     case 2:
3267       return standard_80387_constant_opcode (operands[1]);
3268
3269     case 3:
3270     case 4:
3271       return "mov{l}\t{%1, %0|%0, %1}";
3272
3273     case 5:
3274       return standard_sse_constant_opcode (insn, operands[1]);
3275
3276     case 6:
3277       if (get_attr_mode (insn) == MODE_V4SF)
3278         return "%vmovaps\t{%1, %0|%0, %1}";
3279       if (TARGET_AVX)
3280         return "vmovss\t{%1, %0, %0|%0, %0, %1}";
3281
3282     case 7:
3283     case 8:
3284       return "%vmovss\t{%1, %0|%0, %1}";
3285
3286     case 9:
3287     case 10:
3288     case 14:
3289     case 15:
3290       return "movd\t{%1, %0|%0, %1}";
3291
3292     case 11:
3293       return "movq\t{%1, %0|%0, %1}";
3294
3295     case 12:
3296     case 13:
3297       return "%vmovd\t{%1, %0|%0, %1}";
3298
3299     default:
3300       gcc_unreachable ();
3301     }
3302 }
3303   [(set (attr "type")
3304         (cond [(eq_attr "alternative" "0,1,2")
3305                  (const_string "fmov")
3306                (eq_attr "alternative" "3,4")
3307                  (const_string "multi")
3308                (eq_attr "alternative" "5")
3309                  (const_string "sselog1")
3310                (eq_attr "alternative" "9,10,11,14,15")
3311                  (const_string "mmxmov")
3312               ]
3313               (const_string "ssemov")))
3314    (set (attr "prefix")
3315      (if_then_else (eq_attr "alternative" "5,6,7,8,12,13")
3316        (const_string "maybe_vex")
3317        (const_string "orig")))
3318    (set (attr "mode")
3319         (cond [(eq_attr "alternative" "3,4,9,10")
3320                  (const_string "SI")
3321                (eq_attr "alternative" "5")
3322                  (if_then_else
3323                    (and (and (match_test "TARGET_SSE_LOAD0_BY_PXOR")
3324                              (match_test "TARGET_SSE2"))
3325                         (not (match_test "optimize_function_for_size_p (cfun)")))
3326                    (const_string "TI")
3327                    (const_string "V4SF"))
3328                /* For architectures resolving dependencies on
3329                   whole SSE registers use APS move to break dependency
3330                   chains, otherwise use short move to avoid extra work.
3331
3332                   Do the same for architectures resolving dependencies on
3333                   the parts.  While in DF mode it is better to always handle
3334                   just register parts, the SF mode is different due to lack
3335                   of instructions to load just part of the register.  It is
3336                   better to maintain the whole registers in single format
3337                   to avoid problems on using packed logical operations.  */
3338                (eq_attr "alternative" "6")
3339                  (if_then_else
3340                    (ior (match_test "TARGET_SSE_PARTIAL_REG_DEPENDENCY")
3341                         (match_test "TARGET_SSE_SPLIT_REGS"))
3342                    (const_string "V4SF")
3343                    (const_string "SF"))
3344                (eq_attr "alternative" "11")
3345                  (const_string "DI")]
3346                (const_string "SF")))])
3347
3348 (define_split
3349   [(set (match_operand 0 "any_fp_register_operand" "")
3350         (match_operand 1 "memory_operand" ""))]
3351   "reload_completed
3352    && (GET_MODE (operands[0]) == TFmode
3353        || GET_MODE (operands[0]) == XFmode
3354        || GET_MODE (operands[0]) == DFmode
3355        || GET_MODE (operands[0]) == SFmode)
3356    && (operands[2] = find_constant_src (insn))"
3357   [(set (match_dup 0) (match_dup 2))]
3358 {
3359   rtx c = operands[2];
3360   int r = REGNO (operands[0]);
3361
3362   if ((SSE_REGNO_P (r) && !standard_sse_constant_p (c))
3363       || (FP_REGNO_P (r) && standard_80387_constant_p (c) < 1))
3364     FAIL;
3365 })
3366
3367 (define_split
3368   [(set (match_operand 0 "any_fp_register_operand" "")
3369         (float_extend (match_operand 1 "mem