lib/Target/Hexagon/HexagonInstrInfoV5.td

   1 //=- HexagonInstrInfoV5.td - Target Desc. for Hexagon Target -*- 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 Hexagon V5 instructions in TableGen format.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 //===----------------------------------------------------------------------===//
  15 // XTYPE/MPY
  16 //===----------------------------------------------------------------------===//
  17
  18 let isCodeGenOnly = 0 in
  19 def S2_asr_i_p_rnd : S_2OpInstImm<"asr", 0b110, 0b111, u6Imm,
  20       [(set I64:$dst,
  21             (sra (i64 (add (i64 (sra I64:$src1, u6ImmPred:$src2)), 1)),
  22                  (i32 1)))], 1>,
  23       Requires<[HasV5T]> {
  24   bits<6> src2;
  25   let Inst{13-8} = src2;
  26 }
  27
  28 let isCodeGenOnly = 0 in
  29 def C4_fastcorner9 : T_LOGICAL_2OP<"fastcorner9", 0b000, 0, 0>,
  30   Requires<[HasV5T]> {
  31   let Inst{13,7,4} = 0b111;
  32 }
  33
  34 let isCodeGenOnly = 0 in
  35 def C4_fastcorner9_not : T_LOGICAL_2OP<"!fastcorner9", 0b000, 0, 0>,
  36   Requires<[HasV5T]> {
  37   let Inst{20,13,7,4} = 0b1111;
  38 }
  39
  40 def SDTHexagonFCONST32 : SDTypeProfile<1, 1, [
  41                                             SDTCisVT<0, f32>,
  42                                             SDTCisPtrTy<1>]>;
  43 def HexagonFCONST32 : SDNode<"HexagonISD::FCONST32",     SDTHexagonFCONST32>;
  44
  45 let isReMaterializable = 1, isMoveImm = 1 in
  46 def FCONST32_nsdata : LDInst<(outs IntRegs:$dst), (ins globaladdress:$global),
  47               "$dst = CONST32(#$global)",
  48               [(set (f32 IntRegs:$dst),
  49               (HexagonFCONST32 tglobaladdr:$global))]>,
  50                Requires<[HasV5T]>;
  51
  52 let isReMaterializable = 1, isMoveImm = 1 in
  53 def CONST64_Float_Real : LDInst<(outs DoubleRegs:$dst), (ins f64imm:$src1),
  54                        "$dst = CONST64(#$src1)",
  55                        [(set DoubleRegs:$dst, fpimm:$src1)]>,
  56           Requires<[HasV5T]>;
  57
  58 let isReMaterializable = 1, isMoveImm = 1 in
  59 def CONST32_Float_Real : LDInst<(outs IntRegs:$dst), (ins f32imm:$src1),
  60                        "$dst = CONST32(#$src1)",
  61                        [(set IntRegs:$dst, fpimm:$src1)]>,
  62           Requires<[HasV5T]>;
  63
  64 // Transfer immediate float.
  65 // Only works with single precision fp value.
  66 // For double precision, use CONST64_float_real, as 64bit transfer
  67 // can only hold 40-bit values - 32 from const ext + 8 bit immediate.
  68 // Make sure that complexity is more than the CONST32 pattern in
  69 // HexagonInstrInfo.td patterns.
  70 let isExtended = 1, opExtendable = 1, isMoveImm = 1, isReMaterializable = 1,
  71 isPredicable = 1, AddedComplexity = 30, validSubTargets = HasV5SubT,
  72 isCodeGenOnly = 1 in
  73 def TFRI_f : ALU32_ri<(outs IntRegs:$dst), (ins f32Ext:$src1),
  74            "$dst = #$src1",
  75            [(set IntRegs:$dst, fpimm:$src1)]>,
  76           Requires<[HasV5T]>;
  77
  78 let isExtended = 1, opExtendable = 2, isPredicated = 1,
  79 hasSideEffects = 0, validSubTargets = HasV5SubT in
  80 def TFRI_cPt_f : ALU32_ri<(outs IntRegs:$dst),
  81                           (ins PredRegs:$src1, f32Ext:$src2),
  82            "if ($src1) $dst = #$src2",
  83            []>,
  84           Requires<[HasV5T]>;
  85
  86 let isExtended = 1, opExtendable = 2, isPredicated = 1, isPredicatedFalse = 1,
  87 hasSideEffects = 0, validSubTargets = HasV5SubT in
  88 def TFRI_cNotPt_f : ALU32_ri<(outs IntRegs:$dst),
  89                              (ins PredRegs:$src1, f32Ext:$src2),
  90            "if (!$src1) $dst =#$src2",
  91            []>,
  92           Requires<[HasV5T]>;
  93
  94 def SDTHexagonI32I64: SDTypeProfile<1, 1, [SDTCisVT<0, i32>,
  95                                            SDTCisVT<1, i64>]>;
  96
  97 def HexagonPOPCOUNT: SDNode<"HexagonISD::POPCOUNT", SDTHexagonI32I64>;
  98
  99 let hasNewValue = 1, validSubTargets = HasV5SubT, isCodeGenOnly = 0 in
 100 def S5_popcountp : ALU64_rr<(outs IntRegs:$Rd), (ins DoubleRegs:$Rss),
 101   "$Rd = popcount($Rss)",
 102   [(set I32:$Rd, (HexagonPOPCOUNT I64:$Rss))], "", S_2op_tc_2_SLOT23>,
 103   Requires<[HasV5T]> {
 104     bits<5> Rd;
 105     bits<5> Rss;
 106
 107     let IClass = 0b1000;
 108
 109     let Inst{27-21} = 0b1000011;
 110     let Inst{7-5} = 0b011;
 111     let Inst{4-0} = Rd;
 112     let Inst{20-16} = Rss;
 113   }
 114
 115 // Convert single precision to double precision and vice-versa.
 116 def CONVERT_sf2df : ALU64_rr<(outs DoubleRegs:$dst), (ins IntRegs:$src),
 117                 "$dst = convert_sf2df($src)",
 118                 [(set DoubleRegs:$dst, (fextend IntRegs:$src))]>,
 119           Requires<[HasV5T]>;
 120
 121 def CONVERT_df2sf : ALU64_rr<(outs IntRegs:$dst), (ins DoubleRegs:$src),
 122                 "$dst = convert_df2sf($src)",
 123                 [(set IntRegs:$dst, (fround DoubleRegs:$src))]>,
 124           Requires<[HasV5T]>;
 125
 126
 127 // Load.
 128 def LDrid_f : LDInst<(outs DoubleRegs:$dst),
 129             (ins MEMri:$addr),
 130             "$dst = memd($addr)",
 131             [(set DoubleRegs:$dst, (f64 (load ADDRriS11_3:$addr)))]>,
 132           Requires<[HasV5T]>;
 133
 134
 135 let AddedComplexity = 20 in
 136 def LDrid_indexed_f : LDInst<(outs DoubleRegs:$dst),
 137             (ins IntRegs:$src1, s11_3Imm:$offset),
 138             "$dst = memd($src1+#$offset)",
 139             [(set DoubleRegs:$dst, (f64 (load (add IntRegs:$src1,
 140                                               s11_3ImmPred:$offset))))]>,
 141           Requires<[HasV5T]>;
 142
 143 def LDriw_f : LDInst<(outs IntRegs:$dst),
 144             (ins MEMri:$addr), "$dst = memw($addr)",
 145             [(set IntRegs:$dst, (f32 (load ADDRriS11_2:$addr)))]>,
 146           Requires<[HasV5T]>;
 147
 148
 149 let AddedComplexity = 20 in
 150 def LDriw_indexed_f : LDInst<(outs IntRegs:$dst),
 151             (ins IntRegs:$src1, s11_2Imm:$offset),
 152             "$dst = memw($src1+#$offset)",
 153             [(set IntRegs:$dst, (f32 (load (add IntRegs:$src1,
 154                                            s11_2ImmPred:$offset))))]>,
 155           Requires<[HasV5T]>;
 156
 157 // Store.
 158 def STriw_f : STInst<(outs),
 159             (ins MEMri:$addr, IntRegs:$src1),
 160             "memw($addr) = $src1",
 161             [(store (f32 IntRegs:$src1), ADDRriS11_2:$addr)]>,
 162           Requires<[HasV5T]>;
 163
 164 let AddedComplexity = 10 in
 165 def STriw_indexed_f : STInst<(outs),
 166             (ins IntRegs:$src1, s11_2Imm:$src2, IntRegs:$src3),
 167             "memw($src1+#$src2) = $src3",
 168             [(store (f32 IntRegs:$src3),
 169                 (add IntRegs:$src1, s11_2ImmPred:$src2))]>,
 170           Requires<[HasV5T]>;
 171
 172 def STrid_f : STInst<(outs),
 173             (ins MEMri:$addr, DoubleRegs:$src1),
 174             "memd($addr) = $src1",
 175             [(store (f64 DoubleRegs:$src1), ADDRriS11_2:$addr)]>,
 176           Requires<[HasV5T]>;
 177
 178 // Indexed store double word.
 179 let AddedComplexity = 10 in
 180 def STrid_indexed_f : STInst<(outs),
 181             (ins IntRegs:$src1, s11_3Imm:$src2,  DoubleRegs:$src3),
 182             "memd($src1+#$src2) = $src3",
 183             [(store (f64 DoubleRegs:$src3),
 184                                 (add IntRegs:$src1, s11_3ImmPred:$src2))]>,
 185           Requires<[HasV5T]>;
 186
 187
 188 // Add
 189 let isCommutable = 1 in
 190 def fADD_rr : ALU64_rr<(outs IntRegs:$dst),
 191             (ins IntRegs:$src1, IntRegs:$src2),
 192             "$dst = sfadd($src1, $src2)",
 193             [(set IntRegs:$dst, (fadd IntRegs:$src1, IntRegs:$src2))]>,
 194           Requires<[HasV5T]>;
 195
 196 let isCommutable = 1 in
 197 def fADD64_rr : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 198                                                      DoubleRegs:$src2),
 199                "$dst = dfadd($src1, $src2)",
 200                [(set DoubleRegs:$dst, (fadd DoubleRegs:$src1,
 201                                            DoubleRegs:$src2))]>,
 202           Requires<[HasV5T]>;
 203
 204 def fSUB_rr : ALU64_rr<(outs IntRegs:$dst),
 205             (ins IntRegs:$src1, IntRegs:$src2),
 206             "$dst = sfsub($src1, $src2)",
 207             [(set IntRegs:$dst, (fsub IntRegs:$src1, IntRegs:$src2))]>,
 208           Requires<[HasV5T]>;
 209
 210 def fSUB64_rr : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 211                                                      DoubleRegs:$src2),
 212                "$dst = dfsub($src1, $src2)",
 213                [(set DoubleRegs:$dst, (fsub DoubleRegs:$src1,
 214                                            DoubleRegs:$src2))]>,
 215                Requires<[HasV5T]>;
 216
 217 let isCommutable = 1 in
 218 def fMUL_rr : ALU64_rr<(outs IntRegs:$dst),
 219             (ins IntRegs:$src1, IntRegs:$src2),
 220             "$dst = sfmpy($src1, $src2)",
 221             [(set IntRegs:$dst, (fmul IntRegs:$src1, IntRegs:$src2))]>,
 222             Requires<[HasV5T]>;
 223
 224 let isCommutable = 1 in
 225 def fMUL64_rr : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 226                                                      DoubleRegs:$src2),
 227                "$dst = dfmpy($src1, $src2)",
 228                [(set DoubleRegs:$dst, (fmul DoubleRegs:$src1,
 229                                            DoubleRegs:$src2))]>,
 230                Requires<[HasV5T]>;
 231
 232 // Compare.
 233 let isCompare = 1 in {
 234 multiclass FCMP64_rr<string OpcStr, PatFrag OpNode> {
 235   def _rr : ALU64_rr<(outs PredRegs:$dst), (ins DoubleRegs:$b, DoubleRegs:$c),
 236                  !strconcat("$dst = ", !strconcat(OpcStr, "($b, $c)")),
 237                  [(set PredRegs:$dst,
 238                         (OpNode (f64 DoubleRegs:$b), (f64 DoubleRegs:$c)))]>,
 239                  Requires<[HasV5T]>;
 240 }
 241
 242 multiclass FCMP32_rr<string OpcStr, PatFrag OpNode> {
 243   def _rr : ALU64_rr<(outs PredRegs:$dst), (ins IntRegs:$b, IntRegs:$c),
 244                  !strconcat("$dst = ", !strconcat(OpcStr, "($b, $c)")),
 245                  [(set PredRegs:$dst,
 246                         (OpNode (f32 IntRegs:$b), (f32 IntRegs:$c)))]>,
 247                  Requires<[HasV5T]>;
 248 }
 249 }
 250
 251 defm FCMPOEQ64 : FCMP64_rr<"dfcmp.eq", setoeq>;
 252 defm FCMPUEQ64 : FCMP64_rr<"dfcmp.eq", setueq>;
 253 defm FCMPOGT64 : FCMP64_rr<"dfcmp.gt", setogt>;
 254 defm FCMPUGT64 : FCMP64_rr<"dfcmp.gt", setugt>;
 255 defm FCMPOGE64 : FCMP64_rr<"dfcmp.ge", setoge>;
 256 defm FCMPUGE64 : FCMP64_rr<"dfcmp.ge", setuge>;
 257
 258 defm FCMPOEQ32 : FCMP32_rr<"sfcmp.eq", setoeq>;
 259 defm FCMPUEQ32 : FCMP32_rr<"sfcmp.eq", setueq>;
 260 defm FCMPOGT32 : FCMP32_rr<"sfcmp.gt", setogt>;
 261 defm FCMPUGT32 : FCMP32_rr<"sfcmp.gt", setugt>;
 262 defm FCMPOGE32 : FCMP32_rr<"sfcmp.ge", setoge>;
 263 defm FCMPUGE32 : FCMP32_rr<"sfcmp.ge", setuge>;
 264
 265 // olt.
 266 def : Pat <(i1 (setolt (f32 IntRegs:$src1), (f32 IntRegs:$src2))),
 267       (i1 (FCMPOGT32_rr IntRegs:$src2, IntRegs:$src1))>,
 268       Requires<[HasV5T]>;
 269
 270 def : Pat <(i1 (setolt (f32 IntRegs:$src1), (fpimm:$src2))),
 271       (i1 (FCMPOGT32_rr (f32 (TFRI_f fpimm:$src2)), (f32 IntRegs:$src1)))>,
 272       Requires<[HasV5T]>;
 273
 274 def : Pat <(i1 (setolt (f64 DoubleRegs:$src1), (f64 DoubleRegs:$src2))),
 275       (i1 (FCMPOGT64_rr DoubleRegs:$src2, DoubleRegs:$src1))>,
 276       Requires<[HasV5T]>;
 277
 278 def : Pat <(i1 (setolt (f64 DoubleRegs:$src1), (fpimm:$src2))),
 279       (i1 (FCMPOGT64_rr (f64 (CONST64_Float_Real fpimm:$src2)),
 280                         (f64 DoubleRegs:$src1)))>,
 281       Requires<[HasV5T]>;
 282
 283 // gt.
 284 def : Pat <(i1 (setugt (f64 DoubleRegs:$src1), (fpimm:$src2))),
 285       (i1 (FCMPUGT64_rr (f64 DoubleRegs:$src1),
 286                         (f64 (CONST64_Float_Real fpimm:$src2))))>,
 287       Requires<[HasV5T]>;
 288
 289 def : Pat <(i1 (setugt (f32 IntRegs:$src1), (fpimm:$src2))),
 290       (i1 (FCMPUGT32_rr (f32 IntRegs:$src1), (f32 (TFRI_f fpimm:$src2))))>,
 291       Requires<[HasV5T]>;
 292
 293 // ult.
 294 def : Pat <(i1 (setult (f32 IntRegs:$src1), (f32 IntRegs:$src2))),
 295       (i1 (FCMPUGT32_rr IntRegs:$src2, IntRegs:$src1))>,
 296       Requires<[HasV5T]>;
 297
 298 def : Pat <(i1 (setult (f32 IntRegs:$src1), (fpimm:$src2))),
 299       (i1 (FCMPUGT32_rr (f32 (TFRI_f fpimm:$src2)), (f32 IntRegs:$src1)))>,
 300       Requires<[HasV5T]>;
 301
 302 def : Pat <(i1 (setult (f64 DoubleRegs:$src1), (f64 DoubleRegs:$src2))),
 303       (i1 (FCMPUGT64_rr DoubleRegs:$src2, DoubleRegs:$src1))>,
 304       Requires<[HasV5T]>;
 305
 306 def : Pat <(i1 (setult (f64 DoubleRegs:$src1), (fpimm:$src2))),
 307       (i1 (FCMPUGT64_rr (f64 (CONST64_Float_Real fpimm:$src2)),
 308                         (f64 DoubleRegs:$src1)))>,
 309       Requires<[HasV5T]>;
 310
 311 // le.
 312 // rs <= rt -> rt >= rs.
 313 def : Pat<(i1 (setole (f32 IntRegs:$src1), (f32 IntRegs:$src2))),
 314       (i1 (FCMPOGE32_rr IntRegs:$src2, IntRegs:$src1))>,
 315       Requires<[HasV5T]>;
 316
 317 def : Pat<(i1 (setole (f32 IntRegs:$src1), (fpimm:$src2))),
 318       (i1 (FCMPOGE32_rr (f32 (TFRI_f fpimm:$src2)), IntRegs:$src1))>,
 319       Requires<[HasV5T]>;
 320
 321
 322 // Rss <= Rtt -> Rtt >= Rss.
 323 def : Pat<(i1 (setole (f64 DoubleRegs:$src1), (f64 DoubleRegs:$src2))),
 324       (i1 (FCMPOGE64_rr DoubleRegs:$src2, DoubleRegs:$src1))>,
 325       Requires<[HasV5T]>;
 326
 327 def : Pat<(i1 (setole (f64 DoubleRegs:$src1), (fpimm:$src2))),
 328       (i1 (FCMPOGE64_rr (f64 (CONST64_Float_Real fpimm:$src2)),
 329                                 DoubleRegs:$src1))>,
 330       Requires<[HasV5T]>;
 331
 332 // rs <= rt -> rt >= rs.
 333 def : Pat<(i1 (setule (f32 IntRegs:$src1), (f32 IntRegs:$src2))),
 334       (i1 (FCMPUGE32_rr IntRegs:$src2, IntRegs:$src1))>,
 335       Requires<[HasV5T]>;
 336
 337 def : Pat<(i1 (setule (f32 IntRegs:$src1), (fpimm:$src2))),
 338       (i1 (FCMPUGE32_rr (f32 (TFRI_f fpimm:$src2)), IntRegs:$src1))>,
 339       Requires<[HasV5T]>;
 340
 341 // Rss <= Rtt -> Rtt >= Rss.
 342 def : Pat<(i1 (setule (f64 DoubleRegs:$src1), (f64 DoubleRegs:$src2))),
 343       (i1 (FCMPUGE64_rr DoubleRegs:$src2, DoubleRegs:$src1))>,
 344       Requires<[HasV5T]>;
 345
 346 def : Pat<(i1 (setule (f64 DoubleRegs:$src1), (fpimm:$src2))),
 347       (i1 (FCMPUGE64_rr (f64 (CONST64_Float_Real fpimm:$src2)),
 348                                 DoubleRegs:$src1))>,
 349       Requires<[HasV5T]>;
 350
 351 // ne.
 352 def : Pat<(i1 (setone (f32 IntRegs:$src1), (f32 IntRegs:$src2))),
 353       (i1 (C2_not (FCMPOEQ32_rr IntRegs:$src1, IntRegs:$src2)))>,
 354       Requires<[HasV5T]>;
 355
 356 def : Pat<(i1 (setone (f64 DoubleRegs:$src1), (f64 DoubleRegs:$src2))),
 357       (i1 (C2_not (FCMPOEQ64_rr DoubleRegs:$src1, DoubleRegs:$src2)))>,
 358       Requires<[HasV5T]>;
 359
 360 def : Pat<(i1 (setune (f32 IntRegs:$src1), (f32 IntRegs:$src2))),
 361       (i1 (C2_not (FCMPUEQ32_rr IntRegs:$src1, IntRegs:$src2)))>,
 362       Requires<[HasV5T]>;
 363
 364 def : Pat<(i1 (setune (f64 DoubleRegs:$src1), (f64 DoubleRegs:$src2))),
 365       (i1 (C2_not (FCMPUEQ64_rr DoubleRegs:$src1, DoubleRegs:$src2)))>,
 366       Requires<[HasV5T]>;
 367
 368 def : Pat<(i1 (setone (f32 IntRegs:$src1), (fpimm:$src2))),
 369       (i1 (C2_not (FCMPOEQ32_rr IntRegs:$src1, (f32 (TFRI_f fpimm:$src2)))))>,
 370       Requires<[HasV5T]>;
 371
 372 def : Pat<(i1 (setone (f64 DoubleRegs:$src1), (fpimm:$src2))),
 373       (i1 (C2_not (FCMPOEQ64_rr DoubleRegs:$src1,
 374                               (f64 (CONST64_Float_Real fpimm:$src2)))))>,
 375       Requires<[HasV5T]>;
 376
 377 def : Pat<(i1 (setune (f32 IntRegs:$src1), (fpimm:$src2))),
 378       (i1 (C2_not (FCMPUEQ32_rr IntRegs:$src1,  (f32 (TFRI_f fpimm:$src2)))))>,
 379       Requires<[HasV5T]>;
 380
 381 def : Pat<(i1 (setune (f64 DoubleRegs:$src1), (fpimm:$src2))),
 382       (i1 (C2_not (FCMPUEQ64_rr DoubleRegs:$src1,
 383                               (f64 (CONST64_Float_Real fpimm:$src2)))))>,
 384       Requires<[HasV5T]>;
 385
 386 // Convert Integer to Floating Point.
 387 def CONVERT_d2sf : ALU64_rr<(outs IntRegs:$dst), (ins DoubleRegs:$src),
 388               "$dst = convert_d2sf($src)",
 389               [(set (f32 IntRegs:$dst), (sint_to_fp (i64 DoubleRegs:$src)))]>,
 390               Requires<[HasV5T]>;
 391
 392 def CONVERT_ud2sf : ALU64_rr<(outs IntRegs:$dst), (ins DoubleRegs:$src),
 393               "$dst = convert_ud2sf($src)",
 394               [(set (f32 IntRegs:$dst), (uint_to_fp (i64 DoubleRegs:$src)))]>,
 395               Requires<[HasV5T]>;
 396
 397 def CONVERT_uw2sf : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src),
 398               "$dst = convert_uw2sf($src)",
 399               [(set (f32 IntRegs:$dst), (uint_to_fp (i32 IntRegs:$src)))]>,
 400               Requires<[HasV5T]>;
 401
 402 def CONVERT_w2sf : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src),
 403               "$dst = convert_w2sf($src)",
 404               [(set (f32 IntRegs:$dst), (sint_to_fp (i32 IntRegs:$src)))]>,
 405               Requires<[HasV5T]>;
 406
 407 def CONVERT_d2df : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src),
 408               "$dst = convert_d2df($src)",
 409               [(set (f64 DoubleRegs:$dst), (sint_to_fp (i64 DoubleRegs:$src)))]>,
 410               Requires<[HasV5T]>;
 411
 412 def CONVERT_ud2df : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src),
 413               "$dst = convert_ud2df($src)",
 414               [(set (f64 DoubleRegs:$dst), (uint_to_fp (i64 DoubleRegs:$src)))]>,
 415               Requires<[HasV5T]>;
 416
 417 def CONVERT_uw2df : ALU64_rr<(outs DoubleRegs:$dst), (ins IntRegs:$src),
 418               "$dst = convert_uw2df($src)",
 419               [(set (f64 DoubleRegs:$dst), (uint_to_fp (i32 IntRegs:$src)))]>,
 420               Requires<[HasV5T]>;
 421
 422 def CONVERT_w2df : ALU64_rr<(outs DoubleRegs:$dst), (ins IntRegs:$src),
 423               "$dst = convert_w2df($src)",
 424               [(set (f64 DoubleRegs:$dst), (sint_to_fp (i32 IntRegs:$src)))]>,
 425               Requires<[HasV5T]>;
 426
 427 // Convert Floating Point to Integer - default.
 428 def CONVERT_df2uw : ALU64_rr<(outs IntRegs:$dst), (ins DoubleRegs:$src),
 429               "$dst = convert_df2uw($src):chop",
 430               [(set (i32 IntRegs:$dst), (fp_to_uint (f64 DoubleRegs:$src)))]>,
 431               Requires<[HasV5T]>;
 432
 433 def CONVERT_df2w : ALU64_rr<(outs IntRegs:$dst), (ins DoubleRegs:$src),
 434               "$dst = convert_df2w($src):chop",
 435               [(set (i32 IntRegs:$dst), (fp_to_sint (f64 DoubleRegs:$src)))]>,
 436               Requires<[HasV5T]>;
 437
 438 def CONVERT_sf2uw : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src),
 439               "$dst = convert_sf2uw($src):chop",
 440               [(set (i32 IntRegs:$dst), (fp_to_uint (f32 IntRegs:$src)))]>,
 441               Requires<[HasV5T]>;
 442
 443 def CONVERT_sf2w : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src),
 444               "$dst = convert_sf2w($src):chop",
 445               [(set (i32 IntRegs:$dst), (fp_to_sint (f32 IntRegs:$src)))]>,
 446               Requires<[HasV5T]>;
 447
 448 def CONVERT_df2d : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src),
 449               "$dst = convert_df2d($src):chop",
 450               [(set (i64 DoubleRegs:$dst), (fp_to_sint (f64 DoubleRegs:$src)))]>,
 451               Requires<[HasV5T]>;
 452
 453 def CONVERT_df2ud : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src),
 454               "$dst = convert_df2ud($src):chop",
 455               [(set (i64 DoubleRegs:$dst), (fp_to_uint (f64 DoubleRegs:$src)))]>,
 456               Requires<[HasV5T]>;
 457
 458 def CONVERT_sf2d : ALU64_rr<(outs DoubleRegs:$dst), (ins IntRegs:$src),
 459               "$dst = convert_sf2d($src):chop",
 460               [(set (i64 DoubleRegs:$dst), (fp_to_sint (f32 IntRegs:$src)))]>,
 461               Requires<[HasV5T]>;
 462
 463 def CONVERT_sf2ud : ALU64_rr<(outs DoubleRegs:$dst), (ins IntRegs:$src),
 464               "$dst = convert_sf2ud($src):chop",
 465               [(set (i64 DoubleRegs:$dst), (fp_to_uint (f32 IntRegs:$src)))]>,
 466               Requires<[HasV5T]>;
 467
 468 // Convert Floating Point to Integer: non-chopped.
 469 let AddedComplexity = 20 in
 470 def CONVERT_df2uw_nchop : ALU64_rr<(outs IntRegs:$dst), (ins DoubleRegs:$src),
 471               "$dst = convert_df2uw($src)",
 472               [(set (i32 IntRegs:$dst), (fp_to_uint (f64 DoubleRegs:$src)))]>,
 473               Requires<[HasV5T, IEEERndNearV5T]>;
 474
 475 let AddedComplexity = 20 in
 476 def CONVERT_df2w_nchop : ALU64_rr<(outs IntRegs:$dst), (ins DoubleRegs:$src),
 477               "$dst = convert_df2w($src)",
 478               [(set (i32 IntRegs:$dst), (fp_to_sint (f64 DoubleRegs:$src)))]>,
 479               Requires<[HasV5T, IEEERndNearV5T]>;
 480
 481 let AddedComplexity = 20 in
 482 def CONVERT_sf2uw_nchop : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src),
 483               "$dst = convert_sf2uw($src)",
 484               [(set (i32 IntRegs:$dst), (fp_to_uint (f32 IntRegs:$src)))]>,
 485               Requires<[HasV5T, IEEERndNearV5T]>;
 486
 487 let AddedComplexity = 20 in
 488 def CONVERT_sf2w_nchop : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src),
 489               "$dst = convert_sf2w($src)",
 490               [(set (i32 IntRegs:$dst), (fp_to_sint (f32 IntRegs:$src)))]>,
 491               Requires<[HasV5T, IEEERndNearV5T]>;
 492
 493 let AddedComplexity = 20 in
 494 def CONVERT_df2d_nchop : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src),
 495               "$dst = convert_df2d($src)",
 496               [(set (i64 DoubleRegs:$dst), (fp_to_sint (f64 DoubleRegs:$src)))]>,
 497               Requires<[HasV5T, IEEERndNearV5T]>;
 498
 499 let AddedComplexity = 20 in
 500 def CONVERT_df2ud_nchop : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src),
 501               "$dst = convert_df2ud($src)",
 502               [(set (i64 DoubleRegs:$dst), (fp_to_uint (f64 DoubleRegs:$src)))]>,
 503               Requires<[HasV5T, IEEERndNearV5T]>;
 504
 505 let AddedComplexity = 20 in
 506 def CONVERT_sf2d_nchop : ALU64_rr<(outs DoubleRegs:$dst), (ins IntRegs:$src),
 507               "$dst = convert_sf2d($src)",
 508               [(set (i64 DoubleRegs:$dst), (fp_to_sint (f32 IntRegs:$src)))]>,
 509               Requires<[HasV5T, IEEERndNearV5T]>;
 510
 511 let AddedComplexity = 20 in
 512 def CONVERT_sf2ud_nchop : ALU64_rr<(outs DoubleRegs:$dst), (ins IntRegs:$src),
 513               "$dst = convert_sf2ud($src)",
 514               [(set (i64 DoubleRegs:$dst), (fp_to_uint (f32 IntRegs:$src)))]>,
 515               Requires<[HasV5T, IEEERndNearV5T]>;
 516
 517
 518
 519 // Bitcast is different than [fp|sint|uint]_to_[sint|uint|fp].
 520 def : Pat <(i32 (bitconvert (f32 IntRegs:$src))),
 521            (i32 (A2_tfr IntRegs:$src))>,
 522           Requires<[HasV5T]>;
 523
 524 def : Pat <(f32 (bitconvert (i32 IntRegs:$src))),
 525            (f32 (A2_tfr IntRegs:$src))>,
 526           Requires<[HasV5T]>;
 527
 528 def : Pat <(i64 (bitconvert (f64 DoubleRegs:$src))),
 529            (i64 (A2_tfrp DoubleRegs:$src))>,
 530           Requires<[HasV5T]>;
 531
 532 def : Pat <(f64 (bitconvert (i64 DoubleRegs:$src))),
 533            (f64 (A2_tfrp DoubleRegs:$src))>,
 534           Requires<[HasV5T]>;
 535
 536 def FMADD_sp : ALU64_acc<(outs IntRegs:$dst),
 537                   (ins IntRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 538               "$dst += sfmpy($src2, $src3)",
 539               [(set (f32 IntRegs:$dst),
 540                   (fma IntRegs:$src2, IntRegs:$src3, IntRegs:$src1))],
 541                   "$src1 = $dst">,
 542               Requires<[HasV5T]>;
 543
 544
 545 // Floating point max/min.
 546
 547 let AddedComplexity = 100 in
 548 def FMAX_sp : ALU64_rr<(outs IntRegs:$dst),
 549                   (ins IntRegs:$src1, IntRegs:$src2),
 550               "$dst = sfmax($src1, $src2)",
 551               [(set IntRegs:$dst, (f32 (select (i1 (setolt IntRegs:$src2,
 552                                                         IntRegs:$src1)),
 553                                              IntRegs:$src1,
 554                                              IntRegs:$src2)))]>,
 555                Requires<[HasV5T]>;
 556
 557 let AddedComplexity = 100 in
 558 def FMIN_sp : ALU64_rr<(outs IntRegs:$dst),
 559                   (ins IntRegs:$src1, IntRegs:$src2),
 560               "$dst = sfmin($src1, $src2)",
 561               [(set IntRegs:$dst, (f32 (select (i1 (setogt IntRegs:$src2,
 562                                                         IntRegs:$src1)),
 563                                              IntRegs:$src1,
 564                                              IntRegs:$src2)))]>,
 565                Requires<[HasV5T]>;
 566
 567 // Pseudo instruction to encode a set of conditional transfers.
 568 // This instruction is used instead of a mux and trades-off codesize
 569 // for performance. We conduct this transformation optimistically in
 570 // the hope that these instructions get promoted to dot-new transfers.
 571 let AddedComplexity = 100, isPredicated = 1 in
 572 def TFR_condset_rr_f : ALU32_rr<(outs IntRegs:$dst), (ins PredRegs:$src1,
 573                                                         IntRegs:$src2,
 574                                                         IntRegs:$src3),
 575                      "Error; should not emit",
 576                      [(set IntRegs:$dst, (f32 (select PredRegs:$src1,
 577                                                  IntRegs:$src2,
 578                                                  IntRegs:$src3)))]>,
 579                Requires<[HasV5T]>;
 580
 581 let AddedComplexity = 100, isPredicated = 1 in
 582 def TFR_condset_rr64_f : ALU32_rr<(outs DoubleRegs:$dst), (ins PredRegs:$src1,
 583                                                         DoubleRegs:$src2,
 584                                                         DoubleRegs:$src3),
 585                      "Error; should not emit",
 586                      [(set DoubleRegs:$dst, (f64 (select PredRegs:$src1,
 587                                                  DoubleRegs:$src2,
 588                                                  DoubleRegs:$src3)))]>,
 589                Requires<[HasV5T]>;
 590
 591
 592
 593 let AddedComplexity = 100, isPredicated = 1 in
 594 def TFR_condset_ri_f : ALU32_rr<(outs IntRegs:$dst),
 595             (ins PredRegs:$src1, IntRegs:$src2, f32imm:$src3),
 596             "Error; should not emit",
 597             [(set IntRegs:$dst,
 598              (f32 (select PredRegs:$src1, IntRegs:$src2, fpimm:$src3)))]>,
 599                Requires<[HasV5T]>;
 600
 601 let AddedComplexity = 100, isPredicated = 1 in
 602 def TFR_condset_ir_f : ALU32_rr<(outs IntRegs:$dst),
 603             (ins PredRegs:$src1, f32imm:$src2, IntRegs:$src3),
 604             "Error; should not emit",
 605             [(set IntRegs:$dst,
 606              (f32 (select PredRegs:$src1, fpimm:$src2, IntRegs:$src3)))]>,
 607                Requires<[HasV5T]>;
 608
 609 let AddedComplexity = 100, isPredicated = 1 in
 610 def TFR_condset_ii_f : ALU32_rr<(outs IntRegs:$dst),
 611                               (ins PredRegs:$src1, f32imm:$src2, f32imm:$src3),
 612                      "Error; should not emit",
 613                      [(set IntRegs:$dst, (f32 (select PredRegs:$src1,
 614                                                  fpimm:$src2,
 615                                                  fpimm:$src3)))]>,
 616                Requires<[HasV5T]>;
 617
 618
 619 def : Pat <(select (i1 (setult (f32 IntRegs:$src1), (f32 IntRegs:$src2))),
 620                    (f32 IntRegs:$src3),
 621                    (f32 IntRegs:$src4)),
 622     (TFR_condset_rr_f (FCMPUGT32_rr IntRegs:$src2, IntRegs:$src1), IntRegs:$src4,
 623                       IntRegs:$src3)>, Requires<[HasV5T]>;
 624
 625 def : Pat <(select (i1 (setult (f64 DoubleRegs:$src1), (f64 DoubleRegs:$src2))),
 626                    (f64 DoubleRegs:$src3),
 627                    (f64 DoubleRegs:$src4)),
 628       (TFR_condset_rr64_f (FCMPUGT64_rr DoubleRegs:$src2, DoubleRegs:$src1),
 629                 DoubleRegs:$src4, DoubleRegs:$src3)>, Requires<[HasV5T]>;
 630
 631 // Map from p0 = pnot(p0); r0 = mux(p0, #i, #j) => r0 = mux(p0, #j, #i).
 632 def : Pat <(select (not PredRegs:$src1), fpimm:$src2, fpimm:$src3),
 633       (TFR_condset_ii_f PredRegs:$src1, fpimm:$src3, fpimm:$src2)>;
 634
 635 // Map from p0 = pnot(p0); r0 = select(p0, #i, r1)
 636 // => r0 = TFR_condset_ri(p0, r1, #i)
 637 def : Pat <(select (not PredRegs:$src1), fpimm:$src2, IntRegs:$src3),
 638       (TFR_condset_ri_f PredRegs:$src1, IntRegs:$src3, fpimm:$src2)>;
 639
 640 // Map from p0 = pnot(p0); r0 = mux(p0, r1, #i)
 641 // => r0 = TFR_condset_ir(p0, #i, r1)
 642 def : Pat <(select (not PredRegs:$src1), IntRegs:$src2, fpimm:$src3),
 643       (TFR_condset_ir_f PredRegs:$src1, fpimm:$src3, IntRegs:$src2)>;
 644
 645 def : Pat <(i32 (fp_to_sint (f64 DoubleRegs:$src1))),
 646           (i32 (EXTRACT_SUBREG (i64 (CONVERT_df2d (f64 DoubleRegs:$src1))), subreg_loreg))>,
 647           Requires<[HasV5T]>;
 648
 649 def : Pat <(fabs (f32 IntRegs:$src1)),
 650            (S2_clrbit_i (f32 IntRegs:$src1), 31)>,
 651           Requires<[HasV5T]>;
 652
 653 def : Pat <(fneg (f32 IntRegs:$src1)),
 654            (S2_togglebit_i (f32 IntRegs:$src1), 31)>,
 655           Requires<[HasV5T]>;
 656
 657 /*
 658 def : Pat <(fabs (f64 DoubleRegs:$src1)),
 659           (S2_clrbit_i (f32 (EXTRACT_SUBREG DoubleRegs:$src1, subreg_hireg)), 31)>,
 660           Requires<[HasV5T]>;
 661
 662 def : Pat <(fabs (f64 DoubleRegs:$src1)),
 663           (S2_clrbit_i (f32 (EXTRACT_SUBREG DoubleRegs:$src1, subreg_hireg)), 31)>,
 664           Requires<[HasV5T]>;
 665           */