From f5fa52ed064098be7130aa4ec1236037907ce3fa Mon Sep 17 00:00:00 2001 From: Evan Cheng Date: Fri, 24 Jun 2011 20:42:09 +0000 Subject: - Add MCRegisterInfo registration machinery. Also added x86 registration routines. - Rename TargetRegisterDesc to MCRegisterDesc. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@133820 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/MC/MCRegisterInfo.h | 16 ++++++--- include/llvm/Target/TargetRegisterInfo.h | 3 ++ include/llvm/Target/TargetRegistry.h | 60 +++++++++++++++++++++++--------- 3 files changed, 57 insertions(+), 22 deletions(-) (limited to 'include') diff --git a/include/llvm/MC/MCRegisterInfo.h b/include/llvm/MC/MCRegisterInfo.h index 30db84b..c2ec08e 100644 --- a/include/llvm/MC/MCRegisterInfo.h +++ b/include/llvm/MC/MCRegisterInfo.h @@ -30,7 +30,7 @@ namespace llvm { /// super-registers of the specific register, e.g. RAX, EAX, are super-registers /// of AX. /// -struct TargetRegisterDesc { +struct MCRegisterDesc { const char *Name; // Printable name for the reg (for debugging) const unsigned *Overlaps; // Overlapping registers, described above const unsigned *SubRegs; // Sub-register set, described above @@ -43,20 +43,26 @@ struct TargetRegisterDesc { /// to this array so that we can turn register number into a register /// descriptor. /// +/// Note this class is designed to be a base class of TargetRegisterInfo, which +/// is the interface used by codegen. However, specific targets *should never* +/// specialize this class. MCRegisterInfo should only contain getters to access +/// TableGen generated physical register data. It must not be extended with +/// virtual methods. +/// class MCRegisterInfo { private: - const TargetRegisterDesc *Desc; // Pointer to the descriptor array + const MCRegisterDesc *Desc; // Pointer to the descriptor array unsigned NumRegs; // Number of entries in the array public: /// InitMCRegisterInfo - Initialize MCRegisterInfo, called by TableGen /// auto-generated routines. *DO NOT USE*. - void InitMCRegisterInfo(const TargetRegisterDesc *D, unsigned NR) { + void InitMCRegisterInfo(const MCRegisterDesc *D, unsigned NR) { Desc = D; NumRegs = NR; } - const TargetRegisterDesc &operator[](unsigned RegNo) const { + const MCRegisterDesc &operator[](unsigned RegNo) const { assert(RegNo < NumRegs && "Attempting to access record for invalid register number!"); return Desc[RegNo]; @@ -65,7 +71,7 @@ public: /// Provide a get method, equivalent to [], but more useful if we have a /// pointer to this object. /// - const TargetRegisterDesc &get(unsigned RegNo) const { + const MCRegisterDesc &get(unsigned RegNo) const { return operator[](RegNo); } diff --git a/include/llvm/Target/TargetRegisterInfo.h b/include/llvm/Target/TargetRegisterInfo.h index d50bfe7..2b7e1f9 100644 --- a/include/llvm/Target/TargetRegisterInfo.h +++ b/include/llvm/Target/TargetRegisterInfo.h @@ -256,6 +256,9 @@ public: bool isAllocatable() const { return Allocatable; } }; +/// TargetRegisterDesc - It's just an alias of MCRegisterDesc. +typedef MCRegisterDesc TargetRegisterDesc; + /// TargetRegisterInfoDesc - Extra information, not in MCRegisterDesc, about /// registers. These are used by codegen, not by MC. struct TargetRegisterInfoDesc { diff --git a/include/llvm/Target/TargetRegistry.h b/include/llvm/Target/TargetRegistry.h index 2e21901..cf33899 100644 --- a/include/llvm/Target/TargetRegistry.h +++ b/include/llvm/Target/TargetRegistry.h @@ -66,8 +66,7 @@ namespace llvm { typedef MCAsmInfo *(*AsmInfoCtorFnTy)(const Target &T, StringRef TT); - typedef MCRegisterInfo *(*RegInfoCtorFnTy)(const Target &T, - StringRef TT); + typedef MCRegisterInfo *(*MCRegInfoCtorFnTy)(void); typedef TargetMachine *(*TargetMachineCtorTy)(const Target &T, const std::string &TT, const std::string &Features); @@ -127,9 +126,9 @@ namespace llvm { /// registered. AsmInfoCtorFnTy AsmInfoCtorFn; - /// RegInfoCtorFn - Constructor function for this target's MCRegisterInfo, + /// MCRegInfoCtorFn - Constructor function for this target's MCRegisterInfo, /// if registered. - RegInfoCtorFnTy RegInfoCtorFn; + MCRegInfoCtorFnTy MCRegInfoCtorFn; /// TargetMachineCtorFn - Construction function for this target's /// TargetMachine, if registered. @@ -240,17 +239,12 @@ namespace llvm { return AsmInfoCtorFn(*this, Triple); } - /// createRegInfo - Create a MCRegisterInfo implementation for the specified - /// target triple. + /// createMCRegInfo - Create a MCRegisterInfo implementation. /// - /// \arg Triple - This argument is used to determine the target machine - /// feature set; it should always be provided. Generally this should be - /// either the target triple from the module, or the target triple of the - /// host if that does not exist. - MCRegisterInfo *createRegInfo(StringRef Triple) const { - if (!RegInfoCtorFn) + MCRegisterInfo *createMCRegInfo() const { + if (!MCRegInfoCtorFn) return 0; - return RegInfoCtorFn(*this, Triple); + return MCRegInfoCtorFn(); } /// createTargetMachine - Create a target specific machine implementation @@ -466,7 +460,7 @@ namespace llvm { T.AsmInfoCtorFn = Fn; } - /// RegisterRegInfo - Register a MCRegisterInfo implementation for the + /// RegisterMCRegInfo - Register a MCRegisterInfo implementation for the /// given target. /// /// Clients are responsible for ensuring that registration doesn't occur @@ -475,10 +469,10 @@ namespace llvm { /// /// @param T - The target being registered. /// @param Fn - A function to construct a MCRegisterInfo for the target. - static void RegisterRegInfo(Target &T, Target::RegInfoCtorFnTy Fn) { + static void RegisterMCRegInfo(Target &T, Target::MCRegInfoCtorFnTy Fn) { // Ignore duplicate registration. - if (!T.RegInfoCtorFn) - T.RegInfoCtorFn = Fn; + if (!T.MCRegInfoCtorFn) + T.MCRegInfoCtorFn = Fn; } /// RegisterTargetMachine - Register a TargetMachine implementation for the @@ -691,6 +685,38 @@ namespace llvm { } }; + /// RegisterMCRegInfo - Helper template for registering a target register info + /// implementation. This invokes the static "Create" method on the class to + /// actually do the construction. Usage: + /// + /// extern "C" void LLVMInitializeFooTarget() { + /// extern Target TheFooTarget; + /// RegisterMCRegInfo X(TheFooTarget); + /// } + template + struct RegisterMCRegInfo { + RegisterMCRegInfo(Target &T) { + TargetRegistry::RegisterMCRegInfo(T, &Allocator); + } + private: + static MCRegisterInfo *Allocator() { + return new MCRegisterInfoImpl(); + } + }; + + /// RegisterMCRegInfoFn - Helper template for registering a target register + /// info implementation. This invokes the specified function to do the + /// construction. Usage: + /// + /// extern "C" void LLVMInitializeFooTarget() { + /// extern Target TheFooTarget; + /// RegisterMCRegInfoFn X(TheFooTarget, TheFunction); + /// } + struct RegisterMCRegInfoFn { + RegisterMCRegInfoFn(Target &T, Target::MCRegInfoCtorFnTy Fn) { + TargetRegistry::RegisterMCRegInfo(T, Fn); + } + }; /// RegisterTargetMachine - Helper template for registering a target machine /// implementation, for use in the target machine initialization -- cgit v1.1