Mercurial > hg > truffle
annotate src/share/vm/utilities/exceptions.cpp @ 17716:cdb71841f4bc
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Wed, 26 Feb 2014 15:20:41 -0800 |
| parents | 55fb97c4c58d |
| children | d8041d695d19 78bbf4d43a14 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
17467
55fb97c4c58d
8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013
mikael
parents:
12002
diff
changeset
|
2 * Copyright (c) 1998, 2013, 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" | |
|
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
6725
diff
changeset
|
33 #include "runtime/thread.inline.hpp" |
| 1972 | 34 #include "runtime/threadCritical.hpp" |
| 35 #include "utilities/events.hpp" | |
| 36 #include "utilities/exceptions.hpp" | |
| 0 | 37 |
| 38 | |
| 39 // Implementation of ThreadShadow | |
| 40 void check_ThreadShadow() { | |
| 41 const ByteSize offset1 = byte_offset_of(ThreadShadow, _pending_exception); | |
| 42 const ByteSize offset2 = Thread::pending_exception_offset(); | |
| 43 if (offset1 != offset2) fatal("ThreadShadow::_pending_exception is not positioned correctly"); | |
| 44 } | |
| 45 | |
| 46 | |
| 47 void ThreadShadow::set_pending_exception(oop exception, const char* file, int line) { | |
| 48 assert(exception != NULL && exception->is_oop(), "invalid exception oop"); | |
| 49 _pending_exception = exception; | |
| 50 _exception_file = file; | |
| 51 _exception_line = line; | |
| 52 } | |
| 53 | |
| 54 void ThreadShadow::clear_pending_exception() { | |
| 55 if (TraceClearedExceptions) { | |
| 56 if (_pending_exception != NULL) { | |
| 57 tty->print_cr("Thread::clear_pending_exception: cleared exception:"); | |
| 58 _pending_exception->print(); | |
| 59 } | |
| 60 } | |
| 61 _pending_exception = NULL; | |
| 62 _exception_file = NULL; | |
| 63 _exception_line = 0; | |
| 64 } | |
| 65 // Implementation of Exceptions | |
| 66 | |
| 67 bool Exceptions::special_exception(Thread* thread, const char* file, int line, Handle h_exception) { | |
| 68 // bootstrapping check | |
| 69 if (!Universe::is_fully_initialized()) { | |
| 70 vm_exit_during_initialization(h_exception); | |
| 71 ShouldNotReachHere(); | |
| 72 } | |
| 73 | |
|
1867
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
74 #ifdef ASSERT |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
75 // 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
|
76 // 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
|
77 // adequate stack space. |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
78 // 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
|
79 if (h_exception()->klass() == SystemDictionary::StackOverflowError_klass()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
80 InstanceKlass* ik = InstanceKlass::cast(h_exception->klass()); |
|
1867
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
81 assert(ik->is_initialized(), |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
82 "need to increase min_stack_allowed calculation"); |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
83 } |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
84 #endif // ASSERT |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1684
diff
changeset
|
85 |
| 0 | 86 if (thread->is_VM_thread() |
| 87 || thread->is_Compiler_thread() ) { | |
| 88 // We do not care what kind of exception we get for the vm-thread or a thread which | |
| 89 // is compiling. We just install a dummy exception object | |
| 90 thread->set_pending_exception(Universe::vm_exception(), file, line); | |
| 91 return true; | |
| 92 } | |
| 93 | |
| 94 return false; | |
| 95 } | |
| 96 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
97 bool Exceptions::special_exception(Thread* thread, const char* file, int line, Symbol* h_name, const char* message) { |
| 0 | 98 // bootstrapping check |
| 99 if (!Universe::is_fully_initialized()) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
100 if (h_name == NULL) { |
| 0 | 101 // atleast an informative message. |
| 102 vm_exit_during_initialization("Exception", message); | |
| 103 } else { | |
| 104 vm_exit_during_initialization(h_name, message); | |
| 105 } | |
| 106 ShouldNotReachHere(); | |
| 107 } | |
| 108 | |
| 109 if (thread->is_VM_thread() | |
| 110 || thread->is_Compiler_thread() ) { | |
| 111 // We do not care what kind of exception we get for the vm-thread or a thread which | |
| 112 // is compiling. We just install a dummy exception object | |
| 113 thread->set_pending_exception(Universe::vm_exception(), file, line); | |
| 114 return true; | |
| 115 } | |
| 116 return false; | |
| 117 } | |
| 118 | |
| 119 // This method should only be called from generated code, | |
| 120 // therefore the exception oop should be in the oopmap. | |
| 121 void Exceptions::_throw_oop(Thread* thread, const char* file, int line, oop exception) { | |
| 122 assert(exception != NULL, "exception should not be NULL"); | |
| 123 Handle h_exception = Handle(thread, exception); | |
| 124 _throw(thread, file, line, h_exception); | |
| 125 } | |
| 126 | |
|
1011
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
127 void Exceptions::_throw(Thread* thread, const char* file, int line, Handle h_exception, const char* message) { |
| 12002 | 128 ResourceMark rm; |
| 0 | 129 assert(h_exception() != NULL, "exception should not be NULL"); |
| 130 | |
| 131 // tracing (do this up front - so it works during boot strapping) | |
| 132 if (TraceExceptions) { | |
| 133 ttyLocker ttyl; | |
| 12002 | 134 tty->print_cr("Exception <%s%s%s> (" INTPTR_FORMAT ") \n" |
|
1011
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
135 "thrown [%s, line %d]\nfor thread " INTPTR_FORMAT, |
|
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
136 h_exception->print_value_string(), |
|
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
137 message ? ": " : "", message ? message : "", |
|
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
138 (address)h_exception(), file, line, thread); |
| 0 | 139 } |
| 140 // for AbortVMOnException flag | |
|
1684
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
141 NOT_PRODUCT(Exceptions::debug_check_abort(h_exception, message)); |
| 0 | 142 |
| 143 // Check for special boot-strapping/vm-thread handling | |
| 12002 | 144 if (special_exception(thread, file, line, h_exception)) { |
| 145 return; | |
| 146 } | |
| 0 | 147 |
| 1142 | 148 assert(h_exception->is_a(SystemDictionary::Throwable_klass()), "exception is not a subclass of java/lang/Throwable"); |
| 0 | 149 |
| 150 // set the pending exception | |
| 151 thread->set_pending_exception(h_exception(), file, line); | |
| 152 | |
| 153 // vm log | |
| 12002 | 154 Events::log_exception(thread, "Exception <%s%s%s> (" INTPTR_FORMAT ") thrown at [%s, line %d]", |
| 155 h_exception->print_value_string(), message ? ": " : "", message ? message : "", | |
| 156 (address)h_exception(), file, line); | |
| 0 | 157 } |
| 158 | |
| 159 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
160 void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
161 Handle h_loader, Handle h_protection_domain) { |
| 0 | 162 // Check for special boot-strapping/vm-thread handling |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
163 if (special_exception(thread, file, line, name, message)) return; |
| 0 | 164 // Create and throw exception |
| 165 Handle h_cause(thread, NULL); | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
166 Handle h_exception = new_exception(thread, name, message, h_cause, h_loader, h_protection_domain); |
|
1011
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
167 _throw(thread, file, line, h_exception, message); |
| 0 | 168 } |
| 169 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
170 void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line, Symbol* name, const char* message, Handle h_cause, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
171 Handle h_loader, Handle h_protection_domain) { |
| 0 | 172 // Check for special boot-strapping/vm-thread handling |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
173 if (special_exception(thread, file, line, name, message)) return; |
| 0 | 174 // Create and throw exception and init cause |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
175 Handle h_exception = new_exception(thread, name, message, h_cause, h_loader, h_protection_domain); |
|
1011
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
176 _throw(thread, file, line, h_exception, message); |
| 0 | 177 } |
| 178 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
179 void Exceptions::_throw_cause(Thread* thread, const char* file, int line, Symbol* name, Handle h_cause, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
180 Handle h_loader, Handle h_protection_domain) { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
181 // Check for special boot-strapping/vm-thread handling |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
182 if (special_exception(thread, file, line, h_cause)) return; |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
183 // Create and throw exception |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
184 Handle h_exception = new_exception(thread, name, h_cause, h_loader, h_protection_domain); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
185 _throw(thread, file, line, h_exception, NULL); |
| 0 | 186 } |
| 187 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
188 void Exceptions::_throw_args(Thread* thread, const char* file, int line, Symbol* name, Symbol* signature, JavaCallArguments *args) { |
| 0 | 189 // Check for special boot-strapping/vm-thread handling |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
190 if (special_exception(thread, file, line, name, NULL)) return; |
| 0 | 191 // Create and throw exception |
| 192 Handle h_loader(thread, NULL); | |
| 193 Handle h_prot(thread, NULL); | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
194 Handle exception = new_exception(thread, name, signature, args, h_loader, h_prot); |
| 0 | 195 _throw(thread, file, line, exception); |
| 196 } | |
| 197 | |
| 198 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
199 // Methods for default parameters. |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
200 // NOTE: These must be here (and not in the header file) because of include circularities. |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
201 void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line, Symbol* name, const char* message, Handle h_cause) { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
202 _throw_msg_cause(thread, file, line, name, message, h_cause, Handle(thread, NULL), Handle(thread, NULL)); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
203 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
204 void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message) { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
205 _throw_msg(thread, file, line, name, message, Handle(thread, NULL), Handle(thread, NULL)); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
206 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
207 void Exceptions::_throw_cause(Thread* thread, const char* file, int line, Symbol* name, Handle h_cause) { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
208 _throw_cause(thread, file, line, name, h_cause, Handle(thread, NULL), Handle(thread, NULL)); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
209 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
210 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
211 |
|
3272
01147d8aac1d
7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents:
2426
diff
changeset
|
212 void Exceptions::throw_stack_overflow_exception(Thread* THREAD, const char* file, int line, methodHandle method) { |
| 0 | 213 Handle exception; |
| 214 if (!THREAD->has_pending_exception()) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
215 Klass* k = SystemDictionary::StackOverflowError_klass(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
216 oop e = InstanceKlass::cast(k)->allocate_instance(CHECK); |
| 0 | 217 exception = Handle(THREAD, e); // fill_in_stack trace does gc |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
218 assert(InstanceKlass::cast(k)->is_initialized(), "need to increase min_stack_allowed calculation"); |
| 0 | 219 if (StackTraceInThrowable) { |
|
3272
01147d8aac1d
7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents:
2426
diff
changeset
|
220 java_lang_Throwable::fill_in_stack_trace(exception, method()); |
| 0 | 221 } |
| 222 } else { | |
| 223 // if prior exception, throw that one instead | |
| 224 exception = Handle(THREAD, THREAD->pending_exception()); | |
| 225 } | |
|
3272
01147d8aac1d
7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents:
2426
diff
changeset
|
226 _throw(THREAD, file, line, exception); |
| 0 | 227 } |
| 228 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
229 void Exceptions::fthrow(Thread* thread, const char* file, int line, Symbol* h_name, const char* format, ...) { |
| 0 | 230 const int max_msg_size = 1024; |
| 231 va_list ap; | |
| 232 va_start(ap, format); | |
| 233 char msg[max_msg_size]; | |
| 234 vsnprintf(msg, max_msg_size, format, ap); | |
| 235 msg[max_msg_size-1] = '\0'; | |
| 236 va_end(ap); | |
| 237 _throw_msg(thread, file, line, h_name, msg); | |
| 238 } | |
| 239 | |
| 240 // Creates an exception oop, calls the <init> method with the given signature. | |
| 241 // and returns a Handle | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
242 Handle Exceptions::new_exception(Thread *thread, Symbol* name, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
243 Symbol* signature, JavaCallArguments *args, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
244 Handle h_loader, Handle h_protection_domain) { |
| 0 | 245 assert(Universe::is_fully_initialized(), |
| 246 "cannot be called during initialization"); | |
| 247 assert(thread->is_Java_thread(), "can only be called by a Java thread"); | |
| 248 assert(!thread->has_pending_exception(), "already has exception"); | |
| 249 | |
| 250 Handle h_exception; | |
| 251 | |
| 252 // Resolve exception klass | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
253 Klass* ik = SystemDictionary::resolve_or_fail(name, h_loader, h_protection_domain, true, thread); |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
254 instanceKlassHandle klass(thread, ik); |
| 0 | 255 |
| 256 if (!thread->has_pending_exception()) { | |
| 257 assert(klass.not_null(), "klass must exist"); | |
| 258 // We are about to create an instance - so make sure that klass is initialized | |
| 259 klass->initialize(thread); | |
| 260 if (!thread->has_pending_exception()) { | |
| 261 // Allocate new exception | |
| 262 h_exception = klass->allocate_instance_handle(thread); | |
| 263 if (!thread->has_pending_exception()) { | |
| 264 JavaValue result(T_VOID); | |
| 265 args->set_receiver(h_exception); | |
| 266 // Call constructor | |
| 267 JavaCalls::call_special(&result, klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
268 vmSymbols::object_initializer_name(), |
| 0 | 269 signature, |
| 270 args, | |
| 271 thread); | |
| 272 } | |
| 273 } | |
| 274 } | |
| 275 | |
| 276 // Check if another exception was thrown in the process, if so rethrow that one | |
| 277 if (thread->has_pending_exception()) { | |
| 278 h_exception = Handle(thread, thread->pending_exception()); | |
| 279 thread->clear_pending_exception(); | |
| 280 } | |
| 281 return h_exception; | |
| 282 } | |
| 283 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
284 // Creates an exception oop, calls the <init> method with the given signature. |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
285 // and returns a Handle |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
286 // Initializes the cause if cause non-null |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
287 Handle Exceptions::new_exception(Thread *thread, Symbol* name, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
288 Symbol* signature, JavaCallArguments *args, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
289 Handle h_cause, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
290 Handle h_loader, Handle h_protection_domain) { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
291 Handle h_exception = new_exception(thread, name, signature, args, h_loader, h_protection_domain); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
292 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
293 // Future: object initializer should take a cause argument |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
294 if (h_cause.not_null()) { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
295 assert(h_cause->is_a(SystemDictionary::Throwable_klass()), |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
296 "exception cause is not a subclass of java/lang/Throwable"); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
297 JavaValue result1(T_OBJECT); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
298 JavaCallArguments args1; |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
299 args1.set_receiver(h_exception); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
300 args1.push_oop(h_cause); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
301 JavaCalls::call_virtual(&result1, h_exception->klass(), |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
302 vmSymbols::initCause_name(), |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
303 vmSymbols::throwable_throwable_signature(), |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
304 &args1, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
305 thread); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
306 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
307 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
308 // Check if another exception was thrown in the process, if so rethrow that one |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
309 if (thread->has_pending_exception()) { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
310 h_exception = Handle(thread, thread->pending_exception()); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
311 thread->clear_pending_exception(); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
312 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
313 return h_exception; |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
314 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
315 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
316 // Convenience method. Calls either the <init>() or <init>(Throwable) method when |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
317 // creating a new exception |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
318 Handle Exceptions::new_exception(Thread* thread, Symbol* name, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
319 Handle h_cause, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
320 Handle h_loader, Handle h_protection_domain, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
321 ExceptionMsgToUtf8Mode to_utf8_safe) { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
322 JavaCallArguments args; |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
323 Symbol* signature = NULL; |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
324 if (h_cause.is_null()) { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
325 signature = vmSymbols::void_method_signature(); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
326 } else { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
327 signature = vmSymbols::throwable_void_signature(); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
328 args.push_oop(h_cause); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
329 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
330 return new_exception(thread, name, signature, &args, h_loader, h_protection_domain); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
331 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
332 |
| 0 | 333 // Convenience method. Calls either the <init>() or <init>(String) method when |
| 334 // creating a new exception | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
335 Handle Exceptions::new_exception(Thread* thread, Symbol* name, |
| 0 | 336 const char* message, Handle h_cause, |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
337 Handle h_loader, Handle h_protection_domain, |
| 0 | 338 ExceptionMsgToUtf8Mode to_utf8_safe) { |
| 339 JavaCallArguments args; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
340 Symbol* signature = NULL; |
| 0 | 341 if (message == NULL) { |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
342 signature = vmSymbols::void_method_signature(); |
| 0 | 343 } else { |
| 344 // We want to allocate storage, but we can't do that if there's | |
| 345 // a pending exception, so we preserve any pending exception | |
| 346 // around the allocation. | |
| 347 // If we get an exception from the allocation, prefer that to | |
| 348 // the exception we are trying to build, or the pending exception. | |
| 349 // This is sort of like what PRESERVE_EXCEPTION_MARK does, except | |
| 350 // for the preferencing and the early returns. | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
351 Handle incoming_exception(thread, NULL); |
| 0 | 352 if (thread->has_pending_exception()) { |
| 353 incoming_exception = Handle(thread, thread->pending_exception()); | |
| 354 thread->clear_pending_exception(); | |
| 355 } | |
| 356 Handle msg; | |
| 357 if (to_utf8_safe == safe_to_utf8) { | |
| 358 // Make a java UTF8 string. | |
| 359 msg = java_lang_String::create_from_str(message, thread); | |
| 360 } else { | |
| 361 // Make a java string keeping the encoding scheme of the original string. | |
| 362 msg = java_lang_String::create_from_platform_dependent_str(message, thread); | |
| 363 } | |
| 364 if (thread->has_pending_exception()) { | |
| 365 Handle exception(thread, thread->pending_exception()); | |
| 366 thread->clear_pending_exception(); | |
| 367 return exception; | |
| 368 } | |
| 369 if (incoming_exception.not_null()) { | |
| 370 return incoming_exception; | |
| 371 } | |
| 372 args.push_oop(msg); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
373 signature = vmSymbols::string_void_signature(); |
| 0 | 374 } |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
375 return new_exception(thread, name, signature, &args, h_cause, h_loader, h_protection_domain); |
| 0 | 376 } |
| 377 | |
| 378 // Another convenience method that creates handles for null class loaders and | |
| 379 // protection domains and null causes. | |
| 380 // If the last parameter 'to_utf8_mode' is safe_to_utf8, | |
| 381 // it means we can safely ignore the encoding scheme of the message string and | |
| 382 // convert it directly to a java UTF8 string. Otherwise, we need to take the | |
| 383 // encoding scheme of the string into account. One thing we should do at some | |
| 384 // point is to push this flag down to class java_lang_String since other | |
| 385 // classes may need similar functionalities. | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
386 Handle Exceptions::new_exception(Thread* thread, Symbol* name, |
| 0 | 387 const char* message, |
| 388 ExceptionMsgToUtf8Mode to_utf8_safe) { | |
| 389 | |
| 390 Handle h_loader(thread, NULL); | |
| 391 Handle h_prot(thread, NULL); | |
| 392 Handle h_cause(thread, NULL); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
393 return Exceptions::new_exception(thread, name, message, h_cause, h_loader, |
| 0 | 394 h_prot, to_utf8_safe); |
| 395 } | |
| 396 | |
| 397 // Implementation of ExceptionMark | |
| 398 | |
| 399 ExceptionMark::ExceptionMark(Thread*& thread) { | |
| 400 thread = Thread::current(); | |
| 401 _thread = thread; | |
| 402 if (_thread->has_pending_exception()) { | |
| 403 oop exception = _thread->pending_exception(); | |
| 404 _thread->clear_pending_exception(); // Needed to avoid infinite recursion | |
| 405 exception->print(); | |
| 406 fatal("ExceptionMark constructor expects no pending exceptions"); | |
| 407 } | |
| 408 } | |
| 409 | |
| 410 | |
| 411 ExceptionMark::~ExceptionMark() { | |
| 412 if (_thread->has_pending_exception()) { | |
| 413 Handle exception(_thread, _thread->pending_exception()); | |
| 414 _thread->clear_pending_exception(); // Needed to avoid infinite recursion | |
| 415 if (is_init_completed()) { | |
| 416 exception->print(); | |
| 417 fatal("ExceptionMark destructor expects no pending exceptions"); | |
| 418 } else { | |
| 419 vm_exit_during_initialization(exception); | |
| 420 } | |
| 421 } | |
| 422 } | |
| 423 | |
| 424 // ---------------------------------------------------------------------------------------- | |
| 425 | |
| 426 #ifndef PRODUCT | |
| 427 // 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
|
428 void Exceptions::debug_check_abort(const char *value_string, const char* message) { |
| 0 | 429 if (AbortVMOnException != NULL && value_string != NULL && |
| 430 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
|
431 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
|
432 strcmp(message, AbortVMOnExceptionMessage) == 0) { |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
433 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
|
434 } |
| 0 | 435 } |
| 436 } | |
| 437 | |
|
1684
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
438 void Exceptions::debug_check_abort(Handle exception, const char* message) { |
| 0 | 439 if (AbortVMOnException != NULL) { |
| 440 ResourceMark rm; | |
|
1684
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
441 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
|
442 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
|
443 if (msg != NULL) { |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
444 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
|
445 } |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
446 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
447 debug_check_abort(InstanceKlass::cast(exception()->klass())->external_name(), message); |
| 0 | 448 } |
| 449 } | |
| 450 #endif |