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