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