gcc/config/i386/sse.md

   1 ;; GCC machine description for SSE instructions
   2 ;; Copyright (C) 2005, 2006, 2007
   3 ;; Free Software Foundation, Inc.
   4 ;;
   5 ;; This file is part of GCC.
   6 ;;
   7 ;; GCC is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published by
   9 ;; the Free Software Foundation; either version 3, or (at your option)
  10 ;; any later version.
  11 ;;
  12 ;; GCC is distributed in the hope that it will be useful,
  13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 ;; GNU General Public License for more details.
  16 ;;
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with GCC; see the file COPYING3.  If not see
  19 ;; <http://www.gnu.org/licenses/>.
  20
  21
  22 ;; 16 byte integral modes handled by SSE, minus TImode, which gets
  23 ;; special-cased for TARGET_64BIT.
  24 (define_mode_iterator SSEMODEI [V16QI V8HI V4SI V2DI])
  25
  26 ;; All 16-byte vector modes handled by SSE
  27 (define_mode_iterator SSEMODE [V16QI V8HI V4SI V2DI V4SF V2DF])
  28
  29 ;; Mix-n-match
  30 (define_mode_iterator SSEMODE12 [V16QI V8HI])
  31 (define_mode_iterator SSEMODE24 [V8HI V4SI])
  32 (define_mode_iterator SSEMODE14 [V16QI V4SI])
  33 (define_mode_iterator SSEMODE124 [V16QI V8HI V4SI])
  34 (define_mode_iterator SSEMODE248 [V8HI V4SI V2DI])
  35
  36 ;; Mapping from integer vector mode to mnemonic suffix
  37 (define_mode_attr ssevecsize [(V16QI "b") (V8HI "w") (V4SI "d") (V2DI "q")])
  38
  39 ;; Patterns whose name begins with "sse{,2,3}_" are invoked by intrinsics.
  40
  41 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  42 ;;
  43 ;; Move patterns
  44 ;;
  45 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  46
  47 ;; All of these patterns are enabled for SSE1 as well as SSE2.
  48 ;; This is essential for maintaining stable calling conventions.
  49
  50 (define_expand "mov<mode>"
  51   [(set (match_operand:SSEMODEI 0 "nonimmediate_operand" "")
  52         (match_operand:SSEMODEI 1 "nonimmediate_operand" ""))]
  53   "TARGET_SSE"
  54 {
  55   ix86_expand_vector_move (<MODE>mode, operands);
  56   DONE;
  57 })
  58
  59 (define_insn "*mov<mode>_internal"
  60   [(set (match_operand:SSEMODEI 0 "nonimmediate_operand" "=x,x ,m")
  61         (match_operand:SSEMODEI 1 "nonimmediate_or_sse_const_operand"  "C ,xm,x"))]
  62   "TARGET_SSE
  63    && (register_operand (operands[0], <MODE>mode)
  64        || register_operand (operands[1], <MODE>mode))"
  65 {
  66   switch (which_alternative)
  67     {
  68     case 0:
  69       return standard_sse_constant_opcode (insn, operands[1]);
  70     case 1:
  71     case 2:
  72       if (get_attr_mode (insn) == MODE_V4SF)
  73         return "movaps\t{%1, %0|%0, %1}";
  74       else
  75         return "movdqa\t{%1, %0|%0, %1}";
  76     default:
  77       gcc_unreachable ();
  78     }
  79 }
  80   [(set_attr "type" "sselog1,ssemov,ssemov")
  81    (set (attr "mode")
  82         (if_then_else
  83           (ior (ior (ne (symbol_ref "optimize_size") (const_int 0))
  84                     (eq (symbol_ref "TARGET_SSE2") (const_int 0)))
  85                (and (eq_attr "alternative" "2")
  86                     (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
  87                         (const_int 0))))
  88           (const_string "V4SF")
  89           (const_string "TI")))])
  90
  91 ;; Move a DI from a 32-bit register pair (e.g. %edx:%eax) to an xmm.
  92 ;; We'd rather avoid this entirely; if the 32-bit reg pair was loaded
  93 ;; from memory, we'd prefer to load the memory directly into the %xmm
  94 ;; register.  To facilitate this happy circumstance, this pattern won't
  95 ;; split until after register allocation.  If the 64-bit value didn't
  96 ;; come from memory, this is the best we can do.  This is much better
  97 ;; than storing %edx:%eax into a stack temporary and loading an %xmm
  98 ;; from there.
  99
 100 (define_insn_and_split "movdi_to_sse"
 101   [(parallel
 102     [(set (match_operand:V4SI 0 "register_operand" "=?x,x")
 103           (subreg:V4SI (match_operand:DI 1 "nonimmediate_operand" "r,m") 0))
 104      (clobber (match_scratch:V4SI 2 "=&x,X"))])]
 105   "!TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES"
 106   "#"
 107   "&& reload_completed"
 108   [(const_int 0)]
 109 {
 110  if (register_operand (operands[1], DImode))
 111    {
 112       /* The DImode arrived in a pair of integral registers (e.g. %edx:%eax).
 113          Assemble the 64-bit DImode value in an xmm register.  */
 114       emit_insn (gen_sse2_loadld (operands[0], CONST0_RTX (V4SImode),
 115                                   gen_rtx_SUBREG (SImode, operands[1], 0)));
 116       emit_insn (gen_sse2_loadld (operands[2], CONST0_RTX (V4SImode),
 117                                   gen_rtx_SUBREG (SImode, operands[1], 4)));
 118       emit_insn (gen_sse2_punpckldq (operands[0], operands[0], operands[2]));
 119     }
 120  else if (memory_operand (operands[1], DImode))
 121       emit_insn (gen_vec_concatv2di (gen_lowpart (V2DImode, operands[0]), operands[1], const0_rtx));
 122  else
 123       gcc_unreachable ();
 124 })
 125
 126 (define_expand "movv4sf"
 127   [(set (match_operand:V4SF 0 "nonimmediate_operand" "")
 128         (match_operand:V4SF 1 "nonimmediate_operand" ""))]
 129   "TARGET_SSE"
 130 {
 131   ix86_expand_vector_move (V4SFmode, operands);
 132   DONE;
 133 })
 134
 135 (define_insn "*movv4sf_internal"
 136   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
 137         (match_operand:V4SF 1 "nonimmediate_or_sse_const_operand" "C,xm,x"))]
 138   "TARGET_SSE
 139    && (register_operand (operands[0], V4SFmode)
 140        || register_operand (operands[1], V4SFmode))"
 141 {
 142   switch (which_alternative)
 143     {
 144     case 0:
 145       return standard_sse_constant_opcode (insn, operands[1]);
 146     case 1:
 147     case 2:
 148       return "movaps\t{%1, %0|%0, %1}";
 149     default:
 150       gcc_unreachable ();
 151     }
 152 }
 153   [(set_attr "type" "sselog1,ssemov,ssemov")
 154    (set_attr "mode" "V4SF")])
 155
 156 (define_split
 157   [(set (match_operand:V4SF 0 "register_operand" "")
 158         (match_operand:V4SF 1 "zero_extended_scalar_load_operand" ""))]
 159   "TARGET_SSE && reload_completed"
 160   [(set (match_dup 0)
 161         (vec_merge:V4SF
 162           (vec_duplicate:V4SF (match_dup 1))
 163           (match_dup 2)
 164           (const_int 1)))]
 165 {
 166   operands[1] = simplify_gen_subreg (SFmode, operands[1], V4SFmode, 0);
 167   operands[2] = CONST0_RTX (V4SFmode);
 168 })
 169
 170 (define_expand "movv2df"
 171   [(set (match_operand:V2DF 0 "nonimmediate_operand" "")
 172         (match_operand:V2DF 1 "nonimmediate_operand" ""))]
 173   "TARGET_SSE"
 174 {
 175   ix86_expand_vector_move (V2DFmode, operands);
 176   DONE;
 177 })
 178
 179 (define_insn "*movv2df_internal"
 180   [(set (match_operand:V2DF 0 "nonimmediate_operand" "=x,x,m")
 181         (match_operand:V2DF 1 "nonimmediate_or_sse_const_operand" "C,xm,x"))]
 182   "TARGET_SSE
 183    && (register_operand (operands[0], V2DFmode)
 184        || register_operand (operands[1], V2DFmode))"
 185 {
 186   switch (which_alternative)
 187     {
 188     case 0:
 189       return standard_sse_constant_opcode (insn, operands[1]);
 190     case 1:
 191     case 2:
 192       if (get_attr_mode (insn) == MODE_V4SF)
 193         return "movaps\t{%1, %0|%0, %1}";
 194       else
 195         return "movapd\t{%1, %0|%0, %1}";
 196     default:
 197       gcc_unreachable ();
 198     }
 199 }
 200   [(set_attr "type" "sselog1,ssemov,ssemov")
 201    (set (attr "mode")
 202         (if_then_else
 203           (ior (ior (ne (symbol_ref "optimize_size") (const_int 0))
 204                     (eq (symbol_ref "TARGET_SSE2") (const_int 0)))
 205                (and (eq_attr "alternative" "2")
 206                     (ne (symbol_ref "TARGET_SSE_TYPELESS_STORES")
 207                         (const_int 0))))
 208           (const_string "V4SF")
 209           (const_string "V2DF")))])
 210
 211 (define_split
 212   [(set (match_operand:V2DF 0 "register_operand" "")
 213         (match_operand:V2DF 1 "zero_extended_scalar_load_operand" ""))]
 214   "TARGET_SSE2 && reload_completed"
 215   [(set (match_dup 0) (vec_concat:V2DF (match_dup 1) (match_dup 2)))]
 216 {
 217   operands[1] = simplify_gen_subreg (DFmode, operands[1], V2DFmode, 0);
 218   operands[2] = CONST0_RTX (DFmode);
 219 })
 220
 221 (define_expand "push<mode>1"
 222   [(match_operand:SSEMODE 0 "register_operand" "")]
 223   "TARGET_SSE"
 224 {
 225   ix86_expand_push (<MODE>mode, operands[0]);
 226   DONE;
 227 })
 228
 229 (define_expand "movmisalign<mode>"
 230   [(set (match_operand:SSEMODE 0 "nonimmediate_operand" "")
 231         (match_operand:SSEMODE 1 "nonimmediate_operand" ""))]
 232   "TARGET_SSE"
 233 {
 234   ix86_expand_vector_move_misalign (<MODE>mode, operands);
 235   DONE;
 236 })
 237
 238 (define_insn "sse_movups"
 239   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,m")
 240         (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm,x")]
 241                      UNSPEC_MOVU))]
 242   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 243   "movups\t{%1, %0|%0, %1}"
 244   [(set_attr "type" "ssemov")
 245    (set_attr "mode" "V2DF")])
 246
 247 (define_insn "sse2_movupd"
 248   [(set (match_operand:V2DF 0 "nonimmediate_operand" "=x,m")
 249         (unspec:V2DF [(match_operand:V2DF 1 "nonimmediate_operand" "xm,x")]
 250                      UNSPEC_MOVU))]
 251   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 252   "movupd\t{%1, %0|%0, %1}"
 253   [(set_attr "type" "ssemov")
 254    (set_attr "mode" "V2DF")])
 255
 256 (define_insn "sse2_movdqu"
 257   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,m")
 258         (unspec:V16QI [(match_operand:V16QI 1 "nonimmediate_operand" "xm,x")]
 259                       UNSPEC_MOVU))]
 260   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
 261   "movdqu\t{%1, %0|%0, %1}"
 262   [(set_attr "type" "ssemov")
 263    (set_attr "prefix_data16" "1")
 264    (set_attr "mode" "TI")])
 265
 266 (define_insn "sse_movntv4sf"
 267   [(set (match_operand:V4SF 0 "memory_operand" "=m")
 268         (unspec:V4SF [(match_operand:V4SF 1 "register_operand" "x")]
 269                      UNSPEC_MOVNT))]
 270   "TARGET_SSE"
 271   "movntps\t{%1, %0|%0, %1}"
 272   [(set_attr "type" "ssemov")
 273    (set_attr "mode" "V4SF")])
 274
 275 (define_insn "sse2_movntv2df"
 276   [(set (match_operand:V2DF 0 "memory_operand" "=m")
 277         (unspec:V2DF [(match_operand:V2DF 1 "register_operand" "x")]
 278                      UNSPEC_MOVNT))]
 279   "TARGET_SSE2"
 280   "movntpd\t{%1, %0|%0, %1}"
 281   [(set_attr "type" "ssecvt")
 282    (set_attr "mode" "V2DF")])
 283
 284 (define_insn "sse2_movntv2di"
 285   [(set (match_operand:V2DI 0 "memory_operand" "=m")
 286         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")]
 287                      UNSPEC_MOVNT))]
 288   "TARGET_SSE2"
 289   "movntdq\t{%1, %0|%0, %1}"
 290   [(set_attr "type" "ssecvt")
 291    (set_attr "prefix_data16" "1")
 292    (set_attr "mode" "TI")])
 293
 294 (define_insn "sse2_movntsi"
 295   [(set (match_operand:SI 0 "memory_operand" "=m")
 296         (unspec:SI [(match_operand:SI 1 "register_operand" "r")]
 297                    UNSPEC_MOVNT))]
 298   "TARGET_SSE2"
 299   "movnti\t{%1, %0|%0, %1}"
 300   [(set_attr "type" "ssecvt")
 301    (set_attr "mode" "V2DF")])
 302
 303 (define_insn "sse3_lddqu"
 304   [(set (match_operand:V16QI 0 "register_operand" "=x")
 305         (unspec:V16QI [(match_operand:V16QI 1 "memory_operand" "m")]
 306                       UNSPEC_LDDQU))]
 307   "TARGET_SSE3"
 308   "lddqu\t{%1, %0|%0, %1}"
 309   [(set_attr "type" "ssecvt")
 310    (set_attr "prefix_rep" "1")
 311    (set_attr "mode" "TI")])
 312
 313 ; Expand patterns for non-temporal stores.  At the moment, only those
 314 ; that directly map to insns are defined; it would be possible to
 315 ; define patterns for other modes that would expand to several insns.
 316
 317 (define_expand "storentv4sf"
 318   [(set (match_operand:V4SF 0 "memory_operand" "=m")
 319         (unspec:V4SF [(match_operand:V4SF 1 "register_operand" "x")]
 320                      UNSPEC_MOVNT))]
 321   "TARGET_SSE"
 322   "")
 323
 324 (define_expand "storentv2df"
 325   [(set (match_operand:V2DF 0 "memory_operand" "=m")
 326         (unspec:V2DF [(match_operand:V2DF 1 "register_operand" "x")]
 327                      UNSPEC_MOVNT))]
 328   "TARGET_SSE2"
 329   "")
 330
 331 (define_expand "storentv2di"
 332   [(set (match_operand:V2DI 0 "memory_operand" "=m")
 333         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "x")]
 334                      UNSPEC_MOVNT))]
 335   "TARGET_SSE2"
 336   "")
 337
 338 (define_expand "storentsi"
 339   [(set (match_operand:SI 0 "memory_operand" "=m")
 340         (unspec:SI [(match_operand:SI 1 "register_operand" "r")]
 341                    UNSPEC_MOVNT))]
 342   "TARGET_SSE2"
 343   "")
 344
 345 (define_expand "storentdf"
 346   [(set (match_operand:DF 0 "memory_operand" "")
 347         (unspec:DF [(match_operand:DF 1 "register_operand" "")]
 348                    UNSPEC_MOVNT))]
 349   "TARGET_SSE4A"
 350   "")
 351
 352 (define_expand "storentsf"
 353   [(set (match_operand:SF 0 "memory_operand" "")
 354         (unspec:SF [(match_operand:SF 1 "register_operand" "")]
 355                    UNSPEC_MOVNT))]
 356   "TARGET_SSE4A"
 357   "")
 358
 359 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 360 ;;
 361 ;; Parallel single-precision floating point arithmetic
 362 ;;
 363 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 364
 365 (define_expand "negv4sf2"
 366   [(set (match_operand:V4SF 0 "register_operand" "")
 367         (neg:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")))]
 368   "TARGET_SSE"
 369   "ix86_expand_fp_absneg_operator (NEG, V4SFmode, operands); DONE;")
 370
 371 (define_expand "absv4sf2"
 372   [(set (match_operand:V4SF 0 "register_operand" "")
 373         (abs:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")))]
 374   "TARGET_SSE"
 375   "ix86_expand_fp_absneg_operator (ABS, V4SFmode, operands); DONE;")
 376
 377 (define_expand "addv4sf3"
 378   [(set (match_operand:V4SF 0 "register_operand" "")
 379         (plus:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")
 380                    (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 381   "TARGET_SSE"
 382   "ix86_fixup_binary_operands_no_copy (PLUS, V4SFmode, operands);")
 383
 384 (define_insn "*addv4sf3"
 385   [(set (match_operand:V4SF 0 "register_operand" "=x")
 386         (plus:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "%0")
 387                    (match_operand:V4SF 2 "nonimmediate_operand" "xm")))]
 388   "TARGET_SSE && ix86_binary_operator_ok (PLUS, V4SFmode, operands)"
 389   "addps\t{%2, %0|%0, %2}"
 390   [(set_attr "type" "sseadd")
 391    (set_attr "mode" "V4SF")])
 392
 393 (define_insn "sse_vmaddv4sf3"
 394   [(set (match_operand:V4SF 0 "register_operand" "=x")
 395         (vec_merge:V4SF
 396           (plus:V4SF (match_operand:V4SF 1 "register_operand" "0")
 397                      (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
 398           (match_dup 1)
 399           (const_int 1)))]
 400   "TARGET_SSE && ix86_binary_operator_ok (PLUS, V4SFmode, operands)"
 401   "addss\t{%2, %0|%0, %2}"
 402   [(set_attr "type" "sseadd")
 403    (set_attr "mode" "SF")])
 404
 405 (define_expand "subv4sf3"
 406   [(set (match_operand:V4SF 0 "register_operand" "")
 407         (minus:V4SF (match_operand:V4SF 1 "register_operand" "")
 408                     (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 409   "TARGET_SSE"
 410   "ix86_fixup_binary_operands_no_copy (MINUS, V4SFmode, operands);")
 411
 412 (define_insn "*subv4sf3"
 413   [(set (match_operand:V4SF 0 "register_operand" "=x")
 414         (minus:V4SF (match_operand:V4SF 1 "register_operand" "0")
 415                     (match_operand:V4SF 2 "nonimmediate_operand" "xm")))]
 416   "TARGET_SSE"
 417   "subps\t{%2, %0|%0, %2}"
 418   [(set_attr "type" "sseadd")
 419    (set_attr "mode" "V4SF")])
 420
 421 (define_insn "sse_vmsubv4sf3"
 422   [(set (match_operand:V4SF 0 "register_operand" "=x")
 423         (vec_merge:V4SF
 424           (minus:V4SF (match_operand:V4SF 1 "register_operand" "0")
 425                       (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
 426           (match_dup 1)
 427           (const_int 1)))]
 428   "TARGET_SSE"
 429   "subss\t{%2, %0|%0, %2}"
 430   [(set_attr "type" "sseadd")
 431    (set_attr "mode" "SF")])
 432
 433 (define_expand "mulv4sf3"
 434   [(set (match_operand:V4SF 0 "register_operand" "")
 435         (mult:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")
 436                    (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 437   "TARGET_SSE"
 438   "ix86_fixup_binary_operands_no_copy (MULT, V4SFmode, operands);")
 439
 440 (define_insn "*mulv4sf3"
 441   [(set (match_operand:V4SF 0 "register_operand" "=x")
 442         (mult:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "%0")
 443                    (match_operand:V4SF 2 "nonimmediate_operand" "xm")))]
 444   "TARGET_SSE && ix86_binary_operator_ok (MULT, V4SFmode, operands)"
 445   "mulps\t{%2, %0|%0, %2}"
 446   [(set_attr "type" "ssemul")
 447    (set_attr "mode" "V4SF")])
 448
 449 (define_insn "sse_vmmulv4sf3"
 450   [(set (match_operand:V4SF 0 "register_operand" "=x")
 451         (vec_merge:V4SF
 452           (mult:V4SF (match_operand:V4SF 1 "register_operand" "0")
 453                      (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
 454           (match_dup 1)
 455           (const_int 1)))]
 456   "TARGET_SSE && ix86_binary_operator_ok (MULT, V4SFmode, operands)"
 457   "mulss\t{%2, %0|%0, %2}"
 458   [(set_attr "type" "ssemul")
 459    (set_attr "mode" "SF")])
 460
 461 (define_expand "divv4sf3"
 462   [(set (match_operand:V4SF 0 "register_operand" "")
 463         (div:V4SF (match_operand:V4SF 1 "register_operand" "")
 464                   (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 465   "TARGET_SSE"
 466 {
 467   ix86_fixup_binary_operands_no_copy (DIV, V4SFmode, operands);
 468
 469   if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_size
 470       && flag_finite_math_only && !flag_trapping_math
 471       && flag_unsafe_math_optimizations)
 472     {
 473       ix86_emit_swdivsf (operands[0], operands[1],
 474                          operands[2], V4SFmode);
 475       DONE;
 476     }
 477 })
 478
 479 (define_insn "*divv4sf3"
 480   [(set (match_operand:V4SF 0 "register_operand" "=x")
 481         (div:V4SF (match_operand:V4SF 1 "register_operand" "0")
 482                   (match_operand:V4SF 2 "nonimmediate_operand" "xm")))]
 483   "TARGET_SSE"
 484   "divps\t{%2, %0|%0, %2}"
 485   [(set_attr "type" "ssediv")
 486    (set_attr "mode" "V4SF")])
 487
 488 (define_insn "sse_vmdivv4sf3"
 489   [(set (match_operand:V4SF 0 "register_operand" "=x")
 490         (vec_merge:V4SF
 491           (div:V4SF (match_operand:V4SF 1 "register_operand" "0")
 492                     (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
 493           (match_dup 1)
 494           (const_int 1)))]
 495   "TARGET_SSE"
 496   "divss\t{%2, %0|%0, %2}"
 497   [(set_attr "type" "ssediv")
 498    (set_attr "mode" "SF")])
 499
 500 (define_insn "sse_rcpv4sf2"
 501   [(set (match_operand:V4SF 0 "register_operand" "=x")
 502         (unspec:V4SF
 503          [(match_operand:V4SF 1 "nonimmediate_operand" "xm")] UNSPEC_RCP))]
 504   "TARGET_SSE"
 505   "rcpps\t{%1, %0|%0, %1}"
 506   [(set_attr "type" "sse")
 507    (set_attr "mode" "V4SF")])
 508
 509 (define_insn "sse_vmrcpv4sf2"
 510   [(set (match_operand:V4SF 0 "register_operand" "=x")
 511         (vec_merge:V4SF
 512           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 513                        UNSPEC_RCP)
 514           (match_operand:V4SF 2 "register_operand" "0")
 515           (const_int 1)))]
 516   "TARGET_SSE"
 517   "rcpss\t{%1, %0|%0, %1}"
 518   [(set_attr "type" "sse")
 519    (set_attr "mode" "SF")])
 520
 521 (define_insn "*sse_rsqrtv4sf2"
 522   [(set (match_operand:V4SF 0 "register_operand" "=x")
 523         (unspec:V4SF
 524           [(match_operand:V4SF 1 "nonimmediate_operand" "xm")] UNSPEC_RSQRT))]
 525   "TARGET_SSE"
 526   "rsqrtps\t{%1, %0|%0, %1}"
 527   [(set_attr "type" "sse")
 528    (set_attr "mode" "V4SF")])
 529
 530 (define_expand "sse_rsqrtv4sf2"
 531   [(set (match_operand:V4SF 0 "register_operand" "")
 532         (unspec:V4SF
 533           [(match_operand:V4SF 1 "nonimmediate_operand" "")] UNSPEC_RSQRT))]
 534   "TARGET_SSE"
 535 {
 536   if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_size
 537       && flag_finite_math_only && !flag_trapping_math
 538       && flag_unsafe_math_optimizations)
 539     {
 540       ix86_emit_swsqrtsf (operands[0], operands[1], V4SFmode, 1);
 541       DONE;
 542     }
 543 })
 544
 545 (define_insn "sse_vmrsqrtv4sf2"
 546   [(set (match_operand:V4SF 0 "register_operand" "=x")
 547         (vec_merge:V4SF
 548           (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
 549                        UNSPEC_RSQRT)
 550           (match_operand:V4SF 2 "register_operand" "0")
 551           (const_int 1)))]
 552   "TARGET_SSE"
 553   "rsqrtss\t{%1, %0|%0, %1}"
 554   [(set_attr "type" "sse")
 555    (set_attr "mode" "SF")])
 556
 557 (define_insn "*sqrtv4sf2"
 558   [(set (match_operand:V4SF 0 "register_operand" "=x")
 559         (sqrt:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
 560   "TARGET_SSE"
 561   "sqrtps\t{%1, %0|%0, %1}"
 562   [(set_attr "type" "sse")
 563    (set_attr "mode" "V4SF")])
 564
 565 (define_expand "sqrtv4sf2"
 566   [(set (match_operand:V4SF 0 "register_operand" "=")
 567         (sqrt:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")))]
 568   "TARGET_SSE"
 569 {
 570   if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_size
 571       && flag_finite_math_only && !flag_trapping_math
 572       && flag_unsafe_math_optimizations)
 573     {
 574       ix86_emit_swsqrtsf (operands[0], operands[1], V4SFmode, 0);
 575       DONE;
 576     }
 577 })
 578
 579 (define_insn "sse_vmsqrtv4sf2"
 580   [(set (match_operand:V4SF 0 "register_operand" "=x")
 581         (vec_merge:V4SF
 582           (sqrt:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "xm"))
 583           (match_operand:V4SF 2 "register_operand" "0")
 584           (const_int 1)))]
 585   "TARGET_SSE"
 586   "sqrtss\t{%1, %0|%0, %1}"
 587   [(set_attr "type" "sse")
 588    (set_attr "mode" "SF")])
 589
 590 ;; ??? For !flag_finite_math_only, the representation with SMIN/SMAX
 591 ;; isn't really correct, as those rtl operators aren't defined when
 592 ;; applied to NaNs.  Hopefully the optimizers won't get too smart on us.
 593
 594 (define_expand "smaxv4sf3"
 595   [(set (match_operand:V4SF 0 "register_operand" "")
 596         (smax:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")
 597                    (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 598   "TARGET_SSE"
 599 {
 600   if (!flag_finite_math_only)
 601     operands[1] = force_reg (V4SFmode, operands[1]);
 602   ix86_fixup_binary_operands_no_copy (SMAX, V4SFmode, operands);
 603 })
 604
 605 (define_insn "*smaxv4sf3_finite"
 606   [(set (match_operand:V4SF 0 "register_operand" "=x")
 607         (smax:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "%0")
 608                    (match_operand:V4SF 2 "nonimmediate_operand" "xm")))]
 609   "TARGET_SSE && flag_finite_math_only
 610    && ix86_binary_operator_ok (SMAX, V4SFmode, operands)"
 611   "maxps\t{%2, %0|%0, %2}"
 612   [(set_attr "type" "sse")
 613    (set_attr "mode" "V4SF")])
 614
 615 (define_insn "*smaxv4sf3"
 616   [(set (match_operand:V4SF 0 "register_operand" "=x")
 617         (smax:V4SF (match_operand:V4SF 1 "register_operand" "0")
 618                    (match_operand:V4SF 2 "nonimmediate_operand" "xm")))]
 619   "TARGET_SSE"
 620   "maxps\t{%2, %0|%0, %2}"
 621   [(set_attr "type" "sse")
 622    (set_attr "mode" "V4SF")])
 623
 624 (define_insn "sse_vmsmaxv4sf3"
 625   [(set (match_operand:V4SF 0 "register_operand" "=x")
 626         (vec_merge:V4SF
 627          (smax:V4SF (match_operand:V4SF 1 "register_operand" "0")
 628                     (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
 629          (match_dup 1)
 630          (const_int 1)))]
 631   "TARGET_SSE"
 632   "maxss\t{%2, %0|%0, %2}"
 633   [(set_attr "type" "sse")
 634    (set_attr "mode" "SF")])
 635
 636 (define_expand "sminv4sf3"
 637   [(set (match_operand:V4SF 0 "register_operand" "")
 638         (smin:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")
 639                    (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 640   "TARGET_SSE"
 641 {
 642   if (!flag_finite_math_only)
 643     operands[1] = force_reg (V4SFmode, operands[1]);
 644   ix86_fixup_binary_operands_no_copy (SMIN, V4SFmode, operands);
 645 })
 646
 647 (define_insn "*sminv4sf3_finite"
 648   [(set (match_operand:V4SF 0 "register_operand" "=x")
 649         (smin:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "%0")
 650                    (match_operand:V4SF 2 "nonimmediate_operand" "xm")))]
 651   "TARGET_SSE && flag_finite_math_only
 652    && ix86_binary_operator_ok (SMIN, V4SFmode, operands)"
 653   "minps\t{%2, %0|%0, %2}"
 654   [(set_attr "type" "sse")
 655    (set_attr "mode" "V4SF")])
 656
 657 (define_insn "*sminv4sf3"
 658   [(set (match_operand:V4SF 0 "register_operand" "=x")
 659         (smin:V4SF (match_operand:V4SF 1 "register_operand" "0")
 660                    (match_operand:V4SF 2 "nonimmediate_operand" "xm")))]
 661   "TARGET_SSE"
 662   "minps\t{%2, %0|%0, %2}"
 663   [(set_attr "type" "sse")
 664    (set_attr "mode" "V4SF")])
 665
 666 (define_insn "sse_vmsminv4sf3"
 667   [(set (match_operand:V4SF 0 "register_operand" "=x")
 668         (vec_merge:V4SF
 669          (smin:V4SF (match_operand:V4SF 1 "register_operand" "0")
 670                     (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
 671          (match_dup 1)
 672          (const_int 1)))]
 673   "TARGET_SSE"
 674   "minss\t{%2, %0|%0, %2}"
 675   [(set_attr "type" "sse")
 676    (set_attr "mode" "SF")])
 677
 678 ;; These versions of the min/max patterns implement exactly the operations
 679 ;;   min = (op1 < op2 ? op1 : op2)
 680 ;;   max = (!(op1 < op2) ? op1 : op2)
 681 ;; Their operands are not commutative, and thus they may be used in the
 682 ;; presence of -0.0 and NaN.
 683
 684 (define_insn "*ieee_sminv4sf3"
 685   [(set (match_operand:V4SF 0 "register_operand" "=x")
 686         (unspec:V4SF [(match_operand:V4SF 1 "register_operand" "0")
 687                       (match_operand:V4SF 2 "nonimmediate_operand" "xm")]
 688                      UNSPEC_IEEE_MIN))]
 689   "TARGET_SSE"
 690   "minps\t{%2, %0|%0, %2}"
 691   [(set_attr "type" "sseadd")
 692    (set_attr "mode" "V4SF")])
 693
 694 (define_insn "*ieee_smaxv4sf3"
 695   [(set (match_operand:V4SF 0 "register_operand" "=x")
 696         (unspec:V4SF [(match_operand:V4SF 1 "register_operand" "0")
 697                       (match_operand:V4SF 2 "nonimmediate_operand" "xm")]
 698                      UNSPEC_IEEE_MAX))]
 699   "TARGET_SSE"
 700   "maxps\t{%2, %0|%0, %2}"
 701   [(set_attr "type" "sseadd")
 702    (set_attr "mode" "V4SF")])
 703
 704 (define_insn "*ieee_sminv2df3"
 705   [(set (match_operand:V2DF 0 "register_operand" "=x")
 706         (unspec:V2DF [(match_operand:V2DF 1 "register_operand" "0")
 707                       (match_operand:V2DF 2 "nonimmediate_operand" "xm")]
 708                      UNSPEC_IEEE_MIN))]
 709   "TARGET_SSE2"
 710   "minpd\t{%2, %0|%0, %2}"
 711   [(set_attr "type" "sseadd")
 712    (set_attr "mode" "V2DF")])
 713
 714 (define_insn "*ieee_smaxv2df3"
 715   [(set (match_operand:V2DF 0 "register_operand" "=x")
 716         (unspec:V2DF [(match_operand:V2DF 1 "register_operand" "0")
 717                       (match_operand:V2DF 2 "nonimmediate_operand" "xm")]
 718                      UNSPEC_IEEE_MAX))]
 719   "TARGET_SSE2"
 720   "maxpd\t{%2, %0|%0, %2}"
 721   [(set_attr "type" "sseadd")
 722    (set_attr "mode" "V2DF")])
 723
 724 (define_insn "sse3_addsubv4sf3"
 725   [(set (match_operand:V4SF 0 "register_operand" "=x")
 726         (vec_merge:V4SF
 727           (plus:V4SF
 728             (match_operand:V4SF 1 "register_operand" "0")
 729             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
 730           (minus:V4SF (match_dup 1) (match_dup 2))
 731           (const_int 5)))]
 732   "TARGET_SSE3"
 733   "addsubps\t{%2, %0|%0, %2}"
 734   [(set_attr "type" "sseadd")
 735    (set_attr "prefix_rep" "1")
 736    (set_attr "mode" "V4SF")])
 737
 738 (define_insn "sse3_haddv4sf3"
 739   [(set (match_operand:V4SF 0 "register_operand" "=x")
 740         (vec_concat:V4SF
 741           (vec_concat:V2SF
 742             (plus:SF
 743               (vec_select:SF
 744                 (match_operand:V4SF 1 "register_operand" "0")
 745                 (parallel [(const_int 0)]))
 746               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
 747             (plus:SF
 748               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
 749               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
 750           (vec_concat:V2SF
 751             (plus:SF
 752               (vec_select:SF
 753                 (match_operand:V4SF 2 "nonimmediate_operand" "xm")
 754                 (parallel [(const_int 0)]))
 755               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
 756             (plus:SF
 757               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
 758               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
 759   "TARGET_SSE3"
 760   "haddps\t{%2, %0|%0, %2}"
 761   [(set_attr "type" "sseadd")
 762    (set_attr "prefix_rep" "1")
 763    (set_attr "mode" "V4SF")])
 764
 765 (define_insn "sse3_hsubv4sf3"
 766   [(set (match_operand:V4SF 0 "register_operand" "=x")
 767         (vec_concat:V4SF
 768           (vec_concat:V2SF
 769             (minus:SF
 770               (vec_select:SF
 771                 (match_operand:V4SF 1 "register_operand" "0")
 772                 (parallel [(const_int 0)]))
 773               (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
 774             (minus:SF
 775               (vec_select:SF (match_dup 1) (parallel [(const_int 2)]))
 776               (vec_select:SF (match_dup 1) (parallel [(const_int 3)]))))
 777           (vec_concat:V2SF
 778             (minus:SF
 779               (vec_select:SF
 780                 (match_operand:V4SF 2 "nonimmediate_operand" "xm")
 781                 (parallel [(const_int 0)]))
 782               (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))
 783             (minus:SF
 784               (vec_select:SF (match_dup 2) (parallel [(const_int 2)]))
 785               (vec_select:SF (match_dup 2) (parallel [(const_int 3)]))))))]
 786   "TARGET_SSE3"
 787   "hsubps\t{%2, %0|%0, %2}"
 788   [(set_attr "type" "sseadd")
 789    (set_attr "prefix_rep" "1")
 790    (set_attr "mode" "V4SF")])
 791
 792 (define_expand "reduc_splus_v4sf"
 793   [(match_operand:V4SF 0 "register_operand" "")
 794    (match_operand:V4SF 1 "register_operand" "")]
 795   "TARGET_SSE"
 796 {
 797   if (TARGET_SSE3)
 798     {
 799       rtx tmp = gen_reg_rtx (V4SFmode);
 800       emit_insn (gen_sse3_haddv4sf3 (tmp, operands[1], operands[1]));
 801       emit_insn (gen_sse3_haddv4sf3 (operands[0], tmp, tmp));
 802     }
 803   else
 804     ix86_expand_reduc_v4sf (gen_addv4sf3, operands[0], operands[1]);
 805   DONE;
 806 })
 807
 808 (define_expand "reduc_smax_v4sf"
 809   [(match_operand:V4SF 0 "register_operand" "")
 810    (match_operand:V4SF 1 "register_operand" "")]
 811   "TARGET_SSE"
 812 {
 813   ix86_expand_reduc_v4sf (gen_smaxv4sf3, operands[0], operands[1]);
 814   DONE;
 815 })
 816
 817 (define_expand "reduc_smin_v4sf"
 818   [(match_operand:V4SF 0 "register_operand" "")
 819    (match_operand:V4SF 1 "register_operand" "")]
 820   "TARGET_SSE"
 821 {
 822   ix86_expand_reduc_v4sf (gen_sminv4sf3, operands[0], operands[1]);
 823   DONE;
 824 })
 825
 826 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 827 ;;
 828 ;; Parallel single-precision floating point comparisons
 829 ;;
 830 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 831
 832 (define_insn "sse_maskcmpv4sf3"
 833   [(set (match_operand:V4SF 0 "register_operand" "=x")
 834         (match_operator:V4SF 3 "sse_comparison_operator"
 835                 [(match_operand:V4SF 1 "register_operand" "0")
 836                  (match_operand:V4SF 2 "nonimmediate_operand" "xm")]))]
 837   "TARGET_SSE"
 838   "cmp%D3ps\t{%2, %0|%0, %2}"
 839   [(set_attr "type" "ssecmp")
 840    (set_attr "mode" "V4SF")])
 841
 842 (define_insn "sse_maskcmpsf3"
 843   [(set (match_operand:SF 0 "register_operand" "=x")
 844         (match_operator:SF 3 "sse_comparison_operator"
 845                 [(match_operand:SF 1 "register_operand" "0")
 846                  (match_operand:SF 2 "nonimmediate_operand" "xm")]))]
 847   "TARGET_SSE"
 848   "cmp%D3ss\t{%2, %0|%0, %2}"
 849   [(set_attr "type" "ssecmp")
 850    (set_attr "mode" "SF")])
 851
 852 (define_insn "sse_vmmaskcmpv4sf3"
 853   [(set (match_operand:V4SF 0 "register_operand" "=x")
 854         (vec_merge:V4SF
 855          (match_operator:V4SF 3 "sse_comparison_operator"
 856                 [(match_operand:V4SF 1 "register_operand" "0")
 857                  (match_operand:V4SF 2 "register_operand" "x")])
 858          (match_dup 1)
 859          (const_int 1)))]
 860   "TARGET_SSE"
 861   "cmp%D3ss\t{%2, %0|%0, %2}"
 862   [(set_attr "type" "ssecmp")
 863    (set_attr "mode" "SF")])
 864
 865 (define_insn "sse_comi"
 866   [(set (reg:CCFP FLAGS_REG)
 867         (compare:CCFP
 868           (vec_select:SF
 869             (match_operand:V4SF 0 "register_operand" "x")
 870             (parallel [(const_int 0)]))
 871           (vec_select:SF
 872             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
 873             (parallel [(const_int 0)]))))]
 874   "TARGET_SSE"
 875   "comiss\t{%1, %0|%0, %1}"
 876   [(set_attr "type" "ssecomi")
 877    (set_attr "mode" "SF")])
 878
 879 (define_insn "sse_ucomi"
 880   [(set (reg:CCFPU FLAGS_REG)
 881         (compare:CCFPU
 882           (vec_select:SF
 883             (match_operand:V4SF 0 "register_operand" "x")
 884             (parallel [(const_int 0)]))
 885           (vec_select:SF
 886             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
 887             (parallel [(const_int 0)]))))]
 888   "TARGET_SSE"
 889   "ucomiss\t{%1, %0|%0, %1}"
 890   [(set_attr "type" "ssecomi")
 891    (set_attr "mode" "SF")])
 892
 893 (define_expand "vcondv4sf"
 894   [(set (match_operand:V4SF 0 "register_operand" "")
 895         (if_then_else:V4SF
 896           (match_operator 3 ""
 897             [(match_operand:V4SF 4 "nonimmediate_operand" "")
 898              (match_operand:V4SF 5 "nonimmediate_operand" "")])
 899           (match_operand:V4SF 1 "general_operand" "")
 900           (match_operand:V4SF 2 "general_operand" "")))]
 901   "TARGET_SSE"
 902 {
 903   if (ix86_expand_fp_vcond (operands))
 904     DONE;
 905   else
 906     FAIL;
 907 })
 908
 909 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 910 ;;
 911 ;; Parallel single-precision floating point logical operations
 912 ;;
 913 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 914
 915 (define_expand "andv4sf3"
 916   [(set (match_operand:V4SF 0 "register_operand" "")
 917         (and:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")
 918                   (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 919   "TARGET_SSE"
 920   "ix86_fixup_binary_operands_no_copy (AND, V4SFmode, operands);")
 921
 922 (define_insn "*andv4sf3"
 923   [(set (match_operand:V4SF 0 "register_operand" "=x")
 924         (and:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "%0")
 925                   (match_operand:V4SF 2 "nonimmediate_operand" "xm")))]
 926   "TARGET_SSE && ix86_binary_operator_ok (AND, V4SFmode, operands)"
 927   "andps\t{%2, %0|%0, %2}"
 928   [(set_attr "type" "sselog")
 929    (set_attr "mode" "V4SF")])
 930
 931 (define_insn "sse_nandv4sf3"
 932   [(set (match_operand:V4SF 0 "register_operand" "=x")
 933         (and:V4SF (not:V4SF (match_operand:V4SF 1 "register_operand" "0"))
 934                   (match_operand:V4SF 2 "nonimmediate_operand" "xm")))]
 935   "TARGET_SSE"
 936   "andnps\t{%2, %0|%0, %2}"
 937   [(set_attr "type" "sselog")
 938    (set_attr "mode" "V4SF")])
 939
 940 (define_expand "iorv4sf3"
 941   [(set (match_operand:V4SF 0 "register_operand" "")
 942         (ior:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")
 943                   (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 944   "TARGET_SSE"
 945   "ix86_fixup_binary_operands_no_copy (IOR, V4SFmode, operands);")
 946
 947 (define_insn "*iorv4sf3"
 948   [(set (match_operand:V4SF 0 "register_operand" "=x")
 949         (ior:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "%0")
 950                   (match_operand:V4SF 2 "nonimmediate_operand" "xm")))]
 951   "TARGET_SSE && ix86_binary_operator_ok (IOR, V4SFmode, operands)"
 952   "orps\t{%2, %0|%0, %2}"
 953   [(set_attr "type" "sselog")
 954    (set_attr "mode" "V4SF")])
 955
 956 (define_expand "xorv4sf3"
 957   [(set (match_operand:V4SF 0 "register_operand" "")
 958         (xor:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "")
 959                   (match_operand:V4SF 2 "nonimmediate_operand" "")))]
 960   "TARGET_SSE"
 961   "ix86_fixup_binary_operands_no_copy (XOR, V4SFmode, operands);")
 962
 963 (define_insn "*xorv4sf3"
 964   [(set (match_operand:V4SF 0 "register_operand" "=x")
 965         (xor:V4SF (match_operand:V4SF 1 "nonimmediate_operand" "%0")
 966                   (match_operand:V4SF 2 "nonimmediate_operand" "xm")))]
 967   "TARGET_SSE && ix86_binary_operator_ok (XOR, V4SFmode, operands)"
 968   "xorps\t{%2, %0|%0, %2}"
 969   [(set_attr "type" "sselog")
 970    (set_attr "mode" "V4SF")])
 971
 972 ;; Also define scalar versions.  These are used for abs, neg, and
 973 ;; conditional move.  Using subregs into vector modes causes register
 974 ;; allocation lossage.  These patterns do not allow memory operands
 975 ;; because the native instructions read the full 128-bits.
 976
 977 (define_insn "*andsf3"
 978   [(set (match_operand:SF 0 "register_operand" "=x")
 979         (and:SF (match_operand:SF 1 "register_operand" "0")
 980                 (match_operand:SF 2 "register_operand" "x")))]
 981   "TARGET_SSE"
 982   "andps\t{%2, %0|%0, %2}"
 983   [(set_attr "type" "sselog")
 984    (set_attr "mode" "V4SF")])
 985
 986 (define_insn "*nandsf3"
 987   [(set (match_operand:SF 0 "register_operand" "=x")
 988         (and:SF (not:SF (match_operand:SF 1 "register_operand" "0"))
 989                 (match_operand:SF 2 "register_operand" "x")))]
 990   "TARGET_SSE"
 991   "andnps\t{%2, %0|%0, %2}"
 992   [(set_attr "type" "sselog")
 993    (set_attr "mode" "V4SF")])
 994
 995 (define_insn "*iorsf3"
 996   [(set (match_operand:SF 0 "register_operand" "=x")
 997         (ior:SF (match_operand:SF 1 "register_operand" "0")
 998                 (match_operand:SF 2 "register_operand" "x")))]
 999   "TARGET_SSE"
1000   "orps\t{%2, %0|%0, %2}"
1001   [(set_attr "type" "sselog")
1002    (set_attr "mode" "V4SF")])
1003
1004 (define_insn "*xorsf3"
1005   [(set (match_operand:SF 0 "register_operand" "=x")
1006         (xor:SF (match_operand:SF 1 "register_operand" "0")
1007                 (match_operand:SF 2 "register_operand" "x")))]
1008   "TARGET_SSE"
1009   "xorps\t{%2, %0|%0, %2}"
1010   [(set_attr "type" "sselog")
1011    (set_attr "mode" "V4SF")])
1012
1013 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1014 ;;
1015 ;; Parallel single-precision floating point conversion operations
1016 ;;
1017 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1018
1019 (define_insn "sse_cvtpi2ps"
1020   [(set (match_operand:V4SF 0 "register_operand" "=x")
1021         (vec_merge:V4SF
1022           (vec_duplicate:V4SF
1023             (float:V2SF (match_operand:V2SI 2 "nonimmediate_operand" "ym")))
1024           (match_operand:V4SF 1 "register_operand" "0")
1025           (const_int 3)))]
1026   "TARGET_SSE"
1027   "cvtpi2ps\t{%2, %0|%0, %2}"
1028   [(set_attr "type" "ssecvt")
1029    (set_attr "mode" "V4SF")])
1030
1031 (define_insn "sse_cvtps2pi"
1032   [(set (match_operand:V2SI 0 "register_operand" "=y")
1033         (vec_select:V2SI
1034           (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
1035                        UNSPEC_FIX_NOTRUNC)
1036           (parallel [(const_int 0) (const_int 1)])))]
1037   "TARGET_SSE"
1038   "cvtps2pi\t{%1, %0|%0, %1}"
1039   [(set_attr "type" "ssecvt")
1040    (set_attr "unit" "mmx")
1041    (set_attr "mode" "DI")])
1042
1043 (define_insn "sse_cvttps2pi"
1044   [(set (match_operand:V2SI 0 "register_operand" "=y")
1045         (vec_select:V2SI
1046           (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm"))
1047           (parallel [(const_int 0) (const_int 1)])))]
1048   "TARGET_SSE"
1049   "cvttps2pi\t{%1, %0|%0, %1}"
1050   [(set_attr "type" "ssecvt")
1051    (set_attr "unit" "mmx")
1052    (set_attr "mode" "SF")])
1053
1054 (define_insn "sse_cvtsi2ss"
1055   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
1056         (vec_merge:V4SF
1057           (vec_duplicate:V4SF
1058             (float:SF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
1059           (match_operand:V4SF 1 "register_operand" "0,0")
1060           (const_int 1)))]
1061   "TARGET_SSE"
1062   "cvtsi2ss\t{%2, %0|%0, %2}"
1063   [(set_attr "type" "sseicvt")
1064    (set_attr "athlon_decode" "vector,double")
1065    (set_attr "amdfam10_decode" "vector,double")
1066    (set_attr "mode" "SF")])
1067
1068 (define_insn "sse_cvtsi2ssq"
1069   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
1070         (vec_merge:V4SF
1071           (vec_duplicate:V4SF
1072             (float:SF (match_operand:DI 2 "nonimmediate_operand" "r,rm")))
1073           (match_operand:V4SF 1 "register_operand" "0,0")
1074           (const_int 1)))]
1075   "TARGET_SSE && TARGET_64BIT"
1076   "cvtsi2ssq\t{%2, %0|%0, %2}"
1077   [(set_attr "type" "sseicvt")
1078    (set_attr "athlon_decode" "vector,double")
1079    (set_attr "amdfam10_decode" "vector,double")
1080    (set_attr "mode" "SF")])
1081
1082 (define_insn "sse_cvtss2si"
1083   [(set (match_operand:SI 0 "register_operand" "=r,r")
1084         (unspec:SI
1085           [(vec_select:SF
1086              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
1087              (parallel [(const_int 0)]))]
1088           UNSPEC_FIX_NOTRUNC))]
1089   "TARGET_SSE"
1090   "cvtss2si\t{%1, %0|%0, %1}"
1091   [(set_attr "type" "sseicvt")
1092    (set_attr "athlon_decode" "double,vector")
1093    (set_attr "prefix_rep" "1")
1094    (set_attr "mode" "SI")])
1095
1096 (define_insn "sse_cvtss2si_2"
1097   [(set (match_operand:SI 0 "register_operand" "=r,r")
1098         (unspec:SI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
1099          UNSPEC_FIX_NOTRUNC))]
1100   "TARGET_SSE"
1101   "cvtss2si\t{%1, %0|%0, %1}"
1102   [(set_attr "type" "sseicvt")
1103    (set_attr "athlon_decode" "double,vector")
1104    (set_attr "amdfam10_decode" "double,double")
1105    (set_attr "prefix_rep" "1")
1106    (set_attr "mode" "SI")])
1107
1108 (define_insn "sse_cvtss2siq"
1109   [(set (match_operand:DI 0 "register_operand" "=r,r")
1110         (unspec:DI
1111           [(vec_select:SF
1112              (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
1113              (parallel [(const_int 0)]))]
1114           UNSPEC_FIX_NOTRUNC))]
1115   "TARGET_SSE && TARGET_64BIT"
1116   "cvtss2siq\t{%1, %0|%0, %1}"
1117   [(set_attr "type" "sseicvt")
1118    (set_attr "athlon_decode" "double,vector")
1119    (set_attr "prefix_rep" "1")
1120    (set_attr "mode" "DI")])
1121
1122 (define_insn "sse_cvtss2siq_2"
1123   [(set (match_operand:DI 0 "register_operand" "=r,r")
1124         (unspec:DI [(match_operand:SF 1 "nonimmediate_operand" "x,m")]
1125          UNSPEC_FIX_NOTRUNC))]
1126   "TARGET_SSE && TARGET_64BIT"
1127   "cvtss2siq\t{%1, %0|%0, %1}"
1128   [(set_attr "type" "sseicvt")
1129    (set_attr "athlon_decode" "double,vector")
1130    (set_attr "amdfam10_decode" "double,double")
1131    (set_attr "prefix_rep" "1")
1132    (set_attr "mode" "DI")])
1133
1134 (define_insn "sse_cvttss2si"
1135   [(set (match_operand:SI 0 "register_operand" "=r,r")
1136         (fix:SI
1137           (vec_select:SF
1138             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
1139             (parallel [(const_int 0)]))))]
1140   "TARGET_SSE"
1141   "cvttss2si\t{%1, %0|%0, %1}"
1142   [(set_attr "type" "sseicvt")
1143    (set_attr "athlon_decode" "double,vector")
1144    (set_attr "amdfam10_decode" "double,double")
1145    (set_attr "prefix_rep" "1")
1146    (set_attr "mode" "SI")])
1147
1148 (define_insn "sse_cvttss2siq"
1149   [(set (match_operand:DI 0 "register_operand" "=r,r")
1150         (fix:DI
1151           (vec_select:SF
1152             (match_operand:V4SF 1 "nonimmediate_operand" "x,m")
1153             (parallel [(const_int 0)]))))]
1154   "TARGET_SSE && TARGET_64BIT"
1155   "cvttss2siq\t{%1, %0|%0, %1}"
1156   [(set_attr "type" "sseicvt")
1157    (set_attr "athlon_decode" "double,vector")
1158    (set_attr "amdfam10_decode" "double,double")
1159    (set_attr "prefix_rep" "1")
1160    (set_attr "mode" "DI")])
1161
1162 (define_insn "sse2_cvtdq2ps"
1163   [(set (match_operand:V4SF 0 "register_operand" "=x")
1164         (float:V4SF (match_operand:V4SI 1 "nonimmediate_operand" "xm")))]
1165   "TARGET_SSE2"
1166   "cvtdq2ps\t{%1, %0|%0, %1}"
1167   [(set_attr "type" "ssecvt")
1168    (set_attr "mode" "V4SF")])
1169
1170 (define_insn "sse2_cvtps2dq"
1171   [(set (match_operand:V4SI 0 "register_operand" "=x")
1172         (unspec:V4SI [(match_operand:V4SF 1 "nonimmediate_operand" "xm")]
1173                      UNSPEC_FIX_NOTRUNC))]
1174   "TARGET_SSE2"
1175   "cvtps2dq\t{%1, %0|%0, %1}"
1176   [(set_attr "type" "ssecvt")
1177    (set_attr "prefix_data16" "1")
1178    (set_attr "mode" "TI")])
1179
1180 (define_insn "sse2_cvttps2dq"
1181   [(set (match_operand:V4SI 0 "register_operand" "=x")
1182         (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm")))]
1183   "TARGET_SSE2"
1184   "cvttps2dq\t{%1, %0|%0, %1}"
1185   [(set_attr "type" "ssecvt")
1186    (set_attr "prefix_rep" "1")
1187    (set_attr "mode" "TI")])
1188
1189 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1190 ;;
1191 ;; Parallel single-precision floating point element swizzling
1192 ;;
1193 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1194
1195 (define_insn "sse_movhlps"
1196   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,m")
1197         (vec_select:V4SF
1198           (vec_concat:V8SF
1199             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
1200             (match_operand:V4SF 2 "nonimmediate_operand" " x,o,x"))
1201           (parallel [(const_int 6)
1202                      (const_int 7)
1203                      (const_int 2)
1204                      (const_int 3)])))]
1205   "TARGET_SSE && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
1206   "@
1207    movhlps\t{%2, %0|%0, %2}
1208    movlps\t{%H2, %0|%0, %H2}
1209    movhps\t{%2, %0|%0, %2}"
1210   [(set_attr "type" "ssemov")
1211    (set_attr "mode" "V4SF,V2SF,V2SF")])
1212
1213 (define_insn "sse_movlhps"
1214   [(set (match_operand:V4SF 0 "nonimmediate_operand"     "=x,x,o")
1215         (vec_select:V4SF
1216           (vec_concat:V8SF
1217             (match_operand:V4SF 1 "nonimmediate_operand" " 0,0,0")
1218             (match_operand:V4SF 2 "nonimmediate_operand" " x,m,x"))
1219           (parallel [(const_int 0)
1220                      (const_int 1)
1221                      (const_int 4)
1222                      (const_int 5)])))]
1223   "TARGET_SSE && ix86_binary_operator_ok (UNKNOWN, V4SFmode, operands)"
1224   "@
1225    movlhps\t{%2, %0|%0, %2}
1226    movhps\t{%2, %0|%0, %2}
1227    movlps\t{%2, %H0|%H0, %2}"
1228   [(set_attr "type" "ssemov")
1229    (set_attr "mode" "V4SF,V2SF,V2SF")])
1230
1231 (define_insn "sse_unpckhps"
1232   [(set (match_operand:V4SF 0 "register_operand" "=x")
1233         (vec_select:V4SF
1234           (vec_concat:V8SF
1235             (match_operand:V4SF 1 "register_operand" "0")
1236             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
1237           (parallel [(const_int 2) (const_int 6)
1238                      (const_int 3) (const_int 7)])))]
1239   "TARGET_SSE"
1240   "unpckhps\t{%2, %0|%0, %2}"
1241   [(set_attr "type" "sselog")
1242    (set_attr "mode" "V4SF")])
1243
1244 (define_insn "sse_unpcklps"
1245   [(set (match_operand:V4SF 0 "register_operand" "=x")
1246         (vec_select:V4SF
1247           (vec_concat:V8SF
1248             (match_operand:V4SF 1 "register_operand" "0")
1249             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
1250           (parallel [(const_int 0) (const_int 4)
1251                      (const_int 1) (const_int 5)])))]
1252   "TARGET_SSE"
1253   "unpcklps\t{%2, %0|%0, %2}"
1254   [(set_attr "type" "sselog")
1255    (set_attr "mode" "V4SF")])
1256
1257 ;; These are modeled with the same vec_concat as the others so that we
1258 ;; capture users of shufps that can use the new instructions
1259 (define_insn "sse3_movshdup"
1260   [(set (match_operand:V4SF 0 "register_operand" "=x")
1261         (vec_select:V4SF
1262           (vec_concat:V8SF
1263             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
1264             (match_dup 1))
1265           (parallel [(const_int 1)
1266                      (const_int 1)
1267                      (const_int 7)
1268                      (const_int 7)])))]
1269   "TARGET_SSE3"
1270   "movshdup\t{%1, %0|%0, %1}"
1271   [(set_attr "type" "sse")
1272    (set_attr "prefix_rep" "1")
1273    (set_attr "mode" "V4SF")])
1274
1275 (define_insn "sse3_movsldup"
1276   [(set (match_operand:V4SF 0 "register_operand" "=x")
1277         (vec_select:V4SF
1278           (vec_concat:V8SF
1279             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
1280             (match_dup 1))
1281           (parallel [(const_int 0)
1282                      (const_int 0)
1283                      (const_int 6)
1284                      (const_int 6)])))]
1285   "TARGET_SSE3"
1286   "movsldup\t{%1, %0|%0, %1}"
1287   [(set_attr "type" "sse")
1288    (set_attr "prefix_rep" "1")
1289    (set_attr "mode" "V4SF")])
1290
1291 (define_expand "sse_shufps"
1292   [(match_operand:V4SF 0 "register_operand" "")
1293    (match_operand:V4SF 1 "register_operand" "")
1294    (match_operand:V4SF 2 "nonimmediate_operand" "")
1295    (match_operand:SI 3 "const_int_operand" "")]
1296   "TARGET_SSE"
1297 {
1298   int mask = INTVAL (operands[3]);
1299   emit_insn (gen_sse_shufps_1 (operands[0], operands[1], operands[2],
1300                                GEN_INT ((mask >> 0) & 3),
1301                                GEN_INT ((mask >> 2) & 3),
1302                                GEN_INT (((mask >> 4) & 3) + 4),
1303                                GEN_INT (((mask >> 6) & 3) + 4)));
1304   DONE;
1305 })
1306
1307 (define_insn "sse_shufps_1"
1308   [(set (match_operand:V4SF 0 "register_operand" "=x")
1309         (vec_select:V4SF
1310           (vec_concat:V8SF
1311             (match_operand:V4SF 1 "register_operand" "0")
1312             (match_operand:V4SF 2 "nonimmediate_operand" "xm"))
1313           (parallel [(match_operand 3 "const_0_to_3_operand" "")
1314                      (match_operand 4 "const_0_to_3_operand" "")
1315                      (match_operand 5 "const_4_to_7_operand" "")
1316                      (match_operand 6 "const_4_to_7_operand" "")])))]
1317   "TARGET_SSE"
1318 {
1319   int mask = 0;
1320   mask |= INTVAL (operands[3]) << 0;
1321   mask |= INTVAL (operands[4]) << 2;
1322   mask |= (INTVAL (operands[5]) - 4) << 4;
1323   mask |= (INTVAL (operands[6]) - 4) << 6;
1324   operands[3] = GEN_INT (mask);
1325
1326   return "shufps\t{%3, %2, %0|%0, %2, %3}";
1327 }
1328   [(set_attr "type" "sselog")
1329    (set_attr "mode" "V4SF")])
1330
1331 (define_insn "sse_storehps"
1332   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
1333         (vec_select:V2SF
1334           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,o")
1335           (parallel [(const_int 2) (const_int 3)])))]
1336   "TARGET_SSE"
1337   "@
1338    movhps\t{%1, %0|%0, %1}
1339    movhlps\t{%1, %0|%0, %1}
1340    movlps\t{%H1, %0|%0, %H1}"
1341   [(set_attr "type" "ssemov")
1342    (set_attr "mode" "V2SF,V4SF,V2SF")])
1343
1344 (define_insn "sse_loadhps"
1345   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,o")
1346         (vec_concat:V4SF
1347           (vec_select:V2SF
1348             (match_operand:V4SF 1 "nonimmediate_operand" "0,0,0")
1349             (parallel [(const_int 0) (const_int 1)]))
1350           (match_operand:V2SF 2 "nonimmediate_operand" "m,x,x")))]
1351   "TARGET_SSE"
1352   "@
1353    movhps\t{%2, %0|%0, %2}
1354    movlhps\t{%2, %0|%0, %2}
1355    movlps\t{%2, %H0|%H0, %2}"
1356   [(set_attr "type" "ssemov")
1357    (set_attr "mode" "V2SF,V4SF,V2SF")])
1358
1359 (define_insn "sse_storelps"
1360   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=m,x,x")
1361         (vec_select:V2SF
1362           (match_operand:V4SF 1 "nonimmediate_operand" "x,x,m")
1363           (parallel [(const_int 0) (const_int 1)])))]
1364   "TARGET_SSE"
1365   "@
1366    movlps\t{%1, %0|%0, %1}
1367    movaps\t{%1, %0|%0, %1}
1368    movlps\t{%1, %0|%0, %1}"
1369   [(set_attr "type" "ssemov")
1370    (set_attr "mode" "V2SF,V4SF,V2SF")])
1371
1372 (define_insn "sse_loadlps"
1373   [(set (match_operand:V4SF 0 "nonimmediate_operand" "=x,x,m")
1374         (vec_concat:V4SF
1375           (match_operand:V2SF 2 "nonimmediate_operand" "0,m,x")
1376           (vec_select:V2SF
1377             (match_operand:V4SF 1 "nonimmediate_operand" "x,0,0")
1378             (parallel [(const_int 2) (const_int 3)]))))]
1379   "TARGET_SSE"
1380   "@
1381    shufps\t{$0xe4, %1, %0|%0, %1, 0xe4}
1382    movlps\t{%2, %0|%0, %2}
1383    movlps\t{%2, %0|%0, %2}"
1384   [(set_attr "type" "sselog,ssemov,ssemov")
1385    (set_attr "mode" "V4SF,V2SF,V2SF")])
1386
1387 (define_insn "sse_movss"
1388   [(set (match_operand:V4SF 0 "register_operand" "=x")
1389         (vec_merge:V4SF
1390           (match_operand:V4SF 2 "register_operand" "x")
1391           (match_operand:V4SF 1 "register_operand" "0")
1392           (const_int 1)))]
1393   "TARGET_SSE"
1394   "movss\t{%2, %0|%0, %2}"
1395   [(set_attr "type" "ssemov")
1396    (set_attr "mode" "SF")])
1397
1398 (define_insn "*vec_dupv4sf"
1399   [(set (match_operand:V4SF 0 "register_operand" "=x")
1400         (vec_duplicate:V4SF
1401           (match_operand:SF 1 "register_operand" "0")))]
1402   "TARGET_SSE"
1403   "shufps\t{$0, %0, %0|%0, %0, 0}"
1404   [(set_attr "type" "sselog1")
1405    (set_attr "mode" "V4SF")])
1406
1407 ;; ??? In theory we can match memory for the MMX alternative, but allowing
1408 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
1409 ;; alternatives pretty much forces the MMX alternative to be chosen.
1410 (define_insn "*sse_concatv2sf"
1411   [(set (match_operand:V2SF 0 "register_operand"     "=x,x,*y,*y")
1412         (vec_concat:V2SF
1413           (match_operand:SF 1 "nonimmediate_operand" " 0,m, 0, m")
1414           (match_operand:SF 2 "reg_or_0_operand"     " x,C,*y, C")))]
1415   "TARGET_SSE"
1416   "@
1417    unpcklps\t{%2, %0|%0, %2}
1418    movss\t{%1, %0|%0, %1}
1419    punpckldq\t{%2, %0|%0, %2}
1420    movd\t{%1, %0|%0, %1}"
1421   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
1422    (set_attr "mode" "V4SF,SF,DI,DI")])
1423
1424 (define_insn "*sse_concatv4sf"
1425   [(set (match_operand:V4SF 0 "register_operand"   "=x,x")
1426         (vec_concat:V4SF
1427           (match_operand:V2SF 1 "register_operand" " 0,0")
1428           (match_operand:V2SF 2 "nonimmediate_operand" " x,m")))]
1429   "TARGET_SSE"
1430   "@
1431    movlhps\t{%2, %0|%0, %2}
1432    movhps\t{%2, %0|%0, %2}"
1433   [(set_attr "type" "ssemov")
1434    (set_attr "mode" "V4SF,V2SF")])
1435
1436 (define_expand "vec_initv4sf"
1437   [(match_operand:V4SF 0 "register_operand" "")
1438    (match_operand 1 "" "")]
1439   "TARGET_SSE"
1440 {
1441   ix86_expand_vector_init (false, operands[0], operands[1]);
1442   DONE;
1443 })
1444
1445 (define_insn "vec_setv4sf_0"
1446   [(set (match_operand:V4SF 0 "nonimmediate_operand"  "=x,x,Yt,m")
1447         (vec_merge:V4SF
1448           (vec_duplicate:V4SF
1449             (match_operand:SF 2 "general_operand"     " x,m,*r,x*rfF"))
1450           (match_operand:V4SF 1 "vector_move_operand" " 0,C,C ,0")
1451           (const_int 1)))]
1452   "TARGET_SSE"
1453   "@
1454    movss\t{%2, %0|%0, %2}
1455    movss\t{%2, %0|%0, %2}
1456    movd\t{%2, %0|%0, %2}
1457    #"
1458   [(set_attr "type" "ssemov")
1459    (set_attr "mode" "SF")])
1460
1461 ;; A subset is vec_setv4sf.
1462 (define_insn "*vec_setv4sf_sse4_1"
1463   [(set (match_operand:V4SF 0 "register_operand" "=x")
1464         (vec_merge:V4SF
1465           (vec_duplicate:V4SF
1466             (match_operand:SF 2 "nonimmediate_operand" "xm"))
1467           (match_operand:V4SF 1 "register_operand" "0")
1468           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
1469   "TARGET_SSE4_1"
1470 {
1471   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])) << 4);
1472   return "insertps\t{%3, %2, %0|%0, %2, %3}";
1473 }
1474   [(set_attr "type" "sselog")
1475    (set_attr "prefix_extra" "1")
1476    (set_attr "mode" "V4SF")])
1477
1478 (define_insn "sse4_1_insertps"
1479   [(set (match_operand:V4SF 0 "register_operand" "=x")
1480         (unspec:V4SF [(match_operand:V4SF 2 "register_operand" "x")
1481                       (match_operand:V4SF 1 "register_operand" "0")
1482                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
1483                      UNSPEC_INSERTPS))]
1484   "TARGET_SSE4_1"
1485   "insertps\t{%3, %2, %0|%0, %2, %3}";
1486   [(set_attr "type" "sselog")
1487    (set_attr "prefix_extra" "1")
1488    (set_attr "mode" "V4SF")])
1489
1490 (define_split
1491   [(set (match_operand:V4SF 0 "memory_operand" "")
1492         (vec_merge:V4SF
1493           (vec_duplicate:V4SF
1494             (match_operand:SF 1 "nonmemory_operand" ""))
1495           (match_dup 0)
1496           (const_int 1)))]
1497   "TARGET_SSE && reload_completed"
1498   [(const_int 0)]
1499 {
1500   emit_move_insn (adjust_address (operands[0], SFmode, 0), operands[1]);
1501   DONE;
1502 })
1503
1504 (define_expand "vec_setv4sf"
1505   [(match_operand:V4SF 0 "register_operand" "")
1506    (match_operand:SF 1 "register_operand" "")
1507    (match_operand 2 "const_int_operand" "")]
1508   "TARGET_SSE"
1509 {
1510   ix86_expand_vector_set (false, operands[0], operands[1],
1511                           INTVAL (operands[2]));
1512   DONE;
1513 })
1514
1515 (define_insn_and_split "*vec_extractv4sf_0"
1516   [(set (match_operand:SF 0 "nonimmediate_operand" "=x,m,fr")
1517         (vec_select:SF
1518           (match_operand:V4SF 1 "nonimmediate_operand" "xm,x,m")
1519           (parallel [(const_int 0)])))]
1520   "TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1521   "#"
1522   "&& reload_completed"
1523   [(const_int 0)]
1524 {
1525   rtx op1 = operands[1];
1526   if (REG_P (op1))
1527     op1 = gen_rtx_REG (SFmode, REGNO (op1));
1528   else
1529     op1 = gen_lowpart (SFmode, op1);
1530   emit_move_insn (operands[0], op1);
1531   DONE;
1532 })
1533
1534 (define_insn "*sse4_1_extractps"
1535   [(set (match_operand:SF 0 "nonimmediate_operand" "=rm")
1536         (vec_select:SF
1537           (match_operand:V4SF 1 "register_operand" "x")
1538           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n")])))]
1539   "TARGET_SSE4_1"
1540   "extractps\t{%2, %1, %0|%0, %1, %2}"
1541   [(set_attr "type" "sselog")
1542    (set_attr "prefix_extra" "1")
1543    (set_attr "mode" "V4SF")])
1544
1545 (define_insn_and_split "*vec_extract_v4sf_mem"
1546   [(set (match_operand:SF 0 "register_operand" "=x*rf")
1547        (vec_select:SF
1548          (match_operand:V4SF 1 "memory_operand" "o")
1549          (parallel [(match_operand 2 "const_0_to_3_operand" "n")])))]
1550   ""
1551   "#"
1552   "reload_completed"
1553   [(const_int 0)]
1554 {
1555   int i = INTVAL (operands[2]);
1556
1557   emit_move_insn (operands[0], adjust_address (operands[1], SFmode, i*4));
1558   DONE;
1559 })
1560
1561 (define_expand "vec_extractv4sf"
1562   [(match_operand:SF 0 "register_operand" "")
1563    (match_operand:V4SF 1 "register_operand" "")
1564    (match_operand 2 "const_int_operand" "")]
1565   "TARGET_SSE"
1566 {
1567   ix86_expand_vector_extract (false, operands[0], operands[1],
1568                               INTVAL (operands[2]));
1569   DONE;
1570 })
1571
1572 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1573 ;;
1574 ;; Parallel double-precision floating point arithmetic
1575 ;;
1576 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1577
1578 (define_expand "negv2df2"
1579   [(set (match_operand:V2DF 0 "register_operand" "")
1580         (neg:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "")))]
1581   "TARGET_SSE2"
1582   "ix86_expand_fp_absneg_operator (NEG, V2DFmode, operands); DONE;")
1583
1584 (define_expand "absv2df2"
1585   [(set (match_operand:V2DF 0 "register_operand" "")
1586         (abs:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "")))]
1587   "TARGET_SSE2"
1588   "ix86_expand_fp_absneg_operator (ABS, V2DFmode, operands); DONE;")
1589
1590 (define_expand "addv2df3"
1591   [(set (match_operand:V2DF 0 "register_operand" "")
1592         (plus:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "")
1593                    (match_operand:V2DF 2 "nonimmediate_operand" "")))]
1594   "TARGET_SSE2"
1595   "ix86_fixup_binary_operands_no_copy (PLUS, V2DFmode, operands);")
1596
1597 (define_insn "*addv2df3"
1598   [(set (match_operand:V2DF 0 "register_operand" "=x")
1599         (plus:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "%0")
1600                    (match_operand:V2DF 2 "nonimmediate_operand" "xm")))]
1601   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V2DFmode, operands)"
1602   "addpd\t{%2, %0|%0, %2}"
1603   [(set_attr "type" "sseadd")
1604    (set_attr "mode" "V2DF")])
1605
1606 (define_insn "sse2_vmaddv2df3"
1607   [(set (match_operand:V2DF 0 "register_operand" "=x")
1608         (vec_merge:V2DF
1609           (plus:V2DF (match_operand:V2DF 1 "register_operand" "0")
1610                      (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1611           (match_dup 1)
1612           (const_int 1)))]
1613   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V4SFmode, operands)"
1614   "addsd\t{%2, %0|%0, %2}"
1615   [(set_attr "type" "sseadd")
1616    (set_attr "mode" "DF")])
1617
1618 (define_expand "subv2df3"
1619   [(set (match_operand:V2DF 0 "register_operand" "")
1620         (minus:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "")
1621                     (match_operand:V2DF 2 "nonimmediate_operand" "")))]
1622   "TARGET_SSE2"
1623   "ix86_fixup_binary_operands_no_copy (MINUS, V2DFmode, operands);")
1624
1625 (define_insn "*subv2df3"
1626   [(set (match_operand:V2DF 0 "register_operand" "=x")
1627         (minus:V2DF (match_operand:V2DF 1 "register_operand" "0")
1628                     (match_operand:V2DF 2 "nonimmediate_operand" "xm")))]
1629   "TARGET_SSE2"
1630   "subpd\t{%2, %0|%0, %2}"
1631   [(set_attr "type" "sseadd")
1632    (set_attr "mode" "V2DF")])
1633
1634 (define_insn "sse2_vmsubv2df3"
1635   [(set (match_operand:V2DF 0 "register_operand" "=x")
1636         (vec_merge:V2DF
1637           (minus:V2DF (match_operand:V2DF 1 "register_operand" "0")
1638                       (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1639           (match_dup 1)
1640           (const_int 1)))]
1641   "TARGET_SSE2"
1642   "subsd\t{%2, %0|%0, %2}"
1643   [(set_attr "type" "sseadd")
1644    (set_attr "mode" "DF")])
1645
1646 (define_expand "mulv2df3"
1647   [(set (match_operand:V2DF 0 "register_operand" "")
1648         (mult:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "")
1649                    (match_operand:V2DF 2 "nonimmediate_operand" "")))]
1650   "TARGET_SSE2"
1651   "ix86_fixup_binary_operands_no_copy (MULT, V2DFmode, operands);")
1652
1653 (define_insn "*mulv2df3"
1654   [(set (match_operand:V2DF 0 "register_operand" "=x")
1655         (mult:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "%0")
1656                    (match_operand:V2DF 2 "nonimmediate_operand" "xm")))]
1657   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V2DFmode, operands)"
1658   "mulpd\t{%2, %0|%0, %2}"
1659   [(set_attr "type" "ssemul")
1660    (set_attr "mode" "V2DF")])
1661
1662 (define_insn "sse2_vmmulv2df3"
1663   [(set (match_operand:V2DF 0 "register_operand" "=x")
1664         (vec_merge:V2DF
1665           (mult:V2DF (match_operand:V2DF 1 "register_operand" "0")
1666                      (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1667           (match_dup 1)
1668           (const_int 1)))]
1669   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V2DFmode, operands)"
1670   "mulsd\t{%2, %0|%0, %2}"
1671   [(set_attr "type" "ssemul")
1672    (set_attr "mode" "DF")])
1673
1674 (define_expand "divv2df3"
1675   [(set (match_operand:V2DF 0 "register_operand" "")
1676         (div:V2DF (match_operand:V2DF 1 "register_operand" "")
1677                   (match_operand:V2DF 2 "nonimmediate_operand" "")))]
1678   "TARGET_SSE2"
1679   "ix86_fixup_binary_operands_no_copy (DIV, V2DFmode, operands);")
1680
1681 (define_insn "*divv2df3"
1682   [(set (match_operand:V2DF 0 "register_operand" "=x")
1683         (div:V2DF (match_operand:V2DF 1 "register_operand" "0")
1684                   (match_operand:V2DF 2 "nonimmediate_operand" "xm")))]
1685   "TARGET_SSE2"
1686   "divpd\t{%2, %0|%0, %2}"
1687   [(set_attr "type" "ssediv")
1688    (set_attr "mode" "V2DF")])
1689
1690 (define_insn "sse2_vmdivv2df3"
1691   [(set (match_operand:V2DF 0 "register_operand" "=x")
1692         (vec_merge:V2DF
1693           (div:V2DF (match_operand:V2DF 1 "register_operand" "0")
1694                     (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1695           (match_dup 1)
1696           (const_int 1)))]
1697   "TARGET_SSE2"
1698   "divsd\t{%2, %0|%0, %2}"
1699   [(set_attr "type" "ssediv")
1700    (set_attr "mode" "DF")])
1701
1702 (define_insn "sqrtv2df2"
1703   [(set (match_operand:V2DF 0 "register_operand" "=x")
1704         (sqrt:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
1705   "TARGET_SSE2"
1706   "sqrtpd\t{%1, %0|%0, %1}"
1707   [(set_attr "type" "sse")
1708    (set_attr "mode" "V2DF")])
1709
1710 (define_insn "sse2_vmsqrtv2df2"
1711   [(set (match_operand:V2DF 0 "register_operand" "=x")
1712         (vec_merge:V2DF
1713           (sqrt:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
1714           (match_operand:V2DF 2 "register_operand" "0")
1715           (const_int 1)))]
1716   "TARGET_SSE2"
1717   "sqrtsd\t{%1, %0|%0, %1}"
1718   [(set_attr "type" "sse")
1719    (set_attr "mode" "DF")])
1720
1721 ;; ??? For !flag_finite_math_only, the representation with SMIN/SMAX
1722 ;; isn't really correct, as those rtl operators aren't defined when
1723 ;; applied to NaNs.  Hopefully the optimizers won't get too smart on us.
1724
1725 (define_expand "smaxv2df3"
1726   [(set (match_operand:V2DF 0 "register_operand" "")
1727         (smax:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "")
1728                    (match_operand:V2DF 2 "nonimmediate_operand" "")))]
1729   "TARGET_SSE2"
1730 {
1731   if (!flag_finite_math_only)
1732     operands[1] = force_reg (V2DFmode, operands[1]);
1733   ix86_fixup_binary_operands_no_copy (SMAX, V2DFmode, operands);
1734 })
1735
1736 (define_insn "*smaxv2df3_finite"
1737   [(set (match_operand:V2DF 0 "register_operand" "=x")
1738         (smax:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "%0")
1739                    (match_operand:V2DF 2 "nonimmediate_operand" "xm")))]
1740   "TARGET_SSE2 && flag_finite_math_only
1741    && ix86_binary_operator_ok (SMAX, V2DFmode, operands)"
1742   "maxpd\t{%2, %0|%0, %2}"
1743   [(set_attr "type" "sseadd")
1744    (set_attr "mode" "V2DF")])
1745
1746 (define_insn "*smaxv2df3"
1747   [(set (match_operand:V2DF 0 "register_operand" "=x")
1748         (smax:V2DF (match_operand:V2DF 1 "register_operand" "0")
1749                    (match_operand:V2DF 2 "nonimmediate_operand" "xm")))]
1750   "TARGET_SSE2"
1751   "maxpd\t{%2, %0|%0, %2}"
1752   [(set_attr "type" "sseadd")
1753    (set_attr "mode" "V2DF")])
1754
1755 (define_insn "sse2_vmsmaxv2df3"
1756   [(set (match_operand:V2DF 0 "register_operand" "=x")
1757         (vec_merge:V2DF
1758           (smax:V2DF (match_operand:V2DF 1 "register_operand" "0")
1759                      (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1760           (match_dup 1)
1761           (const_int 1)))]
1762   "TARGET_SSE2"
1763   "maxsd\t{%2, %0|%0, %2}"
1764   [(set_attr "type" "sseadd")
1765    (set_attr "mode" "DF")])
1766
1767 (define_expand "sminv2df3"
1768   [(set (match_operand:V2DF 0 "register_operand" "")
1769         (smin:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "")
1770                    (match_operand:V2DF 2 "nonimmediate_operand" "")))]
1771   "TARGET_SSE2"
1772 {
1773   if (!flag_finite_math_only)
1774     operands[1] = force_reg (V2DFmode, operands[1]);
1775   ix86_fixup_binary_operands_no_copy (SMIN, V2DFmode, operands);
1776 })
1777
1778 (define_insn "*sminv2df3_finite"
1779   [(set (match_operand:V2DF 0 "register_operand" "=x")
1780         (smin:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "%0")
1781                    (match_operand:V2DF 2 "nonimmediate_operand" "xm")))]
1782   "TARGET_SSE2 && flag_finite_math_only
1783    && ix86_binary_operator_ok (SMIN, V2DFmode, operands)"
1784   "minpd\t{%2, %0|%0, %2}"
1785   [(set_attr "type" "sseadd")
1786    (set_attr "mode" "V2DF")])
1787
1788 (define_insn "*sminv2df3"
1789   [(set (match_operand:V2DF 0 "register_operand" "=x")
1790         (smin:V2DF (match_operand:V2DF 1 "register_operand" "0")
1791                    (match_operand:V2DF 2 "nonimmediate_operand" "xm")))]
1792   "TARGET_SSE2"
1793   "minpd\t{%2, %0|%0, %2}"
1794   [(set_attr "type" "sseadd")
1795    (set_attr "mode" "V2DF")])
1796
1797 (define_insn "sse2_vmsminv2df3"
1798   [(set (match_operand:V2DF 0 "register_operand" "=x")
1799         (vec_merge:V2DF
1800           (smin:V2DF (match_operand:V2DF 1 "register_operand" "0")
1801                      (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1802           (match_dup 1)
1803           (const_int 1)))]
1804   "TARGET_SSE2"
1805   "minsd\t{%2, %0|%0, %2}"
1806   [(set_attr "type" "sseadd")
1807    (set_attr "mode" "DF")])
1808
1809 (define_insn "sse3_addsubv2df3"
1810   [(set (match_operand:V2DF 0 "register_operand" "=x")
1811         (vec_merge:V2DF
1812           (plus:V2DF
1813             (match_operand:V2DF 1 "register_operand" "0")
1814             (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
1815           (minus:V2DF (match_dup 1) (match_dup 2))
1816           (const_int 1)))]
1817   "TARGET_SSE3"
1818   "addsubpd\t{%2, %0|%0, %2}"
1819   [(set_attr "type" "sseadd")
1820    (set_attr "mode" "V2DF")])
1821
1822 (define_insn "sse3_haddv2df3"
1823   [(set (match_operand:V2DF 0 "register_operand" "=x")
1824         (vec_concat:V2DF
1825           (plus:DF
1826             (vec_select:DF
1827               (match_operand:V2DF 1 "register_operand" "0")
1828               (parallel [(const_int 0)]))
1829             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1830           (plus:DF
1831             (vec_select:DF
1832               (match_operand:V2DF 2 "nonimmediate_operand" "xm")
1833               (parallel [(const_int 0)]))
1834             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1835   "TARGET_SSE3"
1836   "haddpd\t{%2, %0|%0, %2}"
1837   [(set_attr "type" "sseadd")
1838    (set_attr "mode" "V2DF")])
1839
1840 (define_insn "sse3_hsubv2df3"
1841   [(set (match_operand:V2DF 0 "register_operand" "=x")
1842         (vec_concat:V2DF
1843           (minus:DF
1844             (vec_select:DF
1845               (match_operand:V2DF 1 "register_operand" "0")
1846               (parallel [(const_int 0)]))
1847             (vec_select:DF (match_dup 1) (parallel [(const_int 1)])))
1848           (minus:DF
1849             (vec_select:DF
1850               (match_operand:V2DF 2 "nonimmediate_operand" "xm")
1851               (parallel [(const_int 0)]))
1852             (vec_select:DF (match_dup 2) (parallel [(const_int 1)])))))]
1853   "TARGET_SSE3"
1854   "hsubpd\t{%2, %0|%0, %2}"
1855   [(set_attr "type" "sseadd")
1856    (set_attr "mode" "V2DF")])
1857
1858 (define_expand "reduc_splus_v2df"
1859   [(match_operand:V2DF 0 "register_operand" "")
1860    (match_operand:V2DF 1 "register_operand" "")]
1861   "TARGET_SSE3"
1862 {
1863   emit_insn (gen_sse3_haddv2df3 (operands[0], operands[1], operands[1]));
1864   DONE;
1865 })
1866
1867 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1868 ;;
1869 ;; Parallel double-precision floating point comparisons
1870 ;;
1871 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1872
1873 (define_insn "sse2_maskcmpv2df3"
1874   [(set (match_operand:V2DF 0 "register_operand" "=x")
1875         (match_operator:V2DF 3 "sse_comparison_operator"
1876                 [(match_operand:V2DF 1 "register_operand" "0")
1877                  (match_operand:V2DF 2 "nonimmediate_operand" "xm")]))]
1878   "TARGET_SSE2"
1879   "cmp%D3pd\t{%2, %0|%0, %2}"
1880   [(set_attr "type" "ssecmp")
1881    (set_attr "mode" "V2DF")])
1882
1883 (define_insn "sse2_maskcmpdf3"
1884   [(set (match_operand:DF 0 "register_operand" "=x")
1885         (match_operator:DF 3 "sse_comparison_operator"
1886                 [(match_operand:DF 1 "register_operand" "0")
1887                  (match_operand:DF 2 "nonimmediate_operand" "xm")]))]
1888   "TARGET_SSE2"
1889   "cmp%D3sd\t{%2, %0|%0, %2}"
1890   [(set_attr "type" "ssecmp")
1891    (set_attr "mode" "DF")])
1892
1893 (define_insn "sse2_vmmaskcmpv2df3"
1894   [(set (match_operand:V2DF 0 "register_operand" "=x")
1895         (vec_merge:V2DF
1896           (match_operator:V2DF 3 "sse_comparison_operator"
1897                 [(match_operand:V2DF 1 "register_operand" "0")
1898                  (match_operand:V2DF 2 "nonimmediate_operand" "xm")])
1899           (match_dup 1)
1900           (const_int 1)))]
1901   "TARGET_SSE2"
1902   "cmp%D3sd\t{%2, %0|%0, %2}"
1903   [(set_attr "type" "ssecmp")
1904    (set_attr "mode" "DF")])
1905
1906 (define_insn "sse2_comi"
1907   [(set (reg:CCFP FLAGS_REG)
1908         (compare:CCFP
1909           (vec_select:DF
1910             (match_operand:V2DF 0 "register_operand" "x")
1911             (parallel [(const_int 0)]))
1912           (vec_select:DF
1913             (match_operand:V2DF 1 "nonimmediate_operand" "xm")
1914             (parallel [(const_int 0)]))))]
1915   "TARGET_SSE2"
1916   "comisd\t{%1, %0|%0, %1}"
1917   [(set_attr "type" "ssecomi")
1918    (set_attr "mode" "DF")])
1919
1920 (define_insn "sse2_ucomi"
1921   [(set (reg:CCFPU FLAGS_REG)
1922         (compare:CCFPU
1923           (vec_select:DF
1924             (match_operand:V2DF 0 "register_operand" "x")
1925             (parallel [(const_int 0)]))
1926           (vec_select:DF
1927             (match_operand:V2DF 1 "nonimmediate_operand" "xm")
1928             (parallel [(const_int 0)]))))]
1929   "TARGET_SSE2"
1930   "ucomisd\t{%1, %0|%0, %1}"
1931   [(set_attr "type" "ssecomi")
1932    (set_attr "mode" "DF")])
1933
1934 (define_expand "vcondv2df"
1935   [(set (match_operand:V2DF 0 "register_operand" "")
1936         (if_then_else:V2DF
1937           (match_operator 3 ""
1938             [(match_operand:V2DF 4 "nonimmediate_operand" "")
1939              (match_operand:V2DF 5 "nonimmediate_operand" "")])
1940           (match_operand:V2DF 1 "general_operand" "")
1941           (match_operand:V2DF 2 "general_operand" "")))]
1942   "TARGET_SSE2"
1943 {
1944   if (ix86_expand_fp_vcond (operands))
1945     DONE;
1946   else
1947     FAIL;
1948 })
1949
1950 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1951 ;;
1952 ;; Parallel double-precision floating point logical operations
1953 ;;
1954 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1955
1956 (define_expand "andv2df3"
1957   [(set (match_operand:V2DF 0 "register_operand" "")
1958         (and:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "")
1959                   (match_operand:V2DF 2 "nonimmediate_operand" "")))]
1960   "TARGET_SSE2"
1961   "ix86_fixup_binary_operands_no_copy (AND, V2DFmode, operands);")
1962
1963 (define_insn "*andv2df3"
1964   [(set (match_operand:V2DF 0 "register_operand" "=x")
1965         (and:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "%0")
1966                   (match_operand:V2DF 2 "nonimmediate_operand" "xm")))]
1967   "TARGET_SSE2 && ix86_binary_operator_ok (AND, V2DFmode, operands)"
1968   "andpd\t{%2, %0|%0, %2}"
1969   [(set_attr "type" "sselog")
1970    (set_attr "mode" "V2DF")])
1971
1972 (define_insn "sse2_nandv2df3"
1973   [(set (match_operand:V2DF 0 "register_operand" "=x")
1974         (and:V2DF (not:V2DF (match_operand:V2DF 1 "register_operand" "0"))
1975                   (match_operand:V2DF 2 "nonimmediate_operand" "xm")))]
1976   "TARGET_SSE2"
1977   "andnpd\t{%2, %0|%0, %2}"
1978   [(set_attr "type" "sselog")
1979    (set_attr "mode" "V2DF")])
1980
1981 (define_expand "iorv2df3"
1982   [(set (match_operand:V2DF 0 "register_operand" "")
1983         (ior:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "")
1984                   (match_operand:V2DF 2 "nonimmediate_operand" "")))]
1985   "TARGET_SSE2"
1986   "ix86_fixup_binary_operands_no_copy (IOR, V2DFmode, operands);")
1987
1988 (define_insn "*iorv2df3"
1989   [(set (match_operand:V2DF 0 "register_operand" "=x")
1990         (ior:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "%0")
1991                   (match_operand:V2DF 2 "nonimmediate_operand" "xm")))]
1992   "TARGET_SSE2 && ix86_binary_operator_ok (IOR, V2DFmode, operands)"
1993   "orpd\t{%2, %0|%0, %2}"
1994   [(set_attr "type" "sselog")
1995    (set_attr "mode" "V2DF")])
1996
1997 (define_expand "xorv2df3"
1998   [(set (match_operand:V2DF 0 "register_operand" "")
1999         (xor:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "")
2000                   (match_operand:V2DF 2 "nonimmediate_operand" "")))]
2001   "TARGET_SSE2"
2002   "ix86_fixup_binary_operands_no_copy (XOR, V2DFmode, operands);")
2003
2004 (define_insn "*xorv2df3"
2005   [(set (match_operand:V2DF 0 "register_operand" "=x")
2006         (xor:V2DF (match_operand:V2DF 1 "nonimmediate_operand" "%0")
2007                   (match_operand:V2DF 2 "nonimmediate_operand" "xm")))]
2008   "TARGET_SSE2 && ix86_binary_operator_ok (XOR, V2DFmode, operands)"
2009   "xorpd\t{%2, %0|%0, %2}"
2010   [(set_attr "type" "sselog")
2011    (set_attr "mode" "V2DF")])
2012
2013 ;; Also define scalar versions.  These are used for abs, neg, and
2014 ;; conditional move.  Using subregs into vector modes causes register
2015 ;; allocation lossage.  These patterns do not allow memory operands
2016 ;; because the native instructions read the full 128-bits.
2017
2018 (define_insn "*anddf3"
2019   [(set (match_operand:DF 0 "register_operand" "=x")
2020         (and:DF (match_operand:DF 1 "register_operand" "0")
2021                 (match_operand:DF 2 "register_operand" "x")))]
2022   "TARGET_SSE2"
2023   "andpd\t{%2, %0|%0, %2}"
2024   [(set_attr "type" "sselog")
2025    (set_attr "mode" "V2DF")])
2026
2027 (define_insn "*nanddf3"
2028   [(set (match_operand:DF 0 "register_operand" "=x")
2029         (and:DF (not:DF (match_operand:DF 1 "register_operand" "0"))
2030                 (match_operand:DF 2 "register_operand" "x")))]
2031   "TARGET_SSE2"
2032   "andnpd\t{%2, %0|%0, %2}"
2033   [(set_attr "type" "sselog")
2034    (set_attr "mode" "V2DF")])
2035
2036 (define_insn "*iordf3"
2037   [(set (match_operand:DF 0 "register_operand" "=x")
2038         (ior:DF (match_operand:DF 1 "register_operand" "0")
2039                 (match_operand:DF 2 "register_operand" "x")))]
2040   "TARGET_SSE2"
2041   "orpd\t{%2, %0|%0, %2}"
2042   [(set_attr "type" "sselog")
2043    (set_attr "mode" "V2DF")])
2044
2045 (define_insn "*xordf3"
2046   [(set (match_operand:DF 0 "register_operand" "=x")
2047         (xor:DF (match_operand:DF 1 "register_operand" "0")
2048                 (match_operand:DF 2 "register_operand" "x")))]
2049   "TARGET_SSE2"
2050   "xorpd\t{%2, %0|%0, %2}"
2051   [(set_attr "type" "sselog")
2052    (set_attr "mode" "V2DF")])
2053
2054 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2055 ;;
2056 ;; Parallel double-precision floating point conversion operations
2057 ;;
2058 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2059
2060 (define_insn "sse2_cvtpi2pd"
2061   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2062         (float:V2DF (match_operand:V2SI 1 "nonimmediate_operand" "y,m")))]
2063   "TARGET_SSE2"
2064   "cvtpi2pd\t{%1, %0|%0, %1}"
2065   [(set_attr "type" "ssecvt")
2066    (set_attr "unit" "mmx,*")
2067    (set_attr "mode" "V2DF")])
2068
2069 (define_insn "sse2_cvtpd2pi"
2070   [(set (match_operand:V2SI 0 "register_operand" "=y")
2071         (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2072                      UNSPEC_FIX_NOTRUNC))]
2073   "TARGET_SSE2"
2074   "cvtpd2pi\t{%1, %0|%0, %1}"
2075   [(set_attr "type" "ssecvt")
2076    (set_attr "unit" "mmx")
2077    (set_attr "prefix_data16" "1")
2078    (set_attr "mode" "DI")])
2079
2080 (define_insn "sse2_cvttpd2pi"
2081   [(set (match_operand:V2SI 0 "register_operand" "=y")
2082         (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm")))]
2083   "TARGET_SSE2"
2084   "cvttpd2pi\t{%1, %0|%0, %1}"
2085   [(set_attr "type" "ssecvt")
2086    (set_attr "unit" "mmx")
2087    (set_attr "prefix_data16" "1")
2088    (set_attr "mode" "TI")])
2089
2090 (define_insn "sse2_cvtsi2sd"
2091   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2092         (vec_merge:V2DF
2093           (vec_duplicate:V2DF
2094             (float:DF (match_operand:SI 2 "nonimmediate_operand" "r,m")))
2095           (match_operand:V2DF 1 "register_operand" "0,0")
2096           (const_int 1)))]
2097   "TARGET_SSE2"
2098   "cvtsi2sd\t{%2, %0|%0, %2}"
2099   [(set_attr "type" "sseicvt")
2100    (set_attr "mode" "DF")
2101    (set_attr "athlon_decode" "double,direct")
2102    (set_attr "amdfam10_decode" "vector,double")])
2103
2104 (define_insn "sse2_cvtsi2sdq"
2105   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2106         (vec_merge:V2DF
2107           (vec_duplicate:V2DF
2108             (float:DF (match_operand:DI 2 "nonimmediate_operand" "r,m")))
2109           (match_operand:V2DF 1 "register_operand" "0,0")
2110           (const_int 1)))]
2111   "TARGET_SSE2 && TARGET_64BIT"
2112   "cvtsi2sdq\t{%2, %0|%0, %2}"
2113   [(set_attr "type" "sseicvt")
2114    (set_attr "mode" "DF")
2115    (set_attr "athlon_decode" "double,direct")
2116    (set_attr "amdfam10_decode" "vector,double")])
2117
2118 (define_insn "sse2_cvtsd2si"
2119   [(set (match_operand:SI 0 "register_operand" "=r,r")
2120         (unspec:SI
2121           [(vec_select:DF
2122              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2123              (parallel [(const_int 0)]))]
2124           UNSPEC_FIX_NOTRUNC))]
2125   "TARGET_SSE2"
2126   "cvtsd2si\t{%1, %0|%0, %1}"
2127   [(set_attr "type" "sseicvt")
2128    (set_attr "athlon_decode" "double,vector")
2129    (set_attr "prefix_rep" "1")
2130    (set_attr "mode" "SI")])
2131
2132 (define_insn "sse2_cvtsd2si_2"
2133   [(set (match_operand:SI 0 "register_operand" "=r,r")
2134         (unspec:SI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2135          UNSPEC_FIX_NOTRUNC))]
2136   "TARGET_SSE2"
2137   "cvtsd2si\t{%1, %0|%0, %1}"
2138   [(set_attr "type" "sseicvt")
2139    (set_attr "athlon_decode" "double,vector")
2140    (set_attr "amdfam10_decode" "double,double")
2141    (set_attr "prefix_rep" "1")
2142    (set_attr "mode" "SI")])
2143
2144 (define_insn "sse2_cvtsd2siq"
2145   [(set (match_operand:DI 0 "register_operand" "=r,r")
2146         (unspec:DI
2147           [(vec_select:DF
2148              (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2149              (parallel [(const_int 0)]))]
2150           UNSPEC_FIX_NOTRUNC))]
2151   "TARGET_SSE2 && TARGET_64BIT"
2152   "cvtsd2siq\t{%1, %0|%0, %1}"
2153   [(set_attr "type" "sseicvt")
2154    (set_attr "athlon_decode" "double,vector")
2155    (set_attr "prefix_rep" "1")
2156    (set_attr "mode" "DI")])
2157
2158 (define_insn "sse2_cvtsd2siq_2"
2159   [(set (match_operand:DI 0 "register_operand" "=r,r")
2160         (unspec:DI [(match_operand:DF 1 "nonimmediate_operand" "x,m")]
2161          UNSPEC_FIX_NOTRUNC))]
2162   "TARGET_SSE2 && TARGET_64BIT"
2163   "cvtsd2siq\t{%1, %0|%0, %1}"
2164   [(set_attr "type" "sseicvt")
2165    (set_attr "athlon_decode" "double,vector")
2166    (set_attr "amdfam10_decode" "double,double")
2167    (set_attr "prefix_rep" "1")
2168    (set_attr "mode" "DI")])
2169
2170 (define_insn "sse2_cvttsd2si"
2171   [(set (match_operand:SI 0 "register_operand" "=r,r")
2172         (fix:SI
2173           (vec_select:DF
2174             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2175             (parallel [(const_int 0)]))))]
2176   "TARGET_SSE2"
2177   "cvttsd2si\t{%1, %0|%0, %1}"
2178   [(set_attr "type" "sseicvt")
2179    (set_attr "prefix_rep" "1")
2180    (set_attr "mode" "SI")
2181    (set_attr "athlon_decode" "double,vector")
2182    (set_attr "amdfam10_decode" "double,double")])
2183
2184 (define_insn "sse2_cvttsd2siq"
2185   [(set (match_operand:DI 0 "register_operand" "=r,r")
2186         (fix:DI
2187           (vec_select:DF
2188             (match_operand:V2DF 1 "nonimmediate_operand" "x,m")
2189             (parallel [(const_int 0)]))))]
2190   "TARGET_SSE2 && TARGET_64BIT"
2191   "cvttsd2siq\t{%1, %0|%0, %1}"
2192   [(set_attr "type" "sseicvt")
2193    (set_attr "prefix_rep" "1")
2194    (set_attr "mode" "DI")
2195    (set_attr "athlon_decode" "double,vector")
2196    (set_attr "amdfam10_decode" "double,double")])
2197
2198 (define_insn "sse2_cvtdq2pd"
2199   [(set (match_operand:V2DF 0 "register_operand" "=x")
2200         (float:V2DF
2201           (vec_select:V2SI
2202             (match_operand:V4SI 1 "nonimmediate_operand" "xm")
2203             (parallel [(const_int 0) (const_int 1)]))))]
2204   "TARGET_SSE2"
2205   "cvtdq2pd\t{%1, %0|%0, %1}"
2206   [(set_attr "type" "ssecvt")
2207    (set_attr "mode" "V2DF")])
2208
2209 (define_expand "sse2_cvtpd2dq"
2210   [(set (match_operand:V4SI 0 "register_operand" "")
2211         (vec_concat:V4SI
2212           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "")]
2213                        UNSPEC_FIX_NOTRUNC)
2214           (match_dup 2)))]
2215   "TARGET_SSE2"
2216   "operands[2] = CONST0_RTX (V2SImode);")
2217
2218 (define_insn "*sse2_cvtpd2dq"
2219   [(set (match_operand:V4SI 0 "register_operand" "=x")
2220         (vec_concat:V4SI
2221           (unspec:V2SI [(match_operand:V2DF 1 "nonimmediate_operand" "xm")]
2222                        UNSPEC_FIX_NOTRUNC)
2223           (match_operand:V2SI 2 "const0_operand" "")))]
2224   "TARGET_SSE2"
2225   "cvtpd2dq\t{%1, %0|%0, %1}"
2226   [(set_attr "type" "ssecvt")
2227    (set_attr "prefix_rep" "1")
2228    (set_attr "mode" "TI")
2229    (set_attr "amdfam10_decode" "double")])
2230
2231 (define_expand "sse2_cvttpd2dq"
2232   [(set (match_operand:V4SI 0 "register_operand" "")
2233         (vec_concat:V4SI
2234           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" ""))
2235           (match_dup 2)))]
2236   "TARGET_SSE2"
2237   "operands[2] = CONST0_RTX (V2SImode);")
2238
2239 (define_insn "*sse2_cvttpd2dq"
2240   [(set (match_operand:V4SI 0 "register_operand" "=x")
2241         (vec_concat:V4SI
2242           (fix:V2SI (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2243           (match_operand:V2SI 2 "const0_operand" "")))]
2244   "TARGET_SSE2"
2245   "cvttpd2dq\t{%1, %0|%0, %1}"
2246   [(set_attr "type" "ssecvt")
2247    (set_attr "prefix_rep" "1")
2248    (set_attr "mode" "TI")
2249    (set_attr "amdfam10_decode" "double")])
2250
2251 (define_insn "sse2_cvtsd2ss"
2252   [(set (match_operand:V4SF 0 "register_operand" "=x,x")
2253         (vec_merge:V4SF
2254           (vec_duplicate:V4SF
2255             (float_truncate:V2SF
2256               (match_operand:V2DF 2 "nonimmediate_operand" "x,m")))
2257           (match_operand:V4SF 1 "register_operand" "0,0")
2258           (const_int 1)))]
2259   "TARGET_SSE2"
2260   "cvtsd2ss\t{%2, %0|%0, %2}"
2261   [(set_attr "type" "ssecvt")
2262    (set_attr "athlon_decode" "vector,double")
2263    (set_attr "amdfam10_decode" "vector,double")
2264    (set_attr "mode" "SF")])
2265
2266 (define_insn "sse2_cvtss2sd"
2267   [(set (match_operand:V2DF 0 "register_operand" "=x,x")
2268         (vec_merge:V2DF
2269           (float_extend:V2DF
2270             (vec_select:V2SF
2271               (match_operand:V4SF 2 "nonimmediate_operand" "x,m")
2272               (parallel [(const_int 0) (const_int 1)])))
2273           (match_operand:V2DF 1 "register_operand" "0,0")
2274           (const_int 1)))]
2275   "TARGET_SSE2"
2276   "cvtss2sd\t{%2, %0|%0, %2}"
2277   [(set_attr "type" "ssecvt")
2278    (set_attr "amdfam10_decode" "vector,double")
2279    (set_attr "mode" "DF")])
2280
2281 (define_expand "sse2_cvtpd2ps"
2282   [(set (match_operand:V4SF 0 "register_operand" "")
2283         (vec_concat:V4SF
2284           (float_truncate:V2SF
2285             (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2286           (match_dup 2)))]
2287   "TARGET_SSE2"
2288   "operands[2] = CONST0_RTX (V2SFmode);")
2289
2290 (define_insn "*sse2_cvtpd2ps"
2291   [(set (match_operand:V4SF 0 "register_operand" "=x")
2292         (vec_concat:V4SF
2293           (float_truncate:V2SF
2294             (match_operand:V2DF 1 "nonimmediate_operand" "xm"))
2295           (match_operand:V2SF 2 "const0_operand" "")))]
2296   "TARGET_SSE2"
2297   "cvtpd2ps\t{%1, %0|%0, %1}"
2298   [(set_attr "type" "ssecvt")
2299    (set_attr "prefix_data16" "1")
2300    (set_attr "mode" "V4SF")
2301    (set_attr "amdfam10_decode" "double")])
2302
2303 (define_insn "sse2_cvtps2pd"
2304   [(set (match_operand:V2DF 0 "register_operand" "=x")
2305         (float_extend:V2DF
2306           (vec_select:V2SF
2307             (match_operand:V4SF 1 "nonimmediate_operand" "xm")
2308             (parallel [(const_int 0) (const_int 1)]))))]
2309   "TARGET_SSE2"
2310   "cvtps2pd\t{%1, %0|%0, %1}"
2311   [(set_attr "type" "ssecvt")
2312    (set_attr "mode" "V2DF")
2313    (set_attr "amdfam10_decode" "direct")])
2314
2315 (define_expand "vec_unpacks_hi_v4sf"
2316   [(set (match_dup 2)
2317    (vec_select:V4SF
2318      (vec_concat:V8SF
2319        (match_dup 2)
2320        (match_operand:V4SF 1 "nonimmediate_operand" ""))
2321      (parallel [(const_int 6)
2322                 (const_int 7)
2323                 (const_int 2)
2324                 (const_int 3)])))
2325   (set (match_operand:V2DF 0 "register_operand" "")
2326    (float_extend:V2DF
2327      (vec_select:V2SF
2328        (match_dup 2)
2329        (parallel [(const_int 0) (const_int 1)]))))]
2330  "TARGET_SSE2"
2331 {
2332  operands[2] = gen_reg_rtx (V4SFmode);
2333 })
2334
2335 (define_expand "vec_unpacks_lo_v4sf"
2336   [(set (match_operand:V2DF 0 "register_operand" "")
2337         (float_extend:V2DF
2338           (vec_select:V2SF
2339             (match_operand:V4SF 1 "nonimmediate_operand" "")
2340             (parallel [(const_int 0) (const_int 1)]))))]
2341   "TARGET_SSE2")
2342
2343 (define_expand "vec_unpacks_float_hi_v8hi"
2344   [(match_operand:V4SF 0 "register_operand" "")
2345    (match_operand:V8HI 1 "register_operand" "")]
2346   "TARGET_SSE2"
2347 {
2348   rtx tmp = gen_reg_rtx (V4SImode);
2349
2350   emit_insn (gen_vec_unpacks_hi_v8hi (tmp, operands[1]));
2351   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2352   DONE;
2353 })
2354
2355 (define_expand "vec_unpacks_float_lo_v8hi"
2356   [(match_operand:V4SF 0 "register_operand" "")
2357    (match_operand:V8HI 1 "register_operand" "")]
2358   "TARGET_SSE2"
2359 {
2360   rtx tmp = gen_reg_rtx (V4SImode);
2361
2362   emit_insn (gen_vec_unpacks_lo_v8hi (tmp, operands[1]));
2363   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2364   DONE;
2365 })
2366
2367 (define_expand "vec_unpacku_float_hi_v8hi"
2368   [(match_operand:V4SF 0 "register_operand" "")
2369    (match_operand:V8HI 1 "register_operand" "")]
2370   "TARGET_SSE2"
2371 {
2372   rtx tmp = gen_reg_rtx (V4SImode);
2373
2374   emit_insn (gen_vec_unpacku_hi_v8hi (tmp, operands[1]));
2375   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2376   DONE;
2377 })
2378
2379 (define_expand "vec_unpacku_float_lo_v8hi"
2380   [(match_operand:V4SF 0 "register_operand" "")
2381    (match_operand:V8HI 1 "register_operand" "")]
2382   "TARGET_SSE2"
2383 {
2384   rtx tmp = gen_reg_rtx (V4SImode);
2385
2386   emit_insn (gen_vec_unpacku_lo_v8hi (tmp, operands[1]));
2387   emit_insn (gen_sse2_cvtdq2ps (operands[0], tmp));
2388   DONE;
2389 })
2390
2391 (define_expand "vec_unpacks_float_hi_v4si"
2392   [(set (match_dup 2)
2393         (vec_select:V4SI
2394           (match_operand:V4SI 1 "nonimmediate_operand" "")
2395           (parallel [(const_int 2)
2396                      (const_int 3)
2397                      (const_int 2)
2398                      (const_int 3)])))
2399    (set (match_operand:V2DF 0 "register_operand" "")
2400         (float:V2DF
2401           (vec_select:V2SI
2402           (match_dup 2)
2403             (parallel [(const_int 0) (const_int 1)]))))]
2404  "TARGET_SSE2"
2405 {
2406  operands[2] = gen_reg_rtx (V4SImode);
2407 })
2408
2409 (define_expand "vec_unpacks_float_lo_v4si"
2410   [(set (match_operand:V2DF 0 "register_operand" "")
2411         (float:V2DF
2412           (vec_select:V2SI
2413             (match_operand:V4SI 1 "nonimmediate_operand" "")
2414             (parallel [(const_int 0) (const_int 1)]))))]
2415   "TARGET_SSE2")
2416
2417 (define_expand "vec_pack_trunc_v2df"
2418   [(match_operand:V4SF 0 "register_operand" "")
2419    (match_operand:V2DF 1 "nonimmediate_operand" "")
2420    (match_operand:V2DF 2 "nonimmediate_operand" "")]
2421   "TARGET_SSE2"
2422 {
2423   rtx r1, r2;
2424
2425   r1 = gen_reg_rtx (V4SFmode);
2426   r2 = gen_reg_rtx (V4SFmode);
2427
2428   emit_insn (gen_sse2_cvtpd2ps (r1, operands[1]));
2429   emit_insn (gen_sse2_cvtpd2ps (r2, operands[2]));
2430   emit_insn (gen_sse_movlhps (operands[0], r1, r2));
2431   DONE;
2432 })
2433
2434 (define_expand "vec_pack_sfix_trunc_v2df"
2435   [(match_operand:V4SI 0 "register_operand" "")
2436    (match_operand:V2DF 1 "nonimmediate_operand" "")
2437    (match_operand:V2DF 2 "nonimmediate_operand" "")]
2438   "TARGET_SSE2"
2439 {
2440   rtx r1, r2;
2441
2442   r1 = gen_reg_rtx (V4SImode);
2443   r2 = gen_reg_rtx (V4SImode);
2444
2445   emit_insn (gen_sse2_cvttpd2dq (r1, operands[1]));
2446   emit_insn (gen_sse2_cvttpd2dq (r2, operands[2]));
2447   emit_insn (gen_sse2_punpcklqdq (gen_lowpart (V2DImode, operands[0]),
2448                                   gen_lowpart (V2DImode, r1),
2449                                   gen_lowpart (V2DImode, r2)));
2450   DONE;
2451 })
2452
2453 (define_expand "vec_pack_sfix_v2df"
2454   [(match_operand:V4SI 0 "register_operand" "")
2455    (match_operand:V2DF 1 "nonimmediate_operand" "")
2456    (match_operand:V2DF 2 "nonimmediate_operand" "")]
2457   "TARGET_SSE2"
2458 {
2459   rtx r1, r2;
2460
2461   r1 = gen_reg_rtx (V4SImode);
2462   r2 = gen_reg_rtx (V4SImode);
2463
2464   emit_insn (gen_sse2_cvtpd2dq (r1, operands[1]));
2465   emit_insn (gen_sse2_cvtpd2dq (r2, operands[2]));
2466   emit_insn (gen_sse2_punpcklqdq (gen_lowpart (V2DImode, operands[0]),
2467                                   gen_lowpart (V2DImode, r1),
2468                                   gen_lowpart (V2DImode, r2)));
2469   DONE;
2470 })
2471
2472
2473 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2474 ;;
2475 ;; Parallel double-precision floating point element swizzling
2476 ;;
2477 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2478
2479 (define_insn "sse2_unpckhpd"
2480   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,m")
2481         (vec_select:V2DF
2482           (vec_concat:V4DF
2483             (match_operand:V2DF 1 "nonimmediate_operand" " 0,o,x")
2484             (match_operand:V2DF 2 "nonimmediate_operand" " x,0,0"))
2485           (parallel [(const_int 1)
2486                      (const_int 3)])))]
2487   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
2488   "@
2489    unpckhpd\t{%2, %0|%0, %2}
2490    movlpd\t{%H1, %0|%0, %H1}
2491    movhpd\t{%1, %0|%0, %1}"
2492   [(set_attr "type" "sselog,ssemov,ssemov")
2493    (set_attr "mode" "V2DF,V1DF,V1DF")])
2494
2495 (define_insn "*sse3_movddup"
2496   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,o")
2497         (vec_select:V2DF
2498           (vec_concat:V4DF
2499             (match_operand:V2DF 1 "nonimmediate_operand" "xm,x")
2500             (match_dup 1))
2501           (parallel [(const_int 0)
2502                      (const_int 2)])))]
2503   "TARGET_SSE3 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2504   "@
2505    movddup\t{%1, %0|%0, %1}
2506    #"
2507   [(set_attr "type" "sselog1,ssemov")
2508    (set_attr "mode" "V2DF")])
2509
2510 (define_split
2511   [(set (match_operand:V2DF 0 "memory_operand" "")
2512         (vec_select:V2DF
2513           (vec_concat:V4DF
2514             (match_operand:V2DF 1 "register_operand" "")
2515             (match_dup 1))
2516           (parallel [(const_int 0)
2517                      (const_int 2)])))]
2518   "TARGET_SSE3 && reload_completed"
2519   [(const_int 0)]
2520 {
2521   rtx low = gen_rtx_REG (DFmode, REGNO (operands[1]));
2522   emit_move_insn (adjust_address (operands[0], DFmode, 0), low);
2523   emit_move_insn (adjust_address (operands[0], DFmode, 8), low);
2524   DONE;
2525 })
2526
2527 (define_insn "sse2_unpcklpd"
2528   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,o")
2529         (vec_select:V2DF
2530           (vec_concat:V4DF
2531             (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,0")
2532             (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x"))
2533           (parallel [(const_int 0)
2534                      (const_int 2)])))]
2535   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
2536   "@
2537    unpcklpd\t{%2, %0|%0, %2}
2538    movhpd\t{%2, %0|%0, %2}
2539    movlpd\t{%2, %H0|%H0, %2}"
2540   [(set_attr "type" "sselog,ssemov,ssemov")
2541    (set_attr "mode" "V2DF,V1DF,V1DF")])
2542
2543 (define_expand "sse2_shufpd"
2544   [(match_operand:V2DF 0 "register_operand" "")
2545    (match_operand:V2DF 1 "register_operand" "")
2546    (match_operand:V2DF 2 "nonimmediate_operand" "")
2547    (match_operand:SI 3 "const_int_operand" "")]
2548   "TARGET_SSE2"
2549 {
2550   int mask = INTVAL (operands[3]);
2551   emit_insn (gen_sse2_shufpd_1 (operands[0], operands[1], operands[2],
2552                                 GEN_INT (mask & 1),
2553                                 GEN_INT (mask & 2 ? 3 : 2)));
2554   DONE;
2555 })
2556
2557 (define_insn "sse2_shufpd_1"
2558   [(set (match_operand:V2DF 0 "register_operand" "=x")
2559         (vec_select:V2DF
2560           (vec_concat:V4DF
2561             (match_operand:V2DF 1 "register_operand" "0")
2562             (match_operand:V2DF 2 "nonimmediate_operand" "xm"))
2563           (parallel [(match_operand 3 "const_0_to_1_operand" "")
2564                      (match_operand 4 "const_2_to_3_operand" "")])))]
2565   "TARGET_SSE2"
2566 {
2567   int mask;
2568   mask = INTVAL (operands[3]);
2569   mask |= (INTVAL (operands[4]) - 2) << 1;
2570   operands[3] = GEN_INT (mask);
2571
2572   return "shufpd\t{%3, %2, %0|%0, %2, %3}";
2573 }
2574   [(set_attr "type" "sselog")
2575    (set_attr "mode" "V2DF")])
2576
2577 (define_insn "sse2_storehpd"
2578   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x*fr")
2579         (vec_select:DF
2580           (match_operand:V2DF 1 "nonimmediate_operand" " x,0,o")
2581           (parallel [(const_int 1)])))]
2582   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2583   "@
2584    movhpd\t{%1, %0|%0, %1}
2585    unpckhpd\t%0, %0
2586    #"
2587   [(set_attr "type" "ssemov,sselog1,ssemov")
2588    (set_attr "mode" "V1DF,V2DF,DF")])
2589
2590 (define_split
2591   [(set (match_operand:DF 0 "register_operand" "")
2592         (vec_select:DF
2593           (match_operand:V2DF 1 "memory_operand" "")
2594           (parallel [(const_int 1)])))]
2595   "TARGET_SSE2 && reload_completed"
2596   [(set (match_dup 0) (match_dup 1))]
2597 {
2598   operands[1] = adjust_address (operands[1], DFmode, 8);
2599 })
2600
2601 (define_insn "sse2_storelpd"
2602   [(set (match_operand:DF 0 "nonimmediate_operand"     "=m,x,x*fr")
2603         (vec_select:DF
2604           (match_operand:V2DF 1 "nonimmediate_operand" " x,x,m")
2605           (parallel [(const_int 0)])))]
2606   "TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2607   "@
2608    movlpd\t{%1, %0|%0, %1}
2609    #
2610    #"
2611   [(set_attr "type" "ssemov")
2612    (set_attr "mode" "V1DF,DF,DF")])
2613
2614 (define_split
2615   [(set (match_operand:DF 0 "register_operand" "")
2616         (vec_select:DF
2617           (match_operand:V2DF 1 "nonimmediate_operand" "")
2618           (parallel [(const_int 0)])))]
2619   "TARGET_SSE2 && reload_completed"
2620   [(const_int 0)]
2621 {
2622   rtx op1 = operands[1];
2623   if (REG_P (op1))
2624     op1 = gen_rtx_REG (DFmode, REGNO (op1));
2625   else
2626     op1 = gen_lowpart (DFmode, op1);
2627   emit_move_insn (operands[0], op1);
2628   DONE;
2629 })
2630
2631 (define_insn "sse2_loadhpd"
2632   [(set (match_operand:V2DF 0 "nonimmediate_operand"     "=x,x,x,o")
2633         (vec_concat:V2DF
2634           (vec_select:DF
2635             (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,x,0")
2636             (parallel [(const_int 0)]))
2637           (match_operand:DF 2 "nonimmediate_operand"     " m,x,0,x*fr")))]
2638   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
2639   "@
2640    movhpd\t{%2, %0|%0, %2}
2641    unpcklpd\t{%2, %0|%0, %2}
2642    shufpd\t{$1, %1, %0|%0, %1, 1}
2643    #"
2644   [(set_attr "type" "ssemov,sselog,sselog,other")
2645    (set_attr "mode" "V1DF,V2DF,V2DF,DF")])
2646
2647 (define_split
2648   [(set (match_operand:V2DF 0 "memory_operand" "")
2649         (vec_concat:V2DF
2650           (vec_select:DF (match_dup 0) (parallel [(const_int 0)]))
2651           (match_operand:DF 1 "register_operand" "")))]
2652   "TARGET_SSE2 && reload_completed"
2653   [(set (match_dup 0) (match_dup 1))]
2654 {
2655   operands[0] = adjust_address (operands[0], DFmode, 8);
2656 })
2657
2658 (define_insn "sse2_loadlpd"
2659   [(set (match_operand:V2DF 0 "nonimmediate_operand"    "=x,x,x,x,x,m")
2660         (vec_concat:V2DF
2661           (match_operand:DF 2 "nonimmediate_operand"    " m,m,x,0,0,x*fr")
2662           (vec_select:DF
2663             (match_operand:V2DF 1 "vector_move_operand" " C,0,0,x,o,0")
2664             (parallel [(const_int 1)]))))]
2665   "TARGET_SSE2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
2666   "@
2667    movsd\t{%2, %0|%0, %2}
2668    movlpd\t{%2, %0|%0, %2}
2669    movsd\t{%2, %0|%0, %2}
2670    shufpd\t{$2, %2, %0|%0, %2, 2}
2671    movhpd\t{%H1, %0|%0, %H1}
2672    #"
2673   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,other")
2674    (set_attr "mode" "DF,V1DF,V1DF,V2DF,V1DF,DF")])
2675
2676 (define_split
2677   [(set (match_operand:V2DF 0 "memory_operand" "")
2678         (vec_concat:V2DF
2679           (match_operand:DF 1 "register_operand" "")
2680           (vec_select:DF (match_dup 0) (parallel [(const_int 1)]))))]
2681   "TARGET_SSE2 && reload_completed"
2682   [(set (match_dup 0) (match_dup 1))]
2683 {
2684   operands[0] = adjust_address (operands[0], DFmode, 8);
2685 })
2686
2687 ;; Not sure these two are ever used, but it doesn't hurt to have
2688 ;; them. -aoliva
2689 (define_insn "*vec_extractv2df_1_sse"
2690   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
2691         (vec_select:DF
2692           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,o")
2693           (parallel [(const_int 1)])))]
2694   "!TARGET_SSE2 && TARGET_SSE
2695    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2696   "@
2697    movhps\t{%1, %0|%0, %1}
2698    movhlps\t{%1, %0|%0, %1}
2699    movlps\t{%H1, %0|%0, %H1}"
2700   [(set_attr "type" "ssemov")
2701    (set_attr "mode" "V2SF,V4SF,V2SF")])
2702
2703 (define_insn "*vec_extractv2df_0_sse"
2704   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x")
2705         (vec_select:DF
2706           (match_operand:V2DF 1 "nonimmediate_operand" "x,x,m")
2707           (parallel [(const_int 0)])))]
2708   "!TARGET_SSE2 && TARGET_SSE
2709    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
2710   "@
2711    movlps\t{%1, %0|%0, %1}
2712    movaps\t{%1, %0|%0, %1}
2713    movlps\t{%1, %0|%0, %1}"
2714   [(set_attr "type" "ssemov")
2715    (set_attr "mode" "V2SF,V4SF,V2SF")])
2716
2717 (define_insn "sse2_movsd"
2718   [(set (match_operand:V2DF 0 "nonimmediate_operand"   "=x,x,m,x,x,o")
2719         (vec_merge:V2DF
2720           (match_operand:V2DF 2 "nonimmediate_operand" " x,m,x,0,0,0")
2721           (match_operand:V2DF 1 "nonimmediate_operand" " 0,0,0,x,o,x")
2722           (const_int 1)))]
2723   "TARGET_SSE2"
2724   "@
2725    movsd\t{%2, %0|%0, %2}
2726    movlpd\t{%2, %0|%0, %2}
2727    movlpd\t{%2, %0|%0, %2}
2728    shufpd\t{$2, %2, %0|%0, %2, 2}
2729    movhps\t{%H1, %0|%0, %H1}
2730    movhps\t{%1, %H0|%H0, %1}"
2731   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov")
2732    (set_attr "mode" "DF,V1DF,V1DF,V2DF,V1DF,V1DF")])
2733
2734 (define_insn "*vec_dupv2df_sse3"
2735   [(set (match_operand:V2DF 0 "register_operand" "=x")
2736         (vec_duplicate:V2DF
2737           (match_operand:DF 1 "nonimmediate_operand" "xm")))]
2738   "TARGET_SSE3"
2739   "movddup\t{%1, %0|%0, %1}"
2740   [(set_attr "type" "sselog1")
2741    (set_attr "mode" "DF")])
2742
2743 (define_insn "*vec_dupv2df"
2744   [(set (match_operand:V2DF 0 "register_operand" "=x")
2745         (vec_duplicate:V2DF
2746           (match_operand:DF 1 "register_operand" "0")))]
2747   "TARGET_SSE2"
2748   "unpcklpd\t%0, %0"
2749   [(set_attr "type" "sselog1")
2750    (set_attr "mode" "V2DF")])
2751
2752 (define_insn "*vec_concatv2df_sse3"
2753   [(set (match_operand:V2DF 0 "register_operand" "=x")
2754         (vec_concat:V2DF
2755           (match_operand:DF 1 "nonimmediate_operand" "xm")
2756           (match_dup 1)))]
2757   "TARGET_SSE3"
2758   "movddup\t{%1, %0|%0, %1}"
2759   [(set_attr "type" "sselog1")
2760    (set_attr "mode" "DF")])
2761
2762 (define_insn "*vec_concatv2df"
2763   [(set (match_operand:V2DF 0 "register_operand"     "=Yt,Yt,Yt,x,x")
2764         (vec_concat:V2DF
2765           (match_operand:DF 1 "nonimmediate_operand" " 0 ,0 ,m ,0,0")
2766           (match_operand:DF 2 "vector_move_operand"  " Yt,m ,C ,x,m")))]
2767   "TARGET_SSE"
2768   "@
2769    unpcklpd\t{%2, %0|%0, %2}
2770    movhpd\t{%2, %0|%0, %2}
2771    movsd\t{%1, %0|%0, %1}
2772    movlhps\t{%2, %0|%0, %2}
2773    movhps\t{%2, %0|%0, %2}"
2774   [(set_attr "type" "sselog,ssemov,ssemov,ssemov,ssemov")
2775    (set_attr "mode" "V2DF,V1DF,DF,V4SF,V2SF")])
2776
2777 (define_expand "vec_setv2df"
2778   [(match_operand:V2DF 0 "register_operand" "")
2779    (match_operand:DF 1 "register_operand" "")
2780    (match_operand 2 "const_int_operand" "")]
2781   "TARGET_SSE"
2782 {
2783   ix86_expand_vector_set (false, operands[0], operands[1],
2784                           INTVAL (operands[2]));
2785   DONE;
2786 })
2787
2788 (define_expand "vec_extractv2df"
2789   [(match_operand:DF 0 "register_operand" "")
2790    (match_operand:V2DF 1 "register_operand" "")
2791    (match_operand 2 "const_int_operand" "")]
2792   "TARGET_SSE"
2793 {
2794   ix86_expand_vector_extract (false, operands[0], operands[1],
2795                               INTVAL (operands[2]));
2796   DONE;
2797 })
2798
2799 (define_expand "vec_initv2df"
2800   [(match_operand:V2DF 0 "register_operand" "")
2801    (match_operand 1 "" "")]
2802   "TARGET_SSE"
2803 {
2804   ix86_expand_vector_init (false, operands[0], operands[1]);
2805   DONE;
2806 })
2807
2808 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2809 ;;
2810 ;; Parallel integral arithmetic
2811 ;;
2812 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2813
2814 (define_expand "neg<mode>2"
2815   [(set (match_operand:SSEMODEI 0 "register_operand" "")
2816         (minus:SSEMODEI
2817           (match_dup 2)
2818           (match_operand:SSEMODEI 1 "nonimmediate_operand" "")))]
2819   "TARGET_SSE2"
2820   "operands[2] = force_reg (<MODE>mode, CONST0_RTX (<MODE>mode));")
2821
2822 (define_expand "add<mode>3"
2823   [(set (match_operand:SSEMODEI 0 "register_operand" "")
2824         (plus:SSEMODEI (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
2825                        (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
2826   "TARGET_SSE2"
2827   "ix86_fixup_binary_operands_no_copy (PLUS, <MODE>mode, operands);")
2828
2829 (define_insn "*add<mode>3"
2830   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
2831         (plus:SSEMODEI
2832           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
2833           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
2834   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, <MODE>mode, operands)"
2835   "padd<ssevecsize>\t{%2, %0|%0, %2}"
2836   [(set_attr "type" "sseiadd")
2837    (set_attr "prefix_data16" "1")
2838    (set_attr "mode" "TI")])
2839
2840 (define_insn "sse2_ssadd<mode>3"
2841   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
2842         (ss_plus:SSEMODE12
2843           (match_operand:SSEMODE12 1 "nonimmediate_operand" "%0")
2844           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
2845   "TARGET_SSE2 && ix86_binary_operator_ok (SS_PLUS, <MODE>mode, operands)"
2846   "padds<ssevecsize>\t{%2, %0|%0, %2}"
2847   [(set_attr "type" "sseiadd")
2848    (set_attr "prefix_data16" "1")
2849    (set_attr "mode" "TI")])
2850
2851 (define_insn "sse2_usadd<mode>3"
2852   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
2853         (us_plus:SSEMODE12
2854           (match_operand:SSEMODE12 1 "nonimmediate_operand" "%0")
2855           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
2856   "TARGET_SSE2 && ix86_binary_operator_ok (US_PLUS, <MODE>mode, operands)"
2857   "paddus<ssevecsize>\t{%2, %0|%0, %2}"
2858   [(set_attr "type" "sseiadd")
2859    (set_attr "prefix_data16" "1")
2860    (set_attr "mode" "TI")])
2861
2862 (define_expand "sub<mode>3"
2863   [(set (match_operand:SSEMODEI 0 "register_operand" "")
2864         (minus:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "")
2865                         (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
2866   "TARGET_SSE2"
2867   "ix86_fixup_binary_operands_no_copy (MINUS, <MODE>mode, operands);")
2868
2869 (define_insn "*sub<mode>3"
2870   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
2871         (minus:SSEMODEI
2872           (match_operand:SSEMODEI 1 "register_operand" "0")
2873           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
2874   "TARGET_SSE2"
2875   "psub<ssevecsize>\t{%2, %0|%0, %2}"
2876   [(set_attr "type" "sseiadd")
2877    (set_attr "prefix_data16" "1")
2878    (set_attr "mode" "TI")])
2879
2880 (define_insn "sse2_sssub<mode>3"
2881   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
2882         (ss_minus:SSEMODE12
2883           (match_operand:SSEMODE12 1 "register_operand" "0")
2884           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
2885   "TARGET_SSE2"
2886   "psubs<ssevecsize>\t{%2, %0|%0, %2}"
2887   [(set_attr "type" "sseiadd")
2888    (set_attr "prefix_data16" "1")
2889    (set_attr "mode" "TI")])
2890
2891 (define_insn "sse2_ussub<mode>3"
2892   [(set (match_operand:SSEMODE12 0 "register_operand" "=x")
2893         (us_minus:SSEMODE12
2894           (match_operand:SSEMODE12 1 "register_operand" "0")
2895           (match_operand:SSEMODE12 2 "nonimmediate_operand" "xm")))]
2896   "TARGET_SSE2"
2897   "psubus<ssevecsize>\t{%2, %0|%0, %2}"
2898   [(set_attr "type" "sseiadd")
2899    (set_attr "prefix_data16" "1")
2900    (set_attr "mode" "TI")])
2901
2902 (define_expand "mulv16qi3"
2903   [(set (match_operand:V16QI 0 "register_operand" "")
2904         (mult:V16QI (match_operand:V16QI 1 "register_operand" "")
2905                     (match_operand:V16QI 2 "register_operand" "")))]
2906   "TARGET_SSE2"
2907 {
2908   rtx t[12], op0;
2909   int i;
2910
2911   for (i = 0; i < 12; ++i)
2912     t[i] = gen_reg_rtx (V16QImode);
2913
2914   /* Unpack data such that we've got a source byte in each low byte of
2915      each word.  We don't care what goes into the high byte of each word.
2916      Rather than trying to get zero in there, most convenient is to let
2917      it be a copy of the low byte.  */
2918   emit_insn (gen_sse2_punpckhbw (t[0], operands[1], operands[1]));
2919   emit_insn (gen_sse2_punpckhbw (t[1], operands[2], operands[2]));
2920   emit_insn (gen_sse2_punpcklbw (t[2], operands[1], operands[1]));
2921   emit_insn (gen_sse2_punpcklbw (t[3], operands[2], operands[2]));
2922
2923   /* Multiply words.  The end-of-line annotations here give a picture of what
2924      the output of that instruction looks like.  Dot means don't care; the
2925      letters are the bytes of the result with A being the most significant.  */
2926   emit_insn (gen_mulv8hi3 (gen_lowpart (V8HImode, t[4]), /* .A.B.C.D.E.F.G.H */
2927                            gen_lowpart (V8HImode, t[0]),
2928                            gen_lowpart (V8HImode, t[1])));
2929   emit_insn (gen_mulv8hi3 (gen_lowpart (V8HImode, t[5]), /* .I.J.K.L.M.N.O.P */
2930                            gen_lowpart (V8HImode, t[2]),
2931                            gen_lowpart (V8HImode, t[3])));
2932
2933   /* Extract the relevant bytes and merge them back together.  */
2934   emit_insn (gen_sse2_punpckhbw (t[6], t[5], t[4]));    /* ..AI..BJ..CK..DL */
2935   emit_insn (gen_sse2_punpcklbw (t[7], t[5], t[4]));    /* ..EM..FN..GO..HP */
2936   emit_insn (gen_sse2_punpckhbw (t[8], t[7], t[6]));    /* ....AEIM....BFJN */
2937   emit_insn (gen_sse2_punpcklbw (t[9], t[7], t[6]));    /* ....CGKO....DHLP */
2938   emit_insn (gen_sse2_punpckhbw (t[10], t[9], t[8]));   /* ........ACEGIKMO */
2939   emit_insn (gen_sse2_punpcklbw (t[11], t[9], t[8]));   /* ........BDFHJLNP */
2940
2941   op0 = operands[0];
2942   emit_insn (gen_sse2_punpcklbw (op0, t[11], t[10]));   /* ABCDEFGHIJKLMNOP */
2943   DONE;
2944 })
2945
2946 (define_expand "mulv8hi3"
2947   [(set (match_operand:V8HI 0 "register_operand" "")
2948         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "")
2949                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
2950   "TARGET_SSE2"
2951   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
2952
2953 (define_insn "*mulv8hi3"
2954   [(set (match_operand:V8HI 0 "register_operand" "=x")
2955         (mult:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%0")
2956                    (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
2957   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
2958   "pmullw\t{%2, %0|%0, %2}"
2959   [(set_attr "type" "sseimul")
2960    (set_attr "prefix_data16" "1")
2961    (set_attr "mode" "TI")])
2962
2963 (define_expand "smulv8hi3_highpart"
2964   [(set (match_operand:V8HI 0 "register_operand" "")
2965         (truncate:V8HI
2966           (lshiftrt:V8SI
2967             (mult:V8SI
2968               (sign_extend:V8SI
2969                 (match_operand:V8HI 1 "nonimmediate_operand" ""))
2970               (sign_extend:V8SI
2971                 (match_operand:V8HI 2 "nonimmediate_operand" "")))
2972             (const_int 16))))]
2973   "TARGET_SSE2"
2974   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
2975
2976 (define_insn "*smulv8hi3_highpart"
2977   [(set (match_operand:V8HI 0 "register_operand" "=x")
2978         (truncate:V8HI
2979           (lshiftrt:V8SI
2980             (mult:V8SI
2981               (sign_extend:V8SI
2982                 (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
2983               (sign_extend:V8SI
2984                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
2985             (const_int 16))))]
2986   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
2987   "pmulhw\t{%2, %0|%0, %2}"
2988   [(set_attr "type" "sseimul")
2989    (set_attr "prefix_data16" "1")
2990    (set_attr "mode" "TI")])
2991
2992 (define_expand "umulv8hi3_highpart"
2993   [(set (match_operand:V8HI 0 "register_operand" "")
2994         (truncate:V8HI
2995           (lshiftrt:V8SI
2996             (mult:V8SI
2997               (zero_extend:V8SI
2998                 (match_operand:V8HI 1 "nonimmediate_operand" ""))
2999               (zero_extend:V8SI
3000                 (match_operand:V8HI 2 "nonimmediate_operand" "")))
3001             (const_int 16))))]
3002   "TARGET_SSE2"
3003   "ix86_fixup_binary_operands_no_copy (MULT, V8HImode, operands);")
3004
3005 (define_insn "*umulv8hi3_highpart"
3006   [(set (match_operand:V8HI 0 "register_operand" "=x")
3007         (truncate:V8HI
3008           (lshiftrt:V8SI
3009             (mult:V8SI
3010               (zero_extend:V8SI
3011                 (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
3012               (zero_extend:V8SI
3013                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
3014             (const_int 16))))]
3015   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
3016   "pmulhuw\t{%2, %0|%0, %2}"
3017   [(set_attr "type" "sseimul")
3018    (set_attr "prefix_data16" "1")
3019    (set_attr "mode" "TI")])
3020
3021 (define_insn "sse2_umulv2siv2di3"
3022   [(set (match_operand:V2DI 0 "register_operand" "=x")
3023         (mult:V2DI
3024           (zero_extend:V2DI
3025             (vec_select:V2SI
3026               (match_operand:V4SI 1 "nonimmediate_operand" "%0")
3027               (parallel [(const_int 0) (const_int 2)])))
3028           (zero_extend:V2DI
3029             (vec_select:V2SI
3030               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
3031               (parallel [(const_int 0) (const_int 2)])))))]
3032   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
3033   "pmuludq\t{%2, %0|%0, %2}"
3034   [(set_attr "type" "sseimul")
3035    (set_attr "prefix_data16" "1")
3036    (set_attr "mode" "TI")])
3037
3038 (define_insn "sse4_1_mulv2siv2di3"
3039   [(set (match_operand:V2DI 0 "register_operand" "=x")
3040         (mult:V2DI
3041           (sign_extend:V2DI
3042             (vec_select:V2SI
3043               (match_operand:V4SI 1 "nonimmediate_operand" "%0")
3044               (parallel [(const_int 0) (const_int 2)])))
3045           (sign_extend:V2DI
3046             (vec_select:V2SI
3047               (match_operand:V4SI 2 "nonimmediate_operand" "xm")
3048               (parallel [(const_int 0) (const_int 2)])))))]
3049   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
3050   "pmuldq\t{%2, %0|%0, %2}"
3051   [(set_attr "type" "sseimul")
3052    (set_attr "prefix_extra" "1")
3053    (set_attr "mode" "TI")])
3054
3055 (define_insn "sse2_pmaddwd"
3056   [(set (match_operand:V4SI 0 "register_operand" "=x")
3057         (plus:V4SI
3058           (mult:V4SI
3059             (sign_extend:V4SI
3060               (vec_select:V4HI
3061                 (match_operand:V8HI 1 "nonimmediate_operand" "%0")
3062                 (parallel [(const_int 0)
3063                            (const_int 2)
3064                            (const_int 4)
3065                            (const_int 6)])))
3066             (sign_extend:V4SI
3067               (vec_select:V4HI
3068                 (match_operand:V8HI 2 "nonimmediate_operand" "xm")
3069                 (parallel [(const_int 0)
3070                            (const_int 2)
3071                            (const_int 4)
3072                            (const_int 6)]))))
3073           (mult:V4SI
3074             (sign_extend:V4SI
3075               (vec_select:V4HI (match_dup 1)
3076                 (parallel [(const_int 1)
3077                            (const_int 3)
3078                            (const_int 5)
3079                            (const_int 7)])))
3080             (sign_extend:V4SI
3081               (vec_select:V4HI (match_dup 2)
3082                 (parallel [(const_int 1)
3083                            (const_int 3)
3084                            (const_int 5)
3085                            (const_int 7)]))))))]
3086   "TARGET_SSE2 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
3087   "pmaddwd\t{%2, %0|%0, %2}"
3088   [(set_attr "type" "sseiadd")
3089    (set_attr "prefix_data16" "1")
3090    (set_attr "mode" "TI")])
3091
3092 (define_expand "mulv4si3"
3093   [(set (match_operand:V4SI 0 "register_operand" "")
3094         (mult:V4SI (match_operand:V4SI 1 "register_operand" "")
3095                    (match_operand:V4SI 2 "register_operand" "")))]
3096   "TARGET_SSE2"
3097 {
3098   if (TARGET_SSE4_1)
3099     ix86_fixup_binary_operands_no_copy (MULT, V4SImode, operands);
3100  else
3101    {
3102      rtx t1, t2, t3, t4, t5, t6, thirtytwo;
3103      rtx op0, op1, op2;
3104
3105      op0 = operands[0];
3106      op1 = operands[1];
3107      op2 = operands[2];
3108      t1 = gen_reg_rtx (V4SImode);
3109      t2 = gen_reg_rtx (V4SImode);
3110      t3 = gen_reg_rtx (V4SImode);
3111      t4 = gen_reg_rtx (V4SImode);
3112      t5 = gen_reg_rtx (V4SImode);
3113      t6 = gen_reg_rtx (V4SImode);
3114      thirtytwo = GEN_INT (32);
3115
3116      /* Multiply elements 2 and 0.  */
3117      emit_insn (gen_sse2_umulv2siv2di3 (gen_lowpart (V2DImode, t1),
3118                                         op1, op2));
3119
3120      /* Shift both input vectors down one element, so that elements 3
3121         and 1 are now in the slots for elements 2 and 0.  For K8, at
3122         least, this is faster than using a shuffle.  */
3123      emit_insn (gen_sse2_lshrti3 (gen_lowpart (TImode, t2),
3124                                   gen_lowpart (TImode, op1),
3125                                   thirtytwo));
3126      emit_insn (gen_sse2_lshrti3 (gen_lowpart (TImode, t3),
3127                                   gen_lowpart (TImode, op2),
3128                                   thirtytwo));
3129      /* Multiply elements 3 and 1.  */
3130      emit_insn (gen_sse2_umulv2siv2di3 (gen_lowpart (V2DImode, t4),
3131                                         t2, t3));
3132
3133      /* Move the results in element 2 down to element 1; we don't care
3134         what goes in elements 2 and 3.  */
3135      emit_insn (gen_sse2_pshufd_1 (t5, t1, const0_rtx, const2_rtx,
3136                                 const0_rtx, const0_rtx));
3137      emit_insn (gen_sse2_pshufd_1 (t6, t4, const0_rtx, const2_rtx,
3138                                    const0_rtx, const0_rtx));
3139
3140     /* Merge the parts back together.  */
3141      emit_insn (gen_sse2_punpckldq (op0, t5, t6));
3142      DONE;
3143    }
3144 })
3145
3146 (define_insn "*sse4_1_mulv4si3"
3147   [(set (match_operand:V4SI 0 "register_operand" "=x")
3148         (mult:V4SI (match_operand:V4SI 1 "nonimmediate_operand" "%0")
3149                    (match_operand:V4SI 2 "nonimmediate_operand" "xm")))]
3150   "TARGET_SSE4_1 && ix86_binary_operator_ok (MULT, V4SImode, operands)"
3151   "pmulld\t{%2, %0|%0, %2}"
3152   [(set_attr "type" "sseimul")
3153    (set_attr "prefix_extra" "1")
3154    (set_attr "mode" "TI")])
3155
3156 (define_expand "mulv2di3"
3157   [(set (match_operand:V2DI 0 "register_operand" "")
3158         (mult:V2DI (match_operand:V2DI 1 "register_operand" "")
3159                    (match_operand:V2DI 2 "register_operand" "")))]
3160   "TARGET_SSE2"
3161 {
3162   rtx t1, t2, t3, t4, t5, t6, thirtytwo;
3163   rtx op0, op1, op2;
3164
3165   op0 = operands[0];
3166   op1 = operands[1];
3167   op2 = operands[2];
3168   t1 = gen_reg_rtx (V2DImode);
3169   t2 = gen_reg_rtx (V2DImode);
3170   t3 = gen_reg_rtx (V2DImode);
3171   t4 = gen_reg_rtx (V2DImode);
3172   t5 = gen_reg_rtx (V2DImode);
3173   t6 = gen_reg_rtx (V2DImode);
3174   thirtytwo = GEN_INT (32);
3175
3176   /* Multiply low parts.  */
3177   emit_insn (gen_sse2_umulv2siv2di3 (t1, gen_lowpart (V4SImode, op1),
3178                                      gen_lowpart (V4SImode, op2)));
3179
3180   /* Shift input vectors left 32 bits so we can multiply high parts.  */
3181   emit_insn (gen_lshrv2di3 (t2, op1, thirtytwo));
3182   emit_insn (gen_lshrv2di3 (t3, op2, thirtytwo));
3183
3184   /* Multiply high parts by low parts.  */
3185   emit_insn (gen_sse2_umulv2siv2di3 (t4, gen_lowpart (V4SImode, op1),
3186                                      gen_lowpart (V4SImode, t3)));
3187   emit_insn (gen_sse2_umulv2siv2di3 (t5, gen_lowpart (V4SImode, op2),
3188                                      gen_lowpart (V4SImode, t2)));
3189
3190   /* Shift them back.  */
3191   emit_insn (gen_ashlv2di3 (t4, t4, thirtytwo));
3192   emit_insn (gen_ashlv2di3 (t5, t5, thirtytwo));
3193
3194   /* Add the three parts together.  */
3195   emit_insn (gen_addv2di3 (t6, t1, t4));
3196   emit_insn (gen_addv2di3 (op0, t6, t5));
3197   DONE;
3198 })
3199
3200 (define_expand "vec_widen_smult_hi_v8hi"
3201   [(match_operand:V4SI 0 "register_operand" "")
3202    (match_operand:V8HI 1 "register_operand" "")
3203    (match_operand:V8HI 2 "register_operand" "")]
3204   "TARGET_SSE2"
3205 {
3206   rtx op1, op2, t1, t2, dest;
3207
3208   op1 = operands[1];
3209   op2 = operands[2];
3210   t1 = gen_reg_rtx (V8HImode);
3211   t2 = gen_reg_rtx (V8HImode);
3212   dest = gen_lowpart (V8HImode, operands[0]);
3213
3214   emit_insn (gen_mulv8hi3 (t1, op1, op2));
3215   emit_insn (gen_smulv8hi3_highpart (t2, op1, op2));
3216   emit_insn (gen_vec_interleave_highv8hi (dest, t1, t2));
3217   DONE;
3218 })
3219
3220 (define_expand "vec_widen_smult_lo_v8hi"
3221   [(match_operand:V4SI 0 "register_operand" "")
3222    (match_operand:V8HI 1 "register_operand" "")
3223    (match_operand:V8HI 2 "register_operand" "")]
3224   "TARGET_SSE2"
3225 {
3226   rtx op1, op2, t1, t2, dest;
3227
3228   op1 = operands[1];
3229   op2 = operands[2];
3230   t1 = gen_reg_rtx (V8HImode);
3231   t2 = gen_reg_rtx (V8HImode);
3232   dest = gen_lowpart (V8HImode, operands[0]);
3233
3234   emit_insn (gen_mulv8hi3 (t1, op1, op2));
3235   emit_insn (gen_smulv8hi3_highpart (t2, op1, op2));
3236   emit_insn (gen_vec_interleave_lowv8hi (dest, t1, t2));
3237   DONE;
3238 })
3239
3240 (define_expand "vec_widen_umult_hi_v8hi"
3241   [(match_operand:V4SI 0 "register_operand" "")
3242    (match_operand:V8HI 1 "register_operand" "")
3243    (match_operand:V8HI 2 "register_operand" "")]
3244   "TARGET_SSE2"
3245 {
3246   rtx op1, op2, t1, t2, dest;
3247
3248   op1 = operands[1];
3249   op2 = operands[2];
3250   t1 = gen_reg_rtx (V8HImode);
3251   t2 = gen_reg_rtx (V8HImode);
3252   dest = gen_lowpart (V8HImode, operands[0]);
3253
3254   emit_insn (gen_mulv8hi3 (t1, op1, op2));
3255   emit_insn (gen_umulv8hi3_highpart (t2, op1, op2));
3256   emit_insn (gen_vec_interleave_highv8hi (dest, t1, t2));
3257   DONE;
3258 })
3259
3260 (define_expand "vec_widen_umult_lo_v8hi"
3261   [(match_operand:V4SI 0 "register_operand" "")
3262    (match_operand:V8HI 1 "register_operand" "")
3263    (match_operand:V8HI 2 "register_operand" "")]
3264   "TARGET_SSE2"
3265 {
3266   rtx op1, op2, t1, t2, dest;
3267
3268   op1 = operands[1];
3269   op2 = operands[2];
3270   t1 = gen_reg_rtx (V8HImode);
3271   t2 = gen_reg_rtx (V8HImode);
3272   dest = gen_lowpart (V8HImode, operands[0]);
3273
3274   emit_insn (gen_mulv8hi3 (t1, op1, op2));
3275   emit_insn (gen_umulv8hi3_highpart (t2, op1, op2));
3276   emit_insn (gen_vec_interleave_lowv8hi (dest, t1, t2));
3277   DONE;
3278 })
3279
3280 (define_expand "vec_widen_smult_hi_v4si"
3281   [(match_operand:V2DI 0 "register_operand" "")
3282    (match_operand:V4SI 1 "register_operand" "")
3283    (match_operand:V4SI 2 "register_operand" "")]
3284   "TARGET_SSE2"
3285 {
3286   rtx op1, op2, t1, t2;
3287
3288   op1 = operands[1];
3289   op2 = operands[2];
3290   t1 = gen_reg_rtx (V4SImode);
3291   t2 = gen_reg_rtx (V4SImode);
3292
3293   emit_insn (gen_vec_interleave_highv4si (t1, op1, op1));
3294   emit_insn (gen_vec_interleave_highv4si (t2, op2, op2));
3295   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
3296   DONE;
3297 })
3298
3299 (define_expand "vec_widen_smult_lo_v4si"
3300   [(match_operand:V2DI 0 "register_operand" "")
3301    (match_operand:V4SI 1 "register_operand" "")
3302    (match_operand:V4SI 2 "register_operand" "")]
3303   "TARGET_SSE2"
3304 {
3305   rtx op1, op2, t1, t2;
3306
3307   op1 = operands[1];
3308   op2 = operands[2];
3309   t1 = gen_reg_rtx (V4SImode);
3310   t2 = gen_reg_rtx (V4SImode);
3311
3312   emit_insn (gen_vec_interleave_lowv4si (t1, op1, op1));
3313   emit_insn (gen_vec_interleave_lowv4si (t2, op2, op2));
3314   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
3315   DONE;
3316 })
3317
3318 (define_expand "vec_widen_umult_hi_v4si"
3319   [(match_operand:V2DI 0 "register_operand" "")
3320    (match_operand:V4SI 1 "register_operand" "")
3321    (match_operand:V4SI 2 "register_operand" "")]
3322   "TARGET_SSE2"
3323 {
3324   rtx op1, op2, t1, t2;
3325
3326   op1 = operands[1];
3327   op2 = operands[2];
3328   t1 = gen_reg_rtx (V4SImode);
3329   t2 = gen_reg_rtx (V4SImode);
3330
3331   emit_insn (gen_vec_interleave_highv4si (t1, op1, op1));
3332   emit_insn (gen_vec_interleave_highv4si (t2, op2, op2));
3333   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
3334   DONE;
3335 })
3336
3337 (define_expand "vec_widen_umult_lo_v4si"
3338   [(match_operand:V2DI 0 "register_operand" "")
3339    (match_operand:V4SI 1 "register_operand" "")
3340    (match_operand:V4SI 2 "register_operand" "")]
3341   "TARGET_SSE2"
3342 {
3343   rtx op1, op2, t1, t2;
3344
3345   op1 = operands[1];
3346   op2 = operands[2];
3347   t1 = gen_reg_rtx (V4SImode);
3348   t2 = gen_reg_rtx (V4SImode);
3349
3350   emit_insn (gen_vec_interleave_lowv4si (t1, op1, op1));
3351   emit_insn (gen_vec_interleave_lowv4si (t2, op2, op2));
3352   emit_insn (gen_sse2_umulv2siv2di3 (operands[0], t1, t2));
3353   DONE;
3354 })
3355
3356 (define_expand "sdot_prodv8hi"
3357   [(match_operand:V4SI 0 "register_operand" "")
3358    (match_operand:V8HI 1 "register_operand" "")
3359    (match_operand:V8HI 2 "register_operand" "")
3360    (match_operand:V4SI 3 "register_operand" "")]
3361   "TARGET_SSE2"
3362 {
3363   rtx t = gen_reg_rtx (V4SImode);
3364   emit_insn (gen_sse2_pmaddwd (t, operands[1], operands[2]));
3365   emit_insn (gen_addv4si3 (operands[0], operands[3], t));
3366   DONE;
3367 })
3368
3369 (define_expand "udot_prodv4si"
3370   [(match_operand:V2DI 0 "register_operand" "")
3371    (match_operand:V4SI 1 "register_operand" "")
3372    (match_operand:V4SI 2 "register_operand" "")
3373    (match_operand:V2DI 3 "register_operand" "")]
3374   "TARGET_SSE2"
3375 {
3376   rtx t1, t2, t3, t4;
3377
3378   t1 = gen_reg_rtx (V2DImode);
3379   emit_insn (gen_sse2_umulv2siv2di3 (t1, operands[1], operands[2]));
3380   emit_insn (gen_addv2di3 (t1, t1, operands[3]));
3381
3382   t2 = gen_reg_rtx (V4SImode);
3383   t3 = gen_reg_rtx (V4SImode);
3384   emit_insn (gen_sse2_lshrti3 (gen_lowpart (TImode, t2),
3385                                gen_lowpart (TImode, operands[1]),
3386                                GEN_INT (32)));
3387   emit_insn (gen_sse2_lshrti3 (gen_lowpart (TImode, t3),
3388                                gen_lowpart (TImode, operands[2]),
3389                                GEN_INT (32)));
3390
3391   t4 = gen_reg_rtx (V2DImode);
3392   emit_insn (gen_sse2_umulv2siv2di3 (t4, t2, t3));
3393
3394   emit_insn (gen_addv2di3 (operands[0], t1, t4));
3395   DONE;
3396 })
3397
3398 (define_insn "ashr<mode>3"
3399   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
3400         (ashiftrt:SSEMODE24
3401           (match_operand:SSEMODE24 1 "register_operand" "0")
3402           (match_operand:TI 2 "nonmemory_operand" "xn")))]
3403   "TARGET_SSE2"
3404   "psra<ssevecsize>\t{%2, %0|%0, %2}"
3405   [(set_attr "type" "sseishft")
3406    (set_attr "prefix_data16" "1")
3407    (set_attr "mode" "TI")])
3408
3409 (define_insn "lshr<mode>3"
3410   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
3411         (lshiftrt:SSEMODE248
3412           (match_operand:SSEMODE248 1 "register_operand" "0")
3413           (match_operand:TI 2 "nonmemory_operand" "xn")))]
3414   "TARGET_SSE2"
3415   "psrl<ssevecsize>\t{%2, %0|%0, %2}"
3416   [(set_attr "type" "sseishft")
3417    (set_attr "prefix_data16" "1")
3418    (set_attr "mode" "TI")])
3419
3420 (define_insn "ashl<mode>3"
3421   [(set (match_operand:SSEMODE248 0 "register_operand" "=x")
3422         (ashift:SSEMODE248
3423           (match_operand:SSEMODE248 1 "register_operand" "0")
3424           (match_operand:TI 2 "nonmemory_operand" "xn")))]
3425   "TARGET_SSE2"
3426   "psll<ssevecsize>\t{%2, %0|%0, %2}"
3427   [(set_attr "type" "sseishft")
3428    (set_attr "prefix_data16" "1")
3429    (set_attr "mode" "TI")])
3430
3431 (define_expand "vec_shl_<mode>"
3432   [(set (match_operand:SSEMODEI 0 "register_operand" "")
3433         (ashift:TI (match_operand:SSEMODEI 1 "register_operand" "")
3434                    (match_operand:SI 2 "general_operand" "")))]
3435   "TARGET_SSE2"
3436 {
3437   if (!const_0_to_255_mul_8_operand (operands[2], SImode))
3438     FAIL;
3439   operands[0] = gen_lowpart (TImode, operands[0]);
3440   operands[1] = gen_lowpart (TImode, operands[1]);
3441 })
3442
3443 (define_expand "vec_shr_<mode>"
3444   [(set (match_operand:SSEMODEI 0 "register_operand" "")
3445         (lshiftrt:TI (match_operand:SSEMODEI 1 "register_operand" "")
3446                      (match_operand:SI 2 "general_operand" "")))]
3447   "TARGET_SSE2"
3448 {
3449   if (!const_0_to_255_mul_8_operand (operands[2], SImode))
3450     FAIL;
3451   operands[0] = gen_lowpart (TImode, operands[0]);
3452   operands[1] = gen_lowpart (TImode, operands[1]);
3453 })
3454
3455 (define_expand "umaxv16qi3"
3456   [(set (match_operand:V16QI 0 "register_operand" "")
3457         (umax:V16QI (match_operand:V16QI 1 "nonimmediate_operand" "")
3458                     (match_operand:V16QI 2 "nonimmediate_operand" "")))]
3459   "TARGET_SSE2"
3460   "ix86_fixup_binary_operands_no_copy (UMAX, V16QImode, operands);")
3461
3462 (define_insn "*umaxv16qi3"
3463   [(set (match_operand:V16QI 0 "register_operand" "=x")
3464         (umax:V16QI (match_operand:V16QI 1 "nonimmediate_operand" "%0")
3465                     (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
3466   "TARGET_SSE2 && ix86_binary_operator_ok (UMAX, V16QImode, operands)"
3467   "pmaxub\t{%2, %0|%0, %2}"
3468   [(set_attr "type" "sseiadd")
3469    (set_attr "prefix_data16" "1")
3470    (set_attr "mode" "TI")])
3471
3472 (define_expand "smaxv8hi3"
3473   [(set (match_operand:V8HI 0 "register_operand" "")
3474         (smax:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "")
3475                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
3476   "TARGET_SSE2"
3477   "ix86_fixup_binary_operands_no_copy (SMAX, V8HImode, operands);")
3478
3479 (define_insn "*smaxv8hi3"
3480   [(set (match_operand:V8HI 0 "register_operand" "=x")
3481         (smax:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%0")
3482                    (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
3483   "TARGET_SSE2 && ix86_binary_operator_ok (SMAX, V8HImode, operands)"
3484   "pmaxsw\t{%2, %0|%0, %2}"
3485   [(set_attr "type" "sseiadd")
3486    (set_attr "prefix_data16" "1")
3487    (set_attr "mode" "TI")])
3488
3489 (define_expand "umaxv8hi3"
3490   [(set (match_operand:V8HI 0 "register_operand" "")
3491         (umax:V8HI (match_operand:V8HI 1 "register_operand" "")
3492                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
3493   "TARGET_SSE2"
3494 {
3495   if (TARGET_SSE4_1)
3496     ix86_fixup_binary_operands_no_copy (UMAX, V8HImode, operands);
3497   else
3498     {
3499       rtx op0 = operands[0], op2 = operands[2], op3 = op0;
3500       if (rtx_equal_p (op3, op2))
3501         op3 = gen_reg_rtx (V8HImode);
3502       emit_insn (gen_sse2_ussubv8hi3 (op3, operands[1], op2));
3503       emit_insn (gen_addv8hi3 (op0, op3, op2));
3504       DONE;
3505     }
3506 })
3507
3508 (define_expand "smax<mode>3"
3509   [(set (match_operand:SSEMODE14 0 "register_operand" "")
3510         (smax:SSEMODE14 (match_operand:SSEMODE14 1 "register_operand" "")
3511                         (match_operand:SSEMODE14 2 "register_operand" "")))]
3512   "TARGET_SSE2"
3513 {
3514   if (TARGET_SSE4_1)
3515     ix86_fixup_binary_operands_no_copy (SMAX, <MODE>mode, operands);
3516   else
3517   {
3518     rtx xops[6];
3519     bool ok;
3520
3521     xops[0] = operands[0];
3522     xops[1] = operands[1];
3523     xops[2] = operands[2];
3524     xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
3525     xops[4] = operands[1];
3526     xops[5] = operands[2];
3527     ok = ix86_expand_int_vcond (xops);
3528     gcc_assert (ok);
3529     DONE;
3530   }
3531 })
3532
3533 (define_insn "*sse4_1_smax<mode>3"
3534   [(set (match_operand:SSEMODE14 0 "register_operand" "=x")
3535         (smax:SSEMODE14
3536           (match_operand:SSEMODE14 1 "nonimmediate_operand" "%0")
3537           (match_operand:SSEMODE14 2 "nonimmediate_operand" "xm")))]
3538   "TARGET_SSE4_1 && ix86_binary_operator_ok (SMAX, <MODE>mode, operands)"
3539   "pmaxs<ssevecsize>\t{%2, %0|%0, %2}"
3540   [(set_attr "type" "sseiadd")
3541    (set_attr "prefix_extra" "1")
3542    (set_attr "mode" "TI")])
3543
3544 (define_expand "umaxv4si3"
3545   [(set (match_operand:V4SI 0 "register_operand" "")
3546         (umax:V4SI (match_operand:V4SI 1 "register_operand" "")
3547                    (match_operand:V4SI 2 "register_operand" "")))]
3548   "TARGET_SSE2"
3549 {
3550   if (TARGET_SSE4_1)
3551     ix86_fixup_binary_operands_no_copy (UMAX, V4SImode, operands);
3552   else
3553   {
3554     rtx xops[6];
3555     bool ok;
3556
3557     xops[0] = operands[0];
3558     xops[1] = operands[1];
3559     xops[2] = operands[2];
3560     xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
3561     xops[4] = operands[1];
3562     xops[5] = operands[2];
3563     ok = ix86_expand_int_vcond (xops);
3564     gcc_assert (ok);
3565     DONE;
3566   }
3567 })
3568
3569 (define_insn "*sse4_1_umax<mode>3"
3570   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
3571         (umax:SSEMODE24
3572           (match_operand:SSEMODE24 1 "nonimmediate_operand" "%0")
3573           (match_operand:SSEMODE24 2 "nonimmediate_operand" "xm")))]
3574   "TARGET_SSE4_1 && ix86_binary_operator_ok (UMAX, <MODE>mode, operands)"
3575   "pmaxu<ssevecsize>\t{%2, %0|%0, %2}"
3576   [(set_attr "type" "sseiadd")
3577    (set_attr "prefix_extra" "1")
3578    (set_attr "mode" "TI")])
3579
3580 (define_expand "uminv16qi3"
3581   [(set (match_operand:V16QI 0 "register_operand" "")
3582         (umin:V16QI (match_operand:V16QI 1 "nonimmediate_operand" "")
3583                     (match_operand:V16QI 2 "nonimmediate_operand" "")))]
3584   "TARGET_SSE2"
3585   "ix86_fixup_binary_operands_no_copy (UMIN, V16QImode, operands);")
3586
3587 (define_insn "*uminv16qi3"
3588   [(set (match_operand:V16QI 0 "register_operand" "=x")
3589         (umin:V16QI (match_operand:V16QI 1 "nonimmediate_operand" "%0")
3590                     (match_operand:V16QI 2 "nonimmediate_operand" "xm")))]
3591   "TARGET_SSE2 && ix86_binary_operator_ok (UMIN, V16QImode, operands)"
3592   "pminub\t{%2, %0|%0, %2}"
3593   [(set_attr "type" "sseiadd")
3594    (set_attr "prefix_data16" "1")
3595    (set_attr "mode" "TI")])
3596
3597 (define_expand "sminv8hi3"
3598   [(set (match_operand:V8HI 0 "register_operand" "")
3599         (smin:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "")
3600                    (match_operand:V8HI 2 "nonimmediate_operand" "")))]
3601   "TARGET_SSE2"
3602   "ix86_fixup_binary_operands_no_copy (SMIN, V8HImode, operands);")
3603
3604 (define_insn "*sminv8hi3"
3605   [(set (match_operand:V8HI 0 "register_operand" "=x")
3606         (smin:V8HI (match_operand:V8HI 1 "nonimmediate_operand" "%0")
3607                    (match_operand:V8HI 2 "nonimmediate_operand" "xm")))]
3608   "TARGET_SSE2 && ix86_binary_operator_ok (SMIN, V8HImode, operands)"
3609   "pminsw\t{%2, %0|%0, %2}"
3610   [(set_attr "type" "sseiadd")
3611    (set_attr "prefix_data16" "1")
3612    (set_attr "mode" "TI")])
3613
3614 (define_expand "smin<mode>3"
3615   [(set (match_operand:SSEMODE14 0 "register_operand" "")
3616         (smin:SSEMODE14 (match_operand:SSEMODE14 1 "register_operand" "")
3617                         (match_operand:SSEMODE14 2 "register_operand" "")))]
3618   "TARGET_SSE2"
3619 {
3620   if (TARGET_SSE4_1)
3621     ix86_fixup_binary_operands_no_copy (SMIN, <MODE>mode, operands);
3622   else
3623     {
3624       rtx xops[6];
3625       bool ok;
3626
3627       xops[0] = operands[0];
3628       xops[1] = operands[2];
3629       xops[2] = operands[1];
3630       xops[3] = gen_rtx_GT (VOIDmode, operands[1], operands[2]);
3631       xops[4] = operands[1];
3632       xops[5] = operands[2];
3633       ok = ix86_expand_int_vcond (xops);
3634       gcc_assert (ok);
3635       DONE;
3636     }
3637 })
3638
3639 (define_insn "*sse4_1_smin<mode>3"
3640   [(set (match_operand:SSEMODE14 0 "register_operand" "=x")
3641         (smin:SSEMODE14
3642           (match_operand:SSEMODE14 1 "nonimmediate_operand" "%0")
3643           (match_operand:SSEMODE14 2 "nonimmediate_operand" "xm")))]
3644   "TARGET_SSE4_1 && ix86_binary_operator_ok (SMIN, <MODE>mode, operands)"
3645   "pmins<ssevecsize>\t{%2, %0|%0, %2}"
3646   [(set_attr "type" "sseiadd")
3647    (set_attr "prefix_extra" "1")
3648    (set_attr "mode" "TI")])
3649
3650 (define_expand "umin<mode>3"
3651   [(set (match_operand:SSEMODE24 0 "register_operand" "")
3652         (umin:SSEMODE24 (match_operand:SSEMODE24 1 "register_operand" "")
3653                         (match_operand:SSEMODE24 2 "register_operand" "")))]
3654   "TARGET_SSE2"
3655 {
3656   if (TARGET_SSE4_1)
3657     ix86_fixup_binary_operands_no_copy (UMIN, <MODE>mode, operands);
3658   else
3659     {
3660       rtx xops[6];
3661       bool ok;
3662
3663       xops[0] = operands[0];
3664       xops[1] = operands[2];
3665       xops[2] = operands[1];
3666       xops[3] = gen_rtx_GTU (VOIDmode, operands[1], operands[2]);
3667       xops[4] = operands[1];
3668       xops[5] = operands[2];
3669       ok = ix86_expand_int_vcond (xops);
3670       gcc_assert (ok);
3671       DONE;
3672     }
3673 })
3674
3675 (define_insn "*sse4_1_umin<mode>3"
3676   [(set (match_operand:SSEMODE24 0 "register_operand" "=x")
3677         (umin:SSEMODE24
3678           (match_operand:SSEMODE24 1 "nonimmediate_operand" "%0")
3679           (match_operand:SSEMODE24 2 "nonimmediate_operand" "xm")))]
3680   "TARGET_SSE4_1 && ix86_binary_operator_ok (UMIN, <MODE>mode, operands)"
3681   "pminu<ssevecsize>\t{%2, %0|%0, %2}"
3682   [(set_attr "type" "sseiadd")
3683    (set_attr "prefix_extra" "1")
3684    (set_attr "mode" "TI")])
3685
3686 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3687 ;;
3688 ;; Parallel integral comparisons
3689 ;;
3690 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3691
3692 (define_insn "sse2_eq<mode>3"
3693   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
3694         (eq:SSEMODE124
3695           (match_operand:SSEMODE124 1 "nonimmediate_operand" "%0")
3696           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
3697   "TARGET_SSE2 && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
3698   "pcmpeq<ssevecsize>\t{%2, %0|%0, %2}"
3699   [(set_attr "type" "ssecmp")
3700    (set_attr "prefix_data16" "1")
3701    (set_attr "mode" "TI")])
3702
3703 (define_insn "sse4_1_eqv2di3"
3704   [(set (match_operand:V2DI 0 "register_operand" "=x")
3705         (eq:V2DI
3706           (match_operand:V2DI 1 "nonimmediate_operand" "%0")
3707           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
3708   "TARGET_SSE4_1 && ix86_binary_operator_ok (EQ, V2DImode, operands)"
3709   "pcmpeqq\t{%2, %0|%0, %2}"
3710   [(set_attr "type" "ssecmp")
3711    (set_attr "prefix_extra" "1")
3712    (set_attr "mode" "TI")])
3713
3714 (define_insn "sse2_gt<mode>3"
3715   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
3716         (gt:SSEMODE124
3717           (match_operand:SSEMODE124 1 "register_operand" "0")
3718           (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")))]
3719   "TARGET_SSE2"
3720   "pcmpgt<ssevecsize>\t{%2, %0|%0, %2}"
3721   [(set_attr "type" "ssecmp")
3722    (set_attr "prefix_data16" "1")
3723    (set_attr "mode" "TI")])
3724
3725 (define_insn "sse4_2_gtv2di3"
3726   [(set (match_operand:V2DI 0 "register_operand" "=x")
3727         (gt:V2DI
3728           (match_operand:V2DI 1 "nonimmediate_operand" "0")
3729           (match_operand:V2DI 2 "nonimmediate_operand" "xm")))]
3730   "TARGET_SSE4_2"
3731   "pcmpgtq\t{%2, %0|%0, %2}"
3732   [(set_attr "type" "ssecmp")
3733    (set_attr "mode" "TI")])
3734
3735 (define_expand "vcond<mode>"
3736   [(set (match_operand:SSEMODEI 0 "register_operand" "")
3737         (if_then_else:SSEMODEI
3738           (match_operator 3 ""
3739             [(match_operand:SSEMODEI 4 "nonimmediate_operand" "")
3740              (match_operand:SSEMODEI 5 "nonimmediate_operand" "")])
3741           (match_operand:SSEMODEI 1 "general_operand" "")
3742           (match_operand:SSEMODEI 2 "general_operand" "")))]
3743   "TARGET_SSE2"
3744 {
3745   if (ix86_expand_int_vcond (operands))
3746     DONE;
3747   else
3748     FAIL;
3749 })
3750
3751 (define_expand "vcondu<mode>"
3752   [(set (match_operand:SSEMODEI 0 "register_operand" "")
3753         (if_then_else:SSEMODEI
3754           (match_operator 3 ""
3755             [(match_operand:SSEMODEI 4 "nonimmediate_operand" "")
3756              (match_operand:SSEMODEI 5 "nonimmediate_operand" "")])
3757           (match_operand:SSEMODEI 1 "general_operand" "")
3758           (match_operand:SSEMODEI 2 "general_operand" "")))]
3759   "TARGET_SSE2"
3760 {
3761   if (ix86_expand_int_vcond (operands))
3762     DONE;
3763   else
3764     FAIL;
3765 })
3766
3767 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3768 ;;
3769 ;; Parallel bitwise logical operations
3770 ;;
3771 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3772
3773 (define_expand "one_cmpl<mode>2"
3774   [(set (match_operand:SSEMODEI 0 "register_operand" "")
3775         (xor:SSEMODEI (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
3776                       (match_dup 2)))]
3777   "TARGET_SSE2"
3778 {
3779   int i, n = GET_MODE_NUNITS (<MODE>mode);
3780   rtvec v = rtvec_alloc (n);
3781
3782   for (i = 0; i < n; ++i)
3783     RTVEC_ELT (v, i) = constm1_rtx;
3784
3785   operands[2] = force_reg (<MODE>mode, gen_rtx_CONST_VECTOR (<MODE>mode, v));
3786 })
3787
3788 (define_expand "and<mode>3"
3789   [(set (match_operand:SSEMODEI 0 "register_operand" "")
3790         (and:SSEMODEI (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
3791                       (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
3792   "TARGET_SSE"
3793   "ix86_fixup_binary_operands_no_copy (AND, <MODE>mode, operands);")
3794
3795 (define_insn "*sse_and<mode>3"
3796   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
3797         (and:SSEMODEI
3798           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
3799           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
3800   "(TARGET_SSE && !TARGET_SSE2)
3801    && ix86_binary_operator_ok (AND, <MODE>mode, operands)"
3802   "andps\t{%2, %0|%0, %2}"
3803   [(set_attr "type" "sselog")
3804    (set_attr "mode" "V4SF")])
3805
3806 (define_insn "*sse2_and<mode>3"
3807   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
3808         (and:SSEMODEI
3809           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
3810           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
3811   "TARGET_SSE2 && ix86_binary_operator_ok (AND, <MODE>mode, operands)"
3812   "pand\t{%2, %0|%0, %2}"
3813   [(set_attr "type" "sselog")
3814    (set_attr "prefix_data16" "1")
3815    (set_attr "mode" "TI")])
3816
3817 (define_insn "*sse_nand<mode>3"
3818   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
3819         (and:SSEMODEI
3820           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "0"))
3821           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
3822   "(TARGET_SSE && !TARGET_SSE2)"
3823   "andnps\t{%2, %0|%0, %2}"
3824   [(set_attr "type" "sselog")
3825    (set_attr "mode" "V4SF")])
3826
3827 (define_insn "sse2_nand<mode>3"
3828   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
3829         (and:SSEMODEI
3830           (not:SSEMODEI (match_operand:SSEMODEI 1 "register_operand" "0"))
3831           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
3832   "TARGET_SSE2"
3833   "pandn\t{%2, %0|%0, %2}"
3834   [(set_attr "type" "sselog")
3835    (set_attr "prefix_data16" "1")
3836    (set_attr "mode" "TI")])
3837
3838 (define_expand "andtf3"
3839   [(set (match_operand:TF 0 "register_operand" "")
3840         (and:TF (match_operand:TF 1 "nonimmediate_operand" "")
3841                 (match_operand:TF 2 "nonimmediate_operand" "")))]
3842   "TARGET_64BIT"
3843   "ix86_fixup_binary_operands_no_copy (AND, TFmode, operands);")
3844
3845 (define_insn "*andtf3"
3846   [(set (match_operand:TF 0 "register_operand" "=x")
3847         (and:TF
3848           (match_operand:TF 1 "nonimmediate_operand" "%0")
3849           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
3850   "TARGET_64BIT && ix86_binary_operator_ok (AND, TFmode, operands)"
3851   "pand\t{%2, %0|%0, %2}"
3852   [(set_attr "type" "sselog")
3853    (set_attr "prefix_data16" "1")
3854    (set_attr "mode" "TI")])
3855
3856 (define_insn "*nandtf3"
3857   [(set (match_operand:TF 0 "register_operand" "=x")
3858         (and:TF
3859           (not:TF (match_operand:TF 1 "register_operand" "0"))
3860           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
3861   "TARGET_64BIT"
3862   "pandn\t{%2, %0|%0, %2}"
3863   [(set_attr "type" "sselog")
3864    (set_attr "prefix_data16" "1")
3865    (set_attr "mode" "TI")])
3866
3867 (define_expand "ior<mode>3"
3868   [(set (match_operand:SSEMODEI 0 "register_operand" "")
3869         (ior:SSEMODEI (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
3870                       (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
3871   "TARGET_SSE"
3872   "ix86_fixup_binary_operands_no_copy (IOR, <MODE>mode, operands);")
3873
3874 (define_insn "*sse_ior<mode>3"
3875   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
3876         (ior:SSEMODEI
3877           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
3878           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
3879   "(TARGET_SSE && !TARGET_SSE2)
3880    && ix86_binary_operator_ok (IOR, <MODE>mode, operands)"
3881   "orps\t{%2, %0|%0, %2}"
3882   [(set_attr "type" "sselog")
3883    (set_attr "mode" "V4SF")])
3884
3885 (define_insn "*sse2_ior<mode>3"
3886   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
3887         (ior:SSEMODEI
3888           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
3889           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
3890   "TARGET_SSE2 && ix86_binary_operator_ok (IOR, <MODE>mode, operands)"
3891   "por\t{%2, %0|%0, %2}"
3892   [(set_attr "type" "sselog")
3893    (set_attr "prefix_data16" "1")
3894    (set_attr "mode" "TI")])
3895
3896 (define_expand "iortf3"
3897   [(set (match_operand:TF 0 "register_operand" "")
3898         (ior:TF (match_operand:TF 1 "nonimmediate_operand" "")
3899                 (match_operand:TF 2 "nonimmediate_operand" "")))]
3900   "TARGET_64BIT"
3901   "ix86_fixup_binary_operands_no_copy (IOR, TFmode, operands);")
3902
3903 (define_insn "*iortf3"
3904   [(set (match_operand:TF 0 "register_operand" "=x")
3905         (ior:TF
3906           (match_operand:TF 1 "nonimmediate_operand" "%0")
3907           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
3908   "TARGET_64BIT && ix86_binary_operator_ok (IOR, TFmode, operands)"
3909   "por\t{%2, %0|%0, %2}"
3910   [(set_attr "type" "sselog")
3911    (set_attr "prefix_data16" "1")
3912    (set_attr "mode" "TI")])
3913
3914 (define_expand "xor<mode>3"
3915   [(set (match_operand:SSEMODEI 0 "register_operand" "")
3916         (xor:SSEMODEI (match_operand:SSEMODEI 1 "nonimmediate_operand" "")
3917                       (match_operand:SSEMODEI 2 "nonimmediate_operand" "")))]
3918   "TARGET_SSE"
3919   "ix86_fixup_binary_operands_no_copy (XOR, <MODE>mode, operands);")
3920
3921 (define_insn "*sse_xor<mode>3"
3922   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
3923         (xor:SSEMODEI
3924           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
3925           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
3926   "(TARGET_SSE && !TARGET_SSE2)
3927    && ix86_binary_operator_ok (XOR, <MODE>mode, operands)"
3928   "xorps\t{%2, %0|%0, %2}"
3929   [(set_attr "type" "sselog")
3930    (set_attr "mode" "V4SF")])
3931
3932 (define_insn "*sse2_xor<mode>3"
3933   [(set (match_operand:SSEMODEI 0 "register_operand" "=x")
3934         (xor:SSEMODEI
3935           (match_operand:SSEMODEI 1 "nonimmediate_operand" "%0")
3936           (match_operand:SSEMODEI 2 "nonimmediate_operand" "xm")))]
3937   "TARGET_SSE2 && ix86_binary_operator_ok (XOR, <MODE>mode, operands)"
3938   "pxor\t{%2, %0|%0, %2}"
3939   [(set_attr "type" "sselog")
3940    (set_attr "prefix_data16" "1")
3941    (set_attr "mode" "TI")])
3942
3943 (define_expand "xortf3"
3944   [(set (match_operand:TF 0 "register_operand" "")
3945         (xor:TF (match_operand:TF 1 "nonimmediate_operand" "")
3946                 (match_operand:TF 2 "nonimmediate_operand" "")))]
3947   "TARGET_64BIT"
3948   "ix86_fixup_binary_operands_no_copy (XOR, TFmode, operands);")
3949
3950 (define_insn "*xortf3"
3951   [(set (match_operand:TF 0 "register_operand" "=x")
3952         (xor:TF
3953           (match_operand:TF 1 "nonimmediate_operand" "%0")
3954           (match_operand:TF 2 "nonimmediate_operand" "xm")))]
3955   "TARGET_64BIT && ix86_binary_operator_ok (XOR, TFmode, operands)"
3956   "pxor\t{%2, %0|%0, %2}"
3957   [(set_attr "type" "sselog")
3958    (set_attr "prefix_data16" "1")
3959    (set_attr "mode" "TI")])
3960
3961 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3962 ;;
3963 ;; Parallel integral element swizzling
3964 ;;
3965 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3966
3967 ;; Reduce:
3968 ;;      op1 = abcdefghijklmnop
3969 ;;      op2 = qrstuvwxyz012345
3970 ;;       h1 = aqbrcsdteufvgwhx
3971 ;;       l1 = iyjzk0l1m2n3o4p5
3972 ;;       h2 = aiqybjrzcks0dlt1
3973 ;;       l2 = emu2fnv3gow4hpx5
3974 ;;       h3 = aeimquy2bfjnrvz3
3975 ;;       l3 = cgkosw04dhlptx15
3976 ;;   result = bdfhjlnprtvxz135
3977 (define_expand "vec_pack_trunc_v8hi"
3978   [(match_operand:V16QI 0 "register_operand" "")
3979    (match_operand:V8HI 1 "register_operand" "")
3980    (match_operand:V8HI 2 "register_operand" "")]
3981   "TARGET_SSE2"
3982 {
3983   rtx op1, op2, h1, l1, h2, l2, h3, l3;
3984
3985   op1 = gen_lowpart (V16QImode, operands[1]);
3986   op2 = gen_lowpart (V16QImode, operands[2]);
3987   h1 = gen_reg_rtx (V16QImode);
3988   l1 = gen_reg_rtx (V16QImode);
3989   h2 = gen_reg_rtx (V16QImode);
3990   l2 = gen_reg_rtx (V16QImode);
3991   h3 = gen_reg_rtx (V16QImode);
3992   l3 = gen_reg_rtx (V16QImode);
3993
3994   emit_insn (gen_vec_interleave_highv16qi (h1, op1, op2));
3995   emit_insn (gen_vec_interleave_lowv16qi (l1, op1, op2));
3996   emit_insn (gen_vec_interleave_highv16qi (h2, l1, h1));
3997   emit_insn (gen_vec_interleave_lowv16qi (l2, l1, h1));
3998   emit_insn (gen_vec_interleave_highv16qi (h3, l2, h2));
3999   emit_insn (gen_vec_interleave_lowv16qi (l3, l2, h2));
4000   emit_insn (gen_vec_interleave_lowv16qi (operands[0], l3, h3));
4001   DONE;
4002 })
4003
4004 ;; Reduce:
4005 ;;      op1 = abcdefgh
4006 ;;      op2 = ijklmnop
4007 ;;       h1 = aibjckdl
4008 ;;       l1 = emfngohp
4009 ;;       h2 = aeimbfjn
4010 ;;       l2 = cgkodhlp
4011 ;;   result = bdfhjlnp
4012 (define_expand "vec_pack_trunc_v4si"
4013   [(match_operand:V8HI 0 "register_operand" "")
4014    (match_operand:V4SI 1 "register_operand" "")
4015    (match_operand:V4SI 2 "register_operand" "")]
4016   "TARGET_SSE2"
4017 {
4018   rtx op1, op2, h1, l1, h2, l2;
4019
4020   op1 = gen_lowpart (V8HImode, operands[1]);
4021   op2 = gen_lowpart (V8HImode, operands[2]);
4022   h1 = gen_reg_rtx (V8HImode);
4023   l1 = gen_reg_rtx (V8HImode);
4024   h2 = gen_reg_rtx (V8HImode);
4025   l2 = gen_reg_rtx (V8HImode);
4026
4027   emit_insn (gen_vec_interleave_highv8hi (h1, op1, op2));
4028   emit_insn (gen_vec_interleave_lowv8hi (l1, op1, op2));
4029   emit_insn (gen_vec_interleave_highv8hi (h2, l1, h1));
4030   emit_insn (gen_vec_interleave_lowv8hi (l2, l1, h1));
4031   emit_insn (gen_vec_interleave_lowv8hi (operands[0], l2, h2));
4032   DONE;
4033 })
4034
4035 ;; Reduce:
4036 ;;     op1 = abcd
4037 ;;     op2 = efgh
4038 ;;      h1 = aebf
4039 ;;      l1 = cgdh
4040 ;;  result = bdfh
4041 (define_expand "vec_pack_trunc_v2di"
4042   [(match_operand:V4SI 0 "register_operand" "")
4043    (match_operand:V2DI 1 "register_operand" "")
4044    (match_operand:V2DI 2 "register_operand" "")]
4045   "TARGET_SSE2"
4046 {
4047   rtx op1, op2, h1, l1;
4048
4049   op1 = gen_lowpart (V4SImode, operands[1]);
4050   op2 = gen_lowpart (V4SImode, operands[2]);
4051   h1 = gen_reg_rtx (V4SImode);
4052   l1 = gen_reg_rtx (V4SImode);
4053
4054   emit_insn (gen_vec_interleave_highv4si (h1, op1, op2));
4055   emit_insn (gen_vec_interleave_lowv4si (l1, op1, op2));
4056   emit_insn (gen_vec_interleave_lowv4si (operands[0], l1, h1));
4057   DONE;
4058 })
4059
4060 (define_expand "vec_interleave_highv16qi"
4061   [(set (match_operand:V16QI 0 "register_operand" "=x")
4062         (vec_select:V16QI
4063           (vec_concat:V32QI
4064             (match_operand:V16QI 1 "register_operand" "0")
4065             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
4066           (parallel [(const_int 8)  (const_int 24)
4067                      (const_int 9)  (const_int 25)
4068                      (const_int 10) (const_int 26)
4069                      (const_int 11) (const_int 27)
4070                      (const_int 12) (const_int 28)
4071                      (const_int 13) (const_int 29)
4072                      (const_int 14) (const_int 30)
4073                      (const_int 15) (const_int 31)])))]
4074   "TARGET_SSE2"
4075 {
4076   emit_insn (gen_sse2_punpckhbw (operands[0], operands[1], operands[2]));
4077   DONE;
4078 })
4079
4080 (define_expand "vec_interleave_lowv16qi"
4081   [(set (match_operand:V16QI 0 "register_operand" "=x")
4082         (vec_select:V16QI
4083           (vec_concat:V32QI
4084             (match_operand:V16QI 1 "register_operand" "0")
4085             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
4086           (parallel [(const_int 0) (const_int 16)
4087                      (const_int 1) (const_int 17)
4088                      (const_int 2) (const_int 18)
4089                      (const_int 3) (const_int 19)
4090                      (const_int 4) (const_int 20)
4091                      (const_int 5) (const_int 21)
4092                      (const_int 6) (const_int 22)
4093                      (const_int 7) (const_int 23)])))]
4094   "TARGET_SSE2"
4095 {
4096   emit_insn (gen_sse2_punpcklbw (operands[0], operands[1], operands[2]));
4097   DONE;
4098 })
4099
4100 (define_expand "vec_interleave_highv8hi"
4101   [(set (match_operand:V8HI 0 "register_operand" "=x")
4102         (vec_select:V8HI
4103           (vec_concat:V16HI
4104             (match_operand:V8HI 1 "register_operand" "0")
4105             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
4106           (parallel [(const_int 4) (const_int 12)
4107                      (const_int 5) (const_int 13)
4108                      (const_int 6) (const_int 14)
4109                      (const_int 7) (const_int 15)])))]
4110   "TARGET_SSE2"
4111 {
4112   emit_insn (gen_sse2_punpckhwd (operands[0], operands[1], operands[2]));
4113   DONE;
4114 })
4115
4116 (define_expand "vec_interleave_lowv8hi"
4117   [(set (match_operand:V8HI 0 "register_operand" "=x")
4118         (vec_select:V8HI
4119           (vec_concat:V16HI
4120             (match_operand:V8HI 1 "register_operand" "0")
4121             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
4122           (parallel [(const_int 0) (const_int 8)
4123                      (const_int 1) (const_int 9)
4124                      (const_int 2) (const_int 10)
4125                      (const_int 3) (const_int 11)])))]
4126   "TARGET_SSE2"
4127 {
4128   emit_insn (gen_sse2_punpcklwd (operands[0], operands[1], operands[2]));
4129   DONE;
4130 })
4131
4132 (define_expand "vec_interleave_highv4si"
4133   [(set (match_operand:V4SI 0 "register_operand" "=x")
4134         (vec_select:V4SI
4135           (vec_concat:V8SI
4136             (match_operand:V4SI 1 "register_operand" "0")
4137             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
4138           (parallel [(const_int 2) (const_int 6)
4139                      (const_int 3) (const_int 7)])))]
4140   "TARGET_SSE2"
4141 {
4142   emit_insn (gen_sse2_punpckhdq (operands[0], operands[1], operands[2]));
4143   DONE;
4144 })
4145
4146 (define_expand "vec_interleave_lowv4si"
4147   [(set (match_operand:V4SI 0 "register_operand" "=x")
4148         (vec_select:V4SI
4149           (vec_concat:V8SI
4150             (match_operand:V4SI 1 "register_operand" "0")
4151             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
4152           (parallel [(const_int 0) (const_int 4)
4153                      (const_int 1) (const_int 5)])))]
4154   "TARGET_SSE2"
4155 {
4156   emit_insn (gen_sse2_punpckldq (operands[0], operands[1], operands[2]));
4157   DONE;
4158 })
4159
4160 (define_expand "vec_interleave_highv2di"
4161   [(set (match_operand:V2DI 0 "register_operand" "=x")
4162         (vec_select:V2DI
4163           (vec_concat:V4DI
4164             (match_operand:V2DI 1 "register_operand" "0")
4165             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4166           (parallel [(const_int 1)
4167                      (const_int 3)])))]
4168   "TARGET_SSE2"
4169 {
4170   emit_insn (gen_sse2_punpckhqdq (operands[0], operands[1], operands[2]));
4171   DONE;
4172 })
4173
4174 (define_expand "vec_interleave_lowv2di"
4175   [(set (match_operand:V2DI 0 "register_operand" "=x")
4176         (vec_select:V2DI
4177           (vec_concat:V4DI
4178             (match_operand:V2DI 1 "register_operand" "0")
4179             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4180           (parallel [(const_int 0)
4181                      (const_int 2)])))]
4182   "TARGET_SSE2"
4183 {
4184   emit_insn (gen_sse2_punpcklqdq (operands[0], operands[1], operands[2]));
4185   DONE;
4186 })
4187
4188 (define_insn "sse2_packsswb"
4189   [(set (match_operand:V16QI 0 "register_operand" "=x")
4190         (vec_concat:V16QI
4191           (ss_truncate:V8QI
4192             (match_operand:V8HI 1 "register_operand" "0"))
4193           (ss_truncate:V8QI
4194             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
4195   "TARGET_SSE2"
4196   "packsswb\t{%2, %0|%0, %2}"
4197   [(set_attr "type" "sselog")
4198    (set_attr "prefix_data16" "1")
4199    (set_attr "mode" "TI")])
4200
4201 (define_insn "sse2_packssdw"
4202   [(set (match_operand:V8HI 0 "register_operand" "=x")
4203         (vec_concat:V8HI
4204           (ss_truncate:V4HI
4205             (match_operand:V4SI 1 "register_operand" "0"))
4206           (ss_truncate:V4HI
4207             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
4208   "TARGET_SSE2"
4209   "packssdw\t{%2, %0|%0, %2}"
4210   [(set_attr "type" "sselog")
4211    (set_attr "prefix_data16" "1")
4212    (set_attr "mode" "TI")])
4213
4214 (define_insn "sse2_packuswb"
4215   [(set (match_operand:V16QI 0 "register_operand" "=x")
4216         (vec_concat:V16QI
4217           (us_truncate:V8QI
4218             (match_operand:V8HI 1 "register_operand" "0"))
4219           (us_truncate:V8QI
4220             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))))]
4221   "TARGET_SSE2"
4222   "packuswb\t{%2, %0|%0, %2}"
4223   [(set_attr "type" "sselog")
4224    (set_attr "prefix_data16" "1")
4225    (set_attr "mode" "TI")])
4226
4227 (define_insn "sse2_punpckhbw"
4228   [(set (match_operand:V16QI 0 "register_operand" "=x")
4229         (vec_select:V16QI
4230           (vec_concat:V32QI
4231             (match_operand:V16QI 1 "register_operand" "0")
4232             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
4233           (parallel [(const_int 8)  (const_int 24)
4234                      (const_int 9)  (const_int 25)
4235                      (const_int 10) (const_int 26)
4236                      (const_int 11) (const_int 27)
4237                      (const_int 12) (const_int 28)
4238                      (const_int 13) (const_int 29)
4239                      (const_int 14) (const_int 30)
4240                      (const_int 15) (const_int 31)])))]
4241   "TARGET_SSE2"
4242   "punpckhbw\t{%2, %0|%0, %2}"
4243   [(set_attr "type" "sselog")
4244    (set_attr "prefix_data16" "1")
4245    (set_attr "mode" "TI")])
4246
4247 (define_insn "sse2_punpcklbw"
4248   [(set (match_operand:V16QI 0 "register_operand" "=x")
4249         (vec_select:V16QI
4250           (vec_concat:V32QI
4251             (match_operand:V16QI 1 "register_operand" "0")
4252             (match_operand:V16QI 2 "nonimmediate_operand" "xm"))
4253           (parallel [(const_int 0) (const_int 16)
4254                      (const_int 1) (const_int 17)
4255                      (const_int 2) (const_int 18)
4256                      (const_int 3) (const_int 19)
4257                      (const_int 4) (const_int 20)
4258                      (const_int 5) (const_int 21)
4259                      (const_int 6) (const_int 22)
4260                      (const_int 7) (const_int 23)])))]
4261   "TARGET_SSE2"
4262   "punpcklbw\t{%2, %0|%0, %2}"
4263   [(set_attr "type" "sselog")
4264    (set_attr "prefix_data16" "1")
4265    (set_attr "mode" "TI")])
4266
4267 (define_insn "sse2_punpckhwd"
4268   [(set (match_operand:V8HI 0 "register_operand" "=x")
4269         (vec_select:V8HI
4270           (vec_concat:V16HI
4271             (match_operand:V8HI 1 "register_operand" "0")
4272             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
4273           (parallel [(const_int 4) (const_int 12)
4274                      (const_int 5) (const_int 13)
4275                      (const_int 6) (const_int 14)
4276                      (const_int 7) (const_int 15)])))]
4277   "TARGET_SSE2"
4278   "punpckhwd\t{%2, %0|%0, %2}"
4279   [(set_attr "type" "sselog")
4280    (set_attr "prefix_data16" "1")
4281    (set_attr "mode" "TI")])
4282
4283 (define_insn "sse2_punpcklwd"
4284   [(set (match_operand:V8HI 0 "register_operand" "=x")
4285         (vec_select:V8HI
4286           (vec_concat:V16HI
4287             (match_operand:V8HI 1 "register_operand" "0")
4288             (match_operand:V8HI 2 "nonimmediate_operand" "xm"))
4289           (parallel [(const_int 0) (const_int 8)
4290                      (const_int 1) (const_int 9)
4291                      (const_int 2) (const_int 10)
4292                      (const_int 3) (const_int 11)])))]
4293   "TARGET_SSE2"
4294   "punpcklwd\t{%2, %0|%0, %2}"
4295   [(set_attr "type" "sselog")
4296    (set_attr "prefix_data16" "1")
4297    (set_attr "mode" "TI")])
4298
4299 (define_insn "sse2_punpckhdq"
4300   [(set (match_operand:V4SI 0 "register_operand" "=x")
4301         (vec_select:V4SI
4302           (vec_concat:V8SI
4303             (match_operand:V4SI 1 "register_operand" "0")
4304             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
4305           (parallel [(const_int 2) (const_int 6)
4306                      (const_int 3) (const_int 7)])))]
4307   "TARGET_SSE2"
4308   "punpckhdq\t{%2, %0|%0, %2}"
4309   [(set_attr "type" "sselog")
4310    (set_attr "prefix_data16" "1")
4311    (set_attr "mode" "TI")])
4312
4313 (define_insn "sse2_punpckldq"
4314   [(set (match_operand:V4SI 0 "register_operand" "=x")
4315         (vec_select:V4SI
4316           (vec_concat:V8SI
4317             (match_operand:V4SI 1 "register_operand" "0")
4318             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))
4319           (parallel [(const_int 0) (const_int 4)
4320                      (const_int 1) (const_int 5)])))]
4321   "TARGET_SSE2"
4322   "punpckldq\t{%2, %0|%0, %2}"
4323   [(set_attr "type" "sselog")
4324    (set_attr "prefix_data16" "1")
4325    (set_attr "mode" "TI")])
4326
4327 (define_insn "sse2_punpckhqdq"
4328   [(set (match_operand:V2DI 0 "register_operand" "=x")
4329         (vec_select:V2DI
4330           (vec_concat:V4DI
4331             (match_operand:V2DI 1 "register_operand" "0")
4332             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4333           (parallel [(const_int 1)
4334                      (const_int 3)])))]
4335   "TARGET_SSE2"
4336   "punpckhqdq\t{%2, %0|%0, %2}"
4337   [(set_attr "type" "sselog")
4338    (set_attr "prefix_data16" "1")
4339    (set_attr "mode" "TI")])
4340
4341 (define_insn "sse2_punpcklqdq"
4342   [(set (match_operand:V2DI 0 "register_operand" "=x")
4343         (vec_select:V2DI
4344           (vec_concat:V4DI
4345             (match_operand:V2DI 1 "register_operand" "0")
4346             (match_operand:V2DI 2 "nonimmediate_operand" "xm"))
4347           (parallel [(const_int 0)
4348                      (const_int 2)])))]
4349   "TARGET_SSE2"
4350   "punpcklqdq\t{%2, %0|%0, %2}"
4351   [(set_attr "type" "sselog")
4352    (set_attr "prefix_data16" "1")
4353    (set_attr "mode" "TI")])
4354
4355 (define_insn "*sse4_1_pinsrb"
4356   [(set (match_operand:V16QI 0 "register_operand" "=x")
4357         (vec_merge:V16QI
4358           (vec_duplicate:V16QI
4359             (match_operand:QI 2 "nonimmediate_operand" "rm"))
4360           (match_operand:V16QI 1 "register_operand" "0")
4361           (match_operand:SI 3 "const_pow2_1_to_32768_operand" "n")))]
4362   "TARGET_SSE4_1"
4363 {
4364   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
4365   return "pinsrb\t{%3, %k2, %0|%0, %k2, %3}";
4366 }
4367   [(set_attr "type" "sselog")
4368    (set_attr "prefix_extra" "1")
4369    (set_attr "mode" "TI")])
4370
4371 (define_insn "*sse2_pinsrw"
4372   [(set (match_operand:V8HI 0 "register_operand" "=x")
4373         (vec_merge:V8HI
4374           (vec_duplicate:V8HI
4375             (match_operand:HI 2 "nonimmediate_operand" "rm"))
4376           (match_operand:V8HI 1 "register_operand" "0")
4377           (match_operand:SI 3 "const_pow2_1_to_128_operand" "n")))]
4378   "TARGET_SSE2"
4379 {
4380   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
4381   return "pinsrw\t{%3, %k2, %0|%0, %k2, %3}";
4382 }
4383   [(set_attr "type" "sselog")
4384    (set_attr "prefix_data16" "1")
4385    (set_attr "mode" "TI")])
4386
4387 ;; It must come before sse2_loadld since it is preferred.
4388 (define_insn "*sse4_1_pinsrd"
4389   [(set (match_operand:V4SI 0 "register_operand" "=x")
4390         (vec_merge:V4SI
4391           (vec_duplicate:V4SI
4392             (match_operand:SI 2 "nonimmediate_operand" "rm"))
4393           (match_operand:V4SI 1 "register_operand" "0")
4394           (match_operand:SI 3 "const_pow2_1_to_8_operand" "n")))]
4395   "TARGET_SSE4_1"
4396 {
4397   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
4398   return "pinsrd\t{%3, %2, %0|%0, %2, %3}";
4399 }
4400   [(set_attr "type" "sselog")
4401    (set_attr "prefix_extra" "1")
4402    (set_attr "mode" "TI")])
4403
4404 (define_insn "*sse4_1_pinsrq"
4405   [(set (match_operand:V2DI 0 "register_operand" "=x")
4406         (vec_merge:V2DI
4407           (vec_duplicate:V2DI
4408             (match_operand:DI 2 "nonimmediate_operand" "rm"))
4409           (match_operand:V2DI 1 "register_operand" "0")
4410           (match_operand:SI 3 "const_pow2_1_to_2_operand" "n")))]
4411   "TARGET_SSE4_1"
4412 {
4413   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
4414   return "pinsrq\t{%3, %2, %0|%0, %2, %3}";
4415 }
4416   [(set_attr "type" "sselog")
4417    (set_attr "prefix_extra" "1")
4418    (set_attr "mode" "TI")])
4419
4420 (define_insn "*sse4_1_pextrb"
4421   [(set (match_operand:SI 0 "register_operand" "=r")
4422         (zero_extend:SI
4423           (vec_select:QI
4424             (match_operand:V16QI 1 "register_operand" "x")
4425             (parallel [(match_operand:SI 2 "const_0_to_15_operand" "n")]))))]
4426   "TARGET_SSE4_1"
4427   "pextrb\t{%2, %1, %0|%0, %1, %2}"
4428   [(set_attr "type" "sselog")
4429    (set_attr "prefix_extra" "1")
4430    (set_attr "mode" "TI")])
4431
4432 (define_insn "*sse4_1_pextrb_memory"
4433   [(set (match_operand:QI 0 "memory_operand" "=m")
4434         (vec_select:QI
4435           (match_operand:V16QI 1 "register_operand" "x")
4436           (parallel [(match_operand:SI 2 "const_0_to_15_operand" "n")])))]
4437   "TARGET_SSE4_1"
4438   "pextrb\t{%2, %1, %0|%0, %1, %2}"
4439   [(set_attr "type" "sselog")
4440    (set_attr "prefix_extra" "1")
4441    (set_attr "mode" "TI")])
4442
4443 (define_insn "*sse2_pextrw"
4444   [(set (match_operand:SI 0 "register_operand" "=r")
4445         (zero_extend:SI
4446           (vec_select:HI
4447             (match_operand:V8HI 1 "register_operand" "x")
4448             (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n")]))))]
4449   "TARGET_SSE2"
4450   "pextrw\t{%2, %1, %0|%0, %1, %2}"
4451   [(set_attr "type" "sselog")
4452    (set_attr "prefix_data16" "1")
4453    (set_attr "mode" "TI")])
4454
4455 (define_insn "*sse4_1_pextrw_memory"
4456   [(set (match_operand:HI 0 "memory_operand" "=m")
4457         (vec_select:HI
4458           (match_operand:V8HI 1 "register_operand" "x")
4459           (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n")])))]
4460   "TARGET_SSE4_1"
4461   "pextrw\t{%2, %1, %0|%0, %1, %2}"
4462   [(set_attr "type" "sselog")
4463    (set_attr "prefix_extra" "1")
4464    (set_attr "mode" "TI")])
4465
4466 (define_insn "*sse4_1_pextrd"
4467   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
4468         (vec_select:SI
4469           (match_operand:V4SI 1 "register_operand" "x")
4470           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n")])))]
4471   "TARGET_SSE4_1"
4472   "pextrd\t{%2, %1, %0|%0, %1, %2}"
4473   [(set_attr "type" "sselog")
4474    (set_attr "prefix_extra" "1")
4475    (set_attr "mode" "TI")])
4476
4477 ;; It must come before *vec_extractv2di_1_sse since it is preferred.
4478 (define_insn "*sse4_1_pextrq"
4479   [(set (match_operand:DI 0 "nonimmediate_operand" "=rm")
4480         (vec_select:DI
4481           (match_operand:V2DI 1 "register_operand" "x")
4482           (parallel [(match_operand:SI 2 "const_0_to_1_operand" "n")])))]
4483   "TARGET_SSE4_1 && TARGET_64BIT"
4484   "pextrq\t{%2, %1, %0|%0, %1, %2}"
4485   [(set_attr "type" "sselog")
4486    (set_attr "prefix_extra" "1")
4487    (set_attr "mode" "TI")])
4488
4489 (define_expand "sse2_pshufd"
4490   [(match_operand:V4SI 0 "register_operand" "")
4491    (match_operand:V4SI 1 "nonimmediate_operand" "")
4492    (match_operand:SI 2 "const_int_operand" "")]
4493   "TARGET_SSE2"
4494 {
4495   int mask = INTVAL (operands[2]);
4496   emit_insn (gen_sse2_pshufd_1 (operands[0], operands[1],
4497                                 GEN_INT ((mask >> 0) & 3),
4498                                 GEN_INT ((mask >> 2) & 3),
4499                                 GEN_INT ((mask >> 4) & 3),
4500                                 GEN_INT ((mask >> 6) & 3)));
4501   DONE;
4502 })
4503
4504 (define_insn "sse2_pshufd_1"
4505   [(set (match_operand:V4SI 0 "register_operand" "=x")
4506         (vec_select:V4SI
4507           (match_operand:V4SI 1 "nonimmediate_operand" "xm")
4508           (parallel [(match_operand 2 "const_0_to_3_operand" "")
4509                      (match_operand 3 "const_0_to_3_operand" "")
4510                      (match_operand 4 "const_0_to_3_operand" "")
4511                      (match_operand 5 "const_0_to_3_operand" "")])))]
4512   "TARGET_SSE2"
4513 {
4514   int mask = 0;
4515   mask |= INTVAL (operands[2]) << 0;
4516   mask |= INTVAL (operands[3]) << 2;
4517   mask |= INTVAL (operands[4]) << 4;
4518   mask |= INTVAL (operands[5]) << 6;
4519   operands[2] = GEN_INT (mask);
4520
4521   return "pshufd\t{%2, %1, %0|%0, %1, %2}";
4522 }
4523   [(set_attr "type" "sselog1")
4524    (set_attr "prefix_data16" "1")
4525    (set_attr "mode" "TI")])
4526
4527 (define_expand "sse2_pshuflw"
4528   [(match_operand:V8HI 0 "register_operand" "")
4529    (match_operand:V8HI 1 "nonimmediate_operand" "")
4530    (match_operand:SI 2 "const_int_operand" "")]
4531   "TARGET_SSE2"
4532 {
4533   int mask = INTVAL (operands[2]);
4534   emit_insn (gen_sse2_pshuflw_1 (operands[0], operands[1],
4535                                  GEN_INT ((mask >> 0) & 3),
4536                                  GEN_INT ((mask >> 2) & 3),
4537                                  GEN_INT ((mask >> 4) & 3),
4538                                  GEN_INT ((mask >> 6) & 3)));
4539   DONE;
4540 })
4541
4542 (define_insn "sse2_pshuflw_1"
4543   [(set (match_operand:V8HI 0 "register_operand" "=x")
4544         (vec_select:V8HI
4545           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
4546           (parallel [(match_operand 2 "const_0_to_3_operand" "")
4547                      (match_operand 3 "const_0_to_3_operand" "")
4548                      (match_operand 4 "const_0_to_3_operand" "")
4549                      (match_operand 5 "const_0_to_3_operand" "")
4550                      (const_int 4)
4551                      (const_int 5)
4552                      (const_int 6)
4553                      (const_int 7)])))]
4554   "TARGET_SSE2"
4555 {
4556   int mask = 0;
4557   mask |= INTVAL (operands[2]) << 0;
4558   mask |= INTVAL (operands[3]) << 2;
4559   mask |= INTVAL (operands[4]) << 4;
4560   mask |= INTVAL (operands[5]) << 6;
4561   operands[2] = GEN_INT (mask);
4562
4563   return "pshuflw\t{%2, %1, %0|%0, %1, %2}";
4564 }
4565   [(set_attr "type" "sselog")
4566    (set_attr "prefix_rep" "1")
4567    (set_attr "mode" "TI")])
4568
4569 (define_expand "sse2_pshufhw"
4570   [(match_operand:V8HI 0 "register_operand" "")
4571    (match_operand:V8HI 1 "nonimmediate_operand" "")
4572    (match_operand:SI 2 "const_int_operand" "")]
4573   "TARGET_SSE2"
4574 {
4575   int mask = INTVAL (operands[2]);
4576   emit_insn (gen_sse2_pshufhw_1 (operands[0], operands[1],
4577                                  GEN_INT (((mask >> 0) & 3) + 4),
4578                                  GEN_INT (((mask >> 2) & 3) + 4),
4579                                  GEN_INT (((mask >> 4) & 3) + 4),
4580                                  GEN_INT (((mask >> 6) & 3) + 4)));
4581   DONE;
4582 })
4583
4584 (define_insn "sse2_pshufhw_1"
4585   [(set (match_operand:V8HI 0 "register_operand" "=x")
4586         (vec_select:V8HI
4587           (match_operand:V8HI 1 "nonimmediate_operand" "xm")
4588           (parallel [(const_int 0)
4589                      (const_int 1)
4590                      (const_int 2)
4591                      (const_int 3)
4592                      (match_operand 2 "const_4_to_7_operand" "")
4593                      (match_operand 3 "const_4_to_7_operand" "")
4594                      (match_operand 4 "const_4_to_7_operand" "")
4595                      (match_operand 5 "const_4_to_7_operand" "")])))]
4596   "TARGET_SSE2"
4597 {
4598   int mask = 0;
4599   mask |= (INTVAL (operands[2]) - 4) << 0;
4600   mask |= (INTVAL (operands[3]) - 4) << 2;
4601   mask |= (INTVAL (operands[4]) - 4) << 4;
4602   mask |= (INTVAL (operands[5]) - 4) << 6;
4603   operands[2] = GEN_INT (mask);
4604
4605   return "pshufhw\t{%2, %1, %0|%0, %1, %2}";
4606 }
4607   [(set_attr "type" "sselog")
4608    (set_attr "prefix_rep" "1")
4609    (set_attr "mode" "TI")])
4610
4611 (define_expand "sse2_loadd"
4612   [(set (match_operand:V4SI 0 "register_operand" "")
4613         (vec_merge:V4SI
4614           (vec_duplicate:V4SI
4615             (match_operand:SI 1 "nonimmediate_operand" ""))
4616           (match_dup 2)
4617           (const_int 1)))]
4618   "TARGET_SSE"
4619   "operands[2] = CONST0_RTX (V4SImode);")
4620
4621 (define_insn "sse2_loadld"
4622   [(set (match_operand:V4SI 0 "register_operand"       "=Yt,Yi,x,x")
4623         (vec_merge:V4SI
4624           (vec_duplicate:V4SI
4625             (match_operand:SI 2 "nonimmediate_operand" "m  ,r ,m,x"))
4626           (match_operand:V4SI 1 "reg_or_0_operand"     "C  ,C ,C,0")
4627           (const_int 1)))]
4628   "TARGET_SSE"
4629   "@
4630    movd\t{%2, %0|%0, %2}
4631    movd\t{%2, %0|%0, %2}
4632    movss\t{%2, %0|%0, %2}
4633    movss\t{%2, %0|%0, %2}"
4634   [(set_attr "type" "ssemov")
4635    (set_attr "mode" "TI,TI,V4SF,SF")])
4636
4637 (define_insn_and_split "sse2_stored"
4638   [(set (match_operand:SI 0 "nonimmediate_operand" "=mx,r")
4639         (vec_select:SI
4640           (match_operand:V4SI 1 "register_operand" "x,Yi")
4641           (parallel [(const_int 0)])))]
4642   "TARGET_SSE"
4643   "#"
4644   "&& reload_completed
4645    && (TARGET_INTER_UNIT_MOVES
4646        || MEM_P (operands [0])
4647        || !GENERAL_REGNO_P (true_regnum (operands [0])))"
4648   [(set (match_dup 0) (match_dup 1))]
4649 {
4650   operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]));
4651 })
4652
4653 (define_insn_and_split "*vec_ext_v4si_mem"
4654   [(set (match_operand:SI 0 "register_operand" "=r")
4655         (vec_select:SI
4656           (match_operand:V4SI 1 "memory_operand" "o")
4657           (parallel [(match_operand 2 "const_0_to_3_operand" "")])))]
4658   ""
4659   "#"
4660   "reload_completed"
4661   [(const_int 0)]
4662 {
4663   int i = INTVAL (operands[2]);
4664
4665   emit_move_insn (operands[0], adjust_address (operands[1], SImode, i*4));
4666   DONE;
4667 })
4668
4669 (define_expand "sse_storeq"
4670   [(set (match_operand:DI 0 "nonimmediate_operand" "")
4671         (vec_select:DI
4672           (match_operand:V2DI 1 "register_operand" "")
4673           (parallel [(const_int 0)])))]
4674   "TARGET_SSE"
4675   "")
4676
4677 (define_insn "*sse2_storeq_rex64"
4678   [(set (match_operand:DI 0 "nonimmediate_operand" "=mx,r,r")
4679         (vec_select:DI
4680           (match_operand:V2DI 1 "nonimmediate_operand" "x,Yi,o")
4681           (parallel [(const_int 0)])))]
4682   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4683   "@
4684    #
4685    #
4686    mov{q}\t{%1, %0|%0, %1}"
4687   [(set_attr "type" "*,*,imov")
4688    (set_attr "mode" "*,*,DI")])
4689
4690 (define_insn "*sse2_storeq"
4691   [(set (match_operand:DI 0 "nonimmediate_operand" "=mx")
4692         (vec_select:DI
4693           (match_operand:V2DI 1 "register_operand" "x")
4694           (parallel [(const_int 0)])))]
4695   "TARGET_SSE"
4696   "#")
4697
4698 (define_split
4699   [(set (match_operand:DI 0 "nonimmediate_operand" "")
4700         (vec_select:DI
4701           (match_operand:V2DI 1 "register_operand" "")
4702           (parallel [(const_int 0)])))]
4703   "TARGET_SSE
4704    && reload_completed
4705    && (TARGET_INTER_UNIT_MOVES
4706        || MEM_P (operands [0])
4707        || !GENERAL_REGNO_P (true_regnum (operands [0])))"
4708   [(set (match_dup 0) (match_dup 1))]
4709 {
4710   operands[1] = gen_rtx_REG (DImode, REGNO (operands[1]));
4711 })
4712
4713 (define_insn "*vec_extractv2di_1_rex64"
4714   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x,r")
4715         (vec_select:DI
4716           (match_operand:V2DI 1 "nonimmediate_operand" "x,0,o,o")
4717           (parallel [(const_int 1)])))]
4718   "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4719   "@
4720    movhps\t{%1, %0|%0, %1}
4721    psrldq\t{$8, %0|%0, 8}
4722    movq\t{%H1, %0|%0, %H1}
4723    mov{q}\t{%H1, %0|%0, %H1}"
4724   [(set_attr "type" "ssemov,sseishft,ssemov,imov")
4725    (set_attr "memory" "*,none,*,*")
4726    (set_attr "mode" "V2SF,TI,TI,DI")])
4727
4728 (define_insn "*vec_extractv2di_1_sse2"
4729   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
4730         (vec_select:DI
4731           (match_operand:V2DI 1 "nonimmediate_operand" "x,0,o")
4732           (parallel [(const_int 1)])))]
4733   "!TARGET_64BIT
4734    && TARGET_SSE2 && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4735   "@
4736    movhps\t{%1, %0|%0, %1}
4737    psrldq\t{$8, %0|%0, 8}
4738    movq\t{%H1, %0|%0, %H1}"
4739   [(set_attr "type" "ssemov,sseishft,ssemov")
4740    (set_attr "memory" "*,none,*")
4741    (set_attr "mode" "V2SF,TI,TI")])
4742
4743 ;; Not sure this is ever used, but it doesn't hurt to have it. -aoliva
4744 (define_insn "*vec_extractv2di_1_sse"
4745   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,x,x")
4746         (vec_select:DI
4747           (match_operand:V2DI 1 "nonimmediate_operand" "x,x,o")
4748           (parallel [(const_int 1)])))]
4749   "!TARGET_SSE2 && TARGET_SSE
4750    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
4751   "@
4752    movhps\t{%1, %0|%0, %1}
4753    movhlps\t{%1, %0|%0, %1}
4754    movlps\t{%H1, %0|%0, %H1}"
4755   [(set_attr "type" "ssemov")
4756    (set_attr "mode" "V2SF,V4SF,V2SF")])
4757
4758 (define_insn "*vec_dupv4si"
4759   [(set (match_operand:V4SI 0 "register_operand" "=Yt,x")
4760         (vec_duplicate:V4SI
4761           (match_operand:SI 1 "register_operand" " Yt,0")))]
4762   "TARGET_SSE"
4763   "@
4764    pshufd\t{$0, %1, %0|%0, %1, 0}
4765    shufps\t{$0, %0, %0|%0, %0, 0}"
4766   [(set_attr "type" "sselog1")
4767    (set_attr "mode" "TI,V4SF")])
4768
4769 (define_insn "*vec_dupv2di"
4770   [(set (match_operand:V2DI 0 "register_operand" "=Yt,x")
4771         (vec_duplicate:V2DI
4772           (match_operand:DI 1 "register_operand" " 0 ,0")))]
4773   "TARGET_SSE"
4774   "@
4775    punpcklqdq\t%0, %0
4776    movlhps\t%0, %0"
4777   [(set_attr "type" "sselog1,ssemov")
4778    (set_attr "mode" "TI,V4SF")])
4779
4780 ;; ??? In theory we can match memory for the MMX alternative, but allowing
4781 ;; nonimmediate_operand for operand 2 and *not* allowing memory for the SSE
4782 ;; alternatives pretty much forces the MMX alternative to be chosen.
4783 (define_insn "*sse2_concatv2si"
4784   [(set (match_operand:V2SI 0 "register_operand"     "=Yt, Yt,*y,*y")
4785         (vec_concat:V2SI
4786           (match_operand:SI 1 "nonimmediate_operand" " 0 ,rm , 0,rm")
4787           (match_operand:SI 2 "reg_or_0_operand"     " Yt,C  ,*y, C")))]
4788   "TARGET_SSE2"
4789   "@
4790    punpckldq\t{%2, %0|%0, %2}
4791    movd\t{%1, %0|%0, %1}
4792    punpckldq\t{%2, %0|%0, %2}
4793    movd\t{%1, %0|%0, %1}"
4794   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
4795    (set_attr "mode" "TI,TI,DI,DI")])
4796
4797 (define_insn "*sse1_concatv2si"
4798   [(set (match_operand:V2SI 0 "register_operand"     "=x,x,*y,*y")
4799         (vec_concat:V2SI
4800           (match_operand:SI 1 "nonimmediate_operand" " 0,m, 0,*rm")
4801           (match_operand:SI 2 "reg_or_0_operand"     " x,C,*y,C")))]
4802   "TARGET_SSE"
4803   "@
4804    unpcklps\t{%2, %0|%0, %2}
4805    movss\t{%1, %0|%0, %1}
4806    punpckldq\t{%2, %0|%0, %2}
4807    movd\t{%1, %0|%0, %1}"
4808   [(set_attr "type" "sselog,ssemov,mmxcvt,mmxmov")
4809    (set_attr "mode" "V4SF,V4SF,DI,DI")])
4810
4811 (define_insn "*vec_concatv4si_1"
4812   [(set (match_operand:V4SI 0 "register_operand"       "=Yt,x,x")
4813         (vec_concat:V4SI
4814           (match_operand:V2SI 1 "register_operand"     " 0 ,0,0")
4815           (match_operand:V2SI 2 "nonimmediate_operand" " Yt,x,m")))]
4816   "TARGET_SSE"
4817   "@
4818    punpcklqdq\t{%2, %0|%0, %2}
4819    movlhps\t{%2, %0|%0, %2}
4820    movhps\t{%2, %0|%0, %2}"
4821   [(set_attr "type" "sselog,ssemov,ssemov")
4822    (set_attr "mode" "TI,V4SF,V2SF")])
4823
4824 (define_insn "vec_concatv2di"
4825   [(set (match_operand:V2DI 0 "register_operand"     "=Yt,?Yt,Yt,x,x,x")
4826         (vec_concat:V2DI
4827           (match_operand:DI 1 "nonimmediate_operand" "  m,*y ,0 ,0,0,m")
4828           (match_operand:DI 2 "vector_move_operand"  "  C,  C,Yt,x,m,0")))]
4829   "!TARGET_64BIT && TARGET_SSE"
4830   "@
4831    movq\t{%1, %0|%0, %1}
4832    movq2dq\t{%1, %0|%0, %1}
4833    punpcklqdq\t{%2, %0|%0, %2}
4834    movlhps\t{%2, %0|%0, %2}
4835    movhps\t{%2, %0|%0, %2}
4836    movlps\t{%1, %0|%0, %1}"
4837   [(set_attr "type" "ssemov,ssemov,sselog,ssemov,ssemov,ssemov")
4838    (set_attr "mode" "TI,TI,TI,V4SF,V2SF,V2SF")])
4839
4840 (define_insn "*vec_concatv2di_rex"
4841   [(set (match_operand:V2DI 0 "register_operand"     "=Yt,Yi,!Yt,Yt,x,x,x")
4842         (vec_concat:V2DI
4843           (match_operand:DI 1 "nonimmediate_operand" "  m,r ,*y ,0 ,0,0,m")
4844           (match_operand:DI 2 "vector_move_operand"  "  C,C ,C  ,Yt,x,m,0")))]
4845   "TARGET_64BIT"
4846   "@
4847    movq\t{%1, %0|%0, %1}
4848    movq\t{%1, %0|%0, %1}
4849    movq2dq\t{%1, %0|%0, %1}
4850    punpcklqdq\t{%2, %0|%0, %2}
4851    movlhps\t{%2, %0|%0, %2}
4852    movhps\t{%2, %0|%0, %2}
4853    movlps\t{%1, %0|%0, %1}"
4854   [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov,ssemov")
4855    (set_attr "mode" "TI,TI,TI,TI,V4SF,V2SF,V2SF")])
4856
4857 (define_expand "vec_setv2di"
4858   [(match_operand:V2DI 0 "register_operand" "")
4859    (match_operand:DI 1 "register_operand" "")
4860    (match_operand 2 "const_int_operand" "")]
4861   "TARGET_SSE"
4862 {
4863   ix86_expand_vector_set (false, operands[0], operands[1],
4864                           INTVAL (operands[2]));
4865   DONE;
4866 })
4867
4868 (define_expand "vec_extractv2di"
4869   [(match_operand:DI 0 "register_operand" "")
4870    (match_operand:V2DI 1 "register_operand" "")
4871    (match_operand 2 "const_int_operand" "")]
4872   "TARGET_SSE"
4873 {
4874   ix86_expand_vector_extract (false, operands[0], operands[1],
4875                               INTVAL (operands[2]));
4876   DONE;
4877 })
4878
4879 (define_expand "vec_initv2di"
4880   [(match_operand:V2DI 0 "register_operand" "")
4881    (match_operand 1 "" "")]
4882   "TARGET_SSE"
4883 {
4884   ix86_expand_vector_init (false, operands[0], operands[1]);
4885   DONE;
4886 })
4887
4888 (define_expand "vec_setv4si"
4889   [(match_operand:V4SI 0 "register_operand" "")
4890    (match_operand:SI 1 "register_operand" "")
4891    (match_operand 2 "const_int_operand" "")]
4892   "TARGET_SSE"
4893 {
4894   ix86_expand_vector_set (false, operands[0], operands[1],
4895                           INTVAL (operands[2]));
4896   DONE;
4897 })
4898
4899 (define_expand "vec_extractv4si"
4900   [(match_operand:SI 0 "register_operand" "")
4901    (match_operand:V4SI 1 "register_operand" "")
4902    (match_operand 2 "const_int_operand" "")]
4903   "TARGET_SSE"
4904 {
4905   ix86_expand_vector_extract (false, operands[0], operands[1],
4906                               INTVAL (operands[2]));
4907   DONE;
4908 })
4909
4910 (define_expand "vec_initv4si"
4911   [(match_operand:V4SI 0 "register_operand" "")
4912    (match_operand 1 "" "")]
4913   "TARGET_SSE"
4914 {
4915   ix86_expand_vector_init (false, operands[0], operands[1]);
4916   DONE;
4917 })
4918
4919 (define_expand "vec_setv8hi"
4920   [(match_operand:V8HI 0 "register_operand" "")
4921    (match_operand:HI 1 "register_operand" "")
4922    (match_operand 2 "const_int_operand" "")]
4923   "TARGET_SSE"
4924 {
4925   ix86_expand_vector_set (false, operands[0], operands[1],
4926                           INTVAL (operands[2]));
4927   DONE;
4928 })
4929
4930 (define_expand "vec_extractv8hi"
4931   [(match_operand:HI 0 "register_operand" "")
4932    (match_operand:V8HI 1 "register_operand" "")
4933    (match_operand 2 "const_int_operand" "")]
4934   "TARGET_SSE"
4935 {
4936   ix86_expand_vector_extract (false, operands[0], operands[1],
4937                               INTVAL (operands[2]));
4938   DONE;
4939 })
4940
4941 (define_expand "vec_initv8hi"
4942   [(match_operand:V8HI 0 "register_operand" "")
4943    (match_operand 1 "" "")]
4944   "TARGET_SSE"
4945 {
4946   ix86_expand_vector_init (false, operands[0], operands[1]);
4947   DONE;
4948 })
4949
4950 (define_expand "vec_setv16qi"
4951   [(match_operand:V16QI 0 "register_operand" "")
4952    (match_operand:QI 1 "register_operand" "")
4953    (match_operand 2 "const_int_operand" "")]
4954   "TARGET_SSE"
4955 {
4956   ix86_expand_vector_set (false, operands[0], operands[1],
4957                           INTVAL (operands[2]));
4958   DONE;
4959 })
4960
4961 (define_expand "vec_extractv16qi"
4962   [(match_operand:QI 0 "register_operand" "")
4963    (match_operand:V16QI 1 "register_operand" "")
4964    (match_operand 2 "const_int_operand" "")]
4965   "TARGET_SSE"
4966 {
4967   ix86_expand_vector_extract (false, operands[0], operands[1],
4968                               INTVAL (operands[2]));
4969   DONE;
4970 })
4971
4972 (define_expand "vec_initv16qi"
4973   [(match_operand:V16QI 0 "register_operand" "")
4974    (match_operand 1 "" "")]
4975   "TARGET_SSE"
4976 {
4977   ix86_expand_vector_init (false, operands[0], operands[1]);
4978   DONE;
4979 })
4980
4981 (define_expand "vec_unpacku_hi_v16qi"
4982   [(match_operand:V8HI 0 "register_operand" "")
4983    (match_operand:V16QI 1 "register_operand" "")]
4984   "TARGET_SSE2"
4985 {
4986   if (TARGET_SSE4_1)
4987     ix86_expand_sse4_unpack (operands, true, true);
4988   else
4989     ix86_expand_sse_unpack (operands, true, true);
4990   DONE;
4991 })
4992
4993 (define_expand "vec_unpacks_hi_v16qi"
4994   [(match_operand:V8HI 0 "register_operand" "")
4995    (match_operand:V16QI 1 "register_operand" "")]
4996   "TARGET_SSE2"
4997 {
4998   if (TARGET_SSE4_1)
4999     ix86_expand_sse4_unpack (operands, false, true);
5000   else
5001     ix86_expand_sse_unpack (operands, false, true);
5002   DONE;
5003 })
5004
5005 (define_expand "vec_unpacku_lo_v16qi"
5006   [(match_operand:V8HI 0 "register_operand" "")
5007    (match_operand:V16QI 1 "register_operand" "")]
5008   "TARGET_SSE2"
5009 {
5010   if (TARGET_SSE4_1)
5011     ix86_expand_sse4_unpack (operands, true, false);
5012   else
5013     ix86_expand_sse_unpack (operands, true, false);
5014   DONE;
5015 })
5016
5017 (define_expand "vec_unpacks_lo_v16qi"
5018   [(match_operand:V8HI 0 "register_operand" "")
5019    (match_operand:V16QI 1 "register_operand" "")]
5020   "TARGET_SSE2"
5021 {
5022   if (TARGET_SSE4_1)
5023     ix86_expand_sse4_unpack (operands, false, false);
5024   else
5025     ix86_expand_sse_unpack (operands, false, false);
5026   DONE;
5027 })
5028
5029 (define_expand "vec_unpacku_hi_v8hi"
5030   [(match_operand:V4SI 0 "register_operand" "")
5031    (match_operand:V8HI 1 "register_operand" "")]
5032   "TARGET_SSE2"
5033 {
5034   if (TARGET_SSE4_1)
5035     ix86_expand_sse4_unpack (operands, true, true);
5036   else
5037     ix86_expand_sse_unpack (operands, true, true);
5038   DONE;
5039 })
5040
5041 (define_expand "vec_unpacks_hi_v8hi"
5042   [(match_operand:V4SI 0 "register_operand" "")
5043    (match_operand:V8HI 1 "register_operand" "")]
5044   "TARGET_SSE2"
5045 {
5046   if (TARGET_SSE4_1)
5047     ix86_expand_sse4_unpack (operands, false, true);
5048   else
5049     ix86_expand_sse_unpack (operands, false, true);
5050   DONE;
5051 })
5052
5053 (define_expand "vec_unpacku_lo_v8hi"
5054   [(match_operand:V4SI 0 "register_operand" "")
5055    (match_operand:V8HI 1 "register_operand" "")]
5056   "TARGET_SSE2"
5057 {
5058   if (TARGET_SSE4_1)
5059     ix86_expand_sse4_unpack (operands, true, false);
5060   else
5061     ix86_expand_sse_unpack (operands, true, false);
5062   DONE;
5063 })
5064
5065 (define_expand "vec_unpacks_lo_v8hi"
5066   [(match_operand:V4SI 0 "register_operand" "")
5067    (match_operand:V8HI 1 "register_operand" "")]
5068   "TARGET_SSE2"
5069 {
5070   if (TARGET_SSE4_1)
5071     ix86_expand_sse4_unpack (operands, false, false);
5072   else
5073     ix86_expand_sse_unpack (operands, false, false);
5074   DONE;
5075 })
5076
5077 (define_expand "vec_unpacku_hi_v4si"
5078   [(match_operand:V2DI 0 "register_operand" "")
5079    (match_operand:V4SI 1 "register_operand" "")]
5080   "TARGET_SSE2"
5081 {
5082   if (TARGET_SSE4_1)
5083     ix86_expand_sse4_unpack (operands, true, true);
5084   else
5085     ix86_expand_sse_unpack (operands, true, true);
5086   DONE;
5087 })
5088
5089 (define_expand "vec_unpacks_hi_v4si"
5090   [(match_operand:V2DI 0 "register_operand" "")
5091    (match_operand:V4SI 1 "register_operand" "")]
5092   "TARGET_SSE2"
5093 {
5094   if (TARGET_SSE4_1)
5095     ix86_expand_sse4_unpack (operands, false, true);
5096   else
5097     ix86_expand_sse_unpack (operands, false, true);
5098   DONE;
5099 })
5100
5101 (define_expand "vec_unpacku_lo_v4si"
5102   [(match_operand:V2DI 0 "register_operand" "")
5103    (match_operand:V4SI 1 "register_operand" "")]
5104   "TARGET_SSE2"
5105 {
5106   if (TARGET_SSE4_1)
5107     ix86_expand_sse4_unpack (operands, true, false);
5108   else
5109     ix86_expand_sse_unpack (operands, true, false);
5110   DONE;
5111 })
5112
5113 (define_expand "vec_unpacks_lo_v4si"
5114   [(match_operand:V2DI 0 "register_operand" "")
5115    (match_operand:V4SI 1 "register_operand" "")]
5116   "TARGET_SSE2"
5117 {
5118   if (TARGET_SSE4_1)
5119     ix86_expand_sse4_unpack (operands, false, false);
5120   else
5121     ix86_expand_sse_unpack (operands, false, false);
5122   DONE;
5123 })
5124
5125 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5126 ;;
5127 ;; Miscellaneous
5128 ;;
5129 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5130
5131 (define_insn "sse2_uavgv16qi3"
5132   [(set (match_operand:V16QI 0 "register_operand" "=x")
5133         (truncate:V16QI
5134           (lshiftrt:V16HI
5135             (plus:V16HI
5136               (plus:V16HI
5137                 (zero_extend:V16HI
5138                   (match_operand:V16QI 1 "nonimmediate_operand" "%0"))
5139                 (zero_extend:V16HI
5140                   (match_operand:V16QI 2 "nonimmediate_operand" "xm")))
5141               (const_vector:V16QI [(const_int 1) (const_int 1)
5142                                    (const_int 1) (const_int 1)
5143                                    (const_int 1) (const_int 1)
5144                                    (const_int 1) (const_int 1)
5145                                    (const_int 1) (const_int 1)
5146                                    (const_int 1) (const_int 1)
5147                                    (const_int 1) (const_int 1)
5148                                    (const_int 1) (const_int 1)]))
5149             (const_int 1))))]
5150   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V16QImode, operands)"
5151   "pavgb\t{%2, %0|%0, %2}"
5152   [(set_attr "type" "sseiadd")
5153    (set_attr "prefix_data16" "1")
5154    (set_attr "mode" "TI")])
5155
5156 (define_insn "sse2_uavgv8hi3"
5157   [(set (match_operand:V8HI 0 "register_operand" "=x")
5158         (truncate:V8HI
5159           (lshiftrt:V8SI
5160             (plus:V8SI
5161               (plus:V8SI
5162                 (zero_extend:V8SI
5163                   (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
5164                 (zero_extend:V8SI
5165                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
5166               (const_vector:V8HI [(const_int 1) (const_int 1)
5167                                   (const_int 1) (const_int 1)
5168                                   (const_int 1) (const_int 1)
5169                                   (const_int 1) (const_int 1)]))
5170             (const_int 1))))]
5171   "TARGET_SSE2 && ix86_binary_operator_ok (PLUS, V8HImode, operands)"
5172   "pavgw\t{%2, %0|%0, %2}"
5173   [(set_attr "type" "sseiadd")
5174    (set_attr "prefix_data16" "1")
5175    (set_attr "mode" "TI")])
5176
5177 ;; The correct representation for this is absolutely enormous, and
5178 ;; surely not generally useful.
5179 (define_insn "sse2_psadbw"
5180   [(set (match_operand:V2DI 0 "register_operand" "=x")
5181         (unspec:V2DI [(match_operand:V16QI 1 "register_operand" "0")
5182                       (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
5183                      UNSPEC_PSADBW))]
5184   "TARGET_SSE2"
5185   "psadbw\t{%2, %0|%0, %2}"
5186   [(set_attr "type" "sseiadd")
5187    (set_attr "prefix_data16" "1")
5188    (set_attr "mode" "TI")])
5189
5190 (define_insn "sse_movmskps"
5191   [(set (match_operand:SI 0 "register_operand" "=r")
5192         (unspec:SI [(match_operand:V4SF 1 "register_operand" "x")]
5193                    UNSPEC_MOVMSK))]
5194   "TARGET_SSE"
5195   "movmskps\t{%1, %0|%0, %1}"
5196   [(set_attr "type" "ssecvt")
5197    (set_attr "mode" "V4SF")])
5198
5199 (define_insn "sse2_movmskpd"
5200   [(set (match_operand:SI 0 "register_operand" "=r")
5201         (unspec:SI [(match_operand:V2DF 1 "register_operand" "x")]
5202                    UNSPEC_MOVMSK))]
5203   "TARGET_SSE2"
5204   "movmskpd\t{%1, %0|%0, %1}"
5205   [(set_attr "type" "ssecvt")
5206    (set_attr "mode" "V2DF")])
5207
5208 (define_insn "sse2_pmovmskb"
5209   [(set (match_operand:SI 0 "register_operand" "=r")
5210         (unspec:SI [(match_operand:V16QI 1 "register_operand" "x")]
5211                    UNSPEC_MOVMSK))]
5212   "TARGET_SSE2"
5213   "pmovmskb\t{%1, %0|%0, %1}"
5214   [(set_attr "type" "ssecvt")
5215    (set_attr "prefix_data16" "1")
5216    (set_attr "mode" "SI")])
5217
5218 (define_expand "sse2_maskmovdqu"
5219   [(set (match_operand:V16QI 0 "memory_operand" "")
5220         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
5221                        (match_operand:V16QI 2 "register_operand" "x")
5222                        (match_dup 0)]
5223                       UNSPEC_MASKMOV))]
5224   "TARGET_SSE2"
5225   "")
5226
5227 (define_insn "*sse2_maskmovdqu"
5228   [(set (mem:V16QI (match_operand:SI 0 "register_operand" "D"))
5229         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
5230                        (match_operand:V16QI 2 "register_operand" "x")
5231                        (mem:V16QI (match_dup 0))]
5232                       UNSPEC_MASKMOV))]
5233   "TARGET_SSE2 && !TARGET_64BIT"
5234   ;; @@@ check ordering of operands in intel/nonintel syntax
5235   "maskmovdqu\t{%2, %1|%1, %2}"
5236   [(set_attr "type" "ssecvt")
5237    (set_attr "prefix_data16" "1")
5238    (set_attr "mode" "TI")])
5239
5240 (define_insn "*sse2_maskmovdqu_rex64"
5241   [(set (mem:V16QI (match_operand:DI 0 "register_operand" "D"))
5242         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "x")
5243                        (match_operand:V16QI 2 "register_operand" "x")
5244                        (mem:V16QI (match_dup 0))]
5245                       UNSPEC_MASKMOV))]
5246   "TARGET_SSE2 && TARGET_64BIT"
5247   ;; @@@ check ordering of operands in intel/nonintel syntax
5248   "maskmovdqu\t{%2, %1|%1, %2}"
5249   [(set_attr "type" "ssecvt")
5250    (set_attr "prefix_data16" "1")
5251    (set_attr "mode" "TI")])
5252
5253 (define_insn "sse_ldmxcsr"
5254   [(unspec_volatile [(match_operand:SI 0 "memory_operand" "m")]
5255                     UNSPECV_LDMXCSR)]
5256   "TARGET_SSE"
5257   "ldmxcsr\t%0"
5258   [(set_attr "type" "sse")
5259    (set_attr "memory" "load")])
5260
5261 (define_insn "sse_stmxcsr"
5262   [(set (match_operand:SI 0 "memory_operand" "=m")
5263         (unspec_volatile:SI [(const_int 0)] UNSPECV_STMXCSR))]
5264   "TARGET_SSE"
5265   "stmxcsr\t%0"
5266   [(set_attr "type" "sse")
5267    (set_attr "memory" "store")])
5268
5269 (define_expand "sse_sfence"
5270   [(set (match_dup 0)
5271         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
5272   "TARGET_SSE || TARGET_3DNOW_A"
5273 {
5274   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
5275   MEM_VOLATILE_P (operands[0]) = 1;
5276 })
5277
5278 (define_insn "*sse_sfence"
5279   [(set (match_operand:BLK 0 "" "")
5280         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
5281   "TARGET_SSE || TARGET_3DNOW_A"
5282   "sfence"
5283   [(set_attr "type" "sse")
5284    (set_attr "memory" "unknown")])
5285
5286 (define_insn "sse2_clflush"
5287   [(unspec_volatile [(match_operand 0 "address_operand" "p")]
5288                     UNSPECV_CLFLUSH)]
5289   "TARGET_SSE2"
5290   "clflush\t%a0"
5291   [(set_attr "type" "sse")
5292    (set_attr "memory" "unknown")])
5293
5294 (define_expand "sse2_mfence"
5295   [(set (match_dup 0)
5296         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
5297   "TARGET_SSE2"
5298 {
5299   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
5300   MEM_VOLATILE_P (operands[0]) = 1;
5301 })
5302
5303 (define_insn "*sse2_mfence"
5304   [(set (match_operand:BLK 0 "" "")
5305         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
5306   "TARGET_SSE2"
5307   "mfence"
5308   [(set_attr "type" "sse")
5309    (set_attr "memory" "unknown")])
5310
5311 (define_expand "sse2_lfence"
5312   [(set (match_dup 0)
5313         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
5314   "TARGET_SSE2"
5315 {
5316   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
5317   MEM_VOLATILE_P (operands[0]) = 1;
5318 })
5319
5320 (define_insn "*sse2_lfence"
5321   [(set (match_operand:BLK 0 "" "")
5322         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
5323   "TARGET_SSE2"
5324   "lfence"
5325   [(set_attr "type" "sse")
5326    (set_attr "memory" "unknown")])
5327
5328 (define_insn "sse3_mwait"
5329   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
5330                      (match_operand:SI 1 "register_operand" "c")]
5331                     UNSPECV_MWAIT)]
5332   "TARGET_SSE3"
5333 ;; 64bit version is "mwait %rax,%rcx". But only lower 32bits are used.
5334 ;; Since 32bit register operands are implicitly zero extended to 64bit,
5335 ;; we only need to set up 32bit registers.
5336   "mwait"
5337   [(set_attr "length" "3")])
5338
5339 (define_insn "sse3_monitor"
5340   [(unspec_volatile [(match_operand:SI 0 "register_operand" "a")
5341                      (match_operand:SI 1 "register_operand" "c")
5342                      (match_operand:SI 2 "register_operand" "d")]
5343                     UNSPECV_MONITOR)]
5344   "TARGET_SSE3 && !TARGET_64BIT"
5345   "monitor\t%0, %1, %2"
5346   [(set_attr "length" "3")])
5347
5348 (define_insn "sse3_monitor64"
5349   [(unspec_volatile [(match_operand:DI 0 "register_operand" "a")
5350                      (match_operand:SI 1 "register_operand" "c")
5351                      (match_operand:SI 2 "register_operand" "d")]
5352                     UNSPECV_MONITOR)]
5353   "TARGET_SSE3 && TARGET_64BIT"
5354 ;; 64bit version is "monitor %rax,%rcx,%rdx". But only lower 32bits in
5355 ;; RCX and RDX are used.  Since 32bit register operands are implicitly
5356 ;; zero extended to 64bit, we only need to set up 32bit registers.
5357   "monitor"
5358   [(set_attr "length" "3")])
5359
5360 ;; SSSE3
5361 (define_insn "ssse3_phaddwv8hi3"
5362   [(set (match_operand:V8HI 0 "register_operand" "=x")
5363         (vec_concat:V8HI
5364           (vec_concat:V4HI
5365             (vec_concat:V2HI
5366               (plus:HI
5367                 (vec_select:HI
5368                   (match_operand:V8HI 1 "register_operand" "0")
5369                   (parallel [(const_int 0)]))
5370                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
5371               (plus:HI
5372                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
5373                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
5374             (vec_concat:V2HI
5375               (plus:HI
5376                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
5377                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
5378               (plus:HI
5379                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
5380                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
5381           (vec_concat:V4HI
5382             (vec_concat:V2HI
5383               (plus:HI
5384                 (vec_select:HI
5385                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5386                   (parallel [(const_int 0)]))
5387                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
5388               (plus:HI
5389                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
5390                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
5391             (vec_concat:V2HI
5392               (plus:HI
5393                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
5394                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
5395               (plus:HI
5396                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
5397                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
5398   "TARGET_SSSE3"
5399   "phaddw\t{%2, %0|%0, %2}"
5400   [(set_attr "type" "sseiadd")
5401    (set_attr "prefix_data16" "1")
5402    (set_attr "prefix_extra" "1")
5403    (set_attr "mode" "TI")])
5404
5405 (define_insn "ssse3_phaddwv4hi3"
5406   [(set (match_operand:V4HI 0 "register_operand" "=y")
5407         (vec_concat:V4HI
5408           (vec_concat:V2HI
5409             (plus:HI
5410               (vec_select:HI
5411                 (match_operand:V4HI 1 "register_operand" "0")
5412                 (parallel [(const_int 0)]))
5413               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
5414             (plus:HI
5415               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
5416               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
5417           (vec_concat:V2HI
5418             (plus:HI
5419               (vec_select:HI
5420                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
5421                 (parallel [(const_int 0)]))
5422               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
5423             (plus:HI
5424               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
5425               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
5426   "TARGET_SSSE3"
5427   "phaddw\t{%2, %0|%0, %2}"
5428   [(set_attr "type" "sseiadd")
5429    (set_attr "prefix_extra" "1")
5430    (set_attr "mode" "DI")])
5431
5432 (define_insn "ssse3_phadddv4si3"
5433   [(set (match_operand:V4SI 0 "register_operand" "=x")
5434         (vec_concat:V4SI
5435           (vec_concat:V2SI
5436             (plus:SI
5437               (vec_select:SI
5438                 (match_operand:V4SI 1 "register_operand" "0")
5439                 (parallel [(const_int 0)]))
5440               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
5441             (plus:SI
5442               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
5443               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
5444           (vec_concat:V2SI
5445             (plus:SI
5446               (vec_select:SI
5447                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5448                 (parallel [(const_int 0)]))
5449               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
5450             (plus:SI
5451               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
5452               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
5453   "TARGET_SSSE3"
5454   "phaddd\t{%2, %0|%0, %2}"
5455   [(set_attr "type" "sseiadd")
5456    (set_attr "prefix_data16" "1")
5457    (set_attr "prefix_extra" "1")
5458    (set_attr "mode" "TI")])
5459
5460 (define_insn "ssse3_phadddv2si3"
5461   [(set (match_operand:V2SI 0 "register_operand" "=y")
5462         (vec_concat:V2SI
5463           (plus:SI
5464             (vec_select:SI
5465               (match_operand:V2SI 1 "register_operand" "0")
5466               (parallel [(const_int 0)]))
5467             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
5468           (plus:SI
5469             (vec_select:SI
5470               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
5471               (parallel [(const_int 0)]))
5472             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
5473   "TARGET_SSSE3"
5474   "phaddd\t{%2, %0|%0, %2}"
5475   [(set_attr "type" "sseiadd")
5476    (set_attr "prefix_extra" "1")
5477    (set_attr "mode" "DI")])
5478
5479 (define_insn "ssse3_phaddswv8hi3"
5480   [(set (match_operand:V8HI 0 "register_operand" "=x")
5481         (vec_concat:V8HI
5482           (vec_concat:V4HI
5483             (vec_concat:V2HI
5484               (ss_plus:HI
5485                 (vec_select:HI
5486                   (match_operand:V8HI 1 "register_operand" "0")
5487                   (parallel [(const_int 0)]))
5488                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
5489               (ss_plus:HI
5490                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
5491                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
5492             (vec_concat:V2HI
5493               (ss_plus:HI
5494                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
5495                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
5496               (ss_plus:HI
5497                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
5498                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
5499           (vec_concat:V4HI
5500             (vec_concat:V2HI
5501               (ss_plus:HI
5502                 (vec_select:HI
5503                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5504                   (parallel [(const_int 0)]))
5505                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
5506               (ss_plus:HI
5507                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
5508                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
5509             (vec_concat:V2HI
5510               (ss_plus:HI
5511                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
5512                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
5513               (ss_plus:HI
5514                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
5515                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
5516   "TARGET_SSSE3"
5517   "phaddsw\t{%2, %0|%0, %2}"
5518   [(set_attr "type" "sseiadd")
5519    (set_attr "prefix_data16" "1")
5520    (set_attr "prefix_extra" "1")
5521    (set_attr "mode" "TI")])
5522
5523 (define_insn "ssse3_phaddswv4hi3"
5524   [(set (match_operand:V4HI 0 "register_operand" "=y")
5525         (vec_concat:V4HI
5526           (vec_concat:V2HI
5527             (ss_plus:HI
5528               (vec_select:HI
5529                 (match_operand:V4HI 1 "register_operand" "0")
5530                 (parallel [(const_int 0)]))
5531               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
5532             (ss_plus:HI
5533               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
5534               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
5535           (vec_concat:V2HI
5536             (ss_plus:HI
5537               (vec_select:HI
5538                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
5539                 (parallel [(const_int 0)]))
5540               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
5541             (ss_plus:HI
5542               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
5543               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
5544   "TARGET_SSSE3"
5545   "phaddsw\t{%2, %0|%0, %2}"
5546   [(set_attr "type" "sseiadd")
5547    (set_attr "prefix_extra" "1")
5548    (set_attr "mode" "DI")])
5549
5550 (define_insn "ssse3_phsubwv8hi3"
5551   [(set (match_operand:V8HI 0 "register_operand" "=x")
5552         (vec_concat:V8HI
5553           (vec_concat:V4HI
5554             (vec_concat:V2HI
5555               (minus:HI
5556                 (vec_select:HI
5557                   (match_operand:V8HI 1 "register_operand" "0")
5558                   (parallel [(const_int 0)]))
5559                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
5560               (minus:HI
5561                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
5562                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
5563             (vec_concat:V2HI
5564               (minus:HI
5565                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
5566                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
5567               (minus:HI
5568                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
5569                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
5570           (vec_concat:V4HI
5571             (vec_concat:V2HI
5572               (minus:HI
5573                 (vec_select:HI
5574                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5575                   (parallel [(const_int 0)]))
5576                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
5577               (minus:HI
5578                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
5579                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
5580             (vec_concat:V2HI
5581               (minus:HI
5582                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
5583                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
5584               (minus:HI
5585                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
5586                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
5587   "TARGET_SSSE3"
5588   "phsubw\t{%2, %0|%0, %2}"
5589   [(set_attr "type" "sseiadd")
5590    (set_attr "prefix_data16" "1")
5591    (set_attr "prefix_extra" "1")
5592    (set_attr "mode" "TI")])
5593
5594 (define_insn "ssse3_phsubwv4hi3"
5595   [(set (match_operand:V4HI 0 "register_operand" "=y")
5596         (vec_concat:V4HI
5597           (vec_concat:V2HI
5598             (minus:HI
5599               (vec_select:HI
5600                 (match_operand:V4HI 1 "register_operand" "0")
5601                 (parallel [(const_int 0)]))
5602               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
5603             (minus:HI
5604               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
5605               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
5606           (vec_concat:V2HI
5607             (minus:HI
5608               (vec_select:HI
5609                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
5610                 (parallel [(const_int 0)]))
5611               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
5612             (minus:HI
5613               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
5614               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
5615   "TARGET_SSSE3"
5616   "phsubw\t{%2, %0|%0, %2}"
5617   [(set_attr "type" "sseiadd")
5618    (set_attr "prefix_extra" "1")
5619    (set_attr "mode" "DI")])
5620
5621 (define_insn "ssse3_phsubdv4si3"
5622   [(set (match_operand:V4SI 0 "register_operand" "=x")
5623         (vec_concat:V4SI
5624           (vec_concat:V2SI
5625             (minus:SI
5626               (vec_select:SI
5627                 (match_operand:V4SI 1 "register_operand" "0")
5628                 (parallel [(const_int 0)]))
5629               (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
5630             (minus:SI
5631               (vec_select:SI (match_dup 1) (parallel [(const_int 2)]))
5632               (vec_select:SI (match_dup 1) (parallel [(const_int 3)]))))
5633           (vec_concat:V2SI
5634             (minus:SI
5635               (vec_select:SI
5636                 (match_operand:V4SI 2 "nonimmediate_operand" "xm")
5637                 (parallel [(const_int 0)]))
5638               (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))
5639             (minus:SI
5640               (vec_select:SI (match_dup 2) (parallel [(const_int 2)]))
5641               (vec_select:SI (match_dup 2) (parallel [(const_int 3)]))))))]
5642   "TARGET_SSSE3"
5643   "phsubd\t{%2, %0|%0, %2}"
5644   [(set_attr "type" "sseiadd")
5645    (set_attr "prefix_data16" "1")
5646    (set_attr "prefix_extra" "1")
5647    (set_attr "mode" "TI")])
5648
5649 (define_insn "ssse3_phsubdv2si3"
5650   [(set (match_operand:V2SI 0 "register_operand" "=y")
5651         (vec_concat:V2SI
5652           (minus:SI
5653             (vec_select:SI
5654               (match_operand:V2SI 1 "register_operand" "0")
5655               (parallel [(const_int 0)]))
5656             (vec_select:SI (match_dup 1) (parallel [(const_int 1)])))
5657           (minus:SI
5658             (vec_select:SI
5659               (match_operand:V2SI 2 "nonimmediate_operand" "ym")
5660               (parallel [(const_int 0)]))
5661             (vec_select:SI (match_dup 2) (parallel [(const_int 1)])))))]
5662   "TARGET_SSSE3"
5663   "phsubd\t{%2, %0|%0, %2}"
5664   [(set_attr "type" "sseiadd")
5665    (set_attr "prefix_extra" "1")
5666    (set_attr "mode" "DI")])
5667
5668 (define_insn "ssse3_phsubswv8hi3"
5669   [(set (match_operand:V8HI 0 "register_operand" "=x")
5670         (vec_concat:V8HI
5671           (vec_concat:V4HI
5672             (vec_concat:V2HI
5673               (ss_minus:HI
5674                 (vec_select:HI
5675                   (match_operand:V8HI 1 "register_operand" "0")
5676                   (parallel [(const_int 0)]))
5677                 (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
5678               (ss_minus:HI
5679                 (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
5680                 (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
5681             (vec_concat:V2HI
5682               (ss_minus:HI
5683                 (vec_select:HI (match_dup 1) (parallel [(const_int 4)]))
5684                 (vec_select:HI (match_dup 1) (parallel [(const_int 5)])))
5685               (ss_minus:HI
5686                 (vec_select:HI (match_dup 1) (parallel [(const_int 6)]))
5687                 (vec_select:HI (match_dup 1) (parallel [(const_int 7)])))))
5688           (vec_concat:V4HI
5689             (vec_concat:V2HI
5690               (ss_minus:HI
5691                 (vec_select:HI
5692                   (match_operand:V8HI 2 "nonimmediate_operand" "xm")
5693                   (parallel [(const_int 0)]))
5694                 (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
5695               (ss_minus:HI
5696                 (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
5697                 (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))
5698             (vec_concat:V2HI
5699               (ss_minus:HI
5700                 (vec_select:HI (match_dup 2) (parallel [(const_int 4)]))
5701                 (vec_select:HI (match_dup 2) (parallel [(const_int 5)])))
5702               (ss_minus:HI
5703                 (vec_select:HI (match_dup 2) (parallel [(const_int 6)]))
5704                 (vec_select:HI (match_dup 2) (parallel [(const_int 7)])))))))]
5705   "TARGET_SSSE3"
5706   "phsubsw\t{%2, %0|%0, %2}"
5707   [(set_attr "type" "sseiadd")
5708    (set_attr "prefix_data16" "1")
5709    (set_attr "prefix_extra" "1")
5710    (set_attr "mode" "TI")])
5711
5712 (define_insn "ssse3_phsubswv4hi3"
5713   [(set (match_operand:V4HI 0 "register_operand" "=y")
5714         (vec_concat:V4HI
5715           (vec_concat:V2HI
5716             (ss_minus:HI
5717               (vec_select:HI
5718                 (match_operand:V4HI 1 "register_operand" "0")
5719                 (parallel [(const_int 0)]))
5720               (vec_select:HI (match_dup 1) (parallel [(const_int 1)])))
5721             (ss_minus:HI
5722               (vec_select:HI (match_dup 1) (parallel [(const_int 2)]))
5723               (vec_select:HI (match_dup 1) (parallel [(const_int 3)]))))
5724           (vec_concat:V2HI
5725             (ss_minus:HI
5726               (vec_select:HI
5727                 (match_operand:V4HI 2 "nonimmediate_operand" "ym")
5728                 (parallel [(const_int 0)]))
5729               (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))
5730             (ss_minus:HI
5731               (vec_select:HI (match_dup 2) (parallel [(const_int 2)]))
5732               (vec_select:HI (match_dup 2) (parallel [(const_int 3)]))))))]
5733   "TARGET_SSSE3"
5734   "phsubsw\t{%2, %0|%0, %2}"
5735   [(set_attr "type" "sseiadd")
5736    (set_attr "prefix_extra" "1")
5737    (set_attr "mode" "DI")])
5738
5739 (define_insn "ssse3_pmaddubswv8hi3"
5740   [(set (match_operand:V8HI 0 "register_operand" "=x")
5741         (ss_plus:V8HI
5742           (mult:V8HI
5743             (zero_extend:V8HI
5744               (vec_select:V4QI
5745                 (match_operand:V16QI 1 "nonimmediate_operand" "%0")
5746                 (parallel [(const_int 0)
5747                            (const_int 2)
5748                            (const_int 4)
5749                            (const_int 6)
5750                            (const_int 8)
5751                            (const_int 10)
5752                            (const_int 12)
5753                            (const_int 14)])))
5754             (sign_extend:V8HI
5755               (vec_select:V8QI
5756                 (match_operand:V16QI 2 "nonimmediate_operand" "xm")
5757                 (parallel [(const_int 0)
5758                            (const_int 2)
5759                            (const_int 4)
5760                            (const_int 6)
5761                            (const_int 8)
5762                            (const_int 10)
5763                            (const_int 12)
5764                            (const_int 14)]))))
5765           (mult:V8HI
5766             (zero_extend:V8HI
5767               (vec_select:V16QI (match_dup 1)
5768                 (parallel [(const_int 1)
5769                            (const_int 3)
5770                            (const_int 5)
5771                            (const_int 7)
5772                            (const_int 9)
5773                            (const_int 11)
5774                            (const_int 13)
5775                            (const_int 15)])))
5776             (sign_extend:V8HI
5777               (vec_select:V16QI (match_dup 2)
5778                 (parallel [(const_int 1)
5779                            (const_int 3)
5780                            (const_int 5)
5781                            (const_int 7)
5782                            (const_int 9)
5783                            (const_int 11)
5784                            (const_int 13)
5785                            (const_int 15)]))))))]
5786   "TARGET_SSSE3"
5787   "pmaddubsw\t{%2, %0|%0, %2}"
5788   [(set_attr "type" "sseiadd")
5789    (set_attr "prefix_data16" "1")
5790    (set_attr "prefix_extra" "1")
5791    (set_attr "mode" "TI")])
5792
5793 (define_insn "ssse3_pmaddubswv4hi3"
5794   [(set (match_operand:V4HI 0 "register_operand" "=y")
5795         (ss_plus:V4HI
5796           (mult:V4HI
5797             (zero_extend:V4HI
5798               (vec_select:V4QI
5799                 (match_operand:V8QI 1 "nonimmediate_operand" "%0")
5800                 (parallel [(const_int 0)
5801                            (const_int 2)
5802                            (const_int 4)
5803                            (const_int 6)])))
5804             (sign_extend:V4HI
5805               (vec_select:V4QI
5806                 (match_operand:V8QI 2 "nonimmediate_operand" "ym")
5807                 (parallel [(const_int 0)
5808                            (const_int 2)
5809                            (const_int 4)
5810                            (const_int 6)]))))
5811           (mult:V4HI
5812             (zero_extend:V4HI
5813               (vec_select:V8QI (match_dup 1)
5814                 (parallel [(const_int 1)
5815                            (const_int 3)
5816                            (const_int 5)
5817                            (const_int 7)])))
5818             (sign_extend:V4HI
5819               (vec_select:V8QI (match_dup 2)
5820                 (parallel [(const_int 1)
5821                            (const_int 3)
5822                            (const_int 5)
5823                            (const_int 7)]))))))]
5824   "TARGET_SSSE3"
5825   "pmaddubsw\t{%2, %0|%0, %2}"
5826   [(set_attr "type" "sseiadd")
5827    (set_attr "prefix_extra" "1")
5828    (set_attr "mode" "DI")])
5829
5830 (define_insn "ssse3_pmulhrswv8hi3"
5831   [(set (match_operand:V8HI 0 "register_operand" "=x")
5832         (truncate:V8HI
5833           (lshiftrt:V8SI
5834             (plus:V8SI
5835               (lshiftrt:V8SI
5836                 (mult:V8SI
5837                   (sign_extend:V8SI
5838                     (match_operand:V8HI 1 "nonimmediate_operand" "%0"))
5839                   (sign_extend:V8SI
5840                     (match_operand:V8HI 2 "nonimmediate_operand" "xm")))
5841                 (const_int 14))
5842               (const_vector:V8HI [(const_int 1) (const_int 1)
5843                                   (const_int 1) (const_int 1)
5844                                   (const_int 1) (const_int 1)
5845                                   (const_int 1) (const_int 1)]))
5846             (const_int 1))))]
5847   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V8HImode, operands)"
5848   "pmulhrsw\t{%2, %0|%0, %2}"
5849   [(set_attr "type" "sseimul")
5850    (set_attr "prefix_data16" "1")
5851    (set_attr "prefix_extra" "1")
5852    (set_attr "mode" "TI")])
5853
5854 (define_insn "ssse3_pmulhrswv4hi3"
5855   [(set (match_operand:V4HI 0 "register_operand" "=y")
5856         (truncate:V4HI
5857           (lshiftrt:V4SI
5858             (plus:V4SI
5859               (lshiftrt:V4SI
5860                 (mult:V4SI
5861                   (sign_extend:V4SI
5862                     (match_operand:V4HI 1 "nonimmediate_operand" "%0"))
5863                   (sign_extend:V4SI
5864                     (match_operand:V4HI 2 "nonimmediate_operand" "ym")))
5865                 (const_int 14))
5866               (const_vector:V4HI [(const_int 1) (const_int 1)
5867                                   (const_int 1) (const_int 1)]))
5868             (const_int 1))))]
5869   "TARGET_SSSE3 && ix86_binary_operator_ok (MULT, V4HImode, operands)"
5870   "pmulhrsw\t{%2, %0|%0, %2}"
5871   [(set_attr "type" "sseimul")
5872    (set_attr "prefix_extra" "1")
5873    (set_attr "mode" "DI")])
5874
5875 (define_insn "ssse3_pshufbv16qi3"
5876   [(set (match_operand:V16QI 0 "register_operand" "=x")
5877         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "0")
5878                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")]
5879                        UNSPEC_PSHUFB))]
5880   "TARGET_SSSE3"
5881   "pshufb\t{%2, %0|%0, %2}";
5882   [(set_attr "type" "sselog1")
5883    (set_attr "prefix_data16" "1")
5884    (set_attr "prefix_extra" "1")
5885    (set_attr "mode" "TI")])
5886
5887 (define_insn "ssse3_pshufbv8qi3"
5888   [(set (match_operand:V8QI 0 "register_operand" "=y")
5889         (unspec:V8QI [(match_operand:V8QI 1 "register_operand" "0")
5890                       (match_operand:V8QI 2 "nonimmediate_operand" "ym")]
5891                       UNSPEC_PSHUFB))]
5892   "TARGET_SSSE3"
5893   "pshufb\t{%2, %0|%0, %2}";
5894   [(set_attr "type" "sselog1")
5895    (set_attr "prefix_extra" "1")
5896    (set_attr "mode" "DI")])
5897
5898 (define_insn "ssse3_psign<mode>3"
5899   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
5900         (unspec:SSEMODE124 [(match_operand:SSEMODE124 1 "register_operand" "0")
5901                             (match_operand:SSEMODE124 2 "nonimmediate_operand" "xm")]
5902                             UNSPEC_PSIGN))]
5903   "TARGET_SSSE3"
5904   "psign<ssevecsize>\t{%2, %0|%0, %2}";
5905   [(set_attr "type" "sselog1")
5906    (set_attr "prefix_data16" "1")
5907    (set_attr "prefix_extra" "1")
5908    (set_attr "mode" "TI")])
5909
5910 (define_insn "ssse3_psign<mode>3"
5911   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
5912         (unspec:MMXMODEI [(match_operand:MMXMODEI 1 "register_operand" "0")
5913                           (match_operand:MMXMODEI 2 "nonimmediate_operand" "ym")]
5914                           UNSPEC_PSIGN))]
5915   "TARGET_SSSE3"
5916   "psign<mmxvecsize>\t{%2, %0|%0, %2}";
5917   [(set_attr "type" "sselog1")
5918    (set_attr "prefix_extra" "1")
5919    (set_attr "mode" "DI")])
5920
5921 (define_insn "ssse3_palignrti"
5922   [(set (match_operand:TI 0 "register_operand" "=x")
5923         (unspec:TI [(match_operand:TI 1 "register_operand" "0")
5924                     (match_operand:TI 2 "nonimmediate_operand" "xm")
5925                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
5926                     UNSPEC_PALIGNR))]
5927   "TARGET_SSSE3"
5928 {
5929   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
5930   return "palignr\t{%3, %2, %0|%0, %2, %3}";
5931 }
5932   [(set_attr "type" "sseishft")
5933    (set_attr "prefix_data16" "1")
5934    (set_attr "prefix_extra" "1")
5935    (set_attr "mode" "TI")])
5936
5937 (define_insn "ssse3_palignrdi"
5938   [(set (match_operand:DI 0 "register_operand" "=y")
5939         (unspec:DI [(match_operand:DI 1 "register_operand" "0")
5940                     (match_operand:DI 2 "nonimmediate_operand" "ym")
5941                     (match_operand:SI 3 "const_0_to_255_mul_8_operand" "n")]
5942                     UNSPEC_PALIGNR))]
5943   "TARGET_SSSE3"
5944 {
5945   operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
5946   return "palignr\t{%3, %2, %0|%0, %2, %3}";
5947 }
5948   [(set_attr "type" "sseishft")
5949    (set_attr "prefix_extra" "1")
5950    (set_attr "mode" "DI")])
5951
5952 (define_insn "abs<mode>2"
5953   [(set (match_operand:SSEMODE124 0 "register_operand" "=x")
5954         (abs:SSEMODE124 (match_operand:SSEMODE124 1 "nonimmediate_operand" "xm")))]
5955   "TARGET_SSSE3"
5956   "pabs<ssevecsize>\t{%1, %0|%0, %1}";
5957   [(set_attr "type" "sselog1")
5958    (set_attr "prefix_data16" "1")
5959    (set_attr "prefix_extra" "1")
5960    (set_attr "mode" "TI")])
5961
5962 (define_insn "abs<mode>2"
5963   [(set (match_operand:MMXMODEI 0 "register_operand" "=y")
5964         (abs:MMXMODEI (match_operand:MMXMODEI 1 "nonimmediate_operand" "ym")))]
5965   "TARGET_SSSE3"
5966   "pabs<mmxvecsize>\t{%1, %0|%0, %1}";
5967   [(set_attr "type" "sselog1")
5968    (set_attr "prefix_extra" "1")
5969    (set_attr "mode" "DI")])
5970
5971 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5972 ;;
5973 ;; AMD SSE4A instructions
5974 ;;
5975 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5976
5977 (define_insn "sse4a_vmmovntv2df"
5978   [(set (match_operand:DF 0 "memory_operand" "=m")
5979         (unspec:DF [(vec_select:DF
5980                       (match_operand:V2DF 1 "register_operand" "x")
5981                       (parallel [(const_int 0)]))]
5982                    UNSPEC_MOVNT))]
5983   "TARGET_SSE4A"
5984   "movntsd\t{%1, %0|%0, %1}"
5985   [(set_attr "type" "ssemov")
5986    (set_attr "mode" "DF")])
5987
5988 (define_insn "sse4a_movntdf"
5989   [(set (match_operand:DF 0 "memory_operand" "=m")
5990         (unspec:DF [(match_operand:DF 1 "register_operand" "x")]
5991                    UNSPEC_MOVNT))]
5992   "TARGET_SSE4A"
5993   "movntsd\t{%1, %0|%0, %1}"
5994   [(set_attr "type" "ssemov")
5995    (set_attr "mode" "DF")])
5996
5997 (define_insn "sse4a_vmmovntv4sf"
5998   [(set (match_operand:SF 0 "memory_operand" "=m")
5999         (unspec:SF [(vec_select:SF
6000                       (match_operand:V4SF 1 "register_operand" "x")
6001                       (parallel [(const_int 0)]))]
6002                    UNSPEC_MOVNT))]
6003   "TARGET_SSE4A"
6004   "movntss\t{%1, %0|%0, %1}"
6005   [(set_attr "type" "ssemov")
6006    (set_attr "mode" "SF")])
6007
6008 (define_insn "sse4a_movntsf"
6009   [(set (match_operand:SF 0 "memory_operand" "=m")
6010         (unspec:SF [(match_operand:SF 1 "register_operand" "x")]
6011                    UNSPEC_MOVNT))]
6012   "TARGET_SSE4A"
6013   "movntss\t{%1, %0|%0, %1}"
6014   [(set_attr "type" "ssemov")
6015    (set_attr "mode" "SF")])
6016
6017 (define_insn "sse4a_extrqi"
6018   [(set (match_operand:V2DI 0 "register_operand" "=x")
6019         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
6020                       (match_operand 2 "const_int_operand" "")
6021                       (match_operand 3 "const_int_operand" "")]
6022                      UNSPEC_EXTRQI))]
6023   "TARGET_SSE4A"
6024   "extrq\t{%3, %2, %0|%0, %2, %3}"
6025   [(set_attr "type" "sse")
6026    (set_attr "prefix_data16" "1")
6027    (set_attr "mode" "TI")])
6028
6029 (define_insn "sse4a_extrq"
6030   [(set (match_operand:V2DI 0 "register_operand" "=x")
6031         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
6032                       (match_operand:V16QI 2 "register_operand" "x")]
6033                      UNSPEC_EXTRQ))]
6034   "TARGET_SSE4A"
6035   "extrq\t{%2, %0|%0, %2}"
6036   [(set_attr "type" "sse")
6037    (set_attr "prefix_data16" "1")
6038    (set_attr "mode" "TI")])
6039
6040 (define_insn "sse4a_insertqi"
6041   [(set (match_operand:V2DI 0 "register_operand" "=x")
6042         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
6043                       (match_operand:V2DI 2 "register_operand" "x")
6044                       (match_operand 3 "const_int_operand" "")
6045                       (match_operand 4 "const_int_operand" "")]
6046                      UNSPEC_INSERTQI))]
6047   "TARGET_SSE4A"
6048   "insertq\t{%4, %3, %2, %0|%0, %2, %3, %4}"
6049   [(set_attr "type" "sseins")
6050    (set_attr "prefix_rep" "1")
6051    (set_attr "mode" "TI")])
6052
6053 (define_insn "sse4a_insertq"
6054   [(set (match_operand:V2DI 0 "register_operand" "=x")
6055         (unspec:V2DI [(match_operand:V2DI 1 "register_operand" "0")
6056                       (match_operand:V2DI 2 "register_operand" "x")]
6057                      UNSPEC_INSERTQ))]
6058   "TARGET_SSE4A"
6059   "insertq\t{%2, %0|%0, %2}"
6060   [(set_attr "type" "sseins")
6061    (set_attr "prefix_rep" "1")
6062    (set_attr "mode" "TI")])
6063
6064 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6065 ;;
6066 ;; Intel SSE4.1 instructions
6067 ;;
6068 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6069
6070 (define_insn "sse4_1_blendpd"
6071   [(set (match_operand:V2DF 0 "register_operand" "=x")
6072         (vec_merge:V2DF
6073           (match_operand:V2DF 2 "nonimmediate_operand" "xm")
6074           (match_operand:V2DF 1 "register_operand" "0")
6075           (match_operand:SI 3 "const_0_to_3_operand" "n")))]
6076   "TARGET_SSE4_1"
6077   "blendpd\t{%3, %2, %0|%0, %2, %3}"
6078   [(set_attr "type" "ssemov")
6079    (set_attr "prefix_extra" "1")
6080    (set_attr "mode" "V2DF")])
6081
6082 (define_insn "sse4_1_blendps"
6083   [(set (match_operand:V4SF 0 "register_operand" "=x")
6084         (vec_merge:V4SF
6085           (match_operand:V4SF 2 "nonimmediate_operand" "xm")
6086           (match_operand:V4SF 1 "register_operand" "0")
6087           (match_operand:SI 3 "const_0_to_15_operand" "n")))]
6088   "TARGET_SSE4_1"
6089   "blendps\t{%3, %2, %0|%0, %2, %3}"
6090   [(set_attr "type" "ssemov")
6091    (set_attr "prefix_extra" "1")
6092    (set_attr "mode" "V4SF")])
6093
6094 (define_insn "sse4_1_blendvpd"
6095   [(set (match_operand:V2DF 0 "reg_not_xmm0_operand" "=x")
6096         (unspec:V2DF [(match_operand:V2DF 1 "reg_not_xmm0_operand"  "0")
6097                       (match_operand:V2DF 2 "nonimm_not_xmm0_operand" "xm")
6098                       (match_operand:V2DF 3 "register_operand" "Y0")]
6099                      UNSPEC_BLENDV))]
6100   "TARGET_SSE4_1"
6101   "blendvpd\t{%3, %2, %0|%0, %2, %3}"
6102   [(set_attr "type" "ssemov")
6103    (set_attr "prefix_extra" "1")
6104    (set_attr "mode" "V2DF")])
6105
6106 (define_insn "sse4_1_blendvps"
6107   [(set (match_operand:V4SF 0 "reg_not_xmm0_operand" "=x")
6108         (unspec:V4SF [(match_operand:V4SF 1 "reg_not_xmm0_operand" "0")
6109                       (match_operand:V4SF 2 "nonimm_not_xmm0_operand" "xm")
6110                       (match_operand:V4SF 3 "register_operand" "Y0")]
6111                      UNSPEC_BLENDV))]
6112   "TARGET_SSE4_1"
6113   "blendvps\t{%3, %2, %0|%0, %2, %3}"
6114   [(set_attr "type" "ssemov")
6115    (set_attr "prefix_extra" "1")
6116    (set_attr "mode" "V4SF")])
6117
6118 (define_insn "sse4_1_dppd"
6119   [(set (match_operand:V2DF 0 "register_operand" "=x")
6120         (unspec:V2DF [(match_operand:V2DF 1 "nonimmediate_operand" "%0")
6121                       (match_operand:V2DF 2 "nonimmediate_operand" "xm")
6122                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
6123                       UNSPEC_DP))]
6124   "TARGET_SSE4_1"
6125   "dppd\t{%3, %2, %0|%0, %2, %3}"
6126   [(set_attr "type" "ssemul")
6127    (set_attr "prefix_extra" "1")
6128    (set_attr "mode" "V2DF")])
6129
6130 (define_insn "sse4_1_dpps"
6131   [(set (match_operand:V4SF 0 "register_operand" "=x")
6132         (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "%0")
6133                       (match_operand:V4SF 2 "nonimmediate_operand" "xm")
6134                       (match_operand:SI 3 "const_0_to_255_operand" "n")]
6135                      UNSPEC_DP))]
6136   "TARGET_SSE4_1"
6137   "dpps\t{%3, %2, %0|%0, %2, %3}"
6138   [(set_attr "type" "ssemul")
6139    (set_attr "prefix_extra" "1")
6140    (set_attr "mode" "V4SF")])
6141
6142 (define_insn "sse4_1_movntdqa"
6143   [(set (match_operand:V2DI 0 "register_operand" "=x")
6144         (unspec:V2DI [(match_operand:V2DI 1 "memory_operand" "m")]
6145                      UNSPEC_MOVNTDQA))]
6146   "TARGET_SSE4_1"
6147   "movntdqa\t{%1, %0|%0, %1}"
6148   [(set_attr "type" "ssecvt")
6149    (set_attr "prefix_extra" "1")
6150    (set_attr "mode" "TI")])
6151
6152 (define_insn "sse4_1_mpsadbw"
6153   [(set (match_operand:V16QI 0 "register_operand" "=x")
6154         (unspec:V16QI [(match_operand:V16QI 1 "register_operand" "0")
6155                        (match_operand:V16QI 2 "nonimmediate_operand" "xm")
6156                        (match_operand:SI 3 "const_0_to_255_operand" "n")]
6157                       UNSPEC_MPSADBW))]
6158   "TARGET_SSE4_1"
6159   "mpsadbw\t{%3, %2, %0|%0, %2, %3}"
6160   [(set_attr "type" "sselog1")
6161    (set_attr "prefix_extra" "1")
6162    (set_attr "mode" "TI")])
6163
6164 (define_insn "sse4_1_packusdw"
6165   [(set (match_operand:V8HI 0 "register_operand" "=x")
6166         (vec_concat:V8HI
6167           (us_truncate:V4HI
6168             (match_operand:V4SI 1 "register_operand" "0"))
6169           (us_truncate:V4HI
6170             (match_operand:V4SI 2 "nonimmediate_operand" "xm"))))]
6171   "TARGET_SSE4_1"
6172   "packusdw\t{%2, %0|%0, %2}"
6173   [(set_attr "type" "sselog")
6174    (set_attr "prefix_extra" "1")
6175    (set_attr "mode" "TI")])
6176
6177 (define_insn "sse4_1_pblendvb"
6178   [(set (match_operand:V16QI 0 "reg_not_xmm0_operand" "=x")
6179         (unspec:V16QI [(match_operand:V16QI 1 "reg_not_xmm0_operand"  "0")
6180                        (match_operand:V16QI 2 "nonimm_not_xmm0_operand" "xm")
6181                        (match_operand:V16QI 3 "register_operand" "Y0")]
6182                       UNSPEC_BLENDV))]
6183   "TARGET_SSE4_1"
6184   "pblendvb\t{%3, %2, %0|%0, %2, %3}"
6185   [(set_attr "type" "ssemov")
6186    (set_attr "prefix_extra" "1")
6187    (set_attr "mode" "TI")])
6188
6189 (define_insn "sse4_1_pblendw"
6190   [(set (match_operand:V8HI 0 "register_operand" "=x")
6191         (vec_merge:V8HI
6192           (match_operand:V8HI 2 "nonimmediate_operand" "xm")
6193           (match_operand:V8HI 1 "register_operand" "0")
6194           (match_operand:SI 3 "const_0_to_255_operand" "n")))]
6195   "TARGET_SSE4_1"
6196   "pblendw\t{%3, %2, %0|%0, %2, %3}"
6197   [(set_attr "type" "ssemov")
6198    (set_attr "prefix_extra" "1")
6199    (set_attr "mode" "TI")])
6200
6201 (define_insn "sse4_1_phminposuw"
6202   [(set (match_operand:V8HI 0 "register_operand" "=x")
6203         (unspec:V8HI [(match_operand:V8HI 1 "nonimmediate_operand" "xm")]
6204                      UNSPEC_PHMINPOSUW))]
6205   "TARGET_SSE4_1"
6206   "phminposuw\t{%1, %0|%0, %1}"
6207   [(set_attr "type" "sselog1")
6208    (set_attr "prefix_extra" "1")
6209    (set_attr "mode" "TI")])
6210
6211 (define_insn "sse4_1_extendv8qiv8hi2"
6212   [(set (match_operand:V8HI 0 "register_operand" "=x")
6213         (sign_extend:V8HI
6214           (vec_select:V8QI
6215             (match_operand:V16QI 1 "register_operand" "x")
6216             (parallel [(const_int 0)
6217                        (const_int 1)
6218                        (const_int 2)
6219                        (const_int 3)
6220                        (const_int 4)
6221                        (const_int 5)
6222                        (const_int 6)
6223                        (const_int 7)]))))]
6224   "TARGET_SSE4_1"
6225   "pmovsxbw\t{%1, %0|%0, %1}"
6226   [(set_attr "type" "ssemov")
6227    (set_attr "prefix_extra" "1")
6228    (set_attr "mode" "TI")])
6229
6230 (define_insn "*sse4_1_extendv8qiv8hi2"
6231   [(set (match_operand:V8HI 0 "register_operand" "=x")
6232         (sign_extend:V8HI
6233           (vec_select:V8QI
6234             (vec_duplicate:V16QI
6235               (match_operand:V8QI 1 "nonimmediate_operand" "xm"))
6236             (parallel [(const_int 0)
6237                        (const_int 1)
6238                        (const_int 2)
6239                        (const_int 3)
6240                        (const_int 4)
6241                        (const_int 5)
6242                        (const_int 6)
6243                        (const_int 7)]))))]
6244   "TARGET_SSE4_1"
6245   "pmovsxbw\t{%1, %0|%0, %1}"
6246   [(set_attr "type" "ssemov")
6247    (set_attr "prefix_extra" "1")
6248    (set_attr "mode" "TI")])
6249
6250 (define_insn "sse4_1_extendv4qiv4si2"
6251   [(set (match_operand:V4SI 0 "register_operand" "=x")
6252         (sign_extend:V4SI
6253           (vec_select:V4QI
6254             (match_operand:V16QI 1 "register_operand" "x")
6255             (parallel [(const_int 0)
6256                        (const_int 1)
6257                        (const_int 2)
6258                        (const_int 3)]))))]
6259   "TARGET_SSE4_1"
6260   "pmovsxbd\t{%1, %0|%0, %1}"
6261   [(set_attr "type" "ssemov")
6262    (set_attr "prefix_extra" "1")
6263    (set_attr "mode" "TI")])
6264
6265 (define_insn "*sse4_1_extendv4qiv4si2"
6266   [(set (match_operand:V4SI 0 "register_operand" "=x")
6267         (sign_extend:V4SI
6268           (vec_select:V4QI
6269             (vec_duplicate:V16QI
6270               (match_operand:V4QI 1 "nonimmediate_operand" "xm"))
6271             (parallel [(const_int 0)
6272                        (const_int 1)
6273                        (const_int 2)
6274                        (const_int 3)]))))]
6275   "TARGET_SSE4_1"
6276   "pmovsxbd\t{%1, %0|%0, %1}"
6277   [(set_attr "type" "ssemov")
6278    (set_attr "prefix_extra" "1")
6279    (set_attr "mode" "TI")])
6280
6281 (define_insn "sse4_1_extendv2qiv2di2"
6282   [(set (match_operand:V2DI 0 "register_operand" "=x")
6283         (sign_extend:V2DI
6284           (vec_select:V2QI
6285             (match_operand:V16QI 1 "register_operand" "x")
6286             (parallel [(const_int 0)
6287                        (const_int 1)]))))]
6288   "TARGET_SSE4_1"
6289   "pmovsxbq\t{%1, %0|%0, %1}"
6290   [(set_attr "type" "ssemov")
6291    (set_attr "prefix_extra" "1")
6292    (set_attr "mode" "TI")])
6293
6294 (define_insn "*sse4_1_extendv2qiv2di2"
6295   [(set (match_operand:V2DI 0 "register_operand" "=x")
6296         (sign_extend:V2DI
6297           (vec_select:V2QI
6298             (vec_duplicate:V16QI
6299               (match_operand:V2QI 1 "nonimmediate_operand" "xm"))
6300             (parallel [(const_int 0)
6301                        (const_int 1)]))))]
6302   "TARGET_SSE4_1"
6303   "pmovsxbq\t{%1, %0|%0, %1}"
6304   [(set_attr "type" "ssemov")
6305    (set_attr "prefix_extra" "1")
6306    (set_attr "mode" "TI")])
6307
6308 (define_insn "sse4_1_extendv4hiv4si2"
6309   [(set (match_operand:V4SI 0 "register_operand" "=x")
6310         (sign_extend:V4SI
6311           (vec_select:V4HI
6312             (match_operand:V8HI 1 "register_operand" "x")
6313             (parallel [(const_int 0)
6314                        (const_int 1)
6315                        (const_int 2)
6316                        (const_int 3)]))))]
6317   "TARGET_SSE4_1"
6318   "pmovsxwd\t{%1, %0|%0, %1}"
6319   [(set_attr "type" "ssemov")
6320    (set_attr "prefix_extra" "1")
6321    (set_attr "mode" "TI")])
6322
6323 (define_insn "*sse4_1_extendv4hiv4si2"
6324   [(set (match_operand:V4SI 0 "register_operand" "=x")
6325         (sign_extend:V4SI
6326           (vec_select:V4HI
6327             (vec_duplicate:V8HI
6328               (match_operand:V2HI 1 "nonimmediate_operand" "xm"))
6329             (parallel [(const_int 0)
6330                        (const_int 1)
6331                        (const_int 2)
6332                        (const_int 3)]))))]
6333   "TARGET_SSE4_1"
6334   "pmovsxwd\t{%1, %0|%0, %1}"
6335   [(set_attr "type" "ssemov")
6336    (set_attr "prefix_extra" "1")
6337    (set_attr "mode" "TI")])
6338
6339 (define_insn "sse4_1_extendv2hiv2di2"
6340   [(set (match_operand:V2DI 0 "register_operand" "=x")
6341         (sign_extend:V2DI
6342           (vec_select:V2HI
6343             (match_operand:V8HI 1 "register_operand" "x")
6344             (parallel [(const_int 0)
6345                        (const_int 1)]))))]
6346   "TARGET_SSE4_1"
6347   "pmovsxwq\t{%1, %0|%0, %1}"
6348   [(set_attr "type" "ssemov")
6349    (set_attr "prefix_extra" "1")
6350    (set_attr "mode" "TI")])
6351
6352 (define_insn "*sse4_1_extendv2hiv2di2"
6353   [(set (match_operand:V2DI 0 "register_operand" "=x")
6354         (sign_extend:V2DI
6355           (vec_select:V2HI
6356             (vec_duplicate:V8HI
6357               (match_operand:V8HI 1 "nonimmediate_operand" "xm"))
6358             (parallel [(const_int 0)
6359                        (const_int 1)]))))]
6360   "TARGET_SSE4_1"
6361   "pmovsxwq\t{%1, %0|%0, %1}"
6362   [(set_attr "type" "ssemov")
6363    (set_attr "prefix_extra" "1")
6364    (set_attr "mode" "TI")])
6365
6366 (define_insn "sse4_1_extendv2siv2di2"
6367   [(set (match_operand:V2DI 0 "register_operand" "=x")
6368         (sign_extend:V2DI
6369           (vec_select:V2SI
6370             (match_operand:V4SI 1 "register_operand" "x")
6371             (parallel [(const_int 0)
6372                        (const_int 1)]))))]
6373   "TARGET_SSE4_1"
6374   "pmovsxdq\t{%1, %0|%0, %1}"
6375   [(set_attr "type" "ssemov")
6376    (set_attr "prefix_extra" "1")
6377    (set_attr "mode" "TI")])
6378
6379 (define_insn "*sse4_1_extendv2siv2di2"
6380   [(set (match_operand:V2DI 0 "register_operand" "=x")
6381         (sign_extend:V2DI
6382           (vec_select:V2SI
6383             (vec_duplicate:V4SI
6384               (match_operand:V2SI 1 "nonimmediate_operand" "xm"))
6385             (parallel [(const_int 0)
6386                        (const_int 1)]))))]
6387   "TARGET_SSE4_1"
6388   "pmovsxdq\t{%1, %0|%0, %1}"
6389   [(set_attr "type" "ssemov")
6390    (set_attr "prefix_extra" "1")
6391    (set_attr "mode" "TI")])
6392
6393 (define_insn "sse4_1_zero_extendv8qiv8hi2"
6394   [(set (match_operand:V8HI 0 "register_operand" "=x")
6395         (zero_extend:V8HI
6396           (vec_select:V8QI
6397             (match_operand:V16QI 1 "register_operand" "x")
6398             (parallel [(const_int 0)
6399                        (const_int 1)
6400                        (const_int 2)
6401                        (const_int 3)
6402                        (const_int 4)
6403                        (const_int 5)
6404                        (const_int 6)
6405                        (const_int 7)]))))]
6406   "TARGET_SSE4_1"
6407   "pmovzxbw\t{%1, %0|%0, %1}"
6408   [(set_attr "type" "ssemov")
6409    (set_attr "prefix_extra" "1")
6410    (set_attr "mode" "TI")])
6411
6412 (define_insn "*sse4_1_zero_extendv8qiv8hi2"
6413   [(set (match_operand:V8HI 0 "register_operand" "=x")
6414         (zero_extend:V8HI
6415           (vec_select:V8QI
6416             (vec_duplicate:V16QI
6417               (match_operand:V8QI 1 "nonimmediate_operand" "xm"))
6418             (parallel [(const_int 0)
6419                        (const_int 1)
6420                        (const_int 2)
6421                        (const_int 3)
6422                        (const_int 4)
6423                        (const_int 5)
6424                        (const_int 6)
6425                        (const_int 7)]))))]
6426   "TARGET_SSE4_1"
6427   "pmovzxbw\t{%1, %0|%0, %1}"
6428   [(set_attr "type" "ssemov")
6429    (set_attr "prefix_extra" "1")
6430    (set_attr "mode" "TI")])
6431
6432 (define_insn "sse4_1_zero_extendv4qiv4si2"
6433   [(set (match_operand:V4SI 0 "register_operand" "=x")
6434         (zero_extend:V4SI
6435           (vec_select:V4QI
6436             (match_operand:V16QI 1 "register_operand" "x")
6437             (parallel [(const_int 0)
6438                        (const_int 1)
6439                        (const_int 2)
6440                        (const_int 3)]))))]
6441   "TARGET_SSE4_1"
6442   "pmovzxbd\t{%1, %0|%0, %1}"
6443   [(set_attr "type" "ssemov")
6444    (set_attr "prefix_extra" "1")
6445    (set_attr "mode" "TI")])
6446
6447 (define_insn "*sse4_1_zero_extendv4qiv4si2"
6448   [(set (match_operand:V4SI 0 "register_operand" "=x")
6449         (zero_extend:V4SI
6450           (vec_select:V4QI
6451             (vec_duplicate:V16QI
6452               (match_operand:V4QI 1 "nonimmediate_operand" "xm"))
6453             (parallel [(const_int 0)
6454                        (const_int 1)
6455                        (const_int 2)
6456                        (const_int 3)]))))]
6457   "TARGET_SSE4_1"
6458   "pmovzxbd\t{%1, %0|%0, %1}"
6459   [(set_attr "type" "ssemov")
6460    (set_attr "prefix_extra" "1")
6461    (set_attr "mode" "TI")])
6462
6463 (define_insn "sse4_1_zero_extendv2qiv2di2"
6464   [(set (match_operand:V2DI 0 "register_operand" "=x")
6465         (zero_extend:V2DI
6466           (vec_select:V2QI
6467             (match_operand:V16QI 1 "register_operand" "x")
6468             (parallel [(const_int 0)
6469                        (const_int 1)]))))]
6470   "TARGET_SSE4_1"
6471   "pmovzxbq\t{%1, %0|%0, %1}"
6472   [(set_attr "type" "ssemov")
6473    (set_attr "prefix_extra" "1")
6474    (set_attr "mode" "TI")])
6475
6476 (define_insn "*sse4_1_zero_extendv2qiv2di2"
6477   [(set (match_operand:V2DI 0 "register_operand" "=x")
6478         (zero_extend:V2DI
6479           (vec_select:V2QI
6480             (vec_duplicate:V16QI
6481               (match_operand:V2QI 1 "nonimmediate_operand" "xm"))
6482             (parallel [(const_int 0)
6483                        (const_int 1)]))))]
6484   "TARGET_SSE4_1"
6485   "pmovzxbq\t{%1, %0|%0, %1}"
6486   [(set_attr "type" "ssemov")
6487    (set_attr "prefix_extra" "1")
6488    (set_attr "mode" "TI")])
6489
6490 (define_insn "sse4_1_zero_extendv4hiv4si2"
6491   [(set (match_operand:V4SI 0 "register_operand" "=x")
6492         (zero_extend:V4SI
6493           (vec_select:V4HI
6494             (match_operand:V8HI 1 "register_operand" "x")
6495             (parallel [(const_int 0)
6496                        (const_int 1)
6497                        (const_int 2)
6498                        (const_int 3)]))))]
6499   "TARGET_SSE4_1"
6500   "pmovzxwd\t{%1, %0|%0, %1}"
6501   [(set_attr "type" "ssemov")
6502    (set_attr "prefix_extra" "1")
6503    (set_attr "mode" "TI")])
6504
6505 (define_insn "*sse4_1_zero_extendv4hiv4si2"
6506   [(set (match_operand:V4SI 0 "register_operand" "=x")
6507         (zero_extend:V4SI
6508           (vec_select:V4HI
6509             (vec_duplicate:V8HI
6510               (match_operand:V4HI 1 "nonimmediate_operand" "xm"))
6511             (parallel [(const_int 0)
6512                        (const_int 1)
6513                        (const_int 2)
6514                        (const_int 3)]))))]
6515   "TARGET_SSE4_1"
6516   "pmovzxwd\t{%1, %0|%0, %1}"
6517   [(set_attr "type" "ssemov")
6518    (set_attr "prefix_extra" "1")
6519    (set_attr "mode" "TI")])
6520
6521 (define_insn "sse4_1_zero_extendv2hiv2di2"
6522   [(set (match_operand:V2DI 0 "register_operand" "=x")
6523         (zero_extend:V2DI
6524           (vec_select:V2HI
6525             (match_operand:V8HI 1 "register_operand" "x")
6526             (parallel [(const_int 0)
6527                        (const_int 1)]))))]
6528   "TARGET_SSE4_1"
6529   "pmovzxwq\t{%1, %0|%0, %1}"
6530   [(set_attr "type" "ssemov")
6531    (set_attr "prefix_extra" "1")
6532    (set_attr "mode" "TI")])
6533
6534 (define_insn "*sse4_1_zero_extendv2hiv2di2"
6535   [(set (match_operand:V2DI 0 "register_operand" "=x")
6536         (zero_extend:V2DI
6537           (vec_select:V2HI
6538             (vec_duplicate:V8HI
6539               (match_operand:V2HI 1 "nonimmediate_operand" "xm"))
6540             (parallel [(const_int 0)
6541                        (const_int 1)]))))]
6542   "TARGET_SSE4_1"
6543   "pmovzxwq\t{%1, %0|%0, %1}"
6544   [(set_attr "type" "ssemov")
6545    (set_attr "prefix_extra" "1")
6546    (set_attr "mode" "TI")])
6547
6548 (define_insn "sse4_1_zero_extendv2siv2di2"
6549   [(set (match_operand:V2DI 0 "register_operand" "=x")
6550         (zero_extend:V2DI
6551           (vec_select:V2SI
6552             (match_operand:V4SI 1 "register_operand" "x")
6553             (parallel [(const_int 0)
6554                        (const_int 1)]))))]
6555   "TARGET_SSE4_1"
6556   "pmovzxdq\t{%1, %0|%0, %1}"
6557   [(set_attr "type" "ssemov")
6558    (set_attr "prefix_extra" "1")
6559    (set_attr "mode" "TI")])
6560
6561 (define_insn "*sse4_1_zero_extendv2siv2di2"
6562   [(set (match_operand:V2DI 0 "register_operand" "=x")
6563         (zero_extend:V2DI
6564           (vec_select:V2SI
6565             (vec_duplicate:V4SI
6566               (match_operand:V2SI 1 "nonimmediate_operand" "xm"))
6567             (parallel [(const_int 0)
6568                        (const_int 1)]))))]
6569   "TARGET_SSE4_1"
6570   "pmovzxdq\t{%1, %0|%0, %1}"
6571   [(set_attr "type" "ssemov")
6572    (set_attr "prefix_extra" "1")
6573    (set_attr "mode" "TI")])
6574
6575 ;; ptest is very similar to comiss and ucomiss when setting FLAGS_REG.
6576 ;; But it is not a really compare instruction.
6577 (define_insn "sse4_1_ptest"
6578   [(set (reg:CC FLAGS_REG)
6579         (unspec:CC [(match_operand:V2DI 0 "register_operand" "x")
6580                     (match_operand:V2DI 1 "nonimmediate_operand" "xm")]
6581                    UNSPEC_PTEST))]
6582   "TARGET_SSE4_1"
6583   "ptest\t{%1, %0|%0, %1}"
6584   [(set_attr "type" "ssecomi")
6585    (set_attr "prefix_extra" "1")
6586    (set_attr "mode" "TI")])
6587
6588 (define_insn "sse4_1_roundpd"
6589   [(set (match_operand:V2DF 0 "register_operand" "=x")
6590         (unspec:V2DF [(match_operand:V2DF 1 "nonimmediate_operand" "xm")
6591                       (match_operand:SI 2 "const_0_to_15_operand" "n")]
6592                      UNSPEC_ROUND))]
6593   "TARGET_SSE4_1"
6594   "roundpd\t{%2, %1, %0|%0, %1, %2}"
6595   [(set_attr "type" "ssecvt")
6596    (set_attr "prefix_extra" "1")
6597    (set_attr "mode" "V2DF")])
6598
6599 (define_insn "sse4_1_roundps"
6600   [(set (match_operand:V4SF 0 "register_operand" "=x")
6601         (unspec:V4SF [(match_operand:V4SF 1 "nonimmediate_operand" "xm")
6602                       (match_operand:SI 2 "const_0_to_15_operand" "n")]
6603                      UNSPEC_ROUND))]
6604   "TARGET_SSE4_1"
6605   "roundps\t{%2, %1, %0|%0, %1, %2}"
6606   [(set_attr "type" "ssecvt")
6607    (set_attr "prefix_extra" "1")
6608    (set_attr "mode" "V4SF")])
6609
6610 (define_insn "sse4_1_roundsd"
6611   [(set (match_operand:V2DF 0 "register_operand" "=x")
6612         (vec_merge:V2DF
6613           (unspec:V2DF [(match_operand:V2DF 2 "register_operand" "x")
6614                         (match_operand:SI 3 "const_0_to_15_operand" "n")]
6615                        UNSPEC_ROUND)
6616           (match_operand:V2DF 1 "register_operand" "0")
6617           (const_int 1)))]
6618   "TARGET_SSE4_1"
6619   "roundsd\t{%3, %2, %0|%0, %2, %3}"
6620   [(set_attr "type" "ssecvt")
6621    (set_attr "prefix_extra" "1")
6622    (set_attr "mode" "V2DF")])
6623
6624 (define_insn "sse4_1_roundss"
6625   [(set (match_operand:V4SF 0 "register_operand" "=x")
6626         (vec_merge:V4SF
6627           (unspec:V4SF [(match_operand:V4SF 2 "register_operand" "x")
6628                         (match_operand:SI 3 "const_0_to_15_operand" "n")]
6629                        UNSPEC_ROUND)
6630           (match_operand:V4SF 1 "register_operand" "0")
6631           (const_int 1)))]
6632   "TARGET_SSE4_1"
6633   "roundss\t{%3, %2, %0|%0, %2, %3}"
6634   [(set_attr "type" "ssecvt")
6635    (set_attr "prefix_extra" "1")
6636    (set_attr "mode" "V4SF")])
6637
6638 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6639 ;;
6640 ;; Intel SSE4.2 string/text processing instructions
6641 ;;
6642 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6643
6644 (define_insn_and_split "sse4_2_pcmpestr"
6645   [(set (match_operand:SI 0 "register_operand" "=c,c")
6646         (unspec:SI
6647           [(match_operand:V16QI 2 "register_operand" "x,x")
6648            (match_operand:SI 3 "register_operand" "a,a")
6649            (match_operand:V16QI 4 "nonimmediate_operand" "x,m")
6650            (match_operand:SI 5 "register_operand" "d,d")
6651            (match_operand:SI 6 "const_0_to_255_operand" "n,n")]
6652           UNSPEC_PCMPESTR))
6653    (set (match_operand:V16QI 1 "register_operand" "=Y0,Y0")
6654         (unspec:V16QI
6655           [(match_dup 2)
6656            (match_dup 3)
6657            (match_dup 4)
6658            (match_dup 5)
6659            (match_dup 6)]
6660           UNSPEC_PCMPESTR))
6661    (set (reg:CC FLAGS_REG)
6662         (unspec:CC
6663           [(match_dup 2)
6664            (match_dup 3)
6665            (match_dup 4)
6666            (match_dup 5)
6667            (match_dup 6)]
6668           UNSPEC_PCMPESTR))]
6669   "TARGET_SSE4_2
6670    && !(reload_completed || reload_in_progress)"
6671   "#"
6672   "&& 1"
6673   [(const_int 0)]
6674 {
6675   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
6676   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
6677   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
6678
6679   if (ecx)
6680     emit_insn (gen_sse4_2_pcmpestri (operands[0], operands[2],
6681                                      operands[3], operands[4],
6682                                      operands[5], operands[6]));
6683   if (xmm0)
6684     emit_insn (gen_sse4_2_pcmpestrm (operands[1], operands[2],
6685                                      operands[3], operands[4],
6686                                      operands[5], operands[6]));
6687   if (flags && !(ecx || xmm0))
6688     emit_insn (gen_sse4_2_pcmpestr_cconly (operands[2], operands[3],
6689                                            operands[4], operands[5],
6690                                            operands[6]));
6691   DONE;
6692 }
6693   [(set_attr "type" "sselog")
6694    (set_attr "prefix_data16" "1")
6695    (set_attr "prefix_extra" "1")
6696    (set_attr "memory" "none,load")
6697    (set_attr "mode" "TI")])
6698
6699 (define_insn "sse4_2_pcmpestri"
6700   [(set (match_operand:SI 0 "register_operand" "=c,c")
6701         (unspec:SI
6702           [(match_operand:V16QI 1 "register_operand" "x,x")
6703            (match_operand:SI 2 "register_operand" "a,a")
6704            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
6705            (match_operand:SI 4 "register_operand" "d,d")
6706            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
6707           UNSPEC_PCMPESTR))
6708    (set (reg:CC FLAGS_REG)
6709         (unspec:CC
6710           [(match_dup 1)
6711            (match_dup 2)
6712            (match_dup 3)
6713            (match_dup 4)
6714            (match_dup 5)]
6715           UNSPEC_PCMPESTR))]
6716   "TARGET_SSE4_2"
6717   "pcmpestri\t{%5, %3, %1|%1, %3, %5}"
6718   [(set_attr "type" "sselog")
6719    (set_attr "prefix_data16" "1")
6720    (set_attr "prefix_extra" "1")
6721    (set_attr "memory" "none,load")
6722    (set_attr "mode" "TI")])
6723
6724 (define_insn "sse4_2_pcmpestrm"
6725   [(set (match_operand:V16QI 0 "register_operand" "=Y0,Y0")
6726         (unspec:V16QI
6727           [(match_operand:V16QI 1 "register_operand" "x,x")
6728            (match_operand:SI 2 "register_operand" "a,a")
6729            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
6730            (match_operand:SI 4 "register_operand" "d,d")
6731            (match_operand:SI 5 "const_0_to_255_operand" "n,n")]
6732           UNSPEC_PCMPESTR))
6733    (set (reg:CC FLAGS_REG)
6734         (unspec:CC
6735           [(match_dup 1)
6736            (match_dup 2)
6737            (match_dup 3)
6738            (match_dup 4)
6739            (match_dup 5)]
6740           UNSPEC_PCMPESTR))]
6741   "TARGET_SSE4_2"
6742   "pcmpestrm\t{%5, %3, %1|%1, %3, %5}"
6743   [(set_attr "type" "sselog")
6744    (set_attr "prefix_data16" "1")
6745    (set_attr "prefix_extra" "1")
6746    (set_attr "memory" "none,load")
6747    (set_attr "mode" "TI")])
6748
6749 (define_insn "sse4_2_pcmpestr_cconly"
6750   [(set (reg:CC FLAGS_REG)
6751         (unspec:CC
6752           [(match_operand:V16QI 0 "register_operand" "x,x,x,x")
6753            (match_operand:SI 1 "register_operand" "a,a,a,a")
6754            (match_operand:V16QI 2 "nonimmediate_operand" "x,m,x,m")
6755            (match_operand:SI 3 "register_operand" "d,d,d,d")
6756            (match_operand:SI 4 "const_0_to_255_operand" "n,n,n,n")]
6757           UNSPEC_PCMPESTR))
6758    (clobber (match_scratch:V16QI 5 "=Y0,Y0,X,X"))
6759    (clobber (match_scratch:SI    6 "= X, X,c,c"))]
6760   "TARGET_SSE4_2"
6761   "@
6762    pcmpestrm\t{%4, %2, %0|%0, %2, %4}
6763    pcmpestrm\t{%4, %2, %0|%0, %2, %4}
6764    pcmpestri\t{%4, %2, %0|%0, %2, %4}
6765    pcmpestri\t{%4, %2, %0|%0, %2, %4}"
6766   [(set_attr "type" "sselog")
6767    (set_attr "prefix_data16" "1")
6768    (set_attr "prefix_extra" "1")
6769    (set_attr "memory" "none,load,none,load")
6770    (set_attr "mode" "TI")])
6771
6772 (define_insn_and_split "sse4_2_pcmpistr"
6773   [(set (match_operand:SI 0 "register_operand" "=c,c")
6774         (unspec:SI
6775           [(match_operand:V16QI 2 "register_operand" "x,x")
6776            (match_operand:V16QI 3 "nonimmediate_operand" "x,m")
6777            (match_operand:SI 4 "const_0_to_255_operand" "n,n")]
6778           UNSPEC_PCMPISTR))
6779    (set (match_operand:V16QI 1 "register_operand" "=Y0,Y0")
6780         (unspec:V16QI
6781           [(match_dup 2)
6782            (match_dup 3)
6783            (match_dup 4)]
6784           UNSPEC_PCMPISTR))
6785    (set (reg:CC FLAGS_REG)
6786         (unspec:CC
6787           [(match_dup 2)
6788            (match_dup 3)
6789            (match_dup 4)]
6790           UNSPEC_PCMPISTR))]
6791   "TARGET_SSE4_2
6792    && !(reload_completed || reload_in_progress)"
6793   "#"
6794   "&& 1"
6795   [(const_int 0)]
6796 {
6797   int ecx = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[0]));
6798   int xmm0 = !find_regno_note (curr_insn, REG_UNUSED, REGNO (operands[1]));
6799   int flags = !find_regno_note (curr_insn, REG_UNUSED, FLAGS_REG);
6800
6801   if (ecx)
6802     emit_insn (gen_sse4_2_pcmpistri (operands[0], operands[2],
6803                                      operands[3], operands[4]));
6804   if (xmm0)
6805     emit_insn (gen_sse4_2_pcmpistrm (operands[1], operands[2],
6806                                      operands[3], operands[4]));
6807   if (flags && !(ecx || xmm0))
6808     emit_insn (gen_sse4_2_pcmpistr_cconly (operands[2], operands[3],
6809                                            operands[4]));
6810   DONE;
6811 }
6812   [(set_attr "type" "sselog")
6813    (set_attr "prefix_data16" "1")
6814    (set_attr "prefix_extra" "1")
6815    (set_attr "memory" "none,load")
6816    (set_attr "mode" "TI")])
6817
6818 (define_insn "sse4_2_pcmpistri"
6819   [(set (match_operand:SI 0 "register_operand" "=c,c")
6820         (unspec:SI
6821           [(match_operand:V16QI 1 "register_operand" "x,x")
6822            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
6823            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
6824           UNSPEC_PCMPISTR))
6825    (set (reg:CC FLAGS_REG)
6826         (unspec:CC
6827           [(match_dup 1)
6828            (match_dup 2)
6829            (match_dup 3)]
6830           UNSPEC_PCMPISTR))]
6831   "TARGET_SSE4_2"
6832   "pcmpistri\t{%3, %2, %1|%1, %2, %3}"
6833   [(set_attr "type" "sselog")
6834    (set_attr "prefix_data16" "1")
6835    (set_attr "prefix_extra" "1")
6836    (set_attr "memory" "none,load")
6837    (set_attr "mode" "TI")])
6838
6839 (define_insn "sse4_2_pcmpistrm"
6840   [(set (match_operand:V16QI 0 "register_operand" "=Y0,Y0")
6841         (unspec:V16QI
6842           [(match_operand:V16QI 1 "register_operand" "x,x")
6843            (match_operand:V16QI 2 "nonimmediate_operand" "x,m")
6844            (match_operand:SI 3 "const_0_to_255_operand" "n,n")]
6845           UNSPEC_PCMPISTR))
6846    (set (reg:CC FLAGS_REG)
6847         (unspec:CC
6848           [(match_dup 1)
6849            (match_dup 2)
6850            (match_dup 3)]
6851           UNSPEC_PCMPISTR))]
6852   "TARGET_SSE4_2"
6853   "pcmpistrm\t{%3, %2, %1|%1, %2, %3}"
6854   [(set_attr "type" "sselog")
6855    (set_attr "prefix_data16" "1")
6856    (set_attr "prefix_extra" "1")
6857    (set_attr "memory" "none,load")
6858    (set_attr "mode" "TI")])
6859
6860 (define_insn "sse4_2_pcmpistr_cconly"
6861   [(set (reg:CC FLAGS_REG)
6862         (unspec:CC
6863           [(match_operand:V16QI 0 "register_operand" "x,x,x,x")
6864            (match_operand:V16QI 1 "nonimmediate_operand" "x,m,x,m")
6865            (match_operand:SI 2 "const_0_to_255_operand" "n,n,n,n")]
6866           UNSPEC_PCMPISTR))
6867    (clobber (match_scratch:V16QI 3 "=Y0,Y0,X,X"))
6868    (clobber (match_scratch:SI    4 "= X, X,c,c"))]
6869   "TARGET_SSE4_2"
6870   "@
6871    pcmpistrm\t{%2, %1, %0|%0, %1, %2}
6872    pcmpistrm\t{%2, %1, %0|%0, %1, %2}
6873    pcmpistri\t{%2, %1, %0|%0, %1, %2}
6874    pcmpistri\t{%2, %1, %0|%0, %1, %2}"
6875   [(set_attr "type" "sselog")
6876    (set_attr "prefix_data16" "1")
6877    (set_attr "prefix_extra" "1")
6878    (set_attr "memory" "none,load,none,load")
6879    (set_attr "mode" "TI")])