| /dalvik/vm/ |
| H A D | Exception.h | 24 * Create a Throwable and throw an exception in the current thread (where
25 * "throwing" just means "set the thread's exception pointer").
29 * If we have a bad exception hierarchy -- something in Throwable.<init>
30 * is missing -- then every attempt to throw an exception will result
31 * in another exception. Exceptions are generally allowed to "chain"
90 * Return the exception being thrown in the current thread, or NULL if
91 * no exception is pending.
94 return self->exception;
98 * Set the exception being thrown in the current thread.
100 INLINE void dvmSetException(Thread* self, Object* exception) argument
[all...] |
| H A D | Thread.cpp | 739 ALOGE("exception thrown while constructing main thread object");
757 ALOGE("exception thrown while constructing main vmthread object");
1551 * The current thread is exiting with an uncaught exception. The
1553 * thread-exit-uncaught-exception handler for the VM, for a specific
1560 * This should only be called when an exception is pending. Before
1561 * returning, the exception will be cleared.
1565 Object* exception; local
1569 ALOGW("threadid=%d: thread exiting with uncaught exception (group=%p)",
1574 * Get a pointer to the exception, then clear out the one in the
1577 exception
[all...] |
| H A D | Exception.cpp | 27 We have one fairly sticky issue to deal with: creating the exception stack
32 The exception mechanism requires that the current stack trace be associated
39 (2) The VM throws an exception from within the interpreter core, e.g.
41 (3) The VM throws an exception from somewhere deeper down, e.g. while
47 an exception. We can't store it globally, because the various threads
54 with by passing the PC into the exception creation function. The trick
56 operations. Making it more costly to throw an exception is acceptable.
69 (d) Before doing something that might throw an exception, push a
83 - Throw an exception before re-saving the PC (i.e in the same opcode)
99 static bool initException(Object* exception, cons
115 Object* exception; local
247 initException(Object* exception, const char* msg, Object* cause, Thread* self) argument
469 dvmIsCheckedException(const Object* exception) argument
539 dvmGetExceptionCause(const Object* exception) argument
567 Object* exception; local
715 dvmFindCatchBlock(Thread* self, int relPc, Object* exception, bool scanOnly, void** newFrame) argument
1072 getExceptionMessage(Object* exception) argument
1123 logStackTraceOf(Object* exception) argument
1164 Object* exception = dvmThreadSelf()->exception; local
1295 Object* exception = dvmGetException(self); local
[all...] |
| H A D | Thread.h | 153 /* current exception, or NULL if nothing pending */
154 Object* exception; member in struct:Thread
|
| H A D | Debugger.cpp | 2437 * Tell JDWP that an exception has occurred.
2440 int catchRelPc, Object* exception)
2472 * Hand the event to the JDWP exception handler. Note we're using the
2473 * "NoReg" objectID on the exception, which is not strictly correct --
2474 * the exception object WILL be passed up to the debugger if the
2477 * away, and some people were experiencing a fatal build up of exception
2481 objectToObjectIdNoReg(exception),
2482 classObjectToRefTypeId(exception->clazz), &catchLoc,
2767 * We can be called while an exception is pending in the VM. We need
2816 /* if no exception throw
2439 dvmDbgPostException(void* throwFp, int throwRelPc, void* catchFp, int catchRelPc, Object* exception) argument
[all...] |
| H A D | Jni.cpp | 476 * Throwing an exception on failure is problematic, because JNI code
477 * may not be expecting an exception, and things sort of cascade. We
913 Object* exception = dvmGetException(self); local
914 std::string exceptionClassName(dvmHumanReadableDescriptor(exception->clazz->descriptor));
966 /* ran out of memory? could throw exception instead */
1014 * an exception for abstract and interface classes, and not accepting
1327 * Take this exception and throw it.
1340 * Constructs an exception object from the specified class with the message
1352 * If an exception is being thrown, return the exception objec
1361 Object* exception = dvmGetException(ts.self()); local
1381 Object* exception = dvmGetException(ts.self()); local
[all...] |
| /dalvik/vm/mterp/c/ |
| H A D | gotoTargets.cpp | 594 * Jump here when the code throws an exception.
601 Object* exception; local
607 * We save off the exception and clear the exception status. While
608 * processing the exception we might need to load some Throwable
613 exception = dvmGetException(self);
614 dvmAddTrackedAlloc(exception, self);
617 ALOGV("Handling exception %s at %s:%d",
618 exception->clazz->descriptor, curMethod->name,
622 * Report the exception thro
[all...] |
| /dalvik/vm/interp/ |
| H A D | Interp.cpp | 209 * check in the interpreter results in an exception being thrown.
618 void dvmReportExceptionThrow(Thread* self, Object* exception) argument
633 int catchRelPc = dvmFindCatchBlock(self, offset, exception,
636 catchRelPc, exception);
795 * might get unrolled past it by an exception, and it's tricky
846 * terminates "with a thrown exception".
1175 * an exception has been thrown.
1219 * Returns NULL with an exception raised on failure.
1382 * Throw an exception for a problem identified by the verifier.
1385 * throws an exception
[all...] |
| /dalvik/vm/mterp/out/ |
| H A D | InterpC-allstubs.cpp | 103 * exception.
303 * those created by the various exception throw routines, so that the
304 * exception stack trace can be generated correctly. If we don't do this,
315 * Check to see if "obj" is NULL. If so, throw an exception. Assumes the
321 * something that could throw an exception (so we have already called
348 * frame and throw an exception.
353 * anything else that can throw an exception.
1307 ILOGV("|move-exception v%d", vdst);
1308 assert(self->exception != NULL);
1309 SET_REGISTER(vdst, (u4)self->exception);
3687 Object* exception; local
[all...] |
| H A D | InterpC-mips.cpp | 103 * exception.
303 * those created by the various exception throw routines, so that the
304 * exception stack trace can be generated correctly. If we don't do this,
315 * Check to see if "obj" is NULL. If so, throw an exception. Assumes the
321 * something that could throw an exception (so we have already called
348 * frame and throw an exception.
353 * anything else that can throw an exception.
1785 * Jump here when the code throws an exception.
1792 Object* exception; local
1798 * We save off the exception an
[all...] |
| H A D | InterpC-portable.cpp | 103 * exception.
303 * those created by the various exception throw routines, so that the
304 * exception stack trace can be generated correctly. If we don't do this,
315 * Check to see if "obj" is NULL. If so, throw an exception. Assumes the
321 * something that could throw an exception (so we have already called
348 * frame and throw an exception.
353 * anything else that can throw an exception.
1318 ILOGV("|move-exception v%d", vdst);
1319 assert(self->exception != NULL);
1320 SET_REGISTER(vdst, (u4)self->exception);
3635 Object* exception; local
[all...] |
| H A D | InterpC-x86.cpp | 103 * exception.
303 * those created by the various exception throw routines, so that the
304 * exception stack trace can be generated correctly. If we don't do this,
315 * Check to see if "obj" is NULL. If so, throw an exception. Assumes the
321 * something that could throw an exception (so we have already called
348 * frame and throw an exception.
353 * anything else that can throw an exception.
1861 * Jump here when the code throws an exception.
1868 Object* exception; local
1874 * We save off the exception an
[all...] |