truffle: src/cpu/x86/vm/vtableStubs_x86

annotate src/cpu/x86/vm/vtableStubs_x86_32.cpp @ 20504:6948da6d7c13

8052172: Evacuation failure handling in G1 does not evacuate all objects if -XX:-G1DeferredRSUpdate is set Summary: Remove -XX:-G1DeferredRSUpdate functionality as it is racy. During evacuation failure handling, threads where evacuation failure handling occurred may try to add remembered sets to regions which remembered sets are currently being scanned. The iterator to handle the remembered set scan does not support addition of entries during scan and so may skip valid references. Reviewed-by: iveresov, brutisso, mgerdin

author	tschatzl
date	Tue, 30 Sep 2014 09:44:36 +0200
parents	78bbf4d43a14
children	52b4284cb496

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17467 diff changeset	2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 844 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 844 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: 844 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #include "precompiled.hpp"
7199 cd3d6a6b95d9 8003240: x86: move MacroAssembler into separate file twisti parents: 6725 diff changeset	26 #include "asm/macroAssembler.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27 #include "code/vtableStubs.hpp"
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12294 diff changeset	28 #include "interp_masm_x86.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #include "oops/instanceKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "oops/klassVtable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	33 #include "vmreg_x86.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34 #ifdef COMPILER2
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	35 #include "opto/runtime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	36 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	37
a61af66fc99e Initial load duke parents: diff changeset	38 // machine-dependent part of VtableStubs: create VtableStub of correct size and
a61af66fc99e Initial load duke parents: diff changeset	39 // initialize its code
a61af66fc99e Initial load duke parents: diff changeset	40
a61af66fc99e Initial load duke parents: diff changeset	41 #define __ masm->
a61af66fc99e Initial load duke parents: diff changeset	42
a61af66fc99e Initial load duke parents: diff changeset	43 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	44 extern "C" void bad_compiled_vtable_index(JavaThread* thread, oop receiver, int index);
a61af66fc99e Initial load duke parents: diff changeset	45 #endif
a61af66fc99e Initial load duke parents: diff changeset	46
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	47 // These stubs are used by the compiler only.
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	48 // Argument registers, which must be preserved:
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	49 // rcx - receiver (always first argument)
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	50 // rdx - second argument (if any)
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	51 // Other registers that might be usable:
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	52 // rax - inline cache register (is interface for itable stub)
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	53 // rbx - method (used when calling out to interpreter)
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	54 // Available now, but may become callee-save at some point:
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	55 // rsi, rdi
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	56 // Note that rax and rdx are also used for return values.
0 a61af66fc99e Initial load duke parents: diff changeset	57 //
a61af66fc99e Initial load duke parents: diff changeset	58 VtableStub* VtableStubs::create_vtable_stub(int vtable_index) {
a61af66fc99e Initial load duke parents: diff changeset	59 const int i486_code_length = VtableStub::pd_code_size_limit(true);
a61af66fc99e Initial load duke parents: diff changeset	60 VtableStub* s = new(i486_code_length) VtableStub(true, vtable_index);
12294 891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 7199 diff changeset	61 // Can be NULL if there is no free space in the code cache.
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 7199 diff changeset	62 if (s == NULL) {
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 7199 diff changeset	63 return NULL;
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 7199 diff changeset	64 }
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 7199 diff changeset	65
0 a61af66fc99e Initial load duke parents: diff changeset	66 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	67 CodeBuffer cb(s->entry_point(), i486_code_length);
a61af66fc99e Initial load duke parents: diff changeset	68 MacroAssembler* masm = new MacroAssembler(&cb);
a61af66fc99e Initial load duke parents: diff changeset	69
a61af66fc99e Initial load duke parents: diff changeset	70 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	71
a61af66fc99e Initial load duke parents: diff changeset	72 if (CountCompiledCalls) {
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 16 diff changeset	73 __ incrementl(ExternalAddress((address) SharedRuntime::nof_megamorphic_calls_addr()));
0 a61af66fc99e Initial load duke parents: diff changeset	74 }
a61af66fc99e Initial load duke parents: diff changeset	75 #endif /* PRODUCT */
a61af66fc99e Initial load duke parents: diff changeset	76
a61af66fc99e Initial load duke parents: diff changeset	77 // get receiver (need to skip return address on top of stack)
a61af66fc99e Initial load duke parents: diff changeset	78 assert(VtableStub::receiver_location() == rcx->as_VMReg(), "receiver expected in rcx");
a61af66fc99e Initial load duke parents: diff changeset	79
a61af66fc99e Initial load duke parents: diff changeset	80 // get receiver klass
a61af66fc99e Initial load duke parents: diff changeset	81 address npe_addr = __ pc();
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 16 diff changeset	82 __ movptr(rax, Address(rcx, oopDesc::klass_offset_in_bytes()));
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 1972 diff changeset	83
0 a61af66fc99e Initial load duke parents: diff changeset	84 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	85 if (DebugVtables) {
a61af66fc99e Initial load duke parents: diff changeset	86 Label L;
a61af66fc99e Initial load duke parents: diff changeset	87 // check offset vs vtable length
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	88 __ cmpl(Address(rax, InstanceKlass::vtable_length_offset()wordSize), vtable_indexvtableEntry::size());
0 a61af66fc99e Initial load duke parents: diff changeset	89 __ jcc(Assembler::greater, L);
a61af66fc99e Initial load duke parents: diff changeset	90 __ movl(rbx, vtable_index);
a61af66fc99e Initial load duke parents: diff changeset	91 __ call_VM(noreg, CAST_FROM_FN_PTR(address, bad_compiled_vtable_index), rcx, rbx);
a61af66fc99e Initial load duke parents: diff changeset	92 __ bind(L);
a61af66fc99e Initial load duke parents: diff changeset	93 }
a61af66fc99e Initial load duke parents: diff changeset	94 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	95
a61af66fc99e Initial load duke parents: diff changeset	96 const Register method = rbx;
a61af66fc99e Initial load duke parents: diff changeset	97
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	98 // load Method* and target address
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 1972 diff changeset	99 __ lookup_virtual_method(rax, vtable_index, method);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 1972 diff changeset	100
0 a61af66fc99e Initial load duke parents: diff changeset	101 if (DebugVtables) {
a61af66fc99e Initial load duke parents: diff changeset	102 Label L;
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 16 diff changeset	103 __ cmpptr(method, (int32_t)NULL_WORD);
0 a61af66fc99e Initial load duke parents: diff changeset	104 __ jcc(Assembler::equal, L);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	105 __ cmpptr(Address(method, Method::from_compiled_offset()), (int32_t)NULL_WORD);
0 a61af66fc99e Initial load duke parents: diff changeset	106 __ jcc(Assembler::notZero, L);
a61af66fc99e Initial load duke parents: diff changeset	107 __ stop("Vtable entry is NULL");
a61af66fc99e Initial load duke parents: diff changeset	108 __ bind(L);
a61af66fc99e Initial load duke parents: diff changeset	109 }
a61af66fc99e Initial load duke parents: diff changeset	110
a61af66fc99e Initial load duke parents: diff changeset	111 // rax,: receiver klass
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	112 // method (rbx): Method*
0 a61af66fc99e Initial load duke parents: diff changeset	113 // rcx: receiver
a61af66fc99e Initial load duke parents: diff changeset	114 address ame_addr = __ pc();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	115 __ jmp( Address(method, Method::from_compiled_offset()));
0 a61af66fc99e Initial load duke parents: diff changeset	116
a61af66fc99e Initial load duke parents: diff changeset	117 masm->flush();
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	118
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	119 if (PrintMiscellaneous && (WizardMode \|\| Verbose)) {
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	120 tty->print_cr("vtable #%d at "PTR_FORMAT"[%d] left over: %d",
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17467 diff changeset	121 vtable_index, p2i(s->entry_point()),
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	122 (int)(s->code_end() - s->entry_point()),
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	123 (int)(s->code_end() - __ pc()));
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	124 }
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	125 guarantee(__ pc() <= s->code_end(), "overflowed buffer");
709 1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	126 // shut the door on sizing bugs
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	127 int slop = 3; // 32-bit offset is this much larger than an 8-bit one
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	128 assert(vtable_index > 10 \|\| __ pc() + slop <= s->code_end(), "room for 32-bit offset");
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	129
0 a61af66fc99e Initial load duke parents: diff changeset	130 s->set_exception_points(npe_addr, ame_addr);
a61af66fc99e Initial load duke parents: diff changeset	131 return s;
a61af66fc99e Initial load duke parents: diff changeset	132 }
a61af66fc99e Initial load duke parents: diff changeset	133
a61af66fc99e Initial load duke parents: diff changeset	134
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	135 VtableStub* VtableStubs::create_itable_stub(int itable_index) {
0 a61af66fc99e Initial load duke parents: diff changeset	136 // Note well: pd_code_size_limit is the absolute minimum we can get away with. If you
a61af66fc99e Initial load duke parents: diff changeset	137 // add code here, bump the code stub size returned by pd_code_size_limit!
a61af66fc99e Initial load duke parents: diff changeset	138 const int i486_code_length = VtableStub::pd_code_size_limit(false);
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	139 VtableStub* s = new(i486_code_length) VtableStub(false, itable_index);
12294 891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 7199 diff changeset	140 // Can be NULL if there is no free space in the code cache.
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 7199 diff changeset	141 if (s == NULL) {
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 7199 diff changeset	142 return NULL;
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 7199 diff changeset	143 }
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 7199 diff changeset	144
0 a61af66fc99e Initial load duke parents: diff changeset	145 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	146 CodeBuffer cb(s->entry_point(), i486_code_length);
a61af66fc99e Initial load duke parents: diff changeset	147 MacroAssembler* masm = new MacroAssembler(&cb);
a61af66fc99e Initial load duke parents: diff changeset	148
a61af66fc99e Initial load duke parents: diff changeset	149 // Entry arguments:
a61af66fc99e Initial load duke parents: diff changeset	150 // rax,: Interface
a61af66fc99e Initial load duke parents: diff changeset	151 // rcx: Receiver
a61af66fc99e Initial load duke parents: diff changeset	152
a61af66fc99e Initial load duke parents: diff changeset	153 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	154 if (CountCompiledCalls) {
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 16 diff changeset	155 __ incrementl(ExternalAddress((address) SharedRuntime::nof_megamorphic_calls_addr()));
0 a61af66fc99e Initial load duke parents: diff changeset	156 }
a61af66fc99e Initial load duke parents: diff changeset	157 #endif /* PRODUCT */
a61af66fc99e Initial load duke parents: diff changeset	158 // get receiver (need to skip return address on top of stack)
a61af66fc99e Initial load duke parents: diff changeset	159
a61af66fc99e Initial load duke parents: diff changeset	160 assert(VtableStub::receiver_location() == rcx->as_VMReg(), "receiver expected in rcx");
a61af66fc99e Initial load duke parents: diff changeset	161
a61af66fc99e Initial load duke parents: diff changeset	162 // get receiver klass (also an implicit null-check)
a61af66fc99e Initial load duke parents: diff changeset	163 address npe_addr = __ pc();
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	164 __ movptr(rsi, Address(rcx, oopDesc::klass_offset_in_bytes()));
0 a61af66fc99e Initial load duke parents: diff changeset	165
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	166 // Most registers are in use; we'll use rax, rbx, rsi, rdi
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	167 // (If we need to make rsi, rdi callee-save, do a push/pop here.)
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	168 const Register method = rbx;
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	169 Label throw_icce;
0 a61af66fc99e Initial load duke parents: diff changeset	170
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	171 // Get Method* and entrypoint for compiler
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	172 __ lookup_interface_method(// inputs: rec. class, interface, itable index
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	173 rsi, rax, itable_index,
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	174 // outputs: method, scan temp. reg
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	175 method, rdi,
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	176 throw_icce);
0 a61af66fc99e Initial load duke parents: diff changeset	177
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	178 // method (rbx): Method*
0 a61af66fc99e Initial load duke parents: diff changeset	179 // rcx: receiver
a61af66fc99e Initial load duke parents: diff changeset	180
a61af66fc99e Initial load duke parents: diff changeset	181 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	182 if (DebugVtables) {
a61af66fc99e Initial load duke parents: diff changeset	183 Label L1;
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 16 diff changeset	184 __ cmpptr(method, (int32_t)NULL_WORD);
0 a61af66fc99e Initial load duke parents: diff changeset	185 __ jcc(Assembler::equal, L1);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	186 __ cmpptr(Address(method, Method::from_compiled_offset()), (int32_t)NULL_WORD);
0 a61af66fc99e Initial load duke parents: diff changeset	187 __ jcc(Assembler::notZero, L1);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	188 __ stop("Method* is null");
0 a61af66fc99e Initial load duke parents: diff changeset	189 __ bind(L1);
a61af66fc99e Initial load duke parents: diff changeset	190 }
a61af66fc99e Initial load duke parents: diff changeset	191 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	192
a61af66fc99e Initial load duke parents: diff changeset	193 address ame_addr = __ pc();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	194 __ jmp(Address(method, Method::from_compiled_offset()));
0 a61af66fc99e Initial load duke parents: diff changeset	195
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	196 __ bind(throw_icce);
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	197 __ jump(RuntimeAddress(StubRoutines::throw_IncompatibleClassChangeError_entry()));
0 a61af66fc99e Initial load duke parents: diff changeset	198 masm->flush();
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	199
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	200 if (PrintMiscellaneous && (WizardMode \|\| Verbose)) {
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	201 tty->print_cr("itable #%d at "PTR_FORMAT"[%d] left over: %d",
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17467 diff changeset	202 itable_index, p2i(s->entry_point()),
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	203 (int)(s->code_end() - s->entry_point()),
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	204 (int)(s->code_end() - __ pc()));
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	205 }
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	206 guarantee(__ pc() <= s->code_end(), "overflowed buffer");
709 1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	207 // shut the door on sizing bugs
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	208 int slop = 3; // 32-bit offset is this much larger than an 8-bit one
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	209 assert(itable_index > 10 \|\| __ pc() + slop <= s->code_end(), "room for 32-bit offset");
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	210
0 a61af66fc99e Initial load duke parents: diff changeset	211 s->set_exception_points(npe_addr, ame_addr);
a61af66fc99e Initial load duke parents: diff changeset	212 return s;
a61af66fc99e Initial load duke parents: diff changeset	213 }
a61af66fc99e Initial load duke parents: diff changeset	214
a61af66fc99e Initial load duke parents: diff changeset	215
a61af66fc99e Initial load duke parents: diff changeset	216
a61af66fc99e Initial load duke parents: diff changeset	217 int VtableStub::pd_code_size_limit(bool is_vtable_stub) {
a61af66fc99e Initial load duke parents: diff changeset	218 if (is_vtable_stub) {
a61af66fc99e Initial load duke parents: diff changeset	219 // Vtable stub size
a61af66fc99e Initial load duke parents: diff changeset	220 return (DebugVtables ? 210 : 16) + (CountCompiledCalls ? 6 : 0);
a61af66fc99e Initial load duke parents: diff changeset	221 } else {
a61af66fc99e Initial load duke parents: diff changeset	222 // Itable stub size
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	223 return (DebugVtables ? 256 : 66) + (CountCompiledCalls ? 6 : 0);
0 a61af66fc99e Initial load duke parents: diff changeset	224 }
709 1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	225 // In order to tune these parameters, run the JVM with VM options
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	226 // +PrintMiscellaneous and +WizardMode to see information about
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	227 // actual itable stubs. Look for lines like this:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	228 // itable #1 at 0x5551212[65] left over: 3
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	229 // Reduce the constants so that the "left over" number is >=3
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	230 // for the common cases.
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	231 // Do not aim at a left-over number of zero, because a
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	232 // large vtable or itable index (> 16) will require a 32-bit
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	233 // immediate displacement instead of an 8-bit one.
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	234 //
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	235 // The JVM98 app. _202_jess has a megamorphic interface call.
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	236 // The itable code looks like this:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	237 // Decoding VtableStub itbl[1]@1
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	238 // mov 0x4(%ecx),%esi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	239 // mov 0xe8(%esi),%edi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	240 // lea 0x130(%esi,%edi,4),%edi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	241 // add $0x7,%edi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	242 // and $0xfffffff8,%edi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	243 // lea 0x4(%esi),%esi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	244 // mov (%edi),%ebx
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	245 // cmp %ebx,%eax
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	246 // je success
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	247 // loop:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	248 // test %ebx,%ebx
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	249 // je throw_icce
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	250 // add $0x8,%edi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	251 // mov (%edi),%ebx
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	252 // cmp %ebx,%eax
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	253 // jne loop
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	254 // success:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	255 // mov 0x4(%edi),%edi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	256 // mov (%esi,%edi,1),%ebx
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	257 // jmp *0x44(%ebx)
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	258 // throw_icce:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	259 // jmp throw_ICCE_entry
0 a61af66fc99e Initial load duke parents: diff changeset	260 }
a61af66fc99e Initial load duke parents: diff changeset	261
a61af66fc99e Initial load duke parents: diff changeset	262 int VtableStub::pd_code_alignment() {
a61af66fc99e Initial load duke parents: diff changeset	263 return wordSize;
a61af66fc99e Initial load duke parents: diff changeset	264 }

Mercurial > hg > truffle

annotate src/cpu/x86/vm/vtableStubs_x86_32.cpp @ 20504:6948da6d7c13