author | bobv |
Tue, 03 Aug 2010 08:13:38 -0400 | |
changeset 6176 | 4d9030fe341f |
parent 5924 | dc9d04930c82 |
child 6418 | 6671edbd230e |
permissions | -rw-r--r-- |
1 | 1 |
/* |
5924
dc9d04930c82
6965184: possible races in make_not_entrant_or_zombie
never
parents:
5547
diff
changeset
|
2 |
* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. |
1 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
25 |
#include "incls/_precompiled.incl" |
|
26 |
#include "incls/_vtableStubs.cpp.incl" |
|
27 |
||
28 |
// ----------------------------------------------------------------------------------------- |
|
29 |
// Implementation of VtableStub |
|
30 |
||
31 |
address VtableStub::_chunk = NULL; |
|
32 |
address VtableStub::_chunk_end = NULL; |
|
33 |
VMReg VtableStub::_receiver_location = VMRegImpl::Bad(); |
|
34 |
||
35 |
static int num_vtable_chunks = 0; |
|
36 |
||
37 |
||
38 |
void* VtableStub::operator new(size_t size, int code_size) { |
|
39 |
assert(size == sizeof(VtableStub), "mismatched size"); |
|
40 |
num_vtable_chunks++; |
|
41 |
// compute real VtableStub size (rounded to nearest word) |
|
42 |
const int real_size = round_to(code_size + sizeof(VtableStub), wordSize); |
|
43 |
// malloc them in chunks to minimize header overhead |
|
44 |
const int chunk_factor = 32; |
|
45 |
if (_chunk == NULL || _chunk + real_size > _chunk_end) { |
|
46 |
const int bytes = chunk_factor * real_size + pd_code_alignment(); |
|
47 |
BufferBlob* blob = BufferBlob::create("vtable chunks", bytes); |
|
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3261
diff
changeset
|
48 |
if (blob == NULL) { |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3261
diff
changeset
|
49 |
vm_exit_out_of_memory(bytes, "CodeCache: no room for vtable chunks"); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3261
diff
changeset
|
50 |
} |
1 | 51 |
_chunk = blob->instructions_begin(); |
52 |
_chunk_end = _chunk + bytes; |
|
53 |
Forte::register_stub("vtable stub", _chunk, _chunk_end); |
|
54 |
// Notify JVMTI about this stub. The event will be recorded by the enclosing |
|
55 |
// JvmtiDynamicCodeEventCollector and posted when this thread has released |
|
56 |
// all locks. |
|
57 |
if (JvmtiExport::should_post_dynamic_code_generated()) { |
|
58 |
JvmtiExport::post_dynamic_code_generated_while_holding_locks("vtable stub", _chunk, _chunk_end); |
|
59 |
} |
|
60 |
align_chunk(); |
|
61 |
} |
|
62 |
assert(_chunk + real_size <= _chunk_end, "bad allocation"); |
|
63 |
void* res = _chunk; |
|
64 |
_chunk += real_size; |
|
65 |
align_chunk(); |
|
66 |
return res; |
|
67 |
} |
|
68 |
||
69 |
||
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5924
diff
changeset
|
70 |
void VtableStub::print_on(outputStream* st) const { |
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5924
diff
changeset
|
71 |
st->print("vtable stub (index = %d, receiver_location = %d, code = [" INTPTR_FORMAT ", " INTPTR_FORMAT "[)", |
1 | 72 |
index(), receiver_location(), code_begin(), code_end()); |
73 |
} |
|
74 |
||
75 |
||
76 |
// ----------------------------------------------------------------------------------------- |
|
77 |
// Implementation of VtableStubs |
|
78 |
// |
|
79 |
// For each hash value there's a linked list of vtable stubs (with that |
|
80 |
// hash value). Each list is anchored in a little hash _table, indexed |
|
81 |
// by that hash value. |
|
82 |
||
83 |
VtableStub* VtableStubs::_table[VtableStubs::N]; |
|
84 |
int VtableStubs::_number_of_vtable_stubs = 0; |
|
85 |
||
86 |
||
87 |
void VtableStubs::initialize() { |
|
88 |
VtableStub::_receiver_location = SharedRuntime::name_for_receiver(); |
|
89 |
{ |
|
90 |
MutexLocker ml(VtableStubs_lock); |
|
91 |
assert(_number_of_vtable_stubs == 0, "potential performance bug: VtableStubs initialized more than once"); |
|
92 |
assert(is_power_of_2(N), "N must be a power of 2"); |
|
93 |
for (int i = 0; i < N; i++) { |
|
94 |
_table[i] = NULL; |
|
95 |
} |
|
96 |
} |
|
97 |
} |
|
98 |
||
99 |
||
100 |
address VtableStubs::create_stub(bool is_vtable_stub, int vtable_index, methodOop method) { |
|
101 |
assert(vtable_index >= 0, "must be positive"); |
|
102 |
||
103 |
VtableStub* s = ShareVtableStubs ? lookup(is_vtable_stub, vtable_index) : NULL; |
|
104 |
if (s == NULL) { |
|
105 |
if (is_vtable_stub) { |
|
106 |
s = create_vtable_stub(vtable_index); |
|
107 |
} else { |
|
108 |
s = create_itable_stub(vtable_index); |
|
109 |
} |
|
110 |
enter(is_vtable_stub, vtable_index, s); |
|
111 |
if (PrintAdapterHandlers) { |
|
112 |
tty->print_cr("Decoding VtableStub %s[%d]@%d", |
|
113 |
is_vtable_stub? "vtbl": "itbl", vtable_index, VtableStub::receiver_location()); |
|
114 |
Disassembler::decode(s->code_begin(), s->code_end()); |
|
115 |
} |
|
116 |
} |
|
117 |
return s->entry_point(); |
|
118 |
} |
|
119 |
||
120 |
||
121 |
inline uint VtableStubs::hash(bool is_vtable_stub, int vtable_index){ |
|
122 |
// Assumption: receiver_location < 4 in most cases. |
|
123 |
int hash = ((vtable_index << 2) ^ VtableStub::receiver_location()->value()) + vtable_index; |
|
124 |
return (is_vtable_stub ? ~hash : hash) & mask; |
|
125 |
} |
|
126 |
||
127 |
||
128 |
VtableStub* VtableStubs::lookup(bool is_vtable_stub, int vtable_index) { |
|
129 |
MutexLocker ml(VtableStubs_lock); |
|
130 |
unsigned hash = VtableStubs::hash(is_vtable_stub, vtable_index); |
|
131 |
VtableStub* s = _table[hash]; |
|
132 |
while( s && !s->matches(is_vtable_stub, vtable_index)) s = s->next(); |
|
133 |
return s; |
|
134 |
} |
|
135 |
||
136 |
||
137 |
void VtableStubs::enter(bool is_vtable_stub, int vtable_index, VtableStub* s) { |
|
138 |
MutexLocker ml(VtableStubs_lock); |
|
139 |
assert(s->matches(is_vtable_stub, vtable_index), "bad vtable stub"); |
|
140 |
unsigned int h = VtableStubs::hash(is_vtable_stub, vtable_index); |
|
141 |
// enter s at the beginning of the corresponding list |
|
142 |
s->set_next(_table[h]); |
|
143 |
_table[h] = s; |
|
144 |
_number_of_vtable_stubs++; |
|
145 |
} |
|
146 |
||
147 |
||
148 |
bool VtableStubs::is_entry_point(address pc) { |
|
149 |
MutexLocker ml(VtableStubs_lock); |
|
150 |
VtableStub* stub = (VtableStub*)(pc - VtableStub::entry_offset()); |
|
151 |
uint hash = VtableStubs::hash(stub->is_vtable_stub(), stub->index()); |
|
152 |
VtableStub* s; |
|
153 |
for (s = _table[hash]; s != NULL && s != stub; s = s->next()) {} |
|
154 |
return s == stub; |
|
155 |
} |
|
156 |
||
157 |
||
158 |
bool VtableStubs::contains(address pc) { |
|
159 |
// simple solution for now - we may want to use |
|
160 |
// a faster way if this function is called often |
|
161 |
return stub_containing(pc) != NULL; |
|
162 |
} |
|
163 |
||
164 |
||
165 |
VtableStub* VtableStubs::stub_containing(address pc) { |
|
166 |
// Note: No locking needed since any change to the data structure |
|
167 |
// happens with an atomic store into it (we don't care about |
|
168 |
// consistency with the _number_of_vtable_stubs counter). |
|
169 |
for (int i = 0; i < N; i++) { |
|
170 |
for (VtableStub* s = _table[i]; s != NULL; s = s->next()) { |
|
171 |
if (s->contains(pc)) return s; |
|
172 |
} |
|
173 |
} |
|
174 |
return NULL; |
|
175 |
} |
|
176 |
||
177 |
void vtableStubs_init() { |
|
178 |
VtableStubs::initialize(); |
|
179 |
} |
|
180 |
||
181 |
||
182 |
//----------------------------------------------------------------------------------------------------- |
|
183 |
// Non-product code |
|
184 |
#ifndef PRODUCT |
|
185 |
||
186 |
extern "C" void bad_compiled_vtable_index(JavaThread* thread, oop receiver, int index) { |
|
187 |
ResourceMark rm; |
|
188 |
HandleMark hm; |
|
189 |
klassOop klass = receiver->klass(); |
|
190 |
instanceKlass* ik = instanceKlass::cast(klass); |
|
191 |
klassVtable* vt = ik->vtable(); |
|
192 |
klass->print(); |
|
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3261
diff
changeset
|
193 |
fatal(err_msg("bad compiled vtable dispatch: receiver " INTPTR_FORMAT ", " |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3261
diff
changeset
|
194 |
"index %d (vtable length %d)", |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3261
diff
changeset
|
195 |
(address)receiver, index, vt->length())); |
1 | 196 |
} |
197 |
||
198 |
#endif // Product |