1 /*
2 * Copyright (c) 1998, 2017, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "jvm.h"
27 #include "code/codeBlob.hpp"
28 #include "code/codeCache.hpp"
29 #include "code/relocInfo.hpp"
30 #include "compiler/disassembler.hpp"
31 #include "interpreter/bytecode.hpp"
32 #include "memory/allocation.inline.hpp"
33 #include "memory/heap.hpp"
34 #include "memory/resourceArea.hpp"
35 #include "oops/oop.inline.hpp"
36 #include "prims/forte.hpp"
37 #include "runtime/handles.inline.hpp"
38 #include "runtime/interfaceSupport.inline.hpp"
39 #include "runtime/mutexLocker.hpp"
40 #include "runtime/safepoint.hpp"
41 #include "runtime/sharedRuntime.hpp"
42 #include "runtime/vframe.hpp"
43 #include "services/memoryService.hpp"
44 #include "utilities/align.hpp"
45 #ifdef COMPILER1
46 #include "c1/c1_Runtime1.hpp"
47 #endif
48
49 const char* CodeBlob::compiler_name() const {
50 return compilertype2name(_type);
51 }
52
53 unsigned int CodeBlob::align_code_offset(int offset) {
54 // align the size to CodeEntryAlignment
55 return
56 ((offset + (int)CodeHeap::header_size() + (CodeEntryAlignment-1)) & ~(CodeEntryAlignment-1))
57 - (int)CodeHeap::header_size();
58 }
59
60
61 // This must be consistent with the CodeBlob constructor's layout actions.
62 unsigned int CodeBlob::allocation_size(CodeBuffer* cb, int header_size) {
63 unsigned int size = header_size;
64 size += align_up(cb->total_relocation_size(), oopSize);
65 // align the size to CodeEntryAlignment
66 size = align_code_offset(size);
67 size += align_up(cb->total_content_size(), oopSize);
68 size += align_up(cb->total_oop_size(), oopSize);
69 size += align_up(cb->total_metadata_size(), oopSize);
70 return size;
71 }
72
73 CodeBlob::CodeBlob(const char* name, CompilerType type, const CodeBlobLayout& layout, int frame_complete_offset, int frame_size, ImmutableOopMapSet* oop_maps, bool caller_must_gc_arguments) :
74 _name(name),
75 _size(layout.size()),
76 _header_size(layout.header_size()),
77 _frame_complete_offset(frame_complete_offset),
78 _data_offset(layout.data_offset()),
79 _frame_size(frame_size),
80 _strings(CodeStrings()),
81 _oop_maps(oop_maps),
82 _caller_must_gc_arguments(caller_must_gc_arguments),
83 _code_begin(layout.code_begin()),
84 _code_end(layout.code_end()),
85 _data_end(layout.data_end()),
86 _relocation_begin(layout.relocation_begin()),
87 _relocation_end(layout.relocation_end()),
88 _content_begin(layout.content_begin()),
89 _type(type)
90 {
91 assert(is_aligned(layout.size(), oopSize), "unaligned size");
92 assert(is_aligned(layout.header_size(), oopSize), "unaligned size");
93 assert(is_aligned(layout.relocation_size(), oopSize), "unaligned size");
94 assert(layout.code_end() == layout.content_end(), "must be the same - see code_end()");
95 #ifdef COMPILER1
96 // probably wrong for tiered
97 assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs");
98 #endif // COMPILER1
99 }
100
101 CodeBlob::CodeBlob(const char* name, CompilerType type, const CodeBlobLayout& layout, CodeBuffer* cb, int frame_complete_offset, int frame_size, OopMapSet* oop_maps, bool caller_must_gc_arguments) :
102 _name(name),
103 _size(layout.size()),
104 _header_size(layout.header_size()),
105 _frame_complete_offset(frame_complete_offset),
106 _data_offset(layout.data_offset()),
107 _frame_size(frame_size),
108 _strings(CodeStrings()),
109 _caller_must_gc_arguments(caller_must_gc_arguments),
110 _code_begin(layout.code_begin()),
111 _code_end(layout.code_end()),
112 _data_end(layout.data_end()),
113 _relocation_begin(layout.relocation_begin()),
114 _relocation_end(layout.relocation_end()),
115 _content_begin(layout.content_begin()),
116 _type(type)
117 {
118 assert(is_aligned(_size, oopSize), "unaligned size");
119 assert(is_aligned(_header_size, oopSize), "unaligned size");
120 assert(_data_offset <= _size, "codeBlob is too small");
121 assert(layout.code_end() == layout.content_end(), "must be the same - see code_end()");
122
123 set_oop_maps(oop_maps);
124 #ifdef COMPILER1
125 // probably wrong for tiered
126 assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs");
127 #endif // COMPILER1
128 }
129
130
131 // Creates a simple CodeBlob. Sets up the size of the different regions.
132 RuntimeBlob::RuntimeBlob(const char* name, int header_size, int size, int frame_complete, int locs_size)
133 : CodeBlob(name, compiler_none, CodeBlobLayout((address) this, size, header_size, locs_size, size), frame_complete, 0, NULL, false /* caller_must_gc_arguments */)
134 {
135 assert(is_aligned(locs_size, oopSize), "unaligned size");
136 }
137
138
139 // Creates a RuntimeBlob from a CodeBuffer
140 // and copy code and relocation info.
141 RuntimeBlob::RuntimeBlob(
142 const char* name,
143 CodeBuffer* cb,
144 int header_size,
145 int size,
146 int frame_complete,
147 int frame_size,
148 OopMapSet* oop_maps,
149 bool caller_must_gc_arguments
150 ) : CodeBlob(name, compiler_none, CodeBlobLayout((address) this, size, header_size, cb), cb, frame_complete, frame_size, oop_maps, caller_must_gc_arguments) {
151 cb->copy_code_and_locs_to(this);
152 }
153
154 void CodeBlob::flush() {
155 if (_oop_maps) {
156 FREE_C_HEAP_ARRAY(unsigned char, _oop_maps);
157 _oop_maps = NULL;
158 }
159 _strings.free();
160 }
161
162 void CodeBlob::set_oop_maps(OopMapSet* p) {
163 // Danger Will Robinson! This method allocates a big
164 // chunk of memory, its your job to free it.
165 if (p != NULL) {
166 _oop_maps = ImmutableOopMapSet::build_from(p);
167 } else {
168 _oop_maps = NULL;
169 }
170 }
171
172
173 void RuntimeBlob::trace_new_stub(RuntimeBlob* stub, const char* name1, const char* name2) {
174 // Do not hold the CodeCache lock during name formatting.
175 assert(!CodeCache_lock->owned_by_self(), "release CodeCache before registering the stub");
176
177 if (stub != NULL) {
178 char stub_id[256];
179 assert(strlen(name1) + strlen(name2) < sizeof(stub_id), "");
180 jio_snprintf(stub_id, sizeof(stub_id), "%s%s", name1, name2);
181 if (PrintStubCode) {
182 ttyLocker ttyl;
183 tty->print_cr("Decoding %s " INTPTR_FORMAT, stub_id, (intptr_t) stub);
184 Disassembler::decode(stub->code_begin(), stub->code_end());
185 tty->cr();
186 }
187 Forte::register_stub(stub_id, stub->code_begin(), stub->code_end());
188
189 if (JvmtiExport::should_post_dynamic_code_generated()) {
190 const char* stub_name = name2;
191 if (name2[0] == '\0') stub_name = name1;
192 JvmtiExport::post_dynamic_code_generated(stub_name, stub->code_begin(), stub->code_end());
193 }
194 }
195
196 // Track memory usage statistic after releasing CodeCache_lock
197 MemoryService::track_code_cache_memory_usage();
198 }
199
200 const ImmutableOopMap* CodeBlob::oop_map_for_return_address(address return_address) {
201 assert(_oop_maps != NULL, "nope");
202 return _oop_maps->find_map_at_offset((intptr_t) return_address - (intptr_t) code_begin());
203 }
204
205 void CodeBlob::print_code() {
206 ResourceMark m;
207 Disassembler::decode(this, tty);
208 }
209
210 //----------------------------------------------------------------------------------------------------
211 // Implementation of BufferBlob
212
213
214 BufferBlob::BufferBlob(const char* name, int size)
215 : RuntimeBlob(name, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, /*locs_size:*/ 0)
216 {}
217
218 BufferBlob* BufferBlob::create(const char* name, int buffer_size) {
219 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
220
221 BufferBlob* blob = NULL;
222 unsigned int size = sizeof(BufferBlob);
223 // align the size to CodeEntryAlignment
224 size = CodeBlob::align_code_offset(size);
225 size += align_up(buffer_size, oopSize);
226 assert(name != NULL, "must provide a name");
227 {
228 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
229 blob = new (size) BufferBlob(name, size);
230 }
231 // Track memory usage statistic after releasing CodeCache_lock
232 MemoryService::track_code_cache_memory_usage();
233
234 return blob;
235 }
236
237
238 BufferBlob::BufferBlob(const char* name, int size, CodeBuffer* cb)
239 : RuntimeBlob(name, cb, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, 0, NULL)
240 {}
241
242 BufferBlob* BufferBlob::create(const char* name, CodeBuffer* cb) {
243 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
244
245 BufferBlob* blob = NULL;
246 unsigned int size = CodeBlob::allocation_size(cb, sizeof(BufferBlob));
247 assert(name != NULL, "must provide a name");
248 {
249 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
250 blob = new (size) BufferBlob(name, size, cb);
251 }
252 // Track memory usage statistic after releasing CodeCache_lock
253 MemoryService::track_code_cache_memory_usage();
254
255 return blob;
256 }
257
258 void* BufferBlob::operator new(size_t s, unsigned size) throw() {
259 return CodeCache::allocate(size, CodeBlobType::NonNMethod);
260 }
261
262 void BufferBlob::free(BufferBlob *blob) {
263 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
264 blob->flush();
265 {
266 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
267 CodeCache::free((RuntimeBlob*)blob);
268 }
269 // Track memory usage statistic after releasing CodeCache_lock
270 MemoryService::track_code_cache_memory_usage();
271 }
272
273
274 //----------------------------------------------------------------------------------------------------
275 // Implementation of AdapterBlob
276
277 AdapterBlob::AdapterBlob(int size, CodeBuffer* cb) :
278 BufferBlob("I2C/C2I adapters", size, cb) {
279 CodeCache::commit(this);
280 }
281
282 AdapterBlob* AdapterBlob::create(CodeBuffer* cb) {
283 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
284
285 AdapterBlob* blob = NULL;
286 unsigned int size = CodeBlob::allocation_size(cb, sizeof(AdapterBlob));
287 {
288 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
289 blob = new (size) AdapterBlob(size, cb);
290 }
291 // Track memory usage statistic after releasing CodeCache_lock
292 MemoryService::track_code_cache_memory_usage();
293
294 return blob;
295 }
296
297
298 //----------------------------------------------------------------------------------------------------
299 // Implementation of MethodHandlesAdapterBlob
300
301 MethodHandlesAdapterBlob* MethodHandlesAdapterBlob::create(int buffer_size) {
302 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
303
304 MethodHandlesAdapterBlob* blob = NULL;
305 unsigned int size = sizeof(MethodHandlesAdapterBlob);
306 // align the size to CodeEntryAlignment
307 size = CodeBlob::align_code_offset(size);
308 size += align_up(buffer_size, oopSize);
309 {
310 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
311 blob = new (size) MethodHandlesAdapterBlob(size);
312 if (blob == NULL) {
313 vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "CodeCache: no room for method handle adapter blob");
314 }
315 }
316 // Track memory usage statistic after releasing CodeCache_lock
317 MemoryService::track_code_cache_memory_usage();
318
319 return blob;
320 }
321
322 //----------------------------------------------------------------------------------------------------
323 // Implementation of RuntimeStub
324
325 RuntimeStub::RuntimeStub(
326 const char* name,
327 CodeBuffer* cb,
328 int size,
329 int frame_complete,
330 int frame_size,
331 OopMapSet* oop_maps,
332 bool caller_must_gc_arguments
333 )
334 : RuntimeBlob(name, cb, sizeof(RuntimeStub), size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments)
335 {
336 }
337
338 RuntimeStub* RuntimeStub::new_runtime_stub(const char* stub_name,
339 CodeBuffer* cb,
340 int frame_complete,
341 int frame_size,
342 OopMapSet* oop_maps,
343 bool caller_must_gc_arguments)
344 {
345 RuntimeStub* stub = NULL;
346 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
347 {
348 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
349 unsigned int size = CodeBlob::allocation_size(cb, sizeof(RuntimeStub));
350 stub = new (size) RuntimeStub(stub_name, cb, size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments);
351 }
352
353 trace_new_stub(stub, "RuntimeStub - ", stub_name);
354
355 return stub;
356 }
357
358
359 void* RuntimeStub::operator new(size_t s, unsigned size) throw() {
360 void* p = CodeCache::allocate(size, CodeBlobType::NonNMethod);
361 if (!p) fatal("Initial size of CodeCache is too small");
362 return p;
363 }
364
365 // operator new shared by all singletons:
366 void* SingletonBlob::operator new(size_t s, unsigned size) throw() {
367 void* p = CodeCache::allocate(size, CodeBlobType::NonNMethod);
368 if (!p) fatal("Initial size of CodeCache is too small");
369 return p;
370 }
371
372
373 //----------------------------------------------------------------------------------------------------
374 // Implementation of DeoptimizationBlob
375
376 DeoptimizationBlob::DeoptimizationBlob(
377 CodeBuffer* cb,
378 int size,
379 OopMapSet* oop_maps,
380 int unpack_offset,
381 int unpack_with_exception_offset,
382 int unpack_with_reexecution_offset,
383 int frame_size
384 )
385 : SingletonBlob("DeoptimizationBlob", cb, sizeof(DeoptimizationBlob), size, frame_size, oop_maps)
386 {
387 _unpack_offset = unpack_offset;
388 _unpack_with_exception = unpack_with_exception_offset;
389 _unpack_with_reexecution = unpack_with_reexecution_offset;
390 #ifdef COMPILER1
391 _unpack_with_exception_in_tls = -1;
392 #endif
393 }
394
395
396 DeoptimizationBlob* DeoptimizationBlob::create(
397 CodeBuffer* cb,
398 OopMapSet* oop_maps,
399 int unpack_offset,
400 int unpack_with_exception_offset,
401 int unpack_with_reexecution_offset,
402 int frame_size)
403 {
404 DeoptimizationBlob* blob = NULL;
405 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
406 {
407 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
408 unsigned int size = CodeBlob::allocation_size(cb, sizeof(DeoptimizationBlob));
409 blob = new (size) DeoptimizationBlob(cb,
410 size,
411 oop_maps,
412 unpack_offset,
413 unpack_with_exception_offset,
414 unpack_with_reexecution_offset,
415 frame_size);
416 }
417
418 trace_new_stub(blob, "DeoptimizationBlob");
419
420 return blob;
421 }
422
423
424 //----------------------------------------------------------------------------------------------------
425 // Implementation of UncommonTrapBlob
426
427 #ifdef COMPILER2
428 UncommonTrapBlob::UncommonTrapBlob(
429 CodeBuffer* cb,
430 int size,
431 OopMapSet* oop_maps,
432 int frame_size
433 )
434 : SingletonBlob("UncommonTrapBlob", cb, sizeof(UncommonTrapBlob), size, frame_size, oop_maps)
435 {}
436
437
438 UncommonTrapBlob* UncommonTrapBlob::create(
439 CodeBuffer* cb,
440 OopMapSet* oop_maps,
441 int frame_size)
442 {
443 UncommonTrapBlob* blob = NULL;
444 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
445 {
446 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
447 unsigned int size = CodeBlob::allocation_size(cb, sizeof(UncommonTrapBlob));
448 blob = new (size) UncommonTrapBlob(cb, size, oop_maps, frame_size);
449 }
450
451 trace_new_stub(blob, "UncommonTrapBlob");
452
453 return blob;
454 }
455
456
457 #endif // COMPILER2
458
459
460 //----------------------------------------------------------------------------------------------------
461 // Implementation of ExceptionBlob
462
463 #ifdef COMPILER2
464 ExceptionBlob::ExceptionBlob(
465 CodeBuffer* cb,
466 int size,
467 OopMapSet* oop_maps,
468 int frame_size
469 )
470 : SingletonBlob("ExceptionBlob", cb, sizeof(ExceptionBlob), size, frame_size, oop_maps)
471 {}
472
473
474 ExceptionBlob* ExceptionBlob::create(
475 CodeBuffer* cb,
476 OopMapSet* oop_maps,
477 int frame_size)
478 {
479 ExceptionBlob* blob = NULL;
480 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
481 {
482 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
483 unsigned int size = CodeBlob::allocation_size(cb, sizeof(ExceptionBlob));
484 blob = new (size) ExceptionBlob(cb, size, oop_maps, frame_size);
485 }
486
487 trace_new_stub(blob, "ExceptionBlob");
488
489 return blob;
490 }
491
492
493 #endif // COMPILER2
494
495
496 //----------------------------------------------------------------------------------------------------
497 // Implementation of SafepointBlob
498
499 SafepointBlob::SafepointBlob(
500 CodeBuffer* cb,
501 int size,
502 OopMapSet* oop_maps,
503 int frame_size
504 )
505 : SingletonBlob("SafepointBlob", cb, sizeof(SafepointBlob), size, frame_size, oop_maps)
506 {}
507
508
509 SafepointBlob* SafepointBlob::create(
510 CodeBuffer* cb,
511 OopMapSet* oop_maps,
512 int frame_size)
513 {
514 SafepointBlob* blob = NULL;
515 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
516 {
517 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
518 unsigned int size = CodeBlob::allocation_size(cb, sizeof(SafepointBlob));
519 blob = new (size) SafepointBlob(cb, size, oop_maps, frame_size);
520 }
521
522 trace_new_stub(blob, "SafepointBlob");
523
524 return blob;
525 }
526
527
528 //----------------------------------------------------------------------------------------------------
529 // Verification and printing
530
531 void CodeBlob::print_on(outputStream* st) const {
532 st->print_cr("[CodeBlob (" INTPTR_FORMAT ")]", p2i(this));
533 st->print_cr("Framesize: %d", _frame_size);
534 }
535
536 void CodeBlob::print_value_on(outputStream* st) const {
537 st->print_cr("[CodeBlob]");
538 }
539
540 void RuntimeBlob::verify() {
541 ShouldNotReachHere();
542 }
543
544 void BufferBlob::verify() {
545 // unimplemented
546 }
547
548 void BufferBlob::print_on(outputStream* st) const {
549 RuntimeBlob::print_on(st);
550 print_value_on(st);
551 }
552
553 void BufferBlob::print_value_on(outputStream* st) const {
554 st->print_cr("BufferBlob (" INTPTR_FORMAT ") used for %s", p2i(this), name());
555 }
556
557 void RuntimeStub::verify() {
558 // unimplemented
559 }
560
561 void RuntimeStub::print_on(outputStream* st) const {
562 ttyLocker ttyl;
563 RuntimeBlob::print_on(st);
564 st->print("Runtime Stub (" INTPTR_FORMAT "): ", p2i(this));
565 st->print_cr("%s", name());
566 Disassembler::decode((RuntimeBlob*)this, st);
567 }
568
569 void RuntimeStub::print_value_on(outputStream* st) const {
570 st->print("RuntimeStub (" INTPTR_FORMAT "): ", p2i(this)); st->print("%s", name());
571 }
572
573 void SingletonBlob::verify() {
574 // unimplemented
575 }
576
577 void SingletonBlob::print_on(outputStream* st) const {
578 ttyLocker ttyl;
579 RuntimeBlob::print_on(st);
580 st->print_cr("%s", name());
581 Disassembler::decode((RuntimeBlob*)this, st);
582 }
583
584 void SingletonBlob::print_value_on(outputStream* st) const {
585 st->print_cr("%s", name());
586 }
587
588 void DeoptimizationBlob::print_value_on(outputStream* st) const {
589 st->print_cr("Deoptimization (frame not available)");
590 }