/*
* Copyright (C) 2008 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.
*/
/*
* Access the contents of a .dex file.
*/
#include "DexFile.h"
#include "DexProto.h"
#include "DexCatch.h"
#include "Leb128.h"
#include "sha1.h"
#include "ZipArchive.h"
#include <zlib.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
// fwd
static u4 dexComputeOptChecksum(const DexOptHeader* pOptHeader);
/*
* Verifying checksums is good, but it slows things down and causes us to
* touch every page. In the "optimized" world, it doesn't work at all,
* because we rewrite the contents.
*/
static const bool kVerifyChecksum = false;
static const bool kVerifySignature = false;
/* Compare two '\0'-terminated modified UTF-8 strings, using Unicode
* code point values for comparison. This treats different encodings
* for the same code point as equivalent, except that only a real '\0'
* byte is considered the string terminator. The return value is as
* for strcmp(). */
int dexUtf8Cmp(const char* s1, const char* s2) {
for (;;) {
if (*s1 == '\0') {
if (*s2 == '\0') {
return 0;
}
return -1;
} else if (*s2 == '\0') {
return 1;
}
int utf1 = dexGetUtf16FromUtf8(&s1);
int utf2 = dexGetUtf16FromUtf8(&s2);
int diff = utf1 - utf2;
if (diff != 0) {
return diff;
}
}
}
/* for dexIsValidMemberNameUtf8(), a bit vector indicating valid low ascii */
u4 DEX_MEMBER_VALID_LOW_ASCII[4] = {
0x00000000, // 00..1f low control characters; nothing valid
0x03ff2010, // 20..3f digits and symbols; valid: '0'..'9', '$', '-'
0x87fffffe, // 40..5f uppercase etc.; valid: 'A'..'Z', '_'
0x07fffffe // 60..7f lowercase etc.; valid: 'a'..'z'
};
/* Helper for dexIsValidMemberNameUtf8(); do not call directly. */
bool dexIsValidMemberNameUtf8_0(const char** pUtf8Ptr) {
/*
* It's a multibyte encoded character. Decode it and analyze. We
* accept anything that isn't (a) an improperly encoded low value,
* (b) an improper surrogate pair, (c) an encoded '\0', (d) a high
* control character, or (e) a high space, layout, or special
* character (U+00a0, U+2000..U+200f, U+2028..U+202f,
* U+fff0..U+ffff).
*/
u2 utf16 = dexGetUtf16FromUtf8(pUtf8Ptr);
// Perform follow-up tests based on the high 8 bits.
switch (utf16 >> 8) {
case 0x00: {
// It's only valid if it's above the ISO-8859-1 high space (0xa0).
return (utf16 > 0x00a0);
}
case 0xd8:
case 0xd9:
case 0xda:
case 0xdb: {
/*
* It's a leading surrogate. Check to see that a trailing
* surrogate follows.
*/
utf16 = dexGetUtf16FromUtf8(pUtf8Ptr);
return (utf16 >= 0xdc00) && (utf16 <= 0xdfff);
}
case 0xdc:
case 0xdd:
case 0xde:
case 0xdf: {
// It's a trailing surrogate, which is not valid at this point.
return false;
}
case 0x20:
case 0xff: {
// It's in the range that has spaces, controls, and specials.
switch (utf16 & 0xfff8) {
case 0x2000:
case 0x2008:
case 0x2028:
case 0xfff0:
case 0xfff8: {
return false;
}
}
break;
}
}
return true;
}
/* Return whether the given string is a valid field or method name. */
bool dexIsValidMemberName(const char* s) {
bool angleName = false;
switch (*s) {
case '\0': {
// The empty string is not a valid name.
return false;
}
case '<': {
/*
* '<' is allowed only at the start of a name, and if present,
* means that the name must end with '>'.
*/
angleName = true;
s++;
break;
}
}
for (;;) {
switch (*s) {
case '\0': {
return !angleName;
}
case '>': {
return angleName && s[1] == '\0';
}
}
if (!dexIsValidMemberNameUtf8(&s)) {
return false;
}
}
}
/* Return whether the given string is a valid type descriptor. */
bool dexIsValidTypeDescriptor(const char* s) {
int arrayCount = 0;
while (*s == '[') {
arrayCount++;
s++;
}
if (arrayCount > 255) {
// Arrays may have no more than 255 dimensions.
return false;
}
switch (*(s++)) {
case 'B':
case 'C':
case 'D':
case 'F':
case 'I':
case 'J':
case 'S':
case 'Z': {
// These are all single-character descriptors for primitive types.
return (*s == '\0');
}
case 'V': {
// You can't have an array of void.
return (arrayCount == 0) && (*s == '\0');
}
case 'L': {
// Break out and continue below.
break;
}
default: {
// Oddball descriptor character.
return false;
}
}
// We just consumed the 'L' that introduces a class name.
bool slashOrFirst = true; // first character or just encountered a slash
for (;;) {
u1 c = (u1) *s;
switch (c) {
case '\0': {
// Premature end.
return false;
}
case ';': {
/*
* Make sure that this is the end of the string and that
* it doesn't end with an empty component (including the
* degenerate case of "L;").
*/
return (s[1] == '\0') && !slashOrFirst;
}
case '/': {
if (slashOrFirst) {
// Slash at start or two slashes in a row.
return false;
}
slashOrFirst = true;
s++;
break;
}
default: {
if (!dexIsValidMemberNameUtf8(&s)) {
return false;
}
slashOrFirst = false;
break;
}
}
}
}
/* Return whether the given string is a valid reference descriptor. This
* is true if dexIsValidTypeDescriptor() returns true and the descriptor
* is for a class or array and not a primitive type. */
bool dexIsReferenceDescriptor(const char* s) {
if (!dexIsValidTypeDescriptor(s)) {
return false;
}
return (s[0] == 'L') || (s[0] == '[');
}
/* Return whether the given string is a valid class descriptor. This
* is true if dexIsValidTypeDescriptor() returns true and the descriptor
* is for a class and not an array or primitive type. */
bool dexIsClassDescriptor(const char* s) {
if (!dexIsValidTypeDescriptor(s)) {
return false;
}
return s[0] == 'L';
}
/* Return whether the given string is a valid field type descriptor. This
* is true if dexIsValidTypeDescriptor() returns true and the descriptor
* is for anything but "void". */
bool dexIsFieldDescriptor(const char* s) {
if (!dexIsValidTypeDescriptor(s)) {
return false;
}
return s[0] != 'V';
}
/* Return the UTF-8 encoded string with the specified string_id index,
* also filling in the UTF-16 size (number of 16-bit code points).*/
const char* dexStringAndSizeById(const DexFile* pDexFile, u4 idx,
u4* utf16Size) {
const DexStringId* pStringId = dexGetStringId(pDexFile, idx);
const u1* ptr = pDexFile->baseAddr + pStringId->stringDataOff;
*utf16Size = readUnsignedLeb128(&ptr);
return (const char*) ptr;
}
/*
* Format an SHA-1 digest for printing. tmpBuf must be able to hold at
* least kSHA1DigestOutputLen bytes.
*/
const char* dvmSHA1DigestToStr(const unsigned char digest[], char* tmpBuf);
/*
* Compute a SHA-1 digest on a range of bytes.
*/
static void dexComputeSHA1Digest(const unsigned char* data, size_t length,
unsigned char digest[])
{
SHA1_CTX context;
SHA1Init(&context);
SHA1Update(&context, data, length);
SHA1Final(digest, &context);
}
/*
* Format the SHA-1 digest into the buffer, which must be able to hold at
* least kSHA1DigestOutputLen bytes. Returns a pointer to the buffer,
*/
static const char* dexSHA1DigestToStr(const unsigned char digest[],char* tmpBuf)
{
static const char hexDigit[] = "0123456789abcdef";
char* cp;
int i;
cp = tmpBuf;
for (i = 0; i < kSHA1DigestLen; i++) {
*cp++ = hexDigit[digest[i] >> 4];
*cp++ = hexDigit[digest[i] & 0x0f];
}
*cp++ = '\0';
assert(cp == tmpBuf + kSHA1DigestOutputLen);
return tmpBuf;
}
/*
* Compute a hash code on a UTF-8 string, for use with internal hash tables.
*
* This may or may not be compatible with UTF-8 hash functions used inside
* the Dalvik VM.
*
* The basic "multiply by 31 and add" approach does better on class names
* than most other things tried (e.g. adler32).
*/
static u4 classDescriptorHash(const char* str)
{
u4 hash = 1;
while (*str != '\0')
hash = hash * 31 + *str++;
return hash;
}
/*
* Add an entry to the class lookup table. We hash the string and probe
* until we find an open slot.
*/
static void classLookupAdd(DexFile* pDexFile, DexClassLookup* pLookup,
int stringOff, int classDefOff, int* pNumProbes)
{
const char* classDescriptor =
(const char*) (pDexFile->baseAddr + stringOff);
const DexClassDef* pClassDef =
(const DexClassDef*) (pDexFile->baseAddr + classDefOff);
u4 hash = classDescriptorHash(classDescriptor);
int mask = pLookup->numEntries-1;
int idx = hash & mask;
/*
* Find the first empty slot. We oversized the table, so this is
* guaranteed to finish.
*/
int probes = 0;
while (pLookup->table[idx].classDescriptorOffset != 0) {
idx = (idx + 1) & mask;
probes++;
}
//if (probes > 1)
// LOGW("classLookupAdd: probes=%d\n", probes);
pLookup->table[idx].classDescriptorHash = hash;
pLookup->table[idx].classDescriptorOffset = stringOff;
pLookup->table[idx].classDefOffset = classDefOff;
*pNumProbes = probes;
}
/*
* Round up to the next highest power of 2.
*
* Found on http://graphics.stanford.edu/~seander/bithacks.html.
*/
u4 dexRoundUpPower2(u4 val)
{
val--;
val |= val >> 1;
val |= val >> 2;
val |= val >> 4;
val |= val >> 8;
val |= val >> 16;
val++;
return val;
}
/*
* Create the class lookup hash table.
*
* Returns newly-allocated storage.
*/
DexClassLookup* dexCreateClassLookup(DexFile* pDexFile)
{
DexClassLookup* pLookup;
int allocSize;
int i, numEntries;
int numProbes, totalProbes, maxProbes;
numProbes = totalProbes = maxProbes = 0;
assert(pDexFile != NULL);
/*
* Using a factor of 3 results in far less probing than a factor of 2,
* but almost doubles the flash storage requirements for the bootstrap
* DEX files. The overall impact on class loading performance seems
* to be minor. We could probably get some performance improvement by
* using a secondary hash.
*/
numEntries = dexRoundUpPower2(pDexFile->pHeader->classDefsSize * 2);
allocSize = offsetof(DexClassLookup, table)
+ numEntries * sizeof(pLookup->table[0]);
pLookup = (DexClassLookup*) calloc(1, allocSize);
if (pLookup == NULL)
return NULL;
pLookup->size = allocSize;
pLookup->numEntries = numEntries;
for (i = 0; i < (int)pDexFile->pHeader->classDefsSize; i++) {
const DexClassDef* pClassDef;
const char* pString;
pClassDef = dexGetClassDef(pDexFile, i);
pString = dexStringByTypeIdx(pDexFile, pClassDef->classIdx);
classLookupAdd(pDexFile, pLookup,
(u1*)pString - pDexFile->baseAddr,
(u1*)pClassDef - pDexFile->baseAddr, &numProbes);
if (numProbes > maxProbes)
maxProbes = numProbes;
totalProbes += numProbes;
}
LOGV("Class lookup: classes=%d slots=%d (%d%% occ) alloc=%d"
" total=%d max=%d\n",
pDexFile->pHeader->classDefsSize, numEntries,
(100 * pDexFile->pHeader->classDefsSize) / numEntries,
allocSize, totalProbes, maxProbes);
return pLookup;
}
/*
* Set up the basic raw data pointers of a DexFile. This function isn't
* meant for general use.
*/
void dexFileSetupBasicPointers(DexFile* pDexFile, const u1* data) {
DexHeader *pHeader = (DexHeader*) data;
pDexFile->baseAddr = data;
pDexFile->pHeader = pHeader;
pDexFile->pStringIds = (const DexStringId*) (data + pHeader->stringIdsOff);
pDexFile->pTypeIds = (const DexTypeId*) (data + pHeader->typeIdsOff);
pDexFile->pFieldIds = (const DexFieldId*) (data + pHeader->fieldIdsOff);
pDexFile->pMethodIds = (const DexMethodId*) (data + pHeader->methodIdsOff);
pDexFile->pProtoIds = (const DexProtoId*) (data + pHeader->protoIdsOff);
pDexFile->pClassDefs = (const DexClassDef*) (data + pHeader->classDefsOff);
pDexFile->pLinkData = (const DexLink*) (data + pHeader->linkOff);
}
/*
* Parse out an index map entry, advancing "*pData" and reducing "*pSize".
*/
static bool parseIndexMapEntry(const u1** pData, u4* pSize, bool expanding,
u4* pFullCount, u4* pReducedCount, const u2** pMap)
{
const u4* wordPtr = (const u4*) *pData;
u4 size = *pSize;
u4 mapCount;
if (expanding) {
if (size < 4)
return false;
mapCount = *pReducedCount = *wordPtr++;
*pFullCount = (u4) -1;
size -= sizeof(u4);
} else {
if (size < 8)
return false;
mapCount = *pFullCount = *wordPtr++;
*pReducedCount = *wordPtr++;
size -= sizeof(u4) * 2;
}
u4 mapSize = mapCount * sizeof(u2);
if (size < mapSize)
return false;
*pMap = (const u2*) wordPtr;
size -= mapSize;
/* advance the pointer */
const u1* ptr = (const u1*) wordPtr;
ptr += (mapSize + 3) & ~0x3;
/* update pass-by-reference values */
*pData = (const u1*) ptr;
*pSize = size;
return true;
}
/*
* Set up some pointers into the mapped data.
*
* See analysis/ReduceConstants.c for the data layout description.
*/
static bool parseIndexMap(DexFile* pDexFile, const u1* data, u4 size,
bool expanding)
{
if (!parseIndexMapEntry(&data, &size, expanding,
&pDexFile->indexMap.classFullCount,
&pDexFile->indexMap.classReducedCount,
&pDexFile->indexMap.classMap))
{
return false;
}
if (!parseIndexMapEntry(&data, &size, expanding,
&pDexFile->indexMap.methodFullCount,
&pDexFile->indexMap.methodReducedCount,
&pDexFile->indexMap.methodMap))
{
return false;
}
if (!parseIndexMapEntry(&data, &size, expanding,
&pDexFile->indexMap.fieldFullCount,
&pDexFile->indexMap.fieldReducedCount,
&pDexFile->indexMap.fieldMap))
{
return false;
}
if (!parseIndexMapEntry(&data, &size, expanding,
&pDexFile->indexMap.stringFullCount,
&pDexFile->indexMap.stringReducedCount,
&pDexFile->indexMap.stringMap))
{
return false;
}
if (expanding) {
/*
* The map includes the "reduced" counts; pull the original counts
* out of the DexFile so that code has a consistent source.
*/
assert(pDexFile->indexMap.classFullCount == (u4) -1);
assert(pDexFile->indexMap.methodFullCount == (u4) -1);
assert(pDexFile->indexMap.fieldFullCount == (u4) -1);
assert(pDexFile->indexMap.stringFullCount == (u4) -1);
#if 0 // TODO: not available yet -- do later or just skip this
pDexFile->indexMap.classFullCount =
pDexFile->pHeader->typeIdsSize;
pDexFile->indexMap.methodFullCount =
pDexFile->pHeader->methodIdsSize;
pDexFile->indexMap.fieldFullCount =
pDexFile->pHeader->fieldIdsSize;
pDexFile->indexMap.stringFullCount =
pDexFile->pHeader->stringIdsSize;
#endif
}
LOGI("Class : %u %u %u\n",
pDexFile->indexMap.classFullCount,
pDexFile->indexMap.classReducedCount,
pDexFile->indexMap.classMap[0]);
LOGI("Method: %u %u %u\n",
pDexFile->indexMap.methodFullCount,
pDexFile->indexMap.methodReducedCount,
pDexFile->indexMap.methodMap[0]);
LOGI("Field : %u %u %u\n",
pDexFile->indexMap.fieldFullCount,
pDexFile->indexMap.fieldReducedCount,
pDexFile->indexMap.fieldMap[0]);
LOGI("String: %u %u %u\n",
pDexFile->indexMap.stringFullCount,
pDexFile->indexMap.stringReducedCount,
pDexFile->indexMap.stringMap[0]);
return true;
}
/*
* Parse some auxillary data tables.
*
* v1.0 wrote a zero in the first 32 bits, followed by the DexClassLookup
* table. Subsequent versions switched to the "chunk" format.
*/
static bool parseAuxData(const u1* data, DexFile* pDexFile)
{
const u4* pAux = (const u4*) (data + pDexFile->pOptHeader->auxOffset);
u4 indexMapType = 0;
/* v1.0 format? */
if (*pAux == 0) {
LOGV("+++ found OLD dex format\n");
pDexFile->pClassLookup = (const DexClassLookup*) (pAux+1);
return true;
}
LOGV("+++ found NEW dex format\n");
/* process chunks until we see the end marker */
while (*pAux != kDexChunkEnd) {
u4 size = *(pAux+1);
u1* data = (u1*) (pAux + 2);
switch (*pAux) {
case kDexChunkClassLookup:
pDexFile->pClassLookup = (const DexClassLookup*) data;
break;
case kDexChunkReducingIndexMap:
LOGI("+++ found reducing index map, size=%u\n", size);
if (!parseIndexMap(pDexFile, data, size, false)) {
LOGE("Failed parsing reducing index map\n");
return false;
}
indexMapType = *pAux;
break;
case kDexChunkExpandingIndexMap:
LOGI("+++ found expanding index map, size=%u\n", size);
if (!parseIndexMap(pDexFile, data, size, true)) {
LOGE("Failed parsing expanding index map\n");
return false;
}
indexMapType = *pAux;
break;
case kDexChunkRegisterMaps:
LOGV("+++ found register maps, size=%u\n", size);
pDexFile->pRegisterMapPool = data;
break;
default:
LOGI("Unknown chunk 0x%08x (%c%c%c%c), size=%d in aux data area\n",
*pAux,
(char) ((*pAux) >> 24), (char) ((*pAux) >> 16),
(char) ((*pAux) >> 8), (char) (*pAux),
size);
break;
}
/*
* Advance pointer, padding to 64-bit boundary. The extra "+8" is
* for the type/size header.
*/
size = (size + 8 + 7) & ~7;
pAux += size / sizeof(u4);
}
#if 0 // TODO: propagate expected map type from the VM through the API
/*
* If we're configured to expect an index map, and we don't find one,
* reject this DEX so we'll regenerate it. Also, if we found an
* "expanding" map but we're not configured to use it, we have to fail
* because the constants aren't usable without translation.
*/
if (indexMapType != expectedIndexMapType) {
LOGW("Incompatible index map configuration: found 0x%04x, need %d\n",
indexMapType, DVM_REDUCE_CONSTANTS);
return false;
}
#endif
return true;
}
/*
* Parse an optimized or unoptimized .dex file sitting in memory. This is
* called after the byte-ordering and structure alignment has been fixed up.
*
* On success, return a newly-allocated DexFile.
*/
DexFile* dexFileParse(const u1* data, size_t length, int flags)
{
DexFile* pDexFile = NULL;
const DexHeader* pHeader;
const u1* magic;
int result = -1;
if (length < sizeof(DexHeader)) {
LOGE("too short to be a valid .dex\n");
goto bail; /* bad file format */
}
pDexFile = (DexFile*) malloc(sizeof(DexFile));
if (pDexFile == NULL)
goto bail; /* alloc failure */
memset(pDexFile, 0, sizeof(DexFile));
/*
* Peel off the optimized header.
*/
if (memcmp(data, DEX_OPT_MAGIC, 4) == 0) {
magic = data;
if (memcmp(magic+4, DEX_OPT_MAGIC_VERS, 4) != 0) {
LOGE("bad opt version (0x%02x %02x %02x %02x)\n",
magic[4], magic[5], magic[6], magic[7]);
goto bail;
}
pDexFile->pOptHeader = (const DexOptHeader*) data;
LOGV("Good opt header, DEX offset is %d, flags=0x%02x\n",
pDexFile->pOptHeader->dexOffset, pDexFile->pOptHeader->flags);
/* locate some auxillary data tables */
if (!parseAuxData(data, pDexFile))
goto bail;
/* ignore the opt header and appended data from here on out */
data += pDexFile->pOptHeader->dexOffset;
length -= pDexFile->pOptHeader->dexOffset;
if (pDexFile->pOptHeader->dexLength > length) {
LOGE("File truncated? stored len=%d, rem len=%d\n",
pDexFile->pOptHeader->dexLength, (int) length);
goto bail;
}
length = pDexFile->pOptHeader->dexLength;
}
dexFileSetupBasicPointers(pDexFile, data);
pHeader = pDexFile->pHeader;
magic = pHeader->magic;
if (memcmp(magic, DEX_MAGIC, 4) != 0) {
/* not expected */
LOGE("bad magic number (0x%02x %02x %02x %02x)\n",
magic[0], magic[1], magic[2], magic[3]);
goto bail;
}
if (memcmp(magic+4, DEX_MAGIC_VERS, 4) != 0) {
LOGE("bad dex version (0x%02x %02x %02x %02x)\n",
magic[4], magic[5], magic[6], magic[7]);
goto bail;
}
/*
* Verify the checksum(s). This is reasonably quick, but does require
* touching every byte in the DEX file. The base checksum changes after
* byte-swapping and DEX optimization.
*/
if (flags & kDexParseVerifyChecksum) {
u4 adler = dexComputeChecksum(pHeader);
if (adler != pHeader->checksum) {
LOGE("ERROR: bad checksum (%08x vs %08x)\n",
adler, pHeader->checksum);
if (!(flags & kDexParseContinueOnError))
goto bail;
} else {
LOGV("+++ adler32 checksum (%08x) verified\n", adler);
}
const DexOptHeader* pOptHeader = pDexFile->pOptHeader;
if (pOptHeader != NULL) {
adler = dexComputeOptChecksum(pOptHeader);
if (adler != pOptHeader->checksum) {
LOGE("ERROR: bad opt checksum (%08x vs %08x)\n",
adler, pOptHeader->checksum);
if (!(flags & kDexParseContinueOnError))
goto bail;
} else {
LOGV("+++ adler32 opt checksum (%08x) verified\n", adler);
}
}
}
/*
* Verify the SHA-1 digest. (Normally we don't want to do this --
* the digest is used to uniquely identify the original DEX file, and
* can't be computed for verification after the DEX is byte-swapped
* and optimized.)
*/
if (kVerifySignature) {
unsigned char sha1Digest[kSHA1DigestLen];
const int nonSum = sizeof(pHeader->magic) + sizeof(pHeader->checksum) +
kSHA1DigestLen;
dexComputeSHA1Digest(data + nonSum, length - nonSum, sha1Digest);
if (memcmp(sha1Digest, pHeader->signature, kSHA1DigestLen) != 0) {
char tmpBuf1[kSHA1DigestOutputLen];
char tmpBuf2[kSHA1DigestOutputLen];
LOGE("ERROR: bad SHA1 digest (%s vs %s)\n",
dexSHA1DigestToStr(sha1Digest, tmpBuf1),
dexSHA1DigestToStr(pHeader->signature, tmpBuf2));
if (!(flags & kDexParseContinueOnError))
goto bail;
} else {
LOGV("+++ sha1 digest verified\n");
}
}
if (pHeader->fileSize != length) {
LOGE("ERROR: stored file size (%d) != expected (%d)\n",
(int) pHeader->fileSize, (int) length);
if (!(flags & kDexParseContinueOnError))
goto bail;
}
if (pHeader->classDefsSize == 0) {
LOGE("ERROR: DEX file has no classes in it, failing\n");
goto bail;
}
/*
* Success!
*/
result = 0;
bail:
if (result != 0 && pDexFile != NULL) {
dexFileFree(pDexFile);
pDexFile = NULL;
}
return pDexFile;
}
/*
* Free up the DexFile and any associated data structures.
*
* Note we may be called with a partially-initialized DexFile.
*/
void dexFileFree(DexFile* pDexFile)
{
if (pDexFile == NULL)
return;
free(pDexFile);
}
/*
* Look up a class definition entry by descriptor.
*
* "descriptor" should look like "Landroid/debug/Stuff;".
*/
const DexClassDef* dexFindClass(const DexFile* pDexFile,
const char* descriptor)
{
const DexClassLookup* pLookup = pDexFile->pClassLookup;
u4 hash;
int idx, mask;
hash = classDescriptorHash(descriptor);
mask = pLookup->numEntries - 1;
idx = hash & mask;
/*
* Search until we find a matching entry or an empty slot.
*/
while (true) {
int offset;
offset = pLookup->table[idx].classDescriptorOffset;
if (offset == 0)
return NULL;
if (pLookup->table[idx].classDescriptorHash == hash) {
const char* str;
str = (const char*) (pDexFile->baseAddr + offset);
if (strcmp(str, descriptor) == 0) {
return (const DexClassDef*)
(pDexFile->baseAddr + pLookup->table[idx].classDefOffset);
}
}
idx = (idx + 1) & mask;
}
}
/*
* Compute the DEX file checksum for a memory-mapped DEX file.
*/
u4 dexComputeChecksum(const DexHeader* pHeader)
{
const u1* start = (const u1*) pHeader;
uLong adler = adler32(0L, Z_NULL, 0);
const int nonSum = sizeof(pHeader->magic) + sizeof(pHeader->checksum);
return (u4) adler32(adler, start + nonSum, pHeader->fileSize - nonSum);
}
/*
* Compute the checksum on the data appended to the DEX file by dexopt.
*/
static u4 dexComputeOptChecksum(const DexOptHeader* pOptHeader)
{
const u1* start = (const u1*) pOptHeader + pOptHeader->depsOffset;
const u1* end = (const u1*) pOptHeader +
pOptHeader->auxOffset + pOptHeader->auxLength;
uLong adler = adler32(0L, Z_NULL, 0);
return (u4) adler32(adler, start, end - start);
}
/*
* Compute the size, in bytes, of a DexCode.
*/
size_t dexGetDexCodeSize(const DexCode* pCode)
{
/*
* The catch handler data is the last entry. It has a variable number
* of variable-size pieces, so we need to create an iterator.
*/
u4 handlersSize;
u4 offset;
u4 ui;
if (pCode->triesSize != 0) {
handlersSize = dexGetHandlersSize(pCode);
offset = dexGetFirstHandlerOffset(pCode);
} else {
handlersSize = 0;
offset = 0;
}
for (ui = 0; ui < handlersSize; ui++) {
DexCatchIterator iterator;
dexCatchIteratorInit(&iterator, pCode, offset);
offset = dexCatchIteratorGetEndOffset(&iterator, pCode);
}
const u1* handlerData = dexGetCatchHandlerData(pCode);
//LOGD("+++ pCode=%p handlerData=%p last offset=%d\n",
// pCode, handlerData, offset);
/* return the size of the catch handler + everything before it */
return (handlerData - (u1*) pCode) + offset;
}
/*
* ===========================================================================
* Debug info
* ===========================================================================
*/
/*
* Decode the arguments in a method signature, which looks something
* like "(ID[Ljava/lang/String;)V".
*
* Returns the type signature letter for the next argument, or ')' if
* there are no more args. Advances "pSig" to point to the character
* after the one returned.
*/
static char decodeSignature(const char** pSig)
{
const char* sig = *pSig;
if (*sig == '(')
sig++;
if (*sig == 'L') {
/* object ref */
while (*++sig != ';')
;
*pSig = sig+1;
return 'L';
}
if (*sig == '[') {
/* array; advance past array type */
while (*++sig == '[')
;
if (*sig == 'L') {
while (*++sig != ';')
;
}
*pSig = sig+1;
return '[';
}
if (*sig == '\0')
return *sig; /* don't advance further */
*pSig = sig+1;
return *sig;
}
/*
* returns the length of a type string, given the start of the
* type string. Used for the case where the debug info format
* references types that are inside a method type signature.
*/
static int typeLength (const char *type) {
// Assumes any leading '(' has already been gobbled
const char *end = type;
decodeSignature(&end);
return end - type;
}
/*
* Reads a string index as encoded for the debug info format,
* returning a string pointer or NULL as appropriate.
*/
static const char* readStringIdx(const DexFile* pDexFile,
const u1** pStream) {
u4 stringIdx = readUnsignedLeb128(pStream);
// Remember, encoded string indicies have 1 added to them.
if (stringIdx == 0) {
return NULL;
} else {
return dexStringById(pDexFile, stringIdx - 1);
}
}
/*
* Reads a type index as encoded for the debug info format, returning
* a string pointer for its descriptor or NULL as appropriate.
*/
static const char* readTypeIdx(const DexFile* pDexFile,
const u1** pStream) {
u4 typeIdx = readUnsignedLeb128(pStream);
// Remember, encoded type indicies have 1 added to them.
if (typeIdx == 0) {
return NULL;
} else {
return dexStringByTypeIdx(pDexFile, typeIdx - 1);
}
}
/* access_flag value indicating that a method is static */
#define ACC_STATIC 0x0008
typedef struct LocalInfo {
const char *name;
const char *descriptor;
const char *signature;
u2 startAddress;
bool live;
} LocalInfo;
static void emitLocalCbIfLive (void *cnxt, int reg, u4 endAddress,
LocalInfo *localInReg, DexDebugNewLocalCb localCb)
{
if (localCb != NULL && localInReg[reg].live) {
localCb(cnxt, reg, localInReg[reg].startAddress, endAddress,
localInReg[reg].name,
localInReg[reg].descriptor,
localInReg[reg].signature == NULL
? "" : localInReg[reg].signature );
}
}
// TODO optimize localCb == NULL case
void dexDecodeDebugInfo(
const DexFile* pDexFile,
const DexCode* pCode,
const char* classDescriptor,
u4 protoIdx,
u4 accessFlags,
DexDebugNewPositionCb posCb, DexDebugNewLocalCb localCb,
void* cnxt)
{
const u1 *stream = dexGetDebugInfoStream(pDexFile, pCode);
u4 line;
u4 parametersSize;
u4 address = 0;
LocalInfo localInReg[pCode->registersSize];
u4 insnsSize = pCode->insnsSize;
DexProto proto = { pDexFile, protoIdx };
memset(localInReg, 0, sizeof(LocalInfo) * pCode->registersSize);
if (stream == NULL) {
goto end;
}
line = readUnsignedLeb128(&stream);
parametersSize = readUnsignedLeb128(&stream);
u2 argReg = pCode->registersSize - pCode->insSize;
if ((accessFlags & ACC_STATIC) == 0) {
/*
* The code is an instance method, which means that there is
* an initial this parameter. Also, the proto list should
* contain exactly one fewer argument word than the insSize
* indicates.
*/
assert(pCode->insSize == (dexProtoComputeArgsSize(&proto) + 1));
localInReg[argReg].name = "this";
localInReg[argReg].descriptor = classDescriptor;
localInReg[argReg].startAddress = 0;
localInReg[argReg].live = true;
argReg++;
} else {
assert(pCode->insSize == dexProtoComputeArgsSize(&proto));
}
DexParameterIterator iterator;
dexParameterIteratorInit(&iterator, &proto);
while (parametersSize-- != 0) {
const char* descriptor = dexParameterIteratorNextDescriptor(&iterator);
const char *name;
int reg;
if ((argReg >= pCode->registersSize) || (descriptor == NULL)) {
goto invalid_stream;
}
name = readStringIdx(pDexFile, &stream);
reg = argReg;
switch (descriptor[0]) {
case 'D':
case 'J':
argReg += 2;
break;
default:
argReg += 1;
break;
}
if (name != NULL) {
localInReg[reg].name = name;
localInReg[reg].descriptor = descriptor;
localInReg[reg].signature = NULL;
localInReg[reg].startAddress = address;
localInReg[reg].live = true;
}
}
for (;;) {
u1 opcode = *stream++;
u2 reg;
switch (opcode) {
case DBG_END_SEQUENCE:
goto end;
case DBG_ADVANCE_PC:
address += readUnsignedLeb128(&stream);
break;
case DBG_ADVANCE_LINE:
line += readSignedLeb128(&stream);
break;
case DBG_START_LOCAL:
case DBG_START_LOCAL_EXTENDED:
reg = readUnsignedLeb128(&stream);
if (reg > pCode->registersSize) goto invalid_stream;
// Emit what was previously there, if anything
emitLocalCbIfLive (cnxt, reg, address,
localInReg, localCb);
localInReg[reg].name = readStringIdx(pDexFile, &stream);
localInReg[reg].descriptor = readTypeIdx(pDexFile, &stream);
if (opcode == DBG_START_LOCAL_EXTENDED) {
localInReg[reg].signature
= readStringIdx(pDexFile, &stream);
} else {
localInReg[reg].signature = NULL;
}
localInReg[reg].startAddress = address;
localInReg[reg].live = true;
break;
case DBG_END_LOCAL:
reg = readUnsignedLeb128(&stream);
if (reg > pCode->registersSize) goto invalid_stream;
emitLocalCbIfLive (cnxt, reg, address, localInReg, localCb);
localInReg[reg].live = false;
break;
case DBG_RESTART_LOCAL:
reg = readUnsignedLeb128(&stream);
if (reg > pCode->registersSize) goto invalid_stream;
if (localInReg[reg].name == NULL
|| localInReg[reg].descriptor == NULL) {
goto invalid_stream;
}
/*
* If the register is live, the "restart" is superfluous,
* and we don't want to mess with the existing start address.
*/
if (!localInReg[reg].live) {
localInReg[reg].startAddress = address;
localInReg[reg].live = true;
}
break;
case DBG_SET_PROLOGUE_END:
case DBG_SET_EPILOGUE_BEGIN:
case DBG_SET_FILE:
break;
default: {
int adjopcode = opcode - DBG_FIRST_SPECIAL;
address += adjopcode / DBG_LINE_RANGE;
line += DBG_LINE_BASE + (adjopcode % DBG_LINE_RANGE);
if (posCb != NULL) {
int done;
done = posCb(cnxt, address, line);
if (done) {
// early exit
goto end;
}
}
break;
}
}
}
end:
{
int reg;
for (reg = 0; reg < pCode->registersSize; reg++) {
emitLocalCbIfLive (cnxt, reg, insnsSize, localInReg, localCb);
}
}
return;
invalid_stream:
IF_LOGE() {
char* methodDescriptor = dexProtoCopyMethodDescriptor(&proto);
LOGE("Invalid debug info stream. class %s; proto %s",
classDescriptor, methodDescriptor);
free(methodDescriptor);
}
}