X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTarget%2FSparcV9%2FSparcV9RegClassInfo.cpp;h=4d35f5d3e2b4d8fb047520c84e51c15df2df736a;hb=a2bae305fb5a870c4ef753ed290a7ddea73ec82b;hp=709a8f4c7fe5815e65e1737f763a86956e63ac04;hpb=697954c15da58bd8b186dbafdedd8b06db770201;p=oota-llvm.git diff --git a/lib/Target/SparcV9/SparcV9RegClassInfo.cpp b/lib/Target/SparcV9/SparcV9RegClassInfo.cpp index 709a8f4c7fe..4d35f5d3e2b 100644 --- a/lib/Target/SparcV9/SparcV9RegClassInfo.cpp +++ b/lib/Target/SparcV9/SparcV9RegClassInfo.cpp @@ -1,8 +1,15 @@ -#include "SparcInternals.h" -#include "llvm/CodeGen/IGNode.h" +//===-- SparcRegClassInfo.cpp - Register class def'ns for Sparc -----------===// +// +// This file defines the register classes used by the Sparc target description. +// +//===----------------------------------------------------------------------===// + +#include "SparcRegClassInfo.h" +#include "llvm/CodeGen/RegAllocCommon.h" #include "llvm/Target/Sparc.h" -#include +#include "llvm/Type.h" using std::cerr; +using std::vector; //----------------------------------------------------------------------------- // Int Register Class - method for coloring a node in the interference graph. @@ -17,36 +24,19 @@ using std::cerr; // If both above fail, spill. // //----------------------------------------------------------------------------- -void SparcIntRegClass::colorIGNode(IGNode * Node, bool IsColorUsedArr[]) const -{ - LiveRange * LR = Node->getParentLR(); - unsigned NumNeighbors = Node->getNumOfNeighbors(); // total # of neighbors - - for(unsigned n=0; n < NumNeighbors; n++) { // for each neigh - IGNode *NeighIGNode = Node->getAdjIGNode(n); - LiveRange *NeighLR = NeighIGNode->getParentLR(); - - if( NeighLR->hasColor() ) // if has a color - IsColorUsedArr[ NeighLR->getColor() ] = true; // record that color - - else if( NeighLR->hasSuggestedColor() ) { - - // if the neighbout can use the suggested color - if( NeighLR-> isSuggestedColorUsable() ) - IsColorUsedArr[ NeighLR->getSuggestedColor() ] = true; - } - } +void SparcIntRegClass::colorIGNode(IGNode * Node, vector &IsColorUsedArr) const { + LiveRange *LR = Node->getParentLR(); if( DEBUG_RA ) { cerr << "\nColoring LR [CallInt=" << LR->isCallInterference() <<"]:"; - LR->printSet(); + printSet(*LR); } if( LR->hasSuggestedColor() ) { unsigned SugCol = LR->getSuggestedColor(); - if( ! IsColorUsedArr[ SugCol ] ) { + if (!IsColorUsedArr[SugCol]) { if( LR->isSuggestedColorUsable() ) { @@ -65,7 +55,7 @@ void SparcIntRegClass::colorIGNode(IGNode * Node, bool IsColorUsedArr[]) const } else if ( DEBUG_RA ) { // can't allocate the suggested col cerr << " \n Could NOT allocate the suggested color (already used) "; - LR->printSet(); cerr << "\n"; + printSet(*LR); cerr << "\n"; } } @@ -76,18 +66,18 @@ void SparcIntRegClass::colorIGNode(IGNode * Node, bool IsColorUsedArr[]) const if( ! LR->isCallInterference() ) { // start with volatiles (we can allocate volatiles safely) - SearchStart = SparcIntRegOrder::StartOfAllRegs; + SearchStart = SparcIntRegClass::StartOfAllRegs; } else { // start with non volatiles (no non-volatiles) - SearchStart = SparcIntRegOrder::StartOfNonVolatileRegs; + SearchStart = SparcIntRegClass::StartOfNonVolatileRegs; } unsigned c=0; // color // find first unused color - for( c=SearchStart; c < SparcIntRegOrder::NumOfAvailRegs; c++) { - if( ! IsColorUsedArr[ c ] ) { ColorFound = true; break; } + for( c=SearchStart; c < SparcIntRegClass::NumOfAvailRegs; c++) { + if(!IsColorUsedArr[c] ) { ColorFound = true; break; } } if( ColorFound) { @@ -101,14 +91,14 @@ void SparcIntRegClass::colorIGNode(IGNode * Node, bool IsColorUsedArr[]) const else if( LR->isCallInterference() ) { // start from 0 - try to find even a volatile this time - SearchStart = SparcIntRegOrder::StartOfAllRegs; + SearchStart = SparcIntRegClass::StartOfAllRegs; // find first unused volatile color - for(c=SearchStart; c < SparcIntRegOrder::StartOfNonVolatileRegs; c++) { + for(c=SearchStart; c < SparcIntRegClass::StartOfNonVolatileRegs; c++) { if( ! IsColorUsedArr[ c ] ) { ColorFound = true; break; } } - if( ColorFound) { + if (ColorFound) { LR->setColor(c); // get the live range corresponding to live var // since LR span across calls, must save across calls @@ -122,13 +112,8 @@ void SparcIntRegClass::colorIGNode(IGNode * Node, bool IsColorUsedArr[]) const // If we couldn't find a color regardless of call interference - i.e., we // don't have either a volatile or non-volatile color left // - if( !ColorFound ) + if (!ColorFound) LR->markForSpill(); // no color found - must spill - - - if( DEBUG_RA) - UltraSparcRegInfo::printReg( LR ); - } @@ -151,50 +136,45 @@ void SparcIntRegClass::colorIGNode(IGNode * Node, bool IsColorUsedArr[]) const // If a color is still not fond, mark for spilling // //---------------------------------------------------------------------------- -void SparcFloatRegClass::colorIGNode(IGNode * Node,bool IsColorUsedArr[]) const -{ - - LiveRange * LR = Node->getParentLR(); +void SparcFloatRegClass::colorIGNode(IGNode * Node, + vector &IsColorUsedArr) const{ + LiveRange *LR = Node->getParentLR(); + + // Mark the second color for double-precision registers: + // This is UGLY and should be merged into nearly identical code + // in RegClass::colorIGNode that handles the first color. + // unsigned NumNeighbors = Node->getNumOfNeighbors(); // total # of neighbors - for(unsigned n=0; n < NumNeighbors; n++) { // for each neigh IGNode *NeighIGNode = Node->getAdjIGNode(n); LiveRange *NeighLR = NeighIGNode->getParentLR(); + + if( NeighLR->hasColor() && + NeighLR->getType() == Type::DoubleTy) { + IsColorUsedArr[ (NeighLR->getColor()) + 1 ] = true; + + } else if (NeighLR->hasSuggestedColor() && + NeighLR-> isSuggestedColorUsable() ) { - if( NeighLR->hasColor() ) { // if neigh has a color - IsColorUsedArr[ NeighLR->getColor() ] = true; // record that color - if( NeighLR->getTypeID() == Type::DoubleTyID ) - IsColorUsedArr[ (NeighLR->getColor()) + 1 ] = true; - } - else if( NeighLR->hasSuggestedColor() ) { // if neigh has sugg color - - if( NeighLR-> isSuggestedColorUsable() ) { - - // if the neighbout can use the suggested color - + // if the neighbour can use the suggested color IsColorUsedArr[ NeighLR->getSuggestedColor() ] = true; - if( NeighLR->getTypeID() == Type::DoubleTyID ) + if (NeighLR->getType() == Type::DoubleTy) IsColorUsedArr[ (NeighLR->getSuggestedColor()) + 1 ] = true; - } - - } - + } } - // **NOTE: We don't check for call interferences in allocating suggested // color in this class since ALL registers are volatile. If this fact // changes, we should change the following part //- see SparcIntRegClass::colorIGNode() - + // if( LR->hasSuggestedColor() ) { if( ! IsColorUsedArr[ LR->getSuggestedColor() ] ) { LR->setColor( LR->getSuggestedColor() ); return; - } - else if (DEBUG_RA) { // can't allocate the suggested col + } else if (DEBUG_RA) { // can't allocate the suggested col cerr << " Could NOT allocate the suggested color for LR "; - LR->printSet(); cerr << "\n"; + printSet(*LR); cerr << "\n"; } } @@ -202,21 +182,19 @@ void SparcFloatRegClass::colorIGNode(IGNode * Node,bool IsColorUsedArr[]) const int ColorFound = -1; // have we found a color yet? bool isCallInterf = LR->isCallInterference(); - // if value is a double - search the double only reigon (f32 - f63) + // if value is a double - search the double only region (f32 - f63) // i.e. we try to allocate f32 - f63 first for doubles since singles // cannot go there. By doing that, we provide more space for singles // in f0 - f31 // - if( LR->getTypeID() == Type::DoubleTyID ) + if (LR->getType() == Type::DoubleTy) ColorFound = findFloatColor( LR, 32, 64, IsColorUsedArr ); if( ColorFound >= 0 ) { // if we could find a color LR->setColor(ColorFound); - if( DEBUG_RA) UltraSparcRegInfo::printReg( LR ); return; - } - else { + } else { // if we didn't find a color becuase the LR was single precision or // all f32-f63 range is filled, we try to allocate a register from @@ -227,11 +205,11 @@ void SparcFloatRegClass::colorIGNode(IGNode * Node,bool IsColorUsedArr[]) const //if this Node is between calls (i.e., no call interferences ) if( ! isCallInterf ) { // start with volatiles (we can allocate volatiles safely) - SearchStart = SparcFloatRegOrder::StartOfAllRegs; + SearchStart = SparcFloatRegClass::StartOfAllRegs; } else { // start with non volatiles (no non-volatiles) - SearchStart = SparcFloatRegOrder::StartOfNonVolatileRegs; + SearchStart = SparcFloatRegClass::StartOfNonVolatileRegs; } ColorFound = findFloatColor( LR, SearchStart, 32, IsColorUsedArr ); @@ -241,7 +219,6 @@ void SparcFloatRegClass::colorIGNode(IGNode * Node,bool IsColorUsedArr[]) const if( ColorFound >= 0 ) { // if we could find a color LR->setColor(ColorFound); - if( DEBUG_RA) UltraSparcRegInfo::printReg( LR ); return; } else if( isCallInterf ) { @@ -250,73 +227,44 @@ void SparcFloatRegClass::colorIGNode(IGNode * Node,bool IsColorUsedArr[]) const // color could be found. // Now try to allocate even a volatile color - ColorFound = findFloatColor( LR, SparcFloatRegOrder::StartOfAllRegs, - SparcFloatRegOrder::StartOfNonVolatileRegs, + ColorFound = findFloatColor( LR, SparcFloatRegClass::StartOfAllRegs, + SparcFloatRegClass::StartOfNonVolatileRegs, IsColorUsedArr); } - - if( ColorFound >= 0 ) { - LR->setColor(ColorFound); // first color found in preffered order + LR->setColor(ColorFound); // first color found in prefered order LR->markForSaveAcrossCalls(); - if( DEBUG_RA) UltraSparcRegInfo::printReg( LR ); - return; + } else { + // we are here because no color could be found + LR->markForSpill(); // no color found - must spill } - - - // we are here because no color could be found - - LR->markForSpill(); // no color found - must spill - if( DEBUG_RA) UltraSparcRegInfo::printReg( LR ); - } - //----------------------------------------------------------------------------- // Helper method for coloring a node of Float Reg class. // Finds the first available color in the range [Start,End] depending on the // type of the Node (i.e., float/double) //----------------------------------------------------------------------------- -int SparcFloatRegClass::findFloatColor(const LiveRange *const LR, - unsigned Start, - unsigned End, - bool IsColorUsedArr[] ) const { +int SparcFloatRegClass::findFloatColor(const LiveRange *LR, + unsigned Start, unsigned End, + vector &IsColorUsedArr) const { bool ColorFound = false; unsigned c; - if( LR->getTypeID() == Type::DoubleTyID ) { - + if (LR->getType() == Type::DoubleTy) { // find first unused color for a double - for( c=Start; c < End ;c+= 2){ - if( ! IsColorUsedArr[ c ] && ! IsColorUsedArr[ c+1 ]) - { ColorFound=true; break; } - } - + for (c=Start; c < End ; c+= 2) + if (!IsColorUsedArr[c] && !IsColorUsedArr[c+1]) + return c; } else { - // find first unused color for a single - for( c=Start; c < End; c++) { - if( ! IsColorUsedArr[ c ] ) { ColorFound=true; break; } - } + for (c = Start; c < End; c++) + if (!IsColorUsedArr[c]) + return c; } - if( ColorFound ) return c; - else return -1; + return -1; } - - - - - - - - - - - - - -