Mercurial > hg > graal-compiler
annotate src/share/vm/code/codeBlob.cpp @ 3992:d1bdeef3e3e2
7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
Summary: There is a race between one thread successfully forwarding and copying the klass mirror for the SoftReference class (including the static master clock) and another thread attempting to use the master clock while attempting to discover a soft reference object. Maintain a shadow copy of the soft reference master clock and use the shadow during reference discovery and reference processing.
Reviewed-by: tonyp, brutisso, ysr
author | johnc |
---|---|
date | Wed, 12 Oct 2011 10:25:51 -0700 |
parents | 167b70ff3abc |
children | d2a62e0f25eb |
rev | line source |
---|---|
0 | 1 /* |
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2192
diff
changeset
|
2 * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved. |
0 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1299
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1299
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:
1299
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "code/codeBlob.hpp" | |
27 #include "code/codeCache.hpp" | |
28 #include "code/relocInfo.hpp" | |
29 #include "compiler/disassembler.hpp" | |
30 #include "interpreter/bytecode.hpp" | |
31 #include "memory/allocation.inline.hpp" | |
32 #include "memory/heap.hpp" | |
33 #include "oops/oop.inline.hpp" | |
34 #include "prims/forte.hpp" | |
35 #include "runtime/handles.inline.hpp" | |
36 #include "runtime/interfaceSupport.hpp" | |
37 #include "runtime/mutexLocker.hpp" | |
38 #include "runtime/safepoint.hpp" | |
39 #include "runtime/sharedRuntime.hpp" | |
40 #include "runtime/vframe.hpp" | |
41 #include "services/memoryService.hpp" | |
42 #ifdef TARGET_ARCH_x86 | |
43 # include "nativeInst_x86.hpp" | |
44 #endif | |
45 #ifdef TARGET_ARCH_sparc | |
46 # include "nativeInst_sparc.hpp" | |
47 #endif | |
48 #ifdef TARGET_ARCH_zero | |
49 # include "nativeInst_zero.hpp" | |
50 #endif | |
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
51 #ifdef TARGET_ARCH_arm |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
52 # include "nativeInst_arm.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
53 #endif |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
54 #ifdef TARGET_ARCH_ppc |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
55 # include "nativeInst_ppc.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
56 #endif |
1972 | 57 #ifdef COMPILER1 |
58 #include "c1/c1_Runtime1.hpp" | |
59 #endif | |
0 | 60 |
61 unsigned int align_code_offset(int offset) { | |
62 // align the size to CodeEntryAlignment | |
63 return | |
64 ((offset + (int)CodeHeap::header_size() + (CodeEntryAlignment-1)) & ~(CodeEntryAlignment-1)) | |
65 - (int)CodeHeap::header_size(); | |
66 } | |
67 | |
68 | |
69 // This must be consistent with the CodeBlob constructor's layout actions. | |
70 unsigned int CodeBlob::allocation_size(CodeBuffer* cb, int header_size) { | |
71 unsigned int size = header_size; | |
72 size += round_to(cb->total_relocation_size(), oopSize); | |
73 // align the size to CodeEntryAlignment | |
74 size = align_code_offset(size); | |
1748 | 75 size += round_to(cb->total_content_size(), oopSize); |
0 | 76 size += round_to(cb->total_oop_size(), oopSize); |
77 return size; | |
78 } | |
79 | |
80 | |
81 // Creates a simple CodeBlob. Sets up the size of the different regions. | |
82 CodeBlob::CodeBlob(const char* name, int header_size, int size, int frame_complete, int locs_size) { | |
1748 | 83 assert(size == round_to(size, oopSize), "unaligned size"); |
84 assert(locs_size == round_to(locs_size, oopSize), "unaligned size"); | |
0 | 85 assert(header_size == round_to(header_size, oopSize), "unaligned size"); |
86 assert(!UseRelocIndex, "no space allocated for reloc index yet"); | |
87 | |
88 // Note: If UseRelocIndex is enabled, there needs to be (at least) one | |
89 // extra word for the relocation information, containing the reloc | |
90 // index table length. Unfortunately, the reloc index table imple- | |
91 // mentation is not easily understandable and thus it is not clear | |
92 // what exactly the format is supposed to be. For now, we just turn | |
93 // off the use of this table (gri 7/6/2000). | |
94 | |
95 _name = name; | |
96 _size = size; | |
97 _frame_complete_offset = frame_complete; | |
98 _header_size = header_size; | |
99 _relocation_size = locs_size; | |
1748 | 100 _content_offset = align_code_offset(header_size + _relocation_size); |
101 _code_offset = _content_offset; | |
0 | 102 _data_offset = size; |
103 _frame_size = 0; | |
104 set_oop_maps(NULL); | |
105 } | |
106 | |
107 | |
108 // Creates a CodeBlob from a CodeBuffer. Sets up the size of the different regions, | |
109 // and copy code and relocation info. | |
110 CodeBlob::CodeBlob( | |
111 const char* name, | |
112 CodeBuffer* cb, | |
113 int header_size, | |
114 int size, | |
115 int frame_complete, | |
116 int frame_size, | |
117 OopMapSet* oop_maps | |
118 ) { | |
1748 | 119 assert(size == round_to(size, oopSize), "unaligned size"); |
0 | 120 assert(header_size == round_to(header_size, oopSize), "unaligned size"); |
121 | |
122 _name = name; | |
123 _size = size; | |
124 _frame_complete_offset = frame_complete; | |
125 _header_size = header_size; | |
126 _relocation_size = round_to(cb->total_relocation_size(), oopSize); | |
1748 | 127 _content_offset = align_code_offset(header_size + _relocation_size); |
1762
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1748
diff
changeset
|
128 _code_offset = _content_offset + cb->total_offset_of(cb->insts()); |
1748 | 129 _data_offset = _content_offset + round_to(cb->total_content_size(), oopSize); |
0 | 130 assert(_data_offset <= size, "codeBlob is too small"); |
131 | |
132 cb->copy_code_and_locs_to(this); | |
133 set_oop_maps(oop_maps); | |
134 _frame_size = frame_size; | |
135 #ifdef COMPILER1 | |
136 // probably wrong for tiered | |
137 assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs"); | |
138 #endif // COMPILER1 | |
139 } | |
140 | |
141 | |
142 void CodeBlob::set_oop_maps(OopMapSet* p) { | |
143 // Danger Will Robinson! This method allocates a big | |
144 // chunk of memory, its your job to free it. | |
145 if (p != NULL) { | |
146 // We need to allocate a chunk big enough to hold the OopMapSet and all of its OopMaps | |
147 _oop_maps = (OopMapSet* )NEW_C_HEAP_ARRAY(unsigned char, p->heap_size()); | |
148 p->copy_to((address)_oop_maps); | |
149 } else { | |
150 _oop_maps = NULL; | |
151 } | |
152 } | |
153 | |
154 | |
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
155 void CodeBlob::trace_new_stub(CodeBlob* stub, const char* name1, const char* name2) { |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
156 // Do not hold the CodeCache lock during name formatting. |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
157 assert(!CodeCache_lock->owned_by_self(), "release CodeCache before registering the stub"); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
158 |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
159 if (stub != NULL) { |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
160 char stub_id[256]; |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
161 assert(strlen(name1) + strlen(name2) < sizeof(stub_id), ""); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
162 jio_snprintf(stub_id, sizeof(stub_id), "%s%s", name1, name2); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
163 if (PrintStubCode) { |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
164 tty->print_cr("Decoding %s " INTPTR_FORMAT, stub_id, (intptr_t) stub); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
165 Disassembler::decode(stub->code_begin(), stub->code_end()); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
166 } |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
167 Forte::register_stub(stub_id, stub->code_begin(), stub->code_end()); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
168 |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
169 if (JvmtiExport::should_post_dynamic_code_generated()) { |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
170 const char* stub_name = name2; |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
171 if (name2[0] == '\0') stub_name = name1; |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
172 JvmtiExport::post_dynamic_code_generated(stub_name, stub->code_begin(), stub->code_end()); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
173 } |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
174 } |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
175 |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
176 // Track memory usage statistic after releasing CodeCache_lock |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
177 MemoryService::track_code_cache_memory_usage(); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
178 } |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
179 |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
180 |
0 | 181 void CodeBlob::flush() { |
182 if (_oop_maps) { | |
183 FREE_C_HEAP_ARRAY(unsigned char, _oop_maps); | |
184 _oop_maps = NULL; | |
185 } | |
186 _comments.free(); | |
187 } | |
188 | |
189 | |
190 OopMap* CodeBlob::oop_map_for_return_address(address return_address) { | |
1748 | 191 assert(oop_maps() != NULL, "nope"); |
192 return oop_maps()->find_map_at_offset((intptr_t) return_address - (intptr_t) code_begin()); | |
0 | 193 } |
194 | |
195 | |
196 //---------------------------------------------------------------------------------------------------- | |
197 // Implementation of BufferBlob | |
198 | |
199 | |
200 BufferBlob::BufferBlob(const char* name, int size) | |
201 : CodeBlob(name, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, /*locs_size:*/ 0) | |
202 {} | |
203 | |
204 BufferBlob* BufferBlob::create(const char* name, int buffer_size) { | |
205 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock | |
206 | |
207 BufferBlob* blob = NULL; | |
208 unsigned int size = sizeof(BufferBlob); | |
209 // align the size to CodeEntryAlignment | |
210 size = align_code_offset(size); | |
211 size += round_to(buffer_size, oopSize); | |
212 assert(name != NULL, "must provide a name"); | |
213 { | |
214 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
215 blob = new (size) BufferBlob(name, size); | |
216 } | |
217 // Track memory usage statistic after releasing CodeCache_lock | |
218 MemoryService::track_code_cache_memory_usage(); | |
219 | |
220 return blob; | |
221 } | |
222 | |
223 | |
224 BufferBlob::BufferBlob(const char* name, int size, CodeBuffer* cb) | |
225 : CodeBlob(name, cb, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, 0, NULL) | |
226 {} | |
227 | |
228 BufferBlob* BufferBlob::create(const char* name, CodeBuffer* cb) { | |
229 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock | |
230 | |
231 BufferBlob* blob = NULL; | |
232 unsigned int size = allocation_size(cb, sizeof(BufferBlob)); | |
233 assert(name != NULL, "must provide a name"); | |
234 { | |
235 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
236 blob = new (size) BufferBlob(name, size, cb); | |
237 } | |
238 // Track memory usage statistic after releasing CodeCache_lock | |
239 MemoryService::track_code_cache_memory_usage(); | |
240 | |
241 return blob; | |
242 } | |
243 | |
244 | |
245 void* BufferBlob::operator new(size_t s, unsigned size) { | |
246 void* p = CodeCache::allocate(size); | |
247 return p; | |
248 } | |
249 | |
250 | |
251 void BufferBlob::free( BufferBlob *blob ) { | |
252 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock | |
253 { | |
254 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
255 CodeCache::free((CodeBlob*)blob); | |
256 } | |
257 // Track memory usage statistic after releasing CodeCache_lock | |
258 MemoryService::track_code_cache_memory_usage(); | |
259 } | |
260 | |
1299
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
261 |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
262 //---------------------------------------------------------------------------------------------------- |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
263 // Implementation of AdapterBlob |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
264 |
1663 | 265 AdapterBlob::AdapterBlob(int size, CodeBuffer* cb) : |
266 BufferBlob("I2C/C2I adapters", size, cb) { | |
267 CodeCache::commit(this); | |
268 } | |
269 | |
1299
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
270 AdapterBlob* AdapterBlob::create(CodeBuffer* cb) { |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
271 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
272 |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
273 AdapterBlob* blob = NULL; |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
274 unsigned int size = allocation_size(cb, sizeof(AdapterBlob)); |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
275 { |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
276 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
277 blob = new (size) AdapterBlob(size, cb); |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
278 } |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
279 // Track memory usage statistic after releasing CodeCache_lock |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
280 MemoryService::track_code_cache_memory_usage(); |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
281 |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
282 return blob; |
0 | 283 } |
284 | |
1299
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
285 |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
286 //---------------------------------------------------------------------------------------------------- |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
287 // Implementation of MethodHandlesAdapterBlob |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
288 |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
289 MethodHandlesAdapterBlob* MethodHandlesAdapterBlob::create(int buffer_size) { |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
290 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
291 |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
292 MethodHandlesAdapterBlob* blob = NULL; |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
293 unsigned int size = sizeof(MethodHandlesAdapterBlob); |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
294 // align the size to CodeEntryAlignment |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
295 size = align_code_offset(size); |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
296 size += round_to(buffer_size, oopSize); |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
297 { |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
298 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
299 blob = new (size) MethodHandlesAdapterBlob(size); |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
300 } |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
301 // Track memory usage statistic after releasing CodeCache_lock |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
302 MemoryService::track_code_cache_memory_usage(); |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
303 |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
304 return blob; |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
305 } |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
306 |
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
0
diff
changeset
|
307 |
0 | 308 //---------------------------------------------------------------------------------------------------- |
309 // Implementation of RuntimeStub | |
310 | |
311 RuntimeStub::RuntimeStub( | |
312 const char* name, | |
313 CodeBuffer* cb, | |
314 int size, | |
315 int frame_complete, | |
316 int frame_size, | |
317 OopMapSet* oop_maps, | |
318 bool caller_must_gc_arguments | |
319 ) | |
320 : CodeBlob(name, cb, sizeof(RuntimeStub), size, frame_complete, frame_size, oop_maps) | |
321 { | |
322 _caller_must_gc_arguments = caller_must_gc_arguments; | |
323 } | |
324 | |
325 | |
326 RuntimeStub* RuntimeStub::new_runtime_stub(const char* stub_name, | |
327 CodeBuffer* cb, | |
328 int frame_complete, | |
329 int frame_size, | |
330 OopMapSet* oop_maps, | |
331 bool caller_must_gc_arguments) | |
332 { | |
333 RuntimeStub* stub = NULL; | |
334 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock | |
335 { | |
336 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
337 unsigned int size = allocation_size(cb, sizeof(RuntimeStub)); | |
338 stub = new (size) RuntimeStub(stub_name, cb, size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments); | |
339 } | |
340 | |
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
341 trace_new_stub(stub, "RuntimeStub - ", stub_name); |
0 | 342 |
343 return stub; | |
344 } | |
345 | |
346 | |
347 void* RuntimeStub::operator new(size_t s, unsigned size) { | |
348 void* p = CodeCache::allocate(size); | |
349 if (!p) fatal("Initial size of CodeCache is too small"); | |
350 return p; | |
351 } | |
352 | |
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
353 // operator new shared by all singletons: |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
354 void* SingletonBlob::operator new(size_t s, unsigned size) { |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
355 void* p = CodeCache::allocate(size); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
356 if (!p) fatal("Initial size of CodeCache is too small"); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
357 return p; |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
358 } |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
359 |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
360 |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
361 //---------------------------------------------------------------------------------------------------- |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
362 // Implementation of RicochetBlob |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
363 |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
364 RicochetBlob::RicochetBlob( |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
365 CodeBuffer* cb, |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
366 int size, |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
367 int bounce_offset, |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
368 int exception_offset, |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
369 int frame_size |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
370 ) |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
371 : SingletonBlob("RicochetBlob", cb, sizeof(RicochetBlob), size, frame_size, (OopMapSet*) NULL) |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
372 { |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
373 _bounce_offset = bounce_offset; |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
374 _exception_offset = exception_offset; |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
375 } |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
376 |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
377 |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
378 RicochetBlob* RicochetBlob::create( |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
379 CodeBuffer* cb, |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
380 int bounce_offset, |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
381 int exception_offset, |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
382 int frame_size) |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
383 { |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
384 RicochetBlob* blob = NULL; |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
385 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
386 { |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
387 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
388 unsigned int size = allocation_size(cb, sizeof(RicochetBlob)); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
389 blob = new (size) RicochetBlob(cb, size, bounce_offset, exception_offset, frame_size); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
390 } |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
391 |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
392 trace_new_stub(blob, "RicochetBlob"); |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
393 |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
394 return blob; |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
395 } |
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
396 |
0 | 397 |
398 //---------------------------------------------------------------------------------------------------- | |
399 // Implementation of DeoptimizationBlob | |
400 | |
401 DeoptimizationBlob::DeoptimizationBlob( | |
402 CodeBuffer* cb, | |
403 int size, | |
404 OopMapSet* oop_maps, | |
405 int unpack_offset, | |
406 int unpack_with_exception_offset, | |
407 int unpack_with_reexecution_offset, | |
408 int frame_size | |
409 ) | |
410 : SingletonBlob("DeoptimizationBlob", cb, sizeof(DeoptimizationBlob), size, frame_size, oop_maps) | |
411 { | |
412 _unpack_offset = unpack_offset; | |
413 _unpack_with_exception = unpack_with_exception_offset; | |
414 _unpack_with_reexecution = unpack_with_reexecution_offset; | |
415 #ifdef COMPILER1 | |
416 _unpack_with_exception_in_tls = -1; | |
417 #endif | |
418 } | |
419 | |
420 | |
421 DeoptimizationBlob* DeoptimizationBlob::create( | |
422 CodeBuffer* cb, | |
423 OopMapSet* oop_maps, | |
424 int unpack_offset, | |
425 int unpack_with_exception_offset, | |
426 int unpack_with_reexecution_offset, | |
427 int frame_size) | |
428 { | |
429 DeoptimizationBlob* blob = NULL; | |
430 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock | |
431 { | |
432 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
433 unsigned int size = allocation_size(cb, sizeof(DeoptimizationBlob)); | |
434 blob = new (size) DeoptimizationBlob(cb, | |
435 size, | |
436 oop_maps, | |
437 unpack_offset, | |
438 unpack_with_exception_offset, | |
439 unpack_with_reexecution_offset, | |
440 frame_size); | |
441 } | |
442 | |
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
443 trace_new_stub(blob, "DeoptimizationBlob"); |
0 | 444 |
445 return blob; | |
446 } | |
447 | |
448 | |
449 //---------------------------------------------------------------------------------------------------- | |
450 // Implementation of UncommonTrapBlob | |
451 | |
452 #ifdef COMPILER2 | |
453 UncommonTrapBlob::UncommonTrapBlob( | |
454 CodeBuffer* cb, | |
455 int size, | |
456 OopMapSet* oop_maps, | |
457 int frame_size | |
458 ) | |
459 : SingletonBlob("UncommonTrapBlob", cb, sizeof(UncommonTrapBlob), size, frame_size, oop_maps) | |
460 {} | |
461 | |
462 | |
463 UncommonTrapBlob* UncommonTrapBlob::create( | |
464 CodeBuffer* cb, | |
465 OopMapSet* oop_maps, | |
466 int frame_size) | |
467 { | |
468 UncommonTrapBlob* blob = NULL; | |
469 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock | |
470 { | |
471 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
472 unsigned int size = allocation_size(cb, sizeof(UncommonTrapBlob)); | |
473 blob = new (size) UncommonTrapBlob(cb, size, oop_maps, frame_size); | |
474 } | |
475 | |
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
476 trace_new_stub(blob, "UncommonTrapBlob"); |
0 | 477 |
478 return blob; | |
479 } | |
480 | |
481 | |
482 #endif // COMPILER2 | |
483 | |
484 | |
485 //---------------------------------------------------------------------------------------------------- | |
486 // Implementation of ExceptionBlob | |
487 | |
488 #ifdef COMPILER2 | |
489 ExceptionBlob::ExceptionBlob( | |
490 CodeBuffer* cb, | |
491 int size, | |
492 OopMapSet* oop_maps, | |
493 int frame_size | |
494 ) | |
495 : SingletonBlob("ExceptionBlob", cb, sizeof(ExceptionBlob), size, frame_size, oop_maps) | |
496 {} | |
497 | |
498 | |
499 ExceptionBlob* ExceptionBlob::create( | |
500 CodeBuffer* cb, | |
501 OopMapSet* oop_maps, | |
502 int frame_size) | |
503 { | |
504 ExceptionBlob* blob = NULL; | |
505 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock | |
506 { | |
507 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
508 unsigned int size = allocation_size(cb, sizeof(ExceptionBlob)); | |
509 blob = new (size) ExceptionBlob(cb, size, oop_maps, frame_size); | |
510 } | |
511 | |
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
512 trace_new_stub(blob, "ExceptionBlob"); |
0 | 513 |
514 return blob; | |
515 } | |
516 | |
517 | |
518 #endif // COMPILER2 | |
519 | |
520 | |
521 //---------------------------------------------------------------------------------------------------- | |
522 // Implementation of SafepointBlob | |
523 | |
524 SafepointBlob::SafepointBlob( | |
525 CodeBuffer* cb, | |
526 int size, | |
527 OopMapSet* oop_maps, | |
528 int frame_size | |
529 ) | |
530 : SingletonBlob("SafepointBlob", cb, sizeof(SafepointBlob), size, frame_size, oop_maps) | |
531 {} | |
532 | |
533 | |
534 SafepointBlob* SafepointBlob::create( | |
535 CodeBuffer* cb, | |
536 OopMapSet* oop_maps, | |
537 int frame_size) | |
538 { | |
539 SafepointBlob* blob = NULL; | |
540 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock | |
541 { | |
542 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
543 unsigned int size = allocation_size(cb, sizeof(SafepointBlob)); | |
544 blob = new (size) SafepointBlob(cb, size, oop_maps, frame_size); | |
545 } | |
546 | |
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
2426
diff
changeset
|
547 trace_new_stub(blob, "SafepointBlob"); |
0 | 548 |
549 return blob; | |
550 } | |
551 | |
552 | |
553 //---------------------------------------------------------------------------------------------------- | |
554 // Verification and printing | |
555 | |
556 void CodeBlob::verify() { | |
557 ShouldNotReachHere(); | |
558 } | |
559 | |
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
560 void CodeBlob::print_on(outputStream* st) const { |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
561 st->print_cr("[CodeBlob (" INTPTR_FORMAT ")]", this); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
562 st->print_cr("Framesize: %d", _frame_size); |
0 | 563 } |
564 | |
565 void CodeBlob::print_value_on(outputStream* st) const { | |
566 st->print_cr("[CodeBlob]"); | |
567 } | |
568 | |
569 void BufferBlob::verify() { | |
570 // unimplemented | |
571 } | |
572 | |
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
573 void BufferBlob::print_on(outputStream* st) const { |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
574 CodeBlob::print_on(st); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
575 print_value_on(st); |
0 | 576 } |
577 | |
578 void BufferBlob::print_value_on(outputStream* st) const { | |
579 st->print_cr("BufferBlob (" INTPTR_FORMAT ") used for %s", this, name()); | |
580 } | |
581 | |
582 void RuntimeStub::verify() { | |
583 // unimplemented | |
584 } | |
585 | |
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
586 void RuntimeStub::print_on(outputStream* st) const { |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
587 CodeBlob::print_on(st); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
588 st->print("Runtime Stub (" INTPTR_FORMAT "): ", this); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
589 st->print_cr(name()); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
590 Disassembler::decode((CodeBlob*)this, st); |
0 | 591 } |
592 | |
593 void RuntimeStub::print_value_on(outputStream* st) const { | |
594 st->print("RuntimeStub (" INTPTR_FORMAT "): ", this); st->print(name()); | |
595 } | |
596 | |
597 void SingletonBlob::verify() { | |
598 // unimplemented | |
599 } | |
600 | |
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
601 void SingletonBlob::print_on(outputStream* st) const { |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
602 CodeBlob::print_on(st); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
603 st->print_cr(name()); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1663
diff
changeset
|
604 Disassembler::decode((CodeBlob*)this, st); |
0 | 605 } |
606 | |
607 void SingletonBlob::print_value_on(outputStream* st) const { | |
608 st->print_cr(name()); | |
609 } | |
610 | |
611 void DeoptimizationBlob::print_value_on(outputStream* st) const { | |
612 st->print_cr("Deoptimization (frame not available)"); | |
613 } |