OSDN Git Service

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