lib/Target/MBlaze/MBlazeInstrFPU.td

   1 //===- MBlazeInstrFPU.td - MBlaze FPU Instruction defs -----*- 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 //===----------------------------------------------------------------------===//
  11 // MBlaze profiles and nodes
  12 //===----------------------------------------------------------------------===//
  13
  14 //===----------------------------------------------------------------------===//
  15 // MBlaze Operand, Complex Patterns and Transformations Definitions.
  16 //===----------------------------------------------------------------------===//
  17
  18 //===----------------------------------------------------------------------===//
  19 // Memory Access Instructions
  20 //===----------------------------------------------------------------------===//
  21 class LoadFM<bits<6> op, string instr_asm, PatFrag OpNode> :
  22              TA<op, 0x000, (outs GPR:$dst), (ins memrr:$addr),
  23                 !strconcat(instr_asm, "   $dst, $addr"),
  24                 [(set (f32 GPR:$dst), (OpNode xaddr:$addr))], IILoad>;
  25
  26 class LoadFMI<bits<6> op, string instr_asm, PatFrag OpNode> :
  27               TB<op, (outs GPR:$dst), (ins memri:$addr),
  28                  !strconcat(instr_asm, "   $dst, $addr"),
  29                  [(set (f32 GPR:$dst), (OpNode iaddr:$addr))], IILoad>;
  30
  31 class StoreFM<bits<6> op, string instr_asm, PatFrag OpNode> :
  32               TA<op, 0x000, (outs), (ins GPR:$dst, memrr:$addr),
  33                  !strconcat(instr_asm, "   $dst, $addr"),
  34                  [(OpNode (f32 GPR:$dst), xaddr:$addr)], IIStore>;
  35
  36 class StoreFMI<bits<6> op, string instr_asm, PatFrag OpNode> :
  37                TB<op, (outs), (ins GPR:$dst, memrr:$addr),
  38                   !strconcat(instr_asm, "   $dst, $addr"),
  39                   [(OpNode (f32 GPR:$dst), iaddr:$addr)], IIStore>;
  40
  41 class ArithF<bits<6> op, bits<11> flags, string instr_asm, SDNode OpNode,
  42              InstrItinClass itin> :
  43              TA<op, flags, (outs GPR:$dst), (ins GPR:$b, GPR:$c),
  44                 !strconcat(instr_asm, "   $dst, $b, $c"),
  45                 [(set GPR:$dst, (OpNode GPR:$b, GPR:$c))], itin>;
  46
  47 class CmpFN<bits<6> op, bits<11> flags, string instr_asm,
  48             InstrItinClass itin> :
  49             TA<op, flags, (outs GPR:$dst), (ins GPR:$b, GPR:$c),
  50                !strconcat(instr_asm, "   $dst, $b, $c"),
  51                [], itin>;
  52
  53 class ArithFR<bits<6> op, bits<11> flags, string instr_asm, SDNode OpNode,
  54              InstrItinClass itin> :
  55              TAR<op, flags, (outs GPR:$dst), (ins GPR:$b, GPR:$c),
  56                  !strconcat(instr_asm, "   $dst, $c, $b"),
  57                  [(set GPR:$dst, (OpNode GPR:$b, GPR:$c))], itin>;
  58
  59 class LogicF<bits<6> op, string instr_asm> :
  60              TB<op, (outs GPR:$dst), (ins GPR:$b, GPR:$c),
  61                 !strconcat(instr_asm, "   $dst, $b, $c"),
  62                 [], IIAlu>;
  63
  64 class LogicFI<bits<6> op, string instr_asm> :
  65              TB<op, (outs GPR:$dst), (ins GPR:$b, fimm:$c),
  66                 !strconcat(instr_asm, "   $dst, $b, $c"),
  67                 [], IIAlu>;
  68
  69 let rb=0 in {
  70   class ArithF2<bits<6> op, bits<11> flags, string instr_asm,
  71                 InstrItinClass itin> :
  72                 TA<op, flags, (outs GPR:$dst), (ins GPR:$b),
  73                    !strconcat(instr_asm, "   $dst, $b"),
  74                    [], itin>;
  75
  76   class ArithIF<bits<6> op, bits<11> flags, string instr_asm,
  77                 InstrItinClass itin> :
  78                 TA<op, flags, (outs GPR:$dst), (ins GPR:$b),
  79                    !strconcat(instr_asm, "   $dst, $b"),
  80                    [], itin>;
  81
  82   class ArithFI<bits<6> op, bits<11> flags, string instr_asm,
  83                 InstrItinClass itin> :
  84                 TA<op, flags, (outs GPR:$dst), (ins GPR:$b),
  85                    !strconcat(instr_asm, "   $dst, $b"),
  86                    [], itin>;
  87 }
  88
  89 //===----------------------------------------------------------------------===//
  90 // Pseudo instructions
  91 //===----------------------------------------------------------------------===//
  92
  93 //===----------------------------------------------------------------------===//
  94 // FPU Arithmetic Instructions
  95 //===----------------------------------------------------------------------===//
  96 let Predicates=[HasFPU] in {
  97   def FORI   : LogicFI<0x28, "ori    ">;
  98   def FADD   :  ArithF<0x16, 0x000, "fadd   ", fadd, IIAlu>;
  99   def FRSUB  : ArithFR<0x16, 0x080, "frsub  ", fsub, IIAlu>;
 100   def FMUL   :  ArithF<0x16, 0x100, "fmul   ", fmul, IIAlu>;
 101   def FDIV   :  ArithF<0x16, 0x180, "fdiv   ", fdiv, IIAlu>;
 102 }
 103
 104 let Predicates=[HasFPU], isCodeGenOnly=1 in {
 105   def LWF    :   LoadFM<0x32, "lw      ", load>;
 106   def LWFI   :  LoadFMI<0x3A, "lwi     ", load>;
 107
 108   def SWF    :  StoreFM<0x36, "sw      ", store>;
 109   def SWFI   : StoreFMI<0x3E, "swi     ", store>;
 110 }
 111
 112 let Predicates=[HasFPU,HasSqrt] in {
 113   def FLT    : ArithIF<0x16, 0x280, "flt    ", IIAlu>;
 114   def FINT   : ArithFI<0x16, 0x300, "fint   ", IIAlu>;
 115   def FSQRT  : ArithF2<0x16, 0x380, "fsqrt  ", IIAlu>;
 116 }
 117
 118 let isAsCheapAsAMove = 1 in {
 119   def FCMP_UN : CmpFN<0x16, 0x200, "fcmp.un", IIAlu>;
 120   def FCMP_LT : CmpFN<0x16, 0x210, "fcmp.lt", IIAlu>;
 121   def FCMP_EQ : CmpFN<0x16, 0x220, "fcmp.eq", IIAlu>;
 122   def FCMP_LE : CmpFN<0x16, 0x230, "fcmp.le", IIAlu>;
 123   def FCMP_GT : CmpFN<0x16, 0x240, "fcmp.gt", IIAlu>;
 124   def FCMP_NE : CmpFN<0x16, 0x250, "fcmp.ne", IIAlu>;
 125   def FCMP_GE : CmpFN<0x16, 0x260, "fcmp.ge", IIAlu>;
 126 }
 127
 128
 129 let usesCustomInserter = 1 in {
 130   def Select_FCC : MBlazePseudo<(outs GPR:$dst),
 131     (ins GPR:$T, GPR:$F, GPR:$CMP, i32imm:$CC),
 132     "; SELECT_FCC PSEUDO!",
 133     []>;
 134 }
 135
 136 // Floating point conversions
 137 let Predicates=[HasFPU] in {
 138   def : Pat<(sint_to_fp GPR:$V), (FLT GPR:$V)>;
 139   def : Pat<(fp_to_sint GPR:$V), (FINT GPR:$V)>;
 140   def : Pat<(fsqrt GPR:$V), (FSQRT GPR:$V)>;
 141 }
 142
 143 // SET_CC operations
 144 let Predicates=[HasFPU] in {
 145   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETEQ),
 146             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 147                        (FCMP_EQ GPR:$L, GPR:$R), 2)>;
 148   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETNE),
 149             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 150                        (FCMP_EQ GPR:$L, GPR:$R), 1)>;
 151   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETOEQ),
 152             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 153                        (FCMP_EQ GPR:$L, GPR:$R), 2)>;
 154  def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETONE),
 155             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 156                        (XOR (FCMP_UN GPR:$L, GPR:$R),
 157                             (FCMP_EQ GPR:$L, GPR:$R)), 2)>;
 158   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETONE),
 159             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 160                        (OR (FCMP_UN GPR:$L, GPR:$R),
 161                            (FCMP_EQ GPR:$L, GPR:$R)), 2)>;
 162   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETGT),
 163             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 164                        (FCMP_GT GPR:$L, GPR:$R), 2)>;
 165   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETLT),
 166             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 167                        (FCMP_LT GPR:$L, GPR:$R), 2)>;
 168   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETGE),
 169             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 170                        (FCMP_GE GPR:$L, GPR:$R), 2)>;
 171   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETLE),
 172             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 173                        (FCMP_LE GPR:$L, GPR:$R), 2)>;
 174   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETOGT),
 175             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 176                        (FCMP_GT GPR:$L, GPR:$R), 2)>;
 177   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETOLT),
 178             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 179                        (FCMP_LT GPR:$L, GPR:$R), 2)>;
 180   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETOGE),
 181             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 182                        (FCMP_GE GPR:$L, GPR:$R), 2)>;
 183   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETOLE),
 184             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 185                        (FCMP_LE GPR:$L, GPR:$R), 2)>;
 186   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETUEQ),
 187             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 188                        (OR (FCMP_UN GPR:$L, GPR:$R),
 189                            (FCMP_EQ GPR:$L, GPR:$R)), 2)>;
 190   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETUNE),
 191             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 192                        (FCMP_NE GPR:$L, GPR:$R), 2)>;
 193   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETUGT),
 194             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 195                        (OR (FCMP_UN GPR:$L, GPR:$R),
 196                            (FCMP_GT GPR:$L, GPR:$R)), 2)>;
 197   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETULT),
 198             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 199                        (OR (FCMP_UN GPR:$L, GPR:$R),
 200                            (FCMP_LT GPR:$L, GPR:$R)), 2)>;
 201   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETUGE),
 202             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 203                        (OR (FCMP_UN GPR:$L, GPR:$R),
 204                            (FCMP_GE GPR:$L, GPR:$R)), 2)>;
 205   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETULE),
 206             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 207                        (OR (FCMP_UN GPR:$L, GPR:$R),
 208                            (FCMP_LE GPR:$L, GPR:$R)), 2)>;
 209   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETO),
 210             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 211                        (FCMP_UN GPR:$L, GPR:$R), 1)>;
 212   def : Pat<(setcc (f32 GPR:$L), (f32 GPR:$R), SETUO),
 213             (Select_CC (ADDIK (i32 R0), 1), (ADDIK (i32 R0), 0),
 214                        (FCMP_UN GPR:$L, GPR:$R), 2)>;
 215 }
 216
 217 // SELECT operations
 218 def : Pat<(select (i32 GPR:$C), (f32 GPR:$T), (f32 GPR:$F)),
 219           (Select_FCC GPR:$T, GPR:$F, GPR:$C, 2)>;
 220
 221 //===----------------------------------------------------------------------===//
 222 // Patterns for Floating Point Instructions
 223 //===----------------------------------------------------------------------===//
 224 def : Pat<(f32 fpimm:$imm), (FORI (i32 R0), fpimm:$imm)>;