Mercurial > hg > truffle
annotate src/share/vm/utilities/debug.cpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | 145ffab733e7 |
| children | 4202510ee0fe |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4006
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 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" | |
| 42 #include "runtime/frame.hpp" | |
| 43 #include "runtime/java.hpp" | |
| 44 #include "runtime/sharedRuntime.hpp" | |
| 45 #include "runtime/stubCodeGenerator.hpp" | |
| 46 #include "runtime/stubRoutines.hpp" | |
| 47 #include "runtime/vframe.hpp" | |
| 48 #include "services/heapDumper.hpp" | |
| 49 #include "utilities/defaultStream.hpp" | |
| 50 #include "utilities/events.hpp" | |
| 51 #include "utilities/top.hpp" | |
| 52 #include "utilities/vmError.hpp" | |
| 53 #ifdef TARGET_OS_FAMILY_linux | |
| 54 # include "os_linux.inline.hpp" | |
| 55 # include "thread_linux.inline.hpp" | |
| 56 #endif | |
| 57 #ifdef TARGET_OS_FAMILY_solaris | |
| 58 # include "os_solaris.inline.hpp" | |
| 59 # include "thread_solaris.inline.hpp" | |
| 60 #endif | |
| 61 #ifdef TARGET_OS_FAMILY_windows | |
| 62 # include "os_windows.inline.hpp" | |
| 63 # include "thread_windows.inline.hpp" | |
| 64 #endif | |
| 3960 | 65 #ifdef TARGET_OS_FAMILY_bsd |
| 66 # include "os_bsd.inline.hpp" | |
| 67 # include "thread_bsd.inline.hpp" | |
| 68 #endif | |
| 0 | 69 |
| 70 #ifndef ASSERT | |
| 71 # ifdef _DEBUG | |
| 72 // NOTE: don't turn the lines below into a comment -- if you're getting | |
| 73 // a compile error here, change the settings to define ASSERT | |
| 74 ASSERT should be defined when _DEBUG is defined. It is not intended to be used for debugging | |
| 75 functions that do not slow down the system too much and thus can be left in optimized code. | |
| 76 On the other hand, the code should not be included in a production version. | |
| 77 # endif // _DEBUG | |
| 78 #endif // ASSERT | |
| 79 | |
| 80 | |
| 81 #ifdef _DEBUG | |
| 82 # ifndef ASSERT | |
| 83 configuration error: ASSERT must be defined in debug version | |
| 84 # endif // ASSERT | |
| 85 #endif // _DEBUG | |
| 86 | |
| 87 | |
| 88 #ifdef PRODUCT | |
| 89 # if -defined _DEBUG || -defined ASSERT | |
| 90 configuration error: ASSERT et al. must not be defined in PRODUCT version | |
| 91 # endif | |
| 92 #endif // PRODUCT | |
| 93 | |
|
6268
6c5b7a6becc8
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
4944
diff
changeset
|
94 FormatBufferResource::FormatBufferResource(const char * format, ...) |
|
6c5b7a6becc8
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
4944
diff
changeset
|
95 : FormatBufferBase((char*)resource_allocate_bytes(RES_BUFSZ)) { |
|
6c5b7a6becc8
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
4944
diff
changeset
|
96 va_list argp; |
|
6c5b7a6becc8
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
4944
diff
changeset
|
97 va_start(argp, format); |
|
6c5b7a6becc8
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
4944
diff
changeset
|
98 jio_vsnprintf(_buf, RES_BUFSZ, format, argp); |
|
6c5b7a6becc8
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
4944
diff
changeset
|
99 va_end(argp); |
|
6c5b7a6becc8
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
4944
diff
changeset
|
100 } |
| 0 | 101 |
| 102 void warning(const char* format, ...) { | |
|
1870
c77b5c592eab
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
1775
diff
changeset
|
103 if (PrintWarnings) { |
| 6759 | 104 FILE* const err = defaultStream::error_stream(); |
| 105 jio_fprintf(err, "%s warning: ", VM_Version::vm_name()); | |
|
1870
c77b5c592eab
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
1775
diff
changeset
|
106 va_list ap; |
|
c77b5c592eab
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
1775
diff
changeset
|
107 va_start(ap, format); |
| 6759 | 108 vfprintf(err, format, ap); |
|
1870
c77b5c592eab
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
1775
diff
changeset
|
109 va_end(ap); |
| 6759 | 110 fputc('\n', err); |
|
1870
c77b5c592eab
6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents:
1775
diff
changeset
|
111 } |
| 0 | 112 if (BreakAtWarning) BREAKPOINT; |
| 113 } | |
| 114 | |
| 115 #ifndef PRODUCT | |
| 116 | |
| 117 #define is_token_break(ch) (isspace(ch) || (ch) == ',') | |
| 118 | |
| 119 static const char* last_file_name = NULL; | |
| 120 static int last_line_no = -1; | |
| 121 | |
| 122 // assert/guarantee/... may happen very early during VM initialization. | |
| 123 // Don't rely on anything that is initialized by Threads::create_vm(). For | |
| 124 // example, don't use tty. | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
125 bool error_is_suppressed(const char* file_name, int line_no) { |
| 0 | 126 // The following 1-element cache requires that passed-in |
| 127 // file names are always only constant literals. | |
| 128 if (file_name == last_file_name && line_no == last_line_no) return true; | |
| 129 | |
| 130 int file_name_len = (int)strlen(file_name); | |
| 131 char separator = os::file_separator()[0]; | |
| 132 const char* base_name = strrchr(file_name, separator); | |
| 133 if (base_name == NULL) | |
| 134 base_name = file_name; | |
| 135 | |
| 136 // scan the SuppressErrorAt option | |
| 137 const char* cp = SuppressErrorAt; | |
| 138 for (;;) { | |
| 139 const char* sfile; | |
| 140 int sfile_len; | |
| 141 int sline; | |
| 142 bool noisy; | |
| 143 while ((*cp) != '\0' && is_token_break(*cp)) cp++; | |
| 144 if ((*cp) == '\0') break; | |
| 145 sfile = cp; | |
| 146 while ((*cp) != '\0' && !is_token_break(*cp) && (*cp) != ':') cp++; | |
| 147 sfile_len = cp - sfile; | |
| 148 if ((*cp) == ':') cp++; | |
| 149 sline = 0; | |
| 150 while ((*cp) != '\0' && isdigit(*cp)) { | |
| 151 sline *= 10; | |
| 152 sline += (*cp) - '0'; | |
| 153 cp++; | |
| 154 } | |
| 155 // "file:line!" means the assert suppression is not silent | |
| 156 noisy = ((*cp) == '!'); | |
| 157 while ((*cp) != '\0' && !is_token_break(*cp)) cp++; | |
| 158 // match the line | |
| 159 if (sline != 0) { | |
| 160 if (sline != line_no) continue; | |
| 161 } | |
| 162 // match the file | |
| 163 if (sfile_len > 0) { | |
| 164 const char* look = file_name; | |
| 165 const char* look_max = file_name + file_name_len - sfile_len; | |
| 166 const char* foundp; | |
| 167 bool match = false; | |
| 168 while (!match | |
| 169 && (foundp = strchr(look, sfile[0])) != NULL | |
| 170 && foundp <= look_max) { | |
| 171 match = true; | |
| 172 for (int i = 1; i < sfile_len; i++) { | |
| 173 if (sfile[i] != foundp[i]) { | |
| 174 match = false; | |
| 175 break; | |
| 176 } | |
| 177 } | |
| 178 look = foundp + 1; | |
| 179 } | |
| 180 if (!match) continue; | |
| 181 } | |
| 182 // got a match! | |
| 183 if (noisy) { | |
| 184 fdStream out(defaultStream::output_fd()); | |
| 185 out.print_raw("[error suppressed at "); | |
| 186 out.print_raw(base_name); | |
| 187 char buf[16]; | |
| 188 jio_snprintf(buf, sizeof(buf), ":%d]", line_no); | |
| 189 out.print_raw_cr(buf); | |
| 190 } else { | |
| 191 // update 1-element cache for fast silent matches | |
| 192 last_file_name = file_name; | |
| 193 last_line_no = line_no; | |
| 194 } | |
| 195 return true; | |
| 196 } | |
| 197 | |
| 198 if (!is_error_reported()) { | |
| 199 // print a friendly hint: | |
| 200 fdStream out(defaultStream::output_fd()); | |
| 201 out.print_raw_cr("# To suppress the following error report, specify this argument"); | |
| 202 out.print_raw ("# after -XX: or in .hotspotrc: SuppressErrorAt="); | |
| 203 out.print_raw (base_name); | |
| 204 char buf[16]; | |
| 205 jio_snprintf(buf, sizeof(buf), ":%d", line_no); | |
| 206 out.print_raw_cr(buf); | |
| 207 } | |
| 208 return false; | |
| 209 } | |
| 210 | |
| 211 #undef is_token_break | |
| 212 | |
| 213 #else | |
| 214 | |
| 215 // Place-holder for non-existent suppression check: | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
216 #define error_is_suppressed(file_name, line_no) (false) |
| 0 | 217 |
| 4006 | 218 #endif // !PRODUCT |
| 0 | 219 |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
220 void report_vm_error(const char* file, int line, const char* error_msg, |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
221 const char* detail_msg) |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
222 { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
223 if (Debugging || error_is_suppressed(file, line)) return; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
224 Thread* const thread = ThreadLocalStorage::get_thread_slow(); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
225 VMError err(thread, file, line, error_msg, detail_msg); |
| 0 | 226 err.report_and_die(); |
| 227 } | |
| 228 | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
229 void report_fatal(const char* file, int line, const char* message) |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
230 { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
231 report_vm_error(file, line, "fatal error", message); |
| 0 | 232 } |
| 233 | |
| 234 // Used by report_vm_out_of_memory to detect recursion. | |
| 235 static jint _exiting_out_of_mem = 0; | |
| 236 | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
237 void report_vm_out_of_memory(const char* file, int line, size_t size, |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
238 const char* message) { |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2008
diff
changeset
|
239 if (Debugging) return; |
| 0 | 240 |
| 241 // We try to gather additional information for the first out of memory | |
| 242 // error only; gathering additional data might cause an allocation and a | |
| 243 // recursive out_of_memory condition. | |
| 244 | |
| 245 const jint exiting = 1; | |
| 246 // If we succeed in changing the value, we're the first one in. | |
| 247 bool first_time_here = Atomic::xchg(exiting, &_exiting_out_of_mem) != exiting; | |
| 248 | |
| 249 if (first_time_here) { | |
| 250 Thread* thread = ThreadLocalStorage::get_thread_slow(); | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
251 VMError(thread, file, line, size, message).report_and_die(); |
| 0 | 252 } |
|
227
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
113
diff
changeset
|
253 |
|
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
113
diff
changeset
|
254 // Dump core and abort |
|
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
113
diff
changeset
|
255 vm_abort(true); |
| 0 | 256 } |
| 257 | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
258 void report_should_not_call(const char* file, int line) { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
259 report_vm_error(file, line, "ShouldNotCall()"); |
| 0 | 260 } |
| 261 | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
262 void report_should_not_reach_here(const char* file, int line) { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
263 report_vm_error(file, line, "ShouldNotReachHere()"); |
| 0 | 264 } |
| 265 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
266 void report_should_not_reach_here2(const char* file, int line, const char* message) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
267 report_vm_error(file, line, "ShouldNotReachHere()", message); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
268 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
269 |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
270 void report_unimplemented(const char* file, int line) { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
271 report_vm_error(file, line, "Unimplemented()"); |
| 0 | 272 } |
| 273 | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
274 void report_untested(const char* file, int line, const char* message) { |
| 0 | 275 #ifndef PRODUCT |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
276 warning("Untested: %s in %s: %d\n", message, file, line); |
| 4006 | 277 #endif // !PRODUCT |
| 0 | 278 } |
| 279 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
280 void report_out_of_shared_space(SharedSpaceType shared_space) { |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
281 static const char* name[] = { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
282 "native memory for metadata", |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
283 "shared read only space", |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
284 "shared read write space", |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
285 "shared miscellaneous data space" |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
286 }; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
287 static const char* flag[] = { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
288 "Metaspace", |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
289 "SharedReadOnlySize", |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
290 "SharedReadWriteSize", |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
291 "SharedMiscDataSize" |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
292 }; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
293 |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
294 warning("\nThe %s is not large enough\n" |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
295 "to preload requested classes. Use -XX:%s=\n" |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
296 "to increase the initial size of %s.\n", |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
297 name[shared_space], flag[shared_space], name[shared_space]); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
298 exit(2); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
299 } |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2095
diff
changeset
|
300 |
| 0 | 301 void report_java_out_of_memory(const char* message) { |
| 302 static jint out_of_memory_reported = 0; | |
| 303 | |
| 304 // A number of threads may attempt to report OutOfMemoryError at around the | |
| 305 // same time. To avoid dumping the heap or executing the data collection | |
| 306 // commands multiple times we just do it once when the first threads reports | |
| 307 // the error. | |
| 308 if (Atomic::cmpxchg(1, &out_of_memory_reported, 0) == 0) { | |
| 309 // create heap dump before OnOutOfMemoryError commands are executed | |
| 310 if (HeapDumpOnOutOfMemoryError) { | |
| 311 tty->print_cr("java.lang.OutOfMemoryError: %s", message); | |
|
1775
30f67acf635d
6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents:
1681
diff
changeset
|
312 HeapDumper::dump_heap_from_oome(); |
| 0 | 313 } |
| 314 | |
| 315 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { | |
| 316 VMError err(message); | |
| 317 err.report_java_out_of_memory(); | |
| 318 } | |
| 319 } | |
| 320 } | |
| 321 | |
| 322 static bool error_reported = false; | |
| 323 | |
| 324 // call this when the VM is dying--it might loosen some asserts | |
| 325 void set_error_reported() { | |
| 326 error_reported = true; | |
| 327 } | |
| 328 | |
| 329 bool is_error_reported() { | |
| 330 return error_reported; | |
| 331 } | |
| 332 | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
333 #ifndef PRODUCT |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
334 #include <signal.h> |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
335 |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
336 void test_error_handler(size_t test_num) |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
337 { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
338 if (test_num == 0) return; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
339 |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
340 // If asserts are disabled, use the corresponding guarantee instead. |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
341 size_t n = test_num; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
342 NOT_DEBUG(if (n <= 2) n += 2); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
343 |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
344 const char* const str = "hello"; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
345 const size_t num = (size_t)os::vm_page_size(); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
346 |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
347 const char* const eol = os::line_separator(); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
348 const char* const msg = "this message should be truncated during formatting"; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
349 |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
350 // Keep this in sync with test/runtime/6888954/vmerrors.sh. |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
351 switch (n) { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
352 case 1: assert(str == NULL, "expected null"); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
353 case 2: assert(num == 1023 && *str == 'X', |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
354 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str)); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
355 case 3: guarantee(str == NULL, "expected null"); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
356 case 4: guarantee(num == 1023 && *str == 'X', |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
357 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str)); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
358 case 5: fatal("expected null"); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
359 case 6: fatal(err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str)); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
360 case 7: fatal(err_msg("%s%s# %s%s# %s%s# %s%s# %s%s# " |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
361 "%s%s# %s%s# %s%s# %s%s# %s%s# " |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
362 "%s%s# %s%s# %s%s# %s%s# %s", |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
363 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
364 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
365 msg, eol, msg, eol, msg, eol, msg, eol, msg)); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
366 case 8: vm_exit_out_of_memory(num, "ChunkPool::allocate"); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
367 case 9: ShouldNotCallThis(); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
368 case 10: ShouldNotReachHere(); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
369 case 11: Unimplemented(); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
370 // This is last because it does not generate an hs_err* file on Windows. |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
371 case 12: os::signal_raise(SIGSEGV); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
372 |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
373 default: ShouldNotReachHere(); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
374 } |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
375 } |
| 4006 | 376 #endif // !PRODUCT |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
989
diff
changeset
|
377 |
| 0 | 378 // ------ helper functions for debugging go here ------------ |
| 379 | |
| 380 // All debug entries should be wrapped with a stack allocated | |
| 381 // Command object. It makes sure a resource mark is set and | |
| 382 // flushes the logfile to prevent file sharing problems. | |
| 383 | |
| 384 class Command : public StackObj { | |
| 385 private: | |
| 386 ResourceMark rm; | |
| 387 ResetNoHandleMark rnhm; | |
| 388 HandleMark hm; | |
| 389 bool debug_save; | |
| 390 public: | |
| 391 static int level; | |
| 392 Command(const char* str) { | |
| 393 debug_save = Debugging; | |
| 394 Debugging = true; | |
| 395 if (level++ > 0) return; | |
| 396 tty->cr(); | |
| 397 tty->print_cr("\"Executing %s\"", str); | |
| 398 } | |
| 399 | |
| 4006 | 400 ~Command() { |
| 401 tty->flush(); | |
| 402 Debugging = debug_save; | |
| 403 level--; | |
| 404 } | |
| 0 | 405 }; |
| 406 | |
| 407 int Command::level = 0; | |
| 408 | |
| 4006 | 409 #ifndef PRODUCT |
| 410 | |
| 0 | 411 extern "C" void blob(CodeBlob* cb) { |
| 412 Command c("blob"); | |
| 413 cb->print(); | |
| 414 } | |
| 415 | |
| 416 | |
| 417 extern "C" void dump_vtable(address p) { | |
| 418 Command c("dump_vtable"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
419 Klass* k = (Klass*)p; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
420 InstanceKlass::cast(k)->vtable()->print(); |
| 0 | 421 } |
| 422 | |
| 423 | |
| 424 extern "C" void nm(intptr_t p) { | |
| 425 // Actually we look through all CodeBlobs (the nm name has been kept for backwards compatability) | |
| 426 Command c("nm"); | |
| 427 CodeBlob* cb = CodeCache::find_blob((address)p); | |
| 428 if (cb == NULL) { | |
| 429 tty->print_cr("NULL"); | |
| 430 } else { | |
| 431 cb->print(); | |
| 432 } | |
| 433 } | |
| 434 | |
| 435 | |
| 436 extern "C" void disnm(intptr_t p) { | |
| 437 Command c("disnm"); | |
| 438 CodeBlob* cb = CodeCache::find_blob((address) p); | |
| 2008 | 439 nmethod* nm = cb->as_nmethod_or_null(); |
| 440 if (nm) { | |
| 441 nm->print(); | |
| 442 Disassembler::decode(nm); | |
| 443 } else { | |
| 444 cb->print(); | |
| 445 Disassembler::decode(cb); | |
| 446 } | |
| 0 | 447 } |
| 448 | |
| 449 | |
| 450 extern "C" void printnm(intptr_t p) { | |
| 451 char buffer[256]; | |
| 452 sprintf(buffer, "printnm: " INTPTR_FORMAT, p); | |
| 453 Command c(buffer); | |
| 454 CodeBlob* cb = CodeCache::find_blob((address) p); | |
| 455 if (cb->is_nmethod()) { | |
| 456 nmethod* nm = (nmethod*)cb; | |
| 457 nm->print_nmethod(true); | |
| 458 } | |
| 459 } | |
| 460 | |
| 461 | |
| 462 extern "C" void universe() { | |
| 463 Command c("universe"); | |
| 464 Universe::print(); | |
| 465 } | |
| 466 | |
| 467 | |
| 468 extern "C" void verify() { | |
| 469 // try to run a verify on the entire system | |
| 470 // note: this may not be safe if we're not at a safepoint; for debugging, | |
| 471 // this manipulates the safepoint settings to avoid assertion failures | |
| 472 Command c("universe verify"); | |
| 473 bool safe = SafepointSynchronize::is_at_safepoint(); | |
| 474 if (!safe) { | |
| 475 tty->print_cr("warning: not at safepoint -- verify may fail"); | |
| 476 SafepointSynchronize::set_is_at_safepoint(); | |
| 477 } | |
| 478 // Ensure Eden top is correct before verification | |
| 479 Universe::heap()->prepare_for_verify(); | |
| 480 Universe::verify(true); | |
| 481 if (!safe) SafepointSynchronize::set_is_not_at_safepoint(); | |
| 482 } | |
| 483 | |
| 484 | |
| 485 extern "C" void pp(void* p) { | |
| 486 Command c("pp"); | |
| 487 FlagSetting fl(PrintVMMessages, true); | |
|
3336
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
488 FlagSetting f2(DisplayVMOutput, true); |
| 0 | 489 if (Universe::heap()->is_in(p)) { |
| 490 oop obj = oop(p); | |
| 491 obj->print(); | |
| 492 } else { | |
| 4006 | 493 tty->print(PTR_FORMAT, p); |
| 0 | 494 } |
| 495 } | |
| 496 | |
| 497 | |
| 498 // pv: print vm-printable object | |
| 499 extern "C" void pa(intptr_t p) { ((AllocatedObj*) p)->print(); } | |
| 500 extern "C" void findpc(intptr_t x); | |
| 501 | |
| 4006 | 502 #endif // !PRODUCT |
| 503 | |
| 0 | 504 extern "C" void ps() { // print stack |
| 4006 | 505 if (Thread::current() == NULL) return; |
| 0 | 506 Command c("ps"); |
| 507 | |
| 508 | |
| 509 // Prints the stack of the current Java thread | |
| 510 JavaThread* p = JavaThread::active(); | |
| 511 tty->print(" for thread: "); | |
| 512 p->print(); | |
| 513 tty->cr(); | |
| 514 | |
| 515 if (p->has_last_Java_frame()) { | |
| 516 // If the last_Java_fp is set we are in C land and | |
| 517 // can call the standard stack_trace function. | |
| 4006 | 518 #ifdef PRODUCT |
| 519 p->print_stack(); | |
| 520 } else { | |
| 521 tty->print_cr("Cannot find the last Java frame, printing stack disabled."); | |
| 522 #else // !PRODUCT | |
| 0 | 523 p->trace_stack(); |
| 524 } else { | |
| 525 frame f = os::current_frame(); | |
| 526 RegisterMap reg_map(p); | |
| 527 f = f.sender(®_map); | |
| 528 tty->print("(guessing starting frame id=%#p based on current fp)\n", f.id()); | |
| 529 p->trace_stack_from(vframe::new_vframe(&f, ®_map, p)); | |
| 530 pd_ps(f); | |
| 4006 | 531 #endif // PRODUCT |
| 0 | 532 } |
| 533 | |
| 534 } | |
| 535 | |
|
3336
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
536 extern "C" void pfl() { |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
537 // print frame layout |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
538 Command c("pfl"); |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
539 JavaThread* p = JavaThread::active(); |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
540 tty->print(" for thread: "); |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
541 p->print(); |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
542 tty->cr(); |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
543 if (p->has_last_Java_frame()) { |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
544 p->print_frame_layout(); |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
545 } |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
546 } |
| 0 | 547 |
| 4006 | 548 #ifndef PRODUCT |
| 549 | |
| 0 | 550 extern "C" void psf() { // print stack frames |
| 551 { | |
| 552 Command c("psf"); | |
| 553 JavaThread* p = JavaThread::active(); | |
| 554 tty->print(" for thread: "); | |
| 555 p->print(); | |
| 556 tty->cr(); | |
| 557 if (p->has_last_Java_frame()) { | |
| 558 p->trace_frames(); | |
| 559 } | |
| 560 } | |
| 561 } | |
| 562 | |
| 563 | |
| 564 extern "C" void threads() { | |
| 565 Command c("threads"); | |
| 566 Threads::print(false, true); | |
| 567 } | |
| 568 | |
| 569 | |
| 570 extern "C" void psd() { | |
| 571 Command c("psd"); | |
| 572 SystemDictionary::print(); | |
| 573 } | |
| 574 | |
| 575 | |
| 576 extern "C" void safepoints() { | |
| 577 Command c("safepoints"); | |
| 578 SafepointSynchronize::print_state(); | |
| 579 } | |
| 580 | |
| 4006 | 581 #endif // !PRODUCT |
| 0 | 582 |
| 583 extern "C" void pss() { // print all stacks | |
| 4006 | 584 if (Thread::current() == NULL) return; |
| 0 | 585 Command c("pss"); |
| 4006 | 586 Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true)); |
| 0 | 587 } |
| 588 | |
| 4006 | 589 #ifndef PRODUCT |
| 0 | 590 |
| 591 extern "C" void debug() { // to set things up for compiler debugging | |
| 592 Command c("debug"); | |
| 593 WizardMode = true; | |
| 594 PrintVMMessages = PrintCompilation = true; | |
| 595 PrintInlining = PrintAssembly = true; | |
| 596 tty->flush(); | |
| 597 } | |
| 598 | |
| 599 | |
| 600 extern "C" void ndebug() { // undo debug() | |
| 601 Command c("ndebug"); | |
| 602 PrintCompilation = false; | |
| 603 PrintInlining = PrintAssembly = false; | |
| 604 tty->flush(); | |
| 605 } | |
| 606 | |
| 607 | |
| 608 extern "C" void flush() { | |
| 609 Command c("flush"); | |
| 610 tty->flush(); | |
| 611 } | |
| 612 | |
| 4944 | 613 extern "C" void events() { |
| 614 Command c("events"); | |
| 615 Events::print(); | |
| 616 } | |
| 0 | 617 |
| 618 // Given a heap address that was valid before the most recent GC, if | |
| 619 // the oop that used to contain it is still live, prints the new | |
| 620 // location of the oop and the address. Useful for tracking down | |
| 621 // certain kinds of naked oop and oop map bugs. | |
| 622 extern "C" void pnl(intptr_t old_heap_addr) { | |
| 623 // Print New Location of old heap address | |
| 624 Command c("pnl"); | |
| 625 #ifndef VALIDATE_MARK_SWEEP | |
| 626 tty->print_cr("Requires build with VALIDATE_MARK_SWEEP defined (debug build) and RecordMarkSweepCompaction enabled"); | |
| 627 #else | |
| 628 MarkSweep::print_new_location_of_heap_address((HeapWord*) old_heap_addr); | |
| 629 #endif | |
| 630 } | |
| 631 | |
| 632 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
633 extern "C" Method* findm(intptr_t pc) { |
| 0 | 634 Command c("findm"); |
| 635 nmethod* nm = CodeCache::find_nmethod((address)pc); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
636 return (nm == NULL) ? (Method*)NULL : nm->method(); |
| 0 | 637 } |
| 638 | |
| 639 | |
| 640 extern "C" nmethod* findnm(intptr_t addr) { | |
| 641 Command c("findnm"); | |
| 642 return CodeCache::find_nmethod((address)addr); | |
| 643 } | |
| 644 | |
| 645 static address same_page(address x, address y) { | |
| 646 intptr_t page_bits = -os::vm_page_size(); | |
| 647 if ((intptr_t(x) & page_bits) == (intptr_t(y) & page_bits)) { | |
| 648 return x; | |
| 649 } else if (x > y) { | |
| 650 return (address)(intptr_t(y) | ~page_bits) + 1; | |
| 651 } else { | |
| 652 return (address)(intptr_t(y) & page_bits); | |
| 653 } | |
| 654 } | |
| 655 | |
| 656 | |
| 657 // Another interface that isn't ambiguous in dbx. | |
| 658 // Can we someday rename the other find to hsfind? | |
| 659 extern "C" void hsfind(intptr_t x) { | |
| 660 Command c("hsfind"); | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
661 os::print_location(tty, x, false); |
| 0 | 662 } |
| 663 | |
| 664 | |
| 665 extern "C" void find(intptr_t x) { | |
| 666 Command c("find"); | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
667 os::print_location(tty, x, false); |
| 0 | 668 } |
| 669 | |
| 670 | |
| 671 extern "C" void findpc(intptr_t x) { | |
| 672 Command c("findpc"); | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
673 os::print_location(tty, x, true); |
| 0 | 674 } |
| 675 | |
| 676 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
677 // Need method pointer to find bcp, when not in permgen. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
678 extern "C" void findbcp(intptr_t method, intptr_t bcp) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
679 Command c("findbcp"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
680 Method* mh = (Method*)method; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
681 if (!mh->is_native()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
682 tty->print_cr("bci_from(%p) = %d; print_codes():", |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
683 mh, mh->bci_from(address(bcp))); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
684 mh->print_codes_on(tty); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
685 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
686 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
687 |
| 0 | 688 // int versions of all methods to avoid having to type type casts in the debugger |
| 689 | |
| 690 void pp(intptr_t p) { pp((void*)p); } | |
| 691 void pp(oop p) { pp((void*)p); } | |
| 692 | |
| 693 void help() { | |
| 694 Command c("help"); | |
| 695 tty->print_cr("basic"); | |
| 696 tty->print_cr(" pp(void* p) - try to make sense of p"); | |
| 697 tty->print_cr(" pv(intptr_t p)- ((PrintableResourceObj*) p)->print()"); | |
| 698 tty->print_cr(" ps() - print current thread stack"); | |
| 699 tty->print_cr(" pss() - print all thread stacks"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
700 tty->print_cr(" pm(int pc) - print Method* given compiled PC"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
701 tty->print_cr(" findm(intptr_t pc) - finds Method*"); |
| 0 | 702 tty->print_cr(" find(intptr_t x) - finds & prints nmethod/stub/bytecode/oop based on pointer into it"); |
| 703 | |
| 704 tty->print_cr("misc."); | |
| 705 tty->print_cr(" flush() - flushes the log file"); | |
| 4944 | 706 tty->print_cr(" events() - dump events from ring buffers"); |
| 0 | 707 |
| 708 | |
| 709 tty->print_cr("compiler debugging"); | |
| 710 tty->print_cr(" debug() - to set things up for compiler debugging"); | |
| 711 tty->print_cr(" ndebug() - undo debug"); | |
| 712 } | |
| 713 | |
| 714 #if 0 | |
| 715 | |
| 716 // BobV's command parser for debugging on windows when nothing else works. | |
| 717 | |
| 718 enum CommandID { | |
| 719 CMDID_HELP, | |
| 720 CMDID_QUIT, | |
| 721 CMDID_HSFIND, | |
| 722 CMDID_PSS, | |
| 723 CMDID_PS, | |
| 724 CMDID_PSF, | |
| 725 CMDID_FINDM, | |
| 726 CMDID_FINDNM, | |
| 727 CMDID_PP, | |
| 728 CMDID_BPT, | |
| 729 CMDID_EXIT, | |
| 730 CMDID_VERIFY, | |
| 731 CMDID_THREADS, | |
| 732 CMDID_ILLEGAL = 99 | |
| 733 }; | |
| 734 | |
| 735 struct CommandParser { | |
| 736 char *name; | |
| 737 CommandID code; | |
| 738 char *description; | |
| 739 }; | |
| 740 | |
| 741 struct CommandParser CommandList[] = { | |
| 742 (char *)"help", CMDID_HELP, " Dump this list", | |
| 743 (char *)"quit", CMDID_QUIT, " Return from this routine", | |
| 744 (char *)"hsfind", CMDID_HSFIND, "Perform an hsfind on an address", | |
| 745 (char *)"ps", CMDID_PS, " Print Current Thread Stack Trace", | |
| 746 (char *)"pss", CMDID_PSS, " Print All Thread Stack Trace", | |
| 747 (char *)"psf", CMDID_PSF, " Print All Stack Frames", | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
748 (char *)"findm", CMDID_FINDM, " Find a Method* from a PC", |
| 0 | 749 (char *)"findnm", CMDID_FINDNM, "Find an nmethod from a PC", |
| 750 (char *)"pp", CMDID_PP, " Find out something about a pointer", | |
| 751 (char *)"break", CMDID_BPT, " Execute a breakpoint", | |
| 752 (char *)"exitvm", CMDID_EXIT, "Exit the VM", | |
| 753 (char *)"verify", CMDID_VERIFY, "Perform a Heap Verify", | |
| 754 (char *)"thread", CMDID_THREADS, "Dump Info on all Threads", | |
| 755 (char *)0, CMDID_ILLEGAL | |
| 756 }; | |
| 757 | |
| 758 | |
| 759 // get_debug_command() | |
| 760 // | |
| 761 // Read a command from standard input. | |
| 762 // This is useful when you have a debugger | |
| 763 // which doesn't support calling into functions. | |
| 764 // | |
| 765 void get_debug_command() | |
| 766 { | |
| 767 ssize_t count; | |
| 768 int i,j; | |
| 769 bool gotcommand; | |
| 770 intptr_t addr; | |
| 771 char buffer[256]; | |
| 772 nmethod *nm; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
773 Method* m; |
| 0 | 774 |
| 775 tty->print_cr("You have entered the diagnostic command interpreter"); | |
| 776 tty->print("The supported commands are:\n"); | |
| 777 for ( i=0; ; i++ ) { | |
| 778 if ( CommandList[i].code == CMDID_ILLEGAL ) | |
| 779 break; | |
| 780 tty->print_cr(" %s \n", CommandList[i].name ); | |
| 781 } | |
| 782 | |
| 783 while ( 1 ) { | |
| 784 gotcommand = false; | |
| 785 tty->print("Please enter a command: "); | |
| 786 count = scanf("%s", buffer) ; | |
| 787 if ( count >=0 ) { | |
| 788 for ( i=0; ; i++ ) { | |
| 789 if ( CommandList[i].code == CMDID_ILLEGAL ) { | |
| 790 if (!gotcommand) tty->print("Invalid command, please try again\n"); | |
| 791 break; | |
| 792 } | |
| 793 if ( strcmp(buffer, CommandList[i].name) == 0 ) { | |
| 794 gotcommand = true; | |
| 795 switch ( CommandList[i].code ) { | |
| 796 case CMDID_PS: | |
| 797 ps(); | |
| 798 break; | |
| 799 case CMDID_PSS: | |
| 800 pss(); | |
| 801 break; | |
| 802 case CMDID_PSF: | |
| 803 psf(); | |
| 804 break; | |
| 805 case CMDID_FINDM: | |
| 806 tty->print("Please enter the hex addr to pass to findm: "); | |
| 807 scanf("%I64X", &addr); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
808 m = (Method*)findm(addr); |
| 0 | 809 tty->print("findm(0x%I64X) returned 0x%I64X\n", addr, m); |
| 810 break; | |
| 811 case CMDID_FINDNM: | |
| 812 tty->print("Please enter the hex addr to pass to findnm: "); | |
| 813 scanf("%I64X", &addr); | |
| 814 nm = (nmethod*)findnm(addr); | |
| 815 tty->print("findnm(0x%I64X) returned 0x%I64X\n", addr, nm); | |
| 816 break; | |
| 817 case CMDID_PP: | |
| 818 tty->print("Please enter the hex addr to pass to pp: "); | |
| 819 scanf("%I64X", &addr); | |
| 820 pp((void*)addr); | |
| 821 break; | |
| 822 case CMDID_EXIT: | |
| 823 exit(0); | |
| 824 case CMDID_HELP: | |
| 825 tty->print("Here are the supported commands: "); | |
| 826 for ( j=0; ; j++ ) { | |
| 827 if ( CommandList[j].code == CMDID_ILLEGAL ) | |
| 828 break; | |
| 829 tty->print_cr(" %s -- %s\n", CommandList[j].name, | |
| 830 CommandList[j].description ); | |
| 831 } | |
| 832 break; | |
| 833 case CMDID_QUIT: | |
| 834 return; | |
| 835 break; | |
| 836 case CMDID_BPT: | |
| 837 BREAKPOINT; | |
| 838 break; | |
| 839 case CMDID_VERIFY: | |
| 840 verify();; | |
| 841 break; | |
| 842 case CMDID_THREADS: | |
| 843 threads();; | |
| 844 break; | |
| 845 case CMDID_HSFIND: | |
| 846 tty->print("Please enter the hex addr to pass to hsfind: "); | |
| 847 scanf("%I64X", &addr); | |
| 848 tty->print("Calling hsfind(0x%I64X)\n", addr); | |
| 849 hsfind(addr); | |
| 850 break; | |
| 851 default: | |
| 852 case CMDID_ILLEGAL: | |
| 853 break; | |
| 854 } | |
| 855 } | |
| 856 } | |
| 857 } | |
| 858 } | |
| 859 } | |
| 860 #endif | |
| 861 | |
| 4006 | 862 #endif // !PRODUCT |