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