Mercurial > hg > graal-compiler

annotate src/cpu/x86/vm/vtableStubs_x86_32.cpp @ 1842:6e0aac35bfa9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue Summary: Under certain circumstances a safepoint could happen between a JavaThread object being created and that object being added to the Java threads list. This could cause the active field of that thread's SATB queue to get out-of-sync with respect to the other Java threads. The solution is to activate the SATB queue, when necessary, before adding the thread to the Java threads list, not when the JavaThread object is created. The changeset also includes a small fix to rename the surrogate locker thread from "Surrogate Locker Thread (CMS)" to "Surrogate Locker Thread (Concurrent GC)" since it's also used in G1. Reviewed-by: iveresov, ysr, johnc, jcoomes
author tonyp
date Fri, 01 Oct 2010 16:43:05 -0400
parents c18cbe5936b8
children f95d63e2154a
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
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_index*vtableEntry::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 }