Mercurial > hg > truffle
annotate src/share/vm/utilities/exceptions.hpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | d17383603741 |
| children | aefb345d3f5e |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
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:
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: |
| 64 oop _pending_exception; // Thread has gc actions. | |
| 65 const char* _exception_file; // file information for exception (debugging only) | |
| 66 int _exception_line; // line information for exception (debugging only) | |
| 67 friend void check_ThreadShadow(); // checks _pending_exception offset | |
| 68 | |
| 69 // The following virtual exists only to force creation of a vtable. | |
| 70 // We need ThreadShadow to have a vtable, even in product builds, | |
| 71 // so that its layout will start at an offset of zero relative to Thread. | |
| 72 // Some C++ compilers are so "clever" that they put the ThreadShadow | |
| 73 // base class at offset 4 in Thread (after Thread's vtable), if they | |
| 74 // notice that Thread has a vtable but ThreadShadow does not. | |
| 75 virtual void unused_initial_virtual() { } | |
| 76 | |
| 77 public: | |
| 78 oop pending_exception() const { return _pending_exception; } | |
| 79 bool has_pending_exception() const { return _pending_exception != NULL; } | |
| 80 const char* exception_file() const { return _exception_file; } | |
| 81 int exception_line() const { return _exception_line; } | |
| 82 | |
| 83 // Code generation support | |
| 84 static ByteSize pending_exception_offset() { return byte_offset_of(ThreadShadow, _pending_exception); } | |
| 85 | |
| 86 // use THROW whenever possible! | |
| 87 void set_pending_exception(oop exception, const char* file, int line); | |
| 88 | |
| 89 // use CLEAR_PENDING_EXCEPTION whenever possible! | |
| 90 void clear_pending_exception(); | |
| 91 | |
| 92 ThreadShadow() : _pending_exception(NULL), | |
| 93 _exception_file(NULL), _exception_line(0) {} | |
| 94 }; | |
| 95 | |
| 96 | |
| 97 // Exceptions is a helper class that encapsulates all operations | |
| 98 // that require access to the thread interface and which are | |
| 99 // relatively rare. The Exceptions operations should only be | |
| 100 // used directly if the macros below are insufficient. | |
| 101 | |
| 102 class Exceptions { | |
| 103 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
|
104 static bool special_exception(Thread* thread, const char* file, int line, Symbol* name, const char* message); |
| 0 | 105 public: |
| 106 // this enum is defined to indicate whether it is safe to | |
| 107 // ignore the encoding scheme of the original message string. | |
| 108 typedef enum { | |
| 109 safe_to_utf8 = 0, | |
| 110 unsafe_to_utf8 = 1 | |
| 111 } ExceptionMsgToUtf8Mode; | |
| 112 // Throw exceptions: w/o message, w/ message & with formatted message. | |
| 113 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
|
114 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
|
115 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
116 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
|
117 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
|
118 Handle loader, Handle protection_domain); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
119 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
120 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
|
121 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
|
122 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
|
123 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
124 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
|
125 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
|
126 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
|
127 |
| 0 | 128 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
|
129 Symbol* name, Symbol* signature, |
| 0 | 130 JavaCallArguments* args); |
| 131 | |
| 132 // There is no THROW... macro for this method. Caller should remember | |
| 133 // to do a return after calling it. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
134 static void fthrow(Thread* thread, const char* file, int line, Symbol* name, |
| 0 | 135 const char* format, ...); |
| 136 | |
| 137 // Create and initialize a new exception | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
138 static Handle new_exception(Thread* thread, Symbol* name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
139 Symbol* signature, JavaCallArguments* args, |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
140 Handle loader, Handle protection_domain); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
141 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
142 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
|
143 Symbol* signature, JavaCallArguments* args, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
144 Handle cause, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
145 Handle loader, Handle protection_domain); |
| 0 | 146 |
|
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, |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
148 Handle cause, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
149 Handle loader, Handle protection_domain, |
| 0 | 150 ExceptionMsgToUtf8Mode to_utf8_safe = safe_to_utf8); |
| 151 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
152 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
|
153 const char* message, 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, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
155 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
|
156 |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
157 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
|
158 const char* message, |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
159 ExceptionMsgToUtf8Mode to_utf8_safe = safe_to_utf8); |
| 0 | 160 |
|
3272
01147d8aac1d
7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents:
2426
diff
changeset
|
161 static void throw_stack_overflow_exception(Thread* thread, const char* file, int line, methodHandle method); |
| 0 | 162 |
| 163 // for AbortVMOnException flag | |
|
1684
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
164 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
|
165 NOT_PRODUCT(static void debug_check_abort(const char *value_string, const char* message = NULL);) |
| 0 | 166 }; |
| 167 | |
| 168 | |
| 169 // The THREAD & TRAPS macros facilitate the declaration of functions that throw exceptions. | |
| 170 // Convention: Use the TRAPS macro as the last argument of such a function; e.g.: | |
| 171 // | |
| 172 // int this_function_may_trap(int x, float y, TRAPS) | |
| 173 | |
| 174 #define THREAD __the_thread__ | |
| 175 #define TRAPS Thread* THREAD | |
| 176 | |
| 177 | |
| 178 // The CHECK... macros should be used to pass along a THREAD reference and to check for pending | |
| 179 // exceptions. In special situations it is necessary to handle pending exceptions explicitly, | |
| 180 // in these cases the PENDING_EXCEPTION helper macros should be used. | |
| 181 // | |
| 182 // Macro naming conventions: Macros that end with _ require a result value to be returned. They | |
| 183 // are for functions with non-void result type. The result value is usually ignored because of | |
| 184 // the exception and is only needed for syntactic correctness. The _0 ending is a shortcut for | |
| 185 // _(0) since this is a frequent case. Example: | |
| 186 // | |
| 187 // int result = this_function_may_trap(x_arg, y_arg, CHECK_0); | |
| 188 // | |
| 189 // CAUTION: make sure that the function call using a CHECK macro is not the only statement of a | |
| 190 // conditional branch w/o enclosing {} braces, since the CHECK macros expand into several state- | |
| 191 // ments! | |
| 192 | |
| 193 #define PENDING_EXCEPTION (((ThreadShadow*)THREAD)->pending_exception()) | |
| 194 #define HAS_PENDING_EXCEPTION (((ThreadShadow*)THREAD)->has_pending_exception()) | |
| 195 #define CLEAR_PENDING_EXCEPTION (((ThreadShadow*)THREAD)->clear_pending_exception()) | |
| 196 | |
| 197 #define CHECK THREAD); if (HAS_PENDING_EXCEPTION) return ; (0 | |
| 198 #define CHECK_(result) THREAD); if (HAS_PENDING_EXCEPTION) return result; (0 | |
| 199 #define CHECK_0 CHECK_(0) | |
| 200 #define CHECK_NH CHECK_(Handle()) | |
| 201 #define CHECK_NULL CHECK_(NULL) | |
| 202 #define CHECK_false CHECK_(false) | |
| 203 | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3939
diff
changeset
|
204 #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
|
205 #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
|
206 #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
|
207 #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
|
208 #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
|
209 #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
|
210 |
| 0 | 211 // The THROW... macros should be used to throw an exception. They require a THREAD variable to be |
| 212 // visible within the scope containing the THROW. Usually this is achieved by declaring the function | |
| 213 // with a TRAPS argument. | |
| 214 | |
| 215 #define THREAD_AND_LOCATION THREAD, __FILE__, __LINE__ | |
| 216 | |
| 217 #define THROW_OOP(e) \ | |
| 218 { Exceptions::_throw_oop(THREAD_AND_LOCATION, e); return; } | |
| 219 | |
| 220 #define THROW_HANDLE(e) \ | |
| 221 { Exceptions::_throw(THREAD_AND_LOCATION, e); return; } | |
| 222 | |
| 223 #define THROW(name) \ | |
| 224 { Exceptions::_throw_msg(THREAD_AND_LOCATION, name, NULL); return; } | |
| 225 | |
| 226 #define THROW_MSG(name, message) \ | |
| 227 { Exceptions::_throw_msg(THREAD_AND_LOCATION, name, message); return; } | |
| 228 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
229 #define THROW_CAUSE(name, cause) \ |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
230 { 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
|
231 |
| 0 | 232 #define THROW_MSG_LOADER(name, message, loader, protection_domain) \ |
| 233 { Exceptions::_throw_msg(THREAD_AND_LOCATION, name, message, loader, protection_domain); return; } | |
| 234 | |
| 235 #define THROW_ARG(name, signature, args) \ | |
| 236 { Exceptions::_throw_args(THREAD_AND_LOCATION, name, signature, args); return; } | |
| 237 | |
| 238 #define THROW_OOP_(e, result) \ | |
| 239 { Exceptions::_throw_oop(THREAD_AND_LOCATION, e); return result; } | |
| 240 | |
| 241 #define THROW_HANDLE_(e, result) \ | |
| 242 { Exceptions::_throw(THREAD_AND_LOCATION, e); return result; } | |
| 243 | |
| 244 #define THROW_(name, result) \ | |
| 245 { Exceptions::_throw_msg(THREAD_AND_LOCATION, name, NULL); return result; } | |
| 246 | |
| 247 #define THROW_MSG_(name, message, result) \ | |
| 248 { Exceptions::_throw_msg(THREAD_AND_LOCATION, name, message); return result; } | |
| 249 | |
| 250 #define THROW_MSG_LOADER_(name, message, loader, protection_domain, result) \ | |
| 251 { Exceptions::_throw_msg(THREAD_AND_LOCATION, name, message, loader, protection_domain); return result; } | |
| 252 | |
| 253 #define THROW_ARG_(name, signature, args, result) \ | |
| 254 { Exceptions::_throw_args(THREAD_AND_LOCATION, name, signature, args); return result; } | |
| 255 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
256 #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
|
257 { 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
|
258 |
| 0 | 259 #define THROW_MSG_CAUSE_(name, message, cause, result) \ |
| 260 { Exceptions::_throw_msg_cause(THREAD_AND_LOCATION, name, message, cause); return result; } | |
| 261 | |
| 262 | |
| 263 #define THROW_OOP_0(e) THROW_OOP_(e, 0) | |
| 264 #define THROW_HANDLE_0(e) THROW_HANDLE_(e, 0) | |
| 265 #define THROW_0(name) THROW_(name, 0) | |
| 266 #define THROW_MSG_0(name, message) THROW_MSG_(name, message, 0) | |
| 267 #define THROW_WRAPPED_0(name, oop_to_wrap) THROW_WRAPPED_(name, oop_to_wrap, 0) | |
| 268 #define THROW_ARG_0(name, signature, arg) THROW_ARG_(name, signature, arg, 0) | |
| 269 #define THROW_MSG_CAUSE_0(name, message, cause) THROW_MSG_CAUSE_(name, message, cause, 0) | |
| 270 | |
| 710 | 271 #define THROW_NULL(name) THROW_(name, NULL) |
| 272 #define THROW_MSG_NULL(name, message) THROW_MSG_(name, message, NULL) | |
| 273 | |
| 0 | 274 // The CATCH macro checks that no exception has been thrown by a function; it is used at |
| 275 // call sites about which is statically known that the callee cannot throw an exception | |
| 276 // even though it is declared with TRAPS. | |
| 277 | |
| 278 #define CATCH \ | |
| 279 THREAD); if (HAS_PENDING_EXCEPTION) { \ | |
| 280 oop ex = PENDING_EXCEPTION; \ | |
| 281 CLEAR_PENDING_EXCEPTION; \ | |
| 282 ex->print(); \ | |
| 283 ShouldNotReachHere(); \ | |
| 284 } (0 | |
| 285 | |
| 286 // ExceptionMark is a stack-allocated helper class for local exception handling. | |
| 287 // It is used with the EXCEPTION_MARK macro. | |
| 288 | |
| 289 class ExceptionMark { | |
| 290 private: | |
| 291 Thread* _thread; | |
| 292 | |
| 293 public: | |
| 294 ExceptionMark(Thread*& thread); | |
| 295 ~ExceptionMark(); | |
| 296 }; | |
| 297 | |
| 298 | |
| 299 | |
| 300 // Use an EXCEPTION_MARK for 'local' exceptions. EXCEPTION_MARK makes sure that no | |
| 301 // pending exception exists upon entering its scope and tests that no pending exception | |
| 302 // exists when leaving the scope. | |
| 303 | |
| 304 // See also preserveException.hpp for PRESERVE_EXCEPTION_MARK macro, | |
| 305 // which preserves pre-existing exceptions and does not allow new | |
| 306 // exceptions. | |
| 307 | |
| 308 #define EXCEPTION_MARK Thread* THREAD; ExceptionMark __em(THREAD); | |
| 1972 | 309 |
| 310 #endif // SHARE_VM_UTILITIES_EXCEPTIONS_HPP |