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