OSDN Git Service

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