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