author | ccheung |
Thu, 23 Oct 2014 10:08:02 -0700 | |
changeset 27404 | 33c0f343cd5c |
parent 26821 | ce9f82507dc2 |
child 28476 | ae1ca3bf45ca |
permissions | -rw-r--r-- |
1 | 1 |
/* |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
18683
diff
changeset
|
2 |
* Copyright (c) 1997, 2014, 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" |
|
33 |
#include "gc_implementation/shared/markSweep.hpp" |
|
34 |
#include "gc_interface/collectedHeap.hpp" |
|
35 |
#include "interpreter/bytecodeHistogram.hpp" |
|
36 |
#include "interpreter/interpreter.hpp" |
|
37 |
#include "memory/resourceArea.hpp" |
|
38 |
#include "memory/universe.hpp" |
|
39 |
#include "oops/oop.inline.hpp" |
|
40 |
#include "prims/privilegedStack.hpp" |
|
41 |
#include "runtime/arguments.hpp" |
|
25351
7c198a690050
8044775: Improve usage of umbrella header atomic.inline.hpp.
goetz
parents:
24826
diff
changeset
|
42 |
#include "runtime/atomic.inline.hpp" |
7397 | 43 |
#include "runtime/frame.hpp" |
44 |
#include "runtime/java.hpp" |
|
25468
5331df506290
8048241: Introduce umbrella header os.inline.hpp and clean up includes
goetz
parents:
25351
diff
changeset
|
45 |
#include "runtime/os.hpp" |
7397 | 46 |
#include "runtime/sharedRuntime.hpp" |
47 |
#include "runtime/stubCodeGenerator.hpp" |
|
48 |
#include "runtime/stubRoutines.hpp" |
|
14583
d70ee55535f4
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
14076
diff
changeset
|
49 |
#include "runtime/thread.inline.hpp" |
7397 | 50 |
#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
|
51 |
#include "runtime/vm_version.hpp" |
7397 | 52 |
#include "services/heapDumper.hpp" |
53 |
#include "utilities/defaultStream.hpp" |
|
54 |
#include "utilities/events.hpp" |
|
55 |
#include "utilities/top.hpp" |
|
56 |
#include "utilities/vmError.hpp" |
|
1 | 57 |
|
58 |
#ifndef ASSERT |
|
59 |
# ifdef _DEBUG |
|
60 |
// NOTE: don't turn the lines below into a comment -- if you're getting |
|
61 |
// a compile error here, change the settings to define ASSERT |
|
62 |
ASSERT should be defined when _DEBUG is defined. It is not intended to be used for debugging |
|
63 |
functions that do not slow down the system too much and thus can be left in optimized code. |
|
64 |
On the other hand, the code should not be included in a production version. |
|
65 |
# endif // _DEBUG |
|
66 |
#endif // ASSERT |
|
67 |
||
68 |
||
69 |
#ifdef _DEBUG |
|
70 |
# ifndef ASSERT |
|
71 |
configuration error: ASSERT must be defined in debug version |
|
72 |
# endif // ASSERT |
|
73 |
#endif // _DEBUG |
|
74 |
||
75 |
||
76 |
#ifdef PRODUCT |
|
77 |
# if -defined _DEBUG || -defined ASSERT |
|
78 |
configuration error: ASSERT et al. must not be defined in PRODUCT version |
|
79 |
# endif |
|
80 |
#endif // PRODUCT |
|
81 |
||
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
18683
diff
changeset
|
82 |
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC |
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
18683
diff
changeset
|
83 |
|
13393
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
11788
diff
changeset
|
84 |
FormatBufferResource::FormatBufferResource(const char * format, ...) |
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
11788
diff
changeset
|
85 |
: FormatBufferBase((char*)resource_allocate_bytes(RES_BUFSZ)) { |
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
11788
diff
changeset
|
86 |
va_list argp; |
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
11788
diff
changeset
|
87 |
va_start(argp, format); |
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
11788
diff
changeset
|
88 |
jio_vsnprintf(_buf, RES_BUFSZ, format, argp); |
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
11788
diff
changeset
|
89 |
va_end(argp); |
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
11788
diff
changeset
|
90 |
} |
1 | 91 |
|
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
18683
diff
changeset
|
92 |
ATTRIBUTE_PRINTF(1, 2) |
1 | 93 |
void warning(const char* format, ...) { |
6967
c5ebdcf8372e
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
6445
diff
changeset
|
94 |
if (PrintWarnings) { |
13761 | 95 |
FILE* const err = defaultStream::error_stream(); |
96 |
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
|
97 |
va_list ap; |
c5ebdcf8372e
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
6445
diff
changeset
|
98 |
va_start(ap, format); |
13761 | 99 |
vfprintf(err, format, ap); |
6967
c5ebdcf8372e
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
6445
diff
changeset
|
100 |
va_end(ap); |
13761 | 101 |
fputc('\n', err); |
6967
c5ebdcf8372e
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
6445
diff
changeset
|
102 |
} |
1 | 103 |
if (BreakAtWarning) BREAKPOINT; |
104 |
} |
|
105 |
||
106 |
#ifndef PRODUCT |
|
107 |
||
108 |
#define is_token_break(ch) (isspace(ch) || (ch) == ',') |
|
109 |
||
110 |
static const char* last_file_name = NULL; |
|
111 |
static int last_line_no = -1; |
|
112 |
||
113 |
// assert/guarantee/... may happen very early during VM initialization. |
|
114 |
// Don't rely on anything that is initialized by Threads::create_vm(). For |
|
115 |
// example, don't use tty. |
|
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
116 |
bool error_is_suppressed(const char* file_name, int line_no) { |
1 | 117 |
// The following 1-element cache requires that passed-in |
118 |
// file names are always only constant literals. |
|
119 |
if (file_name == last_file_name && line_no == last_line_no) return true; |
|
120 |
||
121 |
int file_name_len = (int)strlen(file_name); |
|
122 |
char separator = os::file_separator()[0]; |
|
123 |
const char* base_name = strrchr(file_name, separator); |
|
124 |
if (base_name == NULL) |
|
125 |
base_name = file_name; |
|
126 |
||
127 |
// scan the SuppressErrorAt option |
|
128 |
const char* cp = SuppressErrorAt; |
|
129 |
for (;;) { |
|
130 |
const char* sfile; |
|
131 |
int sfile_len; |
|
132 |
int sline; |
|
133 |
bool noisy; |
|
134 |
while ((*cp) != '\0' && is_token_break(*cp)) cp++; |
|
135 |
if ((*cp) == '\0') break; |
|
136 |
sfile = cp; |
|
137 |
while ((*cp) != '\0' && !is_token_break(*cp) && (*cp) != ':') cp++; |
|
138 |
sfile_len = cp - sfile; |
|
139 |
if ((*cp) == ':') cp++; |
|
140 |
sline = 0; |
|
141 |
while ((*cp) != '\0' && isdigit(*cp)) { |
|
142 |
sline *= 10; |
|
143 |
sline += (*cp) - '0'; |
|
144 |
cp++; |
|
145 |
} |
|
146 |
// "file:line!" means the assert suppression is not silent |
|
147 |
noisy = ((*cp) == '!'); |
|
148 |
while ((*cp) != '\0' && !is_token_break(*cp)) cp++; |
|
149 |
// match the line |
|
150 |
if (sline != 0) { |
|
151 |
if (sline != line_no) continue; |
|
152 |
} |
|
153 |
// match the file |
|
154 |
if (sfile_len > 0) { |
|
155 |
const char* look = file_name; |
|
156 |
const char* look_max = file_name + file_name_len - sfile_len; |
|
157 |
const char* foundp; |
|
158 |
bool match = false; |
|
159 |
while (!match |
|
160 |
&& (foundp = strchr(look, sfile[0])) != NULL |
|
161 |
&& foundp <= look_max) { |
|
162 |
match = true; |
|
163 |
for (int i = 1; i < sfile_len; i++) { |
|
164 |
if (sfile[i] != foundp[i]) { |
|
165 |
match = false; |
|
166 |
break; |
|
167 |
} |
|
168 |
} |
|
169 |
look = foundp + 1; |
|
170 |
} |
|
171 |
if (!match) continue; |
|
172 |
} |
|
173 |
// got a match! |
|
174 |
if (noisy) { |
|
175 |
fdStream out(defaultStream::output_fd()); |
|
176 |
out.print_raw("[error suppressed at "); |
|
177 |
out.print_raw(base_name); |
|
178 |
char buf[16]; |
|
179 |
jio_snprintf(buf, sizeof(buf), ":%d]", line_no); |
|
180 |
out.print_raw_cr(buf); |
|
181 |
} else { |
|
182 |
// update 1-element cache for fast silent matches |
|
183 |
last_file_name = file_name; |
|
184 |
last_line_no = line_no; |
|
185 |
} |
|
186 |
return true; |
|
187 |
} |
|
188 |
||
189 |
if (!is_error_reported()) { |
|
190 |
// print a friendly hint: |
|
191 |
fdStream out(defaultStream::output_fd()); |
|
192 |
out.print_raw_cr("# To suppress the following error report, specify this argument"); |
|
193 |
out.print_raw ("# after -XX: or in .hotspotrc: SuppressErrorAt="); |
|
194 |
out.print_raw (base_name); |
|
195 |
char buf[16]; |
|
196 |
jio_snprintf(buf, sizeof(buf), ":%d", line_no); |
|
197 |
out.print_raw_cr(buf); |
|
198 |
} |
|
199 |
return false; |
|
200 |
} |
|
201 |
||
202 |
#undef is_token_break |
|
203 |
||
204 |
#else |
|
205 |
||
206 |
// Place-holder for non-existent suppression check: |
|
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
207 |
#define error_is_suppressed(file_name, line_no) (false) |
1 | 208 |
|
10739 | 209 |
#endif // !PRODUCT |
1 | 210 |
|
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
211 |
void report_vm_error(const char* file, int line, const char* error_msg, |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
212 |
const char* detail_msg) |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
213 |
{ |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
214 |
if (Debugging || error_is_suppressed(file, line)) return; |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
215 |
Thread* const thread = ThreadLocalStorage::get_thread_slow(); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
216 |
VMError err(thread, file, line, error_msg, detail_msg); |
1 | 217 |
err.report_and_die(); |
218 |
} |
|
219 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
220 |
void report_fatal(const char* file, int line, const char* message) |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
221 |
{ |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
222 |
report_vm_error(file, line, "fatal error", message); |
1 | 223 |
} |
224 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
225 |
void report_vm_out_of_memory(const char* file, int line, size_t size, |
17087
f0b76c4c93a0
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
16670
diff
changeset
|
226 |
VMErrorType vm_err_type, const char* message) { |
7719
ef138e2849eb
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
7433
diff
changeset
|
227 |
if (Debugging) return; |
1 | 228 |
|
15796
41577a5deb58
6799919: Recursive calls to report_vm_out_of_memory are handled incorrectly
dcubed
parents:
15088
diff
changeset
|
229 |
Thread* thread = ThreadLocalStorage::get_thread_slow(); |
17087
f0b76c4c93a0
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
16670
diff
changeset
|
230 |
VMError(thread, file, line, size, vm_err_type, message).report_and_die(); |
1 | 231 |
|
15796
41577a5deb58
6799919: Recursive calls to report_vm_out_of_memory are handled incorrectly
dcubed
parents:
15088
diff
changeset
|
232 |
// 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
|
233 |
// 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
|
234 |
guarantee(false, "report_and_die() should not return here"); |
1 | 235 |
} |
236 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
237 |
void report_should_not_call(const char* file, int line) { |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
238 |
report_vm_error(file, line, "ShouldNotCall()"); |
1 | 239 |
} |
240 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
241 |
void report_should_not_reach_here(const char* file, int line) { |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
242 |
report_vm_error(file, line, "ShouldNotReachHere()"); |
1 | 243 |
} |
244 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
245 |
void report_unimplemented(const char* file, int line) { |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
246 |
report_vm_error(file, line, "Unimplemented()"); |
1 | 247 |
} |
248 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
249 |
void report_untested(const char* file, int line, const char* message) { |
1 | 250 |
#ifndef PRODUCT |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
251 |
warning("Untested: %s in %s: %d\n", message, file, line); |
10739 | 252 |
#endif // !PRODUCT |
1 | 253 |
} |
254 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
255 |
void report_out_of_shared_space(SharedSpaceType shared_space) { |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
256 |
static const char* name[] = { |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
257 |
"shared read only space", |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
258 |
"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
|
259 |
"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
|
260 |
"shared miscellaneous code space" |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
261 |
}; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
262 |
static const char* flag[] = { |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
263 |
"SharedReadOnlySize", |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
264 |
"SharedReadWriteSize", |
27404
33c0f343cd5c
8038268: VM Crashes in MetaspaceShared::generate_vtable_methods while creating CDS archive with limiting SharedMiscCodeSize
ccheung
parents:
26821
diff
changeset
|
265 |
"SharedMiscDataSize", |
33c0f343cd5c
8038268: VM Crashes in MetaspaceShared::generate_vtable_methods while creating CDS archive with limiting SharedMiscCodeSize
ccheung
parents:
26821
diff
changeset
|
266 |
"SharedMiscCodeSize" |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
267 |
}; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
268 |
|
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
269 |
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
|
270 |
"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
|
271 |
"to increase the initial size of %s.\n", |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
272 |
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
|
273 |
exit(2); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
274 |
} |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7719
diff
changeset
|
275 |
|
1 | 276 |
void report_java_out_of_memory(const char* message) { |
277 |
static jint out_of_memory_reported = 0; |
|
278 |
||
279 |
// A number of threads may attempt to report OutOfMemoryError at around the |
|
280 |
// same time. To avoid dumping the heap or executing the data collection |
|
281 |
// commands multiple times we just do it once when the first threads reports |
|
282 |
// the error. |
|
283 |
if (Atomic::cmpxchg(1, &out_of_memory_reported, 0) == 0) { |
|
284 |
// create heap dump before OnOutOfMemoryError commands are executed |
|
285 |
if (HeapDumpOnOutOfMemoryError) { |
|
286 |
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
|
287 |
HeapDumper::dump_heap_from_oome(); |
1 | 288 |
} |
289 |
||
290 |
if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { |
|
291 |
VMError err(message); |
|
292 |
err.report_java_out_of_memory(); |
|
293 |
} |
|
294 |
} |
|
295 |
} |
|
296 |
||
297 |
static bool error_reported = false; |
|
298 |
||
299 |
// call this when the VM is dying--it might loosen some asserts |
|
300 |
void set_error_reported() { |
|
301 |
error_reported = true; |
|
302 |
} |
|
303 |
||
304 |
bool is_error_reported() { |
|
305 |
return error_reported; |
|
306 |
} |
|
307 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
308 |
#ifndef PRODUCT |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
309 |
#include <signal.h> |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
310 |
|
18683
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
311 |
void test_error_handler() { |
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
312 |
uintx test_num = ErrorHandlerTest; |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
313 |
if (test_num == 0) return; |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
314 |
|
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
315 |
// If asserts are disabled, use the corresponding guarantee instead. |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
316 |
size_t n = test_num; |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
317 |
NOT_DEBUG(if (n <= 2) n += 2); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
318 |
|
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
319 |
const char* const str = "hello"; |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
320 |
const size_t num = (size_t)os::vm_page_size(); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
321 |
|
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
322 |
const char* const eol = os::line_separator(); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
323 |
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
|
324 |
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
|
325 |
const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
326 |
|
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
327 |
// Keep this in sync with test/runtime/6888954/vmerrors.sh. |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
328 |
switch (n) { |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
329 |
case 1: assert(str == NULL, "expected null"); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
330 |
case 2: assert(num == 1023 && *str == 'X', |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
331 |
err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str)); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
332 |
case 3: guarantee(str == NULL, "expected null"); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
333 |
case 4: guarantee(num == 1023 && *str == 'X', |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
334 |
err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str)); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
335 |
case 5: fatal("expected null"); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
336 |
case 6: fatal(err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str)); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
337 |
case 7: fatal(err_msg("%s%s# %s%s# %s%s# %s%s# %s%s# " |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
338 |
"%s%s# %s%s# %s%s# %s%s# %s%s# " |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
339 |
"%s%s# %s%s# %s%s# %s%s# %s", |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
340 |
msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
341 |
msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
342 |
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
|
343 |
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
|
344 |
case 9: ShouldNotCallThis(); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
345 |
case 10: ShouldNotReachHere(); |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
346 |
case 11: Unimplemented(); |
18683
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
347 |
// 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
|
348 |
// 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
|
349 |
case 12: *dataPtr = '\0'; break; |
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
350 |
// 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
|
351 |
// 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
|
352 |
case 13: (*funcPtr)(); break; |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
353 |
|
18683
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
354 |
default: tty->print_cr("ERROR: %d: unexpected test_num value.", n); |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
355 |
} |
18683
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
17606
diff
changeset
|
356 |
ShouldNotReachHere(); |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
357 |
} |
10739 | 358 |
#endif // !PRODUCT |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
359 |
|
1 | 360 |
// ------ helper functions for debugging go here ------------ |
361 |
||
362 |
// All debug entries should be wrapped with a stack allocated |
|
363 |
// Command object. It makes sure a resource mark is set and |
|
364 |
// flushes the logfile to prevent file sharing problems. |
|
365 |
||
366 |
class Command : public StackObj { |
|
367 |
private: |
|
368 |
ResourceMark rm; |
|
369 |
ResetNoHandleMark rnhm; |
|
370 |
HandleMark hm; |
|
371 |
bool debug_save; |
|
372 |
public: |
|
373 |
static int level; |
|
374 |
Command(const char* str) { |
|
375 |
debug_save = Debugging; |
|
376 |
Debugging = true; |
|
377 |
if (level++ > 0) return; |
|
378 |
tty->cr(); |
|
379 |
tty->print_cr("\"Executing %s\"", str); |
|
380 |
} |
|
381 |
||
10739 | 382 |
~Command() { |
383 |
tty->flush(); |
|
384 |
Debugging = debug_save; |
|
385 |
level--; |
|
386 |
} |
|
1 | 387 |
}; |
388 |
||
389 |
int Command::level = 0; |
|
390 |
||
10739 | 391 |
#ifndef PRODUCT |
392 |
||
1 | 393 |
extern "C" void blob(CodeBlob* cb) { |
394 |
Command c("blob"); |
|
395 |
cb->print(); |
|
396 |
} |
|
397 |
||
398 |
||
399 |
extern "C" void dump_vtable(address p) { |
|
400 |
Command c("dump_vtable"); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
401 |
Klass* k = (Klass*)p; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
402 |
InstanceKlass::cast(k)->vtable()->print(); |
1 | 403 |
} |
404 |
||
405 |
||
406 |
extern "C" void nm(intptr_t p) { |
|
407 |
// Actually we look through all CodeBlobs (the nm name has been kept for backwards compatability) |
|
408 |
Command c("nm"); |
|
409 |
CodeBlob* cb = CodeCache::find_blob((address)p); |
|
410 |
if (cb == NULL) { |
|
411 |
tty->print_cr("NULL"); |
|
412 |
} else { |
|
413 |
cb->print(); |
|
414 |
} |
|
415 |
} |
|
416 |
||
417 |
||
418 |
extern "C" void disnm(intptr_t p) { |
|
419 |
Command c("disnm"); |
|
420 |
CodeBlob* cb = CodeCache::find_blob((address) p); |
|
7433 | 421 |
nmethod* nm = cb->as_nmethod_or_null(); |
422 |
if (nm) { |
|
423 |
nm->print(); |
|
424 |
Disassembler::decode(nm); |
|
425 |
} else { |
|
426 |
cb->print(); |
|
427 |
Disassembler::decode(cb); |
|
428 |
} |
|
1 | 429 |
} |
430 |
||
431 |
||
432 |
extern "C" void printnm(intptr_t p) { |
|
433 |
char buffer[256]; |
|
434 |
sprintf(buffer, "printnm: " INTPTR_FORMAT, p); |
|
435 |
Command c(buffer); |
|
436 |
CodeBlob* cb = CodeCache::find_blob((address) p); |
|
437 |
if (cb->is_nmethod()) { |
|
438 |
nmethod* nm = (nmethod*)cb; |
|
439 |
nm->print_nmethod(true); |
|
440 |
} |
|
441 |
} |
|
442 |
||
443 |
||
444 |
extern "C" void universe() { |
|
445 |
Command c("universe"); |
|
446 |
Universe::print(); |
|
447 |
} |
|
448 |
||
449 |
||
450 |
extern "C" void verify() { |
|
451 |
// try to run a verify on the entire system |
|
452 |
// note: this may not be safe if we're not at a safepoint; for debugging, |
|
453 |
// this manipulates the safepoint settings to avoid assertion failures |
|
454 |
Command c("universe verify"); |
|
455 |
bool safe = SafepointSynchronize::is_at_safepoint(); |
|
456 |
if (!safe) { |
|
457 |
tty->print_cr("warning: not at safepoint -- verify may fail"); |
|
458 |
SafepointSynchronize::set_is_at_safepoint(); |
|
459 |
} |
|
460 |
// Ensure Eden top is correct before verification |
|
461 |
Universe::heap()->prepare_for_verify(); |
|
14076
84643cfaeaa8
8000831: Heap verification output incorrect/incomplete
johnc
parents:
13761
diff
changeset
|
462 |
Universe::verify(); |
1 | 463 |
if (!safe) SafepointSynchronize::set_is_not_at_safepoint(); |
464 |
} |
|
465 |
||
466 |
||
467 |
extern "C" void pp(void* p) { |
|
468 |
Command c("pp"); |
|
469 |
FlagSetting fl(PrintVMMessages, true); |
|
9437
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
470 |
FlagSetting f2(DisplayVMOutput, true); |
1 | 471 |
if (Universe::heap()->is_in(p)) { |
472 |
oop obj = oop(p); |
|
473 |
obj->print(); |
|
474 |
} else { |
|
10739 | 475 |
tty->print(PTR_FORMAT, p); |
1 | 476 |
} |
477 |
} |
|
478 |
||
479 |
||
480 |
// pv: print vm-printable object |
|
481 |
extern "C" void pa(intptr_t p) { ((AllocatedObj*) p)->print(); } |
|
482 |
extern "C" void findpc(intptr_t x); |
|
483 |
||
10739 | 484 |
#endif // !PRODUCT |
485 |
||
1 | 486 |
extern "C" void ps() { // print stack |
10739 | 487 |
if (Thread::current() == NULL) return; |
1 | 488 |
Command c("ps"); |
489 |
||
490 |
||
491 |
// Prints the stack of the current Java thread |
|
492 |
JavaThread* p = JavaThread::active(); |
|
493 |
tty->print(" for thread: "); |
|
494 |
p->print(); |
|
495 |
tty->cr(); |
|
496 |
||
497 |
if (p->has_last_Java_frame()) { |
|
498 |
// If the last_Java_fp is set we are in C land and |
|
499 |
// can call the standard stack_trace function. |
|
10739 | 500 |
#ifdef PRODUCT |
501 |
p->print_stack(); |
|
502 |
} else { |
|
503 |
tty->print_cr("Cannot find the last Java frame, printing stack disabled."); |
|
504 |
#else // !PRODUCT |
|
1 | 505 |
p->trace_stack(); |
506 |
} else { |
|
507 |
frame f = os::current_frame(); |
|
508 |
RegisterMap reg_map(p); |
|
509 |
f = f.sender(®_map); |
|
510 |
tty->print("(guessing starting frame id=%#p based on current fp)\n", f.id()); |
|
511 |
p->trace_stack_from(vframe::new_vframe(&f, ®_map, p)); |
|
512 |
pd_ps(f); |
|
10739 | 513 |
#endif // PRODUCT |
1 | 514 |
} |
515 |
||
516 |
} |
|
517 |
||
9437
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
518 |
extern "C" void pfl() { |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
519 |
// print frame layout |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
520 |
Command c("pfl"); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
521 |
JavaThread* p = JavaThread::active(); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
522 |
tty->print(" for thread: "); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
523 |
p->print(); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
524 |
tty->cr(); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
525 |
if (p->has_last_Java_frame()) { |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
526 |
p->print_frame_layout(); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
527 |
} |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
528 |
} |
1 | 529 |
|
10739 | 530 |
#ifndef PRODUCT |
531 |
||
1 | 532 |
extern "C" void psf() { // print stack frames |
533 |
{ |
|
534 |
Command c("psf"); |
|
535 |
JavaThread* p = JavaThread::active(); |
|
536 |
tty->print(" for thread: "); |
|
537 |
p->print(); |
|
538 |
tty->cr(); |
|
539 |
if (p->has_last_Java_frame()) { |
|
540 |
p->trace_frames(); |
|
541 |
} |
|
542 |
} |
|
543 |
} |
|
544 |
||
545 |
||
546 |
extern "C" void threads() { |
|
547 |
Command c("threads"); |
|
548 |
Threads::print(false, true); |
|
549 |
} |
|
550 |
||
551 |
||
552 |
extern "C" void psd() { |
|
553 |
Command c("psd"); |
|
554 |
SystemDictionary::print(); |
|
555 |
} |
|
556 |
||
557 |
||
558 |
extern "C" void safepoints() { |
|
559 |
Command c("safepoints"); |
|
560 |
SafepointSynchronize::print_state(); |
|
561 |
} |
|
562 |
||
10739 | 563 |
#endif // !PRODUCT |
1 | 564 |
|
565 |
extern "C" void pss() { // print all stacks |
|
10739 | 566 |
if (Thread::current() == NULL) return; |
1 | 567 |
Command c("pss"); |
10739 | 568 |
Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true)); |
1 | 569 |
} |
570 |
||
10739 | 571 |
#ifndef PRODUCT |
1 | 572 |
|
573 |
extern "C" void debug() { // to set things up for compiler debugging |
|
574 |
Command c("debug"); |
|
575 |
WizardMode = true; |
|
576 |
PrintVMMessages = PrintCompilation = true; |
|
577 |
PrintInlining = PrintAssembly = true; |
|
578 |
tty->flush(); |
|
579 |
} |
|
580 |
||
581 |
||
582 |
extern "C" void ndebug() { // undo debug() |
|
583 |
Command c("ndebug"); |
|
584 |
PrintCompilation = false; |
|
585 |
PrintInlining = PrintAssembly = false; |
|
586 |
tty->flush(); |
|
587 |
} |
|
588 |
||
589 |
||
590 |
extern "C" void flush() { |
|
591 |
Command c("flush"); |
|
592 |
tty->flush(); |
|
593 |
} |
|
594 |
||
11788 | 595 |
extern "C" void events() { |
596 |
Command c("events"); |
|
597 |
Events::print(); |
|
598 |
} |
|
1 | 599 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
600 |
extern "C" Method* findm(intptr_t pc) { |
1 | 601 |
Command c("findm"); |
602 |
nmethod* nm = CodeCache::find_nmethod((address)pc); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
603 |
return (nm == NULL) ? (Method*)NULL : nm->method(); |
1 | 604 |
} |
605 |
||
606 |
||
607 |
extern "C" nmethod* findnm(intptr_t addr) { |
|
608 |
Command c("findnm"); |
|
609 |
return CodeCache::find_nmethod((address)addr); |
|
610 |
} |
|
611 |
||
612 |
// Another interface that isn't ambiguous in dbx. |
|
613 |
// Can we someday rename the other find to hsfind? |
|
614 |
extern "C" void hsfind(intptr_t x) { |
|
615 |
Command c("hsfind"); |
|
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
616 |
os::print_location(tty, x, false); |
1 | 617 |
} |
618 |
||
619 |
||
620 |
extern "C" void find(intptr_t x) { |
|
621 |
Command c("find"); |
|
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
622 |
os::print_location(tty, x, false); |
1 | 623 |
} |
624 |
||
625 |
||
626 |
extern "C" void findpc(intptr_t x) { |
|
627 |
Command c("findpc"); |
|
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
628 |
os::print_location(tty, x, true); |
1 | 629 |
} |
630 |
||
631 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
632 |
// 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
|
633 |
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
|
634 |
Command c("findbcp"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
635 |
Method* mh = (Method*)method; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
636 |
if (!mh->is_native()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
637 |
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
|
638 |
mh, mh->bci_from(address(bcp))); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
639 |
mh->print_codes_on(tty); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
640 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
641 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
642 |
|
1 | 643 |
// int versions of all methods to avoid having to type type casts in the debugger |
644 |
||
645 |
void pp(intptr_t p) { pp((void*)p); } |
|
646 |
void pp(oop p) { pp((void*)p); } |
|
647 |
||
648 |
void help() { |
|
649 |
Command c("help"); |
|
650 |
tty->print_cr("basic"); |
|
651 |
tty->print_cr(" pp(void* p) - try to make sense of p"); |
|
652 |
tty->print_cr(" pv(intptr_t p)- ((PrintableResourceObj*) p)->print()"); |
|
653 |
tty->print_cr(" ps() - print current thread stack"); |
|
654 |
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
|
655 |
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
|
656 |
tty->print_cr(" findm(intptr_t pc) - finds Method*"); |
1 | 657 |
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
|
658 |
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
|
659 |
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
|
660 |
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
|
661 |
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
|
662 |
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
|
663 |
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
|
664 |
tty->print_cr(" - in dbx do 'frame 1' before calling pns()"); |
1 | 665 |
|
666 |
tty->print_cr("misc."); |
|
667 |
tty->print_cr(" flush() - flushes the log file"); |
|
11788 | 668 |
tty->print_cr(" events() - dump events from ring buffers"); |
1 | 669 |
|
670 |
||
671 |
tty->print_cr("compiler debugging"); |
|
672 |
tty->print_cr(" debug() - to set things up for compiler debugging"); |
|
673 |
tty->print_cr(" ndebug() - undo debug"); |
|
674 |
} |
|
675 |
||
10739 | 676 |
#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
|
677 |
|
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
|
678 |
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
|
679 |
|
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
|
680 |
// 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
|
681 |
if (fr.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
|
682 |
st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)"); |
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
|
683 |
|
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
|
684 |
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
|
685 |
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
|
686 |
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
|
687 |
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
|
688 |
// 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
|
689 |
// 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
|
690 |
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
|
691 |
// 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
|
692 |
// 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
|
693 |
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
|
694 |
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
|
695 |
} |
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
|
696 |
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
|
697 |
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
|
698 |
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
|
699 |
} 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
|
700 |
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
|
701 |
} |
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
|
702 |
} 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
|
703 |
// 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
|
704 |
// 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
|
705 |
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
|
706 |
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
|
707 |
} |
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
|
708 |
} |
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
|
709 |
|
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
|
710 |
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
|
711 |
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
|
712 |
} |
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
|
713 |
|
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
|
714 |
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
|
715 |
} |
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
|
716 |
} |
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
|
717 |
|
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
|
718 |
#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
|
719 |
|
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
|
720 |
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
|
721 |
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
|
722 |
static char buf[O_BUFLEN]; |
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
|
723 |
Thread* t = ThreadLocalStorage::get_thread_slow(); |
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
|
724 |
// 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
|
725 |
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
|
726 |
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
|
727 |
} |
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
|
728 |
|
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
|
729 |
#endif // !PRODUCT |