lib/Target/SparcV9/SparcV9RegClassInfo.h

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