Mercurial > hg > graal-compiler
annotate src/share/vm/opto/output.cpp @ 8804:91bf0bdae37b
8008217: CDS: Class data sharing limits the malloc heap on Solaris
Summary: In 64bit VM move CDS archive address to 32G on all platforms using new flag SharedBaseAddress. In 32bit VM set CDS archive address to 3Gb on Linux and let other OSs pick the address.
Reviewed-by: kvn, dcubed, zgu, hseigel
| author | coleenp |
|---|---|
| date | Wed, 20 Mar 2013 08:04:54 -0400 |
| parents | 2aff40cb4703 |
| children | 291ffc492eb6 f15df3af32c5 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6620
diff
changeset
|
2 * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "asm/assembler.inline.hpp" | |
| 27 #include "code/debugInfo.hpp" | |
| 28 #include "code/debugInfoRec.hpp" | |
| 29 #include "compiler/compileBroker.hpp" | |
| 30 #include "compiler/oopMap.hpp" | |
| 31 #include "memory/allocation.inline.hpp" | |
| 32 #include "opto/callnode.hpp" | |
| 33 #include "opto/cfgnode.hpp" | |
| 34 #include "opto/locknode.hpp" | |
| 35 #include "opto/machnode.hpp" | |
| 36 #include "opto/output.hpp" | |
| 37 #include "opto/regalloc.hpp" | |
| 38 #include "opto/runtime.hpp" | |
| 39 #include "opto/subnode.hpp" | |
| 40 #include "opto/type.hpp" | |
| 41 #include "runtime/handles.inline.hpp" | |
| 42 #include "utilities/xmlstream.hpp" | |
| 0 | 43 |
| 44 extern uint size_java_to_interp(); | |
| 45 extern uint reloc_java_to_interp(); | |
| 46 extern uint size_exception_handler(); | |
| 47 extern uint size_deopt_handler(); | |
| 48 | |
| 49 #ifndef PRODUCT | |
| 50 #define DEBUG_ARG(x) , x | |
| 51 #else | |
| 52 #define DEBUG_ARG(x) | |
| 53 #endif | |
| 54 | |
| 55 extern int emit_exception_handler(CodeBuffer &cbuf); | |
| 56 extern int emit_deopt_handler(CodeBuffer &cbuf); | |
| 57 | |
| 58 //------------------------------Output----------------------------------------- | |
| 59 // Convert Nodes to instruction bits and pass off to the VM | |
| 60 void Compile::Output() { | |
| 61 // RootNode goes | |
| 62 assert( _cfg->_broot->_nodes.size() == 0, "" ); | |
| 63 | |
|
859
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
707
diff
changeset
|
64 // The number of new nodes (mostly MachNop) is proportional to |
|
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
707
diff
changeset
|
65 // the number of java calls and inner loops which are aligned. |
|
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
707
diff
changeset
|
66 if ( C->check_node_count((NodeLimitFudgeFactor + C->java_calls()*3 + |
|
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
707
diff
changeset
|
67 C->inner_loops()*(OptoLoopAlignment-1)), |
|
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
707
diff
changeset
|
68 "out of nodes before code generation" ) ) { |
|
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
707
diff
changeset
|
69 return; |
|
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
707
diff
changeset
|
70 } |
| 0 | 71 // Make sure I can find the Start Node |
| 72 Block_Array& bbs = _cfg->_bbs; | |
| 73 Block *entry = _cfg->_blocks[1]; | |
| 74 Block *broot = _cfg->_broot; | |
| 75 | |
| 76 const StartNode *start = entry->_nodes[0]->as_Start(); | |
| 77 | |
| 78 // Replace StartNode with prolog | |
| 79 MachPrologNode *prolog = new (this) MachPrologNode(); | |
| 80 entry->_nodes.map( 0, prolog ); | |
| 81 bbs.map( prolog->_idx, entry ); | |
| 82 bbs.map( start->_idx, NULL ); // start is no longer in any block | |
| 83 | |
| 84 // Virtual methods need an unverified entry point | |
| 85 | |
| 86 if( is_osr_compilation() ) { | |
| 87 if( PoisonOSREntry ) { | |
| 88 // TODO: Should use a ShouldNotReachHereNode... | |
| 89 _cfg->insert( broot, 0, new (this) MachBreakpointNode() ); | |
| 90 } | |
| 91 } else { | |
| 92 if( _method && !_method->flags().is_static() ) { | |
| 93 // Insert unvalidated entry point | |
| 94 _cfg->insert( broot, 0, new (this) MachUEPNode() ); | |
| 95 } | |
| 96 | |
| 97 } | |
| 98 | |
| 99 | |
| 100 // Break before main entry point | |
| 101 if( (_method && _method->break_at_execute()) | |
| 102 #ifndef PRODUCT | |
| 103 ||(OptoBreakpoint && is_method_compilation()) | |
| 104 ||(OptoBreakpointOSR && is_osr_compilation()) | |
| 105 ||(OptoBreakpointC2R && !_method) | |
| 106 #endif | |
| 107 ) { | |
| 108 // checking for _method means that OptoBreakpoint does not apply to | |
| 109 // runtime stubs or frame converters | |
| 110 _cfg->insert( entry, 1, new (this) MachBreakpointNode() ); | |
| 111 } | |
| 112 | |
| 113 // Insert epilogs before every return | |
| 114 for( uint i=0; i<_cfg->_num_blocks; i++ ) { | |
| 115 Block *b = _cfg->_blocks[i]; | |
| 116 if( !b->is_connector() && b->non_connector_successor(0) == _cfg->_broot ) { // Found a program exit point? | |
| 117 Node *m = b->end(); | |
| 118 if( m->is_Mach() && m->as_Mach()->ideal_Opcode() != Op_Halt ) { | |
| 119 MachEpilogNode *epilog = new (this) MachEpilogNode(m->as_Mach()->ideal_Opcode() == Op_Return); | |
| 120 b->add_inst( epilog ); | |
| 121 bbs.map(epilog->_idx, b); | |
| 122 //_regalloc->set_bad(epilog->_idx); // Already initialized this way. | |
| 123 } | |
| 124 } | |
| 125 } | |
| 126 | |
| 127 # ifdef ENABLE_ZAP_DEAD_LOCALS | |
| 128 if ( ZapDeadCompiledLocals ) Insert_zap_nodes(); | |
| 129 # endif | |
| 130 | |
| 3851 | 131 uint* blk_starts = NEW_RESOURCE_ARRAY(uint,_cfg->_num_blocks+1); |
| 132 blk_starts[0] = 0; | |
| 133 | |
| 134 // Initialize code buffer and process short branches. | |
| 135 CodeBuffer* cb = init_buffer(blk_starts); | |
| 136 | |
| 137 if (cb == NULL || failing()) return; | |
| 138 | |
| 0 | 139 ScheduleAndBundle(); |
| 140 | |
| 141 #ifndef PRODUCT | |
| 142 if (trace_opto_output()) { | |
| 143 tty->print("\n---- After ScheduleAndBundle ----\n"); | |
| 144 for (uint i = 0; i < _cfg->_num_blocks; i++) { | |
| 145 tty->print("\nBB#%03d:\n", i); | |
| 146 Block *bb = _cfg->_blocks[i]; | |
| 147 for (uint j = 0; j < bb->_nodes.size(); j++) { | |
| 148 Node *n = bb->_nodes[j]; | |
| 149 OptoReg::Name reg = _regalloc->get_reg_first(n); | |
| 150 tty->print(" %-6s ", reg >= 0 && reg < REG_COUNT ? Matcher::regName[reg] : ""); | |
| 151 n->dump(); | |
| 152 } | |
| 153 } | |
| 154 } | |
| 155 #endif | |
| 156 | |
| 157 if (failing()) return; | |
| 158 | |
| 159 BuildOopMaps(); | |
| 160 | |
| 161 if (failing()) return; | |
| 162 | |
| 3851 | 163 fill_buffer(cb, blk_starts); |
| 0 | 164 } |
| 165 | |
| 166 bool Compile::need_stack_bang(int frame_size_in_bytes) const { | |
| 167 // Determine if we need to generate a stack overflow check. | |
| 168 // Do it if the method is not a stub function and | |
| 169 // has java calls or has frame size > vm_page_size/8. | |
|
4947
fd8114661503
7125136: SIGILL on linux amd64 in gc/ArrayJuggle/Juggle29
kvn
parents:
4777
diff
changeset
|
170 return (UseStackBanging && stub_function() == NULL && |
| 0 | 171 (has_java_calls() || frame_size_in_bytes > os::vm_page_size()>>3)); |
| 172 } | |
| 173 | |
| 174 bool Compile::need_register_stack_bang() const { | |
| 175 // Determine if we need to generate a register stack overflow check. | |
| 176 // This is only used on architectures which have split register | |
| 177 // and memory stacks (ie. IA64). | |
| 178 // Bang if the method is not a stub function and has java calls | |
| 179 return (stub_function() == NULL && has_java_calls()); | |
| 180 } | |
| 181 | |
| 182 # ifdef ENABLE_ZAP_DEAD_LOCALS | |
| 183 | |
| 184 | |
| 185 // In order to catch compiler oop-map bugs, we have implemented | |
| 186 // a debugging mode called ZapDeadCompilerLocals. | |
| 187 // This mode causes the compiler to insert a call to a runtime routine, | |
| 188 // "zap_dead_locals", right before each place in compiled code | |
| 189 // that could potentially be a gc-point (i.e., a safepoint or oop map point). | |
| 190 // The runtime routine checks that locations mapped as oops are really | |
| 191 // oops, that locations mapped as values do not look like oops, | |
| 192 // and that locations mapped as dead are not used later | |
| 193 // (by zapping them to an invalid address). | |
| 194 | |
| 195 int Compile::_CompiledZap_count = 0; | |
| 196 | |
| 197 void Compile::Insert_zap_nodes() { | |
| 198 bool skip = false; | |
| 199 | |
| 200 | |
| 201 // Dink with static counts because code code without the extra | |
| 202 // runtime calls is MUCH faster for debugging purposes | |
| 203 | |
| 204 if ( CompileZapFirst == 0 ) ; // nothing special | |
| 205 else if ( CompileZapFirst > CompiledZap_count() ) skip = true; | |
| 206 else if ( CompileZapFirst == CompiledZap_count() ) | |
| 207 warning("starting zap compilation after skipping"); | |
| 208 | |
| 209 if ( CompileZapLast == -1 ) ; // nothing special | |
| 210 else if ( CompileZapLast < CompiledZap_count() ) skip = true; | |
| 211 else if ( CompileZapLast == CompiledZap_count() ) | |
| 212 warning("about to compile last zap"); | |
| 213 | |
| 214 ++_CompiledZap_count; // counts skipped zaps, too | |
| 215 | |
| 216 if ( skip ) return; | |
| 217 | |
| 218 | |
| 219 if ( _method == NULL ) | |
| 220 return; // no safepoints/oopmaps emitted for calls in stubs,so we don't care | |
| 221 | |
| 222 // Insert call to zap runtime stub before every node with an oop map | |
| 223 for( uint i=0; i<_cfg->_num_blocks; i++ ) { | |
| 224 Block *b = _cfg->_blocks[i]; | |
| 225 for ( uint j = 0; j < b->_nodes.size(); ++j ) { | |
| 226 Node *n = b->_nodes[j]; | |
| 227 | |
| 228 // Determining if we should insert a zap-a-lot node in output. | |
| 229 // We do that for all nodes that has oopmap info, except for calls | |
| 230 // to allocation. Calls to allocation passes in the old top-of-eden pointer | |
| 231 // and expect the C code to reset it. Hence, there can be no safepoints between | |
| 232 // the inlined-allocation and the call to new_Java, etc. | |
| 233 // We also cannot zap monitor calls, as they must hold the microlock | |
| 234 // during the call to Zap, which also wants to grab the microlock. | |
| 235 bool insert = n->is_MachSafePoint() && (n->as_MachSafePoint()->oop_map() != NULL); | |
| 236 if ( insert ) { // it is MachSafePoint | |
| 237 if ( !n->is_MachCall() ) { | |
| 238 insert = false; | |
| 239 } else if ( n->is_MachCall() ) { | |
| 240 MachCallNode* call = n->as_MachCall(); | |
| 241 if (call->entry_point() == OptoRuntime::new_instance_Java() || | |
| 242 call->entry_point() == OptoRuntime::new_array_Java() || | |
| 243 call->entry_point() == OptoRuntime::multianewarray2_Java() || | |
| 244 call->entry_point() == OptoRuntime::multianewarray3_Java() || | |
| 245 call->entry_point() == OptoRuntime::multianewarray4_Java() || | |
| 246 call->entry_point() == OptoRuntime::multianewarray5_Java() || | |
| 247 call->entry_point() == OptoRuntime::slow_arraycopy_Java() || | |
| 248 call->entry_point() == OptoRuntime::complete_monitor_locking_Java() | |
| 249 ) { | |
| 250 insert = false; | |
| 251 } | |
| 252 } | |
| 253 if (insert) { | |
| 254 Node *zap = call_zap_node(n->as_MachSafePoint(), i); | |
| 255 b->_nodes.insert( j, zap ); | |
| 256 _cfg->_bbs.map( zap->_idx, b ); | |
| 257 ++j; | |
| 258 } | |
| 259 } | |
| 260 } | |
| 261 } | |
| 262 } | |
| 263 | |
| 264 | |
| 265 Node* Compile::call_zap_node(MachSafePointNode* node_to_check, int block_no) { | |
| 266 const TypeFunc *tf = OptoRuntime::zap_dead_locals_Type(); | |
| 267 CallStaticJavaNode* ideal_node = | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6792
diff
changeset
|
268 new (this) CallStaticJavaNode( tf, |
| 0 | 269 OptoRuntime::zap_dead_locals_stub(_method->flags().is_native()), |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6792
diff
changeset
|
270 "call zap dead locals stub", 0, TypePtr::BOTTOM); |
| 0 | 271 // We need to copy the OopMap from the site we're zapping at. |
| 272 // We have to make a copy, because the zap site might not be | |
| 273 // a call site, and zap_dead is a call site. | |
| 274 OopMap* clone = node_to_check->oop_map()->deep_copy(); | |
| 275 | |
| 276 // Add the cloned OopMap to the zap node | |
| 277 ideal_node->set_oop_map(clone); | |
| 278 return _matcher->match_sfpt(ideal_node); | |
| 279 } | |
| 280 | |
| 281 //------------------------------is_node_getting_a_safepoint-------------------- | |
| 282 bool Compile::is_node_getting_a_safepoint( Node* n) { | |
| 283 // This code duplicates the logic prior to the call of add_safepoint | |
| 284 // below in this file. | |
| 285 if( n->is_MachSafePoint() ) return true; | |
| 286 return false; | |
| 287 } | |
| 288 | |
| 289 # endif // ENABLE_ZAP_DEAD_LOCALS | |
| 290 | |
| 291 //------------------------------compute_loop_first_inst_sizes------------------ | |
| 418 | 292 // Compute the size of first NumberOfLoopInstrToAlign instructions at the top |
| 0 | 293 // of a loop. When aligning a loop we need to provide enough instructions |
| 294 // in cpu's fetch buffer to feed decoders. The loop alignment could be | |
| 295 // avoided if we have enough instructions in fetch buffer at the head of a loop. | |
| 296 // By default, the size is set to 999999 by Block's constructor so that | |
| 297 // a loop will be aligned if the size is not reset here. | |
| 298 // | |
| 299 // Note: Mach instructions could contain several HW instructions | |
| 300 // so the size is estimated only. | |
| 301 // | |
| 302 void Compile::compute_loop_first_inst_sizes() { | |
| 303 // The next condition is used to gate the loop alignment optimization. | |
| 304 // Don't aligned a loop if there are enough instructions at the head of a loop | |
| 305 // or alignment padding is larger then MaxLoopPad. By default, MaxLoopPad | |
| 306 // is equal to OptoLoopAlignment-1 except on new Intel cpus, where it is | |
| 307 // equal to 11 bytes which is the largest address NOP instruction. | |
| 308 if( MaxLoopPad < OptoLoopAlignment-1 ) { | |
| 309 uint last_block = _cfg->_num_blocks-1; | |
| 310 for( uint i=1; i <= last_block; i++ ) { | |
| 311 Block *b = _cfg->_blocks[i]; | |
| 312 // Check the first loop's block which requires an alignment. | |
| 418 | 313 if( b->loop_alignment() > (uint)relocInfo::addr_unit() ) { |
| 0 | 314 uint sum_size = 0; |
| 315 uint inst_cnt = NumberOfLoopInstrToAlign; | |
| 418 | 316 inst_cnt = b->compute_first_inst_size(sum_size, inst_cnt, _regalloc); |
| 317 | |
| 318 // Check subsequent fallthrough blocks if the loop's first | |
| 319 // block(s) does not have enough instructions. | |
| 320 Block *nb = b; | |
| 321 while( inst_cnt > 0 && | |
| 322 i < last_block && | |
| 323 !_cfg->_blocks[i+1]->has_loop_alignment() && | |
| 324 !nb->has_successor(b) ) { | |
| 325 i++; | |
| 326 nb = _cfg->_blocks[i]; | |
| 327 inst_cnt = nb->compute_first_inst_size(sum_size, inst_cnt, _regalloc); | |
| 328 } // while( inst_cnt > 0 && i < last_block ) | |
| 329 | |
| 0 | 330 b->set_first_inst_size(sum_size); |
| 331 } // f( b->head()->is_Loop() ) | |
| 332 } // for( i <= last_block ) | |
| 333 } // if( MaxLoopPad < OptoLoopAlignment-1 ) | |
| 334 } | |
| 335 | |
| 3851 | 336 //----------------------shorten_branches--------------------------------------- |
| 0 | 337 // The architecture description provides short branch variants for some long |
| 338 // branch instructions. Replace eligible long branches with short branches. | |
| 3851 | 339 void Compile::shorten_branches(uint* blk_starts, int& code_size, int& reloc_size, int& stub_size) { |
| 0 | 340 |
| 341 // ------------------ | |
| 342 // Compute size of each block, method size, and relocation information size | |
| 3851 | 343 uint nblocks = _cfg->_num_blocks; |
| 344 | |
| 345 uint* jmp_offset = NEW_RESOURCE_ARRAY(uint,nblocks); | |
| 346 uint* jmp_size = NEW_RESOURCE_ARRAY(uint,nblocks); | |
| 347 int* jmp_nidx = NEW_RESOURCE_ARRAY(int ,nblocks); | |
| 348 DEBUG_ONLY( uint *jmp_target = NEW_RESOURCE_ARRAY(uint,nblocks); ) | |
| 349 DEBUG_ONLY( uint *jmp_rule = NEW_RESOURCE_ARRAY(uint,nblocks); ) | |
| 350 | |
| 351 bool has_short_branch_candidate = false; | |
| 0 | 352 |
| 353 // Initialize the sizes to 0 | |
| 354 code_size = 0; // Size in bytes of generated code | |
| 355 stub_size = 0; // Size in bytes of all stub entries | |
| 356 // Size in bytes of all relocation entries, including those in local stubs. | |
| 357 // Start with 2-bytes of reloc info for the unvalidated entry point | |
| 358 reloc_size = 1; // Number of relocation entries | |
| 359 | |
| 360 // Make three passes. The first computes pessimistic blk_starts, | |
| 3851 | 361 // relative jmp_offset and reloc_size information. The second performs |
| 2008 | 362 // short branch substitution using the pessimistic sizing. The |
| 363 // third inserts nops where needed. | |
| 0 | 364 |
| 365 // Step one, perform a pessimistic sizing pass. | |
| 3851 | 366 uint last_call_adr = max_uint; |
| 367 uint last_avoid_back_to_back_adr = max_uint; | |
| 0 | 368 uint nop_size = (new (this) MachNopNode())->size(_regalloc); |
| 3851 | 369 for (uint i = 0; i < nblocks; i++) { // For all blocks |
| 0 | 370 Block *b = _cfg->_blocks[i]; |
| 371 | |
| 3851 | 372 // During short branch replacement, we store the relative (to blk_starts) |
| 373 // offset of jump in jmp_offset, rather than the absolute offset of jump. | |
| 374 // This is so that we do not need to recompute sizes of all nodes when | |
| 375 // we compute correct blk_starts in our next sizing pass. | |
| 376 jmp_offset[i] = 0; | |
| 377 jmp_size[i] = 0; | |
| 378 jmp_nidx[i] = -1; | |
| 379 DEBUG_ONLY( jmp_target[i] = 0; ) | |
| 380 DEBUG_ONLY( jmp_rule[i] = 0; ) | |
| 381 | |
| 0 | 382 // Sum all instruction sizes to compute block size |
| 383 uint last_inst = b->_nodes.size(); | |
| 384 uint blk_size = 0; | |
| 3851 | 385 for (uint j = 0; j < last_inst; j++) { |
| 386 Node* nj = b->_nodes[j]; | |
| 0 | 387 // Handle machine instruction nodes |
| 3851 | 388 if (nj->is_Mach()) { |
| 0 | 389 MachNode *mach = nj->as_Mach(); |
| 390 blk_size += (mach->alignment_required() - 1) * relocInfo::addr_unit(); // assume worst case padding | |
| 391 reloc_size += mach->reloc(); | |
| 392 if( mach->is_MachCall() ) { | |
| 393 MachCallNode *mcall = mach->as_MachCall(); | |
| 394 // This destination address is NOT PC-relative | |
| 395 | |
| 396 mcall->method_set((intptr_t)mcall->entry_point()); | |
| 397 | |
| 398 if( mcall->is_MachCallJava() && mcall->as_MachCallJava()->_method ) { | |
| 399 stub_size += size_java_to_interp(); | |
| 400 reloc_size += reloc_java_to_interp(); | |
| 401 } | |
| 402 } else if (mach->is_MachSafePoint()) { | |
| 403 // If call/safepoint are adjacent, account for possible | |
| 404 // nop to disambiguate the two safepoints. | |
| 3851 | 405 // ScheduleAndBundle() can rearrange nodes in a block, |
| 406 // check for all offsets inside this block. | |
| 407 if (last_call_adr >= blk_starts[i]) { | |
| 408 blk_size += nop_size; | |
| 409 } | |
| 410 } | |
| 411 if (mach->avoid_back_to_back()) { | |
| 412 // Nop is inserted between "avoid back to back" instructions. | |
| 413 // ScheduleAndBundle() can rearrange nodes in a block, | |
| 414 // check for all offsets inside this block. | |
| 415 if (last_avoid_back_to_back_adr >= blk_starts[i]) { | |
| 0 | 416 blk_size += nop_size; |
| 417 } | |
| 418 } | |
| 3851 | 419 if (mach->may_be_short_branch()) { |
|
3853
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
420 if (!nj->is_MachBranch()) { |
| 3851 | 421 #ifndef PRODUCT |
| 422 nj->dump(3); | |
| 423 #endif | |
| 424 Unimplemented(); | |
| 425 } | |
| 426 assert(jmp_nidx[i] == -1, "block should have only one branch"); | |
| 427 jmp_offset[i] = blk_size; | |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
428 jmp_size[i] = nj->size(_regalloc); |
| 3851 | 429 jmp_nidx[i] = j; |
| 430 has_short_branch_candidate = true; | |
| 431 } | |
| 0 | 432 } |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
433 blk_size += nj->size(_regalloc); |
| 0 | 434 // Remember end of call offset |
| 3842 | 435 if (nj->is_MachCall() && !nj->is_MachCallLeaf()) { |
| 3851 | 436 last_call_adr = blk_starts[i]+blk_size; |
| 437 } | |
| 438 // Remember end of avoid_back_to_back offset | |
| 439 if (nj->is_Mach() && nj->as_Mach()->avoid_back_to_back()) { | |
| 440 last_avoid_back_to_back_adr = blk_starts[i]+blk_size; | |
| 0 | 441 } |
| 442 } | |
| 443 | |
| 444 // When the next block starts a loop, we may insert pad NOP | |
| 445 // instructions. Since we cannot know our future alignment, | |
| 446 // assume the worst. | |
| 3851 | 447 if (i< nblocks-1) { |
| 0 | 448 Block *nb = _cfg->_blocks[i+1]; |
| 449 int max_loop_pad = nb->code_alignment()-relocInfo::addr_unit(); | |
| 3851 | 450 if (max_loop_pad > 0) { |
| 0 | 451 assert(is_power_of_2(max_loop_pad+relocInfo::addr_unit()), ""); |
| 452 blk_size += max_loop_pad; | |
| 453 } | |
| 454 } | |
| 455 | |
| 456 // Save block size; update total method size | |
| 457 blk_starts[i+1] = blk_starts[i]+blk_size; | |
| 458 } | |
| 459 | |
| 460 // Step two, replace eligible long jumps. | |
| 3851 | 461 bool progress = true; |
| 462 uint last_may_be_short_branch_adr = max_uint; | |
| 463 while (has_short_branch_candidate && progress) { | |
| 464 progress = false; | |
| 465 has_short_branch_candidate = false; | |
| 466 int adjust_block_start = 0; | |
| 467 for (uint i = 0; i < nblocks; i++) { | |
| 468 Block *b = _cfg->_blocks[i]; | |
| 469 int idx = jmp_nidx[i]; | |
| 470 MachNode* mach = (idx == -1) ? NULL: b->_nodes[idx]->as_Mach(); | |
| 471 if (mach != NULL && mach->may_be_short_branch()) { | |
| 472 #ifdef ASSERT | |
|
3853
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
473 assert(jmp_size[i] > 0 && mach->is_MachBranch(), "sanity"); |
| 3851 | 474 int j; |
| 475 // Find the branch; ignore trailing NOPs. | |
| 476 for (j = b->_nodes.size()-1; j>=0; j--) { | |
| 477 Node* n = b->_nodes[j]; | |
| 478 if (!n->is_Mach() || n->as_Mach()->ideal_Opcode() != Op_Con) | |
| 479 break; | |
| 480 } | |
| 481 assert(j >= 0 && j == idx && b->_nodes[j] == (Node*)mach, "sanity"); | |
| 482 #endif | |
| 483 int br_size = jmp_size[i]; | |
| 484 int br_offs = blk_starts[i] + jmp_offset[i]; | |
| 485 | |
| 0 | 486 // This requires the TRUE branch target be in succs[0] |
| 487 uint bnum = b->non_connector_successor(0)->_pre_order; | |
| 3851 | 488 int offset = blk_starts[bnum] - br_offs; |
| 489 if (bnum > i) { // adjust following block's offset | |
| 490 offset -= adjust_block_start; | |
| 491 } | |
| 492 // In the following code a nop could be inserted before | |
| 493 // the branch which will increase the backward distance. | |
| 494 bool needs_padding = ((uint)br_offs == last_may_be_short_branch_adr); | |
| 495 if (needs_padding && offset <= 0) | |
| 496 offset -= nop_size; | |
| 497 | |
| 498 if (_matcher->is_short_branch_offset(mach->rule(), br_size, offset)) { | |
| 499 // We've got a winner. Replace this branch. | |
|
3853
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
500 MachNode* replacement = mach->as_MachBranch()->short_branch_version(this); |
| 3851 | 501 |
| 502 // Update the jmp_size. | |
| 503 int new_size = replacement->size(_regalloc); | |
| 504 int diff = br_size - new_size; | |
| 505 assert(diff >= (int)nop_size, "short_branch size should be smaller"); | |
| 506 // Conservatively take into accound padding between | |
| 507 // avoid_back_to_back branches. Previous branch could be | |
| 508 // converted into avoid_back_to_back branch during next | |
| 509 // rounds. | |
| 510 if (needs_padding && replacement->avoid_back_to_back()) { | |
| 511 jmp_offset[i] += nop_size; | |
| 512 diff -= nop_size; | |
| 0 | 513 } |
| 3851 | 514 adjust_block_start += diff; |
| 515 b->_nodes.map(idx, replacement); | |
|
7196
2aff40cb4703
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
6804
diff
changeset
|
516 mach->subsume_by(replacement, C); |
| 3851 | 517 mach = replacement; |
| 518 progress = true; | |
| 519 | |
| 520 jmp_size[i] = new_size; | |
| 521 DEBUG_ONLY( jmp_target[i] = bnum; ); | |
| 522 DEBUG_ONLY( jmp_rule[i] = mach->rule(); ); | |
| 0 | 523 } else { |
| 3851 | 524 // The jump distance is not short, try again during next iteration. |
| 525 has_short_branch_candidate = true; | |
| 0 | 526 } |
| 3851 | 527 } // (mach->may_be_short_branch()) |
| 528 if (mach != NULL && (mach->may_be_short_branch() || | |
| 529 mach->avoid_back_to_back())) { | |
| 530 last_may_be_short_branch_adr = blk_starts[i] + jmp_offset[i] + jmp_size[i]; | |
| 0 | 531 } |
| 3851 | 532 blk_starts[i+1] -= adjust_block_start; |
| 0 | 533 } |
| 534 } | |
| 535 | |
| 536 #ifdef ASSERT | |
| 3851 | 537 for (uint i = 0; i < nblocks; i++) { // For all blocks |
| 538 if (jmp_target[i] != 0) { | |
| 539 int br_size = jmp_size[i]; | |
| 540 int offset = blk_starts[jmp_target[i]]-(blk_starts[i] + jmp_offset[i]); | |
| 541 if (!_matcher->is_short_branch_offset(jmp_rule[i], br_size, offset)) { | |
| 542 tty->print_cr("target (%d) - jmp_offset(%d) = offset (%d), jump_size(%d), jmp_block B%d, target_block B%d", blk_starts[jmp_target[i]], blk_starts[i] + jmp_offset[i], offset, br_size, i, jmp_target[i]); | |
| 0 | 543 } |
| 3851 | 544 assert(_matcher->is_short_branch_offset(jmp_rule[i], br_size, offset), "Displacement too large for short jmp"); |
| 0 | 545 } |
| 546 } | |
| 547 #endif | |
| 548 | |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
549 // Step 3, compute the offsets of all blocks, will be done in fill_buffer() |
| 3851 | 550 // after ScheduleAndBundle(). |
| 551 | |
| 0 | 552 // ------------------ |
| 553 // Compute size for code buffer | |
| 3851 | 554 code_size = blk_starts[nblocks]; |
| 0 | 555 |
| 556 // Relocation records | |
| 557 reloc_size += 1; // Relo entry for exception handler | |
| 558 | |
| 559 // Adjust reloc_size to number of record of relocation info | |
| 560 // Min is 2 bytes, max is probably 6 or 8, with a tax up to 25% for | |
| 561 // a relocation index. | |
| 562 // The CodeBuffer will expand the locs array if this estimate is too low. | |
| 3851 | 563 reloc_size *= 10 / sizeof(relocInfo); |
| 564 } | |
| 565 | |
| 0 | 566 //------------------------------FillLocArray----------------------------------- |
| 567 // Create a bit of debug info and append it to the array. The mapping is from | |
| 568 // Java local or expression stack to constant, register or stack-slot. For | |
| 569 // doubles, insert 2 mappings and return 1 (to tell the caller that the next | |
| 570 // entry has been taken care of and caller should skip it). | |
| 571 static LocationValue *new_loc_value( PhaseRegAlloc *ra, OptoReg::Name regnum, Location::Type l_type ) { | |
| 572 // This should never have accepted Bad before | |
| 573 assert(OptoReg::is_valid(regnum), "location must be valid"); | |
| 574 return (OptoReg::is_reg(regnum)) | |
| 575 ? new LocationValue(Location::new_reg_loc(l_type, OptoReg::as_VMReg(regnum)) ) | |
| 576 : new LocationValue(Location::new_stk_loc(l_type, ra->reg2offset(regnum))); | |
| 577 } | |
| 578 | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
579 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
580 ObjectValue* |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
581 Compile::sv_for_node_id(GrowableArray<ScopeValue*> *objs, int id) { |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
582 for (int i = 0; i < objs->length(); i++) { |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
583 assert(objs->at(i)->is_object(), "corrupt object cache"); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
584 ObjectValue* sv = (ObjectValue*) objs->at(i); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
585 if (sv->id() == id) { |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
586 return sv; |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
587 } |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
588 } |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
589 // Otherwise.. |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
590 return NULL; |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
591 } |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
592 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
593 void Compile::set_sv_for_object_node(GrowableArray<ScopeValue*> *objs, |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
594 ObjectValue* sv ) { |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
595 assert(sv_for_node_id(objs, sv->id()) == NULL, "Precondition"); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
596 objs->append(sv); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
597 } |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
598 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
599 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
600 void Compile::FillLocArray( int idx, MachSafePointNode* sfpt, Node *local, |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
601 GrowableArray<ScopeValue*> *array, |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
602 GrowableArray<ScopeValue*> *objs ) { |
| 0 | 603 assert( local, "use _top instead of null" ); |
| 604 if (array->length() != idx) { | |
| 605 assert(array->length() == idx + 1, "Unexpected array count"); | |
| 606 // Old functionality: | |
| 607 // return | |
| 608 // New functionality: | |
| 609 // Assert if the local is not top. In product mode let the new node | |
| 610 // override the old entry. | |
| 611 assert(local == top(), "LocArray collision"); | |
| 612 if (local == top()) { | |
| 613 return; | |
| 614 } | |
| 615 array->pop(); | |
| 616 } | |
| 617 const Type *t = local->bottom_type(); | |
| 618 | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
619 // Is it a safepoint scalar object node? |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
620 if (local->is_SafePointScalarObject()) { |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
621 SafePointScalarObjectNode* spobj = local->as_SafePointScalarObject(); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
622 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
623 ObjectValue* sv = Compile::sv_for_node_id(objs, spobj->_idx); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
624 if (sv == NULL) { |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
625 ciKlass* cik = t->is_oopptr()->klass(); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
626 assert(cik->is_instance_klass() || |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
627 cik->is_array_klass(), "Not supported allocation."); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
628 sv = new ObjectValue(spobj->_idx, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6620
diff
changeset
|
629 new ConstantOopWriteValue(cik->java_mirror()->constant_encoding())); |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
630 Compile::set_sv_for_object_node(objs, sv); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
631 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
632 uint first_ind = spobj->first_index(); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
633 for (uint i = 0; i < spobj->n_fields(); i++) { |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
634 Node* fld_node = sfpt->in(first_ind+i); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
635 (void)FillLocArray(sv->field_values()->length(), sfpt, fld_node, sv->field_values(), objs); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
636 } |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
637 } |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
638 array->append(sv); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
639 return; |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
640 } |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
641 |
| 0 | 642 // Grab the register number for the local |
| 643 OptoReg::Name regnum = _regalloc->get_reg_first(local); | |
| 644 if( OptoReg::is_valid(regnum) ) {// Got a register/stack? | |
| 645 // Record the double as two float registers. | |
| 646 // The register mask for such a value always specifies two adjacent | |
| 647 // float registers, with the lower register number even. | |
| 648 // Normally, the allocation of high and low words to these registers | |
| 649 // is irrelevant, because nearly all operations on register pairs | |
| 650 // (e.g., StoreD) treat them as a single unit. | |
| 651 // Here, we assume in addition that the words in these two registers | |
| 652 // stored "naturally" (by operations like StoreD and double stores | |
| 653 // within the interpreter) such that the lower-numbered register | |
| 654 // is written to the lower memory address. This may seem like | |
| 655 // a machine dependency, but it is not--it is a requirement on | |
| 656 // the author of the <arch>.ad file to ensure that, for every | |
| 657 // even/odd double-register pair to which a double may be allocated, | |
| 658 // the word in the even single-register is stored to the first | |
| 659 // memory word. (Note that register numbers are completely | |
| 660 // arbitrary, and are not tied to any machine-level encodings.) | |
| 661 #ifdef _LP64 | |
| 662 if( t->base() == Type::DoubleBot || t->base() == Type::DoubleCon ) { | |
| 663 array->append(new ConstantIntValue(0)); | |
| 664 array->append(new_loc_value( _regalloc, regnum, Location::dbl )); | |
| 665 } else if ( t->base() == Type::Long ) { | |
| 666 array->append(new ConstantIntValue(0)); | |
| 667 array->append(new_loc_value( _regalloc, regnum, Location::lng )); | |
| 668 } else if ( t->base() == Type::RawPtr ) { | |
| 669 // jsr/ret return address which must be restored into a the full | |
| 670 // width 64-bit stack slot. | |
| 671 array->append(new_loc_value( _regalloc, regnum, Location::lng )); | |
| 672 } | |
| 673 #else //_LP64 | |
| 674 #ifdef SPARC | |
| 675 if (t->base() == Type::Long && OptoReg::is_reg(regnum)) { | |
| 676 // For SPARC we have to swap high and low words for | |
| 677 // long values stored in a single-register (g0-g7). | |
| 678 array->append(new_loc_value( _regalloc, regnum , Location::normal )); | |
| 679 array->append(new_loc_value( _regalloc, OptoReg::add(regnum,1), Location::normal )); | |
| 680 } else | |
| 681 #endif //SPARC | |
| 682 if( t->base() == Type::DoubleBot || t->base() == Type::DoubleCon || t->base() == Type::Long ) { | |
| 683 // Repack the double/long as two jints. | |
| 684 // The convention the interpreter uses is that the second local | |
| 685 // holds the first raw word of the native double representation. | |
| 686 // This is actually reasonable, since locals and stack arrays | |
| 687 // grow downwards in all implementations. | |
| 688 // (If, on some machine, the interpreter's Java locals or stack | |
| 689 // were to grow upwards, the embedded doubles would be word-swapped.) | |
| 690 array->append(new_loc_value( _regalloc, OptoReg::add(regnum,1), Location::normal )); | |
| 691 array->append(new_loc_value( _regalloc, regnum , Location::normal )); | |
| 692 } | |
| 693 #endif //_LP64 | |
| 694 else if( (t->base() == Type::FloatBot || t->base() == Type::FloatCon) && | |
| 695 OptoReg::is_reg(regnum) ) { | |
|
1274
2883969d09e7
6910664: C2: java/util/Arrays/Sorting.java fails with DeoptimizeALot flag
kvn
parents:
1265
diff
changeset
|
696 array->append(new_loc_value( _regalloc, regnum, Matcher::float_in_double() |
| 0 | 697 ? Location::float_in_dbl : Location::normal )); |
| 698 } else if( t->base() == Type::Int && OptoReg::is_reg(regnum) ) { | |
| 699 array->append(new_loc_value( _regalloc, regnum, Matcher::int_in_long | |
| 700 ? Location::int_in_long : Location::normal )); | |
|
331
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
701 } else if( t->base() == Type::NarrowOop ) { |
|
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
702 array->append(new_loc_value( _regalloc, regnum, Location::narrowoop )); |
| 0 | 703 } else { |
| 704 array->append(new_loc_value( _regalloc, regnum, _regalloc->is_oop(local) ? Location::oop : Location::normal )); | |
| 705 } | |
| 706 return; | |
| 707 } | |
| 708 | |
| 709 // No register. It must be constant data. | |
| 710 switch (t->base()) { | |
| 711 case Type::Half: // Second half of a double | |
| 712 ShouldNotReachHere(); // Caller should skip 2nd halves | |
| 713 break; | |
| 714 case Type::AnyPtr: | |
| 715 array->append(new ConstantOopWriteValue(NULL)); | |
| 716 break; | |
| 717 case Type::AryPtr: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6620
diff
changeset
|
718 case Type::InstPtr: // fall through |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
903
diff
changeset
|
719 array->append(new ConstantOopWriteValue(t->isa_oopptr()->const_oop()->constant_encoding())); |
| 0 | 720 break; |
|
331
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
721 case Type::NarrowOop: |
|
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
722 if (t == TypeNarrowOop::NULL_PTR) { |
|
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
723 array->append(new ConstantOopWriteValue(NULL)); |
|
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
724 } else { |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
903
diff
changeset
|
725 array->append(new ConstantOopWriteValue(t->make_ptr()->isa_oopptr()->const_oop()->constant_encoding())); |
|
331
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
726 } |
|
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
727 break; |
| 0 | 728 case Type::Int: |
| 729 array->append(new ConstantIntValue(t->is_int()->get_con())); | |
| 730 break; | |
| 731 case Type::RawPtr: | |
| 732 // A return address (T_ADDRESS). | |
| 733 assert((intptr_t)t->is_ptr()->get_con() < (intptr_t)0x10000, "must be a valid BCI"); | |
| 734 #ifdef _LP64 | |
| 735 // Must be restored to the full-width 64-bit stack slot. | |
| 736 array->append(new ConstantLongValue(t->is_ptr()->get_con())); | |
| 737 #else | |
| 738 array->append(new ConstantIntValue(t->is_ptr()->get_con())); | |
| 739 #endif | |
| 740 break; | |
| 741 case Type::FloatCon: { | |
| 742 float f = t->is_float_constant()->getf(); | |
| 743 array->append(new ConstantIntValue(jint_cast(f))); | |
| 744 break; | |
| 745 } | |
| 746 case Type::DoubleCon: { | |
| 747 jdouble d = t->is_double_constant()->getd(); | |
| 748 #ifdef _LP64 | |
| 749 array->append(new ConstantIntValue(0)); | |
| 750 array->append(new ConstantDoubleValue(d)); | |
| 751 #else | |
| 752 // Repack the double as two jints. | |
| 753 // The convention the interpreter uses is that the second local | |
| 754 // holds the first raw word of the native double representation. | |
| 755 // This is actually reasonable, since locals and stack arrays | |
| 756 // grow downwards in all implementations. | |
| 757 // (If, on some machine, the interpreter's Java locals or stack | |
| 758 // were to grow upwards, the embedded doubles would be word-swapped.) | |
| 759 jint *dp = (jint*)&d; | |
| 760 array->append(new ConstantIntValue(dp[1])); | |
| 761 array->append(new ConstantIntValue(dp[0])); | |
| 762 #endif | |
| 763 break; | |
| 764 } | |
| 765 case Type::Long: { | |
| 766 jlong d = t->is_long()->get_con(); | |
| 767 #ifdef _LP64 | |
| 768 array->append(new ConstantIntValue(0)); | |
| 769 array->append(new ConstantLongValue(d)); | |
| 770 #else | |
| 771 // Repack the long as two jints. | |
| 772 // The convention the interpreter uses is that the second local | |
| 773 // holds the first raw word of the native double representation. | |
| 774 // This is actually reasonable, since locals and stack arrays | |
| 775 // grow downwards in all implementations. | |
| 776 // (If, on some machine, the interpreter's Java locals or stack | |
| 777 // were to grow upwards, the embedded doubles would be word-swapped.) | |
| 778 jint *dp = (jint*)&d; | |
| 779 array->append(new ConstantIntValue(dp[1])); | |
| 780 array->append(new ConstantIntValue(dp[0])); | |
| 781 #endif | |
| 782 break; | |
| 783 } | |
| 784 case Type::Top: // Add an illegal value here | |
| 785 array->append(new LocationValue(Location())); | |
| 786 break; | |
| 787 default: | |
| 788 ShouldNotReachHere(); | |
| 789 break; | |
| 790 } | |
| 791 } | |
| 792 | |
| 793 // Determine if this node starts a bundle | |
| 794 bool Compile::starts_bundle(const Node *n) const { | |
| 795 return (_node_bundling_limit > n->_idx && | |
| 796 _node_bundling_base[n->_idx].starts_bundle()); | |
| 797 } | |
| 798 | |
| 799 //--------------------------Process_OopMap_Node-------------------------------- | |
| 800 void Compile::Process_OopMap_Node(MachNode *mach, int current_offset) { | |
| 801 | |
| 802 // Handle special safepoint nodes for synchronization | |
| 803 MachSafePointNode *sfn = mach->as_MachSafePoint(); | |
| 804 MachCallNode *mcall; | |
| 805 | |
| 806 #ifdef ENABLE_ZAP_DEAD_LOCALS | |
| 807 assert( is_node_getting_a_safepoint(mach), "logic does not match; false negative"); | |
| 808 #endif | |
| 809 | |
| 810 int safepoint_pc_offset = current_offset; | |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1135
diff
changeset
|
811 bool is_method_handle_invoke = false; |
|
1253
f70b0d9ab095
6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop")
kvn
parents:
1204
diff
changeset
|
812 bool return_oop = false; |
| 0 | 813 |
| 814 // Add the safepoint in the DebugInfoRecorder | |
| 815 if( !mach->is_MachCall() ) { | |
| 816 mcall = NULL; | |
| 817 debug_info()->add_safepoint(safepoint_pc_offset, sfn->_oop_map); | |
| 818 } else { | |
| 819 mcall = mach->as_MachCall(); | |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1135
diff
changeset
|
820 |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1135
diff
changeset
|
821 // Is the call a MethodHandle call? |
| 1265 | 822 if (mcall->is_MachCallJava()) { |
| 823 if (mcall->as_MachCallJava()->_method_handle_invoke) { | |
| 824 assert(has_method_handle_invokes(), "must have been set during call generation"); | |
| 825 is_method_handle_invoke = true; | |
| 826 } | |
| 827 } | |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1135
diff
changeset
|
828 |
|
1253
f70b0d9ab095
6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop")
kvn
parents:
1204
diff
changeset
|
829 // Check if a call returns an object. |
|
f70b0d9ab095
6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop")
kvn
parents:
1204
diff
changeset
|
830 if (mcall->return_value_is_used() && |
|
f70b0d9ab095
6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop")
kvn
parents:
1204
diff
changeset
|
831 mcall->tf()->range()->field_at(TypeFunc::Parms)->isa_ptr()) { |
|
f70b0d9ab095
6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop")
kvn
parents:
1204
diff
changeset
|
832 return_oop = true; |
|
f70b0d9ab095
6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop")
kvn
parents:
1204
diff
changeset
|
833 } |
| 0 | 834 safepoint_pc_offset += mcall->ret_addr_offset(); |
| 835 debug_info()->add_safepoint(safepoint_pc_offset, mcall->_oop_map); | |
| 836 } | |
| 837 | |
| 838 // Loop over the JVMState list to add scope information | |
| 839 // Do not skip safepoints with a NULL method, they need monitor info | |
| 840 JVMState* youngest_jvms = sfn->jvms(); | |
| 841 int max_depth = youngest_jvms->depth(); | |
| 842 | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
843 // Allocate the object pool for scalar-replaced objects -- the map from |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
844 // small-integer keys (which can be recorded in the local and ostack |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
845 // arrays) to descriptions of the object state. |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
846 GrowableArray<ScopeValue*> *objs = new GrowableArray<ScopeValue*>(); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
847 |
| 0 | 848 // Visit scopes from oldest to youngest. |
| 849 for (int depth = 1; depth <= max_depth; depth++) { | |
| 850 JVMState* jvms = youngest_jvms->of_depth(depth); | |
| 851 int idx; | |
| 852 ciMethod* method = jvms->has_method() ? jvms->method() : NULL; | |
| 853 // Safepoints that do not have method() set only provide oop-map and monitor info | |
| 854 // to support GC; these do not support deoptimization. | |
| 855 int num_locs = (method == NULL) ? 0 : jvms->loc_size(); | |
| 856 int num_exps = (method == NULL) ? 0 : jvms->stk_size(); | |
| 857 int num_mon = jvms->nof_monitors(); | |
| 858 assert(method == NULL || jvms->bci() < 0 || num_locs == method->max_locals(), | |
| 859 "JVMS local count must match that of the method"); | |
| 860 | |
| 861 // Add Local and Expression Stack Information | |
| 862 | |
| 863 // Insert locals into the locarray | |
| 864 GrowableArray<ScopeValue*> *locarray = new GrowableArray<ScopeValue*>(num_locs); | |
| 865 for( idx = 0; idx < num_locs; idx++ ) { | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
866 FillLocArray( idx, sfn, sfn->local(jvms, idx), locarray, objs ); |
| 0 | 867 } |
| 868 | |
| 869 // Insert expression stack entries into the exparray | |
| 870 GrowableArray<ScopeValue*> *exparray = new GrowableArray<ScopeValue*>(num_exps); | |
| 871 for( idx = 0; idx < num_exps; idx++ ) { | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
872 FillLocArray( idx, sfn, sfn->stack(jvms, idx), exparray, objs ); |
| 0 | 873 } |
| 874 | |
| 875 // Add in mappings of the monitors | |
| 876 assert( !method || | |
| 877 !method->is_synchronized() || | |
| 878 method->is_native() || | |
| 879 num_mon > 0 || | |
| 880 !GenerateSynchronizationCode, | |
| 881 "monitors must always exist for synchronized methods"); | |
| 882 | |
| 883 // Build the growable array of ScopeValues for exp stack | |
| 884 GrowableArray<MonitorValue*> *monarray = new GrowableArray<MonitorValue*>(num_mon); | |
| 885 | |
| 886 // Loop over monitors and insert into array | |
| 887 for(idx = 0; idx < num_mon; idx++) { | |
| 888 // Grab the node that defines this monitor | |
|
460
424f9bfe6b96
6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents:
418
diff
changeset
|
889 Node* box_node = sfn->monitor_box(jvms, idx); |
|
424f9bfe6b96
6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents:
418
diff
changeset
|
890 Node* obj_node = sfn->monitor_obj(jvms, idx); |
| 0 | 891 |
| 892 // Create ScopeValue for object | |
| 893 ScopeValue *scval = NULL; | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
894 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
895 if( obj_node->is_SafePointScalarObject() ) { |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
896 SafePointScalarObjectNode* spobj = obj_node->as_SafePointScalarObject(); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
897 scval = Compile::sv_for_node_id(objs, spobj->_idx); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
898 if (scval == NULL) { |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
899 const Type *t = obj_node->bottom_type(); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
900 ciKlass* cik = t->is_oopptr()->klass(); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
901 assert(cik->is_instance_klass() || |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
902 cik->is_array_klass(), "Not supported allocation."); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
903 ObjectValue* sv = new ObjectValue(spobj->_idx, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6620
diff
changeset
|
904 new ConstantOopWriteValue(cik->java_mirror()->constant_encoding())); |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
905 Compile::set_sv_for_object_node(objs, sv); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
906 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
907 uint first_ind = spobj->first_index(); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
908 for (uint i = 0; i < spobj->n_fields(); i++) { |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
909 Node* fld_node = sfn->in(first_ind+i); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
910 (void)FillLocArray(sv->field_values()->length(), sfn, fld_node, sv->field_values(), objs); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
911 } |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
912 scval = sv; |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
913 } |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
914 } else if( !obj_node->is_Con() ) { |
| 0 | 915 OptoReg::Name obj_reg = _regalloc->get_reg_first(obj_node); |
|
331
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
916 if( obj_node->bottom_type()->base() == Type::NarrowOop ) { |
|
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
917 scval = new_loc_value( _regalloc, obj_reg, Location::narrowoop ); |
|
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
918 } else { |
|
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
919 scval = new_loc_value( _regalloc, obj_reg, Location::oop ); |
|
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
920 } |
| 0 | 921 } else { |
|
331
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
235
diff
changeset
|
922 const TypePtr *tp = obj_node->bottom_type()->make_ptr(); |
|
3400
7523488edce5
7047300: VM crashes with assert(_base == InstPtr) failed: Not an object pointer
kvn
parents:
3252
diff
changeset
|
923 scval = new ConstantOopWriteValue(tp->is_oopptr()->const_oop()->constant_encoding()); |
| 0 | 924 } |
| 925 | |
| 4777 | 926 OptoReg::Name box_reg = BoxLockNode::reg(box_node); |
|
66
6dbf1a175d6b
6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents:
63
diff
changeset
|
927 Location basic_lock = Location::new_stk_loc(Location::normal,_regalloc->reg2offset(box_reg)); |
| 4777 | 928 bool eliminated = (box_node->is_BoxLock() && box_node->as_BoxLock()->is_eliminated()); |
| 929 monarray->append(new MonitorValue(scval, basic_lock, eliminated)); | |
| 0 | 930 } |
| 931 | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
932 // We dump the object pool first, since deoptimization reads it in first. |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
933 debug_info()->dump_object_pool(objs); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
934 |
| 0 | 935 // Build first class objects to pass to scope |
| 936 DebugToken *locvals = debug_info()->create_scope_values(locarray); | |
| 937 DebugToken *expvals = debug_info()->create_scope_values(exparray); | |
| 938 DebugToken *monvals = debug_info()->create_monitor_values(monarray); | |
| 939 | |
| 940 // Make method available for all Safepoints | |
| 941 ciMethod* scope_method = method ? method : _method; | |
| 942 // Describe the scope here | |
| 943 assert(jvms->bci() >= InvocationEntryBci && jvms->bci() <= 0x10000, "must be a valid or entry BCI"); | |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
989
diff
changeset
|
944 assert(!jvms->should_reexecute() || depth == max_depth, "reexecute allowed only for the youngest"); |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
28
diff
changeset
|
945 // Now we can describe the scope. |
|
1253
f70b0d9ab095
6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop")
kvn
parents:
1204
diff
changeset
|
946 debug_info()->describe_scope(safepoint_pc_offset, scope_method, jvms->bci(), jvms->should_reexecute(), is_method_handle_invoke, return_oop, locvals, expvals, monvals); |
| 0 | 947 } // End jvms loop |
| 948 | |
| 949 // Mark the end of the scope set. | |
| 950 debug_info()->end_safepoint(safepoint_pc_offset); | |
| 951 } | |
| 952 | |
| 953 | |
| 954 | |
| 955 // A simplified version of Process_OopMap_Node, to handle non-safepoints. | |
| 956 class NonSafepointEmitter { | |
| 957 Compile* C; | |
| 958 JVMState* _pending_jvms; | |
| 959 int _pending_offset; | |
| 960 | |
| 961 void emit_non_safepoint(); | |
| 962 | |
| 963 public: | |
| 964 NonSafepointEmitter(Compile* compile) { | |
| 965 this->C = compile; | |
| 966 _pending_jvms = NULL; | |
| 967 _pending_offset = 0; | |
| 968 } | |
| 969 | |
| 970 void observe_instruction(Node* n, int pc_offset) { | |
| 971 if (!C->debug_info()->recording_non_safepoints()) return; | |
| 972 | |
| 973 Node_Notes* nn = C->node_notes_at(n->_idx); | |
| 974 if (nn == NULL || nn->jvms() == NULL) return; | |
| 975 if (_pending_jvms != NULL && | |
| 976 _pending_jvms->same_calls_as(nn->jvms())) { | |
| 977 // Repeated JVMS? Stretch it up here. | |
| 978 _pending_offset = pc_offset; | |
| 979 } else { | |
| 980 if (_pending_jvms != NULL && | |
| 981 _pending_offset < pc_offset) { | |
| 982 emit_non_safepoint(); | |
| 983 } | |
| 984 _pending_jvms = NULL; | |
| 985 if (pc_offset > C->debug_info()->last_pc_offset()) { | |
| 986 // This is the only way _pending_jvms can become non-NULL: | |
| 987 _pending_jvms = nn->jvms(); | |
| 988 _pending_offset = pc_offset; | |
| 989 } | |
| 990 } | |
| 991 } | |
| 992 | |
| 993 // Stay out of the way of real safepoints: | |
| 994 void observe_safepoint(JVMState* jvms, int pc_offset) { | |
| 995 if (_pending_jvms != NULL && | |
| 996 !_pending_jvms->same_calls_as(jvms) && | |
| 997 _pending_offset < pc_offset) { | |
| 998 emit_non_safepoint(); | |
| 999 } | |
| 1000 _pending_jvms = NULL; | |
| 1001 } | |
| 1002 | |
| 1003 void flush_at_end() { | |
| 1004 if (_pending_jvms != NULL) { | |
| 1005 emit_non_safepoint(); | |
| 1006 } | |
| 1007 _pending_jvms = NULL; | |
| 1008 } | |
| 1009 }; | |
| 1010 | |
| 1011 void NonSafepointEmitter::emit_non_safepoint() { | |
| 1012 JVMState* youngest_jvms = _pending_jvms; | |
| 1013 int pc_offset = _pending_offset; | |
| 1014 | |
| 1015 // Clear it now: | |
| 1016 _pending_jvms = NULL; | |
| 1017 | |
| 1018 DebugInformationRecorder* debug_info = C->debug_info(); | |
| 1019 assert(debug_info->recording_non_safepoints(), "sanity"); | |
| 1020 | |
| 1021 debug_info->add_non_safepoint(pc_offset); | |
| 1022 int max_depth = youngest_jvms->depth(); | |
| 1023 | |
| 1024 // Visit scopes from oldest to youngest. | |
| 1025 for (int depth = 1; depth <= max_depth; depth++) { | |
| 1026 JVMState* jvms = youngest_jvms->of_depth(depth); | |
| 1027 ciMethod* method = jvms->has_method() ? jvms->method() : NULL; | |
|
900
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
859
diff
changeset
|
1028 assert(!jvms->should_reexecute() || depth==max_depth, "reexecute allowed only for the youngest"); |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
859
diff
changeset
|
1029 debug_info->describe_scope(pc_offset, method, jvms->bci(), jvms->should_reexecute()); |
| 0 | 1030 } |
| 1031 | |
| 1032 // Mark the end of the scope set. | |
| 1033 debug_info->end_non_safepoint(pc_offset); | |
| 1034 } | |
| 1035 | |
| 1036 | |
| 1037 | |
| 3851 | 1038 // helper for fill_buffer bailout logic |
| 0 | 1039 static void turn_off_compiler(Compile* C) { |
|
2353
1c0cf339481b
7025742: Can not use CodeCache::unallocated_capacity() with fragmented CodeCache
kvn
parents:
2091
diff
changeset
|
1040 if (CodeCache::largest_free_block() >= CodeCacheMinimumFreeSpace*10) { |
| 0 | 1041 // Do not turn off compilation if a single giant method has |
| 1042 // blown the code cache size. | |
| 1043 C->record_failure("excessive request to CodeCache"); | |
| 1044 } else { | |
| 28 | 1045 // Let CompilerBroker disable further compilations. |
| 0 | 1046 C->record_failure("CodeCache is full"); |
| 1047 } | |
| 1048 } | |
| 1049 | |
| 1050 | |
| 3851 | 1051 //------------------------------init_buffer------------------------------------ |
| 1052 CodeBuffer* Compile::init_buffer(uint* blk_starts) { | |
| 0 | 1053 |
| 1054 // Set the initially allocated size | |
| 1055 int code_req = initial_code_capacity; | |
| 1056 int locs_req = initial_locs_capacity; | |
| 1057 int stub_req = TraceJumps ? initial_stub_capacity * 10 : initial_stub_capacity; | |
| 1058 int const_req = initial_const_capacity; | |
| 1059 | |
| 1060 int pad_req = NativeCall::instruction_size; | |
| 1061 // The extra spacing after the code is necessary on some platforms. | |
| 1062 // Sometimes we need to patch in a jump after the last instruction, | |
| 1063 // if the nmethod has been deoptimized. (See 4932387, 4894843.) | |
| 1064 | |
| 1065 // Compute the byte offset where we can store the deopt pc. | |
| 1066 if (fixed_slots() != 0) { | |
| 1067 _orig_pc_slot_offset_in_bytes = _regalloc->reg2offset(OptoReg::stack2reg(_orig_pc_slot)); | |
| 1068 } | |
| 1069 | |
| 1070 // Compute prolog code size | |
| 1071 _method_size = 0; | |
| 1072 _frame_slots = OptoReg::reg2stack(_matcher->_old_SP)+_regalloc->_framesize; | |
| 1073 #ifdef IA64 | |
| 1074 if (save_argument_registers()) { | |
| 1075 // 4815101: this is a stub with implicit and unknown precision fp args. | |
| 1076 // The usual spill mechanism can only generate stfd's in this case, which | |
| 1077 // doesn't work if the fp reg to spill contains a single-precision denorm. | |
| 1078 // Instead, we hack around the normal spill mechanism using stfspill's and | |
| 1079 // ldffill's in the MachProlog and MachEpilog emit methods. We allocate | |
| 1080 // space here for the fp arg regs (f8-f15) we're going to thusly spill. | |
| 1081 // | |
| 1082 // If we ever implement 16-byte 'registers' == stack slots, we can | |
| 1083 // get rid of this hack and have SpillCopy generate stfspill/ldffill | |
| 1084 // instead of stfd/stfs/ldfd/ldfs. | |
| 1085 _frame_slots += 8*(16/BytesPerInt); | |
| 1086 } | |
| 1087 #endif | |
| 3851 | 1088 assert(_frame_slots >= 0 && _frame_slots < 1000000, "sanity check"); |
| 0 | 1089 |
| 2008 | 1090 if (has_mach_constant_base_node()) { |
| 1091 // Fill the constant table. | |
| 3851 | 1092 // Note: This must happen before shorten_branches. |
| 1093 for (uint i = 0; i < _cfg->_num_blocks; i++) { | |
| 2008 | 1094 Block* b = _cfg->_blocks[i]; |
| 1095 | |
| 1096 for (uint j = 0; j < b->_nodes.size(); j++) { | |
| 1097 Node* n = b->_nodes[j]; | |
| 1098 | |
| 1099 // If the node is a MachConstantNode evaluate the constant | |
| 1100 // value section. | |
| 1101 if (n->is_MachConstant()) { | |
| 1102 MachConstantNode* machcon = n->as_MachConstant(); | |
| 1103 machcon->eval_constant(C); | |
| 1104 } | |
| 1105 } | |
| 1106 } | |
| 1107 | |
| 1108 // Calculate the offsets of the constants and the size of the | |
| 1109 // constant table (including the padding to the next section). | |
| 1110 constant_table().calculate_offsets_and_size(); | |
| 1111 const_req = constant_table().size(); | |
| 1112 } | |
| 1113 | |
| 1114 // Initialize the space for the BufferBlob used to find and verify | |
| 1115 // instruction size in MachNode::emit_size() | |
| 1116 init_scratch_buffer_blob(const_req); | |
| 3851 | 1117 if (failing()) return NULL; // Out of memory |
| 1118 | |
| 1119 // Pre-compute the length of blocks and replace | |
| 1120 // long branches with short if machine supports it. | |
| 1121 shorten_branches(blk_starts, code_req, locs_req, stub_req); | |
| 0 | 1122 |
| 1123 // nmethod and CodeBuffer count stubs & constants as part of method's code. | |
| 1124 int exception_handler_req = size_exception_handler(); | |
| 1125 int deopt_handler_req = size_deopt_handler(); | |
| 1126 exception_handler_req += MAX_stubs_size; // add marginal slop for handler | |
| 1127 deopt_handler_req += MAX_stubs_size; // add marginal slop for handler | |
| 1128 stub_req += MAX_stubs_size; // ensure per-stub margin | |
| 1129 code_req += MAX_inst_size; // ensure per-instruction margin | |
| 1265 | 1130 |
| 0 | 1131 if (StressCodeBuffers) |
| 1132 code_req = const_req = stub_req = exception_handler_req = deopt_handler_req = 0x10; // force expansion | |
| 1265 | 1133 |
| 1134 int total_req = | |
| 2008 | 1135 const_req + |
| 1265 | 1136 code_req + |
| 1137 pad_req + | |
| 1138 stub_req + | |
| 1139 exception_handler_req + | |
| 2008 | 1140 deopt_handler_req; // deopt handler |
| 1265 | 1141 |
| 1142 if (has_method_handle_invokes()) | |
| 1143 total_req += deopt_handler_req; // deopt MH handler | |
| 1144 | |
| 0 | 1145 CodeBuffer* cb = code_buffer(); |
| 1146 cb->initialize(total_req, locs_req); | |
| 1147 | |
| 1148 // Have we run out of code space? | |
| 1202 | 1149 if ((cb->blob() == NULL) || (!CompileBroker::should_compile_new_jobs())) { |
| 0 | 1150 turn_off_compiler(this); |
| 3851 | 1151 return NULL; |
| 0 | 1152 } |
| 1153 // Configure the code buffer. | |
| 1154 cb->initialize_consts_size(const_req); | |
| 1155 cb->initialize_stubs_size(stub_req); | |
| 1156 cb->initialize_oop_recorder(env()->oop_recorder()); | |
| 1157 | |
| 1158 // fill in the nop array for bundling computations | |
| 1159 MachNode *_nop_list[Bundle::_nop_count]; | |
| 1160 Bundle::initialize_nops(_nop_list, this); | |
| 1161 | |
| 3851 | 1162 return cb; |
| 1163 } | |
| 1164 | |
| 1165 //------------------------------fill_buffer------------------------------------ | |
| 1166 void Compile::fill_buffer(CodeBuffer* cb, uint* blk_starts) { | |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1167 // blk_starts[] contains offsets calculated during short branches processing, |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1168 // offsets should not be increased during following steps. |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1169 |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1170 // Compute the size of first NumberOfLoopInstrToAlign instructions at head |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1171 // of a loop. It is used to determine the padding for loop alignment. |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1172 compute_loop_first_inst_sizes(); |
| 3851 | 1173 |
| 0 | 1174 // Create oopmap set. |
| 1175 _oop_map_set = new OopMapSet(); | |
| 1176 | |
| 1177 // !!!!! This preserves old handling of oopmaps for now | |
| 1178 debug_info()->set_oopmaps(_oop_map_set); | |
| 1179 | |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1180 uint nblocks = _cfg->_num_blocks; |
| 0 | 1181 // Count and start of implicit null check instructions |
| 1182 uint inct_cnt = 0; | |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1183 uint *inct_starts = NEW_RESOURCE_ARRAY(uint, nblocks+1); |
| 0 | 1184 |
| 1185 // Count and start of calls | |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1186 uint *call_returns = NEW_RESOURCE_ARRAY(uint, nblocks+1); |
| 0 | 1187 |
| 1188 uint return_offset = 0; | |
|
859
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
707
diff
changeset
|
1189 int nop_size = (new (this) MachNopNode())->size(_regalloc); |
| 0 | 1190 |
| 1191 int previous_offset = 0; | |
| 1192 int current_offset = 0; | |
| 1193 int last_call_offset = -1; | |
| 3851 | 1194 int last_avoid_back_to_back_offset = -1; |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1195 #ifdef ASSERT |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1196 int block_alignment_padding = 0; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1197 |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1198 uint* jmp_target = NEW_RESOURCE_ARRAY(uint,nblocks); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1199 uint* jmp_offset = NEW_RESOURCE_ARRAY(uint,nblocks); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1200 uint* jmp_size = NEW_RESOURCE_ARRAY(uint,nblocks); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1201 uint* jmp_rule = NEW_RESOURCE_ARRAY(uint,nblocks); |
| 3851 | 1202 #endif |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1203 |
| 0 | 1204 // Create an array of unused labels, one for each basic block, if printing is enabled |
| 1205 #ifndef PRODUCT | |
| 1206 int *node_offsets = NULL; | |
| 3851 | 1207 uint node_offset_limit = unique(); |
| 1208 | |
| 1209 if (print_assembly()) | |
| 0 | 1210 node_offsets = NEW_RESOURCE_ARRAY(int, node_offset_limit); |
| 1211 #endif | |
| 1212 | |
| 1213 NonSafepointEmitter non_safepoints(this); // emit non-safepoints lazily | |
| 1214 | |
| 2008 | 1215 // Emit the constant table. |
| 1216 if (has_mach_constant_base_node()) { | |
| 1217 constant_table().emit(*cb); | |
| 1218 } | |
| 1219 | |
| 3851 | 1220 // Create an array of labels, one for each basic block |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1221 Label *blk_labels = NEW_RESOURCE_ARRAY(Label, nblocks+1); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1222 for (uint i=0; i <= nblocks; i++) { |
| 3851 | 1223 blk_labels[i].init(); |
| 1224 } | |
| 1225 | |
| 0 | 1226 // ------------------ |
| 1227 // Now fill in the code buffer | |
| 1228 Node *delay_slot = NULL; | |
| 1229 | |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1230 for (uint i=0; i < nblocks; i++) { |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1231 guarantee(blk_starts[i] >= (uint)cb->insts_size(),"should not increase size"); |
| 3851 | 1232 |
| 0 | 1233 Block *b = _cfg->_blocks[i]; |
| 1234 | |
| 1235 Node *head = b->head(); | |
| 1236 | |
| 1237 // If this block needs to start aligned (i.e, can be reached other | |
| 1238 // than by falling-thru from the previous block), then force the | |
| 1239 // start of a new bundle. | |
| 3851 | 1240 if (Pipeline::requires_bundling() && starts_bundle(head)) |
| 0 | 1241 cb->flush_bundle(true); |
| 1242 | |
| 3851 | 1243 #ifdef ASSERT |
| 1244 if (!b->is_connector()) { | |
| 1245 stringStream st; | |
| 1246 b->dump_head(&_cfg->_bbs, &st); | |
| 1247 MacroAssembler(cb).block_comment(st.as_string()); | |
| 1248 } | |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1249 jmp_target[i] = 0; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1250 jmp_offset[i] = 0; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1251 jmp_size[i] = 0; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1252 jmp_rule[i] = 0; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1253 |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1254 // Maximum alignment padding for loop block was used |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1255 // during first round of branches shortening, as result |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1256 // padding for nodes (sfpt after call) was not added. |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1257 // Take this into account for block's size change check |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1258 // and allow increase block's size by the difference |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1259 // of maximum and actual alignment paddings. |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1260 int orig_blk_size = blk_starts[i+1] - blk_starts[i] + block_alignment_padding; |
| 3851 | 1261 #endif |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1262 int blk_offset = current_offset; |
| 3851 | 1263 |
| 0 | 1264 // Define the label at the beginning of the basic block |
| 3851 | 1265 MacroAssembler(cb).bind(blk_labels[b->_pre_order]); |
| 0 | 1266 |
| 1267 uint last_inst = b->_nodes.size(); | |
| 1268 | |
| 1269 // Emit block normally, except for last instruction. | |
| 1270 // Emit means "dump code bits into code buffer". | |
| 3851 | 1271 for (uint j = 0; j<last_inst; j++) { |
| 0 | 1272 |
| 1273 // Get the node | |
| 1274 Node* n = b->_nodes[j]; | |
| 1275 | |
| 1276 // See if delay slots are supported | |
| 1277 if (valid_bundle_info(n) && | |
| 1278 node_bundling(n)->used_in_unconditional_delay()) { | |
| 1279 assert(delay_slot == NULL, "no use of delay slot node"); | |
| 1280 assert(n->size(_regalloc) == Pipeline::instr_unit_size(), "delay slot instruction wrong size"); | |
| 1281 | |
| 1282 delay_slot = n; | |
| 1283 continue; | |
| 1284 } | |
| 1285 | |
| 1286 // If this starts a new instruction group, then flush the current one | |
| 1287 // (but allow split bundles) | |
| 3851 | 1288 if (Pipeline::requires_bundling() && starts_bundle(n)) |
| 0 | 1289 cb->flush_bundle(false); |
| 1290 | |
| 1291 // The following logic is duplicated in the code ifdeffed for | |
| 605 | 1292 // ENABLE_ZAP_DEAD_LOCALS which appears above in this file. It |
| 0 | 1293 // should be factored out. Or maybe dispersed to the nodes? |
| 1294 | |
| 1295 // Special handling for SafePoint/Call Nodes | |
| 1296 bool is_mcall = false; | |
| 3851 | 1297 if (n->is_Mach()) { |
| 0 | 1298 MachNode *mach = n->as_Mach(); |
| 1299 is_mcall = n->is_MachCall(); | |
| 1300 bool is_sfn = n->is_MachSafePoint(); | |
| 1301 | |
| 1302 // If this requires all previous instructions be flushed, then do so | |
| 3851 | 1303 if (is_sfn || is_mcall || mach->alignment_required() != 1) { |
| 0 | 1304 cb->flush_bundle(true); |
| 1748 | 1305 current_offset = cb->insts_size(); |
| 0 | 1306 } |
| 1307 | |
| 3851 | 1308 // A padding may be needed again since a previous instruction |
| 1309 // could be moved to delay slot. | |
| 1310 | |
| 0 | 1311 // align the instruction if necessary |
| 1312 int padding = mach->compute_padding(current_offset); | |
| 1313 // Make sure safepoint node for polling is distinct from a call's | |
| 1314 // return by adding a nop if needed. | |
| 3851 | 1315 if (is_sfn && !is_mcall && padding == 0 && current_offset == last_call_offset) { |
| 0 | 1316 padding = nop_size; |
| 1317 } | |
| 3851 | 1318 if (padding == 0 && mach->avoid_back_to_back() && |
| 1319 current_offset == last_avoid_back_to_back_offset) { | |
| 1320 // Avoid back to back some instructions. | |
| 1321 padding = nop_size; | |
| 0 | 1322 } |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1323 |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1324 if(padding > 0) { |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1325 assert((padding % nop_size) == 0, "padding is not a multiple of NOP size"); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1326 int nops_cnt = padding / nop_size; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1327 MachNode *nop = new (this) MachNopNode(nops_cnt); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1328 b->_nodes.insert(j++, nop); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1329 last_inst++; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1330 _cfg->_bbs.map( nop->_idx, b ); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1331 nop->emit(*cb, _regalloc); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1332 cb->flush_bundle(true); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1333 current_offset = cb->insts_size(); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1334 } |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1335 |
| 0 | 1336 // Remember the start of the last call in a basic block |
| 1337 if (is_mcall) { | |
| 1338 MachCallNode *mcall = mach->as_MachCall(); | |
| 1339 | |
| 1340 // This destination address is NOT PC-relative | |
| 1341 mcall->method_set((intptr_t)mcall->entry_point()); | |
| 1342 | |
| 1343 // Save the return address | |
| 1344 call_returns[b->_pre_order] = current_offset + mcall->ret_addr_offset(); | |
| 1345 | |
| 3842 | 1346 if (mcall->is_MachCallLeaf()) { |
| 0 | 1347 is_mcall = false; |
| 1348 is_sfn = false; | |
| 1349 } | |
| 1350 } | |
| 1351 | |
| 1352 // sfn will be valid whenever mcall is valid now because of inheritance | |
| 3851 | 1353 if (is_sfn || is_mcall) { |
| 0 | 1354 |
| 1355 // Handle special safepoint nodes for synchronization | |
| 3851 | 1356 if (!is_mcall) { |
| 0 | 1357 MachSafePointNode *sfn = mach->as_MachSafePoint(); |
| 1358 // !!!!! Stubs only need an oopmap right now, so bail out | |
| 3851 | 1359 if (sfn->jvms()->method() == NULL) { |
| 0 | 1360 // Write the oopmap directly to the code blob??!! |
| 1361 # ifdef ENABLE_ZAP_DEAD_LOCALS | |
| 1362 assert( !is_node_getting_a_safepoint(sfn), "logic does not match; false positive"); | |
| 1363 # endif | |
| 1364 continue; | |
| 1365 } | |
| 1366 } // End synchronization | |
| 1367 | |
| 1368 non_safepoints.observe_safepoint(mach->as_MachSafePoint()->jvms(), | |
| 1369 current_offset); | |
| 1370 Process_OopMap_Node(mach, current_offset); | |
| 1371 } // End if safepoint | |
| 1372 | |
| 1373 // If this is a null check, then add the start of the previous instruction to the list | |
| 1374 else if( mach->is_MachNullCheck() ) { | |
| 1375 inct_starts[inct_cnt++] = previous_offset; | |
| 1376 } | |
| 1377 | |
| 1378 // If this is a branch, then fill in the label with the target BB's label | |
|
3853
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
1379 else if (mach->is_MachBranch()) { |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
1380 // This requires the TRUE branch target be in succs[0] |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
1381 uint block_num = b->non_connector_successor(0)->_pre_order; |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1382 |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1383 // Try to replace long branch if delay slot is not used, |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1384 // it is mostly for back branches since forward branch's |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1385 // distance is not updated yet. |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1386 bool delay_slot_is_used = valid_bundle_info(n) && |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1387 node_bundling(n)->use_unconditional_delay(); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1388 if (!delay_slot_is_used && mach->may_be_short_branch()) { |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1389 assert(delay_slot == NULL, "not expecting delay slot node"); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1390 int br_size = n->size(_regalloc); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1391 int offset = blk_starts[block_num] - current_offset; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1392 if (block_num >= i) { |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1393 // Current and following block's offset are not |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1394 // finilized yet, adjust distance by the difference |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1395 // between calculated and final offsets of current block. |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1396 offset -= (blk_starts[i] - blk_offset); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1397 } |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1398 // In the following code a nop could be inserted before |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1399 // the branch which will increase the backward distance. |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1400 bool needs_padding = (current_offset == last_avoid_back_to_back_offset); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1401 if (needs_padding && offset <= 0) |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1402 offset -= nop_size; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1403 |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1404 if (_matcher->is_short_branch_offset(mach->rule(), br_size, offset)) { |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1405 // We've got a winner. Replace this branch. |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1406 MachNode* replacement = mach->as_MachBranch()->short_branch_version(this); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1407 |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1408 // Update the jmp_size. |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1409 int new_size = replacement->size(_regalloc); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1410 assert((br_size - new_size) >= (int)nop_size, "short_branch size should be smaller"); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1411 // Insert padding between avoid_back_to_back branches. |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1412 if (needs_padding && replacement->avoid_back_to_back()) { |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1413 MachNode *nop = new (this) MachNopNode(); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1414 b->_nodes.insert(j++, nop); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1415 _cfg->_bbs.map(nop->_idx, b); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1416 last_inst++; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1417 nop->emit(*cb, _regalloc); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1418 cb->flush_bundle(true); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1419 current_offset = cb->insts_size(); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1420 } |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1421 #ifdef ASSERT |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1422 jmp_target[i] = block_num; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1423 jmp_offset[i] = current_offset - blk_offset; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1424 jmp_size[i] = new_size; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1425 jmp_rule[i] = mach->rule(); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1426 #endif |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1427 b->_nodes.map(j, replacement); |
|
7196
2aff40cb4703
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
6804
diff
changeset
|
1428 mach->subsume_by(replacement, C); |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1429 n = replacement; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1430 mach = replacement; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1431 } |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1432 } |
|
3853
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
1433 mach->as_MachBranch()->label_set( &blk_labels[block_num], block_num ); |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
1434 } else if (mach->ideal_Opcode() == Op_Jump) { |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
1435 for (uint h = 0; h < b->_num_succs; h++) { |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
1436 Block* succs_block = b->_succs[h]; |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
1437 for (uint j = 1; j < succs_block->num_preds(); j++) { |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
1438 Node* jpn = succs_block->pred(j); |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
1439 if (jpn->is_JumpProj() && jpn->in(0) == mach) { |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
1440 uint block_num = succs_block->non_connector()->_pre_order; |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
1441 Label *blkLabel = &blk_labels[block_num]; |
|
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
1442 mach->add_case_label(jpn->as_JumpProj()->proj_no(), blkLabel); |
| 0 | 1443 } |
| 1444 } | |
| 1445 } | |
| 1446 } | |
| 1447 | |
| 1448 #ifdef ASSERT | |
| 605 | 1449 // Check that oop-store precedes the card-mark |
| 3851 | 1450 else if (mach->ideal_Opcode() == Op_StoreCM) { |
| 0 | 1451 uint storeCM_idx = j; |
|
3248
e6beb62de02d
7032963: StoreCM shouldn't participate in store elimination
never
parents:
2353
diff
changeset
|
1452 int count = 0; |
|
e6beb62de02d
7032963: StoreCM shouldn't participate in store elimination
never
parents:
2353
diff
changeset
|
1453 for (uint prec = mach->req(); prec < mach->len(); prec++) { |
|
e6beb62de02d
7032963: StoreCM shouldn't participate in store elimination
never
parents:
2353
diff
changeset
|
1454 Node *oop_store = mach->in(prec); // Precedence edge |
|
e6beb62de02d
7032963: StoreCM shouldn't participate in store elimination
never
parents:
2353
diff
changeset
|
1455 if (oop_store == NULL) continue; |
|
e6beb62de02d
7032963: StoreCM shouldn't participate in store elimination
never
parents:
2353
diff
changeset
|
1456 count++; |
|
e6beb62de02d
7032963: StoreCM shouldn't participate in store elimination
never
parents:
2353
diff
changeset
|
1457 uint i4; |
|
e6beb62de02d
7032963: StoreCM shouldn't participate in store elimination
never
parents:
2353
diff
changeset
|
1458 for( i4 = 0; i4 < last_inst; ++i4 ) { |
|
e6beb62de02d
7032963: StoreCM shouldn't participate in store elimination
never
parents:
2353
diff
changeset
|
1459 if( b->_nodes[i4] == oop_store ) break; |
|
e6beb62de02d
7032963: StoreCM shouldn't participate in store elimination
never
parents:
2353
diff
changeset
|
1460 } |
|
e6beb62de02d
7032963: StoreCM shouldn't participate in store elimination
never
parents:
2353
diff
changeset
|
1461 // Note: This test can provide a false failure if other precedence |
|
e6beb62de02d
7032963: StoreCM shouldn't participate in store elimination
never
parents:
2353
diff
changeset
|
1462 // edges have been added to the storeCMNode. |
|
e6beb62de02d
7032963: StoreCM shouldn't participate in store elimination
never
parents:
2353
diff
changeset
|
1463 assert( i4 == last_inst || i4 < storeCM_idx, "CM card-mark executes before oop-store"); |
| 0 | 1464 } |
|
3248
e6beb62de02d
7032963: StoreCM shouldn't participate in store elimination
never
parents:
2353
diff
changeset
|
1465 assert(count > 0, "storeCM expects at least one precedence edge"); |
| 0 | 1466 } |
| 1467 #endif | |
| 1468 | |
| 3851 | 1469 else if (!n->is_Proj()) { |
| 605 | 1470 // Remember the beginning of the previous instruction, in case |
| 0 | 1471 // it's followed by a flag-kill and a null-check. Happens on |
| 1472 // Intel all the time, with add-to-memory kind of opcodes. | |
| 1473 previous_offset = current_offset; | |
| 1474 } | |
| 1475 } | |
| 1476 | |
| 1477 // Verify that there is sufficient space remaining | |
| 1478 cb->insts()->maybe_expand_to_ensure_remaining(MAX_inst_size); | |
| 1202 | 1479 if ((cb->blob() == NULL) || (!CompileBroker::should_compile_new_jobs())) { |
| 0 | 1480 turn_off_compiler(this); |
| 1481 return; | |
| 1482 } | |
| 1483 | |
| 1484 // Save the offset for the listing | |
| 1485 #ifndef PRODUCT | |
| 3851 | 1486 if (node_offsets && n->_idx < node_offset_limit) |
| 1748 | 1487 node_offsets[n->_idx] = cb->insts_size(); |
| 0 | 1488 #endif |
| 1489 | |
| 1490 // "Normal" instruction case | |
| 3851 | 1491 DEBUG_ONLY( uint instr_offset = cb->insts_size(); ) |
| 0 | 1492 n->emit(*cb, _regalloc); |
| 1748 | 1493 current_offset = cb->insts_size(); |
| 3851 | 1494 |
| 1495 #ifdef ASSERT | |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1496 if (n->size(_regalloc) < (current_offset-instr_offset)) { |
| 3851 | 1497 n->dump(); |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1498 assert(false, "wrong size of mach node"); |
| 3851 | 1499 } |
| 1500 #endif | |
| 0 | 1501 non_safepoints.observe_instruction(n, current_offset); |
| 1502 | |
| 1503 // mcall is last "call" that can be a safepoint | |
| 1504 // record it so we can see if a poll will directly follow it | |
| 1505 // in which case we'll need a pad to make the PcDesc sites unique | |
| 1506 // see 5010568. This can be slightly inaccurate but conservative | |
| 1507 // in the case that return address is not actually at current_offset. | |
| 1508 // This is a small price to pay. | |
| 1509 | |
| 1510 if (is_mcall) { | |
| 1511 last_call_offset = current_offset; | |
| 1512 } | |
| 1513 | |
| 3851 | 1514 if (n->is_Mach() && n->as_Mach()->avoid_back_to_back()) { |
| 1515 // Avoid back to back some instructions. | |
| 1516 last_avoid_back_to_back_offset = current_offset; | |
| 1517 } | |
| 1518 | |
| 0 | 1519 // See if this instruction has a delay slot |
| 3851 | 1520 if (valid_bundle_info(n) && node_bundling(n)->use_unconditional_delay()) { |
| 0 | 1521 assert(delay_slot != NULL, "expecting delay slot node"); |
| 1522 | |
| 1523 // Back up 1 instruction | |
| 1748 | 1524 cb->set_insts_end(cb->insts_end() - Pipeline::instr_unit_size()); |
| 0 | 1525 |
| 1526 // Save the offset for the listing | |
| 1527 #ifndef PRODUCT | |
| 3851 | 1528 if (node_offsets && delay_slot->_idx < node_offset_limit) |
| 1748 | 1529 node_offsets[delay_slot->_idx] = cb->insts_size(); |
| 0 | 1530 #endif |
| 1531 | |
| 1532 // Support a SafePoint in the delay slot | |
| 3851 | 1533 if (delay_slot->is_MachSafePoint()) { |
| 0 | 1534 MachNode *mach = delay_slot->as_Mach(); |
| 1535 // !!!!! Stubs only need an oopmap right now, so bail out | |
| 3851 | 1536 if (!mach->is_MachCall() && mach->as_MachSafePoint()->jvms()->method() == NULL) { |
| 0 | 1537 // Write the oopmap directly to the code blob??!! |
| 1538 # ifdef ENABLE_ZAP_DEAD_LOCALS | |
| 1539 assert( !is_node_getting_a_safepoint(mach), "logic does not match; false positive"); | |
| 1540 # endif | |
| 1541 delay_slot = NULL; | |
| 1542 continue; | |
| 1543 } | |
| 1544 | |
| 1545 int adjusted_offset = current_offset - Pipeline::instr_unit_size(); | |
| 1546 non_safepoints.observe_safepoint(mach->as_MachSafePoint()->jvms(), | |
| 1547 adjusted_offset); | |
| 1548 // Generate an OopMap entry | |
| 1549 Process_OopMap_Node(mach, adjusted_offset); | |
| 1550 } | |
| 1551 | |
| 1552 // Insert the delay slot instruction | |
| 1553 delay_slot->emit(*cb, _regalloc); | |
| 1554 | |
| 1555 // Don't reuse it | |
| 1556 delay_slot = NULL; | |
| 1557 } | |
| 1558 | |
| 1559 } // End for all instructions in block | |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1560 assert((uint)blk_offset <= blk_starts[i], "shouldn't increase distance"); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1561 blk_starts[i] = blk_offset; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1562 |
| 418 | 1563 // If the next block is the top of a loop, pad this block out to align |
| 1564 // the loop top a little. Helps prevent pipe stalls at loop back branches. | |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1565 if (i < nblocks-1) { |
| 0 | 1566 Block *nb = _cfg->_blocks[i+1]; |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1567 int padding = nb->alignment_padding(current_offset); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1568 if( padding > 0 ) { |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1569 MachNode *nop = new (this) MachNopNode(padding / nop_size); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1570 b->_nodes.insert( b->_nodes.size(), nop ); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1571 _cfg->_bbs.map( nop->_idx, b ); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1572 nop->emit(*cb, _regalloc); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1573 current_offset = cb->insts_size(); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1574 } |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1575 #ifdef ASSERT |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1576 int max_loop_pad = nb->code_alignment()-relocInfo::addr_unit(); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1577 block_alignment_padding = (max_loop_pad - padding); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1578 assert(block_alignment_padding >= 0, "sanity"); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1579 #endif |
| 0 | 1580 } |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1581 // Verify that the distance for generated before forward |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1582 // short branches is still valid. |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1583 assert(orig_blk_size >= (current_offset - blk_offset), "shouldn't increase block size"); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1584 |
| 0 | 1585 } // End of for all blocks |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1586 blk_starts[nblocks] = current_offset; |
| 0 | 1587 |
| 1588 non_safepoints.flush_at_end(); | |
| 1589 | |
| 1590 // Offset too large? | |
| 1591 if (failing()) return; | |
| 1592 | |
| 1593 // Define a pseudo-label at the end of the code | |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1594 MacroAssembler(cb).bind( blk_labels[nblocks] ); |
| 0 | 1595 |
| 1596 // Compute the size of the first block | |
| 1597 _first_block_size = blk_labels[1].loc_pos() - blk_labels[0].loc_pos(); | |
| 1598 | |
| 1748 | 1599 assert(cb->insts_size() < 500000, "method is unreasonably large"); |
| 0 | 1600 |
|
3857
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1601 #ifdef ASSERT |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1602 for (uint i = 0; i < nblocks; i++) { // For all blocks |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1603 if (jmp_target[i] != 0) { |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1604 int br_size = jmp_size[i]; |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1605 int offset = blk_starts[jmp_target[i]]-(blk_starts[i] + jmp_offset[i]); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1606 if (!_matcher->is_short_branch_offset(jmp_rule[i], br_size, offset)) { |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1607 tty->print_cr("target (%d) - jmp_offset(%d) = offset (%d), jump_size(%d), jmp_block B%d, target_block B%d", blk_starts[jmp_target[i]], blk_starts[i] + jmp_offset[i], offset, br_size, i, jmp_target[i]); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1608 assert(false, "Displacement too large for short jmp"); |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1609 } |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1610 } |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1611 } |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1612 #endif |
|
739a9abbbd4b
7080431: VM asserts if specified size(x) in .ad is larger than emitted size
kvn
parents:
3853
diff
changeset
|
1613 |
| 0 | 1614 // ------------------ |
| 1615 | |
| 1616 #ifndef PRODUCT | |
| 1617 // Information on the size of the method, without the extraneous code | |
| 1748 | 1618 Scheduling::increment_method_size(cb->insts_size()); |
| 0 | 1619 #endif |
| 1620 | |
| 1621 // ------------------ | |
| 1622 // Fill in exception table entries. | |
| 1623 FillExceptionTables(inct_cnt, call_returns, inct_starts, blk_labels); | |
| 1624 | |
| 1625 // Only java methods have exception handlers and deopt handlers | |
| 1626 if (_method) { | |
| 1627 // Emit the exception handler code. | |
| 1628 _code_offsets.set_value(CodeOffsets::Exceptions, emit_exception_handler(*cb)); | |
| 1629 // Emit the deopt handler code. | |
| 1630 _code_offsets.set_value(CodeOffsets::Deopt, emit_deopt_handler(*cb)); | |
| 1265 | 1631 |
| 1632 // Emit the MethodHandle deopt handler code (if required). | |
| 1633 if (has_method_handle_invokes()) { | |
| 1634 // We can use the same code as for the normal deopt handler, we | |
| 1635 // just need a different entry point address. | |
| 1636 _code_offsets.set_value(CodeOffsets::DeoptMH, emit_deopt_handler(*cb)); | |
| 1637 } | |
| 0 | 1638 } |
| 1639 | |
| 1640 // One last check for failed CodeBuffer::expand: | |
| 1202 | 1641 if ((cb->blob() == NULL) || (!CompileBroker::should_compile_new_jobs())) { |
| 0 | 1642 turn_off_compiler(this); |
| 1643 return; | |
| 1644 } | |
| 1645 | |
| 1646 #ifndef PRODUCT | |
| 1647 // Dump the assembly code, including basic-block numbers | |
| 1648 if (print_assembly()) { | |
| 1649 ttyLocker ttyl; // keep the following output all in one block | |
| 1650 if (!VMThread::should_terminate()) { // test this under the tty lock | |
| 1651 // This output goes directly to the tty, not the compiler log. | |
| 1652 // To enable tools to match it up with the compilation activity, | |
| 1653 // be sure to tag this tty output with the compile ID. | |
| 1654 if (xtty != NULL) { | |
| 1655 xtty->head("opto_assembly compile_id='%d'%s", compile_id(), | |
| 1656 is_osr_compilation() ? " compile_kind='osr'" : | |
| 1657 ""); | |
| 1658 } | |
| 1659 if (method() != NULL) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6620
diff
changeset
|
1660 method()->print_metadata(); |
| 0 | 1661 } |
| 1662 dump_asm(node_offsets, node_offset_limit); | |
| 1663 if (xtty != NULL) { | |
| 1664 xtty->tail("opto_assembly"); | |
| 1665 } | |
| 1666 } | |
| 1667 } | |
| 1668 #endif | |
| 1669 | |
| 1670 } | |
| 1671 | |
| 1672 void Compile::FillExceptionTables(uint cnt, uint *call_returns, uint *inct_starts, Label *blk_labels) { | |
| 1673 _inc_table.set_size(cnt); | |
| 1674 | |
| 1675 uint inct_cnt = 0; | |
| 1676 for( uint i=0; i<_cfg->_num_blocks; i++ ) { | |
| 1677 Block *b = _cfg->_blocks[i]; | |
| 1678 Node *n = NULL; | |
| 1679 int j; | |
| 1680 | |
| 1681 // Find the branch; ignore trailing NOPs. | |
| 1682 for( j = b->_nodes.size()-1; j>=0; j-- ) { | |
| 1683 n = b->_nodes[j]; | |
| 1684 if( !n->is_Mach() || n->as_Mach()->ideal_Opcode() != Op_Con ) | |
| 1685 break; | |
| 1686 } | |
| 1687 | |
| 1688 // If we didn't find anything, continue | |
| 1689 if( j < 0 ) continue; | |
| 1690 | |
| 1691 // Compute ExceptionHandlerTable subtable entry and add it | |
| 1692 // (skip empty blocks) | |
| 1693 if( n->is_Catch() ) { | |
| 1694 | |
| 1695 // Get the offset of the return from the call | |
| 1696 uint call_return = call_returns[b->_pre_order]; | |
| 1697 #ifdef ASSERT | |
| 1698 assert( call_return > 0, "no call seen for this basic block" ); | |
| 3842 | 1699 while( b->_nodes[--j]->is_MachProj() ) ; |
| 1700 assert( b->_nodes[j]->is_MachCall(), "CatchProj must follow call" ); | |
| 0 | 1701 #endif |
| 1702 // last instruction is a CatchNode, find it's CatchProjNodes | |
| 1703 int nof_succs = b->_num_succs; | |
| 1704 // allocate space | |
| 1705 GrowableArray<intptr_t> handler_bcis(nof_succs); | |
| 1706 GrowableArray<intptr_t> handler_pcos(nof_succs); | |
| 1707 // iterate through all successors | |
| 1708 for (int j = 0; j < nof_succs; j++) { | |
| 1709 Block* s = b->_succs[j]; | |
| 1710 bool found_p = false; | |
| 1711 for( uint k = 1; k < s->num_preds(); k++ ) { | |
| 1712 Node *pk = s->pred(k); | |
| 1713 if( pk->is_CatchProj() && pk->in(0) == n ) { | |
| 1714 const CatchProjNode* p = pk->as_CatchProj(); | |
| 1715 found_p = true; | |
| 1716 // add the corresponding handler bci & pco information | |
| 1717 if( p->_con != CatchProjNode::fall_through_index ) { | |
| 1718 // p leads to an exception handler (and is not fall through) | |
| 1719 assert(s == _cfg->_blocks[s->_pre_order],"bad numbering"); | |
| 1720 // no duplicates, please | |
| 1721 if( !handler_bcis.contains(p->handler_bci()) ) { | |
| 1722 uint block_num = s->non_connector()->_pre_order; | |
| 1723 handler_bcis.append(p->handler_bci()); | |
| 1724 handler_pcos.append(blk_labels[block_num].loc_pos()); | |
| 1725 } | |
| 1726 } | |
| 1727 } | |
| 1728 } | |
| 1729 assert(found_p, "no matching predecessor found"); | |
| 1730 // Note: Due to empty block removal, one block may have | |
| 1731 // several CatchProj inputs, from the same Catch. | |
| 1732 } | |
| 1733 | |
| 1734 // Set the offset of the return from the call | |
| 1735 _handler_table.add_subtable(call_return, &handler_bcis, NULL, &handler_pcos); | |
| 1736 continue; | |
| 1737 } | |
| 1738 | |
| 1739 // Handle implicit null exception table updates | |
| 1740 if( n->is_MachNullCheck() ) { | |
| 1741 uint block_num = b->non_connector_successor(0)->_pre_order; | |
| 1742 _inc_table.append( inct_starts[inct_cnt++], blk_labels[block_num].loc_pos() ); | |
| 1743 continue; | |
| 1744 } | |
| 1745 } // End of for all blocks fill in exception table entries | |
| 1746 } | |
| 1747 | |
| 1748 // Static Variables | |
| 1749 #ifndef PRODUCT | |
| 1750 uint Scheduling::_total_nop_size = 0; | |
| 1751 uint Scheduling::_total_method_size = 0; | |
| 1752 uint Scheduling::_total_branches = 0; | |
| 1753 uint Scheduling::_total_unconditional_delays = 0; | |
| 1754 uint Scheduling::_total_instructions_per_bundle[Pipeline::_max_instrs_per_cycle+1]; | |
| 1755 #endif | |
| 1756 | |
| 1757 // Initializer for class Scheduling | |
| 1758 | |
| 1759 Scheduling::Scheduling(Arena *arena, Compile &compile) | |
| 1760 : _arena(arena), | |
| 1761 _cfg(compile.cfg()), | |
| 1762 _bbs(compile.cfg()->_bbs), | |
| 1763 _regalloc(compile.regalloc()), | |
| 1764 _reg_node(arena), | |
| 1765 _bundle_instr_count(0), | |
| 1766 _bundle_cycle_number(0), | |
| 1767 _scheduled(arena), | |
| 1768 _available(arena), | |
| 1769 _next_node(NULL), | |
| 1770 _bundle_use(0, 0, resource_count, &_bundle_use_elements[0]), | |
| 1771 _pinch_free_list(arena) | |
| 1772 #ifndef PRODUCT | |
| 1773 , _branches(0) | |
| 1774 , _unconditional_delays(0) | |
| 1775 #endif | |
| 1776 { | |
| 1777 // Create a MachNopNode | |
| 1778 _nop = new (&compile) MachNopNode(); | |
| 1779 | |
| 1780 // Now that the nops are in the array, save the count | |
| 1781 // (but allow entries for the nops) | |
| 1782 _node_bundling_limit = compile.unique(); | |
| 1783 uint node_max = _regalloc->node_regs_max_index(); | |
| 1784 | |
| 1785 compile.set_node_bundling_limit(_node_bundling_limit); | |
| 1786 | |
| 605 | 1787 // This one is persistent within the Compile class |
| 0 | 1788 _node_bundling_base = NEW_ARENA_ARRAY(compile.comp_arena(), Bundle, node_max); |
| 1789 | |
| 1790 // Allocate space for fixed-size arrays | |
| 1791 _node_latency = NEW_ARENA_ARRAY(arena, unsigned short, node_max); | |
| 1792 _uses = NEW_ARENA_ARRAY(arena, short, node_max); | |
| 1793 _current_latency = NEW_ARENA_ARRAY(arena, unsigned short, node_max); | |
| 1794 | |
| 1795 // Clear the arrays | |
| 1796 memset(_node_bundling_base, 0, node_max * sizeof(Bundle)); | |
| 1797 memset(_node_latency, 0, node_max * sizeof(unsigned short)); | |
| 1798 memset(_uses, 0, node_max * sizeof(short)); | |
| 1799 memset(_current_latency, 0, node_max * sizeof(unsigned short)); | |
| 1800 | |
| 1801 // Clear the bundling information | |
| 1802 memcpy(_bundle_use_elements, | |
| 1803 Pipeline_Use::elaborated_elements, | |
| 1804 sizeof(Pipeline_Use::elaborated_elements)); | |
| 1805 | |
| 1806 // Get the last node | |
| 1807 Block *bb = _cfg->_blocks[_cfg->_blocks.size()-1]; | |
| 1808 | |
| 1809 _next_node = bb->_nodes[bb->_nodes.size()-1]; | |
| 1810 } | |
| 1811 | |
| 1812 #ifndef PRODUCT | |
| 1813 // Scheduling destructor | |
| 1814 Scheduling::~Scheduling() { | |
| 1815 _total_branches += _branches; | |
| 1816 _total_unconditional_delays += _unconditional_delays; | |
| 1817 } | |
| 1818 #endif | |
| 1819 | |
| 1820 // Step ahead "i" cycles | |
| 1821 void Scheduling::step(uint i) { | |
| 1822 | |
| 1823 Bundle *bundle = node_bundling(_next_node); | |
| 1824 bundle->set_starts_bundle(); | |
| 1825 | |
| 1826 // Update the bundle record, but leave the flags information alone | |
| 1827 if (_bundle_instr_count > 0) { | |
| 1828 bundle->set_instr_count(_bundle_instr_count); | |
| 1829 bundle->set_resources_used(_bundle_use.resourcesUsed()); | |
| 1830 } | |
| 1831 | |
| 1832 // Update the state information | |
| 1833 _bundle_instr_count = 0; | |
| 1834 _bundle_cycle_number += i; | |
| 1835 _bundle_use.step(i); | |
| 1836 } | |
| 1837 | |
| 1838 void Scheduling::step_and_clear() { | |
| 1839 Bundle *bundle = node_bundling(_next_node); | |
| 1840 bundle->set_starts_bundle(); | |
| 1841 | |
| 1842 // Update the bundle record | |
| 1843 if (_bundle_instr_count > 0) { | |
| 1844 bundle->set_instr_count(_bundle_instr_count); | |
| 1845 bundle->set_resources_used(_bundle_use.resourcesUsed()); | |
| 1846 | |
| 1847 _bundle_cycle_number += 1; | |
| 1848 } | |
| 1849 | |
| 1850 // Clear the bundling information | |
| 1851 _bundle_instr_count = 0; | |
| 1852 _bundle_use.reset(); | |
| 1853 | |
| 1854 memcpy(_bundle_use_elements, | |
| 1855 Pipeline_Use::elaborated_elements, | |
| 1856 sizeof(Pipeline_Use::elaborated_elements)); | |
| 1857 } | |
| 1858 | |
| 1859 //------------------------------ScheduleAndBundle------------------------------ | |
| 1860 // Perform instruction scheduling and bundling over the sequence of | |
| 1861 // instructions in backwards order. | |
| 1862 void Compile::ScheduleAndBundle() { | |
| 1863 | |
| 1864 // Don't optimize this if it isn't a method | |
| 1865 if (!_method) | |
| 1866 return; | |
| 1867 | |
| 1868 // Don't optimize this if scheduling is disabled | |
| 1869 if (!do_scheduling()) | |
| 1870 return; | |
| 1871 | |
|
6792
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6725
diff
changeset
|
1872 // Scheduling code works only with pairs (8 bytes) maximum. |
|
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6725
diff
changeset
|
1873 if (max_vector_size() > 8) |
|
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6725
diff
changeset
|
1874 return; |
|
6620
f7cd53cedd78
7192965: assert(is_aligned_sets(size)) failed: mask is not aligned, adjacent sets
kvn
parents:
4947
diff
changeset
|
1875 |
| 0 | 1876 NOT_PRODUCT( TracePhase t2("isched", &_t_instrSched, TimeCompiler); ) |
| 1877 | |
| 1878 // Create a data structure for all the scheduling information | |
| 1879 Scheduling scheduling(Thread::current()->resource_area(), *this); | |
| 1880 | |
| 1881 // Walk backwards over each basic block, computing the needed alignment | |
| 1882 // Walk over all the basic blocks | |
| 1883 scheduling.DoScheduling(); | |
| 1884 } | |
| 1885 | |
| 1886 //------------------------------ComputeLocalLatenciesForward------------------- | |
| 1887 // Compute the latency of all the instructions. This is fairly simple, | |
| 1888 // because we already have a legal ordering. Walk over the instructions | |
| 1889 // from first to last, and compute the latency of the instruction based | |
| 605 | 1890 // on the latency of the preceding instruction(s). |
| 0 | 1891 void Scheduling::ComputeLocalLatenciesForward(const Block *bb) { |
| 1892 #ifndef PRODUCT | |
| 1893 if (_cfg->C->trace_opto_output()) | |
| 1894 tty->print("# -> ComputeLocalLatenciesForward\n"); | |
| 1895 #endif | |
| 1896 | |
| 1897 // Walk over all the schedulable instructions | |
| 1898 for( uint j=_bb_start; j < _bb_end; j++ ) { | |
| 1899 | |
| 1900 // This is a kludge, forcing all latency calculations to start at 1. | |
| 1901 // Used to allow latency 0 to force an instruction to the beginning | |
| 1902 // of the bb | |
| 1903 uint latency = 1; | |
| 1904 Node *use = bb->_nodes[j]; | |
| 1905 uint nlen = use->len(); | |
| 1906 | |
| 1907 // Walk over all the inputs | |
| 1908 for ( uint k=0; k < nlen; k++ ) { | |
| 1909 Node *def = use->in(k); | |
| 1910 if (!def) | |
| 1911 continue; | |
| 1912 | |
| 1913 uint l = _node_latency[def->_idx] + use->latency(k); | |
| 1914 if (latency < l) | |
| 1915 latency = l; | |
| 1916 } | |
| 1917 | |
| 1918 _node_latency[use->_idx] = latency; | |
| 1919 | |
| 1920 #ifndef PRODUCT | |
| 1921 if (_cfg->C->trace_opto_output()) { | |
| 1922 tty->print("# latency %4d: ", latency); | |
| 1923 use->dump(); | |
| 1924 } | |
| 1925 #endif | |
| 1926 } | |
| 1927 | |
| 1928 #ifndef PRODUCT | |
| 1929 if (_cfg->C->trace_opto_output()) | |
| 1930 tty->print("# <- ComputeLocalLatenciesForward\n"); | |
| 1931 #endif | |
| 1932 | |
| 1933 } // end ComputeLocalLatenciesForward | |
| 1934 | |
| 1935 // See if this node fits into the present instruction bundle | |
| 1936 bool Scheduling::NodeFitsInBundle(Node *n) { | |
| 1937 uint n_idx = n->_idx; | |
| 1938 | |
| 1939 // If this is the unconditional delay instruction, then it fits | |
| 1940 if (n == _unconditional_delay_slot) { | |
| 1941 #ifndef PRODUCT | |
| 1942 if (_cfg->C->trace_opto_output()) | |
| 1943 tty->print("# NodeFitsInBundle [%4d]: TRUE; is in unconditional delay slot\n", n->_idx); | |
| 1944 #endif | |
| 1945 return (true); | |
| 1946 } | |
| 1947 | |
| 1948 // If the node cannot be scheduled this cycle, skip it | |
| 1949 if (_current_latency[n_idx] > _bundle_cycle_number) { | |
| 1950 #ifndef PRODUCT | |
| 1951 if (_cfg->C->trace_opto_output()) | |
| 1952 tty->print("# NodeFitsInBundle [%4d]: FALSE; latency %4d > %d\n", | |
| 1953 n->_idx, _current_latency[n_idx], _bundle_cycle_number); | |
| 1954 #endif | |
| 1955 return (false); | |
| 1956 } | |
| 1957 | |
| 1958 const Pipeline *node_pipeline = n->pipeline(); | |
| 1959 | |
| 1960 uint instruction_count = node_pipeline->instructionCount(); | |
| 1961 if (node_pipeline->mayHaveNoCode() && n->size(_regalloc) == 0) | |
| 1962 instruction_count = 0; | |
| 1963 else if (node_pipeline->hasBranchDelay() && !_unconditional_delay_slot) | |
| 1964 instruction_count++; | |
| 1965 | |
| 1966 if (_bundle_instr_count + instruction_count > Pipeline::_max_instrs_per_cycle) { | |
| 1967 #ifndef PRODUCT | |
| 1968 if (_cfg->C->trace_opto_output()) | |
| 1969 tty->print("# NodeFitsInBundle [%4d]: FALSE; too many instructions: %d > %d\n", | |
| 1970 n->_idx, _bundle_instr_count + instruction_count, Pipeline::_max_instrs_per_cycle); | |
| 1971 #endif | |
| 1972 return (false); | |
| 1973 } | |
| 1974 | |
| 1975 // Don't allow non-machine nodes to be handled this way | |
| 1976 if (!n->is_Mach() && instruction_count == 0) | |
| 1977 return (false); | |
| 1978 | |
| 1979 // See if there is any overlap | |
| 1980 uint delay = _bundle_use.full_latency(0, node_pipeline->resourceUse()); | |
| 1981 | |
| 1982 if (delay > 0) { | |
| 1983 #ifndef PRODUCT | |
| 1984 if (_cfg->C->trace_opto_output()) | |
| 1985 tty->print("# NodeFitsInBundle [%4d]: FALSE; functional units overlap\n", n_idx); | |
| 1986 #endif | |
| 1987 return false; | |
| 1988 } | |
| 1989 | |
| 1990 #ifndef PRODUCT | |
| 1991 if (_cfg->C->trace_opto_output()) | |
| 1992 tty->print("# NodeFitsInBundle [%4d]: TRUE\n", n_idx); | |
| 1993 #endif | |
| 1994 | |
| 1995 return true; | |
| 1996 } | |
| 1997 | |
| 1998 Node * Scheduling::ChooseNodeToBundle() { | |
| 1999 uint siz = _available.size(); | |
| 2000 | |
| 2001 if (siz == 0) { | |
| 2002 | |
| 2003 #ifndef PRODUCT | |
| 2004 if (_cfg->C->trace_opto_output()) | |
| 2005 tty->print("# ChooseNodeToBundle: NULL\n"); | |
| 2006 #endif | |
| 2007 return (NULL); | |
| 2008 } | |
| 2009 | |
| 2010 // Fast path, if only 1 instruction in the bundle | |
| 2011 if (siz == 1) { | |
| 2012 #ifndef PRODUCT | |
| 2013 if (_cfg->C->trace_opto_output()) { | |
| 2014 tty->print("# ChooseNodeToBundle (only 1): "); | |
| 2015 _available[0]->dump(); | |
| 2016 } | |
| 2017 #endif | |
| 2018 return (_available[0]); | |
| 2019 } | |
| 2020 | |
| 2021 // Don't bother, if the bundle is already full | |
| 2022 if (_bundle_instr_count < Pipeline::_max_instrs_per_cycle) { | |
| 2023 for ( uint i = 0; i < siz; i++ ) { | |
| 2024 Node *n = _available[i]; | |
| 2025 | |
| 2026 // Skip projections, we'll handle them another way | |
| 2027 if (n->is_Proj()) | |
| 2028 continue; | |
| 2029 | |
| 2030 // This presupposed that instructions are inserted into the | |
| 2031 // available list in a legality order; i.e. instructions that | |
| 2032 // must be inserted first are at the head of the list | |
| 2033 if (NodeFitsInBundle(n)) { | |
| 2034 #ifndef PRODUCT | |
| 2035 if (_cfg->C->trace_opto_output()) { | |
| 2036 tty->print("# ChooseNodeToBundle: "); | |
| 2037 n->dump(); | |
| 2038 } | |
| 2039 #endif | |
| 2040 return (n); | |
| 2041 } | |
| 2042 } | |
| 2043 } | |
| 2044 | |
| 2045 // Nothing fits in this bundle, choose the highest priority | |
| 2046 #ifndef PRODUCT | |
| 2047 if (_cfg->C->trace_opto_output()) { | |
| 2048 tty->print("# ChooseNodeToBundle: "); | |
| 2049 _available[0]->dump(); | |
| 2050 } | |
| 2051 #endif | |
| 2052 | |
| 2053 return _available[0]; | |
| 2054 } | |
| 2055 | |
| 2056 //------------------------------AddNodeToAvailableList------------------------- | |
| 2057 void Scheduling::AddNodeToAvailableList(Node *n) { | |
| 2058 assert( !n->is_Proj(), "projections never directly made available" ); | |
| 2059 #ifndef PRODUCT | |
| 2060 if (_cfg->C->trace_opto_output()) { | |
| 2061 tty->print("# AddNodeToAvailableList: "); | |
| 2062 n->dump(); | |
| 2063 } | |
| 2064 #endif | |
| 2065 | |
| 2066 int latency = _current_latency[n->_idx]; | |
| 2067 | |
| 2068 // Insert in latency order (insertion sort) | |
| 2069 uint i; | |
| 2070 for ( i=0; i < _available.size(); i++ ) | |
| 2071 if (_current_latency[_available[i]->_idx] > latency) | |
| 2072 break; | |
| 2073 | |
| 2074 // Special Check for compares following branches | |
| 2075 if( n->is_Mach() && _scheduled.size() > 0 ) { | |
| 2076 int op = n->as_Mach()->ideal_Opcode(); | |
| 2077 Node *last = _scheduled[0]; | |
| 2078 if( last->is_MachIf() && last->in(1) == n && | |
| 2079 ( op == Op_CmpI || | |
| 2080 op == Op_CmpU || | |
| 2081 op == Op_CmpP || | |
| 2082 op == Op_CmpF || | |
| 2083 op == Op_CmpD || | |
| 2084 op == Op_CmpL ) ) { | |
| 2085 | |
| 2086 // Recalculate position, moving to front of same latency | |
| 2087 for ( i=0 ; i < _available.size(); i++ ) | |
| 2088 if (_current_latency[_available[i]->_idx] >= latency) | |
| 2089 break; | |
| 2090 } | |
| 2091 } | |
| 2092 | |
| 2093 // Insert the node in the available list | |
| 2094 _available.insert(i, n); | |
| 2095 | |
| 2096 #ifndef PRODUCT | |
| 2097 if (_cfg->C->trace_opto_output()) | |
| 2098 dump_available(); | |
| 2099 #endif | |
| 2100 } | |
| 2101 | |
| 2102 //------------------------------DecrementUseCounts----------------------------- | |
| 2103 void Scheduling::DecrementUseCounts(Node *n, const Block *bb) { | |
| 2104 for ( uint i=0; i < n->len(); i++ ) { | |
| 2105 Node *def = n->in(i); | |
| 2106 if (!def) continue; | |
| 2107 if( def->is_Proj() ) // If this is a machine projection, then | |
| 2108 def = def->in(0); // propagate usage thru to the base instruction | |
| 2109 | |
| 2110 if( _bbs[def->_idx] != bb ) // Ignore if not block-local | |
| 2111 continue; | |
| 2112 | |
| 2113 // Compute the latency | |
| 2114 uint l = _bundle_cycle_number + n->latency(i); | |
| 2115 if (_current_latency[def->_idx] < l) | |
| 2116 _current_latency[def->_idx] = l; | |
| 2117 | |
| 2118 // If this does not have uses then schedule it | |
| 2119 if ((--_uses[def->_idx]) == 0) | |
| 2120 AddNodeToAvailableList(def); | |
| 2121 } | |
| 2122 } | |
| 2123 | |
| 2124 //------------------------------AddNodeToBundle-------------------------------- | |
| 2125 void Scheduling::AddNodeToBundle(Node *n, const Block *bb) { | |
| 2126 #ifndef PRODUCT | |
| 2127 if (_cfg->C->trace_opto_output()) { | |
| 2128 tty->print("# AddNodeToBundle: "); | |
| 2129 n->dump(); | |
| 2130 } | |
| 2131 #endif | |
| 2132 | |
| 2133 // Remove this from the available list | |
| 2134 uint i; | |
| 2135 for (i = 0; i < _available.size(); i++) | |
| 2136 if (_available[i] == n) | |
| 2137 break; | |
| 2138 assert(i < _available.size(), "entry in _available list not found"); | |
| 2139 _available.remove(i); | |
| 2140 | |
| 2141 // See if this fits in the current bundle | |
| 2142 const Pipeline *node_pipeline = n->pipeline(); | |
| 2143 const Pipeline_Use& node_usage = node_pipeline->resourceUse(); | |
| 2144 | |
| 2145 // Check for instructions to be placed in the delay slot. We | |
| 2146 // do this before we actually schedule the current instruction, | |
| 2147 // because the delay slot follows the current instruction. | |
| 2148 if (Pipeline::_branch_has_delay_slot && | |
| 2149 node_pipeline->hasBranchDelay() && | |
| 2150 !_unconditional_delay_slot) { | |
| 2151 | |
| 2152 uint siz = _available.size(); | |
| 2153 | |
| 2154 // Conditional branches can support an instruction that | |
| 605 | 2155 // is unconditionally executed and not dependent by the |
| 0 | 2156 // branch, OR a conditionally executed instruction if |
| 2157 // the branch is taken. In practice, this means that | |
| 2158 // the first instruction at the branch target is | |
| 2159 // copied to the delay slot, and the branch goes to | |
| 2160 // the instruction after that at the branch target | |
|
3853
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
2161 if ( n->is_MachBranch() ) { |
| 0 | 2162 |
| 2163 assert( !n->is_MachNullCheck(), "should not look for delay slot for Null Check" ); | |
| 2164 assert( !n->is_Catch(), "should not look for delay slot for Catch" ); | |
| 2165 | |
| 2166 #ifndef PRODUCT | |
| 2167 _branches++; | |
| 2168 #endif | |
| 2169 | |
| 2170 // At least 1 instruction is on the available list | |
| 605 | 2171 // that is not dependent on the branch |
| 0 | 2172 for (uint i = 0; i < siz; i++) { |
| 2173 Node *d = _available[i]; | |
| 2174 const Pipeline *avail_pipeline = d->pipeline(); | |
| 2175 | |
| 2176 // Don't allow safepoints in the branch shadow, that will | |
| 2177 // cause a number of difficulties | |
| 2178 if ( avail_pipeline->instructionCount() == 1 && | |
| 2179 !avail_pipeline->hasMultipleBundles() && | |
| 2180 !avail_pipeline->hasBranchDelay() && | |
| 2181 Pipeline::instr_has_unit_size() && | |
| 2182 d->size(_regalloc) == Pipeline::instr_unit_size() && | |
| 2183 NodeFitsInBundle(d) && | |
| 2184 !node_bundling(d)->used_in_delay()) { | |
| 2185 | |
| 2186 if (d->is_Mach() && !d->is_MachSafePoint()) { | |
| 2187 // A node that fits in the delay slot was found, so we need to | |
| 2188 // set the appropriate bits in the bundle pipeline information so | |
| 2189 // that it correctly indicates resource usage. Later, when we | |
| 2190 // attempt to add this instruction to the bundle, we will skip | |
| 2191 // setting the resource usage. | |
| 2192 _unconditional_delay_slot = d; | |
| 2193 node_bundling(n)->set_use_unconditional_delay(); | |
| 2194 node_bundling(d)->set_used_in_unconditional_delay(); | |
| 2195 _bundle_use.add_usage(avail_pipeline->resourceUse()); | |
| 2196 _current_latency[d->_idx] = _bundle_cycle_number; | |
| 2197 _next_node = d; | |
| 2198 ++_bundle_instr_count; | |
| 2199 #ifndef PRODUCT | |
| 2200 _unconditional_delays++; | |
| 2201 #endif | |
| 2202 break; | |
| 2203 } | |
| 2204 } | |
| 2205 } | |
| 2206 } | |
| 2207 | |
| 2208 // No delay slot, add a nop to the usage | |
| 2209 if (!_unconditional_delay_slot) { | |
| 2210 // See if adding an instruction in the delay slot will overflow | |
| 2211 // the bundle. | |
| 2212 if (!NodeFitsInBundle(_nop)) { | |
| 2213 #ifndef PRODUCT | |
| 2214 if (_cfg->C->trace_opto_output()) | |
| 2215 tty->print("# *** STEP(1 instruction for delay slot) ***\n"); | |
| 2216 #endif | |
| 2217 step(1); | |
| 2218 } | |
| 2219 | |
| 2220 _bundle_use.add_usage(_nop->pipeline()->resourceUse()); | |
| 2221 _next_node = _nop; | |
| 2222 ++_bundle_instr_count; | |
| 2223 } | |
| 2224 | |
| 2225 // See if the instruction in the delay slot requires a | |
| 2226 // step of the bundles | |
| 2227 if (!NodeFitsInBundle(n)) { | |
| 2228 #ifndef PRODUCT | |
| 2229 if (_cfg->C->trace_opto_output()) | |
| 2230 tty->print("# *** STEP(branch won't fit) ***\n"); | |
| 2231 #endif | |
| 2232 // Update the state information | |
| 2233 _bundle_instr_count = 0; | |
| 2234 _bundle_cycle_number += 1; | |
| 2235 _bundle_use.step(1); | |
| 2236 } | |
| 2237 } | |
| 2238 | |
| 2239 // Get the number of instructions | |
| 2240 uint instruction_count = node_pipeline->instructionCount(); | |
| 2241 if (node_pipeline->mayHaveNoCode() && n->size(_regalloc) == 0) | |
| 2242 instruction_count = 0; | |
| 2243 | |
| 2244 // Compute the latency information | |
| 2245 uint delay = 0; | |
| 2246 | |
| 2247 if (instruction_count > 0 || !node_pipeline->mayHaveNoCode()) { | |
| 2248 int relative_latency = _current_latency[n->_idx] - _bundle_cycle_number; | |
| 2249 if (relative_latency < 0) | |
| 2250 relative_latency = 0; | |
| 2251 | |
| 2252 delay = _bundle_use.full_latency(relative_latency, node_usage); | |
| 2253 | |
| 2254 // Does not fit in this bundle, start a new one | |
| 2255 if (delay > 0) { | |
| 2256 step(delay); | |
| 2257 | |
| 2258 #ifndef PRODUCT | |
| 2259 if (_cfg->C->trace_opto_output()) | |
| 2260 tty->print("# *** STEP(%d) ***\n", delay); | |
| 2261 #endif | |
| 2262 } | |
| 2263 } | |
| 2264 | |
| 2265 // If this was placed in the delay slot, ignore it | |
| 2266 if (n != _unconditional_delay_slot) { | |
| 2267 | |
| 2268 if (delay == 0) { | |
| 2269 if (node_pipeline->hasMultipleBundles()) { | |
| 2270 #ifndef PRODUCT | |
| 2271 if (_cfg->C->trace_opto_output()) | |
| 2272 tty->print("# *** STEP(multiple instructions) ***\n"); | |
| 2273 #endif | |
| 2274 step(1); | |
| 2275 } | |
| 2276 | |
| 2277 else if (instruction_count + _bundle_instr_count > Pipeline::_max_instrs_per_cycle) { | |
| 2278 #ifndef PRODUCT | |
| 2279 if (_cfg->C->trace_opto_output()) | |
| 2280 tty->print("# *** STEP(%d >= %d instructions) ***\n", | |
| 2281 instruction_count + _bundle_instr_count, | |
| 2282 Pipeline::_max_instrs_per_cycle); | |
| 2283 #endif | |
| 2284 step(1); | |
| 2285 } | |
| 2286 } | |
| 2287 | |
| 2288 if (node_pipeline->hasBranchDelay() && !_unconditional_delay_slot) | |
| 2289 _bundle_instr_count++; | |
| 2290 | |
| 2291 // Set the node's latency | |
| 2292 _current_latency[n->_idx] = _bundle_cycle_number; | |
| 2293 | |
| 2294 // Now merge the functional unit information | |
| 2295 if (instruction_count > 0 || !node_pipeline->mayHaveNoCode()) | |
| 2296 _bundle_use.add_usage(node_usage); | |
| 2297 | |
| 2298 // Increment the number of instructions in this bundle | |
| 2299 _bundle_instr_count += instruction_count; | |
| 2300 | |
| 2301 // Remember this node for later | |
| 2302 if (n->is_Mach()) | |
| 2303 _next_node = n; | |
| 2304 } | |
| 2305 | |
| 2306 // It's possible to have a BoxLock in the graph and in the _bbs mapping but | |
| 2307 // not in the bb->_nodes array. This happens for debug-info-only BoxLocks. | |
| 2308 // 'Schedule' them (basically ignore in the schedule) but do not insert them | |
| 2309 // into the block. All other scheduled nodes get put in the schedule here. | |
| 2310 int op = n->Opcode(); | |
| 2311 if( (op == Op_Node && n->req() == 0) || // anti-dependence node OR | |
| 2312 (op != Op_Node && // Not an unused antidepedence node and | |
| 2313 // not an unallocated boxlock | |
| 2314 (OptoReg::is_valid(_regalloc->get_reg_first(n)) || op != Op_BoxLock)) ) { | |
| 2315 | |
| 2316 // Push any trailing projections | |
| 2317 if( bb->_nodes[bb->_nodes.size()-1] != n ) { | |
| 2318 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) { | |
| 2319 Node *foi = n->fast_out(i); | |
| 2320 if( foi->is_Proj() ) | |
| 2321 _scheduled.push(foi); | |
| 2322 } | |
| 2323 } | |
| 2324 | |
| 2325 // Put the instruction in the schedule list | |
| 2326 _scheduled.push(n); | |
| 2327 } | |
| 2328 | |
| 2329 #ifndef PRODUCT | |
| 2330 if (_cfg->C->trace_opto_output()) | |
| 2331 dump_available(); | |
| 2332 #endif | |
| 2333 | |
| 2334 // Walk all the definitions, decrementing use counts, and | |
| 2335 // if a definition has a 0 use count, place it in the available list. | |
| 2336 DecrementUseCounts(n,bb); | |
| 2337 } | |
| 2338 | |
| 2339 //------------------------------ComputeUseCount-------------------------------- | |
| 2340 // This method sets the use count within a basic block. We will ignore all | |
| 2341 // uses outside the current basic block. As we are doing a backwards walk, | |
| 2342 // any node we reach that has a use count of 0 may be scheduled. This also | |
| 2343 // avoids the problem of cyclic references from phi nodes, as long as phi | |
| 2344 // nodes are at the front of the basic block. This method also initializes | |
| 2345 // the available list to the set of instructions that have no uses within this | |
| 2346 // basic block. | |
| 2347 void Scheduling::ComputeUseCount(const Block *bb) { | |
| 2348 #ifndef PRODUCT | |
| 2349 if (_cfg->C->trace_opto_output()) | |
| 2350 tty->print("# -> ComputeUseCount\n"); | |
| 2351 #endif | |
| 2352 | |
| 2353 // Clear the list of available and scheduled instructions, just in case | |
| 2354 _available.clear(); | |
| 2355 _scheduled.clear(); | |
| 2356 | |
| 2357 // No delay slot specified | |
| 2358 _unconditional_delay_slot = NULL; | |
| 2359 | |
| 2360 #ifdef ASSERT | |
| 2361 for( uint i=0; i < bb->_nodes.size(); i++ ) | |
| 2362 assert( _uses[bb->_nodes[i]->_idx] == 0, "_use array not clean" ); | |
| 2363 #endif | |
| 2364 | |
| 2365 // Force the _uses count to never go to zero for unscheduable pieces | |
| 2366 // of the block | |
| 2367 for( uint k = 0; k < _bb_start; k++ ) | |
| 2368 _uses[bb->_nodes[k]->_idx] = 1; | |
| 2369 for( uint l = _bb_end; l < bb->_nodes.size(); l++ ) | |
| 2370 _uses[bb->_nodes[l]->_idx] = 1; | |
| 2371 | |
| 2372 // Iterate backwards over the instructions in the block. Don't count the | |
| 2373 // branch projections at end or the block header instructions. | |
| 2374 for( uint j = _bb_end-1; j >= _bb_start; j-- ) { | |
| 2375 Node *n = bb->_nodes[j]; | |
| 2376 if( n->is_Proj() ) continue; // Projections handled another way | |
| 2377 | |
| 2378 // Account for all uses | |
| 2379 for ( uint k = 0; k < n->len(); k++ ) { | |
| 2380 Node *inp = n->in(k); | |
| 2381 if (!inp) continue; | |
| 2382 assert(inp != n, "no cycles allowed" ); | |
| 2383 if( _bbs[inp->_idx] == bb ) { // Block-local use? | |
| 2384 if( inp->is_Proj() ) // Skip through Proj's | |
| 2385 inp = inp->in(0); | |
| 2386 ++_uses[inp->_idx]; // Count 1 block-local use | |
| 2387 } | |
| 2388 } | |
| 2389 | |
| 2390 // If this instruction has a 0 use count, then it is available | |
| 2391 if (!_uses[n->_idx]) { | |
| 2392 _current_latency[n->_idx] = _bundle_cycle_number; | |
| 2393 AddNodeToAvailableList(n); | |
| 2394 } | |
| 2395 | |
| 2396 #ifndef PRODUCT | |
| 2397 if (_cfg->C->trace_opto_output()) { | |
| 2398 tty->print("# uses: %3d: ", _uses[n->_idx]); | |
| 2399 n->dump(); | |
| 2400 } | |
| 2401 #endif | |
| 2402 } | |
| 2403 | |
| 2404 #ifndef PRODUCT | |
| 2405 if (_cfg->C->trace_opto_output()) | |
| 2406 tty->print("# <- ComputeUseCount\n"); | |
| 2407 #endif | |
| 2408 } | |
| 2409 | |
| 2410 // This routine performs scheduling on each basic block in reverse order, | |
| 2411 // using instruction latencies and taking into account function unit | |
| 2412 // availability. | |
| 2413 void Scheduling::DoScheduling() { | |
| 2414 #ifndef PRODUCT | |
| 2415 if (_cfg->C->trace_opto_output()) | |
| 2416 tty->print("# -> DoScheduling\n"); | |
| 2417 #endif | |
| 2418 | |
| 2419 Block *succ_bb = NULL; | |
| 2420 Block *bb; | |
| 2421 | |
| 2422 // Walk over all the basic blocks in reverse order | |
| 2423 for( int i=_cfg->_num_blocks-1; i >= 0; succ_bb = bb, i-- ) { | |
| 2424 bb = _cfg->_blocks[i]; | |
| 2425 | |
| 2426 #ifndef PRODUCT | |
| 2427 if (_cfg->C->trace_opto_output()) { | |
| 2428 tty->print("# Schedule BB#%03d (initial)\n", i); | |
| 2429 for (uint j = 0; j < bb->_nodes.size(); j++) | |
| 2430 bb->_nodes[j]->dump(); | |
| 2431 } | |
| 2432 #endif | |
| 2433 | |
| 2434 // On the head node, skip processing | |
| 2435 if( bb == _cfg->_broot ) | |
| 2436 continue; | |
| 2437 | |
| 2438 // Skip empty, connector blocks | |
| 2439 if (bb->is_connector()) | |
| 2440 continue; | |
| 2441 | |
| 2442 // If the following block is not the sole successor of | |
| 2443 // this one, then reset the pipeline information | |
| 2444 if (bb->_num_succs != 1 || bb->non_connector_successor(0) != succ_bb) { | |
| 2445 #ifndef PRODUCT | |
| 2446 if (_cfg->C->trace_opto_output()) { | |
| 2447 tty->print("*** bundle start of next BB, node %d, for %d instructions\n", | |
| 2448 _next_node->_idx, _bundle_instr_count); | |
| 2449 } | |
| 2450 #endif | |
| 2451 step_and_clear(); | |
| 2452 } | |
| 2453 | |
| 2454 // Leave untouched the starting instruction, any Phis, a CreateEx node | |
| 2455 // or Top. bb->_nodes[_bb_start] is the first schedulable instruction. | |
| 2456 _bb_end = bb->_nodes.size()-1; | |
| 2457 for( _bb_start=1; _bb_start <= _bb_end; _bb_start++ ) { | |
| 2458 Node *n = bb->_nodes[_bb_start]; | |
| 2459 // Things not matched, like Phinodes and ProjNodes don't get scheduled. | |
| 2460 // Also, MachIdealNodes do not get scheduled | |
| 2461 if( !n->is_Mach() ) continue; // Skip non-machine nodes | |
| 2462 MachNode *mach = n->as_Mach(); | |
| 2463 int iop = mach->ideal_Opcode(); | |
| 2464 if( iop == Op_CreateEx ) continue; // CreateEx is pinned | |
| 2465 if( iop == Op_Con ) continue; // Do not schedule Top | |
| 2466 if( iop == Op_Node && // Do not schedule PhiNodes, ProjNodes | |
| 2467 mach->pipeline() == MachNode::pipeline_class() && | |
| 2468 !n->is_SpillCopy() ) // Breakpoints, Prolog, etc | |
| 2469 continue; | |
| 2470 break; // Funny loop structure to be sure... | |
| 2471 } | |
| 2472 // Compute last "interesting" instruction in block - last instruction we | |
| 2473 // might schedule. _bb_end points just after last schedulable inst. We | |
| 2474 // normally schedule conditional branches (despite them being forced last | |
| 2475 // in the block), because they have delay slots we can fill. Calls all | |
| 2476 // have their delay slots filled in the template expansions, so we don't | |
| 2477 // bother scheduling them. | |
| 2478 Node *last = bb->_nodes[_bb_end]; | |
| 3851 | 2479 // Ignore trailing NOPs. |
| 2480 while (_bb_end > 0 && last->is_Mach() && | |
| 2481 last->as_Mach()->ideal_Opcode() == Op_Con) { | |
| 2482 last = bb->_nodes[--_bb_end]; | |
| 2483 } | |
| 2484 assert(!last->is_Mach() || last->as_Mach()->ideal_Opcode() != Op_Con, ""); | |
| 0 | 2485 if( last->is_Catch() || |
|
707
4ec1257180ec
6826960: C2 Sparc: assert(bb->_nodes(_bb_end)->is_Proj(),"skipping projections after expected call")
kvn
parents:
605
diff
changeset
|
2486 // Exclude unreachable path case when Halt node is in a separate block. |
|
4ec1257180ec
6826960: C2 Sparc: assert(bb->_nodes(_bb_end)->is_Proj(),"skipping projections after expected call")
kvn
parents:
605
diff
changeset
|
2487 (_bb_end > 1 && last->is_Mach() && last->as_Mach()->ideal_Opcode() == Op_Halt) ) { |
| 0 | 2488 // There must be a prior call. Skip it. |
| 3842 | 2489 while( !bb->_nodes[--_bb_end]->is_MachCall() ) { |
| 2490 assert( bb->_nodes[_bb_end]->is_MachProj(), "skipping projections after expected call" ); | |
| 0 | 2491 } |
| 2492 } else if( last->is_MachNullCheck() ) { | |
| 2493 // Backup so the last null-checked memory instruction is | |
| 2494 // outside the schedulable range. Skip over the nullcheck, | |
| 2495 // projection, and the memory nodes. | |
| 2496 Node *mem = last->in(1); | |
| 2497 do { | |
| 2498 _bb_end--; | |
| 2499 } while (mem != bb->_nodes[_bb_end]); | |
| 2500 } else { | |
| 2501 // Set _bb_end to point after last schedulable inst. | |
| 2502 _bb_end++; | |
| 2503 } | |
| 2504 | |
| 2505 assert( _bb_start <= _bb_end, "inverted block ends" ); | |
| 2506 | |
| 2507 // Compute the register antidependencies for the basic block | |
| 2508 ComputeRegisterAntidependencies(bb); | |
| 2509 if (_cfg->C->failing()) return; // too many D-U pinch points | |
| 2510 | |
| 2511 // Compute intra-bb latencies for the nodes | |
| 2512 ComputeLocalLatenciesForward(bb); | |
| 2513 | |
| 2514 // Compute the usage within the block, and set the list of all nodes | |
| 2515 // in the block that have no uses within the block. | |
| 2516 ComputeUseCount(bb); | |
| 2517 | |
| 2518 // Schedule the remaining instructions in the block | |
| 2519 while ( _available.size() > 0 ) { | |
| 2520 Node *n = ChooseNodeToBundle(); | |
| 2521 AddNodeToBundle(n,bb); | |
| 2522 } | |
| 2523 | |
| 2524 assert( _scheduled.size() == _bb_end - _bb_start, "wrong number of instructions" ); | |
| 2525 #ifdef ASSERT | |
| 2526 for( uint l = _bb_start; l < _bb_end; l++ ) { | |
| 2527 Node *n = bb->_nodes[l]; | |
| 2528 uint m; | |
| 2529 for( m = 0; m < _bb_end-_bb_start; m++ ) | |
| 2530 if( _scheduled[m] == n ) | |
| 2531 break; | |
| 2532 assert( m < _bb_end-_bb_start, "instruction missing in schedule" ); | |
| 2533 } | |
| 2534 #endif | |
| 2535 | |
| 2536 // Now copy the instructions (in reverse order) back to the block | |
| 2537 for ( uint k = _bb_start; k < _bb_end; k++ ) | |
| 2538 bb->_nodes.map(k, _scheduled[_bb_end-k-1]); | |
| 2539 | |
| 2540 #ifndef PRODUCT | |
| 2541 if (_cfg->C->trace_opto_output()) { | |
| 2542 tty->print("# Schedule BB#%03d (final)\n", i); | |
| 2543 uint current = 0; | |
| 2544 for (uint j = 0; j < bb->_nodes.size(); j++) { | |
| 2545 Node *n = bb->_nodes[j]; | |
| 2546 if( valid_bundle_info(n) ) { | |
| 2547 Bundle *bundle = node_bundling(n); | |
| 2548 if (bundle->instr_count() > 0 || bundle->flags() > 0) { | |
| 2549 tty->print("*** Bundle: "); | |
| 2550 bundle->dump(); | |
| 2551 } | |
| 2552 n->dump(); | |
| 2553 } | |
| 2554 } | |
| 2555 } | |
| 2556 #endif | |
| 2557 #ifdef ASSERT | |
| 2558 verify_good_schedule(bb,"after block local scheduling"); | |
| 2559 #endif | |
| 2560 } | |
| 2561 | |
| 2562 #ifndef PRODUCT | |
| 2563 if (_cfg->C->trace_opto_output()) | |
| 2564 tty->print("# <- DoScheduling\n"); | |
| 2565 #endif | |
| 2566 | |
| 2567 // Record final node-bundling array location | |
| 2568 _regalloc->C->set_node_bundling_base(_node_bundling_base); | |
| 2569 | |
| 2570 } // end DoScheduling | |
| 2571 | |
| 2572 //------------------------------verify_good_schedule--------------------------- | |
| 2573 // Verify that no live-range used in the block is killed in the block by a | |
| 2574 // wrong DEF. This doesn't verify live-ranges that span blocks. | |
| 2575 | |
| 2576 // Check for edge existence. Used to avoid adding redundant precedence edges. | |
| 2577 static bool edge_from_to( Node *from, Node *to ) { | |
| 2578 for( uint i=0; i<from->len(); i++ ) | |
| 2579 if( from->in(i) == to ) | |
| 2580 return true; | |
| 2581 return false; | |
| 2582 } | |
| 2583 | |
| 2584 #ifdef ASSERT | |
| 2585 //------------------------------verify_do_def---------------------------------- | |
| 2586 void Scheduling::verify_do_def( Node *n, OptoReg::Name def, const char *msg ) { | |
| 2587 // Check for bad kills | |
| 2588 if( OptoReg::is_valid(def) ) { // Ignore stores & control flow | |
| 2589 Node *prior_use = _reg_node[def]; | |
| 2590 if( prior_use && !edge_from_to(prior_use,n) ) { | |
| 2591 tty->print("%s = ",OptoReg::as_VMReg(def)->name()); | |
| 2592 n->dump(); | |
| 2593 tty->print_cr("..."); | |
| 2594 prior_use->dump(); | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1489
diff
changeset
|
2595 assert(edge_from_to(prior_use,n),msg); |
| 0 | 2596 } |
| 2597 _reg_node.map(def,NULL); // Kill live USEs | |
| 2598 } | |
| 2599 } | |
| 2600 | |
| 2601 //------------------------------verify_good_schedule--------------------------- | |
| 2602 void Scheduling::verify_good_schedule( Block *b, const char *msg ) { | |
| 2603 | |
| 2604 // Zap to something reasonable for the verify code | |
| 2605 _reg_node.clear(); | |
| 2606 | |
| 2607 // Walk over the block backwards. Check to make sure each DEF doesn't | |
| 2608 // kill a live value (other than the one it's supposed to). Add each | |
| 2609 // USE to the live set. | |
| 2610 for( uint i = b->_nodes.size()-1; i >= _bb_start; i-- ) { | |
| 2611 Node *n = b->_nodes[i]; | |
| 2612 int n_op = n->Opcode(); | |
| 2613 if( n_op == Op_MachProj && n->ideal_reg() == MachProjNode::fat_proj ) { | |
| 2614 // Fat-proj kills a slew of registers | |
| 2615 RegMask rm = n->out_RegMask();// Make local copy | |
| 2616 while( rm.is_NotEmpty() ) { | |
| 2617 OptoReg::Name kill = rm.find_first_elem(); | |
| 2618 rm.Remove(kill); | |
| 2619 verify_do_def( n, kill, msg ); | |
| 2620 } | |
| 2621 } else if( n_op != Op_Node ) { // Avoid brand new antidependence nodes | |
| 2622 // Get DEF'd registers the normal way | |
| 2623 verify_do_def( n, _regalloc->get_reg_first(n), msg ); | |
| 2624 verify_do_def( n, _regalloc->get_reg_second(n), msg ); | |
| 2625 } | |
| 2626 | |
| 2627 // Now make all USEs live | |
| 2628 for( uint i=1; i<n->req(); i++ ) { | |
| 2629 Node *def = n->in(i); | |
| 2630 assert(def != 0, "input edge required"); | |
| 2631 OptoReg::Name reg_lo = _regalloc->get_reg_first(def); | |
| 2632 OptoReg::Name reg_hi = _regalloc->get_reg_second(def); | |
| 2633 if( OptoReg::is_valid(reg_lo) ) { | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1489
diff
changeset
|
2634 assert(!_reg_node[reg_lo] || edge_from_to(_reg_node[reg_lo],def), msg); |
| 0 | 2635 _reg_node.map(reg_lo,n); |
| 2636 } | |
| 2637 if( OptoReg::is_valid(reg_hi) ) { | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1489
diff
changeset
|
2638 assert(!_reg_node[reg_hi] || edge_from_to(_reg_node[reg_hi],def), msg); |
| 0 | 2639 _reg_node.map(reg_hi,n); |
| 2640 } | |
| 2641 } | |
| 2642 | |
| 2643 } | |
| 2644 | |
| 2645 // Zap to something reasonable for the Antidependence code | |
| 2646 _reg_node.clear(); | |
| 2647 } | |
| 2648 #endif | |
| 2649 | |
| 2650 // Conditionally add precedence edges. Avoid putting edges on Projs. | |
| 2651 static void add_prec_edge_from_to( Node *from, Node *to ) { | |
| 2652 if( from->is_Proj() ) { // Put precedence edge on Proj's input | |
| 2653 assert( from->req() == 1 && (from->len() == 1 || from->in(1)==0), "no precedence edges on projections" ); | |
| 2654 from = from->in(0); | |
| 2655 } | |
| 2656 if( from != to && // No cycles (for things like LD L0,[L0+4] ) | |
| 2657 !edge_from_to( from, to ) ) // Avoid duplicate edge | |
| 2658 from->add_prec(to); | |
| 2659 } | |
| 2660 | |
| 2661 //------------------------------anti_do_def------------------------------------ | |
| 2662 void Scheduling::anti_do_def( Block *b, Node *def, OptoReg::Name def_reg, int is_def ) { | |
| 2663 if( !OptoReg::is_valid(def_reg) ) // Ignore stores & control flow | |
| 2664 return; | |
| 2665 | |
| 2666 Node *pinch = _reg_node[def_reg]; // Get pinch point | |
| 2667 if( !pinch || _bbs[pinch->_idx] != b || // No pinch-point yet? | |
| 2668 is_def ) { // Check for a true def (not a kill) | |
| 2669 _reg_node.map(def_reg,def); // Record def/kill as the optimistic pinch-point | |
| 2670 return; | |
| 2671 } | |
| 2672 | |
| 2673 Node *kill = def; // Rename 'def' to more descriptive 'kill' | |
| 2674 debug_only( def = (Node*)0xdeadbeef; ) | |
| 2675 | |
| 2676 // After some number of kills there _may_ be a later def | |
| 2677 Node *later_def = NULL; | |
| 2678 | |
| 2679 // Finding a kill requires a real pinch-point. | |
| 2680 // Check for not already having a pinch-point. | |
| 2681 // Pinch points are Op_Node's. | |
| 2682 if( pinch->Opcode() != Op_Node ) { // Or later-def/kill as pinch-point? | |
| 2683 later_def = pinch; // Must be def/kill as optimistic pinch-point | |
| 2684 if ( _pinch_free_list.size() > 0) { | |
| 2685 pinch = _pinch_free_list.pop(); | |
| 2686 } else { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6792
diff
changeset
|
2687 pinch = new (_cfg->C) Node(1); // Pinch point to-be |
| 0 | 2688 } |
| 2689 if (pinch->_idx >= _regalloc->node_regs_max_index()) { | |
| 2690 _cfg->C->record_method_not_compilable("too many D-U pinch points"); | |
| 2691 return; | |
| 2692 } | |
| 2693 _bbs.map(pinch->_idx,b); // Pretend it's valid in this block (lazy init) | |
| 2694 _reg_node.map(def_reg,pinch); // Record pinch-point | |
| 2695 //_regalloc->set_bad(pinch->_idx); // Already initialized this way. | |
| 2696 if( later_def->outcnt() == 0 || later_def->ideal_reg() == MachProjNode::fat_proj ) { // Distinguish def from kill | |
| 2697 pinch->init_req(0, _cfg->C->top()); // set not NULL for the next call | |
| 2698 add_prec_edge_from_to(later_def,pinch); // Add edge from kill to pinch | |
| 2699 later_def = NULL; // and no later def | |
| 2700 } | |
| 2701 pinch->set_req(0,later_def); // Hook later def so we can find it | |
| 2702 } else { // Else have valid pinch point | |
| 2703 if( pinch->in(0) ) // If there is a later-def | |
| 2704 later_def = pinch->in(0); // Get it | |
| 2705 } | |
| 2706 | |
| 2707 // Add output-dependence edge from later def to kill | |
| 2708 if( later_def ) // If there is some original def | |
| 2709 add_prec_edge_from_to(later_def,kill); // Add edge from def to kill | |
| 2710 | |
| 2711 // See if current kill is also a use, and so is forced to be the pinch-point. | |
| 2712 if( pinch->Opcode() == Op_Node ) { | |
| 2713 Node *uses = kill->is_Proj() ? kill->in(0) : kill; | |
| 2714 for( uint i=1; i<uses->req(); i++ ) { | |
| 2715 if( _regalloc->get_reg_first(uses->in(i)) == def_reg || | |
| 2716 _regalloc->get_reg_second(uses->in(i)) == def_reg ) { | |
| 2717 // Yes, found a use/kill pinch-point | |
| 2718 pinch->set_req(0,NULL); // | |
| 2719 pinch->replace_by(kill); // Move anti-dep edges up | |
| 2720 pinch = kill; | |
| 2721 _reg_node.map(def_reg,pinch); | |
| 2722 return; | |
| 2723 } | |
| 2724 } | |
| 2725 } | |
| 2726 | |
| 2727 // Add edge from kill to pinch-point | |
| 2728 add_prec_edge_from_to(kill,pinch); | |
| 2729 } | |
| 2730 | |
| 2731 //------------------------------anti_do_use------------------------------------ | |
| 2732 void Scheduling::anti_do_use( Block *b, Node *use, OptoReg::Name use_reg ) { | |
| 2733 if( !OptoReg::is_valid(use_reg) ) // Ignore stores & control flow | |
| 2734 return; | |
| 2735 Node *pinch = _reg_node[use_reg]; // Get pinch point | |
| 2736 // Check for no later def_reg/kill in block | |
| 2737 if( pinch && _bbs[pinch->_idx] == b && | |
| 2738 // Use has to be block-local as well | |
| 2739 _bbs[use->_idx] == b ) { | |
| 2740 if( pinch->Opcode() == Op_Node && // Real pinch-point (not optimistic?) | |
| 2741 pinch->req() == 1 ) { // pinch not yet in block? | |
| 2742 pinch->del_req(0); // yank pointer to later-def, also set flag | |
| 2743 // Insert the pinch-point in the block just after the last use | |
| 2744 b->_nodes.insert(b->find_node(use)+1,pinch); | |
| 2745 _bb_end++; // Increase size scheduled region in block | |
| 2746 } | |
| 2747 | |
| 2748 add_prec_edge_from_to(pinch,use); | |
| 2749 } | |
| 2750 } | |
| 2751 | |
| 2752 //------------------------------ComputeRegisterAntidependences----------------- | |
| 2753 // We insert antidependences between the reads and following write of | |
| 2754 // allocated registers to prevent illegal code motion. Hopefully, the | |
| 2755 // number of added references should be fairly small, especially as we | |
| 2756 // are only adding references within the current basic block. | |
| 2757 void Scheduling::ComputeRegisterAntidependencies(Block *b) { | |
| 2758 | |
| 2759 #ifdef ASSERT | |
| 2760 verify_good_schedule(b,"before block local scheduling"); | |
| 2761 #endif | |
| 2762 | |
| 2763 // A valid schedule, for each register independently, is an endless cycle | |
| 2764 // of: a def, then some uses (connected to the def by true dependencies), | |
| 2765 // then some kills (defs with no uses), finally the cycle repeats with a new | |
| 2766 // def. The uses are allowed to float relative to each other, as are the | |
| 2767 // kills. No use is allowed to slide past a kill (or def). This requires | |
| 2768 // antidependencies between all uses of a single def and all kills that | |
| 2769 // follow, up to the next def. More edges are redundant, because later defs | |
| 2770 // & kills are already serialized with true or antidependencies. To keep | |
| 2771 // the edge count down, we add a 'pinch point' node if there's more than | |
| 2772 // one use or more than one kill/def. | |
| 2773 | |
| 2774 // We add dependencies in one bottom-up pass. | |
| 2775 | |
| 2776 // For each instruction we handle it's DEFs/KILLs, then it's USEs. | |
| 2777 | |
| 2778 // For each DEF/KILL, we check to see if there's a prior DEF/KILL for this | |
| 2779 // register. If not, we record the DEF/KILL in _reg_node, the | |
| 2780 // register-to-def mapping. If there is a prior DEF/KILL, we insert a | |
| 2781 // "pinch point", a new Node that's in the graph but not in the block. | |
| 2782 // We put edges from the prior and current DEF/KILLs to the pinch point. | |
| 2783 // We put the pinch point in _reg_node. If there's already a pinch point | |
| 2784 // we merely add an edge from the current DEF/KILL to the pinch point. | |
| 2785 | |
| 2786 // After doing the DEF/KILLs, we handle USEs. For each used register, we | |
| 2787 // put an edge from the pinch point to the USE. | |
| 2788 | |
| 2789 // To be expedient, the _reg_node array is pre-allocated for the whole | |
| 2790 // compilation. _reg_node is lazily initialized; it either contains a NULL, | |
| 2791 // or a valid def/kill/pinch-point, or a leftover node from some prior | |
| 2792 // block. Leftover node from some prior block is treated like a NULL (no | |
| 2793 // prior def, so no anti-dependence needed). Valid def is distinguished by | |
| 2794 // it being in the current block. | |
| 2795 bool fat_proj_seen = false; | |
| 2796 uint last_safept = _bb_end-1; | |
| 2797 Node* end_node = (_bb_end-1 >= _bb_start) ? b->_nodes[last_safept] : NULL; | |
| 2798 Node* last_safept_node = end_node; | |
| 2799 for( uint i = _bb_end-1; i >= _bb_start; i-- ) { | |
| 2800 Node *n = b->_nodes[i]; | |
| 2801 int is_def = n->outcnt(); // def if some uses prior to adding precedence edges | |
| 3842 | 2802 if( n->is_MachProj() && n->ideal_reg() == MachProjNode::fat_proj ) { |
| 0 | 2803 // Fat-proj kills a slew of registers |
| 2804 // This can add edges to 'n' and obscure whether or not it was a def, | |
| 2805 // hence the is_def flag. | |
| 2806 fat_proj_seen = true; | |
| 2807 RegMask rm = n->out_RegMask();// Make local copy | |
| 2808 while( rm.is_NotEmpty() ) { | |
| 2809 OptoReg::Name kill = rm.find_first_elem(); | |
| 2810 rm.Remove(kill); | |
| 2811 anti_do_def( b, n, kill, is_def ); | |
| 2812 } | |
| 2813 } else { | |
| 2814 // Get DEF'd registers the normal way | |
| 2815 anti_do_def( b, n, _regalloc->get_reg_first(n), is_def ); | |
| 2816 anti_do_def( b, n, _regalloc->get_reg_second(n), is_def ); | |
| 2817 } | |
| 2818 | |
| 3851 | 2819 // Kill projections on a branch should appear to occur on the |
| 2820 // branch, not afterwards, so grab the masks from the projections | |
| 2821 // and process them. | |
|
3853
11211f7cb5a0
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
3851
diff
changeset
|
2822 if (n->is_MachBranch() || n->is_Mach() && n->as_Mach()->ideal_Opcode() == Op_Jump) { |
| 3851 | 2823 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) { |
| 2824 Node* use = n->fast_out(i); | |
| 2825 if (use->is_Proj()) { | |
| 2826 RegMask rm = use->out_RegMask();// Make local copy | |
| 2827 while( rm.is_NotEmpty() ) { | |
| 2828 OptoReg::Name kill = rm.find_first_elem(); | |
| 2829 rm.Remove(kill); | |
| 2830 anti_do_def( b, n, kill, false ); | |
| 2831 } | |
| 2832 } | |
| 2833 } | |
| 2834 } | |
| 2835 | |
| 0 | 2836 // Check each register used by this instruction for a following DEF/KILL |
| 2837 // that must occur afterward and requires an anti-dependence edge. | |
| 2838 for( uint j=0; j<n->req(); j++ ) { | |
| 2839 Node *def = n->in(j); | |
| 2840 if( def ) { | |
| 3842 | 2841 assert( !def->is_MachProj() || def->ideal_reg() != MachProjNode::fat_proj, "" ); |
| 0 | 2842 anti_do_use( b, n, _regalloc->get_reg_first(def) ); |
| 2843 anti_do_use( b, n, _regalloc->get_reg_second(def) ); | |
| 2844 } | |
| 2845 } | |
| 2846 // Do not allow defs of new derived values to float above GC | |
| 2847 // points unless the base is definitely available at the GC point. | |
| 2848 | |
| 2849 Node *m = b->_nodes[i]; | |
| 2850 | |
| 2851 // Add precedence edge from following safepoint to use of derived pointer | |
| 2852 if( last_safept_node != end_node && | |
| 2853 m != last_safept_node) { | |
| 2854 for (uint k = 1; k < m->req(); k++) { | |
| 2855 const Type *t = m->in(k)->bottom_type(); | |
| 2856 if( t->isa_oop_ptr() && | |
| 2857 t->is_ptr()->offset() != 0 ) { | |
| 2858 last_safept_node->add_prec( m ); | |
| 2859 break; | |
| 2860 } | |
| 2861 } | |
| 2862 } | |
| 2863 | |
| 2864 if( n->jvms() ) { // Precedence edge from derived to safept | |
| 2865 // Check if last_safept_node was moved by pinch-point insertion in anti_do_use() | |
| 2866 if( b->_nodes[last_safept] != last_safept_node ) { | |
| 2867 last_safept = b->find_node(last_safept_node); | |
| 2868 } | |
| 2869 for( uint j=last_safept; j > i; j-- ) { | |
| 2870 Node *mach = b->_nodes[j]; | |
| 2871 if( mach->is_Mach() && mach->as_Mach()->ideal_Opcode() == Op_AddP ) | |
| 2872 mach->add_prec( n ); | |
| 2873 } | |
| 2874 last_safept = i; | |
| 2875 last_safept_node = m; | |
| 2876 } | |
| 2877 } | |
| 2878 | |
| 2879 if (fat_proj_seen) { | |
| 2880 // Garbage collect pinch nodes that were not consumed. | |
| 2881 // They are usually created by a fat kill MachProj for a call. | |
| 2882 garbage_collect_pinch_nodes(); | |
| 2883 } | |
| 2884 } | |
| 2885 | |
| 2886 //------------------------------garbage_collect_pinch_nodes------------------------------- | |
| 2887 | |
| 2888 // Garbage collect pinch nodes for reuse by other blocks. | |
| 2889 // | |
| 2890 // The block scheduler's insertion of anti-dependence | |
| 2891 // edges creates many pinch nodes when the block contains | |
| 2892 // 2 or more Calls. A pinch node is used to prevent a | |
| 2893 // combinatorial explosion of edges. If a set of kills for a | |
| 2894 // register is anti-dependent on a set of uses (or defs), rather | |
| 2895 // than adding an edge in the graph between each pair of kill | |
| 2896 // and use (or def), a pinch is inserted between them: | |
| 2897 // | |
| 2898 // use1 use2 use3 | |
| 2899 // \ | / | |
| 2900 // \ | / | |
| 2901 // pinch | |
| 2902 // / | \ | |
| 2903 // / | \ | |
| 2904 // kill1 kill2 kill3 | |
| 2905 // | |
| 2906 // One pinch node is created per register killed when | |
| 2907 // the second call is encountered during a backwards pass | |
| 2908 // over the block. Most of these pinch nodes are never | |
| 2909 // wired into the graph because the register is never | |
| 2910 // used or def'ed in the block. | |
| 2911 // | |
| 2912 void Scheduling::garbage_collect_pinch_nodes() { | |
| 2913 #ifndef PRODUCT | |
| 2914 if (_cfg->C->trace_opto_output()) tty->print("Reclaimed pinch nodes:"); | |
| 2915 #endif | |
| 2916 int trace_cnt = 0; | |
| 2917 for (uint k = 0; k < _reg_node.Size(); k++) { | |
| 2918 Node* pinch = _reg_node[k]; | |
| 2919 if (pinch != NULL && pinch->Opcode() == Op_Node && | |
| 2920 // no predecence input edges | |
| 2921 (pinch->req() == pinch->len() || pinch->in(pinch->req()) == NULL) ) { | |
| 2922 cleanup_pinch(pinch); | |
| 2923 _pinch_free_list.push(pinch); | |
| 2924 _reg_node.map(k, NULL); | |
| 2925 #ifndef PRODUCT | |
| 2926 if (_cfg->C->trace_opto_output()) { | |
| 2927 trace_cnt++; | |
| 2928 if (trace_cnt > 40) { | |
| 2929 tty->print("\n"); | |
| 2930 trace_cnt = 0; | |
| 2931 } | |
| 2932 tty->print(" %d", pinch->_idx); | |
| 2933 } | |
| 2934 #endif | |
| 2935 } | |
| 2936 } | |
| 2937 #ifndef PRODUCT | |
| 2938 if (_cfg->C->trace_opto_output()) tty->print("\n"); | |
| 2939 #endif | |
| 2940 } | |
| 2941 | |
| 2942 // Clean up a pinch node for reuse. | |
| 2943 void Scheduling::cleanup_pinch( Node *pinch ) { | |
| 2944 assert (pinch && pinch->Opcode() == Op_Node && pinch->req() == 1, "just checking"); | |
| 2945 | |
| 2946 for (DUIterator_Last imin, i = pinch->last_outs(imin); i >= imin; ) { | |
| 2947 Node* use = pinch->last_out(i); | |
| 2948 uint uses_found = 0; | |
| 2949 for (uint j = use->req(); j < use->len(); j++) { | |
| 2950 if (use->in(j) == pinch) { | |
| 2951 use->rm_prec(j); | |
| 2952 uses_found++; | |
| 2953 } | |
| 2954 } | |
| 2955 assert(uses_found > 0, "must be a precedence edge"); | |
| 2956 i -= uses_found; // we deleted 1 or more copies of this edge | |
| 2957 } | |
| 2958 // May have a later_def entry | |
| 2959 pinch->set_req(0, NULL); | |
| 2960 } | |
| 2961 | |
| 2962 //------------------------------print_statistics------------------------------- | |
| 2963 #ifndef PRODUCT | |
| 2964 | |
| 2965 void Scheduling::dump_available() const { | |
| 2966 tty->print("#Availist "); | |
| 2967 for (uint i = 0; i < _available.size(); i++) | |
| 2968 tty->print(" N%d/l%d", _available[i]->_idx,_current_latency[_available[i]->_idx]); | |
| 2969 tty->cr(); | |
| 2970 } | |
| 2971 | |
| 2972 // Print Scheduling Statistics | |
| 2973 void Scheduling::print_statistics() { | |
| 2974 // Print the size added by nops for bundling | |
| 2975 tty->print("Nops added %d bytes to total of %d bytes", | |
| 2976 _total_nop_size, _total_method_size); | |
| 2977 if (_total_method_size > 0) | |
| 2978 tty->print(", for %.2f%%", | |
| 2979 ((double)_total_nop_size) / ((double) _total_method_size) * 100.0); | |
| 2980 tty->print("\n"); | |
| 2981 | |
| 2982 // Print the number of branch shadows filled | |
| 2983 if (Pipeline::_branch_has_delay_slot) { | |
| 2984 tty->print("Of %d branches, %d had unconditional delay slots filled", | |
| 2985 _total_branches, _total_unconditional_delays); | |
| 2986 if (_total_branches > 0) | |
| 2987 tty->print(", for %.2f%%", | |
| 2988 ((double)_total_unconditional_delays) / ((double)_total_branches) * 100.0); | |
| 2989 tty->print("\n"); | |
| 2990 } | |
| 2991 | |
| 2992 uint total_instructions = 0, total_bundles = 0; | |
| 2993 | |
| 2994 for (uint i = 1; i <= Pipeline::_max_instrs_per_cycle; i++) { | |
| 2995 uint bundle_count = _total_instructions_per_bundle[i]; | |
| 2996 total_instructions += bundle_count * i; | |
| 2997 total_bundles += bundle_count; | |
| 2998 } | |
| 2999 | |
| 3000 if (total_bundles > 0) | |
| 3001 tty->print("Average ILP (excluding nops) is %.2f\n", | |
| 3002 ((double)total_instructions) / ((double)total_bundles)); | |
| 3003 } | |
| 3004 #endif |