author | vlivanov |
Mon, 14 Mar 2016 12:35:48 +0300 | |
changeset 36602 | 3ab2b2853c57 |
parent 34501 | d914dfe7abf5 |
child 38673 | e8a403dd5a7d |
permissions | -rw-r--r-- |
1 | 1 |
/* |
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33160
diff
changeset
|
2 |
* Copyright (c) 1998, 2015, 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:
4894
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4894
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:
4894
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
26 |
#include "code/debugInfoRec.hpp" |
|
27 |
#include "code/scopeDesc.hpp" |
|
28 |
#include "prims/jvmtiExport.hpp" |
|
1 | 29 |
|
30 |
// Private definition. |
|
31 |
// There is one DIR_Chunk for each scope and values array. |
|
32 |
// A chunk can potentially be used more than once. |
|
33 |
// We keep track of these chunks in order to detect |
|
34 |
// repetition and enable sharing. |
|
35 |
class DIR_Chunk { |
|
34501
d914dfe7abf5
8142333: Build failure in debugInfoRec.cpp with SS12u4
never
parents:
33593
diff
changeset
|
36 |
private: |
1 | 37 |
int _offset; // location in the stream of this scope |
38 |
int _length; // number of bytes in the stream |
|
39 |
int _hash; // hash of stream bytes (for quicker reuse) |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
40 |
#if INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
41 |
DebugInformationRecorder* _DIR; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
42 |
#endif |
1 | 43 |
|
34501
d914dfe7abf5
8142333: Build failure in debugInfoRec.cpp with SS12u4
never
parents:
33593
diff
changeset
|
44 |
public: |
d914dfe7abf5
8142333: Build failure in debugInfoRec.cpp with SS12u4
never
parents:
33593
diff
changeset
|
45 |
int offset() { return _offset; } |
d914dfe7abf5
8142333: Build failure in debugInfoRec.cpp with SS12u4
never
parents:
33593
diff
changeset
|
46 |
|
19696
bd5a0131bde1
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
13728
diff
changeset
|
47 |
void* operator new(size_t ignore, DebugInformationRecorder* dir) throw() { |
1 | 48 |
assert(ignore == sizeof(DIR_Chunk), ""); |
49 |
if (dir->_next_chunk >= dir->_next_chunk_limit) { |
|
50 |
const int CHUNK = 100; |
|
51 |
dir->_next_chunk = NEW_RESOURCE_ARRAY(DIR_Chunk, CHUNK); |
|
52 |
dir->_next_chunk_limit = dir->_next_chunk + CHUNK; |
|
53 |
} |
|
54 |
return dir->_next_chunk++; |
|
55 |
} |
|
56 |
||
57 |
DIR_Chunk(int offset, int length, DebugInformationRecorder* dir) { |
|
58 |
_offset = offset; |
|
59 |
_length = length; |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
60 |
#if INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
61 |
_DIR = dir; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
62 |
#endif |
1 | 63 |
unsigned int hash = 0; |
64 |
address p = dir->stream()->buffer() + _offset; |
|
65 |
for (int i = 0; i < length; i++) { |
|
66 |
if (i == 6) break; |
|
67 |
hash *= 127; |
|
68 |
hash += p[i]; |
|
69 |
} |
|
70 |
_hash = hash; |
|
71 |
} |
|
72 |
||
73 |
DIR_Chunk* find_match(GrowableArray<DIR_Chunk*>* arr, |
|
74 |
int start_index, |
|
75 |
DebugInformationRecorder* dir) { |
|
76 |
int end_index = arr->length(); |
|
77 |
int hash = this->_hash, length = this->_length; |
|
78 |
address buf = dir->stream()->buffer(); |
|
79 |
for (int i = end_index; --i >= start_index; ) { |
|
80 |
DIR_Chunk* that = arr->at(i); |
|
81 |
if (hash == that->_hash && |
|
82 |
length == that->_length && |
|
83 |
0 == memcmp(buf + this->_offset, buf + that->_offset, length)) { |
|
84 |
return that; |
|
85 |
} |
|
86 |
} |
|
87 |
return NULL; |
|
88 |
} |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
89 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
90 |
#if INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
91 |
static int compare(DIR_Chunk* const & a, DIR_Chunk* const & b) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
92 |
if (b->_hash > a->_hash) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
93 |
return 1; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
94 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
95 |
if (b->_hash < a->_hash) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
96 |
return -1; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
97 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
98 |
if (b->_length > a->_length) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
99 |
return 1; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
100 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
101 |
if (b->_length < a->_length) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
102 |
return -1; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
103 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
104 |
address buf = a->_DIR->stream()->buffer(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
105 |
return memcmp(buf + b->_offset, buf + a->_offset, a->_length); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
106 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
107 |
#endif |
1 | 108 |
}; |
109 |
||
110 |
static inline bool compute_recording_non_safepoints() { |
|
111 |
if (JvmtiExport::should_post_compiled_method_load() |
|
112 |
&& FLAG_IS_DEFAULT(DebugNonSafepoints)) { |
|
113 |
// The default value of this flag is taken to be true, |
|
114 |
// if JVMTI is looking at nmethod codes. |
|
115 |
// We anticipate that JVMTI may wish to participate in profiling. |
|
116 |
return true; |
|
117 |
} |
|
118 |
||
119 |
// If the flag is set manually, use it, whether true or false. |
|
120 |
// Otherwise, if JVMTI is not in the picture, use the default setting. |
|
121 |
// (This is true in debug, just for the exercise, false in product mode.) |
|
122 |
return DebugNonSafepoints; |
|
123 |
} |
|
124 |
||
125 |
DebugInformationRecorder::DebugInformationRecorder(OopRecorder* oop_recorder) |
|
126 |
: _recording_non_safepoints(compute_recording_non_safepoints()) |
|
127 |
{ |
|
128 |
_pcs_size = 100; |
|
129 |
_pcs = NEW_RESOURCE_ARRAY(PcDesc, _pcs_size); |
|
130 |
_pcs_length = 0; |
|
131 |
||
132 |
_prev_safepoint_pc = PcDesc::lower_offset_limit; |
|
133 |
||
134 |
_stream = new DebugInfoWriteStream(this, 10 * K); |
|
135 |
// make sure that there is no stream_decode_offset that is zero |
|
136 |
_stream->write_byte((jbyte)0xFF); |
|
137 |
||
138 |
// make sure that we can distinguish the value "serialized_null" from offsets |
|
139 |
assert(_stream->position() > serialized_null, "sanity"); |
|
140 |
||
141 |
_oop_recorder = oop_recorder; |
|
142 |
||
143 |
_all_chunks = new GrowableArray<DIR_Chunk*>(300); |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
144 |
#if !INCLUDE_JVMCI |
1 | 145 |
_shared_chunks = new GrowableArray<DIR_Chunk*>(30); |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
146 |
#endif |
1 | 147 |
_next_chunk = _next_chunk_limit = NULL; |
148 |
||
149 |
add_new_pc_offset(PcDesc::lower_offset_limit); // sentinel record |
|
150 |
||
151 |
debug_only(_recording_state = rs_null); |
|
152 |
} |
|
153 |
||
154 |
||
155 |
void DebugInformationRecorder::add_oopmap(int pc_offset, OopMap* map) { |
|
156 |
// !!!!! Preserve old style handling of oopmaps for now |
|
157 |
_oopmaps->add_gc_map(pc_offset, map); |
|
158 |
} |
|
159 |
||
160 |
void DebugInformationRecorder::add_safepoint(int pc_offset, OopMap* map) { |
|
161 |
assert(!_oop_recorder->is_complete(), "not frozen yet"); |
|
162 |
// Store the new safepoint |
|
163 |
||
164 |
// Add the oop map |
|
165 |
add_oopmap(pc_offset, map); |
|
166 |
||
167 |
add_new_pc_offset(pc_offset); |
|
168 |
||
169 |
assert(_recording_state == rs_null, "nesting of recording calls"); |
|
170 |
debug_only(_recording_state = rs_safepoint); |
|
171 |
} |
|
172 |
||
173 |
void DebugInformationRecorder::add_non_safepoint(int pc_offset) { |
|
174 |
assert(!_oop_recorder->is_complete(), "not frozen yet"); |
|
175 |
assert(_recording_non_safepoints, "must be recording non-safepoints"); |
|
176 |
||
177 |
add_new_pc_offset(pc_offset); |
|
178 |
||
179 |
assert(_recording_state == rs_null, "nesting of recording calls"); |
|
180 |
debug_only(_recording_state = rs_non_safepoint); |
|
181 |
} |
|
182 |
||
183 |
void DebugInformationRecorder::add_new_pc_offset(int pc_offset) { |
|
184 |
assert(_pcs_length == 0 || last_pc()->pc_offset() < pc_offset, |
|
185 |
"must specify a new, larger pc offset"); |
|
186 |
||
187 |
// add the pcdesc |
|
188 |
if (_pcs_length == _pcs_size) { |
|
189 |
// Expand |
|
190 |
int new_pcs_size = _pcs_size * 2; |
|
191 |
PcDesc* new_pcs = NEW_RESOURCE_ARRAY(PcDesc, new_pcs_size); |
|
192 |
for (int index = 0; index < _pcs_length; index++) { |
|
193 |
new_pcs[index] = _pcs[index]; |
|
194 |
} |
|
195 |
_pcs_size = new_pcs_size; |
|
196 |
_pcs = new_pcs; |
|
197 |
} |
|
198 |
assert(_pcs_size > _pcs_length, "There must be room for after expanding"); |
|
199 |
||
200 |
_pcs[_pcs_length++] = PcDesc(pc_offset, DebugInformationRecorder::serialized_null, |
|
201 |
DebugInformationRecorder::serialized_null); |
|
202 |
} |
|
203 |
||
204 |
||
205 |
int DebugInformationRecorder::serialize_monitor_values(GrowableArray<MonitorValue*>* monitors) { |
|
206 |
if (monitors == NULL || monitors->is_empty()) return DebugInformationRecorder::serialized_null; |
|
207 |
assert(_recording_state == rs_safepoint, "must be recording a safepoint"); |
|
208 |
int result = stream()->position(); |
|
209 |
stream()->write_int(monitors->length()); |
|
210 |
for (int index = 0; index < monitors->length(); index++) { |
|
211 |
monitors->at(index)->write_on(stream()); |
|
212 |
} |
|
213 |
assert(result != serialized_null, "sanity"); |
|
214 |
||
215 |
// (See comment below on DebugInformationRecorder::describe_scope.) |
|
216 |
int shared_result = find_sharable_decode_offset(result); |
|
217 |
if (shared_result != serialized_null) { |
|
218 |
stream()->set_position(result); |
|
219 |
result = shared_result; |
|
220 |
} |
|
221 |
||
222 |
return result; |
|
223 |
} |
|
224 |
||
225 |
||
226 |
int DebugInformationRecorder::serialize_scope_values(GrowableArray<ScopeValue*>* values) { |
|
227 |
if (values == NULL || values->is_empty()) return DebugInformationRecorder::serialized_null; |
|
228 |
assert(_recording_state == rs_safepoint, "must be recording a safepoint"); |
|
229 |
int result = stream()->position(); |
|
230 |
assert(result != serialized_null, "sanity"); |
|
231 |
stream()->write_int(values->length()); |
|
232 |
for (int index = 0; index < values->length(); index++) { |
|
233 |
values->at(index)->write_on(stream()); |
|
234 |
} |
|
235 |
||
236 |
// (See comment below on DebugInformationRecorder::describe_scope.) |
|
237 |
int shared_result = find_sharable_decode_offset(result); |
|
238 |
if (shared_result != serialized_null) { |
|
239 |
stream()->set_position(result); |
|
240 |
result = shared_result; |
|
241 |
} |
|
242 |
||
243 |
return result; |
|
244 |
} |
|
245 |
||
246 |
||
247 |
#ifndef PRODUCT |
|
248 |
// These variables are put into one block to reduce relocations |
|
249 |
// and make it simpler to print from the debugger. |
|
250 |
static |
|
251 |
struct dir_stats_struct { |
|
252 |
int chunks_queried; |
|
253 |
int chunks_shared; |
|
254 |
int chunks_reshared; |
|
255 |
int chunks_elided; |
|
256 |
||
257 |
void print() { |
|
258 |
tty->print_cr("Debug Data Chunks: %d, shared %d+%d, non-SP's elided %d", |
|
259 |
chunks_queried, |
|
260 |
chunks_shared, chunks_reshared, |
|
261 |
chunks_elided); |
|
262 |
} |
|
263 |
} dir_stats; |
|
264 |
#endif //PRODUCT |
|
265 |
||
266 |
||
267 |
int DebugInformationRecorder::find_sharable_decode_offset(int stream_offset) { |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
268 |
#if !INCLUDE_JVMCI |
1 | 269 |
// Only pull this trick if non-safepoint recording |
270 |
// is enabled, for now. |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
271 |
if (!recording_non_safepoints()) { |
1 | 272 |
return serialized_null; |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
273 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
274 |
#endif // INCLUDE_JVMCI |
1 | 275 |
|
276 |
NOT_PRODUCT(++dir_stats.chunks_queried); |
|
277 |
int stream_length = stream()->position() - stream_offset; |
|
278 |
assert(stream_offset != serialized_null, "should not be null"); |
|
279 |
assert(stream_length != 0, "should not be empty"); |
|
280 |
||
281 |
DIR_Chunk* ns = new(this) DIR_Chunk(stream_offset, stream_length, this); |
|
282 |
||
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
283 |
#if INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
284 |
DIR_Chunk* match = _all_chunks->insert_sorted<DIR_Chunk::compare>(ns); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
285 |
if (match != ns) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
286 |
// Found an existing chunk |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
287 |
NOT_PRODUCT(++dir_stats.chunks_shared); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
288 |
assert(ns+1 == _next_chunk, ""); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
289 |
_next_chunk = ns; |
34501
d914dfe7abf5
8142333: Build failure in debugInfoRec.cpp with SS12u4
never
parents:
33593
diff
changeset
|
290 |
return match->offset(); |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
291 |
} else { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
292 |
// Inserted this chunk, so nothing to do |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
293 |
return serialized_null; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
294 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
295 |
#else // INCLUDE_JVMCI |
1 | 296 |
// Look in previously shared scopes first: |
297 |
DIR_Chunk* ms = ns->find_match(_shared_chunks, 0, this); |
|
298 |
if (ms != NULL) { |
|
299 |
NOT_PRODUCT(++dir_stats.chunks_reshared); |
|
300 |
assert(ns+1 == _next_chunk, ""); |
|
301 |
_next_chunk = ns; |
|
34501
d914dfe7abf5
8142333: Build failure in debugInfoRec.cpp with SS12u4
never
parents:
33593
diff
changeset
|
302 |
return ms->offset(); |
1 | 303 |
} |
304 |
||
305 |
// Look in recently encountered scopes next: |
|
306 |
const int MAX_RECENT = 50; |
|
307 |
int start_index = _all_chunks->length() - MAX_RECENT; |
|
308 |
if (start_index < 0) start_index = 0; |
|
309 |
ms = ns->find_match(_all_chunks, start_index, this); |
|
310 |
if (ms != NULL) { |
|
311 |
NOT_PRODUCT(++dir_stats.chunks_shared); |
|
312 |
// Searching in _all_chunks is limited to a window, |
|
313 |
// but searching in _shared_chunks is unlimited. |
|
314 |
_shared_chunks->append(ms); |
|
315 |
assert(ns+1 == _next_chunk, ""); |
|
316 |
_next_chunk = ns; |
|
34501
d914dfe7abf5
8142333: Build failure in debugInfoRec.cpp with SS12u4
never
parents:
33593
diff
changeset
|
317 |
return ms->offset(); |
1 | 318 |
} |
319 |
||
320 |
// No match. Add this guy to the list, in hopes of future shares. |
|
321 |
_all_chunks->append(ns); |
|
322 |
return serialized_null; |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
323 |
#endif // INCLUDE_JVMCI |
1 | 324 |
} |
325 |
||
326 |
||
327 |
// must call add_safepoint before: it sets PcDesc and this routine uses |
|
328 |
// the last PcDesc set |
|
329 |
void DebugInformationRecorder::describe_scope(int pc_offset, |
|
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33160
diff
changeset
|
330 |
const methodHandle& methodH, |
1 | 331 |
ciMethod* method, |
332 |
int bci, |
|
3600
27aa4477d039
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
1
diff
changeset
|
333 |
bool reexecute, |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
334 |
bool rethrow_exception, |
4564
55dfb20908d0
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
4017
diff
changeset
|
335 |
bool is_method_handle_invoke, |
4894
8a76fd3d098d
6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop")
kvn
parents:
4564
diff
changeset
|
336 |
bool return_oop, |
1 | 337 |
DebugToken* locals, |
338 |
DebugToken* expressions, |
|
339 |
DebugToken* monitors) { |
|
340 |
assert(_recording_state != rs_null, "nesting of recording calls"); |
|
341 |
PcDesc* last_pd = last_pc(); |
|
342 |
assert(last_pd->pc_offset() == pc_offset, "must be last pc"); |
|
343 |
int sender_stream_offset = last_pd->scope_decode_offset(); |
|
344 |
// update the stream offset of current pc desc |
|
345 |
int stream_offset = stream()->position(); |
|
346 |
last_pd->set_scope_decode_offset(stream_offset); |
|
347 |
||
4564
55dfb20908d0
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
4017
diff
changeset
|
348 |
// Record flags into pcDesc. |
3686
69c1b5228547
6873116: Modify reexecute implementation to use pcDesc to record the reexecute bit
cfang
parents:
3600
diff
changeset
|
349 |
last_pd->set_should_reexecute(reexecute); |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
350 |
last_pd->set_rethrow_exception(rethrow_exception); |
4564
55dfb20908d0
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
4017
diff
changeset
|
351 |
last_pd->set_is_method_handle_invoke(is_method_handle_invoke); |
4894
8a76fd3d098d
6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop")
kvn
parents:
4564
diff
changeset
|
352 |
last_pd->set_return_oop(return_oop); |
3686
69c1b5228547
6873116: Modify reexecute implementation to use pcDesc to record the reexecute bit
cfang
parents:
3600
diff
changeset
|
353 |
|
1 | 354 |
// serialize sender stream offest |
355 |
stream()->write_int(sender_stream_offset); |
|
356 |
||
357 |
// serialize scope |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
358 |
Metadata* method_enc; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
359 |
if (method != NULL) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
360 |
method_enc = method->constant_encoding(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
361 |
} else if (methodH.not_null()) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
362 |
method_enc = methodH(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
363 |
} else { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
364 |
method_enc = NULL; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
365 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
366 |
int method_enc_index = oop_recorder()->find_index(method_enc); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
367 |
stream()->write_int(method_enc_index); |
3686
69c1b5228547
6873116: Modify reexecute implementation to use pcDesc to record the reexecute bit
cfang
parents:
3600
diff
changeset
|
368 |
stream()->write_bci(bci); |
1 | 369 |
assert(method == NULL || |
370 |
(method->is_native() && bci == 0) || |
|
371 |
(!method->is_native() && 0 <= bci && bci < method->code_size()) || |
|
372 |
bci == -1, "illegal bci"); |
|
373 |
||
374 |
// serialize the locals/expressions/monitors |
|
375 |
stream()->write_int((intptr_t) locals); |
|
376 |
stream()->write_int((intptr_t) expressions); |
|
377 |
stream()->write_int((intptr_t) monitors); |
|
378 |
||
379 |
// Here's a tricky bit. We just wrote some bytes. |
|
380 |
// Wouldn't it be nice to find that we had already |
|
381 |
// written those same bytes somewhere else? |
|
382 |
// If we get lucky this way, reset the stream |
|
383 |
// and reuse the old bytes. By the way, this |
|
384 |
// trick not only shares parent scopes, but also |
|
385 |
// compresses equivalent non-safepoint PcDescs. |
|
386 |
int shared_stream_offset = find_sharable_decode_offset(stream_offset); |
|
387 |
if (shared_stream_offset != serialized_null) { |
|
388 |
stream()->set_position(stream_offset); |
|
389 |
last_pd->set_scope_decode_offset(shared_stream_offset); |
|
390 |
} |
|
391 |
} |
|
392 |
||
393 |
void DebugInformationRecorder::dump_object_pool(GrowableArray<ScopeValue*>* objects) { |
|
394 |
guarantee( _pcs_length > 0, "safepoint must exist before describing scopes"); |
|
395 |
PcDesc* last_pd = &_pcs[_pcs_length-1]; |
|
396 |
if (objects != NULL) { |
|
397 |
for (int i = objects->length() - 1; i >= 0; i--) { |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
19696
diff
changeset
|
398 |
objects->at(i)->as_ObjectValue()->set_visited(false); |
1 | 399 |
} |
400 |
} |
|
401 |
int offset = serialize_scope_values(objects); |
|
402 |
last_pd->set_obj_decode_offset(offset); |
|
403 |
} |
|
404 |
||
405 |
void DebugInformationRecorder::end_scopes(int pc_offset, bool is_safepoint) { |
|
406 |
assert(_recording_state == (is_safepoint? rs_safepoint: rs_non_safepoint), |
|
407 |
"nesting of recording calls"); |
|
408 |
debug_only(_recording_state = rs_null); |
|
409 |
||
410 |
// Try to compress away an equivalent non-safepoint predecessor. |
|
411 |
// (This only works because we have previously recognized redundant |
|
412 |
// scope trees and made them use a common scope_decode_offset.) |
|
413 |
if (_pcs_length >= 2 && recording_non_safepoints()) { |
|
414 |
PcDesc* last = last_pc(); |
|
415 |
PcDesc* prev = prev_pc(); |
|
416 |
// If prev is (a) not a safepoint and (b) has the same |
|
417 |
// stream pointer, then it can be coalesced into the last. |
|
418 |
// This is valid because non-safepoints are only sought |
|
419 |
// with pc_desc_near, which (when it misses prev) will |
|
420 |
// search forward until it finds last. |
|
421 |
// In addition, it does not matter if the last PcDesc |
|
422 |
// is for a safepoint or not. |
|
4017
0cb087a2b9a9
6889869: assert(!Interpreter::bytecode_should_reexecute(code),"should not reexecute")
never
parents:
3908
diff
changeset
|
423 |
if (_prev_safepoint_pc < prev->pc_offset() && prev->is_same_info(last)) { |
1 | 424 |
assert(prev == last-1, "sane"); |
425 |
prev->set_pc_offset(pc_offset); |
|
426 |
_pcs_length -= 1; |
|
427 |
NOT_PRODUCT(++dir_stats.chunks_elided); |
|
428 |
} |
|
429 |
} |
|
430 |
||
431 |
// We have just recorded this safepoint. |
|
432 |
// Remember it in case the previous paragraph needs to know. |
|
433 |
if (is_safepoint) { |
|
434 |
_prev_safepoint_pc = pc_offset; |
|
435 |
} |
|
436 |
} |
|
437 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
438 |
#ifdef ASSERT |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
439 |
bool DebugInformationRecorder::recorders_frozen() { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
440 |
return _oop_recorder->is_complete() || _oop_recorder->is_complete(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
441 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
442 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
443 |
void DebugInformationRecorder::mark_recorders_frozen() { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
444 |
_oop_recorder->freeze(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
445 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
446 |
#endif // PRODUCT |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
447 |
|
1 | 448 |
DebugToken* DebugInformationRecorder::create_scope_values(GrowableArray<ScopeValue*>* values) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
449 |
assert(!recorders_frozen(), "not frozen yet"); |
1 | 450 |
return (DebugToken*) (intptr_t) serialize_scope_values(values); |
451 |
} |
|
452 |
||
453 |
||
454 |
DebugToken* DebugInformationRecorder::create_monitor_values(GrowableArray<MonitorValue*>* monitors) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
455 |
assert(!recorders_frozen(), "not frozen yet"); |
1 | 456 |
return (DebugToken*) (intptr_t) serialize_monitor_values(monitors); |
457 |
} |
|
458 |
||
459 |
||
460 |
int DebugInformationRecorder::data_size() { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
461 |
debug_only(mark_recorders_frozen()); // mark it "frozen" for asserts |
1 | 462 |
return _stream->position(); |
463 |
} |
|
464 |
||
465 |
||
466 |
int DebugInformationRecorder::pcs_size() { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
467 |
debug_only(mark_recorders_frozen()); // mark it "frozen" for asserts |
1 | 468 |
if (last_pc()->pc_offset() != PcDesc::upper_offset_limit) |
469 |
add_new_pc_offset(PcDesc::upper_offset_limit); |
|
470 |
return _pcs_length * sizeof(PcDesc); |
|
471 |
} |
|
472 |
||
473 |
||
474 |
void DebugInformationRecorder::copy_to(nmethod* nm) { |
|
475 |
nm->copy_scopes_data(stream()->buffer(), stream()->position()); |
|
476 |
nm->copy_scopes_pcs(_pcs, _pcs_length); |
|
477 |
} |
|
478 |
||
479 |
||
480 |
void DebugInformationRecorder::verify(const nmethod* code) { |
|
481 |
Unimplemented(); |
|
482 |
} |
|
483 |
||
484 |
#ifndef PRODUCT |
|
485 |
void DebugInformationRecorder::print_statistics() { |
|
486 |
dir_stats.print(); |
|
487 |
} |
|
488 |
#endif //PRODUCT |