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