lib/Target/ARM/ARMInstrVFP.td

   1 //===-- ARMInstrVFP.td - VFP support for ARM ---------------*- tablegen -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file describes the ARM VFP instruction set.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 def SDT_CMPFP0  : SDTypeProfile<0, 2, [SDTCisFP<0>, SDTCisVT<1, i32>]>;
  14 def SDT_VMOVDRR : SDTypeProfile<1, 2, [SDTCisVT<0, f64>, SDTCisVT<1, i32>,
  15                                        SDTCisSameAs<1, 2>]>;
  16 def SDT_VMOVRRD : SDTypeProfile<2, 1, [SDTCisVT<0, i32>, SDTCisSameAs<0, 1>,
  17                                        SDTCisVT<2, f64>]>;
  18
  19 def SDT_VMOVSR : SDTypeProfile<1, 1, [SDTCisVT<0, f32>, SDTCisVT<1, i32>]>;
  20
  21 def arm_fmstat : SDNode<"ARMISD::FMSTAT",  SDTNone, [SDNPInGlue, SDNPOutGlue]>;
  22 def arm_cmpfp  : SDNode<"ARMISD::CMPFP",   SDT_ARMFCmp, [SDNPOutGlue]>;
  23 def arm_cmpfp0 : SDNode<"ARMISD::CMPFPw0", SDT_CMPFP0, [SDNPOutGlue]>;
  24 def arm_fmdrr  : SDNode<"ARMISD::VMOVDRR", SDT_VMOVDRR>;
  25 def arm_fmrrd  : SDNode<"ARMISD::VMOVRRD", SDT_VMOVRRD>;
  26 def arm_vmovsr  : SDNode<"ARMISD::VMOVSR", SDT_VMOVSR>;
  27
  28 def SDT_VMOVhr : SDTypeProfile<1, 1, [SDTCisFP<0>, SDTCisVT<1, i32>] >;
  29 def SDT_VMOVrh : SDTypeProfile<1, 1, [SDTCisVT<0, i32>, SDTCisFP<1>] >;
  30 def arm_vmovhr : SDNode<"ARMISD::VMOVhr", SDT_VMOVhr>;
  31 def arm_vmovrh : SDNode<"ARMISD::VMOVrh", SDT_VMOVrh>;
  32
  33 //===----------------------------------------------------------------------===//
  34 // Operand Definitions.
  35 //
  36
  37 // 8-bit floating-point immediate encodings.
  38 def FPImmOperand : AsmOperandClass {
  39   let Name = "FPImm";
  40   let ParserMethod = "parseFPImm";
  41 }
  42
  43 def vfp_f16imm : Operand<f16>,
  44                  PatLeaf<(f16 fpimm), [{
  45       return ARM_AM::getFP16Imm(N->getValueAPF()) != -1;
  46     }], SDNodeXForm<fpimm, [{
  47       APFloat InVal = N->getValueAPF();
  48       uint32_t enc = ARM_AM::getFP16Imm(InVal);
  49       return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
  50     }]>> {
  51   let PrintMethod = "printFPImmOperand";
  52   let ParserMatchClass = FPImmOperand;
  53 }
  54
  55 def vfp_f32imm_xform : SDNodeXForm<fpimm, [{
  56       APFloat InVal = N->getValueAPF();
  57       uint32_t enc = ARM_AM::getFP32Imm(InVal);
  58       return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
  59     }]>;
  60
  61 def gi_vfp_f32imm : GICustomOperandRenderer<"renderVFPF32Imm">,
  62                     GISDNodeXFormEquiv<vfp_f32imm_xform>;
  63
  64 def vfp_f32imm : Operand<f32>,
  65                  PatLeaf<(f32 fpimm), [{
  66       return ARM_AM::getFP32Imm(N->getValueAPF()) != -1;
  67     }], vfp_f32imm_xform> {
  68   let PrintMethod = "printFPImmOperand";
  69   let ParserMatchClass = FPImmOperand;
  70   let GISelPredicateCode = [{
  71       const auto &MO = MI.getOperand(1);
  72       if (!MO.isFPImm())
  73         return false;
  74       return ARM_AM::getFP32Imm(MO.getFPImm()->getValueAPF()) != -1;
  75     }];
  76 }
  77
  78 def vfp_f64imm_xform : SDNodeXForm<fpimm, [{
  79       APFloat InVal = N->getValueAPF();
  80       uint32_t enc = ARM_AM::getFP64Imm(InVal);
  81       return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
  82     }]>;
  83
  84 def gi_vfp_f64imm : GICustomOperandRenderer<"renderVFPF64Imm">,
  85                     GISDNodeXFormEquiv<vfp_f64imm_xform>;
  86
  87 def vfp_f64imm : Operand<f64>,
  88                  PatLeaf<(f64 fpimm), [{
  89       return ARM_AM::getFP64Imm(N->getValueAPF()) != -1;
  90     }], vfp_f64imm_xform> {
  91   let PrintMethod = "printFPImmOperand";
  92   let ParserMatchClass = FPImmOperand;
  93   let GISelPredicateCode = [{
  94       const auto &MO = MI.getOperand(1);
  95       if (!MO.isFPImm())
  96         return false;
  97       return ARM_AM::getFP64Imm(MO.getFPImm()->getValueAPF()) != -1;
  98     }];
  99 }
 100
 101 def alignedload16 : PatFrag<(ops node:$ptr), (load node:$ptr), [{
 102   return cast<LoadSDNode>(N)->getAlignment() >= 2;
 103 }]>;
 104
 105 def alignedload32 : PatFrag<(ops node:$ptr), (load node:$ptr), [{
 106   return cast<LoadSDNode>(N)->getAlignment() >= 4;
 107 }]>;
 108
 109 def alignedstore16 : PatFrag<(ops node:$val, node:$ptr),
 110                              (store node:$val, node:$ptr), [{
 111   return cast<StoreSDNode>(N)->getAlignment() >= 2;
 112 }]>;
 113
 114 def alignedstore32 : PatFrag<(ops node:$val, node:$ptr),
 115                              (store node:$val, node:$ptr), [{
 116   return cast<StoreSDNode>(N)->getAlignment() >= 4;
 117 }]>;
 118
 119 // The VCVT to/from fixed-point instructions encode the 'fbits' operand
 120 // (the number of fixed bits) differently than it appears in the assembly
 121 // source. It's encoded as "Size - fbits" where Size is the size of the
 122 // fixed-point representation (32 or 16) and fbits is the value appearing
 123 // in the assembly source, an integer in [0,16] or (0,32], depending on size.
 124 def fbits32_asm_operand : AsmOperandClass { let Name = "FBits32"; }
 125 def fbits32 : Operand<i32> {
 126   let PrintMethod = "printFBits32";
 127   let ParserMatchClass = fbits32_asm_operand;
 128 }
 129
 130 def fbits16_asm_operand : AsmOperandClass { let Name = "FBits16"; }
 131 def fbits16 : Operand<i32> {
 132   let PrintMethod = "printFBits16";
 133   let ParserMatchClass = fbits16_asm_operand;
 134 }
 135
 136 //===----------------------------------------------------------------------===//
 137 //  Load / store Instructions.
 138 //
 139
 140 let canFoldAsLoad = 1, isReMaterializable = 1 in {
 141
 142 def VLDRD : ADI5<0b1101, 0b01, (outs DPR:$Dd), (ins addrmode5:$addr),
 143                  IIC_fpLoad64, "vldr", "\t$Dd, $addr",
 144                  [(set DPR:$Dd, (f64 (alignedload32 addrmode5:$addr)))]>;
 145
 146 def VLDRS : ASI5<0b1101, 0b01, (outs SPR:$Sd), (ins addrmode5:$addr),
 147                  IIC_fpLoad32, "vldr", "\t$Sd, $addr",
 148                  [(set SPR:$Sd, (alignedload32 addrmode5:$addr))]> {
 149   // Some single precision VFP instructions may be executed on both NEON and VFP
 150   // pipelines.
 151   let D = VFPNeonDomain;
 152 }
 153
 154 let isUnpredicable = 1 in
 155 def VLDRH : AHI5<0b1101, 0b01, (outs HPR:$Sd), (ins addrmode5fp16:$addr),
 156                  IIC_fpLoad16, "vldr", ".16\t$Sd, $addr",
 157                  [(set HPR:$Sd, (alignedload16 addrmode5fp16:$addr))]>,
 158             Requires<[HasFullFP16]>;
 159
 160 } // End of 'let canFoldAsLoad = 1, isReMaterializable = 1 in'
 161
 162 def VSTRD : ADI5<0b1101, 0b00, (outs), (ins DPR:$Dd, addrmode5:$addr),
 163                  IIC_fpStore64, "vstr", "\t$Dd, $addr",
 164                  [(alignedstore32 (f64 DPR:$Dd), addrmode5:$addr)]>;
 165
 166 def VSTRS : ASI5<0b1101, 0b00, (outs), (ins SPR:$Sd, addrmode5:$addr),
 167                  IIC_fpStore32, "vstr", "\t$Sd, $addr",
 168                  [(alignedstore32 SPR:$Sd, addrmode5:$addr)]> {
 169   // Some single precision VFP instructions may be executed on both NEON and VFP
 170   // pipelines.
 171   let D = VFPNeonDomain;
 172 }
 173
 174 let isUnpredicable = 1 in
 175 def VSTRH : AHI5<0b1101, 0b00, (outs), (ins HPR:$Sd, addrmode5fp16:$addr),
 176                  IIC_fpStore16, "vstr", ".16\t$Sd, $addr",
 177                  [(alignedstore16 HPR:$Sd, addrmode5fp16:$addr)]>,
 178             Requires<[HasFullFP16]>;
 179
 180 //===----------------------------------------------------------------------===//
 181 //  Load / store multiple Instructions.
 182 //
 183
 184 multiclass vfp_ldst_mult<string asm, bit L_bit,
 185                          InstrItinClass itin, InstrItinClass itin_upd> {
 186   // Double Precision
 187   def DIA :
 188     AXDI4<(outs), (ins GPR:$Rn, pred:$p, dpr_reglist:$regs, variable_ops),
 189           IndexModeNone, itin,
 190           !strconcat(asm, "ia${p}\t$Rn, $regs"), "", []> {
 191     let Inst{24-23} = 0b01;       // Increment After
 192     let Inst{21}    = 0;          // No writeback
 193     let Inst{20}    = L_bit;
 194   }
 195   def DIA_UPD :
 196     AXDI4<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, dpr_reglist:$regs,
 197                                variable_ops),
 198           IndexModeUpd, itin_upd,
 199           !strconcat(asm, "ia${p}\t$Rn!, $regs"), "$Rn = $wb", []> {
 200     let Inst{24-23} = 0b01;       // Increment After
 201     let Inst{21}    = 1;          // Writeback
 202     let Inst{20}    = L_bit;
 203   }
 204   def DDB_UPD :
 205     AXDI4<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, dpr_reglist:$regs,
 206                                variable_ops),
 207           IndexModeUpd, itin_upd,
 208           !strconcat(asm, "db${p}\t$Rn!, $regs"), "$Rn = $wb", []> {
 209     let Inst{24-23} = 0b10;       // Decrement Before
 210     let Inst{21}    = 1;          // Writeback
 211     let Inst{20}    = L_bit;
 212   }
 213
 214   // Single Precision
 215   def SIA :
 216     AXSI4<(outs), (ins GPR:$Rn, pred:$p, spr_reglist:$regs, variable_ops),
 217           IndexModeNone, itin,
 218           !strconcat(asm, "ia${p}\t$Rn, $regs"), "", []> {
 219     let Inst{24-23} = 0b01;       // Increment After
 220     let Inst{21}    = 0;          // No writeback
 221     let Inst{20}    = L_bit;
 222
 223     // Some single precision VFP instructions may be executed on both NEON and
 224     // VFP pipelines.
 225     let D = VFPNeonDomain;
 226   }
 227   def SIA_UPD :
 228     AXSI4<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, spr_reglist:$regs,
 229                                variable_ops),
 230           IndexModeUpd, itin_upd,
 231           !strconcat(asm, "ia${p}\t$Rn!, $regs"), "$Rn = $wb", []> {
 232     let Inst{24-23} = 0b01;       // Increment After
 233     let Inst{21}    = 1;          // Writeback
 234     let Inst{20}    = L_bit;
 235
 236     // Some single precision VFP instructions may be executed on both NEON and
 237     // VFP pipelines.
 238     let D = VFPNeonDomain;
 239   }
 240   def SDB_UPD :
 241     AXSI4<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, spr_reglist:$regs,
 242                                variable_ops),
 243           IndexModeUpd, itin_upd,
 244           !strconcat(asm, "db${p}\t$Rn!, $regs"), "$Rn = $wb", []> {
 245     let Inst{24-23} = 0b10;       // Decrement Before
 246     let Inst{21}    = 1;          // Writeback
 247     let Inst{20}    = L_bit;
 248
 249     // Some single precision VFP instructions may be executed on both NEON and
 250     // VFP pipelines.
 251     let D = VFPNeonDomain;
 252   }
 253 }
 254
 255 let hasSideEffects = 0 in {
 256
 257 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in
 258 defm VLDM : vfp_ldst_mult<"vldm", 1, IIC_fpLoad_m, IIC_fpLoad_mu>;
 259
 260 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in
 261 defm VSTM : vfp_ldst_mult<"vstm", 0, IIC_fpStore_m, IIC_fpStore_mu>;
 262
 263 } // hasSideEffects
 264
 265 def : MnemonicAlias<"vldm", "vldmia">;
 266 def : MnemonicAlias<"vstm", "vstmia">;
 267
 268
 269 //===----------------------------------------------------------------------===//
 270 //  Lazy load / store multiple Instructions
 271 //
 272 let mayLoad = 1 in
 273 def VLLDM : AXSI4<(outs), (ins GPRnopc:$Rn, pred:$p), IndexModeNone,
 274                   IIC_fpLoad_m, "vlldm${p}\t$Rn", "", []>,
 275             Requires<[HasV8MMainline, Has8MSecExt]> {
 276     let Inst{24-23} = 0b00;
 277     let Inst{22}    = 0;
 278     let Inst{21}    = 1;
 279     let Inst{20}    = 1;
 280     let Inst{15-12} = 0;
 281     let Inst{7-0}   = 0;
 282     let mayLoad     = 1;
 283 }
 284
 285 let mayStore = 1 in
 286 def VLSTM : AXSI4<(outs), (ins GPRnopc:$Rn, pred:$p), IndexModeNone,
 287                   IIC_fpStore_m, "vlstm${p}\t$Rn", "", []>,
 288             Requires<[HasV8MMainline, Has8MSecExt]> {
 289     let Inst{24-23} = 0b00;
 290     let Inst{22}    = 0;
 291     let Inst{21}    = 1;
 292     let Inst{20}    = 0;
 293     let Inst{15-12} = 0;
 294     let Inst{7-0}   = 0;
 295     let mayStore    = 1;
 296 }
 297
 298 def : InstAlias<"vpush${p} $r", (VSTMDDB_UPD SP, pred:$p, dpr_reglist:$r), 0>,
 299                 Requires<[HasVFP2]>;
 300 def : InstAlias<"vpush${p} $r", (VSTMSDB_UPD SP, pred:$p, spr_reglist:$r), 0>,
 301                 Requires<[HasVFP2]>;
 302 def : InstAlias<"vpop${p} $r",  (VLDMDIA_UPD SP, pred:$p, dpr_reglist:$r), 0>,
 303                 Requires<[HasVFP2]>;
 304 def : InstAlias<"vpop${p} $r",  (VLDMSIA_UPD SP, pred:$p, spr_reglist:$r), 0>,
 305                 Requires<[HasVFP2]>;
 306 defm : VFPDTAnyInstAlias<"vpush${p}", "$r",
 307                          (VSTMSDB_UPD SP, pred:$p, spr_reglist:$r)>;
 308 defm : VFPDTAnyInstAlias<"vpush${p}", "$r",
 309                          (VSTMDDB_UPD SP, pred:$p, dpr_reglist:$r)>;
 310 defm : VFPDTAnyInstAlias<"vpop${p}", "$r",
 311                          (VLDMSIA_UPD SP, pred:$p, spr_reglist:$r)>;
 312 defm : VFPDTAnyInstAlias<"vpop${p}", "$r",
 313                          (VLDMDIA_UPD SP, pred:$p, dpr_reglist:$r)>;
 314
 315 // FLDMX, FSTMX - Load and store multiple unknown precision registers for
 316 // pre-armv6 cores.
 317 // These instruction are deprecated so we don't want them to get selected.
 318 // However, there is no UAL syntax for them, so we keep them around for
 319 // (dis)assembly only.
 320 multiclass vfp_ldstx_mult<string asm, bit L_bit> {
 321   // Unknown precision
 322   def XIA :
 323     AXXI4<(outs), (ins GPR:$Rn, pred:$p, dpr_reglist:$regs, variable_ops),
 324           IndexModeNone, !strconcat(asm, "iax${p}\t$Rn, $regs"), "", []> {
 325     let Inst{24-23} = 0b01;       // Increment After
 326     let Inst{21}    = 0;          // No writeback
 327     let Inst{20}    = L_bit;
 328   }
 329   def XIA_UPD :
 330     AXXI4<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, dpr_reglist:$regs, variable_ops),
 331           IndexModeUpd, !strconcat(asm, "iax${p}\t$Rn!, $regs"), "$Rn = $wb", []> {
 332     let Inst{24-23} = 0b01;         // Increment After
 333     let Inst{21}    = 1;            // Writeback
 334     let Inst{20}    = L_bit;
 335   }
 336   def XDB_UPD :
 337     AXXI4<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, dpr_reglist:$regs, variable_ops),
 338           IndexModeUpd, !strconcat(asm, "dbx${p}\t$Rn!, $regs"), "$Rn = $wb", []> {
 339     let Inst{24-23} = 0b10;         // Decrement Before
 340     let Inst{21}    = 1;            // Writeback
 341     let Inst{20}    = L_bit;
 342   }
 343 }
 344
 345 defm FLDM : vfp_ldstx_mult<"fldm", 1>;
 346 defm FSTM : vfp_ldstx_mult<"fstm", 0>;
 347
 348 def : VFP2MnemonicAlias<"fldmeax", "fldmdbx">;
 349 def : VFP2MnemonicAlias<"fldmfdx", "fldmiax">;
 350
 351 def : VFP2MnemonicAlias<"fstmeax", "fstmiax">;
 352 def : VFP2MnemonicAlias<"fstmfdx", "fstmdbx">;
 353
 354 //===----------------------------------------------------------------------===//
 355 // FP Binary Operations.
 356 //
 357
 358 let TwoOperandAliasConstraint = "$Dn = $Dd" in
 359 def VADDD  : ADbI<0b11100, 0b11, 0, 0,
 360                   (outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm),
 361                   IIC_fpALU64, "vadd", ".f64\t$Dd, $Dn, $Dm",
 362                   [(set DPR:$Dd, (fadd DPR:$Dn, (f64 DPR:$Dm)))]>,
 363              Sched<[WriteFPALU64]>;
 364
 365 let TwoOperandAliasConstraint = "$Sn = $Sd" in
 366 def VADDS  : ASbIn<0b11100, 0b11, 0, 0,
 367                    (outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm),
 368                    IIC_fpALU32, "vadd", ".f32\t$Sd, $Sn, $Sm",
 369                    [(set SPR:$Sd, (fadd SPR:$Sn, SPR:$Sm))]>,
 370              Sched<[WriteFPALU32]> {
 371   // Some single precision VFP instructions may be executed on both NEON and
 372   // VFP pipelines on A8.
 373   let D = VFPNeonA8Domain;
 374 }
 375
 376 let TwoOperandAliasConstraint = "$Sn = $Sd" in
 377 def VADDH  : AHbI<0b11100, 0b11, 0, 0,
 378                   (outs HPR:$Sd), (ins HPR:$Sn, HPR:$Sm),
 379                   IIC_fpALU16, "vadd", ".f16\t$Sd, $Sn, $Sm",
 380                   [(set HPR:$Sd, (fadd HPR:$Sn, HPR:$Sm))]>,
 381              Sched<[WriteFPALU32]>;
 382
 383 let TwoOperandAliasConstraint = "$Dn = $Dd" in
 384 def VSUBD  : ADbI<0b11100, 0b11, 1, 0,
 385                   (outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm),
 386                   IIC_fpALU64, "vsub", ".f64\t$Dd, $Dn, $Dm",
 387                   [(set DPR:$Dd, (fsub DPR:$Dn, (f64 DPR:$Dm)))]>,
 388              Sched<[WriteFPALU64]>;
 389
 390 let TwoOperandAliasConstraint = "$Sn = $Sd" in
 391 def VSUBS  : ASbIn<0b11100, 0b11, 1, 0,
 392                    (outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm),
 393                    IIC_fpALU32, "vsub", ".f32\t$Sd, $Sn, $Sm",
 394                    [(set SPR:$Sd, (fsub SPR:$Sn, SPR:$Sm))]>,
 395              Sched<[WriteFPALU32]>{
 396   // Some single precision VFP instructions may be executed on both NEON and
 397   // VFP pipelines on A8.
 398   let D = VFPNeonA8Domain;
 399 }
 400
 401 let TwoOperandAliasConstraint = "$Sn = $Sd" in
 402 def VSUBH  : AHbI<0b11100, 0b11, 1, 0,
 403                   (outs HPR:$Sd), (ins HPR:$Sn, HPR:$Sm),
 404                   IIC_fpALU16, "vsub", ".f16\t$Sd, $Sn, $Sm",
 405                   [(set HPR:$Sd, (fsub HPR:$Sn, HPR:$Sm))]>,
 406             Sched<[WriteFPALU32]>;
 407
 408 let TwoOperandAliasConstraint = "$Dn = $Dd" in
 409 def VDIVD  : ADbI<0b11101, 0b00, 0, 0,
 410                   (outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm),
 411                   IIC_fpDIV64, "vdiv", ".f64\t$Dd, $Dn, $Dm",
 412                   [(set DPR:$Dd, (fdiv DPR:$Dn, (f64 DPR:$Dm)))]>,
 413              Sched<[WriteFPDIV64]>;
 414
 415 let TwoOperandAliasConstraint = "$Sn = $Sd" in
 416 def VDIVS  : ASbI<0b11101, 0b00, 0, 0,
 417                   (outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm),
 418                   IIC_fpDIV32, "vdiv", ".f32\t$Sd, $Sn, $Sm",
 419                   [(set SPR:$Sd, (fdiv SPR:$Sn, SPR:$Sm))]>,
 420              Sched<[WriteFPDIV32]>;
 421
 422 let TwoOperandAliasConstraint = "$Sn = $Sd" in
 423 def VDIVH  : AHbI<0b11101, 0b00, 0, 0,
 424                   (outs HPR:$Sd), (ins HPR:$Sn, HPR:$Sm),
 425                   IIC_fpDIV16, "vdiv", ".f16\t$Sd, $Sn, $Sm",
 426                   [(set HPR:$Sd, (fdiv HPR:$Sn, HPR:$Sm))]>,
 427              Sched<[WriteFPDIV32]>;
 428
 429 let TwoOperandAliasConstraint = "$Dn = $Dd" in
 430 def VMULD  : ADbI<0b11100, 0b10, 0, 0,
 431                   (outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm),
 432                   IIC_fpMUL64, "vmul", ".f64\t$Dd, $Dn, $Dm",
 433                   [(set DPR:$Dd, (fmul DPR:$Dn, (f64 DPR:$Dm)))]>,
 434              Sched<[WriteFPMUL64, ReadFPMUL, ReadFPMUL]>;
 435
 436 let TwoOperandAliasConstraint = "$Sn = $Sd" in
 437 def VMULS  : ASbIn<0b11100, 0b10, 0, 0,
 438                    (outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm),
 439                    IIC_fpMUL32, "vmul", ".f32\t$Sd, $Sn, $Sm",
 440                    [(set SPR:$Sd, (fmul SPR:$Sn, SPR:$Sm))]>,
 441             Sched<[WriteFPMUL32, ReadFPMUL, ReadFPMUL]> {
 442   // Some single precision VFP instructions may be executed on both NEON and
 443   // VFP pipelines on A8.
 444   let D = VFPNeonA8Domain;
 445 }
 446
 447 let TwoOperandAliasConstraint = "$Sn = $Sd" in
 448 def VMULH  : AHbI<0b11100, 0b10, 0, 0,
 449                   (outs HPR:$Sd), (ins HPR:$Sn, HPR:$Sm),
 450                   IIC_fpMUL16, "vmul", ".f16\t$Sd, $Sn, $Sm",
 451                   [(set HPR:$Sd, (fmul HPR:$Sn, HPR:$Sm))]>,
 452              Sched<[WriteFPMUL32, ReadFPMUL, ReadFPMUL]>;
 453
 454 def VNMULD : ADbI<0b11100, 0b10, 1, 0,
 455                   (outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm),
 456                   IIC_fpMUL64, "vnmul", ".f64\t$Dd, $Dn, $Dm",
 457                   [(set DPR:$Dd, (fneg (fmul DPR:$Dn, (f64 DPR:$Dm))))]>,
 458              Sched<[WriteFPMUL64, ReadFPMUL, ReadFPMUL]>;
 459
 460 def VNMULS : ASbI<0b11100, 0b10, 1, 0,
 461                   (outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm),
 462                   IIC_fpMUL32, "vnmul", ".f32\t$Sd, $Sn, $Sm",
 463                   [(set SPR:$Sd, (fneg (fmul SPR:$Sn, SPR:$Sm)))]>,
 464             Sched<[WriteFPMUL32, ReadFPMUL, ReadFPMUL]> {
 465   // Some single precision VFP instructions may be executed on both NEON and
 466   // VFP pipelines on A8.
 467   let D = VFPNeonA8Domain;
 468 }
 469
 470 def VNMULH : AHbI<0b11100, 0b10, 1, 0,
 471                   (outs HPR:$Sd), (ins HPR:$Sn, HPR:$Sm),
 472                   IIC_fpMUL16, "vnmul", ".f16\t$Sd, $Sn, $Sm",
 473                   [(set HPR:$Sd, (fneg (fmul HPR:$Sn, HPR:$Sm)))]>,
 474              Sched<[WriteFPMUL32, ReadFPMUL, ReadFPMUL]>;
 475
 476 multiclass vsel_inst<string op, bits<2> opc, int CC> {
 477   let DecoderNamespace = "VFPV8", PostEncoderMethod = "",
 478       Uses = [CPSR], AddedComplexity = 4, isUnpredicable = 1 in {
 479     def H : AHbInp<0b11100, opc, 0,
 480                    (outs HPR:$Sd), (ins HPR:$Sn, HPR:$Sm),
 481                    NoItinerary, !strconcat("vsel", op, ".f16\t$Sd, $Sn, $Sm"),
 482                    [(set HPR:$Sd, (ARMcmov HPR:$Sm, HPR:$Sn, CC))]>,
 483                    Requires<[HasFullFP16]>;
 484
 485     def S : ASbInp<0b11100, opc, 0,
 486                    (outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm),
 487                    NoItinerary, !strconcat("vsel", op, ".f32\t$Sd, $Sn, $Sm"),
 488                    [(set SPR:$Sd, (ARMcmov SPR:$Sm, SPR:$Sn, CC))]>,
 489                    Requires<[HasFPARMv8]>;
 490
 491     def D : ADbInp<0b11100, opc, 0,
 492                    (outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm),
 493                    NoItinerary, !strconcat("vsel", op, ".f64\t$Dd, $Dn, $Dm"),
 494                    [(set DPR:$Dd, (ARMcmov (f64 DPR:$Dm), (f64 DPR:$Dn), CC))]>,
 495                    Requires<[HasFPARMv8, HasDPVFP]>;
 496   }
 497 }
 498
 499 // The CC constants here match ARMCC::CondCodes.
 500 defm VSELGT : vsel_inst<"gt", 0b11, 12>;
 501 defm VSELGE : vsel_inst<"ge", 0b10, 10>;
 502 defm VSELEQ : vsel_inst<"eq", 0b00, 0>;
 503 defm VSELVS : vsel_inst<"vs", 0b01, 6>;
 504
 505 multiclass vmaxmin_inst<string op, bit opc, SDNode SD> {
 506   let DecoderNamespace = "VFPV8", PostEncoderMethod = "",
 507       isUnpredicable = 1 in {
 508     def H : AHbInp<0b11101, 0b00, opc,
 509                    (outs HPR:$Sd), (ins HPR:$Sn, HPR:$Sm),
 510                    NoItinerary, !strconcat(op, ".f16\t$Sd, $Sn, $Sm"),
 511                    [(set HPR:$Sd, (SD HPR:$Sn, HPR:$Sm))]>,
 512                    Requires<[HasFullFP16]>;
 513
 514     def S : ASbInp<0b11101, 0b00, opc,
 515                    (outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm),
 516                    NoItinerary, !strconcat(op, ".f32\t$Sd, $Sn, $Sm"),
 517                    [(set SPR:$Sd, (SD SPR:$Sn, SPR:$Sm))]>,
 518                    Requires<[HasFPARMv8]>;
 519
 520     def D : ADbInp<0b11101, 0b00, opc,
 521                    (outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm),
 522                    NoItinerary, !strconcat(op, ".f64\t$Dd, $Dn, $Dm"),
 523                    [(set DPR:$Dd, (f64 (SD (f64 DPR:$Dn), (f64 DPR:$Dm))))]>,
 524                    Requires<[HasFPARMv8, HasDPVFP]>;
 525   }
 526 }
 527
 528 defm VMAXNM : vmaxmin_inst<"vmaxnm", 0, fmaxnum>;
 529 defm VMINNM : vmaxmin_inst<"vminnm", 1, fminnum>;
 530
 531 // Match reassociated forms only if not sign dependent rounding.
 532 def : Pat<(fmul (fneg DPR:$a), (f64 DPR:$b)),
 533           (VNMULD DPR:$a, DPR:$b)>,
 534           Requires<[NoHonorSignDependentRounding,HasDPVFP]>;
 535 def : Pat<(fmul (fneg SPR:$a), SPR:$b),
 536           (VNMULS SPR:$a, SPR:$b)>, Requires<[NoHonorSignDependentRounding]>;
 537
 538 // These are encoded as unary instructions.
 539 let Defs = [FPSCR_NZCV] in {
 540 def VCMPED : ADuI<0b11101, 0b11, 0b0100, 0b11, 0,
 541                   (outs), (ins DPR:$Dd, DPR:$Dm),
 542                   IIC_fpCMP64, "vcmpe", ".f64\t$Dd, $Dm",
 543                   [(arm_cmpfp DPR:$Dd, (f64 DPR:$Dm), (i32 1))]>;
 544
 545 def VCMPES : ASuI<0b11101, 0b11, 0b0100, 0b11, 0,
 546                   (outs), (ins SPR:$Sd, SPR:$Sm),
 547                   IIC_fpCMP32, "vcmpe", ".f32\t$Sd, $Sm",
 548                   [(arm_cmpfp SPR:$Sd, SPR:$Sm, (i32 1))]> {
 549   // Some single precision VFP instructions may be executed on both NEON and
 550   // VFP pipelines on A8.
 551   let D = VFPNeonA8Domain;
 552 }
 553
 554 def VCMPEH : AHuI<0b11101, 0b11, 0b0100, 0b11, 0,
 555                   (outs), (ins HPR:$Sd, HPR:$Sm),
 556                   IIC_fpCMP16, "vcmpe", ".f16\t$Sd, $Sm",
 557                   [(arm_cmpfp HPR:$Sd, HPR:$Sm, (i32 1))]>;
 558
 559 def VCMPD  : ADuI<0b11101, 0b11, 0b0100, 0b01, 0,
 560                   (outs), (ins DPR:$Dd, DPR:$Dm),
 561                   IIC_fpCMP64, "vcmp", ".f64\t$Dd, $Dm",
 562                   [(arm_cmpfp DPR:$Dd, (f64 DPR:$Dm), (i32 0))]>;
 563
 564 def VCMPS  : ASuI<0b11101, 0b11, 0b0100, 0b01, 0,
 565                   (outs), (ins SPR:$Sd, SPR:$Sm),
 566                   IIC_fpCMP32, "vcmp", ".f32\t$Sd, $Sm",
 567                   [(arm_cmpfp SPR:$Sd, SPR:$Sm, (i32 0))]> {
 568   // Some single precision VFP instructions may be executed on both NEON and
 569   // VFP pipelines on A8.
 570   let D = VFPNeonA8Domain;
 571 }
 572
 573 def VCMPH  : AHuI<0b11101, 0b11, 0b0100, 0b01, 0,
 574                   (outs), (ins HPR:$Sd, HPR:$Sm),
 575                   IIC_fpCMP16, "vcmp", ".f16\t$Sd, $Sm",
 576                   [(arm_cmpfp HPR:$Sd, HPR:$Sm, (i32 0))]>;
 577 } // Defs = [FPSCR_NZCV]
 578
 579 //===----------------------------------------------------------------------===//
 580 // FP Unary Operations.
 581 //
 582
 583 def VABSD  : ADuI<0b11101, 0b11, 0b0000, 0b11, 0,
 584                   (outs DPR:$Dd), (ins DPR:$Dm),
 585                   IIC_fpUNA64, "vabs", ".f64\t$Dd, $Dm",
 586                   [(set DPR:$Dd, (fabs (f64 DPR:$Dm)))]>;
 587
 588 def VABSS  : ASuIn<0b11101, 0b11, 0b0000, 0b11, 0,
 589                    (outs SPR:$Sd), (ins SPR:$Sm),
 590                    IIC_fpUNA32, "vabs", ".f32\t$Sd, $Sm",
 591                    [(set SPR:$Sd, (fabs SPR:$Sm))]> {
 592   // Some single precision VFP instructions may be executed on both NEON and
 593   // VFP pipelines on A8.
 594   let D = VFPNeonA8Domain;
 595 }
 596
 597 def VABSH  : AHuI<0b11101, 0b11, 0b0000, 0b11, 0,
 598                    (outs HPR:$Sd), (ins HPR:$Sm),
 599                    IIC_fpUNA16, "vabs", ".f16\t$Sd, $Sm",
 600                    [(set HPR:$Sd, (fabs (f16 HPR:$Sm)))]>;
 601
 602 let Defs = [FPSCR_NZCV] in {
 603 def VCMPEZD : ADuI<0b11101, 0b11, 0b0101, 0b11, 0,
 604                    (outs), (ins DPR:$Dd),
 605                    IIC_fpCMP64, "vcmpe", ".f64\t$Dd, #0",
 606                    [(arm_cmpfp0 (f64 DPR:$Dd), (i32 1))]> {
 607   let Inst{3-0} = 0b0000;
 608   let Inst{5}   = 0;
 609 }
 610
 611 def VCMPEZS : ASuI<0b11101, 0b11, 0b0101, 0b11, 0,
 612                    (outs), (ins SPR:$Sd),
 613                    IIC_fpCMP32, "vcmpe", ".f32\t$Sd, #0",
 614                    [(arm_cmpfp0 SPR:$Sd, (i32 1))]> {
 615   let Inst{3-0} = 0b0000;
 616   let Inst{5}   = 0;
 617
 618   // Some single precision VFP instructions may be executed on both NEON and
 619   // VFP pipelines on A8.
 620   let D = VFPNeonA8Domain;
 621 }
 622
 623 def VCMPEZH : AHuI<0b11101, 0b11, 0b0101, 0b11, 0,
 624                    (outs), (ins HPR:$Sd),
 625                    IIC_fpCMP16, "vcmpe", ".f16\t$Sd, #0",
 626                    [(arm_cmpfp0 HPR:$Sd, (i32 1))]> {
 627   let Inst{3-0} = 0b0000;
 628   let Inst{5}   = 0;
 629 }
 630
 631 def VCMPZD  : ADuI<0b11101, 0b11, 0b0101, 0b01, 0,
 632                    (outs), (ins DPR:$Dd),
 633                    IIC_fpCMP64, "vcmp", ".f64\t$Dd, #0",
 634                    [(arm_cmpfp0 (f64 DPR:$Dd), (i32 0))]> {
 635   let Inst{3-0} = 0b0000;
 636   let Inst{5}   = 0;
 637 }
 638
 639 def VCMPZS  : ASuI<0b11101, 0b11, 0b0101, 0b01, 0,
 640                    (outs), (ins SPR:$Sd),
 641                    IIC_fpCMP32, "vcmp", ".f32\t$Sd, #0",
 642                    [(arm_cmpfp0 SPR:$Sd, (i32 0))]> {
 643   let Inst{3-0} = 0b0000;
 644   let Inst{5}   = 0;
 645
 646   // Some single precision VFP instructions may be executed on both NEON and
 647   // VFP pipelines on A8.
 648   let D = VFPNeonA8Domain;
 649 }
 650
 651 def VCMPZH  : AHuI<0b11101, 0b11, 0b0101, 0b01, 0,
 652                    (outs), (ins HPR:$Sd),
 653                    IIC_fpCMP16, "vcmp", ".f16\t$Sd, #0",
 654                    [(arm_cmpfp0 HPR:$Sd, (i32 0))]> {
 655   let Inst{3-0} = 0b0000;
 656   let Inst{5}   = 0;
 657 }
 658 } // Defs = [FPSCR_NZCV]
 659
 660 def VCVTDS  : ASuI<0b11101, 0b11, 0b0111, 0b11, 0,
 661                    (outs DPR:$Dd), (ins SPR:$Sm),
 662                    IIC_fpCVTDS, "vcvt", ".f64.f32\t$Dd, $Sm",
 663                    [(set DPR:$Dd, (fpextend SPR:$Sm))]>,
 664              Sched<[WriteFPCVT]> {
 665   // Instruction operands.
 666   bits<5> Dd;
 667   bits<5> Sm;
 668
 669   // Encode instruction operands.
 670   let Inst{3-0}   = Sm{4-1};
 671   let Inst{5}     = Sm{0};
 672   let Inst{15-12} = Dd{3-0};
 673   let Inst{22}    = Dd{4};
 674
 675   let Predicates = [HasVFP2, HasDPVFP];
 676 }
 677
 678 // Special case encoding: bits 11-8 is 0b1011.
 679 def VCVTSD  : VFPAI<(outs SPR:$Sd), (ins DPR:$Dm), VFPUnaryFrm,
 680                     IIC_fpCVTSD, "vcvt", ".f32.f64\t$Sd, $Dm",
 681                     [(set SPR:$Sd, (fpround DPR:$Dm))]>,
 682               Sched<[WriteFPCVT]> {
 683   // Instruction operands.
 684   bits<5> Sd;
 685   bits<5> Dm;
 686
 687   // Encode instruction operands.
 688   let Inst{3-0}   = Dm{3-0};
 689   let Inst{5}     = Dm{4};
 690   let Inst{15-12} = Sd{4-1};
 691   let Inst{22}    = Sd{0};
 692
 693   let Inst{27-23} = 0b11101;
 694   let Inst{21-16} = 0b110111;
 695   let Inst{11-8}  = 0b1011;
 696   let Inst{7-6}   = 0b11;
 697   let Inst{4}     = 0;
 698
 699   let Predicates = [HasVFP2, HasDPVFP];
 700 }
 701
 702 // Between half, single and double-precision.
 703 def VCVTBHS: ASuI<0b11101, 0b11, 0b0010, 0b01, 0, (outs SPR:$Sd), (ins SPR:$Sm),
 704                  /* FIXME */ IIC_fpCVTSH, "vcvtb", ".f32.f16\t$Sd, $Sm",
 705                  [/* Intentionally left blank, see patterns below */]>,
 706                  Requires<[HasFP16]>,
 707              Sched<[WriteFPCVT]>;
 708
 709 def : FullFP16Pat<(f32 (fpextend HPR:$Sm)),
 710                   (VCVTBHS (COPY_TO_REGCLASS HPR:$Sm, SPR))>;
 711 def : FP16Pat<(f16_to_fp GPR:$a),
 712               (VCVTBHS (COPY_TO_REGCLASS GPR:$a, SPR))>;
 713
 714 def VCVTBSH: ASuI<0b11101, 0b11, 0b0011, 0b01, 0, (outs SPR:$Sd), (ins SPR:$Sm),
 715                  /* FIXME */ IIC_fpCVTHS, "vcvtb", ".f16.f32\t$Sd, $Sm",
 716                  [/* Intentionally left blank, see patterns below */]>,
 717                  Requires<[HasFP16]>,
 718              Sched<[WriteFPCVT]>;
 719
 720 def : FullFP16Pat<(f16 (fpround SPR:$Sm)),
 721                   (COPY_TO_REGCLASS (VCVTBSH SPR:$Sm), HPR)>;
 722 def : FP16Pat<(fp_to_f16 SPR:$a),
 723               (i32 (COPY_TO_REGCLASS (VCVTBSH SPR:$a), GPR))>;
 724
 725 def VCVTTHS: ASuI<0b11101, 0b11, 0b0010, 0b11, 0, (outs SPR:$Sd), (ins SPR:$Sm),
 726                  /* FIXME */ IIC_fpCVTSH, "vcvtt", ".f32.f16\t$Sd, $Sm",
 727                  [/* For disassembly only; pattern left blank */]>,
 728                  Requires<[HasFP16]>,
 729              Sched<[WriteFPCVT]>;
 730
 731 def VCVTTSH: ASuI<0b11101, 0b11, 0b0011, 0b11, 0, (outs SPR:$Sd), (ins SPR:$Sm),
 732                  /* FIXME */ IIC_fpCVTHS, "vcvtt", ".f16.f32\t$Sd, $Sm",
 733                  [/* For disassembly only; pattern left blank */]>,
 734                  Requires<[HasFP16]>,
 735             Sched<[WriteFPCVT]>;
 736
 737 def VCVTBHD : ADuI<0b11101, 0b11, 0b0010, 0b01, 0,
 738                    (outs DPR:$Dd), (ins SPR:$Sm),
 739                    NoItinerary, "vcvtb", ".f64.f16\t$Dd, $Sm",
 740                    [/* Intentionally left blank, see patterns below */]>,
 741                    Requires<[HasFPARMv8, HasDPVFP]>,
 742               Sched<[WriteFPCVT]> {
 743   // Instruction operands.
 744   bits<5> Sm;
 745
 746   // Encode instruction operands.
 747   let Inst{3-0} = Sm{4-1};
 748   let Inst{5}   = Sm{0};
 749 }
 750
 751 def : FullFP16Pat<(f64 (fpextend HPR:$Sm)),
 752                   (VCVTBHD (COPY_TO_REGCLASS HPR:$Sm, SPR))>,
 753                   Requires<[HasFPARMv8, HasDPVFP]>;
 754 def : FP16Pat<(f64 (f16_to_fp GPR:$a)),
 755               (VCVTBHD (COPY_TO_REGCLASS GPR:$a, SPR))>,
 756               Requires<[HasFPARMv8, HasDPVFP]>;
 757
 758 def VCVTBDH : ADuI<0b11101, 0b11, 0b0011, 0b01, 0,
 759                    (outs SPR:$Sd), (ins DPR:$Dm),
 760                    NoItinerary, "vcvtb", ".f16.f64\t$Sd, $Dm",
 761                    [/* Intentionally left blank, see patterns below */]>,
 762                    Requires<[HasFPARMv8, HasDPVFP]> {
 763   // Instruction operands.
 764   bits<5> Sd;
 765   bits<5> Dm;
 766
 767   // Encode instruction operands.
 768   let Inst{3-0}     = Dm{3-0};
 769   let Inst{5}       = Dm{4};
 770   let Inst{15-12}   = Sd{4-1};
 771   let Inst{22}      = Sd{0};
 772 }
 773
 774 def : FullFP16Pat<(f16 (fpround DPR:$Dm)),
 775                   (COPY_TO_REGCLASS (VCVTBDH DPR:$Dm), HPR)>,
 776                   Requires<[HasFPARMv8, HasDPVFP]>;
 777 def : FP16Pat<(fp_to_f16 (f64 DPR:$a)),
 778               (i32 (COPY_TO_REGCLASS (VCVTBDH DPR:$a), GPR))>,
 779                    Requires<[HasFPARMv8, HasDPVFP]>;
 780
 781 def VCVTTHD : ADuI<0b11101, 0b11, 0b0010, 0b11, 0,
 782                    (outs DPR:$Dd), (ins SPR:$Sm),
 783                    NoItinerary, "vcvtt", ".f64.f16\t$Dd, $Sm",
 784                    []>, Requires<[HasFPARMv8, HasDPVFP]> {
 785   // Instruction operands.
 786   bits<5> Sm;
 787
 788   // Encode instruction operands.
 789   let Inst{3-0} = Sm{4-1};
 790   let Inst{5}   = Sm{0};
 791 }
 792
 793 def VCVTTDH : ADuI<0b11101, 0b11, 0b0011, 0b11, 0,
 794                    (outs SPR:$Sd), (ins DPR:$Dm),
 795                    NoItinerary, "vcvtt", ".f16.f64\t$Sd, $Dm",
 796                    []>, Requires<[HasFPARMv8, HasDPVFP]> {
 797   // Instruction operands.
 798   bits<5> Sd;
 799   bits<5> Dm;
 800
 801   // Encode instruction operands.
 802   let Inst{15-12} = Sd{4-1};
 803   let Inst{22}    = Sd{0};
 804   let Inst{3-0}   = Dm{3-0};
 805   let Inst{5}     = Dm{4};
 806 }
 807
 808 multiclass vcvt_inst<string opc, bits<2> rm,
 809                      SDPatternOperator node = null_frag> {
 810   let PostEncoderMethod = "", DecoderNamespace = "VFPV8" in {
 811     def SH : AHuInp<0b11101, 0b11, 0b1100, 0b11, 0,
 812                     (outs SPR:$Sd), (ins HPR:$Sm),
 813                     NoItinerary, !strconcat("vcvt", opc, ".s32.f16\t$Sd, $Sm"),
 814                     []>,
 815                     Requires<[HasFullFP16]> {
 816       let Inst{17-16} = rm;
 817     }
 818
 819     def UH : AHuInp<0b11101, 0b11, 0b1100, 0b01, 0,
 820                     (outs SPR:$Sd), (ins HPR:$Sm),
 821                     NoItinerary, !strconcat("vcvt", opc, ".u32.f16\t$Sd, $Sm"),
 822                     []>,
 823                     Requires<[HasFullFP16]> {
 824       let Inst{17-16} = rm;
 825     }
 826
 827     def SS : ASuInp<0b11101, 0b11, 0b1100, 0b11, 0,
 828                     (outs SPR:$Sd), (ins SPR:$Sm),
 829                     NoItinerary, !strconcat("vcvt", opc, ".s32.f32\t$Sd, $Sm"),
 830                     []>,
 831                     Requires<[HasFPARMv8]> {
 832       let Inst{17-16} = rm;
 833     }
 834
 835     def US : ASuInp<0b11101, 0b11, 0b1100, 0b01, 0,
 836                     (outs SPR:$Sd), (ins SPR:$Sm),
 837                     NoItinerary, !strconcat("vcvt", opc, ".u32.f32\t$Sd, $Sm"),
 838                     []>,
 839                     Requires<[HasFPARMv8]> {
 840       let Inst{17-16} = rm;
 841     }
 842
 843     def SD : ASuInp<0b11101, 0b11, 0b1100, 0b11, 0,
 844                     (outs SPR:$Sd), (ins DPR:$Dm),
 845                     NoItinerary, !strconcat("vcvt", opc, ".s32.f64\t$Sd, $Dm"),
 846                     []>,
 847                     Requires<[HasFPARMv8, HasDPVFP]> {
 848       bits<5> Dm;
 849
 850       let Inst{17-16} = rm;
 851
 852       // Encode instruction operands
 853       let Inst{3-0} = Dm{3-0};
 854       let Inst{5}   = Dm{4};
 855       let Inst{8} = 1;
 856     }
 857
 858     def UD : ASuInp<0b11101, 0b11, 0b1100, 0b01, 0,
 859                     (outs SPR:$Sd), (ins DPR:$Dm),
 860                     NoItinerary, !strconcat("vcvt", opc, ".u32.f64\t$Sd, $Dm"),
 861                     []>,
 862                     Requires<[HasFPARMv8, HasDPVFP]> {
 863       bits<5> Dm;
 864
 865       let Inst{17-16} = rm;
 866
 867       // Encode instruction operands
 868       let Inst{3-0}  = Dm{3-0};
 869       let Inst{5}    = Dm{4};
 870       let Inst{8} = 1;
 871     }
 872   }
 873
 874   let Predicates = [HasFPARMv8] in {
 875     let Predicates = [HasFullFP16] in {
 876     def : Pat<(i32 (fp_to_sint (node HPR:$a))),
 877               (COPY_TO_REGCLASS
 878                 (!cast<Instruction>(NAME#"SH") HPR:$a),
 879                 GPR)>;
 880
 881     def : Pat<(i32 (fp_to_uint (node HPR:$a))),
 882               (COPY_TO_REGCLASS
 883                 (!cast<Instruction>(NAME#"UH") HPR:$a),
 884                 GPR)>;
 885     }
 886     def : Pat<(i32 (fp_to_sint (node SPR:$a))),
 887               (COPY_TO_REGCLASS
 888                 (!cast<Instruction>(NAME#"SS") SPR:$a),
 889                 GPR)>;
 890     def : Pat<(i32 (fp_to_uint (node SPR:$a))),
 891               (COPY_TO_REGCLASS
 892                 (!cast<Instruction>(NAME#"US") SPR:$a),
 893                 GPR)>;
 894   }
 895   let Predicates = [HasFPARMv8, HasDPVFP] in {
 896     def : Pat<(i32 (fp_to_sint (node (f64 DPR:$a)))),
 897               (COPY_TO_REGCLASS
 898                 (!cast<Instruction>(NAME#"SD") DPR:$a),
 899                 GPR)>;
 900     def : Pat<(i32 (fp_to_uint (node (f64 DPR:$a)))),
 901               (COPY_TO_REGCLASS
 902                 (!cast<Instruction>(NAME#"UD") DPR:$a),
 903                 GPR)>;
 904   }
 905 }
 906
 907 defm VCVTA : vcvt_inst<"a", 0b00, fround>;
 908 defm VCVTN : vcvt_inst<"n", 0b01>;
 909 defm VCVTP : vcvt_inst<"p", 0b10, fceil>;
 910 defm VCVTM : vcvt_inst<"m", 0b11, ffloor>;
 911
 912 def VNEGD  : ADuI<0b11101, 0b11, 0b0001, 0b01, 0,
 913                   (outs DPR:$Dd), (ins DPR:$Dm),
 914                   IIC_fpUNA64, "vneg", ".f64\t$Dd, $Dm",
 915                   [(set DPR:$Dd, (fneg (f64 DPR:$Dm)))]>;
 916
 917 def VNEGS  : ASuIn<0b11101, 0b11, 0b0001, 0b01, 0,
 918                    (outs SPR:$Sd), (ins SPR:$Sm),
 919                    IIC_fpUNA32, "vneg", ".f32\t$Sd, $Sm",
 920                    [(set SPR:$Sd, (fneg SPR:$Sm))]> {
 921   // Some single precision VFP instructions may be executed on both NEON and
 922   // VFP pipelines on A8.
 923   let D = VFPNeonA8Domain;
 924 }
 925
 926 def VNEGH  : AHuI<0b11101, 0b11, 0b0001, 0b01, 0,
 927                   (outs HPR:$Sd), (ins HPR:$Sm),
 928                   IIC_fpUNA16, "vneg", ".f16\t$Sd, $Sm",
 929                   [(set HPR:$Sd, (fneg HPR:$Sm))]>;
 930
 931 multiclass vrint_inst_zrx<string opc, bit op, bit op2, SDPatternOperator node> {
 932   def H : AHuI<0b11101, 0b11, 0b0110, 0b11, 0,
 933                (outs SPR:$Sd), (ins SPR:$Sm),
 934                NoItinerary, !strconcat("vrint", opc), ".f16\t$Sd, $Sm",
 935                []>,
 936                Requires<[HasFullFP16]> {
 937     let Inst{7} = op2;
 938     let Inst{16} = op;
 939   }
 940
 941   def S : ASuI<0b11101, 0b11, 0b0110, 0b11, 0,
 942                (outs SPR:$Sd), (ins SPR:$Sm),
 943                NoItinerary, !strconcat("vrint", opc), ".f32\t$Sd, $Sm",
 944                [(set (f32 SPR:$Sd), (node (f32 SPR:$Sm)))]>,
 945                Requires<[HasFPARMv8]> {
 946     let Inst{7} = op2;
 947     let Inst{16} = op;
 948   }
 949   def D : ADuI<0b11101, 0b11, 0b0110, 0b11, 0,
 950                 (outs DPR:$Dd), (ins DPR:$Dm),
 951                 NoItinerary, !strconcat("vrint", opc), ".f64\t$Dd, $Dm",
 952                 [(set (f64 DPR:$Dd), (node (f64 DPR:$Dm)))]>,
 953                 Requires<[HasFPARMv8, HasDPVFP]> {
 954     let Inst{7} = op2;
 955     let Inst{16} = op;
 956   }
 957
 958   def : InstAlias<!strconcat("vrint", opc, "$p.f16.f16\t$Sd, $Sm"),
 959                   (!cast<Instruction>(NAME#"H") SPR:$Sd, SPR:$Sm, pred:$p), 0>,
 960         Requires<[HasFullFP16]>;
 961   def : InstAlias<!strconcat("vrint", opc, "$p.f32.f32\t$Sd, $Sm"),
 962                   (!cast<Instruction>(NAME#"S") SPR:$Sd, SPR:$Sm, pred:$p), 0>,
 963         Requires<[HasFPARMv8]>;
 964   def : InstAlias<!strconcat("vrint", opc, "$p.f64.f64\t$Dd, $Dm"),
 965                   (!cast<Instruction>(NAME#"D") DPR:$Dd, DPR:$Dm, pred:$p), 0>,
 966         Requires<[HasFPARMv8,HasDPVFP]>;
 967 }
 968
 969 defm VRINTZ : vrint_inst_zrx<"z", 0, 1, ftrunc>;
 970 defm VRINTR : vrint_inst_zrx<"r", 0, 0, fnearbyint>;
 971 defm VRINTX : vrint_inst_zrx<"x", 1, 0, frint>;
 972
 973 multiclass vrint_inst_anpm<string opc, bits<2> rm,
 974                            SDPatternOperator node = null_frag> {
 975   let PostEncoderMethod = "", DecoderNamespace = "VFPV8",
 976       isUnpredicable = 1 in {
 977     def H : AHuInp<0b11101, 0b11, 0b1000, 0b01, 0,
 978                    (outs SPR:$Sd), (ins SPR:$Sm),
 979                    NoItinerary, !strconcat("vrint", opc, ".f16\t$Sd, $Sm"),
 980                    []>,
 981                    Requires<[HasFullFP16]> {
 982       let Inst{17-16} = rm;
 983     }
 984     def S : ASuInp<0b11101, 0b11, 0b1000, 0b01, 0,
 985                    (outs SPR:$Sd), (ins SPR:$Sm),
 986                    NoItinerary, !strconcat("vrint", opc, ".f32\t$Sd, $Sm"),
 987                    [(set (f32 SPR:$Sd), (node (f32 SPR:$Sm)))]>,
 988                    Requires<[HasFPARMv8]> {
 989       let Inst{17-16} = rm;
 990     }
 991     def D : ADuInp<0b11101, 0b11, 0b1000, 0b01, 0,
 992                    (outs DPR:$Dd), (ins DPR:$Dm),
 993                    NoItinerary, !strconcat("vrint", opc, ".f64\t$Dd, $Dm"),
 994                    [(set (f64 DPR:$Dd), (node (f64 DPR:$Dm)))]>,
 995                    Requires<[HasFPARMv8, HasDPVFP]> {
 996       let Inst{17-16} = rm;
 997     }
 998   }
 999
1000   def : InstAlias<!strconcat("vrint", opc, ".f32.f32\t$Sd, $Sm"),
1001                   (!cast<Instruction>(NAME#"S") SPR:$Sd, SPR:$Sm), 0>,
1002         Requires<[HasFPARMv8]>;
1003   def : InstAlias<!strconcat("vrint", opc, ".f64.f64\t$Dd, $Dm"),
1004                   (!cast<Instruction>(NAME#"D") DPR:$Dd, DPR:$Dm), 0>,
1005         Requires<[HasFPARMv8,HasDPVFP]>;
1006 }
1007
1008 defm VRINTA : vrint_inst_anpm<"a", 0b00, fround>;
1009 defm VRINTN : vrint_inst_anpm<"n", 0b01, int_arm_neon_vrintn>;
1010 defm VRINTP : vrint_inst_anpm<"p", 0b10, fceil>;
1011 defm VRINTM : vrint_inst_anpm<"m", 0b11, ffloor>;
1012
1013 def VSQRTD : ADuI<0b11101, 0b11, 0b0001, 0b11, 0,
1014                   (outs DPR:$Dd), (ins DPR:$Dm),
1015                   IIC_fpSQRT64, "vsqrt", ".f64\t$Dd, $Dm",
1016                   [(set DPR:$Dd, (fsqrt (f64 DPR:$Dm)))]>,
1017              Sched<[WriteFPSQRT64]>;
1018
1019 def VSQRTS : ASuI<0b11101, 0b11, 0b0001, 0b11, 0,
1020                   (outs SPR:$Sd), (ins SPR:$Sm),
1021                   IIC_fpSQRT32, "vsqrt", ".f32\t$Sd, $Sm",
1022                   [(set SPR:$Sd, (fsqrt SPR:$Sm))]>,
1023              Sched<[WriteFPSQRT32]>;
1024
1025 def VSQRTH : AHuI<0b11101, 0b11, 0b0001, 0b11, 0,
1026                   (outs HPR:$Sd), (ins HPR:$Sm),
1027                   IIC_fpSQRT16, "vsqrt", ".f16\t$Sd, $Sm",
1028                   [(set HPR:$Sd, (fsqrt (f16 HPR:$Sm)))]>;
1029
1030 let hasSideEffects = 0 in {
1031 let isMoveReg = 1 in {
1032 def VMOVD  : ADuI<0b11101, 0b11, 0b0000, 0b01, 0,
1033                   (outs DPR:$Dd), (ins DPR:$Dm),
1034                   IIC_fpUNA64, "vmov", ".f64\t$Dd, $Dm", []>;
1035
1036 def VMOVS  : ASuI<0b11101, 0b11, 0b0000, 0b01, 0,
1037                   (outs SPR:$Sd), (ins SPR:$Sm),
1038                   IIC_fpUNA32, "vmov", ".f32\t$Sd, $Sm", []>;
1039 } // isMoveReg
1040
1041 let PostEncoderMethod = "", DecoderNamespace = "VFPV8", isUnpredicable = 1 in {
1042 def VMOVH  : ASuInp<0b11101, 0b11, 0b0000, 0b01, 0,
1043                   (outs SPR:$Sd), (ins SPR:$Sm),
1044                   IIC_fpUNA16, "vmovx.f16\t$Sd, $Sm", []>,
1045              Requires<[HasFullFP16]>;
1046
1047 def VINSH  : ASuInp<0b11101, 0b11, 0b0000, 0b11, 0,
1048                   (outs SPR:$Sd), (ins SPR:$Sm),
1049                   IIC_fpUNA16, "vins.f16\t$Sd, $Sm", []>,
1050              Requires<[HasFullFP16]>;
1051 } // PostEncoderMethod
1052 } // hasSideEffects
1053
1054 //===----------------------------------------------------------------------===//
1055 // FP <-> GPR Copies.  Int <-> FP Conversions.
1056 //
1057
1058 let isMoveReg = 1 in {
1059 def VMOVRS : AVConv2I<0b11100001, 0b1010,
1060                       (outs GPR:$Rt), (ins SPR:$Sn),
1061                       IIC_fpMOVSI, "vmov", "\t$Rt, $Sn",
1062                       [(set GPR:$Rt, (bitconvert SPR:$Sn))]>,
1063              Sched<[WriteFPMOV]> {
1064   // Instruction operands.
1065   bits<4> Rt;
1066   bits<5> Sn;
1067
1068   // Encode instruction operands.
1069   let Inst{19-16} = Sn{4-1};
1070   let Inst{7}     = Sn{0};
1071   let Inst{15-12} = Rt;
1072
1073   let Inst{6-5}   = 0b00;
1074   let Inst{3-0}   = 0b0000;
1075
1076   // Some single precision VFP instructions may be executed on both NEON and VFP
1077   // pipelines.
1078   let D = VFPNeonDomain;
1079 }
1080
1081 // Bitcast i32 -> f32.  NEON prefers to use VMOVDRR.
1082 def VMOVSR : AVConv4I<0b11100000, 0b1010,
1083                       (outs SPR:$Sn), (ins GPR:$Rt),
1084                       IIC_fpMOVIS, "vmov", "\t$Sn, $Rt",
1085                       [(set SPR:$Sn, (bitconvert GPR:$Rt))]>,
1086              Requires<[HasVFP2, UseVMOVSR]>,
1087              Sched<[WriteFPMOV]> {
1088   // Instruction operands.
1089   bits<5> Sn;
1090   bits<4> Rt;
1091
1092   // Encode instruction operands.
1093   let Inst{19-16} = Sn{4-1};
1094   let Inst{7}     = Sn{0};
1095   let Inst{15-12} = Rt;
1096
1097   let Inst{6-5}   = 0b00;
1098   let Inst{3-0}   = 0b0000;
1099
1100   // Some single precision VFP instructions may be executed on both NEON and VFP
1101   // pipelines.
1102   let D = VFPNeonDomain;
1103 }
1104 } // isMoveReg
1105 def : Pat<(arm_vmovsr GPR:$Rt), (VMOVSR GPR:$Rt)>, Requires<[HasVFP2, UseVMOVSR]>;
1106
1107 let hasSideEffects = 0 in {
1108 def VMOVRRD  : AVConv3I<0b11000101, 0b1011,
1109                         (outs GPR:$Rt, GPR:$Rt2), (ins DPR:$Dm),
1110                         IIC_fpMOVDI, "vmov", "\t$Rt, $Rt2, $Dm",
1111                  [(set GPR:$Rt, GPR:$Rt2, (arm_fmrrd DPR:$Dm))]>,
1112                Sched<[WriteFPMOV]> {
1113   // Instruction operands.
1114   bits<5> Dm;
1115   bits<4> Rt;
1116   bits<4> Rt2;
1117
1118   // Encode instruction operands.
1119   let Inst{3-0}   = Dm{3-0};
1120   let Inst{5}     = Dm{4};
1121   let Inst{15-12} = Rt;
1122   let Inst{19-16} = Rt2;
1123
1124   let Inst{7-6} = 0b00;
1125
1126   // Some single precision VFP instructions may be executed on both NEON and VFP
1127   // pipelines.
1128   let D = VFPNeonDomain;
1129
1130   // This instruction is equivalent to
1131   // $Rt = EXTRACT_SUBREG $Dm, ssub_0
1132   // $Rt2 = EXTRACT_SUBREG $Dm, ssub_1
1133   let isExtractSubreg = 1;
1134 }
1135
1136 def VMOVRRS  : AVConv3I<0b11000101, 0b1010,
1137                       (outs GPR:$Rt, GPR:$Rt2), (ins SPR:$src1, SPR:$src2),
1138                  IIC_fpMOVDI, "vmov", "\t$Rt, $Rt2, $src1, $src2",
1139                  [/* For disassembly only; pattern left blank */]>,
1140                Sched<[WriteFPMOV]> {
1141   bits<5> src1;
1142   bits<4> Rt;
1143   bits<4> Rt2;
1144
1145   // Encode instruction operands.
1146   let Inst{3-0}   = src1{4-1};
1147   let Inst{5}     = src1{0};
1148   let Inst{15-12} = Rt;
1149   let Inst{19-16} = Rt2;
1150
1151   let Inst{7-6} = 0b00;
1152
1153   // Some single precision VFP instructions may be executed on both NEON and VFP
1154   // pipelines.
1155   let D = VFPNeonDomain;
1156   let DecoderMethod = "DecodeVMOVRRS";
1157 }
1158 } // hasSideEffects
1159
1160 // FMDHR: GPR -> SPR
1161 // FMDLR: GPR -> SPR
1162
1163 def VMOVDRR : AVConv5I<0b11000100, 0b1011,
1164                       (outs DPR:$Dm), (ins GPR:$Rt, GPR:$Rt2),
1165                       IIC_fpMOVID, "vmov", "\t$Dm, $Rt, $Rt2",
1166                       [(set DPR:$Dm, (arm_fmdrr GPR:$Rt, GPR:$Rt2))]>,
1167               Sched<[WriteFPMOV]> {
1168   // Instruction operands.
1169   bits<5> Dm;
1170   bits<4> Rt;
1171   bits<4> Rt2;
1172
1173   // Encode instruction operands.
1174   let Inst{3-0}   = Dm{3-0};
1175   let Inst{5}     = Dm{4};
1176   let Inst{15-12} = Rt;
1177   let Inst{19-16} = Rt2;
1178
1179   let Inst{7-6}   = 0b00;
1180
1181   // Some single precision VFP instructions may be executed on both NEON and VFP
1182   // pipelines.
1183   let D = VFPNeonDomain;
1184
1185   // This instruction is equivalent to
1186   // $Dm = REG_SEQUENCE $Rt, ssub_0, $Rt2, ssub_1
1187   let isRegSequence = 1;
1188 }
1189
1190 // Hoist an fabs or a fneg of a value coming from integer registers
1191 // and do the fabs/fneg on the integer value. This is never a lose
1192 // and could enable the conversion to float to be removed completely.
1193 def : Pat<(fabs (arm_fmdrr GPR:$Rl, GPR:$Rh)),
1194           (VMOVDRR GPR:$Rl, (BFC GPR:$Rh, (i32 0x7FFFFFFF)))>,
1195       Requires<[IsARM, HasV6T2]>;
1196 def : Pat<(fabs (arm_fmdrr GPR:$Rl, GPR:$Rh)),
1197           (VMOVDRR GPR:$Rl, (t2BFC GPR:$Rh, (i32 0x7FFFFFFF)))>,
1198       Requires<[IsThumb2, HasV6T2]>;
1199 def : Pat<(fneg (arm_fmdrr GPR:$Rl, GPR:$Rh)),
1200           (VMOVDRR GPR:$Rl, (EORri GPR:$Rh, (i32 0x80000000)))>,
1201       Requires<[IsARM]>;
1202 def : Pat<(fneg (arm_fmdrr GPR:$Rl, GPR:$Rh)),
1203           (VMOVDRR GPR:$Rl, (t2EORri GPR:$Rh, (i32 0x80000000)))>,
1204       Requires<[IsThumb2]>;
1205
1206 let hasSideEffects = 0 in
1207 def VMOVSRR : AVConv5I<0b11000100, 0b1010,
1208                      (outs SPR:$dst1, SPR:$dst2), (ins GPR:$src1, GPR:$src2),
1209                 IIC_fpMOVID, "vmov", "\t$dst1, $dst2, $src1, $src2",
1210                 [/* For disassembly only; pattern left blank */]>,
1211               Sched<[WriteFPMOV]> {
1212   // Instruction operands.
1213   bits<5> dst1;
1214   bits<4> src1;
1215   bits<4> src2;
1216
1217   // Encode instruction operands.
1218   let Inst{3-0}   = dst1{4-1};
1219   let Inst{5}     = dst1{0};
1220   let Inst{15-12} = src1;
1221   let Inst{19-16} = src2;
1222
1223   let Inst{7-6} = 0b00;
1224
1225   // Some single precision VFP instructions may be executed on both NEON and VFP
1226   // pipelines.
1227   let D = VFPNeonDomain;
1228
1229   let DecoderMethod = "DecodeVMOVSRR";
1230 }
1231
1232 // Move H->R, clearing top 16 bits
1233 def VMOVRH : AVConv2I<0b11100001, 0b1001,
1234                       (outs GPR:$Rt), (ins HPR:$Sn),
1235                       IIC_fpMOVSI, "vmov", ".f16\t$Rt, $Sn",
1236                       [(set GPR:$Rt, (arm_vmovrh HPR:$Sn))]>,
1237              Requires<[HasFullFP16]>,
1238              Sched<[WriteFPMOV]> {
1239   // Instruction operands.
1240   bits<4> Rt;
1241   bits<5> Sn;
1242
1243   // Encode instruction operands.
1244   let Inst{19-16} = Sn{4-1};
1245   let Inst{7}     = Sn{0};
1246   let Inst{15-12} = Rt;
1247
1248   let Inst{6-5}   = 0b00;
1249   let Inst{3-0}   = 0b0000;
1250
1251   let isUnpredicable = 1;
1252 }
1253
1254 // Move R->H, clearing top 16 bits
1255 def VMOVHR : AVConv4I<0b11100000, 0b1001,
1256                       (outs HPR:$Sn), (ins GPR:$Rt),
1257                       IIC_fpMOVIS, "vmov", ".f16\t$Sn, $Rt",
1258                       [(set HPR:$Sn, (arm_vmovhr GPR:$Rt))]>,
1259              Requires<[HasFullFP16]>,
1260              Sched<[WriteFPMOV]> {
1261   // Instruction operands.
1262   bits<5> Sn;
1263   bits<4> Rt;
1264
1265   // Encode instruction operands.
1266   let Inst{19-16} = Sn{4-1};
1267   let Inst{7}     = Sn{0};
1268   let Inst{15-12} = Rt;
1269
1270   let Inst{6-5}   = 0b00;
1271   let Inst{3-0}   = 0b0000;
1272
1273   let isUnpredicable = 1;
1274 }
1275
1276 // FMRDH: SPR -> GPR
1277 // FMRDL: SPR -> GPR
1278 // FMRRS: SPR -> GPR
1279 // FMRX:  SPR system reg -> GPR
1280 // FMSRR: GPR -> SPR
1281 // FMXR:  GPR -> VFP system reg
1282
1283
1284 // Int -> FP:
1285
1286 class AVConv1IDs_Encode<bits<5> opcod1, bits<2> opcod2, bits<4> opcod3,
1287                         bits<4> opcod4, dag oops, dag iops,
1288                         InstrItinClass itin, string opc, string asm,
1289                         list<dag> pattern>
1290   : AVConv1I<opcod1, opcod2, opcod3, opcod4, oops, iops, itin, opc, asm,
1291              pattern> {
1292   // Instruction operands.
1293   bits<5> Dd;
1294   bits<5> Sm;
1295
1296   // Encode instruction operands.
1297   let Inst{3-0}   = Sm{4-1};
1298   let Inst{5}     = Sm{0};
1299   let Inst{15-12} = Dd{3-0};
1300   let Inst{22}    = Dd{4};
1301
1302   let Predicates = [HasVFP2, HasDPVFP];
1303 }
1304
1305 class AVConv1InSs_Encode<bits<5> opcod1, bits<2> opcod2, bits<4> opcod3,
1306                          bits<4> opcod4, dag oops, dag iops,InstrItinClass itin,
1307                          string opc, string asm, list<dag> pattern>
1308   : AVConv1In<opcod1, opcod2, opcod3, opcod4, oops, iops, itin, opc, asm,
1309               pattern> {
1310   // Instruction operands.
1311   bits<5> Sd;
1312   bits<5> Sm;
1313
1314   // Encode instruction operands.
1315   let Inst{3-0}   = Sm{4-1};
1316   let Inst{5}     = Sm{0};
1317   let Inst{15-12} = Sd{4-1};
1318   let Inst{22}    = Sd{0};
1319 }
1320
1321 class AVConv1IHs_Encode<bits<5> opcod1, bits<2> opcod2, bits<4> opcod3,
1322                         bits<4> opcod4, dag oops, dag iops,
1323                         InstrItinClass itin, string opc, string asm,
1324                         list<dag> pattern>
1325   : AVConv1I<opcod1, opcod2, opcod3, opcod4, oops, iops, itin, opc, asm,
1326              pattern> {
1327   // Instruction operands.
1328   bits<5> Sd;
1329   bits<5> Sm;
1330
1331   // Encode instruction operands.
1332   let Inst{3-0}   = Sm{4-1};
1333   let Inst{5}     = Sm{0};
1334   let Inst{15-12} = Sd{4-1};
1335   let Inst{22}    = Sd{0};
1336
1337   let Predicates = [HasFullFP16];
1338 }
1339
1340 def VSITOD : AVConv1IDs_Encode<0b11101, 0b11, 0b1000, 0b1011,
1341                                (outs DPR:$Dd), (ins SPR:$Sm),
1342                                IIC_fpCVTID, "vcvt", ".f64.s32\t$Dd, $Sm",
1343                                []>,
1344              Sched<[WriteFPCVT]> {
1345   let Inst{7} = 1; // s32
1346 }
1347
1348 let Predicates=[HasVFP2, HasDPVFP] in {
1349   def : VFPPat<(f64 (sint_to_fp GPR:$a)),
1350                (VSITOD (COPY_TO_REGCLASS GPR:$a, SPR))>;
1351
1352   def : VFPPat<(f64 (sint_to_fp (i32 (alignedload32 addrmode5:$a)))),
1353                (VSITOD (VLDRS addrmode5:$a))>;
1354 }
1355
1356 def VSITOS : AVConv1InSs_Encode<0b11101, 0b11, 0b1000, 0b1010,
1357                                 (outs SPR:$Sd),(ins SPR:$Sm),
1358                                 IIC_fpCVTIS, "vcvt", ".f32.s32\t$Sd, $Sm",
1359                                 []>,
1360              Sched<[WriteFPCVT]> {
1361   let Inst{7} = 1; // s32
1362
1363   // Some single precision VFP instructions may be executed on both NEON and
1364   // VFP pipelines on A8.
1365   let D = VFPNeonA8Domain;
1366 }
1367
1368 def : VFPNoNEONPat<(f32 (sint_to_fp GPR:$a)),
1369                    (VSITOS (COPY_TO_REGCLASS GPR:$a, SPR))>;
1370
1371 def : VFPNoNEONPat<(f32 (sint_to_fp (i32 (alignedload32 addrmode5:$a)))),
1372                    (VSITOS (VLDRS addrmode5:$a))>;
1373
1374 def VSITOH : AVConv1IHs_Encode<0b11101, 0b11, 0b1000, 0b1001,
1375                                (outs HPR:$Sd), (ins SPR:$Sm),
1376                                IIC_fpCVTIH, "vcvt", ".f16.s32\t$Sd, $Sm",
1377                                []>,
1378              Sched<[WriteFPCVT]> {
1379   let Inst{7} = 1; // s32
1380   let isUnpredicable = 1;
1381 }
1382
1383 def : VFPNoNEONPat<(f16 (sint_to_fp GPR:$a)),
1384                    (VSITOH (COPY_TO_REGCLASS GPR:$a, SPR))>;
1385
1386 def VUITOD : AVConv1IDs_Encode<0b11101, 0b11, 0b1000, 0b1011,
1387                                (outs DPR:$Dd), (ins SPR:$Sm),
1388                                IIC_fpCVTID, "vcvt", ".f64.u32\t$Dd, $Sm",
1389                                []>,
1390              Sched<[WriteFPCVT]> {
1391   let Inst{7} = 0; // u32
1392 }
1393
1394 let Predicates=[HasVFP2, HasDPVFP] in {
1395   def : VFPPat<(f64 (uint_to_fp GPR:$a)),
1396                (VUITOD (COPY_TO_REGCLASS GPR:$a, SPR))>;
1397
1398   def : VFPPat<(f64 (uint_to_fp (i32 (alignedload32 addrmode5:$a)))),
1399                (VUITOD (VLDRS addrmode5:$a))>;
1400 }
1401
1402 def VUITOS : AVConv1InSs_Encode<0b11101, 0b11, 0b1000, 0b1010,
1403                                 (outs SPR:$Sd), (ins SPR:$Sm),
1404                                 IIC_fpCVTIS, "vcvt", ".f32.u32\t$Sd, $Sm",
1405                                 []>,
1406              Sched<[WriteFPCVT]> {
1407   let Inst{7} = 0; // u32
1408
1409   // Some single precision VFP instructions may be executed on both NEON and
1410   // VFP pipelines on A8.
1411   let D = VFPNeonA8Domain;
1412 }
1413
1414 def : VFPNoNEONPat<(f32 (uint_to_fp GPR:$a)),
1415                    (VUITOS (COPY_TO_REGCLASS GPR:$a, SPR))>;
1416
1417 def : VFPNoNEONPat<(f32 (uint_to_fp (i32 (alignedload32 addrmode5:$a)))),
1418                    (VUITOS (VLDRS addrmode5:$a))>;
1419
1420 def VUITOH : AVConv1IHs_Encode<0b11101, 0b11, 0b1000, 0b1001,
1421                                 (outs HPR:$Sd), (ins SPR:$Sm),
1422                                 IIC_fpCVTIH, "vcvt", ".f16.u32\t$Sd, $Sm",
1423                                 []>,
1424              Sched<[WriteFPCVT]> {
1425   let Inst{7} = 0; // u32
1426   let isUnpredicable = 1;
1427 }
1428
1429 def : VFPNoNEONPat<(f16 (uint_to_fp GPR:$a)),
1430                    (VUITOH (COPY_TO_REGCLASS GPR:$a, SPR))>;
1431
1432 // FP -> Int:
1433
1434 class AVConv1IsD_Encode<bits<5> opcod1, bits<2> opcod2, bits<4> opcod3,
1435                         bits<4> opcod4, dag oops, dag iops,
1436                         InstrItinClass itin, string opc, string asm,
1437                         list<dag> pattern>
1438   : AVConv1I<opcod1, opcod2, opcod3, opcod4, oops, iops, itin, opc, asm,
1439              pattern> {
1440   // Instruction operands.
1441   bits<5> Sd;
1442   bits<5> Dm;
1443
1444   // Encode instruction operands.
1445   let Inst{3-0}   = Dm{3-0};
1446   let Inst{5}     = Dm{4};
1447   let Inst{15-12} = Sd{4-1};
1448   let Inst{22}    = Sd{0};
1449
1450   let Predicates = [HasVFP2, HasDPVFP];
1451 }
1452
1453 class AVConv1InsS_Encode<bits<5> opcod1, bits<2> opcod2, bits<4> opcod3,
1454                          bits<4> opcod4, dag oops, dag iops,
1455                          InstrItinClass itin, string opc, string asm,
1456                          list<dag> pattern>
1457   : AVConv1In<opcod1, opcod2, opcod3, opcod4, oops, iops, itin, opc, asm,
1458               pattern> {
1459   // Instruction operands.
1460   bits<5> Sd;
1461   bits<5> Sm;
1462
1463   // Encode instruction operands.
1464   let Inst{3-0}   = Sm{4-1};
1465   let Inst{5}     = Sm{0};
1466   let Inst{15-12} = Sd{4-1};
1467   let Inst{22}    = Sd{0};
1468 }
1469
1470 class AVConv1IsH_Encode<bits<5> opcod1, bits<2> opcod2, bits<4> opcod3,
1471                          bits<4> opcod4, dag oops, dag iops,
1472                          InstrItinClass itin, string opc, string asm,
1473                          list<dag> pattern>
1474   : AVConv1I<opcod1, opcod2, opcod3, opcod4, oops, iops, itin, opc, asm,
1475               pattern> {
1476   // Instruction operands.
1477   bits<5> Sd;
1478   bits<5> Sm;
1479
1480   // Encode instruction operands.
1481   let Inst{3-0}   = Sm{4-1};
1482   let Inst{5}     = Sm{0};
1483   let Inst{15-12} = Sd{4-1};
1484   let Inst{22}    = Sd{0};
1485
1486   let Predicates = [HasFullFP16];
1487 }
1488
1489 // Always set Z bit in the instruction, i.e. "round towards zero" variants.
1490 def VTOSIZD : AVConv1IsD_Encode<0b11101, 0b11, 0b1101, 0b1011,
1491                                 (outs SPR:$Sd), (ins DPR:$Dm),
1492                                 IIC_fpCVTDI, "vcvt", ".s32.f64\t$Sd, $Dm",
1493                                 []>,
1494               Sched<[WriteFPCVT]> {
1495   let Inst{7} = 1; // Z bit
1496 }
1497
1498 let Predicates=[HasVFP2, HasDPVFP] in {
1499   def : VFPPat<(i32 (fp_to_sint (f64 DPR:$a))),
1500                (COPY_TO_REGCLASS (VTOSIZD DPR:$a), GPR)>;
1501
1502   def : VFPPat<(alignedstore32 (i32 (fp_to_sint (f64 DPR:$a))), addrmode5:$ptr),
1503                (VSTRS (VTOSIZD DPR:$a), addrmode5:$ptr)>;
1504 }
1505
1506 def VTOSIZS : AVConv1InsS_Encode<0b11101, 0b11, 0b1101, 0b1010,
1507                                  (outs SPR:$Sd), (ins SPR:$Sm),
1508                                  IIC_fpCVTSI, "vcvt", ".s32.f32\t$Sd, $Sm",
1509                                  []>,
1510               Sched<[WriteFPCVT]> {
1511   let Inst{7} = 1; // Z bit
1512
1513   // Some single precision VFP instructions may be executed on both NEON and
1514   // VFP pipelines on A8.
1515   let D = VFPNeonA8Domain;
1516 }
1517
1518 def : VFPNoNEONPat<(i32 (fp_to_sint SPR:$a)),
1519                    (COPY_TO_REGCLASS (VTOSIZS SPR:$a), GPR)>;
1520
1521 def : VFPNoNEONPat<(alignedstore32 (i32 (fp_to_sint (f32 SPR:$a))),
1522                                    addrmode5:$ptr),
1523                    (VSTRS (VTOSIZS SPR:$a), addrmode5:$ptr)>;
1524
1525 def VTOSIZH : AVConv1IsH_Encode<0b11101, 0b11, 0b1101, 0b1001,
1526                                  (outs SPR:$Sd), (ins HPR:$Sm),
1527                                  IIC_fpCVTHI, "vcvt", ".s32.f16\t$Sd, $Sm",
1528                                  []>,
1529               Sched<[WriteFPCVT]> {
1530   let Inst{7} = 1; // Z bit
1531   let isUnpredicable = 1;
1532 }
1533
1534 def : VFPNoNEONPat<(i32 (fp_to_sint HPR:$a)),
1535                    (COPY_TO_REGCLASS (VTOSIZH HPR:$a), GPR)>;
1536
1537 def VTOUIZD : AVConv1IsD_Encode<0b11101, 0b11, 0b1100, 0b1011,
1538                                (outs SPR:$Sd), (ins DPR:$Dm),
1539                                IIC_fpCVTDI, "vcvt", ".u32.f64\t$Sd, $Dm",
1540                                []>,
1541               Sched<[WriteFPCVT]> {
1542   let Inst{7} = 1; // Z bit
1543 }
1544
1545 let Predicates=[HasVFP2, HasDPVFP] in {
1546   def : VFPPat<(i32 (fp_to_uint (f64 DPR:$a))),
1547                (COPY_TO_REGCLASS (VTOUIZD DPR:$a), GPR)>;
1548
1549   def : VFPPat<(alignedstore32 (i32 (fp_to_uint (f64 DPR:$a))), addrmode5:$ptr),
1550                (VSTRS (VTOUIZD DPR:$a), addrmode5:$ptr)>;
1551 }
1552
1553 def VTOUIZS : AVConv1InsS_Encode<0b11101, 0b11, 0b1100, 0b1010,
1554                                  (outs SPR:$Sd), (ins SPR:$Sm),
1555                                  IIC_fpCVTSI, "vcvt", ".u32.f32\t$Sd, $Sm",
1556                                  []>,
1557               Sched<[WriteFPCVT]> {
1558   let Inst{7} = 1; // Z bit
1559
1560   // Some single precision VFP instructions may be executed on both NEON and
1561   // VFP pipelines on A8.
1562   let D = VFPNeonA8Domain;
1563 }
1564
1565 def : VFPNoNEONPat<(i32 (fp_to_uint SPR:$a)),
1566                    (COPY_TO_REGCLASS (VTOUIZS SPR:$a), GPR)>;
1567
1568 def : VFPNoNEONPat<(alignedstore32 (i32 (fp_to_uint (f32 SPR:$a))),
1569                                    addrmode5:$ptr),
1570                   (VSTRS (VTOUIZS SPR:$a), addrmode5:$ptr)>;
1571
1572 def VTOUIZH : AVConv1IsH_Encode<0b11101, 0b11, 0b1100, 0b1001,
1573                                  (outs SPR:$Sd), (ins HPR:$Sm),
1574                                  IIC_fpCVTHI, "vcvt", ".u32.f16\t$Sd, $Sm",
1575                                  []>,
1576               Sched<[WriteFPCVT]> {
1577   let Inst{7} = 1; // Z bit
1578   let isUnpredicable = 1;
1579 }
1580
1581 def : VFPNoNEONPat<(i32 (fp_to_uint HPR:$a)),
1582                    (COPY_TO_REGCLASS (VTOUIZH HPR:$a), GPR)>;
1583
1584 // And the Z bit '0' variants, i.e. use the rounding mode specified by FPSCR.
1585 let Uses = [FPSCR] in {
1586 def VTOSIRD : AVConv1IsD_Encode<0b11101, 0b11, 0b1101, 0b1011,
1587                                 (outs SPR:$Sd), (ins DPR:$Dm),
1588                                 IIC_fpCVTDI, "vcvtr", ".s32.f64\t$Sd, $Dm",
1589                                 [(set SPR:$Sd, (int_arm_vcvtr (f64 DPR:$Dm)))]>,
1590               Sched<[WriteFPCVT]> {
1591   let Inst{7} = 0; // Z bit
1592 }
1593
1594 def VTOSIRS : AVConv1InsS_Encode<0b11101, 0b11, 0b1101, 0b1010,
1595                                  (outs SPR:$Sd), (ins SPR:$Sm),
1596                                  IIC_fpCVTSI, "vcvtr", ".s32.f32\t$Sd, $Sm",
1597                                  [(set SPR:$Sd, (int_arm_vcvtr SPR:$Sm))]>,
1598               Sched<[WriteFPCVT]> {
1599   let Inst{7} = 0; // Z bit
1600 }
1601
1602 def VTOSIRH : AVConv1IsH_Encode<0b11101, 0b11, 0b1101, 0b1001,
1603                                  (outs SPR:$Sd), (ins SPR:$Sm),
1604                                  IIC_fpCVTHI, "vcvtr", ".s32.f16\t$Sd, $Sm",
1605                                  []>,
1606               Sched<[WriteFPCVT]> {
1607   let Inst{7} = 0; // Z bit
1608   let isUnpredicable = 1;
1609 }
1610
1611 def VTOUIRD : AVConv1IsD_Encode<0b11101, 0b11, 0b1100, 0b1011,
1612                                 (outs SPR:$Sd), (ins DPR:$Dm),
1613                                 IIC_fpCVTDI, "vcvtr", ".u32.f64\t$Sd, $Dm",
1614                                 [(set SPR:$Sd, (int_arm_vcvtru(f64 DPR:$Dm)))]>,
1615               Sched<[WriteFPCVT]> {
1616   let Inst{7} = 0; // Z bit
1617 }
1618
1619 def VTOUIRS : AVConv1InsS_Encode<0b11101, 0b11, 0b1100, 0b1010,
1620                                  (outs SPR:$Sd), (ins SPR:$Sm),
1621                                  IIC_fpCVTSI, "vcvtr", ".u32.f32\t$Sd, $Sm",
1622                                  [(set SPR:$Sd, (int_arm_vcvtru SPR:$Sm))]>,
1623               Sched<[WriteFPCVT]> {
1624   let Inst{7} = 0; // Z bit
1625 }
1626
1627 def VTOUIRH : AVConv1IsH_Encode<0b11101, 0b11, 0b1100, 0b1001,
1628                                  (outs SPR:$Sd), (ins SPR:$Sm),
1629                                  IIC_fpCVTHI, "vcvtr", ".u32.f16\t$Sd, $Sm",
1630                                  []>,
1631               Sched<[WriteFPCVT]> {
1632   let Inst{7} = 0; // Z bit
1633   let isUnpredicable = 1;
1634 }
1635 }
1636
1637 // v8.3-a Javascript Convert to Signed fixed-point
1638 def VJCVT : AVConv1IsD_Encode<0b11101, 0b11, 0b1001, 0b1011,
1639                                 (outs SPR:$Sd), (ins DPR:$Dm),
1640                                 IIC_fpCVTDI, "vjcvt", ".s32.f64\t$Sd, $Dm",
1641                                 []>,
1642             Requires<[HasFPARMv8, HasV8_3a]> {
1643   let Inst{7} = 1; // Z bit
1644 }
1645
1646 // Convert between floating-point and fixed-point
1647 // Data type for fixed-point naming convention:
1648 //   S16 (U=0, sx=0) -> SH
1649 //   U16 (U=1, sx=0) -> UH
1650 //   S32 (U=0, sx=1) -> SL
1651 //   U32 (U=1, sx=1) -> UL
1652
1653 let Constraints = "$a = $dst" in {
1654
1655 // FP to Fixed-Point:
1656
1657 // Single Precision register
1658 class AVConv1XInsS_Encode<bits<5> op1, bits<2> op2, bits<4> op3, bits<4> op4,
1659                           bit op5, dag oops, dag iops, InstrItinClass itin,
1660                           string opc, string asm, list<dag> pattern>
1661   : AVConv1XI<op1, op2, op3, op4, op5, oops, iops, itin, opc, asm, pattern> {
1662   bits<5> dst;
1663   // if dp_operation then UInt(D:Vd) else UInt(Vd:D);
1664   let Inst{22} = dst{0};
1665   let Inst{15-12} = dst{4-1};
1666 }
1667
1668 // Double Precision register
1669 class AVConv1XInsD_Encode<bits<5> op1, bits<2> op2, bits<4> op3, bits<4> op4,
1670                           bit op5, dag oops, dag iops, InstrItinClass itin,
1671                           string opc, string asm, list<dag> pattern>
1672   : AVConv1XI<op1, op2, op3, op4, op5, oops, iops, itin, opc, asm, pattern> {
1673   bits<5> dst;
1674   // if dp_operation then UInt(D:Vd) else UInt(Vd:D);
1675   let Inst{22} = dst{4};
1676   let Inst{15-12} = dst{3-0};
1677
1678   let Predicates = [HasVFP2, HasDPVFP];
1679 }
1680
1681 let isUnpredicable = 1 in {
1682
1683 def VTOSHH : AVConv1XInsS_Encode<0b11101, 0b11, 0b1110, 0b1001, 0,
1684                        (outs SPR:$dst), (ins SPR:$a, fbits16:$fbits),
1685                  IIC_fpCVTHI, "vcvt", ".s16.f16\t$dst, $a, $fbits", []>,
1686              Requires<[HasFullFP16]>,
1687              Sched<[WriteFPCVT]>;
1688
1689 def VTOUHH : AVConv1XInsS_Encode<0b11101, 0b11, 0b1111, 0b1001, 0,
1690                        (outs SPR:$dst), (ins SPR:$a, fbits16:$fbits),
1691                  IIC_fpCVTHI, "vcvt", ".u16.f16\t$dst, $a, $fbits", []>,
1692              Requires<[HasFullFP16]>,
1693              Sched<[WriteFPCVT]>;
1694
1695 def VTOSLH : AVConv1XInsS_Encode<0b11101, 0b11, 0b1110, 0b1001, 1,
1696                        (outs SPR:$dst), (ins SPR:$a, fbits32:$fbits),
1697                  IIC_fpCVTHI, "vcvt", ".s32.f16\t$dst, $a, $fbits", []>,
1698              Requires<[HasFullFP16]>,
1699              Sched<[WriteFPCVT]>;
1700
1701 def VTOULH : AVConv1XInsS_Encode<0b11101, 0b11, 0b1111, 0b1001, 1,
1702                        (outs SPR:$dst), (ins SPR:$a, fbits32:$fbits),
1703                  IIC_fpCVTHI, "vcvt", ".u32.f16\t$dst, $a, $fbits", []>,
1704              Requires<[HasFullFP16]>,
1705              Sched<[WriteFPCVT]>;
1706
1707 } // End of 'let isUnpredicable = 1 in'
1708
1709 def VTOSHS : AVConv1XInsS_Encode<0b11101, 0b11, 0b1110, 0b1010, 0,
1710                        (outs SPR:$dst), (ins SPR:$a, fbits16:$fbits),
1711                  IIC_fpCVTSI, "vcvt", ".s16.f32\t$dst, $a, $fbits", []>,
1712              Sched<[WriteFPCVT]> {
1713   // Some single precision VFP instructions may be executed on both NEON and
1714   // VFP pipelines on A8.
1715   let D = VFPNeonA8Domain;
1716 }
1717
1718 def VTOUHS : AVConv1XInsS_Encode<0b11101, 0b11, 0b1111, 0b1010, 0,
1719                        (outs SPR:$dst), (ins SPR:$a, fbits16:$fbits),
1720                  IIC_fpCVTSI, "vcvt", ".u16.f32\t$dst, $a, $fbits", []> {
1721   // Some single precision VFP instructions may be executed on both NEON and
1722   // VFP pipelines on A8.
1723   let D = VFPNeonA8Domain;
1724 }
1725
1726 def VTOSLS : AVConv1XInsS_Encode<0b11101, 0b11, 0b1110, 0b1010, 1,
1727                        (outs SPR:$dst), (ins SPR:$a, fbits32:$fbits),
1728                  IIC_fpCVTSI, "vcvt", ".s32.f32\t$dst, $a, $fbits", []> {
1729   // Some single precision VFP instructions may be executed on both NEON and
1730   // VFP pipelines on A8.
1731   let D = VFPNeonA8Domain;
1732 }
1733
1734 def VTOULS : AVConv1XInsS_Encode<0b11101, 0b11, 0b1111, 0b1010, 1,
1735                        (outs SPR:$dst), (ins SPR:$a, fbits32:$fbits),
1736                  IIC_fpCVTSI, "vcvt", ".u32.f32\t$dst, $a, $fbits", []> {
1737   // Some single precision VFP instructions may be executed on both NEON and
1738   // VFP pipelines on A8.
1739   let D = VFPNeonA8Domain;
1740 }
1741
1742 def VTOSHD : AVConv1XInsD_Encode<0b11101, 0b11, 0b1110, 0b1011, 0,
1743                        (outs DPR:$dst), (ins DPR:$a, fbits16:$fbits),
1744                  IIC_fpCVTDI, "vcvt", ".s16.f64\t$dst, $a, $fbits", []>,
1745              Sched<[WriteFPCVT]>;
1746
1747 def VTOUHD : AVConv1XInsD_Encode<0b11101, 0b11, 0b1111, 0b1011, 0,
1748                        (outs DPR:$dst), (ins DPR:$a, fbits16:$fbits),
1749                  IIC_fpCVTDI, "vcvt", ".u16.f64\t$dst, $a, $fbits", []>,
1750              Sched<[WriteFPCVT]>;
1751
1752 def VTOSLD : AVConv1XInsD_Encode<0b11101, 0b11, 0b1110, 0b1011, 1,
1753                        (outs DPR:$dst), (ins DPR:$a, fbits32:$fbits),
1754                  IIC_fpCVTDI, "vcvt", ".s32.f64\t$dst, $a, $fbits", []>,
1755              Sched<[WriteFPCVT]>;
1756
1757 def VTOULD : AVConv1XInsD_Encode<0b11101, 0b11, 0b1111, 0b1011, 1,
1758                        (outs DPR:$dst), (ins DPR:$a, fbits32:$fbits),
1759                  IIC_fpCVTDI, "vcvt", ".u32.f64\t$dst, $a, $fbits", []>,
1760              Sched<[WriteFPCVT]>;
1761
1762 // Fixed-Point to FP:
1763
1764 let isUnpredicable = 1 in {
1765
1766 def VSHTOH : AVConv1XInsS_Encode<0b11101, 0b11, 0b1010, 0b1001, 0,
1767                        (outs SPR:$dst), (ins SPR:$a, fbits16:$fbits),
1768                  IIC_fpCVTIH, "vcvt", ".f16.s16\t$dst, $a, $fbits", []>,
1769              Requires<[HasFullFP16]>,
1770              Sched<[WriteFPCVT]>;
1771
1772 def VUHTOH : AVConv1XInsS_Encode<0b11101, 0b11, 0b1011, 0b1001, 0,
1773                        (outs SPR:$dst), (ins SPR:$a, fbits16:$fbits),
1774                  IIC_fpCVTIH, "vcvt", ".f16.u16\t$dst, $a, $fbits", []>,
1775              Requires<[HasFullFP16]>,
1776              Sched<[WriteFPCVT]>;
1777
1778 def VSLTOH : AVConv1XInsS_Encode<0b11101, 0b11, 0b1010, 0b1001, 1,
1779                        (outs SPR:$dst), (ins SPR:$a, fbits32:$fbits),
1780                  IIC_fpCVTIH, "vcvt", ".f16.s32\t$dst, $a, $fbits", []>,
1781              Requires<[HasFullFP16]>,
1782              Sched<[WriteFPCVT]>;
1783
1784 def VULTOH : AVConv1XInsS_Encode<0b11101, 0b11, 0b1011, 0b1001, 1,
1785                        (outs SPR:$dst), (ins SPR:$a, fbits32:$fbits),
1786                  IIC_fpCVTIH, "vcvt", ".f16.u32\t$dst, $a, $fbits", []>,
1787              Requires<[HasFullFP16]>,
1788              Sched<[WriteFPCVT]>;
1789
1790 } // End of 'let isUnpredicable = 1 in'
1791
1792 def VSHTOS : AVConv1XInsS_Encode<0b11101, 0b11, 0b1010, 0b1010, 0,
1793                        (outs SPR:$dst), (ins SPR:$a, fbits16:$fbits),
1794                  IIC_fpCVTIS, "vcvt", ".f32.s16\t$dst, $a, $fbits", []>,
1795              Sched<[WriteFPCVT]> {
1796   // Some single precision VFP instructions may be executed on both NEON and
1797   // VFP pipelines on A8.
1798   let D = VFPNeonA8Domain;
1799 }
1800
1801 def VUHTOS : AVConv1XInsS_Encode<0b11101, 0b11, 0b1011, 0b1010, 0,
1802                        (outs SPR:$dst), (ins SPR:$a, fbits16:$fbits),
1803                  IIC_fpCVTIS, "vcvt", ".f32.u16\t$dst, $a, $fbits", []>,
1804              Sched<[WriteFPCVT]> {
1805   // Some single precision VFP instructions may be executed on both NEON and
1806   // VFP pipelines on A8.
1807   let D = VFPNeonA8Domain;
1808 }
1809
1810 def VSLTOS : AVConv1XInsS_Encode<0b11101, 0b11, 0b1010, 0b1010, 1,
1811                        (outs SPR:$dst), (ins SPR:$a, fbits32:$fbits),
1812                  IIC_fpCVTIS, "vcvt", ".f32.s32\t$dst, $a, $fbits", []>,
1813              Sched<[WriteFPCVT]> {
1814   // Some single precision VFP instructions may be executed on both NEON and
1815   // VFP pipelines on A8.
1816   let D = VFPNeonA8Domain;
1817 }
1818
1819 def VULTOS : AVConv1XInsS_Encode<0b11101, 0b11, 0b1011, 0b1010, 1,
1820                        (outs SPR:$dst), (ins SPR:$a, fbits32:$fbits),
1821                  IIC_fpCVTIS, "vcvt", ".f32.u32\t$dst, $a, $fbits", []>,
1822              Sched<[WriteFPCVT]> {
1823   // Some single precision VFP instructions may be executed on both NEON and
1824   // VFP pipelines on A8.
1825   let D = VFPNeonA8Domain;
1826 }
1827
1828 def VSHTOD : AVConv1XInsD_Encode<0b11101, 0b11, 0b1010, 0b1011, 0,
1829                        (outs DPR:$dst), (ins DPR:$a, fbits16:$fbits),
1830                  IIC_fpCVTID, "vcvt", ".f64.s16\t$dst, $a, $fbits", []>,
1831              Sched<[WriteFPCVT]>;
1832
1833 def VUHTOD : AVConv1XInsD_Encode<0b11101, 0b11, 0b1011, 0b1011, 0,
1834                        (outs DPR:$dst), (ins DPR:$a, fbits16:$fbits),
1835                  IIC_fpCVTID, "vcvt", ".f64.u16\t$dst, $a, $fbits", []>,
1836              Sched<[WriteFPCVT]>;
1837
1838 def VSLTOD : AVConv1XInsD_Encode<0b11101, 0b11, 0b1010, 0b1011, 1,
1839                        (outs DPR:$dst), (ins DPR:$a, fbits32:$fbits),
1840                  IIC_fpCVTID, "vcvt", ".f64.s32\t$dst, $a, $fbits", []>,
1841              Sched<[WriteFPCVT]>;
1842
1843 def VULTOD : AVConv1XInsD_Encode<0b11101, 0b11, 0b1011, 0b1011, 1,
1844                        (outs DPR:$dst), (ins DPR:$a, fbits32:$fbits),
1845                  IIC_fpCVTID, "vcvt", ".f64.u32\t$dst, $a, $fbits", []>,
1846              Sched<[WriteFPCVT]>;
1847
1848 } // End of 'let Constraints = "$a = $dst" in'
1849
1850 //===----------------------------------------------------------------------===//
1851 // FP Multiply-Accumulate Operations.
1852 //
1853
1854 def VMLAD : ADbI<0b11100, 0b00, 0, 0,
1855                  (outs DPR:$Dd), (ins DPR:$Ddin, DPR:$Dn, DPR:$Dm),
1856                  IIC_fpMAC64, "vmla", ".f64\t$Dd, $Dn, $Dm",
1857                  [(set DPR:$Dd, (fadd_mlx (fmul_su DPR:$Dn, DPR:$Dm),
1858                                           (f64 DPR:$Ddin)))]>,
1859               RegConstraint<"$Ddin = $Dd">,
1860               Requires<[HasVFP2,HasDPVFP,UseFPVMLx]>,
1861               Sched<[WriteFPMAC64, ReadFPMAC, ReadFPMUL, ReadFPMUL]>;
1862
1863 def VMLAS : ASbIn<0b11100, 0b00, 0, 0,
1864                   (outs SPR:$Sd), (ins SPR:$Sdin, SPR:$Sn, SPR:$Sm),
1865                   IIC_fpMAC32, "vmla", ".f32\t$Sd, $Sn, $Sm",
1866                   [(set SPR:$Sd, (fadd_mlx (fmul_su SPR:$Sn, SPR:$Sm),
1867                                            SPR:$Sdin))]>,
1868               RegConstraint<"$Sdin = $Sd">,
1869               Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]>,
1870               Sched<[WriteFPMAC32, ReadFPMAC, ReadFPMUL, ReadFPMUL]> {
1871   // Some single precision VFP instructions may be executed on both NEON and
1872   // VFP pipelines on A8.
1873   let D = VFPNeonA8Domain;
1874 }
1875
1876 def VMLAH : AHbI<0b11100, 0b00, 0, 0,
1877                   (outs HPR:$Sd), (ins HPR:$Sdin, HPR:$Sn, HPR:$Sm),
1878                   IIC_fpMAC16, "vmla", ".f16\t$Sd, $Sn, $Sm",
1879                   [(set HPR:$Sd, (fadd_mlx (fmul_su HPR:$Sn, HPR:$Sm),
1880                                            HPR:$Sdin))]>,
1881               RegConstraint<"$Sdin = $Sd">,
1882               Requires<[HasFullFP16,UseFPVMLx]>;
1883
1884 def : Pat<(fadd_mlx DPR:$dstin, (fmul_su DPR:$a, (f64 DPR:$b))),
1885           (VMLAD DPR:$dstin, DPR:$a, DPR:$b)>,
1886           Requires<[HasVFP2,HasDPVFP,UseFPVMLx]>;
1887 def : Pat<(fadd_mlx SPR:$dstin, (fmul_su SPR:$a, SPR:$b)),
1888           (VMLAS SPR:$dstin, SPR:$a, SPR:$b)>,
1889           Requires<[HasVFP2,DontUseNEONForFP, UseFPVMLx]>;
1890 def : Pat<(fadd_mlx HPR:$dstin, (fmul_su HPR:$a, HPR:$b)),
1891           (VMLAH HPR:$dstin, HPR:$a, HPR:$b)>,
1892           Requires<[HasFullFP16,DontUseNEONForFP, UseFPVMLx]>;
1893
1894
1895 def VMLSD : ADbI<0b11100, 0b00, 1, 0,
1896                  (outs DPR:$Dd), (ins DPR:$Ddin, DPR:$Dn, DPR:$Dm),
1897                  IIC_fpMAC64, "vmls", ".f64\t$Dd, $Dn, $Dm",
1898                  [(set DPR:$Dd, (fadd_mlx (fneg (fmul_su DPR:$Dn,DPR:$Dm)),
1899                                           (f64 DPR:$Ddin)))]>,
1900               RegConstraint<"$Ddin = $Dd">,
1901               Requires<[HasVFP2,HasDPVFP,UseFPVMLx]>,
1902               Sched<[WriteFPMAC64, ReadFPMAC, ReadFPMUL, ReadFPMUL]>;
1903
1904 def VMLSS : ASbIn<0b11100, 0b00, 1, 0,
1905                   (outs SPR:$Sd), (ins SPR:$Sdin, SPR:$Sn, SPR:$Sm),
1906                   IIC_fpMAC32, "vmls", ".f32\t$Sd, $Sn, $Sm",
1907                   [(set SPR:$Sd, (fadd_mlx (fneg (fmul_su SPR:$Sn, SPR:$Sm)),
1908                                            SPR:$Sdin))]>,
1909               RegConstraint<"$Sdin = $Sd">,
1910               Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]>,
1911               Sched<[WriteFPMAC32, ReadFPMAC, ReadFPMUL, ReadFPMUL]> {
1912   // Some single precision VFP instructions may be executed on both NEON and
1913   // VFP pipelines on A8.
1914   let D = VFPNeonA8Domain;
1915 }
1916
1917 def VMLSH : AHbI<0b11100, 0b00, 1, 0,
1918                   (outs HPR:$Sd), (ins HPR:$Sdin, HPR:$Sn, HPR:$Sm),
1919                   IIC_fpMAC16, "vmls", ".f16\t$Sd, $Sn, $Sm",
1920                   [(set HPR:$Sd, (fadd_mlx (fneg (fmul_su HPR:$Sn, HPR:$Sm)),
1921                                            HPR:$Sdin))]>,
1922               RegConstraint<"$Sdin = $Sd">,
1923               Requires<[HasFullFP16,UseFPVMLx]>;
1924
1925 def : Pat<(fsub_mlx DPR:$dstin, (fmul_su DPR:$a, (f64 DPR:$b))),
1926           (VMLSD DPR:$dstin, DPR:$a, DPR:$b)>,
1927           Requires<[HasVFP2,HasDPVFP,UseFPVMLx]>;
1928 def : Pat<(fsub_mlx SPR:$dstin, (fmul_su SPR:$a, SPR:$b)),
1929           (VMLSS SPR:$dstin, SPR:$a, SPR:$b)>,
1930           Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]>;
1931 def : Pat<(fsub_mlx HPR:$dstin, (fmul_su HPR:$a, HPR:$b)),
1932           (VMLSH HPR:$dstin, HPR:$a, HPR:$b)>,
1933           Requires<[HasFullFP16,DontUseNEONForFP,UseFPVMLx]>;
1934
1935 def VNMLAD : ADbI<0b11100, 0b01, 1, 0,
1936                   (outs DPR:$Dd), (ins DPR:$Ddin, DPR:$Dn, DPR:$Dm),
1937                   IIC_fpMAC64, "vnmla", ".f64\t$Dd, $Dn, $Dm",
1938                   [(set DPR:$Dd,(fsub_mlx (fneg (fmul_su DPR:$Dn,DPR:$Dm)),
1939                                           (f64 DPR:$Ddin)))]>,
1940                 RegConstraint<"$Ddin = $Dd">,
1941                 Requires<[HasVFP2,HasDPVFP,UseFPVMLx]>,
1942                 Sched<[WriteFPMAC64, ReadFPMAC, ReadFPMUL, ReadFPMUL]>;
1943
1944 def VNMLAS : ASbI<0b11100, 0b01, 1, 0,
1945                   (outs SPR:$Sd), (ins SPR:$Sdin, SPR:$Sn, SPR:$Sm),
1946                   IIC_fpMAC32, "vnmla", ".f32\t$Sd, $Sn, $Sm",
1947                   [(set SPR:$Sd, (fsub_mlx (fneg (fmul_su SPR:$Sn, SPR:$Sm)),
1948                                            SPR:$Sdin))]>,
1949                 RegConstraint<"$Sdin = $Sd">,
1950                 Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]>,
1951                 Sched<[WriteFPMAC32, ReadFPMAC, ReadFPMUL, ReadFPMUL]> {
1952   // Some single precision VFP instructions may be executed on both NEON and
1953   // VFP pipelines on A8.
1954   let D = VFPNeonA8Domain;
1955 }
1956
1957 def VNMLAH : AHbI<0b11100, 0b01, 1, 0,
1958                   (outs HPR:$Sd), (ins HPR:$Sdin, HPR:$Sn, HPR:$Sm),
1959                   IIC_fpMAC16, "vnmla", ".f16\t$Sd, $Sn, $Sm",
1960                   [(set HPR:$Sd, (fsub_mlx (fneg (fmul_su HPR:$Sn, HPR:$Sm)),
1961                                            HPR:$Sdin))]>,
1962                 RegConstraint<"$Sdin = $Sd">,
1963                 Requires<[HasFullFP16,UseFPVMLx]>;
1964
1965 // (-(a * b) - dst) -> -(dst + (a * b))
1966 def : Pat<(fsub_mlx (fneg (fmul_su DPR:$a, (f64 DPR:$b))), DPR:$dstin),
1967           (VNMLAD DPR:$dstin, DPR:$a, DPR:$b)>,
1968           Requires<[HasVFP2,HasDPVFP,UseFPVMLx]>;
1969 def : Pat<(fsub_mlx (fneg (fmul_su SPR:$a, SPR:$b)), SPR:$dstin),
1970           (VNMLAS SPR:$dstin, SPR:$a, SPR:$b)>,
1971           Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]>;
1972 def : Pat<(fsub_mlx (fneg (fmul_su HPR:$a, HPR:$b)), HPR:$dstin),
1973           (VNMLAH HPR:$dstin, HPR:$a, HPR:$b)>,
1974           Requires<[HasFullFP16,DontUseNEONForFP,UseFPVMLx]>;
1975
1976 // (-dst - (a * b)) -> -(dst + (a * b))
1977 def : Pat<(fsub_mlx (fneg DPR:$dstin), (fmul_su DPR:$a, (f64 DPR:$b))),
1978           (VNMLAD DPR:$dstin, DPR:$a, DPR:$b)>,
1979           Requires<[HasVFP2,HasDPVFP,UseFPVMLx]>;
1980 def : Pat<(fsub_mlx (fneg SPR:$dstin), (fmul_su SPR:$a, SPR:$b)),
1981           (VNMLAS SPR:$dstin, SPR:$a, SPR:$b)>,
1982           Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]>;
1983 def : Pat<(fsub_mlx (fneg HPR:$dstin), (fmul_su HPR:$a, HPR:$b)),
1984           (VNMLAH HPR:$dstin, HPR:$a, HPR:$b)>,
1985           Requires<[HasFullFP16,DontUseNEONForFP,UseFPVMLx]>;
1986
1987 def VNMLSD : ADbI<0b11100, 0b01, 0, 0,
1988                   (outs DPR:$Dd), (ins DPR:$Ddin, DPR:$Dn, DPR:$Dm),
1989                   IIC_fpMAC64, "vnmls", ".f64\t$Dd, $Dn, $Dm",
1990                   [(set DPR:$Dd, (fsub_mlx (fmul_su DPR:$Dn, DPR:$Dm),
1991                                            (f64 DPR:$Ddin)))]>,
1992                RegConstraint<"$Ddin = $Dd">,
1993                Requires<[HasVFP2,HasDPVFP,UseFPVMLx]>,
1994                Sched<[WriteFPMAC64, ReadFPMAC, ReadFPMUL, ReadFPMUL]>;
1995
1996 def VNMLSS : ASbI<0b11100, 0b01, 0, 0,
1997                   (outs SPR:$Sd), (ins SPR:$Sdin, SPR:$Sn, SPR:$Sm),
1998                   IIC_fpMAC32, "vnmls", ".f32\t$Sd, $Sn, $Sm",
1999              [(set SPR:$Sd, (fsub_mlx (fmul_su SPR:$Sn, SPR:$Sm), SPR:$Sdin))]>,
2000                          RegConstraint<"$Sdin = $Sd">,
2001                 Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]>,
2002              Sched<[WriteFPMAC32, ReadFPMAC, ReadFPMUL, ReadFPMUL]> {
2003   // Some single precision VFP instructions may be executed on both NEON and
2004   // VFP pipelines on A8.
2005   let D = VFPNeonA8Domain;
2006 }
2007
2008 def VNMLSH : AHbI<0b11100, 0b01, 0, 0,
2009                   (outs HPR:$Sd), (ins HPR:$Sdin, HPR:$Sn, HPR:$Sm),
2010                   IIC_fpMAC16, "vnmls", ".f16\t$Sd, $Sn, $Sm",
2011              [(set HPR:$Sd, (fsub_mlx (fmul_su HPR:$Sn, HPR:$Sm), HPR:$Sdin))]>,
2012                          RegConstraint<"$Sdin = $Sd">,
2013                 Requires<[HasFullFP16,UseFPVMLx]>;
2014
2015 def : Pat<(fsub_mlx (fmul_su DPR:$a, (f64 DPR:$b)), DPR:$dstin),
2016           (VNMLSD DPR:$dstin, DPR:$a, DPR:$b)>,
2017           Requires<[HasVFP2,HasDPVFP,UseFPVMLx]>;
2018 def : Pat<(fsub_mlx (fmul_su SPR:$a, SPR:$b), SPR:$dstin),
2019           (VNMLSS SPR:$dstin, SPR:$a, SPR:$b)>,
2020           Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]>;
2021 def : Pat<(fsub_mlx (fmul_su HPR:$a, HPR:$b), HPR:$dstin),
2022           (VNMLSH HPR:$dstin, HPR:$a, HPR:$b)>,
2023           Requires<[HasFullFP16,DontUseNEONForFP,UseFPVMLx]>;
2024
2025 //===----------------------------------------------------------------------===//
2026 // Fused FP Multiply-Accumulate Operations.
2027 //
2028 def VFMAD : ADbI<0b11101, 0b10, 0, 0,
2029                  (outs DPR:$Dd), (ins DPR:$Ddin, DPR:$Dn, DPR:$Dm),
2030                  IIC_fpFMAC64, "vfma", ".f64\t$Dd, $Dn, $Dm",
2031                  [(set DPR:$Dd, (fadd_mlx (fmul_su DPR:$Dn, DPR:$Dm),
2032                                           (f64 DPR:$Ddin)))]>,
2033               RegConstraint<"$Ddin = $Dd">,
2034               Requires<[HasVFP4,HasDPVFP,UseFusedMAC]>,
2035             Sched<[WriteFPMAC64, ReadFPMAC, ReadFPMUL, ReadFPMUL]>;
2036
2037 def VFMAS : ASbIn<0b11101, 0b10, 0, 0,
2038                   (outs SPR:$Sd), (ins SPR:$Sdin, SPR:$Sn, SPR:$Sm),
2039                   IIC_fpFMAC32, "vfma", ".f32\t$Sd, $Sn, $Sm",
2040                   [(set SPR:$Sd, (fadd_mlx (fmul_su SPR:$Sn, SPR:$Sm),
2041                                            SPR:$Sdin))]>,
2042               RegConstraint<"$Sdin = $Sd">,
2043               Requires<[HasVFP4,DontUseNEONForFP,UseFusedMAC]>,
2044             Sched<[WriteFPMAC32, ReadFPMAC, ReadFPMUL, ReadFPMUL]> {
2045   // Some single precision VFP instructions may be executed on both NEON and
2046   // VFP pipelines.
2047 }
2048
2049 def VFMAH : AHbI<0b11101, 0b10, 0, 0,
2050                   (outs HPR:$Sd), (ins HPR:$Sdin, HPR:$Sn, HPR:$Sm),
2051                   IIC_fpFMAC16, "vfma", ".f16\t$Sd, $Sn, $Sm",
2052                   [(set HPR:$Sd, (fadd_mlx (fmul_su HPR:$Sn, HPR:$Sm),
2053                                            HPR:$Sdin))]>,
2054               RegConstraint<"$Sdin = $Sd">,
2055               Requires<[HasFullFP16,UseFusedMAC]>,
2056             Sched<[WriteFPMAC32, ReadFPMAC, ReadFPMUL, ReadFPMUL]>;
2057
2058 def : Pat<(fadd_mlx DPR:$dstin, (fmul_su DPR:$a, (f64 DPR:$b))),
2059           (VFMAD DPR:$dstin, DPR:$a, DPR:$b)>,
2060           Requires<[HasVFP4,HasDPVFP,UseFusedMAC]>;
2061 def : Pat<(fadd_mlx SPR:$dstin, (fmul_su SPR:$a, SPR:$b)),
2062           (VFMAS SPR:$dstin, SPR:$a, SPR:$b)>,
2063           Requires<[HasVFP4,DontUseNEONForFP,UseFusedMAC]>;
2064 def : Pat<(fadd_mlx HPR:$dstin, (fmul_su HPR:$a, HPR:$b)),
2065           (VFMAH HPR:$dstin, HPR:$a, HPR:$b)>,
2066           Requires<[HasFullFP16,DontUseNEONForFP,UseFusedMAC]>;
2067
2068 // Match @llvm.fma.* intrinsics
2069 // (fma x, y, z) -> (vfms z, x, y)
2070 def : Pat<(f64 (fma DPR:$Dn, DPR:$Dm, DPR:$Ddin)),
2071           (VFMAD DPR:$Ddin, DPR:$Dn, DPR:$Dm)>,
2072       Requires<[HasVFP4,HasDPVFP]>;
2073 def : Pat<(f32 (fma SPR:$Sn, SPR:$Sm, SPR:$Sdin)),
2074           (VFMAS SPR:$Sdin, SPR:$Sn, SPR:$Sm)>,
2075       Requires<[HasVFP4]>;
2076
2077 def VFMSD : ADbI<0b11101, 0b10, 1, 0,
2078                  (outs DPR:$Dd), (ins DPR:$Ddin, DPR:$Dn, DPR:$Dm),
2079                  IIC_fpFMAC64, "vfms", ".f64\t$Dd, $Dn, $Dm",
2080                  [(set DPR:$Dd, (fadd_mlx (fneg (fmul_su DPR:$Dn,DPR:$Dm)),
2081                                           (f64 DPR:$Ddin)))]>,
2082               RegConstraint<"$Ddin = $Dd">,
2083               Requires<[HasVFP4,HasDPVFP,UseFusedMAC]>,
2084               Sched<[WriteFPMAC64, ReadFPMAC, ReadFPMUL, ReadFPMUL]>;
2085
2086 def VFMSS : ASbIn<0b11101, 0b10, 1, 0,
2087                   (outs SPR:$Sd), (ins SPR:$Sdin, SPR:$Sn, SPR:$Sm),
2088                   IIC_fpFMAC32, "vfms", ".f32\t$Sd, $Sn, $Sm",
2089                   [(set SPR:$Sd, (fadd_mlx (fneg (fmul_su SPR:$Sn, SPR:$Sm)),
2090                                            SPR:$Sdin))]>,
2091               RegConstraint<"$Sdin = $Sd">,
2092               Requires<[HasVFP4,DontUseNEONForFP,UseFusedMAC]>,
2093               Sched<[WriteFPMAC32, ReadFPMAC, ReadFPMUL, ReadFPMUL]> {
2094   // Some single precision VFP instructions may be executed on both NEON and
2095   // VFP pipelines.
2096 }
2097
2098 def VFMSH : AHbI<0b11101, 0b10, 1, 0,
2099                   (outs HPR:$Sd), (ins HPR:$Sdin, HPR:$Sn, HPR:$Sm),
2100                   IIC_fpFMAC16, "vfms", ".f16\t$Sd, $Sn, $Sm",
2101                   [(set HPR:$Sd, (fadd_mlx (fneg (fmul_su HPR:$Sn, HPR:$Sm)),
2102                                            HPR:$Sdin))]>,
2103               RegConstraint<"$Sdin = $Sd">,
2104               Requires<[HasFullFP16,UseFusedMAC]>,
2105               Sched<[WriteFPMAC32, ReadFPMAC, ReadFPMUL, ReadFPMUL]>;
2106
2107 def : Pat<(fsub_mlx DPR:$dstin, (fmul_su DPR:$a, (f64 DPR:$b))),
2108           (VFMSD DPR:$dstin, DPR:$a, DPR:$b)>,
2109           Requires<[HasVFP4,HasDPVFP,UseFusedMAC]>;
2110 def : Pat<(fsub_mlx SPR:$dstin, (fmul_su SPR:$a, SPR:$b)),
2111           (VFMSS SPR:$dstin, SPR:$a, SPR:$b)>,
2112           Requires<[HasVFP4,DontUseNEONForFP,UseFusedMAC]>;
2113 def : Pat<(fsub_mlx HPR:$dstin, (fmul_su HPR:$a, HPR:$b)),
2114           (VFMSH HPR:$dstin, HPR:$a, HPR:$b)>,
2115           Requires<[HasFullFP16,DontUseNEONForFP,UseFusedMAC]>;
2116
2117 // Match @llvm.fma.* intrinsics
2118 // (fma (fneg x), y, z) -> (vfms z, x, y)
2119 def : Pat<(f64 (fma (fneg DPR:$Dn), DPR:$Dm, DPR:$Ddin)),
2120           (VFMSD DPR:$Ddin, DPR:$Dn, DPR:$Dm)>,
2121       Requires<[HasVFP4,HasDPVFP]>;
2122 def : Pat<(f32 (fma (fneg SPR:$Sn), SPR:$Sm, SPR:$Sdin)),
2123           (VFMSS SPR:$Sdin, SPR:$Sn, SPR:$Sm)>,
2124       Requires<[HasVFP4]>;
2125 // (fma x, (fneg y), z) -> (vfms z, x, y)
2126 def : Pat<(f64 (fma DPR:$Dn, (fneg DPR:$Dm), DPR:$Ddin)),
2127           (VFMSD DPR:$Ddin, DPR:$Dn, DPR:$Dm)>,
2128       Requires<[HasVFP4,HasDPVFP]>;
2129 def : Pat<(f32 (fma SPR:$Sn, (fneg SPR:$Sm), SPR:$Sdin)),
2130           (VFMSS SPR:$Sdin, SPR:$Sn, SPR:$Sm)>,
2131       Requires<[HasVFP4]>;
2132
2133 def VFNMAD : ADbI<0b11101, 0b01, 1, 0,
2134                   (outs DPR:$Dd), (ins DPR:$Ddin, DPR:$Dn, DPR:$Dm),
2135                   IIC_fpFMAC64, "vfnma", ".f64\t$Dd, $Dn, $Dm",
2136                   [(set DPR:$Dd,(fsub_mlx (fneg (fmul_su DPR:$Dn,DPR:$Dm)),
2137                                           (f64 DPR:$Ddin)))]>,
2138                 RegConstraint<"$Ddin = $Dd">,
2139                 Requires<[HasVFP4,HasDPVFP,UseFusedMAC]>,
2140                 Sched<[WriteFPMAC64, ReadFPMAC, ReadFPMUL, ReadFPMUL]>;
2141
2142 def VFNMAS : ASbI<0b11101, 0b01, 1, 0,
2143                   (outs SPR:$Sd), (ins SPR:$Sdin, SPR:$Sn, SPR:$Sm),
2144                   IIC_fpFMAC32, "vfnma", ".f32\t$Sd, $Sn, $Sm",
2145                   [(set SPR:$Sd, (fsub_mlx (fneg (fmul_su SPR:$Sn, SPR:$Sm)),
2146                                            SPR:$Sdin))]>,
2147                 RegConstraint<"$Sdin = $Sd">,
2148                 Requires<[HasVFP4,DontUseNEONForFP,UseFusedMAC]>,
2149                 Sched<[WriteFPMAC32, ReadFPMAC, ReadFPMUL, ReadFPMUL]> {
2150   // Some single precision VFP instructions may be executed on both NEON and
2151   // VFP pipelines.
2152 }
2153
2154 def VFNMAH : AHbI<0b11101, 0b01, 1, 0,
2155                   (outs HPR:$Sd), (ins HPR:$Sdin, HPR:$Sn, HPR:$Sm),
2156                   IIC_fpFMAC16, "vfnma", ".f16\t$Sd, $Sn, $Sm",
2157                   [(set HPR:$Sd, (fsub_mlx (fneg (fmul_su HPR:$Sn, HPR:$Sm)),
2158                                            HPR:$Sdin))]>,
2159                 RegConstraint<"$Sdin = $Sd">,
2160                 Requires<[HasFullFP16,UseFusedMAC]>,
2161                 Sched<[WriteFPMAC32, ReadFPMAC, ReadFPMUL, ReadFPMUL]>;
2162
2163 def : Pat<(fsub_mlx (fneg (fmul_su DPR:$a, (f64 DPR:$b))), DPR:$dstin),
2164           (VFNMAD DPR:$dstin, DPR:$a, DPR:$b)>,
2165           Requires<[HasVFP4,HasDPVFP,UseFusedMAC]>;
2166 def : Pat<(fsub_mlx (fneg (fmul_su SPR:$a, SPR:$b)), SPR:$dstin),
2167           (VFNMAS SPR:$dstin, SPR:$a, SPR:$b)>,
2168           Requires<[HasVFP4,DontUseNEONForFP,UseFusedMAC]>;
2169
2170 // Match @llvm.fma.* intrinsics
2171 // (fneg (fma x, y, z)) -> (vfnma z, x, y)
2172 def : Pat<(fneg (fma (f64 DPR:$Dn), (f64 DPR:$Dm), (f64 DPR:$Ddin))),
2173           (VFNMAD DPR:$Ddin, DPR:$Dn, DPR:$Dm)>,
2174       Requires<[HasVFP4,HasDPVFP]>;
2175 def : Pat<(fneg (fma (f32 SPR:$Sn), (f32 SPR:$Sm), (f32 SPR:$Sdin))),
2176           (VFNMAS SPR:$Sdin, SPR:$Sn, SPR:$Sm)>,
2177       Requires<[HasVFP4]>;
2178 // (fma (fneg x), y, (fneg z)) -> (vfnma z, x, y)
2179 def : Pat<(f64 (fma (fneg DPR:$Dn), DPR:$Dm, (fneg DPR:$Ddin))),
2180           (VFNMAD DPR:$Ddin, DPR:$Dn, DPR:$Dm)>,
2181       Requires<[HasVFP4,HasDPVFP]>;
2182 def : Pat<(f32 (fma (fneg SPR:$Sn), SPR:$Sm, (fneg SPR:$Sdin))),
2183           (VFNMAS SPR:$Sdin, SPR:$Sn, SPR:$Sm)>,
2184       Requires<[HasVFP4]>;
2185
2186 def VFNMSD : ADbI<0b11101, 0b01, 0, 0,
2187                   (outs DPR:$Dd), (ins DPR:$Ddin, DPR:$Dn, DPR:$Dm),
2188                   IIC_fpFMAC64, "vfnms", ".f64\t$Dd, $Dn, $Dm",
2189                   [(set DPR:$Dd, (fsub_mlx (fmul_su DPR:$Dn, DPR:$Dm),
2190                                            (f64 DPR:$Ddin)))]>,
2191                RegConstraint<"$Ddin = $Dd">,
2192                Requires<[HasVFP4,HasDPVFP,UseFusedMAC]>,
2193                Sched<[WriteFPMAC64, ReadFPMAC, ReadFPMUL, ReadFPMUL]>;
2194
2195 def VFNMSS : ASbI<0b11101, 0b01, 0, 0,
2196                   (outs SPR:$Sd), (ins SPR:$Sdin, SPR:$Sn, SPR:$Sm),
2197                   IIC_fpFMAC32, "vfnms", ".f32\t$Sd, $Sn, $Sm",
2198              [(set SPR:$Sd, (fsub_mlx (fmul_su SPR:$Sn, SPR:$Sm), SPR:$Sdin))]>,
2199                          RegConstraint<"$Sdin = $Sd">,
2200                   Requires<[HasVFP4,DontUseNEONForFP,UseFusedMAC]>,
2201                   Sched<[WriteFPMAC32, ReadFPMAC, ReadFPMUL, ReadFPMUL]> {
2202   // Some single precision VFP instructions may be executed on both NEON and
2203   // VFP pipelines.
2204 }
2205
2206 def VFNMSH : AHbI<0b11101, 0b01, 0, 0,
2207                   (outs HPR:$Sd), (ins HPR:$Sdin, HPR:$Sn, HPR:$Sm),
2208                   IIC_fpFMAC16, "vfnms", ".f16\t$Sd, $Sn, $Sm",
2209              [(set HPR:$Sd, (fsub_mlx (fmul_su HPR:$Sn, HPR:$Sm), HPR:$Sdin))]>,
2210                          RegConstraint<"$Sdin = $Sd">,
2211                   Requires<[HasFullFP16,UseFusedMAC]>,
2212                   Sched<[WriteFPMAC32, ReadFPMAC, ReadFPMUL, ReadFPMUL]>;
2213
2214 def : Pat<(fsub_mlx (fmul_su DPR:$a, (f64 DPR:$b)), DPR:$dstin),
2215           (VFNMSD DPR:$dstin, DPR:$a, DPR:$b)>,
2216           Requires<[HasVFP4,HasDPVFP,UseFusedMAC]>;
2217 def : Pat<(fsub_mlx (fmul_su SPR:$a, SPR:$b), SPR:$dstin),
2218           (VFNMSS SPR:$dstin, SPR:$a, SPR:$b)>,
2219           Requires<[HasVFP4,DontUseNEONForFP,UseFusedMAC]>;
2220
2221 // Match @llvm.fma.* intrinsics
2222
2223 // (fma x, y, (fneg z)) -> (vfnms z, x, y))
2224 def : Pat<(f64 (fma DPR:$Dn, DPR:$Dm, (fneg DPR:$Ddin))),
2225           (VFNMSD DPR:$Ddin, DPR:$Dn, DPR:$Dm)>,
2226       Requires<[HasVFP4,HasDPVFP]>;
2227 def : Pat<(f32 (fma SPR:$Sn, SPR:$Sm, (fneg SPR:$Sdin))),
2228           (VFNMSS SPR:$Sdin, SPR:$Sn, SPR:$Sm)>,
2229       Requires<[HasVFP4]>;
2230 // (fneg (fma (fneg x), y, z)) -> (vfnms z, x, y)
2231 def : Pat<(fneg (f64 (fma (fneg DPR:$Dn), DPR:$Dm, DPR:$Ddin))),
2232           (VFNMSD DPR:$Ddin, DPR:$Dn, DPR:$Dm)>,
2233       Requires<[HasVFP4,HasDPVFP]>;
2234 def : Pat<(fneg (f32 (fma (fneg SPR:$Sn), SPR:$Sm, SPR:$Sdin))),
2235           (VFNMSS SPR:$Sdin, SPR:$Sn, SPR:$Sm)>,
2236       Requires<[HasVFP4]>;
2237 // (fneg (fma x, (fneg y), z) -> (vfnms z, x, y)
2238 def : Pat<(fneg (f64 (fma DPR:$Dn, (fneg DPR:$Dm), DPR:$Ddin))),
2239           (VFNMSD DPR:$Ddin, DPR:$Dn, DPR:$Dm)>,
2240       Requires<[HasVFP4,HasDPVFP]>;
2241 def : Pat<(fneg (f32 (fma SPR:$Sn, (fneg SPR:$Sm), SPR:$Sdin))),
2242           (VFNMSS SPR:$Sdin, SPR:$Sn, SPR:$Sm)>,
2243       Requires<[HasVFP4]>;
2244
2245 //===----------------------------------------------------------------------===//
2246 // FP Conditional moves.
2247 //
2248
2249 let hasSideEffects = 0 in {
2250 def VMOVDcc  : PseudoInst<(outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm, cmovpred:$p),
2251                     IIC_fpUNA64,
2252                     [(set (f64 DPR:$Dd),
2253                           (ARMcmov DPR:$Dn, DPR:$Dm, cmovpred:$p))]>,
2254                RegConstraint<"$Dn = $Dd">, Requires<[HasVFP2,HasDPVFP]>;
2255
2256 def VMOVScc  : PseudoInst<(outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm, cmovpred:$p),
2257                     IIC_fpUNA32,
2258                     [(set (f32 SPR:$Sd),
2259                           (ARMcmov SPR:$Sn, SPR:$Sm, cmovpred:$p))]>,
2260                RegConstraint<"$Sn = $Sd">, Requires<[HasVFP2]>;
2261 } // hasSideEffects
2262
2263 //===----------------------------------------------------------------------===//
2264 // Move from VFP System Register to ARM core register.
2265 //
2266
2267 class MovFromVFP<bits<4> opc19_16, dag oops, dag iops, string opc, string asm,
2268                  list<dag> pattern>:
2269   VFPAI<oops, iops, VFPMiscFrm, IIC_fpSTAT, opc, asm, pattern> {
2270
2271   // Instruction operand.
2272   bits<4> Rt;
2273
2274   let Inst{27-20} = 0b11101111;
2275   let Inst{19-16} = opc19_16;
2276   let Inst{15-12} = Rt;
2277   let Inst{11-8}  = 0b1010;
2278   let Inst{7}     = 0;
2279   let Inst{6-5}   = 0b00;
2280   let Inst{4}     = 1;
2281   let Inst{3-0}   = 0b0000;
2282 }
2283
2284 // APSR is the application level alias of CPSR. This FPSCR N, Z, C, V flags
2285 // to APSR.
2286 let Defs = [CPSR], Uses = [FPSCR_NZCV], Rt = 0b1111 /* apsr_nzcv */ in
2287 def FMSTAT : MovFromVFP<0b0001 /* fpscr */, (outs), (ins),
2288                         "vmrs", "\tAPSR_nzcv, fpscr", [(arm_fmstat)]>;
2289
2290 let DecoderMethod = "DecodeForVMRSandVMSR" in {
2291  // Application level FPSCR -> GPR
2292  let hasSideEffects = 1, Uses = [FPSCR] in
2293  def VMRS :  MovFromVFP<0b0001 /* fpscr */, (outs GPRnopc:$Rt), (ins),
2294                         "vmrs", "\t$Rt, fpscr",
2295                         [(set GPRnopc:$Rt, (int_arm_get_fpscr))]>;
2296
2297  // System level FPEXC, FPSID -> GPR
2298  let Uses = [FPSCR] in {
2299    def VMRS_FPEXC : MovFromVFP<0b1000 /* fpexc */, (outs GPRnopc:$Rt), (ins),
2300                                "vmrs", "\t$Rt, fpexc", []>;
2301    def VMRS_FPSID : MovFromVFP<0b0000 /* fpsid */, (outs GPRnopc:$Rt), (ins),
2302                                "vmrs", "\t$Rt, fpsid", []>;
2303    def VMRS_MVFR0 : MovFromVFP<0b0111 /* mvfr0 */, (outs GPRnopc:$Rt), (ins),
2304                               "vmrs", "\t$Rt, mvfr0", []>;
2305    def VMRS_MVFR1 : MovFromVFP<0b0110 /* mvfr1 */, (outs GPRnopc:$Rt), (ins),
2306                                "vmrs", "\t$Rt, mvfr1", []>;
2307    let Predicates = [HasFPARMv8] in {
2308      def VMRS_MVFR2 : MovFromVFP<0b0101 /* mvfr2 */, (outs GPRnopc:$Rt), (ins),
2309                                  "vmrs", "\t$Rt, mvfr2", []>;
2310    }
2311    def VMRS_FPINST : MovFromVFP<0b1001 /* fpinst */, (outs GPRnopc:$Rt), (ins),
2312                                 "vmrs", "\t$Rt, fpinst", []>;
2313    def VMRS_FPINST2 : MovFromVFP<0b1010 /* fpinst2 */, (outs GPRnopc:$Rt),
2314                                  (ins), "vmrs", "\t$Rt, fpinst2", []>;
2315  }
2316 }
2317
2318 //===----------------------------------------------------------------------===//
2319 // Move from ARM core register to VFP System Register.
2320 //
2321
2322 class MovToVFP<bits<4> opc19_16, dag oops, dag iops, string opc, string asm,
2323                list<dag> pattern>:
2324   VFPAI<oops, iops, VFPMiscFrm, IIC_fpSTAT, opc, asm, pattern> {
2325
2326   // Instruction operand.
2327   bits<4> src;
2328
2329   // Encode instruction operand.
2330   let Inst{15-12} = src;
2331
2332   let Inst{27-20} = 0b11101110;
2333   let Inst{19-16} = opc19_16;
2334   let Inst{11-8}  = 0b1010;
2335   let Inst{7}     = 0;
2336   let Inst{4}     = 1;
2337 }
2338
2339 let DecoderMethod = "DecodeForVMRSandVMSR" in {
2340  let Defs = [FPSCR] in {
2341    // Application level GPR -> FPSCR
2342    def VMSR : MovToVFP<0b0001 /* fpscr */, (outs), (ins GPRnopc:$src),
2343                        "vmsr", "\tfpscr, $src",
2344                        [(int_arm_set_fpscr GPRnopc:$src)]>;
2345    // System level GPR -> FPEXC
2346    def VMSR_FPEXC : MovToVFP<0b1000 /* fpexc */, (outs), (ins GPRnopc:$src),
2347                                "vmsr", "\tfpexc, $src", []>;
2348    // System level GPR -> FPSID
2349    def VMSR_FPSID : MovToVFP<0b0000 /* fpsid */, (outs), (ins GPRnopc:$src),
2350                              "vmsr", "\tfpsid, $src", []>;
2351    def VMSR_FPINST : MovToVFP<0b1001 /* fpinst */, (outs), (ins GPRnopc:$src),
2352                               "vmsr", "\tfpinst, $src", []>;
2353    def VMSR_FPINST2 : MovToVFP<0b1010 /* fpinst2 */, (outs), (ins GPRnopc:$src),
2354                                "vmsr", "\tfpinst2, $src", []>;
2355  }
2356 }
2357
2358 //===----------------------------------------------------------------------===//
2359 // Misc.
2360 //
2361
2362 // Materialize FP immediates. VFP3 only.
2363 let isReMaterializable = 1 in {
2364 def FCONSTD : VFPAI<(outs DPR:$Dd), (ins vfp_f64imm:$imm),
2365                     VFPMiscFrm, IIC_fpUNA64,
2366                     "vmov", ".f64\t$Dd, $imm",
2367                     [(set DPR:$Dd, vfp_f64imm:$imm)]>,
2368               Requires<[HasVFP3,HasDPVFP]> {
2369   bits<5> Dd;
2370   bits<8> imm;
2371
2372   let Inst{27-23} = 0b11101;
2373   let Inst{22}    = Dd{4};
2374   let Inst{21-20} = 0b11;
2375   let Inst{19-16} = imm{7-4};
2376   let Inst{15-12} = Dd{3-0};
2377   let Inst{11-9}  = 0b101;
2378   let Inst{8}     = 1;          // Double precision.
2379   let Inst{7-4}   = 0b0000;
2380   let Inst{3-0}   = imm{3-0};
2381 }
2382
2383 def FCONSTS : VFPAI<(outs SPR:$Sd), (ins vfp_f32imm:$imm),
2384                      VFPMiscFrm, IIC_fpUNA32,
2385                      "vmov", ".f32\t$Sd, $imm",
2386                      [(set SPR:$Sd, vfp_f32imm:$imm)]>, Requires<[HasVFP3]> {
2387   bits<5> Sd;
2388   bits<8> imm;
2389
2390   let Inst{27-23} = 0b11101;
2391   let Inst{22}    = Sd{0};
2392   let Inst{21-20} = 0b11;
2393   let Inst{19-16} = imm{7-4};
2394   let Inst{15-12} = Sd{4-1};
2395   let Inst{11-9}  = 0b101;
2396   let Inst{8}     = 0;          // Single precision.
2397   let Inst{7-4}   = 0b0000;
2398   let Inst{3-0}   = imm{3-0};
2399 }
2400
2401 def FCONSTH : VFPAI<(outs HPR:$Sd), (ins vfp_f16imm:$imm),
2402                      VFPMiscFrm, IIC_fpUNA16,
2403                      "vmov", ".f16\t$Sd, $imm",
2404                      [(set HPR:$Sd, vfp_f16imm:$imm)]>,
2405               Requires<[HasFullFP16]> {
2406   bits<5> Sd;
2407   bits<8> imm;
2408
2409   let Inst{27-23} = 0b11101;
2410   let Inst{22}    = Sd{0};
2411   let Inst{21-20} = 0b11;
2412   let Inst{19-16} = imm{7-4};
2413   let Inst{15-12} = Sd{4-1};
2414   let Inst{11-8}  = 0b1001;     // Half precision
2415   let Inst{7-4}   = 0b0000;
2416   let Inst{3-0}   = imm{3-0};
2417
2418   let isUnpredicable = 1;
2419 }
2420 }
2421
2422 //===----------------------------------------------------------------------===//
2423 // Assembler aliases.
2424 //
2425 // A few mnemonic aliases for pre-unifixed syntax. We don't guarantee to
2426 // support them all, but supporting at least some of the basics is
2427 // good to be friendly.
2428 def : VFP2MnemonicAlias<"flds", "vldr">;
2429 def : VFP2MnemonicAlias<"fldd", "vldr">;
2430 def : VFP2MnemonicAlias<"fmrs", "vmov">;
2431 def : VFP2MnemonicAlias<"fmsr", "vmov">;
2432 def : VFP2MnemonicAlias<"fsqrts", "vsqrt">;
2433 def : VFP2MnemonicAlias<"fsqrtd", "vsqrt">;
2434 def : VFP2MnemonicAlias<"fadds", "vadd.f32">;
2435 def : VFP2MnemonicAlias<"faddd", "vadd.f64">;
2436 def : VFP2MnemonicAlias<"fmrdd", "vmov">;
2437 def : VFP2MnemonicAlias<"fmrds", "vmov">;
2438 def : VFP2MnemonicAlias<"fmrrd", "vmov">;
2439 def : VFP2MnemonicAlias<"fmdrr", "vmov">;
2440 def : VFP2MnemonicAlias<"fmuls", "vmul.f32">;
2441 def : VFP2MnemonicAlias<"fmuld", "vmul.f64">;
2442 def : VFP2MnemonicAlias<"fnegs", "vneg.f32">;
2443 def : VFP2MnemonicAlias<"fnegd", "vneg.f64">;
2444 def : VFP2MnemonicAlias<"ftosizd", "vcvt.s32.f64">;
2445 def : VFP2MnemonicAlias<"ftosid", "vcvtr.s32.f64">;
2446 def : VFP2MnemonicAlias<"ftosizs", "vcvt.s32.f32">;
2447 def : VFP2MnemonicAlias<"ftosis", "vcvtr.s32.f32">;
2448 def : VFP2MnemonicAlias<"ftouizd", "vcvt.u32.f64">;
2449 def : VFP2MnemonicAlias<"ftouid", "vcvtr.u32.f64">;
2450 def : VFP2MnemonicAlias<"ftouizs", "vcvt.u32.f32">;
2451 def : VFP2MnemonicAlias<"ftouis", "vcvtr.u32.f32">;
2452 def : VFP2MnemonicAlias<"fsitod", "vcvt.f64.s32">;
2453 def : VFP2MnemonicAlias<"fsitos", "vcvt.f32.s32">;
2454 def : VFP2MnemonicAlias<"fuitod", "vcvt.f64.u32">;
2455 def : VFP2MnemonicAlias<"fuitos", "vcvt.f32.u32">;
2456 def : VFP2MnemonicAlias<"fsts", "vstr">;
2457 def : VFP2MnemonicAlias<"fstd", "vstr">;
2458 def : VFP2MnemonicAlias<"fmacd", "vmla.f64">;
2459 def : VFP2MnemonicAlias<"fmacs", "vmla.f32">;
2460 def : VFP2MnemonicAlias<"fcpys", "vmov.f32">;
2461 def : VFP2MnemonicAlias<"fcpyd", "vmov.f64">;
2462 def : VFP2MnemonicAlias<"fcmps", "vcmp.f32">;
2463 def : VFP2MnemonicAlias<"fcmpd", "vcmp.f64">;
2464 def : VFP2MnemonicAlias<"fdivs", "vdiv.f32">;
2465 def : VFP2MnemonicAlias<"fdivd", "vdiv.f64">;
2466 def : VFP2MnemonicAlias<"fmrx", "vmrs">;
2467 def : VFP2MnemonicAlias<"fmxr", "vmsr">;
2468
2469 // Be friendly and accept the old form of zero-compare
2470 def : VFP2DPInstAlias<"fcmpzd${p} $val", (VCMPZD DPR:$val, pred:$p)>;
2471 def : VFP2InstAlias<"fcmpzs${p} $val", (VCMPZS SPR:$val, pred:$p)>;
2472
2473
2474 def : VFP2InstAlias<"fmstat${p}", (FMSTAT pred:$p)>;
2475 def : VFP2InstAlias<"fadds${p} $Sd, $Sn, $Sm",
2476                     (VADDS SPR:$Sd, SPR:$Sn, SPR:$Sm, pred:$p)>;
2477 def : VFP2DPInstAlias<"faddd${p} $Dd, $Dn, $Dm",
2478                       (VADDD DPR:$Dd, DPR:$Dn, DPR:$Dm, pred:$p)>;
2479 def : VFP2InstAlias<"fsubs${p} $Sd, $Sn, $Sm",
2480                     (VSUBS SPR:$Sd, SPR:$Sn, SPR:$Sm, pred:$p)>;
2481 def : VFP2DPInstAlias<"fsubd${p} $Dd, $Dn, $Dm",
2482                       (VSUBD DPR:$Dd, DPR:$Dn, DPR:$Dm, pred:$p)>;
2483
2484 // No need for the size suffix on VSQRT. It's implied by the register classes.
2485 def : VFP2InstAlias<"vsqrt${p} $Sd, $Sm", (VSQRTS SPR:$Sd, SPR:$Sm, pred:$p)>;
2486 def : VFP2DPInstAlias<"vsqrt${p} $Dd, $Dm", (VSQRTD DPR:$Dd, DPR:$Dm, pred:$p)>;
2487
2488 // VLDR/VSTR accept an optional type suffix.
2489 def : VFP2InstAlias<"vldr${p}.32 $Sd, $addr",
2490                     (VLDRS SPR:$Sd, addrmode5:$addr, pred:$p)>;
2491 def : VFP2InstAlias<"vstr${p}.32 $Sd, $addr",
2492                     (VSTRS SPR:$Sd, addrmode5:$addr, pred:$p)>;
2493 def : VFP2InstAlias<"vldr${p}.64 $Dd, $addr",
2494                     (VLDRD DPR:$Dd, addrmode5:$addr, pred:$p)>;
2495 def : VFP2InstAlias<"vstr${p}.64 $Dd, $addr",
2496                     (VSTRD DPR:$Dd, addrmode5:$addr, pred:$p)>;
2497
2498 // VMOV can accept optional 32-bit or less data type suffix suffix.
2499 def : VFP2InstAlias<"vmov${p}.8 $Rt, $Sn",
2500                     (VMOVRS GPR:$Rt, SPR:$Sn, pred:$p)>;
2501 def : VFP2InstAlias<"vmov${p}.16 $Rt, $Sn",
2502                     (VMOVRS GPR:$Rt, SPR:$Sn, pred:$p)>;
2503 def : VFP2InstAlias<"vmov${p}.32 $Rt, $Sn",
2504                     (VMOVRS GPR:$Rt, SPR:$Sn, pred:$p)>;
2505 def : VFP2InstAlias<"vmov${p}.8 $Sn, $Rt",
2506                     (VMOVSR SPR:$Sn, GPR:$Rt, pred:$p)>;
2507 def : VFP2InstAlias<"vmov${p}.16 $Sn, $Rt",
2508                     (VMOVSR SPR:$Sn, GPR:$Rt, pred:$p)>;
2509 def : VFP2InstAlias<"vmov${p}.32 $Sn, $Rt",
2510                     (VMOVSR SPR:$Sn, GPR:$Rt, pred:$p)>;
2511
2512 def : VFP2InstAlias<"vmov${p}.f64 $Rt, $Rt2, $Dn",
2513                     (VMOVRRD GPR:$Rt, GPR:$Rt2, DPR:$Dn, pred:$p)>;
2514 def : VFP2InstAlias<"vmov${p}.f64 $Dn, $Rt, $Rt2",
2515                     (VMOVDRR DPR:$Dn, GPR:$Rt, GPR:$Rt2, pred:$p)>;
2516
2517 // VMOVS doesn't need the .f32 to disambiguate from the NEON encoding the way
2518 // VMOVD does.
2519 def : VFP2InstAlias<"vmov${p} $Sd, $Sm",
2520                     (VMOVS SPR:$Sd, SPR:$Sm, pred:$p)>;
2521
2522 // FCONSTD/FCONSTS alias for vmov.f64/vmov.f32
2523 // These aliases provide added functionality over vmov.f instructions by
2524 // allowing users to write assembly containing encoded floating point constants
2525 // (e.g. #0x70 vs #1.0).  Without these alises there is no way for the
2526 // assembler to accept encoded fp constants (but the equivalent fp-literal is
2527 // accepted directly by vmovf).
2528 def : VFP3InstAlias<"fconstd${p} $Dd, $val",
2529                     (FCONSTD DPR:$Dd, vfp_f64imm:$val, pred:$p)>;
2530 def : VFP3InstAlias<"fconsts${p} $Sd, $val",
2531                     (FCONSTS SPR:$Sd, vfp_f32imm:$val, pred:$p)>;