1 /*
2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/systemDictionary.hpp"
27 #include "code/codeCache.hpp"
28 #include "code/icBuffer.hpp"
29 #include "code/nmethod.hpp"
30 #include "code/vtableStubs.hpp"
31 #include "compiler/compileBroker.hpp"
32 #include "compiler/disassembler.hpp"
33 #include "gc_implementation/shared/markSweep.hpp"
34 #include "gc_interface/collectedHeap.hpp"
35 #include "interpreter/bytecodeHistogram.hpp"
36 #include "interpreter/interpreter.hpp"
37 #include "memory/resourceArea.hpp"
38 #include "memory/universe.hpp"
39 #include "oops/oop.inline.hpp"
40 #include "prims/privilegedStack.hpp"
41 #include "runtime/arguments.hpp"
42 #include "runtime/atomic.inline.hpp"
43 #include "runtime/frame.hpp"
44 #include "runtime/java.hpp"
45 #include "runtime/os.hpp"
46 #include "runtime/sharedRuntime.hpp"
47 #include "runtime/stubCodeGenerator.hpp"
48 #include "runtime/stubRoutines.hpp"
49 #include "runtime/thread.inline.hpp"
50 #include "runtime/vframe.hpp"
51 #include "runtime/vm_version.hpp"
52 #include "services/heapDumper.hpp"
53 #include "utilities/defaultStream.hpp"
54 #include "utilities/events.hpp"
55 #include "utilities/top.hpp"
56 #include "utilities/vmError.hpp"
57
58 #ifndef ASSERT
59 # ifdef _DEBUG
60 // NOTE: don't turn the lines below into a comment -- if you're getting
61 // a compile error here, change the settings to define ASSERT
62 ASSERT should be defined when _DEBUG is defined. It is not intended to be used for debugging
63 functions that do not slow down the system too much and thus can be left in optimized code.
64 On the other hand, the code should not be included in a production version.
65 # endif // _DEBUG
66 #endif // ASSERT
67
68
69 #ifdef _DEBUG
70 # ifndef ASSERT
71 configuration error: ASSERT must be defined in debug version
72 # endif // ASSERT
73 #endif // _DEBUG
74
75
76 #ifdef PRODUCT
77 # if -defined _DEBUG || -defined ASSERT
78 configuration error: ASSERT et al. must not be defined in PRODUCT version
79 # endif
80 #endif // PRODUCT
81
82 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
83
84 FormatBufferResource::FormatBufferResource(const char * format, ...)
85 : FormatBufferBase((char*)resource_allocate_bytes(RES_BUFSZ)) {
86 va_list argp;
87 va_start(argp, format);
88 jio_vsnprintf(_buf, RES_BUFSZ, format, argp);
89 va_end(argp);
90 }
91
92 ATTRIBUTE_PRINTF(1, 2)
93 void warning(const char* format, ...) {
94 if (PrintWarnings) {
95 FILE* const err = defaultStream::error_stream();
96 jio_fprintf(err, "%s warning: ", VM_Version::vm_name());
97 va_list ap;
98 va_start(ap, format);
99 vfprintf(err, format, ap);
100 va_end(ap);
101 fputc('\n', err);
102 }
103 if (BreakAtWarning) BREAKPOINT;
104 }
105
106 #ifndef PRODUCT
107
108 #define is_token_break(ch) (isspace(ch) || (ch) == ',')
109
110 static const char* last_file_name = NULL;
111 static int last_line_no = -1;
112
113 // assert/guarantee/... may happen very early during VM initialization.
114 // Don't rely on anything that is initialized by Threads::create_vm(). For
115 // example, don't use tty.
116 bool error_is_suppressed(const char* file_name, int line_no) {
117 // The following 1-element cache requires that passed-in
118 // file names are always only constant literals.
119 if (file_name == last_file_name && line_no == last_line_no) return true;
120
121 int file_name_len = (int)strlen(file_name);
122 char separator = os::file_separator()[0];
123 const char* base_name = strrchr(file_name, separator);
124 if (base_name == NULL)
125 base_name = file_name;
126
127 // scan the SuppressErrorAt option
128 const char* cp = SuppressErrorAt;
129 for (;;) {
130 const char* sfile;
131 int sfile_len;
132 int sline;
133 bool noisy;
134 while ((*cp) != '\0' && is_token_break(*cp)) cp++;
135 if ((*cp) == '\0') break;
136 sfile = cp;
137 while ((*cp) != '\0' && !is_token_break(*cp) && (*cp) != ':') cp++;
138 sfile_len = cp - sfile;
139 if ((*cp) == ':') cp++;
140 sline = 0;
141 while ((*cp) != '\0' && isdigit(*cp)) {
142 sline *= 10;
143 sline += (*cp) - '0';
144 cp++;
145 }
146 // "file:line!" means the assert suppression is not silent
147 noisy = ((*cp) == '!');
148 while ((*cp) != '\0' && !is_token_break(*cp)) cp++;
149 // match the line
150 if (sline != 0) {
151 if (sline != line_no) continue;
152 }
153 // match the file
154 if (sfile_len > 0) {
155 const char* look = file_name;
156 const char* look_max = file_name + file_name_len - sfile_len;
157 const char* foundp;
158 bool match = false;
159 while (!match
160 && (foundp = strchr(look, sfile[0])) != NULL
161 && foundp <= look_max) {
162 match = true;
163 for (int i = 1; i < sfile_len; i++) {
164 if (sfile[i] != foundp[i]) {
165 match = false;
166 break;
167 }
168 }
169 look = foundp + 1;
170 }
171 if (!match) continue;
172 }
173 // got a match!
174 if (noisy) {
175 fdStream out(defaultStream::output_fd());
176 out.print_raw("[error suppressed at ");
177 out.print_raw(base_name);
178 char buf[16];
179 jio_snprintf(buf, sizeof(buf), ":%d]", line_no);
180 out.print_raw_cr(buf);
181 } else {
182 // update 1-element cache for fast silent matches
183 last_file_name = file_name;
184 last_line_no = line_no;
185 }
186 return true;
187 }
188
189 if (!is_error_reported()) {
190 // print a friendly hint:
191 fdStream out(defaultStream::output_fd());
192 out.print_raw_cr("# To suppress the following error report, specify this argument");
193 out.print_raw ("# after -XX: or in .hotspotrc: SuppressErrorAt=");
194 out.print_raw (base_name);
195 char buf[16];
196 jio_snprintf(buf, sizeof(buf), ":%d", line_no);
197 out.print_raw_cr(buf);
198 }
199 return false;
200 }
201
202 #undef is_token_break
203
204 #else
205
206 // Place-holder for non-existent suppression check:
207 #define error_is_suppressed(file_name, line_no) (false)
208
209 #endif // !PRODUCT
210
211 void report_vm_error(const char* file, int line, const char* error_msg,
212 const char* detail_msg)
213 {
214 if (Debugging || error_is_suppressed(file, line)) return;
215 Thread* const thread = ThreadLocalStorage::get_thread_slow();
216 VMError err(thread, file, line, error_msg, detail_msg);
217 err.report_and_die();
218 }
219
220 void report_fatal(const char* file, int line, const char* message)
221 {
222 report_vm_error(file, line, "fatal error", message);
223 }
224
225 void report_vm_out_of_memory(const char* file, int line, size_t size,
226 VMErrorType vm_err_type, const char* message) {
227 if (Debugging) return;
228
229 Thread* thread = ThreadLocalStorage::get_thread_slow();
230 VMError(thread, file, line, size, vm_err_type, message).report_and_die();
231
232 // The UseOSErrorReporting option in report_and_die() may allow a return
233 // to here. If so then we'll have to figure out how to handle it.
234 guarantee(false, "report_and_die() should not return here");
235 }
236
237 void report_should_not_call(const char* file, int line) {
238 report_vm_error(file, line, "ShouldNotCall()");
239 }
240
241 void report_should_not_reach_here(const char* file, int line) {
242 report_vm_error(file, line, "ShouldNotReachHere()");
243 }
244
245 void report_unimplemented(const char* file, int line) {
246 report_vm_error(file, line, "Unimplemented()");
247 }
248
249 void report_untested(const char* file, int line, const char* message) {
250 #ifndef PRODUCT
251 warning("Untested: %s in %s: %d\n", message, file, line);
252 #endif // !PRODUCT
253 }
254
255 void report_out_of_shared_space(SharedSpaceType shared_space) {
256 static const char* name[] = {
257 "shared read only space",
258 "shared read write space",
259 "shared miscellaneous data space"
260 };
261 static const char* flag[] = {
262 "SharedReadOnlySize",
263 "SharedReadWriteSize",
264 "SharedMiscDataSize"
265 };
266
267 warning("\nThe %s is not large enough\n"
268 "to preload requested classes. Use -XX:%s=\n"
269 "to increase the initial size of %s.\n",
270 name[shared_space], flag[shared_space], name[shared_space]);
271 exit(2);
272 }
273
274 void report_java_out_of_memory(const char* message) {
275 static jint out_of_memory_reported = 0;
276
277 // A number of threads may attempt to report OutOfMemoryError at around the
278 // same time. To avoid dumping the heap or executing the data collection
279 // commands multiple times we just do it once when the first threads reports
280 // the error.
281 if (Atomic::cmpxchg(1, &out_of_memory_reported, 0) == 0) {
282 // create heap dump before OnOutOfMemoryError commands are executed
283 if (HeapDumpOnOutOfMemoryError) {
284 tty->print_cr("java.lang.OutOfMemoryError: %s", message);
285 HeapDumper::dump_heap_from_oome();
286 }
287
288 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
289 VMError err(message);
290 err.report_java_out_of_memory();
291 }
292 }
293 }
294
295 static bool error_reported = false;
296
297 // call this when the VM is dying--it might loosen some asserts
298 void set_error_reported() {
299 error_reported = true;
300 }
301
302 bool is_error_reported() {
303 return error_reported;
304 }
305
306 #ifndef PRODUCT
307 #include <signal.h>
308
309 void test_error_handler() {
310 uintx test_num = ErrorHandlerTest;
311 if (test_num == 0) return;
312
313 // If asserts are disabled, use the corresponding guarantee instead.
314 size_t n = test_num;
315 NOT_DEBUG(if (n <= 2) n += 2);
316
317 const char* const str = "hello";
318 const size_t num = (size_t)os::vm_page_size();
319
320 const char* const eol = os::line_separator();
321 const char* const msg = "this message should be truncated during formatting";
322 char * const dataPtr = NULL; // bad data pointer
323 const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer
324
325 // Keep this in sync with test/runtime/6888954/vmerrors.sh.
326 switch (n) {
327 case 1: assert(str == NULL, "expected null");
328 case 2: assert(num == 1023 && *str == 'X',
329 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
330 case 3: guarantee(str == NULL, "expected null");
331 case 4: guarantee(num == 1023 && *str == 'X',
332 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
333 case 5: fatal("expected null");
334 case 6: fatal(err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
335 case 7: fatal(err_msg("%s%s# %s%s# %s%s# %s%s# %s%s# "
336 "%s%s# %s%s# %s%s# %s%s# %s%s# "
337 "%s%s# %s%s# %s%s# %s%s# %s",
338 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
339 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
340 msg, eol, msg, eol, msg, eol, msg, eol, msg));
341 case 8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate");
342 case 9: ShouldNotCallThis();
343 case 10: ShouldNotReachHere();
344 case 11: Unimplemented();
345 // There's no guarantee the bad data pointer will crash us
346 // so "break" out to the ShouldNotReachHere().
347 case 12: *dataPtr = '\0'; break;
348 // There's no guarantee the bad function pointer will crash us
349 // so "break" out to the ShouldNotReachHere().
350 case 13: (*funcPtr)(); break;
351
352 default: tty->print_cr("ERROR: %d: unexpected test_num value.", n);
353 }
354 ShouldNotReachHere();
355 }
356 #endif // !PRODUCT
357
358 // ------ helper functions for debugging go here ------------
359
360 // All debug entries should be wrapped with a stack allocated
361 // Command object. It makes sure a resource mark is set and
362 // flushes the logfile to prevent file sharing problems.
363
364 class Command : public StackObj {
365 private:
366 ResourceMark rm;
367 ResetNoHandleMark rnhm;
368 HandleMark hm;
369 bool debug_save;
370 public:
371 static int level;
372 Command(const char* str) {
373 debug_save = Debugging;
374 Debugging = true;
375 if (level++ > 0) return;
376 tty->cr();
377 tty->print_cr("\"Executing %s\"", str);
378 }
379
380 ~Command() {
381 tty->flush();
382 Debugging = debug_save;
383 level--;
384 }
385 };
386
387 int Command::level = 0;
388
389 #ifndef PRODUCT
390
391 extern "C" void blob(CodeBlob* cb) {
392 Command c("blob");
393 cb->print();
394 }
395
396
397 extern "C" void dump_vtable(address p) {
398 Command c("dump_vtable");
399 Klass* k = (Klass*)p;
400 InstanceKlass::cast(k)->vtable()->print();
401 }
402
403
404 extern "C" void nm(intptr_t p) {
405 // Actually we look through all CodeBlobs (the nm name has been kept for backwards compatability)
406 Command c("nm");
407 CodeBlob* cb = CodeCache::find_blob((address)p);
408 if (cb == NULL) {
409 tty->print_cr("NULL");
410 } else {
411 cb->print();
412 }
413 }
414
415
416 extern "C" void disnm(intptr_t p) {
417 Command c("disnm");
418 CodeBlob* cb = CodeCache::find_blob((address) p);
419 nmethod* nm = cb->as_nmethod_or_null();
420 if (nm) {
421 nm->print();
422 Disassembler::decode(nm);
423 } else {
424 cb->print();
425 Disassembler::decode(cb);
426 }
427 }
428
429
430 extern "C" void printnm(intptr_t p) {
431 char buffer[256];
432 sprintf(buffer, "printnm: " INTPTR_FORMAT, p);
433 Command c(buffer);
434 CodeBlob* cb = CodeCache::find_blob((address) p);
435 if (cb->is_nmethod()) {
436 nmethod* nm = (nmethod*)cb;
437 nm->print_nmethod(true);
438 }
439 }
440
441
442 extern "C" void universe() {
443 Command c("universe");
444 Universe::print();
445 }
446
447
448 extern "C" void verify() {
449 // try to run a verify on the entire system
450 // note: this may not be safe if we're not at a safepoint; for debugging,
451 // this manipulates the safepoint settings to avoid assertion failures
452 Command c("universe verify");
453 bool safe = SafepointSynchronize::is_at_safepoint();
454 if (!safe) {
455 tty->print_cr("warning: not at safepoint -- verify may fail");
456 SafepointSynchronize::set_is_at_safepoint();
457 }
458 // Ensure Eden top is correct before verification
459 Universe::heap()->prepare_for_verify();
460 Universe::verify();
461 if (!safe) SafepointSynchronize::set_is_not_at_safepoint();
462 }
463
464
465 extern "C" void pp(void* p) {
466 Command c("pp");
467 FlagSetting fl(PrintVMMessages, true);
468 FlagSetting f2(DisplayVMOutput, true);
469 if (Universe::heap()->is_in(p)) {
470 oop obj = oop(p);
471 obj->print();
472 } else {
473 tty->print(PTR_FORMAT, p);
474 }
475 }
476
477
478 // pv: print vm-printable object
479 extern "C" void pa(intptr_t p) { ((AllocatedObj*) p)->print(); }
480 extern "C" void findpc(intptr_t x);
481
482 #endif // !PRODUCT
483
484 extern "C" void ps() { // print stack
485 if (Thread::current() == NULL) return;
486 Command c("ps");
487
488
489 // Prints the stack of the current Java thread
490 JavaThread* p = JavaThread::active();
491 tty->print(" for thread: ");
492 p->print();
493 tty->cr();
494
495 if (p->has_last_Java_frame()) {
496 // If the last_Java_fp is set we are in C land and
497 // can call the standard stack_trace function.
498 #ifdef PRODUCT
499 p->print_stack();
500 } else {
501 tty->print_cr("Cannot find the last Java frame, printing stack disabled.");
502 #else // !PRODUCT
503 p->trace_stack();
504 } else {
505 frame f = os::current_frame();
506 RegisterMap reg_map(p);
507 f = f.sender(®_map);
508 tty->print("(guessing starting frame id=%#p based on current fp)\n", f.id());
509 p->trace_stack_from(vframe::new_vframe(&f, ®_map, p));
510 pd_ps(f);
511 #endif // PRODUCT
512 }
513
514 }
515
516 extern "C" void pfl() {
517 // print frame layout
518 Command c("pfl");
519 JavaThread* p = JavaThread::active();
520 tty->print(" for thread: ");
521 p->print();
522 tty->cr();
523 if (p->has_last_Java_frame()) {
524 p->print_frame_layout();
525 }
526 }
527
528 #ifndef PRODUCT
529
530 extern "C" void psf() { // print stack frames
531 {
532 Command c("psf");
533 JavaThread* p = JavaThread::active();
534 tty->print(" for thread: ");
535 p->print();
536 tty->cr();
537 if (p->has_last_Java_frame()) {
538 p->trace_frames();
539 }
540 }
541 }
542
543
544 extern "C" void threads() {
545 Command c("threads");
546 Threads::print(false, true);
547 }
548
549
550 extern "C" void psd() {
551 Command c("psd");
552 SystemDictionary::print();
553 }
554
555
556 extern "C" void safepoints() {
557 Command c("safepoints");
558 SafepointSynchronize::print_state();
559 }
560
561 #endif // !PRODUCT
562
563 extern "C" void pss() { // print all stacks
564 if (Thread::current() == NULL) return;
565 Command c("pss");
566 Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true));
567 }
568
569 #ifndef PRODUCT
570
571 extern "C" void debug() { // to set things up for compiler debugging
572 Command c("debug");
573 WizardMode = true;
574 PrintVMMessages = PrintCompilation = true;
575 PrintInlining = PrintAssembly = true;
576 tty->flush();
577 }
578
579
580 extern "C" void ndebug() { // undo debug()
581 Command c("ndebug");
582 PrintCompilation = false;
583 PrintInlining = PrintAssembly = false;
584 tty->flush();
585 }
586
587
588 extern "C" void flush() {
589 Command c("flush");
590 tty->flush();
591 }
592
593 extern "C" void events() {
594 Command c("events");
595 Events::print();
596 }
597
598 extern "C" Method* findm(intptr_t pc) {
599 Command c("findm");
600 nmethod* nm = CodeCache::find_nmethod((address)pc);
601 return (nm == NULL) ? (Method*)NULL : nm->method();
602 }
603
604
605 extern "C" nmethod* findnm(intptr_t addr) {
606 Command c("findnm");
607 return CodeCache::find_nmethod((address)addr);
608 }
609
610 // Another interface that isn't ambiguous in dbx.
611 // Can we someday rename the other find to hsfind?
612 extern "C" void hsfind(intptr_t x) {
613 Command c("hsfind");
614 os::print_location(tty, x, false);
615 }
616
617
618 extern "C" void find(intptr_t x) {
619 Command c("find");
620 os::print_location(tty, x, false);
621 }
622
623
624 extern "C" void findpc(intptr_t x) {
625 Command c("findpc");
626 os::print_location(tty, x, true);
627 }
628
629
630 // Need method pointer to find bcp, when not in permgen.
631 extern "C" void findbcp(intptr_t method, intptr_t bcp) {
632 Command c("findbcp");
633 Method* mh = (Method*)method;
634 if (!mh->is_native()) {
635 tty->print_cr("bci_from(%p) = %d; print_codes():",
636 mh, mh->bci_from(address(bcp)));
637 mh->print_codes_on(tty);
638 }
639 }
640
641 // int versions of all methods to avoid having to type type casts in the debugger
642
643 void pp(intptr_t p) { pp((void*)p); }
644 void pp(oop p) { pp((void*)p); }
645
646 void help() {
647 Command c("help");
648 tty->print_cr("basic");
649 tty->print_cr(" pp(void* p) - try to make sense of p");
650 tty->print_cr(" pv(intptr_t p)- ((PrintableResourceObj*) p)->print()");
651 tty->print_cr(" ps() - print current thread stack");
652 tty->print_cr(" pss() - print all thread stacks");
653 tty->print_cr(" pm(int pc) - print Method* given compiled PC");
654 tty->print_cr(" findm(intptr_t pc) - finds Method*");
655 tty->print_cr(" find(intptr_t x) - finds & prints nmethod/stub/bytecode/oop based on pointer into it");
656
657 tty->print_cr("misc.");
658 tty->print_cr(" flush() - flushes the log file");
659 tty->print_cr(" events() - dump events from ring buffers");
660
661
662 tty->print_cr("compiler debugging");
663 tty->print_cr(" debug() - to set things up for compiler debugging");
664 tty->print_cr(" ndebug() - undo debug");
665 }
666
667 #endif // !PRODUCT
668
669 void print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size) {
670
671 // see if it's a valid frame
672 if (fr.pc()) {
673 st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)");
674
675 int count = 0;
676 while (count++ < StackPrintLimit) {
677 fr.print_on_error(st, buf, buf_size);
678 st->cr();
679 // Compiled code may use EBP register on x86 so it looks like
680 // non-walkable C frame. Use frame.sender() for java frames.
681 if (t && t->is_Java_thread()) {
682 // Catch very first native frame by using stack address.
683 // For JavaThread stack_base and stack_size should be set.
684 if (!t->on_local_stack((address)(fr.sender_sp() + 1))) {
685 break;
686 }
687 if (fr.is_java_frame()) {
688 RegisterMap map((JavaThread*)t, false); // No update
689 fr = fr.sender(&map);
690 } else {
691 fr = os::get_sender_for_C_frame(&fr);
692 }
693 } else {
694 // is_first_C_frame() does only simple checks for frame pointer,
695 // it will pass if java compiled code has a pointer in EBP.
696 if (os::is_first_C_frame(&fr)) break;
697 fr = os::get_sender_for_C_frame(&fr);
698 }
699 }
700
701 if (count > StackPrintLimit) {
702 st->print_cr("...<more frames>...");
703 }
704
705 st->cr();
706 }
707 }
708
709 #ifndef PRODUCT
710
711 extern "C" void pns(frame fr) { // print native stack
712 Command c("pns");
713 static char buf[O_BUFLEN];
714 Thread* t = ThreadLocalStorage::get_thread_slow();
715 print_native_stack(tty, fr, t, buf, sizeof(buf));
716 }
717
718 #endif // !PRODUCT