1 /*
2 * Copyright (c) 1997, 2016, 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/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/thread.inline.hpp"
48 #include "runtime/vframe.hpp"
49 #include "services/heapDumper.hpp"
50 #include "utilities/defaultStream.hpp"
51 #include "utilities/events.hpp"
52 #include "utilities/top.hpp"
53 #include "utilities/vmError.hpp"
54 #ifdef TARGET_OS_FAMILY_linux
55 # include "os_linux.inline.hpp"
56 #endif
57 #ifdef TARGET_OS_FAMILY_solaris
58 # include "os_solaris.inline.hpp"
59 #endif
60 #ifdef TARGET_OS_FAMILY_windows
61 # include "os_windows.inline.hpp"
62 #endif
63 #ifdef TARGET_OS_FAMILY_bsd
64 # include "os_bsd.inline.hpp"
65 #endif
66
67 #ifndef ASSERT
68 # ifdef _DEBUG
69 // NOTE: don't turn the lines below into a comment -- if you're getting
70 // a compile error here, change the settings to define ASSERT
71 ASSERT should be defined when _DEBUG is defined. It is not intended to be used for debugging
72 functions that do not slow down the system too much and thus can be left in optimized code.
73 On the other hand, the code should not be included in a production version.
74 # endif // _DEBUG
75 #endif // ASSERT
76
77
78 #ifdef _DEBUG
79 # ifndef ASSERT
80 configuration error: ASSERT must be defined in debug version
81 # endif // ASSERT
82 #endif // _DEBUG
83
84
85 #ifdef PRODUCT
86 # if -defined _DEBUG || -defined ASSERT
87 configuration error: ASSERT et al. must not be defined in PRODUCT version
88 # endif
89 #endif // PRODUCT
90
91 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
92
93 FormatBufferResource::FormatBufferResource(const char * format, ...)
94 : FormatBufferBase((char*)resource_allocate_bytes(RES_BUFSZ)) {
95 va_list argp;
96 va_start(argp, format);
97 jio_vsnprintf(_buf, RES_BUFSZ, format, argp);
98 va_end(argp);
99 }
100
101 ATTRIBUTE_PRINTF(1, 2)
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 }
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.
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;
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:
216 #define error_is_suppressed(file_name, line_no) (false)
217
218 #endif // !PRODUCT
219
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 }
228
229 void report_fatal(const char* file, int line, const char* message)
230 {
231 report_vm_error(file, line, "fatal error", message);
232 }
233
234 void report_vm_out_of_memory(const char* file, int line, size_t size,
235 VMErrorType vm_err_type, const char* message) {
236 if (Debugging) return;
237
238 Thread* thread = ThreadLocalStorage::get_thread_slow();
239 VMError(thread, file, line, size, vm_err_type, message).report_and_die();
240
241 // The UseOSErrorReporting option in report_and_die() may allow a return
242 // to here. If so then we'll have to figure out how to handle it.
243 guarantee(false, "report_and_die() should not return here");
244 }
245
246 void report_should_not_call(const char* file, int line) {
247 report_vm_error(file, line, "ShouldNotCall()");
248 }
249
250 void report_should_not_reach_here(const char* file, int line) {
251 report_vm_error(file, line, "ShouldNotReachHere()");
252 }
253
254 void report_unimplemented(const char* file, int line) {
255 report_vm_error(file, line, "Unimplemented()");
256 }
257
258 void report_untested(const char* file, int line, const char* message) {
259 #ifndef PRODUCT
260 warning("Untested: %s in %s: %d\n", message, file, line);
261 #endif // !PRODUCT
262 }
263
264 void report_out_of_shared_space(SharedSpaceType shared_space) {
265 static const char* name[] = {
266 "native memory for metadata",
267 "shared read only space",
268 "shared read write space",
269 "shared miscellaneous data space",
270 "shared miscellaneous code space"
271 };
272 static const char* flag[] = {
273 "Metaspace",
274 "SharedReadOnlySize",
275 "SharedReadWriteSize",
276 "SharedMiscDataSize",
277 "SharedMiscCodeSize"
278 };
279
280 warning("\nThe %s is not large enough\n"
281 "to preload requested classes. Use -XX:%s=<size>\n"
282 "to increase the initial size of %s.\n",
283 name[shared_space], flag[shared_space], name[shared_space]);
284 exit(2);
285 }
286
287 void report_java_out_of_memory(const char* message) {
288 static jint out_of_memory_reported = 0;
289
290 // A number of threads may attempt to report OutOfMemoryError at around the
291 // same time. To avoid dumping the heap or executing the data collection
292 // commands multiple times we just do it once when the first threads reports
293 // the error.
294 if (Atomic::cmpxchg(1, &out_of_memory_reported, 0) == 0) {
295 // create heap dump before OnOutOfMemoryError commands are executed
296 if (HeapDumpOnOutOfMemoryError) {
297 tty->print_cr("java.lang.OutOfMemoryError: %s", message);
298 HeapDumper::dump_heap_from_oome();
299 }
300
301 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
302 VMError err(message);
303 err.report_java_out_of_memory();
304 }
305
306 if (CrashOnOutOfMemoryError) {
307 tty->print_cr("Aborting due to java.lang.OutOfMemoryError: %s", message);
308 fatal(err_msg("OutOfMemory encountered: %s", message));
309 }
310
311 if (ExitOnOutOfMemoryError) {
312 tty->print_cr("Terminating due to java.lang.OutOfMemoryError: %s", message);
313 exit(3);
314 }
315 }
316 }
317
318 static bool error_reported = false;
319
320 // call this when the VM is dying--it might loosen some asserts
321 void set_error_reported() {
322 error_reported = true;
323 }
324
325 bool is_error_reported() {
326 return error_reported;
327 }
328
329 #ifndef PRODUCT
330 #include <signal.h>
331
332 void test_error_handler() {
333 uintx test_num = ErrorHandlerTest;
334 if (test_num == 0) return;
335
336 // If asserts are disabled, use the corresponding guarantee instead.
337 size_t n = test_num;
338 NOT_DEBUG(if (n <= 2) n += 2);
339
340 const char* const str = "hello";
341 const size_t num = (size_t)os::vm_page_size();
342
343 const char* const eol = os::line_separator();
344 const char* const msg = "this message should be truncated during formatting";
345 char * const dataPtr = NULL; // bad data pointer
346 const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer
347
348 // Keep this in sync with test/runtime/6888954/vmerrors.sh.
349 switch (n) {
350 case 1: assert(str == NULL, "expected null");
351 case 2: assert(num == 1023 && *str == 'X',
352 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
353 case 3: guarantee(str == NULL, "expected null");
354 case 4: guarantee(num == 1023 && *str == 'X',
355 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
356 case 5: fatal("expected null");
357 case 6: fatal(err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
358 case 7: fatal(err_msg("%s%s# %s%s# %s%s# %s%s# %s%s# "
359 "%s%s# %s%s# %s%s# %s%s# %s%s# "
360 "%s%s# %s%s# %s%s# %s%s# %s",
361 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
362 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
363 msg, eol, msg, eol, msg, eol, msg, eol, msg));
364 case 8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate");
365 case 9: ShouldNotCallThis();
366 case 10: ShouldNotReachHere();
367 case 11: Unimplemented();
368 // There's no guarantee the bad data pointer will crash us
369 // so "break" out to the ShouldNotReachHere().
370 case 12: *dataPtr = '\0'; break;
371 // There's no guarantee the bad function pointer will crash us
372 // so "break" out to the ShouldNotReachHere().
373 case 13: (*funcPtr)(); break;
374
375 default: tty->print_cr("ERROR: %d: unexpected test_num value.", n);
376 }
377 ShouldNotReachHere();
378 }
379 #endif // !PRODUCT
380
381 // ------ helper functions for debugging go here ------------
382
383 // All debug entries should be wrapped with a stack allocated
384 // Command object. It makes sure a resource mark is set and
385 // flushes the logfile to prevent file sharing problems.
386
387 class Command : public StackObj {
388 private:
389 ResourceMark rm;
390 ResetNoHandleMark rnhm;
391 HandleMark hm;
392 bool debug_save;
393 public:
394 static int level;
395 Command(const char* str) {
396 debug_save = Debugging;
397 Debugging = true;
398 if (level++ > 0) return;
399 tty->cr();
400 tty->print_cr("\"Executing %s\"", str);
401 }
402
403 ~Command() {
404 tty->flush();
405 Debugging = debug_save;
406 level--;
407 }
408 };
409
410 int Command::level = 0;
411
412 #ifndef PRODUCT
413
414 extern "C" void blob(CodeBlob* cb) {
415 Command c("blob");
416 cb->print();
417 }
418
419
420 extern "C" void dump_vtable(address p) {
421 Command c("dump_vtable");
422 Klass* k = (Klass*)p;
423 InstanceKlass::cast(k)->vtable()->print();
424 }
425
426
427 extern "C" void nm(intptr_t p) {
428 // Actually we look through all CodeBlobs (the nm name has been kept for backwards compatability)
429 Command c("nm");
430 CodeBlob* cb = CodeCache::find_blob((address)p);
431 if (cb == NULL) {
432 tty->print_cr("NULL");
433 } else {
434 cb->print();
435 }
436 }
437
438
439 extern "C" void disnm(intptr_t p) {
440 Command c("disnm");
441 CodeBlob* cb = CodeCache::find_blob((address) p);
442 nmethod* nm = cb->as_nmethod_or_null();
443 if (nm) {
444 nm->print();
445 Disassembler::decode(nm);
446 } else {
447 cb->print();
448 Disassembler::decode(cb);
449 }
450 }
451
452
453 extern "C" void printnm(intptr_t p) {
454 char buffer[256];
455 sprintf(buffer, "printnm: " INTPTR_FORMAT, p);
456 Command c(buffer);
457 CodeBlob* cb = CodeCache::find_blob((address) p);
458 if (cb->is_nmethod()) {
459 nmethod* nm = (nmethod*)cb;
460 nm->print_nmethod(true);
461 }
462 }
463
464
465 extern "C" void universe() {
466 Command c("universe");
467 Universe::print();
468 }
469
470
471 extern "C" void verify() {
472 // try to run a verify on the entire system
473 // note: this may not be safe if we're not at a safepoint; for debugging,
474 // this manipulates the safepoint settings to avoid assertion failures
475 Command c("universe verify");
476 bool safe = SafepointSynchronize::is_at_safepoint();
477 if (!safe) {
478 tty->print_cr("warning: not at safepoint -- verify may fail");
479 SafepointSynchronize::set_is_at_safepoint();
480 }
481 // Ensure Eden top is correct before verification
482 Universe::heap()->prepare_for_verify();
483 Universe::verify();
484 if (!safe) SafepointSynchronize::set_is_not_at_safepoint();
485 }
486
487
488 extern "C" void pp(void* p) {
489 Command c("pp");
490 FlagSetting fl(PrintVMMessages, true);
491 FlagSetting f2(DisplayVMOutput, true);
492 if (Universe::heap()->is_in(p)) {
493 oop obj = oop(p);
494 obj->print();
495 } else {
496 tty->print(PTR_FORMAT, p);
497 }
498 }
499
500
501 // pv: print vm-printable object
502 extern "C" void pa(intptr_t p) { ((AllocatedObj*) p)->print(); }
503 extern "C" void findpc(intptr_t x);
504
505 #endif // !PRODUCT
506
507 extern "C" void ps() { // print stack
508 if (Thread::current() == NULL) return;
509 Command c("ps");
510
511
512 // Prints the stack of the current Java thread
513 JavaThread* p = JavaThread::active();
514 tty->print(" for thread: ");
515 p->print();
516 tty->cr();
517
518 if (p->has_last_Java_frame()) {
519 // If the last_Java_fp is set we are in C land and
520 // can call the standard stack_trace function.
521 #ifdef PRODUCT
522 p->print_stack();
523 } else {
524 tty->print_cr("Cannot find the last Java frame, printing stack disabled.");
525 #else // !PRODUCT
526 p->trace_stack();
527 } else {
528 frame f = os::current_frame();
529 RegisterMap reg_map(p);
530 f = f.sender(®_map);
531 tty->print("(guessing starting frame id=%#p based on current fp)\n", f.id());
532 p->trace_stack_from(vframe::new_vframe(&f, ®_map, p));
533 pd_ps(f);
534 #endif // PRODUCT
535 }
536
537 }
538
539 extern "C" void pfl() {
540 // print frame layout
541 Command c("pfl");
542 JavaThread* p = JavaThread::active();
543 tty->print(" for thread: ");
544 p->print();
545 tty->cr();
546 if (p->has_last_Java_frame()) {
547 p->print_frame_layout();
548 }
549 }
550
551 #ifndef PRODUCT
552
553 extern "C" void psf() { // print stack frames
554 {
555 Command c("psf");
556 JavaThread* p = JavaThread::active();
557 tty->print(" for thread: ");
558 p->print();
559 tty->cr();
560 if (p->has_last_Java_frame()) {
561 p->trace_frames();
562 }
563 }
564 }
565
566
567 extern "C" void threads() {
568 Command c("threads");
569 Threads::print(false, true);
570 }
571
572
573 extern "C" void psd() {
574 Command c("psd");
575 SystemDictionary::print();
576 }
577
578
579 extern "C" void safepoints() {
580 Command c("safepoints");
581 SafepointSynchronize::print_state();
582 }
583
584 #endif // !PRODUCT
585
586 extern "C" void pss() { // print all stacks
587 if (Thread::current() == NULL) return;
588 Command c("pss");
589 Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true));
590 }
591
592 #ifndef PRODUCT
593
594 extern "C" void debug() { // to set things up for compiler debugging
595 Command c("debug");
596 WizardMode = true;
597 PrintVMMessages = PrintCompilation = true;
598 PrintInlining = PrintAssembly = true;
599 tty->flush();
600 }
601
602
603 extern "C" void ndebug() { // undo debug()
604 Command c("ndebug");
605 PrintCompilation = false;
606 PrintInlining = PrintAssembly = false;
607 tty->flush();
608 }
609
610
611 extern "C" void flush() {
612 Command c("flush");
613 tty->flush();
614 }
615
616 extern "C" void events() {
617 Command c("events");
618 Events::print();
619 }
620
621 extern "C" Method* findm(intptr_t pc) {
622 Command c("findm");
623 nmethod* nm = CodeCache::find_nmethod((address)pc);
624 return (nm == NULL) ? (Method*)NULL : nm->method();
625 }
626
627
628 extern "C" nmethod* findnm(intptr_t addr) {
629 Command c("findnm");
630 return CodeCache::find_nmethod((address)addr);
631 }
632
633 // Another interface that isn't ambiguous in dbx.
634 // Can we someday rename the other find to hsfind?
635 extern "C" void hsfind(intptr_t x) {
636 Command c("hsfind");
637 os::print_location(tty, x, false);
638 }
639
640
641 extern "C" void find(intptr_t x) {
642 Command c("find");
643 os::print_location(tty, x, false);
644 }
645
646
647 extern "C" void findpc(intptr_t x) {
648 Command c("findpc");
649 os::print_location(tty, x, true);
650 }
651
652
653 // Need method pointer to find bcp, when not in permgen.
654 extern "C" void findbcp(intptr_t method, intptr_t bcp) {
655 Command c("findbcp");
656 Method* mh = (Method*)method;
657 if (!mh->is_native()) {
658 tty->print_cr("bci_from(%p) = %d; print_codes():",
659 mh, mh->bci_from(address(bcp)));
660 mh->print_codes_on(tty);
661 }
662 }
663
664 // int versions of all methods to avoid having to type type casts in the debugger
665
666 void pp(intptr_t p) { pp((void*)p); }
667 void pp(oop p) { pp((void*)p); }
668
669 void help() {
670 Command c("help");
671 tty->print_cr("basic");
672 tty->print_cr(" pp(void* p) - try to make sense of p");
673 tty->print_cr(" pv(intptr_t p)- ((PrintableResourceObj*) p)->print()");
674 tty->print_cr(" ps() - print current thread stack");
675 tty->print_cr(" pss() - print all thread stacks");
676 tty->print_cr(" pm(int pc) - print Method* given compiled PC");
677 tty->print_cr(" findm(intptr_t pc) - finds Method*");
678 tty->print_cr(" find(intptr_t x) - finds & prints nmethod/stub/bytecode/oop based on pointer into it");
679 tty->print_cr(" pns(void* sp, void* fp, void* pc) - print native (i.e. mixed) stack trace. E.g.");
680 tty->print_cr(" pns($sp, $rbp, $pc) on Linux/amd64 and Solaris/amd64 or");
681 tty->print_cr(" pns($sp, $ebp, $pc) on Linux/x86 or");
682 tty->print_cr(" pns($sp, 0, $pc) on Linux/ppc64 or");
683 tty->print_cr(" pns($sp + 0x7ff, 0, $pc) on Solaris/SPARC");
684 tty->print_cr(" - in gdb do 'set overload-resolution off' before calling pns()");
685 tty->print_cr(" - in dbx do 'frame 1' before calling pns()");
686
687 tty->print_cr("misc.");
688 tty->print_cr(" flush() - flushes the log file");
689 tty->print_cr(" events() - dump events from ring buffers");
690
691
692 tty->print_cr("compiler debugging");
693 tty->print_cr(" debug() - to set things up for compiler debugging");
694 tty->print_cr(" ndebug() - undo debug");
695 }
696
697 #endif // !PRODUCT
698
699 void print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size) {
700
701 // see if it's a valid frame
702 if (fr.pc()) {
703 st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)");
704
705 int count = 0;
706 while (count++ < StackPrintLimit) {
707 fr.print_on_error(st, buf, buf_size);
708 st->cr();
709 // Compiled code may use EBP register on x86 so it looks like
710 // non-walkable C frame. Use frame.sender() for java frames.
711 if (t && t->is_Java_thread()) {
712 // Catch very first native frame by using stack address.
713 // For JavaThread stack_base and stack_size should be set.
714 if (!t->on_local_stack((address)(fr.real_fp() + 1))) {
715 break;
716 }
717 if (fr.is_java_frame() || fr.is_native_frame() || fr.is_runtime_frame()) {
718 RegisterMap map((JavaThread*)t, false); // No update
719 fr = fr.sender(&map);
720 } else {
721 fr = os::get_sender_for_C_frame(&fr);
722 }
723 } else {
724 // is_first_C_frame() does only simple checks for frame pointer,
725 // it will pass if java compiled code has a pointer in EBP.
726 if (os::is_first_C_frame(&fr)) break;
727 fr = os::get_sender_for_C_frame(&fr);
728 }
729 }
730
731 if (count > StackPrintLimit) {
732 st->print_cr("...<more frames>...");
733 }
734
735 st->cr();
736 }
737 }
738
739 #ifndef PRODUCT
740
741 extern "C" void pns(void* sp, void* fp, void* pc) { // print native stack
742 Command c("pns");
743 static char buf[O_BUFLEN];
744 Thread* t = ThreadLocalStorage::get_thread_slow();
745 // Call generic frame constructor (certain arguments may be ignored)
746 frame fr(sp, fp, pc);
747 print_native_stack(tty, fr, t, buf, sizeof(buf));
748 }
749
750 #endif // !PRODUCT