Mercurial > hg > truffle

comparison src/share/vm/opto/ifg.cpp @ 8867:b808febcad9a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8010281: Remove code that is never executed Reviewed-by: kvn, roland Contributed-by: niclas.adlertz@oracle.com
author neliasso
date Tue, 26 Mar 2013 10:05:33 +0100
parents 2aff40cb4703
children 8373c19be854
comparison
equal deleted inserted replaced
8866:16885e702c88 8867:b808febcad9a
34 #include "opto/connode.hpp" 34 #include "opto/connode.hpp"
35 #include "opto/indexSet.hpp" 35 #include "opto/indexSet.hpp"
36 #include "opto/machnode.hpp" 36 #include "opto/machnode.hpp"
37 #include "opto/memnode.hpp" 37 #include "opto/memnode.hpp"
38 #include "opto/opcodes.hpp" 38 #include "opto/opcodes.hpp"
39
40 #define EXACT_PRESSURE 1
41 39
42 //============================================================================= 40 //=============================================================================
43 //------------------------------IFG-------------------------------------------- 41 //------------------------------IFG--------------------------------------------
44 PhaseIFG::PhaseIFG( Arena *arena ) : Phase(Interference_Graph), _arena(arena) { 42 PhaseIFG::PhaseIFG( Arena *arena ) : Phase(Interference_Graph), _arena(arena) {
45 } 43 }
443 if (lrg->mask().is_UP() && lrg->mask_size()) { 441 if (lrg->mask().is_UP() && lrg->mask_size()) {
444 if (lrg->_is_float || lrg->_is_vector) { 442 if (lrg->_is_float || lrg->_is_vector) {
445 pressure[1] -= lrg->reg_pressure(); 443 pressure[1] -= lrg->reg_pressure();
446 if( pressure[1] == (uint)FLOATPRESSURE ) { 444 if( pressure[1] == (uint)FLOATPRESSURE ) {
447 hrp_index[1] = where; 445 hrp_index[1] = where;
448 #ifdef EXACT_PRESSURE 446 if( pressure[1] > b->_freg_pressure )
449 if( pressure[1] > b->_freg_pressure ) 447 b->_freg_pressure = pressure[1]+1;
450 b->_freg_pressure = pressure[1]+1;
451 #else
452 b->_freg_pressure = (uint)FLOATPRESSURE+1;
453 #endif
454 } 448 }
455 } else if( lrg->mask().overlap(*Matcher::idealreg2regmask[Op_RegI]) ) { 449 } else if( lrg->mask().overlap(*Matcher::idealreg2regmask[Op_RegI]) ) {
456 pressure[0] -= lrg->reg_pressure(); 450 pressure[0] -= lrg->reg_pressure();
457 if( pressure[0] == (uint)INTPRESSURE ) { 451 if( pressure[0] == (uint)INTPRESSURE ) {
458 hrp_index[0] = where; 452 hrp_index[0] = where;
459 #ifdef EXACT_PRESSURE 453 if( pressure[0] > b->_reg_pressure )
460 if( pressure[0] > b->_reg_pressure ) 454 b->_reg_pressure = pressure[0]+1;
461 b->_reg_pressure = pressure[0]+1;
462 #else
463 b->_reg_pressure = (uint)INTPRESSURE+1;
464 #endif
465 } 455 }
466 } 456 }
467 } 457 }
468 } 458 }
469 459
524 lrg._area += cost; 514 lrg._area += cost;
525 // Compute initial register pressure 515 // Compute initial register pressure
526 if (lrg.mask().is_UP() && lrg.mask_size()) { 516 if (lrg.mask().is_UP() && lrg.mask_size()) {
527 if (lrg._is_float || lrg._is_vector) { // Count float pressure 517 if (lrg._is_float || lrg._is_vector) { // Count float pressure
528 pressure[1] += lrg.reg_pressure(); 518 pressure[1] += lrg.reg_pressure();
529 #ifdef EXACT_PRESSURE
530 if( pressure[1] > b->_freg_pressure ) 519 if( pressure[1] > b->_freg_pressure )
531 b->_freg_pressure = pressure[1]; 520 b->_freg_pressure = pressure[1];
532 #endif
533 // Count int pressure, but do not count the SP, flags 521 // Count int pressure, but do not count the SP, flags
534 } else if( lrgs(lidx).mask().overlap(*Matcher::idealreg2regmask[Op_RegI]) ) { 522 } else if( lrgs(lidx).mask().overlap(*Matcher::idealreg2regmask[Op_RegI]) ) {
535 pressure[0] += lrg.reg_pressure(); 523 pressure[0] += lrg.reg_pressure();
536 #ifdef EXACT_PRESSURE
537 if( pressure[0] > b->_reg_pressure ) 524 if( pressure[0] > b->_reg_pressure )
538 b->_reg_pressure = pressure[0]; 525 b->_reg_pressure = pressure[0];
539 #endif
540 } 526 }
541 } 527 }
542 } 528 }
543 assert( pressure[0] == count_int_pressure (&liveout), "" ); 529 assert( pressure[0] == count_int_pressure (&liveout), "" );
544 assert( pressure[1] == count_float_pressure(&liveout), "" ); 530 assert( pressure[1] == count_float_pressure(&liveout), "" );
587 if( lrgs(r)._fat_proj ) { 573 if( lrgs(r)._fat_proj ) {
588 // Count the int-only registers 574 // Count the int-only registers
589 RegMask itmp = lrgs(r).mask(); 575 RegMask itmp = lrgs(r).mask();
590 itmp.AND(*Matcher::idealreg2regmask[Op_RegI]); 576 itmp.AND(*Matcher::idealreg2regmask[Op_RegI]);
591 int iregs = itmp.Size(); 577 int iregs = itmp.Size();
592 #ifdef EXACT_PRESSURE
593 if( pressure[0]+iregs > b->_reg_pressure ) 578 if( pressure[0]+iregs > b->_reg_pressure )
594 b->_reg_pressure = pressure[0]+iregs; 579 b->_reg_pressure = pressure[0]+iregs;
595 #endif
596 if( pressure[0] <= (uint)INTPRESSURE && 580 if( pressure[0] <= (uint)INTPRESSURE &&
597 pressure[0]+iregs > (uint)INTPRESSURE ) { 581 pressure[0]+iregs > (uint)INTPRESSURE ) {
598 #ifndef EXACT_PRESSURE
599 b->_reg_pressure = (uint)INTPRESSURE+1;
600 #endif
601 hrp_index[0] = j-1; 582 hrp_index[0] = j-1;
602 } 583 }
603 // Count the float-only registers 584 // Count the float-only registers
604 RegMask ftmp = lrgs(r).mask(); 585 RegMask ftmp = lrgs(r).mask();
605 ftmp.AND(*Matcher::idealreg2regmask[Op_RegD]); 586 ftmp.AND(*Matcher::idealreg2regmask[Op_RegD]);
606 int fregs = ftmp.Size(); 587 int fregs = ftmp.Size();
607 #ifdef EXACT_PRESSURE
608 if( pressure[1]+fregs > b->_freg_pressure ) 588 if( pressure[1]+fregs > b->_freg_pressure )
609 b->_freg_pressure = pressure[1]+fregs; 589 b->_freg_pressure = pressure[1]+fregs;
610 #endif
611 if( pressure[1] <= (uint)FLOATPRESSURE && 590 if( pressure[1] <= (uint)FLOATPRESSURE &&
612 pressure[1]+fregs > (uint)FLOATPRESSURE ) { 591 pressure[1]+fregs > (uint)FLOATPRESSURE ) {
613 #ifndef EXACT_PRESSURE
614 b->_freg_pressure = (uint)FLOATPRESSURE+1;
615 #endif
616 hrp_index[1] = j-1; 592 hrp_index[1] = j-1;
617 } 593 }
618 } 594 }
619 595
620 } else { // Else it is live 596 } else { // Else it is live
767 lrg._area += cost; 743 lrg._area += cost;
768 // Adjust register pressure 744 // Adjust register pressure
769 if (lrg.mask().is_UP() && lrg.mask_size()) { 745 if (lrg.mask().is_UP() && lrg.mask_size()) {
770 if (lrg._is_float || lrg._is_vector) { 746 if (lrg._is_float || lrg._is_vector) {
771 pressure[1] += lrg.reg_pressure(); 747 pressure[1] += lrg.reg_pressure();
772 #ifdef EXACT_PRESSURE
773 if( pressure[1] > b->_freg_pressure ) 748 if( pressure[1] > b->_freg_pressure )
774 b->_freg_pressure = pressure[1]; 749 b->_freg_pressure = pressure[1];
775 #endif
776 } else if( lrg.mask().overlap(*Matcher::idealreg2regmask[Op_RegI]) ) { 750 } else if( lrg.mask().overlap(*Matcher::idealreg2regmask[Op_RegI]) ) {
777 pressure[0] += lrg.reg_pressure(); 751 pressure[0] += lrg.reg_pressure();
778 #ifdef EXACT_PRESSURE
779 if( pressure[0] > b->_reg_pressure ) 752 if( pressure[0] > b->_reg_pressure )
780 b->_reg_pressure = pressure[0]; 753 b->_reg_pressure = pressure[0];
781 #endif
782 } 754 }
783 } 755 }
784 assert( pressure[0] == count_int_pressure (&liveout), "" ); 756 assert( pressure[0] == count_int_pressure (&liveout), "" );
785 assert( pressure[1] == count_float_pressure(&liveout), "" ); 757 assert( pressure[1] == count_float_pressure(&liveout), "" );
786 } 758 }
792 // If we run off the top of the block with high pressure and 764 // If we run off the top of the block with high pressure and
793 // never see a hi-to-low pressure transition, just record that 765 // never see a hi-to-low pressure transition, just record that
794 // the whole block is high pressure. 766 // the whole block is high pressure.
795 if( pressure[0] > (uint)INTPRESSURE ) { 767 if( pressure[0] > (uint)INTPRESSURE ) {
796 hrp_index[0] = 0; 768 hrp_index[0] = 0;
797 #ifdef EXACT_PRESSURE
798 if( pressure[0] > b->_reg_pressure ) 769 if( pressure[0] > b->_reg_pressure )
799 b->_reg_pressure = pressure[0]; 770 b->_reg_pressure = pressure[0];
800 #else
801 b->_reg_pressure = (uint)INTPRESSURE+1;
802 #endif
803 } 771 }
804 if( pressure[1] > (uint)FLOATPRESSURE ) { 772 if( pressure[1] > (uint)FLOATPRESSURE ) {
805 hrp_index[1] = 0; 773 hrp_index[1] = 0;
806 #ifdef EXACT_PRESSURE
807 if( pressure[1] > b->_freg_pressure ) 774 if( pressure[1] > b->_freg_pressure )
808 b->_freg_pressure = pressure[1]; 775 b->_freg_pressure = pressure[1];
809 #else
810 b->_freg_pressure = (uint)FLOATPRESSURE+1;
811 #endif
812 } 776 }
813 777
814 // Compute high pressure indice; avoid landing in the middle of projnodes 778 // Compute high pressure indice; avoid landing in the middle of projnodes
815 j = hrp_index[0]; 779 j = hrp_index[0];
816 if( j < b->_nodes.size() && j < b->end_idx()+1 ) { 780 if( j < b->_nodes.size() && j < b->end_idx()+1 ) {