X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FRegAlloc%2FLiveRange.h;h=c3caa295717b937320a510bdbb6b4fdc87b1cce8;hb=ef6a6a69ff1e1b709d0acb315b9f6c926c67a778;hp=23c217cd7a39afb8eed8e393bd63078cfbd6d23c;hpb=20c82b12c909ed643e9b47f93a60fefc46753bcd;p=oota-llvm.git diff --git a/lib/CodeGen/RegAlloc/LiveRange.h b/lib/CodeGen/RegAlloc/LiveRange.h index 23c217cd7a3..c3caa295717 100644 --- a/lib/CodeGen/RegAlloc/LiveRange.h +++ b/lib/CodeGen/RegAlloc/LiveRange.h @@ -1,193 +1,173 @@ -/* 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. -*/ +//===-- LiveRange.h - Store info about a live range -------------*- C++ -*-===// +// +// Implements a live range using a ValueSet. A LiveRange is a simple set +// of Values. +// +// 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" - - - +#include "llvm/CodeGen/ValueSet.h" +#include "llvm/Value.h" class RegClass; class IGNode; - -class LiveRange : public ValueSet -{ - private: - +class LiveRange : public ValueSet { RegClass *MyRegClass; // register classs (e.g., int, FP) for this LR - // a list of call instructions that interferes with this live range - //vector CallInterferenceList; - - // does this live range span across calls? + // doesSpanAcrossCalls - Does this live range span across calls? // This information is used by graph // coloring algo to avoid allocating volatile colors to live ranges // that span across calls (since they have to be saved/restored) - + // bool doesSpanAcrossCalls; 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 ***TODO REMOVE this + // mustSaveAcrossCalls - whether this LR must be saved accross calls + // ***TODO REMOVE this + // bool mustSaveAcrossCalls; - - // bool mustLoadFromStack; // must load from stack at start of method - - + + // SuggestedColor - if this LR has a suggested color, can it be + // really alloated? A suggested color cannot be allocated when the + // suggested color is volatile and when there are call + // interferences. + // int SuggestedColor; // The suggested color for this LR - // if this LR has a suggested color, can it be really alloated? - // A suggested color cannot be allocated when the suggested color is - // volatile and when there are call interferences. - + // CanUseSuggestedCol - It is possible that a suggested color for + // this live range is not available before graph coloring (e.g., it + // can be allocated to another live range which interferes with + // this) + // bool CanUseSuggestedCol; - // if this LR is spilled, its stack offset from *FP*. The spilled offsets - // must always be relative to the FP. + // SpilledStackOffsetFromFP - If this LR is spilled, its stack + // offset from *FP*. The spilled offsets must always be relative to + // the FP. + // int SpilledStackOffsetFromFP; - bool HasSpillOffset; - - public: + // HasSpillOffset 0 Whether this live range has a spill offset + // + bool HasSpillOffset; - ~LiveRange() {} // empty destructor + // The spill cost of this live range. Calculated using loop depth of + // each reference to each Value in the live range + // + unsigned SpillCost; + +public: + LiveRange() { + Color = SuggestedColor = -1; // not yet colored + mustSpill = mustSaveAcrossCalls = false; + MyRegClass = 0; + UserIGNode = 0; + doesSpanAcrossCalls = false; + CanUseSuggestedCol = true; + HasSpillOffset = false; + SpillCost = 0; + } - void setRegClass(RegClass *const RC) - { MyRegClass = RC; } + void setRegClass(RegClass *RC) { MyRegClass = RC; } - inline RegClass *const getRegClass() const - { assert(MyRegClass); return MyRegClass; } + RegClass *getRegClass() const { assert(MyRegClass); return MyRegClass; } + unsigned getRegClassID() const; - inline bool hasColor() const - { return Color != -1; } + bool hasColor() const { return Color != -1; } - inline unsigned int getColor() const - { assert( Color != -1); return (unsigned) Color ; } + unsigned getColor() const { assert(Color != -1); return (unsigned)Color; } - inline void setColor(unsigned int Col) - { Color = (int) Col ; } + void setColor(unsigned Col) { Color = (int)Col; } - inline void setCallInterference() { doesSpanAcrossCalls = 1; } - + inline void clearCallInterference() { + doesSpanAcrossCalls = 0; + } inline bool isCallInterference() const { - return (doesSpanAcrossCalls == 1); + return doesSpanAcrossCalls == 1; } - inline void markForSpill() { mustSpill = true; } - inline bool isMarkedForSpill() { return mustSpill; } + inline bool isMarkedForSpill() const { return mustSpill; } inline void setSpillOffFromFP(int StackOffset) { - assert( mustSpill && "This LR is not spilled"); + assert(mustSpill && "This LR is not spilled"); SpilledStackOffsetFromFP = StackOffset; HasSpillOffset = true; } inline void modifySpillOffFromFP(int StackOffset) { - assert( mustSpill && "This LR is not spilled"); + assert(mustSpill && "This LR is not spilled"); SpilledStackOffsetFromFP = StackOffset; HasSpillOffset = true; } - - - inline bool hasSpillOffset() { - return HasSpillOffset; + inline bool hasSpillOffset() const { + return HasSpillOffset; } - inline int getSpillOffFromFP() const { - assert( HasSpillOffset && "This LR is not spilled"); + assert(HasSpillOffset && "This LR is not spilled"); return SpilledStackOffsetFromFP; } - 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 void setUserIGNode(IGNode *IGN) { + assert(!UserIGNode); UserIGNode = IGN; } + // getUserIGNode - NULL if the user is not allocated + inline IGNode *getUserIGNode() const { return UserIGNode; } + inline const Type *getType() const { + return (*begin())->getType(); // set's don't have a front + } + inline void setSuggestedColor(int Col) { - //assert( (SuggestedColor == -1) && "Changing an already suggested color"); - - if(SuggestedColor == -1 ) + if (SuggestedColor == -1) SuggestedColor = Col; - else if (DEBUG_RA) - cerr << "Already has a suggested color " << Col << endl; } inline unsigned getSuggestedColor() const { - assert( SuggestedColor != -1); // only a valid color is obtained - return (unsigned) SuggestedColor; + assert(SuggestedColor != -1); // only a valid color is obtained + return (unsigned)SuggestedColor; } inline bool hasSuggestedColor() const { - return ( SuggestedColor > -1); + return SuggestedColor != -1; } inline bool isSuggestedColorUsable() const { - assert( hasSuggestedColor() && "No suggested color"); + assert(hasSuggestedColor() && "No suggested color"); return CanUseSuggestedCol; } - inline void setSuggestedColorUsable(const bool val) { - assert( hasSuggestedColor() && "No suggested color"); + inline void setSuggestedColorUsable(bool val) { + assert(hasSuggestedColor() && "No suggested color"); CanUseSuggestedCol = val; } + inline void addSpillCost(unsigned cost) { + SpillCost += cost; + } - - - - - - inline LiveRange() : ValueSet() /* , CallInterferenceList() */ - { - Color = SuggestedColor = -1; // not yet colored - mustSpill = mustSaveAcrossCalls = false; - MyRegClass = NULL; - UserIGNode = NULL; - doesSpanAcrossCalls = false; - CanUseSuggestedCol = true; - HasSpillOffset = false; - } - + inline unsigned getSpillCost() const { + return SpillCost; + } }; - - - - #endif -