-/* 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"
-
-
-
+//===-- LiveRange.h - Store info about a live range -------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// 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 LIVERANGE_H
+#define LIVERANGE_H
+
+#include "llvm/Value.h"
+#include "llvm/CodeGen/ValueSet.h"
class RegClass;
class IGNode;
+class LiveRange : public ValueSet {
+ RegClass *MyRegClass; // register class (e.g., int, FP) for this LR
-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<const Instruction *> CallInterferenceList;
-
- // 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)
-
+ /// 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() const {
- return HasSpillOffset;
+ 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 setUserIGNode(IGNode *IGN) {
+ assert(!UserIGNode); UserIGNode = IGN;
+ }
- // 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
+ // getUserIGNode - NULL if the user is not allocated
+ inline IGNode *getUserIGNode() const { return UserIGNode; }
- inline const Type* getType() const {
- const Value *val = *begin();
- assert(val && "Can't find type - Live range is empty" );
- return val->getType();
+ inline const Type *getType() const {
+ return (*begin())->getType(); // set's don't have a front
}
- inline Type::PrimitiveID getTypeID() const {
- return this->getType()->getPrimitiveID();
- }
-
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
-
projects / oota-llvm.git / blobdiff