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