OSDN Git Service

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