137 ResourceMark rm;
138 assert(h_exception() != NULL, "exception should not be NULL");
139
140 // tracing (do this up front - so it works during boot strapping)
141 if (TraceExceptions) {
142 ttyLocker ttyl;
143 tty->print_cr("Exception <%s%s%s> (" INTPTR_FORMAT ") \n"
144 "thrown [%s, line %d]\nfor thread " INTPTR_FORMAT,
145 h_exception->print_value_string(),
146 message ? ": " : "", message ? message : "",
147 (address)h_exception(), file, line, thread);
148 }
149 // for AbortVMOnException flag
150 NOT_PRODUCT(Exceptions::debug_check_abort(h_exception, message));
151
152 // Check for special boot-strapping/vm-thread handling
153 if (special_exception(thread, file, line, h_exception)) {
154 return;
155 }
156
157 assert(h_exception->is_a(SystemDictionary::Throwable_klass()), "exception is not a subclass of java/lang/Throwable");
158
159 // set the pending exception
160 thread->set_pending_exception(h_exception(), file, line);
161
162 // vm log
163 Events::log_exception(thread, "Exception <%s%s%s> (" INTPTR_FORMAT ") thrown at [%s, line %d]",
164 h_exception->print_value_string(), message ? ": " : "", message ? message : "",
165 (address)h_exception(), file, line);
166 }
167
168
169 void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message,
170 Handle h_loader, Handle h_protection_domain) {
171 // Check for special boot-strapping/vm-thread handling
172 if (special_exception(thread, file, line, name, message)) return;
173 // Create and throw exception
174 Handle h_cause(thread, NULL);
175 Handle h_exception = new_exception(thread, name, message, h_cause, h_loader, h_protection_domain);
176 _throw(thread, file, line, h_exception, message);
211 _throw_msg_cause(thread, file, line, name, message, h_cause, Handle(thread, NULL), Handle(thread, NULL));
212 }
213 void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message) {
214 _throw_msg(thread, file, line, name, message, Handle(thread, NULL), Handle(thread, NULL));
215 }
216 void Exceptions::_throw_cause(Thread* thread, const char* file, int line, Symbol* name, Handle h_cause) {
217 _throw_cause(thread, file, line, name, h_cause, Handle(thread, NULL), Handle(thread, NULL));
218 }
219
220
221 void Exceptions::throw_stack_overflow_exception(Thread* THREAD, const char* file, int line, methodHandle method) {
222 Handle exception;
223 if (!THREAD->has_pending_exception()) {
224 Klass* k = SystemDictionary::StackOverflowError_klass();
225 oop e = InstanceKlass::cast(k)->allocate_instance(CHECK);
226 exception = Handle(THREAD, e); // fill_in_stack trace does gc
227 assert(InstanceKlass::cast(k)->is_initialized(), "need to increase min_stack_allowed calculation");
228 if (StackTraceInThrowable) {
229 java_lang_Throwable::fill_in_stack_trace(exception, method());
230 }
231 } else {
232 // if prior exception, throw that one instead
233 exception = Handle(THREAD, THREAD->pending_exception());
234 }
235 _throw(THREAD, file, line, exception);
236 }
237
238 void Exceptions::fthrow(Thread* thread, const char* file, int line, Symbol* h_name, const char* format, ...) {
239 const int max_msg_size = 1024;
240 va_list ap;
241 va_start(ap, format);
242 char msg[max_msg_size];
243 vsnprintf(msg, max_msg_size, format, ap);
244 msg[max_msg_size-1] = '\0';
245 va_end(ap);
246 _throw_msg(thread, file, line, h_name, msg);
247 }
248
249
250 // Creates an exception oop, calls the <init> method with the given signature.
385 return new_exception(thread, name, signature, &args, h_cause, h_loader, h_protection_domain);
386 }
387
388 // Another convenience method that creates handles for null class loaders and
389 // protection domains and null causes.
390 // If the last parameter 'to_utf8_mode' is safe_to_utf8,
391 // it means we can safely ignore the encoding scheme of the message string and
392 // convert it directly to a java UTF8 string. Otherwise, we need to take the
393 // encoding scheme of the string into account. One thing we should do at some
394 // point is to push this flag down to class java_lang_String since other
395 // classes may need similar functionalities.
396 Handle Exceptions::new_exception(Thread* thread, Symbol* name,
397 const char* message,
398 ExceptionMsgToUtf8Mode to_utf8_safe) {
399
400 Handle h_loader(thread, NULL);
401 Handle h_prot(thread, NULL);
402 Handle h_cause(thread, NULL);
403 return Exceptions::new_exception(thread, name, message, h_cause, h_loader,
404 h_prot, to_utf8_safe);
405 }
406
407 // Implementation of ExceptionMark
408
409 ExceptionMark::ExceptionMark(Thread*& thread) {
410 thread = Thread::current();
411 _thread = thread;
412 if (_thread->has_pending_exception()) {
413 oop exception = _thread->pending_exception();
414 _thread->clear_pending_exception(); // Needed to avoid infinite recursion
415 exception->print();
416 fatal("ExceptionMark constructor expects no pending exceptions");
417 }
418 }
419
420
421 ExceptionMark::~ExceptionMark() {
422 if (_thread->has_pending_exception()) {
423 Handle exception(_thread, _thread->pending_exception());
424 _thread->clear_pending_exception(); // Needed to avoid infinite recursion
|
137 ResourceMark rm;
138 assert(h_exception() != NULL, "exception should not be NULL");
139
140 // tracing (do this up front - so it works during boot strapping)
141 if (TraceExceptions) {
142 ttyLocker ttyl;
143 tty->print_cr("Exception <%s%s%s> (" INTPTR_FORMAT ") \n"
144 "thrown [%s, line %d]\nfor thread " INTPTR_FORMAT,
145 h_exception->print_value_string(),
146 message ? ": " : "", message ? message : "",
147 (address)h_exception(), file, line, thread);
148 }
149 // for AbortVMOnException flag
150 NOT_PRODUCT(Exceptions::debug_check_abort(h_exception, message));
151
152 // Check for special boot-strapping/vm-thread handling
153 if (special_exception(thread, file, line, h_exception)) {
154 return;
155 }
156
157 if (h_exception->is_a(SystemDictionary::OutOfMemoryError_klass())) {
158 count_out_of_memory_exceptions(h_exception);
159 }
160
161 assert(h_exception->is_a(SystemDictionary::Throwable_klass()), "exception is not a subclass of java/lang/Throwable");
162
163 // set the pending exception
164 thread->set_pending_exception(h_exception(), file, line);
165
166 // vm log
167 Events::log_exception(thread, "Exception <%s%s%s> (" INTPTR_FORMAT ") thrown at [%s, line %d]",
168 h_exception->print_value_string(), message ? ": " : "", message ? message : "",
169 (address)h_exception(), file, line);
170 }
171
172
173 void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message,
174 Handle h_loader, Handle h_protection_domain) {
175 // Check for special boot-strapping/vm-thread handling
176 if (special_exception(thread, file, line, name, message)) return;
177 // Create and throw exception
178 Handle h_cause(thread, NULL);
179 Handle h_exception = new_exception(thread, name, message, h_cause, h_loader, h_protection_domain);
180 _throw(thread, file, line, h_exception, message);
215 _throw_msg_cause(thread, file, line, name, message, h_cause, Handle(thread, NULL), Handle(thread, NULL));
216 }
217 void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message) {
218 _throw_msg(thread, file, line, name, message, Handle(thread, NULL), Handle(thread, NULL));
219 }
220 void Exceptions::_throw_cause(Thread* thread, const char* file, int line, Symbol* name, Handle h_cause) {
221 _throw_cause(thread, file, line, name, h_cause, Handle(thread, NULL), Handle(thread, NULL));
222 }
223
224
225 void Exceptions::throw_stack_overflow_exception(Thread* THREAD, const char* file, int line, methodHandle method) {
226 Handle exception;
227 if (!THREAD->has_pending_exception()) {
228 Klass* k = SystemDictionary::StackOverflowError_klass();
229 oop e = InstanceKlass::cast(k)->allocate_instance(CHECK);
230 exception = Handle(THREAD, e); // fill_in_stack trace does gc
231 assert(InstanceKlass::cast(k)->is_initialized(), "need to increase min_stack_allowed calculation");
232 if (StackTraceInThrowable) {
233 java_lang_Throwable::fill_in_stack_trace(exception, method());
234 }
235 // Increment counter for hs_err file reporting
236 Atomic::inc(&Exceptions::_stack_overflow_errors);
237 } else {
238 // if prior exception, throw that one instead
239 exception = Handle(THREAD, THREAD->pending_exception());
240 }
241 _throw(THREAD, file, line, exception);
242 }
243
244 void Exceptions::fthrow(Thread* thread, const char* file, int line, Symbol* h_name, const char* format, ...) {
245 const int max_msg_size = 1024;
246 va_list ap;
247 va_start(ap, format);
248 char msg[max_msg_size];
249 vsnprintf(msg, max_msg_size, format, ap);
250 msg[max_msg_size-1] = '\0';
251 va_end(ap);
252 _throw_msg(thread, file, line, h_name, msg);
253 }
254
255
256 // Creates an exception oop, calls the <init> method with the given signature.
391 return new_exception(thread, name, signature, &args, h_cause, h_loader, h_protection_domain);
392 }
393
394 // Another convenience method that creates handles for null class loaders and
395 // protection domains and null causes.
396 // If the last parameter 'to_utf8_mode' is safe_to_utf8,
397 // it means we can safely ignore the encoding scheme of the message string and
398 // convert it directly to a java UTF8 string. Otherwise, we need to take the
399 // encoding scheme of the string into account. One thing we should do at some
400 // point is to push this flag down to class java_lang_String since other
401 // classes may need similar functionalities.
402 Handle Exceptions::new_exception(Thread* thread, Symbol* name,
403 const char* message,
404 ExceptionMsgToUtf8Mode to_utf8_safe) {
405
406 Handle h_loader(thread, NULL);
407 Handle h_prot(thread, NULL);
408 Handle h_cause(thread, NULL);
409 return Exceptions::new_exception(thread, name, message, h_cause, h_loader,
410 h_prot, to_utf8_safe);
411 }
412
413
414 // Exception counting for hs_err file
415 volatile int Exceptions::_stack_overflow_errors = 0;
416 volatile int Exceptions::_out_of_memory_error_java_heap_errors = 0;
417 volatile int Exceptions::_out_of_memory_error_metaspace_errors = 0;
418 volatile int Exceptions::_out_of_memory_error_class_metaspace_errors = 0;
419
420 void Exceptions::count_out_of_memory_exceptions(Handle exception) {
421 if (exception() == Universe::out_of_memory_error_metaspace()) {
422 Atomic::inc(&_out_of_memory_error_metaspace_errors);
423 } else if (exception() == Universe::out_of_memory_error_class_metaspace()) {
424 Atomic::inc(&_out_of_memory_error_class_metaspace_errors);
425 } else {
426 // everything else reported as java heap OOM
427 Atomic::inc(&_out_of_memory_error_java_heap_errors);
428 }
429 }
430
431 void print_oom_count(outputStream* st, const char *err, int count) {
432 if (count > 0) {
433 st->print_cr("OutOfMemoryError %s=%d", err, count);
434 }
435 }
436
437 bool Exceptions::has_exception_counts() {
438 return (_stack_overflow_errors + _out_of_memory_error_java_heap_errors +
439 _out_of_memory_error_metaspace_errors + _out_of_memory_error_class_metaspace_errors) > 0;
440 }
441
442 void Exceptions::print_exception_counts_on_error(outputStream* st) {
443 print_oom_count(st, "java_heap_errors", _out_of_memory_error_java_heap_errors);
444 print_oom_count(st, "metaspace_errors", _out_of_memory_error_metaspace_errors);
445 print_oom_count(st, "class_metaspace_errors", _out_of_memory_error_class_metaspace_errors);
446 if (_stack_overflow_errors > 0) {
447 st->print_cr("StackOverflowErrors=%d", _stack_overflow_errors);
448 }
449 }
450
451 // Implementation of ExceptionMark
452
453 ExceptionMark::ExceptionMark(Thread*& thread) {
454 thread = Thread::current();
455 _thread = thread;
456 if (_thread->has_pending_exception()) {
457 oop exception = _thread->pending_exception();
458 _thread->clear_pending_exception(); // Needed to avoid infinite recursion
459 exception->print();
460 fatal("ExceptionMark constructor expects no pending exceptions");
461 }
462 }
463
464
465 ExceptionMark::~ExceptionMark() {
466 if (_thread->has_pending_exception()) {
467 Handle exception(_thread, _thread->pending_exception());
468 _thread->clear_pending_exception(); // Needed to avoid infinite recursion
|