/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Verifier basic block functions.
*/
#include "Dalvik.h"
#include "analysis/VfyBasicBlock.h"
#include "analysis/CodeVerify.h"
#include "analysis/VerifySubs.h"
#include "libdex/DexCatch.h"
#include "libdex/InstrUtils.h"
/*
* Extract the list of catch handlers from "pTry" into "addrBuf".
*
* Returns the size of the catch handler list. If the return value
* exceeds "addrBufSize", the items at the end of the list will not be
* represented in the output array, and this function should be called
* again with a larger buffer.
*/
static u4 extractCatchHandlers(const DexCode* pCode, const DexTry* pTry,
u4* addrBuf, size_t addrBufSize)
{
DexCatchIterator iterator;
unsigned int idx = 0;
dexCatchIteratorInit(&iterator, pCode, pTry->handlerOff);
while (true) {
DexCatchHandler* handler = dexCatchIteratorNext(&iterator);
if (handler == NULL)
break;
if (idx < addrBufSize) {
addrBuf[idx] = handler->address;
}
idx++;
}
return idx;
}
/*
* Returns "true" if the instruction represents a data chunk, such as a
* switch statement block.
*/
static bool isDataChunk(u2 insn)
{
return (insn == kPackedSwitchSignature ||
insn == kSparseSwitchSignature ||
insn == kArrayDataSignature);
}
/*
* Alloc a basic block in the specified slot. The storage will be
* initialized.
*/
static VfyBasicBlock* allocVfyBasicBlock(VerifierData* vdata, u4 idx)
{
VfyBasicBlock* newBlock = (VfyBasicBlock*) calloc(1, sizeof(VfyBasicBlock));
if (newBlock == NULL)
return NULL;
/*
* TODO: there is no good default size here -- the problem is that most
* addresses will only have one predecessor, but a fair number will
* have 10+, and a few will have 100+ (e.g. the synthetic "finally"
* in a large synchronized method). We probably want to use a small
* base allocation (perhaps two) and then have the first overflow
* allocation jump dramatically (to 32 or thereabouts).
*/
newBlock->predecessors = dvmPointerSetAlloc(32);
if (newBlock->predecessors == NULL) {
free(newBlock);
return NULL;
}
newBlock->firstAddr = (u4) -1; // DEBUG
newBlock->liveRegs = dvmAllocBitVector(vdata->insnRegCount, false);
if (newBlock->liveRegs == NULL) {
dvmPointerSetFree(newBlock->predecessors);
free(newBlock);
return NULL;
}
return newBlock;
}
/*
* Add "curBlock" to the predecessor list in "targetIdx".
*/
static bool addToPredecessor(VerifierData* vdata, VfyBasicBlock* curBlock,
u4 targetIdx)
{
assert(targetIdx < vdata->insnsSize);
/*
* Allocate the target basic block if necessary. This will happen
* on e.g. forward branches.
*
* We can't fill in all the fields, but that will happen automatically
* when we get to that part of the code.
*/
VfyBasicBlock* targetBlock = vdata->basicBlocks[targetIdx];
if (targetBlock == NULL) {
targetBlock = allocVfyBasicBlock(vdata, targetIdx);
if (targetBlock == NULL)
return false;
vdata->basicBlocks[targetIdx] = targetBlock;
}
PointerSet* preds = targetBlock->predecessors;
bool added = dvmPointerSetAddEntry(preds, curBlock);
if (!added) {
/*
* This happens sometimes for packed-switch instructions, where
* the same target address appears more than once. Also, a
* (pointless) conditional branch to the next instruction will
* trip over this.
*/
ALOGV("ODD: point set for targ=0x%04x (%p) already had block "
"fir=0x%04x (%p)",
targetIdx, targetBlock, curBlock->firstAddr, curBlock);
}
return true;
}
/*
* Add ourselves to the predecessor list in all blocks we might transfer
* control to.
*
* There are four ways to proceed to a new instruction:
* (1) continue to the following instruction
* (2) [un]conditionally branch to a specific location
* (3) conditionally branch through a "switch" statement
* (4) throw an exception
*
* Returning from the method (via a return statement or an uncaught
* exception) are not interesting for liveness analysis.
*/
static bool setPredecessors(VerifierData* vdata, VfyBasicBlock* curBlock,
u4 curIdx, OpcodeFlags opFlags, u4 nextIdx, u4* handlerList,
size_t numHandlers)
{
const InsnFlags* insnFlags = vdata->insnFlags;
const Method* meth = vdata->method;
unsigned int handlerIdx;
for (handlerIdx = 0; handlerIdx < numHandlers; handlerIdx++) {
if (!addToPredecessor(vdata, curBlock, handlerList[handlerIdx]))
return false;
}
if ((opFlags & kInstrCanContinue) != 0) {
if (!addToPredecessor(vdata, curBlock, nextIdx))
return false;
}
if ((opFlags & kInstrCanBranch) != 0) {
bool unused, gotBranch;
s4 branchOffset, absOffset;
gotBranch = dvmGetBranchOffset(meth, insnFlags, curIdx,
&branchOffset, &unused);
assert(gotBranch);
absOffset = curIdx + branchOffset;
assert(absOffset >= 0 && (u4) absOffset < vdata->insnsSize);
if (!addToPredecessor(vdata, curBlock, absOffset))
return false;
}
if ((opFlags & kInstrCanSwitch) != 0) {
const u2* curInsn = &meth->insns[curIdx];
const u2* dataPtr;
/* these values have already been verified, so we can trust them */
s4 offsetToData = curInsn[1] | ((s4) curInsn[2]) << 16;
dataPtr = curInsn + offsetToData;
/*
* dataPtr points to the start of the switch data. The first
* item is the NOP+magic, the second is the number of entries in
* the switch table.
*/
u2 switchCount = dataPtr[1];
/*
* Skip past the ident field, size field, and the first_key field
* (for packed) or the key list (for sparse).
*/
if (dexOpcodeFromCodeUnit(meth->insns[curIdx]) == OP_PACKED_SWITCH) {
dataPtr += 4;
} else {
assert(dexOpcodeFromCodeUnit(meth->insns[curIdx]) ==
OP_SPARSE_SWITCH);
dataPtr += 2 + 2 * switchCount;
}
u4 switchIdx;
for (switchIdx = 0; switchIdx < switchCount; switchIdx++) {
s4 offset, absOffset;
offset = (s4) dataPtr[switchIdx*2] |
(s4) (dataPtr[switchIdx*2 +1] << 16);
absOffset = curIdx + offset;
assert(absOffset >= 0 && (u4) absOffset < vdata->insnsSize);
if (!addToPredecessor(vdata, curBlock, absOffset))
return false;
}
}
if (false) {
if (dvmPointerSetGetCount(curBlock->predecessors) > 256) {
ALOGI("Lots of preds at 0x%04x in %s.%s:%s", curIdx,
meth->clazz->descriptor, meth->name, meth->shorty);
}
}
return true;
}
/*
* Dump the contents of the basic blocks.
*/
static void dumpBasicBlocks(const VerifierData* vdata)
{
char printBuf[256];
unsigned int idx;
int count;
ALOGI("Basic blocks for %s.%s:%s", vdata->method->clazz->descriptor,
vdata->method->name, vdata->method->shorty);
for (idx = 0; idx < vdata->insnsSize; idx++) {
VfyBasicBlock* block = vdata->basicBlocks[idx];
if (block == NULL)
continue;
assert(block->firstAddr == idx);
count = snprintf(printBuf, sizeof(printBuf), " %04x-%04x ",
block->firstAddr, block->lastAddr);
PointerSet* preds = block->predecessors;
size_t numPreds = dvmPointerSetGetCount(preds);
if (numPreds > 0) {
count += snprintf(printBuf + count, sizeof(printBuf) - count,
"preds:");
unsigned int predIdx;
for (predIdx = 0; predIdx < numPreds; predIdx++) {
if (count >= (int) sizeof(printBuf))
break;
const VfyBasicBlock* pred =
(const VfyBasicBlock*) dvmPointerSetGetEntry(preds, predIdx);
count += snprintf(printBuf + count, sizeof(printBuf) - count,
"%04x(%p),", pred->firstAddr, pred);
}
} else {
count += snprintf(printBuf + count, sizeof(printBuf) - count,
"(no preds)");
}
printBuf[sizeof(printBuf)-2] = '!';
printBuf[sizeof(printBuf)-1] = '\0';
ALOGI("%s", printBuf);
}
usleep(100 * 1000); /* ugh...let logcat catch up */
}
/*
* Generate a list of basic blocks and related information.
*
* On success, returns "true" with vdata->basicBlocks initialized.
*/
bool dvmComputeVfyBasicBlocks(VerifierData* vdata)
{
const InsnFlags* insnFlags = vdata->insnFlags;
const Method* meth = vdata->method;
const u4 insnsSize = vdata->insnsSize;
const DexCode* pCode = dvmGetMethodCode(meth);
const DexTry* pTries = NULL;
const size_t kHandlerStackAllocSize = 16; /* max seen so far is 7 */
u4 handlerAddrs[kHandlerStackAllocSize];
u4* handlerListAlloc = NULL;
u4* handlerList = NULL;
size_t numHandlers = 0;
u4 idx, blockStartAddr;
bool result = false;
bool verbose = false; //dvmWantVerboseVerification(meth);
if (verbose) {
ALOGI("Basic blocks for %s.%s:%s",
meth->clazz->descriptor, meth->name, meth->shorty);
}
/*
* Allocate a data structure that allows us to map from an address to
* the corresponding basic block. Initially all pointers are NULL.
* They are populated on demand as we proceed (either when we reach a
* new BB, or when we need to add an item to the predecessor list in
* a not-yet-reached BB).
*
* Only the first instruction in the block points to the BB structure;
* the rest remain NULL.
*/
vdata->basicBlocks =
(VfyBasicBlock**) calloc(insnsSize, sizeof(VfyBasicBlock*));
if (vdata->basicBlocks == NULL)
return false;
/*
* The "tries" list is a series of non-overlapping regions with a list
* of "catch" handlers. Rather than do the "find a matching try block"
* computation at each step, we just walk the "try" list in parallel.
*
* Not all methods have "try" blocks. If this one does, we init tryEnd
* to zero, so that the (exclusive bound) range check trips immediately.
*/
u4 tryIndex = 0, tryStart = 0, tryEnd = 0;
if (pCode->triesSize != 0) {
pTries = dexGetTries(pCode);
}
u4 debugBBIndex = 0;
/*
* The address associated with a basic block is the start address.
*/
blockStartAddr = 0;
for (idx = 0; idx < insnsSize; ) {
/*
* Make sure we're pointing at the right "try" block. It should
* not be possible to "jump over" a block, so if we're no longer
* in the correct one we can just advance to the next.
*/
if (pTries != NULL && idx >= tryEnd) {
if (tryIndex == pCode->triesSize) {
/* no more try blocks in this method */
pTries = NULL;
numHandlers = 0;
} else {
/*
* Extract the set of handlers. We want to avoid doing
* this for each block, so we copy them to local storage.
* If it doesn't fit in the small stack area, we'll use
* the heap instead.
*
* It's rare to encounter a method with more than half a
* dozen possible handlers.
*/
tryStart = pTries[tryIndex].startAddr;
tryEnd = tryStart + pTries[tryIndex].insnCount;
if (handlerListAlloc != NULL) {
free(handlerListAlloc);
handlerListAlloc = NULL;
}
numHandlers = extractCatchHandlers(pCode, &pTries[tryIndex],
handlerAddrs, kHandlerStackAllocSize);
assert(numHandlers > 0); // TODO make sure this is verified
if (numHandlers <= kHandlerStackAllocSize) {
handlerList = handlerAddrs;
} else {
ALOGD("overflow, numHandlers=%d", numHandlers);
handlerListAlloc = (u4*) malloc(sizeof(u4) * numHandlers);
if (handlerListAlloc == NULL)
return false;
extractCatchHandlers(pCode, &pTries[tryIndex],
handlerListAlloc, numHandlers);
handlerList = handlerListAlloc;
}
ALOGV("+++ start=%x end=%x numHan=%d",
tryStart, tryEnd, numHandlers);
tryIndex++;
}
}
/*
* Check the current instruction, and possibly aspects of the
* next instruction, to see if this instruction ends the current
* basic block.
*
* Instructions that can throw only end the block if there is the
* possibility of a local handler catching the exception.
*/
Opcode opcode = dexOpcodeFromCodeUnit(meth->insns[idx]);
OpcodeFlags opFlags = dexGetFlagsFromOpcode(opcode);
size_t nextIdx = idx + dexGetWidthFromInstruction(&meth->insns[idx]);
bool endBB = false;
bool ignoreInstr = false;
if ((opFlags & kInstrCanContinue) == 0) {
/* does not continue */
endBB = true;
} else if ((opFlags & (kInstrCanBranch | kInstrCanSwitch)) != 0) {
/* conditionally branches elsewhere */
endBB = true;
} else if ((opFlags & kInstrCanThrow) != 0 &&
dvmInsnIsInTry(insnFlags, idx))
{
/* throws an exception that might be caught locally */
endBB = true;
} else if (isDataChunk(meth->insns[idx])) {
/*
* If this is a data chunk (e.g. switch data) we want to skip
* over it entirely. Set endBB so we don't carry this along as
* the start of a block, and ignoreInstr so we don't try to
* open a basic block for this instruction.
*/
endBB = ignoreInstr = true;
} else if (dvmInsnIsBranchTarget(insnFlags, nextIdx)) {
/*
* We also need to end it if the next instruction is a branch
* target. Note we've tagged exception catch blocks as such.
*
* If we're this far along in the "else" chain, we know that
* this isn't a data-chunk NOP, and control can continue to
* the next instruction, so we're okay examining "nextIdx".
*/
assert(nextIdx < insnsSize);
endBB = true;
} else if (opcode == OP_NOP && isDataChunk(meth->insns[nextIdx])) {
/*
* Handle an odd special case: if this is NOP padding before a
* data chunk, also treat it as "ignore". Otherwise it'll look
* like a block that starts and doesn't end.
*/
endBB = ignoreInstr = true;
} else {
/* check: return ops should be caught by absence of can-continue */
assert((opFlags & kInstrCanReturn) == 0);
}
if (verbose) {
char btc = dvmInsnIsBranchTarget(insnFlags, idx) ? '>' : ' ';
char tryc =
(pTries != NULL && idx >= tryStart && idx < tryEnd) ? 't' : ' ';
bool startBB = (idx == blockStartAddr);
const char* startEnd;
if (ignoreInstr)
startEnd = "IGNORE";
else if (startBB && endBB)
startEnd = "START/END";
else if (startBB)
startEnd = "START";
else if (endBB)
startEnd = "END";
else
startEnd = "-";
ALOGI("%04x: %c%c%s #%d", idx, tryc, btc, startEnd, debugBBIndex);
if (pTries != NULL && idx == tryStart) {
assert(numHandlers > 0);
ALOGI(" EXC block: [%04x, %04x) %d:(%04x...)",
tryStart, tryEnd, numHandlers, handlerList[0]);
}
}
if (idx != blockStartAddr) {
/* should not be a basic block struct associated with this addr */
assert(vdata->basicBlocks[idx] == NULL);
}
if (endBB) {
if (!ignoreInstr) {
/*
* Create a new BB if one doesn't already exist.
*/
VfyBasicBlock* curBlock = vdata->basicBlocks[blockStartAddr];
if (curBlock == NULL) {
curBlock = allocVfyBasicBlock(vdata, blockStartAddr);
if (curBlock == NULL)
return false;
vdata->basicBlocks[blockStartAddr] = curBlock;
}
curBlock->firstAddr = blockStartAddr;
curBlock->lastAddr = idx;
if (!setPredecessors(vdata, curBlock, idx, opFlags, nextIdx,
handlerList, numHandlers))
{
goto bail;
}
}
blockStartAddr = nextIdx;
debugBBIndex++;
}
idx = nextIdx;
}
assert(idx == insnsSize);
result = true;
if (verbose)
dumpBasicBlocks(vdata);
bail:
free(handlerListAlloc);
return result;
}
/*
* Free the storage used by basic blocks.
*/
void dvmFreeVfyBasicBlocks(VerifierData* vdata)
{
unsigned int idx;
if (vdata->basicBlocks == NULL)
return;
for (idx = 0; idx < vdata->insnsSize; idx++) {
VfyBasicBlock* block = vdata->basicBlocks[idx];
if (block == NULL)
continue;
dvmPointerSetFree(block->predecessors);
free(block);
}
}