1 /*
2 * Copyright (c) 1997, 2015, 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 */
24
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_interface/collectedHeap.hpp"
34 #include "interpreter/bytecodeHistogram.hpp"
35 #include "interpreter/interpreter.hpp"
36 #include "memory/resourceArea.hpp"
37 #include "memory/universe.hpp"
38 #include "oops/oop.inline.hpp"
39 #include "prims/privilegedStack.hpp"
40 #include "runtime/arguments.hpp"
41 #include "runtime/atomic.inline.hpp"
42 #include "runtime/frame.hpp"
43 #include "runtime/java.hpp"
44 #include "runtime/os.hpp"
45 #include "runtime/sharedRuntime.hpp"
46 #include "runtime/stubCodeGenerator.hpp"
47 #include "runtime/stubRoutines.hpp"
48 #include "runtime/thread.inline.hpp"
49 #include "runtime/vframe.hpp"
50 #include "runtime/vm_version.hpp"
51 #include "services/heapDumper.hpp"
52 #include "utilities/defaultStream.hpp"
53 #include "utilities/events.hpp"
54 #include "utilities/top.hpp"
55 #include "utilities/vmError.hpp"
56
57 #ifndef ASSERT
58 # ifdef _DEBUG
59 // NOTE: don't turn the lines below into a comment -- if you're getting
60 // a compile error here, change the settings to define ASSERT
61 ASSERT should be defined when _DEBUG is defined. It is not intended to be used for debugging
62 functions that do not slow down the system too much and thus can be left in optimized code.
63 On the other hand, the code should not be included in a production version.
64 # endif // _DEBUG
65 #endif // ASSERT
66
67
68 #ifdef _DEBUG
69 # ifndef ASSERT
70 configuration error: ASSERT must be defined in debug version
71 # endif // ASSERT
72 #endif // _DEBUG
73
74
75 #ifdef PRODUCT
76 # if -defined _DEBUG || -defined ASSERT
77 configuration error: ASSERT et al. must not be defined in PRODUCT version
78 # endif
79 #endif // PRODUCT
80
81 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
82
83 FormatBufferResource::FormatBufferResource(const char * format, ...)
84 : FormatBufferBase((char*)resource_allocate_bytes(RES_BUFSZ)) {
85 va_list argp;
86 va_start(argp, format);
87 jio_vsnprintf(_buf, RES_BUFSZ, format, argp);
88 va_end(argp);
89 }
90
91 ATTRIBUTE_PRINTF(1, 2)
92 void warning(const char* format, ...) {
93 if (PrintWarnings) {
94 FILE* const err = defaultStream::error_stream();
95 jio_fprintf(err, "%s warning: ", VM_Version::vm_name());
96 va_list ap;
97 va_start(ap, format);
98 vfprintf(err, format, ap);
99 va_end(ap);
100 fputc('\n', err);
101 }
102 if (BreakAtWarning) BREAKPOINT;
103 }
104
105 #ifndef PRODUCT
106
107 #define is_token_break(ch) (isspace(ch) || (ch) == ',')
108
109 static const char* last_file_name = NULL;
110 static int last_line_no = -1;
111
112 // assert/guarantee/... may happen very early during VM initialization.
113 // Don't rely on anything that is initialized by Threads::create_vm(). For
114 // example, don't use tty.
115 bool error_is_suppressed(const char* file_name, int line_no) {
116 // The following 1-element cache requires that passed-in
117 // file names are always only constant literals.
118 if (file_name == last_file_name && line_no == last_line_no) return true;
119
120 int file_name_len = (int)strlen(file_name);
121 char separator = os::file_separator()[0];
122 const char* base_name = strrchr(file_name, separator);
123 if (base_name == NULL)
124 base_name = file_name;
125
126 // scan the SuppressErrorAt option
127 const char* cp = SuppressErrorAt;
128 for (;;) {
129 const char* sfile;
130 int sfile_len;
131 int sline;
132 bool noisy;
133 while ((*cp) != '\0' && is_token_break(*cp)) cp++;
134 if ((*cp) == '\0') break;
135 sfile = cp;
136 while ((*cp) != '\0' && !is_token_break(*cp) && (*cp) != ':') cp++;
137 sfile_len = cp - sfile;
138 if ((*cp) == ':') cp++;
139 sline = 0;
140 while ((*cp) != '\0' && isdigit(*cp)) {
141 sline *= 10;
142 sline += (*cp) - '0';
143 cp++;
144 }
145 // "file:line!" means the assert suppression is not silent
146 noisy = ((*cp) == '!');
147 while ((*cp) != '\0' && !is_token_break(*cp)) cp++;
148 // match the line
149 if (sline != 0) {
150 if (sline != line_no) continue;
151 }
152 // match the file
153 if (sfile_len > 0) {
154 const char* look = file_name;
155 const char* look_max = file_name + file_name_len - sfile_len;
156 const char* foundp;
157 bool match = false;
158 while (!match
159 && (foundp = strchr(look, sfile[0])) != NULL
160 && foundp <= look_max) {
161 match = true;
162 for (int i = 1; i < sfile_len; i++) {
163 if (sfile[i] != foundp[i]) {
164 match = false;
165 break;
166 }
167 }
168 look = foundp + 1;
169 }
170 if (!match) continue;
171 }
172 // got a match!
173 if (noisy) {
174 fdStream out(defaultStream::output_fd());
175 out.print_raw("[error suppressed at ");
176 out.print_raw(base_name);
177 char buf[16];
178 jio_snprintf(buf, sizeof(buf), ":%d]", line_no);
179 out.print_raw_cr(buf);
180 } else {
181 // update 1-element cache for fast silent matches
182 last_file_name = file_name;
183 last_line_no = line_no;
184 }
185 return true;
186 }
187
188 if (!is_error_reported()) {
189 // print a friendly hint:
190 fdStream out(defaultStream::output_fd());
191 out.print_raw_cr("# To suppress the following error report, specify this argument");
192 out.print_raw ("# after -XX: or in .hotspotrc: SuppressErrorAt=");
193 out.print_raw (base_name);
194 char buf[16];
195 jio_snprintf(buf, sizeof(buf), ":%d", line_no);
196 out.print_raw_cr(buf);
197 }
198 return false;
199 }
200
201 #undef is_token_break
202
203 #else
204
205 // Place-holder for non-existent suppression check:
206 #define error_is_suppressed(file_name, line_no) (false)
207
208 #endif // !PRODUCT
209
210 // A function that never returns. Tells the compilers
211 // that the control flow stops at the call of this function.
212 ATTRIBUTE_NORETURN static void noreturn_function() {
213 while (true) {
214 os::naked_short_sleep(10);
215 }
216 }
217
218 void report_vm_error(const char* file, int line, const char* error_msg,
219 const char* detail_msg)
220 {
221 if (!Debugging && !error_is_suppressed(file, line)) {
222 Thread* const thread = ThreadLocalStorage::get_thread_slow();
223 VMError err(thread, file, line, error_msg, detail_msg);
224 err.report_and_die();
225 }
226 BREAKPOINT;
227 }
228
229 void report_vm_out_of_memory(const char* file, int line, size_t size,
230 VMErrorType vm_err_type, const char* message) {
231 if (!Debugging) {
232 Thread* const thread = ThreadLocalStorage::get_thread_slow();
233 VMError err(thread, file, line, size, vm_err_type, message);
234 err.report_and_die();
235 }
236 BREAKPOINT;
237 noreturn_function();
238 }
239
240 void report_vm_error_noreturn(const char* file, int line, const char* error_msg,
241 const char* detail_msg)
242 {
243 report_vm_error(file, line, error_msg, detail_msg);
244 noreturn_function();
245 }
246
247 void report_fatal(const char* file, int line, const char* message)
248 {
249 report_vm_error_noreturn(file, line, "fatal error", message);
250 }
251
252
253 void report_should_not_call(const char* file, int line) {
254 report_vm_error_noreturn(file, line, "ShouldNotCall()");
255 }
256
257 void report_should_not_reach_here(const char* file, int line) {
258 report_vm_error_noreturn(file, line, "ShouldNotReachHere()");
259 }
260
261 void report_unimplemented(const char* file, int line) {
262 report_vm_error(file, line, "Unimplemented()");
263 }
264
265 void report_untested(const char* file, int line, const char* message) {
266 #ifndef PRODUCT
267 warning("Untested: %s in %s: %d\n", message, file, line);
268 #endif // !PRODUCT
269 }
270
271 void report_out_of_shared_space(SharedSpaceType shared_space) {
272 static const char* name[] = {
273 "shared read only space",
274 "shared read write space",
275 "shared miscellaneous data space",
276 "shared miscellaneous code space"
277 };
278 static const char* flag[] = {
279 "SharedReadOnlySize",
280 "SharedReadWriteSize",
281 "SharedMiscDataSize",
282 "SharedMiscCodeSize"
283 };
284
285 warning("\nThe %s is not large enough\n"
286 "to preload requested classes. Use -XX:%s=<size>\n"
287 "to increase the initial size of %s.\n",
288 name[shared_space], flag[shared_space], name[shared_space]);
289 exit(2);
290 }
291
292 void report_insufficient_metaspace(size_t required_size) {
293 warning("\nThe MaxMetaspaceSize of " SIZE_FORMAT " bytes is not large enough.\n"
294 "Either don't specify the -XX:MaxMetaspaceSize=<size>\n"
295 "or increase the size to at least " SIZE_FORMAT ".\n",
296 MaxMetaspaceSize, required_size);
297 exit(2);
298 }
299
300 void report_java_out_of_memory(const char* message) {
301 static jint out_of_memory_reported = 0;
302
303 // A number of threads may attempt to report OutOfMemoryError at around the
304 // same time. To avoid dumping the heap or executing the data collection
305 // commands multiple times we just do it once when the first threads reports
306 // the error.
307 if (Atomic::cmpxchg(1, &out_of_memory_reported, 0) == 0) {
308 // create heap dump before OnOutOfMemoryError commands are executed
309 if (HeapDumpOnOutOfMemoryError) {
310 tty->print_cr("java.lang.OutOfMemoryError: %s", message);
311 HeapDumper::dump_heap_from_oome();
312 }
313
314 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
315 VMError err(message);
316 err.report_java_out_of_memory();
317 }
318 }
319 }
320
321 static bool error_reported = false;
322
323 // call this when the VM is dying--it might loosen some asserts
324 void set_error_reported() {
325 error_reported = true;
326 }
327
328 bool is_error_reported() {
329 return error_reported;
330 }
331
332 #ifndef PRODUCT
333 #include <signal.h>
334
335 typedef void (*voidfun_t)();
336 // Crash with an authentic sigfpe
337 static void crash_with_sigfpe() {
338 // generate a native synchronous SIGFPE where possible;
339 // if that did not cause a signal (e.g. on ppc), just
340 // raise the signal.
341 volatile int x = 0;
342 volatile int y = 1/x;
343 #ifndef _WIN32
344 raise(SIGFPE);
345 #endif
346 } // end: crash_with_sigfpe
347
348 // crash with sigsegv at non-null address.
349 static void crash_with_segfault() {
350
351 char* const crash_addr = (char*) get_segfault_address();
352 *crash_addr = 'X';
353
354 } // end: crash_with_segfault
355
356 // returns an address which is guaranteed to generate a SIGSEGV on read,
357 // for test purposes, which is not NULL and contains bits in every word
358 void* get_segfault_address() {
359 return (void*)
360 #ifdef _LP64
361 0xABC0000000000ABCULL;
362 #else
363 0x00000ABC;
364 #endif
365 }
366
367 void test_error_handler() {
368 controlled_crash(ErrorHandlerTest);
369 }
370
371 void controlled_crash(int how) {
372 if (how == 0) return;
373
374 // If asserts are disabled, use the corresponding guarantee instead.
375 NOT_DEBUG(if (how <= 2) how += 2);
376
377 const char* const str = "hello";
378 const size_t num = (size_t)os::vm_page_size();
379
380 const char* const eol = os::line_separator();
381 const char* const msg = "this message should be truncated during formatting";
382 char * const dataPtr = NULL; // bad data pointer
383 const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer
384
385 // Keep this in sync with test/runtime/6888954/vmerrors.sh.
386 switch (how) {
387 case 1: vmassert(str == NULL, "expected null");
388 case 2: vmassert(num == 1023 && *str == 'X',
389 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
390 case 3: guarantee(str == NULL, "expected null");
391 case 4: guarantee(num == 1023 && *str == 'X',
392 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
393 case 5: fatal("expected null");
394 case 6: fatal(err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
395 case 7: fatal(err_msg("%s%s# %s%s# %s%s# %s%s# %s%s# "
396 "%s%s# %s%s# %s%s# %s%s# %s%s# "
397 "%s%s# %s%s# %s%s# %s%s# %s",
398 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
399 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
400 msg, eol, msg, eol, msg, eol, msg, eol, msg));
401 case 8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate");
402 case 9: ShouldNotCallThis();
403 case 10: ShouldNotReachHere();
404 case 11: Unimplemented();
405 // There's no guarantee the bad data pointer will crash us
406 // so "break" out to the ShouldNotReachHere().
407 case 12: *dataPtr = '\0'; break;
408 // There's no guarantee the bad function pointer will crash us
409 // so "break" out to the ShouldNotReachHere().
410 case 13: (*funcPtr)(); break;
411 case 14: crash_with_segfault(); break;
412 case 15: crash_with_sigfpe(); break;
413
414 default: tty->print_cr("ERROR: %d: unexpected test_num value.", how);
415 }
416 ShouldNotReachHere();
417 }
418 #endif // !PRODUCT
419
420 // ------ helper functions for debugging go here ------------
421
422 // All debug entries should be wrapped with a stack allocated
423 // Command object. It makes sure a resource mark is set and
424 // flushes the logfile to prevent file sharing problems.
425
426 class Command : public StackObj {
427 private:
428 ResourceMark rm;
429 ResetNoHandleMark rnhm;
430 HandleMark hm;
431 bool debug_save;
432 public:
433 static int level;
434 Command(const char* str) {
435 debug_save = Debugging;
436 Debugging = true;
437 if (level++ > 0) return;
438 tty->cr();
439 tty->print_cr("\"Executing %s\"", str);
440 }
441
442 ~Command() {
443 tty->flush();
444 Debugging = debug_save;
445 level--;
446 }
447 };
448
449 int Command::level = 0;
450
451 #ifndef PRODUCT
452
453 extern "C" void blob(CodeBlob* cb) {
454 Command c("blob");
455 cb->print();
456 }
457
458
459 extern "C" void dump_vtable(address p) {
460 Command c("dump_vtable");
461 Klass* k = (Klass*)p;
462 InstanceKlass::cast(k)->vtable()->print();
463 }
464
465
466 extern "C" void nm(intptr_t p) {
467 // Actually we look through all CodeBlobs (the nm name has been kept for backwards compatability)
468 Command c("nm");
469 CodeBlob* cb = CodeCache::find_blob((address)p);
470 if (cb == NULL) {
471 tty->print_cr("NULL");
472 } else {
473 cb->print();
474 }
475 }
476
477
478 extern "C" void disnm(intptr_t p) {
479 Command c("disnm");
480 CodeBlob* cb = CodeCache::find_blob((address) p);
481 nmethod* nm = cb->as_nmethod_or_null();
482 if (nm) {
483 nm->print();
484 Disassembler::decode(nm);
485 } else {
486 cb->print();
487 Disassembler::decode(cb);
488 }
489 }
490
491
492 extern "C" void printnm(intptr_t p) {
493 char buffer[256];
494 sprintf(buffer, "printnm: " INTPTR_FORMAT, p);
495 Command c(buffer);
496 CodeBlob* cb = CodeCache::find_blob((address) p);
497 if (cb->is_nmethod()) {
498 nmethod* nm = (nmethod*)cb;
499 nm->print_nmethod(true);
500 }
501 }
502
503
504 extern "C" void universe() {
505 Command c("universe");
506 Universe::print();
507 }
508
509
510 extern "C" void verify() {
511 // try to run a verify on the entire system
512 // note: this may not be safe if we're not at a safepoint; for debugging,
513 // this manipulates the safepoint settings to avoid assertion failures
514 Command c("universe verify");
515 bool safe = SafepointSynchronize::is_at_safepoint();
516 if (!safe) {
517 tty->print_cr("warning: not at safepoint -- verify may fail");
518 SafepointSynchronize::set_is_at_safepoint();
519 }
520 // Ensure Eden top is correct before verification
521 Universe::heap()->prepare_for_verify();
522 Universe::verify();
523 if (!safe) SafepointSynchronize::set_is_not_at_safepoint();
524 }
525
526
527 extern "C" void pp(void* p) {
528 Command c("pp");
529 FlagSetting fl(PrintVMMessages, true);
530 FlagSetting f2(DisplayVMOutput, true);
531 if (Universe::heap()->is_in(p)) {
532 oop obj = oop(p);
533 obj->print();
534 } else {
535 tty->print(PTR_FORMAT, p);
536 }
537 }
538
539
540 // pv: print vm-printable object
541 extern "C" void pa(intptr_t p) { ((AllocatedObj*) p)->print(); }
542 extern "C" void findpc(intptr_t x);
543
544 #endif // !PRODUCT
545
546 extern "C" void ps() { // print stack
547 if (Thread::current() == NULL) return;
548 Command c("ps");
549
550
551 // Prints the stack of the current Java thread
552 JavaThread* p = JavaThread::active();
553 tty->print(" for thread: ");
554 p->print();
555 tty->cr();
556
557 if (p->has_last_Java_frame()) {
558 // If the last_Java_fp is set we are in C land and
559 // can call the standard stack_trace function.
560 #ifdef PRODUCT
561 p->print_stack();
562 } else {
563 tty->print_cr("Cannot find the last Java frame, printing stack disabled.");
564 #else // !PRODUCT
565 p->trace_stack();
566 } else {
567 frame f = os::current_frame();
568 RegisterMap reg_map(p);
569 f = f.sender(®_map);
570 tty->print("(guessing starting frame id=%#p based on current fp)\n", f.id());
571 p->trace_stack_from(vframe::new_vframe(&f, ®_map, p));
572 pd_ps(f);
573 #endif // PRODUCT
574 }
575
576 }
577
578 extern "C" void pfl() {
579 // print frame layout
580 Command c("pfl");
581 JavaThread* p = JavaThread::active();
582 tty->print(" for thread: ");
583 p->print();
584 tty->cr();
585 if (p->has_last_Java_frame()) {
586 p->print_frame_layout();
587 }
588 }
589
590 #ifndef PRODUCT
591
592 extern "C" void psf() { // print stack frames
593 {
594 Command c("psf");
595 JavaThread* p = JavaThread::active();
596 tty->print(" for thread: ");
597 p->print();
598 tty->cr();
599 if (p->has_last_Java_frame()) {
600 p->trace_frames();
601 }
602 }
603 }
604
605
606 extern "C" void threads() {
607 Command c("threads");
608 Threads::print(false, true);
609 }
610
611
612 extern "C" void psd() {
613 Command c("psd");
614 SystemDictionary::print();
615 }
616
617
618 extern "C" void safepoints() {
619 Command c("safepoints");
620 SafepointSynchronize::print_state();
621 }
622
623 #endif // !PRODUCT
624
625 extern "C" void pss() { // print all stacks
626 if (Thread::current() == NULL) return;
627 Command c("pss");
628 Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true));
629 }
630
631 #ifndef PRODUCT
632
633 extern "C" void debug() { // to set things up for compiler debugging
634 Command c("debug");
635 WizardMode = true;
636 PrintVMMessages = PrintCompilation = true;
637 PrintInlining = PrintAssembly = true;
638 tty->flush();
639 }
640
641
642 extern "C" void ndebug() { // undo debug()
643 Command c("ndebug");
644 PrintCompilation = false;
645 PrintInlining = PrintAssembly = false;
646 tty->flush();
647 }
648
649
650 extern "C" void flush() {
651 Command c("flush");
652 tty->flush();
653 }
654
655 extern "C" void events() {
656 Command c("events");
657 Events::print();
658 }
659
660 extern "C" Method* findm(intptr_t pc) {
661 Command c("findm");
662 nmethod* nm = CodeCache::find_nmethod((address)pc);
663 return (nm == NULL) ? (Method*)NULL : nm->method();
664 }
665
666
667 extern "C" nmethod* findnm(intptr_t addr) {
668 Command c("findnm");
669 return CodeCache::find_nmethod((address)addr);
670 }
671
672 // Another interface that isn't ambiguous in dbx.
673 // Can we someday rename the other find to hsfind?
674 extern "C" void hsfind(intptr_t x) {
675 Command c("hsfind");
676 os::print_location(tty, x, false);
677 }
678
679
680 extern "C" void find(intptr_t x) {
681 Command c("find");
682 os::print_location(tty, x, false);
683 }
684
685
686 extern "C" void findpc(intptr_t x) {
687 Command c("findpc");
688 os::print_location(tty, x, true);
689 }
690
691
692 // Need method pointer to find bcp, when not in permgen.
693 extern "C" void findbcp(intptr_t method, intptr_t bcp) {
694 Command c("findbcp");
695 Method* mh = (Method*)method;
696 if (!mh->is_native()) {
697 tty->print_cr("bci_from(%p) = %d; print_codes():",
698 mh, mh->bci_from(address(bcp)));
699 mh->print_codes_on(tty);
700 }
701 }
702
703 // int versions of all methods to avoid having to type type casts in the debugger
704
705 void pp(intptr_t p) { pp((void*)p); }
706 void pp(oop p) { pp((void*)p); }
707
708 void help() {
709 Command c("help");
710 tty->print_cr("basic");
711 tty->print_cr(" pp(void* p) - try to make sense of p");
712 tty->print_cr(" pv(intptr_t p)- ((PrintableResourceObj*) p)->print()");
713 tty->print_cr(" ps() - print current thread stack");
714 tty->print_cr(" pss() - print all thread stacks");
715 tty->print_cr(" pm(int pc) - print Method* given compiled PC");
716 tty->print_cr(" findm(intptr_t pc) - finds Method*");
717 tty->print_cr(" find(intptr_t x) - finds & prints nmethod/stub/bytecode/oop based on pointer into it");
718 tty->print_cr(" pns(void* sp, void* fp, void* pc) - print native (i.e. mixed) stack trace. E.g.");
719 tty->print_cr(" pns($sp, $rbp, $pc) on Linux/amd64 and Solaris/amd64 or");
720 tty->print_cr(" pns($sp, $ebp, $pc) on Linux/x86 or");
721 tty->print_cr(" pns($sp, 0, $pc) on Linux/ppc64 or");
722 tty->print_cr(" pns($sp + 0x7ff, 0, $pc) on Solaris/SPARC");
723 tty->print_cr(" - in gdb do 'set overload-resolution off' before calling pns()");
724 tty->print_cr(" - in dbx do 'frame 1' before calling pns()");
725
726 tty->print_cr("misc.");
727 tty->print_cr(" flush() - flushes the log file");
728 tty->print_cr(" events() - dump events from ring buffers");
729
730
731 tty->print_cr("compiler debugging");
732 tty->print_cr(" debug() - to set things up for compiler debugging");
733 tty->print_cr(" ndebug() - undo debug");
734 }
735
736 #endif // !PRODUCT
737
738 void print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size) {
739
740 // see if it's a valid frame
741 if (fr.pc()) {
742 st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)");
743
744 int count = 0;
745 while (count++ < StackPrintLimit) {
746 fr.print_on_error(st, buf, buf_size);
747 st->cr();
748 // Compiled code may use EBP register on x86 so it looks like
749 // non-walkable C frame. Use frame.sender() for java frames.
750 if (t && t->is_Java_thread()) {
751 // Catch very first native frame by using stack address.
752 // For JavaThread stack_base and stack_size should be set.
753 if (!t->on_local_stack((address)(fr.real_fp() + 1))) {
754 break;
755 }
756 if (fr.is_java_frame() || fr.is_native_frame() || fr.is_runtime_frame()) {
757 RegisterMap map((JavaThread*)t, false); // No update
758 fr = fr.sender(&map);
759 } else {
760 fr = os::get_sender_for_C_frame(&fr);
761 }
762 } else {
763 // is_first_C_frame() does only simple checks for frame pointer,
764 // it will pass if java compiled code has a pointer in EBP.
765 if (os::is_first_C_frame(&fr)) break;
766 fr = os::get_sender_for_C_frame(&fr);
767 }
768 }
769
770 if (count > StackPrintLimit) {
771 st->print_cr("...<more frames>...");
772 }
773
774 st->cr();
775 }
776 }
777
778 #ifndef PRODUCT
779
780 extern "C" void pns(void* sp, void* fp, void* pc) { // print native stack
781 Command c("pns");
782 static char buf[O_BUFLEN];
783 Thread* t = ThreadLocalStorage::get_thread_slow();
784 // Call generic frame constructor (certain arguments may be ignored)
785 frame fr(sp, fp, pc);
786 print_native_stack(tty, fr, t, buf, sizeof(buf));
787 }
788
789 #endif // !PRODUCT