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