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