lib/Target/ARM/ARMInstrVFP.td

   1 //===- ARMInstrVFP.td - VFP support for ARM ----------------*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file describes the ARM VFP instruction set.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 def SDT_FTOI    : SDTypeProfile<1, 1, [SDTCisVT<0, f32>, SDTCisFP<1>]>;
  15 def SDT_ITOF    : SDTypeProfile<1, 1, [SDTCisFP<0>, SDTCisVT<1, f32>]>;
  16 def SDT_CMPFP0  : SDTypeProfile<0, 1, [SDTCisFP<0>]>;
  17 def SDT_VMOVDRR : SDTypeProfile<1, 2, [SDTCisVT<0, f64>, SDTCisVT<1, i32>,
  18                                        SDTCisSameAs<1, 2>]>;
  19
  20 def arm_ftoui  : SDNode<"ARMISD::FTOUI",   SDT_FTOI>;
  21 def arm_ftosi  : SDNode<"ARMISD::FTOSI",   SDT_FTOI>;
  22 def arm_sitof  : SDNode<"ARMISD::SITOF",   SDT_ITOF>;
  23 def arm_uitof  : SDNode<"ARMISD::UITOF",   SDT_ITOF>;
  24 def arm_fmstat : SDNode<"ARMISD::FMSTAT",  SDTNone, [SDNPInGlue, SDNPOutGlue]>;
  25 def arm_cmpfp  : SDNode<"ARMISD::CMPFP",   SDT_ARMCmp, [SDNPOutGlue]>;
  26 def arm_cmpfp0 : SDNode<"ARMISD::CMPFPw0", SDT_CMPFP0, [SDNPOutGlue]>;
  27 def arm_fmdrr  : SDNode<"ARMISD::VMOVDRR", SDT_VMOVDRR>;
  28
  29
  30 //===----------------------------------------------------------------------===//
  31 // Operand Definitions.
  32 //
  33
  34 def vfp_f32imm : Operand<f32>,
  35                  PatLeaf<(f32 fpimm), [{
  36       return ARM::getVFPf32Imm(N->getValueAPF()) != -1;
  37     }]> {
  38   let PrintMethod = "printVFPf32ImmOperand";
  39   let DecoderMethod = "DecodeVFPfpImm";
  40 }
  41
  42 def vfp_f64imm : Operand<f64>,
  43                  PatLeaf<(f64 fpimm), [{
  44       return ARM::getVFPf64Imm(N->getValueAPF()) != -1;
  45     }]> {
  46   let PrintMethod = "printVFPf64ImmOperand";
  47   let DecoderMethod = "DecodeVFPfpImm";
  48 }
  49
  50
  51 //===----------------------------------------------------------------------===//
  52 //  Load / store Instructions.
  53 //
  54
  55 let canFoldAsLoad = 1, isReMaterializable = 1 in {
  56
  57 def VLDRD : ADI5<0b1101, 0b01, (outs DPR:$Dd), (ins addrmode5:$addr),
  58                  IIC_fpLoad64, "vldr", ".64\t$Dd, $addr",
  59                  [(set DPR:$Dd, (f64 (load addrmode5:$addr)))]>;
  60
  61 def VLDRS : ASI5<0b1101, 0b01, (outs SPR:$Sd), (ins addrmode5:$addr),
  62                  IIC_fpLoad32, "vldr", ".32\t$Sd, $addr",
  63                  [(set SPR:$Sd, (load addrmode5:$addr))]> {
  64   // Some single precision VFP instructions may be executed on both NEON and VFP
  65   // pipelines.
  66   let D = VFPNeonDomain;
  67 }
  68
  69 } // End of 'let canFoldAsLoad = 1, isReMaterializable = 1 in'
  70
  71 def VSTRD : ADI5<0b1101, 0b00, (outs), (ins DPR:$Dd, addrmode5:$addr),
  72                  IIC_fpStore64, "vstr", ".64\t$Dd, $addr",
  73                  [(store (f64 DPR:$Dd), addrmode5:$addr)]>;
  74
  75 def VSTRS : ASI5<0b1101, 0b00, (outs), (ins SPR:$Sd, addrmode5:$addr),
  76                  IIC_fpStore32, "vstr", ".32\t$Sd, $addr",
  77                  [(store SPR:$Sd, addrmode5:$addr)]> {
  78   // Some single precision VFP instructions may be executed on both NEON and VFP
  79   // pipelines.
  80   let D = VFPNeonDomain;
  81 }
  82
  83 //===----------------------------------------------------------------------===//
  84 //  Load / store multiple Instructions.
  85 //
  86
  87 multiclass vfp_ldst_mult<string asm, bit L_bit,
  88                          InstrItinClass itin, InstrItinClass itin_upd> {
  89   // Double Precision
  90   def DIA :
  91     AXDI4<(outs), (ins GPR:$Rn, pred:$p, dpr_reglist:$regs, variable_ops),
  92           IndexModeNone, itin,
  93           !strconcat(asm, "ia${p}\t$Rn, $regs"), "", []> {
  94     let Inst{24-23} = 0b01;       // Increment After
  95     let Inst{21}    = 0;          // No writeback
  96     let Inst{20}    = L_bit;
  97   }
  98   def DIA_UPD :
  99     AXDI4<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, dpr_reglist:$regs,
 100                                variable_ops),
 101           IndexModeUpd, itin_upd,
 102           !strconcat(asm, "ia${p}\t$Rn!, $regs"), "$Rn = $wb", []> {
 103     let Inst{24-23} = 0b01;       // Increment After
 104     let Inst{21}    = 1;          // Writeback
 105     let Inst{20}    = L_bit;
 106   }
 107   def DDB_UPD :
 108     AXDI4<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, dpr_reglist:$regs,
 109                                variable_ops),
 110           IndexModeUpd, itin_upd,
 111           !strconcat(asm, "db${p}\t$Rn!, $regs"), "$Rn = $wb", []> {
 112     let Inst{24-23} = 0b10;       // Decrement Before
 113     let Inst{21}    = 1;          // Writeback
 114     let Inst{20}    = L_bit;
 115   }
 116
 117   // Single Precision
 118   def SIA :
 119     AXSI4<(outs), (ins GPR:$Rn, pred:$p, spr_reglist:$regs, variable_ops),
 120           IndexModeNone, itin,
 121           !strconcat(asm, "ia${p}\t$Rn, $regs"), "", []> {
 122     let Inst{24-23} = 0b01;       // Increment After
 123     let Inst{21}    = 0;          // No writeback
 124     let Inst{20}    = L_bit;
 125
 126     // Some single precision VFP instructions may be executed on both NEON and
 127     // VFP pipelines.
 128     let D = VFPNeonDomain;
 129   }
 130   def SIA_UPD :
 131     AXSI4<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, spr_reglist:$regs,
 132                                variable_ops),
 133           IndexModeUpd, itin_upd,
 134           !strconcat(asm, "ia${p}\t$Rn!, $regs"), "$Rn = $wb", []> {
 135     let Inst{24-23} = 0b01;       // Increment After
 136     let Inst{21}    = 1;          // Writeback
 137     let Inst{20}    = L_bit;
 138
 139     // Some single precision VFP instructions may be executed on both NEON and
 140     // VFP pipelines.
 141     let D = VFPNeonDomain;
 142   }
 143   def SDB_UPD :
 144     AXSI4<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, spr_reglist:$regs,
 145                                variable_ops),
 146           IndexModeUpd, itin_upd,
 147           !strconcat(asm, "db${p}\t$Rn!, $regs"), "$Rn = $wb", []> {
 148     let Inst{24-23} = 0b10;       // Decrement Before
 149     let Inst{21}    = 1;          // Writeback
 150     let Inst{20}    = L_bit;
 151
 152     // Some single precision VFP instructions may be executed on both NEON and
 153     // VFP pipelines.
 154     let D = VFPNeonDomain;
 155   }
 156 }
 157
 158 let neverHasSideEffects = 1 in {
 159
 160 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in
 161 defm VLDM : vfp_ldst_mult<"vldm", 1, IIC_fpLoad_m, IIC_fpLoad_mu>;
 162
 163 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in
 164 defm VSTM : vfp_ldst_mult<"vstm", 0, IIC_fpLoad_m, IIC_fpLoad_mu>;
 165
 166 } // neverHasSideEffects
 167
 168 def : MnemonicAlias<"vldm", "vldmia">;
 169 def : MnemonicAlias<"vstm", "vstmia">;
 170
 171 def : InstAlias<"vpush${p} $r", (VSTMDDB_UPD SP, pred:$p, dpr_reglist:$r)>,
 172                 Requires<[HasVFP2]>;
 173 def : InstAlias<"vpush${p} $r", (VSTMSDB_UPD SP, pred:$p, spr_reglist:$r)>,
 174                 Requires<[HasVFP2]>;
 175 def : InstAlias<"vpop${p} $r",  (VLDMDIA_UPD SP, pred:$p, dpr_reglist:$r)>,
 176                 Requires<[HasVFP2]>;
 177 def : InstAlias<"vpop${p} $r",  (VLDMSIA_UPD SP, pred:$p, spr_reglist:$r)>,
 178                 Requires<[HasVFP2]>;
 179
 180 // FLDMX, FSTMX - mixing S/D registers for pre-armv6 cores
 181
 182 //===----------------------------------------------------------------------===//
 183 // FP Binary Operations.
 184 //
 185
 186 def VADDD  : ADbI<0b11100, 0b11, 0, 0,
 187                   (outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm),
 188                   IIC_fpALU64, "vadd", ".f64\t$Dd, $Dn, $Dm",
 189                   [(set DPR:$Dd, (fadd DPR:$Dn, (f64 DPR:$Dm)))]>;
 190
 191 def VADDS  : ASbIn<0b11100, 0b11, 0, 0,
 192                    (outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm),
 193                    IIC_fpALU32, "vadd", ".f32\t$Sd, $Sn, $Sm",
 194                    [(set SPR:$Sd, (fadd SPR:$Sn, SPR:$Sm))]> {
 195   // Some single precision VFP instructions may be executed on both NEON and
 196   // VFP pipelines on A8.
 197   let D = VFPNeonA8Domain;
 198 }
 199
 200 def VSUBD  : ADbI<0b11100, 0b11, 1, 0,
 201                   (outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm),
 202                   IIC_fpALU64, "vsub", ".f64\t$Dd, $Dn, $Dm",
 203                   [(set DPR:$Dd, (fsub DPR:$Dn, (f64 DPR:$Dm)))]>;
 204
 205 def VSUBS  : ASbIn<0b11100, 0b11, 1, 0,
 206                    (outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm),
 207                    IIC_fpALU32, "vsub", ".f32\t$Sd, $Sn, $Sm",
 208                    [(set SPR:$Sd, (fsub SPR:$Sn, SPR:$Sm))]> {
 209   // Some single precision VFP instructions may be executed on both NEON and
 210   // VFP pipelines on A8.
 211   let D = VFPNeonA8Domain;
 212 }
 213
 214 def VDIVD  : ADbI<0b11101, 0b00, 0, 0,
 215                   (outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm),
 216                   IIC_fpDIV64, "vdiv", ".f64\t$Dd, $Dn, $Dm",
 217                   [(set DPR:$Dd, (fdiv DPR:$Dn, (f64 DPR:$Dm)))]>;
 218
 219 def VDIVS  : ASbI<0b11101, 0b00, 0, 0,
 220                   (outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm),
 221                   IIC_fpDIV32, "vdiv", ".f32\t$Sd, $Sn, $Sm",
 222                   [(set SPR:$Sd, (fdiv SPR:$Sn, SPR:$Sm))]>;
 223
 224 def VMULD  : ADbI<0b11100, 0b10, 0, 0,
 225                   (outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm),
 226                   IIC_fpMUL64, "vmul", ".f64\t$Dd, $Dn, $Dm",
 227                   [(set DPR:$Dd, (fmul DPR:$Dn, (f64 DPR:$Dm)))]>;
 228
 229 def VMULS  : ASbIn<0b11100, 0b10, 0, 0,
 230                    (outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm),
 231                    IIC_fpMUL32, "vmul", ".f32\t$Sd, $Sn, $Sm",
 232                    [(set SPR:$Sd, (fmul SPR:$Sn, SPR:$Sm))]> {
 233   // Some single precision VFP instructions may be executed on both NEON and
 234   // VFP pipelines on A8.
 235   let D = VFPNeonA8Domain;
 236 }
 237
 238 def VNMULD : ADbI<0b11100, 0b10, 1, 0,
 239                   (outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm),
 240                   IIC_fpMUL64, "vnmul", ".f64\t$Dd, $Dn, $Dm",
 241                   [(set DPR:$Dd, (fneg (fmul DPR:$Dn, (f64 DPR:$Dm))))]>;
 242
 243 def VNMULS : ASbI<0b11100, 0b10, 1, 0,
 244                   (outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm),
 245                   IIC_fpMUL32, "vnmul", ".f32\t$Sd, $Sn, $Sm",
 246                   [(set SPR:$Sd, (fneg (fmul SPR:$Sn, SPR:$Sm)))]> {
 247   // Some single precision VFP instructions may be executed on both NEON and
 248   // VFP pipelines on A8.
 249   let D = VFPNeonA8Domain;
 250 }
 251
 252 // Match reassociated forms only if not sign dependent rounding.
 253 def : Pat<(fmul (fneg DPR:$a), (f64 DPR:$b)),
 254           (VNMULD DPR:$a, DPR:$b)>, Requires<[NoHonorSignDependentRounding]>;
 255 def : Pat<(fmul (fneg SPR:$a), SPR:$b),
 256           (VNMULS SPR:$a, SPR:$b)>, Requires<[NoHonorSignDependentRounding]>;
 257
 258 // These are encoded as unary instructions.
 259 let Defs = [FPSCR] in {
 260 def VCMPED : ADuI<0b11101, 0b11, 0b0100, 0b11, 0,
 261                   (outs), (ins DPR:$Dd, DPR:$Dm),
 262                   IIC_fpCMP64, "vcmpe", ".f64\t$Dd, $Dm",
 263                   [(arm_cmpfp DPR:$Dd, (f64 DPR:$Dm))]>;
 264
 265 def VCMPES : ASuI<0b11101, 0b11, 0b0100, 0b11, 0,
 266                   (outs), (ins SPR:$Sd, SPR:$Sm),
 267                   IIC_fpCMP32, "vcmpe", ".f32\t$Sd, $Sm",
 268                   [(arm_cmpfp SPR:$Sd, SPR:$Sm)]> {
 269   // Some single precision VFP instructions may be executed on both NEON and
 270   // VFP pipelines on A8.
 271   let D = VFPNeonA8Domain;
 272 }
 273
 274 // FIXME: Verify encoding after integrated assembler is working.
 275 def VCMPD  : ADuI<0b11101, 0b11, 0b0100, 0b01, 0,
 276                   (outs), (ins DPR:$Dd, DPR:$Dm),
 277                   IIC_fpCMP64, "vcmp", ".f64\t$Dd, $Dm",
 278                   [/* For disassembly only; pattern left blank */]>;
 279
 280 def VCMPS  : ASuI<0b11101, 0b11, 0b0100, 0b01, 0,
 281                   (outs), (ins SPR:$Sd, SPR:$Sm),
 282                   IIC_fpCMP32, "vcmp", ".f32\t$Sd, $Sm",
 283                   [/* For disassembly only; pattern left blank */]> {
 284   // Some single precision VFP instructions may be executed on both NEON and
 285   // VFP pipelines on A8.
 286   let D = VFPNeonA8Domain;
 287 }
 288 } // Defs = [FPSCR]
 289
 290 //===----------------------------------------------------------------------===//
 291 // FP Unary Operations.
 292 //
 293
 294 def VABSD  : ADuI<0b11101, 0b11, 0b0000, 0b11, 0,
 295                   (outs DPR:$Dd), (ins DPR:$Dm),
 296                   IIC_fpUNA64, "vabs", ".f64\t$Dd, $Dm",
 297                   [(set DPR:$Dd, (fabs (f64 DPR:$Dm)))]>;
 298
 299 def VABSS  : ASuIn<0b11101, 0b11, 0b0000, 0b11, 0,
 300                    (outs SPR:$Sd), (ins SPR:$Sm),
 301                    IIC_fpUNA32, "vabs", ".f32\t$Sd, $Sm",
 302                    [(set SPR:$Sd, (fabs SPR:$Sm))]> {
 303   // Some single precision VFP instructions may be executed on both NEON and
 304   // VFP pipelines on A8.
 305   let D = VFPNeonA8Domain;
 306 }
 307
 308 let Defs = [FPSCR] in {
 309 def VCMPEZD : ADuI<0b11101, 0b11, 0b0101, 0b11, 0,
 310                    (outs), (ins DPR:$Dd),
 311                    IIC_fpCMP64, "vcmpe", ".f64\t$Dd, #0",
 312                    [(arm_cmpfp0 (f64 DPR:$Dd))]> {
 313   let Inst{3-0} = 0b0000;
 314   let Inst{5}   = 0;
 315 }
 316
 317 def VCMPEZS : ASuI<0b11101, 0b11, 0b0101, 0b11, 0,
 318                    (outs), (ins SPR:$Sd),
 319                    IIC_fpCMP32, "vcmpe", ".f32\t$Sd, #0",
 320                    [(arm_cmpfp0 SPR:$Sd)]> {
 321   let Inst{3-0} = 0b0000;
 322   let Inst{5}   = 0;
 323
 324   // Some single precision VFP instructions may be executed on both NEON and
 325   // VFP pipelines on A8.
 326   let D = VFPNeonA8Domain;
 327 }
 328
 329 // FIXME: Verify encoding after integrated assembler is working.
 330 def VCMPZD  : ADuI<0b11101, 0b11, 0b0101, 0b01, 0,
 331                    (outs), (ins DPR:$Dd),
 332                    IIC_fpCMP64, "vcmp", ".f64\t$Dd, #0",
 333                    [/* For disassembly only; pattern left blank */]> {
 334   let Inst{3-0} = 0b0000;
 335   let Inst{5}   = 0;
 336 }
 337
 338 def VCMPZS  : ASuI<0b11101, 0b11, 0b0101, 0b01, 0,
 339                    (outs), (ins SPR:$Sd),
 340                    IIC_fpCMP32, "vcmp", ".f32\t$Sd, #0",
 341                    [/* For disassembly only; pattern left blank */]> {
 342   let Inst{3-0} = 0b0000;
 343   let Inst{5}   = 0;
 344
 345   // Some single precision VFP instructions may be executed on both NEON and
 346   // VFP pipelines on A8.
 347   let D = VFPNeonA8Domain;
 348 }
 349 } // Defs = [FPSCR]
 350
 351 def VCVTDS  : ASuI<0b11101, 0b11, 0b0111, 0b11, 0,
 352                    (outs DPR:$Dd), (ins SPR:$Sm),
 353                    IIC_fpCVTDS, "vcvt", ".f64.f32\t$Dd, $Sm",
 354                    [(set DPR:$Dd, (fextend SPR:$Sm))]> {
 355   // Instruction operands.
 356   bits<5> Dd;
 357   bits<5> Sm;
 358
 359   // Encode instruction operands.
 360   let Inst{3-0}   = Sm{4-1};
 361   let Inst{5}     = Sm{0};
 362   let Inst{15-12} = Dd{3-0};
 363   let Inst{22}    = Dd{4};
 364 }
 365
 366 // Special case encoding: bits 11-8 is 0b1011.
 367 def VCVTSD  : VFPAI<(outs SPR:$Sd), (ins DPR:$Dm), VFPUnaryFrm,
 368                     IIC_fpCVTSD, "vcvt", ".f32.f64\t$Sd, $Dm",
 369                     [(set SPR:$Sd, (fround DPR:$Dm))]> {
 370   // Instruction operands.
 371   bits<5> Sd;
 372   bits<5> Dm;
 373
 374   // Encode instruction operands.
 375   let Inst{3-0}   = Dm{3-0};
 376   let Inst{5}     = Dm{4};
 377   let Inst{15-12} = Sd{4-1};
 378   let Inst{22}    = Sd{0};
 379
 380   let Inst{27-23} = 0b11101;
 381   let Inst{21-16} = 0b110111;
 382   let Inst{11-8}  = 0b1011;
 383   let Inst{7-6}   = 0b11;
 384   let Inst{4}     = 0;
 385 }
 386
 387 // Between half-precision and single-precision.  For disassembly only.
 388
 389 // FIXME: Verify encoding after integrated assembler is working.
 390 def VCVTBSH: ASuI<0b11101, 0b11, 0b0010, 0b01, 0, (outs SPR:$Sd), (ins SPR:$Sm),
 391                  /* FIXME */ IIC_fpCVTSH, "vcvtb", ".f32.f16\t$Sd, $Sm",
 392                  [/* For disassembly only; pattern left blank */]>;
 393
 394 def : ARMPat<(f32_to_f16 SPR:$a),
 395              (i32 (COPY_TO_REGCLASS (VCVTBSH SPR:$a), GPR))>;
 396
 397 def VCVTBHS: ASuI<0b11101, 0b11, 0b0011, 0b01, 0, (outs SPR:$Sd), (ins SPR:$Sm),
 398                  /* FIXME */ IIC_fpCVTHS, "vcvtb", ".f16.f32\t$Sd, $Sm",
 399                  [/* For disassembly only; pattern left blank */]>;
 400
 401 def : ARMPat<(f16_to_f32 GPR:$a),
 402              (VCVTBHS (COPY_TO_REGCLASS GPR:$a, SPR))>;
 403
 404 def VCVTTSH: ASuI<0b11101, 0b11, 0b0010, 0b11, 0, (outs SPR:$Sd), (ins SPR:$Sm),
 405                  /* FIXME */ IIC_fpCVTSH, "vcvtt", ".f32.f16\t$Sd, $Sm",
 406                  [/* For disassembly only; pattern left blank */]>;
 407
 408 def VCVTTHS: ASuI<0b11101, 0b11, 0b0011, 0b11, 0, (outs SPR:$Sd), (ins SPR:$Sm),
 409                  /* FIXME */ IIC_fpCVTHS, "vcvtt", ".f16.f32\t$Sd, $Sm",
 410                  [/* For disassembly only; pattern left blank */]>;
 411
 412 def VNEGD  : ADuI<0b11101, 0b11, 0b0001, 0b01, 0,
 413                   (outs DPR:$Dd), (ins DPR:$Dm),
 414                   IIC_fpUNA64, "vneg", ".f64\t$Dd, $Dm",
 415                   [(set DPR:$Dd, (fneg (f64 DPR:$Dm)))]>;
 416
 417 def VNEGS  : ASuIn<0b11101, 0b11, 0b0001, 0b01, 0,
 418                    (outs SPR:$Sd), (ins SPR:$Sm),
 419                    IIC_fpUNA32, "vneg", ".f32\t$Sd, $Sm",
 420                    [(set SPR:$Sd, (fneg SPR:$Sm))]> {
 421   // Some single precision VFP instructions may be executed on both NEON and
 422   // VFP pipelines on A8.
 423   let D = VFPNeonA8Domain;
 424 }
 425
 426 def VSQRTD : ADuI<0b11101, 0b11, 0b0001, 0b11, 0,
 427                   (outs DPR:$Dd), (ins DPR:$Dm),
 428                   IIC_fpSQRT64, "vsqrt", ".f64\t$Dd, $Dm",
 429                   [(set DPR:$Dd, (fsqrt (f64 DPR:$Dm)))]>;
 430
 431 def VSQRTS : ASuI<0b11101, 0b11, 0b0001, 0b11, 0,
 432                   (outs SPR:$Sd), (ins SPR:$Sm),
 433                   IIC_fpSQRT32, "vsqrt", ".f32\t$Sd, $Sm",
 434                   [(set SPR:$Sd, (fsqrt SPR:$Sm))]>;
 435
 436 let neverHasSideEffects = 1 in {
 437 def VMOVD  : ADuI<0b11101, 0b11, 0b0000, 0b01, 0,
 438                   (outs DPR:$Dd), (ins DPR:$Dm),
 439                   IIC_fpUNA64, "vmov", ".f64\t$Dd, $Dm", []>;
 440
 441 def VMOVS  : ASuI<0b11101, 0b11, 0b0000, 0b01, 0,
 442                   (outs SPR:$Sd), (ins SPR:$Sm),
 443                   IIC_fpUNA32, "vmov", ".f32\t$Sd, $Sm", []>;
 444 } // neverHasSideEffects
 445
 446 //===----------------------------------------------------------------------===//
 447 // FP <-> GPR Copies.  Int <-> FP Conversions.
 448 //
 449
 450 def VMOVRS : AVConv2I<0b11100001, 0b1010,
 451                       (outs GPR:$Rt), (ins SPR:$Sn),
 452                       IIC_fpMOVSI, "vmov", "\t$Rt, $Sn",
 453                       [(set GPR:$Rt, (bitconvert SPR:$Sn))]> {
 454   // Instruction operands.
 455   bits<4> Rt;
 456   bits<5> Sn;
 457
 458   // Encode instruction operands.
 459   let Inst{19-16} = Sn{4-1};
 460   let Inst{7}     = Sn{0};
 461   let Inst{15-12} = Rt;
 462
 463   let Inst{6-5}   = 0b00;
 464   let Inst{3-0}   = 0b0000;
 465
 466   // Some single precision VFP instructions may be executed on both NEON and VFP
 467   // pipelines.
 468   let D = VFPNeonDomain;
 469 }
 470
 471 def VMOVSR : AVConv4I<0b11100000, 0b1010,
 472                       (outs SPR:$Sn), (ins GPR:$Rt),
 473                       IIC_fpMOVIS, "vmov", "\t$Sn, $Rt",
 474                       [(set SPR:$Sn, (bitconvert GPR:$Rt))]> {
 475   // Instruction operands.
 476   bits<5> Sn;
 477   bits<4> Rt;
 478
 479   // Encode instruction operands.
 480   let Inst{19-16} = Sn{4-1};
 481   let Inst{7}     = Sn{0};
 482   let Inst{15-12} = Rt;
 483
 484   let Inst{6-5}   = 0b00;
 485   let Inst{3-0}   = 0b0000;
 486
 487   // Some single precision VFP instructions may be executed on both NEON and VFP
 488   // pipelines.
 489   let D = VFPNeonDomain;
 490 }
 491
 492 let neverHasSideEffects = 1 in {
 493 def VMOVRRD  : AVConv3I<0b11000101, 0b1011,
 494                         (outs GPR:$Rt, GPR:$Rt2), (ins DPR:$Dm),
 495                         IIC_fpMOVDI, "vmov", "\t$Rt, $Rt2, $Dm",
 496                  [/* FIXME: Can't write pattern for multiple result instr*/]> {
 497   // Instruction operands.
 498   bits<5> Dm;
 499   bits<4> Rt;
 500   bits<4> Rt2;
 501
 502   // Encode instruction operands.
 503   let Inst{3-0}   = Dm{3-0};
 504   let Inst{5}     = Dm{4};
 505   let Inst{15-12} = Rt;
 506   let Inst{19-16} = Rt2;
 507
 508   let Inst{7-6} = 0b00;
 509
 510   // Some single precision VFP instructions may be executed on both NEON and VFP
 511   // pipelines.
 512   let D = VFPNeonDomain;
 513 }
 514
 515 def VMOVRRS  : AVConv3I<0b11000101, 0b1010,
 516                       (outs GPR:$wb, GPR:$dst2), (ins SPR:$src1, SPR:$src2),
 517                  IIC_fpMOVDI, "vmov", "\t$wb, $dst2, $src1, $src2",
 518                  [/* For disassembly only; pattern left blank */]> {
 519   let Inst{7-6} = 0b00;
 520
 521   // Some single precision VFP instructions may be executed on both NEON and VFP
 522   // pipelines.
 523   let D = VFPNeonDomain;
 524   let DecoderMethod = "DecodeVMOVRRS";
 525 }
 526 } // neverHasSideEffects
 527
 528 // FMDHR: GPR -> SPR
 529 // FMDLR: GPR -> SPR
 530
 531 def VMOVDRR : AVConv5I<0b11000100, 0b1011,
 532                       (outs DPR:$Dm), (ins GPR:$Rt, GPR:$Rt2),
 533                       IIC_fpMOVID, "vmov", "\t$Dm, $Rt, $Rt2",
 534                       [(set DPR:$Dm, (arm_fmdrr GPR:$Rt, GPR:$Rt2))]> {
 535   // Instruction operands.
 536   bits<5> Dm;
 537   bits<4> Rt;
 538   bits<4> Rt2;
 539
 540   // Encode instruction operands.
 541   let Inst{3-0}   = Dm{3-0};
 542   let Inst{5}     = Dm{4};
 543   let Inst{15-12} = Rt;
 544   let Inst{19-16} = Rt2;
 545
 546   let Inst{7-6}   = 0b00;
 547
 548   // Some single precision VFP instructions may be executed on both NEON and VFP
 549   // pipelines.
 550   let D = VFPNeonDomain;
 551 }
 552
 553 let neverHasSideEffects = 1 in
 554 def VMOVSRR : AVConv5I<0b11000100, 0b1010,
 555                      (outs SPR:$dst1, SPR:$dst2), (ins GPR:$src1, GPR:$src2),
 556                 IIC_fpMOVID, "vmov", "\t$dst1, $dst2, $src1, $src2",
 557                 [/* For disassembly only; pattern left blank */]> {
 558   let Inst{7-6} = 0b00;
 559
 560   // Some single precision VFP instructions may be executed on both NEON and VFP
 561   // pipelines.
 562   let D = VFPNeonDomain;
 563
 564   let DecoderMethod = "DecodeVMOVSRR";
 565 }
 566
 567 // FMRDH: SPR -> GPR
 568 // FMRDL: SPR -> GPR
 569 // FMRRS: SPR -> GPR
 570 // FMRX:  SPR system reg -> GPR
 571 // FMSRR: GPR -> SPR
 572 // FMXR:  GPR -> VFP system reg
 573
 574
 575 // Int -> FP:
 576
 577 class AVConv1IDs_Encode<bits<5> opcod1, bits<2> opcod2, bits<4> opcod3,
 578                         bits<4> opcod4, dag oops, dag iops,
 579                         InstrItinClass itin, string opc, string asm,
 580                         list<dag> pattern>
 581   : AVConv1I<opcod1, opcod2, opcod3, opcod4, oops, iops, itin, opc, asm,
 582              pattern> {
 583   // Instruction operands.
 584   bits<5> Dd;
 585   bits<5> Sm;
 586
 587   // Encode instruction operands.
 588   let Inst{3-0}   = Sm{4-1};
 589   let Inst{5}     = Sm{0};
 590   let Inst{15-12} = Dd{3-0};
 591   let Inst{22}    = Dd{4};
 592 }
 593
 594 class AVConv1InSs_Encode<bits<5> opcod1, bits<2> opcod2, bits<4> opcod3,
 595                          bits<4> opcod4, dag oops, dag iops,InstrItinClass itin,
 596                          string opc, string asm, list<dag> pattern>
 597   : AVConv1In<opcod1, opcod2, opcod3, opcod4, oops, iops, itin, opc, asm,
 598               pattern> {
 599   // Instruction operands.
 600   bits<5> Sd;
 601   bits<5> Sm;
 602
 603   // Encode instruction operands.
 604   let Inst{3-0}   = Sm{4-1};
 605   let Inst{5}     = Sm{0};
 606   let Inst{15-12} = Sd{4-1};
 607   let Inst{22}    = Sd{0};
 608 }
 609
 610 def VSITOD : AVConv1IDs_Encode<0b11101, 0b11, 0b1000, 0b1011,
 611                                (outs DPR:$Dd), (ins SPR:$Sm),
 612                                IIC_fpCVTID, "vcvt", ".f64.s32\t$Dd, $Sm",
 613                                [(set DPR:$Dd, (f64 (arm_sitof SPR:$Sm)))]> {
 614   let Inst{7} = 1; // s32
 615 }
 616
 617 def VSITOS : AVConv1InSs_Encode<0b11101, 0b11, 0b1000, 0b1010,
 618                                 (outs SPR:$Sd),(ins SPR:$Sm),
 619                                 IIC_fpCVTIS, "vcvt", ".f32.s32\t$Sd, $Sm",
 620                                 [(set SPR:$Sd, (arm_sitof SPR:$Sm))]> {
 621   let Inst{7} = 1; // s32
 622
 623   // Some single precision VFP instructions may be executed on both NEON and
 624   // VFP pipelines on A8.
 625   let D = VFPNeonA8Domain;
 626 }
 627
 628 def VUITOD : AVConv1IDs_Encode<0b11101, 0b11, 0b1000, 0b1011,
 629                                (outs DPR:$Dd), (ins SPR:$Sm),
 630                                IIC_fpCVTID, "vcvt", ".f64.u32\t$Dd, $Sm",
 631                                [(set DPR:$Dd, (f64 (arm_uitof SPR:$Sm)))]> {
 632   let Inst{7} = 0; // u32
 633 }
 634
 635 def VUITOS : AVConv1InSs_Encode<0b11101, 0b11, 0b1000, 0b1010,
 636                                 (outs SPR:$Sd), (ins SPR:$Sm),
 637                                 IIC_fpCVTIS, "vcvt", ".f32.u32\t$Sd, $Sm",
 638                                 [(set SPR:$Sd, (arm_uitof SPR:$Sm))]> {
 639   let Inst{7} = 0; // u32
 640
 641   // Some single precision VFP instructions may be executed on both NEON and
 642   // VFP pipelines on A8.
 643   let D = VFPNeonA8Domain;
 644 }
 645
 646 // FP -> Int:
 647
 648 class AVConv1IsD_Encode<bits<5> opcod1, bits<2> opcod2, bits<4> opcod3,
 649                         bits<4> opcod4, dag oops, dag iops,
 650                         InstrItinClass itin, string opc, string asm,
 651                         list<dag> pattern>
 652   : AVConv1I<opcod1, opcod2, opcod3, opcod4, oops, iops, itin, opc, asm,
 653              pattern> {
 654   // Instruction operands.
 655   bits<5> Sd;
 656   bits<5> Dm;
 657
 658   // Encode instruction operands.
 659   let Inst{3-0}   = Dm{3-0};
 660   let Inst{5}     = Dm{4};
 661   let Inst{15-12} = Sd{4-1};
 662   let Inst{22}    = Sd{0};
 663 }
 664
 665 class AVConv1InsS_Encode<bits<5> opcod1, bits<2> opcod2, bits<4> opcod3,
 666                          bits<4> opcod4, dag oops, dag iops,
 667                          InstrItinClass itin, string opc, string asm,
 668                          list<dag> pattern>
 669   : AVConv1In<opcod1, opcod2, opcod3, opcod4, oops, iops, itin, opc, asm,
 670               pattern> {
 671   // Instruction operands.
 672   bits<5> Sd;
 673   bits<5> Sm;
 674
 675   // Encode instruction operands.
 676   let Inst{3-0}   = Sm{4-1};
 677   let Inst{5}     = Sm{0};
 678   let Inst{15-12} = Sd{4-1};
 679   let Inst{22}    = Sd{0};
 680 }
 681
 682 // Always set Z bit in the instruction, i.e. "round towards zero" variants.
 683 def VTOSIZD : AVConv1IsD_Encode<0b11101, 0b11, 0b1101, 0b1011,
 684                                 (outs SPR:$Sd), (ins DPR:$Dm),
 685                                 IIC_fpCVTDI, "vcvt", ".s32.f64\t$Sd, $Dm",
 686                                 [(set SPR:$Sd, (arm_ftosi (f64 DPR:$Dm)))]> {
 687   let Inst{7} = 1; // Z bit
 688 }
 689
 690 def VTOSIZS : AVConv1InsS_Encode<0b11101, 0b11, 0b1101, 0b1010,
 691                                  (outs SPR:$Sd), (ins SPR:$Sm),
 692                                  IIC_fpCVTSI, "vcvt", ".s32.f32\t$Sd, $Sm",
 693                                  [(set SPR:$Sd, (arm_ftosi SPR:$Sm))]> {
 694   let Inst{7} = 1; // Z bit
 695
 696   // Some single precision VFP instructions may be executed on both NEON and
 697   // VFP pipelines on A8.
 698   let D = VFPNeonA8Domain;
 699 }
 700
 701 def VTOUIZD : AVConv1IsD_Encode<0b11101, 0b11, 0b1100, 0b1011,
 702                                (outs SPR:$Sd), (ins DPR:$Dm),
 703                                IIC_fpCVTDI, "vcvt", ".u32.f64\t$Sd, $Dm",
 704                                [(set SPR:$Sd, (arm_ftoui (f64 DPR:$Dm)))]> {
 705   let Inst{7} = 1; // Z bit
 706 }
 707
 708 def VTOUIZS : AVConv1InsS_Encode<0b11101, 0b11, 0b1100, 0b1010,
 709                                  (outs SPR:$Sd), (ins SPR:$Sm),
 710                                  IIC_fpCVTSI, "vcvt", ".u32.f32\t$Sd, $Sm",
 711                                  [(set SPR:$Sd, (arm_ftoui SPR:$Sm))]> {
 712   let Inst{7} = 1; // Z bit
 713
 714   // Some single precision VFP instructions may be executed on both NEON and
 715   // VFP pipelines on A8.
 716   let D = VFPNeonA8Domain;
 717 }
 718
 719 // And the Z bit '0' variants, i.e. use the rounding mode specified by FPSCR.
 720 let Uses = [FPSCR] in {
 721 // FIXME: Verify encoding after integrated assembler is working.
 722 def VTOSIRD : AVConv1IsD_Encode<0b11101, 0b11, 0b1101, 0b1011,
 723                                 (outs SPR:$Sd), (ins DPR:$Dm),
 724                                 IIC_fpCVTDI, "vcvtr", ".s32.f64\t$Sd, $Dm",
 725                                 [(set SPR:$Sd, (int_arm_vcvtr (f64 DPR:$Dm)))]>{
 726   let Inst{7} = 0; // Z bit
 727 }
 728
 729 def VTOSIRS : AVConv1InsS_Encode<0b11101, 0b11, 0b1101, 0b1010,
 730                                  (outs SPR:$Sd), (ins SPR:$Sm),
 731                                  IIC_fpCVTSI, "vcvtr", ".s32.f32\t$Sd, $Sm",
 732                                  [(set SPR:$Sd, (int_arm_vcvtr SPR:$Sm))]> {
 733   let Inst{7} = 0; // Z bit
 734 }
 735
 736 def VTOUIRD : AVConv1IsD_Encode<0b11101, 0b11, 0b1100, 0b1011,
 737                                 (outs SPR:$Sd), (ins DPR:$Dm),
 738                                 IIC_fpCVTDI, "vcvtr", ".u32.f64\t$Sd, $Dm",
 739                                 [(set SPR:$Sd, (int_arm_vcvtru(f64 DPR:$Dm)))]>{
 740   let Inst{7} = 0; // Z bit
 741 }
 742
 743 def VTOUIRS : AVConv1InsS_Encode<0b11101, 0b11, 0b1100, 0b1010,
 744                                  (outs SPR:$Sd), (ins SPR:$Sm),
 745                                  IIC_fpCVTSI, "vcvtr", ".u32.f32\t$Sd, $Sm",
 746                                  [(set SPR:$Sd, (int_arm_vcvtru SPR:$Sm))]> {
 747   let Inst{7} = 0; // Z bit
 748 }
 749 }
 750
 751 // Convert between floating-point and fixed-point
 752 // Data type for fixed-point naming convention:
 753 //   S16 (U=0, sx=0) -> SH
 754 //   U16 (U=1, sx=0) -> UH
 755 //   S32 (U=0, sx=1) -> SL
 756 //   U32 (U=1, sx=1) -> UL
 757
 758 // FIXME: Marking these as codegen only seems wrong. They are real
 759 //        instructions(?)
 760 let Constraints = "$a = $dst", isCodeGenOnly = 1 in {
 761
 762 // FP to Fixed-Point:
 763
 764 def VTOSHS : AVConv1XI<0b11101, 0b11, 0b1110, 0b1010, 0,
 765                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 766                  IIC_fpCVTSI, "vcvt", ".s16.f32\t$dst, $a, $fbits",
 767                  [/* For disassembly only; pattern left blank */]> {
 768   // Some single precision VFP instructions may be executed on both NEON and
 769   // VFP pipelines on A8.
 770   let D = VFPNeonA8Domain;
 771 }
 772
 773 def VTOUHS : AVConv1XI<0b11101, 0b11, 0b1111, 0b1010, 0,
 774                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 775                  IIC_fpCVTSI, "vcvt", ".u16.f32\t$dst, $a, $fbits",
 776                  [/* For disassembly only; pattern left blank */]> {
 777   // Some single precision VFP instructions may be executed on both NEON and
 778   // VFP pipelines on A8.
 779   let D = VFPNeonA8Domain;
 780 }
 781
 782 def VTOSLS : AVConv1XI<0b11101, 0b11, 0b1110, 0b1010, 1,
 783                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 784                  IIC_fpCVTSI, "vcvt", ".s32.f32\t$dst, $a, $fbits",
 785                  [/* For disassembly only; pattern left blank */]> {
 786   // Some single precision VFP instructions may be executed on both NEON and
 787   // VFP pipelines on A8.
 788   let D = VFPNeonA8Domain;
 789 }
 790
 791 def VTOULS : AVConv1XI<0b11101, 0b11, 0b1111, 0b1010, 1,
 792                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 793                  IIC_fpCVTSI, "vcvt", ".u32.f32\t$dst, $a, $fbits",
 794                  [/* For disassembly only; pattern left blank */]> {
 795   // Some single precision VFP instructions may be executed on both NEON and
 796   // VFP pipelines on A8.
 797   let D = VFPNeonA8Domain;
 798 }
 799
 800 def VTOSHD : AVConv1XI<0b11101, 0b11, 0b1110, 0b1011, 0,
 801                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 802                  IIC_fpCVTDI, "vcvt", ".s16.f64\t$dst, $a, $fbits",
 803                  [/* For disassembly only; pattern left blank */]>;
 804
 805 def VTOUHD : AVConv1XI<0b11101, 0b11, 0b1111, 0b1011, 0,
 806                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 807                  IIC_fpCVTDI, "vcvt", ".u16.f64\t$dst, $a, $fbits",
 808                  [/* For disassembly only; pattern left blank */]>;
 809
 810 def VTOSLD : AVConv1XI<0b11101, 0b11, 0b1110, 0b1011, 1,
 811                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 812                  IIC_fpCVTDI, "vcvt", ".s32.f64\t$dst, $a, $fbits",
 813                  [/* For disassembly only; pattern left blank */]>;
 814
 815 def VTOULD : AVConv1XI<0b11101, 0b11, 0b1111, 0b1011, 1,
 816                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 817                  IIC_fpCVTDI, "vcvt", ".u32.f64\t$dst, $a, $fbits",
 818                  [/* For disassembly only; pattern left blank */]>;
 819
 820 // Fixed-Point to FP:
 821
 822 def VSHTOS : AVConv1XI<0b11101, 0b11, 0b1010, 0b1010, 0,
 823                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 824                  IIC_fpCVTIS, "vcvt", ".f32.s16\t$dst, $a, $fbits",
 825                  [/* For disassembly only; pattern left blank */]> {
 826   // Some single precision VFP instructions may be executed on both NEON and
 827   // VFP pipelines on A8.
 828   let D = VFPNeonA8Domain;
 829 }
 830
 831 def VUHTOS : AVConv1XI<0b11101, 0b11, 0b1011, 0b1010, 0,
 832                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 833                  IIC_fpCVTIS, "vcvt", ".f32.u16\t$dst, $a, $fbits",
 834                  [/* For disassembly only; pattern left blank */]> {
 835   // Some single precision VFP instructions may be executed on both NEON and
 836   // VFP pipelines on A8.
 837   let D = VFPNeonA8Domain;
 838 }
 839
 840 def VSLTOS : AVConv1XI<0b11101, 0b11, 0b1010, 0b1010, 1,
 841                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 842                  IIC_fpCVTIS, "vcvt", ".f32.s32\t$dst, $a, $fbits",
 843                  [/* For disassembly only; pattern left blank */]> {
 844   // Some single precision VFP instructions may be executed on both NEON and
 845   // VFP pipelines on A8.
 846   let D = VFPNeonA8Domain;
 847 }
 848
 849 def VULTOS : AVConv1XI<0b11101, 0b11, 0b1011, 0b1010, 1,
 850                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 851                  IIC_fpCVTIS, "vcvt", ".f32.u32\t$dst, $a, $fbits",
 852                  [/* For disassembly only; pattern left blank */]> {
 853   // Some single precision VFP instructions may be executed on both NEON and
 854   // VFP pipelines on A8.
 855   let D = VFPNeonA8Domain;
 856 }
 857
 858 def VSHTOD : AVConv1XI<0b11101, 0b11, 0b1010, 0b1011, 0,
 859                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 860                  IIC_fpCVTID, "vcvt", ".f64.s16\t$dst, $a, $fbits",
 861                  [/* For disassembly only; pattern left blank */]>;
 862
 863 def VUHTOD : AVConv1XI<0b11101, 0b11, 0b1011, 0b1011, 0,
 864                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 865                  IIC_fpCVTID, "vcvt", ".f64.u16\t$dst, $a, $fbits",
 866                  [/* For disassembly only; pattern left blank */]>;
 867
 868 def VSLTOD : AVConv1XI<0b11101, 0b11, 0b1010, 0b1011, 1,
 869                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 870                  IIC_fpCVTID, "vcvt", ".f64.s32\t$dst, $a, $fbits",
 871                  [/* For disassembly only; pattern left blank */]>;
 872
 873 def VULTOD : AVConv1XI<0b11101, 0b11, 0b1011, 0b1011, 1,
 874                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 875                  IIC_fpCVTID, "vcvt", ".f64.u32\t$dst, $a, $fbits",
 876                  [/* For disassembly only; pattern left blank */]>;
 877
 878 } // End of 'let Constraints = "$a = $dst", isCodeGenOnly = 1 in'
 879
 880 //===----------------------------------------------------------------------===//
 881 // FP Multiply-Accumulate Operations.
 882 //
 883
 884 def VMLAD : ADbI<0b11100, 0b00, 0, 0,
 885                  (outs DPR:$Dd), (ins DPR:$Ddin, DPR:$Dn, DPR:$Dm),
 886                  IIC_fpMAC64, "vmla", ".f64\t$Dd, $Dn, $Dm",
 887                  [(set DPR:$Dd, (fadd_mlx (fmul_su DPR:$Dn, DPR:$Dm),
 888                                           (f64 DPR:$Ddin)))]>,
 889               RegConstraint<"$Ddin = $Dd">,
 890               Requires<[HasVFP2,UseFPVMLx]>;
 891
 892 def VMLAS : ASbIn<0b11100, 0b00, 0, 0,
 893                   (outs SPR:$Sd), (ins SPR:$Sdin, SPR:$Sn, SPR:$Sm),
 894                   IIC_fpMAC32, "vmla", ".f32\t$Sd, $Sn, $Sm",
 895                   [(set SPR:$Sd, (fadd_mlx (fmul_su SPR:$Sn, SPR:$Sm),
 896                                            SPR:$Sdin))]>,
 897               RegConstraint<"$Sdin = $Sd">,
 898               Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]> {
 899   // Some single precision VFP instructions may be executed on both NEON and
 900   // VFP pipelines on A8.
 901   let D = VFPNeonA8Domain;
 902 }
 903
 904 def : Pat<(fadd_mlx DPR:$dstin, (fmul_su DPR:$a, (f64 DPR:$b))),
 905           (VMLAD DPR:$dstin, DPR:$a, DPR:$b)>,
 906           Requires<[HasVFP2,UseFPVMLx]>;
 907 def : Pat<(fadd_mlx SPR:$dstin, (fmul_su SPR:$a, SPR:$b)),
 908           (VMLAS SPR:$dstin, SPR:$a, SPR:$b)>,
 909           Requires<[HasVFP2,DontUseNEONForFP, UseFPVMLx]>;
 910
 911 def VMLSD : ADbI<0b11100, 0b00, 1, 0,
 912                  (outs DPR:$Dd), (ins DPR:$Ddin, DPR:$Dn, DPR:$Dm),
 913                  IIC_fpMAC64, "vmls", ".f64\t$Dd, $Dn, $Dm",
 914                  [(set DPR:$Dd, (fadd_mlx (fneg (fmul_su DPR:$Dn,DPR:$Dm)),
 915                                           (f64 DPR:$Ddin)))]>,
 916               RegConstraint<"$Ddin = $Dd">,
 917               Requires<[HasVFP2,UseFPVMLx]>;
 918
 919 def VMLSS : ASbIn<0b11100, 0b00, 1, 0,
 920                   (outs SPR:$Sd), (ins SPR:$Sdin, SPR:$Sn, SPR:$Sm),
 921                   IIC_fpMAC32, "vmls", ".f32\t$Sd, $Sn, $Sm",
 922                   [(set SPR:$Sd, (fadd_mlx (fneg (fmul_su SPR:$Sn, SPR:$Sm)),
 923                                            SPR:$Sdin))]>,
 924               RegConstraint<"$Sdin = $Sd">,
 925               Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]> {
 926   // Some single precision VFP instructions may be executed on both NEON and
 927   // VFP pipelines on A8.
 928   let D = VFPNeonA8Domain;
 929 }
 930
 931 def : Pat<(fsub_mlx DPR:$dstin, (fmul_su DPR:$a, (f64 DPR:$b))),
 932           (VMLSD DPR:$dstin, DPR:$a, DPR:$b)>,
 933           Requires<[HasVFP2,UseFPVMLx]>;
 934 def : Pat<(fsub_mlx SPR:$dstin, (fmul_su SPR:$a, SPR:$b)),
 935           (VMLSS SPR:$dstin, SPR:$a, SPR:$b)>,
 936           Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]>;
 937
 938 def VNMLAD : ADbI<0b11100, 0b01, 1, 0,
 939                   (outs DPR:$Dd), (ins DPR:$Ddin, DPR:$Dn, DPR:$Dm),
 940                   IIC_fpMAC64, "vnmla", ".f64\t$Dd, $Dn, $Dm",
 941                   [(set DPR:$Dd,(fsub_mlx (fneg (fmul_su DPR:$Dn,DPR:$Dm)),
 942                                           (f64 DPR:$Ddin)))]>,
 943                 RegConstraint<"$Ddin = $Dd">,
 944                 Requires<[HasVFP2,UseFPVMLx]>;
 945
 946 def VNMLAS : ASbI<0b11100, 0b01, 1, 0,
 947                   (outs SPR:$Sd), (ins SPR:$Sdin, SPR:$Sn, SPR:$Sm),
 948                   IIC_fpMAC32, "vnmla", ".f32\t$Sd, $Sn, $Sm",
 949                   [(set SPR:$Sd, (fsub_mlx (fneg (fmul_su SPR:$Sn, SPR:$Sm)),
 950                                            SPR:$Sdin))]>,
 951                 RegConstraint<"$Sdin = $Sd">,
 952                 Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]> {
 953   // Some single precision VFP instructions may be executed on both NEON and
 954   // VFP pipelines on A8.
 955   let D = VFPNeonA8Domain;
 956 }
 957
 958 def : Pat<(fsub_mlx (fneg (fmul_su DPR:$a, (f64 DPR:$b))), DPR:$dstin),
 959           (VNMLAD DPR:$dstin, DPR:$a, DPR:$b)>,
 960           Requires<[HasVFP2,UseFPVMLx]>;
 961 def : Pat<(fsub_mlx (fneg (fmul_su SPR:$a, SPR:$b)), SPR:$dstin),
 962           (VNMLAS SPR:$dstin, SPR:$a, SPR:$b)>,
 963           Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]>;
 964
 965 def VNMLSD : ADbI<0b11100, 0b01, 0, 0,
 966                   (outs DPR:$Dd), (ins DPR:$Ddin, DPR:$Dn, DPR:$Dm),
 967                   IIC_fpMAC64, "vnmls", ".f64\t$Dd, $Dn, $Dm",
 968                   [(set DPR:$Dd, (fsub_mlx (fmul_su DPR:$Dn, DPR:$Dm),
 969                                            (f64 DPR:$Ddin)))]>,
 970                RegConstraint<"$Ddin = $Dd">,
 971                Requires<[HasVFP2,UseFPVMLx]>;
 972
 973 def VNMLSS : ASbI<0b11100, 0b01, 0, 0,
 974                   (outs SPR:$Sd), (ins SPR:$Sdin, SPR:$Sn, SPR:$Sm),
 975                   IIC_fpMAC32, "vnmls", ".f32\t$Sd, $Sn, $Sm",
 976              [(set SPR:$Sd, (fsub_mlx (fmul_su SPR:$Sn, SPR:$Sm), SPR:$Sdin))]>,
 977                          RegConstraint<"$Sdin = $Sd">,
 978                   Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]> {
 979   // Some single precision VFP instructions may be executed on both NEON and
 980   // VFP pipelines on A8.
 981   let D = VFPNeonA8Domain;
 982 }
 983
 984 def : Pat<(fsub_mlx (fmul_su DPR:$a, (f64 DPR:$b)), DPR:$dstin),
 985           (VNMLSD DPR:$dstin, DPR:$a, DPR:$b)>,
 986           Requires<[HasVFP2,UseFPVMLx]>;
 987 def : Pat<(fsub_mlx (fmul_su SPR:$a, SPR:$b), SPR:$dstin),
 988           (VNMLSS SPR:$dstin, SPR:$a, SPR:$b)>,
 989           Requires<[HasVFP2,DontUseNEONForFP,UseFPVMLx]>;
 990
 991
 992 //===----------------------------------------------------------------------===//
 993 // FP Conditional moves.
 994 //
 995
 996 let neverHasSideEffects = 1 in {
 997 def VMOVDcc  : ARMPseudoInst<(outs DPR:$Dd), (ins DPR:$Dn, DPR:$Dm, pred:$p),
 998                     4, IIC_fpUNA64,
 999                     [/*(set DPR:$Dd, (ARMcmov DPR:$Dn, DPR:$Dm, imm:$cc))*/]>,
1000                  RegConstraint<"$Dn = $Dd">;
1001
1002 def VMOVScc  : ARMPseudoInst<(outs SPR:$Sd), (ins SPR:$Sn, SPR:$Sm, pred:$p),
1003                     4, IIC_fpUNA32,
1004                     [/*(set SPR:$Sd, (ARMcmov SPR:$Sn, SPR:$Sm, imm:$cc))*/]>,
1005                  RegConstraint<"$Sn = $Sd">;
1006 } // neverHasSideEffects
1007
1008 //===----------------------------------------------------------------------===//
1009 // Move from VFP System Register to ARM core register.
1010 //
1011
1012 class MovFromVFP<bits<4> opc19_16, dag oops, dag iops, string opc, string asm,
1013                  list<dag> pattern>:
1014   VFPAI<oops, iops, VFPMiscFrm, IIC_fpSTAT, opc, asm, pattern> {
1015
1016   // Instruction operand.
1017   bits<4> Rt;
1018
1019   let Inst{27-20} = 0b11101111;
1020   let Inst{19-16} = opc19_16;
1021   let Inst{15-12} = Rt;
1022   let Inst{11-8}  = 0b1010;
1023   let Inst{7}     = 0;
1024   let Inst{6-5}   = 0b00;
1025   let Inst{4}     = 1;
1026   let Inst{3-0}   = 0b0000;
1027 }
1028
1029 // APSR is the application level alias of CPSR. This FPSCR N, Z, C, V flags
1030 // to APSR.
1031 let Defs = [CPSR], Uses = [FPSCR], Rt = 0b1111 /* apsr_nzcv */ in
1032 def FMSTAT : MovFromVFP<0b0001 /* fpscr */, (outs), (ins),
1033                         "vmrs", "\tapsr_nzcv, fpscr", [(arm_fmstat)]>;
1034
1035 // Application level FPSCR -> GPR
1036 let hasSideEffects = 1, Uses = [FPSCR] in
1037 def VMRS : MovFromVFP<0b0001 /* fpscr */, (outs GPR:$Rt), (ins),
1038                       "vmrs", "\t$Rt, fpscr",
1039                       [(set GPR:$Rt, (int_arm_get_fpscr))]>;
1040
1041 // System level FPEXC, FPSID -> GPR
1042 let Uses = [FPSCR] in {
1043   def VMRS_FPEXC : MovFromVFP<0b1000 /* fpexc */, (outs GPR:$Rt), (ins),
1044                               "vmrs", "\t$Rt, fpexc", []>;
1045   def VMRS_FPSID : MovFromVFP<0b0000 /* fpsid */, (outs GPR:$Rt), (ins),
1046                               "vmrs", "\t$Rt, fpsid", []>;
1047 }
1048
1049 //===----------------------------------------------------------------------===//
1050 // Move from ARM core register to VFP System Register.
1051 //
1052
1053 class MovToVFP<bits<4> opc19_16, dag oops, dag iops, string opc, string asm,
1054                list<dag> pattern>:
1055   VFPAI<oops, iops, VFPMiscFrm, IIC_fpSTAT, opc, asm, pattern> {
1056
1057   // Instruction operand.
1058   bits<4> src;
1059
1060   // Encode instruction operand.
1061   let Inst{15-12} = src;
1062
1063   let Inst{27-20} = 0b11101110;
1064   let Inst{19-16} = opc19_16;
1065   let Inst{11-8}  = 0b1010;
1066   let Inst{7}     = 0;
1067   let Inst{4}     = 1;
1068 }
1069
1070 let Defs = [FPSCR] in {
1071   // Application level GPR -> FPSCR
1072   def VMSR : MovToVFP<0b0001 /* fpscr */, (outs), (ins GPR:$src),
1073                       "vmsr", "\tfpscr, $src", [(int_arm_set_fpscr GPR:$src)]>;
1074   // System level GPR -> FPEXC
1075   def VMSR_FPEXC : MovToVFP<0b1000 /* fpexc */, (outs), (ins GPR:$src),
1076                       "vmsr", "\tfpexc, $src", []>;
1077   // System level GPR -> FPSID
1078   def VMSR_FPSID : MovToVFP<0b0000 /* fpsid */, (outs), (ins GPR:$src),
1079                       "vmsr", "\tfpsid, $src", []>;
1080 }
1081
1082 //===----------------------------------------------------------------------===//
1083 // Misc.
1084 //
1085
1086 // Materialize FP immediates. VFP3 only.
1087 let isReMaterializable = 1 in {
1088 def FCONSTD : VFPAI<(outs DPR:$Dd), (ins vfp_f64imm:$imm),
1089                     VFPMiscFrm, IIC_fpUNA64,
1090                     "vmov", ".f64\t$Dd, $imm",
1091                     [(set DPR:$Dd, vfp_f64imm:$imm)]>, Requires<[HasVFP3]> {
1092   // Instruction operands.
1093   bits<5>  Dd;
1094   bits<32> imm;
1095
1096   // Encode instruction operands.
1097   let Inst{15-12} = Dd{3-0};
1098   let Inst{22}    = Dd{4};
1099   let Inst{19}    = imm{31};    // The immediate is handled as a float.
1100   let Inst{18-16} = imm{25-23};
1101   let Inst{3-0}   = imm{22-19};
1102
1103   // Encode remaining instruction bits.
1104   let Inst{27-23} = 0b11101;
1105   let Inst{21-20} = 0b11;
1106   let Inst{11-9}  = 0b101;
1107   let Inst{8}     = 1;          // Double precision.
1108   let Inst{7-4}   = 0b0000;
1109 }
1110
1111 def FCONSTS : VFPAI<(outs SPR:$Sd), (ins vfp_f32imm:$imm),
1112                      VFPMiscFrm, IIC_fpUNA32,
1113                      "vmov", ".f32\t$Sd, $imm",
1114                      [(set SPR:$Sd, vfp_f32imm:$imm)]>, Requires<[HasVFP3]> {
1115   // Instruction operands.
1116   bits<5>  Sd;
1117   bits<32> imm;
1118
1119   // Encode instruction operands.
1120   let Inst{15-12} = Sd{4-1};
1121   let Inst{22}    = Sd{0};
1122   let Inst{19}    = imm{31};    // The immediate is handled as a float.
1123   let Inst{18-16} = imm{25-23};
1124   let Inst{3-0}   = imm{22-19};
1125
1126   // Encode remaining instruction bits.
1127   let Inst{27-23} = 0b11101;
1128   let Inst{21-20} = 0b11;
1129   let Inst{11-9}  = 0b101;
1130   let Inst{8}     = 0;          // Single precision.
1131   let Inst{7-4}   = 0b0000;
1132 }
1133 }