OSDN Git Service

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