author | coleenp |
Thu, 18 May 2017 08:17:52 -0400 | |
changeset 46475 | 75902cea18af |
parent 46408 | 70aab0c2ea8b |
child 46560 | 388aa8d67c80 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
46408
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
42650
diff
changeset
|
2 |
* Copyright (c) 1997, 2017, 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:
5403
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
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:
5403
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
26 |
#include "classfile/systemDictionary.hpp" |
|
27 |
#include "code/codeCache.hpp" |
|
28 |
#include "code/icBuffer.hpp" |
|
29 |
#include "code/nmethod.hpp" |
|
30 |
#include "code/vtableStubs.hpp" |
|
31 |
#include "compiler/compileBroker.hpp" |
|
32 |
#include "compiler/disassembler.hpp" |
|
30764 | 33 |
#include "gc/shared/collectedHeap.hpp" |
7397 | 34 |
#include "interpreter/bytecodeHistogram.hpp" |
35 |
#include "interpreter/interpreter.hpp" |
|
36 |
#include "memory/resourceArea.hpp" |
|
37 |
#include "memory/universe.hpp" |
|
38 |
#include "oops/oop.inline.hpp" |
|
39 |
#include "prims/privilegedStack.hpp" |
|
40 |
#include "runtime/arguments.hpp" |
|
40655
9f644073d3a0
8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents:
39274
diff
changeset
|
41 |
#include "runtime/atomic.hpp" |
7397 | 42 |
#include "runtime/frame.hpp" |
43 |
#include "runtime/java.hpp" |
|
25468
5331df506290
8048241: Introduce umbrella header os.inline.hpp and clean up includes
goetz
parents:
25351
diff
changeset
|
44 |
#include "runtime/os.hpp" |
7397 | 45 |
#include "runtime/sharedRuntime.hpp" |
46 |
#include "runtime/stubCodeGenerator.hpp" |
|
47 |
#include "runtime/stubRoutines.hpp" |
|
14583
d70ee55535f4
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
14076
diff
changeset
|
48 |
#include "runtime/thread.inline.hpp" |
7397 | 49 |
#include "runtime/vframe.hpp" |
25715
d5a8dbdc5150
8049325: Introduce and clean up umbrella headers for the files in the cpu subdirectories.
goetz
parents:
25468
diff
changeset
|
50 |
#include "runtime/vm_version.hpp" |
7397 | 51 |
#include "services/heapDumper.hpp" |
52 |
#include "utilities/defaultStream.hpp" |
|
53 |
#include "utilities/events.hpp" |
|
36384 | 54 |
#include "utilities/macros.hpp" |
7397 | 55 |
#include "utilities/vmError.hpp" |
1 | 56 |
|
38254 | 57 |
#include <stdio.h> |
58 |
||
1 | 59 |
#ifndef ASSERT |
60 |
# ifdef _DEBUG |
|
61 |
// NOTE: don't turn the lines below into a comment -- if you're getting |
|
62 |
// a compile error here, change the settings to define ASSERT |
|
63 |
ASSERT should be defined when _DEBUG is defined. It is not intended to be used for debugging |
|
64 |
functions that do not slow down the system too much and thus can be left in optimized code. |
|
65 |
On the other hand, the code should not be included in a production version. |
|
66 |
# endif // _DEBUG |
|
67 |
#endif // ASSERT |
|
68 |
||
69 |
||
70 |
#ifdef _DEBUG |
|
71 |
# ifndef ASSERT |
|
72 |
configuration error: ASSERT must be defined in debug version |
|
73 |
# endif // ASSERT |
|
74 |
#endif // _DEBUG |
|
75 |
||
76 |
||
77 |
#ifdef PRODUCT |
|
78 |
# if -defined _DEBUG || -defined ASSERT |
|
79 |
configuration error: ASSERT et al. must not be defined in PRODUCT version |
|
80 |
# endif |
|
81 |
#endif // PRODUCT |
|
82 |
||
13393
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
11788
diff
changeset
|
83 |
FormatBufferResource::FormatBufferResource(const char * format, ...) |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
84 |
: FormatBufferBase((char*)resource_allocate_bytes(FormatBufferBase::BufferSize)) { |
13393
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
11788
diff
changeset
|
85 |
va_list argp; |
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
11788
diff
changeset
|
86 |
va_start(argp, format); |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
87 |
jio_vsnprintf(_buf, FormatBufferBase::BufferSize, format, argp); |
13393
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
11788
diff
changeset
|
88 |
va_end(argp); |
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
11788
diff
changeset
|
89 |
} |
1 | 90 |
|
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
18683
diff
changeset
|
91 |
ATTRIBUTE_PRINTF(1, 2) |
1 | 92 |
void warning(const char* format, ...) { |
6967
c5ebdcf8372e
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
6445
diff
changeset
|
93 |
if (PrintWarnings) { |
13761 | 94 |
FILE* const err = defaultStream::error_stream(); |
95 |
jio_fprintf(err, "%s warning: ", VM_Version::vm_name()); |
|
6967
c5ebdcf8372e
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
6445
diff
changeset
|
96 |
va_list ap; |
c5ebdcf8372e
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
6445
diff
changeset
|
97 |
va_start(ap, format); |
13761 | 98 |
vfprintf(err, format, ap); |
6967
c5ebdcf8372e
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
6445
diff
changeset
|
99 |
va_end(ap); |
13761 | 100 |
fputc('\n', err); |
6967
c5ebdcf8372e
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
6445
diff
changeset
|
101 |
} |
1 | 102 |
if (BreakAtWarning) BREAKPOINT; |
103 |
} |
|
104 |
||
105 |
#ifndef PRODUCT |
|
106 |
||
107 |
#define is_token_break(ch) (isspace(ch) || (ch) == ',') |
|
108 |
||
109 |
static const char* last_file_name = NULL; |
|
110 |
static int last_line_no = -1; |
|
111 |
||
112 |
// assert/guarantee/... may happen very early during VM initialization. |
|
113 |
// Don't rely on anything that is initialized by Threads::create_vm(). For |
|
114 |
// example, don't use tty. |
|
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
115 |
bool error_is_suppressed(const char* file_name, int line_no) { |
1 | 116 |
// The following 1-element cache requires that passed-in |
117 |
// file names are always only constant literals. |
|
118 |
if (file_name == last_file_name && line_no == last_line_no) return true; |
|
119 |
||
120 |
int file_name_len = (int)strlen(file_name); |
|
121 |
char separator = os::file_separator()[0]; |
|
122 |
const char* base_name = strrchr(file_name, separator); |
|
123 |
if (base_name == NULL) |
|
124 |
base_name = file_name; |
|
125 |
||
126 |
// scan the SuppressErrorAt option |
|
127 |
const char* cp = SuppressErrorAt; |
|
128 |
for (;;) { |
|
129 |
const char* sfile; |
|
130 |
int sfile_len; |
|
131 |
int sline; |
|
132 |
bool noisy; |
|
133 |
while ((*cp) != '\0' && is_token_break(*cp)) cp++; |
|
134 |
if ((*cp) == '\0') break; |
|
135 |
sfile = cp; |
|
136 |
while ((*cp) != '\0' && !is_token_break(*cp) && (*cp) != ':') cp++; |
|
137 |
sfile_len = cp - sfile; |
|
138 |
if ((*cp) == ':') cp++; |
|
139 |
sline = 0; |
|
140 |
while ((*cp) != '\0' && isdigit(*cp)) { |
|
141 |
sline *= 10; |
|
142 |
sline += (*cp) - '0'; |
|
143 |
cp++; |
|
144 |
} |
|
145 |
// "file:line!" means the assert suppression is not silent |
|
146 |
noisy = ((*cp) == '!'); |
|
147 |
while ((*cp) != '\0' && !is_token_break(*cp)) cp++; |
|
148 |
// match the line |
|
149 |
if (sline != 0) { |
|
150 |
if (sline != line_no) continue; |
|
151 |
} |
|
152 |
// match the file |
|
153 |
if (sfile_len > 0) { |
|
154 |
const char* look = file_name; |
|
155 |
const char* look_max = file_name + file_name_len - sfile_len; |
|
156 |
const char* foundp; |
|
157 |
bool match = false; |
|
158 |
while (!match |
|
159 |
&& (foundp = strchr(look, sfile[0])) != NULL |
|
160 |
&& foundp <= look_max) { |
|
161 |
match = true; |
|
162 |
for (int i = 1; i < sfile_len; i++) { |
|
163 |
if (sfile[i] != foundp[i]) { |
|
164 |
match = false; |
|
165 |
break; |
|
166 |
} |
|
167 |
} |
|
168 |
look = foundp + 1; |
|
169 |
} |
|
170 |
if (!match) continue; |
|
171 |
} |
|
172 |
// got a match! |
|
173 |
if (noisy) { |
|
174 |
fdStream out(defaultStream::output_fd()); |
|
175 |
out.print_raw("[error suppressed at "); |
|
176 |
out.print_raw(base_name); |
|
177 |
char buf[16]; |
|
178 |
jio_snprintf(buf, sizeof(buf), ":%d]", line_no); |
|
179 |
out.print_raw_cr(buf); |
|
180 |
} else { |
|
181 |
// update 1-element cache for fast silent matches |
|
182 |
last_file_name = file_name; |
|
183 |
last_line_no = line_no; |
|
184 |
} |
|
185 |
return true; |
|
186 |
} |
|
187 |
||
38254 | 188 |
if (!is_error_reported() && !SuppressFatalErrorMessage) { |
1 | 189 |
// print a friendly hint: |
190 |
fdStream out(defaultStream::output_fd()); |
|
191 |
out.print_raw_cr("# To suppress the following error report, specify this argument"); |
|
192 |
out.print_raw ("# after -XX: or in .hotspotrc: SuppressErrorAt="); |
|
193 |
out.print_raw (base_name); |
|
194 |
char buf[16]; |
|
195 |
jio_snprintf(buf, sizeof(buf), ":%d", line_no); |
|
196 |
out.print_raw_cr(buf); |
|
197 |
} |
|
198 |
return false; |
|
199 |
} |
|
200 |
||
201 |
#undef is_token_break |
|
202 |
||
203 |
#else |
|
204 |
||
205 |
// Place-holder for non-existent suppression check: |
|
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
206 |
#define error_is_suppressed(file_name, line_no) (false) |
1 | 207 |
|
10739 | 208 |
#endif // !PRODUCT |
1 | 209 |
|
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
210 |
void report_vm_error(const char* file, int line, const char* error_msg) |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
211 |
{ |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
212 |
report_vm_error(file, line, error_msg, "%s", ""); |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
213 |
} |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
214 |
|
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
215 |
void report_vm_error(const char* file, int line, const char* error_msg, const char* detail_fmt, ...) |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
216 |
{ |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
217 |
if (Debugging || error_is_suppressed(file, line)) return; |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
218 |
va_list detail_args; |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
219 |
va_start(detail_args, detail_fmt); |
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34144
diff
changeset
|
220 |
VMError::report_and_die(Thread::current_or_null(), file, line, error_msg, detail_fmt, detail_args); |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
221 |
va_end(detail_args); |
1 | 222 |
} |
223 |
||
37113 | 224 |
void report_vm_status_error(const char* file, int line, const char* error_msg, |
225 |
int status, const char* detail) { |
|
226 |
report_vm_error(file, line, error_msg, "error %s(%d), %s", os::errno_name(status), status, detail); |
|
227 |
} |
|
228 |
||
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
229 |
void report_fatal(const char* file, int line, const char* detail_fmt, ...) |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
230 |
{ |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
231 |
if (Debugging || error_is_suppressed(file, line)) return; |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
232 |
va_list detail_args; |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
233 |
va_start(detail_args, detail_fmt); |
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34144
diff
changeset
|
234 |
VMError::report_and_die(Thread::current_or_null(), file, line, "fatal error", detail_fmt, detail_args); |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
235 |
va_end(detail_args); |
1 | 236 |
} |
237 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
238 |
void report_vm_out_of_memory(const char* file, int line, size_t size, |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
239 |
VMErrorType vm_err_type, const char* detail_fmt, ...) { |
7719
ef138e2849eb
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
7433
diff
changeset
|
240 |
if (Debugging) return; |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
241 |
va_list detail_args; |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
242 |
va_start(detail_args, detail_fmt); |
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34144
diff
changeset
|
243 |
VMError::report_and_die(Thread::current_or_null(), file, line, size, vm_err_type, detail_fmt, detail_args); |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
244 |
va_end(detail_args); |
1 | 245 |
|
15796
41577a5deb58
6799919: Recursive calls to report_vm_out_of_memory are handled incorrectly
dcubed
parents:
15088
diff
changeset
|
246 |
// The UseOSErrorReporting option in report_and_die() may allow a return |
41577a5deb58
6799919: Recursive calls to report_vm_out_of_memory are handled incorrectly
dcubed
parents:
15088
diff
changeset
|
247 |
// to here. If so then we'll have to figure out how to handle it. |
41577a5deb58
6799919: Recursive calls to report_vm_out_of_memory are handled incorrectly
dcubed
parents:
15088
diff
changeset
|
248 |
guarantee(false, "report_and_die() should not return here"); |
1 | 249 |
} |
250 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
251 |
void report_should_not_call(const char* file, int line) { |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
252 |
report_vm_error(file, line, "ShouldNotCall()"); |
1 | 253 |
} |
254 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
255 |
void report_should_not_reach_here(const char* file, int line) { |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
256 |
report_vm_error(file, line, "ShouldNotReachHere()"); |
1 | 257 |
} |
258 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
259 |
void report_unimplemented(const char* file, int line) { |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
260 |
report_vm_error(file, line, "Unimplemented()"); |
1 | 261 |
} |
262 |
||
38254 | 263 |
#ifdef ASSERT |
264 |
bool is_executing_unit_tests() { |
|
265 |
return ExecutingUnitTests; |
|
266 |
} |
|
267 |
||
268 |
void report_assert_msg(const char* msg, ...) { |
|
269 |
va_list ap; |
|
270 |
va_start(ap, msg); |
|
271 |
||
272 |
fprintf(stderr, "assert failed: %s\n", err_msg(FormatBufferDummy(), msg, ap).buffer()); |
|
273 |
||
274 |
va_end(ap); |
|
275 |
} |
|
276 |
#endif // ASSERT |
|
277 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
278 |
void report_untested(const char* file, int line, const char* message) { |
1 | 279 |
#ifndef PRODUCT |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
280 |
warning("Untested: %s in %s: %d\n", message, file, line); |
10739 | 281 |
#endif // !PRODUCT |
1 | 282 |
} |
283 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
284 |
void report_out_of_shared_space(SharedSpaceType shared_space) { |
41182 | 285 |
if (shared_space == SharedOptional) { |
286 |
// The estimated shared_optional_space size is large enough |
|
287 |
// for all class bytes. It should not run out of space. |
|
288 |
ShouldNotReachHere(); |
|
289 |
} |
|
290 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
291 |
static const char* name[] = { |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
292 |
"shared read only space", |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
293 |
"shared read write space", |
27404
33c0f343cd5c
8038268: VM Crashes in MetaspaceShared::generate_vtable_methods while creating CDS archive with limiting SharedMiscCodeSize
ccheung
parents:
26821
diff
changeset
|
294 |
"shared miscellaneous data space", |
33c0f343cd5c
8038268: VM Crashes in MetaspaceShared::generate_vtable_methods while creating CDS archive with limiting SharedMiscCodeSize
ccheung
parents:
26821
diff
changeset
|
295 |
"shared miscellaneous code space" |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
296 |
}; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
297 |
static const char* flag[] = { |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
298 |
"SharedReadOnlySize", |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
299 |
"SharedReadWriteSize", |
27404
33c0f343cd5c
8038268: VM Crashes in MetaspaceShared::generate_vtable_methods while creating CDS archive with limiting SharedMiscCodeSize
ccheung
parents:
26821
diff
changeset
|
300 |
"SharedMiscDataSize", |
33c0f343cd5c
8038268: VM Crashes in MetaspaceShared::generate_vtable_methods while creating CDS archive with limiting SharedMiscCodeSize
ccheung
parents:
26821
diff
changeset
|
301 |
"SharedMiscCodeSize" |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
302 |
}; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
303 |
|
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
304 |
warning("\nThe %s is not large enough\n" |
27404
33c0f343cd5c
8038268: VM Crashes in MetaspaceShared::generate_vtable_methods while creating CDS archive with limiting SharedMiscCodeSize
ccheung
parents:
26821
diff
changeset
|
305 |
"to preload requested classes. Use -XX:%s=<size>\n" |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
306 |
"to increase the initial size of %s.\n", |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
307 |
name[shared_space], flag[shared_space], name[shared_space]); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
308 |
exit(2); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
309 |
} |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
310 |
|
36384 | 311 |
|
28476
ae1ca3bf45ca
8067187: -XX:MaxMetaspaceSize=20m -Xshare:dump caused JVM to crash
ccheung
parents:
27404
diff
changeset
|
312 |
void report_insufficient_metaspace(size_t required_size) { |
29697
92501504191b
8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents:
29204
diff
changeset
|
313 |
warning("\nThe MaxMetaspaceSize of " SIZE_FORMAT " bytes is not large enough.\n" |
28476
ae1ca3bf45ca
8067187: -XX:MaxMetaspaceSize=20m -Xshare:dump caused JVM to crash
ccheung
parents:
27404
diff
changeset
|
314 |
"Either don't specify the -XX:MaxMetaspaceSize=<size>\n" |
ae1ca3bf45ca
8067187: -XX:MaxMetaspaceSize=20m -Xshare:dump caused JVM to crash
ccheung
parents:
27404
diff
changeset
|
315 |
"or increase the size to at least " SIZE_FORMAT ".\n", |
ae1ca3bf45ca
8067187: -XX:MaxMetaspaceSize=20m -Xshare:dump caused JVM to crash
ccheung
parents:
27404
diff
changeset
|
316 |
MaxMetaspaceSize, required_size); |
ae1ca3bf45ca
8067187: -XX:MaxMetaspaceSize=20m -Xshare:dump caused JVM to crash
ccheung
parents:
27404
diff
changeset
|
317 |
exit(2); |
ae1ca3bf45ca
8067187: -XX:MaxMetaspaceSize=20m -Xshare:dump caused JVM to crash
ccheung
parents:
27404
diff
changeset
|
318 |
} |
ae1ca3bf45ca
8067187: -XX:MaxMetaspaceSize=20m -Xshare:dump caused JVM to crash
ccheung
parents:
27404
diff
changeset
|
319 |
|
1 | 320 |
void report_java_out_of_memory(const char* message) { |
321 |
static jint out_of_memory_reported = 0; |
|
322 |
||
323 |
// A number of threads may attempt to report OutOfMemoryError at around the |
|
324 |
// same time. To avoid dumping the heap or executing the data collection |
|
325 |
// commands multiple times we just do it once when the first threads reports |
|
326 |
// the error. |
|
327 |
if (Atomic::cmpxchg(1, &out_of_memory_reported, 0) == 0) { |
|
328 |
// create heap dump before OnOutOfMemoryError commands are executed |
|
329 |
if (HeapDumpOnOutOfMemoryError) { |
|
330 |
tty->print_cr("java.lang.OutOfMemoryError: %s", message); |
|
6445
64694b1e56e7
6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents:
6176
diff
changeset
|
331 |
HeapDumper::dump_heap_from_oome(); |
1 | 332 |
} |
333 |
||
334 |
if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { |
|
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
335 |
VMError::report_java_out_of_memory(message); |
1 | 336 |
} |
34670
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
337 |
|
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
338 |
if (CrashOnOutOfMemoryError) { |
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
339 |
tty->print_cr("Aborting due to java.lang.OutOfMemoryError: %s", message); |
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
340 |
fatal("OutOfMemory encountered: %s", message); |
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
341 |
} |
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
342 |
|
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
343 |
if (ExitOnOutOfMemoryError) { |
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
344 |
tty->print_cr("Terminating due to java.lang.OutOfMemoryError: %s", message); |
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
345 |
os::exit(3); |
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
346 |
} |
1 | 347 |
} |
348 |
} |
|
349 |
||
350 |
static bool error_reported = false; |
|
351 |
||
352 |
// call this when the VM is dying--it might loosen some asserts |
|
353 |
void set_error_reported() { |
|
354 |
error_reported = true; |
|
355 |
} |
|
356 |
||
357 |
bool is_error_reported() { |
|
358 |
return error_reported; |
|
359 |
} |
|
360 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
361 |
#ifndef PRODUCT |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
362 |
#include <signal.h> |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
363 |
|
28943
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
364 |
typedef void (*voidfun_t)(); |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
365 |
// Crash with an authentic sigfpe |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
366 |
static void crash_with_sigfpe() { |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
367 |
// generate a native synchronous SIGFPE where possible; |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
368 |
// if that did not cause a signal (e.g. on ppc), just |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
369 |
// raise the signal. |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
370 |
volatile int x = 0; |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
371 |
volatile int y = 1/x; |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
372 |
#ifndef _WIN32 |
34144
b181699c6616
8139300: Internal Error (vm/utilities/debug.cpp:399), # Error: ShouldNotReachHere()
dholmes
parents:
33148
diff
changeset
|
373 |
// OSX implements raise(sig) incorrectly so we need to |
b181699c6616
8139300: Internal Error (vm/utilities/debug.cpp:399), # Error: ShouldNotReachHere()
dholmes
parents:
33148
diff
changeset
|
374 |
// explicitly target the current thread |
b181699c6616
8139300: Internal Error (vm/utilities/debug.cpp:399), # Error: ShouldNotReachHere()
dholmes
parents:
33148
diff
changeset
|
375 |
pthread_kill(pthread_self(), SIGFPE); |
28943
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
376 |
#endif |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
377 |
} // end: crash_with_sigfpe |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
378 |
|
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
379 |
// crash with sigsegv at non-null address. |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
380 |
static void crash_with_segfault() { |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
381 |
|
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
382 |
char* const crash_addr = (char*) get_segfault_address(); |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
383 |
*crash_addr = 'X'; |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
384 |
|
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
385 |
} // end: crash_with_segfault |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
386 |
|
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
387 |
// returns an address which is guaranteed to generate a SIGSEGV on read, |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
388 |
// for test purposes, which is not NULL and contains bits in every word |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
389 |
void* get_segfault_address() { |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
390 |
return (void*) |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
391 |
#ifdef _LP64 |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
392 |
0xABC0000000000ABCULL; |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
393 |
#else |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
394 |
0x00000ABC; |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
395 |
#endif |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
396 |
} |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
397 |
|
18683
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
398 |
void test_error_handler() { |
28943
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
399 |
controlled_crash(ErrorHandlerTest); |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
400 |
} |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
401 |
|
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
402 |
void controlled_crash(int how) { |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
403 |
if (how == 0) return; |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
404 |
|
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
405 |
// If asserts are disabled, use the corresponding guarantee instead. |
28943
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
406 |
NOT_DEBUG(if (how <= 2) how += 2); |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
407 |
|
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
408 |
const char* const str = "hello"; |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
409 |
const size_t num = (size_t)os::vm_page_size(); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
410 |
|
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
411 |
const char* const eol = os::line_separator(); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
412 |
const char* const msg = "this message should be truncated during formatting"; |
18683
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
413 |
char * const dataPtr = NULL; // bad data pointer |
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
414 |
const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
415 |
|
33135
aa536100693c
8134432: [TESTBUG] Rewrite test/runtime/6888954/vmerrors.sh in Java
gtriantafill
parents:
33105
diff
changeset
|
416 |
// Keep this in sync with test/runtime/ErrorHandling/ErrorHandler.java |
28943
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
417 |
switch (how) { |
28477 | 418 |
case 1: vmassert(str == NULL, "expected null"); |
419 |
case 2: vmassert(num == 1023 && *str == 'X', |
|
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
420 |
"num=" SIZE_FORMAT " str=\"%s\"", num, str); |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
421 |
case 3: guarantee(str == NULL, "expected null"); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
422 |
case 4: guarantee(num == 1023 && *str == 'X', |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
423 |
"num=" SIZE_FORMAT " str=\"%s\"", num, str); |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
424 |
case 5: fatal("expected null"); |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
425 |
case 6: fatal("num=" SIZE_FORMAT " str=\"%s\"", num, str); |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
426 |
case 7: fatal("%s%s# %s%s# %s%s# %s%s# %s%s# " |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
427 |
"%s%s# %s%s# %s%s# %s%s# %s%s# " |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
428 |
"%s%s# %s%s# %s%s# %s%s# %s", |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
429 |
msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
430 |
msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
431 |
msg, eol, msg, eol, msg, eol, msg, eol, msg); |
17087
f0b76c4c93a0
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
16670
diff
changeset
|
432 |
case 8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate"); |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
433 |
case 9: ShouldNotCallThis(); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
434 |
case 10: ShouldNotReachHere(); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
435 |
case 11: Unimplemented(); |
18683
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
436 |
// There's no guarantee the bad data pointer will crash us |
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
437 |
// so "break" out to the ShouldNotReachHere(). |
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
438 |
case 12: *dataPtr = '\0'; break; |
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
439 |
// There's no guarantee the bad function pointer will crash us |
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
440 |
// so "break" out to the ShouldNotReachHere(). |
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
441 |
case 13: (*funcPtr)(); break; |
28943
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
442 |
case 14: crash_with_segfault(); break; |
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
443 |
case 15: crash_with_sigfpe(); break; |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
444 |
|
28943
679546f0cc1f
8065895: Synchronous signals during error reporting may terminate or hang VM process
dholmes
parents:
28477
diff
changeset
|
445 |
default: tty->print_cr("ERROR: %d: unexpected test_num value.", how); |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
446 |
} |
18683
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
447 |
ShouldNotReachHere(); |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
448 |
} |
10739 | 449 |
#endif // !PRODUCT |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
450 |
|
1 | 451 |
// ------ helper functions for debugging go here ------------ |
452 |
||
453 |
// All debug entries should be wrapped with a stack allocated |
|
454 |
// Command object. It makes sure a resource mark is set and |
|
455 |
// flushes the logfile to prevent file sharing problems. |
|
456 |
||
457 |
class Command : public StackObj { |
|
458 |
private: |
|
459 |
ResourceMark rm; |
|
460 |
ResetNoHandleMark rnhm; |
|
461 |
HandleMark hm; |
|
462 |
bool debug_save; |
|
463 |
public: |
|
464 |
static int level; |
|
465 |
Command(const char* str) { |
|
466 |
debug_save = Debugging; |
|
467 |
Debugging = true; |
|
468 |
if (level++ > 0) return; |
|
469 |
tty->cr(); |
|
470 |
tty->print_cr("\"Executing %s\"", str); |
|
471 |
} |
|
472 |
||
10739 | 473 |
~Command() { |
474 |
tty->flush(); |
|
475 |
Debugging = debug_save; |
|
476 |
level--; |
|
477 |
} |
|
1 | 478 |
}; |
479 |
||
480 |
int Command::level = 0; |
|
481 |
||
10739 | 482 |
#ifndef PRODUCT |
483 |
||
1 | 484 |
extern "C" void blob(CodeBlob* cb) { |
485 |
Command c("blob"); |
|
486 |
cb->print(); |
|
487 |
} |
|
488 |
||
489 |
||
490 |
extern "C" void dump_vtable(address p) { |
|
491 |
Command c("dump_vtable"); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
492 |
Klass* k = (Klass*)p; |
46408
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
42650
diff
changeset
|
493 |
k->vtable().print(); |
1 | 494 |
} |
495 |
||
496 |
||
497 |
extern "C" void nm(intptr_t p) { |
|
498 |
// Actually we look through all CodeBlobs (the nm name has been kept for backwards compatability) |
|
499 |
Command c("nm"); |
|
500 |
CodeBlob* cb = CodeCache::find_blob((address)p); |
|
501 |
if (cb == NULL) { |
|
502 |
tty->print_cr("NULL"); |
|
503 |
} else { |
|
504 |
cb->print(); |
|
505 |
} |
|
506 |
} |
|
507 |
||
508 |
||
509 |
extern "C" void disnm(intptr_t p) { |
|
510 |
Command c("disnm"); |
|
511 |
CodeBlob* cb = CodeCache::find_blob((address) p); |
|
35542
9dccb7f9f656
8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents:
35061
diff
changeset
|
512 |
if (cb != NULL) { |
9dccb7f9f656
8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents:
35061
diff
changeset
|
513 |
nmethod* nm = cb->as_nmethod_or_null(); |
9dccb7f9f656
8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents:
35061
diff
changeset
|
514 |
if (nm != NULL) { |
9dccb7f9f656
8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents:
35061
diff
changeset
|
515 |
nm->print(); |
9dccb7f9f656
8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents:
35061
diff
changeset
|
516 |
} else { |
9dccb7f9f656
8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents:
35061
diff
changeset
|
517 |
cb->print(); |
9dccb7f9f656
8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents:
35061
diff
changeset
|
518 |
} |
7433 | 519 |
Disassembler::decode(cb); |
520 |
} |
|
1 | 521 |
} |
522 |
||
523 |
||
524 |
extern "C" void printnm(intptr_t p) { |
|
525 |
char buffer[256]; |
|
526 |
sprintf(buffer, "printnm: " INTPTR_FORMAT, p); |
|
527 |
Command c(buffer); |
|
528 |
CodeBlob* cb = CodeCache::find_blob((address) p); |
|
529 |
if (cb->is_nmethod()) { |
|
530 |
nmethod* nm = (nmethod*)cb; |
|
531 |
nm->print_nmethod(true); |
|
532 |
} |
|
533 |
} |
|
534 |
||
535 |
||
536 |
extern "C" void universe() { |
|
537 |
Command c("universe"); |
|
35061 | 538 |
Universe::print_on(tty); |
1 | 539 |
} |
540 |
||
541 |
||
542 |
extern "C" void verify() { |
|
543 |
// try to run a verify on the entire system |
|
544 |
// note: this may not be safe if we're not at a safepoint; for debugging, |
|
545 |
// this manipulates the safepoint settings to avoid assertion failures |
|
546 |
Command c("universe verify"); |
|
547 |
bool safe = SafepointSynchronize::is_at_safepoint(); |
|
548 |
if (!safe) { |
|
549 |
tty->print_cr("warning: not at safepoint -- verify may fail"); |
|
550 |
SafepointSynchronize::set_is_at_safepoint(); |
|
551 |
} |
|
552 |
// Ensure Eden top is correct before verification |
|
553 |
Universe::heap()->prepare_for_verify(); |
|
14076
84643cfaeaa8
8000831: Heap verification output incorrect/incomplete
johnc
parents:
13761
diff
changeset
|
554 |
Universe::verify(); |
1 | 555 |
if (!safe) SafepointSynchronize::set_is_not_at_safepoint(); |
556 |
} |
|
557 |
||
558 |
||
559 |
extern "C" void pp(void* p) { |
|
560 |
Command c("pp"); |
|
561 |
FlagSetting fl(PrintVMMessages, true); |
|
9437
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
562 |
FlagSetting f2(DisplayVMOutput, true); |
1 | 563 |
if (Universe::heap()->is_in(p)) { |
564 |
oop obj = oop(p); |
|
565 |
obj->print(); |
|
566 |
} else { |
|
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33135
diff
changeset
|
567 |
tty->print(PTR_FORMAT, p2i(p)); |
1 | 568 |
} |
569 |
} |
|
570 |
||
571 |
||
572 |
// pv: print vm-printable object |
|
573 |
extern "C" void pa(intptr_t p) { ((AllocatedObj*) p)->print(); } |
|
574 |
extern "C" void findpc(intptr_t x); |
|
575 |
||
10739 | 576 |
#endif // !PRODUCT |
577 |
||
1 | 578 |
extern "C" void ps() { // print stack |
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34144
diff
changeset
|
579 |
if (Thread::current_or_null() == NULL) return; |
1 | 580 |
Command c("ps"); |
581 |
||
582 |
||
583 |
// Prints the stack of the current Java thread |
|
584 |
JavaThread* p = JavaThread::active(); |
|
585 |
tty->print(" for thread: "); |
|
586 |
p->print(); |
|
587 |
tty->cr(); |
|
588 |
||
589 |
if (p->has_last_Java_frame()) { |
|
590 |
// If the last_Java_fp is set we are in C land and |
|
591 |
// can call the standard stack_trace function. |
|
10739 | 592 |
#ifdef PRODUCT |
593 |
p->print_stack(); |
|
594 |
} else { |
|
595 |
tty->print_cr("Cannot find the last Java frame, printing stack disabled."); |
|
596 |
#else // !PRODUCT |
|
1 | 597 |
p->trace_stack(); |
598 |
} else { |
|
599 |
frame f = os::current_frame(); |
|
600 |
RegisterMap reg_map(p); |
|
601 |
f = f.sender(®_map); |
|
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33135
diff
changeset
|
602 |
tty->print("(guessing starting frame id=" PTR_FORMAT " based on current fp)\n", p2i(f.id())); |
1 | 603 |
p->trace_stack_from(vframe::new_vframe(&f, ®_map, p)); |
604 |
pd_ps(f); |
|
10739 | 605 |
#endif // PRODUCT |
1 | 606 |
} |
607 |
||
608 |
} |
|
609 |
||
9437
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
610 |
extern "C" void pfl() { |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
611 |
// print frame layout |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
612 |
Command c("pfl"); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
613 |
JavaThread* p = JavaThread::active(); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
614 |
tty->print(" for thread: "); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
615 |
p->print(); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
616 |
tty->cr(); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
617 |
if (p->has_last_Java_frame()) { |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
618 |
p->print_frame_layout(); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
619 |
} |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
620 |
} |
1 | 621 |
|
10739 | 622 |
#ifndef PRODUCT |
623 |
||
1 | 624 |
extern "C" void psf() { // print stack frames |
625 |
{ |
|
626 |
Command c("psf"); |
|
627 |
JavaThread* p = JavaThread::active(); |
|
628 |
tty->print(" for thread: "); |
|
629 |
p->print(); |
|
630 |
tty->cr(); |
|
631 |
if (p->has_last_Java_frame()) { |
|
632 |
p->trace_frames(); |
|
633 |
} |
|
634 |
} |
|
635 |
} |
|
636 |
||
637 |
||
638 |
extern "C" void threads() { |
|
639 |
Command c("threads"); |
|
640 |
Threads::print(false, true); |
|
641 |
} |
|
642 |
||
643 |
||
644 |
extern "C" void psd() { |
|
645 |
Command c("psd"); |
|
646 |
SystemDictionary::print(); |
|
647 |
} |
|
648 |
||
649 |
||
650 |
extern "C" void safepoints() { |
|
651 |
Command c("safepoints"); |
|
652 |
SafepointSynchronize::print_state(); |
|
653 |
} |
|
654 |
||
10739 | 655 |
#endif // !PRODUCT |
1 | 656 |
|
657 |
extern "C" void pss() { // print all stacks |
|
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34144
diff
changeset
|
658 |
if (Thread::current_or_null() == NULL) return; |
1 | 659 |
Command c("pss"); |
10739 | 660 |
Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true)); |
1 | 661 |
} |
662 |
||
10739 | 663 |
#ifndef PRODUCT |
1 | 664 |
|
665 |
extern "C" void debug() { // to set things up for compiler debugging |
|
666 |
Command c("debug"); |
|
667 |
WizardMode = true; |
|
668 |
PrintVMMessages = PrintCompilation = true; |
|
669 |
PrintInlining = PrintAssembly = true; |
|
670 |
tty->flush(); |
|
671 |
} |
|
672 |
||
673 |
||
674 |
extern "C" void ndebug() { // undo debug() |
|
675 |
Command c("ndebug"); |
|
676 |
PrintCompilation = false; |
|
677 |
PrintInlining = PrintAssembly = false; |
|
678 |
tty->flush(); |
|
679 |
} |
|
680 |
||
681 |
||
682 |
extern "C" void flush() { |
|
683 |
Command c("flush"); |
|
684 |
tty->flush(); |
|
685 |
} |
|
686 |
||
11788 | 687 |
extern "C" void events() { |
688 |
Command c("events"); |
|
689 |
Events::print(); |
|
690 |
} |
|
1 | 691 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
692 |
extern "C" Method* findm(intptr_t pc) { |
1 | 693 |
Command c("findm"); |
694 |
nmethod* nm = CodeCache::find_nmethod((address)pc); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
695 |
return (nm == NULL) ? (Method*)NULL : nm->method(); |
1 | 696 |
} |
697 |
||
698 |
||
699 |
extern "C" nmethod* findnm(intptr_t addr) { |
|
700 |
Command c("findnm"); |
|
701 |
return CodeCache::find_nmethod((address)addr); |
|
702 |
} |
|
703 |
||
704 |
// Another interface that isn't ambiguous in dbx. |
|
705 |
// Can we someday rename the other find to hsfind? |
|
706 |
extern "C" void hsfind(intptr_t x) { |
|
707 |
Command c("hsfind"); |
|
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
708 |
os::print_location(tty, x, false); |
1 | 709 |
} |
710 |
||
711 |
||
712 |
extern "C" void find(intptr_t x) { |
|
713 |
Command c("find"); |
|
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
714 |
os::print_location(tty, x, false); |
1 | 715 |
} |
716 |
||
717 |
||
718 |
extern "C" void findpc(intptr_t x) { |
|
719 |
Command c("findpc"); |
|
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
720 |
os::print_location(tty, x, true); |
1 | 721 |
} |
722 |
||
723 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
724 |
// Need method pointer to find bcp, when not in permgen. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
725 |
extern "C" void findbcp(intptr_t method, intptr_t bcp) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
726 |
Command c("findbcp"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
727 |
Method* mh = (Method*)method; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
728 |
if (!mh->is_native()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
729 |
tty->print_cr("bci_from(%p) = %d; print_codes():", |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
730 |
mh, mh->bci_from(address(bcp))); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
731 |
mh->print_codes_on(tty); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
732 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
733 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
734 |
|
1 | 735 |
// int versions of all methods to avoid having to type type casts in the debugger |
736 |
||
737 |
void pp(intptr_t p) { pp((void*)p); } |
|
738 |
void pp(oop p) { pp((void*)p); } |
|
739 |
||
740 |
void help() { |
|
741 |
Command c("help"); |
|
742 |
tty->print_cr("basic"); |
|
743 |
tty->print_cr(" pp(void* p) - try to make sense of p"); |
|
744 |
tty->print_cr(" pv(intptr_t p)- ((PrintableResourceObj*) p)->print()"); |
|
745 |
tty->print_cr(" ps() - print current thread stack"); |
|
746 |
tty->print_cr(" pss() - print all thread stacks"); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
747 |
tty->print_cr(" pm(int pc) - print Method* given compiled PC"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
748 |
tty->print_cr(" findm(intptr_t pc) - finds Method*"); |
1 | 749 |
tty->print_cr(" find(intptr_t x) - finds & prints nmethod/stub/bytecode/oop based on pointer into it"); |
26821
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
750 |
tty->print_cr(" pns(void* sp, void* fp, void* pc) - print native (i.e. mixed) stack trace. E.g."); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
751 |
tty->print_cr(" pns($sp, $rbp, $pc) on Linux/amd64 and Solaris/amd64 or"); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
752 |
tty->print_cr(" pns($sp, $ebp, $pc) on Linux/x86 or"); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
753 |
tty->print_cr(" pns($sp, 0, $pc) on Linux/ppc64 or"); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
754 |
tty->print_cr(" pns($sp + 0x7ff, 0, $pc) on Solaris/SPARC"); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
755 |
tty->print_cr(" - in gdb do 'set overload-resolution off' before calling pns()"); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
756 |
tty->print_cr(" - in dbx do 'frame 1' before calling pns()"); |
1 | 757 |
|
758 |
tty->print_cr("misc."); |
|
759 |
tty->print_cr(" flush() - flushes the log file"); |
|
11788 | 760 |
tty->print_cr(" events() - dump events from ring buffers"); |
1 | 761 |
|
762 |
||
763 |
tty->print_cr("compiler debugging"); |
|
764 |
tty->print_cr(" debug() - to set things up for compiler debugging"); |
|
765 |
tty->print_cr(" ndebug() - undo debug"); |
|
766 |
} |
|
767 |
||
10739 | 768 |
#endif // !PRODUCT |
26821
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
769 |
|
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
770 |
void print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size) { |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
771 |
|
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
772 |
// see if it's a valid frame |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
773 |
if (fr.pc()) { |
42650 | 774 |
st->print_cr("Native frames: (J=compiled Java code, A=aot compiled Java code, j=interpreted, Vv=VM code, C=native code)"); |
26821
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
775 |
|
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
776 |
int count = 0; |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
777 |
while (count++ < StackPrintLimit) { |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
778 |
fr.print_on_error(st, buf, buf_size); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
779 |
st->cr(); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
780 |
// Compiled code may use EBP register on x86 so it looks like |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
781 |
// non-walkable C frame. Use frame.sender() for java frames. |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
782 |
if (t && t->is_Java_thread()) { |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
783 |
// Catch very first native frame by using stack address. |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
784 |
// For JavaThread stack_base and stack_size should be set. |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
785 |
if (!t->on_local_stack((address)(fr.real_fp() + 1))) { |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
786 |
break; |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
787 |
} |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
788 |
if (fr.is_java_frame() || fr.is_native_frame() || fr.is_runtime_frame()) { |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
789 |
RegisterMap map((JavaThread*)t, false); // No update |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
790 |
fr = fr.sender(&map); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
791 |
} else { |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
792 |
fr = os::get_sender_for_C_frame(&fr); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
793 |
} |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
794 |
} else { |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
795 |
// is_first_C_frame() does only simple checks for frame pointer, |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
796 |
// it will pass if java compiled code has a pointer in EBP. |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
797 |
if (os::is_first_C_frame(&fr)) break; |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
798 |
fr = os::get_sender_for_C_frame(&fr); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
799 |
} |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
800 |
} |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
801 |
|
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
802 |
if (count > StackPrintLimit) { |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
803 |
st->print_cr("...<more frames>..."); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
804 |
} |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
805 |
|
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
806 |
st->cr(); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
807 |
} |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
808 |
} |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
809 |
|
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
810 |
#ifndef PRODUCT |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
811 |
|
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
812 |
extern "C" void pns(void* sp, void* fp, void* pc) { // print native stack |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
813 |
Command c("pns"); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
814 |
static char buf[O_BUFLEN]; |
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34144
diff
changeset
|
815 |
Thread* t = Thread::current_or_null(); |
26821
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
816 |
// Call generic frame constructor (certain arguments may be ignored) |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
817 |
frame fr(sp, fp, pc); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
818 |
print_native_stack(tty, fr, t, buf, sizeof(buf)); |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
819 |
} |
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
820 |
|
ce9f82507dc2
8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents:
25715
diff
changeset
|
821 |
#endif // !PRODUCT |
31340
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
822 |
|
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
823 |
////////////////////////////////////////////////////////////////////////////// |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
824 |
// Test multiple STATIC_ASSERT forms in various scopes. |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
825 |
|
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
826 |
#ifndef PRODUCT |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
827 |
|
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
828 |
// namespace scope |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
829 |
STATIC_ASSERT(true); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
830 |
STATIC_ASSERT(true); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
831 |
STATIC_ASSERT(1 == 1); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
832 |
STATIC_ASSERT(0 == 0); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
833 |
|
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
834 |
void test_multiple_static_assert_forms_in_function_scope() { |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
835 |
STATIC_ASSERT(true); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
836 |
STATIC_ASSERT(true); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
837 |
STATIC_ASSERT(0 == 0); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
838 |
STATIC_ASSERT(1 == 1); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
839 |
} |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
840 |
|
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
841 |
// class scope |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
842 |
struct TestMultipleStaticAssertFormsInClassScope { |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
843 |
STATIC_ASSERT(true); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
844 |
STATIC_ASSERT(true); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
845 |
STATIC_ASSERT(0 == 0); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
846 |
STATIC_ASSERT(1 == 1); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
847 |
}; |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
848 |
|
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
849 |
#endif // !PRODUCT |