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