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