/*
* Dump the catches table associated with the code.
*/
void dumpCatches(DexFile* pDexFile, const DexCode* pCode)
{
u4 triesSize = pCode->triesSize;
if (triesSize == 0) {
printf(" catches : (none)\n");
return;
}
printf(" catches : %d\n", triesSize);
const DexTry* pTries = dexGetTries(pCode);
u4 i;
for (i = 0; i < triesSize; i++) {
const DexTry* pTry = &pTries[i];
u4 start = pTry->startAddr;
u4 end = start + pTry->insnCount;
DexCatchIterator iterator;
printf(" 0x%04x - 0x%04x\n", start, end);
dexCatchIteratorInit(&iterator, pCode, pTry->handlerOff);
for (;;) {
DexCatchHandler* handler = dexCatchIteratorNext(&iterator);
const char* descriptor;
if (handler == NULL) {
break;
}
descriptor = (handler->typeIdx == kDexNoIndex) ? "<any>" :
dexStringByTypeIdx(pDexFile, handler->typeIdx);
printf(" %s -> 0x%04x\n", descriptor,
handler->address);
}
}
}
/* Get the handler offset just past the end of the one just iterated over.
* This ends the iteration if it wasn't already. */
u4 dexCatchIteratorGetEndOffset(DexCatchIterator* pIterator,
const DexCode* pCode) {
while (dexCatchIteratorNext(pIterator) != NULL) /* empty */ ;
return (u4) (pIterator->pEncodedData - dexGetCatchHandlerData(pCode));
}
/*
Set the "in try" flags for all instructions protected by "try" statements.
Also sets the "branch target" flags for exception handlers.
Call this after widths have been set in "insnFlags".
Returns "false" if something in the exception table looks fishy, but
we're expecting the exception table to be somewhat sane.
对被“try”声明保护的所有指令的设置"in try"标识。同时为异常句柄设置“branch target(分支目标)”
标识。
在宽度被设置“inFlags”后调用。
返回“false”，如果异常表中出现可疑的东西，我们期望它能有点理智。
*/
static bool scanTryCatchBlocks(const Method* meth, InsnFlags* insnFlags)
{
u4 insnsSize = dvmGetMethodInsnsSize(meth);
const DexCode* pCode = dvmGetMethodCode(meth);
u4 triesSize = pCode->triesSize;
const DexTry* pTries;
u4 idx;
if (triesSize == 0) {
return true;
}
pTries = dexGetTries(pCode);
for (idx = 0; idx < triesSize; idx++) {
const DexTry* pTry = &pTries[idx];
u4 start = pTry->startAddr;
u4 end = start + pTry->insnCount;
u4 addr;
if ((start >= end) || (start >= insnsSize) || (end > insnsSize)) {
LOG_VFY_METH(meth,
"VFY: bad exception entry: startAddr=%d endAddr=%d (size=%d)",
start, end, insnsSize);
return false;
}
if (dvmInsnGetWidth(insnFlags, start) == 0) {
LOG_VFY_METH(meth,
"VFY: 'try' block starts inside an instruction (%d)",
start);
return false;
}
for (addr = start; addr < end;
addr += dvmInsnGetWidth(insnFlags, addr))
{
assert(dvmInsnGetWidth(insnFlags, addr) != 0);
dvmInsnSetInTry(insnFlags, addr, true);
}
}
/* Iterate over each of the handlers to verify target addresses. */
u4 handlersSize = dexGetHandlersSize(pCode);
u4 offset = dexGetFirstHandlerOffset(pCode);
for (idx = 0; idx < handlersSize; idx++) {
DexCatchIterator iterator;
dexCatchIteratorInit(&iterator, pCode, offset);
for (;;) {
DexCatchHandler* handler = dexCatchIteratorNext(&iterator);
u4 addr;
if (handler == NULL) {
break;
}
addr = handler->address;
if (dvmInsnGetWidth(insnFlags, addr) == 0) {
LOG_VFY_METH(meth,
"VFY: exception handler starts at bad address (%d)",
addr);
return false;
}
dvmInsnSetBranchTarget(insnFlags, addr, true);
}
offset = dexCatchIteratorGetEndOffset(&iterator, pCode);
}
return true;
}
/*
* Search the method's list of exceptions for a match.
*
* Returns the offset of the catch block on success, or -1 on failure.
*/
static int findCatchInMethod(Thread* self, const Method* method, int relPc,
ClassObject* excepClass)
{
/*
* Need to clear the exception before entry. Otherwise, dvmResolveClass
* might think somebody threw an exception while it was loading a class.
*/
assert(!dvmCheckException(self));
assert(!dvmIsNativeMethod(method));
LOGVV("findCatchInMethod %s.%s excep=%s depth=%d\n",
method->clazz->descriptor, method->name, excepClass->descriptor,
dvmComputeExactFrameDepth(self->curFrame));
DvmDex* pDvmDex = method->clazz->pDvmDex;
const DexCode* pCode = dvmGetMethodCode(method);
DexCatchIterator iterator;
if (dexFindCatchHandler(&iterator, pCode, relPc)) {
for (;;) {
DexCatchHandler* handler = dexCatchIteratorNext(&iterator);
if (handler == NULL) {
break;
}
if (handler->typeIdx == kDexNoIndex) {
/* catch-all */
LOGV("Match on catch-all block at 0x%02x in %s.%s for %s\n",
relPc, method->clazz->descriptor,
method->name, excepClass->descriptor);
return handler->address;
}
ClassObject* throwable =
dvmDexGetResolvedClass(pDvmDex, handler->typeIdx);
if (throwable == NULL) {
/*
* TODO: this behaves badly if we run off the stack
* while trying to throw an exception. The problem is
* that, if we're in a class loaded by a class loader,
* the call to dvmResolveClass has to ask the class
* loader for help resolving any previously-unresolved
* classes. If this particular class loader hasn't
* resolved StackOverflowError, it will call into
* interpreted code, and blow up.
*
* We currently replace the previous exception with
* the StackOverflowError, which means they won't be
* catching it *unless* they explicitly catch
* StackOverflowError, in which case we'll be unable
* to resolve the class referred to by the "catch"
* block.
*
* We end up getting a huge pile of warnings if we do
* a simple synthetic test, because this method gets
* called on every stack frame up the tree, and it
* fails every time.
*
* This eventually bails out, effectively becoming an
* uncatchable exception, so other than the flurry of
* warnings it's not really a problem. Still, we could
* probably handle this better.
*/
throwable = dvmResolveClass(method->clazz, handler->typeIdx,
true);
if (throwable == NULL) {
/*
* We couldn't find the exception they wanted in
* our class files (or, perhaps, the stack blew up
* while we were querying a class loader). Cough
* up a warning, then move on to the next entry.
* Keep the exception status clear.
*/
LOGW("Could not resolve class ref'ed in exception "
"catch list (class index %d, exception %s)\n",
handler->typeIdx,
(self->exception != NULL) ?
self->exception->clazz->descriptor : "(none)");
dvmClearException(self);
continue;
}
}
//LOGD("ADDR MATCH, check %s instanceof %s\n",
// excepClass->descriptor, pEntry->excepClass->descriptor);
if (dvmInstanceof(excepClass, throwable)) {
LOGV("Match on catch block at 0x%02x in %s.%s for %s\n",
relPc, method->clazz->descriptor,
method->name, excepClass->descriptor);
return handler->address;
}
}
}
LOGV("No matching catch block at 0x%02x in %s for %s\n",
relPc, method->name, excepClass->descriptor);
return -1;
}
