1 /*
2 * Copyright (c) 1997, 2019, 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 "jvm.h"
27 #include "classfile/systemDictionary.hpp"
28 #include "code/codeCache.hpp"
29 #include "code/icBuffer.hpp"
30 #include "code/nmethod.hpp"
31 #include "code/vtableStubs.hpp"
32 #include "compiler/compileBroker.hpp"
33 #include "compiler/disassembler.hpp"
34 #include "gc/shared/collectedHeap.hpp"
35 #include "interpreter/bytecodeHistogram.hpp"
36 #include "interpreter/interpreter.hpp"
37 #include "memory/allocation.hpp"
38 #include "memory/resourceArea.hpp"
39 #include "memory/universe.hpp"
40 #include "oops/oop.inline.hpp"
41 #include "runtime/arguments.hpp"
42 #include "runtime/atomic.hpp"
43 #include "runtime/flags/flagSetting.hpp"
44 #include "runtime/frame.inline.hpp"
45 #include "runtime/handles.inline.hpp"
46 #include "runtime/java.hpp"
47 #include "runtime/os.hpp"
48 #include "runtime/sharedRuntime.hpp"
49 #include "runtime/stubCodeGenerator.hpp"
50 #include "runtime/stubRoutines.hpp"
51 #include "runtime/thread.inline.hpp"
52 #include "runtime/vframe.hpp"
53 #include "runtime/vm_version.hpp"
54 #include "services/heapDumper.hpp"
55 #include "services/memTracker.hpp"
56 #include "utilities/defaultStream.hpp"
57 #include "utilities/events.hpp"
58 #include "utilities/formatBuffer.hpp"
59 #include "utilities/globalDefinitions.hpp"
60 #include "utilities/macros.hpp"
61 #include "utilities/vmError.hpp"
62
63 #include <stdio.h>
64 #include <stdarg.h>
65
66 // Support for showing register content on asserts/guarantees.
67 #ifdef CAN_SHOW_REGISTERS_ON_ASSERT
68 static char g_dummy;
69 char* g_assert_poison = &g_dummy;
70 static intx g_asserting_thread = 0;
71 static void* g_assertion_context = NULL;
72 #endif // CAN_SHOW_REGISTERS_ON_ASSERT
73
74 #ifndef ASSERT
75 # ifdef _DEBUG
76 // NOTE: don't turn the lines below into a comment -- if you're getting
77 // a compile error here, change the settings to define ASSERT
78 ASSERT should be defined when _DEBUG is defined. It is not intended to be used for debugging
79 functions that do not slow down the system too much and thus can be left in optimized code.
80 On the other hand, the code should not be included in a production version.
81 # endif // _DEBUG
82 #endif // ASSERT
83
84
85 #ifdef _DEBUG
86 # ifndef ASSERT
87 configuration error: ASSERT must be defined in debug version
88 # endif // ASSERT
89 #endif // _DEBUG
90
91
92 #ifdef PRODUCT
93 # if -defined _DEBUG || -defined ASSERT
94 configuration error: ASSERT et al. must not be defined in PRODUCT version
95 # endif
96 #endif // PRODUCT
97
98 #ifdef ASSERT
99 // This is to test that error reporting works if we assert during dynamic
100 // initialization of the hotspot. See JDK-8214975.
101 struct Crasher {
102 Crasher() {
103 // Using getenv - no other mechanism would work yet.
104 const char* s = ::getenv("HOTSPOT_FATAL_ERROR_DURING_DYNAMIC_INITIALIZATION");
105 if (s != NULL && ::strcmp(s, "1") == 0) {
106 fatal("HOTSPOT_FATAL_ERROR_DURING_DYNAMIC_INITIALIZATION");
107 }
108 }
109 };
110 static Crasher g_crasher;
111 #endif // ASSERT
112
113 ATTRIBUTE_PRINTF(1, 2)
114 void warning(const char* format, ...) {
115 if (PrintWarnings) {
116 FILE* const err = defaultStream::error_stream();
117 jio_fprintf(err, "%s warning: ", VM_Version::vm_name());
118 va_list ap;
119 va_start(ap, format);
120 vfprintf(err, format, ap);
121 va_end(ap);
122 fputc('\n', err);
123 }
124 if (BreakAtWarning) BREAKPOINT;
125 }
126
127 #ifndef PRODUCT
128
129 #define is_token_break(ch) (isspace(ch) || (ch) == ',')
130
131 static const char* last_file_name = NULL;
132 static int last_line_no = -1;
133
134 // assert/guarantee/... may happen very early during VM initialization.
135 // Don't rely on anything that is initialized by Threads::create_vm(). For
136 // example, don't use tty.
137 bool error_is_suppressed(const char* file_name, int line_no) {
138 // The following 1-element cache requires that passed-in
139 // file names are always only constant literals.
140 if (file_name == last_file_name && line_no == last_line_no) return true;
141
142 int file_name_len = (int)strlen(file_name);
143 char separator = os::file_separator()[0];
144 const char* base_name = strrchr(file_name, separator);
145 if (base_name == NULL)
146 base_name = file_name;
147
148 // scan the SuppressErrorAt option
149 const char* cp = SuppressErrorAt;
150 for (;;) {
151 const char* sfile;
152 int sfile_len;
153 int sline;
154 bool noisy;
155 while ((*cp) != '\0' && is_token_break(*cp)) cp++;
156 if ((*cp) == '\0') break;
157 sfile = cp;
158 while ((*cp) != '\0' && !is_token_break(*cp) && (*cp) != ':') cp++;
159 sfile_len = cp - sfile;
160 if ((*cp) == ':') cp++;
161 sline = 0;
162 while ((*cp) != '\0' && isdigit(*cp)) {
163 sline *= 10;
164 sline += (*cp) - '0';
165 cp++;
166 }
167 // "file:line!" means the assert suppression is not silent
168 noisy = ((*cp) == '!');
169 while ((*cp) != '\0' && !is_token_break(*cp)) cp++;
170 // match the line
171 if (sline != 0) {
172 if (sline != line_no) continue;
173 }
174 // match the file
175 if (sfile_len > 0) {
176 const char* look = file_name;
177 const char* look_max = file_name + file_name_len - sfile_len;
178 const char* foundp;
179 bool match = false;
180 while (!match
181 && (foundp = strchr(look, sfile[0])) != NULL
182 && foundp <= look_max) {
183 match = true;
184 for (int i = 1; i < sfile_len; i++) {
185 if (sfile[i] != foundp[i]) {
186 match = false;
187 break;
188 }
189 }
190 look = foundp + 1;
191 }
192 if (!match) continue;
193 }
194 // got a match!
195 if (noisy) {
196 fdStream out(defaultStream::output_fd());
197 out.print_raw("[error suppressed at ");
198 out.print_raw(base_name);
199 char buf[16];
200 jio_snprintf(buf, sizeof(buf), ":%d]", line_no);
201 out.print_raw_cr(buf);
202 } else {
203 // update 1-element cache for fast silent matches
204 last_file_name = file_name;
205 last_line_no = line_no;
206 }
207 return true;
208 }
209
210 if (!VMError::is_error_reported() && !SuppressFatalErrorMessage) {
211 // print a friendly hint:
212 fdStream out(defaultStream::output_fd());
213 out.print_raw_cr("# To suppress the following error report, specify this argument");
214 out.print_raw ("# after -XX: or in .hotspotrc: SuppressErrorAt=");
215 out.print_raw (base_name);
216 char buf[16];
217 jio_snprintf(buf, sizeof(buf), ":%d", line_no);
218 out.print_raw_cr(buf);
219 }
220 return false;
221 }
222
223 #undef is_token_break
224
225 #else
226
227 // Place-holder for non-existent suppression check:
228 #define error_is_suppressed(file_name, line_no) (false)
229
230 #endif // !PRODUCT
231
232 void report_vm_error(const char* file, int line, const char* error_msg)
233 {
234 report_vm_error(file, line, error_msg, "%s", "");
235 }
236
237 void report_vm_error(const char* file, int line, const char* error_msg, const char* detail_fmt, ...)
238 {
239 if (Debugging || error_is_suppressed(file, line)) return;
240 va_list detail_args;
241 va_start(detail_args, detail_fmt);
242 void* context = NULL;
243 #ifdef CAN_SHOW_REGISTERS_ON_ASSERT
244 if (g_assertion_context != NULL && os::current_thread_id() == g_asserting_thread) {
245 context = g_assertion_context;
246 }
247 #endif // CAN_SHOW_REGISTERS_ON_ASSERT
248
249 #ifdef ASSERT
250 if (detail_fmt != NULL && ExecutingUnitTests) {
251 // Special handling for the sake of gtest death tests which expect the assert
252 // message to be printed in one short line to stderr (see TEST_VM_ASSERT_MSG) and
253 // cannot be tweaked to accept our normal assert message.
254 va_list detail_args_copy;
255 va_copy(detail_args_copy, detail_args);
256 ::fputs("assert failed: ", stderr);
257 ::vfprintf(stderr, detail_fmt, detail_args_copy);
258 ::fputs("\n", stderr);
259 ::fflush(stderr);
260 va_end(detail_args_copy);
261 }
262 #endif
263
264 VMError::report_and_die(Thread::current_or_null(), context, file, line, error_msg, detail_fmt, detail_args);
265 va_end(detail_args);
266 }
267
268 void report_vm_status_error(const char* file, int line, const char* error_msg,
269 int status, const char* detail) {
270 report_vm_error(file, line, error_msg, "error %s(%d), %s", os::errno_name(status), status, detail);
271 }
272
273 void report_fatal(const char* file, int line, const char* detail_fmt, ...)
274 {
275 if (Debugging || error_is_suppressed(file, line)) return;
276 va_list detail_args;
277 va_start(detail_args, detail_fmt);
278 void* context = NULL;
279 #ifdef CAN_SHOW_REGISTERS_ON_ASSERT
280 if (g_assertion_context != NULL && os::current_thread_id() == g_asserting_thread) {
281 context = g_assertion_context;
282 }
283 #endif // CAN_SHOW_REGISTERS_ON_ASSERT
284 VMError::report_and_die(Thread::current_or_null(), context, file, line, "fatal error", detail_fmt, detail_args);
285 va_end(detail_args);
286 }
287
288 void report_vm_out_of_memory(const char* file, int line, size_t size,
289 VMErrorType vm_err_type, const char* detail_fmt, ...) {
290 if (Debugging) return;
291 va_list detail_args;
292 va_start(detail_args, detail_fmt);
293 VMError::report_and_die(Thread::current_or_null(), file, line, size, vm_err_type, detail_fmt, detail_args);
294 va_end(detail_args);
295
296 // The UseOSErrorReporting option in report_and_die() may allow a return
297 // to here. If so then we'll have to figure out how to handle it.
298 guarantee(false, "report_and_die() should not return here");
299 }
300
301 void report_should_not_call(const char* file, int line) {
302 report_vm_error(file, line, "ShouldNotCall()");
303 }
304
305 void report_should_not_reach_here(const char* file, int line) {
306 report_vm_error(file, line, "ShouldNotReachHere()");
307 }
308
309 void report_unimplemented(const char* file, int line) {
310 report_vm_error(file, line, "Unimplemented()");
311 }
312
313 void report_untested(const char* file, int line, const char* message) {
314 #ifndef PRODUCT
315 warning("Untested: %s in %s: %d\n", message, file, line);
316 #endif // !PRODUCT
317 }
318
319 void report_java_out_of_memory(const char* message) {
320 static int out_of_memory_reported = 0;
321
322 // A number of threads may attempt to report OutOfMemoryError at around the
323 // same time. To avoid dumping the heap or executing the data collection
324 // commands multiple times we just do it once when the first threads reports
325 // the error.
326 if (Atomic::cmpxchg(1, &out_of_memory_reported, 0) == 0) {
327 // create heap dump before OnOutOfMemoryError commands are executed
328 if (HeapDumpOnOutOfMemoryError) {
329 tty->print_cr("java.lang.OutOfMemoryError: %s", message);
330 HeapDumper::dump_heap_from_oome();
331 }
332
333 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
334 VMError::report_java_out_of_memory(message);
335 }
336
337 if (CrashOnOutOfMemoryError) {
338 tty->print_cr("Aborting due to java.lang.OutOfMemoryError: %s", message);
339 fatal("OutOfMemory encountered: %s", message);
340 }
341
342 if (ExitOnOutOfMemoryError) {
343 tty->print_cr("Terminating due to java.lang.OutOfMemoryError: %s", message);
344 os::exit(3);
345 }
346 }
347 }
348
349 // ------ helper functions for debugging go here ------------
350
351 // All debug entries should be wrapped with a stack allocated
352 // Command object. It makes sure a resource mark is set and
353 // flushes the logfile to prevent file sharing problems.
354
355 class Command : public StackObj {
356 private:
357 ResourceMark rm;
358 ResetNoHandleMark rnhm;
359 HandleMark hm;
360 bool debug_save;
361 public:
362 static int level;
363 Command(const char* str) {
364 debug_save = Debugging;
365 Debugging = true;
366 if (level++ > 0) return;
367 tty->cr();
368 tty->print_cr("\"Executing %s\"", str);
369 }
370
371 ~Command() {
372 tty->flush();
373 Debugging = debug_save;
374 level--;
375 }
376 };
377
378 int Command::level = 0;
379
380 #ifndef PRODUCT
381
382 extern "C" void blob(CodeBlob* cb) {
383 Command c("blob");
384 cb->print();
385 }
386
387
388 extern "C" void dump_vtable(address p) {
389 Command c("dump_vtable");
390 Klass* k = (Klass*)p;
391 k->vtable().print();
392 }
393
394
395 extern "C" void nm(intptr_t p) {
396 // Actually we look through all CodeBlobs (the nm name has been kept for backwards compatability)
397 Command c("nm");
398 CodeBlob* cb = CodeCache::find_blob((address)p);
399 if (cb == NULL) {
400 tty->print_cr("NULL");
401 } else {
402 cb->print();
403 }
404 }
405
406
407 extern "C" void disnm(intptr_t p) {
408 Command c("disnm");
409 CodeBlob* cb = CodeCache::find_blob((address) p);
410 if (cb != NULL) {
411 nmethod* nm = cb->as_nmethod_or_null();
412 if (nm != NULL) {
413 nm->print();
414 } else {
415 cb->print();
416 }
417 Disassembler::decode(cb);
418 }
419 }
420
421
422 extern "C" void printnm(intptr_t p) {
423 char buffer[256];
424 sprintf(buffer, "printnm: " INTPTR_FORMAT, p);
425 Command c(buffer);
426 CodeBlob* cb = CodeCache::find_blob((address) p);
427 if (cb->is_nmethod()) {
428 nmethod* nm = (nmethod*)cb;
429 nm->print_nmethod(true);
430 }
431 }
432
433
434 extern "C" void universe() {
435 Command c("universe");
436 Universe::print_on(tty);
437 }
438
439
440 extern "C" void verify() {
441 // try to run a verify on the entire system
442 // note: this may not be safe if we're not at a safepoint; for debugging,
443 // this manipulates the safepoint settings to avoid assertion failures
444 Command c("universe verify");
445 bool safe = SafepointSynchronize::is_at_safepoint();
446 if (!safe) {
447 tty->print_cr("warning: not at safepoint -- verify may fail");
448 SafepointSynchronize::set_is_at_safepoint();
449 }
450 // Ensure Eden top is correct before verification
451 Universe::heap()->prepare_for_verify();
452 Universe::verify();
453 if (!safe) SafepointSynchronize::set_is_not_at_safepoint();
454 }
455
456
457 extern "C" void pp(void* p) {
458 Command c("pp");
459 FlagSetting fl(PrintVMMessages, true);
460 FlagSetting f2(DisplayVMOutput, true);
461 if (Universe::heap()->is_in(p)) {
462 oop obj = oop(p);
463 obj->print();
464 } else {
465 tty->print(PTR_FORMAT, p2i(p));
466 }
467 }
468
469
470 // pv: print vm-printable object
471 extern "C" void pa(intptr_t p) { ((AllocatedObj*) p)->print(); }
472 extern "C" void findpc(intptr_t x);
473
474 #endif // !PRODUCT
475
476 extern "C" void ps() { // print stack
477 if (Thread::current_or_null() == NULL) return;
478 Command c("ps");
479
480
481 // Prints the stack of the current Java thread
482 JavaThread* p = JavaThread::active();
483 tty->print(" for thread: ");
484 p->print();
485 tty->cr();
486
487 if (p->has_last_Java_frame()) {
488 // If the last_Java_fp is set we are in C land and
489 // can call the standard stack_trace function.
490 #ifdef PRODUCT
491 p->print_stack();
492 } else {
493 tty->print_cr("Cannot find the last Java frame, printing stack disabled.");
494 #else // !PRODUCT
495 p->trace_stack();
496 } else {
497 frame f = os::current_frame();
498 RegisterMap reg_map(p);
499 f = f.sender(®_map);
500 tty->print("(guessing starting frame id=" PTR_FORMAT " based on current fp)\n", p2i(f.id()));
501 p->trace_stack_from(vframe::new_vframe(&f, ®_map, p));
502 f.pd_ps();
503 #endif // PRODUCT
504 }
505
506 }
507
508 extern "C" void pfl() {
509 // print frame layout
510 Command c("pfl");
511 JavaThread* p = JavaThread::active();
512 tty->print(" for thread: ");
513 p->print();
514 tty->cr();
515 if (p->has_last_Java_frame()) {
516 p->print_frame_layout();
517 }
518 }
519
520 #ifndef PRODUCT
521
522 extern "C" void psf() { // print stack frames
523 {
524 Command c("psf");
525 JavaThread* p = JavaThread::active();
526 tty->print(" for thread: ");
527 p->print();
528 tty->cr();
529 if (p->has_last_Java_frame()) {
530 p->trace_frames();
531 }
532 }
533 }
534
535
536 extern "C" void threads() {
537 Command c("threads");
538 Threads::print(false, true);
539 }
540
541
542 extern "C" void psd() {
543 Command c("psd");
544 SystemDictionary::print();
545 }
546
547 #endif // !PRODUCT
548
549 extern "C" void pss() { // print all stacks
550 if (Thread::current_or_null() == NULL) return;
551 Command c("pss");
552 Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true));
553 }
554
555 #ifndef PRODUCT
556
557 extern "C" void debug() { // to set things up for compiler debugging
558 Command c("debug");
559 WizardMode = true;
560 PrintVMMessages = PrintCompilation = true;
561 PrintInlining = PrintAssembly = true;
562 tty->flush();
563 }
564
565
566 extern "C" void ndebug() { // undo debug()
567 Command c("ndebug");
568 PrintCompilation = false;
569 PrintInlining = PrintAssembly = false;
570 tty->flush();
571 }
572
573
574 extern "C" void flush() {
575 Command c("flush");
576 tty->flush();
577 }
578
579 extern "C" void events() {
580 Command c("events");
581 Events::print();
582 }
583
584 extern "C" Method* findm(intptr_t pc) {
585 Command c("findm");
586 nmethod* nm = CodeCache::find_nmethod((address)pc);
587 return (nm == NULL) ? (Method*)NULL : nm->method();
588 }
589
590
591 extern "C" nmethod* findnm(intptr_t addr) {
592 Command c("findnm");
593 return CodeCache::find_nmethod((address)addr);
594 }
595
596 // Another interface that isn't ambiguous in dbx.
597 // Can we someday rename the other find to hsfind?
598 extern "C" void hsfind(intptr_t x) {
599 Command c("hsfind");
600 os::print_location(tty, x, false);
601 }
602
603
604 extern "C" void find(intptr_t x) {
605 Command c("find");
606 os::print_location(tty, x, false);
607 }
608
609
610 extern "C" void findpc(intptr_t x) {
611 Command c("findpc");
612 os::print_location(tty, x, true);
613 }
614
615
616 // Need method pointer to find bcp, when not in permgen.
617 extern "C" void findbcp(intptr_t method, intptr_t bcp) {
618 Command c("findbcp");
619 Method* mh = (Method*)method;
620 if (!mh->is_native()) {
621 tty->print_cr("bci_from(%p) = %d; print_codes():",
622 mh, mh->bci_from(address(bcp)));
623 mh->print_codes_on(tty);
624 }
625 }
626
627 // int versions of all methods to avoid having to type type casts in the debugger
628
629 void pp(intptr_t p) { pp((void*)p); }
630 void pp(oop p) { pp((void*)p); }
631
632 void help() {
633 Command c("help");
634 tty->print_cr("basic");
635 tty->print_cr(" pp(void* p) - try to make sense of p");
636 tty->print_cr(" pv(intptr_t p)- ((PrintableResourceObj*) p)->print()");
637 tty->print_cr(" ps() - print current thread stack");
638 tty->print_cr(" pss() - print all thread stacks");
639 tty->print_cr(" pm(int pc) - print Method* given compiled PC");
640 tty->print_cr(" findm(intptr_t pc) - finds Method*");
641 tty->print_cr(" find(intptr_t x) - finds & prints nmethod/stub/bytecode/oop based on pointer into it");
642 tty->print_cr(" pns(void* sp, void* fp, void* pc) - print native (i.e. mixed) stack trace. E.g.");
643 tty->print_cr(" pns($sp, $rbp, $pc) on Linux/amd64 and Solaris/amd64 or");
644 tty->print_cr(" pns($sp, $ebp, $pc) on Linux/x86 or");
645 tty->print_cr(" pns($sp, 0, $pc) on Linux/ppc64 or");
646 tty->print_cr(" pns($sp, $s8, $pc) on Linux/mips or");
647 tty->print_cr(" pns($sp + 0x7ff, 0, $pc) on Solaris/SPARC");
648 tty->print_cr(" - in gdb do 'set overload-resolution off' before calling pns()");
649 tty->print_cr(" - in dbx do 'frame 1' before calling pns()");
650
651 tty->print_cr("misc.");
652 tty->print_cr(" flush() - flushes the log file");
653 tty->print_cr(" events() - dump events from ring buffers");
654
655
656 tty->print_cr("compiler debugging");
657 tty->print_cr(" debug() - to set things up for compiler debugging");
658 tty->print_cr(" ndebug() - undo debug");
659 }
660
661 extern "C" void pns(void* sp, void* fp, void* pc) { // print native stack
662 Command c("pns");
663 static char buf[O_BUFLEN];
664 Thread* t = Thread::current_or_null();
665 // Call generic frame constructor (certain arguments may be ignored)
666 frame fr(sp, fp, pc);
667 VMError::print_native_stack(tty, fr, t, buf, sizeof(buf));
668 }
669
670 //
671 // This version of pns() will not work when called from the debugger, but is
672 // useful when called from within hotspot code. The advantages over pns()
673 // are not having to pass in any arguments, and it will work on Windows/x64.
674 //
675 // WARNING: Only intended for use when debugging. Do not leave calls to
676 // pns2() in committed source (product or debug).
677 //
678 extern "C" void pns2() { // print native stack
679 Command c("pns2");
680 static char buf[O_BUFLEN];
681 if (os::platform_print_native_stack(tty, NULL, buf, sizeof(buf))) {
682 // We have printed the native stack in platform-specific code,
683 // so nothing else to do in this case.
684 } else {
685 Thread* t = Thread::current_or_null();
686 frame fr = os::current_frame();
687 VMError::print_native_stack(tty, fr, t, buf, sizeof(buf));
688 }
689 }
690
691 #endif // !PRODUCT
692
693 //////////////////////////////////////////////////////////////////////////////
694 // Test multiple STATIC_ASSERT forms in various scopes.
695
696 #ifndef PRODUCT
697
698 // namespace scope
699 STATIC_ASSERT(true);
700 STATIC_ASSERT(true);
701 STATIC_ASSERT(1 == 1);
702 STATIC_ASSERT(0 == 0);
703
704 void test_multiple_static_assert_forms_in_function_scope() {
705 STATIC_ASSERT(true);
706 STATIC_ASSERT(true);
707 STATIC_ASSERT(0 == 0);
708 STATIC_ASSERT(1 == 1);
709 }
710
711 // class scope
712 struct TestMultipleStaticAssertFormsInClassScope {
713 STATIC_ASSERT(true);
714 STATIC_ASSERT(true);
715 STATIC_ASSERT(0 == 0);
716 STATIC_ASSERT(1 == 1);
717 };
718
719 #endif // !PRODUCT
720
721 // Support for showing register content on asserts/guarantees.
722 #ifdef CAN_SHOW_REGISTERS_ON_ASSERT
723
724 static ucontext_t g_stored_assertion_context;
725
726 void initialize_assert_poison() {
727 char* page = os::reserve_memory(os::vm_page_size());
728 if (page) {
729 MemTracker::record_virtual_memory_type(page, mtInternal);
730 if (os::commit_memory(page, os::vm_page_size(), false) &&
731 os::protect_memory(page, os::vm_page_size(), os::MEM_PROT_NONE)) {
732 g_assert_poison = page;
733 }
734 }
735 }
736
737 static void store_context(const void* context) {
738 memcpy(&g_stored_assertion_context, context, sizeof(ucontext_t));
739 #if defined(__linux) && defined(PPC64)
740 // on Linux ppc64, ucontext_t contains pointers into itself which have to be patched up
741 // after copying the context (see comment in sys/ucontext.h):
742 *((void**) &g_stored_assertion_context.uc_mcontext.regs) = &(g_stored_assertion_context.uc_mcontext.gp_regs);
743 #endif
744 }
745
746 bool handle_assert_poison_fault(const void* ucVoid, const void* faulting_address) {
747 if (faulting_address == g_assert_poison) {
748 // Disarm poison page.
749 os::protect_memory((char*)g_assert_poison, os::vm_page_size(), os::MEM_PROT_RWX);
750 // Store Context away.
751 if (ucVoid) {
752 const intx my_tid = os::current_thread_id();
753 if (Atomic::cmpxchg(my_tid, &g_asserting_thread, (intx)0) == 0) {
754 store_context(ucVoid);
755 g_assertion_context = &g_stored_assertion_context;
756 }
757 }
758 return true;
759 }
760 return false;
761 }
762 #endif // CAN_SHOW_REGISTERS_ON_ASSERT
763