lib/Target/SparcV9/SparcV9RegClassInfo.h

   1 //===-- SparcV9RegClassInfo.h - Register class def'ns for SparcV9 ---*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the register classes used by the SparcV9 target description.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef SPARC_REG_CLASS_INFO_H
  15 #define SPARC_REG_CLASS_INFO_H
  16
  17 #include "llvm/Target/TargetRegInfo.h"
  18
  19 namespace llvm {
  20
  21 //-----------------------------------------------------------------------------
  22 // Integer Register Class
  23 //-----------------------------------------------------------------------------
  24
  25 struct SparcV9IntRegClass : public TargetRegClassInfo {
  26   SparcV9IntRegClass(unsigned ID)
  27     : TargetRegClassInfo(ID, NumOfAvailRegs, NumOfAllRegs) {  }
  28
  29   void colorIGNode(IGNode *Node,
  30                    const std::vector<bool> &IsColorUsedArr) const;
  31
  32   inline bool isRegVolatile(int Reg) const {
  33     return (Reg < (int)StartOfNonVolatileRegs);
  34   }
  35
  36   inline bool modifiedByCall(int Reg) const {
  37     return Reg==(int)ModifiedByCall;
  38   }
  39
  40   enum {   // colors possible for a LR (in preferred order)
  41      // --- following colors are volatile across function calls
  42      // %g0 can't be used for coloring - always 0
  43      o0, o1, o2, o3, o4, o5, o7,  // %o0-%o5,
  44
  45      // %o6 is sp,
  46      // all %0's can get modified by a call
  47
  48      // --- following colors are NON-volatile across function calls
  49      l0, l1, l2, l3, l4, l5, l6, l7,    //  %l0-%l7
  50      i0, i1, i2, i3, i4, i5,         // %i0-%i5: i's need not be preserved
  51
  52      // %i6 is the fp - so not allocated
  53      // %i7 is the ret address by convention - can be used for others
  54
  55      // max # of colors reg coloring  can allocate (NumOfAvailRegs)
  56
  57      // --- following colors are not available for allocation within this phase
  58      // --- but can appear for pre-colored ranges
  59
  60      i6, i7, g0,  g1, g2, g3, g4, g5, g6, g7, o6,
  61
  62      NumOfAllRegs,  // Must be first AFTER registers...
  63
  64      //*** NOTE: If we decide to use some %g regs, they are volatile
  65      // (see sparc64ABI)
  66      // Move the %g regs from the end of the enumeration to just above the
  67      // enumeration of %o0 (change StartOfAllRegs below)
  68      // change isRegVloatile method below
  69      // Also change IntRegNames above.
  70
  71      // max # of colors reg coloring  can allocate
  72      NumOfAvailRegs = i6,
  73
  74      StartOfNonVolatileRegs = l0,
  75      StartOfAllRegs = o0,
  76
  77      ModifiedByCall = o7,
  78   };
  79
  80   const char * const getRegName(unsigned reg) const;
  81 };
  82
  83
  84
  85
  86 //-----------------------------------------------------------------------------
  87 // Float Register Class
  88 //-----------------------------------------------------------------------------
  89
  90 class SparcV9FloatRegClass : public TargetRegClassInfo {
  91   int findFloatColor(const LiveRange *LR, unsigned Start,
  92                      unsigned End,
  93                      const std::vector<bool> &IsColorUsedArr) const;
  94 public:
  95   SparcV9FloatRegClass(unsigned ID)
  96     : TargetRegClassInfo(ID, NumOfAvailRegs, NumOfAllRegs) {}
  97
  98   // This method marks the registers used for a given register number.
  99   // This marks a single register for Float regs, but the R,R+1 pair
 100   // for double-precision registers.
 101   //
 102   virtual void markColorsUsed(unsigned RegInClass,
 103                               int UserRegType,
 104                               int RegTypeWanted,
 105                               std::vector<bool> &IsColorUsedArr) const;
 106
 107   // This method finds unused registers of the specified register type,
 108   // using the given "used" flag array IsColorUsedArr.  It checks a single
 109   // entry in the array directly for float regs, and checks the pair [R,R+1]
 110   // for double-precision registers
 111   // It returns -1 if no unused color is found.
 112   //
 113   virtual int findUnusedColor(int RegTypeWanted,
 114                               const std::vector<bool> &IsColorUsedArr) const;
 115
 116   void colorIGNode(IGNode *Node,
 117                    const std::vector<bool> &IsColorUsedArr) const;
 118
 119   // according to  SparcV9 64 ABI, all %fp regs are volatile
 120   inline bool isRegVolatile(int Reg) const { return true; }
 121
 122   enum {
 123     f0, f1, f2, f3, f4, f5, f6, f7, f8, f9,
 124     f10, f11, f12, f13, f14, f15, f16, f17, f18, f19,
 125     f20, f21, f22, f23, f24, f25, f26, f27, f28, f29,
 126     f30, f31, f32, f33, f34, f35, f36, f37, f38, f39,
 127     f40, f41, f42, f43, f44, f45, f46, f47, f48, f49,
 128     f50, f51, f52, f53, f54, f55, f56, f57, f58, f59,
 129     f60, f61, f62, f63,
 130
 131     // there are 64 regs alltogether but only 32 regs can be allocated at
 132     // a time.
 133     //
 134     NumOfAvailRegs = 32,
 135     NumOfAllRegs = 64,
 136
 137     StartOfNonVolatileRegs = f32,
 138     StartOfAllRegs = f0,
 139   };
 140
 141   const char * const getRegName(unsigned reg) const;
 142 };
 143
 144
 145
 146
 147 //-----------------------------------------------------------------------------
 148 // Int CC Register Class
 149 // Only one integer cc register is available. However, this register is
 150 // referred to as %xcc or %icc when instructions like subcc are executed but
 151 // referred to as %ccr (i.e., %xcc . %icc") when this register is moved
 152 // into an integer register using RD or WR instrcutions. So, three ids are
 153 // allocated for the three names.
 154 //-----------------------------------------------------------------------------
 155
 156 struct SparcV9IntCCRegClass : public TargetRegClassInfo {
 157   SparcV9IntCCRegClass(unsigned ID)
 158     : TargetRegClassInfo(ID, 1, 3) {  }
 159
 160   void colorIGNode(IGNode *Node,
 161                    const std::vector<bool> &IsColorUsedArr) const;
 162
 163   // according to  SparcV9 64 ABI,  %ccr is volatile
 164   //
 165   inline bool isRegVolatile(int Reg) const { return true; }
 166
 167   enum {
 168     xcc, icc, ccr   // only one is available - see the note above
 169   };
 170
 171   const char * const getRegName(unsigned reg) const;
 172 };
 173
 174
 175 //-----------------------------------------------------------------------------
 176 // Float CC Register Class
 177 // Only 4 Float CC registers are available for allocation.
 178 //-----------------------------------------------------------------------------
 179
 180 struct SparcV9FloatCCRegClass : public TargetRegClassInfo {
 181   SparcV9FloatCCRegClass(unsigned ID)
 182     : TargetRegClassInfo(ID, 4, 5) {  }
 183
 184   void colorIGNode(IGNode *Node,
 185                    const std::vector<bool> &IsColorUsedArr) const;
 186
 187   // according to  SparcV9 64 ABI, all %fp CC regs are volatile
 188   //
 189   inline bool isRegVolatile(int Reg) const { return true; }
 190
 191   enum {
 192     fcc0, fcc1, fcc2, fcc3, fsr         // fsr is not used in allocation
 193   };                                    // but has a name in getRegName()
 194
 195   const char * const getRegName(unsigned reg) const;
 196 };
 197
 198 //-----------------------------------------------------------------------------
 199 // SparcV9 special register class.  These registers are not used for allocation
 200 // but are used as arguments of some instructions.
 201 //-----------------------------------------------------------------------------
 202
 203 struct SparcV9SpecialRegClass : public TargetRegClassInfo {
 204   SparcV9SpecialRegClass(unsigned ID)
 205     : TargetRegClassInfo(ID, 0, 1) {  }
 206
 207   void colorIGNode(IGNode *Node,
 208                    const std::vector<bool> &IsColorUsedArr) const {
 209     assert(0 && "SparcV9SpecialRegClass should never be used for allocation");
 210   }
 211
 212   // all currently included special regs are volatile
 213   inline bool isRegVolatile(int Reg) const { return true; }
 214
 215   enum {
 216     fsr                                 // floating point state register
 217   };
 218
 219   const char * const getRegName(unsigned reg) const;
 220 };
 221
 222 } // End llvm namespace
 223
 224 #endif