1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 /*
18 * Exception handling.
19 */
20 #ifndef _DALVIK_EXCEPTION
21 #define _DALVIK_EXCEPTION
22
23 /* initialization */
24 bool dvmExceptionStartup(void);
25 void dvmExceptionShutdown(void);
26
27 /*
28 * Throw an exception in the current thread, by class descriptor.
29 */
30 void dvmThrowChainedException(const char* exceptionDescriptor, const char* msg,
31 Object* cause);
dvmThrowException(const char * exceptionDescriptor,const char * msg)32 INLINE void dvmThrowException(const char* exceptionDescriptor,
33 const char* msg)
34 {
35 dvmThrowChainedException(exceptionDescriptor, msg, NULL);
36 }
37
38 /*
39 * Like dvmThrowChainedException, but takes printf-style args for the message.
40 */
41 void dvmThrowExceptionFmtV(const char* exceptionDescriptor, const char* fmt,
42 va_list args);
43 void dvmThrowExceptionFmt(const char* exceptionDescriptor, const char* fmt, ...)
44 #if defined(__GNUC__)
45 __attribute__ ((format(printf, 2, 3)))
46 #endif
47 ;
dvmThrowExceptionFmt(const char * exceptionDescriptor,const char * fmt,...)48 INLINE void dvmThrowExceptionFmt(const char* exceptionDescriptor,
49 const char* fmt, ...)
50 {
51 va_list args;
52 va_start(args, fmt);
53 dvmThrowExceptionFmtV(exceptionDescriptor, fmt, args);
54 va_end(args);
55 }
56
57 /*
58 * Throw an exception in the current thread, by class object.
59 */
60 void dvmThrowChainedExceptionByClass(ClassObject* exceptionClass,
61 const char* msg, Object* cause);
dvmThrowExceptionByClass(ClassObject * exceptionClass,const char * msg)62 INLINE void dvmThrowExceptionByClass(ClassObject* exceptionClass,
63 const char* msg)
64 {
65 dvmThrowChainedExceptionByClass(exceptionClass, msg, NULL);
66 }
67
68 /*
69 * Throw the named exception using the name of a class as the exception
70 * message.
71 */
72 void dvmThrowChainedExceptionWithClassMessage(const char* exceptionDescriptor,
73 const char* messageDescriptor, Object* cause);
dvmThrowExceptionWithClassMessage(const char * exceptionDescriptor,const char * messageDescriptor)74 INLINE void dvmThrowExceptionWithClassMessage(const char* exceptionDescriptor,
75 const char* messageDescriptor)
76 {
77 dvmThrowChainedExceptionWithClassMessage(exceptionDescriptor,
78 messageDescriptor, NULL);
79 }
80
81 /*
82 * Like dvmThrowExceptionWithMessageFromDescriptor, but take a
83 * class object instead of a name.
84 */
85 void dvmThrowExceptionByClassWithClassMessage(ClassObject* exceptionClass,
86 const char* messageDescriptor);
87
88 /*
89 * Return the exception being thrown in the current thread, or NULL if
90 * no exception is pending.
91 */
dvmGetException(Thread * self)92 INLINE Object* dvmGetException(Thread* self) {
93 return self->exception;
94 }
95
96 /*
97 * Set the exception being thrown in the current thread.
98 */
dvmSetException(Thread * self,Object * exception)99 INLINE void dvmSetException(Thread* self, Object* exception)
100 {
101 assert(exception != NULL);
102 self->exception = exception;
103 }
104
105 /*
106 * Clear the pending exception.
107 *
108 * (We use this rather than "set(null)" because we may need to have special
109 * fixups here for StackOverflowError stuff. Calling "clear" in the code
110 * makes it obvious.)
111 */
dvmClearException(Thread * self)112 INLINE void dvmClearException(Thread* self) {
113 self->exception = NULL;
114 }
115
116 /*
117 * Clear the pending exception. Used by the optimization and verification
118 * code, which has to run with "initializing" set to avoid going into a
119 * death-spin if the "class not found" exception can't be found.
120 */
121 void dvmClearOptException(Thread* self);
122
123 /*
124 * Returns "true" if an exception is pending. Use this if you have a
125 * "self" pointer.
126 */
dvmCheckException(Thread * self)127 INLINE bool dvmCheckException(Thread* self) {
128 return (self->exception != NULL);
129 }
130
131 /*
132 * Returns "true" if this is a "checked" exception, i.e. it's a subclass
133 * of Throwable (assumed) but not a subclass of RuntimeException or Error.
134 */
135 bool dvmIsCheckedException(const Object* exception);
136
137 /*
138 * Wrap the now-pending exception in a different exception.
139 *
140 * If something fails, an (unchecked) exception related to that failure
141 * will be pending instead.
142 */
143 void dvmWrapException(const char* newExcepStr);
144
145 /*
146 * Get the "cause" field from an exception.
147 *
148 * Returns NULL if the field is null or uninitialized.
149 */
150 Object* dvmGetExceptionCause(const Object* exception);
151
152 /*
153 * Print the exception stack trace on stderr. Calls the exception's
154 * print function.
155 */
156 void dvmPrintExceptionStackTrace(void);
157
158 /*
159 * Print the exception stack trace to the log file. The exception stack
160 * trace is computed within the VM.
161 */
162 void dvmLogExceptionStackTrace(void);
163
164 /*
165 * Search for a catch block that matches "exception".
166 *
167 * "*newFrame" gets a copy of the new frame pointer.
168 *
169 * If "doUnroll" is set, we unroll "thread"s stack as we go (and update
170 * self->curFrame with the same value as in *newFrame).
171 *
172 * Returns the offset to the catch code on success, or -1 if we couldn't
173 * find a catcher.
174 */
175 int dvmFindCatchBlock(Thread* self, int relPc, Object* exception,
176 bool doUnroll, void** newFrame);
177
178 /*
179 * Support for saving exception stack traces and converting them to
180 * usable form. Use the "FillIn" function to generate a compact array
181 * that represents the stack frames, then "GetStackTrace" to convert it
182 * to an array of StackTraceElement objects.
183 *
184 * Don't call the "Internal" form of the function directly.
185 */
186 void* dvmFillInStackTraceInternal(Thread* thread, bool wantObject, int* pCount);
187 /* return an [I for use by interpreted code */
dvmFillInStackTrace(Thread * thread)188 INLINE Object* dvmFillInStackTrace(Thread* thread) {
189 return (Object*) dvmFillInStackTraceInternal(thread, true, NULL);
190 }
191 ArrayObject* dvmGetStackTrace(const Object* stackState);
192 /* return an int* and array count; caller must free() the return value */
dvmFillInStackTraceRaw(Thread * thread,int * pCount)193 INLINE int* dvmFillInStackTraceRaw(Thread* thread, int* pCount) {
194 return (int*) dvmFillInStackTraceInternal(thread, false, pCount);
195 }
196 ArrayObject* dvmGetStackTraceRaw(const int* intVals, int stackDepth);
197
198 /*
199 * Print a formatted version of a raw stack trace to the log file.
200 */
201 void dvmLogRawStackTrace(const int* intVals, int stackDepth);
202
203 #endif /*_DALVIK_EXCEPTION*/
204