From c7136d2b09a796528d7ce790190394dceb3ab6c3 Mon Sep 17 00:00:00 2001 From: Ruchira Sasanka Date: Sat, 8 Sep 2001 14:10:34 +0000 Subject: [PATCH] --Ruchira git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@504 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/CodeGen/RegAlloc/LiveRange.h | 110 ++++++++++++++++++++ lib/CodeGen/RegAlloc/LiveRangeInfo.h | 87 ++++++++++++++++ lib/Target/SparcV9/RegAlloc/LiveRange.h | 110 ++++++++++++++++++++ lib/Target/SparcV9/RegAlloc/LiveRangeInfo.h | 87 ++++++++++++++++ 4 files changed, 394 insertions(+) create mode 100644 lib/CodeGen/RegAlloc/LiveRange.h create mode 100644 lib/CodeGen/RegAlloc/LiveRangeInfo.h create mode 100644 lib/Target/SparcV9/RegAlloc/LiveRange.h create mode 100644 lib/Target/SparcV9/RegAlloc/LiveRangeInfo.h diff --git a/lib/CodeGen/RegAlloc/LiveRange.h b/lib/CodeGen/RegAlloc/LiveRange.h new file mode 100644 index 00000000000..d8e130a329c --- /dev/null +++ b/lib/CodeGen/RegAlloc/LiveRange.h @@ -0,0 +1,110 @@ +/* Title: LiveRange.h + Author: Ruchira Sasanka + Date: July 25, 01 + Purpose: To keep info about a live range. + Asuumptions: + + Since the Value pointed by a use is the same as of its def, it is sufficient + to keep only defs in a LiveRange. +*/ + +#ifndef LIVE_RANGE_H +#define LIVE_RANGE_H + +#include "llvm/Analysis/LiveVar/ValueSet.h" +#include "llvm/Type.h" + + + + +class RegClass; +class IGNode; + + +class LiveRange : public ValueSet +{ + private: + + RegClass *MyRegClass; // register classs (e.g., int, FP) for this LR + + // a list of call instructions that interferes with this live range + vector CallInterferenceList; + + IGNode *UserIGNode; // IGNode which uses this LR + int Color; // color assigned to this live range + bool mustSpill; // whether this LR must be spilt + + // whether this LR must be saved accross calls + bool mustSaveAcrossCalls; + + // bool mustLoadFromStack; // must load from stack at start of method + + public: + + + ~LiveRange() {} // empty destructor + + void setRegClass(RegClass *const RC) + { MyRegClass = RC; } + + inline RegClass *const getRegClass() const + { assert(MyRegClass); return MyRegClass; } + + inline bool hasColor() const + { return Color != -1; } + + inline unsigned int getColor() const + { assert( Color != -1); return (unsigned) Color ; } + + inline void setColor(unsigned int Col) + { Color = (int) Col ; } + + + inline void addCallInterference(const Instruction *const Inst) + { CallInterferenceList.push_back( Inst ); } + + inline const Instruction *const getCallInterference(const unsigned i) const { + assert( i < CallInterferenceList.size() ); + return CallInterferenceList[i]; + } + + inline unsigned int getNumOfCallInterferences() const + { return CallInterferenceList.size(); } + + + inline void markForSpill() { mustSpill = true; } + + inline void markForSaveAcrossCalls() { mustSaveAcrossCalls = true; } + + // inline void markForLoadFromStack() { mustLoadFromStack = true; + + + inline void setUserIGNode( IGNode *const IGN) + { assert( !UserIGNode); UserIGNode = IGN; } + + inline IGNode * getUserIGNode() const + { return UserIGNode; } // NULL if the user is not allocated + + inline Type::PrimitiveID getTypeID() const { + const Value *val = *begin(); + assert(val && "Can't find type - Live range is empty" ); + return (val->getType())->getPrimitiveID(); + } + + + inline LiveRange() : ValueSet() , CallInterferenceList() + { + Color = -1; // not yet colored + mustSpill = mustSaveAcrossCalls = false; + MyRegClass = NULL; + UserIGNode = NULL; + } + +}; + + + + + +#endif + diff --git a/lib/CodeGen/RegAlloc/LiveRangeInfo.h b/lib/CodeGen/RegAlloc/LiveRangeInfo.h new file mode 100644 index 00000000000..9d386c1d985 --- /dev/null +++ b/lib/CodeGen/RegAlloc/LiveRangeInfo.h @@ -0,0 +1,87 @@ +/* Title: LiveRangeInfo.h + Author: Ruchira Sasanka + Date: Jun 30, 01 + Purpose: + + This file constructs and keeps the LiveRang map which contains all the live + ranges used in a method. + + Assumptions: + + All variables (llvm Values) are defined before they are used. However, a + constant may not be defined in the machine instruction stream if it can be + used as an immediate value within a machine instruction. However, register + allocation does not have to worry about immediate constants since they + do not require registers. + + Since an llvm Value has a list of uses associated, it is sufficient to + record only the defs in a Live Range. + +*/ + + +#ifndef LIVE_RANGE_INFO_H +#define LIVE_RANGE_INFO_H + + +#include "llvm/Type.h" +#include "llvm/Method.h" +#include "llvm/CodeGen/MachineInstr.h" + +#include "llvm/Analysis/LiveVar/LiveVarSet.h" + +#include "llvm/CodeGen/IGNode.h" +#include "llvm/CodeGen/LiveRange.h" +#include "llvm/CodeGen/RegClass.h" + +/* + #ifndef size_type + #define size_type (unsigned int) + #endif +*/ + + +typedef hash_map LiveRangeMapType; + + +class LiveRangeInfo +{ + +private: + + const Method *const Meth; // Method for which live range info is held + + LiveRangeMapType LiveRangeMap; // A map from Value * to LiveRange * + // created by constructLiveRanges + + void unionAndUpdateLRs(LiveRange *L1, LiveRange *L2); + + void addInterference(const Instruction *const Inst, + const LiveVarSet *const LVSet); + + +public: + + LiveRangeInfo(const Method *const M); + + void constructLiveRanges(); + + inline const LiveRangeMapType *const getLiveRangeMap() const + { return &LiveRangeMap; } + + inline LiveRange *getLiveRangeForValue( const Value *const Val) + { return LiveRangeMap[ Val ]; } + + + + + void coalesceLRs(); + + void printLiveRanges(); + +}; + + + + +#endif diff --git a/lib/Target/SparcV9/RegAlloc/LiveRange.h b/lib/Target/SparcV9/RegAlloc/LiveRange.h new file mode 100644 index 00000000000..d8e130a329c --- /dev/null +++ b/lib/Target/SparcV9/RegAlloc/LiveRange.h @@ -0,0 +1,110 @@ +/* Title: LiveRange.h + Author: Ruchira Sasanka + Date: July 25, 01 + Purpose: To keep info about a live range. + Asuumptions: + + Since the Value pointed by a use is the same as of its def, it is sufficient + to keep only defs in a LiveRange. +*/ + +#ifndef LIVE_RANGE_H +#define LIVE_RANGE_H + +#include "llvm/Analysis/LiveVar/ValueSet.h" +#include "llvm/Type.h" + + + + +class RegClass; +class IGNode; + + +class LiveRange : public ValueSet +{ + private: + + RegClass *MyRegClass; // register classs (e.g., int, FP) for this LR + + // a list of call instructions that interferes with this live range + vector CallInterferenceList; + + IGNode *UserIGNode; // IGNode which uses this LR + int Color; // color assigned to this live range + bool mustSpill; // whether this LR must be spilt + + // whether this LR must be saved accross calls + bool mustSaveAcrossCalls; + + // bool mustLoadFromStack; // must load from stack at start of method + + public: + + + ~LiveRange() {} // empty destructor + + void setRegClass(RegClass *const RC) + { MyRegClass = RC; } + + inline RegClass *const getRegClass() const + { assert(MyRegClass); return MyRegClass; } + + inline bool hasColor() const + { return Color != -1; } + + inline unsigned int getColor() const + { assert( Color != -1); return (unsigned) Color ; } + + inline void setColor(unsigned int Col) + { Color = (int) Col ; } + + + inline void addCallInterference(const Instruction *const Inst) + { CallInterferenceList.push_back( Inst ); } + + inline const Instruction *const getCallInterference(const unsigned i) const { + assert( i < CallInterferenceList.size() ); + return CallInterferenceList[i]; + } + + inline unsigned int getNumOfCallInterferences() const + { return CallInterferenceList.size(); } + + + inline void markForSpill() { mustSpill = true; } + + inline void markForSaveAcrossCalls() { mustSaveAcrossCalls = true; } + + // inline void markForLoadFromStack() { mustLoadFromStack = true; + + + inline void setUserIGNode( IGNode *const IGN) + { assert( !UserIGNode); UserIGNode = IGN; } + + inline IGNode * getUserIGNode() const + { return UserIGNode; } // NULL if the user is not allocated + + inline Type::PrimitiveID getTypeID() const { + const Value *val = *begin(); + assert(val && "Can't find type - Live range is empty" ); + return (val->getType())->getPrimitiveID(); + } + + + inline LiveRange() : ValueSet() , CallInterferenceList() + { + Color = -1; // not yet colored + mustSpill = mustSaveAcrossCalls = false; + MyRegClass = NULL; + UserIGNode = NULL; + } + +}; + + + + + +#endif + diff --git a/lib/Target/SparcV9/RegAlloc/LiveRangeInfo.h b/lib/Target/SparcV9/RegAlloc/LiveRangeInfo.h new file mode 100644 index 00000000000..9d386c1d985 --- /dev/null +++ b/lib/Target/SparcV9/RegAlloc/LiveRangeInfo.h @@ -0,0 +1,87 @@ +/* Title: LiveRangeInfo.h + Author: Ruchira Sasanka + Date: Jun 30, 01 + Purpose: + + This file constructs and keeps the LiveRang map which contains all the live + ranges used in a method. + + Assumptions: + + All variables (llvm Values) are defined before they are used. However, a + constant may not be defined in the machine instruction stream if it can be + used as an immediate value within a machine instruction. However, register + allocation does not have to worry about immediate constants since they + do not require registers. + + Since an llvm Value has a list of uses associated, it is sufficient to + record only the defs in a Live Range. + +*/ + + +#ifndef LIVE_RANGE_INFO_H +#define LIVE_RANGE_INFO_H + + +#include "llvm/Type.h" +#include "llvm/Method.h" +#include "llvm/CodeGen/MachineInstr.h" + +#include "llvm/Analysis/LiveVar/LiveVarSet.h" + +#include "llvm/CodeGen/IGNode.h" +#include "llvm/CodeGen/LiveRange.h" +#include "llvm/CodeGen/RegClass.h" + +/* + #ifndef size_type + #define size_type (unsigned int) + #endif +*/ + + +typedef hash_map LiveRangeMapType; + + +class LiveRangeInfo +{ + +private: + + const Method *const Meth; // Method for which live range info is held + + LiveRangeMapType LiveRangeMap; // A map from Value * to LiveRange * + // created by constructLiveRanges + + void unionAndUpdateLRs(LiveRange *L1, LiveRange *L2); + + void addInterference(const Instruction *const Inst, + const LiveVarSet *const LVSet); + + +public: + + LiveRangeInfo(const Method *const M); + + void constructLiveRanges(); + + inline const LiveRangeMapType *const getLiveRangeMap() const + { return &LiveRangeMap; } + + inline LiveRange *getLiveRangeForValue( const Value *const Val) + { return LiveRangeMap[ Val ]; } + + + + + void coalesceLRs(); + + void printLiveRanges(); + +}; + + + + +#endif -- 2.34.1