gcc/config/rs6000/vector.md

   1 ;; Expander definitions for vector support between altivec & vsx.  No
   2 ;; instructions are in this file, this file provides the generic vector
   3 ;; expander, and the actual vector instructions will be in altivec.md and
   4 ;; vsx.md
   5
   6 ;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
   7 ;; Contributed by Michael Meissner <meissner@linux.vnet.ibm.com>
   8
   9 ;; This file is part of GCC.
  10
  11 ;; GCC is free software; you can redistribute it and/or modify it
  12 ;; under the terms of the GNU General Public License as published
  13 ;; by the Free Software Foundation; either version 3, or (at your
  14 ;; option) any later version.
  15
  16 ;; GCC is distributed in the hope that it will be useful, but WITHOUT
  17 ;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  18 ;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  19 ;; License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GCC; see the file COPYING3.  If not see
  23 ;; <http://www.gnu.org/licenses/>.
  24
  25
  26 ;; Vector int modes
  27 (define_mode_iterator VEC_I [V16QI V8HI V4SI V2DI])
  28
  29 ;; Vector float modes
  30 (define_mode_iterator VEC_F [V4SF V2DF])
  31
  32 ;; Vector arithmetic modes
  33 (define_mode_iterator VEC_A [V16QI V8HI V4SI V2DI V4SF V2DF])
  34
  35 ;; Vector modes that need alginment via permutes
  36 (define_mode_iterator VEC_K [V16QI V8HI V4SI V4SF])
  37
  38 ;; Vector logical modes
  39 (define_mode_iterator VEC_L [V16QI V8HI V4SI V2DI V4SF V2DF V1TI TI])
  40
  41 ;; Vector modes for moves.  Don't do TImode here.
  42 (define_mode_iterator VEC_M [V16QI V8HI V4SI V2DI V4SF V2DF V1TI])
  43
  44 ;; Vector modes for types that don't need a realignment under VSX
  45 (define_mode_iterator VEC_N [V4SI V4SF V2DI V2DF V1TI])
  46
  47 ;; Vector comparison modes
  48 (define_mode_iterator VEC_C [V16QI V8HI V4SI V2DI V4SF V2DF])
  49
  50 ;; Vector init/extract modes
  51 (define_mode_iterator VEC_E [V16QI V8HI V4SI V2DI V4SF V2DF])
  52
  53 ;; Vector modes for 64-bit base types
  54 (define_mode_iterator VEC_64 [V2DI V2DF])
  55
  56 ;; Vector reload iterator
  57 (define_mode_iterator VEC_R [V16QI V8HI V4SI V2DI V4SF V2DF V1TI
  58                              SF SD SI DF DD DI TI])
  59
  60 ;; Base type from vector mode
  61 (define_mode_attr VEC_base [(V16QI "QI")
  62                             (V8HI  "HI")
  63                             (V4SI  "SI")
  64                             (V2DI  "DI")
  65                             (V4SF  "SF")
  66                             (V2DF  "DF")
  67                             (V1TI  "TI")
  68                             (TI    "TI")])
  69
  70 ;; Same size integer type for floating point data
  71 (define_mode_attr VEC_int [(V4SF  "v4si")
  72                            (V2DF  "v2di")])
  73
  74 (define_mode_attr VEC_INT [(V4SF  "V4SI")
  75                            (V2DF  "V2DI")])
  76
  77 ;; constants for unspec
  78 (define_c_enum "unspec" [UNSPEC_PREDICATE
  79                          UNSPEC_REDUC])
  80
  81 ;; Vector reduction code iterators
  82 (define_code_iterator VEC_reduc [plus smin smax])
  83
  84 (define_code_attr VEC_reduc_name [(plus "splus")
  85                                   (smin "smin")
  86                                   (smax "smax")])
  87
  88 (define_code_attr VEC_reduc_rtx [(plus "add")
  89                                  (smin "smin")
  90                                  (smax "smax")])
  91
  92 \f
  93 ;; Vector move instructions.  Little-endian VSX loads and stores require
  94 ;; special handling to circumvent "element endianness."
  95 (define_expand "mov<mode>"
  96   [(set (match_operand:VEC_M 0 "nonimmediate_operand" "")
  97         (match_operand:VEC_M 1 "any_operand" ""))]
  98   "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)"
  99 {
 100   if (can_create_pseudo_p ())
 101     {
 102       if (CONSTANT_P (operands[1])
 103           && !easy_vector_constant (operands[1], <MODE>mode))
 104         operands[1] = force_const_mem (<MODE>mode, operands[1]);
 105
 106       else if (!vlogical_operand (operands[0], <MODE>mode)
 107                && !vlogical_operand (operands[1], <MODE>mode))
 108         operands[1] = force_reg (<MODE>mode, operands[1]);
 109     }
 110   if (!BYTES_BIG_ENDIAN
 111       && VECTOR_MEM_VSX_P (<MODE>mode)
 112       && !gpr_or_gpr_p (operands[0], operands[1])
 113       && (memory_operand (operands[0], <MODE>mode)
 114           ^ memory_operand (operands[1], <MODE>mode)))
 115     {
 116       rs6000_emit_le_vsx_move (operands[0], operands[1], <MODE>mode);
 117       DONE;
 118     }
 119 })
 120
 121 ;; Generic vector floating point load/store instructions.  These will match
 122 ;; insns defined in vsx.md or altivec.md depending on the switches.
 123 (define_expand "vector_load_<mode>"
 124   [(set (match_operand:VEC_M 0 "vfloat_operand" "")
 125         (match_operand:VEC_M 1 "memory_operand" ""))]
 126   "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)"
 127   "")
 128
 129 (define_expand "vector_store_<mode>"
 130   [(set (match_operand:VEC_M 0 "memory_operand" "")
 131         (match_operand:VEC_M 1 "vfloat_operand" ""))]
 132   "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)"
 133   "")
 134
 135 ;; Splits if a GPR register was chosen for the move
 136 (define_split
 137   [(set (match_operand:VEC_L 0 "nonimmediate_operand" "")
 138         (match_operand:VEC_L 1 "input_operand" ""))]
 139   "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)
 140    && reload_completed
 141    && gpr_or_gpr_p (operands[0], operands[1])
 142    && !direct_move_p (operands[0], operands[1])
 143    && !quad_load_store_p (operands[0], operands[1])"
 144   [(pc)]
 145 {
 146   rs6000_split_multireg_move (operands[0], operands[1]);
 147   DONE;
 148 })
 149
 150 ;; Vector floating point load/store instructions that uses the Altivec
 151 ;; instructions even if we are compiling for VSX, since the Altivec
 152 ;; instructions silently ignore the bottom 3 bits of the address, and VSX does
 153 ;; not.
 154 (define_expand "vector_altivec_load_<mode>"
 155   [(set (match_operand:VEC_M 0 "vfloat_operand" "")
 156         (match_operand:VEC_M 1 "memory_operand" ""))]
 157   "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)"
 158   "
 159 {
 160   gcc_assert (VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode));
 161
 162   if (VECTOR_MEM_VSX_P (<MODE>mode))
 163     {
 164       operands[1] = rs6000_address_for_altivec (operands[1]);
 165       emit_insn (gen_altivec_lvx_<mode> (operands[0], operands[1]));
 166       DONE;
 167     }
 168 }")
 169
 170 (define_expand "vector_altivec_store_<mode>"
 171   [(set (match_operand:VEC_M 0 "memory_operand" "")
 172         (match_operand:VEC_M 1 "vfloat_operand" ""))]
 173   "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)"
 174   "
 175 {
 176   gcc_assert (VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode));
 177
 178   if (VECTOR_MEM_VSX_P (<MODE>mode))
 179     {
 180       operands[0] = rs6000_address_for_altivec (operands[0]);
 181       emit_insn (gen_altivec_stvx_<mode> (operands[0], operands[1]));
 182       DONE;
 183     }
 184 }")
 185
 186
 187 \f
 188 ;; Reload patterns for vector operations.  We may need an additional base
 189 ;; register to convert the reg+offset addressing to reg+reg for vector
 190 ;; registers and reg+reg or (reg+reg)&(-16) addressing to just an index
 191 ;; register for gpr registers.
 192 (define_expand "reload_<VEC_R:mode>_<P:mptrsize>_store"
 193   [(parallel [(match_operand:VEC_R 0 "memory_operand" "m")
 194               (match_operand:VEC_R 1 "gpc_reg_operand" "r")
 195               (match_operand:P 2 "register_operand" "=&b")])]
 196   "<P:tptrsize>"
 197 {
 198   rs6000_secondary_reload_inner (operands[1], operands[0], operands[2], true);
 199   DONE;
 200 })
 201
 202 (define_expand "reload_<VEC_R:mode>_<P:mptrsize>_load"
 203   [(parallel [(match_operand:VEC_R 0 "gpc_reg_operand" "=&r")
 204               (match_operand:VEC_R 1 "memory_operand" "m")
 205               (match_operand:P 2 "register_operand" "=&b")])]
 206   "<P:tptrsize>"
 207 {
 208   rs6000_secondary_reload_inner (operands[0], operands[1], operands[2], false);
 209   DONE;
 210 })
 211
 212 ;; Reload sometimes tries to move the address to a GPR, and can generate
 213 ;; invalid RTL for addresses involving AND -16.  Allow addresses involving
 214 ;; reg+reg, reg+small constant, or just reg, all wrapped in an AND -16.
 215
 216 (define_insn_and_split "*vec_reload_and_plus_<mptrsize>"
 217   [(set (match_operand:P 0 "gpc_reg_operand" "=b")
 218         (and:P (plus:P (match_operand:P 1 "gpc_reg_operand" "r")
 219                        (match_operand:P 2 "reg_or_cint_operand" "rI"))
 220                (const_int -16)))]
 221   "(TARGET_ALTIVEC || TARGET_VSX) && (reload_in_progress || reload_completed)"
 222   "#"
 223   "&& reload_completed"
 224   [(set (match_dup 0)
 225         (plus:P (match_dup 1)
 226                 (match_dup 2)))
 227    (parallel [(set (match_dup 0)
 228                    (and:P (match_dup 0)
 229                           (const_int -16)))
 230               (clobber:CC (scratch:CC))])])
 231
 232 ;; The normal ANDSI3/ANDDI3 won't match if reload decides to move an AND -16
 233 ;; address to a register because there is no clobber of a (scratch), so we add
 234 ;; it here.
 235 (define_insn_and_split "*vec_reload_and_reg_<mptrsize>"
 236   [(set (match_operand:P 0 "gpc_reg_operand" "=b")
 237         (and:P (match_operand:P 1 "gpc_reg_operand" "r")
 238                (const_int -16)))]
 239   "(TARGET_ALTIVEC || TARGET_VSX) && (reload_in_progress || reload_completed)"
 240   "#"
 241   "&& reload_completed"
 242   [(parallel [(set (match_dup 0)
 243                    (and:P (match_dup 1)
 244                           (const_int -16)))
 245               (clobber:CC (scratch:CC))])])
 246 \f
 247 ;; Generic floating point vector arithmetic support
 248 (define_expand "add<mode>3"
 249   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 250         (plus:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "")
 251                     (match_operand:VEC_F 2 "vfloat_operand" "")))]
 252   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 253   "")
 254
 255 (define_expand "sub<mode>3"
 256   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 257         (minus:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "")
 258                      (match_operand:VEC_F 2 "vfloat_operand" "")))]
 259   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 260   "")
 261
 262 (define_expand "mul<mode>3"
 263   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 264         (mult:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "")
 265                     (match_operand:VEC_F 2 "vfloat_operand" "")))]
 266   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 267 {
 268   if (<MODE>mode == V4SFmode && VECTOR_UNIT_ALTIVEC_P (<MODE>mode))
 269     {
 270       emit_insn (gen_altivec_mulv4sf3 (operands[0], operands[1], operands[2]));
 271       DONE;
 272     }
 273 })
 274
 275 (define_expand "div<mode>3"
 276   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 277         (div:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "")
 278                    (match_operand:VEC_F 2 "vfloat_operand" "")))]
 279   "VECTOR_UNIT_VSX_P (<MODE>mode)"
 280   "")
 281
 282 (define_expand "neg<mode>2"
 283   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 284         (neg:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "")))]
 285   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 286   "
 287 {
 288   if (<MODE>mode == V4SFmode && VECTOR_UNIT_ALTIVEC_P (<MODE>mode))
 289     {
 290       emit_insn (gen_altivec_negv4sf2 (operands[0], operands[1]));
 291       DONE;
 292     }
 293 }")
 294
 295 (define_expand "abs<mode>2"
 296   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 297         (abs:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "")))]
 298   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 299   "
 300 {
 301   if (<MODE>mode == V4SFmode && VECTOR_UNIT_ALTIVEC_P (<MODE>mode))
 302     {
 303       emit_insn (gen_altivec_absv4sf2 (operands[0], operands[1]));
 304       DONE;
 305     }
 306 }")
 307
 308 (define_expand "smin<mode>3"
 309   [(set (match_operand:VEC_F 0 "register_operand" "")
 310         (smin:VEC_F (match_operand:VEC_F 1 "register_operand" "")
 311                     (match_operand:VEC_F 2 "register_operand" "")))]
 312   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 313   "")
 314
 315 (define_expand "smax<mode>3"
 316   [(set (match_operand:VEC_F 0 "register_operand" "")
 317         (smax:VEC_F (match_operand:VEC_F 1 "register_operand" "")
 318                     (match_operand:VEC_F 2 "register_operand" "")))]
 319   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 320   "")
 321
 322
 323 (define_expand "sqrt<mode>2"
 324   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 325         (sqrt:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "")))]
 326   "VECTOR_UNIT_VSX_P (<MODE>mode)"
 327   "")
 328
 329 (define_expand "rsqrte<mode>2"
 330   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 331         (unspec:VEC_F [(match_operand:VEC_F 1 "vfloat_operand" "")]
 332                       UNSPEC_RSQRT))]
 333   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 334   "")
 335
 336 (define_expand "re<mode>2"
 337   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 338         (unspec:VEC_F [(match_operand:VEC_F 1 "vfloat_operand" "f")]
 339                       UNSPEC_FRES))]
 340   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 341   "")
 342
 343 (define_expand "ftrunc<mode>2"
 344   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 345         (fix:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "")))]
 346   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 347   "")
 348
 349 (define_expand "vector_ceil<mode>2"
 350   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 351         (unspec:VEC_F [(match_operand:VEC_F 1 "vfloat_operand" "")]
 352                       UNSPEC_FRIP))]
 353   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 354   "")
 355
 356 (define_expand "vector_floor<mode>2"
 357   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 358         (unspec:VEC_F [(match_operand:VEC_F 1 "vfloat_operand" "")]
 359                       UNSPEC_FRIM))]
 360   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 361   "")
 362
 363 (define_expand "vector_btrunc<mode>2"
 364   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 365         (fix:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "")))]
 366   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 367   "")
 368
 369 (define_expand "vector_copysign<mode>3"
 370   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 371         (unspec:VEC_F [(match_operand:VEC_F 1 "vfloat_operand" "")
 372                        (match_operand:VEC_F 2 "vfloat_operand" "")] UNSPEC_COPYSIGN))]
 373   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 374   "
 375 {
 376   if (<MODE>mode == V4SFmode && VECTOR_UNIT_ALTIVEC_P (<MODE>mode))
 377     {
 378       emit_insn (gen_altivec_copysign_v4sf3 (operands[0], operands[1],
 379                                              operands[2]));
 380       DONE;
 381     }
 382 }")
 383
 384 \f
 385 ;; Vector comparisons
 386 (define_expand "vcond<mode><mode>"
 387   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 388         (if_then_else:VEC_F
 389          (match_operator 3 "comparison_operator"
 390                          [(match_operand:VEC_F 4 "vfloat_operand" "")
 391                           (match_operand:VEC_F 5 "vfloat_operand" "")])
 392          (match_operand:VEC_F 1 "vfloat_operand" "")
 393          (match_operand:VEC_F 2 "vfloat_operand" "")))]
 394   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 395   "
 396 {
 397   if (rs6000_emit_vector_cond_expr (operands[0], operands[1], operands[2],
 398                                     operands[3], operands[4], operands[5]))
 399     DONE;
 400   else
 401     FAIL;
 402 }")
 403
 404 (define_expand "vcond<mode><mode>"
 405   [(set (match_operand:VEC_I 0 "vint_operand" "")
 406         (if_then_else:VEC_I
 407          (match_operator 3 "comparison_operator"
 408                          [(match_operand:VEC_I 4 "vint_operand" "")
 409                           (match_operand:VEC_I 5 "vint_operand" "")])
 410          (match_operand:VEC_I 1 "vint_operand" "")
 411          (match_operand:VEC_I 2 "vint_operand" "")))]
 412   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 413   "
 414 {
 415   if (rs6000_emit_vector_cond_expr (operands[0], operands[1], operands[2],
 416                                     operands[3], operands[4], operands[5]))
 417     DONE;
 418   else
 419     FAIL;
 420 }")
 421
 422 (define_expand "vcondv4sfv4si"
 423   [(set (match_operand:V4SF 0 "vfloat_operand" "")
 424         (if_then_else:V4SF
 425          (match_operator 3 "comparison_operator"
 426                          [(match_operand:V4SI 4 "vint_operand" "")
 427                           (match_operand:V4SI 5 "vint_operand" "")])
 428          (match_operand:V4SF 1 "vfloat_operand" "")
 429          (match_operand:V4SF 2 "vfloat_operand" "")))]
 430   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SFmode)
 431    && VECTOR_UNIT_ALTIVEC_P (V4SImode)"
 432   "
 433 {
 434   if (rs6000_emit_vector_cond_expr (operands[0], operands[1], operands[2],
 435                                     operands[3], operands[4], operands[5]))
 436     DONE;
 437   else
 438     FAIL;
 439 }")
 440
 441 (define_expand "vcondv4siv4sf"
 442   [(set (match_operand:V4SI 0 "vint_operand" "")
 443         (if_then_else:V4SI
 444          (match_operator 3 "comparison_operator"
 445                          [(match_operand:V4SF 4 "vfloat_operand" "")
 446                           (match_operand:V4SF 5 "vfloat_operand" "")])
 447          (match_operand:V4SI 1 "vint_operand" "")
 448          (match_operand:V4SI 2 "vint_operand" "")))]
 449   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SFmode)
 450    && VECTOR_UNIT_ALTIVEC_P (V4SImode)"
 451   "
 452 {
 453   if (rs6000_emit_vector_cond_expr (operands[0], operands[1], operands[2],
 454                                     operands[3], operands[4], operands[5]))
 455     DONE;
 456   else
 457     FAIL;
 458 }")
 459
 460 (define_expand "vcondu<mode><mode>"
 461   [(set (match_operand:VEC_I 0 "vint_operand" "")
 462         (if_then_else:VEC_I
 463          (match_operator 3 "comparison_operator"
 464                          [(match_operand:VEC_I 4 "vint_operand" "")
 465                           (match_operand:VEC_I 5 "vint_operand" "")])
 466          (match_operand:VEC_I 1 "vint_operand" "")
 467          (match_operand:VEC_I 2 "vint_operand" "")))]
 468   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 469   "
 470 {
 471   if (rs6000_emit_vector_cond_expr (operands[0], operands[1], operands[2],
 472                                     operands[3], operands[4], operands[5]))
 473     DONE;
 474   else
 475     FAIL;
 476 }")
 477
 478 (define_expand "vconduv4sfv4si"
 479   [(set (match_operand:V4SF 0 "vfloat_operand" "")
 480         (if_then_else:V4SF
 481          (match_operator 3 "comparison_operator"
 482                          [(match_operand:V4SI 4 "vint_operand" "")
 483                           (match_operand:V4SI 5 "vint_operand" "")])
 484          (match_operand:V4SF 1 "vfloat_operand" "")
 485          (match_operand:V4SF 2 "vfloat_operand" "")))]
 486   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SFmode)
 487    && VECTOR_UNIT_ALTIVEC_P (V4SImode)"
 488   "
 489 {
 490   if (rs6000_emit_vector_cond_expr (operands[0], operands[1], operands[2],
 491                                     operands[3], operands[4], operands[5]))
 492     DONE;
 493   else
 494     FAIL;
 495 }")
 496
 497 (define_expand "vector_eq<mode>"
 498   [(set (match_operand:VEC_C 0 "vlogical_operand" "")
 499         (eq:VEC_C (match_operand:VEC_C 1 "vlogical_operand" "")
 500                   (match_operand:VEC_C 2 "vlogical_operand" "")))]
 501   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 502   "")
 503
 504 (define_expand "vector_gt<mode>"
 505   [(set (match_operand:VEC_C 0 "vlogical_operand" "")
 506         (gt:VEC_C (match_operand:VEC_C 1 "vlogical_operand" "")
 507                   (match_operand:VEC_C 2 "vlogical_operand" "")))]
 508   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 509   "")
 510
 511 (define_expand "vector_ge<mode>"
 512   [(set (match_operand:VEC_C 0 "vlogical_operand" "")
 513         (ge:VEC_C (match_operand:VEC_C 1 "vlogical_operand" "")
 514                   (match_operand:VEC_C 2 "vlogical_operand" "")))]
 515   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 516   "")
 517
 518 (define_expand "vector_gtu<mode>"
 519   [(set (match_operand:VEC_I 0 "vint_operand" "")
 520         (gtu:VEC_I (match_operand:VEC_I 1 "vint_operand" "")
 521                    (match_operand:VEC_I 2 "vint_operand" "")))]
 522   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 523   "")
 524
 525 (define_expand "vector_geu<mode>"
 526   [(set (match_operand:VEC_I 0 "vint_operand" "")
 527         (geu:VEC_I (match_operand:VEC_I 1 "vint_operand" "")
 528                    (match_operand:VEC_I 2 "vint_operand" "")))]
 529   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 530   "")
 531
 532 (define_insn_and_split "*vector_uneq<mode>"
 533   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 534         (uneq:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "")
 535                     (match_operand:VEC_F 2 "vfloat_operand" "")))]
 536   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 537   "#"
 538   ""
 539   [(set (match_dup 3)
 540         (gt:VEC_F (match_dup 1)
 541                   (match_dup 2)))
 542    (set (match_dup 4)
 543         (gt:VEC_F (match_dup 2)
 544                   (match_dup 1)))
 545    (set (match_dup 0)
 546         (not:VEC_F (ior:VEC_F (match_dup 3)
 547                               (match_dup 4))))]
 548   "
 549 {
 550   operands[3] = gen_reg_rtx (<MODE>mode);
 551   operands[4] = gen_reg_rtx (<MODE>mode);
 552 }")
 553
 554 (define_insn_and_split "*vector_ltgt<mode>"
 555   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 556         (ltgt:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "")
 557                     (match_operand:VEC_F 2 "vfloat_operand" "")))]
 558   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 559   "#"
 560   ""
 561   [(set (match_dup 3)
 562         (gt:VEC_F (match_dup 1)
 563                   (match_dup 2)))
 564    (set (match_dup 4)
 565         (gt:VEC_F (match_dup 2)
 566                   (match_dup 1)))
 567    (set (match_dup 0)
 568         (ior:VEC_F (match_dup 3)
 569                    (match_dup 4)))]
 570   "
 571 {
 572   operands[3] = gen_reg_rtx (<MODE>mode);
 573   operands[4] = gen_reg_rtx (<MODE>mode);
 574 }")
 575
 576 (define_insn_and_split "*vector_ordered<mode>"
 577   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 578         (ordered:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "")
 579                        (match_operand:VEC_F 2 "vfloat_operand" "")))]
 580   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 581   "#"
 582   ""
 583   [(set (match_dup 3)
 584         (ge:VEC_F (match_dup 1)
 585                   (match_dup 2)))
 586    (set (match_dup 4)
 587         (ge:VEC_F (match_dup 2)
 588                   (match_dup 1)))
 589    (set (match_dup 0)
 590         (ior:VEC_F (match_dup 3)
 591                    (match_dup 4)))]
 592   "
 593 {
 594   operands[3] = gen_reg_rtx (<MODE>mode);
 595   operands[4] = gen_reg_rtx (<MODE>mode);
 596 }")
 597
 598 (define_insn_and_split "*vector_unordered<mode>"
 599   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 600         (unordered:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "")
 601                          (match_operand:VEC_F 2 "vfloat_operand" "")))]
 602   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 603   "#"
 604   ""
 605   [(set (match_dup 3)
 606         (ge:VEC_F (match_dup 1)
 607                   (match_dup 2)))
 608    (set (match_dup 4)
 609         (ge:VEC_F (match_dup 2)
 610                   (match_dup 1)))
 611    (set (match_dup 0)
 612         (and:VEC_F (not:VEC_F (match_dup 3))
 613                    (not:VEC_F (match_dup 4))))]
 614   "
 615 {
 616   operands[3] = gen_reg_rtx (<MODE>mode);
 617   operands[4] = gen_reg_rtx (<MODE>mode);
 618 }")
 619
 620 ;; Note the arguments for __builtin_altivec_vsel are op2, op1, mask
 621 ;; which is in the reverse order that we want
 622 (define_expand "vector_select_<mode>"
 623   [(set (match_operand:VEC_L 0 "vlogical_operand" "")
 624         (if_then_else:VEC_L
 625          (ne:CC (match_operand:VEC_L 3 "vlogical_operand" "")
 626                 (match_dup 4))
 627          (match_operand:VEC_L 2 "vlogical_operand" "")
 628          (match_operand:VEC_L 1 "vlogical_operand" "")))]
 629   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 630   "operands[4] = CONST0_RTX (<MODE>mode);")
 631
 632 (define_expand "vector_select_<mode>_uns"
 633   [(set (match_operand:VEC_L 0 "vlogical_operand" "")
 634         (if_then_else:VEC_L
 635          (ne:CCUNS (match_operand:VEC_L 3 "vlogical_operand" "")
 636                    (match_dup 4))
 637          (match_operand:VEC_L 2 "vlogical_operand" "")
 638          (match_operand:VEC_L 1 "vlogical_operand" "")))]
 639   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 640   "operands[4] = CONST0_RTX (<MODE>mode);")
 641
 642 ;; Expansions that compare vectors producing a vector result and a predicate,
 643 ;; setting CR6 to indicate a combined status
 644 (define_expand "vector_eq_<mode>_p"
 645   [(parallel
 646     [(set (reg:CC 74)
 647           (unspec:CC [(eq:CC (match_operand:VEC_A 1 "vlogical_operand" "")
 648                              (match_operand:VEC_A 2 "vlogical_operand" ""))]
 649                      UNSPEC_PREDICATE))
 650      (set (match_operand:VEC_A 0 "vlogical_operand" "")
 651           (eq:VEC_A (match_dup 1)
 652                     (match_dup 2)))])]
 653   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 654   "")
 655
 656 (define_expand "vector_gt_<mode>_p"
 657   [(parallel
 658     [(set (reg:CC 74)
 659           (unspec:CC [(gt:CC (match_operand:VEC_A 1 "vlogical_operand" "")
 660                              (match_operand:VEC_A 2 "vlogical_operand" ""))]
 661                      UNSPEC_PREDICATE))
 662      (set (match_operand:VEC_A 0 "vlogical_operand" "")
 663           (gt:VEC_A (match_dup 1)
 664                     (match_dup 2)))])]
 665   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 666   "")
 667
 668 (define_expand "vector_ge_<mode>_p"
 669   [(parallel
 670     [(set (reg:CC 74)
 671           (unspec:CC [(ge:CC (match_operand:VEC_F 1 "vfloat_operand" "")
 672                              (match_operand:VEC_F 2 "vfloat_operand" ""))]
 673                      UNSPEC_PREDICATE))
 674      (set (match_operand:VEC_F 0 "vfloat_operand" "")
 675           (ge:VEC_F (match_dup 1)
 676                     (match_dup 2)))])]
 677   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 678   "")
 679
 680 (define_expand "vector_gtu_<mode>_p"
 681   [(parallel
 682     [(set (reg:CC 74)
 683           (unspec:CC [(gtu:CC (match_operand:VEC_I 1 "vint_operand" "")
 684                               (match_operand:VEC_I 2 "vint_operand" ""))]
 685                      UNSPEC_PREDICATE))
 686      (set (match_operand:VEC_I 0 "vlogical_operand" "")
 687           (gtu:VEC_I (match_dup 1)
 688                      (match_dup 2)))])]
 689   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 690   "")
 691
 692 ;; AltiVec/VSX predicates.
 693
 694 (define_expand "cr6_test_for_zero"
 695   [(set (match_operand:SI 0 "register_operand" "=r")
 696         (eq:SI (reg:CC 74)
 697                (const_int 0)))]
 698   "TARGET_ALTIVEC || TARGET_VSX"
 699   "")
 700
 701 (define_expand "cr6_test_for_zero_reverse"
 702   [(set (match_operand:SI 0 "register_operand" "=r")
 703         (eq:SI (reg:CC 74)
 704                (const_int 0)))
 705    (set (match_dup 0) (minus:SI (const_int 1) (match_dup 0)))]
 706   "TARGET_ALTIVEC || TARGET_VSX"
 707   "")
 708
 709 (define_expand "cr6_test_for_lt"
 710   [(set (match_operand:SI 0 "register_operand" "=r")
 711         (lt:SI (reg:CC 74)
 712                (const_int 0)))]
 713   "TARGET_ALTIVEC || TARGET_VSX"
 714   "")
 715
 716 (define_expand "cr6_test_for_lt_reverse"
 717   [(set (match_operand:SI 0 "register_operand" "=r")
 718         (lt:SI (reg:CC 74)
 719                (const_int 0)))
 720    (set (match_dup 0) (minus:SI (const_int 1) (match_dup 0)))]
 721   "TARGET_ALTIVEC || TARGET_VSX"
 722   "")
 723
 724 \f
 725 ;; Vector count leading zeros
 726 (define_expand "clz<mode>2"
 727   [(set (match_operand:VEC_I 0 "register_operand" "")
 728         (clz:VEC_I (match_operand:VEC_I 1 "register_operand" "")))]
 729   "TARGET_P8_VECTOR")
 730
 731 ;; Vector population count
 732 (define_expand "popcount<mode>2"
 733   [(set (match_operand:VEC_I 0 "register_operand" "")
 734         (popcount:VEC_I (match_operand:VEC_I 1 "register_operand" "")))]
 735   "TARGET_P8_VECTOR")
 736
 737 \f
 738 ;; Same size conversions
 739 (define_expand "float<VEC_int><mode>2"
 740   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 741         (float:VEC_F (match_operand:<VEC_INT> 1 "vint_operand" "")))]
 742   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 743   "
 744 {
 745   if (<MODE>mode == V4SFmode && VECTOR_UNIT_ALTIVEC_P (<MODE>mode))
 746     {
 747       emit_insn (gen_altivec_vcfsx (operands[0], operands[1], const0_rtx));
 748       DONE;
 749     }
 750 }")
 751
 752 (define_expand "floatuns<VEC_int><mode>2"
 753   [(set (match_operand:VEC_F 0 "vfloat_operand" "")
 754         (unsigned_float:VEC_F (match_operand:<VEC_INT> 1 "vint_operand" "")))]
 755   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 756   "
 757 {
 758   if (<MODE>mode == V4SFmode && VECTOR_UNIT_ALTIVEC_P (<MODE>mode))
 759     {
 760       emit_insn (gen_altivec_vcfux (operands[0], operands[1], const0_rtx));
 761       DONE;
 762     }
 763 }")
 764
 765 (define_expand "fix_trunc<mode><VEC_int>2"
 766   [(set (match_operand:<VEC_INT> 0 "vint_operand" "")
 767         (fix:<VEC_INT> (match_operand:VEC_F 1 "vfloat_operand" "")))]
 768   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 769   "
 770 {
 771   if (<MODE>mode == V4SFmode && VECTOR_UNIT_ALTIVEC_P (<MODE>mode))
 772     {
 773       emit_insn (gen_altivec_vctsxs (operands[0], operands[1], const0_rtx));
 774       DONE;
 775     }
 776 }")
 777
 778 (define_expand "fixuns_trunc<mode><VEC_int>2"
 779   [(set (match_operand:<VEC_INT> 0 "vint_operand" "")
 780         (unsigned_fix:<VEC_INT> (match_operand:VEC_F 1 "vfloat_operand" "")))]
 781   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
 782   "
 783 {
 784   if (<MODE>mode == V4SFmode && VECTOR_UNIT_ALTIVEC_P (<MODE>mode))
 785     {
 786       emit_insn (gen_altivec_vctuxs (operands[0], operands[1], const0_rtx));
 787       DONE;
 788     }
 789 }")
 790
 791 \f
 792 ;; Vector initialization, set, extract
 793 (define_expand "vec_init<mode>"
 794   [(match_operand:VEC_E 0 "vlogical_operand" "")
 795    (match_operand:VEC_E 1 "" "")]
 796   "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)"
 797 {
 798   rs6000_expand_vector_init (operands[0], operands[1]);
 799   DONE;
 800 })
 801
 802 (define_expand "vec_set<mode>"
 803   [(match_operand:VEC_E 0 "vlogical_operand" "")
 804    (match_operand:<VEC_base> 1 "register_operand" "")
 805    (match_operand 2 "const_int_operand" "")]
 806   "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)"
 807 {
 808   rs6000_expand_vector_set (operands[0], operands[1], INTVAL (operands[2]));
 809   DONE;
 810 })
 811
 812 (define_expand "vec_extract<mode>"
 813   [(match_operand:<VEC_base> 0 "register_operand" "")
 814    (match_operand:VEC_E 1 "vlogical_operand" "")
 815    (match_operand 2 "const_int_operand" "")]
 816   "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)"
 817 {
 818   rs6000_expand_vector_extract (operands[0], operands[1],
 819                                 INTVAL (operands[2]));
 820   DONE;
 821 })
 822 \f
 823 ;; Convert double word types to single word types
 824 (define_expand "vec_pack_trunc_v2df"
 825   [(match_operand:V4SF 0 "vfloat_operand" "")
 826    (match_operand:V2DF 1 "vfloat_operand" "")
 827    (match_operand:V2DF 2 "vfloat_operand" "")]
 828   "VECTOR_UNIT_VSX_P (V2DFmode) && TARGET_ALTIVEC"
 829 {
 830   rtx r1 = gen_reg_rtx (V4SFmode);
 831   rtx r2 = gen_reg_rtx (V4SFmode);
 832
 833   emit_insn (gen_vsx_xvcvdpsp (r1, operands[1]));
 834   emit_insn (gen_vsx_xvcvdpsp (r2, operands[2]));
 835   rs6000_expand_extract_even (operands[0], r1, r2);
 836   DONE;
 837 })
 838
 839 (define_expand "vec_pack_sfix_trunc_v2df"
 840   [(match_operand:V4SI 0 "vint_operand" "")
 841    (match_operand:V2DF 1 "vfloat_operand" "")
 842    (match_operand:V2DF 2 "vfloat_operand" "")]
 843   "VECTOR_UNIT_VSX_P (V2DFmode) && TARGET_ALTIVEC"
 844 {
 845   rtx r1 = gen_reg_rtx (V4SImode);
 846   rtx r2 = gen_reg_rtx (V4SImode);
 847
 848   emit_insn (gen_vsx_xvcvdpsxws (r1, operands[1]));
 849   emit_insn (gen_vsx_xvcvdpsxws (r2, operands[2]));
 850   rs6000_expand_extract_even (operands[0], r1, r2);
 851   DONE;
 852 })
 853
 854 (define_expand "vec_pack_ufix_trunc_v2df"
 855   [(match_operand:V4SI 0 "vint_operand" "")
 856    (match_operand:V2DF 1 "vfloat_operand" "")
 857    (match_operand:V2DF 2 "vfloat_operand" "")]
 858   "VECTOR_UNIT_VSX_P (V2DFmode) && TARGET_ALTIVEC"
 859 {
 860   rtx r1 = gen_reg_rtx (V4SImode);
 861   rtx r2 = gen_reg_rtx (V4SImode);
 862
 863   emit_insn (gen_vsx_xvcvdpuxws (r1, operands[1]));
 864   emit_insn (gen_vsx_xvcvdpuxws (r2, operands[2]));
 865   rs6000_expand_extract_even (operands[0], r1, r2);
 866   DONE;
 867 })
 868
 869 ;; Convert single word types to double word
 870 (define_expand "vec_unpacks_hi_v4sf"
 871   [(match_operand:V2DF 0 "vfloat_operand" "")
 872    (match_operand:V4SF 1 "vfloat_operand" "")]
 873   "VECTOR_UNIT_VSX_P (V2DFmode) && VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SFmode)"
 874 {
 875   rtx reg = gen_reg_rtx (V4SFmode);
 876
 877   rs6000_expand_interleave (reg, operands[1], operands[1], BYTES_BIG_ENDIAN);
 878   emit_insn (gen_vsx_xvcvspdp (operands[0], reg));
 879   DONE;
 880 })
 881
 882 (define_expand "vec_unpacks_lo_v4sf"
 883   [(match_operand:V2DF 0 "vfloat_operand" "")
 884    (match_operand:V4SF 1 "vfloat_operand" "")]
 885   "VECTOR_UNIT_VSX_P (V2DFmode) && VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SFmode)"
 886 {
 887   rtx reg = gen_reg_rtx (V4SFmode);
 888
 889   rs6000_expand_interleave (reg, operands[1], operands[1], !BYTES_BIG_ENDIAN);
 890   emit_insn (gen_vsx_xvcvspdp (operands[0], reg));
 891   DONE;
 892 })
 893
 894 (define_expand "vec_unpacks_float_hi_v4si"
 895   [(match_operand:V2DF 0 "vfloat_operand" "")
 896    (match_operand:V4SI 1 "vint_operand" "")]
 897   "VECTOR_UNIT_VSX_P (V2DFmode) && VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SImode)"
 898 {
 899   rtx reg = gen_reg_rtx (V4SImode);
 900
 901   rs6000_expand_interleave (reg, operands[1], operands[1], BYTES_BIG_ENDIAN);
 902   emit_insn (gen_vsx_xvcvsxwdp (operands[0], reg));
 903   DONE;
 904 })
 905
 906 (define_expand "vec_unpacks_float_lo_v4si"
 907   [(match_operand:V2DF 0 "vfloat_operand" "")
 908    (match_operand:V4SI 1 "vint_operand" "")]
 909   "VECTOR_UNIT_VSX_P (V2DFmode) && VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SImode)"
 910 {
 911   rtx reg = gen_reg_rtx (V4SImode);
 912
 913   rs6000_expand_interleave (reg, operands[1], operands[1], !BYTES_BIG_ENDIAN);
 914   emit_insn (gen_vsx_xvcvsxwdp (operands[0], reg));
 915   DONE;
 916 })
 917
 918 (define_expand "vec_unpacku_float_hi_v4si"
 919   [(match_operand:V2DF 0 "vfloat_operand" "")
 920    (match_operand:V4SI 1 "vint_operand" "")]
 921   "VECTOR_UNIT_VSX_P (V2DFmode) && VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SImode)"
 922 {
 923   rtx reg = gen_reg_rtx (V4SImode);
 924
 925   rs6000_expand_interleave (reg, operands[1], operands[1], BYTES_BIG_ENDIAN);
 926   emit_insn (gen_vsx_xvcvuxwdp (operands[0], reg));
 927   DONE;
 928 })
 929
 930 (define_expand "vec_unpacku_float_lo_v4si"
 931   [(match_operand:V2DF 0 "vfloat_operand" "")
 932    (match_operand:V4SI 1 "vint_operand" "")]
 933   "VECTOR_UNIT_VSX_P (V2DFmode) && VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SImode)"
 934 {
 935   rtx reg = gen_reg_rtx (V4SImode);
 936
 937   rs6000_expand_interleave (reg, operands[1], operands[1], !BYTES_BIG_ENDIAN);
 938   emit_insn (gen_vsx_xvcvuxwdp (operands[0], reg));
 939   DONE;
 940 })
 941
 942 \f
 943 ;; Align vector loads with a permute.
 944 (define_expand "vec_realign_load_<mode>"
 945   [(match_operand:VEC_K 0 "vlogical_operand" "")
 946    (match_operand:VEC_K 1 "vlogical_operand" "")
 947    (match_operand:VEC_K 2 "vlogical_operand" "")
 948    (match_operand:V16QI 3 "vlogical_operand" "")]
 949   "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)"
 950 {
 951   if (BYTES_BIG_ENDIAN)
 952     emit_insn (gen_altivec_vperm_<mode> (operands[0], operands[1],
 953                                          operands[2], operands[3]));
 954   else
 955     {
 956       /* We have changed lvsr to lvsl, so to complete the transformation
 957          of vperm for LE, we must swap the inputs.  */
 958       rtx unspec = gen_rtx_UNSPEC (<MODE>mode,
 959                                    gen_rtvec (3, operands[2],
 960                                               operands[1], operands[3]),
 961                                    UNSPEC_VPERM);
 962       emit_move_insn (operands[0], unspec);
 963     }
 964   DONE;
 965 })
 966
 967 ;; Under VSX, vectors of 4/8 byte alignments do not need to be aligned
 968 ;; since the load already handles it.
 969 (define_expand "movmisalign<mode>"
 970  [(set (match_operand:VEC_N 0 "nonimmediate_operand" "")
 971        (match_operand:VEC_N 1 "any_operand" ""))]
 972  "VECTOR_MEM_VSX_P (<MODE>mode) && TARGET_ALLOW_MOVMISALIGN"
 973  "")
 974
 975 \f
 976 ;; Vector shift left in bits.  Currently supported ony for shift
 977 ;; amounts that can be expressed as byte shifts (divisible by 8).
 978 ;; General shift amounts can be supported using vslo + vsl. We're
 979 ;; not expecting to see these yet (the vectorizer currently
 980 ;; generates only shifts divisible by byte_size).
 981 (define_expand "vec_shl_<mode>"
 982   [(match_operand:VEC_L 0 "vlogical_operand" "")
 983    (match_operand:VEC_L 1 "vlogical_operand" "")
 984    (match_operand:QI 2 "reg_or_short_operand" "")]
 985   "TARGET_ALTIVEC"
 986   "
 987 {
 988   rtx bitshift = operands[2];
 989   rtx shift;
 990   rtx insn;
 991   HOST_WIDE_INT bitshift_val;
 992   HOST_WIDE_INT byteshift_val;
 993
 994   if (! CONSTANT_P (bitshift))
 995     FAIL;
 996   bitshift_val = INTVAL (bitshift);
 997   if (bitshift_val & 0x7)
 998     FAIL;
 999   byteshift_val = bitshift_val >> 3;
1000   if (TARGET_VSX && (byteshift_val & 0x3) == 0)
1001     {
1002       shift = gen_rtx_CONST_INT (QImode, byteshift_val >> 2);
1003       insn = gen_vsx_xxsldwi_<mode> (operands[0], operands[1], operands[1],
1004                                      shift);
1005     }
1006   else
1007     {
1008       shift = gen_rtx_CONST_INT (QImode, byteshift_val);
1009       insn = gen_altivec_vsldoi_<mode> (operands[0], operands[1], operands[1],
1010                                         shift);
1011     }
1012
1013   emit_insn (insn);
1014   DONE;
1015 }")
1016
1017 ;; Vector shift right in bits. Currently supported ony for shift
1018 ;; amounts that can be expressed as byte shifts (divisible by 8).
1019 ;; General shift amounts can be supported using vsro + vsr. We're
1020 ;; not expecting to see these yet (the vectorizer currently
1021 ;; generates only shifts divisible by byte_size).
1022 (define_expand "vec_shr_<mode>"
1023   [(match_operand:VEC_L 0 "vlogical_operand" "")
1024    (match_operand:VEC_L 1 "vlogical_operand" "")
1025    (match_operand:QI 2 "reg_or_short_operand" "")]
1026   "TARGET_ALTIVEC"
1027   "
1028 {
1029   rtx bitshift = operands[2];
1030   rtx shift;
1031   rtx insn;
1032   HOST_WIDE_INT bitshift_val;
1033   HOST_WIDE_INT byteshift_val;
1034
1035   if (! CONSTANT_P (bitshift))
1036     FAIL;
1037   bitshift_val = INTVAL (bitshift);
1038   if (bitshift_val & 0x7)
1039     FAIL;
1040   byteshift_val = 16 - (bitshift_val >> 3);
1041   if (TARGET_VSX && (byteshift_val & 0x3) == 0)
1042     {
1043       shift = gen_rtx_CONST_INT (QImode, byteshift_val >> 2);
1044       insn = gen_vsx_xxsldwi_<mode> (operands[0], operands[1], operands[1],
1045                                      shift);
1046     }
1047   else
1048     {
1049       shift = gen_rtx_CONST_INT (QImode, byteshift_val);
1050       insn = gen_altivec_vsldoi_<mode> (operands[0], operands[1], operands[1],
1051                                         shift);
1052     }
1053
1054   emit_insn (insn);
1055   DONE;
1056 }")
1057
1058 ;; Expanders for rotate each element in a vector
1059 (define_expand "vrotl<mode>3"
1060   [(set (match_operand:VEC_I 0 "vint_operand" "")
1061         (rotate:VEC_I (match_operand:VEC_I 1 "vint_operand" "")
1062                       (match_operand:VEC_I 2 "vint_operand" "")))]
1063   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
1064   "")
1065
1066 ;; Expanders for arithmetic shift left on each vector element
1067 (define_expand "vashl<mode>3"
1068   [(set (match_operand:VEC_I 0 "vint_operand" "")
1069         (ashift:VEC_I (match_operand:VEC_I 1 "vint_operand" "")
1070                       (match_operand:VEC_I 2 "vint_operand" "")))]
1071   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
1072   "")
1073
1074 ;; Expanders for logical shift right on each vector element
1075 (define_expand "vlshr<mode>3"
1076   [(set (match_operand:VEC_I 0 "vint_operand" "")
1077         (lshiftrt:VEC_I (match_operand:VEC_I 1 "vint_operand" "")
1078                         (match_operand:VEC_I 2 "vint_operand" "")))]
1079   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
1080   "")
1081
1082 ;; Expanders for arithmetic shift right on each vector element
1083 (define_expand "vashr<mode>3"
1084   [(set (match_operand:VEC_I 0 "vint_operand" "")
1085         (ashiftrt:VEC_I (match_operand:VEC_I 1 "vint_operand" "")
1086                         (match_operand:VEC_I 2 "vint_operand" "")))]
1087   "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)"
1088   "")
1089 \f
1090 ;; Vector reduction expanders for VSX
1091
1092 (define_expand "reduc_<VEC_reduc_name>_v2df"
1093   [(parallel [(set (match_operand:V2DF 0 "vfloat_operand" "")
1094                    (VEC_reduc:V2DF
1095                     (vec_concat:V2DF
1096                      (vec_select:DF
1097                       (match_operand:V2DF 1 "vfloat_operand" "")
1098                       (parallel [(const_int 1)]))
1099                      (vec_select:DF
1100                       (match_dup 1)
1101                       (parallel [(const_int 0)])))
1102                     (match_dup 1)))
1103               (clobber (match_scratch:V2DF 2 ""))])]
1104   "VECTOR_UNIT_VSX_P (V2DFmode)"
1105   "")
1106
1107 ; The (VEC_reduc:V4SF
1108 ;       (op1)
1109 ;       (unspec:V4SF [(const_int 0)] UNSPEC_REDUC))
1110 ;
1111 ; is to allow us to use a code iterator, but not completely list all of the
1112 ; vector rotates, etc. to prevent canonicalization
1113
1114 (define_expand "reduc_<VEC_reduc_name>_v4sf"
1115   [(parallel [(set (match_operand:V4SF 0 "vfloat_operand" "")
1116                    (VEC_reduc:V4SF
1117                     (unspec:V4SF [(const_int 0)] UNSPEC_REDUC)
1118                     (match_operand:V4SF 1 "vfloat_operand" "")))
1119               (clobber (match_scratch:V4SF 2 ""))
1120               (clobber (match_scratch:V4SF 3 ""))])]
1121   "VECTOR_UNIT_VSX_P (V4SFmode)"
1122   "")
1123
1124 \f
1125 ;;; Expanders for vector insn patterns shared between the SPE and TARGET_PAIRED systems.
1126
1127 (define_expand "absv2sf2"
1128   [(set (match_operand:V2SF 0 "gpc_reg_operand" "")
1129         (abs:V2SF (match_operand:V2SF 1 "gpc_reg_operand" "")))]
1130   "TARGET_PAIRED_FLOAT || TARGET_SPE"
1131   "")
1132
1133 (define_expand "negv2sf2"
1134   [(set (match_operand:V2SF 0 "gpc_reg_operand" "")
1135         (neg:V2SF (match_operand:V2SF 1 "gpc_reg_operand" "")))]
1136   "TARGET_PAIRED_FLOAT || TARGET_SPE"
1137   "")
1138
1139 (define_expand "addv2sf3"
1140   [(set (match_operand:V2SF 0 "gpc_reg_operand" "")
1141         (plus:V2SF (match_operand:V2SF 1 "gpc_reg_operand" "")
1142                    (match_operand:V2SF 2 "gpc_reg_operand" "")))]
1143   "TARGET_PAIRED_FLOAT || TARGET_SPE"
1144   "
1145 {
1146   if (TARGET_SPE)
1147     {
1148       /* We need to make a note that we clobber SPEFSCR.  */
1149       rtx par = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
1150
1151       XVECEXP (par, 0, 0) = gen_rtx_SET (VOIDmode, operands[0],
1152                                          gen_rtx_PLUS (V2SFmode, operands[1], operands[2]));
1153       XVECEXP (par, 0, 1) = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (SImode, SPEFSCR_REGNO));
1154       emit_insn (par);
1155       DONE;
1156     }
1157 }")
1158
1159 (define_expand "subv2sf3"
1160   [(set (match_operand:V2SF 0 "gpc_reg_operand" "")
1161         (minus:V2SF (match_operand:V2SF 1 "gpc_reg_operand" "")
1162                     (match_operand:V2SF 2 "gpc_reg_operand" "")))]
1163   "TARGET_PAIRED_FLOAT || TARGET_SPE"
1164   "
1165 {
1166   if (TARGET_SPE)
1167     {
1168       /* We need to make a note that we clobber SPEFSCR.  */
1169       rtx par = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
1170
1171       XVECEXP (par, 0, 0) = gen_rtx_SET (VOIDmode, operands[0],
1172                                          gen_rtx_MINUS (V2SFmode, operands[1], operands[2]));
1173       XVECEXP (par, 0, 1) = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (SImode, SPEFSCR_REGNO));
1174       emit_insn (par);
1175       DONE;
1176     }
1177 }")
1178
1179 (define_expand "mulv2sf3"
1180   [(set (match_operand:V2SF 0 "gpc_reg_operand" "")
1181         (mult:V2SF (match_operand:V2SF 1 "gpc_reg_operand" "")
1182                    (match_operand:V2SF 2 "gpc_reg_operand" "")))]
1183   "TARGET_PAIRED_FLOAT || TARGET_SPE"
1184   "
1185 {
1186   if (TARGET_SPE)
1187     {
1188       /* We need to make a note that we clobber SPEFSCR.  */
1189       rtx par = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
1190
1191       XVECEXP (par, 0, 0) = gen_rtx_SET (VOIDmode, operands[0],
1192                                          gen_rtx_MULT (V2SFmode, operands[1], operands[2]));
1193       XVECEXP (par, 0, 1) = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (SImode, SPEFSCR_REGNO));
1194       emit_insn (par);
1195       DONE;
1196     }
1197 }")
1198
1199 (define_expand "divv2sf3"
1200   [(set (match_operand:V2SF 0 "gpc_reg_operand" "")
1201         (div:V2SF (match_operand:V2SF 1 "gpc_reg_operand" "")
1202                   (match_operand:V2SF 2 "gpc_reg_operand" "")))]
1203   "TARGET_PAIRED_FLOAT || TARGET_SPE"
1204   "
1205 {
1206   if (TARGET_SPE)
1207     {
1208       /* We need to make a note that we clobber SPEFSCR.  */
1209       rtx par = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
1210
1211       XVECEXP (par, 0, 0) = gen_rtx_SET (VOIDmode, operands[0],
1212                                          gen_rtx_DIV (V2SFmode, operands[1], operands[2]));
1213       XVECEXP (par, 0, 1) = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (SImode, SPEFSCR_REGNO));
1214       emit_insn (par);
1215       DONE;
1216     }
1217 }")