6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-13 20:32:21 +00:00
Code Issues Projects Releases Wiki Activity

Cleaned up code layout, spacing, etc. for readability purposes and to be more

Browse Source 
consistent with the style of LLVM's code base (and itself! it's inconsistent in
some places.)

No functional changes were made.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@6262 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Misha Brukman 2003-05-21 18:05:35 +00:00
parent ee563cb978
commit 77c9fcb797
1 changed files with 44 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
lib/Target/SparcV9/SparcV9RegClassInfo.cpp
View File

@ -26,33 +26,26 @@ void SparcIntRegClass::colorIGNode(IGNode * Node,
{
LiveRange *LR = Node->getParentLR();
if( DEBUG_RA ) {
if (DEBUG_RA) {
std::cerr << "\nColoring LR [CallInt=" << LR->isCallInterference() <<"]:";
printSet(*LR);
}
if( LR->hasSuggestedColor() ) {
if (LR->hasSuggestedColor()) {
unsigned SugCol = LR->getSuggestedColor();
if (!IsColorUsedArr[SugCol]) {
if( LR->isSuggestedColorUsable() ) {
if (LR->isSuggestedColorUsable()) {
// if the suggested color is volatile, we should use it only if
// there are no call interferences. Otherwise, it will get spilled.
if (DEBUG_RA)
std::cerr << "\n -Coloring with sug color: " << SugCol;
LR->setColor( LR->getSuggestedColor() );
LR->setColor(LR->getSuggestedColor());
return;
}
else if(DEBUG_RA)
} else if(DEBUG_RA) {
std::cerr << "\n Couldn't alloc Sug col - LR voloatile & calls interf";
}
else if (DEBUG_RA) { // can't allocate the suggested col
} else if (DEBUG_RA) { // can't allocate the suggested col
std::cerr << "\n Could NOT allocate the suggested color (already used) ";
printSet(*LR); std::cerr << "\n";
}
@ -62,12 +55,10 @@ void SparcIntRegClass::colorIGNode(IGNode * Node,
bool ColorFound= false; // have we found a color yet?
//if this Node is between calls
if( ! LR->isCallInterference() ) {
if (! LR->isCallInterference()) {
// start with volatiles (we can allocate volatiles safely)
SearchStart = SparcIntRegClass::StartOfAllRegs;
}
else {
} else {
// start with non volatiles (no non-volatiles)
SearchStart = SparcIntRegClass::StartOfNonVolatileRegs;
}
@ -75,11 +66,14 @@ void SparcIntRegClass::colorIGNode(IGNode * Node,
unsigned c=0; // color
// find first unused color
for( c=SearchStart; c < SparcIntRegClass::NumOfAvailRegs; c++) {
if(!IsColorUsedArr[c] ) { ColorFound = true; break; }
for (c=SearchStart; c < SparcIntRegClass::NumOfAvailRegs; c++) {
if (!IsColorUsedArr[c]) {
ColorFound = true;
break;
}
}
if( ColorFound) {
if (ColorFound) {
LR->setColor(c); // first color found in preffered order
if (DEBUG_RA) std::cerr << "\n Colored after first search with col " << c;
}
@ -87,14 +81,16 @@ void SparcIntRegClass::colorIGNode(IGNode * Node,
// if color is not found because of call interference
// try even finding a volatile color and insert save across calls
//
else if( LR->isCallInterference() )
{
else if (LR->isCallInterference()) {
// start from 0 - try to find even a volatile this time
SearchStart = SparcIntRegClass::StartOfAllRegs;
// find first unused volatile color
for(c=SearchStart; c < SparcIntRegClass::StartOfNonVolatileRegs; c++) {
if( ! IsColorUsedArr[ c ] ) { ColorFound = true; break; }
if (! IsColorUsedArr[c]) {
ColorFound = true;
break;
}
}
if (ColorFound) {
@ -117,10 +113,6 @@ void SparcIntRegClass::colorIGNode(IGNode * Node,
}
//-----------------------------------------------------------------------------
// Float Register Class - method for coloring a node in the interference graph.
//
@ -150,7 +142,7 @@ void SparcFloatRegClass::colorIGNode(IGNode * Node,
IGNode *NeighIGNode = Node->getAdjIGNode(n);
LiveRange *NeighLR = NeighIGNode->getParentLR();
if( NeighLR->hasColor() &&
if (NeighLR->hasColor() &&
NeighLR->getType() == Type::DoubleTy) {
IsColorUsedArr[ (NeighLR->getColor()) + 1 ] = true;
@ -191,8 +183,7 @@ void SparcFloatRegClass::colorIGNode(IGNode * Node,
if (LR->getType() == Type::DoubleTy)
ColorFound = findFloatColor( LR, 32, 64, IsColorUsedArr );
if( ColorFound >= 0 ) { // if we could find a color
if (ColorFound >= 0) { // if we could find a color
LR->setColor(ColorFound);
return;
} else {
@ -204,36 +195,30 @@ void SparcFloatRegClass::colorIGNode(IGNode * Node,
unsigned SearchStart; // start pos of color in pref-order
//if this Node is between calls (i.e., no call interferences )
if( ! isCallInterf ) {
if (! isCallInterf) {
// start with volatiles (we can allocate volatiles safely)
SearchStart = SparcFloatRegClass::StartOfAllRegs;
}
else {
} else {
// start with non volatiles (no non-volatiles)
SearchStart = SparcFloatRegClass::StartOfNonVolatileRegs;
}
ColorFound = findFloatColor( LR, SearchStart, 32, IsColorUsedArr );
ColorFound = findFloatColor(LR, SearchStart, 32, IsColorUsedArr);
}
if( ColorFound >= 0 ) { // if we could find a color
if (ColorFound >= 0) { // if we could find a color
LR->setColor(ColorFound);
return;
}
else if( isCallInterf ) {
} else if (isCallInterf) {
// We are here because there is a call interference and no non-volatile
// color could be found.
// Now try to allocate even a volatile color
ColorFound = findFloatColor( LR, SparcFloatRegClass::StartOfAllRegs,
ColorFound = findFloatColor(LR, SparcFloatRegClass::StartOfAllRegs,
SparcFloatRegClass::StartOfNonVolatileRegs,
IsColorUsedArr);
}
if( ColorFound >= 0 ) {
if (ColorFound >= 0) {
LR->setColor(ColorFound); // first color found in prefered order
LR->markForSaveAcrossCalls();
} else {
@ -249,9 +234,9 @@ void SparcFloatRegClass::colorIGNode(IGNode * Node,
// type of the Node (i.e., float/double)
//-----------------------------------------------------------------------------
int SparcFloatRegClass::findFloatColor
(const LiveRange *LR,
unsigned Start, unsigned End,
int SparcFloatRegClass::findFloatColor(const LiveRange *LR,
unsigned Start,
unsigned End,
std::vector<bool> &IsColorUsedArr) const
{
bool ColorFound = false;