truffle: src/cpu/x86/vm/vtableStubs_x86

annotate src/cpu/x86/vm/vtableStubs_x86_32.cpp @ 12355:cefad50507d8

Merge with hs25-b53

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Fri, 11 Oct 2013 10:38:03 +0200
parents	891687731b59
children	5ccbab1c69f3

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2 * Copyright (c) 1997, 2012, 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"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "interp_masm_x86_32.hpp"
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",
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	121 vtable_index, s->entry_point(),
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",
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	202 itable_index, s->entry_point(),
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 @ 12355:cefad50507d8