debug.cpp revision 7833:6bfc40057b3f 
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
82PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
83
84FormatBufferResource::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
92ATTRIBUTE_PRINTF(1, 2)
93void 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
110static const char* last_file_name = NULL;
111static 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.
116bool 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
211void 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
220void report_fatal(const char* file, int line, const char* message)
221{
222  report_vm_error(file, line, "fatal error", message);
223}
224
225void 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
237void report_should_not_call(const char* file, int line) {
238  report_vm_error(file, line, "ShouldNotCall()");
239}
240
241void report_should_not_reach_here(const char* file, int line) {
242  report_vm_error(file, line, "ShouldNotReachHere()");
243}
244
245void report_unimplemented(const char* file, int line) {
246  report_vm_error(file, line, "Unimplemented()");
247}
248
249void 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
255void 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
276void 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
284void 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
305static bool error_reported = false;
306
307// call this when the VM is dying--it might loosen some asserts
308void set_error_reported() {
309  error_reported = true;
310}
311
312bool is_error_reported() {
313    return error_reported;
314}
315
316#ifndef PRODUCT
317#include <signal.h>
318
319typedef void (*voidfun_t)();
320// Crash with an authentic sigfpe
321static 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.
333static 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
342void* get_segfault_address() {
343  return (void*)
344#ifdef _LP64
345    0xABC0000000000ABCULL;
346#else
347    0x00000ABC;
348#endif
349}
350
351void test_error_handler() {
352  controlled_crash(ErrorHandlerTest);
353}
354
355void 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
410class 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
433int Command::level = 0;
434
435#ifndef PRODUCT
436
437extern "C" void blob(CodeBlob* cb) {
438  Command c("blob");
439  cb->print();
440}
441
442
443extern "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
450extern "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
462extern "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
476extern "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
488extern "C" void universe() {
489  Command c("universe");
490  Universe::print();
491}
492
493
494extern "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
511extern "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
525extern "C" void pa(intptr_t p)   { ((AllocatedObj*) p)->print(); }
526extern "C" void findpc(intptr_t x);
527
528#endif // !PRODUCT
529
530extern "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(&reg_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, &reg_map, p));
556  pd_ps(f);
557#endif // PRODUCT
558  }
559
560}
561
562extern "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
576extern "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
590extern "C" void threads() {
591  Command c("threads");
592  Threads::print(false, true);
593}
594
595
596extern "C" void psd() {
597  Command c("psd");
598  SystemDictionary::print();
599}
600
601
602extern "C" void safepoints() {
603  Command c("safepoints");
604  SafepointSynchronize::print_state();
605}
606
607#endif // !PRODUCT
608
609extern "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
617extern "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
626extern "C" void ndebug() {              // undo debug()
627  Command c("ndebug");
628  PrintCompilation = false;
629  PrintInlining = PrintAssembly = false;
630  tty->flush();
631}
632
633
634extern "C" void flush()  {
635  Command c("flush");
636  tty->flush();
637}
638
639extern "C" void events() {
640  Command c("events");
641  Events::print();
642}
643
644extern "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
651extern "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?
658extern "C" void hsfind(intptr_t x) {
659  Command c("hsfind");
660  os::print_location(tty, x, false);
661}
662
663
664extern "C" void find(intptr_t x) {
665  Command c("find");
666  os::print_location(tty, x, false);
667}
668
669
670extern "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.
677extern "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
689void pp(intptr_t p)          { pp((void*)p); }
690void pp(oop p)               { pp((void*)p); }
691
692void 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
722void 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
764extern "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
774