author | stefank |
Mon, 25 Nov 2019 12:33:15 +0100 | |
changeset 59252 | 623722a6aeb9 |
parent 59049 | dc1899bb84c0 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
53659
da5dc7e654aa
8218566: NMT: missing memory tag for assert poison page
zgu
parents:
53599
diff
changeset
|
2 |
* Copyright (c) 1997, 2019, 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" |
47765
b7c7428eaab9
8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents:
47216
diff
changeset
|
26 |
#include "jvm.h" |
7397 | 27 |
#include "classfile/systemDictionary.hpp" |
28 |
#include "code/codeCache.hpp" |
|
29 |
#include "code/icBuffer.hpp" |
|
30 |
#include "code/nmethod.hpp" |
|
31 |
#include "code/vtableStubs.hpp" |
|
32 |
#include "compiler/compileBroker.hpp" |
|
33 |
#include "compiler/disassembler.hpp" |
|
30764 | 34 |
#include "gc/shared/collectedHeap.hpp" |
7397 | 35 |
#include "interpreter/bytecodeHistogram.hpp" |
36 |
#include "interpreter/interpreter.hpp" |
|
53659
da5dc7e654aa
8218566: NMT: missing memory tag for assert poison page
zgu
parents:
53599
diff
changeset
|
37 |
#include "memory/allocation.hpp" |
7397 | 38 |
#include "memory/resourceArea.hpp" |
39 |
#include "memory/universe.hpp" |
|
40 |
#include "oops/oop.inline.hpp" |
|
41 |
#include "runtime/arguments.hpp" |
|
40655
9f644073d3a0
8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents:
39274
diff
changeset
|
42 |
#include "runtime/atomic.hpp" |
49902
3661f31c6df4
8202150: [REDO] Split globals.hpp to factor out the Flag class
gziemski
parents:
49860
diff
changeset
|
43 |
#include "runtime/flags/flagSetting.hpp" |
49480
d7df2dd501ce
8199809: Don't include frame.inline.hpp and other.inline.hpp from .hpp files
coleenp
parents:
49061
diff
changeset
|
44 |
#include "runtime/frame.inline.hpp" |
d7df2dd501ce
8199809: Don't include frame.inline.hpp and other.inline.hpp from .hpp files
coleenp
parents:
49061
diff
changeset
|
45 |
#include "runtime/handles.inline.hpp" |
7397 | 46 |
#include "runtime/java.hpp" |
25468
5331df506290
8048241: Introduce umbrella header os.inline.hpp and clean up includes
goetz
parents:
25351
diff
changeset
|
47 |
#include "runtime/os.hpp" |
7397 | 48 |
#include "runtime/sharedRuntime.hpp" |
49 |
#include "runtime/stubCodeGenerator.hpp" |
|
50 |
#include "runtime/stubRoutines.hpp" |
|
14583
d70ee55535f4
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
14076
diff
changeset
|
51 |
#include "runtime/thread.inline.hpp" |
7397 | 52 |
#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
|
53 |
#include "runtime/vm_version.hpp" |
7397 | 54 |
#include "services/heapDumper.hpp" |
53659
da5dc7e654aa
8218566: NMT: missing memory tag for assert poison page
zgu
parents:
53599
diff
changeset
|
55 |
#include "services/memTracker.hpp" |
7397 | 56 |
#include "utilities/defaultStream.hpp" |
57 |
#include "utilities/events.hpp" |
|
46560
388aa8d67c80
8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents:
46408
diff
changeset
|
58 |
#include "utilities/formatBuffer.hpp" |
49653
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
59 |
#include "utilities/globalDefinitions.hpp" |
36384 | 60 |
#include "utilities/macros.hpp" |
7397 | 61 |
#include "utilities/vmError.hpp" |
1 | 62 |
|
38254 | 63 |
#include <stdio.h> |
53757
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
64 |
#include <stdarg.h> |
38254 | 65 |
|
49653
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
66 |
// Support for showing register content on asserts/guarantees. |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
67 |
#ifdef CAN_SHOW_REGISTERS_ON_ASSERT |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
68 |
static char g_dummy; |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
69 |
char* g_assert_poison = &g_dummy; |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
70 |
static intx g_asserting_thread = 0; |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
71 |
static void* g_assertion_context = NULL; |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
72 |
#endif // CAN_SHOW_REGISTERS_ON_ASSERT |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
73 |
|
1 | 74 |
#ifndef ASSERT |
75 |
# ifdef _DEBUG |
|
76 |
// NOTE: don't turn the lines below into a comment -- if you're getting |
|
77 |
// a compile error here, change the settings to define ASSERT |
|
78 |
ASSERT should be defined when _DEBUG is defined. It is not intended to be used for debugging |
|
79 |
functions that do not slow down the system too much and thus can be left in optimized code. |
|
80 |
On the other hand, the code should not be included in a production version. |
|
81 |
# endif // _DEBUG |
|
82 |
#endif // ASSERT |
|
83 |
||
84 |
||
85 |
#ifdef _DEBUG |
|
86 |
# ifndef ASSERT |
|
87 |
configuration error: ASSERT must be defined in debug version |
|
88 |
# endif // ASSERT |
|
89 |
#endif // _DEBUG |
|
90 |
||
91 |
||
92 |
#ifdef PRODUCT |
|
93 |
# if -defined _DEBUG || -defined ASSERT |
|
94 |
configuration error: ASSERT et al. must not be defined in PRODUCT version |
|
95 |
# endif |
|
96 |
#endif // PRODUCT |
|
97 |
||
53599
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
98 |
#ifdef ASSERT |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
99 |
// This is to test that error reporting works if we assert during dynamic |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
100 |
// initialization of the hotspot. See JDK-8214975. |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
101 |
struct Crasher { |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
102 |
Crasher() { |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
103 |
// Using getenv - no other mechanism would work yet. |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
104 |
const char* s = ::getenv("HOTSPOT_FATAL_ERROR_DURING_DYNAMIC_INITIALIZATION"); |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
105 |
if (s != NULL && ::strcmp(s, "1") == 0) { |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
106 |
fatal("HOTSPOT_FATAL_ERROR_DURING_DYNAMIC_INITIALIZATION"); |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
107 |
} |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
108 |
} |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
109 |
}; |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
110 |
static Crasher g_crasher; |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
111 |
#endif // ASSERT |
0de1f006d3c3
8214975: No hs-err file if fatal error is raised during dynamic initialization
stuefe
parents:
52431
diff
changeset
|
112 |
|
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
18683
diff
changeset
|
113 |
ATTRIBUTE_PRINTF(1, 2) |
1 | 114 |
void warning(const char* format, ...) { |
6967
c5ebdcf8372e
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
6445
diff
changeset
|
115 |
if (PrintWarnings) { |
13761 | 116 |
FILE* const err = defaultStream::error_stream(); |
117 |
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
|
118 |
va_list ap; |
c5ebdcf8372e
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
6445
diff
changeset
|
119 |
va_start(ap, format); |
13761 | 120 |
vfprintf(err, format, ap); |
6967
c5ebdcf8372e
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
6445
diff
changeset
|
121 |
va_end(ap); |
13761 | 122 |
fputc('\n', err); |
6967
c5ebdcf8372e
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
6445
diff
changeset
|
123 |
} |
1 | 124 |
if (BreakAtWarning) BREAKPOINT; |
125 |
} |
|
126 |
||
127 |
#ifndef PRODUCT |
|
128 |
||
129 |
#define is_token_break(ch) (isspace(ch) || (ch) == ',') |
|
130 |
||
131 |
static const char* last_file_name = NULL; |
|
132 |
static int last_line_no = -1; |
|
133 |
||
134 |
// assert/guarantee/... may happen very early during VM initialization. |
|
135 |
// Don't rely on anything that is initialized by Threads::create_vm(). For |
|
136 |
// example, don't use tty. |
|
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
137 |
bool error_is_suppressed(const char* file_name, int line_no) { |
1 | 138 |
// The following 1-element cache requires that passed-in |
139 |
// file names are always only constant literals. |
|
140 |
if (file_name == last_file_name && line_no == last_line_no) return true; |
|
141 |
||
142 |
int file_name_len = (int)strlen(file_name); |
|
143 |
char separator = os::file_separator()[0]; |
|
144 |
const char* base_name = strrchr(file_name, separator); |
|
145 |
if (base_name == NULL) |
|
146 |
base_name = file_name; |
|
147 |
||
148 |
// scan the SuppressErrorAt option |
|
149 |
const char* cp = SuppressErrorAt; |
|
150 |
for (;;) { |
|
151 |
const char* sfile; |
|
152 |
int sfile_len; |
|
153 |
int sline; |
|
154 |
bool noisy; |
|
155 |
while ((*cp) != '\0' && is_token_break(*cp)) cp++; |
|
156 |
if ((*cp) == '\0') break; |
|
157 |
sfile = cp; |
|
158 |
while ((*cp) != '\0' && !is_token_break(*cp) && (*cp) != ':') cp++; |
|
159 |
sfile_len = cp - sfile; |
|
160 |
if ((*cp) == ':') cp++; |
|
161 |
sline = 0; |
|
162 |
while ((*cp) != '\0' && isdigit(*cp)) { |
|
163 |
sline *= 10; |
|
164 |
sline += (*cp) - '0'; |
|
165 |
cp++; |
|
166 |
} |
|
167 |
// "file:line!" means the assert suppression is not silent |
|
168 |
noisy = ((*cp) == '!'); |
|
169 |
while ((*cp) != '\0' && !is_token_break(*cp)) cp++; |
|
170 |
// match the line |
|
171 |
if (sline != 0) { |
|
172 |
if (sline != line_no) continue; |
|
173 |
} |
|
174 |
// match the file |
|
175 |
if (sfile_len > 0) { |
|
176 |
const char* look = file_name; |
|
177 |
const char* look_max = file_name + file_name_len - sfile_len; |
|
178 |
const char* foundp; |
|
179 |
bool match = false; |
|
180 |
while (!match |
|
181 |
&& (foundp = strchr(look, sfile[0])) != NULL |
|
182 |
&& foundp <= look_max) { |
|
183 |
match = true; |
|
184 |
for (int i = 1; i < sfile_len; i++) { |
|
185 |
if (sfile[i] != foundp[i]) { |
|
186 |
match = false; |
|
187 |
break; |
|
188 |
} |
|
189 |
} |
|
190 |
look = foundp + 1; |
|
191 |
} |
|
192 |
if (!match) continue; |
|
193 |
} |
|
194 |
// got a match! |
|
195 |
if (noisy) { |
|
196 |
fdStream out(defaultStream::output_fd()); |
|
197 |
out.print_raw("[error suppressed at "); |
|
198 |
out.print_raw(base_name); |
|
199 |
char buf[16]; |
|
200 |
jio_snprintf(buf, sizeof(buf), ":%d]", line_no); |
|
201 |
out.print_raw_cr(buf); |
|
202 |
} else { |
|
203 |
// update 1-element cache for fast silent matches |
|
204 |
last_file_name = file_name; |
|
205 |
last_line_no = line_no; |
|
206 |
} |
|
207 |
return true; |
|
208 |
} |
|
209 |
||
46589 | 210 |
if (!VMError::is_error_reported() && !SuppressFatalErrorMessage) { |
1 | 211 |
// print a friendly hint: |
212 |
fdStream out(defaultStream::output_fd()); |
|
213 |
out.print_raw_cr("# To suppress the following error report, specify this argument"); |
|
214 |
out.print_raw ("# after -XX: or in .hotspotrc: SuppressErrorAt="); |
|
215 |
out.print_raw (base_name); |
|
216 |
char buf[16]; |
|
217 |
jio_snprintf(buf, sizeof(buf), ":%d", line_no); |
|
218 |
out.print_raw_cr(buf); |
|
219 |
} |
|
220 |
return false; |
|
221 |
} |
|
222 |
||
223 |
#undef is_token_break |
|
224 |
||
225 |
#else |
|
226 |
||
227 |
// Place-holder for non-existent suppression check: |
|
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
228 |
#define error_is_suppressed(file_name, line_no) (false) |
1 | 229 |
|
10739 | 230 |
#endif // !PRODUCT |
1 | 231 |
|
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
232 |
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
|
233 |
{ |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
234 |
report_vm_error(file, line, error_msg, "%s", ""); |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
235 |
} |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
236 |
|
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
237 |
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
|
238 |
{ |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
239 |
if (Debugging || error_is_suppressed(file, line)) return; |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
240 |
va_list detail_args; |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
241 |
va_start(detail_args, detail_fmt); |
49653
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
242 |
void* context = NULL; |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
243 |
#ifdef CAN_SHOW_REGISTERS_ON_ASSERT |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
244 |
if (g_assertion_context != NULL && os::current_thread_id() == g_asserting_thread) { |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
245 |
context = g_assertion_context; |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
246 |
} |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
247 |
#endif // CAN_SHOW_REGISTERS_ON_ASSERT |
53757
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
248 |
|
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
249 |
#ifdef ASSERT |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
250 |
if (detail_fmt != NULL && ExecutingUnitTests) { |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
251 |
// Special handling for the sake of gtest death tests which expect the assert |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
252 |
// message to be printed in one short line to stderr (see TEST_VM_ASSERT_MSG) and |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
253 |
// cannot be tweaked to accept our normal assert message. |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
254 |
va_list detail_args_copy; |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
255 |
va_copy(detail_args_copy, detail_args); |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
256 |
::fputs("assert failed: ", stderr); |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
257 |
::vfprintf(stderr, detail_fmt, detail_args_copy); |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
258 |
::fputs("\n", stderr); |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
259 |
::fflush(stderr); |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
260 |
va_end(detail_args_copy); |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
261 |
} |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
262 |
#endif |
e31f39e088b7
8183004: Remove code related to gtest death tests from assert macro
stuefe
parents:
53659
diff
changeset
|
263 |
|
49653
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
264 |
VMError::report_and_die(Thread::current_or_null(), context, file, line, error_msg, detail_fmt, detail_args); |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
265 |
va_end(detail_args); |
1 | 266 |
} |
267 |
||
37113 | 268 |
void report_vm_status_error(const char* file, int line, const char* error_msg, |
269 |
int status, const char* detail) { |
|
270 |
report_vm_error(file, line, error_msg, "error %s(%d), %s", os::errno_name(status), status, detail); |
|
271 |
} |
|
272 |
||
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
273 |
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
|
274 |
{ |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
275 |
if (Debugging || error_is_suppressed(file, line)) return; |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
276 |
va_list detail_args; |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
277 |
va_start(detail_args, detail_fmt); |
49653
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
278 |
void* context = NULL; |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
279 |
#ifdef CAN_SHOW_REGISTERS_ON_ASSERT |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
280 |
if (g_assertion_context != NULL && os::current_thread_id() == g_asserting_thread) { |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
281 |
context = g_assertion_context; |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
282 |
} |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
283 |
#endif // CAN_SHOW_REGISTERS_ON_ASSERT |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
284 |
VMError::report_and_die(Thread::current_or_null(), context, file, line, "fatal error", detail_fmt, detail_args); |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
285 |
va_end(detail_args); |
1 | 286 |
} |
287 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
288 |
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
|
289 |
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
|
290 |
if (Debugging) return; |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
291 |
va_list detail_args; |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
292 |
va_start(detail_args, detail_fmt); |
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34144
diff
changeset
|
293 |
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
|
294 |
va_end(detail_args); |
1 | 295 |
|
15796
41577a5deb58
6799919: Recursive calls to report_vm_out_of_memory are handled incorrectly
dcubed
parents:
15088
diff
changeset
|
296 |
// 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
|
297 |
// 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
|
298 |
guarantee(false, "report_and_die() should not return here"); |
1 | 299 |
} |
300 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
301 |
void report_should_not_call(const char* file, int line) { |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
302 |
report_vm_error(file, line, "ShouldNotCall()"); |
1 | 303 |
} |
304 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
305 |
void report_should_not_reach_here(const char* file, int line) { |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
306 |
report_vm_error(file, line, "ShouldNotReachHere()"); |
1 | 307 |
} |
308 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
309 |
void report_unimplemented(const char* file, int line) { |
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
310 |
report_vm_error(file, line, "Unimplemented()"); |
1 | 311 |
} |
312 |
||
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
313 |
void report_untested(const char* file, int line, const char* message) { |
1 | 314 |
#ifndef PRODUCT |
5403
6b0dd9c75dde
6888954: argument formatting for assert() and friends
jcoomes
parents:
3908
diff
changeset
|
315 |
warning("Untested: %s in %s: %d\n", message, file, line); |
10739 | 316 |
#endif // !PRODUCT |
1 | 317 |
} |
318 |
||
319 |
void report_java_out_of_memory(const char* message) { |
|
47765
b7c7428eaab9
8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents:
47216
diff
changeset
|
320 |
static int out_of_memory_reported = 0; |
1 | 321 |
|
322 |
// A number of threads may attempt to report OutOfMemoryError at around the |
|
323 |
// same time. To avoid dumping the heap or executing the data collection |
|
324 |
// commands multiple times we just do it once when the first threads reports |
|
325 |
// the error. |
|
59252
623722a6aeb9
8234740: Harmonize parameter order in Atomic - cmpxchg
stefank
parents:
59049
diff
changeset
|
326 |
if (Atomic::cmpxchg(&out_of_memory_reported, 0, 1) == 0) { |
1 | 327 |
// create heap dump before OnOutOfMemoryError commands are executed |
328 |
if (HeapDumpOnOutOfMemoryError) { |
|
329 |
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
|
330 |
HeapDumper::dump_heap_from_oome(); |
1 | 331 |
} |
332 |
||
333 |
if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { |
|
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31340
diff
changeset
|
334 |
VMError::report_java_out_of_memory(message); |
1 | 335 |
} |
34670
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
336 |
|
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
337 |
if (CrashOnOutOfMemoryError) { |
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
338 |
tty->print_cr("Aborting due to java.lang.OutOfMemoryError: %s", message); |
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
339 |
fatal("OutOfMemory encountered: %s", message); |
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
340 |
} |
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 |
if (ExitOnOutOfMemoryError) { |
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
343 |
tty->print_cr("Terminating due to java.lang.OutOfMemoryError: %s", message); |
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
344 |
os::exit(3); |
5ab871b40190
8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents:
34633
diff
changeset
|
345 |
} |
1 | 346 |
} |
347 |
} |
|
348 |
||
349 |
// ------ helper functions for debugging go here ------------ |
|
350 |
||
351 |
// All debug entries should be wrapped with a stack allocated |
|
352 |
// Command object. It makes sure a resource mark is set and |
|
353 |
// flushes the logfile to prevent file sharing problems. |
|
354 |
||
355 |
class Command : public StackObj { |
|
356 |
private: |
|
357 |
ResourceMark rm; |
|
358 |
ResetNoHandleMark rnhm; |
|
359 |
HandleMark hm; |
|
360 |
bool debug_save; |
|
361 |
public: |
|
362 |
static int level; |
|
363 |
Command(const char* str) { |
|
364 |
debug_save = Debugging; |
|
365 |
Debugging = true; |
|
366 |
if (level++ > 0) return; |
|
367 |
tty->cr(); |
|
368 |
tty->print_cr("\"Executing %s\"", str); |
|
369 |
} |
|
370 |
||
10739 | 371 |
~Command() { |
372 |
tty->flush(); |
|
373 |
Debugging = debug_save; |
|
374 |
level--; |
|
375 |
} |
|
1 | 376 |
}; |
377 |
||
378 |
int Command::level = 0; |
|
379 |
||
10739 | 380 |
#ifndef PRODUCT |
381 |
||
1 | 382 |
extern "C" void blob(CodeBlob* cb) { |
383 |
Command c("blob"); |
|
384 |
cb->print(); |
|
385 |
} |
|
386 |
||
387 |
||
388 |
extern "C" void dump_vtable(address p) { |
|
389 |
Command c("dump_vtable"); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
390 |
Klass* k = (Klass*)p; |
46408
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
42650
diff
changeset
|
391 |
k->vtable().print(); |
1 | 392 |
} |
393 |
||
394 |
||
395 |
extern "C" void nm(intptr_t p) { |
|
396 |
// Actually we look through all CodeBlobs (the nm name has been kept for backwards compatability) |
|
397 |
Command c("nm"); |
|
398 |
CodeBlob* cb = CodeCache::find_blob((address)p); |
|
399 |
if (cb == NULL) { |
|
400 |
tty->print_cr("NULL"); |
|
401 |
} else { |
|
402 |
cb->print(); |
|
403 |
} |
|
404 |
} |
|
405 |
||
406 |
||
407 |
extern "C" void disnm(intptr_t p) { |
|
408 |
Command c("disnm"); |
|
409 |
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
|
410 |
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
|
411 |
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
|
412 |
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
|
413 |
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
|
414 |
} 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
|
415 |
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
|
416 |
} |
7433 | 417 |
Disassembler::decode(cb); |
418 |
} |
|
1 | 419 |
} |
420 |
||
421 |
||
422 |
extern "C" void printnm(intptr_t p) { |
|
423 |
char buffer[256]; |
|
424 |
sprintf(buffer, "printnm: " INTPTR_FORMAT, p); |
|
425 |
Command c(buffer); |
|
426 |
CodeBlob* cb = CodeCache::find_blob((address) p); |
|
427 |
if (cb->is_nmethod()) { |
|
428 |
nmethod* nm = (nmethod*)cb; |
|
429 |
nm->print_nmethod(true); |
|
430 |
} |
|
431 |
} |
|
432 |
||
433 |
||
434 |
extern "C" void universe() { |
|
435 |
Command c("universe"); |
|
35061 | 436 |
Universe::print_on(tty); |
1 | 437 |
} |
438 |
||
439 |
||
440 |
extern "C" void verify() { |
|
441 |
// try to run a verify on the entire system |
|
442 |
// note: this may not be safe if we're not at a safepoint; for debugging, |
|
443 |
// this manipulates the safepoint settings to avoid assertion failures |
|
444 |
Command c("universe verify"); |
|
445 |
bool safe = SafepointSynchronize::is_at_safepoint(); |
|
446 |
if (!safe) { |
|
447 |
tty->print_cr("warning: not at safepoint -- verify may fail"); |
|
448 |
SafepointSynchronize::set_is_at_safepoint(); |
|
449 |
} |
|
450 |
// Ensure Eden top is correct before verification |
|
451 |
Universe::heap()->prepare_for_verify(); |
|
14076
84643cfaeaa8
8000831: Heap verification output incorrect/incomplete
johnc
parents:
13761
diff
changeset
|
452 |
Universe::verify(); |
1 | 453 |
if (!safe) SafepointSynchronize::set_is_not_at_safepoint(); |
454 |
} |
|
455 |
||
456 |
||
457 |
extern "C" void pp(void* p) { |
|
458 |
Command c("pp"); |
|
459 |
FlagSetting fl(PrintVMMessages, true); |
|
9437
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
460 |
FlagSetting f2(DisplayVMOutput, true); |
1 | 461 |
if (Universe::heap()->is_in(p)) { |
462 |
oop obj = oop(p); |
|
463 |
obj->print(); |
|
464 |
} else { |
|
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33135
diff
changeset
|
465 |
tty->print(PTR_FORMAT, p2i(p)); |
1 | 466 |
} |
467 |
} |
|
468 |
||
469 |
||
470 |
// pv: print vm-printable object |
|
471 |
extern "C" void pa(intptr_t p) { ((AllocatedObj*) p)->print(); } |
|
472 |
extern "C" void findpc(intptr_t x); |
|
473 |
||
10739 | 474 |
#endif // !PRODUCT |
475 |
||
1 | 476 |
extern "C" void ps() { // print stack |
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34144
diff
changeset
|
477 |
if (Thread::current_or_null() == NULL) return; |
1 | 478 |
Command c("ps"); |
479 |
||
480 |
||
481 |
// Prints the stack of the current Java thread |
|
482 |
JavaThread* p = JavaThread::active(); |
|
483 |
tty->print(" for thread: "); |
|
484 |
p->print(); |
|
485 |
tty->cr(); |
|
486 |
||
487 |
if (p->has_last_Java_frame()) { |
|
488 |
// If the last_Java_fp is set we are in C land and |
|
489 |
// can call the standard stack_trace function. |
|
10739 | 490 |
#ifdef PRODUCT |
491 |
p->print_stack(); |
|
492 |
} else { |
|
493 |
tty->print_cr("Cannot find the last Java frame, printing stack disabled."); |
|
494 |
#else // !PRODUCT |
|
1 | 495 |
p->trace_stack(); |
496 |
} else { |
|
497 |
frame f = os::current_frame(); |
|
498 |
RegisterMap reg_map(p); |
|
499 |
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
|
500 |
tty->print("(guessing starting frame id=" PTR_FORMAT " based on current fp)\n", p2i(f.id())); |
1 | 501 |
p->trace_stack_from(vframe::new_vframe(&f, ®_map, p)); |
46589 | 502 |
f.pd_ps(); |
10739 | 503 |
#endif // PRODUCT |
1 | 504 |
} |
505 |
||
506 |
} |
|
507 |
||
9437
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
508 |
extern "C" void pfl() { |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
509 |
// print frame layout |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
510 |
Command c("pfl"); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
511 |
JavaThread* p = JavaThread::active(); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
512 |
tty->print(" for thread: "); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
513 |
p->print(); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
514 |
tty->cr(); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
515 |
if (p->has_last_Java_frame()) { |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
516 |
p->print_frame_layout(); |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
517 |
} |
9981851b4b8c
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
8921
diff
changeset
|
518 |
} |
1 | 519 |
|
10739 | 520 |
#ifndef PRODUCT |
521 |
||
1 | 522 |
extern "C" void psf() { // print stack frames |
523 |
{ |
|
524 |
Command c("psf"); |
|
525 |
JavaThread* p = JavaThread::active(); |
|
526 |
tty->print(" for thread: "); |
|
527 |
p->print(); |
|
528 |
tty->cr(); |
|
529 |
if (p->has_last_Java_frame()) { |
|
530 |
p->trace_frames(); |
|
531 |
} |
|
532 |
} |
|
533 |
} |
|
534 |
||
535 |
||
536 |
extern "C" void threads() { |
|
537 |
Command c("threads"); |
|
538 |
Threads::print(false, true); |
|
539 |
} |
|
540 |
||
541 |
||
542 |
extern "C" void psd() { |
|
543 |
Command c("psd"); |
|
544 |
SystemDictionary::print(); |
|
545 |
} |
|
546 |
||
10739 | 547 |
#endif // !PRODUCT |
1 | 548 |
|
549 |
extern "C" void pss() { // print all stacks |
|
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34144
diff
changeset
|
550 |
if (Thread::current_or_null() == NULL) return; |
1 | 551 |
Command c("pss"); |
10739 | 552 |
Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true)); |
1 | 553 |
} |
554 |
||
10739 | 555 |
#ifndef PRODUCT |
1 | 556 |
|
557 |
extern "C" void debug() { // to set things up for compiler debugging |
|
558 |
Command c("debug"); |
|
559 |
WizardMode = true; |
|
560 |
PrintVMMessages = PrintCompilation = true; |
|
561 |
PrintInlining = PrintAssembly = true; |
|
562 |
tty->flush(); |
|
563 |
} |
|
564 |
||
565 |
||
566 |
extern "C" void ndebug() { // undo debug() |
|
567 |
Command c("ndebug"); |
|
568 |
PrintCompilation = false; |
|
569 |
PrintInlining = PrintAssembly = false; |
|
570 |
tty->flush(); |
|
571 |
} |
|
572 |
||
573 |
||
574 |
extern "C" void flush() { |
|
575 |
Command c("flush"); |
|
576 |
tty->flush(); |
|
577 |
} |
|
578 |
||
11788 | 579 |
extern "C" void events() { |
580 |
Command c("events"); |
|
581 |
Events::print(); |
|
582 |
} |
|
1 | 583 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
584 |
extern "C" Method* findm(intptr_t pc) { |
1 | 585 |
Command c("findm"); |
586 |
nmethod* nm = CodeCache::find_nmethod((address)pc); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
587 |
return (nm == NULL) ? (Method*)NULL : nm->method(); |
1 | 588 |
} |
589 |
||
590 |
||
591 |
extern "C" nmethod* findnm(intptr_t addr) { |
|
592 |
Command c("findnm"); |
|
593 |
return CodeCache::find_nmethod((address)addr); |
|
594 |
} |
|
595 |
||
596 |
// Another interface that isn't ambiguous in dbx. |
|
597 |
// Can we someday rename the other find to hsfind? |
|
598 |
extern "C" void hsfind(intptr_t x) { |
|
599 |
Command c("hsfind"); |
|
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
600 |
os::print_location(tty, x, false); |
1 | 601 |
} |
602 |
||
603 |
||
604 |
extern "C" void find(intptr_t x) { |
|
605 |
Command c("find"); |
|
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
606 |
os::print_location(tty, x, false); |
1 | 607 |
} |
608 |
||
609 |
||
610 |
extern "C" void findpc(intptr_t x) { |
|
611 |
Command c("findpc"); |
|
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
612 |
os::print_location(tty, x, true); |
1 | 613 |
} |
614 |
||
615 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
616 |
// 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
|
617 |
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
|
618 |
Command c("findbcp"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
619 |
Method* mh = (Method*)method; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
620 |
if (!mh->is_native()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
621 |
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
|
622 |
mh, mh->bci_from(address(bcp))); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
623 |
mh->print_codes_on(tty); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
624 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
625 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13393
diff
changeset
|
626 |
|
1 | 627 |
// int versions of all methods to avoid having to type type casts in the debugger |
628 |
||
629 |
void pp(intptr_t p) { pp((void*)p); } |
|
630 |
void pp(oop p) { pp((void*)p); } |
|
631 |
||
632 |
void help() { |
|
633 |
Command c("help"); |
|
634 |
tty->print_cr("basic"); |
|
635 |
tty->print_cr(" pp(void* p) - try to make sense of p"); |
|
636 |
tty->print_cr(" pv(intptr_t p)- ((PrintableResourceObj*) p)->print()"); |
|
637 |
tty->print_cr(" ps() - print current thread stack"); |
|
638 |
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
|
639 |
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
|
640 |
tty->print_cr(" findm(intptr_t pc) - finds Method*"); |
1 | 641 |
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
|
642 |
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
|
643 |
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
|
644 |
tty->print_cr(" pns($sp, $ebp, $pc) on Linux/x86 or"); |
59049
dc1899bb84c0
8231841: AArch64: debug.cpp help() is missing an AArch64 line for pns
smonteith
parents:
55653
diff
changeset
|
645 |
tty->print_cr(" pns($sp, $fp, $pc) on Linux/AArch64 or"); |
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
|
646 |
tty->print_cr(" pns($sp, 0, $pc) on Linux/ppc64 or"); |
53932 | 647 |
tty->print_cr(" pns($sp, $s8, $pc) on Linux/mips or"); |
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
|
648 |
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
|
649 |
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
|
650 |
tty->print_cr(" - in dbx do 'frame 1' before calling pns()"); |
1 | 651 |
|
652 |
tty->print_cr("misc."); |
|
653 |
tty->print_cr(" flush() - flushes the log file"); |
|
11788 | 654 |
tty->print_cr(" events() - dump events from ring buffers"); |
1 | 655 |
|
656 |
||
657 |
tty->print_cr("compiler debugging"); |
|
658 |
tty->print_cr(" debug() - to set things up for compiler debugging"); |
|
659 |
tty->print_cr(" ndebug() - undo debug"); |
|
660 |
} |
|
661 |
||
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
|
662 |
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
|
663 |
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
|
664 |
static char buf[O_BUFLEN]; |
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34144
diff
changeset
|
665 |
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
|
666 |
// 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
|
667 |
frame fr(sp, fp, pc); |
46560
388aa8d67c80
8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents:
46408
diff
changeset
|
668 |
VMError::print_native_stack(tty, fr, t, buf, sizeof(buf)); |
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
|
669 |
} |
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
|
670 |
|
47891
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
671 |
// |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
672 |
// This version of pns() will not work when called from the debugger, but is |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
673 |
// useful when called from within hotspot code. The advantages over pns() |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
674 |
// are not having to pass in any arguments, and it will work on Windows/x64. |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
675 |
// |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
676 |
// WARNING: Only intended for use when debugging. Do not leave calls to |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
677 |
// pns2() in committed source (product or debug). |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
678 |
// |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
679 |
extern "C" void pns2() { // print native stack |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
680 |
Command c("pns2"); |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
681 |
static char buf[O_BUFLEN]; |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
682 |
if (os::platform_print_native_stack(tty, NULL, buf, sizeof(buf))) { |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
683 |
// We have printed the native stack in platform-specific code, |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
684 |
// so nothing else to do in this case. |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
685 |
} else { |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
686 |
Thread* t = Thread::current_or_null(); |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
687 |
frame fr = os::current_frame(); |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
688 |
VMError::print_native_stack(tty, fr, t, buf, sizeof(buf)); |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
689 |
} |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
690 |
} |
fa736014cf28
8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents:
47765
diff
changeset
|
691 |
|
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
|
692 |
#endif // !PRODUCT |
31340
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
693 |
|
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
694 |
////////////////////////////////////////////////////////////////////////////// |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
695 |
// Test multiple STATIC_ASSERT forms in various scopes. |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
696 |
|
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
697 |
#ifndef PRODUCT |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
698 |
|
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
699 |
// namespace scope |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
700 |
STATIC_ASSERT(true); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
701 |
STATIC_ASSERT(true); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
702 |
STATIC_ASSERT(1 == 1); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
703 |
STATIC_ASSERT(0 == 0); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
704 |
|
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
705 |
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
|
706 |
STATIC_ASSERT(true); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
707 |
STATIC_ASSERT(true); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
708 |
STATIC_ASSERT(0 == 0); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
709 |
STATIC_ASSERT(1 == 1); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
710 |
} |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
711 |
|
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
712 |
// class scope |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
713 |
struct TestMultipleStaticAssertFormsInClassScope { |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
714 |
STATIC_ASSERT(true); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
715 |
STATIC_ASSERT(true); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
716 |
STATIC_ASSERT(0 == 0); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
717 |
STATIC_ASSERT(1 == 1); |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
718 |
}; |
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
719 |
|
2f9ff278bb13
8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents:
30764
diff
changeset
|
720 |
#endif // !PRODUCT |
49653
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
721 |
|
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
722 |
// Support for showing register content on asserts/guarantees. |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
723 |
#ifdef CAN_SHOW_REGISTERS_ON_ASSERT |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
724 |
|
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
725 |
static ucontext_t g_stored_assertion_context; |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
726 |
|
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
727 |
void initialize_assert_poison() { |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
728 |
char* page = os::reserve_memory(os::vm_page_size()); |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
729 |
if (page) { |
53659
da5dc7e654aa
8218566: NMT: missing memory tag for assert poison page
zgu
parents:
53599
diff
changeset
|
730 |
MemTracker::record_virtual_memory_type(page, mtInternal); |
49653
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
731 |
if (os::commit_memory(page, os::vm_page_size(), false) && |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
732 |
os::protect_memory(page, os::vm_page_size(), os::MEM_PROT_NONE)) { |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
733 |
g_assert_poison = page; |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
734 |
} |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
735 |
} |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
736 |
} |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
737 |
|
55653
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
53932
diff
changeset
|
738 |
void disarm_assert_poison() { |
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
53932
diff
changeset
|
739 |
g_assert_poison = &g_dummy; |
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
53932
diff
changeset
|
740 |
} |
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
53932
diff
changeset
|
741 |
|
50734 | 742 |
static void store_context(const void* context) { |
743 |
memcpy(&g_stored_assertion_context, context, sizeof(ucontext_t)); |
|
49653
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
744 |
#if defined(__linux) && defined(PPC64) |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
745 |
// on Linux ppc64, ucontext_t contains pointers into itself which have to be patched up |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
746 |
// after copying the context (see comment in sys/ucontext.h): |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
747 |
*((void**) &g_stored_assertion_context.uc_mcontext.regs) = &(g_stored_assertion_context.uc_mcontext.gp_regs); |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
748 |
#endif |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
749 |
} |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
750 |
|
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
751 |
bool handle_assert_poison_fault(const void* ucVoid, const void* faulting_address) { |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
752 |
if (faulting_address == g_assert_poison) { |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
753 |
// Disarm poison page. |
55653
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
53932
diff
changeset
|
754 |
if (os::protect_memory((char*)g_assert_poison, os::vm_page_size(), os::MEM_PROT_RWX) == false) { |
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
53932
diff
changeset
|
755 |
#ifdef ASSERT |
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
53932
diff
changeset
|
756 |
fprintf(stderr, "Assertion poison page cannot be unprotected - mprotect failed with %d (%s)", |
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
53932
diff
changeset
|
757 |
errno, os::strerror(errno)); |
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
53932
diff
changeset
|
758 |
fflush(stderr); |
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
53932
diff
changeset
|
759 |
#endif |
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
53932
diff
changeset
|
760 |
return false; // unprotecting memory may fail in OOM situations, as surprising as this sounds. |
3243c42d737d
8227275: Within native OOM error handling, assertions may hang the process
stuefe
parents:
53932
diff
changeset
|
761 |
} |
49653
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
762 |
// Store Context away. |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
763 |
if (ucVoid) { |
49671
015af70b9a1d
8200608: Build failures after JDK-8191101 (Show register content in hs-err file on assert)
shade
parents:
49653
diff
changeset
|
764 |
const intx my_tid = os::current_thread_id(); |
59252
623722a6aeb9
8234740: Harmonize parameter order in Atomic - cmpxchg
stefank
parents:
59049
diff
changeset
|
765 |
if (Atomic::cmpxchg(&g_asserting_thread, (intx)0, my_tid) == 0) { |
50734 | 766 |
store_context(ucVoid); |
767 |
g_assertion_context = &g_stored_assertion_context; |
|
49653
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
768 |
} |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
769 |
} |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
770 |
return true; |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
771 |
} |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
772 |
return false; |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
773 |
} |
a569cb4425f3
8191101: Show register content in hs-err file on assert
stuefe
parents:
49480
diff
changeset
|
774 |
#endif // CAN_SHOW_REGISTERS_ON_ASSERT |