Mercurial > hg > graal-compiler
annotate src/share/vm/utilities/exceptions.cpp @ 8804:91bf0bdae37b
8008217: CDS: Class data sharing limits the malloc heap on Solaris
Summary: In 64bit VM move CDS archive address to 32G on all platforms using new flag SharedBaseAddress. In 32bit VM set CDS archive address to 3Gb on Linux and let other OSs pick the address.
Reviewed-by: kvn, dcubed, zgu, hseigel
| author | coleenp |
|---|---|
| date | Wed, 20 Mar 2013 08:04:54 -0400 |
| parents | f34d701e952e |
| children | 291ffc492eb6 6e04c193845f |
| 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" | |
|
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) { |
| 0 | 128 assert(h_exception() != NULL, "exception should not be NULL"); |
| 129 | |
| 130 // tracing (do this up front - so it works during boot strapping) | |
| 131 if (TraceExceptions) { | |
| 132 ttyLocker ttyl; | |
| 133 ResourceMark rm; | |
|
1011
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
0
diff
changeset
|
134 tty->print_cr("Exception <%s>%s%s (" INTPTR_FORMAT " ) \n" |
|
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 | |
| 144 if (special_exception(thread, file, line, h_exception)) return; | |
| 145 | |
| 1142 | 146 assert(h_exception->is_a(SystemDictionary::Throwable_klass()), "exception is not a subclass of java/lang/Throwable"); |
| 0 | 147 |
| 148 // set the pending exception | |
| 149 thread->set_pending_exception(h_exception(), file, line); | |
| 150 | |
| 151 // vm log | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
3960
diff
changeset
|
152 Events::log_exception(thread, "Threw " INTPTR_FORMAT " at %s:%d", (address)h_exception(), file, line); |
| 0 | 153 } |
| 154 | |
| 155 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
156 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
|
157 Handle h_loader, Handle h_protection_domain) { |
| 0 | 158 // 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
|
159 if (special_exception(thread, file, line, name, message)) return; |
| 0 | 160 // Create and throw exception |
| 161 Handle h_cause(thread, NULL); | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
162 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
|
163 _throw(thread, file, line, h_exception, message); |
| 0 | 164 } |
| 165 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
166 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
|
167 Handle h_loader, Handle h_protection_domain) { |
| 0 | 168 // 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
|
169 if (special_exception(thread, file, line, name, message)) return; |
| 0 | 170 // 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
|
171 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
|
172 _throw(thread, file, line, h_exception, message); |
| 0 | 173 } |
| 174 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
175 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
|
176 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
|
177 // 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
|
178 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
|
179 // Create and throw exception |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
180 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
|
181 _throw(thread, file, line, h_exception, NULL); |
| 0 | 182 } |
| 183 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
184 void Exceptions::_throw_args(Thread* thread, const char* file, int line, Symbol* name, Symbol* signature, JavaCallArguments *args) { |
| 0 | 185 // 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
|
186 if (special_exception(thread, file, line, name, NULL)) return; |
| 0 | 187 // Create and throw exception |
| 188 Handle h_loader(thread, NULL); | |
| 189 Handle h_prot(thread, NULL); | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
190 Handle exception = new_exception(thread, name, signature, args, h_loader, h_prot); |
| 0 | 191 _throw(thread, file, line, exception); |
| 192 } | |
| 193 | |
| 194 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
195 // Methods for default parameters. |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
196 // 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
|
197 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
|
198 _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
|
199 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
200 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
|
201 _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
|
202 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
203 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
|
204 _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
|
205 } |
|
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 |
|
3272
01147d8aac1d
7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents:
2426
diff
changeset
|
208 void Exceptions::throw_stack_overflow_exception(Thread* THREAD, const char* file, int line, methodHandle method) { |
| 0 | 209 Handle exception; |
| 210 if (!THREAD->has_pending_exception()) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
211 Klass* k = SystemDictionary::StackOverflowError_klass(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
212 oop e = InstanceKlass::cast(k)->allocate_instance(CHECK); |
| 0 | 213 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
|
214 assert(InstanceKlass::cast(k)->is_initialized(), "need to increase min_stack_allowed calculation"); |
| 0 | 215 if (StackTraceInThrowable) { |
|
3272
01147d8aac1d
7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents:
2426
diff
changeset
|
216 java_lang_Throwable::fill_in_stack_trace(exception, method()); |
| 0 | 217 } |
| 218 } else { | |
| 219 // if prior exception, throw that one instead | |
| 220 exception = Handle(THREAD, THREAD->pending_exception()); | |
| 221 } | |
|
3272
01147d8aac1d
7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents:
2426
diff
changeset
|
222 _throw(THREAD, file, line, exception); |
| 0 | 223 } |
| 224 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
225 void Exceptions::fthrow(Thread* thread, const char* file, int line, Symbol* h_name, const char* format, ...) { |
| 0 | 226 const int max_msg_size = 1024; |
| 227 va_list ap; | |
| 228 va_start(ap, format); | |
| 229 char msg[max_msg_size]; | |
| 230 vsnprintf(msg, max_msg_size, format, ap); | |
| 231 msg[max_msg_size-1] = '\0'; | |
| 232 va_end(ap); | |
| 233 _throw_msg(thread, file, line, h_name, msg); | |
| 234 } | |
| 235 | |
| 236 // Creates an exception oop, calls the <init> method with the given signature. | |
| 237 // and returns a Handle | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
238 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
|
239 Symbol* signature, JavaCallArguments *args, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
240 Handle h_loader, Handle h_protection_domain) { |
| 0 | 241 assert(Universe::is_fully_initialized(), |
| 242 "cannot be called during initialization"); | |
| 243 assert(thread->is_Java_thread(), "can only be called by a Java thread"); | |
| 244 assert(!thread->has_pending_exception(), "already has exception"); | |
| 245 | |
| 246 Handle h_exception; | |
| 247 | |
| 248 // Resolve exception klass | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
249 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
|
250 instanceKlassHandle klass(thread, ik); |
| 0 | 251 |
| 252 if (!thread->has_pending_exception()) { | |
| 253 assert(klass.not_null(), "klass must exist"); | |
| 254 // We are about to create an instance - so make sure that klass is initialized | |
| 255 klass->initialize(thread); | |
| 256 if (!thread->has_pending_exception()) { | |
| 257 // Allocate new exception | |
| 258 h_exception = klass->allocate_instance_handle(thread); | |
| 259 if (!thread->has_pending_exception()) { | |
| 260 JavaValue result(T_VOID); | |
| 261 args->set_receiver(h_exception); | |
| 262 // Call constructor | |
| 263 JavaCalls::call_special(&result, klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
264 vmSymbols::object_initializer_name(), |
| 0 | 265 signature, |
| 266 args, | |
| 267 thread); | |
| 268 } | |
| 269 } | |
| 270 } | |
| 271 | |
| 272 // Check if another exception was thrown in the process, if so rethrow that one | |
| 273 if (thread->has_pending_exception()) { | |
| 274 h_exception = Handle(thread, thread->pending_exception()); | |
| 275 thread->clear_pending_exception(); | |
| 276 } | |
| 277 return h_exception; | |
| 278 } | |
| 279 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
280 // 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
|
281 // and returns a Handle |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
282 // 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
|
283 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
|
284 Symbol* signature, JavaCallArguments *args, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
285 Handle h_cause, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
286 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
|
287 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
|
288 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
289 // 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
|
290 if (h_cause.not_null()) { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
291 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
|
292 "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
|
293 JavaValue result1(T_OBJECT); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
294 JavaCallArguments args1; |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
295 args1.set_receiver(h_exception); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
296 args1.push_oop(h_cause); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
297 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
|
298 vmSymbols::initCause_name(), |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
299 vmSymbols::throwable_throwable_signature(), |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
300 &args1, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
301 thread); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
302 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
303 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
304 // 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
|
305 if (thread->has_pending_exception()) { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
306 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
|
307 thread->clear_pending_exception(); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
308 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
309 return h_exception; |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
310 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
311 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
312 // 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
|
313 // creating a new exception |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
314 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
|
315 Handle h_cause, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
316 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
|
317 ExceptionMsgToUtf8Mode to_utf8_safe) { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
318 JavaCallArguments args; |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
319 Symbol* signature = NULL; |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
320 if (h_cause.is_null()) { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
321 signature = vmSymbols::void_method_signature(); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
322 } else { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
323 signature = vmSymbols::throwable_void_signature(); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
324 args.push_oop(h_cause); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
325 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
326 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
|
327 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
328 |
| 0 | 329 // Convenience method. Calls either the <init>() or <init>(String) method when |
| 330 // creating a new exception | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
331 Handle Exceptions::new_exception(Thread* thread, Symbol* name, |
| 0 | 332 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
|
333 Handle h_loader, Handle h_protection_domain, |
| 0 | 334 ExceptionMsgToUtf8Mode to_utf8_safe) { |
| 335 JavaCallArguments args; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
336 Symbol* signature = NULL; |
| 0 | 337 if (message == NULL) { |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
338 signature = vmSymbols::void_method_signature(); |
| 0 | 339 } else { |
| 340 // We want to allocate storage, but we can't do that if there's | |
| 341 // a pending exception, so we preserve any pending exception | |
| 342 // around the allocation. | |
| 343 // If we get an exception from the allocation, prefer that to | |
| 344 // the exception we are trying to build, or the pending exception. | |
| 345 // This is sort of like what PRESERVE_EXCEPTION_MARK does, except | |
| 346 // 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
|
347 Handle incoming_exception(thread, NULL); |
| 0 | 348 if (thread->has_pending_exception()) { |
| 349 incoming_exception = Handle(thread, thread->pending_exception()); | |
| 350 thread->clear_pending_exception(); | |
| 351 } | |
| 352 Handle msg; | |
| 353 if (to_utf8_safe == safe_to_utf8) { | |
| 354 // Make a java UTF8 string. | |
| 355 msg = java_lang_String::create_from_str(message, thread); | |
| 356 } else { | |
| 357 // Make a java string keeping the encoding scheme of the original string. | |
| 358 msg = java_lang_String::create_from_platform_dependent_str(message, thread); | |
| 359 } | |
| 360 if (thread->has_pending_exception()) { | |
| 361 Handle exception(thread, thread->pending_exception()); | |
| 362 thread->clear_pending_exception(); | |
| 363 return exception; | |
| 364 } | |
| 365 if (incoming_exception.not_null()) { | |
| 366 return incoming_exception; | |
| 367 } | |
| 368 args.push_oop(msg); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
369 signature = vmSymbols::string_void_signature(); |
| 0 | 370 } |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
371 return new_exception(thread, name, signature, &args, h_cause, h_loader, h_protection_domain); |
| 0 | 372 } |
| 373 | |
| 374 // Another convenience method that creates handles for null class loaders and | |
| 375 // protection domains and null causes. | |
| 376 // If the last parameter 'to_utf8_mode' is safe_to_utf8, | |
| 377 // it means we can safely ignore the encoding scheme of the message string and | |
| 378 // convert it directly to a java UTF8 string. Otherwise, we need to take the | |
| 379 // encoding scheme of the string into account. One thing we should do at some | |
| 380 // point is to push this flag down to class java_lang_String since other | |
| 381 // classes may need similar functionalities. | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
4872
diff
changeset
|
382 Handle Exceptions::new_exception(Thread* thread, Symbol* name, |
| 0 | 383 const char* message, |
| 384 ExceptionMsgToUtf8Mode to_utf8_safe) { | |
| 385 | |
| 386 Handle h_loader(thread, NULL); | |
| 387 Handle h_prot(thread, NULL); | |
| 388 Handle h_cause(thread, NULL); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
389 return Exceptions::new_exception(thread, name, message, h_cause, h_loader, |
| 0 | 390 h_prot, to_utf8_safe); |
| 391 } | |
| 392 | |
| 393 // Implementation of ExceptionMark | |
| 394 | |
| 395 ExceptionMark::ExceptionMark(Thread*& thread) { | |
| 396 thread = Thread::current(); | |
| 397 _thread = thread; | |
| 398 if (_thread->has_pending_exception()) { | |
| 399 oop exception = _thread->pending_exception(); | |
| 400 _thread->clear_pending_exception(); // Needed to avoid infinite recursion | |
| 401 exception->print(); | |
| 402 fatal("ExceptionMark constructor expects no pending exceptions"); | |
| 403 } | |
| 404 } | |
| 405 | |
| 406 | |
| 407 ExceptionMark::~ExceptionMark() { | |
| 408 if (_thread->has_pending_exception()) { | |
| 409 Handle exception(_thread, _thread->pending_exception()); | |
| 410 _thread->clear_pending_exception(); // Needed to avoid infinite recursion | |
| 411 if (is_init_completed()) { | |
| 412 exception->print(); | |
| 413 fatal("ExceptionMark destructor expects no pending exceptions"); | |
| 414 } else { | |
| 415 vm_exit_during_initialization(exception); | |
| 416 } | |
| 417 } | |
| 418 } | |
| 419 | |
| 420 // ---------------------------------------------------------------------------------------- | |
| 421 | |
| 422 #ifndef PRODUCT | |
| 423 // 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
|
424 void Exceptions::debug_check_abort(const char *value_string, const char* message) { |
| 0 | 425 if (AbortVMOnException != NULL && value_string != NULL && |
| 426 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
|
427 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
|
428 strcmp(message, AbortVMOnExceptionMessage) == 0) { |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
429 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
|
430 } |
| 0 | 431 } |
| 432 } | |
| 433 | |
|
1684
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
434 void Exceptions::debug_check_abort(Handle exception, const char* message) { |
| 0 | 435 if (AbortVMOnException != NULL) { |
| 436 ResourceMark rm; | |
|
1684
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
437 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
|
438 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
|
439 if (msg != NULL) { |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
440 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
|
441 } |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
442 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
443 debug_check_abort(InstanceKlass::cast(exception()->klass())->external_name(), message); |
| 0 | 444 } |
| 445 } | |
| 446 #endif |