lib/Target/ARM/ARMInstrVFP.td

   1 //===- ARMInstrVFP.td - VFP support for ARM -------------------------------===//
   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 :
  15 SDTypeProfile<1, 1, [SDTCisVT<0, f32>, SDTCisFP<1>]>;
  16 def SDT_ITOF :
  17 SDTypeProfile<1, 1, [SDTCisFP<0>, SDTCisVT<1, f32>]>;
  18 def SDT_CMPFP0 :
  19 SDTypeProfile<0, 1, [SDTCisFP<0>]>;
  20 def SDT_VMOVDRR :
  21 SDTypeProfile<1, 2, [SDTCisVT<0, f64>, SDTCisVT<1, i32>,
  22                      SDTCisSameAs<1, 2>]>;
  23
  24 def arm_ftoui  : SDNode<"ARMISD::FTOUI",  SDT_FTOI>;
  25 def arm_ftosi  : SDNode<"ARMISD::FTOSI",  SDT_FTOI>;
  26 def arm_sitof  : SDNode<"ARMISD::SITOF",  SDT_ITOF>;
  27 def arm_uitof  : SDNode<"ARMISD::UITOF",  SDT_ITOF>;
  28 def arm_f16tof32 : SDNode<"ARMISD::F16_TO_F32", SDT_ITOF>;
  29 def arm_f32tof16 : SDNode<"ARMISD::F32_TO_F16", SDT_FTOI>;
  30 def arm_fmstat : SDNode<"ARMISD::FMSTAT", SDTNone, [SDNPInFlag,SDNPOutFlag]>;
  31 def arm_cmpfp  : SDNode<"ARMISD::CMPFP",  SDT_ARMCmp, [SDNPOutFlag]>;
  32 def arm_cmpfp0 : SDNode<"ARMISD::CMPFPw0",SDT_CMPFP0, [SDNPOutFlag]>;
  33 def arm_fmdrr  : SDNode<"ARMISD::VMOVDRR",  SDT_VMOVDRR>;
  34
  35 //===----------------------------------------------------------------------===//
  36 // Operand Definitions.
  37 //
  38
  39
  40 def vfp_f32imm : Operand<f32>,
  41                  PatLeaf<(f32 fpimm), [{
  42       return ARM::getVFPf32Imm(N->getValueAPF()) != -1;
  43     }]> {
  44   let PrintMethod = "printVFPf32ImmOperand";
  45 }
  46
  47 def vfp_f64imm : Operand<f64>,
  48                  PatLeaf<(f64 fpimm), [{
  49       return ARM::getVFPf64Imm(N->getValueAPF()) != -1;
  50     }]> {
  51   let PrintMethod = "printVFPf64ImmOperand";
  52 }
  53
  54
  55 //===----------------------------------------------------------------------===//
  56 //  Load / store Instructions.
  57 //
  58
  59 let canFoldAsLoad = 1, isReMaterializable = 1 in {
  60 def VLDRD : ADI5<0b1101, 0b01, (outs DPR:$dst), (ins addrmode5:$addr),
  61                  IIC_fpLoad64, "vldr", ".64\t$dst, $addr",
  62                  [(set DPR:$dst, (f64 (load addrmode5:$addr)))]>;
  63
  64 def VLDRS : ASI5<0b1101, 0b01, (outs SPR:$dst), (ins addrmode5:$addr),
  65                  IIC_fpLoad32, "vldr", ".32\t$dst, $addr",
  66                  [(set SPR:$dst, (load addrmode5:$addr))]>;
  67 } // canFoldAsLoad
  68
  69 def VSTRD  : ADI5<0b1101, 0b00, (outs), (ins DPR:$src, addrmode5:$addr),
  70                  IIC_fpStore64, "vstr", ".64\t$src, $addr",
  71                  [(store (f64 DPR:$src), addrmode5:$addr)]>;
  72
  73 def VSTRS  : ASI5<0b1101, 0b00, (outs), (ins SPR:$src, addrmode5:$addr),
  74                  IIC_fpStore32, "vstr", ".32\t$src, $addr",
  75                  [(store SPR:$src, addrmode5:$addr)]>;
  76
  77 //===----------------------------------------------------------------------===//
  78 //  Load / store multiple Instructions.
  79 //
  80
  81 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in {
  82 def VLDMD : AXDI5<(outs), (ins addrmode5:$addr, pred:$p, reglist:$dsts,
  83                            variable_ops), IndexModeNone, IIC_fpLoadm,
  84                   "vldm${addr:submode}${p}\t${addr:base}, $dsts", "", []> {
  85   let Inst{20} = 1;
  86 }
  87
  88 def VLDMS : AXSI5<(outs), (ins addrmode5:$addr, pred:$p, reglist:$dsts,
  89                            variable_ops), IndexModeNone, IIC_fpLoadm,
  90                   "vldm${addr:submode}${p}\t${addr:base}, $dsts", "", []> {
  91   let Inst{20} = 1;
  92 }
  93
  94 def VLDMD_UPD : AXDI5<(outs GPR:$wb), (ins addrmode5:$addr, pred:$p,
  95                                        reglist:$dsts, variable_ops),
  96                       IndexModeUpd, IIC_fpLoadm,
  97                       "vldm${addr:submode}${p}\t${addr:base}!, $dsts",
  98                       "$addr.base = $wb", []> {
  99   let Inst{20} = 1;
 100 }
 101
 102 def VLDMS_UPD : AXSI5<(outs GPR:$wb), (ins addrmode5:$addr, pred:$p,
 103                                        reglist:$dsts, variable_ops),
 104                       IndexModeUpd, IIC_fpLoadm,
 105                       "vldm${addr:submode}${p}\t${addr:base}!, $dsts",
 106                       "$addr.base = $wb", []> {
 107   let Inst{20} = 1;
 108 }
 109 } // mayLoad, hasExtraDefRegAllocReq
 110
 111 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in {
 112 def VSTMD : AXDI5<(outs), (ins addrmode5:$addr, pred:$p, reglist:$srcs,
 113                            variable_ops), IndexModeNone, IIC_fpStorem,
 114                   "vstm${addr:submode}${p}\t${addr:base}, $srcs", "", []> {
 115   let Inst{20} = 0;
 116 }
 117
 118 def VSTMS : AXSI5<(outs), (ins addrmode5:$addr, pred:$p, reglist:$srcs,
 119                            variable_ops), IndexModeNone, IIC_fpStorem,
 120                   "vstm${addr:submode}${p}\t${addr:base}, $srcs", "", []> {
 121   let Inst{20} = 0;
 122 }
 123
 124 def VSTMD_UPD : AXDI5<(outs GPR:$wb), (ins addrmode5:$addr, pred:$p,
 125                                        reglist:$srcs, variable_ops),
 126                       IndexModeUpd, IIC_fpStorem,
 127                       "vstm${addr:submode}${p}\t${addr:base}!, $srcs",
 128                       "$addr.base = $wb", []> {
 129   let Inst{20} = 0;
 130 }
 131
 132 def VSTMS_UPD : AXSI5<(outs GPR:$wb), (ins addrmode5:$addr, pred:$p,
 133                                        reglist:$srcs, variable_ops),
 134                       IndexModeUpd, IIC_fpStorem,
 135                       "vstm${addr:submode}${p}\t${addr:base}!, $srcs",
 136                       "$addr.base = $wb", []> {
 137   let Inst{20} = 0;
 138 }
 139 } // mayStore, hasExtraSrcRegAllocReq
 140
 141 // FLDMX, FSTMX - mixing S/D registers for pre-armv6 cores
 142
 143 //===----------------------------------------------------------------------===//
 144 // FP Binary Operations.
 145 //
 146
 147 def VADDD  : ADbI<0b11100, 0b11, 0, 0, (outs DPR:$dst), (ins DPR:$a, DPR:$b),
 148                  IIC_fpALU64, "vadd", ".f64\t$dst, $a, $b",
 149                  [(set DPR:$dst, (fadd DPR:$a, (f64 DPR:$b)))]>;
 150
 151 def VADDS  : ASbIn<0b11100, 0b11, 0, 0, (outs SPR:$dst), (ins SPR:$a, SPR:$b),
 152                   IIC_fpALU32, "vadd", ".f32\t$dst, $a, $b",
 153                   [(set SPR:$dst, (fadd SPR:$a, SPR:$b))]>;
 154
 155 // These are encoded as unary instructions.
 156 let Defs = [FPSCR] in {
 157 def VCMPED : ADuI<0b11101, 0b11, 0b0100, 0b11, 0, (outs), (ins DPR:$a, DPR:$b),
 158                  IIC_fpCMP64, "vcmpe", ".f64\t$a, $b",
 159                  [(arm_cmpfp DPR:$a, (f64 DPR:$b))]>;
 160
 161 def VCMPD  : ADuI<0b11101, 0b11, 0b0100, 0b01, 0, (outs), (ins DPR:$a, DPR:$b),
 162                  IIC_fpCMP64, "vcmp", ".f64\t$a, $b",
 163                  [/* For disassembly only; pattern left blank */]>;
 164
 165 def VCMPES : ASuI<0b11101, 0b11, 0b0100, 0b11, 0, (outs), (ins SPR:$a, SPR:$b),
 166                  IIC_fpCMP32, "vcmpe", ".f32\t$a, $b",
 167                  [(arm_cmpfp SPR:$a, SPR:$b)]>;
 168
 169 def VCMPS  : ASuI<0b11101, 0b11, 0b0100, 0b01, 0, (outs), (ins SPR:$a, SPR:$b),
 170                  IIC_fpCMP32, "vcmp", ".f32\t$a, $b",
 171                  [/* For disassembly only; pattern left blank */]>;
 172 }
 173
 174 def VDIVD  : ADbI<0b11101, 0b00, 0, 0, (outs DPR:$dst), (ins DPR:$a, DPR:$b),
 175                  IIC_fpDIV64, "vdiv", ".f64\t$dst, $a, $b",
 176                  [(set DPR:$dst, (fdiv DPR:$a, (f64 DPR:$b)))]>;
 177
 178 def VDIVS  : ASbI<0b11101, 0b00, 0, 0, (outs SPR:$dst), (ins SPR:$a, SPR:$b),
 179                  IIC_fpDIV32, "vdiv", ".f32\t$dst, $a, $b",
 180                  [(set SPR:$dst, (fdiv SPR:$a, SPR:$b))]>;
 181
 182 def VMULD  : ADbI<0b11100, 0b10, 0, 0, (outs DPR:$dst), (ins DPR:$a, DPR:$b),
 183                  IIC_fpMUL64, "vmul", ".f64\t$dst, $a, $b",
 184                  [(set DPR:$dst, (fmul DPR:$a, (f64 DPR:$b)))]>;
 185
 186 def VMULS  : ASbIn<0b11100, 0b10, 0, 0, (outs SPR:$dst), (ins SPR:$a, SPR:$b),
 187                   IIC_fpMUL32, "vmul", ".f32\t$dst, $a, $b",
 188                   [(set SPR:$dst, (fmul SPR:$a, SPR:$b))]>;
 189
 190 def VNMULD  : ADbI<0b11100, 0b10, 1, 0, (outs DPR:$dst), (ins DPR:$a, DPR:$b),
 191                   IIC_fpMUL64, "vnmul", ".f64\t$dst, $a, $b",
 192                   [(set DPR:$dst, (fneg (fmul DPR:$a, (f64 DPR:$b))))]>;
 193
 194 def VNMULS  : ASbI<0b11100, 0b10, 1, 0, (outs SPR:$dst), (ins SPR:$a, SPR:$b),
 195                   IIC_fpMUL32, "vnmul", ".f32\t$dst, $a, $b",
 196                   [(set SPR:$dst, (fneg (fmul SPR:$a, SPR:$b)))]>;
 197
 198 // Match reassociated forms only if not sign dependent rounding.
 199 def : Pat<(fmul (fneg DPR:$a), (f64 DPR:$b)),
 200           (VNMULD DPR:$a, DPR:$b)>, Requires<[NoHonorSignDependentRounding]>;
 201 def : Pat<(fmul (fneg SPR:$a), SPR:$b),
 202           (VNMULS SPR:$a, SPR:$b)>, Requires<[NoHonorSignDependentRounding]>;
 203
 204
 205 def VSUBD  : ADbI<0b11100, 0b11, 1, 0, (outs DPR:$dst), (ins DPR:$a, DPR:$b),
 206                  IIC_fpALU64, "vsub", ".f64\t$dst, $a, $b",
 207                  [(set DPR:$dst, (fsub DPR:$a, (f64 DPR:$b)))]>;
 208
 209 def VSUBS  : ASbIn<0b11100, 0b11, 1, 0, (outs SPR:$dst), (ins SPR:$a, SPR:$b),
 210                   IIC_fpALU32, "vsub", ".f32\t$dst, $a, $b",
 211                   [(set SPR:$dst, (fsub SPR:$a, SPR:$b))]>;
 212
 213 //===----------------------------------------------------------------------===//
 214 // FP Unary Operations.
 215 //
 216
 217 def VABSD  : ADuI<0b11101, 0b11, 0b0000, 0b11, 0, (outs DPR:$dst), (ins DPR:$a),
 218                  IIC_fpUNA64, "vabs", ".f64\t$dst, $a",
 219                  [(set DPR:$dst, (fabs (f64 DPR:$a)))]>;
 220
 221 def VABSS  : ASuIn<0b11101, 0b11, 0b0000, 0b11, 0,(outs SPR:$dst), (ins SPR:$a),
 222                   IIC_fpUNA32, "vabs", ".f32\t$dst, $a",
 223                   [(set SPR:$dst, (fabs SPR:$a))]>;
 224
 225 let Defs = [FPSCR] in {
 226 def VCMPEZD : ADuI<0b11101, 0b11, 0b0101, 0b11, 0, (outs), (ins DPR:$a),
 227                   IIC_fpCMP64, "vcmpe", ".f64\t$a, #0",
 228                   [(arm_cmpfp0 (f64 DPR:$a))]>;
 229
 230 def VCMPZD  : ADuI<0b11101, 0b11, 0b0101, 0b01, 0, (outs), (ins DPR:$a),
 231                   IIC_fpCMP64, "vcmp", ".f64\t$a, #0",
 232                   [/* For disassembly only; pattern left blank */]>;
 233
 234 def VCMPEZS : ASuI<0b11101, 0b11, 0b0101, 0b11, 0, (outs), (ins SPR:$a),
 235                   IIC_fpCMP32, "vcmpe", ".f32\t$a, #0",
 236                   [(arm_cmpfp0 SPR:$a)]>;
 237
 238 def VCMPZS  : ASuI<0b11101, 0b11, 0b0101, 0b01, 0, (outs), (ins SPR:$a),
 239                   IIC_fpCMP32, "vcmp", ".f32\t$a, #0",
 240                   [/* For disassembly only; pattern left blank */]>;
 241 }
 242
 243 def VCVTDS : ASuI<0b11101, 0b11, 0b0111, 0b11, 0, (outs DPR:$dst), (ins SPR:$a),
 244                  IIC_fpCVTDS, "vcvt", ".f64.f32\t$dst, $a",
 245                  [(set DPR:$dst, (fextend SPR:$a))]>;
 246
 247 // Special case encoding: bits 11-8 is 0b1011.
 248 def VCVTSD : VFPAI<(outs SPR:$dst), (ins DPR:$a), VFPUnaryFrm,
 249                    IIC_fpCVTSD, "vcvt", ".f32.f64\t$dst, $a",
 250                    [(set SPR:$dst, (fround DPR:$a))]> {
 251   let Inst{27-23} = 0b11101;
 252   let Inst{21-16} = 0b110111;
 253   let Inst{11-8}  = 0b1011;
 254   let Inst{7-6}   = 0b11;
 255   let Inst{4}     = 0;
 256 }
 257
 258 // Between half-precision and single-precision.  For disassembly only.
 259
 260 def VCVTBSH : ASuI<0b11101, 0b11, 0b0010, 0b01, 0, (outs SPR:$dst), (ins SPR:$a),
 261                  /* FIXME */ IIC_fpCVTDS, "vcvtb", ".f32.f16\t$dst, $a",
 262                  [(set SPR:$dst, (f32 (arm_f32tof16 SPR:$a)))]>;
 263
 264 def VCVTBHS : ASuI<0b11101, 0b11, 0b0011, 0b01, 0, (outs SPR:$dst), (ins SPR:$a),
 265                  /* FIXME */ IIC_fpCVTDS, "vcvtb", ".f16.f32\t$dst, $a",
 266                  [(set SPR:$dst, (arm_f16tof32 SPR:$a))]>;
 267
 268 def VCVTTSH : ASuI<0b11101, 0b11, 0b0010, 0b11, 0, (outs SPR:$dst), (ins SPR:$a),
 269                  /* FIXME */ IIC_fpCVTDS, "vcvtt", ".f32.f16\t$dst, $a",
 270                  [/* For disassembly only; pattern left blank */]>;
 271
 272 def VCVTTHS : ASuI<0b11101, 0b11, 0b0011, 0b11, 0, (outs SPR:$dst), (ins SPR:$a),
 273                  /* FIXME */ IIC_fpCVTDS, "vcvtt", ".f16.f32\t$dst, $a",
 274                  [/* For disassembly only; pattern left blank */]>;
 275
 276 let neverHasSideEffects = 1 in {
 277 def VMOVD: ADuI<0b11101, 0b11, 0b0000, 0b01, 0, (outs DPR:$dst), (ins DPR:$a),
 278                  IIC_fpUNA64, "vmov", ".f64\t$dst, $a", []>;
 279
 280 def VMOVS: ASuI<0b11101, 0b11, 0b0000, 0b01, 0, (outs SPR:$dst), (ins SPR:$a),
 281                  IIC_fpUNA32, "vmov", ".f32\t$dst, $a", []>;
 282 } // neverHasSideEffects
 283
 284 def VNEGD  : ADuI<0b11101, 0b11, 0b0001, 0b01, 0, (outs DPR:$dst), (ins DPR:$a),
 285                  IIC_fpUNA64, "vneg", ".f64\t$dst, $a",
 286                  [(set DPR:$dst, (fneg (f64 DPR:$a)))]>;
 287
 288 def VNEGS  : ASuIn<0b11101, 0b11, 0b0001, 0b01, 0,(outs SPR:$dst), (ins SPR:$a),
 289                   IIC_fpUNA32, "vneg", ".f32\t$dst, $a",
 290                   [(set SPR:$dst, (fneg SPR:$a))]>;
 291
 292 def VSQRTD : ADuI<0b11101, 0b11, 0b0001, 0b11, 0, (outs DPR:$dst), (ins DPR:$a),
 293                  IIC_fpSQRT64, "vsqrt", ".f64\t$dst, $a",
 294                  [(set DPR:$dst, (fsqrt (f64 DPR:$a)))]>;
 295
 296 def VSQRTS : ASuI<0b11101, 0b11, 0b0001, 0b11, 0, (outs SPR:$dst), (ins SPR:$a),
 297                  IIC_fpSQRT32, "vsqrt", ".f32\t$dst, $a",
 298                  [(set SPR:$dst, (fsqrt SPR:$a))]>;
 299
 300 //===----------------------------------------------------------------------===//
 301 // FP <-> GPR Copies.  Int <-> FP Conversions.
 302 //
 303
 304 def VMOVRS : AVConv2I<0b11100001, 0b1010, (outs GPR:$dst), (ins SPR:$src),
 305                  IIC_VMOVSI, "vmov", "\t$dst, $src",
 306                  [(set GPR:$dst, (bitconvert SPR:$src))]>;
 307
 308 def VMOVSR : AVConv4I<0b11100000, 0b1010, (outs SPR:$dst), (ins GPR:$src),
 309                  IIC_VMOVIS, "vmov", "\t$dst, $src",
 310                  [(set SPR:$dst, (bitconvert GPR:$src))]>;
 311
 312 def VMOVRRD  : AVConv3I<0b11000101, 0b1011,
 313                       (outs GPR:$wb, GPR:$dst2), (ins DPR:$src),
 314                  IIC_VMOVDI, "vmov", "\t$wb, $dst2, $src",
 315                  [/* FIXME: Can't write pattern for multiple result instr*/]> {
 316   let Inst{7-6} = 0b00;
 317 }
 318
 319 def VMOVRRS  : AVConv3I<0b11000101, 0b1010,
 320                       (outs GPR:$wb, GPR:$dst2), (ins SPR:$src1, SPR:$src2),
 321                  IIC_VMOVDI, "vmov", "\t$wb, $dst2, $src1, $src2",
 322                  [/* For disassembly only; pattern left blank */]> {
 323   let Inst{7-6} = 0b00;
 324 }
 325
 326 // FMDHR: GPR -> SPR
 327 // FMDLR: GPR -> SPR
 328
 329 def VMOVDRR : AVConv5I<0b11000100, 0b1011,
 330                      (outs DPR:$dst), (ins GPR:$src1, GPR:$src2),
 331                 IIC_VMOVID, "vmov", "\t$dst, $src1, $src2",
 332                 [(set DPR:$dst, (arm_fmdrr GPR:$src1, GPR:$src2))]> {
 333   let Inst{7-6} = 0b00;
 334 }
 335
 336 def VMOVSRR : AVConv5I<0b11000100, 0b1010,
 337                      (outs SPR:$dst1, SPR:$dst2), (ins GPR:$src1, GPR:$src2),
 338                 IIC_VMOVID, "vmov", "\t$dst1, $dst2, $src1, $src2",
 339                 [/* For disassembly only; pattern left blank */]> {
 340   let Inst{7-6} = 0b00;
 341 }
 342
 343 // FMRDH: SPR -> GPR
 344 // FMRDL: SPR -> GPR
 345 // FMRRS: SPR -> GPR
 346 // FMRX : SPR system reg -> GPR
 347
 348 // FMSRR: GPR -> SPR
 349
 350 // FMXR: GPR -> VFP Sstem reg
 351
 352
 353 // Int to FP:
 354
 355 def VSITOD : AVConv1I<0b11101, 0b11, 0b1000, 0b1011,
 356                  (outs DPR:$dst), (ins SPR:$a),
 357                  IIC_fpCVTID, "vcvt", ".f64.s32\t$dst, $a",
 358                  [(set DPR:$dst, (f64 (arm_sitof SPR:$a)))]> {
 359   let Inst{7} = 1; // s32
 360 }
 361
 362 def VSITOS : AVConv1In<0b11101, 0b11, 0b1000, 0b1010,
 363                  (outs SPR:$dst),(ins SPR:$a),
 364                  IIC_fpCVTIS, "vcvt", ".f32.s32\t$dst, $a",
 365                  [(set SPR:$dst, (arm_sitof SPR:$a))]> {
 366   let Inst{7} = 1; // s32
 367 }
 368
 369 def VUITOD : AVConv1I<0b11101, 0b11, 0b1000, 0b1011,
 370                  (outs DPR:$dst), (ins SPR:$a),
 371                  IIC_fpCVTID, "vcvt", ".f64.u32\t$dst, $a",
 372                  [(set DPR:$dst, (f64 (arm_uitof SPR:$a)))]> {
 373   let Inst{7} = 0; // u32
 374 }
 375
 376 def VUITOS : AVConv1In<0b11101, 0b11, 0b1000, 0b1010,
 377                  (outs SPR:$dst), (ins SPR:$a),
 378                  IIC_fpCVTIS, "vcvt", ".f32.u32\t$dst, $a",
 379                  [(set SPR:$dst, (arm_uitof SPR:$a))]> {
 380   let Inst{7} = 0; // u32
 381 }
 382
 383 // FP to Int:
 384 // Always set Z bit in the instruction, i.e. "round towards zero" variants.
 385
 386 def VTOSIZD : AVConv1I<0b11101, 0b11, 0b1101, 0b1011,
 387                        (outs SPR:$dst), (ins DPR:$a),
 388                  IIC_fpCVTDI, "vcvt", ".s32.f64\t$dst, $a",
 389                  [(set SPR:$dst, (arm_ftosi (f64 DPR:$a)))]> {
 390   let Inst{7} = 1; // Z bit
 391 }
 392
 393 def VTOSIZS : AVConv1In<0b11101, 0b11, 0b1101, 0b1010,
 394                         (outs SPR:$dst), (ins SPR:$a),
 395                  IIC_fpCVTSI, "vcvt", ".s32.f32\t$dst, $a",
 396                  [(set SPR:$dst, (arm_ftosi SPR:$a))]> {
 397   let Inst{7} = 1; // Z bit
 398 }
 399
 400 def VTOUIZD : AVConv1I<0b11101, 0b11, 0b1100, 0b1011,
 401                        (outs SPR:$dst), (ins DPR:$a),
 402                  IIC_fpCVTDI, "vcvt", ".u32.f64\t$dst, $a",
 403                  [(set SPR:$dst, (arm_ftoui (f64 DPR:$a)))]> {
 404   let Inst{7} = 1; // Z bit
 405 }
 406
 407 def VTOUIZS : AVConv1In<0b11101, 0b11, 0b1100, 0b1010,
 408                         (outs SPR:$dst), (ins SPR:$a),
 409                  IIC_fpCVTSI, "vcvt", ".u32.f32\t$dst, $a",
 410                  [(set SPR:$dst, (arm_ftoui SPR:$a))]> {
 411   let Inst{7} = 1; // Z bit
 412 }
 413
 414 // And the Z bit '0' variants, i.e. use the rounding mode specified by FPSCR.
 415 // For disassembly only.
 416
 417 def VTOSIRD : AVConv1I<0b11101, 0b11, 0b1101, 0b1011,
 418                        (outs SPR:$dst), (ins DPR:$a),
 419                  IIC_fpCVTDI, "vcvtr", ".s32.f64\t$dst, $a",
 420                  [/* For disassembly only; pattern left blank */]> {
 421   let Inst{7} = 0; // Z bit
 422 }
 423
 424 def VTOSIRS : AVConv1In<0b11101, 0b11, 0b1101, 0b1010,
 425                         (outs SPR:$dst), (ins SPR:$a),
 426                  IIC_fpCVTSI, "vcvtr", ".s32.f32\t$dst, $a",
 427                  [/* For disassembly only; pattern left blank */]> {
 428   let Inst{7} = 0; // Z bit
 429 }
 430
 431 def VTOUIRD : AVConv1I<0b11101, 0b11, 0b1100, 0b1011,
 432                        (outs SPR:$dst), (ins DPR:$a),
 433                  IIC_fpCVTDI, "vcvtr", ".u32.f64\t$dst, $a",
 434                  [/* For disassembly only; pattern left blank */]> {
 435   let Inst{7} = 0; // Z bit
 436 }
 437
 438 def VTOUIRS : AVConv1In<0b11101, 0b11, 0b1100, 0b1010,
 439                         (outs SPR:$dst), (ins SPR:$a),
 440                  IIC_fpCVTSI, "vcvtr", ".u32.f32\t$dst, $a",
 441                  [/* For disassembly only; pattern left blank */]> {
 442   let Inst{7} = 0; // Z bit
 443 }
 444
 445 // Convert between floating-point and fixed-point
 446 // Data type for fixed-point naming convention:
 447 //   S16 (U=0, sx=0) -> SH
 448 //   U16 (U=1, sx=0) -> UH
 449 //   S32 (U=0, sx=1) -> SL
 450 //   U32 (U=1, sx=1) -> UL
 451
 452 let Constraints = "$a = $dst" in {
 453
 454 // FP to Fixed-Point:
 455
 456 def VTOSHS : AVConv1XI<0b11101, 0b11, 0b1110, 0b1010, 0,
 457                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 458                  IIC_fpCVTSI, "vcvt", ".s16.f32\t$dst, $a, $fbits",
 459                  [/* For disassembly only; pattern left blank */]>;
 460
 461 def VTOUHS : AVConv1XI<0b11101, 0b11, 0b1111, 0b1010, 0,
 462                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 463                  IIC_fpCVTSI, "vcvt", ".u16.f32\t$dst, $a, $fbits",
 464                  [/* For disassembly only; pattern left blank */]>;
 465
 466 def VTOSLS : AVConv1XI<0b11101, 0b11, 0b1110, 0b1010, 1,
 467                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 468                  IIC_fpCVTSI, "vcvt", ".s32.f32\t$dst, $a, $fbits",
 469                  [/* For disassembly only; pattern left blank */]>;
 470
 471 def VTOULS : AVConv1XI<0b11101, 0b11, 0b1111, 0b1010, 1,
 472                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 473                  IIC_fpCVTSI, "vcvt", ".u32.f32\t$dst, $a, $fbits",
 474                  [/* For disassembly only; pattern left blank */]>;
 475
 476 def VTOSHD : AVConv1XI<0b11101, 0b11, 0b1110, 0b1011, 0,
 477                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 478                  IIC_fpCVTDI, "vcvt", ".s16.f64\t$dst, $a, $fbits",
 479                  [/* For disassembly only; pattern left blank */]>;
 480
 481 def VTOUHD : AVConv1XI<0b11101, 0b11, 0b1111, 0b1011, 0,
 482                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 483                  IIC_fpCVTDI, "vcvt", ".u16.f64\t$dst, $a, $fbits",
 484                  [/* For disassembly only; pattern left blank */]>;
 485
 486 def VTOSLD : AVConv1XI<0b11101, 0b11, 0b1110, 0b1011, 1,
 487                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 488                  IIC_fpCVTDI, "vcvt", ".s32.f64\t$dst, $a, $fbits",
 489                  [/* For disassembly only; pattern left blank */]>;
 490
 491 def VTOULD : AVConv1XI<0b11101, 0b11, 0b1111, 0b1011, 1,
 492                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 493                  IIC_fpCVTDI, "vcvt", ".u32.f64\t$dst, $a, $fbits",
 494                  [/* For disassembly only; pattern left blank */]>;
 495
 496 // Fixed-Point to FP:
 497
 498 def VSHTOS : AVConv1XI<0b11101, 0b11, 0b1010, 0b1010, 0,
 499                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 500                  IIC_fpCVTIS, "vcvt", ".f32.s16\t$dst, $a, $fbits",
 501                  [/* For disassembly only; pattern left blank */]>;
 502
 503 def VUHTOS : AVConv1XI<0b11101, 0b11, 0b1011, 0b1010, 0,
 504                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 505                  IIC_fpCVTIS, "vcvt", ".f32.u16\t$dst, $a, $fbits",
 506                  [/* For disassembly only; pattern left blank */]>;
 507
 508 def VSLTOS : AVConv1XI<0b11101, 0b11, 0b1010, 0b1010, 1,
 509                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 510                  IIC_fpCVTIS, "vcvt", ".f32.s32\t$dst, $a, $fbits",
 511                  [/* For disassembly only; pattern left blank */]>;
 512
 513 def VULTOS : AVConv1XI<0b11101, 0b11, 0b1011, 0b1010, 1,
 514                        (outs SPR:$dst), (ins SPR:$a, i32imm:$fbits),
 515                  IIC_fpCVTIS, "vcvt", ".f32.u32\t$dst, $a, $fbits",
 516                  [/* For disassembly only; pattern left blank */]>;
 517
 518 def VSHTOD : AVConv1XI<0b11101, 0b11, 0b1010, 0b1011, 0,
 519                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 520                  IIC_fpCVTID, "vcvt", ".f64.s16\t$dst, $a, $fbits",
 521                  [/* For disassembly only; pattern left blank */]>;
 522
 523 def VUHTOD : AVConv1XI<0b11101, 0b11, 0b1011, 0b1011, 0,
 524                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 525                  IIC_fpCVTID, "vcvt", ".f64.u16\t$dst, $a, $fbits",
 526                  [/* For disassembly only; pattern left blank */]>;
 527
 528 def VSLTOD : AVConv1XI<0b11101, 0b11, 0b1010, 0b1011, 1,
 529                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 530                  IIC_fpCVTID, "vcvt", ".f64.s32\t$dst, $a, $fbits",
 531                  [/* For disassembly only; pattern left blank */]>;
 532
 533 def VULTOD : AVConv1XI<0b11101, 0b11, 0b1011, 0b1011, 1,
 534                        (outs DPR:$dst), (ins DPR:$a, i32imm:$fbits),
 535                  IIC_fpCVTID, "vcvt", ".f64.u32\t$dst, $a, $fbits",
 536                  [/* For disassembly only; pattern left blank */]>;
 537
 538 } // End of 'let Constraints = "$src = $dst" in'
 539
 540 //===----------------------------------------------------------------------===//
 541 // FP FMA Operations.
 542 //
 543
 544 def VMLAD : ADbI<0b11100, 0b00, 0, 0,
 545                 (outs DPR:$dst), (ins DPR:$dstin, DPR:$a, DPR:$b),
 546                 IIC_fpMAC64, "vmla", ".f64\t$dst, $a, $b",
 547                 [(set DPR:$dst, (fadd (fmul DPR:$a, DPR:$b),
 548                                       (f64 DPR:$dstin)))]>,
 549                 RegConstraint<"$dstin = $dst">;
 550
 551 def VMLAS : ASbIn<0b11100, 0b00, 0, 0,
 552                  (outs SPR:$dst), (ins SPR:$dstin, SPR:$a, SPR:$b),
 553                  IIC_fpMAC32, "vmla", ".f32\t$dst, $a, $b",
 554                  [(set SPR:$dst, (fadd (fmul SPR:$a, SPR:$b), SPR:$dstin))]>,
 555                  RegConstraint<"$dstin = $dst">;
 556
 557 def VNMLSD : ADbI<0b11100, 0b01, 0, 0,
 558                 (outs DPR:$dst), (ins DPR:$dstin, DPR:$a, DPR:$b),
 559                 IIC_fpMAC64, "vnmls", ".f64\t$dst, $a, $b",
 560                 [(set DPR:$dst, (fsub (fmul DPR:$a, DPR:$b),
 561                                 (f64 DPR:$dstin)))]>,
 562                 RegConstraint<"$dstin = $dst">;
 563
 564 def VNMLSS : ASbI<0b11100, 0b01, 0, 0,
 565                 (outs SPR:$dst), (ins SPR:$dstin, SPR:$a, SPR:$b),
 566                 IIC_fpMAC32, "vnmls", ".f32\t$dst, $a, $b",
 567                 [(set SPR:$dst, (fsub (fmul SPR:$a, SPR:$b), SPR:$dstin))]>,
 568                 RegConstraint<"$dstin = $dst">;
 569
 570 def VMLSD : ADbI<0b11100, 0b00, 1, 0,
 571                  (outs DPR:$dst), (ins DPR:$dstin, DPR:$a, DPR:$b),
 572                  IIC_fpMAC64, "vmls", ".f64\t$dst, $a, $b",
 573              [(set DPR:$dst, (fadd (fneg (fmul DPR:$a, DPR:$b)),
 574                              (f64 DPR:$dstin)))]>,
 575                 RegConstraint<"$dstin = $dst">;
 576
 577 def VMLSS : ASbIn<0b11100, 0b00, 1, 0,
 578                   (outs SPR:$dst), (ins SPR:$dstin, SPR:$a, SPR:$b),
 579                   IIC_fpMAC32, "vmls", ".f32\t$dst, $a, $b",
 580              [(set SPR:$dst, (fadd (fneg (fmul SPR:$a, SPR:$b)), SPR:$dstin))]>,
 581                 RegConstraint<"$dstin = $dst">;
 582
 583 def : Pat<(fsub DPR:$dstin, (fmul DPR:$a, (f64 DPR:$b))),
 584           (VMLSD DPR:$dstin, DPR:$a, DPR:$b)>, Requires<[DontUseNEONForFP]>;
 585 def : Pat<(fsub SPR:$dstin, (fmul SPR:$a, SPR:$b)),
 586           (VMLSS SPR:$dstin, SPR:$a, SPR:$b)>, Requires<[DontUseNEONForFP]>;
 587
 588 def VNMLAD : ADbI<0b11100, 0b01, 1, 0,
 589                  (outs DPR:$dst), (ins DPR:$dstin, DPR:$a, DPR:$b),
 590                  IIC_fpMAC64, "vnmla", ".f64\t$dst, $a, $b",
 591              [(set DPR:$dst, (fsub (fneg (fmul DPR:$a, DPR:$b)),
 592                              (f64 DPR:$dstin)))]>,
 593                 RegConstraint<"$dstin = $dst">;
 594
 595 def VNMLAS : ASbI<0b11100, 0b01, 1, 0,
 596                 (outs SPR:$dst), (ins SPR:$dstin, SPR:$a, SPR:$b),
 597                 IIC_fpMAC32, "vnmla", ".f32\t$dst, $a, $b",
 598              [(set SPR:$dst, (fsub (fneg (fmul SPR:$a, SPR:$b)), SPR:$dstin))]>,
 599                 RegConstraint<"$dstin = $dst">;
 600
 601 //===----------------------------------------------------------------------===//
 602 // FP Conditional moves.
 603 //
 604
 605 def VMOVDcc  : ADuI<0b11101, 0b11, 0b0000, 0b01, 0,
 606                     (outs DPR:$dst), (ins DPR:$false, DPR:$true),
 607                     IIC_fpUNA64, "vmov", ".f64\t$dst, $true",
 608                 [/*(set DPR:$dst, (ARMcmov DPR:$false, DPR:$true, imm:$cc))*/]>,
 609                     RegConstraint<"$false = $dst">;
 610
 611 def VMOVScc  : ASuI<0b11101, 0b11, 0b0000, 0b01, 0,
 612                     (outs SPR:$dst), (ins SPR:$false, SPR:$true),
 613                     IIC_fpUNA32, "vmov", ".f32\t$dst, $true",
 614                 [/*(set SPR:$dst, (ARMcmov SPR:$false, SPR:$true, imm:$cc))*/]>,
 615                     RegConstraint<"$false = $dst">;
 616
 617 def VNEGDcc  : ADuI<0b11101, 0b11, 0b0001, 0b01, 0,
 618                     (outs DPR:$dst), (ins DPR:$false, DPR:$true),
 619                     IIC_fpUNA64, "vneg", ".f64\t$dst, $true",
 620                 [/*(set DPR:$dst, (ARMcneg DPR:$false, DPR:$true, imm:$cc))*/]>,
 621                     RegConstraint<"$false = $dst">;
 622
 623 def VNEGScc  : ASuI<0b11101, 0b11, 0b0001, 0b01, 0,
 624                     (outs SPR:$dst), (ins SPR:$false, SPR:$true),
 625                     IIC_fpUNA32, "vneg", ".f32\t$dst, $true",
 626                 [/*(set SPR:$dst, (ARMcneg SPR:$false, SPR:$true, imm:$cc))*/]>,
 627                     RegConstraint<"$false = $dst">;
 628
 629
 630 //===----------------------------------------------------------------------===//
 631 // Misc.
 632 //
 633
 634 // APSR is the application level alias of CPSR. This FPSCR N, Z, C, V flags
 635 // to APSR.
 636 let Defs = [CPSR], Uses = [FPSCR] in
 637 def FMSTAT : VFPAI<(outs), (ins), VFPMiscFrm, IIC_fpSTAT, "vmrs",
 638                    "\tapsr_nzcv, fpscr",
 639              [(arm_fmstat)]> {
 640   let Inst{27-20} = 0b11101111;
 641   let Inst{19-16} = 0b0001;
 642   let Inst{15-12} = 0b1111;
 643   let Inst{11-8}  = 0b1010;
 644   let Inst{7}     = 0;
 645   let Inst{4}     = 1;
 646 }
 647
 648 // FPSCR <-> GPR (for disassembly only)
 649
 650 let Uses = [FPSCR] in {
 651 def VMRS : VFPAI<(outs GPR:$dst), (ins), VFPMiscFrm, IIC_fpSTAT, "vmrs",
 652                  "\t$dst, fpscr",
 653              [/* For disassembly only; pattern left blank */]> {
 654   let Inst{27-20} = 0b11101111;
 655   let Inst{19-16} = 0b0001;
 656   let Inst{11-8}  = 0b1010;
 657   let Inst{7}     = 0;
 658   let Inst{4}     = 1;
 659 }
 660 }
 661
 662 let Defs = [FPSCR] in {
 663 def VMSR : VFPAI<(outs), (ins GPR:$src), VFPMiscFrm, IIC_fpSTAT, "vmsr",
 664                  "\tfpscr, $src",
 665              [/* For disassembly only; pattern left blank */]> {
 666   let Inst{27-20} = 0b11101110;
 667   let Inst{19-16} = 0b0001;
 668   let Inst{11-8}  = 0b1010;
 669   let Inst{7}     = 0;
 670   let Inst{4}     = 1;
 671 }
 672 }
 673
 674 // Materialize FP immediates. VFP3 only.
 675 let isReMaterializable = 1 in {
 676 def FCONSTD : VFPAI<(outs DPR:$dst), (ins vfp_f64imm:$imm),
 677                     VFPMiscFrm, IIC_VMOVImm,
 678                     "vmov", ".f64\t$dst, $imm",
 679                     [(set DPR:$dst, vfp_f64imm:$imm)]>, Requires<[HasVFP3]> {
 680   let Inst{27-23} = 0b11101;
 681   let Inst{21-20} = 0b11;
 682   let Inst{11-9}  = 0b101;
 683   let Inst{8}     = 1;
 684   let Inst{7-4}   = 0b0000;
 685 }
 686
 687 def FCONSTS : VFPAI<(outs SPR:$dst), (ins vfp_f32imm:$imm),
 688                     VFPMiscFrm, IIC_VMOVImm,
 689                     "vmov", ".f32\t$dst, $imm",
 690                     [(set SPR:$dst, vfp_f32imm:$imm)]>, Requires<[HasVFP3]> {
 691   let Inst{27-23} = 0b11101;
 692   let Inst{21-20} = 0b11;
 693   let Inst{11-9}  = 0b101;
 694   let Inst{8}     = 0;
 695   let Inst{7-4}   = 0b0000;
 696 }
 697 }