author | mdoerr |
Thu, 04 Oct 2018 16:39:07 +0200 | |
changeset 52014 | 1aa9beac610e |
parent 51333 | f6641fcf7b7e |
child 54623 | 1126f0607c70 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
49655
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
2 |
* Copyright (c) 1998, 2018, 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:
5050
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5050
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:
5050
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
47765
b7c7428eaab9
8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents:
47216
diff
changeset
|
26 |
#include "jvm.h" |
7397 | 27 |
#include "code/codeBlob.hpp" |
28 |
#include "code/codeCache.hpp" |
|
52014
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
29 |
#include "code/icBuffer.hpp" |
7397 | 30 |
#include "code/relocInfo.hpp" |
52014
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
31 |
#include "code/vtableStubs.hpp" |
7397 | 32 |
#include "compiler/disassembler.hpp" |
33 |
#include "interpreter/bytecode.hpp" |
|
34 |
#include "memory/allocation.inline.hpp" |
|
35 |
#include "memory/heap.hpp" |
|
37248 | 36 |
#include "memory/resourceArea.hpp" |
7397 | 37 |
#include "oops/oop.inline.hpp" |
38 |
#include "prims/forte.hpp" |
|
39 |
#include "runtime/handles.inline.hpp" |
|
49449
ef5d5d343e2a
8199263: Split interfaceSupport.hpp to not require including .inline.hpp files
coleenp
parents:
47765
diff
changeset
|
40 |
#include "runtime/interfaceSupport.inline.hpp" |
7397 | 41 |
#include "runtime/mutexLocker.hpp" |
42 |
#include "runtime/safepoint.hpp" |
|
43 |
#include "runtime/sharedRuntime.hpp" |
|
44 |
#include "runtime/vframe.hpp" |
|
45 |
#include "services/memoryService.hpp" |
|
46625 | 46 |
#include "utilities/align.hpp" |
7397 | 47 |
#ifdef COMPILER1 |
48 |
#include "c1/c1_Runtime1.hpp" |
|
49 |
#endif |
|
1 | 50 |
|
42040
70ec5a09a0d5
8166377: is_compiled_by_jvmci hot in some profiles - improve nmethod compiler type detection
neliasso
parents:
38133
diff
changeset
|
51 |
const char* CodeBlob::compiler_name() const { |
70ec5a09a0d5
8166377: is_compiled_by_jvmci hot in some profiles - improve nmethod compiler type detection
neliasso
parents:
38133
diff
changeset
|
52 |
return compilertype2name(_type); |
70ec5a09a0d5
8166377: is_compiled_by_jvmci hot in some profiles - improve nmethod compiler type detection
neliasso
parents:
38133
diff
changeset
|
53 |
} |
70ec5a09a0d5
8166377: is_compiled_by_jvmci hot in some profiles - improve nmethod compiler type detection
neliasso
parents:
38133
diff
changeset
|
54 |
|
27642
8c9eff693145
8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents:
27420
diff
changeset
|
55 |
unsigned int CodeBlob::align_code_offset(int offset) { |
1 | 56 |
// align the size to CodeEntryAlignment |
57 |
return |
|
58 |
((offset + (int)CodeHeap::header_size() + (CodeEntryAlignment-1)) & ~(CodeEntryAlignment-1)) |
|
59 |
- (int)CodeHeap::header_size(); |
|
60 |
} |
|
61 |
||
62 |
||
63 |
// This must be consistent with the CodeBlob constructor's layout actions. |
|
64 |
unsigned int CodeBlob::allocation_size(CodeBuffer* cb, int header_size) { |
|
65 |
unsigned int size = header_size; |
|
46620
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46560
diff
changeset
|
66 |
size += align_up(cb->total_relocation_size(), oopSize); |
1 | 67 |
// align the size to CodeEntryAlignment |
68 |
size = align_code_offset(size); |
|
46620
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46560
diff
changeset
|
69 |
size += align_up(cb->total_content_size(), oopSize); |
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46560
diff
changeset
|
70 |
size += align_up(cb->total_oop_size(), oopSize); |
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46560
diff
changeset
|
71 |
size += align_up(cb->total_metadata_size(), oopSize); |
1 | 72 |
return size; |
73 |
} |
|
74 |
||
42040
70ec5a09a0d5
8166377: is_compiled_by_jvmci hot in some profiles - improve nmethod compiler type detection
neliasso
parents:
38133
diff
changeset
|
75 |
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) : |
51333
f6641fcf7b7e
8208670: Compiler changes to allow enabling -Wreorder
tschatzl
parents:
49655
diff
changeset
|
76 |
_type(type), |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
77 |
_size(layout.size()), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
78 |
_header_size(layout.header_size()), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
79 |
_frame_complete_offset(frame_complete_offset), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
80 |
_data_offset(layout.data_offset()), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
81 |
_frame_size(frame_size), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
82 |
_code_begin(layout.code_begin()), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
83 |
_code_end(layout.code_end()), |
51333
f6641fcf7b7e
8208670: Compiler changes to allow enabling -Wreorder
tschatzl
parents:
49655
diff
changeset
|
84 |
_content_begin(layout.content_begin()), |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
85 |
_data_end(layout.data_end()), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
86 |
_relocation_begin(layout.relocation_begin()), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
87 |
_relocation_end(layout.relocation_end()), |
51333
f6641fcf7b7e
8208670: Compiler changes to allow enabling -Wreorder
tschatzl
parents:
49655
diff
changeset
|
88 |
_oop_maps(oop_maps), |
f6641fcf7b7e
8208670: Compiler changes to allow enabling -Wreorder
tschatzl
parents:
49655
diff
changeset
|
89 |
_caller_must_gc_arguments(caller_must_gc_arguments), |
f6641fcf7b7e
8208670: Compiler changes to allow enabling -Wreorder
tschatzl
parents:
49655
diff
changeset
|
90 |
_strings(CodeStrings()), |
f6641fcf7b7e
8208670: Compiler changes to allow enabling -Wreorder
tschatzl
parents:
49655
diff
changeset
|
91 |
_name(name) |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
92 |
{ |
46620
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46560
diff
changeset
|
93 |
assert(is_aligned(layout.size(), oopSize), "unaligned size"); |
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46560
diff
changeset
|
94 |
assert(is_aligned(layout.header_size(), oopSize), "unaligned size"); |
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46560
diff
changeset
|
95 |
assert(is_aligned(layout.relocation_size(), oopSize), "unaligned size"); |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
96 |
assert(layout.code_end() == layout.content_end(), "must be the same - see code_end()"); |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
97 |
#ifdef COMPILER1 |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
98 |
// probably wrong for tiered |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
99 |
assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs"); |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
100 |
#endif // COMPILER1 |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
101 |
} |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
102 |
|
42040
70ec5a09a0d5
8166377: is_compiled_by_jvmci hot in some profiles - improve nmethod compiler type detection
neliasso
parents:
38133
diff
changeset
|
103 |
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) : |
51333
f6641fcf7b7e
8208670: Compiler changes to allow enabling -Wreorder
tschatzl
parents:
49655
diff
changeset
|
104 |
_type(type), |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
105 |
_size(layout.size()), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
106 |
_header_size(layout.header_size()), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
107 |
_frame_complete_offset(frame_complete_offset), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
108 |
_data_offset(layout.data_offset()), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
109 |
_frame_size(frame_size), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
110 |
_code_begin(layout.code_begin()), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
111 |
_code_end(layout.code_end()), |
51333
f6641fcf7b7e
8208670: Compiler changes to allow enabling -Wreorder
tschatzl
parents:
49655
diff
changeset
|
112 |
_content_begin(layout.content_begin()), |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
113 |
_data_end(layout.data_end()), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
114 |
_relocation_begin(layout.relocation_begin()), |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
115 |
_relocation_end(layout.relocation_end()), |
51333
f6641fcf7b7e
8208670: Compiler changes to allow enabling -Wreorder
tschatzl
parents:
49655
diff
changeset
|
116 |
_caller_must_gc_arguments(caller_must_gc_arguments), |
f6641fcf7b7e
8208670: Compiler changes to allow enabling -Wreorder
tschatzl
parents:
49655
diff
changeset
|
117 |
_strings(CodeStrings()), |
f6641fcf7b7e
8208670: Compiler changes to allow enabling -Wreorder
tschatzl
parents:
49655
diff
changeset
|
118 |
_name(name) |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
119 |
{ |
46620
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46560
diff
changeset
|
120 |
assert(is_aligned(_size, oopSize), "unaligned size"); |
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46560
diff
changeset
|
121 |
assert(is_aligned(_header_size, oopSize), "unaligned size"); |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
122 |
assert(_data_offset <= _size, "codeBlob is too small"); |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
123 |
assert(layout.code_end() == layout.content_end(), "must be the same - see code_end()"); |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
124 |
|
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
125 |
set_oop_maps(oop_maps); |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
126 |
#ifdef COMPILER1 |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
127 |
// probably wrong for tiered |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
128 |
assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs"); |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
129 |
#endif // COMPILER1 |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
130 |
} |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
131 |
|
1 | 132 |
|
133 |
// Creates a simple CodeBlob. Sets up the size of the different regions. |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
134 |
RuntimeBlob::RuntimeBlob(const char* name, int header_size, int size, int frame_complete, int locs_size) |
42040
70ec5a09a0d5
8166377: is_compiled_by_jvmci hot in some profiles - improve nmethod compiler type detection
neliasso
parents:
38133
diff
changeset
|
135 |
: CodeBlob(name, compiler_none, CodeBlobLayout((address) this, size, header_size, locs_size, size), frame_complete, 0, NULL, false /* caller_must_gc_arguments */) |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
136 |
{ |
46620
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46560
diff
changeset
|
137 |
assert(is_aligned(locs_size, oopSize), "unaligned size"); |
1 | 138 |
} |
139 |
||
140 |
||
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
141 |
// Creates a RuntimeBlob from a CodeBuffer |
1 | 142 |
// and copy code and relocation info. |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
143 |
RuntimeBlob::RuntimeBlob( |
1 | 144 |
const char* name, |
145 |
CodeBuffer* cb, |
|
146 |
int header_size, |
|
147 |
int size, |
|
148 |
int frame_complete, |
|
149 |
int frame_size, |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
150 |
OopMapSet* oop_maps, |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
151 |
bool caller_must_gc_arguments |
42040
70ec5a09a0d5
8166377: is_compiled_by_jvmci hot in some profiles - improve nmethod compiler type detection
neliasso
parents:
38133
diff
changeset
|
152 |
) : CodeBlob(name, compiler_none, CodeBlobLayout((address) this, size, header_size, cb), cb, frame_complete, frame_size, oop_maps, caller_must_gc_arguments) { |
1 | 153 |
cb->copy_code_and_locs_to(this); |
154 |
} |
|
155 |
||
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
156 |
void CodeBlob::flush() { |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
157 |
if (_oop_maps) { |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
158 |
FREE_C_HEAP_ARRAY(unsigned char, _oop_maps); |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
159 |
_oop_maps = NULL; |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
160 |
} |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
161 |
_strings.free(); |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
162 |
} |
1 | 163 |
|
164 |
void CodeBlob::set_oop_maps(OopMapSet* p) { |
|
165 |
// Danger Will Robinson! This method allocates a big |
|
166 |
// chunk of memory, its your job to free it. |
|
167 |
if (p != NULL) { |
|
30590 | 168 |
_oop_maps = ImmutableOopMapSet::build_from(p); |
1 | 169 |
} else { |
170 |
_oop_maps = NULL; |
|
171 |
} |
|
172 |
} |
|
173 |
||
174 |
||
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
175 |
void RuntimeBlob::trace_new_stub(RuntimeBlob* stub, const char* name1, const char* name2) { |
9630
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
176 |
// Do not hold the CodeCache lock during name formatting. |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
177 |
assert(!CodeCache_lock->owned_by_self(), "release CodeCache before registering the stub"); |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
178 |
|
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
179 |
if (stub != NULL) { |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
180 |
char stub_id[256]; |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
181 |
assert(strlen(name1) + strlen(name2) < sizeof(stub_id), ""); |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
182 |
jio_snprintf(stub_id, sizeof(stub_id), "%s%s", name1, name2); |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
183 |
if (PrintStubCode) { |
13887
89b873bcc55b
7200163: add CodeComments functionality to assember stubs
kvn
parents:
13728
diff
changeset
|
184 |
ttyLocker ttyl; |
9630
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
185 |
tty->print_cr("Decoding %s " INTPTR_FORMAT, stub_id, (intptr_t) stub); |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
186 |
Disassembler::decode(stub->code_begin(), stub->code_end()); |
13887
89b873bcc55b
7200163: add CodeComments functionality to assember stubs
kvn
parents:
13728
diff
changeset
|
187 |
tty->cr(); |
9630
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
188 |
} |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
189 |
Forte::register_stub(stub_id, stub->code_begin(), stub->code_end()); |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
190 |
|
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
191 |
if (JvmtiExport::should_post_dynamic_code_generated()) { |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
192 |
const char* stub_name = name2; |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
193 |
if (name2[0] == '\0') stub_name = name1; |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
194 |
JvmtiExport::post_dynamic_code_generated(stub_name, stub->code_begin(), stub->code_end()); |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
195 |
} |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
196 |
} |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
197 |
|
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
198 |
// Track memory usage statistic after releasing CodeCache_lock |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
199 |
MemoryService::track_code_cache_memory_usage(); |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
200 |
} |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
201 |
|
30590 | 202 |
const ImmutableOopMap* CodeBlob::oop_map_for_return_address(address return_address) { |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
203 |
assert(_oop_maps != NULL, "nope"); |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
204 |
return _oop_maps->find_map_at_offset((intptr_t) return_address - (intptr_t) code_begin()); |
1 | 205 |
} |
206 |
||
35542
9dccb7f9f656
8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents:
31620
diff
changeset
|
207 |
void CodeBlob::print_code() { |
9dccb7f9f656
8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents:
31620
diff
changeset
|
208 |
ResourceMark m; |
9dccb7f9f656
8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents:
31620
diff
changeset
|
209 |
Disassembler::decode(this, tty); |
9dccb7f9f656
8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents:
31620
diff
changeset
|
210 |
} |
1 | 211 |
|
212 |
//---------------------------------------------------------------------------------------------------- |
|
213 |
// Implementation of BufferBlob |
|
214 |
||
215 |
||
216 |
BufferBlob::BufferBlob(const char* name, int size) |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
217 |
: RuntimeBlob(name, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, /*locs_size:*/ 0) |
1 | 218 |
{} |
219 |
||
220 |
BufferBlob* BufferBlob::create(const char* name, int buffer_size) { |
|
221 |
ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
|
222 |
||
223 |
BufferBlob* blob = NULL; |
|
224 |
unsigned int size = sizeof(BufferBlob); |
|
225 |
// align the size to CodeEntryAlignment |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
226 |
size = CodeBlob::align_code_offset(size); |
46620
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46560
diff
changeset
|
227 |
size += align_up(buffer_size, oopSize); |
1 | 228 |
assert(name != NULL, "must provide a name"); |
229 |
{ |
|
230 |
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
|
231 |
blob = new (size) BufferBlob(name, size); |
|
232 |
} |
|
233 |
// Track memory usage statistic after releasing CodeCache_lock |
|
234 |
MemoryService::track_code_cache_memory_usage(); |
|
235 |
||
236 |
return blob; |
|
237 |
} |
|
238 |
||
239 |
||
240 |
BufferBlob::BufferBlob(const char* name, int size, CodeBuffer* cb) |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
241 |
: RuntimeBlob(name, cb, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, 0, NULL) |
1 | 242 |
{} |
243 |
||
244 |
BufferBlob* BufferBlob::create(const char* name, CodeBuffer* cb) { |
|
245 |
ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
|
246 |
||
247 |
BufferBlob* blob = NULL; |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
248 |
unsigned int size = CodeBlob::allocation_size(cb, sizeof(BufferBlob)); |
1 | 249 |
assert(name != NULL, "must provide a name"); |
250 |
{ |
|
251 |
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
|
252 |
blob = new (size) BufferBlob(name, size, cb); |
|
253 |
} |
|
254 |
// Track memory usage statistic after releasing CodeCache_lock |
|
255 |
MemoryService::track_code_cache_memory_usage(); |
|
256 |
||
257 |
return blob; |
|
258 |
} |
|
259 |
||
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26919
diff
changeset
|
260 |
void* BufferBlob::operator new(size_t s, unsigned size) throw() { |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26919
diff
changeset
|
261 |
return CodeCache::allocate(size, CodeBlobType::NonNMethod); |
1 | 262 |
} |
263 |
||
26796 | 264 |
void BufferBlob::free(BufferBlob *blob) { |
1 | 265 |
ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
26432 | 266 |
blob->flush(); |
1 | 267 |
{ |
268 |
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
269 |
CodeCache::free((RuntimeBlob*)blob); |
1 | 270 |
} |
271 |
// Track memory usage statistic after releasing CodeCache_lock |
|
272 |
MemoryService::track_code_cache_memory_usage(); |
|
273 |
} |
|
274 |
||
5050
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
275 |
|
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
276 |
//---------------------------------------------------------------------------------------------------- |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
277 |
// Implementation of AdapterBlob |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
278 |
|
6065 | 279 |
AdapterBlob::AdapterBlob(int size, CodeBuffer* cb) : |
280 |
BufferBlob("I2C/C2I adapters", size, cb) { |
|
281 |
CodeCache::commit(this); |
|
282 |
} |
|
283 |
||
5050
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
284 |
AdapterBlob* AdapterBlob::create(CodeBuffer* cb) { |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
285 |
ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
286 |
|
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
287 |
AdapterBlob* blob = NULL; |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
288 |
unsigned int size = CodeBlob::allocation_size(cb, sizeof(AdapterBlob)); |
5050
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
289 |
{ |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
290 |
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26919
diff
changeset
|
291 |
blob = new (size) AdapterBlob(size, cb); |
5050
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
292 |
} |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
293 |
// Track memory usage statistic after releasing CodeCache_lock |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
294 |
MemoryService::track_code_cache_memory_usage(); |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
295 |
|
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
296 |
return blob; |
1 | 297 |
} |
298 |
||
49655
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
299 |
VtableBlob::VtableBlob(const char* name, int size) : |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
300 |
BufferBlob(name, size) { |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
301 |
} |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
302 |
|
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
303 |
VtableBlob* VtableBlob::create(const char* name, int buffer_size) { |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
304 |
ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
305 |
|
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
306 |
VtableBlob* blob = NULL; |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
307 |
unsigned int size = sizeof(VtableBlob); |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
308 |
// align the size to CodeEntryAlignment |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
309 |
size = align_code_offset(size); |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
310 |
size += align_up(buffer_size, oopSize); |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
311 |
assert(name != NULL, "must provide a name"); |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
312 |
{ |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
313 |
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
314 |
blob = new (size) VtableBlob(name, size); |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
315 |
} |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
316 |
// Track memory usage statistic after releasing CodeCache_lock |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
317 |
MemoryService::track_code_cache_memory_usage(); |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
318 |
|
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
319 |
return blob; |
d6893a76c554
8199406: Performance drop with Java JDK 1.8.0_162-b32
poonam
parents:
49449
diff
changeset
|
320 |
} |
5050
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
321 |
|
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
322 |
//---------------------------------------------------------------------------------------------------- |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
323 |
// Implementation of MethodHandlesAdapterBlob |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
324 |
|
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
325 |
MethodHandlesAdapterBlob* MethodHandlesAdapterBlob::create(int buffer_size) { |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
326 |
ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
327 |
|
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
328 |
MethodHandlesAdapterBlob* blob = NULL; |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
329 |
unsigned int size = sizeof(MethodHandlesAdapterBlob); |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
330 |
// align the size to CodeEntryAlignment |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
331 |
size = CodeBlob::align_code_offset(size); |
46620
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46560
diff
changeset
|
332 |
size += align_up(buffer_size, oopSize); |
5050
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
333 |
{ |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
334 |
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26919
diff
changeset
|
335 |
blob = new (size) MethodHandlesAdapterBlob(size); |
36074
11263906664c
8138922: StubCodeDesc constructor publishes partially-constructed objects on StubCodeDesc::_list
vlivanov
parents:
35542
diff
changeset
|
336 |
if (blob == NULL) { |
11263906664c
8138922: StubCodeDesc constructor publishes partially-constructed objects on StubCodeDesc::_list
vlivanov
parents:
35542
diff
changeset
|
337 |
vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "CodeCache: no room for method handle adapter blob"); |
11263906664c
8138922: StubCodeDesc constructor publishes partially-constructed objects on StubCodeDesc::_list
vlivanov
parents:
35542
diff
changeset
|
338 |
} |
5050
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
339 |
} |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
340 |
// Track memory usage statistic after releasing CodeCache_lock |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
341 |
MemoryService::track_code_cache_memory_usage(); |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
342 |
|
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
343 |
return blob; |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
344 |
} |
47ecd86932ce
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1
diff
changeset
|
345 |
|
1 | 346 |
//---------------------------------------------------------------------------------------------------- |
347 |
// Implementation of RuntimeStub |
|
348 |
||
349 |
RuntimeStub::RuntimeStub( |
|
350 |
const char* name, |
|
351 |
CodeBuffer* cb, |
|
352 |
int size, |
|
353 |
int frame_complete, |
|
354 |
int frame_size, |
|
355 |
OopMapSet* oop_maps, |
|
356 |
bool caller_must_gc_arguments |
|
357 |
) |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
358 |
: RuntimeBlob(name, cb, sizeof(RuntimeStub), size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments) |
1 | 359 |
{ |
360 |
} |
|
361 |
||
362 |
RuntimeStub* RuntimeStub::new_runtime_stub(const char* stub_name, |
|
363 |
CodeBuffer* cb, |
|
364 |
int frame_complete, |
|
365 |
int frame_size, |
|
366 |
OopMapSet* oop_maps, |
|
367 |
bool caller_must_gc_arguments) |
|
368 |
{ |
|
369 |
RuntimeStub* stub = NULL; |
|
370 |
ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
|
42664 | 371 |
{ |
1 | 372 |
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
373 |
unsigned int size = CodeBlob::allocation_size(cb, sizeof(RuntimeStub)); |
1 | 374 |
stub = new (size) RuntimeStub(stub_name, cb, size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments); |
375 |
} |
|
376 |
||
9630
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
377 |
trace_new_stub(stub, "RuntimeStub - ", stub_name); |
1 | 378 |
|
379 |
return stub; |
|
380 |
} |
|
381 |
||
382 |
||
19696
bd5a0131bde1
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
17016
diff
changeset
|
383 |
void* RuntimeStub::operator new(size_t s, unsigned size) throw() { |
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26919
diff
changeset
|
384 |
void* p = CodeCache::allocate(size, CodeBlobType::NonNMethod); |
1 | 385 |
if (!p) fatal("Initial size of CodeCache is too small"); |
386 |
return p; |
|
387 |
} |
|
388 |
||
9630
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
389 |
// operator new shared by all singletons: |
19696
bd5a0131bde1
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
17016
diff
changeset
|
390 |
void* SingletonBlob::operator new(size_t s, unsigned size) throw() { |
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26919
diff
changeset
|
391 |
void* p = CodeCache::allocate(size, CodeBlobType::NonNMethod); |
9630
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
392 |
if (!p) fatal("Initial size of CodeCache is too small"); |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
393 |
return p; |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
394 |
} |
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
395 |
|
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
396 |
|
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
397 |
//---------------------------------------------------------------------------------------------------- |
1 | 398 |
// Implementation of DeoptimizationBlob |
399 |
||
400 |
DeoptimizationBlob::DeoptimizationBlob( |
|
401 |
CodeBuffer* cb, |
|
402 |
int size, |
|
403 |
OopMapSet* oop_maps, |
|
404 |
int unpack_offset, |
|
405 |
int unpack_with_exception_offset, |
|
406 |
int unpack_with_reexecution_offset, |
|
407 |
int frame_size |
|
408 |
) |
|
409 |
: SingletonBlob("DeoptimizationBlob", cb, sizeof(DeoptimizationBlob), size, frame_size, oop_maps) |
|
410 |
{ |
|
411 |
_unpack_offset = unpack_offset; |
|
412 |
_unpack_with_exception = unpack_with_exception_offset; |
|
413 |
_unpack_with_reexecution = unpack_with_reexecution_offset; |
|
414 |
#ifdef COMPILER1 |
|
415 |
_unpack_with_exception_in_tls = -1; |
|
416 |
#endif |
|
417 |
} |
|
418 |
||
419 |
||
420 |
DeoptimizationBlob* DeoptimizationBlob::create( |
|
421 |
CodeBuffer* cb, |
|
422 |
OopMapSet* oop_maps, |
|
423 |
int unpack_offset, |
|
424 |
int unpack_with_exception_offset, |
|
425 |
int unpack_with_reexecution_offset, |
|
426 |
int frame_size) |
|
427 |
{ |
|
428 |
DeoptimizationBlob* blob = NULL; |
|
429 |
ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
|
430 |
{ |
|
431 |
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
432 |
unsigned int size = CodeBlob::allocation_size(cb, sizeof(DeoptimizationBlob)); |
1 | 433 |
blob = new (size) DeoptimizationBlob(cb, |
434 |
size, |
|
435 |
oop_maps, |
|
436 |
unpack_offset, |
|
437 |
unpack_with_exception_offset, |
|
438 |
unpack_with_reexecution_offset, |
|
439 |
frame_size); |
|
440 |
} |
|
441 |
||
9630
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
442 |
trace_new_stub(blob, "DeoptimizationBlob"); |
1 | 443 |
|
444 |
return blob; |
|
445 |
} |
|
446 |
||
447 |
||
448 |
//---------------------------------------------------------------------------------------------------- |
|
449 |
// Implementation of UncommonTrapBlob |
|
450 |
||
451 |
#ifdef COMPILER2 |
|
452 |
UncommonTrapBlob::UncommonTrapBlob( |
|
453 |
CodeBuffer* cb, |
|
454 |
int size, |
|
455 |
OopMapSet* oop_maps, |
|
456 |
int frame_size |
|
457 |
) |
|
458 |
: SingletonBlob("UncommonTrapBlob", cb, sizeof(UncommonTrapBlob), size, frame_size, oop_maps) |
|
459 |
{} |
|
460 |
||
461 |
||
462 |
UncommonTrapBlob* UncommonTrapBlob::create( |
|
463 |
CodeBuffer* cb, |
|
464 |
OopMapSet* oop_maps, |
|
465 |
int frame_size) |
|
466 |
{ |
|
467 |
UncommonTrapBlob* blob = NULL; |
|
468 |
ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
|
469 |
{ |
|
470 |
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
471 |
unsigned int size = CodeBlob::allocation_size(cb, sizeof(UncommonTrapBlob)); |
1 | 472 |
blob = new (size) UncommonTrapBlob(cb, size, oop_maps, frame_size); |
473 |
} |
|
474 |
||
9630
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
475 |
trace_new_stub(blob, "UncommonTrapBlob"); |
1 | 476 |
|
477 |
return blob; |
|
478 |
} |
|
479 |
||
480 |
||
481 |
#endif // COMPILER2 |
|
482 |
||
483 |
||
484 |
//---------------------------------------------------------------------------------------------------- |
|
485 |
// Implementation of ExceptionBlob |
|
486 |
||
487 |
#ifdef COMPILER2 |
|
488 |
ExceptionBlob::ExceptionBlob( |
|
489 |
CodeBuffer* cb, |
|
490 |
int size, |
|
491 |
OopMapSet* oop_maps, |
|
492 |
int frame_size |
|
493 |
) |
|
494 |
: SingletonBlob("ExceptionBlob", cb, sizeof(ExceptionBlob), size, frame_size, oop_maps) |
|
495 |
{} |
|
496 |
||
497 |
||
498 |
ExceptionBlob* ExceptionBlob::create( |
|
499 |
CodeBuffer* cb, |
|
500 |
OopMapSet* oop_maps, |
|
501 |
int frame_size) |
|
502 |
{ |
|
503 |
ExceptionBlob* blob = NULL; |
|
504 |
ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
|
505 |
{ |
|
506 |
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
507 |
unsigned int size = CodeBlob::allocation_size(cb, sizeof(ExceptionBlob)); |
1 | 508 |
blob = new (size) ExceptionBlob(cb, size, oop_maps, frame_size); |
509 |
} |
|
510 |
||
9630
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
511 |
trace_new_stub(blob, "ExceptionBlob"); |
1 | 512 |
|
513 |
return blob; |
|
514 |
} |
|
515 |
||
516 |
||
517 |
#endif // COMPILER2 |
|
518 |
||
519 |
||
520 |
//---------------------------------------------------------------------------------------------------- |
|
521 |
// Implementation of SafepointBlob |
|
522 |
||
523 |
SafepointBlob::SafepointBlob( |
|
524 |
CodeBuffer* cb, |
|
525 |
int size, |
|
526 |
OopMapSet* oop_maps, |
|
527 |
int frame_size |
|
528 |
) |
|
529 |
: SingletonBlob("SafepointBlob", cb, sizeof(SafepointBlob), size, frame_size, oop_maps) |
|
530 |
{} |
|
531 |
||
532 |
||
533 |
SafepointBlob* SafepointBlob::create( |
|
534 |
CodeBuffer* cb, |
|
535 |
OopMapSet* oop_maps, |
|
536 |
int frame_size) |
|
537 |
{ |
|
538 |
SafepointBlob* blob = NULL; |
|
539 |
ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock |
|
540 |
{ |
|
541 |
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
542 |
unsigned int size = CodeBlob::allocation_size(cb, sizeof(SafepointBlob)); |
1 | 543 |
blob = new (size) SafepointBlob(cb, size, oop_maps, frame_size); |
544 |
} |
|
545 |
||
9630
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
8921
diff
changeset
|
546 |
trace_new_stub(blob, "SafepointBlob"); |
1 | 547 |
|
548 |
return blob; |
|
549 |
} |
|
550 |
||
551 |
||
552 |
//---------------------------------------------------------------------------------------------------- |
|
553 |
// Verification and printing |
|
554 |
||
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
6065
diff
changeset
|
555 |
void CodeBlob::print_on(outputStream* st) const { |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
20707
diff
changeset
|
556 |
st->print_cr("[CodeBlob (" INTPTR_FORMAT ")]", p2i(this)); |
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
6065
diff
changeset
|
557 |
st->print_cr("Framesize: %d", _frame_size); |
1 | 558 |
} |
559 |
||
560 |
void CodeBlob::print_value_on(outputStream* st) const { |
|
561 |
st->print_cr("[CodeBlob]"); |
|
562 |
} |
|
563 |
||
52014
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
564 |
void CodeBlob::dump_for_addr(address addr, outputStream* st, bool verbose) const { |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
565 |
if (is_buffer_blob()) { |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
566 |
// the interpreter is generated into a buffer blob |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
567 |
InterpreterCodelet* i = Interpreter::codelet_containing(addr); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
568 |
if (i != NULL) { |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
569 |
st->print_cr(INTPTR_FORMAT " is at code_begin+%d in an Interpreter codelet", p2i(addr), (int)(addr - i->code_begin())); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
570 |
i->print_on(st); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
571 |
return; |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
572 |
} |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
573 |
if (Interpreter::contains(addr)) { |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
574 |
st->print_cr(INTPTR_FORMAT " is pointing into interpreter code" |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
575 |
" (not bytecode specific)", p2i(addr)); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
576 |
return; |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
577 |
} |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
578 |
// |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
579 |
if (AdapterHandlerLibrary::contains(this)) { |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
580 |
st->print_cr(INTPTR_FORMAT " is at code_begin+%d in an AdapterHandler", p2i(addr), (int)(addr - code_begin())); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
581 |
AdapterHandlerLibrary::print_handler_on(st, this); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
582 |
} |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
583 |
// the stubroutines are generated into a buffer blob |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
584 |
StubCodeDesc* d = StubCodeDesc::desc_for(addr); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
585 |
if (d != NULL) { |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
586 |
st->print_cr(INTPTR_FORMAT " is at begin+%d in a stub", p2i(addr), (int)(addr - d->begin())); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
587 |
d->print_on(st); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
588 |
st->cr(); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
589 |
return; |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
590 |
} |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
591 |
if (StubRoutines::contains(addr)) { |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
592 |
st->print_cr(INTPTR_FORMAT " is pointing to an (unnamed) stub routine", p2i(addr)); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
593 |
return; |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
594 |
} |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
595 |
// the InlineCacheBuffer is using stubs generated into a buffer blob |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
596 |
if (InlineCacheBuffer::contains(addr)) { |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
597 |
st->print_cr(INTPTR_FORMAT " is pointing into InlineCacheBuffer", p2i(addr)); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
598 |
return; |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
599 |
} |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
600 |
VtableStub* v = VtableStubs::stub_containing(addr); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
601 |
if (v != NULL) { |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
602 |
st->print_cr(INTPTR_FORMAT " is at entry_point+%d in a vtable stub", p2i(addr), (int)(addr - v->entry_point())); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
603 |
v->print_on(st); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
604 |
st->cr(); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
605 |
return; |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
606 |
} |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
607 |
} |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
608 |
if (is_nmethod()) { |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
609 |
nmethod* nm = (nmethod*)this; |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
610 |
ResourceMark rm; |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
611 |
st->print(INTPTR_FORMAT " is at entry_point+%d in (nmethod*)" INTPTR_FORMAT, |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
612 |
p2i(addr), (int)(addr - nm->entry_point()), p2i(nm)); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
613 |
if (verbose) { |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
614 |
st->print(" for "); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
615 |
nm->method()->print_value_on(st); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
616 |
} |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
617 |
st->cr(); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
618 |
nm->print_nmethod(verbose); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
619 |
return; |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
620 |
} |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
621 |
st->print_cr(INTPTR_FORMAT " is at code_begin+%d in ", p2i(addr), (int)(addr - code_begin())); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
622 |
print_on(st); |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
623 |
} |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51333
diff
changeset
|
624 |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
625 |
void RuntimeBlob::verify() { |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
626 |
ShouldNotReachHere(); |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
627 |
} |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
628 |
|
1 | 629 |
void BufferBlob::verify() { |
630 |
// unimplemented |
|
631 |
} |
|
632 |
||
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
6065
diff
changeset
|
633 |
void BufferBlob::print_on(outputStream* st) const { |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
634 |
RuntimeBlob::print_on(st); |
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
6065
diff
changeset
|
635 |
print_value_on(st); |
1 | 636 |
} |
637 |
||
638 |
void BufferBlob::print_value_on(outputStream* st) const { |
|
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
20707
diff
changeset
|
639 |
st->print_cr("BufferBlob (" INTPTR_FORMAT ") used for %s", p2i(this), name()); |
1 | 640 |
} |
641 |
||
642 |
void RuntimeStub::verify() { |
|
643 |
// unimplemented |
|
644 |
} |
|
645 |
||
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
6065
diff
changeset
|
646 |
void RuntimeStub::print_on(outputStream* st) const { |
13887
89b873bcc55b
7200163: add CodeComments functionality to assember stubs
kvn
parents:
13728
diff
changeset
|
647 |
ttyLocker ttyl; |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
648 |
RuntimeBlob::print_on(st); |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
20707
diff
changeset
|
649 |
st->print("Runtime Stub (" INTPTR_FORMAT "): ", p2i(this)); |
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
20707
diff
changeset
|
650 |
st->print_cr("%s", name()); |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
651 |
Disassembler::decode((RuntimeBlob*)this, st); |
1 | 652 |
} |
653 |
||
654 |
void RuntimeStub::print_value_on(outputStream* st) const { |
|
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
20707
diff
changeset
|
655 |
st->print("RuntimeStub (" INTPTR_FORMAT "): ", p2i(this)); st->print("%s", name()); |
1 | 656 |
} |
657 |
||
658 |
void SingletonBlob::verify() { |
|
659 |
// unimplemented |
|
660 |
} |
|
661 |
||
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
6065
diff
changeset
|
662 |
void SingletonBlob::print_on(outputStream* st) const { |
13887
89b873bcc55b
7200163: add CodeComments functionality to assember stubs
kvn
parents:
13728
diff
changeset
|
663 |
ttyLocker ttyl; |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
664 |
RuntimeBlob::print_on(st); |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
20707
diff
changeset
|
665 |
st->print_cr("%s", name()); |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
37248
diff
changeset
|
666 |
Disassembler::decode((RuntimeBlob*)this, st); |
1 | 667 |
} |
668 |
||
669 |
void SingletonBlob::print_value_on(outputStream* st) const { |
|
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
20707
diff
changeset
|
670 |
st->print_cr("%s", name()); |
1 | 671 |
} |
672 |
||
673 |
void DeoptimizationBlob::print_value_on(outputStream* st) const { |
|
674 |
st->print_cr("Deoptimization (frame not available)"); |
|
675 |
} |