lib/Target/X86/X86RegisterClasses.cpp

   1 //===- Target/X86/X86RegisterClasses.cpp - Register Classes -------*-C++-*-===//
   2 //
   3 // This file describes the X86 Register Classes which describe registers.
   4 //
   5 //===----------------------------------------------------------------------===//
   6
   7 #include "llvm/Target/MRegisterInfo.h"
   8 #include "X86RegisterInfo.h"
   9 #include "llvm/Type.h"
  10
  11 enum {
  12 #define R(ENUM, NAME, FLAGS, TSFLAGS) ENUM,
  13 #include "X86RegisterInfo.def"
  14 };
  15
  16 namespace {
  17   static const unsigned X86ByteRegisterClassRegs[] = {
  18 #define R(ENUM, NAME, FLAGS, TSFLAGS)
  19 #define R8(ENUM, NAME, FLAGS, TSFLAGS) ENUM,
  20 #include "X86RegisterInfo.def"
  21   };
  22
  23   class X86ByteRegisterClass : public TargetRegisterClass {
  24   protected:
  25
  26   public:
  27     X86ByteRegisterClass() {}
  28     unsigned getNumRegs() const {
  29       return sizeof(X86ByteRegisterClassRegs)/
  30         sizeof(X86ByteRegisterClassRegs[0]);
  31     }
  32     unsigned getRegister(unsigned idx) const {
  33       assert(idx < getNumRegs() && "Index out of bounds!");
  34       return X86ByteRegisterClassRegs[idx];
  35     }
  36
  37     unsigned getDataSize() const { return 1; }
  38
  39   } X86ByteRegisterClassInstance;
  40
  41
  42 //
  43 //
  44 //
  45   static const unsigned X86ShortRegisterClassRegs[] = {
  46 #define R(ENUM, NAME, FLAGS, TSFLAGS)
  47 #define R16(ENUM, NAME, FLAGS, TSFLAGS) ENUM,
  48 #include "X86RegisterInfo.def"
  49   };
  50
  51   class X86ShortRegisterClass : public TargetRegisterClass {
  52   protected:
  53
  54   public:
  55     X86ShortRegisterClass() {}
  56     unsigned getNumRegs() const {
  57       return sizeof(X86ShortRegisterClassRegs)/
  58         sizeof(X86ShortRegisterClassRegs[0]); }
  59     unsigned getRegister(unsigned idx) const {
  60       assert(idx < getNumRegs() && "Index out of bounds!");
  61       return X86ShortRegisterClassRegs[idx];
  62     }
  63     unsigned getDataSize() const { return 2; }
  64
  65   } X86ShortRegisterClassInstance;
  66
  67 //
  68 //
  69 //
  70
  71   static const unsigned X86IntRegisterClassRegs[] = {
  72 #define R(ENUM, NAME, FLAGS, TSFLAGS)
  73 #define R32(ENUM, NAME, FLAGS, TSFLAGS) ENUM,
  74 #include "X86RegisterInfo.def"
  75   };
  76
  77   class X86IntRegisterClass : public TargetRegisterClass {
  78   protected:
  79
  80   public:
  81     X86IntRegisterClass() {}
  82     unsigned getNumRegs() const {
  83       return sizeof(X86IntRegisterClassRegs)/
  84         sizeof(X86IntRegisterClassRegs[0]); }
  85     unsigned getRegister(unsigned idx) const {
  86       assert(idx < getNumRegs() && "Index out of bounds!");
  87       return X86IntRegisterClassRegs[idx];
  88     }
  89     unsigned getDataSize() const { return 4; }
  90
  91   } X86IntRegisterClassInstance;
  92
  93
  94   static const TargetRegisterClass *X86RegClasses[] = {
  95     &X86ByteRegisterClassInstance,
  96     &X86ShortRegisterClassInstance,
  97     &X86IntRegisterClassInstance
  98   };
  99
 100   const TargetRegisterClass* X86RegisterInfo::getRegClassForType(const Type* Ty)
 101     const
 102   {
 103     switch (Ty->getPrimitiveID()) {
 104     case Type::BoolTyID:
 105     case Type::SByteTyID:
 106     case Type::UByteTyID:   return &X86ByteRegisterClassInstance;
 107     case Type::ShortTyID:
 108     case Type::UShortTyID:  return &X86ShortRegisterClassInstance;
 109     case Type::IntTyID:
 110     case Type::UIntTyID:
 111     case Type::PointerTyID: return &X86IntRegisterClassInstance;
 112
 113     case Type::LongTyID:    /* None of these are handled yet! */
 114     case Type::ULongTyID:
 115     case Type::FloatTyID:
 116     case Type::DoubleTyID:
 117
 118     default:
 119       assert(0 && "Invalid type to getClass!");
 120       return 0;  // not reached
 121     }
 122
 123
 124   }
 125 }
 126
 127
 128 MRegisterInfo::const_iterator X86RegisterInfo::const_regclass_begin() const {
 129   return X86RegClasses[0];
 130 }
 131
 132 unsigned X86RegisterInfo::getNumRegClasses() const {
 133   return sizeof(X86RegClasses)/sizeof(X86RegClasses[0]);
 134 }
 135
 136 MRegisterInfo::const_iterator X86RegisterInfo::const_regclass_end() const {
 137   return (X86RegClasses[0]+getNumRegClasses());
 138 }
 139