Mon, 15 Oct 2012 10:02:42 -0700
8000831: Heap verification output incorrect/incomplete
Summary: Restore non-silent output of heap verification.
Reviewed-by: ysr, brutisso, jmasa
1 /*
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
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
65 #ifdef TARGET_OS_FAMILY_bsd
66 # include "os_bsd.inline.hpp"
67 # include "thread_bsd.inline.hpp"
68 #endif
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
81 #ifdef _DEBUG
82 # ifndef ASSERT
83 configuration error: ASSERT must be defined in debug version
84 # endif // ASSERT
85 #endif // _DEBUG
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
94 FormatBufferResource::FormatBufferResource(const char * format, ...)
95 : FormatBufferBase((char*)resource_allocate_bytes(RES_BUFSZ)) {
96 va_list argp;
97 va_start(argp, format);
98 jio_vsnprintf(_buf, RES_BUFSZ, format, argp);
99 va_end(argp);
100 }
102 void warning(const char* format, ...) {
103 if (PrintWarnings) {
104 FILE* const err = defaultStream::error_stream();
105 jio_fprintf(err, "%s warning: ", VM_Version::vm_name());
106 va_list ap;
107 va_start(ap, format);
108 vfprintf(err, format, ap);
109 va_end(ap);
110 fputc('\n', err);
111 }
112 if (BreakAtWarning) BREAKPOINT;
113 }
115 #ifndef PRODUCT
117 #define is_token_break(ch) (isspace(ch) || (ch) == ',')
119 static const char* last_file_name = NULL;
120 static int last_line_no = -1;
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.
125 bool error_is_suppressed(const char* file_name, int line_no) {
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;
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;
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 }
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 }
211 #undef is_token_break
213 #else
215 // Place-holder for non-existent suppression check:
216 #define error_is_suppressed(file_name, line_no) (false)
218 #endif // !PRODUCT
220 void report_vm_error(const char* file, int line, const char* error_msg,
221 const char* detail_msg)
222 {
223 if (Debugging || error_is_suppressed(file, line)) return;
224 Thread* const thread = ThreadLocalStorage::get_thread_slow();
225 VMError err(thread, file, line, error_msg, detail_msg);
226 err.report_and_die();
227 }
229 void report_fatal(const char* file, int line, const char* message)
230 {
231 report_vm_error(file, line, "fatal error", message);
232 }
234 // Used by report_vm_out_of_memory to detect recursion.
235 static jint _exiting_out_of_mem = 0;
237 void report_vm_out_of_memory(const char* file, int line, size_t size,
238 const char* message) {
239 if (Debugging) return;
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.
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;
249 if (first_time_here) {
250 Thread* thread = ThreadLocalStorage::get_thread_slow();
251 VMError(thread, file, line, size, message).report_and_die();
252 }
254 // Dump core and abort
255 vm_abort(true);
256 }
258 void report_should_not_call(const char* file, int line) {
259 report_vm_error(file, line, "ShouldNotCall()");
260 }
262 void report_should_not_reach_here(const char* file, int line) {
263 report_vm_error(file, line, "ShouldNotReachHere()");
264 }
266 void report_should_not_reach_here2(const char* file, int line, const char* message) {
267 report_vm_error(file, line, "ShouldNotReachHere()", message);
268 }
270 void report_unimplemented(const char* file, int line) {
271 report_vm_error(file, line, "Unimplemented()");
272 }
274 void report_untested(const char* file, int line, const char* message) {
275 #ifndef PRODUCT
276 warning("Untested: %s in %s: %d\n", message, file, line);
277 #endif // !PRODUCT
278 }
280 void report_out_of_shared_space(SharedSpaceType shared_space) {
281 static const char* name[] = {
282 "native memory for metadata",
283 "shared read only space",
284 "shared read write space",
285 "shared miscellaneous data space"
286 };
287 static const char* flag[] = {
288 "Metaspace",
289 "SharedReadOnlySize",
290 "SharedReadWriteSize",
291 "SharedMiscDataSize"
292 };
294 warning("\nThe %s is not large enough\n"
295 "to preload requested classes. Use -XX:%s=\n"
296 "to increase the initial size of %s.\n",
297 name[shared_space], flag[shared_space], name[shared_space]);
298 exit(2);
299 }
301 void report_java_out_of_memory(const char* message) {
302 static jint out_of_memory_reported = 0;
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);
312 HeapDumper::dump_heap_from_oome();
313 }
315 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
316 VMError err(message);
317 err.report_java_out_of_memory();
318 }
319 }
320 }
322 static bool error_reported = false;
324 // call this when the VM is dying--it might loosen some asserts
325 void set_error_reported() {
326 error_reported = true;
327 }
329 bool is_error_reported() {
330 return error_reported;
331 }
333 #ifndef PRODUCT
334 #include <signal.h>
336 void test_error_handler(size_t test_num)
337 {
338 if (test_num == 0) return;
340 // If asserts are disabled, use the corresponding guarantee instead.
341 size_t n = test_num;
342 NOT_DEBUG(if (n <= 2) n += 2);
344 const char* const str = "hello";
345 const size_t num = (size_t)os::vm_page_size();
347 const char* const eol = os::line_separator();
348 const char* const msg = "this message should be truncated during formatting";
350 // Keep this in sync with test/runtime/6888954/vmerrors.sh.
351 switch (n) {
352 case 1: assert(str == NULL, "expected null");
353 case 2: assert(num == 1023 && *str == 'X',
354 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
355 case 3: guarantee(str == NULL, "expected null");
356 case 4: guarantee(num == 1023 && *str == 'X',
357 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
358 case 5: fatal("expected null");
359 case 6: fatal(err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
360 case 7: fatal(err_msg("%s%s# %s%s# %s%s# %s%s# %s%s# "
361 "%s%s# %s%s# %s%s# %s%s# %s%s# "
362 "%s%s# %s%s# %s%s# %s%s# %s",
363 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
364 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
365 msg, eol, msg, eol, msg, eol, msg, eol, msg));
366 case 8: vm_exit_out_of_memory(num, "ChunkPool::allocate");
367 case 9: ShouldNotCallThis();
368 case 10: ShouldNotReachHere();
369 case 11: Unimplemented();
370 // This is last because it does not generate an hs_err* file on Windows.
371 case 12: os::signal_raise(SIGSEGV);
373 default: ShouldNotReachHere();
374 }
375 }
376 #endif // !PRODUCT
378 // ------ helper functions for debugging go here ------------
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.
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 }
400 ~Command() {
401 tty->flush();
402 Debugging = debug_save;
403 level--;
404 }
405 };
407 int Command::level = 0;
409 #ifndef PRODUCT
411 extern "C" void blob(CodeBlob* cb) {
412 Command c("blob");
413 cb->print();
414 }
417 extern "C" void dump_vtable(address p) {
418 Command c("dump_vtable");
419 Klass* k = (Klass*)p;
420 InstanceKlass::cast(k)->vtable()->print();
421 }
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 }
436 extern "C" void disnm(intptr_t p) {
437 Command c("disnm");
438 CodeBlob* cb = CodeCache::find_blob((address) p);
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 }
447 }
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 }
462 extern "C" void universe() {
463 Command c("universe");
464 Universe::print();
465 }
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();
481 if (!safe) SafepointSynchronize::set_is_not_at_safepoint();
482 }
485 extern "C" void pp(void* p) {
486 Command c("pp");
487 FlagSetting fl(PrintVMMessages, true);
488 FlagSetting f2(DisplayVMOutput, true);
489 if (Universe::heap()->is_in(p)) {
490 oop obj = oop(p);
491 obj->print();
492 } else {
493 tty->print(PTR_FORMAT, p);
494 }
495 }
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);
502 #endif // !PRODUCT
504 extern "C" void ps() { // print stack
505 if (Thread::current() == NULL) return;
506 Command c("ps");
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();
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.
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
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);
531 #endif // PRODUCT
532 }
534 }
536 extern "C" void pfl() {
537 // print frame layout
538 Command c("pfl");
539 JavaThread* p = JavaThread::active();
540 tty->print(" for thread: ");
541 p->print();
542 tty->cr();
543 if (p->has_last_Java_frame()) {
544 p->print_frame_layout();
545 }
546 }
548 #ifndef PRODUCT
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 }
564 extern "C" void threads() {
565 Command c("threads");
566 Threads::print(false, true);
567 }
570 extern "C" void psd() {
571 Command c("psd");
572 SystemDictionary::print();
573 }
576 extern "C" void safepoints() {
577 Command c("safepoints");
578 SafepointSynchronize::print_state();
579 }
581 #endif // !PRODUCT
583 extern "C" void pss() { // print all stacks
584 if (Thread::current() == NULL) return;
585 Command c("pss");
586 Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true));
587 }
589 #ifndef PRODUCT
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 }
600 extern "C" void ndebug() { // undo debug()
601 Command c("ndebug");
602 PrintCompilation = false;
603 PrintInlining = PrintAssembly = false;
604 tty->flush();
605 }
608 extern "C" void flush() {
609 Command c("flush");
610 tty->flush();
611 }
613 extern "C" void events() {
614 Command c("events");
615 Events::print();
616 }
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 }
633 extern "C" Method* findm(intptr_t pc) {
634 Command c("findm");
635 nmethod* nm = CodeCache::find_nmethod((address)pc);
636 return (nm == NULL) ? (Method*)NULL : nm->method();
637 }
640 extern "C" nmethod* findnm(intptr_t addr) {
641 Command c("findnm");
642 return CodeCache::find_nmethod((address)addr);
643 }
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 }
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");
661 os::print_location(tty, x, false);
662 }
665 extern "C" void find(intptr_t x) {
666 Command c("find");
667 os::print_location(tty, x, false);
668 }
671 extern "C" void findpc(intptr_t x) {
672 Command c("findpc");
673 os::print_location(tty, x, true);
674 }
677 // Need method pointer to find bcp, when not in permgen.
678 extern "C" void findbcp(intptr_t method, intptr_t bcp) {
679 Command c("findbcp");
680 Method* mh = (Method*)method;
681 if (!mh->is_native()) {
682 tty->print_cr("bci_from(%p) = %d; print_codes():",
683 mh, mh->bci_from(address(bcp)));
684 mh->print_codes_on(tty);
685 }
686 }
688 // int versions of all methods to avoid having to type type casts in the debugger
690 void pp(intptr_t p) { pp((void*)p); }
691 void pp(oop p) { pp((void*)p); }
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");
700 tty->print_cr(" pm(int pc) - print Method* given compiled PC");
701 tty->print_cr(" findm(intptr_t pc) - finds Method*");
702 tty->print_cr(" find(intptr_t x) - finds & prints nmethod/stub/bytecode/oop based on pointer into it");
704 tty->print_cr("misc.");
705 tty->print_cr(" flush() - flushes the log file");
706 tty->print_cr(" events() - dump events from ring buffers");
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 }
714 #if 0
716 // BobV's command parser for debugging on windows when nothing else works.
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 };
735 struct CommandParser {
736 char *name;
737 CommandID code;
738 char *description;
739 };
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",
748 (char *)"findm", CMDID_FINDM, " Find a Method* from a PC",
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 };
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;
773 Method* m;
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 }
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);
808 m = (Method*)findm(addr);
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
862 #endif // !PRODUCT