graal-compiler: src/share/vm/opto/output.cpp comparison

comparison src/share/vm/opto/output.cpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	562643f42b65 0bf37f737702
children	7848fc12602b

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 #include "opto/subnode.hpp"
 #include "opto/type.hpp"
 #include "runtime/handles.inline.hpp"
 #include "utilities/xmlstream.hpp"
-extern uint size_exception_handler();
-extern uint size_deopt_handler();
 #ifndef PRODUCT
 #define DEBUG_ARG(x) , x
 #else
 #define DEBUG_ARG(x)
 #endif
-extern int emit_exception_handler(CodeBuffer &cbuf);
-extern int emit_deopt_handler(CodeBuffer &cbuf);
 // Convert Nodes to instruction bits and pass off to the VM
 void Compile::Output() {
 // RootNode goes
 assert( _cfg->get_root_block()->number_of_nodes() == 0, "" );
 bool Compile::need_stack_bang(int frame_size_in_bytes) const {
 // Determine if we need to generate a stack overflow check.
 // Do it if the method is not a stub function and
 // has java calls or has frame size > vm_page_size/8.
+// The debug VM checks that deoptimization doesn't trigger an
+// unexpected stack overflow (compiled method stack banging should
+// guarantee it doesn't happen) so we always need the stack bang in
+// a debug VM.
 return (UseStackBanging && stub_function() == NULL &&
-(has_java_calls() || frame_size_in_bytes > os::vm_page_size()>>3));
+(has_java_calls() || frame_size_in_bytes > os::vm_page_size()>>3
+DEBUG_ONLY(|| true)));
 }
 bool Compile::need_register_stack_bang() const {
 // Determine if we need to generate a register stack overflow check.
 // This is only used on architectures which have split register
 if (nj->is_Mach()) {
 MachNode *mach = nj->as_Mach();
 blk_size += (mach->alignment_required() - 1) * relocInfo::addr_unit(); // assume worst case padding
 reloc_size += mach->reloc();
 if (mach->is_MachCall()) {
+// add size information for trampoline stub
+// class CallStubImpl is platform-specific and defined in the *.ad files.
+stub_size  += CallStubImpl::size_call_trampoline();
+reloc_size += CallStubImpl::reloc_call_trampoline();
 MachCallNode *mcall = mach->as_MachCall();
 // This destination address is NOT PC-relative
 mcall->method_set((intptr_t)mcall->entry_point());
 // check for all offsets inside this block.
 if (last_call_adr >= blk_starts[i]) {
 blk_size += nop_size;
 }
 }
-if (mach->avoid_back_to_back()) {
+if (mach->avoid_back_to_back(MachNode::AVOID_BEFORE)) {
 // Nop is inserted between "avoid back to back" instructions.
 // ScheduleAndBundle() can rearrange nodes in a block,
 // check for all offsets inside this block.
 if (last_avoid_back_to_back_adr >= blk_starts[i]) {
 blk_size += nop_size;
 // Remember end of call offset
 if (nj->is_MachCall() && !nj->is_MachCallLeaf()) {
 last_call_adr = blk_starts[i]+blk_size;
 }
 // Remember end of avoid_back_to_back offset
-if (nj->is_Mach() && nj->as_Mach()->avoid_back_to_back()) {
+if (nj->is_Mach() && nj->as_Mach()->avoid_back_to_back(MachNode::AVOID_AFTER)) {
 last_avoid_back_to_back_adr = blk_starts[i]+blk_size;
 }
 }
 // When the next block starts a loop, we may insert pad NOP
 // Update the jmp_size.
 int new_size = replacement->size(_regalloc);
 int diff     = br_size - new_size;
 assert(diff >= (int)nop_size, "short_branch size should be smaller");
-// Conservatively take into accound padding between
+// Conservatively take into account padding between
 // avoid_back_to_back branches. Previous branch could be
 // converted into avoid_back_to_back branch during next
 // rounds.
-if (needs_padding && replacement->avoid_back_to_back()) {
+if (needs_padding && replacement->avoid_back_to_back(MachNode::AVOID_BEFORE)) {
 jmp_offset[i] += nop_size;
 diff -= nop_size;
 }
 adjust_block_start += diff;
 block->map_node(replacement, idx);
 // The jump distance is not short, try again during next iteration.
 has_short_branch_candidate = true;
 }
 } // (mach->may_be_short_branch())
 if (mach != NULL && (mach->may_be_short_branch() ||
-mach->avoid_back_to_back())) {
+mach->avoid_back_to_back(MachNode::AVOID_AFTER))) {
 last_may_be_short_branch_adr = blk_starts[i] + jmp_offset[i] + jmp_size[i];
 }
 blk_starts[i+1] -= adjust_block_start;
 }
 }
 }
 // Compute prolog code size
 _method_size = 0;
 _frame_slots = OptoReg::reg2stack(_matcher->_old_SP)+_regalloc->_framesize;
-#ifdef IA64
+#if defined(IA64) && !defined(AIX)
 if (save_argument_registers()) {
 // 4815101: this is a stub with implicit and unknown precision fp args.
 // The usual spill mechanism can only generate stfd's in this case, which
 // doesn't work if the fp reg to spill contains a single-precision denorm.
 // Instead, we hack around the normal spill mechanism using stfspill's and
 }
 #endif
 assert(_frame_slots >= 0 && _frame_slots < 1000000, "sanity check");
 if (has_mach_constant_base_node()) {
+uint add_size = 0;
 // Fill the constant table.
 // Note:  This must happen before shorten_branches.
 for (uint i = 0; i < _cfg->number_of_blocks(); i++) {
 Block* b = _cfg->get_block(i);
 // If the node is a MachConstantNode evaluate the constant
 // value section.
 if (n->is_MachConstant()) {
 MachConstantNode* machcon = n->as_MachConstant();
 machcon->eval_constant(C);
+} else if (n->is_Mach()) {
+// On Power there are more nodes that issue constants.
+add_size += (n->as_Mach()->ins_num_consts() * 8);
 }
 }
 }
 // Calculate the offsets of the constants and the size of the
 // constant table (including the padding to the next section).
 constant_table().calculate_offsets_and_size();
-const_req = constant_table().size();
+const_req = constant_table().size() + add_size;
 }
 // Initialize the space for the BufferBlob used to find and verify
 // instruction size in MachNode::emit_size()
 init_scratch_buffer_blob(const_req);
 // Pre-compute the length of blocks and replace
 // long branches with short if machine supports it.
 shorten_branches(blk_starts, code_req, locs_req, stub_req);
 // nmethod and CodeBuffer count stubs & constants as part of method's code.
-int exception_handler_req = size_exception_handler();
+// class HandlerImpl is platform-specific and defined in the *.ad files.
-int deopt_handler_req = size_deopt_handler();
+int exception_handler_req = HandlerImpl::size_exception_handler() + MAX_stubs_size; // add marginal slop for handler
-exception_handler_req += MAX_stubs_size; // add marginal slop for handler
+int deopt_handler_req     = HandlerImpl::size_deopt_handler()     + MAX_stubs_size; // add marginal slop for handler
-deopt_handler_req += MAX_stubs_size; // add marginal slop for handler
 stub_req += MAX_stubs_size;   // ensure per-stub margin
 code_req += MAX_inst_size;    // ensure per-instruction margin
 if (StressCodeBuffers)
 code_req = const_req = stub_req = exception_handler_req = deopt_handler_req = 0x10;  // force expansion
 // Make sure safepoint node for polling is distinct from a call's
 // return by adding a nop if needed.
 if (is_sfn && !is_mcall && padding == 0 && current_offset == last_call_offset) {
 padding = nop_size;
 }
-if (padding == 0 && mach->avoid_back_to_back() &&
+if (padding == 0 && mach->avoid_back_to_back(MachNode::AVOID_BEFORE) &&
 current_offset == last_avoid_back_to_back_offset) {
 // Avoid back to back some instructions.
 padding = nop_size;
 }
 assert(delay_slot == NULL, "not expecting delay slot node");
 int br_size = n->size(_regalloc);
 int offset = blk_starts[block_num] - current_offset;
 if (block_num >= i) {
 // Current and following block's offset are not
-// finilized yet, adjust distance by the difference
+// finalized yet, adjust distance by the difference
 // between calculated and final offsets of current block.
 offset -= (blk_starts[i] - blk_offset);
 }
 // In the following code a nop could be inserted before
 // the branch which will increase the backward distance.
 // Update the jmp_size.
 int new_size = replacement->size(_regalloc);
 assert((br_size - new_size) >= (int)nop_size, "short_branch size should be smaller");
 // Insert padding between avoid_back_to_back branches.
-if (needs_padding && replacement->avoid_back_to_back()) {
+if (needs_padding && replacement->avoid_back_to_back(MachNode::AVOID_BEFORE)) {
 MachNode *nop = new (this) MachNopNode();
 block->insert_node(nop, j++);
 _cfg->map_node_to_block(nop, block);
 last_inst++;
 nop->emit(*cb, _regalloc);
 // Remember the beginning of the previous instruction, in case
 // it's followed by a flag-kill and a null-check.  Happens on
 // Intel all the time, with add-to-memory kind of opcodes.
 previous_offset = current_offset;
 }
+// Not an else-if!
+// If this is a trap based cmp then add its offset to the list.
+if (mach->is_TrapBasedCheckNode()) {
+inct_starts[inct_cnt++] = current_offset;
+}
 }
 // Verify that there is sufficient space remaining
 cb->insts()->maybe_expand_to_ensure_remaining(MAX_inst_size);
 if ((cb->blob() == NULL) || (!CompileBroker::should_compile_new_jobs())) {
 if (is_mcall) {
 last_call_offset = current_offset;
 }
-if (n->is_Mach() && n->as_Mach()->avoid_back_to_back()) {
+if (n->is_Mach() && n->as_Mach()->avoid_back_to_back(MachNode::AVOID_AFTER)) {
 // Avoid back to back some instructions.
 last_avoid_back_to_back_offset = current_offset;
 }
 // See if this instruction has a delay slot
 // ------------------
 // Fill in exception table entries.
 FillExceptionTables(inct_cnt, call_returns, inct_starts, blk_labels);
 // Only java methods have exception handlers and deopt handlers
+// class HandlerImpl is platform-specific and defined in the *.ad files.
 if (_method) {
 // Emit the exception handler code.
-_code_offsets.set_value(CodeOffsets::Exceptions, emit_exception_handler(*cb));
+_code_offsets.set_value(CodeOffsets::Exceptions, HandlerImpl::emit_exception_handler(*cb));
 // Emit the deopt handler code.
-_code_offsets.set_value(CodeOffsets::Deopt, emit_deopt_handler(*cb));
+_code_offsets.set_value(CodeOffsets::Deopt, HandlerImpl::emit_deopt_handler(*cb));
 // Emit the MethodHandle deopt handler code (if required).
 if (has_method_handle_invokes()) {
 // We can use the same code as for the normal deopt handler, we
 // just need a different entry point address.
-_code_offsets.set_value(CodeOffsets::DeoptMH, emit_deopt_handler(*cb));
+_code_offsets.set_value(CodeOffsets::DeoptMH, HandlerImpl::emit_deopt_handler(*cb));
 }
 }
 // One last check for failed CodeBuffer::expand:
 if ((cb->blob() == NULL) || (!CompileBroker::should_compile_new_jobs())) {
 if (n->is_MachNullCheck()) {
 uint block_num = block->non_connector_successor(0)->_pre_order;
 _inc_table.append(inct_starts[inct_cnt++], blk_labels[block_num].loc_pos());
 continue;
 }
+// Handle implicit exception table updates: trap instructions.
+if (n->is_Mach() && n->as_Mach()->is_TrapBasedCheckNode()) {
+uint block_num = block->non_connector_successor(0)->_pre_order;
+_inc_table.append(inct_starts[inct_cnt++], blk_labels[block_num].loc_pos());
+continue;
+}
 } // End of for all blocks fill in exception table entries
 }
 // Static Variables
 #ifndef PRODUCT

Mercurial > hg > graal-compiler

comparison src/share/vm/opto/output.cpp @ 18041:52b4284cb496