OSDN Git Service

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