Mercurial > hg > graal-compiler

annotate src/cpu/x86/vm/vtableStubs_x86_32.cpp @ 2007:5ddfcf4b079e

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