LCOV - code coverage report
Current view: top level - gcc/config/i386 - mmx.md (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1901 2114 89.9 %
Date: 2020-03-28 11:57:23 Functions: 112 155 72.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : ;; GCC machine description for MMX and 3dNOW! instructions
       2                 :            : ;; Copyright (C) 2005-2020 Free Software Foundation, Inc.
       3                 :            : ;;
       4                 :            : ;; This file is part of GCC.
       5                 :            : ;;
       6                 :            : ;; GCC is free software; you can redistribute it and/or modify
       7                 :            : ;; it under the terms of the GNU General Public License as published by
       8                 :            : ;; the Free Software Foundation; either version 3, or (at your option)
       9                 :            : ;; any later version.
      10                 :            : ;;
      11                 :            : ;; GCC is distributed in the hope that it will be useful,
      12                 :            : ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            : ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            : ;; GNU General Public License for more details.
      15                 :            : ;;
      16                 :            : ;; You should have received a copy of the GNU General Public License
      17                 :            : ;; along with GCC; see the file COPYING3.  If not see
      18                 :            : ;; <http://www.gnu.org/licenses/>.
      19                 :            : 
      20                 :            : ;; The MMX and 3dNOW! patterns are in the same file because they use
      21                 :            : ;; the same register file, and 3dNOW! adds a number of extensions to
      22                 :            : ;; the base integer MMX isa.
      23                 :            : 
      24                 :            : ;; Note!  Except for the basic move instructions, *all* of these
      25                 :            : ;; patterns are outside the normal optabs namespace.  This is because
      26                 :            : ;; use of these registers requires the insertion of emms or femms
      27                 :            : ;; instructions to return to normal fpu mode.  The compiler doesn't
      28                 :            : ;; know how to do that itself, which means it's up to the user.  Which
      29                 :            : ;; means that we should never use any of these patterns except at the
      30                 :            : ;; direction of the user via a builtin.
      31                 :            : 
      32                 :            : (define_c_enum "unspec" [
      33                 :            :   UNSPEC_MOVNTQ
      34                 :            :   UNSPEC_PFRCP
      35                 :            :   UNSPEC_PFRCPIT1
      36                 :            :   UNSPEC_PFRCPIT2
      37                 :            :   UNSPEC_PFRSQRT
      38                 :            :   UNSPEC_PFRSQIT1
      39                 :            : ])
      40                 :            : 
      41                 :            : (define_c_enum "unspecv" [
      42                 :            :   UNSPECV_EMMS
      43                 :            :   UNSPECV_FEMMS
      44                 :            : ])
      45                 :            : 
      46                 :            : ;; 8 byte integral modes handled by MMX (and by extension, SSE)
      47                 :            : (define_mode_iterator MMXMODEI [V8QI V4HI V2SI])
      48                 :         92 : (define_mode_iterator MMXMODEI8 [V8QI V4HI V2SI (V1DI "TARGET_SSE2")])
      49                 :         25 : 
      50                 :            : ;; All 8-byte vector modes handled by MMX
      51                 :            : (define_mode_iterator MMXMODE [V8QI V4HI V2SI V1DI V2SF])
      52                 :            : 
      53                 :            : ;; Mix-n-match
      54                 :            : (define_mode_iterator MMXMODE12 [V8QI V4HI])
      55                 :            : (define_mode_iterator MMXMODE24 [V4HI V2SI])
      56                 :        172 : (define_mode_iterator MMXMODE248 [V4HI V2SI V1DI])
      57                 :        172 : 
      58                 :            : ;; Mapping from integer vector mode to mnemonic suffix
      59                 :         66 : (define_mode_attr mmxvecsize [(V8QI "b") (V4HI "w") (V2SI "d") (V1DI "q")])
      60                 :        124 : 
      61                 :          4 : (define_mode_attr mmxdoublemode
      62                 :            :   [(V8QI "V8HI") (V4HI "V4SI")])
      63                 :          2 : 
      64                 :          2 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
      65                 :          4 : ;;
      66                 :            : ;; Move patterns
      67                 :            : ;;
      68                 :            : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
      69                 :            : 
      70                 :            : ;; All of these patterns are enabled for MMX as well as 3dNOW.
      71                 :            : ;; This is essential for maintaining stable calling conventions.
      72                 :            : 
      73                 :            : (define_expand "mov<mode>"
      74                 :            :   [(set (match_operand:MMXMODE 0 "nonimmediate_operand")
      75                 :            :         (match_operand:MMXMODE 1 "nonimmediate_operand"))]
      76                 :            :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
      77                 :      82600 : {
      78                 :       4600 :   ix86_expand_vector_move (<MODE>mode, operands);
      79                 :      82600 :   DONE;
      80                 :            : })
      81                 :            : 
      82                 :            : (define_insn "*mov<mode>_internal"
      83                 :            :   [(set (match_operand:MMXMODE 0 "nonimmediate_operand"
      84                 :            :     "=r ,o ,r,r ,m ,?!y,!y,?!y,m  ,r  ,?!y,v,v,v,m,r,v,!y,*x")
      85                 :            :         (match_operand:MMXMODE 1 "nonimm_or_0_operand"
      86                 :            :     "rCo,rC,C,rm,rC,C  ,!y,m  ,?!y,?!y,r  ,C,v,m,v,v,r,*x,!y"))]
      87                 :    7201500 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
      88                 :   34347000 :    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
      89                 :      46616 : {
      90                 :      46616 :   switch (get_attr_type (insn))
      91                 :            :     {
      92                 :   28810600 :     case TYPE_MULTI:
      93                 :   28810600 :       return "#";
      94                 :   27728300 : 
      95                 :   56455566 :     case TYPE_IMOV:
      96                 :      29566 :       if (get_attr_mode (insn) == MODE_SI)
      97                 :      78000 :         return "mov{l}\t{%1, %k0|%k0, %1}";
      98                 :          0 :       else
      99                 :      29531 :         return "mov{q}\t{%1, %0|%0, %1}";
     100                 :      78000 : 
     101                 :      78000 :     case TYPE_MMX:
     102                 :          0 :       return "pxor\t%0, %0";
     103                 :          0 : 
     104                 :      78640 :     case TYPE_MMXMOV:
     105                 :      78000 :       /* Handle broken assemblers that require movd instead of movq.  */
     106                 :        640 :       if (!HAVE_AS_IX86_INTERUNIT_MOVQ
     107                 :            :           && (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1])))
     108                 :            :         return "movd\t{%1, %0|%0, %1}";
     109                 :        640 :       return "movq\t{%1, %0|%0, %1}";
     110                 :            : 
     111                 :         70 :     case TYPE_SSECVT:
     112                 :         70 :       if (SSE_REG_P (operands[0]))
     113                 :            :         return "movq2dq\t{%1, %0|%0, %1}";
     114                 :            :       else
     115                 :         20 :         return "movdq2q\t{%1, %0|%0, %1}";
     116                 :            : 
     117                 :        148 :     case TYPE_SSELOG1:
     118                 :        148 :       return standard_sse_constant_opcode (insn, operands);
     119                 :            : 
     120                 :      16192 :     case TYPE_SSEMOV:
     121                 :      16192 :       return ix86_output_ssemov (insn, operands);
     122                 :            : 
     123                 :          0 :     default:
     124                 :          0 :       gcc_unreachable ();
     125                 :            :     }
     126                 :            : }
     127                 :            :   [(set (attr "isa")
     128                 :            :      (cond [(eq_attr "alternative" "0,1")
     129                 :            :               (const_string "nox64")
     130                 :      43457 :             (eq_attr "alternative" "2,3,4,9,10")
     131                 :            :               (const_string "x64")
     132                 :            :             (eq_attr "alternative" "15,16")
     133                 :            :               (const_string "x64_sse2")
     134                 :            :             (eq_attr "alternative" "17,18")
     135                 :            :               (const_string "sse2")
     136                 :            :            ]
     137                 :            :            (const_string "*")))
     138                 :            :    (set (attr "type")
     139                 :            :      (cond [(eq_attr "alternative" "0,1")
     140                 :            :               (const_string "multi")
     141                 :            :             (eq_attr "alternative" "2,3,4")
     142                 :            :               (const_string "imov")
     143                 :            :             (eq_attr "alternative" "5")
     144                 :            :               (const_string "mmx")
     145                 :            :             (eq_attr "alternative" "6,7,8,9,10")
     146                 :            :               (const_string "mmxmov")
     147                 :            :             (eq_attr "alternative" "11")
     148                 :            :               (const_string "sselog1")
     149                 :            :             (eq_attr "alternative" "17,18")
     150                 :            :               (const_string "ssecvt")
     151                 :            :            ]
     152                 :            :            (const_string "ssemov")))
     153                 :            :    (set (attr "prefix_rex")
     154                 :            :      (if_then_else (eq_attr "alternative" "9,10,15,16")
     155                 :            :        (const_string "1")
     156                 :            :        (const_string "*")))
     157                 :            :    (set (attr "prefix")
     158                 :            :      (if_then_else (eq_attr "type" "sselog1,ssemov")
     159                 :            :        (const_string "maybe_vex")
     160                 :            :        (const_string "orig")))
     161                 :            :    (set (attr "prefix_data16")
     162                 :            :      (if_then_else
     163                 :            :        (and (eq_attr "type" "ssemov") (eq_attr "mode" "DI"))
     164                 :            :        (const_string "1")
     165                 :            :        (const_string "*")))
     166                 :            :    (set (attr "mode")
     167                 :            :      (cond [(eq_attr "alternative" "2")
     168                 :            :               (const_string "SI")
     169                 :            :             (eq_attr "alternative" "11,12")
     170                 :     386658 :               (cond [(match_test "<MODE>mode == V2SFmode")
     171                 :            :                        (const_string "V4SF")
     172                 :            :                      (ior (not (match_test "TARGET_SSE2"))
     173                 :            :                           (match_test "optimize_function_for_size_p (cfun)"))
     174                 :      18489 :                        (const_string "V4SF")
     175                 :            :                     ]
     176                 :            :                     (const_string "TI"))
     177                 :            : 
     178                 :            :             (and (eq_attr "alternative" "13,14")
     179                 :            :                  (ior (match_test "<MODE>mode == V2SFmode")
     180                 :            :                       (not (match_test "TARGET_SSE2"))))
     181                 :            :               (const_string "V2SF")
     182                 :            :            ]
     183                 :            :            (const_string "DI")))
     184                 :            :    (set (attr "preferred_for_speed")
     185                 :            :      (cond [(eq_attr "alternative" "9,15")
     186                 :            :               (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
     187                 :            :             (eq_attr "alternative" "10,16")
     188                 :            :               (symbol_ref "TARGET_INTER_UNIT_MOVES_TO_VEC")
     189                 :            :            ]
     190                 :            :            (symbol_ref "true")))])
     191                 :            : 
     192                 :            : (define_split
     193                 :            :   [(set (match_operand:MMXMODE 0 "nonimmediate_gr_operand")
     194                 :            :         (match_operand:MMXMODE 1 "nonimmediate_gr_operand"))]
     195                 :       4533 :   "!TARGET_64BIT && reload_completed"
     196                 :         12 :   [(const_int 0)]
     197                 :         12 :   "ix86_split_long_move (operands); DONE;")
     198                 :            : 
     199                 :     536859 : (define_split
     200                 :     536859 :   [(set (match_operand:MMXMODE 0 "nonimmediate_gr_operand")
     201                 :     270454 :         (match_operand:MMXMODE 1 "const0_operand"))]
     202                 :     605453 :   "!TARGET_64BIT && reload_completed"
     203                 :          0 :   [(const_int 0)]
     204                 :          0 :   "ix86_split_long_move (operands); DONE;")
     205                 :            : 
     206                 :       1100 : (define_expand "movmisalign<mode>"
     207                 :       1100 :   [(set (match_operand:MMXMODE 0 "nonimmediate_operand")
     208                 :        709 :         (match_operand:MMXMODE 1 "nonimmediate_operand"))]
     209                 :       1819 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
     210                 :       7901 : {
     211                 :       7913 :   ix86_expand_vector_move (<MODE>mode, operands);
     212                 :       7913 :   DONE;
     213                 :          0 : })
     214                 :   69591212 : 
     215                 :   69591732 : (define_insn "sse_movntq"
     216                 :          0 :   [(set (match_operand:DI 0 "memory_operand" "=m,m")
     217                 :        180 :         (unspec:DI [(match_operand:DI 1 "register_operand" "y,r")]
     218                 :        712 :                    UNSPEC_MOVNTQ))]
     219                 :        745 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
     220                 :        573 :    && (TARGET_SSE || TARGET_3DNOW_A)"
     221                 :          0 :   "@
     222                 :        532 :    movntq\t{%1, %0|%0, %1}
     223                 :        532 :    movnti\t{%1, %0|%0, %1}"
     224                 :        475 :   [(set_attr "isa" "*,x64")
     225                 :        475 :    (set_attr "mmx_isa" "native,*")
     226                 :        475 :    (set_attr "type" "mmxmov,ssemov")
     227                 :        475 :    (set_attr "mode" "DI")])
     228                 :            : 
     229                 :        110 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     230                 :       7496 : ;;
     231                 :         91 : ;; Parallel single-precision floating point arithmetic
     232                 :         91 : ;;
     233                 :       7546 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     234                 :       7369 : 
     235                 :         17 : (define_expand "mmx_addv2sf3"
     236                 :       7386 :   [(set (match_operand:V2SF 0 "register_operand")
     237                 :       7386 :         (plus:V2SF
     238                 :       7369 :           (match_operand:V2SF 1 "nonimmediate_operand")
     239                 :         17 :           (match_operand:V2SF 2 "nonimmediate_operand")))]
     240                 :         17 :   "TARGET_3DNOW"
     241                 :         17 :   "ix86_fixup_binary_operands_no_copy (PLUS, V2SFmode, operands);")
     242                 :            : 
     243                 :            : (define_insn "*mmx_addv2sf3"
     244                 :         17 :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     245                 :         17 :         (plus:V2SF (match_operand:V2SF 1 "nonimmediate_operand" "%0")
     246                 :         17 :                    (match_operand:V2SF 2 "nonimmediate_operand" "ym")))]
     247                 :         55 :   "TARGET_3DNOW && ix86_binary_operator_ok (PLUS, V2SFmode, operands)"
     248                 :         17 :   "pfadd\t{%2, %0|%0, %2}"
     249                 :         17 :   [(set_attr "type" "mmxadd")
     250                 :            :    (set_attr "prefix_extra" "1")
     251                 :        635 :    (set_attr "mode" "V2SF")])
     252                 :        618 : 
     253                 :        814 : (define_expand "mmx_subv2sf3"
     254                 :            :   [(set (match_operand:V2SF 0 "register_operand")
     255                 :         17 :         (minus:V2SF (match_operand:V2SF 1 "register_operand")
     256                 :         17 :                     (match_operand:V2SF 2 "nonimmediate_operand")))]
     257                 :         17 :   "TARGET_3DNOW")
     258                 :            : 
     259                 :            : (define_expand "mmx_subrv2sf3"
     260                 :            :   [(set (match_operand:V2SF 0 "register_operand")
     261                 :            :         (minus:V2SF (match_operand:V2SF 2 "register_operand")
     262                 :         15 :                     (match_operand:V2SF 1 "nonimmediate_operand")))]
     263                 :            :   "TARGET_3DNOW")
     264                 :            : 
     265                 :            : (define_insn "*mmx_subv2sf3"
     266                 :         15 :   [(set (match_operand:V2SF 0 "register_operand" "=y,y")
     267                 :            :         (minus:V2SF (match_operand:V2SF 1 "nonimmediate_operand" "0,ym")
     268                 :            :                     (match_operand:V2SF 2 "nonimmediate_operand" "ym,0")))]
     269                 :         62 :   "TARGET_3DNOW && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
     270                 :          0 :   "@
     271                 :            :    pfsub\t{%2, %0|%0, %2}
     272                 :            :    pfsubr\t{%1, %0|%0, %1}"
     273                 :         75 :   [(set_attr "type" "mmxadd")
     274                 :         89 :    (set_attr "prefix_extra" "1")
     275                 :        144 :    (set_attr "mode" "V2SF")])
     276                 :            : 
     277                 :            : (define_expand "mmx_mulv2sf3"
     278                 :         14 :   [(set (match_operand:V2SF 0 "register_operand")
     279                 :            :         (mult:V2SF (match_operand:V2SF 1 "nonimmediate_operand")
     280                 :            :                    (match_operand:V2SF 2 "nonimmediate_operand")))]
     281                 :            :   "TARGET_3DNOW"
     282                 :         15 :   "ix86_fixup_binary_operands_no_copy (MULT, V2SFmode, operands);")
     283                 :            : 
     284                 :            : (define_insn "*mmx_mulv2sf3"
     285                 :         15 :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     286                 :         30 :         (mult:V2SF (match_operand:V2SF 1 "nonimmediate_operand" "%0")
     287                 :         15 :                    (match_operand:V2SF 2 "nonimmediate_operand" "ym")))]
     288                 :         47 :   "TARGET_3DNOW && ix86_binary_operator_ok (MULT, V2SFmode, operands)"
     289                 :         15 :   "pfmul\t{%2, %0|%0, %2}"
     290                 :         30 :   [(set_attr "type" "mmxmul")
     291                 :         15 :    (set_attr "prefix_extra" "1")
     292                 :       2800 :    (set_attr "mode" "V2SF")])
     293                 :       2800 : 
     294                 :       4507 : (define_expand "mmx_<code>v2sf3"
     295                 :         15 :   [(set (match_operand:V2SF 0 "register_operand")
     296                 :         30 :         (smaxmin:V2SF
     297                 :         15 :           (match_operand:V2SF 1 "nonimmediate_operand")
     298                 :         15 :           (match_operand:V2SF 2 "nonimmediate_operand")))]
     299                 :            :   "TARGET_3DNOW"
     300                 :         28 : {
     301                 :          0 :   if (!flag_finite_math_only || flag_signed_zeros)
     302                 :            :     {
     303                 :         28 :       operands[1] = force_reg (V2SFmode, operands[1]);
     304                 :         28 :       emit_insn (gen_mmx_ieee_<maxmin_float>v2sf3
     305                 :            :                  (operands[0], operands[1], operands[2]));
     306                 :         28 :       DONE;
     307                 :         14 :     }
     308                 :         14 :   else
     309                 :          0 :     ix86_fixup_binary_operands_no_copy (<CODE>, V2SFmode, operands);
     310                 :         14 : })
     311                 :         14 : 
     312                 :         14 : ;; These versions of the min/max patterns are intentionally ignorant of
     313                 :         14 : ;; their behavior wrt -0.0 and NaN (via the commutative operand mark).
     314                 :          0 : ;; Since both the tree-level MAX_EXPR and the rtl-level SMAX operator
     315                 :          0 : ;; are undefined in this condition, we're certain this is correct.
     316                 :          0 : 
     317                 :          0 : (define_insn "*mmx_<code>v2sf3"
     318                 :          0 :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     319                 :            :         (smaxmin:V2SF
     320                 :          0 :           (match_operand:V2SF 1 "nonimmediate_operand" "%0")
     321                 :            :           (match_operand:V2SF 2 "nonimmediate_operand" "ym")))]
     322                 :          0 :   "TARGET_3DNOW && ix86_binary_operator_ok (<CODE>, V2SFmode, operands)"
     323                 :            :   "pf<maxmin_float>\t{%2, %0|%0, %2}"
     324                 :          0 :   [(set_attr "type" "mmxadd")
     325                 :          0 :    (set_attr "prefix_extra" "1")
     326                 :         92 :    (set_attr "mode" "V2SF")])
     327                 :         92 : 
     328                 :            : ;; These versions of the min/max patterns implement exactly the operations
     329                 :            : ;;   min = (op1 < op2 ? op1 : op2)
     330                 :            : ;;   max = (!(op1 < op2) ? op1 : op2)
     331                 :         28 : ;; Their operands are not commutative, and thus they may be used in the
     332                 :            : ;; presence of -0.0 and NaN.
     333                 :            : 
     334                 :            : (define_insn "mmx_ieee_<ieee_maxmin>v2sf3"
     335                 :         28 :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     336                 :         28 :         (unspec:V2SF
     337                 :         28 :           [(match_operand:V2SF 1 "register_operand" "0")
     338                 :         28 :            (match_operand:V2SF 2 "nonimmediate_operand" "ym")]
     339                 :         28 :           IEEE_MAXMIN))]
     340                 :        104 :   "TARGET_3DNOW"
     341                 :         14 :   "pf<ieee_maxmin>\t{%2, %0|%0, %2}"
     342                 :            :   [(set_attr "type" "mmxadd")
     343                 :            :    (set_attr "prefix_extra" "1")
     344                 :            :    (set_attr "mode" "V2SF")])
     345                 :            : 
     346                 :            : (define_insn "mmx_rcpv2sf2"
     347                 :            :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     348                 :       5101 :         (unspec:V2SF [(match_operand:V2SF 1 "nonimmediate_operand" "ym")]
     349                 :       5101 :                      UNSPEC_PFRCP))]
     350                 :         30 :   "TARGET_3DNOW"
     351                 :          0 :   "pfrcp\t{%1, %0|%0, %1}"
     352                 :       2117 :   [(set_attr "type" "mmx")
     353                 :          0 :    (set_attr "prefix_extra" "1")
     354                 :          0 :    (set_attr "mode" "V2SF")])
     355                 :         30 : 
     356                 :          0 : (define_insn "mmx_rcpit1v2sf3"
     357                 :         30 :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     358                 :         30 :         (unspec:V2SF [(match_operand:V2SF 1 "register_operand" "0")
     359                 :         30 :                       (match_operand:V2SF 2 "nonimmediate_operand" "ym")]
     360                 :          0 :                      UNSPEC_PFRCPIT1))]
     361                 :         30 :   "TARGET_3DNOW"
     362                 :          0 :   "pfrcpit1\t{%2, %0|%0, %2}"
     363                 :         30 :   [(set_attr "type" "mmx")
     364                 :         30 :    (set_attr "prefix_extra" "1")
     365                 :          0 :    (set_attr "mode" "V2SF")])
     366                 :         30 : 
     367                 :         30 : (define_insn "mmx_rcpit2v2sf3"
     368                 :            :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     369                 :            :         (unspec:V2SF [(match_operand:V2SF 1 "register_operand" "0")
     370                 :            :                       (match_operand:V2SF 2 "nonimmediate_operand" "ym")]
     371                 :            :                      UNSPEC_PFRCPIT2))]
     372                 :         30 :   "TARGET_3DNOW"
     373                 :          0 :   "pfrcpit2\t{%2, %0|%0, %2}"
     374                 :            :   [(set_attr "type" "mmx")
     375                 :            :    (set_attr "prefix_extra" "1")
     376                 :         30 :    (set_attr "mode" "V2SF")])
     377                 :         30 : 
     378                 :         30 : (define_insn "mmx_rsqrtv2sf2"
     379                 :            :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     380                 :            :         (unspec:V2SF [(match_operand:V2SF 1 "nonimmediate_operand" "ym")]
     381                 :            :                      UNSPEC_PFRSQRT))]
     382                 :         30 :   "TARGET_3DNOW"
     383                 :          0 :   "pfrsqrt\t{%1, %0|%0, %1}"
     384                 :            :   [(set_attr "type" "mmx")
     385                 :            :    (set_attr "prefix_extra" "1")
     386                 :        794 :    (set_attr "mode" "V2SF")])
     387                 :        794 : 
     388                 :            : (define_insn "mmx_rsqit1v2sf3"
     389                 :         33 :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     390                 :         33 :         (unspec:V2SF [(match_operand:V2SF 1 "register_operand" "0")
     391                 :         33 :                       (match_operand:V2SF 2 "nonimmediate_operand" "ym")]
     392                 :            :                      UNSPEC_PFRSQIT1))]
     393                 :         30 :   "TARGET_3DNOW"
     394                 :          0 :   "pfrsqit1\t{%2, %0|%0, %2}"
     395                 :         33 :   [(set_attr "type" "mmx")
     396                 :         33 :    (set_attr "prefix_extra" "1")
     397                 :      17297 :    (set_attr "mode" "V2SF")])
     398                 :      17297 : 
     399                 :      17297 : (define_insn "mmx_haddv2sf3"
     400                 :            :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     401                 :            :         (vec_concat:V2SF
     402                 :            :           (plus:SF
     403                 :            :             (vec_select:SF
     404                 :            :               (match_operand:V2SF 1 "register_operand" "0")
     405                 :            :               (parallel [(const_int  0)]))
     406                 :            :             (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
     407                 :            :           (plus:SF
     408                 :            :             (vec_select:SF
     409                 :            :               (match_operand:V2SF 2 "nonimmediate_operand" "ym")
     410                 :            :               (parallel [(const_int  0)]))
     411                 :            :             (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))))]
     412                 :         30 :   "TARGET_3DNOW"
     413                 :          0 :   "pfacc\t{%2, %0|%0, %2}"
     414                 :            :   [(set_attr "type" "mmxadd")
     415                 :            :    (set_attr "prefix_extra" "1")
     416                 :         31 :    (set_attr "mode" "V2SF")])
     417                 :         32 : 
     418                 :            : (define_insn "mmx_hsubv2sf3"
     419                 :            :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     420                 :            :         (vec_concat:V2SF
     421                 :            :           (minus:SF
     422                 :            :             (vec_select:SF
     423                 :            :               (match_operand:V2SF 1 "register_operand" "0")
     424                 :            :               (parallel [(const_int  0)]))
     425                 :            :             (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
     426                 :            :           (minus:SF
     427                 :            :             (vec_select:SF
     428                 :            :               (match_operand:V2SF 2 "nonimmediate_operand" "ym")
     429                 :            :               (parallel [(const_int  0)]))
     430                 :            :             (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))))]
     431                 :         31 :   "TARGET_3DNOW_A"
     432                 :          0 :   "pfnacc\t{%2, %0|%0, %2}"
     433                 :            :   [(set_attr "type" "mmxadd")
     434                 :            :    (set_attr "prefix_extra" "1")
     435                 :         31 :    (set_attr "mode" "V2SF")])
     436                 :         32 : 
     437                 :            : (define_insn "mmx_addsubv2sf3"
     438                 :            :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     439                 :            :         (vec_merge:V2SF
     440                 :            :           (plus:V2SF
     441                 :            :             (match_operand:V2SF 1 "register_operand" "0")
     442                 :            :             (match_operand:V2SF 2 "nonimmediate_operand" "ym"))
     443                 :            :           (minus:V2SF (match_dup 1) (match_dup 2))
     444                 :            :           (const_int 1)))]
     445                 :         30 :   "TARGET_3DNOW_A"
     446                 :          0 :   "pfpnacc\t{%2, %0|%0, %2}"
     447                 :            :   [(set_attr "type" "mmxadd")
     448                 :            :    (set_attr "prefix_extra" "1")
     449                 :     130912 :    (set_attr "mode" "V2SF")])
     450                 :     130912 : 
     451                 :     130912 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     452                 :     130912 : ;;
     453                 :     130912 : ;; Parallel single-precision floating point comparisons
     454                 :     130912 : ;;
     455                 :     130912 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     456                 :     130912 : 
     457                 :            : (define_expand "mmx_eqv2sf3"
     458                 :     123868 :   [(set (match_operand:V2SI 0 "register_operand")
     459                 :            :         (eq:V2SI (match_operand:V2SF 1 "nonimmediate_operand")
     460                 :          0 :                  (match_operand:V2SF 2 "nonimmediate_operand")))]
     461                 :          0 :   "TARGET_3DNOW"
     462                 :         14 :   "ix86_fixup_binary_operands_no_copy (EQ, V2SFmode, operands);")
     463                 :            : 
     464                 :            : (define_insn "*mmx_eqv2sf3"
     465                 :         14 :   [(set (match_operand:V2SI 0 "register_operand" "=y")
     466                 :         14 :         (eq:V2SI (match_operand:V2SF 1 "nonimmediate_operand" "%0")
     467                 :         14 :                  (match_operand:V2SF 2 "nonimmediate_operand" "ym")))]
     468                 :         44 :   "TARGET_3DNOW && ix86_binary_operator_ok (EQ, V2SFmode, operands)"
     469                 :         14 :   "pfcmpeq\t{%2, %0|%0, %2}"
     470                 :         14 :   [(set_attr "type" "mmxcmp")
     471                 :            :    (set_attr "prefix_extra" "1")
     472                 :         87 :    (set_attr "mode" "V2SF")])
     473                 :         73 : 
     474                 :         71 : (define_insn "mmx_gtv2sf3"
     475                 :         73 :   [(set (match_operand:V2SI 0 "register_operand" "=y")
     476                 :         14 :         (gt:V2SI (match_operand:V2SF 1 "register_operand" "0")
     477                 :         14 :                  (match_operand:V2SF 2 "nonimmediate_operand" "ym")))]
     478                 :         44 :   "TARGET_3DNOW"
     479                 :            :   "pfcmpgt\t{%2, %0|%0, %2}"
     480                 :            :   [(set_attr "type" "mmxcmp")
     481                 :            :    (set_attr "prefix_extra" "1")
     482                 :         73 :    (set_attr "mode" "V2SF")])
     483                 :         73 : 
     484                 :         71 : (define_insn "mmx_gev2sf3"
     485                 :         73 :   [(set (match_operand:V2SI 0 "register_operand" "=y")
     486                 :          0 :         (ge:V2SI (match_operand:V2SF 1 "register_operand" "0")
     487                 :          0 :                  (match_operand:V2SF 2 "nonimmediate_operand" "ym")))]
     488                 :         30 :   "TARGET_3DNOW"
     489                 :          0 :   "pfcmpge\t{%2, %0|%0, %2}"
     490                 :          0 :   [(set_attr "type" "mmxcmp")
     491                 :          0 :    (set_attr "prefix_extra" "1")
     492                 :            :    (set_attr "mode" "V2SF")])
     493                 :            : 
     494                 :            : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     495                 :     672322 : ;;
     496                 :     672322 : ;; Parallel single-precision floating point conversion operations
     497                 :            : ;;
     498                 :       6833 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     499                 :       6833 : 
     500                 :       6833 : (define_insn "mmx_pf2id"
     501                 :        803 :   [(set (match_operand:V2SI 0 "register_operand" "=y")
     502                 :       6030 :         (fix:V2SI (match_operand:V2SF 1 "nonimmediate_operand" "ym")))]
     503                 :         30 :   "TARGET_3DNOW"
     504                 :          0 :   "pf2id\t{%1, %0|%0, %1}"
     505                 :        658 :   [(set_attr "type" "mmxcvt")
     506                 :        498 :    (set_attr "prefix_extra" "1")
     507                 :        870 :    (set_attr "mode" "V2SF")])
     508                 :        475 : 
     509                 :        475 : (define_insn "mmx_pf2iw"
     510                 :            :   [(set (match_operand:V2SI 0 "register_operand" "=y")
     511                 :            :         (sign_extend:V2SI
     512                 :            :           (ss_truncate:V2HI
     513                 :            :             (fix:V2SI
     514                 :            :               (match_operand:V2SF 1 "nonimmediate_operand" "ym")))))]
     515                 :         30 :   "TARGET_3DNOW_A"
     516                 :          0 :   "pf2iw\t{%1, %0|%0, %1}"
     517                 :            :   [(set_attr "type" "mmxcvt")
     518                 :            :    (set_attr "prefix_extra" "1")
     519                 :            :    (set_attr "mode" "V2SF")])
     520                 :            : 
     521                 :          0 : (define_insn "mmx_pi2fw"
     522                 :            :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     523                 :            :         (float:V2SF
     524                 :            :           (sign_extend:V2SI
     525                 :     304013 :             (truncate:V2HI
     526                 :            :               (match_operand:V2SI 1 "nonimmediate_operand" "ym")))))]
     527                 :         28 :   "TARGET_3DNOW_A"
     528                 :          0 :   "pi2fw\t{%1, %0|%0, %1}"
     529                 :     304013 :   [(set_attr "type" "mmxcvt")
     530                 :     304013 :    (set_attr "prefix_extra" "1")
     531                 :     304013 :    (set_attr "mode" "V2SF")])
     532                 :     304013 : 
     533                 :     304013 : (define_insn "mmx_floatv2si2"
     534                 :     304013 :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     535                 :     304013 :         (float:V2SF (match_operand:V2SI 1 "nonimmediate_operand" "ym")))]
     536                 :        101 :   "TARGET_3DNOW"
     537                 :     304038 :   "pi2fd\t{%1, %0|%0, %1}"
     538                 :            :   [(set_attr "type" "mmxcvt")
     539                 :      60601 :    (set_attr "prefix_extra" "1")
     540                 :      60601 :    (set_attr "mode" "V2SF")])
     541                 :      57161 : 
     542                 :      57161 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     543                 :     111235 : ;;
     544                 :       5402 : ;; Parallel single-precision floating point element swizzling
     545                 :       4044 : ;;
     546                 :       1358 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     547                 :       1386 : 
     548                 :       1386 : (define_insn "mmx_pswapdv2sf2"
     549                 :       1358 :   [(set (match_operand:V2SF 0 "register_operand" "=y")
     550                 :         28 :         (vec_select:V2SF (match_operand:V2SF 1 "nonimmediate_operand" "ym")
     551                 :         56 :                          (parallel [(const_int 1) (const_int 0)])))]
     552                 :        460 :   "TARGET_3DNOW_A"
     553                 :          0 :   "pswapd\t{%1, %0|%0, %1}"
     554                 :         90 :   [(set_attr "type" "mmxcvt")
     555                 :         90 :    (set_attr "prefix_extra" "1")
     556                 :         28 :    (set_attr "mode" "V2SF")])
     557                 :         13 : 
     558                 :         13 : (define_insn_and_split "*vec_dupv2sf"
     559                 :         13 :   [(set (match_operand:V2SF 0 "register_operand" "=y,x,Yv")
     560                 :         13 :         (vec_duplicate:V2SF
     561                 :            :           (match_operand:SF 1 "register_operand" "0,0,Yv")))]
     562                 :          0 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
     563                 :          0 :   "@
     564                 :            :    punpckldq\t%0, %0
     565                 :            :    #
     566                 :        846 :    #"
     567                 :        846 :   "TARGET_SSE && reload_completed
     568                 :        743 :    && SSE_REGNO_P (REGNO (operands[0]))"
     569                 :        743 :   [(set (match_dup 0)
     570                 :        846 :         (vec_duplicate:V4SF (match_dup 1)))]
     571                 :          0 : {
     572                 :        535 :   operands[0] = lowpart_subreg (V4SFmode, operands[0],
     573                 :        535 :                                 GET_MODE (operands[0]));
     574                 :        526 : }
     575                 :        526 :   [(set_attr "isa" "*,sse_noavx,avx")
     576                 :        798 :    (set_attr "mmx_isa" "native,*,*")
     577                 :          0 :    (set_attr "type" "mmxcvt,ssemov,ssemov")
     578                 :          0 :    (set_attr "mode" "DI,TI,TI")])
     579                 :          0 : 
     580                 :          0 : (define_insn "*mmx_concatv2sf"
     581                 :          0 :   [(set (match_operand:V2SF 0 "register_operand"     "=y,y")
     582                 :            :         (vec_concat:V2SF
     583                 :            :           (match_operand:SF 1 "nonimmediate_operand" " 0,rm")
     584                 :          0 :           (match_operand:SF 2 "nonimm_or_0_operand"  "ym,C")))]
     585                 :      14575 :   "TARGET_MMX && !TARGET_SSE"
     586                 :          0 :   "@
     587                 :      14575 :    punpckldq\t{%2, %0|%0, %2}
     588                 :            :    movd\t{%1, %0|%0, %1}"
     589                 :            :   [(set_attr "type" "mmxcvt,mmxmov")
     590                 :            :    (set_attr "mode" "DI")])
     591                 :          0 : 
     592                 :            : (define_expand "vec_setv2sf"
     593                 :            :   [(match_operand:V2SF 0 "register_operand")
     594                 :            :    (match_operand:SF 1 "register_operand")
     595                 :          0 :    (match_operand 2 "const_int_operand")]
     596                 :          0 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
     597                 :          0 : {
     598                 :          0 :   ix86_expand_vector_set (TARGET_MMX_WITH_SSE, operands[0], operands[1],
     599                 :          0 :                           INTVAL (operands[2]));
     600                 :          0 :   DONE;
     601                 :          0 : })
     602                 :            : 
     603                 :            : ;; Avoid combining registers from different units in a single alternative,
     604                 :            : ;; see comment above inline_secondary_memory_needed function in i386.c
     605                 :            : (define_insn_and_split "*vec_extractv2sf_0"
     606                 :            :   [(set (match_operand:SF 0 "nonimmediate_operand"     "=x, m,y ,m,f,r")
     607                 :            :         (vec_select:SF
     608                 :            :           (match_operand:V2SF 1 "nonimmediate_operand" " xm,x,ym,y,m,m")
     609                 :            :           (parallel [(const_int 0)])))]
     610                 :         33 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
     611                 :         33 :    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
     612                 :            :   "#"
     613                 :         11 :   "&& reload_completed"
     614                 :          0 :   [(set (match_dup 0) (match_dup 1))]
     615                 :      21200 :   "operands[1] = gen_lowpart (SFmode, operands[1]);"
     616                 :      21200 :   [(set_attr "mmx_isa" "*,*,native,native,*,*")])
     617                 :      11174 : 
     618                 :      11174 : ;; Avoid combining registers from different units in a single alternative,
     619                 :          0 : ;; see comment above inline_secondary_memory_needed function in i386.c
     620                 :          0 : (define_insn "*vec_extractv2sf_1"
     621                 :          0 :   [(set (match_operand:SF 0 "nonimmediate_operand"     "=y,x,x,y,x,f,r")
     622                 :          0 :         (vec_select:SF
     623                 :            :           (match_operand:V2SF 1 "nonimmediate_operand" " 0,x,0,o,o,o,o")
     624                 :          0 :           (parallel [(const_int 1)])))]
     625                 :          6 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
     626                 :          6 :    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
     627                 :          0 :   "@
     628                 :          0 :    punpckhdq\t%0, %0
     629                 :          0 :    %vmovshdup\t{%1, %0|%0, %1}
     630                 :       7185 :    shufps\t{$0xe5, %0, %0|%0, %0, 0xe5}
     631                 :       7185 :    #
     632                 :       7173 :    #
     633                 :      14358 :    #
     634                 :          0 :    #"
     635                 :       7167 :   [(set_attr "isa" "*,sse3,noavx,*,*,*,*")
     636                 :          0 :    (set_attr "mmx_isa" "native,*,*,native,*,*,*")
     637                 :          0 :    (set_attr "type" "mmxcvt,sse,sseshuf1,mmxmov,ssemov,fmov,imov")
     638                 :          0 :    (set (attr "length_immediate")
     639                 :          0 :      (if_then_else (eq_attr "alternative" "2")
     640                 :            :                    (const_string "1")
     641                 :            :                    (const_string "*")))
     642                 :            :    (set (attr "prefix_rep")
     643                 :            :      (if_then_else (eq_attr "alternative" "1")
     644                 :            :                    (const_string "1")
     645                 :            :                    (const_string "*")))
     646                 :            :    (set_attr "prefix" "orig,maybe_vex,orig,orig,orig,orig,orig")
     647                 :            :    (set_attr "mode" "DI,V4SF,V4SF,SF,SF,SF,SF")])
     648                 :            : 
     649                 :            : (define_split
     650                 :            :   [(set (match_operand:SF 0 "register_operand")
     651                 :            :         (vec_select:SF
     652                 :            :           (match_operand:V2SF 1 "memory_operand")
     653                 :            :           (parallel [(const_int 1)])))]
     654                 :          0 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE) && reload_completed"
     655                 :          0 :   [(set (match_dup 0) (match_dup 1))]
     656                 :          0 :   "operands[1] = adjust_address (operands[1], SFmode, 4);")
     657                 :            : 
     658                 :       2671 : (define_expand "vec_extractv2sfsf"
     659                 :       2671 :   [(match_operand:SF 0 "register_operand")
     660                 :       2176 :    (match_operand:V2SF 1 "register_operand")
     661                 :       2176 :    (match_operand 2 "const_int_operand")]
     662                 :       2671 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
     663                 :          0 : {
     664                 :         20 :   ix86_expand_vector_extract (TARGET_MMX_WITH_SSE, operands[0],
     665                 :          0 :                               operands[1], INTVAL (operands[2]));
     666                 :         20 :   DONE;
     667                 :          0 : })
     668                 :            : 
     669                 :            : (define_expand "vec_initv2sfsf"
     670                 :            :   [(match_operand:V2SF 0 "register_operand")
     671                 :            :    (match_operand 1)]
     672                 :         20 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSE"
     673                 :         14 : {
     674                 :         14 :   ix86_expand_vector_init (TARGET_MMX_WITH_SSE, operands[0],
     675                 :            :                            operands[1]);
     676                 :         14 :   DONE;
     677                 :         20 : })
     678                 :         20 : 
     679                 :         20 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     680                 :         20 : ;;
     681                 :         20 : ;; Parallel integral arithmetic
     682                 :         20 : ;;
     683                 :            : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     684                 :            : 
     685                 :            : (define_expand "mmx_<plusminus_insn><mode>3"
     686                 :            :   [(set (match_operand:MMXMODEI8 0 "register_operand")
     687                 :         14 :         (plusminus:MMXMODEI8
     688                 :            :           (match_operand:MMXMODEI8 1 "register_mmxmem_operand")
     689                 :            :           (match_operand:MMXMODEI8 2 "register_mmxmem_operand")))]
     690                 :         14 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
     691                 :         14 :   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
     692                 :         14 : 
     693                 :         14 : (define_expand "<plusminus_insn><mode>3"
     694                 :        298 :   [(set (match_operand:MMXMODEI 0 "register_operand")
     695                 :         14 :         (plusminus:MMXMODEI
     696                 :        250 :           (match_operand:MMXMODEI 1 "register_operand")
     697                 :        250 :           (match_operand:MMXMODEI 2 "register_operand")))]
     698                 :        284 :   "TARGET_MMX_WITH_SSE"
     699                 :         34 :   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
     700                 :         34 : 
     701                 :        250 : (define_insn "*mmx_<plusminus_insn><mode>3"
     702                 :       1948 :   [(set (match_operand:MMXMODEI8 0 "register_operand" "=y,x,Yv")
     703                 :       1948 :         (plusminus:MMXMODEI8
     704                 :         34 :           (match_operand:MMXMODEI8 1 "register_mmxmem_operand" "<comm>0,0,Yv")
     705                 :        250 :           (match_operand:MMXMODEI8 2 "register_mmxmem_operand" "ym,x,Yv")))]
     706                 :        541 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
     707                 :      10059 :    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
     708                 :       9725 :   "@
     709                 :       1914 :    p<plusminus_mnemonic><mmxvecsize>\t{%2, %0|%0, %2}
     710                 :            :    p<plusminus_mnemonic><mmxvecsize>\t{%2, %0|%0, %2}
     711                 :      16951 :    vp<plusminus_mnemonic><mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
     712                 :      17215 :   [(set_attr "isa" "*,sse2_noavx,avx")
     713                 :      26495 :    (set_attr "mmx_isa" "native,*,*")
     714                 :       1914 :    (set_attr "type" "mmxadd,sseadd,sseadd")
     715                 :       1914 :    (set_attr "mode" "DI,TI,TI")])
     716                 :        264 : 
     717                 :        264 : (define_expand "mmx_<plusminus_insn><mode>3"
     718                 :        264 :   [(set (match_operand:MMXMODE12 0 "register_operand")
     719                 :        264 :         (sat_plusminus:MMXMODE12
     720                 :       2163 :           (match_operand:MMXMODE12 1 "register_mmxmem_operand")
     721                 :        264 :           (match_operand:MMXMODE12 2 "register_mmxmem_operand")))]
     722                 :        264 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
     723                 :        263 :   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
     724                 :       1899 : 
     725                 :       1899 : (define_insn "*mmx_<plusminus_insn><mode>3"
     726                 :       2162 :   [(set (match_operand:MMXMODE12 0 "register_operand" "=y,x,Yv")
     727                 :       2162 :         (sat_plusminus:MMXMODE12
     728                 :       2162 :           (match_operand:MMXMODE12 1 "register_mmxmem_operand" "<comm>0,0,Yv")
     729                 :       2162 :           (match_operand:MMXMODE12 2 "register_mmxmem_operand" "ym,x,Yv")))]
     730                 :       1905 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
     731                 :        815 :    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
     732                 :          0 :   "@
     733                 :        263 :    p<plusminus_mnemonic><mmxvecsize>\t{%2, %0|%0, %2}
     734                 :            :    p<plusminus_mnemonic><mmxvecsize>\t{%2, %0|%0, %2}
     735                 :        275 :    vp<plusminus_mnemonic><mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
     736                 :        344 :   [(set_attr "isa" "*,sse2_noavx,avx")
     737                 :        263 :    (set_attr "mmx_isa" "native,*,*")
     738                 :        263 :    (set_attr "type" "mmxadd,sseadd,sseadd")
     739                 :        605 :    (set_attr "mode" "DI,TI,TI")])
     740                 :        342 : 
     741                 :      46993 : (define_expand "mmx_mulv4hi3"
     742                 :      46993 :   [(set (match_operand:V4HI 0 "register_operand")
     743                 :       2260 :         (mult:V4HI (match_operand:V4HI 1 "register_mmxmem_operand")
     744                 :        306 :                    (match_operand:V4HI 2 "register_mmxmem_operand")))]
     745                 :        137 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
     746                 :        170 :   "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
     747                 :       5781 : 
     748                 :       6087 : (define_expand "mulv4hi3"
     749                 :        263 :   [(set (match_operand:V4HI 0 "register_operand")
     750                 :        339 :         (mult:V4HI (match_operand:V4HI 1 "register_operand")
     751                 :        339 :                    (match_operand:V4HI 2 "register_operand")))]
     752                 :        339 :   "TARGET_MMX_WITH_SSE"
     753                 :        573 :   "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
     754                 :        263 : 
     755                 :         43 : (define_insn "*mmx_mulv4hi3"
     756                 :         76 :   [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yv")
     757                 :        234 :         (mult:V4HI (match_operand:V4HI 1 "register_mmxmem_operand" "%0,0,Yv")
     758                 :        277 :                    (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yv")))]
     759                 :       1941 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
     760                 :       1783 :    && ix86_binary_operator_ok (MULT, V4HImode, operands)"
     761                 :       1111 :   "@
     762                 :         76 :    pmullw\t{%2, %0|%0, %2}
     763                 :        277 :    pmullw\t{%2, %0|%0, %2}
     764                 :         43 :    vpmullw\t{%2, %1, %0|%0, %1, %2}"
     765                 :         86 :   [(set_attr "isa" "*,sse2_noavx,avx")
     766                 :          0 :    (set_attr "mmx_isa" "native,*,*")
     767                 :        277 :    (set_attr "type" "mmxmul,ssemul,ssemul")
     768                 :     135464 :    (set_attr "mode" "DI,TI,TI")])
     769                 :        277 : 
     770                 :     135187 : (define_expand "mmx_smulv4hi3_highpart"
     771                 :        269 :   [(set (match_operand:V4HI 0 "register_operand")
     772                 :      69944 :         (truncate:V4HI
     773                 :      69944 :           (lshiftrt:V4SI
     774                 :        268 :             (mult:V4SI
     775                 :      29060 :               (sign_extend:V4SI
     776                 :      29060 :                 (match_operand:V4HI 1 "register_mmxmem_operand"))
     777                 :      29060 :               (sign_extend:V4SI
     778                 :      28860 :                 (match_operand:V4HI 2 "register_mmxmem_operand")))
     779                 :         34 :             (const_int 16))))]
     780                 :      28809 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
     781                 :         65 :   "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
     782                 :      11613 : 
     783                 :      13018 : (define_insn "*mmx_smulv4hi3_highpart"
     784                 :         66 :   [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yv")
     785                 :         34 :         (truncate:V4HI
     786                 :         34 :           (lshiftrt:V4SI
     787                 :         34 :             (mult:V4SI
     788                 :         34 :               (sign_extend:V4SI
     789                 :         34 :                 (match_operand:V4HI 1 "register_mmxmem_operand" "%0,0,Yv"))
     790                 :            :               (sign_extend:V4SI
     791                 :         34 :                 (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yv")))
     792                 :            :             (const_int 16))))]
     793                 :         71 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
     794                 :         71 :    && ix86_binary_operator_ok (MULT, V4HImode, operands)"
     795                 :          1 :   "@
     796                 :            :    pmulhw\t{%2, %0|%0, %2}
     797                 :            :    pmulhw\t{%2, %0|%0, %2}
     798                 :         49 :    vpmulhw\t{%2, %1, %0|%0, %1, %2}"
     799                 :         49 :   [(set_attr "isa" "*,sse2_noavx,avx")
     800                 :         34 :    (set_attr "mmx_isa" "native,*,*")
     801                 :         83 :    (set_attr "type" "mmxmul,ssemul,ssemul")
     802                 :         83 :    (set_attr "mode" "DI,TI,TI")])
     803                 :         49 : 
     804                 :            : (define_expand "mmx_umulv4hi3_highpart"
     805                 :         47 :   [(set (match_operand:V4HI 0 "register_operand")
     806                 :         47 :         (truncate:V4HI
     807                 :         69 :           (lshiftrt:V4SI
     808                 :         93 :             (mult:V4SI
     809                 :            :               (zero_extend:V4SI
     810                 :            :                 (match_operand:V4HI 1 "register_mmxmem_operand"))
     811                 :         22 :               (zero_extend:V4SI
     812                 :         22 :                 (match_operand:V4HI 2 "register_mmxmem_operand")))
     813                 :         22 :             (const_int 16))))]
     814                 :         22 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
     815                 :         22 :    && (TARGET_SSE || TARGET_3DNOW_A)"
     816                 :         22 :   "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
     817                 :         22 : 
     818                 :            : (define_insn "*mmx_umulv4hi3_highpart"
     819                 :         22 :   [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yv")
     820                 :         22 :         (truncate:V4HI
     821                 :         22 :           (lshiftrt:V4SI
     822                 :         22 :             (mult:V4SI
     823                 :         22 :               (zero_extend:V4SI
     824                 :         22 :                 (match_operand:V4HI 1 "register_mmxmem_operand" "%0,0,Yv"))
     825                 :            :               (zero_extend:V4SI
     826                 :         22 :                 (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yv")))
     827                 :            :           (const_int 16))))]
     828                 :         46 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
     829                 :         46 :    && (TARGET_SSE || TARGET_3DNOW_A)
     830                 :         46 :    && ix86_binary_operator_ok (MULT, V4HImode, operands)"
     831                 :          1 :   "@
     832                 :            :    pmulhuw\t{%2, %0|%0, %2}
     833                 :            :    pmulhuw\t{%2, %0|%0, %2}
     834                 :            :    vpmulhuw\t{%2, %1, %0|%0, %1, %2}"
     835                 :         22 :   [(set_attr "isa" "*,sse2_noavx,avx")
     836                 :         22 :    (set_attr "mmx_isa" "native,*,*")
     837                 :         22 :    (set_attr "type" "mmxmul,ssemul,ssemul")
     838                 :        685 :    (set_attr "mode" "DI,TI,TI")])
     839                 :        685 : 
     840                 :        685 : (define_expand "mmx_pmaddwd"
     841                 :            :   [(set (match_operand:V2SI 0 "register_operand")
     842                 :         63 :         (plus:V2SI
     843                 :         30 :           (mult:V2SI
     844                 :            :             (sign_extend:V2SI
     845                 :         30 :               (vec_select:V2HI
     846                 :         63 :                 (match_operand:V4HI 1 "register_mmxmem_operand")
     847                 :         63 :                 (parallel [(const_int 0) (const_int 2)])))
     848                 :         33 :             (sign_extend:V2SI
     849                 :         63 :               (vec_select:V2HI
     850                 :         63 :                 (match_operand:V4HI 2 "register_mmxmem_operand")
     851                 :         63 :                 (parallel [(const_int 0) (const_int 2)]))))
     852                 :         33 :           (mult:V2SI
     853                 :         30 :             (sign_extend:V2SI
     854                 :         30 :               (vec_select:V2HI (match_dup 1)
     855                 :         30 :                 (parallel [(const_int 1) (const_int 3)])))
     856                 :         30 :             (sign_extend:V2SI
     857                 :            :               (vec_select:V2HI (match_dup 2)
     858                 :         30 :                 (parallel [(const_int 1) (const_int 3)]))))))]
     859                 :         30 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
     860                 :         63 :   "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
     861                 :            : 
     862                 :         30 : (define_insn "*mmx_pmaddwd"
     863                 :         63 :   [(set (match_operand:V2SI 0 "register_operand" "=y,x,Yv")
     864                 :         63 :         (plus:V2SI
     865                 :         33 :           (mult:V2SI
     866                 :         63 :             (sign_extend:V2SI
     867                 :         63 :               (vec_select:V2HI
     868                 :         63 :                 (match_operand:V4HI 1 "register_mmxmem_operand" "%0,0,Yv")
     869                 :            :                 (parallel [(const_int 0) (const_int 2)])))
     870                 :         63 :             (sign_extend:V2SI
     871                 :         30 :               (vec_select:V2HI
     872                 :         30 :                 (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yv")
     873                 :         30 :                 (parallel [(const_int 0) (const_int 2)]))))
     874                 :         60 :           (mult:V2SI
     875                 :          0 :             (sign_extend:V2SI
     876                 :         30 :               (vec_select:V2HI (match_dup 1)
     877                 :         30 :                 (parallel [(const_int 1) (const_int 3)])))
     878                 :         30 :             (sign_extend:V2SI
     879                 :            :               (vec_select:V2HI (match_dup 2)
     880                 :         30 :                 (parallel [(const_int 1) (const_int 3)]))))))]
     881                 :         69 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
     882                 :         99 :    && ix86_binary_operator_ok (MULT, V4HImode, operands)"
     883                 :         60 :   "@
     884                 :            :    pmaddwd\t{%2, %0|%0, %2}
     885                 :            :    pmaddwd\t{%2, %0|%0, %2}
     886                 :            :    vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
     887                 :            :   [(set_attr "isa" "*,sse2_noavx,avx")
     888                 :            :    (set_attr "mmx_isa" "native,*,*")
     889                 :            :    (set_attr "type" "mmxmul,sseiadd,sseiadd")
     890                 :     673519 :    (set_attr "mode" "DI,TI,TI")])
     891                 :     673519 : 
     892                 :     673519 : (define_expand "mmx_pmulhrwv4hi3"
     893                 :     673519 :   [(set (match_operand:V4HI 0 "register_operand")
     894                 :            :         (truncate:V4HI
     895                 :       1060 :           (lshiftrt:V4SI
     896                 :       1060 :             (plus:V4SI
     897                 :            :               (mult:V4SI
     898                 :            :                 (sign_extend:V4SI
     899                 :            :                   (match_operand:V4HI 1 "nonimmediate_operand"))
     900                 :            :                 (sign_extend:V4SI
     901                 :            :                   (match_operand:V4HI 2 "nonimmediate_operand")))
     902                 :         33 :               (const_vector:V4SI [(const_int 32768) (const_int 32768)
     903                 :         33 :                                   (const_int 32768) (const_int 32768)]))
     904                 :         33 :             (const_int 16))))]
     905                 :            :   "TARGET_3DNOW"
     906                 :         14 :   "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
     907                 :            : 
     908                 :            : (define_insn "*mmx_pmulhrwv4hi3"
     909                 :         28 :   [(set (match_operand:V4HI 0 "register_operand" "=y")
     910                 :         14 :         (truncate:V4HI
     911                 :         14 :           (lshiftrt:V4SI
     912                 :         14 :             (plus:V4SI
     913                 :         28 :               (mult:V4SI
     914                 :         14 :                 (sign_extend:V4SI
     915                 :         14 :                   (match_operand:V4HI 1 "nonimmediate_operand" "%0"))
     916                 :         14 :                 (sign_extend:V4SI
     917                 :         14 :                   (match_operand:V4HI 2 "nonimmediate_operand" "ym")))
     918                 :         14 :               (const_vector:V4SI [(const_int 32768) (const_int 32768)
     919                 :         14 :                                   (const_int 32768) (const_int 32768)]))
     920                 :            :             (const_int 16))))]
     921                 :         30 :   "TARGET_3DNOW && ix86_binary_operator_ok (MULT, V4HImode, operands)"
     922                 :          0 :   "pmulhrw\t{%2, %0|%0, %2}"
     923                 :            :   [(set_attr "type" "mmxmul")
     924                 :            :    (set_attr "prefix_extra" "1")
     925                 :        451 :    (set_attr "mode" "DI")])
     926                 :        451 : 
     927                 :        451 : (define_expand "sse2_umulv1siv1di3"
     928                 :            :   [(set (match_operand:V1DI 0 "register_operand")
     929                 :        451 :         (mult:V1DI
     930                 :        451 :           (zero_extend:V1DI
     931                 :            :             (vec_select:V1SI
     932                 :        465 :               (match_operand:V2SI 1 "register_mmxmem_operand")
     933                 :        465 :               (parallel [(const_int 0)])))
     934                 :        465 :           (zero_extend:V1DI
     935                 :            :             (vec_select:V1SI
     936                 :        451 :               (match_operand:V2SI 2 "register_mmxmem_operand")
     937                 :        451 :               (parallel [(const_int 0)])))))]
     938                 :        451 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSE2"
     939                 :        475 :   "ix86_fixup_binary_operands_no_copy (MULT, V2SImode, operands);")
     940                 :        451 : 
     941                 :            : (define_insn "*sse2_umulv1siv1di3"
     942                 :        153 :   [(set (match_operand:V1DI 0 "register_operand" "=y,x,Yv")
     943                 :        165 :         (mult:V1DI
     944                 :        113 :           (zero_extend:V1DI
     945                 :        165 :             (vec_select:V1SI
     946                 :         24 :               (match_operand:V2SI 1 "register_mmxmem_operand" "%0,0,Yv")
     947                 :         24 :               (parallel [(const_int 0)])))
     948                 :         12 :           (zero_extend:V1DI
     949                 :         12 :             (vec_select:V1SI
     950                 :            :               (match_operand:V2SI 2 "register_mmxmem_operand" "ym,x,Yv")
     951                 :            :               (parallel [(const_int 0)])))))]
     952                 :         24 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
     953                 :         24 :    && TARGET_SSE2
     954                 :         24 :    && ix86_binary_operator_ok (MULT, V2SImode, operands)"
     955                 :          1 :   "@
     956                 :            :    pmuludq\t{%2, %0|%0, %2}
     957                 :            :    pmuludq\t{%2, %0|%0, %2}
     958                 :            :    vpmuludq\t{%2, %1, %0|%0, %1, %2}"
     959                 :            :   [(set_attr "isa" "*,sse2_noavx,avx")
     960                 :            :    (set_attr "mmx_isa" "native,*,*")
     961                 :            :    (set_attr "type" "mmxmul,ssemul,ssemul")
     962                 :      20350 :    (set_attr "mode" "DI,TI,TI")])
     963                 :      20362 : 
     964                 :         12 : (define_expand "mmx_<code>v4hi3"
     965                 :      20113 :   [(set (match_operand:V4HI 0 "register_operand")
     966                 :      20101 :         (smaxmin:V4HI
     967                 :            :           (match_operand:V4HI 1 "register_mmxmem_operand")
     968                 :       2643 :           (match_operand:V4HI 2 "register_mmxmem_operand")))]
     969                 :            :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
     970                 :        371 :    && (TARGET_SSE || TARGET_3DNOW_A)"
     971                 :        393 :   "ix86_fixup_binary_operands_no_copy (<CODE>, V4HImode, operands);")
     972                 :            : 
     973                 :            : (define_expand "<code>v4hi3"
     974                 :         66 :   [(set (match_operand:V4HI 0 "register_operand")
     975                 :         22 :         (smaxmin:V4HI
     976                 :         66 :           (match_operand:V4HI 1 "register_operand")
     977                 :         66 :           (match_operand:V4HI 2 "register_operand")))]
     978                 :         66 :   "TARGET_MMX_WITH_SSE"
     979                 :         66 :   "ix86_fixup_binary_operands_no_copy (<CODE>, V4HImode, operands);")
     980                 :         22 : 
     981                 :         44 : (define_insn "*mmx_<code>v4hi3"
     982                 :          0 :   [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yv")
     983                 :          0 :         (smaxmin:V4HI
     984                 :          0 :           (match_operand:V4HI 1 "register_mmxmem_operand" "%0,0,Yv")
     985                 :         44 :           (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yv")))]
     986                 :         48 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
     987                 :        136 :    && (TARGET_SSE || TARGET_3DNOW_A)
     988                 :        184 :    && ix86_binary_operator_ok (<CODE>, V4HImode, operands)"
     989                 :          0 :   "@
     990                 :            :    p<maxmin_int>w\t{%2, %0|%0, %2}
     991                 :            :    p<maxmin_int>w\t{%2, %0|%0, %2}
     992                 :         22 :    vp<maxmin_int>w\t{%2, %1, %0|%0, %1, %2}"
     993                 :          0 :   [(set_attr "isa" "*,sse2_noavx,avx")
     994                 :          0 :    (set_attr "mmx_isa" "native,*,*")
     995                 :          0 :    (set_attr "type" "mmxadd,sseiadd,sseiadd")
     996                 :         22 :    (set_attr "mode" "DI,TI,TI")])
     997                 :     163003 : 
     998                 :     163003 : (define_expand "mmx_<code>v8qi3"
     999                 :     111535 :   [(set (match_operand:V8QI 0 "register_operand")
    1000                 :        501 :         (umaxmin:V8QI
    1001                 :        479 :           (match_operand:V8QI 1 "register_mmxmem_operand")
    1002                 :         22 :           (match_operand:V8QI 2 "register_mmxmem_operand")))]
    1003                 :     442940 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1004                 :     442962 :    && (TARGET_SSE || TARGET_3DNOW_A)"
    1005                 :     442962 :   "ix86_fixup_binary_operands_no_copy (<CODE>, V8QImode, operands);")
    1006                 :         22 : 
    1007                 :         22 : (define_expand "<code>v8qi3"
    1008                 :         66 :   [(set (match_operand:V8QI 0 "register_operand")
    1009                 :     327305 :         (umaxmin:V8QI
    1010                 :     327261 :           (match_operand:V8QI 1 "register_operand")
    1011                 :     327283 :           (match_operand:V8QI 2 "register_operand")))]
    1012                 :         44 :   "TARGET_MMX_WITH_SSE"
    1013                 :         44 :   "ix86_fixup_binary_operands_no_copy (<CODE>, V8QImode, operands);")
    1014                 :            : 
    1015                 :     995046 : (define_insn "*mmx_<code>v8qi3"
    1016                 :     995002 :   [(set (match_operand:V8QI 0 "register_operand" "=y,x,Yv")
    1017                 :     995002 :         (umaxmin:V8QI
    1018                 :          0 :           (match_operand:V8QI 1 "register_mmxmem_operand" "%0,0,Yv")
    1019                 :         44 :           (match_operand:V8QI 2 "register_mmxmem_operand" "ym,x,Yv")))]
    1020                 :         92 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1021                 :        136 :    && (TARGET_SSE || TARGET_3DNOW_A)
    1022                 :      28914 :    && ix86_binary_operator_ok (<CODE>, V8QImode, operands)"
    1023                 :      28822 :   "@
    1024                 :            :    p<maxmin_int>b\t{%2, %0|%0, %2}
    1025                 :            :    p<maxmin_int>b\t{%2, %0|%0, %2}
    1026                 :     168740 :    vp<maxmin_int>b\t{%2, %1, %0|%0, %1, %2}"
    1027                 :     168718 :   [(set_attr "isa" "*,sse2_noavx,avx")
    1028                 :     169476 :    (set_attr "mmx_isa" "native,*,*")
    1029                 :        758 :    (set_attr "type" "mmxadd,sseiadd,sseiadd")
    1030                 :         22 :    (set_attr "mode" "DI,TI,TI")])
    1031                 :         22 : 
    1032                 :         22 : (define_insn "mmx_ashr<mode>3"
    1033                 :        409 :   [(set (match_operand:MMXMODE24 0 "register_operand" "=y,x,Yv")
    1034                 :        409 :         (ashiftrt:MMXMODE24
    1035                 :  275254022 :           (match_operand:MMXMODE24 1 "register_operand" "0,0,Yv")
    1036                 :        409 :           (match_operand:DI 2 "nonmemory_operand" "yN,xN,YvN")))]
    1037                 :        209 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1038                 :  275254000 :   "@
    1039                 :         71 :    psra<mmxvecsize>\t{%2, %0|%0, %2}
    1040                 :     126451 :    psra<mmxvecsize>\t{%2, %0|%0, %2}
    1041                 :     126451 :    vpsra<mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
    1042                 :     126170 :   [(set_attr "isa" "*,sse2_noavx,avx")
    1043                 :     252621 :    (set_attr "mmx_isa" "native,*,*")
    1044                 :          0 :    (set_attr "type" "mmxshft,sseishft,sseishft")
    1045                 :          5 :    (set (attr "length_immediate")
    1046                 :         10 :      (if_then_else (match_operand 2 "const_int_operand")
    1047                 :            :        (const_string "1")
    1048                 :            :        (const_string "0")))
    1049                 :            :    (set_attr "mode" "DI,TI,TI")])
    1050                 :          0 : 
    1051                 :            : (define_expand "ashr<mode>3"
    1052                 :            :   [(set (match_operand:MMXMODE24 0 "register_operand")
    1053                 :            :         (ashiftrt:MMXMODE24
    1054                 :            :           (match_operand:MMXMODE24 1 "register_operand")
    1055                 :            :           (match_operand:DI 2 "nonmemory_operand")))]
    1056                 :            :   "TARGET_MMX_WITH_SSE")
    1057                 :            : 
    1058                 :          8 : (define_insn "mmx_<shift_insn><mode>3"
    1059                 :            :   [(set (match_operand:MMXMODE248 0 "register_operand" "=y,x,Yv")
    1060                 :            :         (any_lshift:MMXMODE248
    1061                 :            :           (match_operand:MMXMODE248 1 "register_operand" "0,0,Yv")
    1062                 :          8 :           (match_operand:DI 2 "nonmemory_operand" "yN,xN,YvN")))]
    1063                 :        526 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1064                 :        534 :   "@
    1065                 :            :    p<vshift><mmxvecsize>\t{%2, %0|%0, %2}
    1066                 :            :    p<vshift><mmxvecsize>\t{%2, %0|%0, %2}
    1067                 :       2334 :    vp<vshift><mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
    1068                 :       2334 :   [(set_attr "isa" "*,sse2_noavx,avx")
    1069                 :       2334 :    (set_attr "mmx_isa" "native,*,*")
    1070                 :          2 :    (set_attr "type" "mmxshft,sseishft,sseishft")
    1071                 :         31 :    (set (attr "length_immediate")
    1072                 :         62 :      (if_then_else (match_operand 2 "const_int_operand")
    1073                 :            :        (const_string "1")
    1074                 :          2 :        (const_string "0")))
    1075                 :            :    (set_attr "mode" "DI,TI,TI")])
    1076                 :            : 
    1077                 :            : (define_expand "<shift_insn><mode>3"
    1078                 :            :   [(set (match_operand:MMXMODE248 0 "register_operand")
    1079                 :            :         (any_lshift:MMXMODE248
    1080                 :            :           (match_operand:MMXMODE248 1 "register_operand")
    1081                 :            :           (match_operand:DI 2 "nonmemory_operand")))]
    1082                 :         98 :   "TARGET_MMX_WITH_SSE")
    1083                 :            : 
    1084                 :            : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    1085                 :            : ;;
    1086                 :         98 : ;; Parallel integral comparisons
    1087                 :            : ;;
    1088                 :            : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    1089                 :            : 
    1090                 :            : (define_expand "mmx_eq<mode>3"
    1091                 :            :   [(set (match_operand:MMXMODEI 0 "register_operand")
    1092                 :            :         (eq:MMXMODEI
    1093                 :            :           (match_operand:MMXMODEI 1 "register_mmxmem_operand")
    1094                 :          0 :           (match_operand:MMXMODEI 2 "register_mmxmem_operand")))]
    1095                 :            :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1096                 :        104 :   "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
    1097                 :            : 
    1098                 :          0 : (define_insn "*mmx_eq<mode>3"
    1099                 :        104 :   [(set (match_operand:MMXMODEI 0 "register_operand" "=y,x,Yv")
    1100                 :        104 :         (eq:MMXMODEI
    1101                 :        104 :           (match_operand:MMXMODEI 1 "register_mmxmem_operand" "%0,0,Yv")
    1102                 :        104 :           (match_operand:MMXMODEI 2 "register_mmxmem_operand" "ym,x,Yv")))]
    1103                 :        176 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1104                 :        324 :    && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
    1105                 :            :   "@
    1106                 :        104 :    pcmpeq<mmxvecsize>\t{%2, %0|%0, %2}
    1107                 :            :    pcmpeq<mmxvecsize>\t{%2, %0|%0, %2}
    1108                 :         83 :    vpcmpeq<mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
    1109                 :         83 :   [(set_attr "isa" "*,sse2_noavx,avx")
    1110                 :        187 :    (set_attr "mmx_isa" "native,*,*")
    1111                 :        104 :    (set_attr "type" "mmxcmp,ssecmp,ssecmp")
    1112                 :        104 :    (set_attr "mode" "DI,TI,TI")])
    1113                 :      90586 : 
    1114                 :      90586 : (define_insn "mmx_gt<mode>3"
    1115                 :        117 :   [(set (match_operand:MMXMODEI 0 "register_operand" "=y,x,Yv")
    1116                 :        117 :         (gt:MMXMODEI
    1117                 :        175 :           (match_operand:MMXMODEI 1 "register_operand" "0,0,Yv")
    1118                 :        107 :           (match_operand:MMXMODEI 2 "register_mmxmem_operand" "ym,x,Yv")))]
    1119                 :         71 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1120                 :        103 :   "@
    1121                 :         68 :    pcmpgt<mmxvecsize>\t{%2, %0|%0, %2}
    1122                 :         98 :    pcmpgt<mmxvecsize>\t{%2, %0|%0, %2}
    1123                 :         98 :    vpcmpgt<mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
    1124                 :        303 :   [(set_attr "isa" "*,sse2_noavx,avx")
    1125                 :        333 :    (set_attr "mmx_isa" "native,*,*")
    1126                 :         68 :    (set_attr "type" "mmxcmp,ssecmp,ssecmp")
    1127                 :         68 :    (set_attr "mode" "DI,TI,TI")])
    1128                 :      81986 : 
    1129                 :      82122 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    1130                 :        202 : ;;
    1131                 :        166 : ;; Parallel integral logical operations
    1132                 :         30 : ;;
    1133                 :      82016 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    1134                 :         36 : 
    1135                 :         36 : (define_expand "one_cmpl<mode>2"
    1136                 :         36 :   [(set (match_operand:MMXMODEI 0 "register_operand")
    1137                 :         36 :         (xor:MMXMODEI
    1138                 :         36 :           (match_operand:MMXMODEI 1 "register_operand")
    1139                 :         36 :           (match_dup 2)))]
    1140                 :         36 :   "TARGET_MMX_WITH_SSE"
    1141                 :          0 :   "operands[2] = force_reg (<MODE>mode, CONSTM1_RTX (<MODE>mode));")
    1142                 :            : 
    1143                 :            : (define_insn "mmx_andnot<mode>3"
    1144                 :         14 :   [(set (match_operand:MMXMODEI 0 "register_operand" "=y,x,Yv")
    1145                 :         14 :         (and:MMXMODEI
    1146                 :         14 :           (not:MMXMODEI (match_operand:MMXMODEI 1 "register_operand" "0,0,Yv"))
    1147                 :         14 :           (match_operand:MMXMODEI 2 "register_mmxmem_operand" "ym,x,Yv")))]
    1148                 :         14 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1149                 :         89 :   "@
    1150                 :            :    pandn\t{%2, %0|%0, %2}
    1151                 :         14 :    pandn\t{%2, %0|%0, %2}
    1152                 :       1959 :    vpandn\t{%2, %1, %0|%0, %1, %2}"
    1153                 :       1959 :   [(set_attr "isa" "*,sse2_noavx,avx")
    1154                 :       1959 :    (set_attr "mmx_isa" "native,*,*")
    1155                 :         14 :    (set_attr "type" "mmxadd,sselog,sselog")
    1156                 :         14 :    (set_attr "mode" "DI,TI,TI")])
    1157                 :         14 : 
    1158                 :            : (define_expand "mmx_<code><mode>3"
    1159                 :            :   [(set (match_operand:MMXMODEI 0 "register_operand")
    1160                 :            :         (any_logic:MMXMODEI
    1161                 :            :           (match_operand:MMXMODEI 1 "register_mmxmem_operand")
    1162                 :         14 :           (match_operand:MMXMODEI 2 "register_mmxmem_operand")))]
    1163                 :            :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1164                 :        104 :   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
    1165                 :         14 : 
    1166                 :         14 : (define_expand "<code><mode>3"
    1167                 :         14 :   [(set (match_operand:MMXMODEI 0 "register_operand")
    1168                 :        118 :         (any_logic:MMXMODEI
    1169                 :        118 :           (match_operand:MMXMODEI 1 "register_operand")
    1170                 :        118 :           (match_operand:MMXMODEI 2 "register_operand")))]
    1171                 :         14 :   "TARGET_MMX_WITH_SSE"
    1172                 :          0 :   "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
    1173                 :            : 
    1174                 :        104 : (define_insn "*mmx_<code><mode>3"
    1175                 :        101 :   [(set (match_operand:MMXMODEI 0 "register_operand" "=y,x,Yv")
    1176                 :        101 :         (any_logic:MMXMODEI
    1177                 :        101 :           (match_operand:MMXMODEI 1 "register_mmxmem_operand" "%0,0,Yv")
    1178                 :        104 :           (match_operand:MMXMODEI 2 "register_mmxmem_operand" "ym,x,Yv")))]
    1179                 :        173 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1180                 :        938 :    && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
    1181                 :          0 :   "@
    1182                 :        101 :    p<logic>\t{%2, %0|%0, %2}
    1183                 :            :    p<logic>\t{%2, %0|%0, %2}
    1184                 :       5679 :    vp<logic>\t{%2, %1, %0|%0, %1, %2}"
    1185                 :       6265 :   [(set_attr "isa" "*,sse2_noavx,avx")
    1186                 :        101 :    (set_attr "mmx_isa" "native,*,*")
    1187                 :        101 :    (set_attr "type" "mmxadd,sselog,sselog")
    1188                 :        101 :    (set_attr "mode" "DI,TI,TI")])
    1189                 :        111 : 
    1190                 :        111 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    1191                 :        111 : ;;
    1192                 :        111 : ;; Parallel integral element swizzling
    1193                 :        205 : ;;
    1194                 :        154 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    1195                 :        111 : 
    1196                 :         43 : ;; Used in signed and unsigned truncations with saturation.
    1197                 :         43 : (define_code_iterator any_s_truncate [ss_truncate us_truncate])
    1198                 :         94 : ;; Instruction suffix for truncations with saturation.
    1199                 :         43 : (define_code_attr s_trunsuffix [(ss_truncate "s") (us_truncate "u")])
    1200                 :         94 : 
    1201                 :         94 : (define_insn_and_split "mmx_pack<s_trunsuffix>swb"
    1202                 :         94 :   [(set (match_operand:V8QI 0 "register_operand" "=y,x,Yv")
    1203                 :         94 :         (vec_concat:V8QI
    1204                 :            :           (any_s_truncate:V4QI
    1205                 :            :             (match_operand:V4HI 1 "register_operand" "0,0,Yv"))
    1206                 :            :           (any_s_truncate:V4QI
    1207                 :            :             (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yv"))))]
    1208                 :         85 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1209                 :      31636 :   "@
    1210                 :            :    pack<s_trunsuffix>swb\t{%2, %0|%0, %2}
    1211                 :            :    #
    1212                 :      15240 :    #"
    1213                 :      15283 :   "TARGET_SSE2 && reload_completed
    1214                 :         76 :    && SSE_REGNO_P (REGNO (operands[0]))"
    1215                 :        172 :   [(const_int 0)]
    1216                 :        152 :   "ix86_split_mmx_pack (operands, <any_s_truncate:CODE>); DONE;"
    1217                 :        172 :   [(set_attr "mmx_isa" "native,sse_noavx,avx")
    1218                 :        172 :    (set_attr "type" "mmxshft,sselog,sselog")
    1219                 :       1462 :    (set_attr "mode" "DI,TI,TI")])
    1220                 :        168 : 
    1221                 :         27 : (define_insn_and_split "mmx_packssdw"
    1222                 :       1206 :   [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yv")
    1223                 :         27 :         (vec_concat:V4HI
    1224                 :        199 :           (ss_truncate:V2HI
    1225                 :        199 :             (match_operand:V2SI 1 "register_operand" "0,0,Yv"))
    1226                 :            :           (ss_truncate:V2HI
    1227                 :        199 :             (match_operand:V2SI 2 "register_mmxmem_operand" "ym,x,Yv"))))]
    1228                 :        398 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1229                 :         27 :   "@
    1230                 :        262 :    packssdw\t{%2, %0|%0, %2}
    1231                 :        262 :    #
    1232                 :          0 :    #"
    1233                 :        376 :   "TARGET_SSE2 && reload_completed
    1234                 :         57 :    && SSE_REGNO_P (REGNO (operands[0]))"
    1235                 :         43 :   [(const_int 0)]
    1236                 :        157 :   "ix86_split_mmx_pack (operands, SS_TRUNCATE); DONE;"
    1237                 :      31749 :   [(set_attr "mmx_isa" "native,sse_noavx,avx")
    1238                 :      31705 :    (set_attr "type" "mmxshft,sselog,sselog")
    1239                 :            :    (set_attr "mode" "DI,TI,TI")])
    1240                 :            : 
    1241                 :            : (define_insn_and_split "mmx_punpckhbw"
    1242                 :      17139 :   [(set (match_operand:V8QI 0 "register_operand" "=y,x,Yv")
    1243                 :      17139 :         (vec_select:V8QI
    1244                 :      17172 :           (vec_concat:V16QI
    1245                 :            :             (match_operand:V8QI 1 "register_operand" "0,0,Yv")
    1246                 :            :             (match_operand:V8QI 2 "register_mmxmem_operand" "ym,x,Yv"))
    1247                 :            :           (parallel [(const_int 4) (const_int 12)
    1248                 :         33 :                      (const_int 5) (const_int 13)
    1249                 :            :                      (const_int 6) (const_int 14)
    1250                 :         33 :                      (const_int 7) (const_int 15)])))]
    1251                 :        103 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1252                 :          0 :   "@
    1253                 :         33 :    punpckhbw\t{%2, %0|%0, %2}
    1254                 :            :    #
    1255                 :        160 :    #"
    1256                 :         66 :   "TARGET_SSE2 && reload_completed
    1257                 :         33 :    && SSE_REGNO_P (REGNO (operands[0]))"
    1258                 :            :   [(const_int 0)]
    1259                 :         66 :   "ix86_split_mmx_punpck (operands, true); DONE;"
    1260                 :            :   [(set_attr "mmx_isa" "native,sse_noavx,avx")
    1261                 :        132 :    (set_attr "type" "mmxcvt,sselog,sselog")
    1262                 :         66 :    (set_attr "mode" "DI,TI,TI")])
    1263                 :            : 
    1264                 :            : (define_insn_and_split "mmx_punpcklbw"
    1265                 :            :   [(set (match_operand:V8QI 0 "register_operand" "=y,x,Yv")
    1266                 :            :         (vec_select:V8QI
    1267                 :            :           (vec_concat:V16QI
    1268                 :            :             (match_operand:V8QI 1 "register_operand" "0,0,Yv")
    1269                 :            :             (match_operand:V8QI 2 "register_mmxmem_operand" "ym,x,Yv"))
    1270                 :            :           (parallel [(const_int 0) (const_int 8)
    1271                 :         66 :                      (const_int 1) (const_int 9)
    1272                 :            :                      (const_int 2) (const_int 10)
    1273                 :         66 :                      (const_int 3) (const_int 11)])))]
    1274                 :        226 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1275                 :          0 :   "@
    1276                 :         66 :    punpcklbw\t{%2, %0|%0, %k2}
    1277                 :            :    #
    1278                 :            :    #"
    1279                 :        132 :   "TARGET_SSE2 && reload_completed
    1280                 :         66 :    && SSE_REGNO_P (REGNO (operands[0]))"
    1281                 :            :   [(const_int 0)]
    1282                 :        132 :   "ix86_split_mmx_punpck (operands, false); DONE;"
    1283                 :     252370 :   [(set_attr "mmx_isa" "native,sse_noavx,avx")
    1284                 :     252370 :    (set_attr "type" "mmxcvt,sselog,sselog")
    1285                 :        509 :    (set_attr "mode" "DI,TI,TI")])
    1286                 :     252016 : 
    1287                 :        354 : (define_insn_and_split "mmx_punpckhwd"
    1288                 :     109327 :   [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yv")
    1289                 :     109327 :         (vec_select:V4HI
    1290                 :     109327 :           (vec_concat:V8HI
    1291                 :        318 :             (match_operand:V4HI 1 "register_operand" "0,0,Yv")
    1292                 :        318 :             (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yv"))
    1293                 :        318 :           (parallel [(const_int 2) (const_int 6)
    1294                 :     109090 :                      (const_int 3) (const_int 7)])))]
    1295                 :        183 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1296                 :         79 :   "@
    1297                 :        395 :    punpckhwd\t{%2, %0|%0, %2}
    1298                 :          0 :    #
    1299                 :        395 :    #"
    1300                 :        158 :   "TARGET_SSE2 && reload_completed
    1301                 :         79 :    && SSE_REGNO_P (REGNO (operands[0]))"
    1302                 :        237 :   [(const_int 0)]
    1303                 :        158 :   "ix86_split_mmx_punpck (operands, true); DONE;"
    1304                 :            :   [(set_attr "mmx_isa" "native,sse_noavx,avx")
    1305                 :        158 :    (set_attr "type" "mmxcvt,sselog,sselog")
    1306                 :         79 :    (set_attr "mode" "DI,TI,TI")])
    1307                 :            : 
    1308                 :            : (define_insn_and_split "mmx_punpcklwd"
    1309                 :            :   [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yv")
    1310                 :            :         (vec_select:V4HI
    1311                 :            :           (vec_concat:V8HI
    1312                 :            :             (match_operand:V4HI 1 "register_operand" "0,0,Yv")
    1313                 :            :             (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yv"))
    1314                 :            :           (parallel [(const_int 0) (const_int 4)
    1315                 :         79 :                      (const_int 1) (const_int 5)])))]
    1316                 :        171 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1317                 :         79 :   "@
    1318                 :         79 :    punpcklwd\t{%2, %0|%0, %k2}
    1319                 :          0 :    #
    1320                 :         79 :    #"
    1321                 :        158 :   "TARGET_SSE2 && reload_completed
    1322                 :         79 :    && SSE_REGNO_P (REGNO (operands[0]))"
    1323                 :            :   [(const_int 0)]
    1324                 :        158 :   "ix86_split_mmx_punpck (operands, false); DONE;"
    1325                 :      34450 :   [(set_attr "mmx_isa" "native,sse_noavx,avx")
    1326                 :      34450 :    (set_attr "type" "mmxcvt,sselog,sselog")
    1327                 :            :    (set_attr "mode" "DI,TI,TI")])
    1328                 :      34450 : 
    1329                 :      34450 : (define_insn_and_split "mmx_punpckhdq"
    1330                 :      34450 :   [(set (match_operand:V2SI 0 "register_operand" "=y,x,Yv")
    1331                 :      34606 :         (vec_select:V2SI
    1332                 :      52550 :           (vec_concat:V4SI
    1333                 :        154 :             (match_operand:V2SI 1 "register_operand" "0,0,Yv")
    1334                 :      18254 :             (match_operand:V2SI 2 "register_mmxmem_operand" "ym,x,Yv"))
    1335                 :      18254 :           (parallel [(const_int 1)
    1336                 :        118 :                      (const_int 3)])))]
    1337                 :      18339 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1338                 :      18287 :   "@
    1339                 :         33 :    punpckhdq\t{%2, %0|%0, %2}
    1340                 :          0 :    #
    1341                 :      18290 :    #"
    1342                 :      18323 :   "TARGET_SSE2 && reload_completed
    1343                 :      18221 :    && SSE_REGNO_P (REGNO (operands[0]))"
    1344                 :      23869 :   [(const_int 0)]
    1345                 :      12768 :   "ix86_split_mmx_punpck (operands, true); DONE;"
    1346                 :      30890 :   [(set_attr "mmx_isa" "native,sse_noavx,avx")
    1347                 :      17781 :    (set_attr "type" "mmxcvt,sselog,sselog")
    1348                 :       7461 :    (set_attr "mode" "DI,TI,TI")])
    1349                 :       7461 : 
    1350                 :            : (define_insn_and_split "mmx_punpckldq"
    1351                 :       6988 :   [(set (match_operand:V2SI 0 "register_operand" "=y,x,Yv")
    1352                 :        407 :         (vec_select:V2SI
    1353                 :        407 :           (vec_concat:V4SI
    1354                 :         69 :             (match_operand:V2SI 1 "register_operand" "0,0,Yv")
    1355                 :        102 :             (match_operand:V2SI 2 "register_mmxmem_operand" "ym,x,Yv"))
    1356                 :            :           (parallel [(const_int 0)
    1357                 :         33 :                      (const_int 2)])))]
    1358                 :         69 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1359                 :         33 :   "@
    1360                 :         33 :    punpckldq\t{%2, %0|%0, %k2}
    1361                 :          0 :    #
    1362                 :         33 :    #"
    1363                 :         66 :   "TARGET_SSE2 && reload_completed
    1364                 :         33 :    && SSE_REGNO_P (REGNO (operands[0]))"
    1365                 :            :   [(const_int 0)]
    1366                 :         66 :   "ix86_split_mmx_punpck (operands, false); DONE;"
    1367                 :            :   [(set_attr "mmx_isa" "native,sse_noavx,avx")
    1368                 :       1927 :    (set_attr "type" "mmxcvt,sselog,sselog")
    1369                 :       1927 :    (set_attr "mode" "DI,TI,TI")])
    1370                 :       1927 : 
    1371                 :       1691 : (define_insn "*mmx_pinsrd"
    1372                 :        395 :   [(set (match_operand:V2SI 0 "register_operand" "=x,Yv")
    1373                 :       1699 :         (vec_merge:V2SI
    1374                 :        183 :           (vec_duplicate:V2SI
    1375                 :       1872 :             (match_operand:SI 2 "nonimmediate_operand" "rm,rm"))
    1376                 :       1516 :           (match_operand:V2SI 1 "register_operand" "0,Yv")
    1377                 :          0 :           (match_operand:SI 3 "const_int_operand")))]
    1378                 :          0 :   "TARGET_MMX_WITH_SSE && TARGET_SSE4_1
    1379                 :        175 :    && ((unsigned) exact_log2 (INTVAL (operands[3]))
    1380                 :        177 :        < GET_MODE_NUNITS (V2SImode))"
    1381                 :          0 : {
    1382                 :          0 :   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
    1383                 :          0 :   switch (which_alternative)
    1384                 :        136 :     {
    1385                 :        136 :     case 1:
    1386                 :        136 :       return "vpinsrd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
    1387                 :          0 :     case 0:
    1388                 :          0 :       return "pinsrd\t{%3, %2, %0|%0, %2, %3}";
    1389                 :          0 :     default:
    1390                 :          0 :       gcc_unreachable ();
    1391                 :            :     }
    1392                 :            : }
    1393                 :            :   [(set_attr "isa" "noavx,avx")
    1394                 :            :    (set_attr "prefix_data16" "1")
    1395                 :            :    (set_attr "prefix_extra" "1")
    1396                 :         31 :    (set_attr "type" "sselog")
    1397                 :            :    (set_attr "length_immediate" "1")
    1398                 :            :    (set_attr "prefix" "orig,vex")
    1399                 :            :    (set_attr "mode" "TI")])
    1400                 :            : 
    1401                 :            : (define_expand "mmx_pinsrw"
    1402                 :            :   [(set (match_operand:V4HI 0 "register_operand")
    1403                 :            :         (vec_merge:V4HI
    1404                 :            :           (vec_duplicate:V4HI
    1405                 :            :             (match_operand:SI 2 "nonimmediate_operand"))
    1406                 :            :           (match_operand:V4HI 1 "register_operand")
    1407                 :            :           (match_operand:SI 3 "const_0_to_3_operand")))]
    1408                 :            :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1409                 :            :    && (TARGET_SSE || TARGET_3DNOW_A)"
    1410                 :          0 : {
    1411                 :          0 :   operands[2] = gen_lowpart (HImode, operands[2]);
    1412                 :          0 :   operands[3] = GEN_INT (1 << INTVAL (operands[3]));
    1413                 :            : })
    1414                 :            : 
    1415                 :            : (define_insn "*mmx_pinsrw"
    1416                 :          0 :   [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yv")
    1417                 :          0 :         (vec_merge:V4HI
    1418                 :          0 :           (vec_duplicate:V4HI
    1419                 :          0 :             (match_operand:HI 2 "nonimmediate_operand" "rm,rm,rm"))
    1420                 :          0 :           (match_operand:V4HI 1 "register_operand" "0,0,Yv")
    1421                 :          0 :           (match_operand:SI 3 "const_int_operand")))]
    1422                 :        116 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1423                 :        116 :    && (TARGET_SSE || TARGET_3DNOW_A)
    1424                 :        232 :    && ((unsigned) exact_log2 (INTVAL (operands[3]))
    1425                 :        116 :        < GET_MODE_NUNITS (V4HImode))"
    1426                 :         51 : {
    1427                 :         62 :   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
    1428                 :         31 :   switch (which_alternative)
    1429                 :          0 :     {
    1430                 :         16 :     case 2:
    1431                 :         16 :       if (MEM_P (operands[2]))
    1432                 :          0 :         return "vpinsrw\t{%3, %2, %1, %0|%0, %1, %2, %3}";
    1433                 :          0 :       else
    1434                 :         16 :         return "vpinsrw\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
    1435                 :         15 :     case 1:
    1436                 :         15 :     case 0:
    1437                 :         15 :       if (MEM_P (operands[2]))
    1438                 :         76 :         return "pinsrw\t{%3, %2, %0|%0, %2, %3}";
    1439                 :            :       else
    1440                 :         12 :         return "pinsrw\t{%3, %k2, %0|%0, %k2, %3}";
    1441                 :          0 :     default:
    1442                 :         76 :       gcc_unreachable ();
    1443                 :         76 :     }
    1444                 :         76 : }
    1445                 :         76 :   [(set_attr "isa" "*,sse2_noavx,avx")
    1446                 :         76 :    (set_attr "mmx_isa" "native,*,*")
    1447                 :         76 :    (set_attr "type" "mmxcvt,sselog,sselog")
    1448                 :         76 :    (set_attr "length_immediate" "1")
    1449                 :            :    (set_attr "mode" "DI,TI,TI")])
    1450                 :            : 
    1451                 :            : (define_insn "*mmx_pinsrb"
    1452                 :            :   [(set (match_operand:V8QI 0 "register_operand" "=x,Yv")
    1453                 :            :         (vec_merge:V8QI
    1454                 :            :           (vec_duplicate:V8QI
    1455                 :            :             (match_operand:QI 2 "nonimmediate_operand" "rm,rm"))
    1456                 :            :           (match_operand:V8QI 1 "register_operand" "0,Yv")
    1457                 :            :           (match_operand:SI 3 "const_int_operand")))]
    1458                 :          0 :   "TARGET_MMX_WITH_SSE && TARGET_SSE4_1
    1459                 :          0 :    && ((unsigned) exact_log2 (INTVAL (operands[3]))
    1460                 :          0 :        < GET_MODE_NUNITS (V8QImode))"
    1461                 :          0 : {
    1462                 :          0 :   operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
    1463                 :          0 :   switch (which_alternative)
    1464                 :            :     {
    1465                 :          0 :     case 1:
    1466                 :          0 :       if (MEM_P (operands[2]))
    1467                 :            :         return "vpinsrb\t{%3, %2, %1, %0|%0, %1, %2, %3}";
    1468                 :            :       else
    1469                 :          0 :         return "vpinsrb\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
    1470                 :          0 :     case 0:
    1471                 :          0 :       if (MEM_P (operands[2]))
    1472                 :            :         return "pinsrb\t{%3, %2, %0|%0, %2, %3}";
    1473                 :            :       else
    1474                 :     995002 :         return "pinsrb\t{%3, %k2, %0|%0, %k2, %3}";
    1475                 :          0 :     default:
    1476                 :          0 :       gcc_unreachable ();
    1477                 :            :     }
    1478                 :     995002 : }
    1479                 :     995002 :   [(set_attr "isa" "noavx,avx")
    1480                 :     995002 :    (set_attr "type" "sselog")
    1481                 :     995002 :    (set_attr "prefix_data16" "1")
    1482                 :     995002 :    (set_attr "prefix_extra" "1")
    1483                 :     995002 :    (set_attr "length_immediate" "1")
    1484                 :     995002 :    (set_attr "prefix" "orig,vex")
    1485                 :            :    (set_attr "mode" "TI")])
    1486                 :     995002 : 
    1487                 :     995002 : (define_insn "*mmx_pextrw"
    1488                 :     995002 :   [(set (match_operand:HI 0 "register_sse4nonimm_operand" "=r,r,m")
    1489                 :     995002 :         (vec_select:HI
    1490                 :            :           (match_operand:V4HI 1 "register_operand" "y,Yv,Yv")
    1491                 :     496235 :           (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n,n,n")])))]
    1492                 :       1565 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1493                 :       1565 :    && (TARGET_SSE || TARGET_3DNOW_A)"
    1494                 :     496235 :   "@
    1495                 :     496235 :    pextrw\t{%2, %1, %k0|%k0, %1, %2}
    1496                 :            :    %vpextrw\t{%2, %1, %k0|%k0, %1, %2}
    1497                 :      69311 :    %vpextrw\t{%2, %1, %0|%0, %1, %2}"
    1498                 :      18538 :   [(set_attr "isa" "*,sse2,sse4")
    1499                 :      69303 :    (set_attr "mmx_isa" "native,*,*")
    1500                 :      37068 :    (set_attr "type" "mmxcvt,sselog1,sselog1")
    1501                 :      50773 :    (set_attr "length_immediate" "1")
    1502                 :      50773 :    (set_attr "prefix" "orig,maybe_vex,maybe_vex")
    1503                 :         76 :    (set_attr "mode" "DI,TI,TI")])
    1504                 :      50773 : 
    1505                 :            : (define_insn "*mmx_pextrw_zext"
    1506                 :       3648 :   [(set (match_operand:SWI48 0 "register_operand" "=r,r")
    1507                 :       3648 :         (zero_extend:SWI48
    1508                 :            :           (vec_select:HI
    1509                 :       2074 :             (match_operand:V4HI 1 "register_operand" "y,Yv")
    1510                 :            :             (parallel [(match_operand:SI 2 "const_0_to_3_operand" "n,n")]))))]
    1511                 :       3611 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1512                 :       3641 :    && (TARGET_SSE || TARGET_3DNOW_A)"
    1513                 :         30 :   "@
    1514                 :         30 :    pextrw\t{%2, %1, %k0|%k0, %1, %2}
    1515                 :         60 :    %vpextrw\t{%2, %1, %k0|%k0, %1, %2}"
    1516                 :      13634 :   [(set_attr "isa" "*,sse2")
    1517                 :      13634 :    (set_attr "mmx_isa" "native,*")
    1518                 :            :    (set_attr "type" "mmxcvt,sselog1")
    1519                 :            :    (set_attr "length_immediate" "1")
    1520                 :            :    (set_attr "prefix" "orig,maybe_vex")
    1521                 :            :    (set_attr "mode" "DI,TI")])
    1522                 :            : 
    1523                 :            : (define_insn "*mmx_pextrb"
    1524                 :            :   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,m")
    1525                 :            :         (vec_select:QI
    1526                 :            :           (match_operand:V8QI 1 "register_operand" "Yv,Yv")
    1527                 :            :           (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n,n")])))]
    1528                 :        252 :   "TARGET_MMX_WITH_SSE && TARGET_SSE4_1"
    1529                 :            :   "@
    1530                 :      28348 :    %vpextrb\t{%2, %1, %k0|%k0, %1, %2}
    1531                 :      28324 :    %vpextrb\t{%2, %1, %0|%0, %1, %2}"
    1532                 :      26616 :   [(set_attr "type" "sselog1")
    1533                 :      54964 :    (set_attr "prefix_data16" "1")
    1534                 :            :    (set_attr "prefix_extra" "1")
    1535                 :            :    (set_attr "length_immediate" "1")
    1536                 :            :    (set_attr "prefix" "maybe_vex")
    1537                 :            :    (set_attr "mode" "TI")])
    1538                 :            : 
    1539                 :            : (define_insn "*mmx_pextrb_zext"
    1540                 :            :   [(set (match_operand:SWI248 0 "register_operand" "=r")
    1541                 :            :         (zero_extend:SWI248
    1542                 :            :           (vec_select:QI
    1543                 :            :             (match_operand:V8QI 1 "register_operand" "Yv")
    1544                 :            :             (parallel [(match_operand:SI 2 "const_0_to_7_operand" "n")]))))]
    1545                 :         64 :   "TARGET_MMX_WITH_SSE && TARGET_SSE4_1"
    1546                 :          0 :   "%vpextrb\t{%2, %1, %k0|%k0, %1, %2}"
    1547                 :            :   [(set_attr "type" "sselog1")
    1548                 :            :    (set_attr "prefix_data16" "1")
    1549                 :      10133 :    (set_attr "prefix_extra" "1")
    1550                 :      10133 :    (set_attr "length_immediate" "1")
    1551                 :            :    (set_attr "prefix" "maybe_vex")
    1552                 :            :    (set_attr "mode" "TI")])
    1553                 :            : 
    1554                 :            : (define_expand "mmx_pshufw"
    1555                 :            :   [(match_operand:V4HI 0 "register_operand")
    1556                 :            :    (match_operand:V4HI 1 "register_mmxmem_operand")
    1557                 :            :    (match_operand:SI 2 "const_int_operand")]
    1558                 :            :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1559                 :            :    && (TARGET_SSE || TARGET_3DNOW_A)"
    1560                 :         76 : {
    1561                 :         76 :   int mask = INTVAL (operands[2]);
    1562                 :         76 :   emit_insn (gen_mmx_pshufw_1 (operands[0], operands[1],
    1563                 :            :                                GEN_INT ((mask >> 0) & 3),
    1564                 :         76 :                                GEN_INT ((mask >> 2) & 3),
    1565                 :         76 :                                GEN_INT ((mask >> 4) & 3),
    1566                 :         76 :                                GEN_INT ((mask >> 6) & 3)));
    1567                 :         76 :   DONE;
    1568                 :            : })
    1569                 :            : 
    1570                 :            : (define_insn "mmx_pshufw_1"
    1571                 :            :   [(set (match_operand:V4HI 0 "register_operand" "=y,Yv")
    1572                 :            :         (vec_select:V4HI
    1573                 :            :           (match_operand:V4HI 1 "register_mmxmem_operand" "ym,Yv")
    1574                 :            :           (parallel [(match_operand 2 "const_0_to_3_operand")
    1575                 :            :                      (match_operand 3 "const_0_to_3_operand")
    1576                 :            :                      (match_operand 4 "const_0_to_3_operand")
    1577                 :            :                      (match_operand 5 "const_0_to_3_operand")])))]
    1578                 :        208 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1579                 :        208 :    && (TARGET_SSE || TARGET_3DNOW_A)"
    1580                 :     133092 : {
    1581                 :         76 :   int mask = 0;
    1582                 :         76 :   mask |= INTVAL (operands[2]) << 0;
    1583                 :         76 :   mask |= INTVAL (operands[3]) << 2;
    1584                 :         76 :   mask |= INTVAL (operands[4]) << 4;
    1585                 :         76 :   mask |= INTVAL (operands[5]) << 6;
    1586                 :         76 :   operands[2] = GEN_INT (mask);
    1587                 :     451453 : 
    1588                 :     451529 :   switch (which_alternative)
    1589                 :     451637 :     {
    1590                 :     451453 :     case 0:
    1591                 :     451637 :       return "pshufw\t{%2, %1, %0|%0, %1, %2}";
    1592                 :     451713 :     case 1:
    1593                 :         76 :       return "%vpshuflw\t{%2, %1, %0|%0, %1, %2}";
    1594                 :     102993 :     default:
    1595                 :     102809 :       gcc_unreachable ();
    1596                 :     102809 :     }
    1597                 :     102455 : }
    1598                 :        354 :   [(set_attr "isa" "*,sse2")
    1599                 :            :    (set_attr "mmx_isa" "native,*")
    1600                 :         69 :    (set_attr "type" "mmxcvt,sselog")
    1601                 :         69 :    (set_attr "length_immediate" "1")
    1602                 :            :    (set_attr "mode" "DI,TI")])
    1603                 :            : 
    1604                 :            : (define_insn "mmx_pswapdv2si2"
    1605                 :            :   [(set (match_operand:V2SI 0 "register_operand" "=y")
    1606                 :            :         (vec_select:V2SI
    1607                 :            :           (match_operand:V2SI 1 "nonimmediate_operand" "ym")
    1608                 :            :           (parallel [(const_int 1) (const_int 0)])))]
    1609                 :         13 :   "TARGET_3DNOW_A"
    1610                 :         13 :   "pswapd\t{%1, %0|%0, %1}"
    1611                 :            :   [(set_attr "type" "mmxcvt")
    1612                 :            :    (set_attr "prefix_extra" "1")
    1613                 :            :    (set_attr "mode" "DI")])
    1614                 :            : 
    1615                 :            : (define_insn_and_split "*vec_dupv4hi"
    1616                 :            :   [(set (match_operand:V4HI 0 "register_operand" "=y,Yv,Yw")
    1617                 :      22441 :         (vec_duplicate:V4HI
    1618                 :      22441 :           (truncate:HI
    1619                 :      22437 :             (match_operand:SI 1 "register_operand" "0,Yv,r"))))]
    1620                 :        107 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1621                 :         47 :    && (TARGET_SSE || TARGET_3DNOW_A)"
    1622                 :      22488 :   "@
    1623                 :            :    pshufw\t{$0, %0, %0|%0, %0, 0}
    1624                 :            :    #
    1625                 :            :    #"
    1626                 :        368 :   "TARGET_SSE2 && reload_completed
    1627                 :        184 :    && SSE_REGNO_P (REGNO (operands[0]))"
    1628                 :            :   [(const_int 0)]
    1629                 :        406 : {
    1630                 :        184 :   rtx op;
    1631                 :       1126 :   operands[0] = lowpart_subreg (V8HImode, operands[0],
    1632                 :        184 :                                 GET_MODE (operands[0]));
    1633                 :        184 :   if (TARGET_AVX2)
    1634                 :            :     {
    1635                 :        816 :       operands[1] = lowpart_subreg (HImode, operands[1],
    1636                 :        787 :                                     GET_MODE (operands[1]));
    1637                 :  236551029 :       op = gen_rtx_VEC_DUPLICATE (V8HImode, operands[1]);
    1638                 :        758 :     }
    1639                 :  236551000 :   else
    1640                 :  236551000 :     {
    1641                 :  236551310 :       operands[1] = lowpart_subreg (V8HImode, operands[1],
    1642                 :  236551155 :                                     GET_MODE (operands[1]));
    1643                 :  236551155 :       rtx mask = gen_rtx_PARALLEL (VOIDmode,
    1644                 :  236551000 :                                    gen_rtvec (8,
    1645                 :            :                                               GEN_INT (0),
    1646                 :        442 :                                               GEN_INT (0),
    1647                 :         70 :                                               GEN_INT (0),
    1648                 :        372 :                                               GEN_INT (0),
    1649                 :        372 :                                               GEN_INT (4),
    1650                 :            :                                               GEN_INT (5),
    1651                 :         69 :                                               GEN_INT (6),
    1652                 :        138 :                                               GEN_INT (7)));
    1653                 :            : 
    1654                 :        155 :       op = gen_rtx_VEC_SELECT (V8HImode, operands[1], mask);
    1655                 :            :     }
    1656                 :        184 :   emit_insn (gen_rtx_SET (operands[0], op));
    1657                 :        184 :   DONE;
    1658                 :            : }
    1659                 :            :   [(set_attr "mmx_isa" "native,sse,avx")
    1660                 :            :    (set_attr "type" "mmxcvt,sselog1,ssemov")
    1661                 :            :    (set_attr "length_immediate" "1,1,0")
    1662                 :            :    (set_attr "mode" "DI,TI,TI")])
    1663                 :            : 
    1664                 :            : (define_insn_and_split "*vec_dupv2si"
    1665                 :            :   [(set (match_operand:V2SI 0 "register_operand" "=y,x,Yv,Yw")
    1666                 :            :         (vec_duplicate:V2SI
    1667                 :            :           (match_operand:SI 1 "register_operand" "0,0,Yv,r")))]
    1668                 :        743 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1669                 :        103 :   "@
    1670                 :        263 :    punpckldq\t%0, %0
    1671                 :            :    #
    1672                 :        263 :    #
    1673                 :        263 :    #"
    1674                 :        789 :   "TARGET_SSE && reload_completed
    1675                 :        526 :    && SSE_REGNO_P (REGNO (operands[0]))"
    1676                 :        272 :   [(set (match_dup 0)
    1677                 :        836 :         (vec_duplicate:V4SI (match_dup 1)))]
    1678                 :        633 : {
    1679                 :        570 :   operands[0] = lowpart_subreg (V4SImode, operands[0],
    1680                 :        307 :                                 GET_MODE (operands[0]));
    1681                 :         44 : }
    1682                 :         44 :   [(set_attr "isa" "*,sse_noavx,avx,avx")
    1683                 :        102 :    (set_attr "mmx_isa" "native,*,*,*")
    1684                 :        263 :    (set_attr "type" "mmxcvt,ssemov,ssemov,ssemov")
    1685                 :        263 :    (set_attr "mode" "DI,TI,TI,TI")])
    1686                 :        263 : 
    1687                 :        263 : (define_insn "*mmx_concatv2si"
    1688                 :        263 :   [(set (match_operand:V2SI 0 "register_operand"     "=y,y")
    1689                 :            :         (vec_concat:V2SI
    1690                 :            :           (match_operand:SI 1 "nonimmediate_operand" " 0,rm")
    1691                 :        263 :           (match_operand:SI 2 "nonimm_or_0_operand"  "ym,C")))]
    1692                 :      14073 :   "TARGET_MMX && !TARGET_SSE"
    1693                 :        263 :   "@
    1694                 :      13810 :    punpckldq\t{%2, %0|%0, %2}
    1695                 :            :    movd\t{%1, %0|%0, %1}"
    1696                 :            :   [(set_attr "type" "mmxcvt,mmxmov")
    1697                 :            :    (set_attr "mode" "DI")])
    1698                 :          0 : 
    1699                 :            : (define_expand "vec_setv2si"
    1700                 :            :   [(match_operand:V2SI 0 "register_operand")
    1701                 :            :    (match_operand:SI 1 "register_operand")
    1702                 :          0 :    (match_operand 2 "const_int_operand")]
    1703                 :          0 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1704                 :          0 : {
    1705                 :          0 :   ix86_expand_vector_set (TARGET_MMX_WITH_SSE, operands[0], operands[1],
    1706                 :          0 :                           INTVAL (operands[2]));
    1707                 :          0 :   DONE;
    1708                 :          0 : })
    1709                 :            : 
    1710                 :            : ;; Avoid combining registers from different units in a single alternative,
    1711                 :            : ;; see comment above inline_secondary_memory_needed function in i386.c
    1712                 :            : (define_insn_and_split "*vec_extractv2si_0"
    1713                 :            :   [(set (match_operand:SI 0 "nonimmediate_operand"     "=x,m,y, m,r,r")
    1714                 :            :         (vec_select:SI
    1715                 :            :           (match_operand:V2SI 1 "nonimmediate_operand" "xm,x,ym,y,m,x")
    1716                 :            :           (parallel [(const_int 0)])))]
    1717                 :       2684 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1718                 :       2684 :    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
    1719                 :            :   "#"
    1720                 :       1107 :   "&& reload_completed"
    1721                 :        550 :   [(set (match_dup 0) (match_dup 1))]
    1722                 :      63722 :   "operands[1] = gen_lowpart (SImode, operands[1]);"
    1723                 :      63172 :   [(set_attr "isa" "*,*,*,*,*,sse2")
    1724                 :      63172 :    (set_attr "mmx_isa" "*,*,native,native,*,*")
    1725                 :      52518 :    (set (attr "preferred_for_speed")
    1726                 :      52518 :      (cond [(eq_attr "alternative" "5")
    1727                 :        550 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
    1728                 :        550 :            ]
    1729                 :        550 :            (symbol_ref "true")))])
    1730                 :            : 
    1731                 :        550 : (define_insn "*vec_extractv2si_0_zext_sse4"
    1732                 :        550 :   [(set (match_operand:DI 0 "register_operand" "=r,x")
    1733                 :       1100 :         (zero_extend:DI
    1734                 :        550 :           (vec_select:SI
    1735                 :          0 :             (match_operand:V2SI 1 "register_operand" "x,x")
    1736                 :        550 :             (parallel [(const_int 0)]))))]
    1737                 :          0 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSE4_1"
    1738                 :            :   "#"
    1739                 :          0 :   [(set_attr "isa" "x64,*")
    1740                 :            :    (set (attr "preferred_for_speed")
    1741                 :          0 :      (cond [(eq_attr "alternative" "0")
    1742                 :          0 :               (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
    1743                 :          0 :            ]
    1744                 :          0 :            (symbol_ref "true")))])
    1745                 :          0 : 
    1746                 :          0 : (define_insn "*vec_extractv2si_0_zext"
    1747                 :            :   [(set (match_operand:DI 0 "register_operand" "=r")
    1748                 :            :         (zero_extend:DI
    1749                 :            :           (vec_select:SI
    1750                 :            :             (match_operand:V2SI 1 "register_operand" "x")
    1751                 :            :             (parallel [(const_int 0)]))))]
    1752                 :          0 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1753                 :          0 :    && TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES_FROM_VEC"
    1754                 :            :   "#")
    1755                 :            : 
    1756                 :            : (define_split
    1757                 :            :   [(set (match_operand:DI 0 "register_operand")
    1758                 :         41 :         (zero_extend:DI
    1759                 :         41 :           (vec_select:SI
    1760                 :            :             (match_operand:V2SI 1 "register_operand")
    1761                 :         41 :             (parallel [(const_int 0)]))))]
    1762                 :          0 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1763                 :          0 :    && TARGET_SSE2 && reload_completed"
    1764                 :          0 :   [(set (match_dup 0) (zero_extend:DI (match_dup 1)))]
    1765                 :          0 :   "operands[1] = gen_lowpart (SImode, operands[1]);")
    1766                 :            : 
    1767                 :         54 : ;; Avoid combining registers from different units in a single alternative,
    1768                 :         54 : ;; see comment above inline_secondary_memory_needed function in i386.c
    1769                 :         54 : (define_insn "*vec_extractv2si_1"
    1770                 :          0 :   [(set (match_operand:SI 0 "nonimmediate_operand"     "=y,rm,x,x,y,x,r")
    1771                 :          0 :         (vec_select:SI
    1772                 :          0 :           (match_operand:V2SI 1 "nonimmediate_operand" " 0,x ,x,0,o,o,o")
    1773                 :            :           (parallel [(const_int 1)])))]
    1774                 :       1659 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1775                 :       1659 :    && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
    1776                 :          0 :   "@
    1777                 :          0 :    punpckhdq\t%0, %0
    1778                 :            :    %vpextrd\t{$1, %1, %0|%0, %1, 1}
    1779                 :       9770 :    %vpshufd\t{$0xe5, %1, %0|%0, %1, 0xe5}
    1780                 :       9770 :    shufps\t{$0xe5, %0, %0|%0, %0, 0xe5}
    1781                 :       9770 :    #
    1782                 :       9770 :    #
    1783                 :      19619 :    #"
    1784                 :            :   [(set_attr "isa" "*,sse4,sse2,noavx,*,*,*")
    1785                 :        128 :    (set_attr "mmx_isa" "native,*,*,*,native,*,*")
    1786                 :        128 :    (set_attr "type" "mmxcvt,ssemov,sseshuf1,sseshuf1,mmxmov,ssemov,imov")
    1787                 :        128 :    (set (attr "length_immediate")
    1788                 :        128 :      (if_then_else (eq_attr "alternative" "1,2,3")
    1789                 :          0 :                    (const_string "1")
    1790                 :        128 :                    (const_string "*")))
    1791                 :            :    (set_attr "prefix" "orig,maybe_vex,maybe_vex,orig,orig,orig,orig")
    1792                 :            :    (set_attr "mode" "DI,TI,TI,V4SF,SI,SI,SI")])
    1793                 :            : 
    1794                 :            : (define_split
    1795                 :            :   [(set (match_operand:SI 0 "register_operand")
    1796                 :            :         (vec_select:SI
    1797                 :            :           (match_operand:V2SI 1 "memory_operand")
    1798                 :            :           (parallel [(const_int 1)])))]
    1799                 :        128 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE) && reload_completed"
    1800                 :        128 :   [(set (match_dup 0) (match_dup 1))]
    1801                 :        128 :   "operands[1] = adjust_address (operands[1], SImode, 4);")
    1802                 :            : 
    1803                 :       4041 : (define_insn "*vec_extractv2si_1_zext"
    1804                 :       4169 :   [(set (match_operand:DI 0 "register_operand" "=r")
    1805                 :       2525 :         (zero_extend:DI
    1806                 :       2525 :           (vec_select:SI
    1807                 :       4283 :             (match_operand:V2SI 1 "register_operand" "x")
    1808                 :        128 :             (parallel [(const_int 1)]))))]
    1809                 :          0 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1810                 :        128 :    && TARGET_64BIT && TARGET_SSE4_1"
    1811                 :        128 :   "%vpextrd\t{$1, %1, %k0|%k0, %1, 1}"
    1812                 :        128 :   [(set_attr "type" "sselog1")
    1813                 :            :    (set_attr "prefix_extra" "1")
    1814                 :            :    (set_attr "length_immediate" "1")
    1815                 :            :    (set_attr "prefix" "maybe_vex")
    1816                 :            :    (set_attr "mode" "TI")])
    1817                 :         59 : 
    1818                 :         59 : (define_insn_and_split "*vec_extractv2si_zext_mem"
    1819                 :            :   [(set (match_operand:DI 0 "register_operand" "=y,x,r")
    1820                 :          0 :         (zero_extend:DI
    1821                 :          0 :           (vec_select:SI
    1822                 :          0 :             (match_operand:V2SI 1 "memory_operand" "o,o,o")
    1823                 :          0 :             (parallel [(match_operand:SI 2 "const_0_to_1_operand")]))))]
    1824                 :          0 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_64BIT"
    1825                 :          0 :   "#"
    1826                 :          0 :   "&& reload_completed"
    1827                 :          0 :   [(set (match_dup 0) (zero_extend:DI (match_dup 1)))]
    1828                 :          0 : {
    1829                 :         41 :   operands[1] = adjust_address (operands[1], SImode, INTVAL (operands[2]) * 4);
    1830                 :         75 : }
    1831                 :        116 :   [(set_attr "isa" "*,sse2,*")
    1832                 :         41 :    (set_attr "mmx_isa" "native,*,*")])
    1833                 :         75 : 
    1834                 :          0 : (define_expand "vec_extractv2sisi"
    1835                 :          0 :   [(match_operand:SI 0 "register_operand")
    1836                 :          0 :    (match_operand:V2SI 1 "register_operand")
    1837                 :          0 :    (match_operand 2 "const_int_operand")]
    1838                 :            :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1839                 :        969 : {
    1840                 :          0 :   ix86_expand_vector_extract (TARGET_MMX_WITH_SSE, operands[0],
    1841                 :          0 :                               operands[1], INTVAL (operands[2]));
    1842                 :        969 :   DONE;
    1843                 :            : })
    1844                 :            : 
    1845                 :            : (define_expand "vec_initv2sisi"
    1846                 :            :   [(match_operand:V2SI 0 "register_operand")
    1847                 :        969 :    (match_operand 1)]
    1848                 :            :   "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSE"
    1849                 :       2074 : {
    1850                 :       2074 :   ix86_expand_vector_init (TARGET_MMX_WITH_SSE, operands[0],
    1851                 :        969 :                            operands[1]);
    1852                 :       3043 :   DONE;
    1853                 :        969 : })
    1854                 :        969 : 
    1855                 :        969 : (define_expand "vec_setv4hi"
    1856                 :        969 :   [(match_operand:V4HI 0 "register_operand")
    1857                 :        969 :    (match_operand:HI 1 "register_operand")
    1858                 :            :    (match_operand 2 "const_int_operand")]
    1859                 :            :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1860                 :          4 : {
    1861                 :          4 :   ix86_expand_vector_set (TARGET_MMX_WITH_SSE, operands[0], operands[1],
    1862                 :          4 :                           INTVAL (operands[2]));
    1863                 :          4 :   DONE;
    1864                 :            : })
    1865                 :            : 
    1866                 :       2074 : (define_expand "vec_extractv4hihi"
    1867                 :       2074 :   [(match_operand:HI 0 "register_operand")
    1868                 :       2074 :    (match_operand:V4HI 1 "register_operand")
    1869                 :       2074 :    (match_operand 2 "const_int_operand")]
    1870                 :       2078 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1871                 :       2074 : {
    1872                 :       1271 :   ix86_expand_vector_extract (TARGET_MMX_WITH_SSE, operands[0],
    1873                 :       1271 :                               operands[1], INTVAL (operands[2]));
    1874                 :       1271 :   DONE;
    1875                 :          4 : })
    1876                 :          4 : 
    1877                 :          4 : (define_expand "vec_initv4hihi"
    1878                 :          4 :   [(match_operand:V4HI 0 "register_operand")
    1879                 :          4 :    (match_operand 1)]
    1880                 :          4 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSE"
    1881                 :        241 : {
    1882                 :        241 :   ix86_expand_vector_init (TARGET_MMX_WITH_SSE, operands[0],
    1883                 :            :                            operands[1]);
    1884                 :        241 :   DONE;
    1885                 :            : })
    1886                 :            : 
    1887                 :            : (define_expand "vec_setv8qi"
    1888                 :       1271 :   [(match_operand:V8QI 0 "register_operand")
    1889                 :       1271 :    (match_operand:QI 1 "register_operand")
    1890                 :       1271 :    (match_operand 2 "const_int_operand")]
    1891                 :       1271 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1892                 :       1271 : {
    1893                 :       1271 :   ix86_expand_vector_set (TARGET_MMX_WITH_SSE, operands[0], operands[1],
    1894                 :       1271 :                           INTVAL (operands[2]));
    1895                 :          0 :   DONE;
    1896                 :            : })
    1897                 :            : 
    1898                 :        241 : (define_expand "vec_extractv8qiqi"
    1899                 :        241 :   [(match_operand:QI 0 "register_operand")
    1900                 :        241 :    (match_operand:V8QI 1 "register_operand")
    1901                 :        241 :    (match_operand 2 "const_int_operand")]
    1902                 :        241 :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    1903                 :        241 : {
    1904                 :       1007 :   ix86_expand_vector_extract (TARGET_MMX_WITH_SSE, operands[0],
    1905                 :       1007 :                               operands[1], INTVAL (operands[2]));
    1906                 :       1007 :   DONE;
    1907                 :          0 : })
    1908                 :          0 : 
    1909                 :          0 : (define_expand "vec_initv8qiqi"
    1910                 :          0 :   [(match_operand:V8QI 0 "register_operand")
    1911                 :          0 :    (match_operand 1)]
    1912                 :          0 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSE"
    1913                 :        277 : {
    1914                 :        277 :   ix86_expand_vector_init (TARGET_MMX_WITH_SSE, operands[0],
    1915                 :            :                            operands[1]);
    1916                 :        277 :   DONE;
    1917                 :            : })
    1918                 :            : 
    1919                 :            : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    1920                 :       1007 : ;;
    1921                 :       1007 : ;; Miscellaneous
    1922                 :       1007 : ;;
    1923                 :       1007 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    1924                 :       1007 : 
    1925                 :       1007 : (define_expand "mmx_uavg<mode>3"
    1926                 :       1007 :   [(set (match_operand:MMXMODE12 0 "register_operand")
    1927                 :        277 :         (truncate:MMXMODE12
    1928                 :            :           (lshiftrt:<mmxdoublemode>
    1929                 :            :             (plus:<mmxdoublemode>
    1930                 :        277 :               (plus:<mmxdoublemode>
    1931                 :        277 :                 (zero_extend:<mmxdoublemode>
    1932                 :        277 :                   (match_operand:MMXMODE12 1 "register_mmxmem_operand"))
    1933                 :        277 :                 (zero_extend:<mmxdoublemode>
    1934                 :        313 :                   (match_operand:MMXMODE12 2 "register_mmxmem_operand")))
    1935                 :        277 :               (match_dup 3))
    1936                 :            :             (const_int 1))))]
    1937                 :            :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1938                 :         36 :    && (TARGET_SSE || TARGET_3DNOW)"
    1939                 :         94 : {
    1940                 :         36 :   operands[3] = CONST1_RTX(<mmxdoublemode>mode);
    1941                 :         58 :   ix86_fixup_binary_operands_no_copy (PLUS, <MODE>mode, operands);
    1942                 :         36 : })
    1943                 :         36 : 
    1944                 :         36 : (define_insn "*mmx_uavgv8qi3"
    1945                 :         36 :   [(set (match_operand:V8QI 0 "register_operand" "=y,x,Yv")
    1946                 :         58 :         (truncate:V8QI
    1947                 :         58 :           (lshiftrt:V8HI
    1948                 :         58 :             (plus:V8HI
    1949                 :         58 :               (plus:V8HI
    1950                 :         58 :                 (zero_extend:V8HI
    1951                 :         58 :                   (match_operand:V8QI 1 "register_mmxmem_operand" "%0,0,Yv"))
    1952                 :         58 :                 (zero_extend:V8HI
    1953                 :            :                   (match_operand:V8QI 2 "register_mmxmem_operand" "ym,x,Yv")))
    1954                 :         58 :               (const_vector:V8HI [(const_int 1) (const_int 1)
    1955                 :            :                                   (const_int 1) (const_int 1)
    1956                 :            :                                   (const_int 1) (const_int 1)
    1957                 :            :                                   (const_int 1) (const_int 1)]))
    1958                 :            :             (const_int 1))))]
    1959                 :         80 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    1960                 :         80 :    && (TARGET_SSE || TARGET_3DNOW)
    1961                 :         80 :    && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
    1962                 :         99 : {
    1963                 :         38 :   switch (which_alternative)
    1964                 :            :     {
    1965                 :        107 :     case 2:
    1966                 :        107 :       return "vpavgb\t{%2, %1, %0|%0, %1, %2}";
    1967                 :         72 :     case 1:
    1968                 :         63 :     case 0:
    1969                 :         49 :       /* These two instructions have the same operation, but their encoding
    1970                 :            :          is different.  Prefer the one that is de facto standard.  */
    1971                 :         63 :       if (TARGET_SSE || TARGET_3DNOW_A)
    1972                 :         73 :         return "pavgb\t{%2, %0|%0, %2}";
    1973                 :            :       else
    1974                 :         49 :         return "pavgusb\t{%2, %0|%0, %2}";
    1975                 :         49 :       default:
    1976                 :         24 :         gcc_unreachable ();
    1977                 :         73 :     }
    1978                 :         73 : }
    1979                 :         73 :   [(set_attr "isa" "*,sse2_noavx,avx")
    1980                 :         73 :    (set_attr "mmx_isa" "native,*,*")
    1981                 :         24 :    (set_attr "type" "mmxshft,sseiadd,sseiadd")
    1982                 :         24 :    (set (attr "prefix_extra")
    1983                 :         22 :      (if_then_else
    1984                 :         65 :        (not (ior (match_test "TARGET_SSE")
    1985                 :            :                  (match_test "TARGET_3DNOW_A")))
    1986                 :            :        (const_string "1")
    1987                 :          0 :        (const_string "*")))
    1988                 :            :    (set_attr "mode" "DI,TI,TI")])
    1989                 :            : 
    1990                 :            : (define_insn "*mmx_uavgv4hi3"
    1991                 :         65 :   [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yv")
    1992                 :            :         (truncate:V4HI
    1993                 :            :           (lshiftrt:V4SI
    1994                 :        149 :             (plus:V4SI
    1995                 :        149 :               (plus:V4SI
    1996                 :        149 :                 (zero_extend:V4SI
    1997                 :        149 :                   (match_operand:V4HI 1 "register_mmxmem_operand" "%0,0,Yv"))
    1998                 :        149 :                 (zero_extend:V4SI
    1999                 :       1432 :                   (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yv")))
    2000                 :            :               (const_vector:V4SI [(const_int 1) (const_int 1)
    2001                 :            :                                   (const_int 1) (const_int 1)]))
    2002                 :            :             (const_int 1))))]
    2003                 :         46 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    2004                 :         46 :    && (TARGET_SSE || TARGET_3DNOW_A)
    2005                 :         46 :    && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
    2006                 :          3 :   "@
    2007                 :       1166 :    pavgw\t{%2, %0|%0, %2}
    2008                 :       1166 :    pavgw\t{%2, %0|%0, %2}
    2009                 :       1166 :    vpavgw\t{%2, %1, %0|%0, %1, %2}"
    2010                 :       1166 :   [(set_attr "isa" "*,sse2_noavx,avx")
    2011                 :       1166 :    (set_attr "mmx_isa" "native,*,*")
    2012                 :       1166 :    (set_attr "type" "mmxshft,sseiadd,sseiadd")
    2013                 :       1346 :    (set_attr "mode" "DI,TI,TI")])
    2014                 :       1346 : 
    2015                 :       1166 : (define_expand "uavg<mode>3_ceil"
    2016                 :         54 :   [(set (match_operand:MMXMODE12 0 "register_operand")
    2017                 :         54 :         (truncate:MMXMODE12
    2018                 :         54 :           (lshiftrt:<mmxdoublemode>
    2019                 :            :             (plus:<mmxdoublemode>
    2020                 :         54 :               (plus:<mmxdoublemode>
    2021                 :         80 :                 (zero_extend:<mmxdoublemode>
    2022                 :         54 :                   (match_operand:MMXMODE12 1 "register_operand"))
    2023                 :            :                 (zero_extend:<mmxdoublemode>
    2024                 :     212460 :                   (match_operand:MMXMODE12 2 "register_operand")))
    2025                 :     212460 :               (match_dup 3))
    2026                 :     212460 :             (const_int 1))))]
    2027                 :            :   "TARGET_MMX_WITH_SSE"
    2028                 :         54 : {
    2029                 :         54 :   operands[3] = CONST1_RTX(<mmxdoublemode>mode);
    2030                 :         54 :   ix86_fixup_binary_operands_no_copy (PLUS, <MODE>mode, operands);
    2031                 :        104 : })
    2032                 :     212409 : 
    2033                 :         49 : (define_insn "mmx_psadbw"
    2034                 :         51 :   [(set (match_operand:V1DI 0 "register_operand" "=y,x,Yv")
    2035                 :         51 :         (unspec:V1DI [(match_operand:V8QI 1 "register_operand" "0,0,Yv")
    2036                 :          2 :                       (match_operand:V8QI 2 "register_mmxmem_operand" "ym,x,Yv")]
    2037                 :         40 :                      UNSPEC_PSADBW))]
    2038                 :         59 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    2039                 :         97 :    && (TARGET_SSE || TARGET_3DNOW_A)"
    2040                 :      17242 :   "@
    2041                 :         34 :    psadbw\t{%2, %0|%0, %2}
    2042                 :         32 :    psadbw\t{%2, %0|%0, %2}
    2043                 :         34 :    vpsadbw\t{%2, %1, %0|%0, %1, %2}"
    2044                 :        417 :   [(set_attr "isa" "*,sse2_noavx,avx")
    2045                 :            :    (set_attr "mmx_isa" "native,*,*")
    2046                 :         82 :    (set_attr "type" "mmxshft,sseiadd,sseiadd")
    2047                 :         82 :    (set_attr "mode" "DI,TI,TI")])
    2048                 :            : 
    2049                 :            : (define_expand "reduc_plus_scal_v8qi"
    2050                 :            :  [(plus:V8QI
    2051                 :            :     (match_operand:QI 0 "register_operand")
    2052                 :            :     (match_operand:V8QI 1 "register_operand"))]
    2053                 :            :  "TARGET_MMX_WITH_SSE"
    2054                 :          2 : {
    2055                 :          2 :   rtx tmp = gen_reg_rtx (V8QImode);
    2056                 :          1 :   emit_move_insn (tmp, CONST0_RTX (V8QImode));
    2057                 :          1 :   rtx tmp2 = gen_reg_rtx (V1DImode);
    2058                 :          1 :   emit_insn (gen_mmx_psadbw (tmp2, operands[1], tmp));
    2059                 :          1 :   tmp2 = gen_lowpart (V8QImode, tmp2);
    2060                 :          1 :   emit_insn (gen_vec_extractv8qiqi (operands[0], tmp2, const0_rtx));
    2061                 :          1 :   DONE;
    2062                 :            : })
    2063                 :            : 
    2064                 :          1 : (define_expand "usadv8qi"
    2065                 :          1 :   [(match_operand:V2SI 0 "register_operand")
    2066                 :          1 :    (match_operand:V8QI 1 "register_operand")
    2067                 :          0 :    (match_operand:V8QI 2 "register_operand")
    2068                 :          1 :    (match_operand:V2SI 3 "register_operand")]
    2069                 :          1 :   "TARGET_MMX_WITH_SSE"
    2070                 :          3 : {
    2071                 :          6 :   rtx t1 = gen_reg_rtx (V1DImode);
    2072                 :          3 :   rtx t2 = gen_reg_rtx (V2SImode);
    2073                 :          3 :   emit_insn (gen_mmx_psadbw (t1, operands[1], operands[2]));
    2074                 :          3 :   convert_move (t2, t1, 0);
    2075                 :          3 :   emit_insn (gen_addv2si3 (operands[0], t2, operands[3]));
    2076                 :          3 :   DONE;
    2077                 :            : })
    2078                 :            : 
    2079                 :            : (define_insn_and_split "mmx_pmovmskb"
    2080                 :          3 :   [(set (match_operand:SI 0 "register_operand" "=r,r")
    2081                 :            :         (unspec:SI [(match_operand:V8QI 1 "register_operand" "y,x")]
    2082                 :            :                    UNSPEC_MOVMSK))]
    2083                 :         46 :   "(TARGET_MMX || TARGET_MMX_WITH_SSE)
    2084                 :         46 :    && (TARGET_SSE || TARGET_3DNOW_A)"
    2085                 :          3 :   "@
    2086                 :          3 :    pmovmskb\t{%1, %0|%0, %1}
    2087                 :          3 :    #"
    2088                 :         47 :   "TARGET_SSE2 && reload_completed
    2089                 :         68 :    && SSE_REGNO_P (REGNO (operands[1]))"
    2090                 :         68 :   [(set (match_dup 0)
    2091                 :       1719 :         (unspec:SI [(match_dup 1)] UNSPEC_MOVMSK))
    2092                 :          3 :    (set (match_dup 0)
    2093                 :        163 :         (zero_extend:SI (match_dup 2)))]
    2094                 :         22 : {
    2095                 :          6 :   /* Generate SSE pmovmskb and zero-extend from QImode to SImode.  */
    2096                 :         50 :   operands[1] = lowpart_subreg (V16QImode, operands[1],
    2097                 :         22 :                                 GET_MODE (operands[1]));
    2098                 :         44 :   operands[2] = lowpart_subreg (QImode, operands[0],
    2099                 :         22 :                                 GET_MODE (operands[0]));
    2100                 :            : }
    2101                 :         22 :   [(set_attr "mmx_isa" "native,sse")
    2102                 :            :    (set_attr "type" "mmxcvt,ssemov")
    2103                 :         44 :    (set_attr "mode" "DI,TI")])
    2104                 :         44 : 
    2105                 :         44 : (define_expand "mmx_maskmovq"
    2106                 :         44 :   [(set (match_operand:V8QI 0 "memory_operand")
    2107                 :         22 :         (unspec:V8QI [(match_operand:V8QI 1 "register_operand")
    2108                 :          0 :                       (match_operand:V8QI 2 "register_operand")
    2109                 :         44 :                       (match_dup 0)]
    2110                 :            :                      UNSPEC_MASKMOV))]
    2111                 :            :   "TARGET_SSE || TARGET_3DNOW_A")
    2112                 :            : 
    2113                 :            : (define_insn "*mmx_maskmovq"
    2114                 :         22 :   [(set (mem:V8QI (match_operand:P 0 "register_operand" "D"))
    2115                 :            :         (unspec:V8QI [(match_operand:V8QI 1 "register_operand" "y")
    2116                 :            :                       (match_operand:V8QI 2 "register_operand" "y")
    2117                 :         22 :                       (mem:V8QI (match_dup 0))]
    2118                 :         22 :                      UNSPEC_MASKMOV))]
    2119                 :         26 :   "TARGET_SSE || TARGET_3DNOW_A"
    2120                 :            :   ;; @@@ check ordering of operands in intel/nonintel syntax
    2121                 :            :   "maskmovq\t{%2, %1|%1, %2}"
    2122                 :            :   [(set_attr "type" "mmxcvt")
    2123                 :            :    (set_attr "znver1_decode" "vector")
    2124                 :          1 :    (set_attr "mode" "DI")])
    2125                 :            : 
    2126                 :            : (define_int_iterator EMMS
    2127                 :        105 :   [(UNSPECV_EMMS "TARGET_MMX")
    2128                 :          1 :    (UNSPECV_FEMMS "TARGET_3DNOW")])
    2129                 :          0 : 
    2130                 :          0 : (define_int_attr emms
    2131                 :          0 :   [(UNSPECV_EMMS "emms")
    2132                 :         15 :    (UNSPECV_FEMMS "femms")])
    2133                 :          0 : 
    2134                 :      94957 : (define_expand "mmx_<emms>"
    2135                 :      94957 :   [(parallel
    2136                 :      94957 :     [(unspec_volatile [(const_int 0)] EMMS)
    2137                 :      94957 :       (clobber (reg:XF ST0_REG))
    2138                 :   20066100 :       (clobber (reg:XF ST1_REG))
    2139                 :        106 :       (clobber (reg:XF ST2_REG))
    2140                 :            :       (clobber (reg:XF ST3_REG))
    2141                 :        106 :       (clobber (reg:XF ST4_REG))
    2142                 :   20066206 :       (clobber (reg:XF ST5_REG))
    2143                 :   20066206 :       (clobber (reg:XF ST6_REG))
    2144                 :   20066100 :       (clobber (reg:XF ST7_REG))
    2145                 :   20066100 :       (clobber (reg:DI MM0_REG))
    2146                 :   20066100 :       (clobber (reg:DI MM1_REG))
    2147                 :            :       (clobber (reg:DI MM2_REG))
    2148                 :      10885 :       (clobber (reg:DI MM3_REG))
    2149                 :      10885 :       (clobber (reg:DI MM4_REG))
    2150                 :            :       (clobber (reg:DI MM5_REG))
    2151                 :      10859 :       (clobber (reg:DI MM6_REG))
    2152                 :      10859 :       (clobber (reg:DI MM7_REG))])]
    2153                 :            :   "TARGET_MMX || TARGET_MMX_WITH_SSE"
    2154                 :      10980 : {
    2155                 :        106 :    if (!TARGET_MMX)
    2156                 :         69 :      {
    2157                 :         70 :        emit_insn (gen_nop ());
    2158                 :         70 :        DONE;
    2159                 :            :      }
    2160                 :            : })
    2161                 :            : 
    2162                 :            : (define_insn "*mmx_<emms>"
    2163                 :            :   [(unspec_volatile [(const_int 0)] EMMS)
    2164                 :        120 :    (clobber (reg:XF ST0_REG))
    2165                 :            :    (clobber (reg:XF ST1_REG))
    2166                 :            :    (clobber (reg:XF ST2_REG))
    2167                 :            :    (clobber (reg:XF ST3_REG))
    2168                 :            :    (clobber (reg:XF ST4_REG))
    2169                 :            :    (clobber (reg:XF ST5_REG))
    2170                 :            :    (clobber (reg:XF ST6_REG))
    2171                 :            :    (clobber (reg:XF ST7_REG))
    2172                 :            :    (clobber (reg:DI MM0_REG))
    2173                 :            :    (clobber (reg:DI MM1_REG))
    2174                 :            :    (clobber (reg:DI MM2_REG))
    2175                 :            :    (clobber (reg:DI MM3_REG))
    2176                 :            :    (clobber (reg:DI MM4_REG))
    2177                 :            :    (clobber (reg:DI MM5_REG))
    2178                 :            :    (clobber (reg:DI MM6_REG))
    2179                 :            :    (clobber (reg:DI MM7_REG))]
    2180                 :            :   ""
    2181                 :            :   "<emms>"
    2182                 :            :   [(set_attr "type" "mmx")
    2183                 :            :    (set_attr "modrm" "0")
    2184                 :            :    (set_attr "memory" "none")])

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.