Wed, 09 Dec 2009 16:40:45 -0800
6895383: JCK test throws NPE for method compiled with Escape Analysis
Summary: Add missing checks for MemBar nodes in EA.
Reviewed-by: never
duke@435 | 1 | /* |
xdono@1014 | 2 | * Copyright 1998-2009 Sun Microsystems, Inc. All Rights Reserved. |
duke@435 | 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
duke@435 | 4 | * |
duke@435 | 5 | * This code is free software; you can redistribute it and/or modify it |
duke@435 | 6 | * under the terms of the GNU General Public License version 2 only, as |
duke@435 | 7 | * published by the Free Software Foundation. |
duke@435 | 8 | * |
duke@435 | 9 | * This code is distributed in the hope that it will be useful, but WITHOUT |
duke@435 | 10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
duke@435 | 11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
duke@435 | 12 | * version 2 for more details (a copy is included in the LICENSE file that |
duke@435 | 13 | * accompanied this code). |
duke@435 | 14 | * |
duke@435 | 15 | * You should have received a copy of the GNU General Public License version |
duke@435 | 16 | * 2 along with this work; if not, write to the Free Software Foundation, |
duke@435 | 17 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
duke@435 | 18 | * |
duke@435 | 19 | * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
duke@435 | 20 | * CA 95054 USA or visit www.sun.com if you need additional information or |
duke@435 | 21 | * have any questions. |
duke@435 | 22 | * |
duke@435 | 23 | */ |
duke@435 | 24 | |
duke@435 | 25 | #include "incls/_precompiled.incl" |
duke@435 | 26 | #include "incls/_ifg.cpp.incl" |
duke@435 | 27 | |
duke@435 | 28 | #define EXACT_PRESSURE 1 |
duke@435 | 29 | |
duke@435 | 30 | //============================================================================= |
duke@435 | 31 | //------------------------------IFG-------------------------------------------- |
duke@435 | 32 | PhaseIFG::PhaseIFG( Arena *arena ) : Phase(Interference_Graph), _arena(arena) { |
duke@435 | 33 | } |
duke@435 | 34 | |
duke@435 | 35 | //------------------------------init------------------------------------------- |
duke@435 | 36 | void PhaseIFG::init( uint maxlrg ) { |
duke@435 | 37 | _maxlrg = maxlrg; |
duke@435 | 38 | _yanked = new (_arena) VectorSet(_arena); |
duke@435 | 39 | _is_square = false; |
duke@435 | 40 | // Make uninitialized adjacency lists |
duke@435 | 41 | _adjs = (IndexSet*)_arena->Amalloc(sizeof(IndexSet)*maxlrg); |
duke@435 | 42 | // Also make empty live range structures |
duke@435 | 43 | _lrgs = (LRG *)_arena->Amalloc( maxlrg * sizeof(LRG) ); |
duke@435 | 44 | memset(_lrgs,0,sizeof(LRG)*maxlrg); |
duke@435 | 45 | // Init all to empty |
duke@435 | 46 | for( uint i = 0; i < maxlrg; i++ ) { |
duke@435 | 47 | _adjs[i].initialize(maxlrg); |
duke@435 | 48 | _lrgs[i].Set_All(); |
duke@435 | 49 | } |
duke@435 | 50 | } |
duke@435 | 51 | |
duke@435 | 52 | //------------------------------add-------------------------------------------- |
duke@435 | 53 | // Add edge between vertices a & b. These are sorted (triangular matrix), |
duke@435 | 54 | // then the smaller number is inserted in the larger numbered array. |
duke@435 | 55 | int PhaseIFG::add_edge( uint a, uint b ) { |
duke@435 | 56 | lrgs(a).invalid_degree(); |
duke@435 | 57 | lrgs(b).invalid_degree(); |
duke@435 | 58 | // Sort a and b, so that a is bigger |
duke@435 | 59 | assert( !_is_square, "only on triangular" ); |
duke@435 | 60 | if( a < b ) { uint tmp = a; a = b; b = tmp; } |
duke@435 | 61 | return _adjs[a].insert( b ); |
duke@435 | 62 | } |
duke@435 | 63 | |
duke@435 | 64 | //------------------------------add_vector------------------------------------- |
duke@435 | 65 | // Add an edge between 'a' and everything in the vector. |
duke@435 | 66 | void PhaseIFG::add_vector( uint a, IndexSet *vec ) { |
duke@435 | 67 | // IFG is triangular, so do the inserts where 'a' < 'b'. |
duke@435 | 68 | assert( !_is_square, "only on triangular" ); |
duke@435 | 69 | IndexSet *adjs_a = &_adjs[a]; |
duke@435 | 70 | if( !vec->count() ) return; |
duke@435 | 71 | |
duke@435 | 72 | IndexSetIterator elements(vec); |
duke@435 | 73 | uint neighbor; |
duke@435 | 74 | while ((neighbor = elements.next()) != 0) { |
duke@435 | 75 | add_edge( a, neighbor ); |
duke@435 | 76 | } |
duke@435 | 77 | } |
duke@435 | 78 | |
duke@435 | 79 | //------------------------------test------------------------------------------- |
duke@435 | 80 | // Is there an edge between a and b? |
duke@435 | 81 | int PhaseIFG::test_edge( uint a, uint b ) const { |
duke@435 | 82 | // Sort a and b, so that a is larger |
duke@435 | 83 | assert( !_is_square, "only on triangular" ); |
duke@435 | 84 | if( a < b ) { uint tmp = a; a = b; b = tmp; } |
duke@435 | 85 | return _adjs[a].member(b); |
duke@435 | 86 | } |
duke@435 | 87 | |
duke@435 | 88 | //------------------------------SquareUp--------------------------------------- |
duke@435 | 89 | // Convert triangular matrix to square matrix |
duke@435 | 90 | void PhaseIFG::SquareUp() { |
duke@435 | 91 | assert( !_is_square, "only on triangular" ); |
duke@435 | 92 | |
duke@435 | 93 | // Simple transpose |
duke@435 | 94 | for( uint i = 0; i < _maxlrg; i++ ) { |
duke@435 | 95 | IndexSetIterator elements(&_adjs[i]); |
duke@435 | 96 | uint datum; |
duke@435 | 97 | while ((datum = elements.next()) != 0) { |
duke@435 | 98 | _adjs[datum].insert( i ); |
duke@435 | 99 | } |
duke@435 | 100 | } |
duke@435 | 101 | _is_square = true; |
duke@435 | 102 | } |
duke@435 | 103 | |
duke@435 | 104 | //------------------------------Compute_Effective_Degree----------------------- |
duke@435 | 105 | // Compute effective degree in bulk |
duke@435 | 106 | void PhaseIFG::Compute_Effective_Degree() { |
duke@435 | 107 | assert( _is_square, "only on square" ); |
duke@435 | 108 | |
duke@435 | 109 | for( uint i = 0; i < _maxlrg; i++ ) |
duke@435 | 110 | lrgs(i).set_degree(effective_degree(i)); |
duke@435 | 111 | } |
duke@435 | 112 | |
duke@435 | 113 | //------------------------------test_edge_sq----------------------------------- |
duke@435 | 114 | int PhaseIFG::test_edge_sq( uint a, uint b ) const { |
duke@435 | 115 | assert( _is_square, "only on square" ); |
duke@435 | 116 | // Swap, so that 'a' has the lesser count. Then binary search is on |
duke@435 | 117 | // the smaller of a's list and b's list. |
duke@435 | 118 | if( neighbor_cnt(a) > neighbor_cnt(b) ) { uint tmp = a; a = b; b = tmp; } |
duke@435 | 119 | //return _adjs[a].unordered_member(b); |
duke@435 | 120 | return _adjs[a].member(b); |
duke@435 | 121 | } |
duke@435 | 122 | |
duke@435 | 123 | //------------------------------Union------------------------------------------ |
duke@435 | 124 | // Union edges of B into A |
duke@435 | 125 | void PhaseIFG::Union( uint a, uint b ) { |
duke@435 | 126 | assert( _is_square, "only on square" ); |
duke@435 | 127 | IndexSet *A = &_adjs[a]; |
duke@435 | 128 | IndexSetIterator b_elements(&_adjs[b]); |
duke@435 | 129 | uint datum; |
duke@435 | 130 | while ((datum = b_elements.next()) != 0) { |
duke@435 | 131 | if(A->insert(datum)) { |
duke@435 | 132 | _adjs[datum].insert(a); |
duke@435 | 133 | lrgs(a).invalid_degree(); |
duke@435 | 134 | lrgs(datum).invalid_degree(); |
duke@435 | 135 | } |
duke@435 | 136 | } |
duke@435 | 137 | } |
duke@435 | 138 | |
duke@435 | 139 | //------------------------------remove_node------------------------------------ |
duke@435 | 140 | // Yank a Node and all connected edges from the IFG. Return a |
duke@435 | 141 | // list of neighbors (edges) yanked. |
duke@435 | 142 | IndexSet *PhaseIFG::remove_node( uint a ) { |
duke@435 | 143 | assert( _is_square, "only on square" ); |
duke@435 | 144 | assert( !_yanked->test(a), "" ); |
duke@435 | 145 | _yanked->set(a); |
duke@435 | 146 | |
duke@435 | 147 | // I remove the LRG from all neighbors. |
duke@435 | 148 | IndexSetIterator elements(&_adjs[a]); |
duke@435 | 149 | LRG &lrg_a = lrgs(a); |
duke@435 | 150 | uint datum; |
duke@435 | 151 | while ((datum = elements.next()) != 0) { |
duke@435 | 152 | _adjs[datum].remove(a); |
duke@435 | 153 | lrgs(datum).inc_degree( -lrg_a.compute_degree(lrgs(datum)) ); |
duke@435 | 154 | } |
duke@435 | 155 | return neighbors(a); |
duke@435 | 156 | } |
duke@435 | 157 | |
duke@435 | 158 | //------------------------------re_insert-------------------------------------- |
duke@435 | 159 | // Re-insert a yanked Node. |
duke@435 | 160 | void PhaseIFG::re_insert( uint a ) { |
duke@435 | 161 | assert( _is_square, "only on square" ); |
duke@435 | 162 | assert( _yanked->test(a), "" ); |
duke@435 | 163 | (*_yanked) >>= a; |
duke@435 | 164 | |
duke@435 | 165 | IndexSetIterator elements(&_adjs[a]); |
duke@435 | 166 | uint datum; |
duke@435 | 167 | while ((datum = elements.next()) != 0) { |
duke@435 | 168 | _adjs[datum].insert(a); |
duke@435 | 169 | lrgs(datum).invalid_degree(); |
duke@435 | 170 | } |
duke@435 | 171 | } |
duke@435 | 172 | |
duke@435 | 173 | //------------------------------compute_degree--------------------------------- |
duke@435 | 174 | // Compute the degree between 2 live ranges. If both live ranges are |
duke@435 | 175 | // aligned-adjacent powers-of-2 then we use the MAX size. If either is |
duke@435 | 176 | // mis-aligned (or for Fat-Projections, not-adjacent) then we have to |
duke@435 | 177 | // MULTIPLY the sizes. Inspect Brigg's thesis on register pairs to see why |
duke@435 | 178 | // this is so. |
duke@435 | 179 | int LRG::compute_degree( LRG &l ) const { |
duke@435 | 180 | int tmp; |
duke@435 | 181 | int num_regs = _num_regs; |
duke@435 | 182 | int nregs = l.num_regs(); |
duke@435 | 183 | tmp = (_fat_proj || l._fat_proj) // either is a fat-proj? |
duke@435 | 184 | ? (num_regs * nregs) // then use product |
duke@435 | 185 | : MAX2(num_regs,nregs); // else use max |
duke@435 | 186 | return tmp; |
duke@435 | 187 | } |
duke@435 | 188 | |
duke@435 | 189 | //------------------------------effective_degree------------------------------- |
duke@435 | 190 | // Compute effective degree for this live range. If both live ranges are |
duke@435 | 191 | // aligned-adjacent powers-of-2 then we use the MAX size. If either is |
duke@435 | 192 | // mis-aligned (or for Fat-Projections, not-adjacent) then we have to |
duke@435 | 193 | // MULTIPLY the sizes. Inspect Brigg's thesis on register pairs to see why |
duke@435 | 194 | // this is so. |
duke@435 | 195 | int PhaseIFG::effective_degree( uint lidx ) const { |
duke@435 | 196 | int eff = 0; |
duke@435 | 197 | int num_regs = lrgs(lidx).num_regs(); |
duke@435 | 198 | int fat_proj = lrgs(lidx)._fat_proj; |
duke@435 | 199 | IndexSet *s = neighbors(lidx); |
duke@435 | 200 | IndexSetIterator elements(s); |
duke@435 | 201 | uint nidx; |
duke@435 | 202 | while((nidx = elements.next()) != 0) { |
duke@435 | 203 | LRG &lrgn = lrgs(nidx); |
duke@435 | 204 | int nregs = lrgn.num_regs(); |
duke@435 | 205 | eff += (fat_proj || lrgn._fat_proj) // either is a fat-proj? |
duke@435 | 206 | ? (num_regs * nregs) // then use product |
duke@435 | 207 | : MAX2(num_regs,nregs); // else use max |
duke@435 | 208 | } |
duke@435 | 209 | return eff; |
duke@435 | 210 | } |
duke@435 | 211 | |
duke@435 | 212 | |
duke@435 | 213 | #ifndef PRODUCT |
duke@435 | 214 | //------------------------------dump------------------------------------------- |
duke@435 | 215 | void PhaseIFG::dump() const { |
duke@435 | 216 | tty->print_cr("-- Interference Graph --%s--", |
duke@435 | 217 | _is_square ? "square" : "triangular" ); |
duke@435 | 218 | if( _is_square ) { |
duke@435 | 219 | for( uint i = 0; i < _maxlrg; i++ ) { |
duke@435 | 220 | tty->print( (*_yanked)[i] ? "XX " : " "); |
duke@435 | 221 | tty->print("L%d: { ",i); |
duke@435 | 222 | IndexSetIterator elements(&_adjs[i]); |
duke@435 | 223 | uint datum; |
duke@435 | 224 | while ((datum = elements.next()) != 0) { |
duke@435 | 225 | tty->print("L%d ", datum); |
duke@435 | 226 | } |
duke@435 | 227 | tty->print_cr("}"); |
duke@435 | 228 | |
duke@435 | 229 | } |
duke@435 | 230 | return; |
duke@435 | 231 | } |
duke@435 | 232 | |
duke@435 | 233 | // Triangular |
duke@435 | 234 | for( uint i = 0; i < _maxlrg; i++ ) { |
duke@435 | 235 | uint j; |
duke@435 | 236 | tty->print( (*_yanked)[i] ? "XX " : " "); |
duke@435 | 237 | tty->print("L%d: { ",i); |
duke@435 | 238 | for( j = _maxlrg; j > i; j-- ) |
duke@435 | 239 | if( test_edge(j - 1,i) ) { |
duke@435 | 240 | tty->print("L%d ",j - 1); |
duke@435 | 241 | } |
duke@435 | 242 | tty->print("| "); |
duke@435 | 243 | IndexSetIterator elements(&_adjs[i]); |
duke@435 | 244 | uint datum; |
duke@435 | 245 | while ((datum = elements.next()) != 0) { |
duke@435 | 246 | tty->print("L%d ", datum); |
duke@435 | 247 | } |
duke@435 | 248 | tty->print("}\n"); |
duke@435 | 249 | } |
duke@435 | 250 | tty->print("\n"); |
duke@435 | 251 | } |
duke@435 | 252 | |
duke@435 | 253 | //------------------------------stats------------------------------------------ |
duke@435 | 254 | void PhaseIFG::stats() const { |
duke@435 | 255 | ResourceMark rm; |
duke@435 | 256 | int *h_cnt = NEW_RESOURCE_ARRAY(int,_maxlrg*2); |
duke@435 | 257 | memset( h_cnt, 0, sizeof(int)*_maxlrg*2 ); |
duke@435 | 258 | uint i; |
duke@435 | 259 | for( i = 0; i < _maxlrg; i++ ) { |
duke@435 | 260 | h_cnt[neighbor_cnt(i)]++; |
duke@435 | 261 | } |
duke@435 | 262 | tty->print_cr("--Histogram of counts--"); |
duke@435 | 263 | for( i = 0; i < _maxlrg*2; i++ ) |
duke@435 | 264 | if( h_cnt[i] ) |
duke@435 | 265 | tty->print("%d/%d ",i,h_cnt[i]); |
duke@435 | 266 | tty->print_cr(""); |
duke@435 | 267 | } |
duke@435 | 268 | |
duke@435 | 269 | //------------------------------verify----------------------------------------- |
duke@435 | 270 | void PhaseIFG::verify( const PhaseChaitin *pc ) const { |
duke@435 | 271 | // IFG is square, sorted and no need for Find |
duke@435 | 272 | for( uint i = 0; i < _maxlrg; i++ ) { |
duke@435 | 273 | assert(!((*_yanked)[i]) || !neighbor_cnt(i), "Is removed completely" ); |
duke@435 | 274 | IndexSet *set = &_adjs[i]; |
duke@435 | 275 | IndexSetIterator elements(set); |
duke@435 | 276 | uint idx; |
duke@435 | 277 | uint last = 0; |
duke@435 | 278 | while ((idx = elements.next()) != 0) { |
duke@435 | 279 | assert( idx != i, "Must have empty diagonal"); |
duke@435 | 280 | assert( pc->Find_const(idx) == idx, "Must not need Find" ); |
duke@435 | 281 | assert( _adjs[idx].member(i), "IFG not square" ); |
duke@435 | 282 | assert( !(*_yanked)[idx], "No yanked neighbors" ); |
duke@435 | 283 | assert( last < idx, "not sorted increasing"); |
duke@435 | 284 | last = idx; |
duke@435 | 285 | } |
duke@435 | 286 | assert( !lrgs(i)._degree_valid || |
duke@435 | 287 | effective_degree(i) == lrgs(i).degree(), "degree is valid but wrong" ); |
duke@435 | 288 | } |
duke@435 | 289 | } |
duke@435 | 290 | #endif |
duke@435 | 291 | |
duke@435 | 292 | //------------------------------interfere_with_live---------------------------- |
duke@435 | 293 | // Interfere this register with everything currently live. Use the RegMasks |
duke@435 | 294 | // to trim the set of possible interferences. Return a count of register-only |
twisti@1040 | 295 | // interferences as an estimate of register pressure. |
duke@435 | 296 | void PhaseChaitin::interfere_with_live( uint r, IndexSet *liveout ) { |
duke@435 | 297 | uint retval = 0; |
duke@435 | 298 | // Interfere with everything live. |
duke@435 | 299 | const RegMask &rm = lrgs(r).mask(); |
duke@435 | 300 | // Check for interference by checking overlap of regmasks. |
duke@435 | 301 | // Only interfere if acceptable register masks overlap. |
duke@435 | 302 | IndexSetIterator elements(liveout); |
duke@435 | 303 | uint l; |
duke@435 | 304 | while( (l = elements.next()) != 0 ) |
duke@435 | 305 | if( rm.overlap( lrgs(l).mask() ) ) |
duke@435 | 306 | _ifg->add_edge( r, l ); |
duke@435 | 307 | } |
duke@435 | 308 | |
duke@435 | 309 | //------------------------------build_ifg_virtual------------------------------ |
duke@435 | 310 | // Actually build the interference graph. Uses virtual registers only, no |
duke@435 | 311 | // physical register masks. This allows me to be very aggressive when |
duke@435 | 312 | // coalescing copies. Some of this aggressiveness will have to be undone |
duke@435 | 313 | // later, but I'd rather get all the copies I can now (since unremoved copies |
duke@435 | 314 | // at this point can end up in bad places). Copies I re-insert later I have |
duke@435 | 315 | // more opportunity to insert them in low-frequency locations. |
duke@435 | 316 | void PhaseChaitin::build_ifg_virtual( ) { |
duke@435 | 317 | |
duke@435 | 318 | // For all blocks (in any order) do... |
duke@435 | 319 | for( uint i=0; i<_cfg._num_blocks; i++ ) { |
duke@435 | 320 | Block *b = _cfg._blocks[i]; |
duke@435 | 321 | IndexSet *liveout = _live->live(b); |
duke@435 | 322 | |
duke@435 | 323 | // The IFG is built by a single reverse pass over each basic block. |
duke@435 | 324 | // Starting with the known live-out set, we remove things that get |
duke@435 | 325 | // defined and add things that become live (essentially executing one |
duke@435 | 326 | // pass of a standard LIVE analysis). Just before a Node defines a value |
duke@435 | 327 | // (and removes it from the live-ness set) that value is certainly live. |
duke@435 | 328 | // The defined value interferes with everything currently live. The |
duke@435 | 329 | // value is then removed from the live-ness set and it's inputs are |
duke@435 | 330 | // added to the live-ness set. |
duke@435 | 331 | for( uint j = b->end_idx() + 1; j > 1; j-- ) { |
duke@435 | 332 | Node *n = b->_nodes[j-1]; |
duke@435 | 333 | |
duke@435 | 334 | // Get value being defined |
duke@435 | 335 | uint r = n2lidx(n); |
duke@435 | 336 | |
duke@435 | 337 | // Some special values do not allocate |
duke@435 | 338 | if( r ) { |
duke@435 | 339 | |
duke@435 | 340 | // Remove from live-out set |
duke@435 | 341 | liveout->remove(r); |
duke@435 | 342 | |
duke@435 | 343 | // Copies do not define a new value and so do not interfere. |
duke@435 | 344 | // Remove the copies source from the liveout set before interfering. |
duke@435 | 345 | uint idx = n->is_Copy(); |
duke@435 | 346 | if( idx ) liveout->remove( n2lidx(n->in(idx)) ); |
duke@435 | 347 | |
duke@435 | 348 | // Interfere with everything live |
duke@435 | 349 | interfere_with_live( r, liveout ); |
duke@435 | 350 | } |
duke@435 | 351 | |
duke@435 | 352 | // Make all inputs live |
duke@435 | 353 | if( !n->is_Phi() ) { // Phi function uses come from prior block |
duke@435 | 354 | for( uint k = 1; k < n->req(); k++ ) |
duke@435 | 355 | liveout->insert( n2lidx(n->in(k)) ); |
duke@435 | 356 | } |
duke@435 | 357 | |
duke@435 | 358 | // 2-address instructions always have the defined value live |
duke@435 | 359 | // on entry to the instruction, even though it is being defined |
duke@435 | 360 | // by the instruction. We pretend a virtual copy sits just prior |
duke@435 | 361 | // to the instruction and kills the src-def'd register. |
duke@435 | 362 | // In other words, for 2-address instructions the defined value |
duke@435 | 363 | // interferes with all inputs. |
duke@435 | 364 | uint idx; |
duke@435 | 365 | if( n->is_Mach() && (idx = n->as_Mach()->two_adr()) ) { |
duke@435 | 366 | const MachNode *mach = n->as_Mach(); |
duke@435 | 367 | // Sometimes my 2-address ADDs are commuted in a bad way. |
duke@435 | 368 | // We generally want the USE-DEF register to refer to the |
duke@435 | 369 | // loop-varying quantity, to avoid a copy. |
duke@435 | 370 | uint op = mach->ideal_Opcode(); |
duke@435 | 371 | // Check that mach->num_opnds() == 3 to ensure instruction is |
duke@435 | 372 | // not subsuming constants, effectively excludes addI_cin_imm |
duke@435 | 373 | // Can NOT swap for instructions like addI_cin_imm since it |
duke@435 | 374 | // is adding zero to yhi + carry and the second ideal-input |
duke@435 | 375 | // points to the result of adding low-halves. |
duke@435 | 376 | // Checking req() and num_opnds() does NOT distinguish addI_cout from addI_cout_imm |
duke@435 | 377 | if( (op == Op_AddI && mach->req() == 3 && mach->num_opnds() == 3) && |
duke@435 | 378 | n->in(1)->bottom_type()->base() == Type::Int && |
duke@435 | 379 | // See if the ADD is involved in a tight data loop the wrong way |
duke@435 | 380 | n->in(2)->is_Phi() && |
duke@435 | 381 | n->in(2)->in(2) == n ) { |
duke@435 | 382 | Node *tmp = n->in(1); |
duke@435 | 383 | n->set_req( 1, n->in(2) ); |
duke@435 | 384 | n->set_req( 2, tmp ); |
duke@435 | 385 | } |
duke@435 | 386 | // Defined value interferes with all inputs |
duke@435 | 387 | uint lidx = n2lidx(n->in(idx)); |
duke@435 | 388 | for( uint k = 1; k < n->req(); k++ ) { |
duke@435 | 389 | uint kidx = n2lidx(n->in(k)); |
duke@435 | 390 | if( kidx != lidx ) |
duke@435 | 391 | _ifg->add_edge( r, kidx ); |
duke@435 | 392 | } |
duke@435 | 393 | } |
duke@435 | 394 | } // End of forall instructions in block |
duke@435 | 395 | } // End of forall blocks |
duke@435 | 396 | } |
duke@435 | 397 | |
duke@435 | 398 | //------------------------------count_int_pressure----------------------------- |
duke@435 | 399 | uint PhaseChaitin::count_int_pressure( IndexSet *liveout ) { |
duke@435 | 400 | IndexSetIterator elements(liveout); |
duke@435 | 401 | uint lidx; |
duke@435 | 402 | uint cnt = 0; |
duke@435 | 403 | while ((lidx = elements.next()) != 0) { |
duke@435 | 404 | if( lrgs(lidx).mask().is_UP() && |
duke@435 | 405 | lrgs(lidx).mask_size() && |
duke@435 | 406 | !lrgs(lidx)._is_float && |
duke@435 | 407 | lrgs(lidx).mask().overlap(*Matcher::idealreg2regmask[Op_RegI]) ) |
duke@435 | 408 | cnt += lrgs(lidx).reg_pressure(); |
duke@435 | 409 | } |
duke@435 | 410 | return cnt; |
duke@435 | 411 | } |
duke@435 | 412 | |
duke@435 | 413 | //------------------------------count_float_pressure--------------------------- |
duke@435 | 414 | uint PhaseChaitin::count_float_pressure( IndexSet *liveout ) { |
duke@435 | 415 | IndexSetIterator elements(liveout); |
duke@435 | 416 | uint lidx; |
duke@435 | 417 | uint cnt = 0; |
duke@435 | 418 | while ((lidx = elements.next()) != 0) { |
duke@435 | 419 | if( lrgs(lidx).mask().is_UP() && |
duke@435 | 420 | lrgs(lidx).mask_size() && |
duke@435 | 421 | lrgs(lidx)._is_float ) |
duke@435 | 422 | cnt += lrgs(lidx).reg_pressure(); |
duke@435 | 423 | } |
duke@435 | 424 | return cnt; |
duke@435 | 425 | } |
duke@435 | 426 | |
duke@435 | 427 | //------------------------------lower_pressure--------------------------------- |
duke@435 | 428 | // Adjust register pressure down by 1. Capture last hi-to-low transition, |
duke@435 | 429 | static void lower_pressure( LRG *lrg, uint where, Block *b, uint *pressure, uint *hrp_index ) { |
duke@435 | 430 | if( lrg->mask().is_UP() && lrg->mask_size() ) { |
duke@435 | 431 | if( lrg->_is_float ) { |
duke@435 | 432 | pressure[1] -= lrg->reg_pressure(); |
duke@435 | 433 | if( pressure[1] == (uint)FLOATPRESSURE ) { |
duke@435 | 434 | hrp_index[1] = where; |
duke@435 | 435 | #ifdef EXACT_PRESSURE |
duke@435 | 436 | if( pressure[1] > b->_freg_pressure ) |
duke@435 | 437 | b->_freg_pressure = pressure[1]+1; |
duke@435 | 438 | #else |
duke@435 | 439 | b->_freg_pressure = (uint)FLOATPRESSURE+1; |
duke@435 | 440 | #endif |
duke@435 | 441 | } |
duke@435 | 442 | } else if( lrg->mask().overlap(*Matcher::idealreg2regmask[Op_RegI]) ) { |
duke@435 | 443 | pressure[0] -= lrg->reg_pressure(); |
duke@435 | 444 | if( pressure[0] == (uint)INTPRESSURE ) { |
duke@435 | 445 | hrp_index[0] = where; |
duke@435 | 446 | #ifdef EXACT_PRESSURE |
duke@435 | 447 | if( pressure[0] > b->_reg_pressure ) |
duke@435 | 448 | b->_reg_pressure = pressure[0]+1; |
duke@435 | 449 | #else |
duke@435 | 450 | b->_reg_pressure = (uint)INTPRESSURE+1; |
duke@435 | 451 | #endif |
duke@435 | 452 | } |
duke@435 | 453 | } |
duke@435 | 454 | } |
duke@435 | 455 | } |
duke@435 | 456 | |
duke@435 | 457 | //------------------------------build_ifg_physical----------------------------- |
duke@435 | 458 | // Build the interference graph using physical registers when available. |
duke@435 | 459 | // That is, if 2 live ranges are simultaneously alive but in their acceptable |
duke@435 | 460 | // register sets do not overlap, then they do not interfere. |
duke@435 | 461 | uint PhaseChaitin::build_ifg_physical( ResourceArea *a ) { |
duke@435 | 462 | NOT_PRODUCT( Compile::TracePhase t3("buildIFG", &_t_buildIFGphysical, TimeCompiler); ) |
duke@435 | 463 | |
duke@435 | 464 | uint spill_reg = LRG::SPILL_REG; |
duke@435 | 465 | uint must_spill = 0; |
duke@435 | 466 | |
duke@435 | 467 | // For all blocks (in any order) do... |
duke@435 | 468 | for( uint i = 0; i < _cfg._num_blocks; i++ ) { |
duke@435 | 469 | Block *b = _cfg._blocks[i]; |
duke@435 | 470 | // Clone (rather than smash in place) the liveout info, so it is alive |
duke@435 | 471 | // for the "collect_gc_info" phase later. |
duke@435 | 472 | IndexSet liveout(_live->live(b)); |
duke@435 | 473 | uint last_inst = b->end_idx(); |
kvn@1001 | 474 | // Compute first nonphi node index |
kvn@1001 | 475 | uint first_inst; |
kvn@1001 | 476 | for( first_inst = 1; first_inst < last_inst; first_inst++ ) |
kvn@1001 | 477 | if( !b->_nodes[first_inst]->is_Phi() ) |
duke@435 | 478 | break; |
duke@435 | 479 | |
kvn@1001 | 480 | // Spills could be inserted before CreateEx node which should be |
kvn@1001 | 481 | // first instruction in block after Phis. Move CreateEx up. |
kvn@1001 | 482 | for( uint insidx = first_inst; insidx < last_inst; insidx++ ) { |
kvn@1001 | 483 | Node *ex = b->_nodes[insidx]; |
kvn@1001 | 484 | if( ex->is_SpillCopy() ) continue; |
kvn@1001 | 485 | if( insidx > first_inst && ex->is_Mach() && |
kvn@1001 | 486 | ex->as_Mach()->ideal_Opcode() == Op_CreateEx ) { |
kvn@1001 | 487 | // If the CreateEx isn't above all the MachSpillCopies |
kvn@1001 | 488 | // then move it to the top. |
kvn@1001 | 489 | b->_nodes.remove(insidx); |
kvn@1001 | 490 | b->_nodes.insert(first_inst, ex); |
kvn@1001 | 491 | } |
kvn@1001 | 492 | // Stop once a CreateEx or any other node is found |
kvn@1001 | 493 | break; |
kvn@1001 | 494 | } |
kvn@1001 | 495 | |
duke@435 | 496 | // Reset block's register pressure values for each ifg construction |
duke@435 | 497 | uint pressure[2], hrp_index[2]; |
duke@435 | 498 | pressure[0] = pressure[1] = 0; |
duke@435 | 499 | hrp_index[0] = hrp_index[1] = last_inst+1; |
duke@435 | 500 | b->_reg_pressure = b->_freg_pressure = 0; |
duke@435 | 501 | // Liveout things are presumed live for the whole block. We accumulate |
duke@435 | 502 | // 'area' accordingly. If they get killed in the block, we'll subtract |
duke@435 | 503 | // the unused part of the block from the area. |
kvn@1001 | 504 | int inst_count = last_inst - first_inst; |
rasbold@804 | 505 | double cost = (inst_count <= 0) ? 0.0 : b->_freq * double(inst_count); |
rasbold@804 | 506 | assert(!(cost < 0.0), "negative spill cost" ); |
duke@435 | 507 | IndexSetIterator elements(&liveout); |
duke@435 | 508 | uint lidx; |
duke@435 | 509 | while ((lidx = elements.next()) != 0) { |
duke@435 | 510 | LRG &lrg = lrgs(lidx); |
duke@435 | 511 | lrg._area += cost; |
duke@435 | 512 | // Compute initial register pressure |
duke@435 | 513 | if( lrg.mask().is_UP() && lrg.mask_size() ) { |
duke@435 | 514 | if( lrg._is_float ) { // Count float pressure |
duke@435 | 515 | pressure[1] += lrg.reg_pressure(); |
duke@435 | 516 | #ifdef EXACT_PRESSURE |
duke@435 | 517 | if( pressure[1] > b->_freg_pressure ) |
duke@435 | 518 | b->_freg_pressure = pressure[1]; |
duke@435 | 519 | #endif |
duke@435 | 520 | // Count int pressure, but do not count the SP, flags |
duke@435 | 521 | } else if( lrgs(lidx).mask().overlap(*Matcher::idealreg2regmask[Op_RegI]) ) { |
duke@435 | 522 | pressure[0] += lrg.reg_pressure(); |
duke@435 | 523 | #ifdef EXACT_PRESSURE |
duke@435 | 524 | if( pressure[0] > b->_reg_pressure ) |
duke@435 | 525 | b->_reg_pressure = pressure[0]; |
duke@435 | 526 | #endif |
duke@435 | 527 | } |
duke@435 | 528 | } |
duke@435 | 529 | } |
duke@435 | 530 | assert( pressure[0] == count_int_pressure (&liveout), "" ); |
duke@435 | 531 | assert( pressure[1] == count_float_pressure(&liveout), "" ); |
duke@435 | 532 | |
duke@435 | 533 | // The IFG is built by a single reverse pass over each basic block. |
duke@435 | 534 | // Starting with the known live-out set, we remove things that get |
duke@435 | 535 | // defined and add things that become live (essentially executing one |
duke@435 | 536 | // pass of a standard LIVE analysis). Just before a Node defines a value |
duke@435 | 537 | // (and removes it from the live-ness set) that value is certainly live. |
duke@435 | 538 | // The defined value interferes with everything currently live. The |
duke@435 | 539 | // value is then removed from the live-ness set and it's inputs are added |
duke@435 | 540 | // to the live-ness set. |
duke@435 | 541 | uint j; |
duke@435 | 542 | for( j = last_inst + 1; j > 1; j-- ) { |
duke@435 | 543 | Node *n = b->_nodes[j - 1]; |
duke@435 | 544 | |
duke@435 | 545 | // Get value being defined |
duke@435 | 546 | uint r = n2lidx(n); |
duke@435 | 547 | |
duke@435 | 548 | // Some special values do not allocate |
duke@435 | 549 | if( r ) { |
duke@435 | 550 | // A DEF normally costs block frequency; rematerialized values are |
duke@435 | 551 | // removed from the DEF sight, so LOWER costs here. |
duke@435 | 552 | lrgs(r)._cost += n->rematerialize() ? 0 : b->_freq; |
duke@435 | 553 | |
duke@435 | 554 | // If it is not live, then this instruction is dead. Probably caused |
duke@435 | 555 | // by spilling and rematerialization. Who cares why, yank this baby. |
duke@435 | 556 | if( !liveout.member(r) && n->Opcode() != Op_SafePoint ) { |
duke@435 | 557 | Node *def = n->in(0); |
duke@435 | 558 | if( !n->is_Proj() || |
duke@435 | 559 | // Could also be a flags-projection of a dead ADD or such. |
duke@435 | 560 | (n2lidx(def) && !liveout.member(n2lidx(def)) ) ) { |
duke@435 | 561 | b->_nodes.remove(j - 1); |
duke@435 | 562 | if( lrgs(r)._def == n ) lrgs(r)._def = 0; |
duke@435 | 563 | n->disconnect_inputs(NULL); |
duke@435 | 564 | _cfg._bbs.map(n->_idx,NULL); |
duke@435 | 565 | n->replace_by(C->top()); |
duke@435 | 566 | // Since yanking a Node from block, high pressure moves up one |
duke@435 | 567 | hrp_index[0]--; |
duke@435 | 568 | hrp_index[1]--; |
duke@435 | 569 | continue; |
duke@435 | 570 | } |
duke@435 | 571 | |
duke@435 | 572 | // Fat-projections kill many registers which cannot be used to |
duke@435 | 573 | // hold live ranges. |
duke@435 | 574 | if( lrgs(r)._fat_proj ) { |
duke@435 | 575 | // Count the int-only registers |
duke@435 | 576 | RegMask itmp = lrgs(r).mask(); |
duke@435 | 577 | itmp.AND(*Matcher::idealreg2regmask[Op_RegI]); |
duke@435 | 578 | int iregs = itmp.Size(); |
duke@435 | 579 | #ifdef EXACT_PRESSURE |
duke@435 | 580 | if( pressure[0]+iregs > b->_reg_pressure ) |
duke@435 | 581 | b->_reg_pressure = pressure[0]+iregs; |
duke@435 | 582 | #endif |
duke@435 | 583 | if( pressure[0] <= (uint)INTPRESSURE && |
duke@435 | 584 | pressure[0]+iregs > (uint)INTPRESSURE ) { |
duke@435 | 585 | #ifndef EXACT_PRESSURE |
duke@435 | 586 | b->_reg_pressure = (uint)INTPRESSURE+1; |
duke@435 | 587 | #endif |
duke@435 | 588 | hrp_index[0] = j-1; |
duke@435 | 589 | } |
duke@435 | 590 | // Count the float-only registers |
duke@435 | 591 | RegMask ftmp = lrgs(r).mask(); |
duke@435 | 592 | ftmp.AND(*Matcher::idealreg2regmask[Op_RegD]); |
duke@435 | 593 | int fregs = ftmp.Size(); |
duke@435 | 594 | #ifdef EXACT_PRESSURE |
duke@435 | 595 | if( pressure[1]+fregs > b->_freg_pressure ) |
duke@435 | 596 | b->_freg_pressure = pressure[1]+fregs; |
duke@435 | 597 | #endif |
duke@435 | 598 | if( pressure[1] <= (uint)FLOATPRESSURE && |
duke@435 | 599 | pressure[1]+fregs > (uint)FLOATPRESSURE ) { |
duke@435 | 600 | #ifndef EXACT_PRESSURE |
duke@435 | 601 | b->_freg_pressure = (uint)FLOATPRESSURE+1; |
duke@435 | 602 | #endif |
duke@435 | 603 | hrp_index[1] = j-1; |
duke@435 | 604 | } |
duke@435 | 605 | } |
duke@435 | 606 | |
duke@435 | 607 | } else { // Else it is live |
duke@435 | 608 | // A DEF also ends 'area' partway through the block. |
duke@435 | 609 | lrgs(r)._area -= cost; |
rasbold@804 | 610 | assert(!(lrgs(r)._area < 0.0), "negative spill area" ); |
duke@435 | 611 | |
duke@435 | 612 | // Insure high score for immediate-use spill copies so they get a color |
duke@435 | 613 | if( n->is_SpillCopy() |
never@730 | 614 | && lrgs(r).is_singledef() // MultiDef live range can still split |
duke@435 | 615 | && n->outcnt() == 1 // and use must be in this block |
duke@435 | 616 | && _cfg._bbs[n->unique_out()->_idx] == b ) { |
duke@435 | 617 | // All single-use MachSpillCopy(s) that immediately precede their |
duke@435 | 618 | // use must color early. If a longer live range steals their |
duke@435 | 619 | // color, the spill copy will split and may push another spill copy |
duke@435 | 620 | // further away resulting in an infinite spill-split-retry cycle. |
duke@435 | 621 | // Assigning a zero area results in a high score() and a good |
duke@435 | 622 | // location in the simplify list. |
duke@435 | 623 | // |
duke@435 | 624 | |
duke@435 | 625 | Node *single_use = n->unique_out(); |
duke@435 | 626 | assert( b->find_node(single_use) >= j, "Use must be later in block"); |
duke@435 | 627 | // Use can be earlier in block if it is a Phi, but then I should be a MultiDef |
duke@435 | 628 | |
duke@435 | 629 | // Find first non SpillCopy 'm' that follows the current instruction |
duke@435 | 630 | // (j - 1) is index for current instruction 'n' |
duke@435 | 631 | Node *m = n; |
duke@435 | 632 | for( uint i = j; i <= last_inst && m->is_SpillCopy(); ++i ) { m = b->_nodes[i]; } |
duke@435 | 633 | if( m == single_use ) { |
duke@435 | 634 | lrgs(r)._area = 0.0; |
duke@435 | 635 | } |
duke@435 | 636 | } |
duke@435 | 637 | |
duke@435 | 638 | // Remove from live-out set |
duke@435 | 639 | if( liveout.remove(r) ) { |
duke@435 | 640 | // Adjust register pressure. |
duke@435 | 641 | // Capture last hi-to-lo pressure transition |
duke@435 | 642 | lower_pressure( &lrgs(r), j-1, b, pressure, hrp_index ); |
duke@435 | 643 | assert( pressure[0] == count_int_pressure (&liveout), "" ); |
duke@435 | 644 | assert( pressure[1] == count_float_pressure(&liveout), "" ); |
duke@435 | 645 | } |
duke@435 | 646 | |
duke@435 | 647 | // Copies do not define a new value and so do not interfere. |
duke@435 | 648 | // Remove the copies source from the liveout set before interfering. |
duke@435 | 649 | uint idx = n->is_Copy(); |
duke@435 | 650 | if( idx ) { |
duke@435 | 651 | uint x = n2lidx(n->in(idx)); |
duke@435 | 652 | if( liveout.remove( x ) ) { |
duke@435 | 653 | lrgs(x)._area -= cost; |
duke@435 | 654 | // Adjust register pressure. |
duke@435 | 655 | lower_pressure( &lrgs(x), j-1, b, pressure, hrp_index ); |
duke@435 | 656 | assert( pressure[0] == count_int_pressure (&liveout), "" ); |
duke@435 | 657 | assert( pressure[1] == count_float_pressure(&liveout), "" ); |
duke@435 | 658 | } |
duke@435 | 659 | } |
duke@435 | 660 | } // End of if live or not |
duke@435 | 661 | |
duke@435 | 662 | // Interfere with everything live. If the defined value must |
duke@435 | 663 | // go in a particular register, just remove that register from |
duke@435 | 664 | // all conflicting parties and avoid the interference. |
duke@435 | 665 | |
duke@435 | 666 | // Make exclusions for rematerializable defs. Since rematerializable |
duke@435 | 667 | // DEFs are not bound but the live range is, some uses must be bound. |
duke@435 | 668 | // If we spill live range 'r', it can rematerialize at each use site |
duke@435 | 669 | // according to its bindings. |
duke@435 | 670 | const RegMask &rmask = lrgs(r).mask(); |
duke@435 | 671 | if( lrgs(r).is_bound() && !(n->rematerialize()) && rmask.is_NotEmpty() ) { |
duke@435 | 672 | // Smear odd bits; leave only aligned pairs of bits. |
duke@435 | 673 | RegMask r2mask = rmask; |
duke@435 | 674 | r2mask.SmearToPairs(); |
duke@435 | 675 | // Check for common case |
duke@435 | 676 | int r_size = lrgs(r).num_regs(); |
duke@435 | 677 | OptoReg::Name r_reg = (r_size == 1) ? rmask.find_first_elem() : OptoReg::Physical; |
duke@435 | 678 | |
duke@435 | 679 | IndexSetIterator elements(&liveout); |
duke@435 | 680 | uint l; |
duke@435 | 681 | while ((l = elements.next()) != 0) { |
duke@435 | 682 | LRG &lrg = lrgs(l); |
duke@435 | 683 | // If 'l' must spill already, do not further hack his bits. |
duke@435 | 684 | // He'll get some interferences and be forced to spill later. |
duke@435 | 685 | if( lrg._must_spill ) continue; |
duke@435 | 686 | // Remove bound register(s) from 'l's choices |
duke@435 | 687 | RegMask old = lrg.mask(); |
duke@435 | 688 | uint old_size = lrg.mask_size(); |
duke@435 | 689 | // Remove the bits from LRG 'r' from LRG 'l' so 'l' no |
duke@435 | 690 | // longer interferes with 'r'. If 'l' requires aligned |
duke@435 | 691 | // adjacent pairs, subtract out bit pairs. |
duke@435 | 692 | if( lrg.num_regs() == 2 && !lrg._fat_proj ) { |
duke@435 | 693 | lrg.SUBTRACT( r2mask ); |
duke@435 | 694 | lrg.compute_set_mask_size(); |
duke@435 | 695 | } else if( r_size != 1 ) { |
duke@435 | 696 | lrg.SUBTRACT( rmask ); |
duke@435 | 697 | lrg.compute_set_mask_size(); |
duke@435 | 698 | } else { // Common case: size 1 bound removal |
duke@435 | 699 | if( lrg.mask().Member(r_reg) ) { |
duke@435 | 700 | lrg.Remove(r_reg); |
duke@435 | 701 | lrg.set_mask_size(lrg.mask().is_AllStack() ? 65535:old_size-1); |
duke@435 | 702 | } |
duke@435 | 703 | } |
duke@435 | 704 | // If 'l' goes completely dry, it must spill. |
duke@435 | 705 | if( lrg.not_free() ) { |
duke@435 | 706 | // Give 'l' some kind of reasonable mask, so he picks up |
duke@435 | 707 | // interferences (and will spill later). |
duke@435 | 708 | lrg.set_mask( old ); |
duke@435 | 709 | lrg.set_mask_size(old_size); |
duke@435 | 710 | must_spill++; |
duke@435 | 711 | lrg._must_spill = 1; |
duke@435 | 712 | lrg.set_reg(OptoReg::Name(LRG::SPILL_REG)); |
duke@435 | 713 | } |
duke@435 | 714 | } |
duke@435 | 715 | } // End of if bound |
duke@435 | 716 | |
duke@435 | 717 | // Now interference with everything that is live and has |
duke@435 | 718 | // compatible register sets. |
duke@435 | 719 | interfere_with_live(r,&liveout); |
duke@435 | 720 | |
duke@435 | 721 | } // End of if normal register-allocated value |
duke@435 | 722 | |
rasbold@804 | 723 | // Area remaining in the block |
rasbold@804 | 724 | inst_count--; |
rasbold@804 | 725 | cost = (inst_count <= 0) ? 0.0 : b->_freq * double(inst_count); |
duke@435 | 726 | |
duke@435 | 727 | // Make all inputs live |
duke@435 | 728 | if( !n->is_Phi() ) { // Phi function uses come from prior block |
duke@435 | 729 | JVMState* jvms = n->jvms(); |
duke@435 | 730 | uint debug_start = jvms ? jvms->debug_start() : 999999; |
duke@435 | 731 | // Start loop at 1 (skip control edge) for most Nodes. |
duke@435 | 732 | // SCMemProj's might be the sole use of a StoreLConditional. |
duke@435 | 733 | // While StoreLConditionals set memory (the SCMemProj use) |
duke@435 | 734 | // they also def flags; if that flag def is unused the |
duke@435 | 735 | // allocator sees a flag-setting instruction with no use of |
duke@435 | 736 | // the flags and assumes it's dead. This keeps the (useless) |
duke@435 | 737 | // flag-setting behavior alive while also keeping the (useful) |
duke@435 | 738 | // memory update effect. |
duke@435 | 739 | for( uint k = ((n->Opcode() == Op_SCMemProj) ? 0:1); k < n->req(); k++ ) { |
duke@435 | 740 | Node *def = n->in(k); |
duke@435 | 741 | uint x = n2lidx(def); |
duke@435 | 742 | if( !x ) continue; |
duke@435 | 743 | LRG &lrg = lrgs(x); |
duke@435 | 744 | // No use-side cost for spilling debug info |
duke@435 | 745 | if( k < debug_start ) |
duke@435 | 746 | // A USE costs twice block frequency (once for the Load, once |
duke@435 | 747 | // for a Load-delay). Rematerialized uses only cost once. |
duke@435 | 748 | lrg._cost += (def->rematerialize() ? b->_freq : (b->_freq + b->_freq)); |
duke@435 | 749 | // It is live now |
duke@435 | 750 | if( liveout.insert( x ) ) { |
duke@435 | 751 | // Newly live things assumed live from here to top of block |
duke@435 | 752 | lrg._area += cost; |
duke@435 | 753 | // Adjust register pressure |
duke@435 | 754 | if( lrg.mask().is_UP() && lrg.mask_size() ) { |
duke@435 | 755 | if( lrg._is_float ) { |
duke@435 | 756 | pressure[1] += lrg.reg_pressure(); |
duke@435 | 757 | #ifdef EXACT_PRESSURE |
duke@435 | 758 | if( pressure[1] > b->_freg_pressure ) |
duke@435 | 759 | b->_freg_pressure = pressure[1]; |
duke@435 | 760 | #endif |
duke@435 | 761 | } else if( lrg.mask().overlap(*Matcher::idealreg2regmask[Op_RegI]) ) { |
duke@435 | 762 | pressure[0] += lrg.reg_pressure(); |
duke@435 | 763 | #ifdef EXACT_PRESSURE |
duke@435 | 764 | if( pressure[0] > b->_reg_pressure ) |
duke@435 | 765 | b->_reg_pressure = pressure[0]; |
duke@435 | 766 | #endif |
duke@435 | 767 | } |
duke@435 | 768 | } |
duke@435 | 769 | assert( pressure[0] == count_int_pressure (&liveout), "" ); |
duke@435 | 770 | assert( pressure[1] == count_float_pressure(&liveout), "" ); |
duke@435 | 771 | } |
rasbold@804 | 772 | assert(!(lrg._area < 0.0), "negative spill area" ); |
duke@435 | 773 | } |
duke@435 | 774 | } |
duke@435 | 775 | } // End of reverse pass over all instructions in block |
duke@435 | 776 | |
duke@435 | 777 | // If we run off the top of the block with high pressure and |
duke@435 | 778 | // never see a hi-to-low pressure transition, just record that |
duke@435 | 779 | // the whole block is high pressure. |
duke@435 | 780 | if( pressure[0] > (uint)INTPRESSURE ) { |
duke@435 | 781 | hrp_index[0] = 0; |
duke@435 | 782 | #ifdef EXACT_PRESSURE |
duke@435 | 783 | if( pressure[0] > b->_reg_pressure ) |
duke@435 | 784 | b->_reg_pressure = pressure[0]; |
duke@435 | 785 | #else |
duke@435 | 786 | b->_reg_pressure = (uint)INTPRESSURE+1; |
duke@435 | 787 | #endif |
duke@435 | 788 | } |
duke@435 | 789 | if( pressure[1] > (uint)FLOATPRESSURE ) { |
duke@435 | 790 | hrp_index[1] = 0; |
duke@435 | 791 | #ifdef EXACT_PRESSURE |
duke@435 | 792 | if( pressure[1] > b->_freg_pressure ) |
duke@435 | 793 | b->_freg_pressure = pressure[1]; |
duke@435 | 794 | #else |
duke@435 | 795 | b->_freg_pressure = (uint)FLOATPRESSURE+1; |
duke@435 | 796 | #endif |
duke@435 | 797 | } |
duke@435 | 798 | |
duke@435 | 799 | // Compute high pressure indice; avoid landing in the middle of projnodes |
duke@435 | 800 | j = hrp_index[0]; |
duke@435 | 801 | if( j < b->_nodes.size() && j < b->end_idx()+1 ) { |
duke@435 | 802 | Node *cur = b->_nodes[j]; |
duke@435 | 803 | while( cur->is_Proj() || (cur->is_MachNullCheck()) || cur->is_Catch() ) { |
duke@435 | 804 | j--; |
duke@435 | 805 | cur = b->_nodes[j]; |
duke@435 | 806 | } |
duke@435 | 807 | } |
duke@435 | 808 | b->_ihrp_index = j; |
duke@435 | 809 | j = hrp_index[1]; |
duke@435 | 810 | if( j < b->_nodes.size() && j < b->end_idx()+1 ) { |
duke@435 | 811 | Node *cur = b->_nodes[j]; |
duke@435 | 812 | while( cur->is_Proj() || (cur->is_MachNullCheck()) || cur->is_Catch() ) { |
duke@435 | 813 | j--; |
duke@435 | 814 | cur = b->_nodes[j]; |
duke@435 | 815 | } |
duke@435 | 816 | } |
duke@435 | 817 | b->_fhrp_index = j; |
duke@435 | 818 | |
duke@435 | 819 | #ifndef PRODUCT |
duke@435 | 820 | // Gather Register Pressure Statistics |
duke@435 | 821 | if( PrintOptoStatistics ) { |
duke@435 | 822 | if( b->_reg_pressure > (uint)INTPRESSURE || b->_freg_pressure > (uint)FLOATPRESSURE ) |
duke@435 | 823 | _high_pressure++; |
duke@435 | 824 | else |
duke@435 | 825 | _low_pressure++; |
duke@435 | 826 | } |
duke@435 | 827 | #endif |
duke@435 | 828 | } // End of for all blocks |
duke@435 | 829 | |
duke@435 | 830 | return must_spill; |
duke@435 | 831 | } |