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