OSDN Git Service

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