Mercurial > hg > truffle

annotate src/share/vm/code/codeBlob.cpp @ 21205:f34ae5c01864

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
include reexecute, rethrow_exception and return_oop info when disassembling debug scopes
author Doug Simon <doug.simon@oracle.com>
date Mon, 04 May 2015 10:39:12 +0200
parents 7848fc12602b
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 12880
diff changeset
2 * Copyright (c) 1998, 2014, Oracle and/or its affiliates. All rights reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1299
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1299
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1299
diff changeset
21 * questions.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
26 #include "code/codeBlob.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
27 #include "code/codeCache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
28 #include "code/relocInfo.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
29 #include "compiler/disassembler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
30 #include "interpreter/bytecode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
31 #include "memory/allocation.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
32 #include "memory/heap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
33 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
34 #include "prims/forte.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
35 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
36 #include "runtime/interfaceSupport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
37 #include "runtime/mutexLocker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
38 #include "runtime/safepoint.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
39 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
40 #include "runtime/vframe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
41 #include "services/memoryService.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
42 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
43 # include "nativeInst_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
44 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
45 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
46 # include "nativeInst_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
47 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
48 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
49 # include "nativeInst_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
50 #endif
2192
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 1972
diff changeset
51 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 1972
diff changeset
52 # include "nativeInst_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 1972
diff changeset
53 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 1972
diff changeset
54 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 1972
diff changeset
55 # include "nativeInst_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 1972
diff changeset
56 #endif
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
57 #ifdef COMPILER1
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
58 #include "c1/c1_Runtime1.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1762
diff changeset
59 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
60
a61af66fc99e Initial load
duke
parents:
diff changeset
61 unsigned int align_code_offset(int offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
62 // align the size to CodeEntryAlignment
a61af66fc99e Initial load
duke
parents:
diff changeset
63 return
a61af66fc99e Initial load
duke
parents:
diff changeset
64 ((offset + (int)CodeHeap::header_size() + (CodeEntryAlignment-1)) & ~(CodeEntryAlignment-1))
a61af66fc99e Initial load
duke
parents:
diff changeset
65 - (int)CodeHeap::header_size();
a61af66fc99e Initial load
duke
parents:
diff changeset
66 }
a61af66fc99e Initial load
duke
parents:
diff changeset
67
a61af66fc99e Initial load
duke
parents:
diff changeset
68
a61af66fc99e Initial load
duke
parents:
diff changeset
69 // This must be consistent with the CodeBlob constructor's layout actions.
a61af66fc99e Initial load
duke
parents:
diff changeset
70 unsigned int CodeBlob::allocation_size(CodeBuffer* cb, int header_size) {
a61af66fc99e Initial load
duke
parents:
diff changeset
71 unsigned int size = header_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
72 size += round_to(cb->total_relocation_size(), oopSize);
a61af66fc99e Initial load
duke
parents:
diff changeset
73 // align the size to CodeEntryAlignment
a61af66fc99e Initial load
duke
parents:
diff changeset
74 size = align_code_offset(size);
1748
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1681
diff changeset
75 size += round_to(cb->total_content_size(), oopSize);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
76 size += round_to(cb->total_oop_size(), oopSize);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6266
diff changeset
77 size += round_to(cb->total_metadata_size(), oopSize);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
78 return size;
a61af66fc99e Initial load
duke
parents:
diff changeset
79 }
a61af66fc99e Initial load
duke
parents:
diff changeset
80
a61af66fc99e Initial load
duke
parents:
diff changeset
81
a61af66fc99e Initial load
duke
parents:
diff changeset
82 // Creates a simple CodeBlob. Sets up the size of the different regions.
a61af66fc99e Initial load
duke
parents:
diff changeset
83 CodeBlob::CodeBlob(const char* name, int header_size, int size, int frame_complete, int locs_size) {
1748
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1681
diff changeset
84 assert(size == round_to(size, oopSize), "unaligned size");
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1681
diff changeset
85 assert(locs_size == round_to(locs_size, oopSize), "unaligned size");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
86 assert(header_size == round_to(header_size, oopSize), "unaligned size");
a61af66fc99e Initial load
duke
parents:
diff changeset
87 assert(!UseRelocIndex, "no space allocated for reloc index yet");
a61af66fc99e Initial load
duke
parents:
diff changeset
88
a61af66fc99e Initial load
duke
parents:
diff changeset
89 // Note: If UseRelocIndex is enabled, there needs to be (at least) one
a61af66fc99e Initial load
duke
parents:
diff changeset
90 // extra word for the relocation information, containing the reloc
a61af66fc99e Initial load
duke
parents:
diff changeset
91 // index table length. Unfortunately, the reloc index table imple-
a61af66fc99e Initial load
duke
parents:
diff changeset
92 // mentation is not easily understandable and thus it is not clear
a61af66fc99e Initial load
duke
parents:
diff changeset
93 // what exactly the format is supposed to be. For now, we just turn
a61af66fc99e Initial load
duke
parents:
diff changeset
94 // off the use of this table (gri 7/6/2000).
a61af66fc99e Initial load
duke
parents:
diff changeset
95
a61af66fc99e Initial load
duke
parents:
diff changeset
96 _name = name;
a61af66fc99e Initial load
duke
parents:
diff changeset
97 _size = size;
a61af66fc99e Initial load
duke
parents:
diff changeset
98 _frame_complete_offset = frame_complete;
a61af66fc99e Initial load
duke
parents:
diff changeset
99 _header_size = header_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
100 _relocation_size = locs_size;
1748
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1681
diff changeset
101 _content_offset = align_code_offset(header_size + _relocation_size);
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1681
diff changeset
102 _code_offset = _content_offset;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
103 _data_offset = size;
a61af66fc99e Initial load
duke
parents:
diff changeset
104 _frame_size = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
105 set_oop_maps(NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
106 }
a61af66fc99e Initial load
duke
parents:
diff changeset
107
a61af66fc99e Initial load
duke
parents:
diff changeset
108
a61af66fc99e Initial load
duke
parents:
diff changeset
109 // Creates a CodeBlob from a CodeBuffer. Sets up the size of the different regions,
a61af66fc99e Initial load
duke
parents:
diff changeset
110 // and copy code and relocation info.
a61af66fc99e Initial load
duke
parents:
diff changeset
111 CodeBlob::CodeBlob(
a61af66fc99e Initial load
duke
parents:
diff changeset
112 const char* name,
a61af66fc99e Initial load
duke
parents:
diff changeset
113 CodeBuffer* cb,
a61af66fc99e Initial load
duke
parents:
diff changeset
114 int header_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
115 int size,
a61af66fc99e Initial load
duke
parents:
diff changeset
116 int frame_complete,
a61af66fc99e Initial load
duke
parents:
diff changeset
117 int frame_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
118 OopMapSet* oop_maps
a61af66fc99e Initial load
duke
parents:
diff changeset
119 ) {
1748
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1681
diff changeset
120 assert(size == round_to(size, oopSize), "unaligned size");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
121 assert(header_size == round_to(header_size, oopSize), "unaligned size");
a61af66fc99e Initial load
duke
parents:
diff changeset
122
a61af66fc99e Initial load
duke
parents:
diff changeset
123 _name = name;
a61af66fc99e Initial load
duke
parents:
diff changeset
124 _size = size;
a61af66fc99e Initial load
duke
parents:
diff changeset
125 _frame_complete_offset = frame_complete;
a61af66fc99e Initial load
duke
parents:
diff changeset
126 _header_size = header_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
127 _relocation_size = round_to(cb->total_relocation_size(), oopSize);
1748
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1681
diff changeset
128 _content_offset = align_code_offset(header_size + _relocation_size);
1762
0878d7bae69f 6961697: move nmethod constants section before instruction section
twisti
parents: 1748
diff changeset
129 _code_offset = _content_offset + cb->total_offset_of(cb->insts());
1748
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1681
diff changeset
130 _data_offset = _content_offset + round_to(cb->total_content_size(), oopSize);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
131 assert(_data_offset <= size, "codeBlob is too small");
a61af66fc99e Initial load
duke
parents:
diff changeset
132
a61af66fc99e Initial load
duke
parents:
diff changeset
133 cb->copy_code_and_locs_to(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
134 set_oop_maps(oop_maps);
a61af66fc99e Initial load
duke
parents:
diff changeset
135 _frame_size = frame_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
136 #ifdef COMPILER1
a61af66fc99e Initial load
duke
parents:
diff changeset
137 // probably wrong for tiered
a61af66fc99e Initial load
duke
parents:
diff changeset
138 assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs");
a61af66fc99e Initial load
duke
parents:
diff changeset
139 #endif // COMPILER1
a61af66fc99e Initial load
duke
parents:
diff changeset
140 }
a61af66fc99e Initial load
duke
parents:
diff changeset
141
a61af66fc99e Initial load
duke
parents:
diff changeset
142
a61af66fc99e Initial load
duke
parents:
diff changeset
143 void CodeBlob::set_oop_maps(OopMapSet* p) {
a61af66fc99e Initial load
duke
parents:
diff changeset
144 // Danger Will Robinson! This method allocates a big
a61af66fc99e Initial load
duke
parents:
diff changeset
145 // chunk of memory, its your job to free it.
a61af66fc99e Initial load
duke
parents:
diff changeset
146 if (p != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
147 // We need to allocate a chunk big enough to hold the OopMapSet and all of its OopMaps
6197
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 3363
diff changeset
148 _oop_maps = (OopMapSet* )NEW_C_HEAP_ARRAY(unsigned char, p->heap_size(), mtCode);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
149 p->copy_to((address)_oop_maps);
a61af66fc99e Initial load
duke
parents:
diff changeset
150 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
151 _oop_maps = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
152 }
a61af66fc99e Initial load
duke
parents:
diff changeset
153 }
a61af66fc99e Initial load
duke
parents:
diff changeset
154
a61af66fc99e Initial load
duke
parents:
diff changeset
155
3363
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
156 void CodeBlob::trace_new_stub(CodeBlob* stub, const char* name1, const char* name2) {
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
157 // Do not hold the CodeCache lock during name formatting.
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
158 assert(!CodeCache_lock->owned_by_self(), "release CodeCache before registering the stub");
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
159
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
160 if (stub != NULL) {
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
161 char stub_id[256];
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
162 assert(strlen(name1) + strlen(name2) < sizeof(stub_id), "");
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
163 jio_snprintf(stub_id, sizeof(stub_id), "%s%s", name1, name2);
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
164 if (PrintStubCode) {
6796
b31471cdc53e 7200163: add CodeComments functionality to assember stubs
kvn
parents: 6725
diff changeset
165 ttyLocker ttyl;
3363
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
166 tty->print_cr("Decoding %s " INTPTR_FORMAT, stub_id, (intptr_t) stub);
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
167 Disassembler::decode(stub->code_begin(), stub->code_end());
6796
b31471cdc53e 7200163: add CodeComments functionality to assember stubs
kvn
parents: 6725
diff changeset
168 tty->cr();
3363
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
169 }
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
170 Forte::register_stub(stub_id, stub->code_begin(), stub->code_end());
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
171
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
172 if (JvmtiExport::should_post_dynamic_code_generated()) {
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
173 const char* stub_name = name2;
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
174 if (name2[0] == '\0') stub_name = name1;
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
175 JvmtiExport::post_dynamic_code_generated(stub_name, stub->code_begin(), stub->code_end());
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
176 }
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
177 }
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
178
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
179 // Track memory usage statistic after releasing CodeCache_lock
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
180 MemoryService::track_code_cache_memory_usage();
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
181 }
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
182
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
183
0
a61af66fc99e Initial load
duke
parents:
diff changeset
184 void CodeBlob::flush() {
a61af66fc99e Initial load
duke
parents:
diff changeset
185 if (_oop_maps) {
6197
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 3363
diff changeset
186 FREE_C_HEAP_ARRAY(unsigned char, _oop_maps, mtCode);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
187 _oop_maps = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
188 }
8767
a5de0cc2f91c 8008555: Debugging code in compiled method sometimes leaks memory
roland
parents: 6796
diff changeset
189 _strings.free();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
190 }
a61af66fc99e Initial load
duke
parents:
diff changeset
191
a61af66fc99e Initial load
duke
parents:
diff changeset
192
a61af66fc99e Initial load
duke
parents:
diff changeset
193 OopMap* CodeBlob::oop_map_for_return_address(address return_address) {
1748
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1681
diff changeset
194 assert(oop_maps() != NULL, "nope");
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1681
diff changeset
195 return oop_maps()->find_map_at_offset((intptr_t) return_address - (intptr_t) code_begin());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
196 }
a61af66fc99e Initial load
duke
parents:
diff changeset
197
a61af66fc99e Initial load
duke
parents:
diff changeset
198
a61af66fc99e Initial load
duke
parents:
diff changeset
199 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
200 // Implementation of BufferBlob
a61af66fc99e Initial load
duke
parents:
diff changeset
201
a61af66fc99e Initial load
duke
parents:
diff changeset
202
a61af66fc99e Initial load
duke
parents:
diff changeset
203 BufferBlob::BufferBlob(const char* name, int size)
a61af66fc99e Initial load
duke
parents:
diff changeset
204 : CodeBlob(name, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, /*locs_size:*/ 0)
a61af66fc99e Initial load
duke
parents:
diff changeset
205 {}
a61af66fc99e Initial load
duke
parents:
diff changeset
206
a61af66fc99e Initial load
duke
parents:
diff changeset
207 BufferBlob* BufferBlob::create(const char* name, int buffer_size) {
a61af66fc99e Initial load
duke
parents:
diff changeset
208 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load
duke
parents:
diff changeset
209
a61af66fc99e Initial load
duke
parents:
diff changeset
210 BufferBlob* blob = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
211 unsigned int size = sizeof(BufferBlob);
a61af66fc99e Initial load
duke
parents:
diff changeset
212 // align the size to CodeEntryAlignment
a61af66fc99e Initial load
duke
parents:
diff changeset
213 size = align_code_offset(size);
a61af66fc99e Initial load
duke
parents:
diff changeset
214 size += round_to(buffer_size, oopSize);
a61af66fc99e Initial load
duke
parents:
diff changeset
215 assert(name != NULL, "must provide a name");
a61af66fc99e Initial load
duke
parents:
diff changeset
216 {
a61af66fc99e Initial load
duke
parents:
diff changeset
217 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load
duke
parents:
diff changeset
218 blob = new (size) BufferBlob(name, size);
a61af66fc99e Initial load
duke
parents:
diff changeset
219 }
a61af66fc99e Initial load
duke
parents:
diff changeset
220 // Track memory usage statistic after releasing CodeCache_lock
a61af66fc99e Initial load
duke
parents:
diff changeset
221 MemoryService::track_code_cache_memory_usage();
a61af66fc99e Initial load
duke
parents:
diff changeset
222
a61af66fc99e Initial load
duke
parents:
diff changeset
223 return blob;
a61af66fc99e Initial load
duke
parents:
diff changeset
224 }
a61af66fc99e Initial load
duke
parents:
diff changeset
225
a61af66fc99e Initial load
duke
parents:
diff changeset
226
a61af66fc99e Initial load
duke
parents:
diff changeset
227 BufferBlob::BufferBlob(const char* name, int size, CodeBuffer* cb)
a61af66fc99e Initial load
duke
parents:
diff changeset
228 : CodeBlob(name, cb, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, 0, NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
229 {}
a61af66fc99e Initial load
duke
parents:
diff changeset
230
a61af66fc99e Initial load
duke
parents:
diff changeset
231 BufferBlob* BufferBlob::create(const char* name, CodeBuffer* cb) {
a61af66fc99e Initial load
duke
parents:
diff changeset
232 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load
duke
parents:
diff changeset
233
a61af66fc99e Initial load
duke
parents:
diff changeset
234 BufferBlob* blob = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
235 unsigned int size = allocation_size(cb, sizeof(BufferBlob));
a61af66fc99e Initial load
duke
parents:
diff changeset
236 assert(name != NULL, "must provide a name");
a61af66fc99e Initial load
duke
parents:
diff changeset
237 {
a61af66fc99e Initial load
duke
parents:
diff changeset
238 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load
duke
parents:
diff changeset
239 blob = new (size) BufferBlob(name, size, cb);
a61af66fc99e Initial load
duke
parents:
diff changeset
240 }
a61af66fc99e Initial load
duke
parents:
diff changeset
241 // Track memory usage statistic after releasing CodeCache_lock
a61af66fc99e Initial load
duke
parents:
diff changeset
242 MemoryService::track_code_cache_memory_usage();
a61af66fc99e Initial load
duke
parents:
diff changeset
243
a61af66fc99e Initial load
duke
parents:
diff changeset
244 return blob;
a61af66fc99e Initial load
duke
parents:
diff changeset
245 }
a61af66fc99e Initial load
duke
parents:
diff changeset
246
a61af66fc99e Initial load
duke
parents:
diff changeset
247
12880
469216acdb28 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 12146
diff changeset
248 void* BufferBlob::operator new(size_t s, unsigned size, bool is_critical) throw() {
469216acdb28 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 12146
diff changeset
249 void* p = CodeCache::allocate(size, is_critical);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
250 return p;
a61af66fc99e Initial load
duke
parents:
diff changeset
251 }
a61af66fc99e Initial load
duke
parents:
diff changeset
252
a61af66fc99e Initial load
duke
parents:
diff changeset
253
a61af66fc99e Initial load
duke
parents:
diff changeset
254 void BufferBlob::free( BufferBlob *blob ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
255 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
20435
094cbdffa87d 8054292: code comments leak in fastdebug builds
drchase
parents: 17937
diff changeset
256 blob->flush();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
257 {
a61af66fc99e Initial load
duke
parents:
diff changeset
258 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load
duke
parents:
diff changeset
259 CodeCache::free((CodeBlob*)blob);
a61af66fc99e Initial load
duke
parents:
diff changeset
260 }
a61af66fc99e Initial load
duke
parents:
diff changeset
261 // Track memory usage statistic after releasing CodeCache_lock
a61af66fc99e Initial load
duke
parents:
diff changeset
262 MemoryService::track_code_cache_memory_usage();
a61af66fc99e Initial load
duke
parents:
diff changeset
263 }
a61af66fc99e Initial load
duke
parents:
diff changeset
264
1299
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
265
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
266 //----------------------------------------------------------------------------------------------------
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
267 // Implementation of AdapterBlob
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
268
1663
7139e81efd2d 6970566: runThese fails with SIGSEGV
never
parents: 1644
diff changeset
269 AdapterBlob::AdapterBlob(int size, CodeBuffer* cb) :
7139e81efd2d 6970566: runThese fails with SIGSEGV
never
parents: 1644
diff changeset
270 BufferBlob("I2C/C2I adapters", size, cb) {
7139e81efd2d 6970566: runThese fails with SIGSEGV
never
parents: 1644
diff changeset
271 CodeCache::commit(this);
7139e81efd2d 6970566: runThese fails with SIGSEGV
never
parents: 1644
diff changeset
272 }
7139e81efd2d 6970566: runThese fails with SIGSEGV
never
parents: 1644
diff changeset
273
1299
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
274 AdapterBlob* AdapterBlob::create(CodeBuffer* cb) {
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
275 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
276
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
277 AdapterBlob* blob = NULL;
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
278 unsigned int size = allocation_size(cb, sizeof(AdapterBlob));
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
279 {
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
280 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
12880
469216acdb28 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 12146
diff changeset
281 // The parameter 'true' indicates a critical memory allocation.
469216acdb28 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 12146
diff changeset
282 // This means that CodeCacheMinimumFreeSpace is used, if necessary
469216acdb28 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 12146
diff changeset
283 const bool is_critical = true;
469216acdb28 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 12146
diff changeset
284 blob = new (size, is_critical) AdapterBlob(size, cb);
1299
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
285 }
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
286 // Track memory usage statistic after releasing CodeCache_lock
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
287 MemoryService::track_code_cache_memory_usage();
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
288
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
289 return blob;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
290 }
a61af66fc99e Initial load
duke
parents:
diff changeset
291
1299
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
292
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
293 //----------------------------------------------------------------------------------------------------
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
294 // Implementation of MethodHandlesAdapterBlob
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
295
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
296 MethodHandlesAdapterBlob* MethodHandlesAdapterBlob::create(int buffer_size) {
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
297 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
298
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
299 MethodHandlesAdapterBlob* blob = NULL;
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
300 unsigned int size = sizeof(MethodHandlesAdapterBlob);
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
301 // align the size to CodeEntryAlignment
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
302 size = align_code_offset(size);
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
303 size += round_to(buffer_size, oopSize);
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
304 {
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
305 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
12880
469216acdb28 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 12146
diff changeset
306 // The parameter 'true' indicates a critical memory allocation.
469216acdb28 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 12146
diff changeset
307 // This means that CodeCacheMinimumFreeSpace is used, if necessary
469216acdb28 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 12146
diff changeset
308 const bool is_critical = true;
469216acdb28 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 12146
diff changeset
309 blob = new (size, is_critical) MethodHandlesAdapterBlob(size);
1299
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
310 }
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
311 // Track memory usage statistic after releasing CodeCache_lock
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
312 MemoryService::track_code_cache_memory_usage();
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
313
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
314 return blob;
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
315 }
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
316
9eba43136cb5 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 0
diff changeset
317
0
a61af66fc99e Initial load
duke
parents:
diff changeset
318 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
319 // Implementation of RuntimeStub
a61af66fc99e Initial load
duke
parents:
diff changeset
320
a61af66fc99e Initial load
duke
parents:
diff changeset
321 RuntimeStub::RuntimeStub(
a61af66fc99e Initial load
duke
parents:
diff changeset
322 const char* name,
a61af66fc99e Initial load
duke
parents:
diff changeset
323 CodeBuffer* cb,
a61af66fc99e Initial load
duke
parents:
diff changeset
324 int size,
a61af66fc99e Initial load
duke
parents:
diff changeset
325 int frame_complete,
a61af66fc99e Initial load
duke
parents:
diff changeset
326 int frame_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
327 OopMapSet* oop_maps,
a61af66fc99e Initial load
duke
parents:
diff changeset
328 bool caller_must_gc_arguments
a61af66fc99e Initial load
duke
parents:
diff changeset
329 )
a61af66fc99e Initial load
duke
parents:
diff changeset
330 : CodeBlob(name, cb, sizeof(RuntimeStub), size, frame_complete, frame_size, oop_maps)
a61af66fc99e Initial load
duke
parents:
diff changeset
331 {
a61af66fc99e Initial load
duke
parents:
diff changeset
332 _caller_must_gc_arguments = caller_must_gc_arguments;
a61af66fc99e Initial load
duke
parents:
diff changeset
333 }
a61af66fc99e Initial load
duke
parents:
diff changeset
334
a61af66fc99e Initial load
duke
parents:
diff changeset
335
a61af66fc99e Initial load
duke
parents:
diff changeset
336 RuntimeStub* RuntimeStub::new_runtime_stub(const char* stub_name,
a61af66fc99e Initial load
duke
parents:
diff changeset
337 CodeBuffer* cb,
a61af66fc99e Initial load
duke
parents:
diff changeset
338 int frame_complete,
a61af66fc99e Initial load
duke
parents:
diff changeset
339 int frame_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
340 OopMapSet* oop_maps,
a61af66fc99e Initial load
duke
parents:
diff changeset
341 bool caller_must_gc_arguments)
a61af66fc99e Initial load
duke
parents:
diff changeset
342 {
a61af66fc99e Initial load
duke
parents:
diff changeset
343 RuntimeStub* stub = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
344 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load
duke
parents:
diff changeset
345 {
a61af66fc99e Initial load
duke
parents:
diff changeset
346 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load
duke
parents:
diff changeset
347 unsigned int size = allocation_size(cb, sizeof(RuntimeStub));
a61af66fc99e Initial load
duke
parents:
diff changeset
348 stub = new (size) RuntimeStub(stub_name, cb, size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
349 }
a61af66fc99e Initial load
duke
parents:
diff changeset
350
3363
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
351 trace_new_stub(stub, "RuntimeStub - ", stub_name);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
352
a61af66fc99e Initial load
duke
parents:
diff changeset
353 return stub;
a61af66fc99e Initial load
duke
parents:
diff changeset
354 }
a61af66fc99e Initial load
duke
parents:
diff changeset
355
a61af66fc99e Initial load
duke
parents:
diff changeset
356
12146
9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents: 10114
diff changeset
357 void* RuntimeStub::operator new(size_t s, unsigned size) throw() {
10114
a7fb14888912 8006952: Slow VM due to excessive code cache freelist iteration
neliasso
parents: 8767
diff changeset
358 void* p = CodeCache::allocate(size, true);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
359 if (!p) fatal("Initial size of CodeCache is too small");
a61af66fc99e Initial load
duke
parents:
diff changeset
360 return p;
a61af66fc99e Initial load
duke
parents:
diff changeset
361 }
a61af66fc99e Initial load
duke
parents:
diff changeset
362
3363
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
363 // operator new shared by all singletons:
12146
9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents: 10114
diff changeset
364 void* SingletonBlob::operator new(size_t s, unsigned size) throw() {
10114
a7fb14888912 8006952: Slow VM due to excessive code cache freelist iteration
neliasso
parents: 8767
diff changeset
365 void* p = CodeCache::allocate(size, true);
3363
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
366 if (!p) fatal("Initial size of CodeCache is too small");
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
367 return p;
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
368 }
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
369
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
370
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
371 //----------------------------------------------------------------------------------------------------
0
a61af66fc99e Initial load
duke
parents:
diff changeset
372 // Implementation of DeoptimizationBlob
a61af66fc99e Initial load
duke
parents:
diff changeset
373
a61af66fc99e Initial load
duke
parents:
diff changeset
374 DeoptimizationBlob::DeoptimizationBlob(
a61af66fc99e Initial load
duke
parents:
diff changeset
375 CodeBuffer* cb,
a61af66fc99e Initial load
duke
parents:
diff changeset
376 int size,
a61af66fc99e Initial load
duke
parents:
diff changeset
377 OopMapSet* oop_maps,
a61af66fc99e Initial load
duke
parents:
diff changeset
378 int unpack_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
379 int unpack_with_exception_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
380 int unpack_with_reexecution_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
381 int frame_size
a61af66fc99e Initial load
duke
parents:
diff changeset
382 )
a61af66fc99e Initial load
duke
parents:
diff changeset
383 : SingletonBlob("DeoptimizationBlob", cb, sizeof(DeoptimizationBlob), size, frame_size, oop_maps)
a61af66fc99e Initial load
duke
parents:
diff changeset
384 {
a61af66fc99e Initial load
duke
parents:
diff changeset
385 _unpack_offset = unpack_offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
386 _unpack_with_exception = unpack_with_exception_offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
387 _unpack_with_reexecution = unpack_with_reexecution_offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
388 #ifdef COMPILER1
a61af66fc99e Initial load
duke
parents:
diff changeset
389 _unpack_with_exception_in_tls = -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
390 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
391 }
a61af66fc99e Initial load
duke
parents:
diff changeset
392
a61af66fc99e Initial load
duke
parents:
diff changeset
393
a61af66fc99e Initial load
duke
parents:
diff changeset
394 DeoptimizationBlob* DeoptimizationBlob::create(
a61af66fc99e Initial load
duke
parents:
diff changeset
395 CodeBuffer* cb,
a61af66fc99e Initial load
duke
parents:
diff changeset
396 OopMapSet* oop_maps,
a61af66fc99e Initial load
duke
parents:
diff changeset
397 int unpack_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
398 int unpack_with_exception_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
399 int unpack_with_reexecution_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
400 int frame_size)
a61af66fc99e Initial load
duke
parents:
diff changeset
401 {
a61af66fc99e Initial load
duke
parents:
diff changeset
402 DeoptimizationBlob* blob = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
403 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load
duke
parents:
diff changeset
404 {
a61af66fc99e Initial load
duke
parents:
diff changeset
405 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load
duke
parents:
diff changeset
406 unsigned int size = allocation_size(cb, sizeof(DeoptimizationBlob));
a61af66fc99e Initial load
duke
parents:
diff changeset
407 blob = new (size) DeoptimizationBlob(cb,
a61af66fc99e Initial load
duke
parents:
diff changeset
408 size,
a61af66fc99e Initial load
duke
parents:
diff changeset
409 oop_maps,
a61af66fc99e Initial load
duke
parents:
diff changeset
410 unpack_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
411 unpack_with_exception_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
412 unpack_with_reexecution_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
413 frame_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
414 }
a61af66fc99e Initial load
duke
parents:
diff changeset
415
3363
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
416 trace_new_stub(blob, "DeoptimizationBlob");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
417
a61af66fc99e Initial load
duke
parents:
diff changeset
418 return blob;
a61af66fc99e Initial load
duke
parents:
diff changeset
419 }
a61af66fc99e Initial load
duke
parents:
diff changeset
420
a61af66fc99e Initial load
duke
parents:
diff changeset
421
a61af66fc99e Initial load
duke
parents:
diff changeset
422 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
423 // Implementation of UncommonTrapBlob
a61af66fc99e Initial load
duke
parents:
diff changeset
424
a61af66fc99e Initial load
duke
parents:
diff changeset
425 #ifdef COMPILER2
a61af66fc99e Initial load
duke
parents:
diff changeset
426 UncommonTrapBlob::UncommonTrapBlob(
a61af66fc99e Initial load
duke
parents:
diff changeset
427 CodeBuffer* cb,
a61af66fc99e Initial load
duke
parents:
diff changeset
428 int size,
a61af66fc99e Initial load
duke
parents:
diff changeset
429 OopMapSet* oop_maps,
a61af66fc99e Initial load
duke
parents:
diff changeset
430 int frame_size
a61af66fc99e Initial load
duke
parents:
diff changeset
431 )
a61af66fc99e Initial load
duke
parents:
diff changeset
432 : SingletonBlob("UncommonTrapBlob", cb, sizeof(UncommonTrapBlob), size, frame_size, oop_maps)
a61af66fc99e Initial load
duke
parents:
diff changeset
433 {}
a61af66fc99e Initial load
duke
parents:
diff changeset
434
a61af66fc99e Initial load
duke
parents:
diff changeset
435
a61af66fc99e Initial load
duke
parents:
diff changeset
436 UncommonTrapBlob* UncommonTrapBlob::create(
a61af66fc99e Initial load
duke
parents:
diff changeset
437 CodeBuffer* cb,
a61af66fc99e Initial load
duke
parents:
diff changeset
438 OopMapSet* oop_maps,
a61af66fc99e Initial load
duke
parents:
diff changeset
439 int frame_size)
a61af66fc99e Initial load
duke
parents:
diff changeset
440 {
a61af66fc99e Initial load
duke
parents:
diff changeset
441 UncommonTrapBlob* blob = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
442 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load
duke
parents:
diff changeset
443 {
a61af66fc99e Initial load
duke
parents:
diff changeset
444 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load
duke
parents:
diff changeset
445 unsigned int size = allocation_size(cb, sizeof(UncommonTrapBlob));
a61af66fc99e Initial load
duke
parents:
diff changeset
446 blob = new (size) UncommonTrapBlob(cb, size, oop_maps, frame_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
447 }
a61af66fc99e Initial load
duke
parents:
diff changeset
448
3363
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
449 trace_new_stub(blob, "UncommonTrapBlob");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
450
a61af66fc99e Initial load
duke
parents:
diff changeset
451 return blob;
a61af66fc99e Initial load
duke
parents:
diff changeset
452 }
a61af66fc99e Initial load
duke
parents:
diff changeset
453
a61af66fc99e Initial load
duke
parents:
diff changeset
454
a61af66fc99e Initial load
duke
parents:
diff changeset
455 #endif // COMPILER2
a61af66fc99e Initial load
duke
parents:
diff changeset
456
a61af66fc99e Initial load
duke
parents:
diff changeset
457
a61af66fc99e Initial load
duke
parents:
diff changeset
458 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
459 // Implementation of ExceptionBlob
a61af66fc99e Initial load
duke
parents:
diff changeset
460
a61af66fc99e Initial load
duke
parents:
diff changeset
461 #ifdef COMPILER2
a61af66fc99e Initial load
duke
parents:
diff changeset
462 ExceptionBlob::ExceptionBlob(
a61af66fc99e Initial load
duke
parents:
diff changeset
463 CodeBuffer* cb,
a61af66fc99e Initial load
duke
parents:
diff changeset
464 int size,
a61af66fc99e Initial load
duke
parents:
diff changeset
465 OopMapSet* oop_maps,
a61af66fc99e Initial load
duke
parents:
diff changeset
466 int frame_size
a61af66fc99e Initial load
duke
parents:
diff changeset
467 )
a61af66fc99e Initial load
duke
parents:
diff changeset
468 : SingletonBlob("ExceptionBlob", cb, sizeof(ExceptionBlob), size, frame_size, oop_maps)
a61af66fc99e Initial load
duke
parents:
diff changeset
469 {}
a61af66fc99e Initial load
duke
parents:
diff changeset
470
a61af66fc99e Initial load
duke
parents:
diff changeset
471
a61af66fc99e Initial load
duke
parents:
diff changeset
472 ExceptionBlob* ExceptionBlob::create(
a61af66fc99e Initial load
duke
parents:
diff changeset
473 CodeBuffer* cb,
a61af66fc99e Initial load
duke
parents:
diff changeset
474 OopMapSet* oop_maps,
a61af66fc99e Initial load
duke
parents:
diff changeset
475 int frame_size)
a61af66fc99e Initial load
duke
parents:
diff changeset
476 {
a61af66fc99e Initial load
duke
parents:
diff changeset
477 ExceptionBlob* blob = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
478 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load
duke
parents:
diff changeset
479 {
a61af66fc99e Initial load
duke
parents:
diff changeset
480 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load
duke
parents:
diff changeset
481 unsigned int size = allocation_size(cb, sizeof(ExceptionBlob));
a61af66fc99e Initial load
duke
parents:
diff changeset
482 blob = new (size) ExceptionBlob(cb, size, oop_maps, frame_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
483 }
a61af66fc99e Initial load
duke
parents:
diff changeset
484
3363
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
485 trace_new_stub(blob, "ExceptionBlob");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
486
a61af66fc99e Initial load
duke
parents:
diff changeset
487 return blob;
a61af66fc99e Initial load
duke
parents:
diff changeset
488 }
a61af66fc99e Initial load
duke
parents:
diff changeset
489
a61af66fc99e Initial load
duke
parents:
diff changeset
490
a61af66fc99e Initial load
duke
parents:
diff changeset
491 #endif // COMPILER2
a61af66fc99e Initial load
duke
parents:
diff changeset
492
a61af66fc99e Initial load
duke
parents:
diff changeset
493
a61af66fc99e Initial load
duke
parents:
diff changeset
494 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
495 // Implementation of SafepointBlob
a61af66fc99e Initial load
duke
parents:
diff changeset
496
a61af66fc99e Initial load
duke
parents:
diff changeset
497 SafepointBlob::SafepointBlob(
a61af66fc99e Initial load
duke
parents:
diff changeset
498 CodeBuffer* cb,
a61af66fc99e Initial load
duke
parents:
diff changeset
499 int size,
a61af66fc99e Initial load
duke
parents:
diff changeset
500 OopMapSet* oop_maps,
a61af66fc99e Initial load
duke
parents:
diff changeset
501 int frame_size
a61af66fc99e Initial load
duke
parents:
diff changeset
502 )
a61af66fc99e Initial load
duke
parents:
diff changeset
503 : SingletonBlob("SafepointBlob", cb, sizeof(SafepointBlob), size, frame_size, oop_maps)
a61af66fc99e Initial load
duke
parents:
diff changeset
504 {}
a61af66fc99e Initial load
duke
parents:
diff changeset
505
a61af66fc99e Initial load
duke
parents:
diff changeset
506
a61af66fc99e Initial load
duke
parents:
diff changeset
507 SafepointBlob* SafepointBlob::create(
a61af66fc99e Initial load
duke
parents:
diff changeset
508 CodeBuffer* cb,
a61af66fc99e Initial load
duke
parents:
diff changeset
509 OopMapSet* oop_maps,
a61af66fc99e Initial load
duke
parents:
diff changeset
510 int frame_size)
a61af66fc99e Initial load
duke
parents:
diff changeset
511 {
a61af66fc99e Initial load
duke
parents:
diff changeset
512 SafepointBlob* blob = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
513 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
a61af66fc99e Initial load
duke
parents:
diff changeset
514 {
a61af66fc99e Initial load
duke
parents:
diff changeset
515 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load
duke
parents:
diff changeset
516 unsigned int size = allocation_size(cb, sizeof(SafepointBlob));
a61af66fc99e Initial load
duke
parents:
diff changeset
517 blob = new (size) SafepointBlob(cb, size, oop_maps, frame_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
518 }
a61af66fc99e Initial load
duke
parents:
diff changeset
519
3363
167b70ff3abc 6939861: JVM should handle more conversion operations
never
parents: 2426
diff changeset
520 trace_new_stub(blob, "SafepointBlob");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
521
a61af66fc99e Initial load
duke
parents:
diff changeset
522 return blob;
a61af66fc99e Initial load
duke
parents:
diff changeset
523 }
a61af66fc99e Initial load
duke
parents:
diff changeset
524
a61af66fc99e Initial load
duke
parents:
diff changeset
525
a61af66fc99e Initial load
duke
parents:
diff changeset
526 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
527 // Verification and printing
a61af66fc99e Initial load
duke
parents:
diff changeset
528
a61af66fc99e Initial load
duke
parents:
diff changeset
529 void CodeBlob::verify() {
a61af66fc99e Initial load
duke
parents:
diff changeset
530 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
531 }
a61af66fc99e Initial load
duke
parents:
diff changeset
532
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1663
diff changeset
533 void CodeBlob::print_on(outputStream* st) const {
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 12880
diff changeset
534 st->print_cr("[CodeBlob (" INTPTR_FORMAT ")]", p2i(this));
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1663
diff changeset
535 st->print_cr("Framesize: %d", _frame_size);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
536 }
a61af66fc99e Initial load
duke
parents:
diff changeset
537
a61af66fc99e Initial load
duke
parents:
diff changeset
538 void CodeBlob::print_value_on(outputStream* st) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
539 st->print_cr("[CodeBlob]");
a61af66fc99e Initial load
duke
parents:
diff changeset
540 }
a61af66fc99e Initial load
duke
parents:
diff changeset
541
a61af66fc99e Initial load
duke
parents:
diff changeset
542 void BufferBlob::verify() {
a61af66fc99e Initial load
duke
parents:
diff changeset
543 // unimplemented
a61af66fc99e Initial load
duke
parents:
diff changeset
544 }
a61af66fc99e Initial load
duke
parents:
diff changeset
545
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1663
diff changeset
546 void BufferBlob::print_on(outputStream* st) const {
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1663
diff changeset
547 CodeBlob::print_on(st);
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1663
diff changeset
548 print_value_on(st);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
549 }
a61af66fc99e Initial load
duke
parents:
diff changeset
550
a61af66fc99e Initial load
duke
parents:
diff changeset
551 void BufferBlob::print_value_on(outputStream* st) const {
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 12880
diff changeset
552 st->print_cr("BufferBlob (" INTPTR_FORMAT ") used for %s", p2i(this), name());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
553 }
a61af66fc99e Initial load
duke
parents:
diff changeset
554
a61af66fc99e Initial load
duke
parents:
diff changeset
555 void RuntimeStub::verify() {
a61af66fc99e Initial load
duke
parents:
diff changeset
556 // unimplemented
a61af66fc99e Initial load
duke
parents:
diff changeset
557 }
a61af66fc99e Initial load
duke
parents:
diff changeset
558
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1663
diff changeset
559 void RuntimeStub::print_on(outputStream* st) const {
6796
b31471cdc53e 7200163: add CodeComments functionality to assember stubs
kvn
parents: 6725
diff changeset
560 ttyLocker ttyl;
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1663
diff changeset
561 CodeBlob::print_on(st);
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 12880
diff changeset
562 st->print("Runtime Stub (" INTPTR_FORMAT "): ", p2i(this));
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 12880
diff changeset
563 st->print_cr("%s", name());
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1663
diff changeset
564 Disassembler::decode((CodeBlob*)this, st);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
565 }
a61af66fc99e Initial load
duke
parents:
diff changeset
566
a61af66fc99e Initial load
duke
parents:
diff changeset
567 void RuntimeStub::print_value_on(outputStream* st) const {
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 12880
diff changeset
568 st->print("RuntimeStub (" INTPTR_FORMAT "): ", p2i(this)); st->print("%s", name());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
569 }
a61af66fc99e Initial load
duke
parents:
diff changeset
570
a61af66fc99e Initial load
duke
parents:
diff changeset
571 void SingletonBlob::verify() {
a61af66fc99e Initial load
duke
parents:
diff changeset
572 // unimplemented
a61af66fc99e Initial load
duke
parents:
diff changeset
573 }
a61af66fc99e Initial load
duke
parents:
diff changeset
574
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1663
diff changeset
575 void SingletonBlob::print_on(outputStream* st) const {
6796
b31471cdc53e 7200163: add CodeComments functionality to assember stubs
kvn
parents: 6725
diff changeset
576 ttyLocker ttyl;
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1663
diff changeset
577 CodeBlob::print_on(st);
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 12880
diff changeset
578 st->print_cr("%s", name());
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1663
diff changeset
579 Disassembler::decode((CodeBlob*)this, st);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
580 }
a61af66fc99e Initial load
duke
parents:
diff changeset
581
a61af66fc99e Initial load
duke
parents:
diff changeset
582 void SingletonBlob::print_value_on(outputStream* st) const {
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 12880
diff changeset
583 st->print_cr("%s", name());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
584 }
a61af66fc99e Initial load
duke
parents:
diff changeset
585
a61af66fc99e Initial load
duke
parents:
diff changeset
586 void DeoptimizationBlob::print_value_on(outputStream* st) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
587 st->print_cr("Deoptimization (frame not available)");
a61af66fc99e Initial load
duke
parents:
diff changeset
588 }