Mercurial > hg > truffle
annotate src/share/vm/utilities/exceptions.cpp @ 1994:6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp
| author | ysr |
|---|---|
| date | Tue, 07 Dec 2010 21:55:53 -0800 |
| parents | f95d63e2154a |
| children | 06f017f7daa7 3582bf76420e |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "classfile/vmSymbols.hpp" | |
| 28 #include "compiler/compileBroker.hpp" | |
| 29 #include "oops/oop.inline.hpp" | |
| 30 #include "runtime/init.hpp" | |
| 31 #include "runtime/java.hpp" | |
| 32 #include "runtime/javaCalls.hpp" | |
| 33 #include "runtime/threadCritical.hpp" | |
| 34 #include "utilities/events.hpp" | |
| 35 #include "utilities/exceptions.hpp" | |
| 36 #ifdef TARGET_OS_FAMILY_linux | |
| 37 # include "thread_linux.inline.hpp" | |
| 38 #endif | |
| 39 #ifdef TARGET_OS_FAMILY_solaris | |
| 40 # include "thread_solaris.inline.hpp" | |
| 41 #endif | |
| 42 #ifdef TARGET_OS_FAMILY_windows | |
| 43 # include "thread_windows.inline.hpp" | |
| 44 #endif | |
| 0 | 45 |
| 46 | |
| 47 // Implementation of ThreadShadow | |
| 48 void check_ThreadShadow() { | |
| 49 const ByteSize offset1 = byte_offset_of(ThreadShadow, _pending_exception); | |
| 50 const ByteSize offset2 = Thread::pending_exception_offset(); | |
| 51 if (offset1 != offset2) fatal("ThreadShadow::_pending_exception is not positioned correctly"); | |
| 52 } | |
| 53 | |
| 54 | |
| 55 void ThreadShadow::set_pending_exception(oop exception, const char* file, int line) { | |
| 56 assert(exception != NULL && exception->is_oop(), "invalid exception oop"); | |
| 57 _pending_exception = exception; | |
| 58 _exception_file = file; | |
| 59 _exception_line = line; | |
| 60 } | |
| 61 | |
| 62 void ThreadShadow::clear_pending_exception() { | |
| 63 if (TraceClearedExceptions) { | |
| 64 if (_pending_exception != NULL) { | |
| 65 tty->print_cr("Thread::clear_pending_exception: cleared exception:"); | |
| 66 _pending_exception->print(); | |
| 67 } | |
| 68 } | |
| 69 _pending_exception = NULL; | |
| 70 _exception_file = NULL; | |
| 71 _exception_line = 0; | |
| 72 } | |
| 73 // Implementation of Exceptions | |
| 74 | |
| 75 bool Exceptions::special_exception(Thread* thread, const char* file, int line, Handle h_exception) { | |
| 76 // bootstrapping check | |
| 77 if (!Universe::is_fully_initialized()) { | |
| 78 vm_exit_during_initialization(h_exception); | |
| 79 ShouldNotReachHere(); | |
| 80 } | |
| 81 | |
|
1867
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
82 #ifdef ASSERT |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
83 // Check for trying to throw stack overflow before initialization is complete |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
84 // to prevent infinite recursion trying to initialize stack overflow without |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
85 // adequate stack space. |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
86 // This can happen with stress testing a large value of StackShadowPages |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
87 if (h_exception()->klass() == SystemDictionary::StackOverflowError_klass()) { |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
88 instanceKlass* ik = instanceKlass::cast(h_exception->klass()); |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
89 assert(ik->is_initialized(), |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
90 "need to increase min_stack_allowed calculation"); |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
91 } |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
92 #endif // ASSERT |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
93 |
| 0 | 94 if (thread->is_VM_thread() |
| 95 || thread->is_Compiler_thread() ) { | |
| 96 // We do not care what kind of exception we get for the vm-thread or a thread which | |
| 97 // is compiling. We just install a dummy exception object | |
| 98 thread->set_pending_exception(Universe::vm_exception(), file, line); | |
| 99 return true; | |
| 100 } | |
| 101 | |
| 102 return false; | |
| 103 } | |
| 104 | |
| 105 bool Exceptions::special_exception(Thread* thread, const char* file, int line, symbolHandle h_name, const char* message) { | |
| 106 // bootstrapping check | |
| 107 if (!Universe::is_fully_initialized()) { | |
| 108 if (h_name.is_null()) { | |
| 109 // atleast an informative message. | |
| 110 vm_exit_during_initialization("Exception", message); | |
| 111 } else { | |
| 112 vm_exit_during_initialization(h_name, message); | |
| 113 } | |
| 114 ShouldNotReachHere(); | |
| 115 } | |
| 116 | |
| 117 if (thread->is_VM_thread() | |
| 118 || thread->is_Compiler_thread() ) { | |
| 119 // We do not care what kind of exception we get for the vm-thread or a thread which | |
| 120 // is compiling. We just install a dummy exception object | |
| 121 thread->set_pending_exception(Universe::vm_exception(), file, line); | |
| 122 return true; | |
| 123 } | |
| 124 return false; | |
| 125 } | |
| 126 | |
| 127 // This method should only be called from generated code, | |
| 128 // therefore the exception oop should be in the oopmap. | |
| 129 void Exceptions::_throw_oop(Thread* thread, const char* file, int line, oop exception) { | |
| 130 assert(exception != NULL, "exception should not be NULL"); | |
| 131 Handle h_exception = Handle(thread, exception); | |
| 132 _throw(thread, file, line, h_exception); | |
| 133 } | |
| 134 | |
|
1011
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
135 void Exceptions::_throw(Thread* thread, const char* file, int line, Handle h_exception, const char* message) { |
| 0 | 136 assert(h_exception() != NULL, "exception should not be NULL"); |
| 137 | |
| 138 // tracing (do this up front - so it works during boot strapping) | |
| 139 if (TraceExceptions) { | |
| 140 ttyLocker ttyl; | |
| 141 ResourceMark rm; | |
|
1011
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
142 tty->print_cr("Exception <%s>%s%s (" INTPTR_FORMAT " ) \n" |
|
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
143 "thrown [%s, line %d]\nfor thread " INTPTR_FORMAT, |
|
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
144 h_exception->print_value_string(), |
|
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
145 message ? ": " : "", message ? message : "", |
|
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
146 (address)h_exception(), file, line, thread); |
| 0 | 147 } |
| 148 // for AbortVMOnException flag | |
|
1684
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
149 NOT_PRODUCT(Exceptions::debug_check_abort(h_exception, message)); |
| 0 | 150 |
| 151 // Check for special boot-strapping/vm-thread handling | |
| 152 if (special_exception(thread, file, line, h_exception)) return; | |
| 153 | |
| 1142 | 154 assert(h_exception->is_a(SystemDictionary::Throwable_klass()), "exception is not a subclass of java/lang/Throwable"); |
| 0 | 155 |
| 156 // set the pending exception | |
| 157 thread->set_pending_exception(h_exception(), file, line); | |
| 158 | |
| 159 // vm log | |
| 160 Events::log("throw_exception " INTPTR_FORMAT, (address)h_exception()); | |
| 161 } | |
| 162 | |
| 163 | |
| 164 void Exceptions::_throw_msg(Thread* thread, const char* file, int line, symbolHandle h_name, const char* message, Handle h_loader, Handle h_protection_domain) { | |
| 165 // Check for special boot-strapping/vm-thread handling | |
| 166 if (special_exception(thread, file, line, h_name, message)) return; | |
| 167 // Create and throw exception | |
| 168 Handle h_cause(thread, NULL); | |
| 169 Handle h_exception = new_exception(thread, h_name, message, h_cause, h_loader, h_protection_domain); | |
|
1011
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
170 _throw(thread, file, line, h_exception, message); |
| 0 | 171 } |
| 172 | |
| 173 // Throw an exception with a message and a cause | |
| 174 void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line, symbolHandle h_name, const char* message, Handle h_cause, Handle h_loader, Handle h_protection_domain) { | |
| 175 // Check for special boot-strapping/vm-thread handling | |
| 176 if (special_exception(thread, file, line, h_name, message)) return; | |
| 177 // Create and throw exception and init cause | |
| 178 Handle h_exception = new_exception(thread, h_name, message, h_cause, h_loader, h_protection_domain); | |
|
1011
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
179 _throw(thread, file, line, h_exception, message); |
| 0 | 180 } |
| 181 | |
| 182 // This version creates handles and calls the other version | |
| 183 void Exceptions::_throw_msg(Thread* thread, const char* file, int line, | |
| 184 symbolOop name, const char* message) { | |
| 185 symbolHandle h_name(thread, name); | |
| 186 Handle h_loader(thread, NULL); | |
| 187 Handle h_protection_domain(thread, NULL); | |
| 188 Exceptions::_throw_msg(thread, file, line, h_name, message, h_loader, h_protection_domain); | |
| 189 } | |
| 190 | |
| 191 // This version already has a handle for name | |
| 192 void Exceptions::_throw_msg(Thread* thread, const char* file, int line, | |
| 193 symbolHandle name, const char* message) { | |
| 194 Handle h_loader(thread, NULL); | |
| 195 Handle h_protection_domain(thread, NULL); | |
| 196 Exceptions::_throw_msg(thread, file, line, name, message, h_loader, h_protection_domain); | |
| 197 } | |
| 198 | |
| 199 // This version already has a handle for name | |
| 200 void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line, | |
| 201 symbolHandle name, const char* message, Handle cause) { | |
| 202 Handle h_loader(thread, NULL); | |
| 203 Handle h_protection_domain(thread, NULL); | |
| 204 Exceptions::_throw_msg_cause(thread, file, line, name, message, cause, h_loader, h_protection_domain); | |
| 205 } | |
| 206 | |
| 207 void Exceptions::_throw_args(Thread* thread, const char* file, int line, symbolHandle h_name, symbolHandle h_signature, JavaCallArguments *args) { | |
| 208 // Check for special boot-strapping/vm-thread handling | |
| 209 if (special_exception(thread, file, line, h_name, NULL)) return; | |
| 210 // Create and throw exception | |
| 211 Handle h_loader(thread, NULL); | |
| 212 Handle h_prot(thread, NULL); | |
| 213 Handle h_cause(thread, NULL); | |
| 214 Handle exception = new_exception(thread, h_name, h_signature, args, h_cause, h_loader, h_prot); | |
| 215 _throw(thread, file, line, exception); | |
| 216 } | |
| 217 | |
| 218 | |
| 219 void Exceptions::throw_stack_overflow_exception(Thread* THREAD, const char* file, int line) { | |
| 220 Handle exception; | |
| 221 if (!THREAD->has_pending_exception()) { | |
| 222 klassOop k = SystemDictionary::StackOverflowError_klass(); | |
| 223 oop e = instanceKlass::cast(k)->allocate_instance(CHECK); | |
| 224 exception = Handle(THREAD, e); // fill_in_stack trace does gc | |
|
1867
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
225 assert(instanceKlass::cast(k)->is_initialized(), "need to increase min_stack_allowed calculation"); |
| 0 | 226 if (StackTraceInThrowable) { |
| 227 java_lang_Throwable::fill_in_stack_trace(exception); | |
| 228 } | |
| 229 } else { | |
| 230 // if prior exception, throw that one instead | |
| 231 exception = Handle(THREAD, THREAD->pending_exception()); | |
| 232 } | |
| 233 _throw_oop(THREAD, file, line, exception()); | |
| 234 } | |
| 235 | |
| 236 void Exceptions::fthrow(Thread* thread, const char* file, int line, symbolHandle h_name, const char* format, ...) { | |
| 237 const int max_msg_size = 1024; | |
| 238 va_list ap; | |
| 239 va_start(ap, format); | |
| 240 char msg[max_msg_size]; | |
| 241 vsnprintf(msg, max_msg_size, format, ap); | |
| 242 msg[max_msg_size-1] = '\0'; | |
| 243 va_end(ap); | |
| 244 _throw_msg(thread, file, line, h_name, msg); | |
| 245 } | |
| 246 | |
| 247 // Creates an exception oop, calls the <init> method with the given signature. | |
| 248 // and returns a Handle | |
| 249 // Initializes the cause if cause non-null | |
| 250 Handle Exceptions::new_exception(Thread *thread, symbolHandle h_name, | |
| 251 symbolHandle signature, | |
| 252 JavaCallArguments *args, | |
| 253 Handle h_cause, Handle h_loader, | |
| 254 Handle h_protection_domain) { | |
| 255 assert(Universe::is_fully_initialized(), | |
| 256 "cannot be called during initialization"); | |
| 257 assert(thread->is_Java_thread(), "can only be called by a Java thread"); | |
| 258 assert(!thread->has_pending_exception(), "already has exception"); | |
| 259 | |
| 260 Handle h_exception; | |
| 261 | |
| 262 // Resolve exception klass | |
| 263 klassOop ik = SystemDictionary::resolve_or_fail(h_name, h_loader, h_protection_domain, true, thread); | |
| 264 instanceKlassHandle klass (thread, ik); | |
| 265 | |
| 266 if (!thread->has_pending_exception()) { | |
| 267 assert(klass.not_null(), "klass must exist"); | |
| 268 // We are about to create an instance - so make sure that klass is initialized | |
| 269 klass->initialize(thread); | |
| 270 if (!thread->has_pending_exception()) { | |
| 271 // Allocate new exception | |
| 272 h_exception = klass->allocate_instance_handle(thread); | |
| 273 if (!thread->has_pending_exception()) { | |
| 274 JavaValue result(T_VOID); | |
| 275 args->set_receiver(h_exception); | |
| 276 // Call constructor | |
| 277 JavaCalls::call_special(&result, klass, | |
| 278 vmSymbolHandles::object_initializer_name(), | |
| 279 signature, | |
| 280 args, | |
| 281 thread); | |
| 282 | |
| 283 } | |
| 284 } | |
| 285 | |
| 286 // Future: object initializer should take a cause argument | |
| 287 if (h_cause() != NULL) { | |
| 1142 | 288 assert(h_cause->is_a(SystemDictionary::Throwable_klass()), |
| 0 | 289 "exception cause is not a subclass of java/lang/Throwable"); |
| 290 JavaValue result1(T_OBJECT); | |
| 291 JavaCallArguments args1; | |
| 292 args1.set_receiver(h_exception); | |
| 293 args1.push_oop(h_cause); | |
| 294 JavaCalls::call_virtual(&result1, klass, | |
| 295 vmSymbolHandles::initCause_name(), | |
| 296 vmSymbolHandles::throwable_throwable_signature(), | |
| 297 &args1, | |
| 298 thread); | |
| 299 } | |
| 300 } | |
| 301 | |
| 302 // Check if another exception was thrown in the process, if so rethrow that one | |
| 303 if (thread->has_pending_exception()) { | |
| 304 h_exception = Handle(thread, thread->pending_exception()); | |
| 305 thread->clear_pending_exception(); | |
| 306 } | |
| 307 return h_exception; | |
| 308 } | |
| 309 | |
| 310 // Convenience method. Calls either the <init>() or <init>(String) method when | |
| 311 // creating a new exception | |
| 312 Handle Exceptions::new_exception(Thread* thread, symbolHandle h_name, | |
| 313 const char* message, Handle h_cause, | |
| 314 Handle h_loader, | |
| 315 Handle h_protection_domain, | |
| 316 ExceptionMsgToUtf8Mode to_utf8_safe) { | |
| 317 JavaCallArguments args; | |
| 318 symbolHandle signature; | |
| 319 if (message == NULL) { | |
| 320 signature = vmSymbolHandles::void_method_signature(); | |
| 321 } else { | |
| 322 // We want to allocate storage, but we can't do that if there's | |
| 323 // a pending exception, so we preserve any pending exception | |
| 324 // around the allocation. | |
| 325 // If we get an exception from the allocation, prefer that to | |
| 326 // the exception we are trying to build, or the pending exception. | |
| 327 // This is sort of like what PRESERVE_EXCEPTION_MARK does, except | |
| 328 // for the preferencing and the early returns. | |
| 329 Handle incoming_exception (thread, NULL); | |
| 330 if (thread->has_pending_exception()) { | |
| 331 incoming_exception = Handle(thread, thread->pending_exception()); | |
| 332 thread->clear_pending_exception(); | |
| 333 } | |
| 334 Handle msg; | |
| 335 if (to_utf8_safe == safe_to_utf8) { | |
| 336 // Make a java UTF8 string. | |
| 337 msg = java_lang_String::create_from_str(message, thread); | |
| 338 } else { | |
| 339 // Make a java string keeping the encoding scheme of the original string. | |
| 340 msg = java_lang_String::create_from_platform_dependent_str(message, thread); | |
| 341 } | |
| 342 if (thread->has_pending_exception()) { | |
| 343 Handle exception(thread, thread->pending_exception()); | |
| 344 thread->clear_pending_exception(); | |
| 345 return exception; | |
| 346 } | |
| 347 if (incoming_exception.not_null()) { | |
| 348 return incoming_exception; | |
| 349 } | |
| 350 args.push_oop(msg); | |
| 351 signature = vmSymbolHandles::string_void_signature(); | |
| 352 } | |
| 353 return new_exception(thread, h_name, signature, &args, h_cause, h_loader, h_protection_domain); | |
| 354 } | |
| 355 | |
| 356 // Another convenience method that creates handles for null class loaders and | |
| 357 // protection domains and null causes. | |
| 358 // If the last parameter 'to_utf8_mode' is safe_to_utf8, | |
| 359 // it means we can safely ignore the encoding scheme of the message string and | |
| 360 // convert it directly to a java UTF8 string. Otherwise, we need to take the | |
| 361 // encoding scheme of the string into account. One thing we should do at some | |
| 362 // point is to push this flag down to class java_lang_String since other | |
| 363 // classes may need similar functionalities. | |
| 364 Handle Exceptions::new_exception(Thread* thread, | |
| 365 symbolOop name, | |
| 366 const char* message, | |
| 367 ExceptionMsgToUtf8Mode to_utf8_safe) { | |
| 368 | |
| 369 symbolHandle h_name(thread, name); | |
| 370 Handle h_loader(thread, NULL); | |
| 371 Handle h_prot(thread, NULL); | |
| 372 Handle h_cause(thread, NULL); | |
| 373 return Exceptions::new_exception(thread, h_name, message, h_cause, h_loader, | |
| 374 h_prot, to_utf8_safe); | |
| 375 } | |
| 376 | |
| 377 // Implementation of ExceptionMark | |
| 378 | |
| 379 ExceptionMark::ExceptionMark(Thread*& thread) { | |
| 380 thread = Thread::current(); | |
| 381 _thread = thread; | |
| 382 if (_thread->has_pending_exception()) { | |
| 383 oop exception = _thread->pending_exception(); | |
| 384 _thread->clear_pending_exception(); // Needed to avoid infinite recursion | |
| 385 exception->print(); | |
| 386 fatal("ExceptionMark constructor expects no pending exceptions"); | |
| 387 } | |
| 388 } | |
| 389 | |
| 390 | |
| 391 ExceptionMark::~ExceptionMark() { | |
| 392 if (_thread->has_pending_exception()) { | |
| 393 Handle exception(_thread, _thread->pending_exception()); | |
| 394 _thread->clear_pending_exception(); // Needed to avoid infinite recursion | |
| 395 if (is_init_completed()) { | |
| 396 exception->print(); | |
| 397 fatal("ExceptionMark destructor expects no pending exceptions"); | |
| 398 } else { | |
| 399 vm_exit_during_initialization(exception); | |
| 400 } | |
| 401 } | |
| 402 } | |
| 403 | |
| 404 // ---------------------------------------------------------------------------------------- | |
| 405 | |
| 406 #ifndef PRODUCT | |
| 407 // caller frees value_string if necessary | |
|
1684
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
408 void Exceptions::debug_check_abort(const char *value_string, const char* message) { |
| 0 | 409 if (AbortVMOnException != NULL && value_string != NULL && |
| 410 strstr(value_string, AbortVMOnException)) { | |
|
1684
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
411 if (AbortVMOnExceptionMessage == NULL || message == NULL || |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
412 strcmp(message, AbortVMOnExceptionMessage) == 0) { |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
413 fatal(err_msg("Saw %s, aborting", value_string)); |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
414 } |
| 0 | 415 } |
| 416 } | |
| 417 | |
|
1684
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
418 void Exceptions::debug_check_abort(Handle exception, const char* message) { |
| 0 | 419 if (AbortVMOnException != NULL) { |
| 420 ResourceMark rm; | |
|
1684
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
421 if (message == NULL && exception->is_a(SystemDictionary::Throwable_klass())) { |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
422 oop msg = java_lang_Throwable::message(exception); |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
423 if (msg != NULL) { |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
424 message = java_lang_String::as_utf8_string(msg); |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
425 } |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
426 } |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
427 debug_check_abort(instanceKlass::cast(exception()->klass())->external_name(), message); |
| 0 | 428 } |
| 429 } | |
| 430 #endif |