Mercurial > hg > graal-compiler

comparison src/share/vm/opto/postaloc.cpp @ 10111:8373c19be854

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8011621: live_ranges_in_separate_class.patch Reviewed-by: kvn, roland Contributed-by: niclas.adlertz@oracle.com
author neliasso
date Tue, 16 Apr 2013 10:08:41 +0200
parents 2aff40cb4703
children d1034bd8cefc
comparison
equal deleted inserted replaced
10109:1c6887c9afaa 10111:8373c19be854
54 54
55 const int limit = 60; 55 const int limit = 60;
56 int i; 56 int i;
57 for( i=0; i < limit; i++ ) { 57 for( i=0; i < limit; i++ ) {
58 if( def->is_Proj() && def->in(0)->is_Start() && 58 if( def->is_Proj() && def->in(0)->is_Start() &&
59 _matcher.is_save_on_entry(lrgs(n2lidx(def)).reg()) ) 59 _matcher.is_save_on_entry(lrgs(_lrg_map.live_range_id(def)).reg()))
60 return true; // Direct use of callee-save proj 60 return true; // Direct use of callee-save proj
61 if( def->is_Copy() ) // Copies carry value through 61 if( def->is_Copy() ) // Copies carry value through
62 def = def->in(def->is_Copy()); 62 def = def->in(def->is_Copy());
63 else if( def->is_Phi() ) // Phis can merge it from any direction 63 else if( def->is_Phi() ) // Phis can merge it from any direction
64 def = def->in(1); 64 def = def->in(1);
81 Block *oldb = _cfg._bbs[old->_idx]; 81 Block *oldb = _cfg._bbs[old->_idx];
82 oldb->find_remove(old); 82 oldb->find_remove(old);
83 // Count 1 if deleting an instruction from the current block 83 // Count 1 if deleting an instruction from the current block
84 if( oldb == current_block ) blk_adjust++; 84 if( oldb == current_block ) blk_adjust++;
85 _cfg._bbs.map(old->_idx,NULL); 85 _cfg._bbs.map(old->_idx,NULL);
86 OptoReg::Name old_reg = lrgs(n2lidx(old)).reg(); 86 OptoReg::Name old_reg = lrgs(_lrg_map.live_range_id(old)).reg();
87 if( regnd && (*regnd)[old_reg]==old ) { // Instruction is currently available? 87 if( regnd && (*regnd)[old_reg]==old ) { // Instruction is currently available?
88 value->map(old_reg,NULL); // Yank from value/regnd maps 88 value->map(old_reg,NULL); // Yank from value/regnd maps
89 regnd->map(old_reg,NULL); // This register's value is now unknown 89 regnd->map(old_reg,NULL); // This register's value is now unknown
90 } 90 }
91 return blk_adjust; 91 return blk_adjust;
162 if( def->outcnt() == 0 ) return 0; 162 if( def->outcnt() == 0 ) return 0;
163 163
164 // Not every pair of physical registers are assignment compatible, 164 // Not every pair of physical registers are assignment compatible,
165 // e.g. on sparc floating point registers are not assignable to integer 165 // e.g. on sparc floating point registers are not assignable to integer
166 // registers. 166 // registers.
167 const LRG &def_lrg = lrgs(n2lidx(def)); 167 const LRG &def_lrg = lrgs(_lrg_map.live_range_id(def));
168 OptoReg::Name def_reg = def_lrg.reg(); 168 OptoReg::Name def_reg = def_lrg.reg();
169 const RegMask &use_mask = n->in_RegMask(idx); 169 const RegMask &use_mask = n->in_RegMask(idx);
170 bool can_use = ( RegMask::can_represent(def_reg) ? (use_mask.Member(def_reg) != 0) 170 bool can_use = ( RegMask::can_represent(def_reg) ? (use_mask.Member(def_reg) != 0)
171 : (use_mask.is_AllStack() != 0)); 171 : (use_mask.is_AllStack() != 0));
172 if (!RegMask::is_vector(def->ideal_reg())) { 172 if (!RegMask::is_vector(def->ideal_reg())) {
207 207
208 //------------------------------skip_copies------------------------------------ 208 //------------------------------skip_copies------------------------------------
209 // Skip through any number of copies (that don't mod oop-i-ness) 209 // Skip through any number of copies (that don't mod oop-i-ness)
210 Node *PhaseChaitin::skip_copies( Node *c ) { 210 Node *PhaseChaitin::skip_copies( Node *c ) {
211 int idx = c->is_Copy(); 211 int idx = c->is_Copy();
212 uint is_oop = lrgs(n2lidx(c))._is_oop; 212 uint is_oop = lrgs(_lrg_map.live_range_id(c))._is_oop;
213 while (idx != 0) { 213 while (idx != 0) {
214 guarantee(c->in(idx) != NULL, "must not resurrect dead copy"); 214 guarantee(c->in(idx) != NULL, "must not resurrect dead copy");
215 if (lrgs(n2lidx(c->in(idx)))._is_oop != is_oop) 215 if (lrgs(_lrg_map.live_range_id(c->in(idx)))._is_oop != is_oop) {
216 break; // casting copy, not the same value 216 break; // casting copy, not the same value
217 }
217 c = c->in(idx); 218 c = c->in(idx);
218 idx = c->is_Copy(); 219 idx = c->is_Copy();
219 } 220 }
220 return c; 221 return c;
221 } 222 }
223 //------------------------------elide_copy------------------------------------- 224 //------------------------------elide_copy-------------------------------------
224 // Remove (bypass) copies along Node n, edge k. 225 // Remove (bypass) copies along Node n, edge k.
225 int PhaseChaitin::elide_copy( Node *n, int k, Block *current_block, Node_List &value, Node_List &regnd, bool can_change_regs ) { 226 int PhaseChaitin::elide_copy( Node *n, int k, Block *current_block, Node_List &value, Node_List &regnd, bool can_change_regs ) {
226 int blk_adjust = 0; 227 int blk_adjust = 0;
227 228
228 uint nk_idx = n2lidx(n->in(k)); 229 uint nk_idx = _lrg_map.live_range_id(n->in(k));
229 OptoReg::Name nk_reg = lrgs(nk_idx ).reg(); 230 OptoReg::Name nk_reg = lrgs(nk_idx).reg();
230 231
231 // Remove obvious same-register copies 232 // Remove obvious same-register copies
232 Node *x = n->in(k); 233 Node *x = n->in(k);
233 int idx; 234 int idx;
234 while( (idx=x->is_Copy()) != 0 ) { 235 while( (idx=x->is_Copy()) != 0 ) {
235 Node *copy = x->in(idx); 236 Node *copy = x->in(idx);
236 guarantee(copy != NULL, "must not resurrect dead copy"); 237 guarantee(copy != NULL, "must not resurrect dead copy");
237 if( lrgs(n2lidx(copy)).reg() != nk_reg ) break; 238 if(lrgs(_lrg_map.live_range_id(copy)).reg() != nk_reg) {
239 break;
240 }
238 blk_adjust += use_prior_register(n,k,copy,current_block,value,regnd); 241 blk_adjust += use_prior_register(n,k,copy,current_block,value,regnd);
239 if( n->in(k) != copy ) break; // Failed for some cutout? 242 if (n->in(k) != copy) {
243 break; // Failed for some cutout?
244 }
240 x = copy; // Progress, try again 245 x = copy; // Progress, try again
241 } 246 }
242 247
243 // Phis and 2-address instructions cannot change registers so easily - their 248 // Phis and 2-address instructions cannot change registers so easily - their
244 // outputs must match their input. 249 // outputs must match their input.
254 // then reloaded BUT survives in a register the whole way. 259 // then reloaded BUT survives in a register the whole way.
255 Node *val = skip_copies(n->in(k)); 260 Node *val = skip_copies(n->in(k));
256 261
257 if (val == x && nk_idx != 0 && 262 if (val == x && nk_idx != 0 &&
258 regnd[nk_reg] != NULL && regnd[nk_reg] != x && 263 regnd[nk_reg] != NULL && regnd[nk_reg] != x &&
259 n2lidx(x) == n2lidx(regnd[nk_reg])) { 264 _lrg_map.live_range_id(x) == _lrg_map.live_range_id(regnd[nk_reg])) {
260 // When rematerialzing nodes and stretching lifetimes, the 265 // When rematerialzing nodes and stretching lifetimes, the
261 // allocator will reuse the original def for multidef LRG instead 266 // allocator will reuse the original def for multidef LRG instead
262 // of the current reaching def because it can't know it's safe to 267 // of the current reaching def because it can't know it's safe to
263 // do so. After allocation completes if they are in the same LRG 268 // do so. After allocation completes if they are in the same LRG
264 // then it should use the current reaching def instead. 269 // then it should use the current reaching def instead.
268 } 273 }
269 274
270 if (val == x) return blk_adjust; // No progress? 275 if (val == x) return blk_adjust; // No progress?
271 276
272 int n_regs = RegMask::num_registers(val->ideal_reg()); 277 int n_regs = RegMask::num_registers(val->ideal_reg());
273 uint val_idx = n2lidx(val); 278 uint val_idx = _lrg_map.live_range_id(val);
274 OptoReg::Name val_reg = lrgs(val_idx).reg(); 279 OptoReg::Name val_reg = lrgs(val_idx).reg();
275 280
276 // See if it happens to already be in the correct register! 281 // See if it happens to already be in the correct register!
277 // (either Phi's direct register, or the common case of the name 282 // (either Phi's direct register, or the common case of the name
278 // never-clobbered original-def register) 283 // never-clobbered original-def register)
497 502
498 // For all Phi's 503 // For all Phi's
499 for( j = 1; j < phi_dex; j++ ) { 504 for( j = 1; j < phi_dex; j++ ) {
500 uint k; 505 uint k;
501 Node *phi = b->_nodes[j]; 506 Node *phi = b->_nodes[j];
502 uint pidx = n2lidx(phi); 507 uint pidx = _lrg_map.live_range_id(phi);
503 OptoReg::Name preg = lrgs(n2lidx(phi)).reg(); 508 OptoReg::Name preg = lrgs(_lrg_map.live_range_id(phi)).reg();
504 509
505 // Remove copies remaining on edges. Check for junk phi. 510 // Remove copies remaining on edges. Check for junk phi.
506 Node *u = NULL; 511 Node *u = NULL;
507 for( k=1; k<phi->req(); k++ ) { 512 for (k = 1; k < phi->req(); k++) {
508 Node *x = phi->in(k); 513 Node *x = phi->in(k);
509 if( phi != x && u != x ) // Found a different input 514 if( phi != x && u != x ) // Found a different input
510 u = u ? NodeSentinel : x; // Capture unique input, or NodeSentinel for 2nd input 515 u = u ? NodeSentinel : x; // Capture unique input, or NodeSentinel for 2nd input
511 } 516 }
512 if( u != NodeSentinel ) { // Junk Phi. Remove 517 if( u != NodeSentinel ) { // Junk Phi. Remove
553 // up (at loop backedges, because we aren't doing a full flow pass). 558 // up (at loop backedges, because we aren't doing a full flow pass).
554 // The presence of a live use essentially asserts that the use's def is 559 // The presence of a live use essentially asserts that the use's def is
555 // alive and well at the use (or else the allocator fubar'd). Take 560 // alive and well at the use (or else the allocator fubar'd). Take
556 // advantage of this info to set a reaching def for the use-reg. 561 // advantage of this info to set a reaching def for the use-reg.
557 uint k; 562 uint k;
558 for( k = 1; k < n->req(); k++ ) { 563 for (k = 1; k < n->req(); k++) {
559 Node *def = n->in(k); // n->in(k) is a USE; def is the DEF for this USE 564 Node *def = n->in(k); // n->in(k) is a USE; def is the DEF for this USE
560 guarantee(def != NULL, "no disconnected nodes at this point"); 565 guarantee(def != NULL, "no disconnected nodes at this point");
561 uint useidx = n2lidx(def); // useidx is the live range index for this USE 566 uint useidx = _lrg_map.live_range_id(def); // useidx is the live range index for this USE
562 567
563 if( useidx ) { 568 if( useidx ) {
564 OptoReg::Name ureg = lrgs(useidx).reg(); 569 OptoReg::Name ureg = lrgs(useidx).reg();
565 if( !value[ureg] ) { 570 if( !value[ureg] ) {
566 int idx; // Skip occasional useless copy 571 int idx; // Skip occasional useless copy
567 while( (idx=def->is_Copy()) != 0 && 572 while( (idx=def->is_Copy()) != 0 &&
568 def->in(idx) != NULL && // NULL should not happen 573 def->in(idx) != NULL && // NULL should not happen
569 ureg == lrgs(n2lidx(def->in(idx))).reg() ) 574 ureg == lrgs(_lrg_map.live_range_id(def->in(idx))).reg())
570 def = def->in(idx); 575 def = def->in(idx);
571 Node *valdef = skip_copies(def); // tighten up val through non-useless copies 576 Node *valdef = skip_copies(def); // tighten up val through non-useless copies
572 value.map(ureg,valdef); // record improved reaching-def info 577 value.map(ureg,valdef); // record improved reaching-def info
573 regnd.map(ureg, def); 578 regnd.map(ureg, def);
574 // Record other half of doubles 579 // Record other half of doubles
592 // Remove copies along input edges 597 // Remove copies along input edges
593 for( k = 1; k < n->req(); k++ ) 598 for( k = 1; k < n->req(); k++ )
594 j -= elide_copy( n, k, b, value, regnd, two_adr!=k ); 599 j -= elide_copy( n, k, b, value, regnd, two_adr!=k );
595 600
596 // Unallocated Nodes define no registers 601 // Unallocated Nodes define no registers
597 uint lidx = n2lidx(n); 602 uint lidx = _lrg_map.live_range_id(n);
598 if( !lidx ) continue; 603 if (!lidx) {
604 continue;
605 }
599 606
600 // Update the register defined by this instruction 607 // Update the register defined by this instruction
601 OptoReg::Name nreg = lrgs(lidx).reg(); 608 OptoReg::Name nreg = lrgs(lidx).reg();
602 // Skip through all copies to the _value_ being defined. 609 // Skip through all copies to the _value_ being defined.
603 // Do not change from int to pointer 610 // Do not change from int to pointer