Mercurial > hg > truffle
annotate src/share/vm/utilities/exceptions.hpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
| author | Bernhard Urban <bernhard.urban@jku.at> |
|---|---|
| date | Mon, 15 Apr 2013 19:54:58 +0200 |
| parents | 37977d1dcedc |
| children | 6b0fd0964b87 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
7582
aefb345d3f5e
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
6729
diff
changeset
|
2 * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1011
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1011
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:
1011
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_UTILITIES_EXCEPTIONS_HPP |
| 26 #define SHARE_VM_UTILITIES_EXCEPTIONS_HPP | |
| 27 | |
| 28 #include "memory/allocation.hpp" | |
| 29 #include "oops/oopsHierarchy.hpp" | |
| 30 #include "utilities/sizes.hpp" | |
| 31 | |
| 0 | 32 // This file provides the basic support for exception handling in the VM. |
| 33 // Note: We do not use C++ exceptions to avoid compiler dependencies and | |
| 34 // unpredictable performance. | |
| 35 // | |
| 36 // Scheme: Exceptions are stored with the thread. There is never more | |
| 37 // than one pending exception per thread. All functions that can throw | |
| 38 // an exception carry a THREAD argument (usually the last argument and | |
| 39 // declared with the TRAPS macro). Throwing an exception means setting | |
| 40 // a pending exception in the thread. Upon return from a function that | |
| 41 // can throw an exception, we must check if an exception is pending. | |
| 42 // The CHECK macros do this in a convenient way. Carrying around the | |
| 43 // thread provides also convenient access to it (e.g. for Handle | |
| 44 // creation, w/o the need for recomputation). | |
| 45 | |
| 46 | |
| 47 | |
| 48 // Forward declarations to be independent of the include structure. | |
| 49 // This allows us to have exceptions.hpp included in top.hpp. | |
| 50 | |
| 51 class Thread; | |
| 52 class Handle; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
53 class Symbol; |
| 0 | 54 class JavaCallArguments; |
| 55 | |
| 56 // The ThreadShadow class is a helper class to access the _pending_exception | |
| 57 // field of the Thread class w/o having access to the Thread's interface (for | |
| 58 // include hierachy reasons). | |
| 59 | |
| 6197 | 60 class ThreadShadow: public CHeapObj<mtThread> { |
| 3939 | 61 friend class VMStructs; |
| 62 | |
| 0 | 63 protected: |
|
8337
37977d1dcedc
Transmit deoptimization reason in thread local.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
8328
diff
changeset
|
64 int _pending_deoptimization; |
|
8328
6b6cbd8b8914
Support deoptimizing before the entry to a synchronized method.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
7582
diff
changeset
|
65 bool _pending_monitorenter; |
| 0 | 66 oop _pending_exception; // Thread has gc actions. |
| 67 const char* _exception_file; // file information for exception (debugging only) | |
| 68 int _exception_line; // line information for exception (debugging only) | |
| 69 friend void check_ThreadShadow(); // checks _pending_exception offset | |
| 70 | |
| 71 // The following virtual exists only to force creation of a vtable. | |
| 72 // We need ThreadShadow to have a vtable, even in product builds, | |
| 73 // so that its layout will start at an offset of zero relative to Thread. | |
| 74 // Some C++ compilers are so "clever" that they put the ThreadShadow | |
| 75 // base class at offset 4 in Thread (after Thread's vtable), if they | |
| 76 // notice that Thread has a vtable but ThreadShadow does not. | |
| 77 virtual void unused_initial_virtual() { } | |
| 78 | |
| 79 public: | |
| 80 oop pending_exception() const { return _pending_exception; } | |
|
8337
37977d1dcedc
Transmit deoptimization reason in thread local.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
8328
diff
changeset
|
81 int pending_deoptimization() const { return _pending_deoptimization; } |
| 0 | 82 bool has_pending_exception() const { return _pending_exception != NULL; } |
| 83 const char* exception_file() const { return _exception_file; } | |
| 84 int exception_line() const { return _exception_line; } | |
|
8328
6b6cbd8b8914
Support deoptimizing before the entry to a synchronized method.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
7582
diff
changeset
|
85 bool has_pending_monitorenter() const { return _pending_monitorenter; } |
| 0 | 86 |
| 87 // Code generation support | |
|
8337
37977d1dcedc
Transmit deoptimization reason in thread local.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
8328
diff
changeset
|
88 static ByteSize pending_deoptimization_offset() { return byte_offset_of(ThreadShadow, _pending_deoptimization); } |
| 0 | 89 static ByteSize pending_exception_offset() { return byte_offset_of(ThreadShadow, _pending_exception); } |
|
8328
6b6cbd8b8914
Support deoptimizing before the entry to a synchronized method.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
7582
diff
changeset
|
90 static ByteSize pending_monitorenter_offset() { return byte_offset_of(ThreadShadow, _pending_monitorenter); } |
|
6b6cbd8b8914
Support deoptimizing before the entry to a synchronized method.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
7582
diff
changeset
|
91 |
|
8337
37977d1dcedc
Transmit deoptimization reason in thread local.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
8328
diff
changeset
|
92 void set_pending_monitorenter(bool b) { _pending_monitorenter = b; } |
|
37977d1dcedc
Transmit deoptimization reason in thread local.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
8328
diff
changeset
|
93 void set_pending_deoptimization(int reason) { _pending_deoptimization = reason; } |
| 0 | 94 |
| 95 // use THROW whenever possible! | |
| 96 void set_pending_exception(oop exception, const char* file, int line); | |
| 97 | |
| 98 // use CLEAR_PENDING_EXCEPTION whenever possible! | |
| 99 void clear_pending_exception(); | |
| 100 | |
| 101 ThreadShadow() : _pending_exception(NULL), | |
|
8337
37977d1dcedc
Transmit deoptimization reason in thread local.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
8328
diff
changeset
|
102 _exception_file(NULL), _exception_line(0), _pending_monitorenter(false), _pending_deoptimization(-1) {} |
| 0 | 103 }; |
| 104 | |
| 105 | |
| 106 // Exceptions is a helper class that encapsulates all operations | |
| 107 // that require access to the thread interface and which are | |
| 108 // relatively rare. The Exceptions operations should only be | |
| 109 // used directly if the macros below are insufficient. | |
| 110 | |
| 111 class Exceptions { | |
| 112 static bool special_exception(Thread *thread, const char* file, int line, Handle exception); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
113 static bool special_exception(Thread* thread, const char* file, int line, Symbol* name, const char* message); |
| 0 | 114 public: |
| 115 // this enum is defined to indicate whether it is safe to | |
| 116 // ignore the encoding scheme of the original message string. | |
| 117 typedef enum { | |
| 118 safe_to_utf8 = 0, | |
| 119 unsafe_to_utf8 = 1 | |
| 120 } ExceptionMsgToUtf8Mode; | |
| 121 // Throw exceptions: w/o message, w/ message & with formatted message. | |
| 122 static void _throw_oop(Thread* thread, const char* file, int line, oop exception); | |
|
1011
fcb148c6b605
6889302: TraceExceptions output should include detail message
never
parents:
844
diff
changeset
|
123 static void _throw(Thread* thread, const char* file, int line, Handle exception, const char* msg = NULL); |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
124 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
125 static void _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:
6266
diff
changeset
|
126 static void _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:
6266
diff
changeset
|
127 Handle loader, Handle protection_domain); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
128 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
129 static void _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:
6266
diff
changeset
|
130 static void _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:
6266
diff
changeset
|
131 Handle h_loader, Handle h_protection_domain); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
132 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
133 static void _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:
6266
diff
changeset
|
134 static void _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:
6266
diff
changeset
|
135 Handle h_loader, Handle h_protection_domain); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
136 |
| 0 | 137 static void _throw_args(Thread* thread, const char* file, int line, |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
138 Symbol* name, Symbol* signature, |
| 0 | 139 JavaCallArguments* args); |
| 140 | |
| 141 // There is no THROW... macro for this method. Caller should remember | |
| 142 // to do a return after calling it. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
143 static void fthrow(Thread* thread, const char* file, int line, Symbol* name, |
| 0 | 144 const char* format, ...); |
| 145 | |
| 146 // Create and initialize a new exception | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
147 static Handle new_exception(Thread* thread, Symbol* name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
148 Symbol* signature, JavaCallArguments* args, |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
149 Handle loader, Handle protection_domain); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
150 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
151 static Handle new_exception(Thread* thread, Symbol* name, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
152 Symbol* signature, JavaCallArguments* args, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
153 Handle cause, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
154 Handle loader, Handle protection_domain); |
| 0 | 155 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
156 static Handle new_exception(Thread* thread, Symbol* name, |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
157 Handle cause, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
158 Handle loader, Handle protection_domain, |
| 0 | 159 ExceptionMsgToUtf8Mode to_utf8_safe = safe_to_utf8); |
| 160 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
161 static Handle new_exception(Thread* thread, Symbol* name, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
162 const char* message, Handle cause, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
163 Handle loader, Handle protection_domain, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
164 ExceptionMsgToUtf8Mode to_utf8_safe = safe_to_utf8); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
165 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
166 static Handle new_exception(Thread* thread, Symbol* name, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
167 const char* message, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
168 ExceptionMsgToUtf8Mode to_utf8_safe = safe_to_utf8); |
| 0 | 169 |
|
3272
01147d8aac1d
7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents:
2426
diff
changeset
|
170 static void throw_stack_overflow_exception(Thread* thread, const char* file, int line, methodHandle method); |
| 0 | 171 |
| 172 // for AbortVMOnException flag | |
|
1684
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
173 NOT_PRODUCT(static void debug_check_abort(Handle exception, const char* message = NULL);) |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
174 NOT_PRODUCT(static void debug_check_abort(const char *value_string, const char* message = NULL);) |
| 0 | 175 }; |
| 176 | |
| 177 | |
| 178 // The THREAD & TRAPS macros facilitate the declaration of functions that throw exceptions. | |
| 179 // Convention: Use the TRAPS macro as the last argument of such a function; e.g.: | |
| 180 // | |
| 181 // int this_function_may_trap(int x, float y, TRAPS) | |
| 182 | |
| 183 #define THREAD __the_thread__ | |
| 184 #define TRAPS Thread* THREAD | |
| 185 | |
| 186 | |
| 187 // The CHECK... macros should be used to pass along a THREAD reference and to check for pending | |
| 188 // exceptions. In special situations it is necessary to handle pending exceptions explicitly, | |
| 189 // in these cases the PENDING_EXCEPTION helper macros should be used. | |
| 190 // | |
| 191 // Macro naming conventions: Macros that end with _ require a result value to be returned. They | |
| 192 // are for functions with non-void result type. The result value is usually ignored because of | |
| 193 // the exception and is only needed for syntactic correctness. The _0 ending is a shortcut for | |
| 194 // _(0) since this is a frequent case. Example: | |
| 195 // | |
| 196 // int result = this_function_may_trap(x_arg, y_arg, CHECK_0); | |
| 197 // | |
| 198 // CAUTION: make sure that the function call using a CHECK macro is not the only statement of a | |
| 199 // conditional branch w/o enclosing {} braces, since the CHECK macros expand into several state- | |
| 200 // ments! | |
| 201 | |
| 202 #define PENDING_EXCEPTION (((ThreadShadow*)THREAD)->pending_exception()) | |
| 203 #define HAS_PENDING_EXCEPTION (((ThreadShadow*)THREAD)->has_pending_exception()) | |
| 204 #define CLEAR_PENDING_EXCEPTION (((ThreadShadow*)THREAD)->clear_pending_exception()) | |
| 205 | |
| 206 #define CHECK THREAD); if (HAS_PENDING_EXCEPTION) return ; (0 | |
| 207 #define CHECK_(result) THREAD); if (HAS_PENDING_EXCEPTION) return result; (0 | |
| 208 #define CHECK_0 CHECK_(0) | |
| 209 #define CHECK_NH CHECK_(Handle()) | |
| 210 #define CHECK_NULL CHECK_(NULL) | |
| 211 #define CHECK_false CHECK_(false) | |
| 212 | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3939
diff
changeset
|
213 #define CHECK_AND_CLEAR THREAD); if (HAS_PENDING_EXCEPTION) { CLEAR_PENDING_EXCEPTION; return; } (0 |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3939
diff
changeset
|
214 #define CHECK_AND_CLEAR_(result) THREAD); if (HAS_PENDING_EXCEPTION) { CLEAR_PENDING_EXCEPTION; return result; } (0 |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3939
diff
changeset
|
215 #define CHECK_AND_CLEAR_0 CHECK_AND_CLEAR_(0) |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3939
diff
changeset
|
216 #define CHECK_AND_CLEAR_NH CHECK_AND_CLEAR_(Handle()) |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3939
diff
changeset
|
217 #define CHECK_AND_CLEAR_NULL CHECK_AND_CLEAR_(NULL) |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3939
diff
changeset
|
218 #define CHECK_AND_CLEAR_false CHECK_AND_CLEAR_(false) |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3939
diff
changeset
|
219 |
| 0 | 220 // The THROW... macros should be used to throw an exception. They require a THREAD variable to be |
| 221 // visible within the scope containing the THROW. Usually this is achieved by declaring the function | |
| 222 // with a TRAPS argument. | |
| 223 | |
| 224 #define THREAD_AND_LOCATION THREAD, __FILE__, __LINE__ | |
| 225 | |
| 226 #define THROW_OOP(e) \ | |
| 227 { Exceptions::_throw_oop(THREAD_AND_LOCATION, e); return; } | |
| 228 | |
| 229 #define THROW_HANDLE(e) \ | |
| 230 { Exceptions::_throw(THREAD_AND_LOCATION, e); return; } | |
| 231 | |
| 232 #define THROW(name) \ | |
| 233 { Exceptions::_throw_msg(THREAD_AND_LOCATION, name, NULL); return; } | |
| 234 | |
| 235 #define THROW_MSG(name, message) \ | |
| 236 { Exceptions::_throw_msg(THREAD_AND_LOCATION, name, message); return; } | |
| 237 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
238 #define THROW_CAUSE(name, cause) \ |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
239 { Exceptions::_throw_cause(THREAD_AND_LOCATION, name, cause); return; } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
240 |
| 0 | 241 #define THROW_MSG_LOADER(name, message, loader, protection_domain) \ |
| 242 { Exceptions::_throw_msg(THREAD_AND_LOCATION, name, message, loader, protection_domain); return; } | |
| 243 | |
| 244 #define THROW_ARG(name, signature, args) \ | |
| 245 { Exceptions::_throw_args(THREAD_AND_LOCATION, name, signature, args); return; } | |
| 246 | |
| 247 #define THROW_OOP_(e, result) \ | |
| 248 { Exceptions::_throw_oop(THREAD_AND_LOCATION, e); return result; } | |
| 249 | |
| 250 #define THROW_HANDLE_(e, result) \ | |
| 251 { Exceptions::_throw(THREAD_AND_LOCATION, e); return result; } | |
| 252 | |
| 253 #define THROW_(name, result) \ | |
| 254 { Exceptions::_throw_msg(THREAD_AND_LOCATION, name, NULL); return result; } | |
| 255 | |
| 256 #define THROW_MSG_(name, message, result) \ | |
| 257 { Exceptions::_throw_msg(THREAD_AND_LOCATION, name, message); return result; } | |
| 258 | |
| 259 #define THROW_MSG_LOADER_(name, message, loader, protection_domain, result) \ | |
| 260 { Exceptions::_throw_msg(THREAD_AND_LOCATION, name, message, loader, protection_domain); return result; } | |
| 261 | |
| 262 #define THROW_ARG_(name, signature, args, result) \ | |
| 263 { Exceptions::_throw_args(THREAD_AND_LOCATION, name, signature, args); return result; } | |
| 264 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
265 #define THROW_MSG_CAUSE(name, message, cause) \ |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
266 { Exceptions::_throw_msg_cause(THREAD_AND_LOCATION, name, message, cause); return; } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
267 |
| 0 | 268 #define THROW_MSG_CAUSE_(name, message, cause, result) \ |
| 269 { Exceptions::_throw_msg_cause(THREAD_AND_LOCATION, name, message, cause); return result; } | |
| 270 | |
| 271 | |
| 272 #define THROW_OOP_0(e) THROW_OOP_(e, 0) | |
| 273 #define THROW_HANDLE_0(e) THROW_HANDLE_(e, 0) | |
| 274 #define THROW_0(name) THROW_(name, 0) | |
| 275 #define THROW_MSG_0(name, message) THROW_MSG_(name, message, 0) | |
| 276 #define THROW_WRAPPED_0(name, oop_to_wrap) THROW_WRAPPED_(name, oop_to_wrap, 0) | |
| 277 #define THROW_ARG_0(name, signature, arg) THROW_ARG_(name, signature, arg, 0) | |
| 278 #define THROW_MSG_CAUSE_0(name, message, cause) THROW_MSG_CAUSE_(name, message, cause, 0) | |
|
7582
aefb345d3f5e
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
6729
diff
changeset
|
279 #define THROW_MSG_CAUSE_NULL(name, message, cause) THROW_MSG_CAUSE_(name, message, cause, NULL) |
| 0 | 280 |
| 710 | 281 #define THROW_NULL(name) THROW_(name, NULL) |
| 282 #define THROW_MSG_NULL(name, message) THROW_MSG_(name, message, NULL) | |
| 283 | |
| 0 | 284 // The CATCH macro checks that no exception has been thrown by a function; it is used at |
| 285 // call sites about which is statically known that the callee cannot throw an exception | |
| 286 // even though it is declared with TRAPS. | |
| 287 | |
| 288 #define CATCH \ | |
| 289 THREAD); if (HAS_PENDING_EXCEPTION) { \ | |
| 290 oop ex = PENDING_EXCEPTION; \ | |
| 291 CLEAR_PENDING_EXCEPTION; \ | |
| 292 ex->print(); \ | |
| 293 ShouldNotReachHere(); \ | |
| 294 } (0 | |
| 295 | |
| 296 // ExceptionMark is a stack-allocated helper class for local exception handling. | |
| 297 // It is used with the EXCEPTION_MARK macro. | |
| 298 | |
| 299 class ExceptionMark { | |
| 300 private: | |
| 301 Thread* _thread; | |
| 302 | |
| 303 public: | |
| 304 ExceptionMark(Thread*& thread); | |
| 305 ~ExceptionMark(); | |
| 306 }; | |
| 307 | |
| 308 | |
| 309 | |
| 310 // Use an EXCEPTION_MARK for 'local' exceptions. EXCEPTION_MARK makes sure that no | |
| 311 // pending exception exists upon entering its scope and tests that no pending exception | |
| 312 // exists when leaving the scope. | |
| 313 | |
| 314 // See also preserveException.hpp for PRESERVE_EXCEPTION_MARK macro, | |
| 315 // which preserves pre-existing exceptions and does not allow new | |
| 316 // exceptions. | |
| 317 | |
| 318 #define EXCEPTION_MARK Thread* THREAD; ExceptionMark __em(THREAD); | |
| 1972 | 319 |
| 320 #endif // SHARE_VM_UTILITIES_EXCEPTIONS_HPP |