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/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_out_of_shared_space(SharedSpaceType shared_space) {
285 static const char* name[] = {
286 "shared read only space",
287 "shared read write space",
288 "shared miscellaneous data space",
289 "shared miscellaneous code space"
290 };
291 static const char* flag[] = {
292 "SharedReadOnlySize",
293 "SharedReadWriteSize",
294 "SharedMiscDataSize",
295 "SharedMiscCodeSize"
296 };
297
298 warning("\nThe %s is not large enough\n"
299 "to preload requested classes. Use -XX:%s=<size>\n"
300 "to increase the initial size of %s.\n",
301 name[shared_space], flag[shared_space], name[shared_space]);
302 exit(2);
303 }
304
305
306 void report_insufficient_metaspace(size_t required_size) {
307 warning("\nThe MaxMetaspaceSize of " SIZE_FORMAT " bytes is not large enough.\n"
308 "Either don't specify the -XX:MaxMetaspaceSize=<size>\n"
309 "or increase the size to at least " SIZE_FORMAT ".\n",
310 MaxMetaspaceSize, required_size);
311 exit(2);
312 }
313
314 void report_java_out_of_memory(const char* message) {
315 static jint out_of_memory_reported = 0;
316
317 // A number of threads may attempt to report OutOfMemoryError at around the
318 // same time. To avoid dumping the heap or executing the data collection
319 // commands multiple times we just do it once when the first threads reports
320 // the error.
321 if (Atomic::cmpxchg(1, &out_of_memory_reported, 0) == 0) {
322 // create heap dump before OnOutOfMemoryError commands are executed
323 if (HeapDumpOnOutOfMemoryError) {
324 tty->print_cr("java.lang.OutOfMemoryError: %s", message);
325 HeapDumper::dump_heap_from_oome();
326 }
327
328 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
329 VMError::report_java_out_of_memory(message);
330 }
331
332 if (CrashOnOutOfMemoryError) {
333 tty->print_cr("Aborting due to java.lang.OutOfMemoryError: %s", message);
334 fatal("OutOfMemory encountered: %s", message);
335 }
336
337 if (ExitOnOutOfMemoryError) {
338 tty->print_cr("Terminating due to java.lang.OutOfMemoryError: %s", message);
339 os::exit(3);
340 }
341 }
342 }
343
344 static bool error_reported = false;
345
346 // call this when the VM is dying--it might loosen some asserts
347 void set_error_reported() {
348 error_reported = true;
349 }
350
351 bool is_error_reported() {
352 return error_reported;
353 }
354
355 #ifndef PRODUCT
356 #include <signal.h>
357
358 typedef void (*voidfun_t)();
359 // Crash with an authentic sigfpe
360 static void crash_with_sigfpe() {
361 // generate a native synchronous SIGFPE where possible;
362 // if that did not cause a signal (e.g. on ppc), just
363 // raise the signal.
364 volatile int x = 0;
365 volatile int y = 1/x;
366 #ifndef _WIN32
367 // OSX implements raise(sig) incorrectly so we need to
368 // explicitly target the current thread
369 pthread_kill(pthread_self(), SIGFPE);
370 #endif
371 } // end: crash_with_sigfpe
372
373 // crash with sigsegv at non-null address.
374 static void crash_with_segfault() {
375
376 char* const crash_addr = (char*) get_segfault_address();
377 *crash_addr = 'X';
378
379 } // end: crash_with_segfault
380
381 // returns an address which is guaranteed to generate a SIGSEGV on read,
382 // for test purposes, which is not NULL and contains bits in every word
383 void* get_segfault_address() {
384 return (void*)
385 #ifdef _LP64
386 0xABC0000000000ABCULL;
387 #else
388 0x00000ABC;
389 #endif
390 }
391
392 void test_error_handler() {
393 controlled_crash(ErrorHandlerTest);
394 }
395
396 void controlled_crash(int how) {
397 if (how == 0) return;
398
399 // If asserts are disabled, use the corresponding guarantee instead.
400 NOT_DEBUG(if (how <= 2) how += 2);
401
402 const char* const str = "hello";
403 const size_t num = (size_t)os::vm_page_size();
404
405 const char* const eol = os::line_separator();
406 const char* const msg = "this message should be truncated during formatting";
407 char * const dataPtr = NULL; // bad data pointer
408 const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer
409
410 // Keep this in sync with test/runtime/ErrorHandling/ErrorHandler.java
411 switch (how) {
412 case 1: vmassert(str == NULL, "expected null");
413 case 2: vmassert(num == 1023 && *str == 'X',
414 "num=" SIZE_FORMAT " str=\"%s\"", num, str);
415 case 3: guarantee(str == NULL, "expected null");
416 case 4: guarantee(num == 1023 && *str == 'X',
417 "num=" SIZE_FORMAT " str=\"%s\"", num, str);
418 case 5: fatal("expected null");
419 case 6: fatal("num=" SIZE_FORMAT " str=\"%s\"", num, str);
420 case 7: fatal("%s%s# %s%s# %s%s# %s%s# %s%s# "
421 "%s%s# %s%s# %s%s# %s%s# %s%s# "
422 "%s%s# %s%s# %s%s# %s%s# %s",
423 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
424 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
425 msg, eol, msg, eol, msg, eol, msg, eol, msg);
426 case 8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate");
427 case 9: ShouldNotCallThis();
428 case 10: ShouldNotReachHere();
429 case 11: Unimplemented();
430 // There's no guarantee the bad data pointer will crash us
431 // so "break" out to the ShouldNotReachHere().
432 case 12: *dataPtr = '\0'; break;
433 // There's no guarantee the bad function pointer will crash us
434 // so "break" out to the ShouldNotReachHere().
435 case 13: (*funcPtr)(); break;
436 case 14: crash_with_segfault(); break;
437 case 15: crash_with_sigfpe(); break;
438
439 default: tty->print_cr("ERROR: %d: unexpected test_num value.", how);
440 }
441 ShouldNotReachHere();
442 }
443 #endif // !PRODUCT
444
445 // ------ helper functions for debugging go here ------------
446
447 // All debug entries should be wrapped with a stack allocated
448 // Command object. It makes sure a resource mark is set and
449 // flushes the logfile to prevent file sharing problems.
450
451 class Command : public StackObj {
452 private:
453 ResourceMark rm;
454 ResetNoHandleMark rnhm;
455 HandleMark hm;
456 bool debug_save;
457 public:
458 static int level;
459 Command(const char* str) {
460 debug_save = Debugging;
461 Debugging = true;
462 if (level++ > 0) return;
463 tty->cr();
464 tty->print_cr("\"Executing %s\"", str);
465 }
466
467 ~Command() {
468 tty->flush();
469 Debugging = debug_save;
470 level--;
471 }
472 };
473
474 int Command::level = 0;
475
476 #ifndef PRODUCT
477
478 extern "C" void blob(CodeBlob* cb) {
479 Command c("blob");
480 cb->print();
481 }
482
483
484 extern "C" void dump_vtable(address p) {
485 Command c("dump_vtable");
486 Klass* k = (Klass*)p;
487 k->vtable()->print();
488 }
489
490
491 extern "C" void nm(intptr_t p) {
492 // Actually we look through all CodeBlobs (the nm name has been kept for backwards compatability)
493 Command c("nm");
494 CodeBlob* cb = CodeCache::find_blob((address)p);
495 if (cb == NULL) {
496 tty->print_cr("NULL");
497 } else {
498 cb->print();
499 }
500 }
501
502
503 extern "C" void disnm(intptr_t p) {
504 Command c("disnm");
505 CodeBlob* cb = CodeCache::find_blob((address) p);
506 if (cb != NULL) {
507 nmethod* nm = cb->as_nmethod_or_null();
508 if (nm != NULL) {
509 nm->print();
510 } else {
511 cb->print();
512 }
513 Disassembler::decode(cb);
514 }
515 }
516
517
518 extern "C" void printnm(intptr_t p) {
519 char buffer[256];
520 sprintf(buffer, "printnm: " INTPTR_FORMAT, p);
521 Command c(buffer);
522 CodeBlob* cb = CodeCache::find_blob((address) p);
523 if (cb->is_nmethod()) {
524 nmethod* nm = (nmethod*)cb;
525 nm->print_nmethod(true);
526 }
527 }
528
529
530 extern "C" void universe() {
531 Command c("universe");
532 Universe::print_on(tty);
533 }
534
535
536 extern "C" void verify() {
537 // try to run a verify on the entire system
538 // note: this may not be safe if we're not at a safepoint; for debugging,
539 // this manipulates the safepoint settings to avoid assertion failures
540 Command c("universe verify");
541 bool safe = SafepointSynchronize::is_at_safepoint();
542 if (!safe) {
543 tty->print_cr("warning: not at safepoint -- verify may fail");
544 SafepointSynchronize::set_is_at_safepoint();
545 }
546 // Ensure Eden top is correct before verification
547 Universe::heap()->prepare_for_verify();
548 Universe::verify();
549 if (!safe) SafepointSynchronize::set_is_not_at_safepoint();
550 }
551
552
553 extern "C" void pp(void* p) {
554 Command c("pp");
555 FlagSetting fl(PrintVMMessages, true);
556 FlagSetting f2(DisplayVMOutput, true);
557 if (Universe::heap()->is_in(p)) {
558 oop obj = oop(p);
559 obj->print();
560 } else {
561 tty->print(PTR_FORMAT, p2i(p));
562 }
563 }
564
565
566 // pv: print vm-printable object
567 extern "C" void pa(intptr_t p) { ((AllocatedObj*) p)->print(); }
568 extern "C" void findpc(intptr_t x);
569
570 #endif // !PRODUCT
571
572 extern "C" void ps() { // print stack
573 if (Thread::current_or_null() == NULL) return;
574 Command c("ps");
575
576
577 // Prints the stack of the current Java thread
578 JavaThread* p = JavaThread::active();
579 tty->print(" for thread: ");
580 p->print();
581 tty->cr();
582
583 if (p->has_last_Java_frame()) {
584 // If the last_Java_fp is set we are in C land and
585 // can call the standard stack_trace function.
586 #ifdef PRODUCT
587 p->print_stack();
588 } else {
589 tty->print_cr("Cannot find the last Java frame, printing stack disabled.");
590 #else // !PRODUCT
591 p->trace_stack();
592 } else {
593 frame f = os::current_frame();
594 RegisterMap reg_map(p);
595 f = f.sender(®_map);
596 tty->print("(guessing starting frame id=" PTR_FORMAT " based on current fp)\n", p2i(f.id()));
597 p->trace_stack_from(vframe::new_vframe(&f, ®_map, p));
598 pd_ps(f);
599 #endif // PRODUCT
600 }
601
602 }
603
604 extern "C" void pfl() {
605 // print frame layout
606 Command c("pfl");
607 JavaThread* p = JavaThread::active();
608 tty->print(" for thread: ");
609 p->print();
610 tty->cr();
611 if (p->has_last_Java_frame()) {
612 p->print_frame_layout();
613 }
614 }
615
616 #ifndef PRODUCT
617
618 extern "C" void psf() { // print stack frames
619 {
620 Command c("psf");
621 JavaThread* p = JavaThread::active();
622 tty->print(" for thread: ");
623 p->print();
624 tty->cr();
625 if (p->has_last_Java_frame()) {
626 p->trace_frames();
627 }
628 }
629 }
630
631
632 extern "C" void threads() {
633 Command c("threads");
634 Threads::print(false, true);
635 }
636
637
638 extern "C" void psd() {
639 Command c("psd");
640 SystemDictionary::print();
641 }
642
643
644 extern "C" void safepoints() {
645 Command c("safepoints");
646 SafepointSynchronize::print_state();
647 }
648
649 #endif // !PRODUCT
650
651 extern "C" void pss() { // print all stacks
652 if (Thread::current_or_null() == NULL) return;
653 Command c("pss");
654 Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true));
655 }
656
657 #ifndef PRODUCT
658
659 extern "C" void debug() { // to set things up for compiler debugging
660 Command c("debug");
661 WizardMode = true;
662 PrintVMMessages = PrintCompilation = true;
663 PrintInlining = PrintAssembly = true;
664 tty->flush();
665 }
666
667
668 extern "C" void ndebug() { // undo debug()
669 Command c("ndebug");
670 PrintCompilation = false;
671 PrintInlining = PrintAssembly = false;
672 tty->flush();
673 }
674
675
676 extern "C" void flush() {
677 Command c("flush");
678 tty->flush();
679 }
680
681 extern "C" void events() {
682 Command c("events");
683 Events::print();
684 }
685
686 extern "C" Method* findm(intptr_t pc) {
687 Command c("findm");
688 nmethod* nm = CodeCache::find_nmethod((address)pc);
689 return (nm == NULL) ? (Method*)NULL : nm->method();
690 }
691
692
693 extern "C" nmethod* findnm(intptr_t addr) {
694 Command c("findnm");
695 return CodeCache::find_nmethod((address)addr);
696 }
697
698 // Another interface that isn't ambiguous in dbx.
699 // Can we someday rename the other find to hsfind?
700 extern "C" void hsfind(intptr_t x) {
701 Command c("hsfind");
702 os::print_location(tty, x, false);
703 }
704
705
706 extern "C" void find(intptr_t x) {
707 Command c("find");
708 os::print_location(tty, x, false);
709 }
710
711
712 extern "C" void findpc(intptr_t x) {
713 Command c("findpc");
714 os::print_location(tty, x, true);
715 }
716
717
718 // Need method pointer to find bcp, when not in permgen.
719 extern "C" void findbcp(intptr_t method, intptr_t bcp) {
720 Command c("findbcp");
721 Method* mh = (Method*)method;
722 if (!mh->is_native()) {
723 tty->print_cr("bci_from(%p) = %d; print_codes():",
724 mh, mh->bci_from(address(bcp)));
725 mh->print_codes_on(tty);
726 }
727 }
728
729 // int versions of all methods to avoid having to type type casts in the debugger
730
731 void pp(intptr_t p) { pp((void*)p); }
732 void pp(oop p) { pp((void*)p); }
733
734 void help() {
735 Command c("help");
736 tty->print_cr("basic");
737 tty->print_cr(" pp(void* p) - try to make sense of p");
738 tty->print_cr(" pv(intptr_t p)- ((PrintableResourceObj*) p)->print()");
739 tty->print_cr(" ps() - print current thread stack");
740 tty->print_cr(" pss() - print all thread stacks");
741 tty->print_cr(" pm(int pc) - print Method* given compiled PC");
742 tty->print_cr(" findm(intptr_t pc) - finds Method*");
743 tty->print_cr(" find(intptr_t x) - finds & prints nmethod/stub/bytecode/oop based on pointer into it");
744 tty->print_cr(" pns(void* sp, void* fp, void* pc) - print native (i.e. mixed) stack trace. E.g.");
745 tty->print_cr(" pns($sp, $rbp, $pc) on Linux/amd64 and Solaris/amd64 or");
746 tty->print_cr(" pns($sp, $ebp, $pc) on Linux/x86 or");
747 tty->print_cr(" pns($sp, 0, $pc) on Linux/ppc64 or");
748 tty->print_cr(" pns($sp + 0x7ff, 0, $pc) on Solaris/SPARC");
749 tty->print_cr(" - in gdb do 'set overload-resolution off' before calling pns()");
750 tty->print_cr(" - in dbx do 'frame 1' before calling pns()");
751
752 tty->print_cr("misc.");
753 tty->print_cr(" flush() - flushes the log file");
754 tty->print_cr(" events() - dump events from ring buffers");
755
756
757 tty->print_cr("compiler debugging");
758 tty->print_cr(" debug() - to set things up for compiler debugging");
759 tty->print_cr(" ndebug() - undo debug");
760 }
761
762 #endif // !PRODUCT
763
764 void print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size) {
765
766 // see if it's a valid frame
767 if (fr.pc()) {
768 st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)");
769
770 int count = 0;
771 while (count++ < StackPrintLimit) {
772 fr.print_on_error(st, buf, buf_size);
773 st->cr();
774 // Compiled code may use EBP register on x86 so it looks like
775 // non-walkable C frame. Use frame.sender() for java frames.
776 if (t && t->is_Java_thread()) {
777 // Catch very first native frame by using stack address.
778 // For JavaThread stack_base and stack_size should be set.
779 if (!t->on_local_stack((address)(fr.real_fp() + 1))) {
780 break;
781 }
782 if (fr.is_java_frame() || fr.is_native_frame() || fr.is_runtime_frame()) {
783 RegisterMap map((JavaThread*)t, false); // No update
784 fr = fr.sender(&map);
785 } else {
786 fr = os::get_sender_for_C_frame(&fr);
787 }
788 } else {
789 // is_first_C_frame() does only simple checks for frame pointer,
790 // it will pass if java compiled code has a pointer in EBP.
791 if (os::is_first_C_frame(&fr)) break;
792 fr = os::get_sender_for_C_frame(&fr);
793 }
794 }
795
796 if (count > StackPrintLimit) {
797 st->print_cr("...<more frames>...");
798 }
799
800 st->cr();
801 }
802 }
803
804 #ifndef PRODUCT
805
806 extern "C" void pns(void* sp, void* fp, void* pc) { // print native stack
807 Command c("pns");
808 static char buf[O_BUFLEN];
809 Thread* t = Thread::current_or_null();
810 // Call generic frame constructor (certain arguments may be ignored)
811 frame fr(sp, fp, pc);
812 print_native_stack(tty, fr, t, buf, sizeof(buf));
813 }
814
815 #endif // !PRODUCT
816
817 //////////////////////////////////////////////////////////////////////////////
818 // Test multiple STATIC_ASSERT forms in various scopes.
819
820 #ifndef PRODUCT
821
822 // namespace scope
823 STATIC_ASSERT(true);
824 STATIC_ASSERT(true);
825 STATIC_ASSERT(1 == 1);
826 STATIC_ASSERT(0 == 0);
827
828 void test_multiple_static_assert_forms_in_function_scope() {
829 STATIC_ASSERT(true);
830 STATIC_ASSERT(true);
831 STATIC_ASSERT(0 == 0);
832 STATIC_ASSERT(1 == 1);
833 }
834
835 // class scope
836 struct TestMultipleStaticAssertFormsInClassScope {
837 STATIC_ASSERT(true);
838 STATIC_ASSERT(true);
839 STATIC_ASSERT(0 == 0);
840 STATIC_ASSERT(1 == 1);
841 };
842
843 #endif // !PRODUCT