graal-compiler: src/cpu/x86/vm/vtableStubs_x86

annotate src/cpu/x86/vm/vtableStubs_x86_32.cpp @ 1818:c93c652551b5

6986944: JSR 292 assert(caller_nm->is_method_handle_return(caller_frame.pc())) failed: must be MH call site Reviewed-by: never, kvn

author	twisti
date	Fri, 24 Sep 2010 03:51:43 -0700
parents	c18cbe5936b8
children	f95d63e2154a

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 844 diff changeset	2 * Copyright (c) 1997, 2009, 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
a61af66fc99e Initial load duke parents: diff changeset	25 #include "incls/_precompiled.incl"
a61af66fc99e Initial load duke parents: diff changeset	26 #include "incls/_vtableStubs_x86_32.cpp.incl"
a61af66fc99e Initial load duke parents: diff changeset	27
a61af66fc99e Initial load duke parents: diff changeset	28 // machine-dependent part of VtableStubs: create VtableStub of correct size and
a61af66fc99e Initial load duke parents: diff changeset	29 // initialize its code
a61af66fc99e Initial load duke parents: diff changeset	30
a61af66fc99e Initial load duke parents: diff changeset	31 #define __ masm->
a61af66fc99e Initial load duke parents: diff changeset	32
a61af66fc99e Initial load duke parents: diff changeset	33 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	34 extern "C" void bad_compiled_vtable_index(JavaThread* thread, oop receiver, int index);
a61af66fc99e Initial load duke parents: diff changeset	35 #endif
a61af66fc99e Initial load duke parents: diff changeset	36
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	37 // These stubs are used by the compiler only.
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	38 // Argument registers, which must be preserved:
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	39 // rcx - receiver (always first argument)
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	40 // rdx - second argument (if any)
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	41 // Other registers that might be usable:
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	42 // 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	43 // rbx - method (used when calling out to interpreter)
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	44 // 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	45 // rsi, rdi
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	46 // Note that rax and rdx are also used for return values.
0 a61af66fc99e Initial load duke parents: diff changeset	47 //
a61af66fc99e Initial load duke parents: diff changeset	48 VtableStub* VtableStubs::create_vtable_stub(int vtable_index) {
a61af66fc99e Initial load duke parents: diff changeset	49 const int i486_code_length = VtableStub::pd_code_size_limit(true);
a61af66fc99e Initial load duke parents: diff changeset	50 VtableStub* s = new(i486_code_length) VtableStub(true, vtable_index);
a61af66fc99e Initial load duke parents: diff changeset	51 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	52 CodeBuffer cb(s->entry_point(), i486_code_length);
a61af66fc99e Initial load duke parents: diff changeset	53 MacroAssembler* masm = new MacroAssembler(&cb);
a61af66fc99e Initial load duke parents: diff changeset	54
a61af66fc99e Initial load duke parents: diff changeset	55 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	56
a61af66fc99e Initial load duke parents: diff changeset	57 if (CountCompiledCalls) {
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 16 diff changeset	58 __ incrementl(ExternalAddress((address) SharedRuntime::nof_megamorphic_calls_addr()));
0 a61af66fc99e Initial load duke parents: diff changeset	59 }
a61af66fc99e Initial load duke parents: diff changeset	60 #endif /* PRODUCT */
a61af66fc99e Initial load duke parents: diff changeset	61
a61af66fc99e Initial load duke parents: diff changeset	62 // get receiver (need to skip return address on top of stack)
a61af66fc99e Initial load duke parents: diff changeset	63 assert(VtableStub::receiver_location() == rcx->as_VMReg(), "receiver expected in rcx");
a61af66fc99e Initial load duke parents: diff changeset	64
a61af66fc99e Initial load duke parents: diff changeset	65 // get receiver klass
a61af66fc99e Initial load duke parents: diff changeset	66 address npe_addr = __ pc();
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 16 diff changeset	67 __ movptr(rax, Address(rcx, oopDesc::klass_offset_in_bytes()));
0 a61af66fc99e Initial load duke parents: diff changeset	68 // compute entry offset (in words)
a61af66fc99e Initial load duke parents: diff changeset	69 int entry_offset = instanceKlass::vtable_start_offset() + vtable_index*vtableEntry::size();
a61af66fc99e Initial load duke parents: diff changeset	70 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	71 if (DebugVtables) {
a61af66fc99e Initial load duke parents: diff changeset	72 Label L;
a61af66fc99e Initial load duke parents: diff changeset	73 // check offset vs vtable length
a61af66fc99e Initial load duke parents: diff changeset	74 __ cmpl(Address(rax, instanceKlass::vtable_length_offset()wordSize), vtable_indexvtableEntry::size());
a61af66fc99e Initial load duke parents: diff changeset	75 __ jcc(Assembler::greater, L);
a61af66fc99e Initial load duke parents: diff changeset	76 __ movl(rbx, vtable_index);
a61af66fc99e Initial load duke parents: diff changeset	77 __ call_VM(noreg, CAST_FROM_FN_PTR(address, bad_compiled_vtable_index), rcx, rbx);
a61af66fc99e Initial load duke parents: diff changeset	78 __ bind(L);
a61af66fc99e Initial load duke parents: diff changeset	79 }
a61af66fc99e Initial load duke parents: diff changeset	80 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	81
a61af66fc99e Initial load duke parents: diff changeset	82 const Register method = rbx;
a61af66fc99e Initial load duke parents: diff changeset	83
a61af66fc99e Initial load duke parents: diff changeset	84 // load methodOop and target address
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 16 diff changeset	85 __ movptr(method, Address(rax, entry_offset*wordSize + vtableEntry::method_offset_in_bytes()));
0 a61af66fc99e Initial load duke parents: diff changeset	86 if (DebugVtables) {
a61af66fc99e Initial load duke parents: diff changeset	87 Label L;
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 16 diff changeset	88 __ cmpptr(method, (int32_t)NULL_WORD);
0 a61af66fc99e Initial load duke parents: diff changeset	89 __ jcc(Assembler::equal, L);
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 16 diff changeset	90 __ cmpptr(Address(method, methodOopDesc::from_compiled_offset()), (int32_t)NULL_WORD);
0 a61af66fc99e Initial load duke parents: diff changeset	91 __ jcc(Assembler::notZero, L);
a61af66fc99e Initial load duke parents: diff changeset	92 __ stop("Vtable entry is NULL");
a61af66fc99e Initial load duke parents: diff changeset	93 __ bind(L);
a61af66fc99e Initial load duke parents: diff changeset	94 }
a61af66fc99e Initial load duke parents: diff changeset	95
a61af66fc99e Initial load duke parents: diff changeset	96 // rax,: receiver klass
a61af66fc99e Initial load duke parents: diff changeset	97 // method (rbx): methodOop
a61af66fc99e Initial load duke parents: diff changeset	98 // rcx: receiver
a61af66fc99e Initial load duke parents: diff changeset	99 address ame_addr = __ pc();
a61af66fc99e Initial load duke parents: diff changeset	100 __ jmp( Address(method, methodOopDesc::from_compiled_offset()));
a61af66fc99e Initial load duke parents: diff changeset	101
a61af66fc99e Initial load duke parents: diff changeset	102 masm->flush();
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	103
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	104 if (PrintMiscellaneous && (WizardMode \|\| Verbose)) {
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	105 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	106 vtable_index, s->entry_point(),
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	107 (int)(s->code_end() - s->entry_point()),
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	108 (int)(s->code_end() - __ pc()));
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	109 }
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	110 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	111 // shut the door on sizing bugs
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	112 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	113 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	114
0 a61af66fc99e Initial load duke parents: diff changeset	115 s->set_exception_points(npe_addr, ame_addr);
a61af66fc99e Initial load duke parents: diff changeset	116 return s;
a61af66fc99e Initial load duke parents: diff changeset	117 }
a61af66fc99e Initial load duke parents: diff changeset	118
a61af66fc99e Initial load duke parents: diff changeset	119
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	120 VtableStub* VtableStubs::create_itable_stub(int itable_index) {
0 a61af66fc99e Initial load duke parents: diff changeset	121 // Note well: pd_code_size_limit is the absolute minimum we can get away with. If you
a61af66fc99e Initial load duke parents: diff changeset	122 // add code here, bump the code stub size returned by pd_code_size_limit!
a61af66fc99e Initial load duke parents: diff changeset	123 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	124 VtableStub* s = new(i486_code_length) VtableStub(false, itable_index);
0 a61af66fc99e Initial load duke parents: diff changeset	125 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	126 CodeBuffer cb(s->entry_point(), i486_code_length);
a61af66fc99e Initial load duke parents: diff changeset	127 MacroAssembler* masm = new MacroAssembler(&cb);
a61af66fc99e Initial load duke parents: diff changeset	128
a61af66fc99e Initial load duke parents: diff changeset	129 // Entry arguments:
a61af66fc99e Initial load duke parents: diff changeset	130 // rax,: Interface
a61af66fc99e Initial load duke parents: diff changeset	131 // rcx: Receiver
a61af66fc99e Initial load duke parents: diff changeset	132
a61af66fc99e Initial load duke parents: diff changeset	133 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	134 if (CountCompiledCalls) {
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 16 diff changeset	135 __ incrementl(ExternalAddress((address) SharedRuntime::nof_megamorphic_calls_addr()));
0 a61af66fc99e Initial load duke parents: diff changeset	136 }
a61af66fc99e Initial load duke parents: diff changeset	137 #endif /* PRODUCT */
a61af66fc99e Initial load duke parents: diff changeset	138 // get receiver (need to skip return address on top of stack)
a61af66fc99e Initial load duke parents: diff changeset	139
a61af66fc99e Initial load duke parents: diff changeset	140 assert(VtableStub::receiver_location() == rcx->as_VMReg(), "receiver expected in rcx");
a61af66fc99e Initial load duke parents: diff changeset	141
a61af66fc99e Initial load duke parents: diff changeset	142 // get receiver klass (also an implicit null-check)
a61af66fc99e Initial load duke parents: diff changeset	143 address npe_addr = __ pc();
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	144 __ movptr(rsi, Address(rcx, oopDesc::klass_offset_in_bytes()));
0 a61af66fc99e Initial load duke parents: diff changeset	145
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	146 // 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	147 // (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	148 const Register method = rbx;
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	149 Label throw_icce;
0 a61af66fc99e Initial load duke parents: diff changeset	150
a61af66fc99e Initial load duke parents: diff changeset	151 // Get methodOop and entrypoint for compiler
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	152 __ 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	153 rsi, rax, itable_index,
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	154 // outputs: method, scan temp. reg
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	155 method, rdi,
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	156 throw_icce);
0 a61af66fc99e Initial load duke parents: diff changeset	157
a61af66fc99e Initial load duke parents: diff changeset	158 // method (rbx): methodOop
a61af66fc99e Initial load duke parents: diff changeset	159 // rcx: receiver
a61af66fc99e Initial load duke parents: diff changeset	160
a61af66fc99e Initial load duke parents: diff changeset	161 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	162 if (DebugVtables) {
a61af66fc99e Initial load duke parents: diff changeset	163 Label L1;
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 16 diff changeset	164 __ cmpptr(method, (int32_t)NULL_WORD);
0 a61af66fc99e Initial load duke parents: diff changeset	165 __ jcc(Assembler::equal, L1);
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 16 diff changeset	166 __ cmpptr(Address(method, methodOopDesc::from_compiled_offset()), (int32_t)NULL_WORD);
0 a61af66fc99e Initial load duke parents: diff changeset	167 __ jcc(Assembler::notZero, L1);
a61af66fc99e Initial load duke parents: diff changeset	168 __ stop("methodOop is null");
a61af66fc99e Initial load duke parents: diff changeset	169 __ bind(L1);
a61af66fc99e Initial load duke parents: diff changeset	170 }
a61af66fc99e Initial load duke parents: diff changeset	171 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	172
a61af66fc99e Initial load duke parents: diff changeset	173 address ame_addr = __ pc();
a61af66fc99e Initial load duke parents: diff changeset	174 __ jmp(Address(method, methodOopDesc::from_compiled_offset()));
a61af66fc99e Initial load duke parents: diff changeset	175
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	176 __ bind(throw_icce);
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	177 __ jump(RuntimeAddress(StubRoutines::throw_IncompatibleClassChangeError_entry()));
0 a61af66fc99e Initial load duke parents: diff changeset	178 masm->flush();
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	179
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	180 if (PrintMiscellaneous && (WizardMode \|\| Verbose)) {
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	181 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	182 itable_index, s->entry_point(),
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	183 (int)(s->code_end() - s->entry_point()),
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	184 (int)(s->code_end() - __ pc()));
9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	185 }
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	186 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	187 // shut the door on sizing bugs
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	188 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	189 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	190
0 a61af66fc99e Initial load duke parents: diff changeset	191 s->set_exception_points(npe_addr, ame_addr);
a61af66fc99e Initial load duke parents: diff changeset	192 return s;
a61af66fc99e Initial load duke parents: diff changeset	193 }
a61af66fc99e Initial load duke parents: diff changeset	194
a61af66fc99e Initial load duke parents: diff changeset	195
a61af66fc99e Initial load duke parents: diff changeset	196
a61af66fc99e Initial load duke parents: diff changeset	197 int VtableStub::pd_code_size_limit(bool is_vtable_stub) {
a61af66fc99e Initial load duke parents: diff changeset	198 if (is_vtable_stub) {
a61af66fc99e Initial load duke parents: diff changeset	199 // Vtable stub size
a61af66fc99e Initial load duke parents: diff changeset	200 return (DebugVtables ? 210 : 16) + (CountCompiledCalls ? 6 : 0);
a61af66fc99e Initial load duke parents: diff changeset	201 } else {
a61af66fc99e Initial load duke parents: diff changeset	202 // Itable stub size
623 9adddb8c0fc8 6812831: factor duplicated assembly code for megamorphic invokeinterface (for 6655638) jrose parents: 337 diff changeset	203 return (DebugVtables ? 256 : 66) + (CountCompiledCalls ? 6 : 0);
0 a61af66fc99e Initial load duke parents: diff changeset	204 }
709 1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	205 // 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	206 // +PrintMiscellaneous and +WizardMode to see information about
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	207 // 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	208 // 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	209 // 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	210 // for the common cases.
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	211 // 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	212 // 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	213 // 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	214 //
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	215 // 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	216 // The itable code looks like this:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	217 // Decoding VtableStub itbl[1]@1
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	218 // mov 0x4(%ecx),%esi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	219 // mov 0xe8(%esi),%edi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	220 // lea 0x130(%esi,%edi,4),%edi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	221 // add $0x7,%edi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	222 // and $0xfffffff8,%edi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	223 // lea 0x4(%esi),%esi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	224 // mov (%edi),%ebx
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	225 // cmp %ebx,%eax
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	226 // je success
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	227 // loop:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	228 // test %ebx,%ebx
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	229 // je throw_icce
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	230 // add $0x8,%edi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	231 // mov (%edi),%ebx
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	232 // cmp %ebx,%eax
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	233 // jne loop
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	234 // success:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	235 // mov 0x4(%edi),%edi
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	236 // mov (%esi,%edi,1),%ebx
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	237 // jmp *0x44(%ebx)
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	238 // throw_icce:
1d037ecd7960 6827505: sizing logic for vtable and itable stubs needs self-check jrose parents: 623 diff changeset	239 // jmp throw_ICCE_entry
0 a61af66fc99e Initial load duke parents: diff changeset	240 }
a61af66fc99e Initial load duke parents: diff changeset	241
a61af66fc99e Initial load duke parents: diff changeset	242 int VtableStub::pd_code_alignment() {
a61af66fc99e Initial load duke parents: diff changeset	243 return wordSize;
a61af66fc99e Initial load duke parents: diff changeset	244 }

Mercurial > hg > graal-compiler

annotate src/cpu/x86/vm/vtableStubs_x86_32.cpp @ 1818:c93c652551b5