1 //===- Target/X86/X86RegisterClasses.cpp - Register Classes -------*-C++-*-===//
3 // This file describes the X86 Register Classes which describe registers.
5 //===----------------------------------------------------------------------===//
7 #include "llvm/Target/MRegisterInfo.h"
8 #include "X86RegisterInfo.h"
12 #define R(ENUM, NAME, FLAGS, TSFLAGS) ENUM,
13 #include "X86RegisterInfo.def"
17 static const unsigned X86ByteRegisterClassRegs[] = {
18 #define R(ENUM, NAME, FLAGS, TSFLAGS)
19 #define R8(ENUM, NAME, FLAGS, TSFLAGS) ENUM,
20 #include "X86RegisterInfo.def"
23 class X86ByteRegisterClass : public TargetRegisterClass {
27 X86ByteRegisterClass() {}
28 unsigned getNumRegs() const {
29 return sizeof(X86ByteRegisterClassRegs)/
30 sizeof(X86ByteRegisterClassRegs[0]);
32 unsigned getRegister(unsigned idx) const {
33 assert(idx < getNumRegs() && "Index out of bounds!");
34 return X86ByteRegisterClassRegs[idx];
37 unsigned getDataSize() const { return 1; }
39 } X86ByteRegisterClassInstance;
45 static const unsigned X86ShortRegisterClassRegs[] = {
46 #define R(ENUM, NAME, FLAGS, TSFLAGS)
47 #define R16(ENUM, NAME, FLAGS, TSFLAGS) ENUM,
48 #include "X86RegisterInfo.def"
51 class X86ShortRegisterClass : public TargetRegisterClass {
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];
63 unsigned getDataSize() const { return 2; }
65 } X86ShortRegisterClassInstance;
71 static const unsigned X86IntRegisterClassRegs[] = {
72 #define R(ENUM, NAME, FLAGS, TSFLAGS)
73 #define R32(ENUM, NAME, FLAGS, TSFLAGS) ENUM,
74 #include "X86RegisterInfo.def"
77 class X86IntRegisterClass : public TargetRegisterClass {
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];
89 unsigned getDataSize() const { return 4; }
91 } X86IntRegisterClassInstance;
94 static const TargetRegisterClass *X86RegClasses[] = {
95 &X86ByteRegisterClassInstance,
96 &X86ShortRegisterClassInstance,
97 &X86IntRegisterClassInstance
100 const TargetRegisterClass* X86RegisterInfo::getRegClassForType(const Type* Ty)
103 switch (Ty->getPrimitiveID()) {
105 case Type::SByteTyID:
106 case Type::UByteTyID: return &X86ByteRegisterClassInstance;
107 case Type::ShortTyID:
108 case Type::UShortTyID: return &X86ShortRegisterClassInstance;
109 case Type::LongTyID: // None of these are handled yet!
110 case Type::ULongTyID: // FIXME: Treat these like ints, this is bogus!
114 case Type::PointerTyID: return &X86IntRegisterClassInstance;
116 case Type::FloatTyID:
117 case Type::DoubleTyID:
120 assert(0 && "Invalid type to getClass!");
121 return 0; // not reached
129 MRegisterInfo::const_iterator X86RegisterInfo::const_regclass_begin() const {
130 return X86RegClasses[0];
133 unsigned X86RegisterInfo::getNumRegClasses() const {
134 return sizeof(X86RegClasses)/sizeof(X86RegClasses[0]);
137 MRegisterInfo::const_iterator X86RegisterInfo::const_regclass_end() const {
138 return (X86RegClasses[0]+getNumRegClasses());