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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "asm/assembler.inline.hpp"
26 #include "code/compiledIC.hpp"
27 #include "code/debugInfo.hpp"
28 #include "code/debugInfoRec.hpp"
29 #include "compiler/compileBroker.hpp"
30 #include "compiler/compilerDirectives.hpp"
31 #include "compiler/disassembler.hpp"
32 #include "compiler/oopMap.hpp"
33 #include "gc/shared/barrierSet.hpp"
34 #include "gc/shared/c2/barrierSetC2.hpp"
35 #include "memory/allocation.hpp"
36 #include "opto/ad.hpp"
37 #include "opto/block.hpp"
38 #include "opto/c2compiler.hpp"
39 #include "opto/c2_MacroAssembler.hpp"
40 #include "opto/callnode.hpp"
41 #include "opto/cfgnode.hpp"
42 #include "opto/locknode.hpp"
43 #include "opto/machnode.hpp"
44 #include "opto/node.hpp"
45 #include "opto/optoreg.hpp"
46 #include "opto/output.hpp"
47 #include "opto/regalloc.hpp"
48 #include "opto/type.hpp"
49 #include "runtime/sharedRuntime.hpp"
50 #include "utilities/macros.hpp"
51 #include "utilities/powerOfTwo.hpp"
52 #include "utilities/xmlstream.hpp"
53
223 _first_block_size(0),
224 _handler_table(),
225 _inc_table(),
226 _stub_list(),
227 _oop_map_set(nullptr),
228 _scratch_buffer_blob(nullptr),
229 _scratch_locs_memory(nullptr),
230 _scratch_const_size(-1),
231 _in_scratch_emit_size(false),
232 _frame_slots(0),
233 _code_offsets(),
234 _node_bundling_limit(0),
235 _node_bundling_base(nullptr),
236 _orig_pc_slot(0),
237 _orig_pc_slot_offset_in_bytes(0),
238 _buf_sizes(),
239 _block(nullptr),
240 _index(0) {
241 C->set_output(this);
242 if (C->stub_name() == nullptr) {
243 _orig_pc_slot = C->fixed_slots() - (sizeof(address) / VMRegImpl::stack_slot_size);
244 }
245 }
246
247 PhaseOutput::~PhaseOutput() {
248 C->set_output(nullptr);
249 if (_scratch_buffer_blob != nullptr) {
250 BufferBlob::free(_scratch_buffer_blob);
251 }
252 }
253
254 void PhaseOutput::perform_mach_node_analysis() {
255 // Late barrier analysis must be done after schedule and bundle
256 // Otherwise liveness based spilling will fail
257 BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
258 bs->late_barrier_analysis();
259
260 pd_perform_mach_node_analysis();
261
262 C->print_method(CompilerPhaseType::PHASE_MACH_ANALYSIS, 3);
263 }
264
265 // Convert Nodes to instruction bits and pass off to the VM
266 void PhaseOutput::Output() {
267 // RootNode goes
268 assert( C->cfg()->get_root_block()->number_of_nodes() == 0, "" );
269
270 // The number of new nodes (mostly MachNop) is proportional to
271 // the number of java calls and inner loops which are aligned.
272 if ( C->check_node_count((NodeLimitFudgeFactor + C->java_calls()*3 +
273 C->inner_loops()*(OptoLoopAlignment-1)),
274 "out of nodes before code generation" ) ) {
275 return;
276 }
277 // Make sure I can find the Start Node
278 Block *entry = C->cfg()->get_block(1);
279 Block *broot = C->cfg()->get_root_block();
280
281 const StartNode *start = entry->head()->as_Start();
282
283 // Replace StartNode with prolog
284 MachPrologNode *prolog = new MachPrologNode();
285 entry->map_node(prolog, 0);
286 C->cfg()->map_node_to_block(prolog, entry);
287 C->cfg()->unmap_node_from_block(start); // start is no longer in any block
288
289 // Virtual methods need an unverified entry point
290
291 if( C->is_osr_compilation() ) {
292 if( PoisonOSREntry ) {
293 // TODO: Should use a ShouldNotReachHereNode...
294 C->cfg()->insert( broot, 0, new MachBreakpointNode() );
295 }
296 } else {
297 if( C->method() && !C->method()->flags().is_static() ) {
298 // Insert unvalidated entry point
299 C->cfg()->insert( broot, 0, new MachUEPNode() );
300 }
301
302 }
303
304 // Break before main entry point
305 if ((C->method() && C->directive()->BreakAtExecuteOption) ||
306 (OptoBreakpoint && C->is_method_compilation()) ||
307 (OptoBreakpointOSR && C->is_osr_compilation()) ||
308 (OptoBreakpointC2R && !C->method()) ) {
309 // checking for C->method() means that OptoBreakpoint does not apply to
310 // runtime stubs or frame converters
311 C->cfg()->insert( entry, 1, new MachBreakpointNode() );
312 }
313
314 // Insert epilogs before every return
315 for (uint i = 0; i < C->cfg()->number_of_blocks(); i++) {
316 Block* block = C->cfg()->get_block(i);
317 if (!block->is_connector() && block->non_connector_successor(0) == C->cfg()->get_root_block()) { // Found a program exit point?
318 Node* m = block->end();
319 if (m->is_Mach() && m->as_Mach()->ideal_Opcode() != Op_Halt) {
320 MachEpilogNode* epilog = new MachEpilogNode(m->as_Mach()->ideal_Opcode() == Op_Return);
321 block->add_inst(epilog);
322 C->cfg()->map_node_to_block(epilog, block);
323 }
324 }
325 }
326
327 // Keeper of sizing aspects
328 _buf_sizes = BufferSizingData();
329
330 // Initialize code buffer
331 estimate_buffer_size(_buf_sizes._const);
332 if (C->failing()) return;
333
334 // Pre-compute the length of blocks and replace
335 // long branches with short if machine supports it.
336 // Must be done before ScheduleAndBundle due to SPARC delay slots
337 uint* blk_starts = NEW_RESOURCE_ARRAY(uint, C->cfg()->number_of_blocks() + 1);
338 blk_starts[0] = 0;
339 shorten_branches(blk_starts);
340
341 ScheduleAndBundle();
342 if (C->failing()) {
343 return;
344 }
345
346 perform_mach_node_analysis();
347
348 // Complete sizing of codebuffer
349 CodeBuffer* cb = init_buffer();
350 if (cb == nullptr || C->failing()) {
351 return;
352 }
353
354 BuildOopMaps();
355
356 if (C->failing()) {
357 return;
358 }
359
360 C2_MacroAssembler masm(cb);
482 // Sum all instruction sizes to compute block size
483 uint last_inst = block->number_of_nodes();
484 uint blk_size = 0;
485 for (uint j = 0; j < last_inst; j++) {
486 _index = j;
487 Node* nj = block->get_node(_index);
488 // Handle machine instruction nodes
489 if (nj->is_Mach()) {
490 MachNode* mach = nj->as_Mach();
491 blk_size += (mach->alignment_required() - 1) * relocInfo::addr_unit(); // assume worst case padding
492 reloc_size += mach->reloc();
493 if (mach->is_MachCall()) {
494 // add size information for trampoline stub
495 // class CallStubImpl is platform-specific and defined in the *.ad files.
496 stub_size += CallStubImpl::size_call_trampoline();
497 reloc_size += CallStubImpl::reloc_call_trampoline();
498
499 MachCallNode *mcall = mach->as_MachCall();
500 // This destination address is NOT PC-relative
501
502 mcall->method_set((intptr_t)mcall->entry_point());
503
504 if (mcall->is_MachCallJava() && mcall->as_MachCallJava()->_method) {
505 stub_size += CompiledDirectCall::to_interp_stub_size();
506 reloc_size += CompiledDirectCall::reloc_to_interp_stub();
507 }
508 } else if (mach->is_MachSafePoint()) {
509 // If call/safepoint are adjacent, account for possible
510 // nop to disambiguate the two safepoints.
511 // ScheduleAndBundle() can rearrange nodes in a block,
512 // check for all offsets inside this block.
513 if (last_call_adr >= blk_starts[i]) {
514 blk_size += nop_size;
515 }
516 }
517 if (mach->avoid_back_to_back(MachNode::AVOID_BEFORE)) {
518 // Nop is inserted between "avoid back to back" instructions.
519 // ScheduleAndBundle() can rearrange nodes in a block,
520 // check for all offsets inside this block.
521 if (last_avoid_back_to_back_adr >= blk_starts[i]) {
522 blk_size += nop_size;
737 // New functionality:
738 // Assert if the local is not top. In product mode let the new node
739 // override the old entry.
740 assert(local == C->top(), "LocArray collision");
741 if (local == C->top()) {
742 return;
743 }
744 array->pop();
745 }
746 const Type *t = local->bottom_type();
747
748 // Is it a safepoint scalar object node?
749 if (local->is_SafePointScalarObject()) {
750 SafePointScalarObjectNode* spobj = local->as_SafePointScalarObject();
751
752 ObjectValue* sv = sv_for_node_id(objs, spobj->_idx);
753 if (sv == nullptr) {
754 ciKlass* cik = t->is_oopptr()->exact_klass();
755 assert(cik->is_instance_klass() ||
756 cik->is_array_klass(), "Not supported allocation.");
757 sv = new ObjectValue(spobj->_idx,
758 new ConstantOopWriteValue(cik->java_mirror()->constant_encoding()));
759 set_sv_for_object_node(objs, sv);
760
761 uint first_ind = spobj->first_index(sfpt->jvms());
762 for (uint i = 0; i < spobj->n_fields(); i++) {
763 Node* fld_node = sfpt->in(first_ind+i);
764 (void)FillLocArray(sv->field_values()->length(), sfpt, fld_node, sv->field_values(), objs);
765 }
766 }
767 array->append(sv);
768 return;
769 } else if (local->is_SafePointScalarMerge()) {
770 SafePointScalarMergeNode* smerge = local->as_SafePointScalarMerge();
771 ObjectMergeValue* mv = (ObjectMergeValue*) sv_for_node_id(objs, smerge->_idx);
772
773 if (mv == nullptr) {
774 GrowableArray<ScopeValue*> deps;
775
776 int merge_pointer_idx = smerge->merge_pointer_idx(sfpt->jvms());
777 (void)FillLocArray(0, sfpt, sfpt->in(merge_pointer_idx), &deps, objs);
778 assert(deps.length() == 1, "missing value");
779
780 int selector_idx = smerge->selector_idx(sfpt->jvms());
781 (void)FillLocArray(1, nullptr, sfpt->in(selector_idx), &deps, nullptr);
988 continue;
989 }
990
991 ObjectValue* other = sv_for_node_id(objs, n->_idx);
992 if (ov == other) {
993 return true;
994 }
995 }
996 return false;
997 }
998
999 //--------------------------Process_OopMap_Node--------------------------------
1000 void PhaseOutput::Process_OopMap_Node(MachNode *mach, int current_offset) {
1001 // Handle special safepoint nodes for synchronization
1002 MachSafePointNode *sfn = mach->as_MachSafePoint();
1003 MachCallNode *mcall;
1004
1005 int safepoint_pc_offset = current_offset;
1006 bool is_method_handle_invoke = false;
1007 bool return_oop = false;
1008 bool has_ea_local_in_scope = sfn->_has_ea_local_in_scope;
1009 bool arg_escape = false;
1010
1011 // Add the safepoint in the DebugInfoRecorder
1012 if( !mach->is_MachCall() ) {
1013 mcall = nullptr;
1014 C->debug_info()->add_safepoint(safepoint_pc_offset, sfn->_oop_map);
1015 } else {
1016 mcall = mach->as_MachCall();
1017
1018 // Is the call a MethodHandle call?
1019 if (mcall->is_MachCallJava()) {
1020 if (mcall->as_MachCallJava()->_method_handle_invoke) {
1021 assert(C->has_method_handle_invokes(), "must have been set during call generation");
1022 is_method_handle_invoke = true;
1023 }
1024 arg_escape = mcall->as_MachCallJava()->_arg_escape;
1025 }
1026
1027 // Check if a call returns an object.
1028 if (mcall->returns_pointer()) {
1029 return_oop = true;
1030 }
1031 safepoint_pc_offset += mcall->ret_addr_offset();
1032 C->debug_info()->add_safepoint(safepoint_pc_offset, mcall->_oop_map);
1033 }
1034
1035 // Loop over the JVMState list to add scope information
1036 // Do not skip safepoints with a null method, they need monitor info
1037 JVMState* youngest_jvms = sfn->jvms();
1038 int max_depth = youngest_jvms->depth();
1039
1040 // Allocate the object pool for scalar-replaced objects -- the map from
1041 // small-integer keys (which can be recorded in the local and ostack
1042 // arrays) to descriptions of the object state.
1043 GrowableArray<ScopeValue*> *objs = new GrowableArray<ScopeValue*>();
1044
1045 // Visit scopes from oldest to youngest.
1046 for (int depth = 1; depth <= max_depth; depth++) {
1047 JVMState* jvms = youngest_jvms->of_depth(depth);
1048 int idx;
1049 ciMethod* method = jvms->has_method() ? jvms->method() : nullptr;
1050 // Safepoints that do not have method() set only provide oop-map and monitor info
1189 DebugToken *expvals = C->debug_info()->create_scope_values(exparray);
1190 DebugToken *monvals = C->debug_info()->create_monitor_values(monarray);
1191
1192 // Make method available for all Safepoints
1193 ciMethod* scope_method = method ? method : C->method();
1194 // Describe the scope here
1195 assert(jvms->bci() >= InvocationEntryBci && jvms->bci() <= 0x10000, "must be a valid or entry BCI");
1196 assert(!jvms->should_reexecute() || depth == max_depth, "reexecute allowed only for the youngest");
1197 // Now we can describe the scope.
1198 methodHandle null_mh;
1199 bool rethrow_exception = false;
1200 C->debug_info()->describe_scope(
1201 safepoint_pc_offset,
1202 null_mh,
1203 scope_method,
1204 jvms->bci(),
1205 jvms->should_reexecute(),
1206 rethrow_exception,
1207 is_method_handle_invoke,
1208 return_oop,
1209 has_ea_local_in_scope,
1210 arg_escape,
1211 locvals,
1212 expvals,
1213 monvals
1214 );
1215 } // End jvms loop
1216
1217 // Mark the end of the scope set.
1218 C->debug_info()->end_safepoint(safepoint_pc_offset);
1219 }
1220
1221
1222
1223 // A simplified version of Process_OopMap_Node, to handle non-safepoints.
1224 class NonSafepointEmitter {
1225 Compile* C;
1226 JVMState* _pending_jvms;
1227 int _pending_offset;
1228
1564 MachNode *nop = new MachNopNode(nops_cnt);
1565 block->insert_node(nop, j++);
1566 last_inst++;
1567 C->cfg()->map_node_to_block(nop, block);
1568 // Ensure enough space.
1569 masm->code()->insts()->maybe_expand_to_ensure_remaining(MAX_inst_size);
1570 if ((masm->code()->blob() == nullptr) || (!CompileBroker::should_compile_new_jobs())) {
1571 C->record_failure("CodeCache is full");
1572 return;
1573 }
1574 nop->emit(masm, C->regalloc());
1575 masm->code()->flush_bundle(true);
1576 current_offset = masm->offset();
1577 }
1578
1579 bool observe_safepoint = is_sfn;
1580 // Remember the start of the last call in a basic block
1581 if (is_mcall) {
1582 MachCallNode *mcall = mach->as_MachCall();
1583
1584 // This destination address is NOT PC-relative
1585 mcall->method_set((intptr_t)mcall->entry_point());
1586
1587 // Save the return address
1588 call_returns[block->_pre_order] = current_offset + mcall->ret_addr_offset();
1589
1590 observe_safepoint = mcall->guaranteed_safepoint();
1591 }
1592
1593 // sfn will be valid whenever mcall is valid now because of inheritance
1594 if (observe_safepoint) {
1595 // Handle special safepoint nodes for synchronization
1596 if (!is_mcall) {
1597 MachSafePointNode *sfn = mach->as_MachSafePoint();
1598 // !!!!! Stubs only need an oopmap right now, so bail out
1599 if (sfn->jvms()->method() == nullptr) {
1600 // Write the oopmap directly to the code blob??!!
1601 continue;
1602 }
1603 } // End synchronization
1604
1605 non_safepoints.observe_safepoint(mach->as_MachSafePoint()->jvms(),
1706 if ((node_offsets != nullptr) && (n->_idx < node_offset_limit)) {
1707 node_offsets[n->_idx] = masm->offset();
1708 }
1709 #endif
1710 assert(!C->failing_internal() || C->failure_is_artificial(), "Should not reach here if failing.");
1711
1712 // "Normal" instruction case
1713 DEBUG_ONLY(uint instr_offset = masm->offset());
1714 n->emit(masm, C->regalloc());
1715 current_offset = masm->offset();
1716
1717 // Above we only verified that there is enough space in the instruction section.
1718 // However, the instruction may emit stubs that cause code buffer expansion.
1719 // Bail out here if expansion failed due to a lack of code cache space.
1720 if (C->failing()) {
1721 return;
1722 }
1723
1724 assert(!is_mcall || (call_returns[block->_pre_order] <= (uint)current_offset),
1725 "ret_addr_offset() not within emitted code");
1726
1727 #ifdef ASSERT
1728 uint n_size = n->size(C->regalloc());
1729 if (n_size < (current_offset-instr_offset)) {
1730 MachNode* mach = n->as_Mach();
1731 n->dump();
1732 mach->dump_format(C->regalloc(), tty);
1733 tty->print_cr(" n_size (%d), current_offset (%d), instr_offset (%d)", n_size, current_offset, instr_offset);
1734 Disassembler::decode(masm->code()->insts_begin() + instr_offset, masm->code()->insts_begin() + current_offset + 1, tty);
1735 tty->print_cr(" ------------------- ");
1736 BufferBlob* blob = this->scratch_buffer_blob();
1737 address blob_begin = blob->content_begin();
1738 Disassembler::decode(blob_begin, blob_begin + n_size + 1, tty);
1739 assert(false, "wrong size of mach node");
1740 }
1741 #endif
1742 non_safepoints.observe_instruction(n, current_offset);
1743
1744 // mcall is last "call" that can be a safepoint
1745 // record it so we can see if a poll will directly follow it
1746 // in which case we'll need a pad to make the PcDesc sites unique
3142 anti_do_use( b, n, _regalloc->get_reg_first(def) );
3143 anti_do_use( b, n, _regalloc->get_reg_second(def) );
3144 }
3145 }
3146 // Do not allow defs of new derived values to float above GC
3147 // points unless the base is definitely available at the GC point.
3148
3149 Node *m = b->get_node(i);
3150
3151 // Add precedence edge from following safepoint to use of derived pointer
3152 if( last_safept_node != end_node &&
3153 m != last_safept_node) {
3154 for (uint k = 1; k < m->req(); k++) {
3155 const Type *t = m->in(k)->bottom_type();
3156 if( t->isa_oop_ptr() &&
3157 t->is_ptr()->offset() != 0 ) {
3158 last_safept_node->add_prec( m );
3159 break;
3160 }
3161 }
3162 }
3163
3164 if( n->jvms() ) { // Precedence edge from derived to safept
3165 // Check if last_safept_node was moved by pinch-point insertion in anti_do_use()
3166 if( b->get_node(last_safept) != last_safept_node ) {
3167 last_safept = b->find_node(last_safept_node);
3168 }
3169 for( uint j=last_safept; j > i; j-- ) {
3170 Node *mach = b->get_node(j);
3171 if( mach->is_Mach() && mach->as_Mach()->ideal_Opcode() == Op_AddP )
3172 mach->add_prec( n );
3173 }
3174 last_safept = i;
3175 last_safept_node = m;
3176 }
3177 }
3178
3179 if (fat_proj_seen) {
3180 // Garbage collect pinch nodes that were not consumed.
3181 // They are usually created by a fat kill MachProj for a call.
3300 }
3301 #endif
3302
3303 //-----------------------init_scratch_buffer_blob------------------------------
3304 // Construct a temporary BufferBlob and cache it for this compile.
3305 void PhaseOutput::init_scratch_buffer_blob(int const_size) {
3306 // If there is already a scratch buffer blob allocated and the
3307 // constant section is big enough, use it. Otherwise free the
3308 // current and allocate a new one.
3309 BufferBlob* blob = scratch_buffer_blob();
3310 if ((blob != nullptr) && (const_size <= _scratch_const_size)) {
3311 // Use the current blob.
3312 } else {
3313 if (blob != nullptr) {
3314 BufferBlob::free(blob);
3315 }
3316
3317 ResourceMark rm;
3318 _scratch_const_size = const_size;
3319 int size = C2Compiler::initial_code_buffer_size(const_size);
3320 blob = BufferBlob::create("Compile::scratch_buffer", size);
3321 // Record the buffer blob for next time.
3322 set_scratch_buffer_blob(blob);
3323 // Have we run out of code space?
3324 if (scratch_buffer_blob() == nullptr) {
3325 // Let CompilerBroker disable further compilations.
3326 C->record_failure("Not enough space for scratch buffer in CodeCache");
3327 return;
3328 }
3329 }
3330
3331 // Initialize the relocation buffers
3332 relocInfo* locs_buf = (relocInfo*) blob->content_end() - MAX_locs_size;
3333 set_scratch_locs_memory(locs_buf);
3334 }
3335
3336
3337 //-----------------------scratch_emit_size-------------------------------------
3338 // Helper function that computes size by emitting code
3339 uint PhaseOutput::scratch_emit_size(const Node* n) {
3370 buf.insts()->set_scratch_emit();
3371 buf.stubs()->set_scratch_emit();
3372
3373 // Do the emission.
3374
3375 Label fakeL; // Fake label for branch instructions.
3376 Label* saveL = nullptr;
3377 uint save_bnum = 0;
3378 bool is_branch = n->is_MachBranch();
3379 C2_MacroAssembler masm(&buf);
3380 masm.bind(fakeL);
3381 if (is_branch) {
3382 n->as_MachBranch()->save_label(&saveL, &save_bnum);
3383 n->as_MachBranch()->label_set(&fakeL, 0);
3384 }
3385 n->emit(&masm, C->regalloc());
3386
3387 // Emitting into the scratch buffer should not fail
3388 assert(!C->failing_internal() || C->failure_is_artificial(), "Must not have pending failure. Reason is: %s", C->failure_reason());
3389
3390 if (is_branch) // Restore label.
3391 n->as_MachBranch()->label_set(saveL, save_bnum);
3392
3393 // End scratch_emit_size section.
3394 set_in_scratch_emit_size(false);
3395
3396 return buf.insts_size();
3397 }
3398
3399 void PhaseOutput::install() {
3400 if (!C->should_install_code()) {
3401 return;
3402 } else if (C->stub_function() != nullptr) {
3403 install_stub(C->stub_name());
3404 } else {
3405 install_code(C->method(),
3406 C->entry_bci(),
3407 CompileBroker::compiler2(),
3408 C->has_unsafe_access(),
3409 SharedRuntime::is_wide_vector(C->max_vector_size()));
3410 }
3411 }
3412
3413 void PhaseOutput::install_code(ciMethod* target,
3414 int entry_bci,
3415 AbstractCompiler* compiler,
3416 bool has_unsafe_access,
3417 bool has_wide_vectors) {
3418 // Check if we want to skip execution of all compiled code.
3419 {
3420 #ifndef PRODUCT
3421 if (OptoNoExecute) {
3422 C->record_method_not_compilable("+OptoNoExecute"); // Flag as failed
3423 return;
3424 }
3425 #endif
3426 Compile::TracePhase tp(_t_registerMethod);
3427
3428 if (C->is_osr_compilation()) {
3429 _code_offsets.set_value(CodeOffsets::Verified_Entry, 0);
3430 _code_offsets.set_value(CodeOffsets::OSR_Entry, _first_block_size);
3431 } else {
3432 if (!target->is_static()) {
3433 // The UEP of an nmethod ensures that the VEP is padded. However, the padding of the UEP is placed
3434 // before the inline cache check, so we don't have to execute any nop instructions when dispatching
3435 // through the UEP, yet we can ensure that the VEP is aligned appropriately.
3436 _code_offsets.set_value(CodeOffsets::Entry, _first_block_size - MacroAssembler::ic_check_size());
3437 }
3438 _code_offsets.set_value(CodeOffsets::Verified_Entry, _first_block_size);
3439 _code_offsets.set_value(CodeOffsets::OSR_Entry, 0);
3440 }
3441
3442 C->env()->register_method(target,
3443 entry_bci,
3444 &_code_offsets,
3445 _orig_pc_slot_offset_in_bytes,
3446 code_buffer(),
3447 frame_size_in_words(),
3448 oop_map_set(),
3449 &_handler_table,
3450 inc_table(),
3451 compiler,
3452 has_unsafe_access,
3453 SharedRuntime::is_wide_vector(C->max_vector_size()),
3454 C->has_monitors(),
3455 C->has_scoped_access(),
3456 0);
3457
3458 if (C->log() != nullptr) { // Print code cache state into compiler log
3459 C->log()->code_cache_state();
3460 }
3461 }
3462 }
3463 void PhaseOutput::install_stub(const char* stub_name) {
3464 // Entry point will be accessed using stub_entry_point();
3465 if (code_buffer() == nullptr) {
3466 Matcher::soft_match_failure();
3467 } else {
3468 if (PrintAssembly && (WizardMode || Verbose))
3469 tty->print_cr("### Stub::%s", stub_name);
3470
3471 if (!C->failing()) {
3472 assert(C->fixed_slots() == 0, "no fixed slots used for runtime stubs");
3473
3474 // Make the NMethod
3475 // For now we mark the frame as never safe for profile stackwalking
3476 RuntimeStub *rs = RuntimeStub::new_runtime_stub(stub_name,
|
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "asm/assembler.inline.hpp"
26 #include "code/compiledIC.hpp"
27 #include "code/debugInfo.hpp"
28 #include "code/debugInfoRec.hpp"
29 #include "compiler/compileBroker.hpp"
30 #include "compiler/compilerDirectives.hpp"
31 #include "compiler/disassembler.hpp"
32 #include "compiler/oopMap.hpp"
33 #include "gc/shared/barrierSet.hpp"
34 #include "gc/shared/gc_globals.hpp"
35 #include "gc/shared/c2/barrierSetC2.hpp"
36 #include "memory/allocation.hpp"
37 #include "opto/ad.hpp"
38 #include "opto/block.hpp"
39 #include "opto/c2compiler.hpp"
40 #include "opto/c2_MacroAssembler.hpp"
41 #include "opto/callnode.hpp"
42 #include "opto/cfgnode.hpp"
43 #include "opto/locknode.hpp"
44 #include "opto/machnode.hpp"
45 #include "opto/node.hpp"
46 #include "opto/optoreg.hpp"
47 #include "opto/output.hpp"
48 #include "opto/regalloc.hpp"
49 #include "opto/type.hpp"
50 #include "runtime/sharedRuntime.hpp"
51 #include "utilities/macros.hpp"
52 #include "utilities/powerOfTwo.hpp"
53 #include "utilities/xmlstream.hpp"
54
224 _first_block_size(0),
225 _handler_table(),
226 _inc_table(),
227 _stub_list(),
228 _oop_map_set(nullptr),
229 _scratch_buffer_blob(nullptr),
230 _scratch_locs_memory(nullptr),
231 _scratch_const_size(-1),
232 _in_scratch_emit_size(false),
233 _frame_slots(0),
234 _code_offsets(),
235 _node_bundling_limit(0),
236 _node_bundling_base(nullptr),
237 _orig_pc_slot(0),
238 _orig_pc_slot_offset_in_bytes(0),
239 _buf_sizes(),
240 _block(nullptr),
241 _index(0) {
242 C->set_output(this);
243 if (C->stub_name() == nullptr) {
244 int fixed_slots = C->fixed_slots();
245 if (C->needs_stack_repair()) {
246 fixed_slots -= 2;
247 }
248 // TODO 8284443 Only reserve extra slot if needed
249 if (InlineTypeReturnedAsFields) {
250 fixed_slots -= 2;
251 }
252 _orig_pc_slot = fixed_slots - (sizeof(address) / VMRegImpl::stack_slot_size);
253 }
254 }
255
256 PhaseOutput::~PhaseOutput() {
257 C->set_output(nullptr);
258 if (_scratch_buffer_blob != nullptr) {
259 BufferBlob::free(_scratch_buffer_blob);
260 }
261 }
262
263 void PhaseOutput::perform_mach_node_analysis() {
264 // Late barrier analysis must be done after schedule and bundle
265 // Otherwise liveness based spilling will fail
266 BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
267 bs->late_barrier_analysis();
268
269 pd_perform_mach_node_analysis();
270
271 C->print_method(CompilerPhaseType::PHASE_MACH_ANALYSIS, 3);
272 }
273
274 // Convert Nodes to instruction bits and pass off to the VM
275 void PhaseOutput::Output() {
276 // RootNode goes
277 assert( C->cfg()->get_root_block()->number_of_nodes() == 0, "" );
278
279 // The number of new nodes (mostly MachNop) is proportional to
280 // the number of java calls and inner loops which are aligned.
281 if ( C->check_node_count((NodeLimitFudgeFactor + C->java_calls()*3 +
282 C->inner_loops()*(OptoLoopAlignment-1)),
283 "out of nodes before code generation" ) ) {
284 return;
285 }
286 // Make sure I can find the Start Node
287 Block *entry = C->cfg()->get_block(1);
288 Block *broot = C->cfg()->get_root_block();
289
290 const StartNode *start = entry->head()->as_Start();
291
292 // Replace StartNode with prolog
293 Label verified_entry;
294 MachPrologNode* prolog = new MachPrologNode(&verified_entry);
295 entry->map_node(prolog, 0);
296 C->cfg()->map_node_to_block(prolog, entry);
297 C->cfg()->unmap_node_from_block(start); // start is no longer in any block
298
299 // Virtual methods need an unverified entry point
300 if (C->is_osr_compilation()) {
301 if (PoisonOSREntry) {
302 // TODO: Should use a ShouldNotReachHereNode...
303 C->cfg()->insert( broot, 0, new MachBreakpointNode() );
304 }
305 } else {
306 if (C->method()) {
307 if (C->method()->has_scalarized_args()) {
308 // Add entry point to unpack all inline type arguments
309 C->cfg()->insert(broot, 0, new MachVEPNode(&verified_entry, /* verified */ true, /* receiver_only */ false));
310 if (!C->method()->is_static()) {
311 // Add verified/unverified entry points to only unpack inline type receiver at interface calls
312 C->cfg()->insert(broot, 0, new MachVEPNode(&verified_entry, /* verified */ false, /* receiver_only */ false));
313 C->cfg()->insert(broot, 0, new MachVEPNode(&verified_entry, /* verified */ true, /* receiver_only */ true));
314 C->cfg()->insert(broot, 0, new MachVEPNode(&verified_entry, /* verified */ false, /* receiver_only */ true));
315 }
316 } else if (!C->method()->is_static()) {
317 // Insert unvalidated entry point
318 C->cfg()->insert(broot, 0, new MachUEPNode());
319 }
320 }
321 }
322
323 // Break before main entry point
324 if ((C->method() && C->directive()->BreakAtExecuteOption) ||
325 (OptoBreakpoint && C->is_method_compilation()) ||
326 (OptoBreakpointOSR && C->is_osr_compilation()) ||
327 (OptoBreakpointC2R && !C->method()) ) {
328 // checking for C->method() means that OptoBreakpoint does not apply to
329 // runtime stubs or frame converters
330 C->cfg()->insert( entry, 1, new MachBreakpointNode() );
331 }
332
333 // Insert epilogs before every return
334 for (uint i = 0; i < C->cfg()->number_of_blocks(); i++) {
335 Block* block = C->cfg()->get_block(i);
336 if (!block->is_connector() && block->non_connector_successor(0) == C->cfg()->get_root_block()) { // Found a program exit point?
337 Node* m = block->end();
338 if (m->is_Mach() && m->as_Mach()->ideal_Opcode() != Op_Halt) {
339 MachEpilogNode* epilog = new MachEpilogNode(m->as_Mach()->ideal_Opcode() == Op_Return);
340 block->add_inst(epilog);
341 C->cfg()->map_node_to_block(epilog, block);
342 }
343 }
344 }
345
346 // Keeper of sizing aspects
347 _buf_sizes = BufferSizingData();
348
349 // Initialize code buffer
350 estimate_buffer_size(_buf_sizes._const);
351 if (C->failing()) return;
352
353 // Pre-compute the length of blocks and replace
354 // long branches with short if machine supports it.
355 // Must be done before ScheduleAndBundle due to SPARC delay slots
356 uint* blk_starts = NEW_RESOURCE_ARRAY(uint, C->cfg()->number_of_blocks() + 1);
357 blk_starts[0] = 0;
358 shorten_branches(blk_starts);
359
360 if (!C->is_osr_compilation() && C->has_scalarized_args()) {
361 // Compute the offsets of the entry points required by the inline type calling convention
362 if (!C->method()->is_static()) {
363 // We have entries at the beginning of the method, implemented by the first 4 nodes.
364 // Entry (unverified) @ offset 0
365 // Verified_Inline_Entry_RO
366 // Inline_Entry (unverified)
367 // Verified_Inline_Entry
368 uint offset = 0;
369 _code_offsets.set_value(CodeOffsets::Entry, offset);
370
371 offset += ((MachVEPNode*)broot->get_node(0))->size(C->regalloc());
372 _code_offsets.set_value(CodeOffsets::Verified_Inline_Entry_RO, offset);
373
374 offset += ((MachVEPNode*)broot->get_node(1))->size(C->regalloc());
375 _code_offsets.set_value(CodeOffsets::Inline_Entry, offset);
376
377 offset += ((MachVEPNode*)broot->get_node(2))->size(C->regalloc());
378 _code_offsets.set_value(CodeOffsets::Verified_Inline_Entry, offset);
379 } else {
380 _code_offsets.set_value(CodeOffsets::Entry, -1); // will be patched later
381 _code_offsets.set_value(CodeOffsets::Verified_Inline_Entry, 0);
382 }
383 }
384
385 ScheduleAndBundle();
386 if (C->failing()) {
387 return;
388 }
389
390 perform_mach_node_analysis();
391
392 // Complete sizing of codebuffer
393 CodeBuffer* cb = init_buffer();
394 if (cb == nullptr || C->failing()) {
395 return;
396 }
397
398 BuildOopMaps();
399
400 if (C->failing()) {
401 return;
402 }
403
404 C2_MacroAssembler masm(cb);
526 // Sum all instruction sizes to compute block size
527 uint last_inst = block->number_of_nodes();
528 uint blk_size = 0;
529 for (uint j = 0; j < last_inst; j++) {
530 _index = j;
531 Node* nj = block->get_node(_index);
532 // Handle machine instruction nodes
533 if (nj->is_Mach()) {
534 MachNode* mach = nj->as_Mach();
535 blk_size += (mach->alignment_required() - 1) * relocInfo::addr_unit(); // assume worst case padding
536 reloc_size += mach->reloc();
537 if (mach->is_MachCall()) {
538 // add size information for trampoline stub
539 // class CallStubImpl is platform-specific and defined in the *.ad files.
540 stub_size += CallStubImpl::size_call_trampoline();
541 reloc_size += CallStubImpl::reloc_call_trampoline();
542
543 MachCallNode *mcall = mach->as_MachCall();
544 // This destination address is NOT PC-relative
545
546 if (mcall->entry_point() != nullptr) {
547 mcall->method_set((intptr_t)mcall->entry_point());
548 }
549
550 if (mcall->is_MachCallJava() && mcall->as_MachCallJava()->_method) {
551 stub_size += CompiledDirectCall::to_interp_stub_size();
552 reloc_size += CompiledDirectCall::reloc_to_interp_stub();
553 }
554 } else if (mach->is_MachSafePoint()) {
555 // If call/safepoint are adjacent, account for possible
556 // nop to disambiguate the two safepoints.
557 // ScheduleAndBundle() can rearrange nodes in a block,
558 // check for all offsets inside this block.
559 if (last_call_adr >= blk_starts[i]) {
560 blk_size += nop_size;
561 }
562 }
563 if (mach->avoid_back_to_back(MachNode::AVOID_BEFORE)) {
564 // Nop is inserted between "avoid back to back" instructions.
565 // ScheduleAndBundle() can rearrange nodes in a block,
566 // check for all offsets inside this block.
567 if (last_avoid_back_to_back_adr >= blk_starts[i]) {
568 blk_size += nop_size;
783 // New functionality:
784 // Assert if the local is not top. In product mode let the new node
785 // override the old entry.
786 assert(local == C->top(), "LocArray collision");
787 if (local == C->top()) {
788 return;
789 }
790 array->pop();
791 }
792 const Type *t = local->bottom_type();
793
794 // Is it a safepoint scalar object node?
795 if (local->is_SafePointScalarObject()) {
796 SafePointScalarObjectNode* spobj = local->as_SafePointScalarObject();
797
798 ObjectValue* sv = sv_for_node_id(objs, spobj->_idx);
799 if (sv == nullptr) {
800 ciKlass* cik = t->is_oopptr()->exact_klass();
801 assert(cik->is_instance_klass() ||
802 cik->is_array_klass(), "Not supported allocation.");
803 uint first_ind = spobj->first_index(sfpt->jvms());
804 // Nullable, scalarized inline types have a null_marker input
805 // that needs to be checked before using the field values.
806 ScopeValue* null_marker = nullptr;
807 if (cik->is_inlinetype()) {
808 Node* null_marker_node = sfpt->in(first_ind++);
809 assert(null_marker_node != nullptr, "null_marker node not found");
810 if (!null_marker_node->is_top()) {
811 const TypeInt* null_marker_type = null_marker_node->bottom_type()->is_int();
812 if (null_marker_node->is_Con()) {
813 null_marker = new ConstantIntValue(null_marker_type->get_con());
814 } else {
815 OptoReg::Name null_marker_reg = C->regalloc()->get_reg_first(null_marker_node);
816 null_marker = new_loc_value(C->regalloc(), null_marker_reg, Location::normal);
817 }
818 }
819 }
820 sv = new ObjectValue(spobj->_idx,
821 new ConstantOopWriteValue(cik->java_mirror()->constant_encoding()), true, null_marker);
822 set_sv_for_object_node(objs, sv);
823
824 for (uint i = 0; i < spobj->n_fields(); i++) {
825 Node* fld_node = sfpt->in(first_ind+i);
826 (void)FillLocArray(sv->field_values()->length(), sfpt, fld_node, sv->field_values(), objs);
827 }
828 }
829 array->append(sv);
830 return;
831 } else if (local->is_SafePointScalarMerge()) {
832 SafePointScalarMergeNode* smerge = local->as_SafePointScalarMerge();
833 ObjectMergeValue* mv = (ObjectMergeValue*) sv_for_node_id(objs, smerge->_idx);
834
835 if (mv == nullptr) {
836 GrowableArray<ScopeValue*> deps;
837
838 int merge_pointer_idx = smerge->merge_pointer_idx(sfpt->jvms());
839 (void)FillLocArray(0, sfpt, sfpt->in(merge_pointer_idx), &deps, objs);
840 assert(deps.length() == 1, "missing value");
841
842 int selector_idx = smerge->selector_idx(sfpt->jvms());
843 (void)FillLocArray(1, nullptr, sfpt->in(selector_idx), &deps, nullptr);
1050 continue;
1051 }
1052
1053 ObjectValue* other = sv_for_node_id(objs, n->_idx);
1054 if (ov == other) {
1055 return true;
1056 }
1057 }
1058 return false;
1059 }
1060
1061 //--------------------------Process_OopMap_Node--------------------------------
1062 void PhaseOutput::Process_OopMap_Node(MachNode *mach, int current_offset) {
1063 // Handle special safepoint nodes for synchronization
1064 MachSafePointNode *sfn = mach->as_MachSafePoint();
1065 MachCallNode *mcall;
1066
1067 int safepoint_pc_offset = current_offset;
1068 bool is_method_handle_invoke = false;
1069 bool return_oop = false;
1070 bool return_scalarized = false;
1071 bool has_ea_local_in_scope = sfn->_has_ea_local_in_scope;
1072 bool arg_escape = false;
1073
1074 // Add the safepoint in the DebugInfoRecorder
1075 if( !mach->is_MachCall() ) {
1076 mcall = nullptr;
1077 C->debug_info()->add_safepoint(safepoint_pc_offset, sfn->_oop_map);
1078 } else {
1079 mcall = mach->as_MachCall();
1080
1081 // Is the call a MethodHandle call?
1082 if (mcall->is_MachCallJava()) {
1083 if (mcall->as_MachCallJava()->_method_handle_invoke) {
1084 assert(C->has_method_handle_invokes(), "must have been set during call generation");
1085 is_method_handle_invoke = true;
1086 }
1087 arg_escape = mcall->as_MachCallJava()->_arg_escape;
1088 }
1089
1090 // Check if a call returns an object.
1091 if (mcall->returns_pointer() || mcall->returns_scalarized()) {
1092 return_oop = true;
1093 }
1094 if (mcall->returns_scalarized()) {
1095 return_scalarized = true;
1096 }
1097 safepoint_pc_offset += mcall->ret_addr_offset();
1098 C->debug_info()->add_safepoint(safepoint_pc_offset, mcall->_oop_map);
1099 }
1100
1101 // Loop over the JVMState list to add scope information
1102 // Do not skip safepoints with a null method, they need monitor info
1103 JVMState* youngest_jvms = sfn->jvms();
1104 int max_depth = youngest_jvms->depth();
1105
1106 // Allocate the object pool for scalar-replaced objects -- the map from
1107 // small-integer keys (which can be recorded in the local and ostack
1108 // arrays) to descriptions of the object state.
1109 GrowableArray<ScopeValue*> *objs = new GrowableArray<ScopeValue*>();
1110
1111 // Visit scopes from oldest to youngest.
1112 for (int depth = 1; depth <= max_depth; depth++) {
1113 JVMState* jvms = youngest_jvms->of_depth(depth);
1114 int idx;
1115 ciMethod* method = jvms->has_method() ? jvms->method() : nullptr;
1116 // Safepoints that do not have method() set only provide oop-map and monitor info
1255 DebugToken *expvals = C->debug_info()->create_scope_values(exparray);
1256 DebugToken *monvals = C->debug_info()->create_monitor_values(monarray);
1257
1258 // Make method available for all Safepoints
1259 ciMethod* scope_method = method ? method : C->method();
1260 // Describe the scope here
1261 assert(jvms->bci() >= InvocationEntryBci && jvms->bci() <= 0x10000, "must be a valid or entry BCI");
1262 assert(!jvms->should_reexecute() || depth == max_depth, "reexecute allowed only for the youngest");
1263 // Now we can describe the scope.
1264 methodHandle null_mh;
1265 bool rethrow_exception = false;
1266 C->debug_info()->describe_scope(
1267 safepoint_pc_offset,
1268 null_mh,
1269 scope_method,
1270 jvms->bci(),
1271 jvms->should_reexecute(),
1272 rethrow_exception,
1273 is_method_handle_invoke,
1274 return_oop,
1275 return_scalarized,
1276 has_ea_local_in_scope,
1277 arg_escape,
1278 locvals,
1279 expvals,
1280 monvals
1281 );
1282 } // End jvms loop
1283
1284 // Mark the end of the scope set.
1285 C->debug_info()->end_safepoint(safepoint_pc_offset);
1286 }
1287
1288
1289
1290 // A simplified version of Process_OopMap_Node, to handle non-safepoints.
1291 class NonSafepointEmitter {
1292 Compile* C;
1293 JVMState* _pending_jvms;
1294 int _pending_offset;
1295
1631 MachNode *nop = new MachNopNode(nops_cnt);
1632 block->insert_node(nop, j++);
1633 last_inst++;
1634 C->cfg()->map_node_to_block(nop, block);
1635 // Ensure enough space.
1636 masm->code()->insts()->maybe_expand_to_ensure_remaining(MAX_inst_size);
1637 if ((masm->code()->blob() == nullptr) || (!CompileBroker::should_compile_new_jobs())) {
1638 C->record_failure("CodeCache is full");
1639 return;
1640 }
1641 nop->emit(masm, C->regalloc());
1642 masm->code()->flush_bundle(true);
1643 current_offset = masm->offset();
1644 }
1645
1646 bool observe_safepoint = is_sfn;
1647 // Remember the start of the last call in a basic block
1648 if (is_mcall) {
1649 MachCallNode *mcall = mach->as_MachCall();
1650
1651 if (mcall->entry_point() != nullptr) {
1652 // This destination address is NOT PC-relative
1653 mcall->method_set((intptr_t)mcall->entry_point());
1654 }
1655
1656 // Save the return address
1657 call_returns[block->_pre_order] = current_offset + mcall->ret_addr_offset();
1658
1659 observe_safepoint = mcall->guaranteed_safepoint();
1660 }
1661
1662 // sfn will be valid whenever mcall is valid now because of inheritance
1663 if (observe_safepoint) {
1664 // Handle special safepoint nodes for synchronization
1665 if (!is_mcall) {
1666 MachSafePointNode *sfn = mach->as_MachSafePoint();
1667 // !!!!! Stubs only need an oopmap right now, so bail out
1668 if (sfn->jvms()->method() == nullptr) {
1669 // Write the oopmap directly to the code blob??!!
1670 continue;
1671 }
1672 } // End synchronization
1673
1674 non_safepoints.observe_safepoint(mach->as_MachSafePoint()->jvms(),
1775 if ((node_offsets != nullptr) && (n->_idx < node_offset_limit)) {
1776 node_offsets[n->_idx] = masm->offset();
1777 }
1778 #endif
1779 assert(!C->failing_internal() || C->failure_is_artificial(), "Should not reach here if failing.");
1780
1781 // "Normal" instruction case
1782 DEBUG_ONLY(uint instr_offset = masm->offset());
1783 n->emit(masm, C->regalloc());
1784 current_offset = masm->offset();
1785
1786 // Above we only verified that there is enough space in the instruction section.
1787 // However, the instruction may emit stubs that cause code buffer expansion.
1788 // Bail out here if expansion failed due to a lack of code cache space.
1789 if (C->failing()) {
1790 return;
1791 }
1792
1793 assert(!is_mcall || (call_returns[block->_pre_order] <= (uint)current_offset),
1794 "ret_addr_offset() not within emitted code");
1795 #ifdef ASSERT
1796 uint n_size = n->size(C->regalloc());
1797 if (n_size < (current_offset-instr_offset)) {
1798 MachNode* mach = n->as_Mach();
1799 n->dump();
1800 mach->dump_format(C->regalloc(), tty);
1801 tty->print_cr(" n_size (%d), current_offset (%d), instr_offset (%d)", n_size, current_offset, instr_offset);
1802 Disassembler::decode(masm->code()->insts_begin() + instr_offset, masm->code()->insts_begin() + current_offset + 1, tty);
1803 tty->print_cr(" ------------------- ");
1804 BufferBlob* blob = this->scratch_buffer_blob();
1805 address blob_begin = blob->content_begin();
1806 Disassembler::decode(blob_begin, blob_begin + n_size + 1, tty);
1807 assert(false, "wrong size of mach node");
1808 }
1809 #endif
1810 non_safepoints.observe_instruction(n, current_offset);
1811
1812 // mcall is last "call" that can be a safepoint
1813 // record it so we can see if a poll will directly follow it
1814 // in which case we'll need a pad to make the PcDesc sites unique
3210 anti_do_use( b, n, _regalloc->get_reg_first(def) );
3211 anti_do_use( b, n, _regalloc->get_reg_second(def) );
3212 }
3213 }
3214 // Do not allow defs of new derived values to float above GC
3215 // points unless the base is definitely available at the GC point.
3216
3217 Node *m = b->get_node(i);
3218
3219 // Add precedence edge from following safepoint to use of derived pointer
3220 if( last_safept_node != end_node &&
3221 m != last_safept_node) {
3222 for (uint k = 1; k < m->req(); k++) {
3223 const Type *t = m->in(k)->bottom_type();
3224 if( t->isa_oop_ptr() &&
3225 t->is_ptr()->offset() != 0 ) {
3226 last_safept_node->add_prec( m );
3227 break;
3228 }
3229 }
3230
3231 // Do not allow a CheckCastPP node whose input is a raw pointer to
3232 // float past a safepoint. This can occur when a buffered inline
3233 // type is allocated in a loop and the CheckCastPP from that
3234 // allocation is reused outside the loop. If the use inside the
3235 // loop is scalarized the CheckCastPP will no longer be connected
3236 // to the loop safepoint. See JDK-8264340.
3237 if (m->is_Mach() && m->as_Mach()->ideal_Opcode() == Op_CheckCastPP) {
3238 Node *def = m->in(1);
3239 if (def != nullptr && def->bottom_type()->base() == Type::RawPtr) {
3240 last_safept_node->add_prec(m);
3241 }
3242 }
3243 }
3244
3245 if( n->jvms() ) { // Precedence edge from derived to safept
3246 // Check if last_safept_node was moved by pinch-point insertion in anti_do_use()
3247 if( b->get_node(last_safept) != last_safept_node ) {
3248 last_safept = b->find_node(last_safept_node);
3249 }
3250 for( uint j=last_safept; j > i; j-- ) {
3251 Node *mach = b->get_node(j);
3252 if( mach->is_Mach() && mach->as_Mach()->ideal_Opcode() == Op_AddP )
3253 mach->add_prec( n );
3254 }
3255 last_safept = i;
3256 last_safept_node = m;
3257 }
3258 }
3259
3260 if (fat_proj_seen) {
3261 // Garbage collect pinch nodes that were not consumed.
3262 // They are usually created by a fat kill MachProj for a call.
3381 }
3382 #endif
3383
3384 //-----------------------init_scratch_buffer_blob------------------------------
3385 // Construct a temporary BufferBlob and cache it for this compile.
3386 void PhaseOutput::init_scratch_buffer_blob(int const_size) {
3387 // If there is already a scratch buffer blob allocated and the
3388 // constant section is big enough, use it. Otherwise free the
3389 // current and allocate a new one.
3390 BufferBlob* blob = scratch_buffer_blob();
3391 if ((blob != nullptr) && (const_size <= _scratch_const_size)) {
3392 // Use the current blob.
3393 } else {
3394 if (blob != nullptr) {
3395 BufferBlob::free(blob);
3396 }
3397
3398 ResourceMark rm;
3399 _scratch_const_size = const_size;
3400 int size = C2Compiler::initial_code_buffer_size(const_size);
3401 if (C->has_scalarized_args()) {
3402 // Inline type entry points (MachVEPNodes) require lots of space for GC barriers and oop verification
3403 // when loading object fields from the buffered argument. Increase scratch buffer size accordingly.
3404 ciMethod* method = C->method();
3405 int barrier_size = UseZGC ? 200 : (7 DEBUG_ONLY(+ 37));
3406 int arg_num = 0;
3407 if (!method->is_static()) {
3408 if (method->is_scalarized_arg(arg_num)) {
3409 size += method->holder()->as_inline_klass()->oop_count() * barrier_size;
3410 }
3411 arg_num++;
3412 }
3413 for (ciSignatureStream str(method->signature()); !str.at_return_type(); str.next()) {
3414 if (method->is_scalarized_arg(arg_num)) {
3415 size += str.type()->as_inline_klass()->oop_count() * barrier_size;
3416 }
3417 arg_num++;
3418 }
3419 }
3420 blob = BufferBlob::create("Compile::scratch_buffer", size);
3421 // Record the buffer blob for next time.
3422 set_scratch_buffer_blob(blob);
3423 // Have we run out of code space?
3424 if (scratch_buffer_blob() == nullptr) {
3425 // Let CompilerBroker disable further compilations.
3426 C->record_failure("Not enough space for scratch buffer in CodeCache");
3427 return;
3428 }
3429 }
3430
3431 // Initialize the relocation buffers
3432 relocInfo* locs_buf = (relocInfo*) blob->content_end() - MAX_locs_size;
3433 set_scratch_locs_memory(locs_buf);
3434 }
3435
3436
3437 //-----------------------scratch_emit_size-------------------------------------
3438 // Helper function that computes size by emitting code
3439 uint PhaseOutput::scratch_emit_size(const Node* n) {
3470 buf.insts()->set_scratch_emit();
3471 buf.stubs()->set_scratch_emit();
3472
3473 // Do the emission.
3474
3475 Label fakeL; // Fake label for branch instructions.
3476 Label* saveL = nullptr;
3477 uint save_bnum = 0;
3478 bool is_branch = n->is_MachBranch();
3479 C2_MacroAssembler masm(&buf);
3480 masm.bind(fakeL);
3481 if (is_branch) {
3482 n->as_MachBranch()->save_label(&saveL, &save_bnum);
3483 n->as_MachBranch()->label_set(&fakeL, 0);
3484 }
3485 n->emit(&masm, C->regalloc());
3486
3487 // Emitting into the scratch buffer should not fail
3488 assert(!C->failing_internal() || C->failure_is_artificial(), "Must not have pending failure. Reason is: %s", C->failure_reason());
3489
3490 // Restore label.
3491 if (is_branch) {
3492 n->as_MachBranch()->label_set(saveL, save_bnum);
3493 }
3494
3495 // End scratch_emit_size section.
3496 set_in_scratch_emit_size(false);
3497
3498 return buf.insts_size();
3499 }
3500
3501 void PhaseOutput::install() {
3502 if (!C->should_install_code()) {
3503 return;
3504 } else if (C->stub_function() != nullptr) {
3505 install_stub(C->stub_name());
3506 } else {
3507 install_code(C->method(),
3508 C->entry_bci(),
3509 CompileBroker::compiler2(),
3510 C->has_unsafe_access(),
3511 SharedRuntime::is_wide_vector(C->max_vector_size()));
3512 }
3513 }
3514
3515 void PhaseOutput::install_code(ciMethod* target,
3516 int entry_bci,
3517 AbstractCompiler* compiler,
3518 bool has_unsafe_access,
3519 bool has_wide_vectors) {
3520 // Check if we want to skip execution of all compiled code.
3521 {
3522 #ifndef PRODUCT
3523 if (OptoNoExecute) {
3524 C->record_method_not_compilable("+OptoNoExecute"); // Flag as failed
3525 return;
3526 }
3527 #endif
3528 Compile::TracePhase tp(_t_registerMethod);
3529
3530 if (C->is_osr_compilation()) {
3531 _code_offsets.set_value(CodeOffsets::Verified_Entry, 0);
3532 _code_offsets.set_value(CodeOffsets::OSR_Entry, _first_block_size);
3533 } else {
3534 _code_offsets.set_value(CodeOffsets::Verified_Entry, _first_block_size);
3535 if (_code_offsets.value(CodeOffsets::Verified_Inline_Entry) == -1) {
3536 _code_offsets.set_value(CodeOffsets::Verified_Inline_Entry, _first_block_size);
3537 }
3538 if (_code_offsets.value(CodeOffsets::Verified_Inline_Entry_RO) == -1) {
3539 _code_offsets.set_value(CodeOffsets::Verified_Inline_Entry_RO, _first_block_size);
3540 }
3541 if (_code_offsets.value(CodeOffsets::Entry) == -1) {
3542 _code_offsets.set_value(CodeOffsets::Entry, _first_block_size);
3543 }
3544 _code_offsets.set_value(CodeOffsets::OSR_Entry, 0);
3545 }
3546
3547 C->env()->register_method(target,
3548 entry_bci,
3549 &_code_offsets,
3550 _orig_pc_slot_offset_in_bytes,
3551 code_buffer(),
3552 frame_size_in_words(),
3553 _oop_map_set,
3554 &_handler_table,
3555 inc_table(),
3556 compiler,
3557 has_unsafe_access,
3558 SharedRuntime::is_wide_vector(C->max_vector_size()),
3559 C->has_monitors(),
3560 C->has_scoped_access(),
3561 0);
3562
3563 if (C->log() != nullptr) { // Print code cache state into compiler log
3564 C->log()->code_cache_state();
3565 }
3566 }
3567 }
3568 void PhaseOutput::install_stub(const char* stub_name) {
3569 // Entry point will be accessed using stub_entry_point();
3570 if (code_buffer() == nullptr) {
3571 Matcher::soft_match_failure();
3572 } else {
3573 if (PrintAssembly && (WizardMode || Verbose))
3574 tty->print_cr("### Stub::%s", stub_name);
3575
3576 if (!C->failing()) {
3577 assert(C->fixed_slots() == 0, "no fixed slots used for runtime stubs");
3578
3579 // Make the NMethod
3580 // For now we mark the frame as never safe for profile stackwalking
3581 RuntimeStub *rs = RuntimeStub::new_runtime_stub(stub_name,
|