2002-11-20 19:59:43 +01:00
|
|
|
//===- 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"
|
2002-12-16 16:55:25 +01:00
|
|
|
#include "X86.h"
|
2002-11-20 19:59:43 +01:00
|
|
|
|
|
|
|
namespace {
|
2002-12-15 20:29:34 +01:00
|
|
|
const unsigned ByteRegClassRegs[] = {
|
2002-12-16 16:55:25 +01:00
|
|
|
#define R8(ENUM, NAME, FLAGS, TSFLAGS, A1, A2, A3) X86::ENUM,
|
2002-11-20 19:59:43 +01:00
|
|
|
#include "X86RegisterInfo.def"
|
|
|
|
};
|
|
|
|
|
2002-12-15 20:29:34 +01:00
|
|
|
TargetRegisterClass X86ByteRegisterClassInstance(1, ByteRegClassRegs,
|
|
|
|
ByteRegClassRegs+sizeof(ByteRegClassRegs)/sizeof(ByteRegClassRegs[0]));
|
2002-11-20 19:59:43 +01:00
|
|
|
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
2002-12-15 20:29:34 +01:00
|
|
|
const unsigned ShortRegClassRegs[] = {
|
2002-12-16 16:55:25 +01:00
|
|
|
#define R16(ENUM, NAME, FLAGS, TSFLAGS, A1, A2, A3) X86::ENUM,
|
2002-11-20 19:59:43 +01:00
|
|
|
#include "X86RegisterInfo.def"
|
|
|
|
};
|
|
|
|
|
2002-12-15 20:29:34 +01:00
|
|
|
TargetRegisterClass X86ShortRegisterClassInstance(2, ShortRegClassRegs,
|
|
|
|
ShortRegClassRegs+sizeof(ShortRegClassRegs)/sizeof(ShortRegClassRegs[0]));
|
2002-11-20 19:59:43 +01:00
|
|
|
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
|
2002-12-15 20:29:34 +01:00
|
|
|
const unsigned IntRegClassRegs[] = {
|
2002-12-16 16:55:25 +01:00
|
|
|
#define R32(ENUM, NAME, FLAGS, TSFLAGS, A1, A2, A3) X86::ENUM,
|
2002-11-20 19:59:43 +01:00
|
|
|
#include "X86RegisterInfo.def"
|
|
|
|
};
|
|
|
|
|
2002-12-15 20:29:34 +01:00
|
|
|
TargetRegisterClass X86IntRegisterClassInstance(4, IntRegClassRegs,
|
|
|
|
IntRegClassRegs+sizeof(IntRegClassRegs)/sizeof(IntRegClassRegs[0]));
|
2002-11-20 19:59:43 +01:00
|
|
|
|
2002-12-15 20:29:34 +01:00
|
|
|
const TargetRegisterClass * const X86RegClasses[] = {
|
2002-11-20 19:59:43 +01:00
|
|
|
&X86ByteRegisterClassInstance,
|
|
|
|
&X86ShortRegisterClassInstance,
|
|
|
|
&X86IntRegisterClassInstance
|
|
|
|
};
|
2002-12-15 20:29:34 +01:00
|
|
|
}
|
2002-11-20 19:59:43 +01:00
|
|
|
|
2002-12-15 20:29:34 +01:00
|
|
|
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::LongTyID: // None of these are handled yet!
|
|
|
|
case Type::ULongTyID: // FIXME: Treat these like ints, this is bogus!
|
|
|
|
|
|
|
|
case Type::IntTyID:
|
|
|
|
case Type::UIntTyID:
|
|
|
|
case Type::PointerTyID: return &X86IntRegisterClassInstance;
|
|
|
|
|
|
|
|
case Type::FloatTyID:
|
|
|
|
case Type::DoubleTyID:
|
|
|
|
|
|
|
|
default:
|
|
|
|
assert(0 && "Invalid type to getClass!");
|
|
|
|
return 0; // not reached
|
2002-11-20 19:59:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-12-15 19:40:36 +01:00
|
|
|
MRegisterInfo::const_iterator X86RegisterInfo::regclass_begin() const {
|
|
|
|
return X86RegClasses;
|
2002-11-20 19:59:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned X86RegisterInfo::getNumRegClasses() const {
|
|
|
|
return sizeof(X86RegClasses)/sizeof(X86RegClasses[0]);
|
|
|
|
}
|
|
|
|
|
2002-12-15 19:40:36 +01:00
|
|
|
MRegisterInfo::const_iterator X86RegisterInfo::regclass_end() const {
|
|
|
|
return X86RegClasses+getNumRegClasses();
|
2002-11-20 19:59:43 +01:00
|
|
|
}
|
|
|
|
|