6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-25 16:24:23 +00:00
Code Issues Projects Releases Wiki Activity

* Code Cleanups

Browse Source 
* 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
This commit is contained in:
Chris Lattner
2002-02-05 01:43:49 +00:00
parent f39f379f9e
commit 0665a5f1f5
16 changed files with 300 additions and 462 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/Analysis/LiveVar/LiveVarSet.h
View File

@ -16,7 +16,7 @@ struct LiveVarSet : public ValueSet {
// This function applies a machine instr to a live var set (accepts OutSet) // This function applies a machine instr to a live var set (accepts OutSet)
// and makes necessary changes to it (produces InSet). // and makes necessary changes to it (produces InSet).
// //
void applyTranferFuncForMInst(const MachineInstr *const MInst); void applyTranferFuncForMInst(const MachineInstr *MInst);
}; };

13
include/llvm/Analysis/LiveVar/ValueSet.h
View File

@ -8,13 +8,20 @@
#ifndef VALUE_SET_H #ifndef VALUE_SET_H
#define VALUE_SET_H #define VALUE_SET_H
class Value;
#include <set> #include <set>
class Value;
// RAV - Used to print values in a form used by the register allocator.
//
struct RAV { // Register Allocator Value
const Value *V;
RAV(const Value *v) : V(v) {}
};
ostream &operator<<(ostream &out, RAV Val);
//------------------- Class Definition for ValueSet -------------------------- //------------------- Class Definition for ValueSet --------------------------
void printValue( const Value *v); // func to print a Value
struct ValueSet : public std::set<const Value*> { struct ValueSet : public std::set<const Value*> {
bool setUnion( const ValueSet *const set1); // for performing set union bool setUnion( const ValueSet *const set1); // for performing set union
void setSubtract( const ValueSet *const set1); // for performing set diff void setSubtract( const ValueSet *const set1); // for performing set diff

13
include/llvm/CodeGen/ValueSet.h
View File

@ -8,13 +8,20 @@
#ifndef VALUE_SET_H #ifndef VALUE_SET_H
#define VALUE_SET_H #define VALUE_SET_H
class Value;
#include <set> #include <set>
class Value;
// RAV - Used to print values in a form used by the register allocator.
//
struct RAV { // Register Allocator Value
const Value *V;
RAV(const Value *v) : V(v) {}
};
ostream &operator<<(ostream &out, RAV Val);
//------------------- Class Definition for ValueSet -------------------------- //------------------- Class Definition for ValueSet --------------------------
void printValue( const Value *v); // func to print a Value
struct ValueSet : public std::set<const Value*> { struct ValueSet : public std::set<const Value*> {
bool setUnion( const ValueSet *const set1); // for performing set union bool setUnion( const ValueSet *const set1); // for performing set union
void setSubtract( const ValueSet *const set1); // for performing set diff void setSubtract( const ValueSet *const set1); // for performing set diff

18
lib/Analysis/LiveVar/BBLiveVar.cpp
View File

@ -70,13 +70,9 @@ void BBLiveVar::calcDefUseSets() {
PhiArgMap[ArgVal] = cast<BasicBlock>(BBVal); PhiArgMap[ArgVal] = cast<BasicBlock>(BBVal);
if (DEBUG_LV > 1) { if (DEBUG_LV > 1)
cerr << " - phi operand "; cerr << " - phi operand " << RAV(ArgVal) << " came from BB "
printValue(ArgVal); << RAV(PhiArgMap[ArgVal]) << "\n";
cerr << " came from BB ";
printValue(PhiArgMap[ArgVal]);
cerr << "\n";
}
} // if( IsPhi ) } // if( IsPhi )
} // if a use } // if a use
} // for all operands } // for all operands
@ -105,9 +101,7 @@ void BBLiveVar::addDef(const Value *Op) {
InSet.erase(Op); // this definition kills any uses InSet.erase(Op); // this definition kills any uses
InSetChanged = true; InSetChanged = true;
if (DEBUG_LV > 1) { if (DEBUG_LV > 1) cerr << " +Def: " << RAV(Op) << "\n";
cerr << " +Def: "; printValue( Op ); cerr << "\n";
}
} }
@ -119,9 +113,7 @@ void BBLiveVar::addUse(const Value *Op) {
OutSet.erase(Op); // remove if there is a def below this use OutSet.erase(Op); // remove if there is a def below this use
InSetChanged = true; InSetChanged = true;
if (DEBUG_LV > 1) { if (DEBUG_LV > 1) cerr << " Use: " << RAV(Op) << "\n";
cerr << " Use: "; printValue( Op ); cerr << "\n";
}
} }

2
lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp
View File

@ -62,7 +62,7 @@ void MethodLiveVarInfo::constructBBs(const Method *M) {
BBI != BBE; ++BBI, ++POId) { BBI != BBE; ++BBI, ++POId) {
const BasicBlock *BB = *BBI; // get the current BB const BasicBlock *BB = *BBI; // get the current BB
if (DEBUG_LV) { std::cerr << " For BB "; printValue(BB); cerr << ":\n"; } if (DEBUG_LV) std::cerr << " For BB " << RAV(BB) << ":\n";
// create a new BBLiveVar // create a new BBLiveVar
BBLiveVar *LVBB = new BBLiveVar(BB, POId); BBLiveVar *LVBB = new BBLiveVar(BB, POId);

68
lib/Analysis/LiveVar/ValueSet.cpp
View File

@ -1,64 +1,42 @@
#include "llvm/Analysis/LiveVar/ValueSet.h" #include "llvm/Analysis/LiveVar/ValueSet.h"
#include "llvm/ConstantVals.h" #include "llvm/ConstantVals.h"
#include <algorithm>
#include <iostream> #include <iostream>
using std::cerr;
using std::endl;
using std::pair;
using std::hash_set;
void printValue(const Value *v) { // func to print a Value ostream &operator<<(ostream &O, RAV V) { // func to print a Value
const Value *v = V.V;
if (v->hasName()) if (v->hasName())
cerr << v << "(" << v->getName() << ") "; return O << v << "(" << v->getName() << ") ";
else if (Constant *C = dyn_cast<Constant>(v)) else if (Constant *C = dyn_cast<Constant>(v))
cerr << v << "(" << C->getStrValue() << ") "; return O << v << "(" << C->getStrValue() << ") ";
else else
cerr << v << " "; return O << v << " ";
} }
bool ValueSet::setUnion( const ValueSet *S) {
bool Changed = false;
//---------------- Method implementations -------------------------- for (const_iterator SI = S->begin(), SE = S->end(); SI != SE; ++SI)
// for performing two set unions if (insert(*SI).second)
bool ValueSet::setUnion( const ValueSet *set1) { Changed = true;
pair<iterator, bool> result;
bool changed = false;
for(const_iterator set1it = set1->begin() ; set1it != set1->end(); ++set1it) { return Changed;
// for all all elements in set1
result = insert(*set1it); // insert to this set
if(result.second == true) changed = true;
}
return changed;
} }
void ValueSet::setDifference(const ValueSet *S1, const ValueSet *S2) {
// for performing set difference for (const_iterator SI = S1->begin(), SE = S1->end() ; SI != SE; ++SI)
void ValueSet::setDifference( const ValueSet *const set1, if (S2->find(*SI) == S2->end()) // if the element is not in set2
const ValueSet *const set2) { insert(*SI);
const_iterator set1it, set2it;
for( set1it = set1->begin() ; set1it != set1->end(); ++set1it) {
// for all elements in set1
iterator set2it = set2->find( *set1it ); // find wether the elem is in set2
if( set2it == set2->end() ) // if the element is not in set2
insert( *set1it ); // insert to this set
}
} }
void ValueSet::setSubtract(const ValueSet *S) {
// for performing set subtraction for (const_iterator SI = S->begin() ; SI != S->end(); ++SI)
void ValueSet::setSubtract( const ValueSet *const set1) { erase(*SI);
const_iterator set1it;
for( set1it = set1->begin() ; set1it != set1->end(); ++set1it)
// for all elements in set1
erase( *set1it ); // erase that element from this set
} }
void ValueSet::printSet() const {
for (const_iterator I = begin(), E = end(); I != E; ++I)
std::cerr << RAV(*I);
void ValueSet::printSet() const { // for printing a live variable set
for_each(begin(), end(), printValue);
} }

151
lib/CodeGen/RegAlloc/LiveRange.h
View File

@ -1,12 +1,12 @@
/* Title: LiveRange.h -*- C++ -*- //===-- LiveRange.h - Store info about a live range --------------*- C++ -*--=//
Author: Ruchira Sasanka //
Date: July 25, 01 // Implements a live range using a ValueSet. A LiveRange is a simple set
Purpose: To keep info about a live range. // of Values.
Asuumptions: //
// Since the Value pointed by a use is the same as of its def, it is sufficient
Since the Value pointed by a use is the same as of its def, it is sufficient // to keep only defs in a LiveRange.
to keep only defs in a LiveRange. //
*/ //===----------------------------------------------------------------------===//
#ifndef LIVE_RANGE_H #ifndef LIVE_RANGE_H
#define LIVE_RANGE_H #define LIVE_RANGE_H
@ -18,105 +18,82 @@
class RegClass; class RegClass;
class IGNode; class IGNode;
//----------------------------------------------------------------------------
// Class LiveRange
//
// Implements a live range using a ValueSet. A LiveRange is a simple set
// of Values.
//----------------------------------------------------------------------------
class LiveRange : public ValueSet { class LiveRange : public ValueSet {
RegClass *MyRegClass; // register classs (e.g., int, FP) for this LR RegClass *MyRegClass; // register classs (e.g., int, FP) for this LR
bool doesSpanAcrossCalls; // doesSpanAcrossCalls - Does this live range span across calls?
//
// Does this live range span across calls?
// This information is used by graph // This information is used by graph
// coloring algo to avoid allocating volatile colors to live ranges // coloring algo to avoid allocating volatile colors to live ranges
// that span across calls (since they have to be saved/restored) // that span across calls (since they have to be saved/restored)
//
bool doesSpanAcrossCalls;
IGNode *UserIGNode; // IGNode which uses this LR IGNode *UserIGNode; // IGNode which uses this LR
int Color; // color assigned to this live range int Color; // color assigned to this live range
bool mustSpill; // whether this LR must be spilt bool mustSpill; // whether this LR must be spilt
// mustSaveAcrossCalls - whether this LR must be saved accross calls
// ***TODO REMOVE this
//
bool mustSaveAcrossCalls; 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 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; bool 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)
// SpilledStackOffsetFromFP - If this LR is spilled, its stack
// offset from *FP*. The spilled offsets must always be relative to
// the FP.
//
int SpilledStackOffsetFromFP; 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; bool HasSpillOffset;
//
// Whether this live range has a spill offset
unsigned SpillCost;
//
// The spill cost of this live range. Calculated using loop depth of // The spill cost of this live range. Calculated using loop depth of
// each reference to each Value in the live range // each reference to each Value in the live range
public:
// constructor
// //
LiveRange() : ValueSet() { unsigned SpillCost;
public:
LiveRange() {
Color = SuggestedColor = -1; // not yet colored Color = SuggestedColor = -1; // not yet colored
mustSpill = mustSaveAcrossCalls = false; mustSpill = mustSaveAcrossCalls = false;
MyRegClass = NULL; MyRegClass = 0;
UserIGNode = NULL; UserIGNode = 0;
doesSpanAcrossCalls = false; doesSpanAcrossCalls = false;
CanUseSuggestedCol = true; CanUseSuggestedCol = true;
HasSpillOffset = false; HasSpillOffset = false;
SpillCost = 0; SpillCost = 0;
} }
// empty destructor since there are nothing to be deleted void setRegClass(RegClass *RC) { MyRegClass = RC; }
//
~LiveRange() {}
RegClass *getRegClass() const { assert(MyRegClass); return MyRegClass; }
void setRegClass(RegClass *const RC) bool hasColor() const { return Color != -1; }
{ MyRegClass = RC; }
inline RegClass *const getRegClass() const unsigned getColor() const { assert(Color != -1); return (unsigned)Color; }
{ 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 ; }
void setColor(unsigned Col) { Color = (int)Col; }
inline void setCallInterference() { inline void setCallInterference() {
doesSpanAcrossCalls = 1; doesSpanAcrossCalls = 1;
} }
inline bool isCallInterference() const { inline bool isCallInterference() const {
return (doesSpanAcrossCalls == 1); return doesSpanAcrossCalls == 1;
} }
inline void markForSpill() { mustSpill = true; } inline void markForSpill() { mustSpill = true; }
@ -124,43 +101,37 @@ class LiveRange : public ValueSet {
inline bool isMarkedForSpill() { return mustSpill; } inline bool isMarkedForSpill() { return mustSpill; }
inline void setSpillOffFromFP(int StackOffset) { inline void setSpillOffFromFP(int StackOffset) {
assert( mustSpill && "This LR is not spilled"); assert(mustSpill && "This LR is not spilled");
SpilledStackOffsetFromFP = StackOffset; SpilledStackOffsetFromFP = StackOffset;
HasSpillOffset = true; HasSpillOffset = true;
} }
inline void modifySpillOffFromFP(int StackOffset) { inline void modifySpillOffFromFP(int StackOffset) {
assert( mustSpill && "This LR is not spilled"); assert(mustSpill && "This LR is not spilled");
SpilledStackOffsetFromFP = StackOffset; SpilledStackOffsetFromFP = StackOffset;
HasSpillOffset = true; HasSpillOffset = true;
} }
inline bool hasSpillOffset() const { inline bool hasSpillOffset() const {
return HasSpillOffset; return HasSpillOffset;
} }
inline int getSpillOffFromFP() const { inline int getSpillOffFromFP() const {
assert( HasSpillOffset && "This LR is not spilled"); assert(HasSpillOffset && "This LR is not spilled");
return SpilledStackOffsetFromFP; return SpilledStackOffsetFromFP;
} }
inline void markForSaveAcrossCalls() { mustSaveAcrossCalls = true; } inline void markForSaveAcrossCalls() { mustSaveAcrossCalls = true; }
inline void setUserIGNode(IGNode *IGN) {
assert(!UserIGNode); UserIGNode = IGN;
}
inline void setUserIGNode( IGNode *const IGN) // getUserIGNode - NULL if the user is not allocated
{ assert( !UserIGNode); UserIGNode = IGN; } inline IGNode *getUserIGNode() const { return UserIGNode; }
inline IGNode * getUserIGNode() const inline const Type *getType() const {
{ return UserIGNode; } // NULL if the user is not allocated return (*begin())->getType(); // set's don't have a front
inline const Type* getType() const {
const Value *val = *begin();
assert(val && "Can't find type - Live range is empty" );
return val->getType();
} }
inline Type::PrimitiveID getTypeID() const { inline Type::PrimitiveID getTypeID() const {
@ -168,9 +139,7 @@ class LiveRange : public ValueSet {
} }
inline void setSuggestedColor(int Col) { inline void setSuggestedColor(int Col) {
//assert( (SuggestedColor == -1) && "Changing an already suggested color"); if (SuggestedColor == -1)
if(SuggestedColor == -1 )
SuggestedColor = Col; SuggestedColor = Col;
#if 0 #if 0
else if (DEBUG_RA) else if (DEBUG_RA)
@ -179,21 +148,21 @@ class LiveRange : public ValueSet {
} }
inline unsigned getSuggestedColor() const { inline unsigned getSuggestedColor() const {
assert( SuggestedColor != -1); // only a valid color is obtained assert(SuggestedColor != -1); // only a valid color is obtained
return (unsigned) SuggestedColor; return (unsigned)SuggestedColor;
} }
inline bool hasSuggestedColor() const { inline bool hasSuggestedColor() const {
return ( SuggestedColor > -1); return SuggestedColor != -1;
} }
inline bool isSuggestedColorUsable() const { inline bool isSuggestedColorUsable() const {
assert( hasSuggestedColor() && "No suggested color"); assert(hasSuggestedColor() && "No suggested color");
return CanUseSuggestedCol; return CanUseSuggestedCol;
} }
inline void setSuggestedColorUsable(const bool val) { inline void setSuggestedColorUsable(bool val) {
assert( hasSuggestedColor() && "No suggested color"); assert(hasSuggestedColor() && "No suggested color");
CanUseSuggestedCol = val; CanUseSuggestedCol = val;
} }

61
lib/CodeGen/RegAlloc/LiveRangeInfo.cpp
View File

@ -118,8 +118,8 @@ void LiveRangeInfo::constructLiveRanges()
if( DEBUG_RA > 1) { if( DEBUG_RA > 1) {
cerr << " adding LiveRange for argument "; cerr << " adding LiveRange for argument "
printValue((const Value *) *ArgIt); cerr << "\n"; << RAV((const Value *)*ArgIt) << "\n";
} }
} }
@ -163,11 +163,9 @@ void LiveRangeInfo::constructLiveRanges()
MachineOperand::MachineOperandType OpTyp = MachineOperand::MachineOperandType OpTyp =
OpI.getMachineOperand().getOperandType(); OpI.getMachineOperand().getOperandType();
if (OpTyp == MachineOperand::MO_CCRegister) { if (OpTyp == MachineOperand::MO_CCRegister)
cerr << "\n**CC reg found. Is Def=" << OpI.isDef() << " Val:"; cerr << "\n**CC reg found. Is Def=" << OpI.isDef() << " Val:"
printValue( OpI.getMachineOperand().getVRegValue() ); << RAV(OpI.getMachineOperand().getVRegValue()) << "\n";
cerr << "\n";
}
} }
// create a new LR iff this operand is a def // create a new LR iff this operand is a def
@ -175,9 +173,9 @@ void LiveRangeInfo::constructLiveRanges()
const Value *Def = *OpI; const Value *Def = *OpI;
// Only instruction values are accepted for live ranges here // Only instruction values are accepted for live ranges here
if( Def->getValueType() != Value::InstructionVal ) { if (Def->getValueType() != Value::InstructionVal ) {
cerr << "\n**%%Error: Def is not an instruction val. Def="; cerr << "\n**%%Error: Def is not an instruction val. Def="
printValue( Def ); cerr << "\n"; << RAV(Def) << "\n";
continue; continue;
} }
@ -189,10 +187,8 @@ void LiveRangeInfo::constructLiveRanges()
DefRange->insert(Def); // add the instruction (def) to it DefRange->insert(Def); // add the instruction (def) to it
LiveRangeMap[ Def ] = DefRange; // update the map LiveRangeMap[ Def ] = DefRange; // update the map
if (DEBUG_RA > 1) { if (DEBUG_RA > 1)
cerr << " creating a LR for def: "; cerr << " creating a LR for def: " << RAV(Def) << "\n";
printValue(Def); cerr << "\n";
}
// set the register class of the new live range // set the register class of the new live range
//assert( RegClassList.size() ); //assert( RegClassList.size() );
@ -204,24 +200,20 @@ void LiveRangeInfo::constructLiveRanges()
OpI.getMachineOperand().getVRegValue(), isCC ); OpI.getMachineOperand().getVRegValue(), isCC );
if(isCC && DEBUG_RA) { if (isCC && DEBUG_RA)
cerr << "\a**created a LR for a CC reg:"; cerr << "\a**created a LR for a CC reg:"
printValue( OpI.getMachineOperand().getVRegValue() ); << RAV(OpI.getMachineOperand().getVRegValue());
}
DefRange->setRegClass( RegClassList[ rcid ] ); DefRange->setRegClass(RegClassList[rcid]);
} else {
}
else {
DefRange->insert(Def); // add the opearand to def range DefRange->insert(Def); // add the opearand to def range
// update the map - Operand points // update the map - Operand points
// to the merged set // to the merged set
LiveRangeMap[ Def ] = DefRange; LiveRangeMap[Def] = DefRange;
if( DEBUG_RA > 1) { if (DEBUG_RA > 1)
cerr << " added to an existing LR for def: "; cerr << " added to an existing LR for def: "
printValue( Def ); cerr << "\n"; << RAV(Def) << "\n";
}
} }
} // if isDef() } // if isDef()
@ -336,10 +328,8 @@ void LiveRangeInfo::coalesceLRs()
if( ! LROfUse ) { // if LR of use is not found if( ! LROfUse ) { // if LR of use is not found
//don't warn about labels //don't warn about labels
if (!((*UseI)->getType())->isLabelType() && DEBUG_RA) { if (!((*UseI)->getType())->isLabelType() && DEBUG_RA)
cerr<<" !! Warning: No LR for use "; printValue(*UseI); cerr << " !! Warning: No LR for use " << RAV(*UseI) << "\n";
cerr << "\n";
}
continue; // ignore and continue continue; // ignore and continue
} }
@ -398,13 +388,12 @@ void LiveRangeInfo::coalesceLRs()
/*--------------------------- Debug code for printing ---------------*/ /*--------------------------- Debug code for printing ---------------*/
void LiveRangeInfo::printLiveRanges() void LiveRangeInfo::printLiveRanges() {
{
LiveRangeMapType::iterator HMI = LiveRangeMap.begin(); // hash map iterator LiveRangeMapType::iterator HMI = LiveRangeMap.begin(); // hash map iterator
cerr << "\nPrinting Live Ranges from Hash Map:\n"; cerr << "\nPrinting Live Ranges from Hash Map:\n";
for( ; HMI != LiveRangeMap.end() ; ++HMI) { for( ; HMI != LiveRangeMap.end(); ++HMI) {
if( HMI->first && HMI->second ) { if (HMI->first && HMI->second) {
cerr <<" "; printValue((*HMI).first); cerr << "\t: "; cerr << " " << RAV(HMI->first) << "\t: ";
HMI->second->printSet(); cerr << "\n"; HMI->second->printSet(); cerr << "\n";
} }
} }

36
lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
View File

@ -118,8 +118,8 @@ void PhyRegAlloc::createIGNodeListsAndIGs() {
LiveRange *L = HMI->second; // get the LiveRange LiveRange *L = HMI->second; // get the LiveRange
if (!L) { if (!L) {
if( DEBUG_RA) { if( DEBUG_RA) {
cerr << "\n*?!?Warning: Null liver range found for: "; cerr << "\n*?!?Warning: Null liver range found for: "
printValue(HMI->first); cerr << "\n"; << RAV(HMI->first) << "\n";
} }
continue; continue;
} }
@ -170,14 +170,12 @@ void PhyRegAlloc::addInterference(const Value *const Def,
// //
for( ; LIt != LVSet->end(); ++LIt) { for( ; LIt != LVSet->end(); ++LIt) {
if( DEBUG_RA > 1) { if (DEBUG_RA > 1)
cerr << "< Def="; printValue(Def); cerr << "< Def=" << RAV(Def) << ", Lvar=" << RAV(*LIt) << "> ";
cerr << ", Lvar="; printValue( *LIt); cerr << "> ";
}
// get the live range corresponding to live var // 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 // LROfVar can be null if it is a const since a const
// doesn't have a dominating def - see Assumptions above // doesn't have a dominating def - see Assumptions above
@ -188,13 +186,12 @@ void PhyRegAlloc::addInterference(const Value *const Def,
// if 2 reg classes are the same set interference // if 2 reg classes are the same set interference
// //
if(RCOfDef == LROfVar->getRegClass()) { if (RCOfDef == LROfVar->getRegClass()) {
RCOfDef->setInterference( LROfDef, LROfVar); 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 // we will not have LRs for values not explicitly allocated in the
// instruction stream (e.g., constants) // instruction stream (e.g., constants)
cerr << " warning: no live range for " ; cerr << " warning: no live range for " << RAV(*LIt) << "\n";
printValue(*LIt); cerr << "\n";
} }
} }
} }
@ -434,10 +431,9 @@ void PhyRegAlloc::addInterferencesForArgs()
for( ; ArgIt != ArgList.end() ; ++ArgIt) { // for each argument for( ; ArgIt != ArgList.end() ; ++ArgIt) { // for each argument
addInterference((Value*)*ArgIt, InSet, false); // add interferences between addInterference((Value*)*ArgIt, InSet, false); // add interferences between
// args and LVars at start // args and LVars at start
if( DEBUG_RA > 1) { if( DEBUG_RA > 1)
cerr << " - %% adding interference for argument "; cerr << " - %% adding interference for argument "
printValue((const Value *)*ArgIt); cerr << "\n"; << RAV((const Value *)*ArgIt) << "\n";
}
} }
} }
@ -1051,15 +1047,11 @@ void PhyRegAlloc::printMachineCode()
unsigned NumOfImpRefs = MInst->getNumImplicitRefs(); unsigned NumOfImpRefs = MInst->getNumImplicitRefs();
if( NumOfImpRefs > 0 ) { if( NumOfImpRefs > 0) {
cerr << "\tImplicit:"; cerr << "\tImplicit:";
for(unsigned z=0; z < NumOfImpRefs; z++) { for(unsigned z=0; z < NumOfImpRefs; z++)
printValue( MInst->getImplicitRef(z) ); cerr << RAV(MInst->getImplicitRef(z)) << "\t";
cerr << "\t";
}
} }
} // for all machine instructions } // for all machine instructions

18
lib/Target/SparcV9/LiveVar/BBLiveVar.cpp
View File

@ -70,13 +70,9 @@ void BBLiveVar::calcDefUseSets() {
PhiArgMap[ArgVal] = cast<BasicBlock>(BBVal); PhiArgMap[ArgVal] = cast<BasicBlock>(BBVal);
if (DEBUG_LV > 1) { if (DEBUG_LV > 1)
cerr << " - phi operand "; cerr << " - phi operand " << RAV(ArgVal) << " came from BB "
printValue(ArgVal); << RAV(PhiArgMap[ArgVal]) << "\n";
cerr << " came from BB ";
printValue(PhiArgMap[ArgVal]);
cerr << "\n";
}
} // if( IsPhi ) } // if( IsPhi )
} // if a use } // if a use
} // for all operands } // for all operands
@ -105,9 +101,7 @@ void BBLiveVar::addDef(const Value *Op) {
InSet.erase(Op); // this definition kills any uses InSet.erase(Op); // this definition kills any uses
InSetChanged = true; InSetChanged = true;
if (DEBUG_LV > 1) { if (DEBUG_LV > 1) cerr << " +Def: " << RAV(Op) << "\n";
cerr << " +Def: "; printValue( Op ); cerr << "\n";
}
} }
@ -119,9 +113,7 @@ void BBLiveVar::addUse(const Value *Op) {
OutSet.erase(Op); // remove if there is a def below this use OutSet.erase(Op); // remove if there is a def below this use
InSetChanged = true; InSetChanged = true;
if (DEBUG_LV > 1) { if (DEBUG_LV > 1) cerr << " Use: " << RAV(Op) << "\n";
cerr << " Use: "; printValue( Op ); cerr << "\n";
}
} }

2
lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp
View File

@ -62,7 +62,7 @@ void MethodLiveVarInfo::constructBBs(const Method *M) {
BBI != BBE; ++BBI, ++POId) { BBI != BBE; ++BBI, ++POId) {
const BasicBlock *BB = *BBI; // get the current BB const BasicBlock *BB = *BBI; // get the current BB
if (DEBUG_LV) { std::cerr << " For BB "; printValue(BB); cerr << ":\n"; } if (DEBUG_LV) std::cerr << " For BB " << RAV(BB) << ":\n";
// create a new BBLiveVar // create a new BBLiveVar
BBLiveVar *LVBB = new BBLiveVar(BB, POId); BBLiveVar *LVBB = new BBLiveVar(BB, POId);

68
lib/Target/SparcV9/LiveVar/ValueSet.cpp
View File

@ -1,64 +1,42 @@
#include "llvm/Analysis/LiveVar/ValueSet.h" #include "llvm/Analysis/LiveVar/ValueSet.h"
#include "llvm/ConstantVals.h" #include "llvm/ConstantVals.h"
#include <algorithm>
#include <iostream> #include <iostream>
using std::cerr;
using std::endl;
using std::pair;
using std::hash_set;
void printValue(const Value *v) { // func to print a Value ostream &operator<<(ostream &O, RAV V) { // func to print a Value
const Value *v = V.V;
if (v->hasName()) if (v->hasName())
cerr << v << "(" << v->getName() << ") "; return O << v << "(" << v->getName() << ") ";
else if (Constant *C = dyn_cast<Constant>(v)) else if (Constant *C = dyn_cast<Constant>(v))
cerr << v << "(" << C->getStrValue() << ") "; return O << v << "(" << C->getStrValue() << ") ";
else else
cerr << v << " "; return O << v << " ";
} }
bool ValueSet::setUnion( const ValueSet *S) {
bool Changed = false;
//---------------- Method implementations -------------------------- for (const_iterator SI = S->begin(), SE = S->end(); SI != SE; ++SI)
// for performing two set unions if (insert(*SI).second)
bool ValueSet::setUnion( const ValueSet *set1) { Changed = true;
pair<iterator, bool> result;
bool changed = false;
for(const_iterator set1it = set1->begin() ; set1it != set1->end(); ++set1it) { return Changed;
// for all all elements in set1
result = insert(*set1it); // insert to this set
if(result.second == true) changed = true;
}
return changed;
} }
void ValueSet::setDifference(const ValueSet *S1, const ValueSet *S2) {
// for performing set difference for (const_iterator SI = S1->begin(), SE = S1->end() ; SI != SE; ++SI)
void ValueSet::setDifference( const ValueSet *const set1, if (S2->find(*SI) == S2->end()) // if the element is not in set2
const ValueSet *const set2) { insert(*SI);
const_iterator set1it, set2it;
for( set1it = set1->begin() ; set1it != set1->end(); ++set1it) {
// for all elements in set1
iterator set2it = set2->find( *set1it ); // find wether the elem is in set2
if( set2it == set2->end() ) // if the element is not in set2
insert( *set1it ); // insert to this set
}
} }
void ValueSet::setSubtract(const ValueSet *S) {
// for performing set subtraction for (const_iterator SI = S->begin() ; SI != S->end(); ++SI)
void ValueSet::setSubtract( const ValueSet *const set1) { erase(*SI);
const_iterator set1it;
for( set1it = set1->begin() ; set1it != set1->end(); ++set1it)
// for all elements in set1
erase( *set1it ); // erase that element from this set
} }
void ValueSet::printSet() const {
for (const_iterator I = begin(), E = end(); I != E; ++I)
std::cerr << RAV(*I);
void ValueSet::printSet() const { // for printing a live variable set
for_each(begin(), end(), printValue);
} }

151
lib/Target/SparcV9/RegAlloc/LiveRange.h
View File

@ -1,12 +1,12 @@
/* Title: LiveRange.h -*- C++ -*- //===-- LiveRange.h - Store info about a live range --------------*- C++ -*--=//
Author: Ruchira Sasanka //
Date: July 25, 01 // Implements a live range using a ValueSet. A LiveRange is a simple set
Purpose: To keep info about a live range. // of Values.
Asuumptions: //
// Since the Value pointed by a use is the same as of its def, it is sufficient
Since the Value pointed by a use is the same as of its def, it is sufficient // to keep only defs in a LiveRange.
to keep only defs in a LiveRange. //
*/ //===----------------------------------------------------------------------===//
#ifndef LIVE_RANGE_H #ifndef LIVE_RANGE_H
#define LIVE_RANGE_H #define LIVE_RANGE_H
@ -18,105 +18,82 @@
class RegClass; class RegClass;
class IGNode; class IGNode;
//----------------------------------------------------------------------------
// Class LiveRange
//
// Implements a live range using a ValueSet. A LiveRange is a simple set
// of Values.
//----------------------------------------------------------------------------
class LiveRange : public ValueSet { class LiveRange : public ValueSet {
RegClass *MyRegClass; // register classs (e.g., int, FP) for this LR RegClass *MyRegClass; // register classs (e.g., int, FP) for this LR
bool doesSpanAcrossCalls; // doesSpanAcrossCalls - Does this live range span across calls?
//
// Does this live range span across calls?
// This information is used by graph // This information is used by graph
// coloring algo to avoid allocating volatile colors to live ranges // coloring algo to avoid allocating volatile colors to live ranges
// that span across calls (since they have to be saved/restored) // that span across calls (since they have to be saved/restored)
//
bool doesSpanAcrossCalls;
IGNode *UserIGNode; // IGNode which uses this LR IGNode *UserIGNode; // IGNode which uses this LR
int Color; // color assigned to this live range int Color; // color assigned to this live range
bool mustSpill; // whether this LR must be spilt bool mustSpill; // whether this LR must be spilt
// mustSaveAcrossCalls - whether this LR must be saved accross calls
// ***TODO REMOVE this
//
bool mustSaveAcrossCalls; 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 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; bool 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)
// SpilledStackOffsetFromFP - If this LR is spilled, its stack
// offset from *FP*. The spilled offsets must always be relative to
// the FP.
//
int SpilledStackOffsetFromFP; 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; bool HasSpillOffset;
//
// Whether this live range has a spill offset
unsigned SpillCost;
//
// The spill cost of this live range. Calculated using loop depth of // The spill cost of this live range. Calculated using loop depth of
// each reference to each Value in the live range // each reference to each Value in the live range
public:
// constructor
// //
LiveRange() : ValueSet() { unsigned SpillCost;
public:
LiveRange() {
Color = SuggestedColor = -1; // not yet colored Color = SuggestedColor = -1; // not yet colored
mustSpill = mustSaveAcrossCalls = false; mustSpill = mustSaveAcrossCalls = false;
MyRegClass = NULL; MyRegClass = 0;
UserIGNode = NULL; UserIGNode = 0;
doesSpanAcrossCalls = false; doesSpanAcrossCalls = false;
CanUseSuggestedCol = true; CanUseSuggestedCol = true;
HasSpillOffset = false; HasSpillOffset = false;
SpillCost = 0; SpillCost = 0;
} }
// empty destructor since there are nothing to be deleted void setRegClass(RegClass *RC) { MyRegClass = RC; }
//
~LiveRange() {}
RegClass *getRegClass() const { assert(MyRegClass); return MyRegClass; }
void setRegClass(RegClass *const RC) bool hasColor() const { return Color != -1; }
{ MyRegClass = RC; }
inline RegClass *const getRegClass() const unsigned getColor() const { assert(Color != -1); return (unsigned)Color; }
{ 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 ; }
void setColor(unsigned Col) { Color = (int)Col; }
inline void setCallInterference() { inline void setCallInterference() {
doesSpanAcrossCalls = 1; doesSpanAcrossCalls = 1;
} }
inline bool isCallInterference() const { inline bool isCallInterference() const {
return (doesSpanAcrossCalls == 1); return doesSpanAcrossCalls == 1;
} }
inline void markForSpill() { mustSpill = true; } inline void markForSpill() { mustSpill = true; }
@ -124,43 +101,37 @@ class LiveRange : public ValueSet {
inline bool isMarkedForSpill() { return mustSpill; } inline bool isMarkedForSpill() { return mustSpill; }
inline void setSpillOffFromFP(int StackOffset) { inline void setSpillOffFromFP(int StackOffset) {
assert( mustSpill && "This LR is not spilled"); assert(mustSpill && "This LR is not spilled");
SpilledStackOffsetFromFP = StackOffset; SpilledStackOffsetFromFP = StackOffset;
HasSpillOffset = true; HasSpillOffset = true;
} }
inline void modifySpillOffFromFP(int StackOffset) { inline void modifySpillOffFromFP(int StackOffset) {
assert( mustSpill && "This LR is not spilled"); assert(mustSpill && "This LR is not spilled");
SpilledStackOffsetFromFP = StackOffset; SpilledStackOffsetFromFP = StackOffset;
HasSpillOffset = true; HasSpillOffset = true;
} }
inline bool hasSpillOffset() const { inline bool hasSpillOffset() const {
return HasSpillOffset; return HasSpillOffset;
} }
inline int getSpillOffFromFP() const { inline int getSpillOffFromFP() const {
assert( HasSpillOffset && "This LR is not spilled"); assert(HasSpillOffset && "This LR is not spilled");
return SpilledStackOffsetFromFP; return SpilledStackOffsetFromFP;
} }
inline void markForSaveAcrossCalls() { mustSaveAcrossCalls = true; } inline void markForSaveAcrossCalls() { mustSaveAcrossCalls = true; }
inline void setUserIGNode(IGNode *IGN) {
assert(!UserIGNode); UserIGNode = IGN;
}
inline void setUserIGNode( IGNode *const IGN) // getUserIGNode - NULL if the user is not allocated
{ assert( !UserIGNode); UserIGNode = IGN; } inline IGNode *getUserIGNode() const { return UserIGNode; }
inline IGNode * getUserIGNode() const inline const Type *getType() const {
{ return UserIGNode; } // NULL if the user is not allocated return (*begin())->getType(); // set's don't have a front
inline const Type* getType() const {
const Value *val = *begin();
assert(val && "Can't find type - Live range is empty" );
return val->getType();
} }
inline Type::PrimitiveID getTypeID() const { inline Type::PrimitiveID getTypeID() const {
@ -168,9 +139,7 @@ class LiveRange : public ValueSet {
} }
inline void setSuggestedColor(int Col) { inline void setSuggestedColor(int Col) {
//assert( (SuggestedColor == -1) && "Changing an already suggested color"); if (SuggestedColor == -1)
if(SuggestedColor == -1 )
SuggestedColor = Col; SuggestedColor = Col;
#if 0 #if 0
else if (DEBUG_RA) else if (DEBUG_RA)
@ -179,21 +148,21 @@ class LiveRange : public ValueSet {
} }
inline unsigned getSuggestedColor() const { inline unsigned getSuggestedColor() const {
assert( SuggestedColor != -1); // only a valid color is obtained assert(SuggestedColor != -1); // only a valid color is obtained
return (unsigned) SuggestedColor; return (unsigned)SuggestedColor;
} }
inline bool hasSuggestedColor() const { inline bool hasSuggestedColor() const {
return ( SuggestedColor > -1); return SuggestedColor != -1;
} }
inline bool isSuggestedColorUsable() const { inline bool isSuggestedColorUsable() const {
assert( hasSuggestedColor() && "No suggested color"); assert(hasSuggestedColor() && "No suggested color");
return CanUseSuggestedCol; return CanUseSuggestedCol;
} }
inline void setSuggestedColorUsable(const bool val) { inline void setSuggestedColorUsable(bool val) {
assert( hasSuggestedColor() && "No suggested color"); assert(hasSuggestedColor() && "No suggested color");
CanUseSuggestedCol = val; CanUseSuggestedCol = val;
} }

61
lib/Target/SparcV9/RegAlloc/LiveRangeInfo.cpp
View File

@ -118,8 +118,8 @@ void LiveRangeInfo::constructLiveRanges()
if( DEBUG_RA > 1) { if( DEBUG_RA > 1) {
cerr << " adding LiveRange for argument "; cerr << " adding LiveRange for argument "
printValue((const Value *) *ArgIt); cerr << "\n"; << RAV((const Value *)*ArgIt) << "\n";
} }
} }
@ -163,11 +163,9 @@ void LiveRangeInfo::constructLiveRanges()
MachineOperand::MachineOperandType OpTyp = MachineOperand::MachineOperandType OpTyp =
OpI.getMachineOperand().getOperandType(); OpI.getMachineOperand().getOperandType();
if (OpTyp == MachineOperand::MO_CCRegister) { if (OpTyp == MachineOperand::MO_CCRegister)
cerr << "\n**CC reg found. Is Def=" << OpI.isDef() << " Val:"; cerr << "\n**CC reg found. Is Def=" << OpI.isDef() << " Val:"
printValue( OpI.getMachineOperand().getVRegValue() ); << RAV(OpI.getMachineOperand().getVRegValue()) << "\n";
cerr << "\n";
}
} }
// create a new LR iff this operand is a def // create a new LR iff this operand is a def
@ -175,9 +173,9 @@ void LiveRangeInfo::constructLiveRanges()
const Value *Def = *OpI; const Value *Def = *OpI;
// Only instruction values are accepted for live ranges here // Only instruction values are accepted for live ranges here
if( Def->getValueType() != Value::InstructionVal ) { if (Def->getValueType() != Value::InstructionVal ) {
cerr << "\n**%%Error: Def is not an instruction val. Def="; cerr << "\n**%%Error: Def is not an instruction val. Def="
printValue( Def ); cerr << "\n"; << RAV(Def) << "\n";
continue; continue;
} }
@ -189,10 +187,8 @@ void LiveRangeInfo::constructLiveRanges()
DefRange->insert(Def); // add the instruction (def) to it DefRange->insert(Def); // add the instruction (def) to it
LiveRangeMap[ Def ] = DefRange; // update the map LiveRangeMap[ Def ] = DefRange; // update the map
if (DEBUG_RA > 1) { if (DEBUG_RA > 1)
cerr << " creating a LR for def: "; cerr << " creating a LR for def: " << RAV(Def) << "\n";
printValue(Def); cerr << "\n";
}
// set the register class of the new live range // set the register class of the new live range
//assert( RegClassList.size() ); //assert( RegClassList.size() );
@ -204,24 +200,20 @@ void LiveRangeInfo::constructLiveRanges()
OpI.getMachineOperand().getVRegValue(), isCC ); OpI.getMachineOperand().getVRegValue(), isCC );
if(isCC && DEBUG_RA) { if (isCC && DEBUG_RA)
cerr << "\a**created a LR for a CC reg:"; cerr << "\a**created a LR for a CC reg:"
printValue( OpI.getMachineOperand().getVRegValue() ); << RAV(OpI.getMachineOperand().getVRegValue());
}
DefRange->setRegClass( RegClassList[ rcid ] ); DefRange->setRegClass(RegClassList[rcid]);
} else {
}
else {
DefRange->insert(Def); // add the opearand to def range DefRange->insert(Def); // add the opearand to def range
// update the map - Operand points // update the map - Operand points
// to the merged set // to the merged set
LiveRangeMap[ Def ] = DefRange; LiveRangeMap[Def] = DefRange;
if( DEBUG_RA > 1) { if (DEBUG_RA > 1)
cerr << " added to an existing LR for def: "; cerr << " added to an existing LR for def: "
printValue( Def ); cerr << "\n"; << RAV(Def) << "\n";
}
} }
} // if isDef() } // if isDef()
@ -336,10 +328,8 @@ void LiveRangeInfo::coalesceLRs()
if( ! LROfUse ) { // if LR of use is not found if( ! LROfUse ) { // if LR of use is not found
//don't warn about labels //don't warn about labels
if (!((*UseI)->getType())->isLabelType() && DEBUG_RA) { if (!((*UseI)->getType())->isLabelType() && DEBUG_RA)
cerr<<" !! Warning: No LR for use "; printValue(*UseI); cerr << " !! Warning: No LR for use " << RAV(*UseI) << "\n";
cerr << "\n";
}
continue; // ignore and continue continue; // ignore and continue
} }
@ -398,13 +388,12 @@ void LiveRangeInfo::coalesceLRs()
/*--------------------------- Debug code for printing ---------------*/ /*--------------------------- Debug code for printing ---------------*/
void LiveRangeInfo::printLiveRanges() void LiveRangeInfo::printLiveRanges() {
{
LiveRangeMapType::iterator HMI = LiveRangeMap.begin(); // hash map iterator LiveRangeMapType::iterator HMI = LiveRangeMap.begin(); // hash map iterator
cerr << "\nPrinting Live Ranges from Hash Map:\n"; cerr << "\nPrinting Live Ranges from Hash Map:\n";
for( ; HMI != LiveRangeMap.end() ; ++HMI) { for( ; HMI != LiveRangeMap.end(); ++HMI) {
if( HMI->first && HMI->second ) { if (HMI->first && HMI->second) {
cerr <<" "; printValue((*HMI).first); cerr << "\t: "; cerr << " " << RAV(HMI->first) << "\t: ";
HMI->second->printSet(); cerr << "\n"; HMI->second->printSet(); cerr << "\n";
} }
} }

36
lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp
View File

@ -118,8 +118,8 @@ void PhyRegAlloc::createIGNodeListsAndIGs() {
LiveRange *L = HMI->second; // get the LiveRange LiveRange *L = HMI->second; // get the LiveRange
if (!L) { if (!L) {
if( DEBUG_RA) { if( DEBUG_RA) {
cerr << "\n*?!?Warning: Null liver range found for: "; cerr << "\n*?!?Warning: Null liver range found for: "
printValue(HMI->first); cerr << "\n"; << RAV(HMI->first) << "\n";
} }
continue; continue;
} }
@ -170,14 +170,12 @@ void PhyRegAlloc::addInterference(const Value *const Def,
// //
for( ; LIt != LVSet->end(); ++LIt) { for( ; LIt != LVSet->end(); ++LIt) {
if( DEBUG_RA > 1) { if (DEBUG_RA > 1)
cerr << "< Def="; printValue(Def); cerr << "< Def=" << RAV(Def) << ", Lvar=" << RAV(*LIt) << "> ";
cerr << ", Lvar="; printValue( *LIt); cerr << "> ";
}
// get the live range corresponding to live var // 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 // LROfVar can be null if it is a const since a const
// doesn't have a dominating def - see Assumptions above // doesn't have a dominating def - see Assumptions above
@ -188,13 +186,12 @@ void PhyRegAlloc::addInterference(const Value *const Def,
// if 2 reg classes are the same set interference // if 2 reg classes are the same set interference
// //
if(RCOfDef == LROfVar->getRegClass()) { if (RCOfDef == LROfVar->getRegClass()) {
RCOfDef->setInterference( LROfDef, LROfVar); 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 // we will not have LRs for values not explicitly allocated in the
// instruction stream (e.g., constants) // instruction stream (e.g., constants)
cerr << " warning: no live range for " ; cerr << " warning: no live range for " << RAV(*LIt) << "\n";
printValue(*LIt); cerr << "\n";
} }
} }
} }
@ -434,10 +431,9 @@ void PhyRegAlloc::addInterferencesForArgs()
for( ; ArgIt != ArgList.end() ; ++ArgIt) { // for each argument for( ; ArgIt != ArgList.end() ; ++ArgIt) { // for each argument
addInterference((Value*)*ArgIt, InSet, false); // add interferences between addInterference((Value*)*ArgIt, InSet, false); // add interferences between
// args and LVars at start // args and LVars at start
if( DEBUG_RA > 1) { if( DEBUG_RA > 1)
cerr << " - %% adding interference for argument "; cerr << " - %% adding interference for argument "
printValue((const Value *)*ArgIt); cerr << "\n"; << RAV((const Value *)*ArgIt) << "\n";
}
} }
} }
@ -1051,15 +1047,11 @@ void PhyRegAlloc::printMachineCode()
unsigned NumOfImpRefs = MInst->getNumImplicitRefs(); unsigned NumOfImpRefs = MInst->getNumImplicitRefs();
if( NumOfImpRefs > 0 ) { if( NumOfImpRefs > 0) {
cerr << "\tImplicit:"; cerr << "\tImplicit:";
for(unsigned z=0; z < NumOfImpRefs; z++) { for(unsigned z=0; z < NumOfImpRefs; z++)
printValue( MInst->getImplicitRef(z) ); cerr << RAV(MInst->getImplicitRef(z)) << "\t";
cerr << "\t";
}
} }
} // for all machine instructions } // for all machine instructions

44
lib/Target/SparcV9/SparcV9RegInfo.cpp
View File

@ -563,11 +563,8 @@ void UltraSparcRegInfo::suggestRegs4CallArgs(const MachineInstr *CallMI,
// not possible to have a null LR since all args (even consts) // not possible to have a null LR since all args (even consts)
// must be defined before // must be defined before
if( !LR ) { if (!LR) {
if( DEBUG_RA) { cerr << " ERROR: In call instr, no LR for arg: " << RAV(CallArg) << "\n";
cerr << " ERROR: In call instr, no LR for arg: " ;
printValue(CallArg); cerr << "\n";
}
assert(0 && "NO LR for call arg"); assert(0 && "NO LR for call arg");
} }
@ -624,16 +621,12 @@ void UltraSparcRegInfo::colorCallArgs(const MachineInstr *CallMI,
const Value *RetVal = getCallInstRetVal( CallMI ); const Value *RetVal = getCallInstRetVal( CallMI );
if( RetVal ) { if (RetVal) {
LiveRange *RetValLR = LRI.getLiveRangeForValue( RetVal );
LiveRange * RetValLR = LRI.getLiveRangeForValue( RetVal ); if (!RetValLR) {
cerr << "\nNo LR for:" << RAV(RetVal) << "\n";
if( !RetValLR ) { assert(0 && "ERR:No LR for non-void return value");
cerr << "\nNo LR for:";
printValue( RetVal );
cerr << "\n";
assert( RetValLR && "ERR:No LR for non-void return value");
//return;
} }
unsigned RegClassID = (RetValLR->getRegClass())->getID(); unsigned RegClassID = (RetValLR->getRegClass())->getID();
@ -755,13 +748,9 @@ void UltraSparcRegInfo::colorCallArgs(const MachineInstr *CallMI,
// not possible to have a null LR since all args (even consts) // not possible to have a null LR since all args (even consts)
// must be defined before // must be defined before
if( !LR ) { if (!LR) {
if( DEBUG_RA) { cerr << " ERROR: In call instr, no LR for arg: " << RAV(CallArg) << "\n";
cerr << " ERROR: In call instr, no LR for arg: " ;
printValue(CallArg); cerr << "\n";
}
assert(0 && "NO LR for call arg"); assert(0 && "NO LR for call arg");
// continue;
} }
@ -942,12 +931,9 @@ void UltraSparcRegInfo::suggestReg4RetValue(const MachineInstr *RetMI,
LiveRange *const LR = LRI.getLiveRangeForValue( RetVal ); LiveRange *const LR = LRI.getLiveRangeForValue( RetVal );
if( !LR ) { if (!LR) {
cerr << "\nNo LR for:"; cerr << "\nNo LR for:" << RAV(RetVal) << "\n";
printValue( RetVal ); assert(0 && "No LR for return value of non-void method");
cerr << "\n";
assert( LR && "No LR for return value of non-void method");
//return;
} }
unsigned RegClassID = (LR->getRegClass())->getID(); unsigned RegClassID = (LR->getRegClass())->getID();
@ -981,10 +967,8 @@ void UltraSparcRegInfo::colorRetValue(const MachineInstr *RetMI,
LiveRange *LR = LRI.getLiveRangeForValue(RetVal); LiveRange *LR = LRI.getLiveRangeForValue(RetVal);
if( ! LR ) { if (!LR) {
cerr << "\nNo LR for:"; cerr << "\nNo LR for:" << RAV(RetVal) << "\n";
printValue( RetVal );
cerr << "\n";
// assert( LR && "No LR for return value of non-void method"); // assert( LR && "No LR for return value of non-void method");
return; return;
} }