inline
void
VectorDBase<T>::assign(const VectorDBase<T>& v1, const IndexSet& is)
{
assert(v1.get_size() == is.get_size());
assert(get_size() == is.count());
T* i = start;
for (typename IndexSet::Iter i1 = is.begin(); i1 != is.end(); ++i1) {
*i = v1[i1]; ++i;
}
}
//------------------------------add_liveout------------------------------------
// Add a vector of live-out values to a given blocks live-out set.
void PhaseLive::add_liveout( Block *p, IndexSet *lo, VectorSet &first_pass ) {
IndexSet *live = &_live[p->_pre_order-1];
IndexSet *defs = &_defs[p->_pre_order-1];
IndexSet *on_worklist = _deltas[p->_pre_order-1];
IndexSet *delta = on_worklist ? on_worklist : getfreeset();
IndexSetIterator elements(lo);
uint r;
while ((r = elements.next()) != 0) {
if( live->insert(r) && // If actually inserted...
!defs->member( r ) ) // and not defined locally
delta->insert(r); // Then add to live-in set
}
if( delta->count() ) { // If actually added things
_deltas[p->_pre_order-1] = delta; // Flag as on worklist now
if( !on_worklist && // Not on worklist?
first_pass.test(p->_pre_order) )
_worklist->push(p); // Actually go on worklist if already 1st pass
} else { // Nothing there; just free it
delta->set_next(_free_IndexSet);
_free_IndexSet = delta; // Drop onto free list
}
}
void PhaseLive::compute(uint maxlrg) {
_maxlrg = maxlrg;
_worklist = new (_arena) Block_List();
// Init the sparse live arrays. This data is live on exit from here!
// The _live info is the live-out info.
_live = (IndexSet*)_arena->Amalloc(sizeof(IndexSet)*_cfg._num_blocks);
uint i;
for( i=0; i<_cfg._num_blocks; i++ ) {
_live[i].initialize(_maxlrg);
}
// Init the sparse arrays for delta-sets.
ResourceMark rm; // Nuke temp storage on exit
// Does the memory used by _defs and _deltas get reclaimed? Does it matter? TT
// Array of values defined locally in blocks
_defs = NEW_RESOURCE_ARRAY(IndexSet,_cfg._num_blocks);
for( i=0; i<_cfg._num_blocks; i++ ) {
_defs[i].initialize(_maxlrg);
}
// Array of delta-set pointers, indexed by block pre_order-1.
_deltas = NEW_RESOURCE_ARRAY(IndexSet*,_cfg._num_blocks);
memset( _deltas, 0, sizeof(IndexSet*)* _cfg._num_blocks);
_free_IndexSet = NULL;
// Blocks having done pass-1
VectorSet first_pass(Thread::current()->resource_area());
// Outer loop: must compute local live-in sets and push into predecessors.
uint iters = _cfg._num_blocks; // stat counters
for( uint j=_cfg._num_blocks; j>0; j-- ) {
Block *b = _cfg._blocks[j-1];
// Compute the local live-in set. Start with any new live-out bits.
IndexSet *use = getset( b );
IndexSet *def = &_defs[b->_pre_order-1];
uint i;
for( i=b->_nodes.size(); i>1; i-- ) {
Node *n = b->_nodes[i-1];
if( n->is_Phi() ) break;
// BoxNodes keep their input alive as long as their uses. If we
// see a BoxNode then make its input live to the Root block.
// Because we are solving LIVEness, the input now becomes live
// over the whole procedure, interferencing with everything else
// and getting a private unshared stack slot. YeeeHaw!
MachNode *mach = n->is_Mach();
if( mach && mach->ideal_Opcode() == Op_Box )
getset(_cfg._broot)->insert( _names[n->in(1)->_idx] );
uint r = _names[n->_idx];
def->insert( r );
use->remove( r );
uint cnt = n->req();
for( uint k=1; k<cnt; k++ ) {
Node *nk = n->in(k);
uint nkidx = nk->_idx;
if( _cfg._bbs[nkidx] != b )
use->insert( _names[nkidx] );
}
}
// Remove anything defined by Phis and the block start instruction
for( uint k=i; k>0; k-- ) {
uint r = _names[b->_nodes[k-1]->_idx];
def->insert( r );
use->remove( r );
}
// Push these live-in things to predecessors
for( uint l=1; l<b->num_preds(); l++ ) {
Block *p = _cfg._bbs[b->pred(l)->_idx];
add_liveout( p, use, first_pass );
// PhiNode uses go in the live-out set of prior blocks.
for( uint k=i; k>0; k-- )
add_liveout( p, _names[b->_nodes[k-1]->in(l)->_idx], first_pass );
}
freeset( b );
first_pass.set(b->_pre_order);
// Inner loop: blocks that picked up new live-out values to be propagated
while( _worklist->size() ) {
// !!!!!
// #ifdef ASSERT
iters++;
// #endif
Block *b = _worklist->pop();
IndexSet *delta = getset(b);
assert( delta->count(), "missing delta set" );
// Add new-live-in to predecessors live-out sets
for( uint l=1; l<b->num_preds(); l++ )
add_liveout( _cfg._bbs[b->pred(l)->_idx], delta, first_pass );
freeset(b);
} // End of while-worklist-not-empty
} // End of for-all-blocks-outer-loop
// We explicitly clear all of the IndexSets which we are about to release.
// This allows us to recycle their internal memory into IndexSet's free list.
for( i=0; i<_cfg._num_blocks; i++ ) {
_defs[i].clear();
if (_deltas[i]) {
// Is this always true?
_deltas[i]->clear();
}
}
IndexSet *free = _free_IndexSet;
while (free != NULL) {
IndexSet *temp = free;
free = free->next();
temp->clear();
}
}
uint IndexSet::lrg_union(uint lr1, uint lr2,
const uint fail_degree,
const PhaseIFG *ifg,
const RegMask &mask ) {
IndexSet *one = ifg->neighbors(lr1);
IndexSet *two = ifg->neighbors(lr2);
LRG &lrg1 = ifg->lrgs(lr1);
LRG &lrg2 = ifg->lrgs(lr2);
#ifdef ASSERT
assert(_max_elements == one->_max_elements, "max element mismatch");
check_watch("union destination");
one->check_watch("union source");
two->check_watch("union source");
#endif
// Compute the degree of the combined live-range. The combined
// live-range has the union of the original live-ranges' neighbors set as
// well as the neighbors of all intermediate copies, minus those neighbors
// that can not use the intersected allowed-register-set.
// Copy the larger set. Insert the smaller set into the larger.
if (two->count() > one->count()) {
IndexSet *temp = one;
one = two;
two = temp;
}
clear();
// Used to compute degree of register-only interferences. Infinite-stack
// neighbors do not alter colorability, as they can always color to some
// other color. (A variant of the Briggs assertion)
uint reg_degree = 0;
uint element;
// Load up the combined interference set with the neighbors of one
IndexSetIterator elements(one);
while ((element = elements.next()) != 0) {
LRG &lrg = ifg->lrgs(element);
if (mask.overlap(lrg.mask())) {
insert(element);
if( !lrg.mask().is_AllStack() ) {
reg_degree += lrg1.compute_degree(lrg);
if( reg_degree >= fail_degree ) return reg_degree;
} else {
// !!!!! Danger! No update to reg_degree despite having a neighbor.
// A variant of the Briggs assertion.
// Not needed if I simplify during coalesce, ala George/Appel.
assert( lrg.lo_degree(), "" );
}
}
}
// Add neighbors of two as well
IndexSetIterator elements2(two);
while ((element = elements2.next()) != 0) {
LRG &lrg = ifg->lrgs(element);
if (mask.overlap(lrg.mask())) {
if (insert(element)) {
if( !lrg.mask().is_AllStack() ) {
reg_degree += lrg2.compute_degree(lrg);
if( reg_degree >= fail_degree ) return reg_degree;
} else {
// !!!!! Danger! No update to reg_degree despite having a neighbor.
// A variant of the Briggs assertion.
// Not needed if I simplify during coalesce, ala George/Appel.
assert( lrg.lo_degree(), "" );
}
}
}
}
return reg_degree;
}
