lib/Target/PowerPC/PPCInstrVSX.td

   1 //===- PPCInstrVSX.td - The PowerPC VSX Extension --*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file describes the VSX extension to the PowerPC instruction set.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 def PPCRegVSRCAsmOperand : AsmOperandClass {
  15   let Name = "RegVSRC"; let PredicateMethod = "isVSRegNumber";
  16 }
  17 def vsrc : RegisterOperand<VSRC> {
  18   let ParserMatchClass = PPCRegVSRCAsmOperand;
  19 }
  20
  21 multiclass XX3Form_Rcr<bits<6> opcode, bits<7> xo, dag OOL, dag IOL,
  22                     string asmbase, string asmstr, InstrItinClass itin,
  23                     list<dag> pattern> {
  24   let BaseName = asmbase in {
  25     def NAME : XX3Form_Rc<opcode, xo, OOL, IOL,
  26                        !strconcat(asmbase, !strconcat(" ", asmstr)), itin,
  27                        pattern>;
  28     let Defs = [CR6] in
  29     def o    : XX3Form_Rc<opcode, xo, OOL, IOL,
  30                        !strconcat(asmbase, !strconcat(". ", asmstr)), itin,
  31                        []>, isDOT;
  32   }
  33 }
  34
  35 def HasVSX : Predicate<"PPCSubTarget.hasVSX()">;
  36 let Predicates = [HasVSX] in {
  37 let AddedComplexity = 400 in { // Prefer VSX patterns over non-VSX patterns.
  38 let neverHasSideEffects = 1 in { // VSX instructions don't have side effects.
  39 let Uses = [RM] in {
  40
  41   // Load indexed instructions
  42   let mayLoad = 1, canFoldAsLoad = 1 in {
  43     def LXSDX : XForm_1<31, 588,
  44                         (outs vsrc:$XT), (ins memrr:$src),
  45                         "lxsdx $XT, $src", IIC_LdStLFD,
  46                         [(set f64:$XT, (load xoaddr:$src))]>;
  47
  48     def LXVD2X : XForm_1<31, 844,
  49                          (outs vsrc:$XT), (ins memrr:$src),
  50                          "lxvd2x $XT, $src", IIC_LdStLFD,
  51                          [(set v2f64:$XT, (load xoaddr:$src))]>;
  52
  53     def LXVDSX : XForm_1<31, 332,
  54                          (outs vsrc:$XT), (ins memrr:$src),
  55                          "lxvdsx $XT, $src", IIC_LdStLFD, []>;
  56     // TODO: match load + splat to lxvdsx.
  57
  58     def LXVW4X : XForm_1<31, 780,
  59                          (outs vsrc:$XT), (ins memrr:$src),
  60                          "lxvw4x $XT, $src", IIC_LdStLFD,
  61                          [(set v4f32:$XT, (load xoaddr:$src))]>;
  62   }
  63
  64   // Store indexed instructions
  65   let mayStore = 1 in {
  66     def STXSDX : XX1Form<31, 716,
  67                         (outs), (ins vsrc:$XT, memrr:$dst),
  68                         "stxsdx $XT, $dst", IIC_LdStSTFD,
  69                         [(store f64:$XT, xoaddr:$dst)]>;
  70
  71     def STXVD2X : XX1Form<31, 972,
  72                          (outs), (ins vsrc:$XT, memrr:$dst),
  73                          "stxvd2x $XT, $dst", IIC_LdStSTFD,
  74                          [(store v2f64:$XT, xoaddr:$dst)]>;
  75
  76     def STXVW4X : XX1Form<31, 908,
  77                          (outs), (ins vsrc:$XT, memrr:$dst),
  78                          "stxvw4x $XT, $dst", IIC_LdStSTFD,
  79                          [(store v4f32:$XT, xoaddr:$dst)]>;
  80   }
  81
  82   // Add/Mul Instructions
  83   let isCommutable = 1 in {
  84     def XSADDDP : XX3Form<60, 32,
  85                           (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
  86                           "xsadddp $XT, $XA, $XB", IIC_VecFP,
  87                           [(set f64:$XT, (fadd f64:$XA, f64:$XB))]>;
  88     def XSMULDP : XX3Form<60, 48,
  89                           (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
  90                           "xsmuldp $XT, $XA, $XB", IIC_VecFP,
  91                           [(set f64:$XT, (fmul f64:$XA, f64:$XB))]>;
  92
  93     def XVADDDP : XX3Form<60, 96,
  94                           (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
  95                           "xvadddp $XT, $XA, $XB", IIC_VecFP,
  96                           [(set v2f64:$XT, (fadd v2f64:$XA, v2f64:$XB))]>;
  97
  98     def XVADDSP : XX3Form<60, 64,
  99                           (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 100                           "xvaddsp $XT, $XA, $XB", IIC_VecFP,
 101                           [(set v4f32:$XT, (fadd v4f32:$XA, v4f32:$XB))]>;
 102
 103     def XVMULDP : XX3Form<60, 112,
 104                           (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 105                           "xvmuldp $XT, $XA, $XB", IIC_VecFP,
 106                           [(set v2f64:$XT, (fmul v2f64:$XA, v2f64:$XB))]>;
 107
 108     def XVMULSP : XX3Form<60, 80,
 109                           (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 110                           "xvmulsp $XT, $XA, $XB", IIC_VecFP,
 111                           [(set v4f32:$XT, (fmul v4f32:$XA, v4f32:$XB))]>;
 112   }
 113
 114   // Subtract Instructions
 115   def XSSUBDP : XX3Form<60, 40,
 116                         (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 117                         "xssubdp $XT, $XA, $XB", IIC_VecFP,
 118                         [(set f64:$XT, (fsub f64:$XA, f64:$XB))]>;
 119
 120   def XVSUBDP : XX3Form<60, 104,
 121                         (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 122                         "xvsubdp $XT, $XA, $XB", IIC_VecFP,
 123                         [(set v2f64:$XT, (fsub v2f64:$XA, v2f64:$XB))]>;
 124   def XVSUBSP : XX3Form<60, 72,
 125                         (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 126                         "xvsubsp $XT, $XA, $XB", IIC_VecFP,
 127                         [(set v4f32:$XT, (fsub v4f32:$XA, v4f32:$XB))]>;
 128
 129   // FMA Instructions
 130   let BaseName = "XSMADDADP" in {
 131   let isCommutable = 1 in
 132   def XSMADDADP : XX3Form<60, 33,
 133                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 134                           "xsmaddadp $XT, $XA, $XB", IIC_VecFP,
 135                           [(set f64:$XT, (fma f64:$XA, f64:$XB, f64:$XTi))]>,
 136                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 137                           AltVSXFMARel;
 138   let IsVSXFMAAlt = 1 in
 139   def XSMADDMDP : XX3Form<60, 41,
 140                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 141                           "xsmaddmdp $XT, $XA, $XB", IIC_VecFP, []>,
 142                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 143                           AltVSXFMARel;
 144   }
 145
 146   let BaseName = "XSMSUBADP" in {
 147   let isCommutable = 1 in
 148   def XSMSUBADP : XX3Form<60, 49,
 149                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 150                           "xsmsubadp $XT, $XA, $XB", IIC_VecFP,
 151                           [(set f64:$XT, (fma f64:$XA, f64:$XB, (fneg f64:$XTi)))]>,
 152                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 153                           AltVSXFMARel;
 154   let IsVSXFMAAlt = 1 in
 155   def XSMSUBMDP : XX3Form<60, 57,
 156                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 157                           "xsmsubmdp $XT, $XA, $XB", IIC_VecFP, []>,
 158                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 159                           AltVSXFMARel;
 160   }
 161
 162   let BaseName = "XSNMADDADP" in {
 163   let isCommutable = 1 in
 164   def XSNMADDADP : XX3Form<60, 161,
 165                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 166                           "xsnmaddadp $XT, $XA, $XB", IIC_VecFP,
 167                           [(set f64:$XT, (fneg (fma f64:$XA, f64:$XB, f64:$XTi)))]>,
 168                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 169                           AltVSXFMARel;
 170   let IsVSXFMAAlt = 1 in
 171   def XSNMADDMDP : XX3Form<60, 169,
 172                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 173                           "xsnmaddmdp $XT, $XA, $XB", IIC_VecFP, []>,
 174                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 175                           AltVSXFMARel;
 176   }
 177
 178   let BaseName = "XSNMSUBADP" in {
 179   let isCommutable = 1 in
 180   def XSNMSUBADP : XX3Form<60, 177,
 181                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 182                           "xsnmsubadp $XT, $XA, $XB", IIC_VecFP,
 183                           [(set f64:$XT, (fneg (fma f64:$XA, f64:$XB, (fneg f64:$XTi))))]>,
 184                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 185                           AltVSXFMARel;
 186   let IsVSXFMAAlt = 1 in
 187   def XSNMSUBMDP : XX3Form<60, 185,
 188                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 189                           "xsnmsubmdp $XT, $XA, $XB", IIC_VecFP, []>,
 190                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 191                           AltVSXFMARel;
 192   }
 193
 194   let BaseName = "XVMADDADP" in {
 195   let isCommutable = 1 in
 196   def XVMADDADP : XX3Form<60, 97,
 197                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 198                           "xvmaddadp $XT, $XA, $XB", IIC_VecFP,
 199                           [(set v2f64:$XT, (fma v2f64:$XA, v2f64:$XB, v2f64:$XTi))]>,
 200                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 201                           AltVSXFMARel;
 202   let IsVSXFMAAlt = 1 in
 203   def XVMADDMDP : XX3Form<60, 105,
 204                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 205                           "xvmaddmdp $XT, $XA, $XB", IIC_VecFP, []>,
 206                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 207                           AltVSXFMARel;
 208   }
 209
 210   let BaseName = "XVMADDASP" in {
 211   let isCommutable = 1 in
 212   def XVMADDASP : XX3Form<60, 65,
 213                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 214                           "xvmaddasp $XT, $XA, $XB", IIC_VecFP,
 215                           [(set v4f32:$XT, (fma v4f32:$XA, v4f32:$XB, v4f32:$XTi))]>,
 216                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 217                           AltVSXFMARel;
 218   let IsVSXFMAAlt = 1 in
 219   def XVMADDMSP : XX3Form<60, 73,
 220                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 221                           "xvmaddmsp $XT, $XA, $XB", IIC_VecFP, []>,
 222                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 223                           AltVSXFMARel;
 224   }
 225
 226   let BaseName = "XVMSUBADP" in {
 227   let isCommutable = 1 in
 228   def XVMSUBADP : XX3Form<60, 113,
 229                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 230                           "xvmsubadp $XT, $XA, $XB", IIC_VecFP,
 231                           [(set v2f64:$XT, (fma v2f64:$XA, v2f64:$XB, (fneg v2f64:$XTi)))]>,
 232                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 233                           AltVSXFMARel;
 234   let IsVSXFMAAlt = 1 in
 235   def XVMSUBMDP : XX3Form<60, 121,
 236                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 237                           "xvmsubmdp $XT, $XA, $XB", IIC_VecFP, []>,
 238                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 239                           AltVSXFMARel;
 240   }
 241
 242   let BaseName = "XVMSUBASP" in {
 243   let isCommutable = 1 in
 244   def XVMSUBASP : XX3Form<60, 81,
 245                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 246                           "xvmsubasp $XT, $XA, $XB", IIC_VecFP,
 247                           [(set v4f32:$XT, (fma v4f32:$XA, v4f32:$XB, (fneg v4f32:$XTi)))]>,
 248                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 249                           AltVSXFMARel;
 250   let IsVSXFMAAlt = 1 in
 251   def XVMSUBMSP : XX3Form<60, 89,
 252                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 253                           "xvmsubmsp $XT, $XA, $XB", IIC_VecFP, []>,
 254                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 255                           AltVSXFMARel;
 256   }
 257
 258   let BaseName = "XVNMADDADP" in {
 259   let isCommutable = 1 in
 260   def XVNMADDADP : XX3Form<60, 225,
 261                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 262                           "xvnmaddadp $XT, $XA, $XB", IIC_VecFP,
 263                           [(set v2f64:$XT, (fneg (fma v2f64:$XA, v2f64:$XB, v2f64:$XTi)))]>,
 264                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 265                           AltVSXFMARel;
 266   let IsVSXFMAAlt = 1 in
 267   def XVNMADDMDP : XX3Form<60, 233,
 268                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 269                           "xvnmaddmdp $XT, $XA, $XB", IIC_VecFP, []>,
 270                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 271                           AltVSXFMARel;
 272   }
 273
 274   let BaseName = "XVNMADDASP" in {
 275   let isCommutable = 1 in
 276   def XVNMADDASP : XX3Form<60, 193,
 277                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 278                           "xvnmaddasp $XT, $XA, $XB", IIC_VecFP,
 279                           [(set v4f32:$XT, (fneg (fma v4f32:$XA, v4f32:$XB, v4f32:$XTi)))]>,
 280                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 281                           AltVSXFMARel;
 282   let IsVSXFMAAlt = 1 in
 283   def XVNMADDMSP : XX3Form<60, 201,
 284                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 285                           "xvnmaddmsp $XT, $XA, $XB", IIC_VecFP, []>,
 286                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 287                           AltVSXFMARel;
 288   }
 289
 290   let BaseName = "XVNMSUBADP" in {
 291   let isCommutable = 1 in
 292   def XVNMSUBADP : XX3Form<60, 241,
 293                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 294                           "xvnmsubadp $XT, $XA, $XB", IIC_VecFP,
 295                           [(set v2f64:$XT, (fneg (fma v2f64:$XA, v2f64:$XB, (fneg v2f64:$XTi))))]>,
 296                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 297                           AltVSXFMARel;
 298   let IsVSXFMAAlt = 1 in
 299   def XVNMSUBMDP : XX3Form<60, 249,
 300                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 301                           "xvnmsubmdp $XT, $XA, $XB", IIC_VecFP, []>,
 302                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 303                           AltVSXFMARel;
 304   }
 305
 306   let BaseName = "XVNMSUBASP" in {
 307   let isCommutable = 1 in
 308   def XVNMSUBASP : XX3Form<60, 209,
 309                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 310                           "xvnmsubasp $XT, $XA, $XB", IIC_VecFP,
 311                           [(set v4f32:$XT, (fneg (fma v4f32:$XA, v4f32:$XB, (fneg v4f32:$XTi))))]>,
 312                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 313                           AltVSXFMARel;
 314   let IsVSXFMAAlt = 1 in
 315   def XVNMSUBMSP : XX3Form<60, 217,
 316                           (outs vsrc:$XT), (ins vsrc:$XTi, vsrc:$XA, vsrc:$XB),
 317                           "xvnmsubmsp $XT, $XA, $XB", IIC_VecFP, []>,
 318                           RegConstraint<"$XTi = $XT">, NoEncode<"$XTi">,
 319                           AltVSXFMARel;
 320   }
 321
 322   // Division Instructions
 323   def XSDIVDP : XX3Form<60, 56,
 324                         (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 325                         "xsdivdp $XT, $XA, $XB", IIC_VecFP,
 326                         [(set f64:$XT, (fdiv f64:$XA, f64:$XB))]>;
 327   def XSSQRTDP : XX2Form<60, 75,
 328                         (outs vsrc:$XT), (ins vsrc:$XB),
 329                         "xssqrtdp $XT, $XB", IIC_VecFP,
 330                         [(set f64:$XT, (fsqrt f64:$XB))]>;
 331
 332   def XSREDP : XX2Form<60, 90,
 333                         (outs vsrc:$XT), (ins vsrc:$XB),
 334                         "xsredp $XT, $XB", IIC_VecFP,
 335                         [(set f64:$XT, (PPCfre f64:$XB))]>;
 336   def XSRSQRTEDP : XX2Form<60, 74,
 337                            (outs vsrc:$XT), (ins vsrc:$XB),
 338                            "xsrsqrtedp $XT, $XB", IIC_VecFP,
 339                            [(set f64:$XT, (PPCfrsqrte f64:$XB))]>;
 340
 341   def XSTDIVDP : XX3Form_1<60, 61,
 342                          (outs crrc:$crD), (ins vsrc:$XA, vsrc:$XB),
 343                          "xstdivdp $crD, $XA, $XB", IIC_VecFP, []>;
 344   def XSTSQRTDP : XX2Form_1<60, 106,
 345                           (outs crrc:$crD), (ins vsrc:$XB),
 346                           "xstsqrtdp $crD, $XB", IIC_VecFP, []>;
 347
 348   def XVDIVDP : XX3Form<60, 120,
 349                         (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 350                         "xvdivdp $XT, $XA, $XB", IIC_VecFP,
 351                         [(set v2f64:$XT, (fdiv v2f64:$XA, v2f64:$XB))]>;
 352   def XVDIVSP : XX3Form<60, 88,
 353                         (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 354                         "xvdivsp $XT, $XA, $XB", IIC_VecFP,
 355                         [(set v4f32:$XT, (fdiv v4f32:$XA, v4f32:$XB))]>;
 356
 357   def XVSQRTDP : XX2Form<60, 203,
 358                         (outs vsrc:$XT), (ins vsrc:$XB),
 359                         "xvsqrtdp $XT, $XB", IIC_VecFP,
 360                         [(set v2f64:$XT, (fsqrt v2f64:$XB))]>;
 361   def XVSQRTSP : XX2Form<60, 139,
 362                         (outs vsrc:$XT), (ins vsrc:$XB),
 363                         "xvsqrtsp $XT, $XB", IIC_VecFP,
 364                         [(set v4f32:$XT, (fsqrt v4f32:$XB))]>;
 365
 366   def XVTDIVDP : XX3Form_1<60, 125,
 367                          (outs crrc:$crD), (ins vsrc:$XA, vsrc:$XB),
 368                          "xvtdivdp $crD, $XA, $XB", IIC_VecFP, []>;
 369   def XVTDIVSP : XX3Form_1<60, 93,
 370                          (outs crrc:$crD), (ins vsrc:$XA, vsrc:$XB),
 371                          "xvtdivsp $crD, $XA, $XB", IIC_VecFP, []>;
 372
 373   def XVTSQRTDP : XX2Form_1<60, 234,
 374                           (outs crrc:$crD), (ins vsrc:$XB),
 375                           "xvtsqrtdp $crD, $XB", IIC_VecFP, []>;
 376   def XVTSQRTSP : XX2Form_1<60, 170,
 377                           (outs crrc:$crD), (ins vsrc:$XB),
 378                           "xvtsqrtsp $crD, $XB", IIC_VecFP, []>;
 379
 380   def XVREDP : XX2Form<60, 218,
 381                         (outs vsrc:$XT), (ins vsrc:$XB),
 382                         "xvredp $XT, $XB", IIC_VecFP,
 383                         [(set v2f64:$XT, (PPCfre v2f64:$XB))]>;
 384   def XVRESP : XX2Form<60, 154,
 385                         (outs vsrc:$XT), (ins vsrc:$XB),
 386                         "xvresp $XT, $XB", IIC_VecFP,
 387                         [(set v4f32:$XT, (PPCfre v4f32:$XB))]>;
 388
 389   def XVRSQRTEDP : XX2Form<60, 202,
 390                            (outs vsrc:$XT), (ins vsrc:$XB),
 391                            "xvrsqrtedp $XT, $XB", IIC_VecFP,
 392                            [(set v2f64:$XT, (PPCfrsqrte v2f64:$XB))]>;
 393   def XVRSQRTESP : XX2Form<60, 138,
 394                            (outs vsrc:$XT), (ins vsrc:$XB),
 395                            "xvrsqrtesp $XT, $XB", IIC_VecFP,
 396                            [(set v4f32:$XT, (PPCfrsqrte v4f32:$XB))]>;
 397
 398   // Compare Instructions
 399   def XSCMPODP : XX3Form_1<60, 43,
 400                            (outs crrc:$crD), (ins vsrc:$XA, vsrc:$XB),
 401                            "xscmpodp $crD, $XA, $XB", IIC_VecFPCompare, []>;
 402   def XSCMPUDP : XX3Form_1<60, 35,
 403                            (outs crrc:$crD), (ins vsrc:$XA, vsrc:$XB),
 404                            "xscmpudp $crD, $XA, $XB", IIC_VecFPCompare, []>;
 405
 406   defm XVCMPEQDP : XX3Form_Rcr<60, 99,
 407                              (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 408                              "xvcmpeqdp", "$XT, $XA, $XB", IIC_VecFPCompare, []>;
 409   defm XVCMPEQSP : XX3Form_Rcr<60, 67,
 410                              (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 411                              "xvcmpeqsp", "$XT, $XA, $XB", IIC_VecFPCompare, []>;
 412   defm XVCMPGEDP : XX3Form_Rcr<60, 115,
 413                              (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 414                              "xvcmpgedp", "$XT, $XA, $XB", IIC_VecFPCompare, []>;
 415   defm XVCMPGESP : XX3Form_Rcr<60, 83,
 416                              (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 417                              "xvcmpgesp", "$XT, $XA, $XB", IIC_VecFPCompare, []>;
 418   defm XVCMPGTDP : XX3Form_Rcr<60, 107,
 419                              (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 420                              "xvcmpgtdp", "$XT, $XA, $XB", IIC_VecFPCompare, []>;
 421   defm XVCMPGTSP : XX3Form_Rcr<60, 75,
 422                              (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 423                              "xvcmpgtsp", "$XT, $XA, $XB", IIC_VecFPCompare, []>;
 424
 425   // Move Instructions
 426   def XSABSDP : XX2Form<60, 345,
 427                       (outs vsrc:$XT), (ins vsrc:$XB),
 428                       "xsabsdp $XT, $XB", IIC_VecFP,
 429                       [(set f64:$XT, (fabs f64:$XB))]>;
 430   def XSNABSDP : XX2Form<60, 361,
 431                       (outs vsrc:$XT), (ins vsrc:$XB),
 432                       "xsnabsdp $XT, $XB", IIC_VecFP,
 433                       [(set f64:$XT, (fneg (fabs f64:$XB)))]>;
 434   def XSNEGDP : XX2Form<60, 377,
 435                       (outs vsrc:$XT), (ins vsrc:$XB),
 436                       "xsnegdp $XT, $XB", IIC_VecFP,
 437                       [(set f64:$XT, (fneg f64:$XB))]>;
 438   def XSCPSGNDP : XX3Form<60, 176,
 439                       (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 440                       "xscpsgndp $XT, $XA, $XB", IIC_VecFP,
 441                       [(set f64:$XT, (fcopysign f64:$XB, f64:$XA))]>;
 442
 443   def XVABSDP : XX2Form<60, 473,
 444                       (outs vsrc:$XT), (ins vsrc:$XB),
 445                       "xvabsdp $XT, $XB", IIC_VecFP,
 446                       [(set v2f64:$XT, (fabs v2f64:$XB))]>;
 447
 448   def XVABSSP : XX2Form<60, 409,
 449                       (outs vsrc:$XT), (ins vsrc:$XB),
 450                       "xvabssp $XT, $XB", IIC_VecFP,
 451                       [(set v4f32:$XT, (fabs v4f32:$XB))]>;
 452
 453   def XVCPSGNDP : XX3Form<60, 240,
 454                       (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 455                       "xvcpsgndp $XT, $XA, $XB", IIC_VecFP,
 456                       [(set v2f64:$XT, (fcopysign v2f64:$XB, v2f64:$XA))]>;
 457   def XVCPSGNSP : XX3Form<60, 208,
 458                       (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 459                       "xvcpsgnsp $XT, $XA, $XB", IIC_VecFP,
 460                       [(set v4f32:$XT, (fcopysign v4f32:$XB, v4f32:$XA))]>;
 461
 462   def XVNABSDP : XX2Form<60, 489,
 463                       (outs vsrc:$XT), (ins vsrc:$XB),
 464                       "xvnabsdp $XT, $XB", IIC_VecFP,
 465                       [(set v2f64:$XT, (fneg (fabs v2f64:$XB)))]>;
 466   def XVNABSSP : XX2Form<60, 425,
 467                       (outs vsrc:$XT), (ins vsrc:$XB),
 468                       "xvnabssp $XT, $XB", IIC_VecFP,
 469                       [(set v4f32:$XT, (fneg (fabs v4f32:$XB)))]>;
 470
 471   def XVNEGDP : XX2Form<60, 505,
 472                       (outs vsrc:$XT), (ins vsrc:$XB),
 473                       "xvnegdp $XT, $XB", IIC_VecFP,
 474                       [(set v2f64:$XT, (fneg v2f64:$XB))]>;
 475   def XVNEGSP : XX2Form<60, 441,
 476                       (outs vsrc:$XT), (ins vsrc:$XB),
 477                       "xvnegsp $XT, $XB", IIC_VecFP,
 478                       [(set v4f32:$XT, (fneg v4f32:$XB))]>;
 479
 480   // Conversion Instructions
 481   def XSCVDPSP : XX2Form<60, 265,
 482                       (outs vsrc:$XT), (ins vsrc:$XB),
 483                       "xscvdpsp $XT, $XB", IIC_VecFP, []>;
 484   def XSCVDPSXDS : XX2Form<60, 344,
 485                       (outs vsrc:$XT), (ins vsrc:$XB),
 486                       "xscvdpsxds $XT, $XB", IIC_VecFP,
 487                       [(set f64:$XT, (PPCfctidz f64:$XB))]>;
 488   def XSCVDPSXWS : XX2Form<60, 88,
 489                       (outs vsrc:$XT), (ins vsrc:$XB),
 490                       "xscvdpsxws $XT, $XB", IIC_VecFP,
 491                       [(set f64:$XT, (PPCfctiwz f64:$XB))]>;
 492   def XSCVDPUXDS : XX2Form<60, 328,
 493                       (outs vsrc:$XT), (ins vsrc:$XB),
 494                       "xscvdpuxds $XT, $XB", IIC_VecFP,
 495                       [(set f64:$XT, (PPCfctiduz f64:$XB))]>;
 496   def XSCVDPUXWS : XX2Form<60, 72,
 497                       (outs vsrc:$XT), (ins vsrc:$XB),
 498                       "xscvdpuxws $XT, $XB", IIC_VecFP,
 499                       [(set f64:$XT, (PPCfctiwuz f64:$XB))]>;
 500   def XSCVSPDP : XX2Form<60, 329,
 501                       (outs vsrc:$XT), (ins vsrc:$XB),
 502                       "xscvspdp $XT, $XB", IIC_VecFP, []>;
 503   def XSCVSXDDP : XX2Form<60, 376,
 504                       (outs vsrc:$XT), (ins vsrc:$XB),
 505                       "xscvsxddp $XT, $XB", IIC_VecFP,
 506                       [(set f64:$XT, (PPCfcfid f64:$XB))]>;
 507   def XSCVUXDDP : XX2Form<60, 360,
 508                       (outs vsrc:$XT), (ins vsrc:$XB),
 509                       "xscvuxddp $XT, $XB", IIC_VecFP,
 510                       [(set f64:$XT, (PPCfcfidu f64:$XB))]>;
 511
 512   def XVCVDPSP : XX2Form<60, 393,
 513                       (outs vsrc:$XT), (ins vsrc:$XB),
 514                       "xvcvdpsp $XT, $XB", IIC_VecFP, []>;
 515   def XVCVDPSXDS : XX2Form<60, 472,
 516                       (outs vsrc:$XT), (ins vsrc:$XB),
 517                       "xvcvdpsxds $XT, $XB", IIC_VecFP, []>;
 518   def XVCVDPSXWS : XX2Form<60, 216,
 519                       (outs vsrc:$XT), (ins vsrc:$XB),
 520                       "xvcvdpsxws $XT, $XB", IIC_VecFP, []>;
 521   def XVCVDPUXDS : XX2Form<60, 456,
 522                       (outs vsrc:$XT), (ins vsrc:$XB),
 523                       "xvcvdpuxds $XT, $XB", IIC_VecFP, []>;
 524   def XVCVDPUXWS : XX2Form<60, 200,
 525                       (outs vsrc:$XT), (ins vsrc:$XB),
 526                       "xvcvdpuxws $XT, $XB", IIC_VecFP, []>;
 527
 528   def XVCVSPDP : XX2Form<60, 457,
 529                       (outs vsrc:$XT), (ins vsrc:$XB),
 530                       "xvcvspdp $XT, $XB", IIC_VecFP, []>;
 531   def XVCVSPSXDS : XX2Form<60, 408,
 532                       (outs vsrc:$XT), (ins vsrc:$XB),
 533                       "xvcvspsxds $XT, $XB", IIC_VecFP, []>;
 534   def XVCVSPSXWS : XX2Form<60, 152,
 535                       (outs vsrc:$XT), (ins vsrc:$XB),
 536                       "xvcvspsxws $XT, $XB", IIC_VecFP, []>;
 537   def XVCVSPUXDS : XX2Form<60, 392,
 538                       (outs vsrc:$XT), (ins vsrc:$XB),
 539                       "xvcvspuxds $XT, $XB", IIC_VecFP, []>;
 540   def XVCVSPUXWS : XX2Form<60, 136,
 541                       (outs vsrc:$XT), (ins vsrc:$XB),
 542                       "xvcvspuxws $XT, $XB", IIC_VecFP, []>;
 543   def XVCVSXDDP : XX2Form<60, 504,
 544                       (outs vsrc:$XT), (ins vsrc:$XB),
 545                       "xvcvsxddp $XT, $XB", IIC_VecFP, []>;
 546   def XVCVSXDSP : XX2Form<60, 440,
 547                       (outs vsrc:$XT), (ins vsrc:$XB),
 548                       "xvcvsxdsp $XT, $XB", IIC_VecFP, []>;
 549   def XVCVSXWDP : XX2Form<60, 248,
 550                       (outs vsrc:$XT), (ins vsrc:$XB),
 551                       "xvcvsxwdp $XT, $XB", IIC_VecFP, []>;
 552   def XVCVSXWSP : XX2Form<60, 184,
 553                       (outs vsrc:$XT), (ins vsrc:$XB),
 554                       "xvcvsxwsp $XT, $XB", IIC_VecFP, []>;
 555   def XVCVUXDDP : XX2Form<60, 488,
 556                       (outs vsrc:$XT), (ins vsrc:$XB),
 557                       "xvcvuxddp $XT, $XB", IIC_VecFP, []>;
 558   def XVCVUXDSP : XX2Form<60, 424,
 559                       (outs vsrc:$XT), (ins vsrc:$XB),
 560                       "xvcvuxdsp $XT, $XB", IIC_VecFP, []>;
 561   def XVCVUXWDP : XX2Form<60, 232,
 562                       (outs vsrc:$XT), (ins vsrc:$XB),
 563                       "xvcvuxwdp $XT, $XB", IIC_VecFP, []>;
 564   def XVCVUXWSP : XX2Form<60, 168,
 565                       (outs vsrc:$XT), (ins vsrc:$XB),
 566                       "xvcvuxwsp $XT, $XB", IIC_VecFP, []>;
 567
 568   // Rounding Instructions
 569   def XSRDPI : XX2Form<60, 73,
 570                       (outs vsrc:$XT), (ins vsrc:$XB),
 571                       "xsrdpi $XT, $XB", IIC_VecFP,
 572                       [(set f64:$XT, (frnd f64:$XB))]>;
 573   def XSRDPIC : XX2Form<60, 107,
 574                       (outs vsrc:$XT), (ins vsrc:$XB),
 575                       "xsrdpic $XT, $XB", IIC_VecFP,
 576                       [(set f64:$XT, (fnearbyint f64:$XB))]>;
 577   def XSRDPIM : XX2Form<60, 121,
 578                       (outs vsrc:$XT), (ins vsrc:$XB),
 579                       "xsrdpim $XT, $XB", IIC_VecFP,
 580                       [(set f64:$XT, (ffloor f64:$XB))]>;
 581   def XSRDPIP : XX2Form<60, 105,
 582                       (outs vsrc:$XT), (ins vsrc:$XB),
 583                       "xsrdpip $XT, $XB", IIC_VecFP,
 584                       [(set f64:$XT, (fceil f64:$XB))]>;
 585   def XSRDPIZ : XX2Form<60, 89,
 586                       (outs vsrc:$XT), (ins vsrc:$XB),
 587                       "xsrdpiz $XT, $XB", IIC_VecFP,
 588                       [(set f64:$XT, (ftrunc f64:$XB))]>;
 589
 590   def XVRDPI : XX2Form<60, 201,
 591                       (outs vsrc:$XT), (ins vsrc:$XB),
 592                       "xvrdpi $XT, $XB", IIC_VecFP,
 593                       [(set v2f64:$XT, (frnd v2f64:$XB))]>;
 594   def XVRDPIC : XX2Form<60, 235,
 595                       (outs vsrc:$XT), (ins vsrc:$XB),
 596                       "xvrdpic $XT, $XB", IIC_VecFP,
 597                       [(set v2f64:$XT, (fnearbyint v2f64:$XB))]>;
 598   def XVRDPIM : XX2Form<60, 249,
 599                       (outs vsrc:$XT), (ins vsrc:$XB),
 600                       "xvrdpim $XT, $XB", IIC_VecFP,
 601                       [(set v2f64:$XT, (ffloor v2f64:$XB))]>;
 602   def XVRDPIP : XX2Form<60, 233,
 603                       (outs vsrc:$XT), (ins vsrc:$XB),
 604                       "xvrdpip $XT, $XB", IIC_VecFP,
 605                       [(set v2f64:$XT, (fceil v2f64:$XB))]>;
 606   def XVRDPIZ : XX2Form<60, 217,
 607                       (outs vsrc:$XT), (ins vsrc:$XB),
 608                       "xvrdpiz $XT, $XB", IIC_VecFP,
 609                       [(set v2f64:$XT, (ftrunc v2f64:$XB))]>;
 610
 611   def XVRSPI : XX2Form<60, 137,
 612                       (outs vsrc:$XT), (ins vsrc:$XB),
 613                       "xvrspi $XT, $XB", IIC_VecFP,
 614                       [(set v4f32:$XT, (frnd v4f32:$XB))]>;
 615   def XVRSPIC : XX2Form<60, 171,
 616                       (outs vsrc:$XT), (ins vsrc:$XB),
 617                       "xvrspic $XT, $XB", IIC_VecFP,
 618                       [(set v4f32:$XT, (fnearbyint v4f32:$XB))]>;
 619   def XVRSPIM : XX2Form<60, 185,
 620                       (outs vsrc:$XT), (ins vsrc:$XB),
 621                       "xvrspim $XT, $XB", IIC_VecFP,
 622                       [(set v4f32:$XT, (ffloor v4f32:$XB))]>;
 623   def XVRSPIP : XX2Form<60, 169,
 624                       (outs vsrc:$XT), (ins vsrc:$XB),
 625                       "xvrspip $XT, $XB", IIC_VecFP,
 626                       [(set v4f32:$XT, (fceil v4f32:$XB))]>;
 627   def XVRSPIZ : XX2Form<60, 153,
 628                       (outs vsrc:$XT), (ins vsrc:$XB),
 629                       "xvrspiz $XT, $XB", IIC_VecFP,
 630                       [(set v4f32:$XT, (ftrunc v4f32:$XB))]>;
 631
 632   // Max/Min Instructions
 633   let isCommutable = 1 in {
 634   def XSMAXDP : XX3Form<60, 160,
 635                         (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 636                         "xsmaxdp $XT, $XA, $XB", IIC_VecFP, []>;
 637   def XSMINDP : XX3Form<60, 168,
 638                         (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 639                         "xsmindp $XT, $XA, $XB", IIC_VecFP, []>;
 640
 641   def XVMAXDP : XX3Form<60, 224,
 642                         (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 643                         "xvmaxdp $XT, $XA, $XB", IIC_VecFP, []>;
 644   def XVMINDP : XX3Form<60, 232,
 645                         (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 646                         "xvmindp $XT, $XA, $XB", IIC_VecFP, []>;
 647
 648   def XVMAXSP : XX3Form<60, 192,
 649                         (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 650                         "xvmaxsp $XT, $XA, $XB", IIC_VecFP, []>;
 651   def XVMINSP : XX3Form<60, 200,
 652                         (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 653                         "xvminsp $XT, $XA, $XB", IIC_VecFP, []>;
 654   } // isCommutable
 655 } // Uses = [RM]
 656
 657   // Logical Instructions
 658   let isCommutable = 1 in
 659   def XXLAND : XX3Form<60, 130,
 660                        (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 661                        "xxland $XT, $XA, $XB", IIC_VecGeneral,
 662                        [(set v4i32:$XT, (and v4i32:$XA, v4i32:$XB))]>;
 663   def XXLANDC : XX3Form<60, 138,
 664                         (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 665                         "xxlandc $XT, $XA, $XB", IIC_VecGeneral,
 666                         [(set v4i32:$XT, (and v4i32:$XA,
 667                                               (vnot_ppc v4i32:$XB)))]>;
 668   let isCommutable = 1 in {
 669   def XXLNOR : XX3Form<60, 162,
 670                        (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 671                        "xxlnor $XT, $XA, $XB", IIC_VecGeneral,
 672                        [(set v4i32:$XT, (vnot_ppc (or v4i32:$XA,
 673                                                    v4i32:$XB)))]>;
 674   def XXLOR : XX3Form<60, 146,
 675                       (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 676                       "xxlor $XT, $XA, $XB", IIC_VecGeneral,
 677                       [(set v4i32:$XT, (or v4i32:$XA, v4i32:$XB))]>;
 678   def XXLXOR : XX3Form<60, 154,
 679                        (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 680                        "xxlxor $XT, $XA, $XB", IIC_VecGeneral,
 681                        [(set v4i32:$XT, (xor v4i32:$XA, v4i32:$XB))]>;
 682   } // isCommutable
 683
 684   // Permutation Instructions
 685   def XXMRGHW : XX3Form<60, 18,
 686                        (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 687                        "xxmrghw $XT, $XA, $XB", IIC_VecPerm, []>;
 688   def XXMRGLW : XX3Form<60, 50,
 689                        (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB),
 690                        "xxmrglw $XT, $XA, $XB", IIC_VecPerm, []>;
 691
 692   def XXPERMDI : XX3Form_2<60, 10,
 693                        (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB, u2imm:$DM),
 694                        "xxpermdi $XT, $XA, $XB, $DM", IIC_VecPerm, []>;
 695   def XXSEL : XX4Form<60, 3,
 696                       (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB, vsrc:$XC),
 697                       "xxsel $XT, $XA, $XB, $XC", IIC_VecPerm, []>;
 698
 699   def XXSLDWI : XX3Form_2<60, 2,
 700                        (outs vsrc:$XT), (ins vsrc:$XA, vsrc:$XB, u2imm:$SHW),
 701                        "xxsldwi $XT, $XA, $XB, $SHW", IIC_VecPerm, []>;
 702   def XXSPLTW : XX2Form_2<60, 164,
 703                        (outs vsrc:$XT), (ins vsrc:$XB, u2imm:$UIM),
 704                        "xxspltw $XT, $XB, $UIM", IIC_VecPerm, []>;
 705 } // neverHasSideEffects
 706 } // AddedComplexity
 707
 708 def : InstAlias<"xvmovdp $XT, $XB",
 709                 (XVCPSGNDP vsrc:$XT, vsrc:$XB, vsrc:$XB)>;
 710 def : InstAlias<"xvmovsp $XT, $XB",
 711                 (XVCPSGNSP vsrc:$XT, vsrc:$XB, vsrc:$XB)>;
 712
 713 def : InstAlias<"xxspltd $XT, $XB, 0",
 714                 (XXPERMDI vsrc:$XT, vsrc:$XB, vsrc:$XB, 0)>;
 715 def : InstAlias<"xxspltd $XT, $XB, 1",
 716                 (XXPERMDI vsrc:$XT, vsrc:$XB, vsrc:$XB, 3)>;
 717 def : InstAlias<"xxmrghd $XT, $XA, $XB",
 718                 (XXPERMDI vsrc:$XT, vsrc:$XA, vsrc:$XB, 0)>;
 719 def : InstAlias<"xxmrgld $XT, $XA, $XB",
 720                 (XXPERMDI vsrc:$XT, vsrc:$XA, vsrc:$XB, 3)>;
 721 def : InstAlias<"xxswapd $XT, $XB",
 722                 (XXPERMDI vsrc:$XT, vsrc:$XB, vsrc:$XB, 2)>;
 723
 724 let AddedComplexity = 400 in { // Prefer VSX patterns over non-VSX patterns.
 725 def : Pat<(v2f64 (scalar_to_vector f64:$A)),
 726           (INSERT_SUBREG (v2f64 (IMPLICIT_DEF)), $A, sub_64)>;
 727
 728 def : Pat<(f64 (vector_extract v2f64:$S, 0)),
 729           (EXTRACT_SUBREG (v2f64 (COPY_TO_REGCLASS $S, VSLRC)), sub_64)>;
 730 def : Pat<(f64 (vector_extract v2f64:$S, 1)),
 731           (EXTRACT_SUBREG (v2f64 (COPY_TO_REGCLASS (XXPERMDI $S, $S, 3),
 732                                                    VSLRC)), sub_64)>;
 733
 734 // Additional fnmsub patterns: -a*c + b == -(a*c - b)
 735 def : Pat<(fma (fneg f64:$A), f64:$C, f64:$B),
 736           (XSNMSUBADP $B, $C, $A)>;
 737 def : Pat<(fma f64:$A, (fneg f64:$C), f64:$B),
 738           (XSNMSUBADP $B, $C, $A)>;
 739
 740 def : Pat<(fma (fneg v2f64:$A), v2f64:$C, v2f64:$B),
 741           (XVNMSUBADP $B, $C, $A)>;
 742 def : Pat<(fma v2f64:$A, (fneg v2f64:$C), v2f64:$B),
 743           (XVNMSUBADP $B, $C, $A)>;
 744
 745 def : Pat<(fma (fneg v4f32:$A), v4f32:$C, v4f32:$B),
 746           (XVNMSUBASP $B, $C, $A)>;
 747 def : Pat<(fma v4f32:$A, (fneg v4f32:$C), v4f32:$B),
 748           (XVNMSUBASP $B, $C, $A)>;
 749
 750 def : Pat<(v2f64 (bitconvert v4i32:$A)),
 751           (COPY_TO_REGCLASS $A, VSRC)>;
 752 def : Pat<(v2f64 (bitconvert v8i16:$A)),
 753           (COPY_TO_REGCLASS $A, VSRC)>;
 754 def : Pat<(v2f64 (bitconvert v16i8:$A)),
 755           (COPY_TO_REGCLASS $A, VSRC)>;
 756
 757 def : Pat<(v4i32 (bitconvert v2f64:$A)),
 758           (COPY_TO_REGCLASS $A, VRRC)>;
 759 def : Pat<(v8i16 (bitconvert v2f64:$A)),
 760           (COPY_TO_REGCLASS $A, VRRC)>;
 761 def : Pat<(v16i8 (bitconvert v2f64:$A)),
 762           (COPY_TO_REGCLASS $A, VRRC)>;
 763
 764 def : Pat<(v2i64 (bitconvert v4i32:$A)),
 765           (COPY_TO_REGCLASS $A, VSRC)>;
 766 def : Pat<(v2i64 (bitconvert v8i16:$A)),
 767           (COPY_TO_REGCLASS $A, VSRC)>;
 768 def : Pat<(v2i64 (bitconvert v16i8:$A)),
 769           (COPY_TO_REGCLASS $A, VSRC)>;
 770
 771 def : Pat<(v4i32 (bitconvert v2i64:$A)),
 772           (COPY_TO_REGCLASS $A, VRRC)>;
 773 def : Pat<(v8i16 (bitconvert v2i64:$A)),
 774           (COPY_TO_REGCLASS $A, VRRC)>;
 775 def : Pat<(v16i8 (bitconvert v2i64:$A)),
 776           (COPY_TO_REGCLASS $A, VRRC)>;
 777
 778 } // AddedComplexity
 779 } // HasVSX
 780