#ifndef LIVERANGE_H
#define LIVERANGE_H
-#include "llvm/CodeGen/ValueSet.h"
#include "llvm/Value.h"
+#include "llvm/CodeGen/ValueSet.h"
class RegClass;
class IGNode;
class LiveRange : public ValueSet {
- RegClass *MyRegClass; // register classs (e.g., int, FP) for this LR
+ RegClass *MyRegClass; // register class (e.g., int, FP) for this LR
- // 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)
- //
+ /// 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
- // mustSaveAcrossCalls - 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;
- // 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.
- //
+ /// 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
- // 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)
- //
+ /// 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;
- // SpilledStackOffsetFromFP - 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;
- // HasSpillOffset 0 Whether this live range has a spill offset
- //
+ /// HasSpillOffset 0 Whether this live range has a spill offset
+ ///
bool HasSpillOffset;
- // The spill cost of this live range. Calculated using loop depth of
- // each reference to each Value in the live range
- //
+ /// The spill cost of this live range. Calculated using loop depth of
+ /// each reference to each Value in the live range
+ ///
unsigned SpillCost;
public:
//
//===----------------------------------------------------------------------===//
+#include "IGNode.h"
#include "LiveRangeInfo.h"
#include "RegAllocCommon.h"
#include "RegClass.h"
-#include "IGNode.h"
+#include "llvm/Function.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetRegInfo.h"
-#include "llvm/Function.h"
#include "Support/SetOperations.h"
unsigned LiveRange::getRegClassID() const { return getRegClass()->getID(); }
}
} // for all machine instructions in the BB
-
} // for all BBs in function
// Now we have to suggest clors for call and return arg live ranges.
// Checks if live range LR interferes with any node assigned or suggested to
// be assigned the specified color
//
-inline bool InterferesWithColor(const LiveRange& LR, unsigned color)
-{
+inline bool InterferesWithColor(const LiveRange& LR, unsigned color) {
IGNode* lrNode = LR.getUserIGNode();
for (unsigned n=0, NN = lrNode->getNumOfNeighbors(); n < NN; n++) {
LiveRange *neighLR = lrNode->getAdjIGNode(n)->getParentLR();
// (4) LR2 has color and LR1 interferes with any LR that has the same color
//
inline bool InterfsPreventCoalescing(const LiveRange& LROfDef,
- const LiveRange& LROfUse)
-{
+ const LiveRange& LROfUse) {
// (4) if they have different suggested colors, cannot coalesce
if (LROfDef.hasSuggestedColor() && LROfUse.hasSuggestedColor())
return true;
std::vector<RegClass *> & RCList);
- // Destructor to destroy all LiveRanges in the LiveRange Map
+ /// Destructor to destroy all LiveRanges in the LiveRange Map
+ ///
~LiveRangeInfo();
// Main entry point for live range construction
//
void constructLiveRanges();
- // return the common live range map for this method
- //
+ /// return the common live range map for this method
+ ///
inline const LiveRangeMapType *getLiveRangeMap() const
{ return &LiveRangeMap; }
- // Method used to get the live range containing a Value.
- // This may return NULL if no live range exists for a Value (eg, some consts)
+ /// Method used to get the live range containing a Value.
+ /// This may return NULL if no live range exists for a Value (eg, some consts)
+ ///
inline LiveRange *getLiveRangeForValue(const Value *Val) {
return LiveRangeMap[Val];
}
return I->second;
}
- // Method for coalescing live ranges. Called only after interference info
- // is calculated.
- //
+ /// Method for coalescing live ranges. Called only after interference info
+ /// is calculated.
+ ///
void coalesceLRs();
- // debugging method to print the live ranges
- //
+ /// debugging method to print the live ranges
+ ///
void printLiveRanges();
};
#ifndef LIVERANGE_H
#define LIVERANGE_H
-#include "llvm/CodeGen/ValueSet.h"
#include "llvm/Value.h"
+#include "llvm/CodeGen/ValueSet.h"
class RegClass;
class IGNode;
class LiveRange : public ValueSet {
- RegClass *MyRegClass; // register classs (e.g., int, FP) for this LR
+ RegClass *MyRegClass; // register class (e.g., int, FP) for this LR
- // 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)
- //
+ /// 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
- // mustSaveAcrossCalls - 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;
- // 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.
- //
+ /// 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
- // 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)
- //
+ /// 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;
- // SpilledStackOffsetFromFP - 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;
- // HasSpillOffset 0 Whether this live range has a spill offset
- //
+ /// HasSpillOffset 0 Whether this live range has a spill offset
+ ///
bool HasSpillOffset;
- // The spill cost of this live range. Calculated using loop depth of
- // each reference to each Value in the live range
- //
+ /// The spill cost of this live range. Calculated using loop depth of
+ /// each reference to each Value in the live range
+ ///
unsigned SpillCost;
public:
//
//===----------------------------------------------------------------------===//
+#include "IGNode.h"
#include "LiveRangeInfo.h"
#include "RegAllocCommon.h"
#include "RegClass.h"
-#include "IGNode.h"
+#include "llvm/Function.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetRegInfo.h"
-#include "llvm/Function.h"
#include "Support/SetOperations.h"
unsigned LiveRange::getRegClassID() const { return getRegClass()->getID(); }
}
} // for all machine instructions in the BB
-
} // for all BBs in function
// Now we have to suggest clors for call and return arg live ranges.
// Checks if live range LR interferes with any node assigned or suggested to
// be assigned the specified color
//
-inline bool InterferesWithColor(const LiveRange& LR, unsigned color)
-{
+inline bool InterferesWithColor(const LiveRange& LR, unsigned color) {
IGNode* lrNode = LR.getUserIGNode();
for (unsigned n=0, NN = lrNode->getNumOfNeighbors(); n < NN; n++) {
LiveRange *neighLR = lrNode->getAdjIGNode(n)->getParentLR();
// (4) LR2 has color and LR1 interferes with any LR that has the same color
//
inline bool InterfsPreventCoalescing(const LiveRange& LROfDef,
- const LiveRange& LROfUse)
-{
+ const LiveRange& LROfUse) {
// (4) if they have different suggested colors, cannot coalesce
if (LROfDef.hasSuggestedColor() && LROfUse.hasSuggestedColor())
return true;
std::vector<RegClass *> & RCList);
- // Destructor to destroy all LiveRanges in the LiveRange Map
+ /// Destructor to destroy all LiveRanges in the LiveRange Map
+ ///
~LiveRangeInfo();
// Main entry point for live range construction
//
void constructLiveRanges();
- // return the common live range map for this method
- //
+ /// return the common live range map for this method
+ ///
inline const LiveRangeMapType *getLiveRangeMap() const
{ return &LiveRangeMap; }
- // Method used to get the live range containing a Value.
- // This may return NULL if no live range exists for a Value (eg, some consts)
+ /// Method used to get the live range containing a Value.
+ /// This may return NULL if no live range exists for a Value (eg, some consts)
+ ///
inline LiveRange *getLiveRangeForValue(const Value *Val) {
return LiveRangeMap[Val];
}
return I->second;
}
- // Method for coalescing live ranges. Called only after interference info
- // is calculated.
- //
+ /// Method for coalescing live ranges. Called only after interference info
+ /// is calculated.
+ ///
void coalesceLRs();
- // debugging method to print the live ranges
- //
+ /// debugging method to print the live ranges
+ ///
void printLiveRanges();
};
projects / oota-llvm.git / commitdiff