* Code Cleanups
* Introduce RAV to allow stream I/O instead of using printValue
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1710 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/CodeGen/RegAlloc/LiveRange.h b/lib/CodeGen/RegAlloc/LiveRange.h
index e1e2992..6c2952a 100644
--- a/lib/CodeGen/RegAlloc/LiveRange.h
+++ b/lib/CodeGen/RegAlloc/LiveRange.h
@@ -1,12 +1,12 @@
-/* Title: LiveRange.h -*- C++ -*-
- 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
@@ -18,149 +18,120 @@
class RegClass;
class IGNode;
-
-//----------------------------------------------------------------------------
-// Class LiveRange
-//
-// Implements a live range using a ValueSet. A LiveRange is a simple set
-// of Values.
-//----------------------------------------------------------------------------
-
class LiveRange : public ValueSet {
RegClass *MyRegClass; // register classs (e.g., int, FP) for this LR
- bool doesSpanAcrossCalls;
- //
- // 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
-
+ // mustSaveAcrossCalls - whether this LR must be saved accross calls
+ // ***TODO REMOVE this
+ //
bool mustSaveAcrossCalls;
- //
- // whether this LR must be saved accross calls ***TODO REMOVE this
+ // 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.
- bool CanUseSuggestedCol;
+ // 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)
//
- // 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.
+ //
int SpilledStackOffsetFromFP;
- //
- // if this LR is spilled, its stack offset from *FP*. The spilled offsets
- // must always be relative to the FP.
+ // HasSpillOffset 0 Whether this live range has a spill offset
+ //
bool HasSpillOffset;
- //
- // Whether this live range has a spill offset
- unsigned SpillCost;
- //
// The spill cost of this live range. Calculated using loop depth of
// each reference to each Value in the live range
-
- public:
-
- // constructor
//
- LiveRange() : ValueSet() {
+ unsigned SpillCost;
+
+public:
+ LiveRange() {
Color = SuggestedColor = -1; // not yet colored
mustSpill = mustSaveAcrossCalls = false;
- MyRegClass = NULL;
- UserIGNode = NULL;
+ MyRegClass = 0;
+ UserIGNode = 0;
doesSpanAcrossCalls = false;
CanUseSuggestedCol = true;
- HasSpillOffset = false;
+ HasSpillOffset = false;
SpillCost = 0;
}
- // empty destructor since there are nothing to be deleted
- //
- ~LiveRange() {}
+ void setRegClass(RegClass *RC) { MyRegClass = RC; }
+ RegClass *getRegClass() const { assert(MyRegClass); return MyRegClass; }
- void setRegClass(RegClass *const RC)
- { MyRegClass = RC; }
-
- inline RegClass *const getRegClass() const
- { assert(MyRegClass); return MyRegClass; }
-
- 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 bool isCallInterference() const {
- return (doesSpanAcrossCalls == 1);
+ return doesSpanAcrossCalls == 1;
}
inline void markForSpill() { mustSpill = true; }
- inline bool isMarkedForSpill() { return mustSpill; }
+ inline bool isMarkedForSpill() { 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 *const IGN)
- { assert( !UserIGNode); UserIGNode = IGN; }
+ inline void setUserIGNode(IGNode *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 {
@@ -168,9 +139,7 @@
}
inline void setSuggestedColor(int Col) {
- //assert( (SuggestedColor == -1) && "Changing an already suggested color");
-
- if(SuggestedColor == -1 )
+ if (SuggestedColor == -1)
SuggestedColor = Col;
#if 0
else if (DEBUG_RA)
@@ -179,21 +148,21 @@
}
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;
}
diff --git a/lib/CodeGen/RegAlloc/LiveRangeInfo.cpp b/lib/CodeGen/RegAlloc/LiveRangeInfo.cpp
index 26e4788..590c88f 100644
--- a/lib/CodeGen/RegAlloc/LiveRangeInfo.cpp
+++ b/lib/CodeGen/RegAlloc/LiveRangeInfo.cpp
@@ -118,8 +118,8 @@
if( DEBUG_RA > 1) {
- cerr << " adding LiveRange for argument ";
- printValue((const Value *) *ArgIt); cerr << "\n";
+ cerr << " adding LiveRange for argument "
+ << RAV((const Value *)*ArgIt) << "\n";
}
}
@@ -163,11 +163,9 @@
MachineOperand::MachineOperandType OpTyp =
OpI.getMachineOperand().getOperandType();
- if (OpTyp == MachineOperand::MO_CCRegister) {
- cerr << "\n**CC reg found. Is Def=" << OpI.isDef() << " Val:";
- printValue( OpI.getMachineOperand().getVRegValue() );
- cerr << "\n";
- }
+ if (OpTyp == MachineOperand::MO_CCRegister)
+ cerr << "\n**CC reg found. Is Def=" << OpI.isDef() << " Val:"
+ << RAV(OpI.getMachineOperand().getVRegValue()) << "\n";
}
// create a new LR iff this operand is a def
@@ -175,9 +173,9 @@
const Value *Def = *OpI;
// Only instruction values are accepted for live ranges here
- if( Def->getValueType() != Value::InstructionVal ) {
- cerr << "\n**%%Error: Def is not an instruction val. Def=";
- printValue( Def ); cerr << "\n";
+ if (Def->getValueType() != Value::InstructionVal ) {
+ cerr << "\n**%%Error: Def is not an instruction val. Def="
+ << RAV(Def) << "\n";
continue;
}
@@ -189,10 +187,8 @@
DefRange->insert(Def); // add the instruction (def) to it
LiveRangeMap[ Def ] = DefRange; // update the map
- if (DEBUG_RA > 1) {
- cerr << " creating a LR for def: ";
- printValue(Def); cerr << "\n";
- }
+ if (DEBUG_RA > 1)
+ cerr << " creating a LR for def: " << RAV(Def) << "\n";
// set the register class of the new live range
//assert( RegClassList.size() );
@@ -204,24 +200,20 @@
OpI.getMachineOperand().getVRegValue(), isCC );
- if(isCC && DEBUG_RA) {
- cerr << "\a**created a LR for a CC reg:";
- printValue( OpI.getMachineOperand().getVRegValue() );
- }
+ if (isCC && DEBUG_RA)
+ cerr << "\a**created a LR for a CC reg:"
+ << RAV(OpI.getMachineOperand().getVRegValue());
- DefRange->setRegClass( RegClassList[ rcid ] );
-
- }
- else {
+ DefRange->setRegClass(RegClassList[rcid]);
+ } else {
DefRange->insert(Def); // add the opearand to def range
// update the map - Operand points
// to the merged set
- LiveRangeMap[ Def ] = DefRange;
+ LiveRangeMap[Def] = DefRange;
- if( DEBUG_RA > 1) {
- cerr << " added to an existing LR for def: ";
- printValue( Def ); cerr << "\n";
- }
+ if (DEBUG_RA > 1)
+ cerr << " added to an existing LR for def: "
+ << RAV(Def) << "\n";
}
} // if isDef()
@@ -336,10 +328,8 @@
if( ! LROfUse ) { // if LR of use is not found
//don't warn about labels
- if (!((*UseI)->getType())->isLabelType() && DEBUG_RA) {
- cerr<<" !! Warning: No LR for use "; printValue(*UseI);
- cerr << "\n";
- }
+ if (!((*UseI)->getType())->isLabelType() && DEBUG_RA)
+ cerr << " !! Warning: No LR for use " << RAV(*UseI) << "\n";
continue; // ignore and continue
}
@@ -398,13 +388,12 @@
/*--------------------------- Debug code for printing ---------------*/
-void LiveRangeInfo::printLiveRanges()
-{
+void LiveRangeInfo::printLiveRanges() {
LiveRangeMapType::iterator HMI = LiveRangeMap.begin(); // hash map iterator
cerr << "\nPrinting Live Ranges from Hash Map:\n";
- for( ; HMI != LiveRangeMap.end() ; ++HMI) {
- if( HMI->first && HMI->second ) {
- cerr <<" "; printValue((*HMI).first); cerr << "\t: ";
+ for( ; HMI != LiveRangeMap.end(); ++HMI) {
+ if (HMI->first && HMI->second) {
+ cerr << " " << RAV(HMI->first) << "\t: ";
HMI->second->printSet(); cerr << "\n";
}
}
diff --git a/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp b/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
index d901337..90de8b9 100644
--- a/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
+++ b/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
@@ -118,8 +118,8 @@
LiveRange *L = HMI->second; // get the LiveRange
if (!L) {
if( DEBUG_RA) {
- cerr << "\n*?!?Warning: Null liver range found for: ";
- printValue(HMI->first); cerr << "\n";
+ cerr << "\n*?!?Warning: Null liver range found for: "
+ << RAV(HMI->first) << "\n";
}
continue;
}
@@ -170,14 +170,12 @@
//
for( ; LIt != LVSet->end(); ++LIt) {
- if( DEBUG_RA > 1) {
- cerr << "< Def="; printValue(Def);
- cerr << ", Lvar="; printValue( *LIt); cerr << "> ";
- }
+ if (DEBUG_RA > 1)
+ cerr << "< Def=" << RAV(Def) << ", Lvar=" << RAV(*LIt) << "> ";
// get the live range corresponding to live var
//
- LiveRange *const LROfVar = LRI.getLiveRangeForValue(*LIt );
+ LiveRange *LROfVar = LRI.getLiveRangeForValue(*LIt);
// LROfVar can be null if it is a const since a const
// doesn't have a dominating def - see Assumptions above
@@ -188,13 +186,12 @@
// if 2 reg classes are the same set interference
//
- if(RCOfDef == LROfVar->getRegClass()) {
+ if (RCOfDef == LROfVar->getRegClass()) {
RCOfDef->setInterference( LROfDef, LROfVar);
- } else if(DEBUG_RA > 1) {
+ } else if (DEBUG_RA > 1) {
// we will not have LRs for values not explicitly allocated in the
// instruction stream (e.g., constants)
- cerr << " warning: no live range for " ;
- printValue(*LIt); cerr << "\n";
+ cerr << " warning: no live range for " << RAV(*LIt) << "\n";
}
}
}
@@ -434,10 +431,9 @@
for( ; ArgIt != ArgList.end() ; ++ArgIt) { // for each argument
addInterference((Value*)*ArgIt, InSet, false); // add interferences between
// args and LVars at start
- if( DEBUG_RA > 1) {
- cerr << " - %% adding interference for argument ";
- printValue((const Value *)*ArgIt); cerr << "\n";
- }
+ if( DEBUG_RA > 1)
+ cerr << " - %% adding interference for argument "
+ << RAV((const Value *)*ArgIt) << "\n";
}
}
@@ -1051,15 +1047,11 @@
unsigned NumOfImpRefs = MInst->getNumImplicitRefs();
- if( NumOfImpRefs > 0 ) {
-
+ if( NumOfImpRefs > 0) {
cerr << "\tImplicit:";
- for(unsigned z=0; z < NumOfImpRefs; z++) {
- printValue( MInst->getImplicitRef(z) );
- cerr << "\t";
- }
-
+ for(unsigned z=0; z < NumOfImpRefs; z++)
+ cerr << RAV(MInst->getImplicitRef(z)) << "\t";
}
} // for all machine instructions