Dex动态加载的C语言部分

原创 2015年01月19日 09:57:03

 今天主要来分析Dex动态加载C++语言的部分(Android4.0)

 内存加载:

native代码:private static int openDexFile(byte[] fileContents) throws IOException

所对应的实现如下:

static void Dalvik_dalvik_system_DexFile_openDexFile_bytearray(const u4* args , JValue* pResult)
{
    ArrayObject* fileContentsObj = (ArrayObject*) args[0];
    u4 length;
    u1* pBytes;
    RawDexFile* pRawDexFile;
    DexOrJar* pDexOrJar = NULL;

    if (fileContentsObj == NULL) {
        dvmThrowNullPointerException("fileContents == null");
        RETURN_VOID();
    }

    length = fileContentsObj->length;
    pBytes = (u1*) malloc(length);

    if (pBytes == NULL) {
        dvmThrowRuntimeException("unable to allocate DEX memory");
        RETURN_VOID();
    }

    memcpy(pBytes, fileContentsObj->contents, length);

    if (dvmRawDexFileOpenArray(pBytes, length, &pRawDexFile) != 0) {
        LOGV("Unable to open in-memory DEX file");
        free(pBytes);
        dvmThrowRuntimeException("unable to open in-memory DEX file");
        RETURN_VOID();
    }

    LOGV("Opening in-memory DEX");
    pDexOrJar = (DexOrJar*) malloc(sizeof(DexOrJar));
    pDexOrJar->isDex = true;
    pDexOrJar->pRawDexFile = pRawDexFile;
    pDexOrJar->pDexMemory = pBytes;
    pDexOrJar->fileName = strdup("<memory>"); // Needs to be free()able.
    addToDexFileTable(pDexOrJar);

    RETURN_PTR(pDexOrJar);

}

首先来解释fileContentsObj这个对象的内容,从Java层传过来的byte[]类型的一个对象,当到达c++语言层的时候成了两个参数,args和pResult,然后把args这个数组中
的第一个元素直接转化成了ArrayObject对象,接下来显而易见,把这个元素的内容赋给了pBytes对象,那么这个总体的过程可以理解为一个Java层的byte[]类型的对象
转化为c++语言层的一个byte[]类型的对象;

接下来将是对dvmRawDexFileOpenArray(pBytes, length, &pRawDexFile)这个函数的分析,在分析之前,可以一起来看一下这个函数的三个参数,第一个参数和第二个
参数已经不用说了,就是一个byte[]类型的数组,以及这个数组中内容的长度,其实这个内容就是dex的字节流信息,第三个参数是一个RawDexFile的对象,这个对象的数据
结构是这样的:
struct RawDexFile {
    char*       cacheFileName;
    DvmDex*     pDvmDex;
};

这里又看到一个新的数据对象DvmDex,再来看一下这个数据结构:
struct DvmDex {
    DexFile*            pDexFile;
    const DexHeader*    pHeader;
    struct StringObject** pResStrings;
    struct ClassObject** pResClasses;
    struct Method**     pResMethods;
    struct Field**      pResFields;
    struct AtomicCache* pInterfaceCache;
    bool                isMappedReadOnly;
    MemMapping          memMap;
    pthread_mutex_t     modLock;
};

这里又看到一个新的数据对象DexFile,再来看一下这个数据结构:
struct DexFile {
    const DexOptHeader* pOptHeader;
 
    const DexHeader*    pHeader;
    const DexStringId*  pStringIds;
    const DexTypeId*    pTypeIds;
    const DexFieldId*   pFieldIds;
    const DexMethodId*  pMethodIds;
    const DexProtoId*   pProtoIds;
    const DexClassDef*  pClassDefs;
    const DexLink*      pLinkData;

    const DexClassLookup* pClassLookup;
    const void*         pRegisterMapPool;       // RegisterMapClassPool

    const u1*           baseAddr;

    int                 overhead;
}; 

这个数据结构如果了解dex文件格式的话,就对这里的一些对象比较清楚了,其实这个DvmDex数据结构中就保存了Dex文件的各个部分的一些相关内容,具体可以看一下Dex文件
的格式,这里不做多详细的介绍
现在回到那个方法,我们继续往下玩dvmRawDexFileOpenArray这个函数,
int dvmRawDexFileOpenArray(u1* pBytes, u4 length, RawDexFile** ppRawDexFile)
{
    DvmDex* pDvmDex = NULL;

    if (!dvmPrepareDexInMemory(pBytes, length, &pDvmDex)) {
        LOGD("Unable to open raw DEX from array");
        return -1;
    }
    assert(pDvmDex != NULL);

    *ppRawDexFile = (RawDexFile*) calloc(1, sizeof(RawDexFile));
    (*ppRawDexFile)->pDvmDex = pDvmDex;

    return 0;
}
我们可以看到进入这个函数的第一步就是建立了一个DvmDex类型的对象,并初始化为空,经过前面的分析,我们都应该有这个联系,这个pDvmDex对象不就是包含于RawDexFile
这个数据结构中的吗,再看最后第三行,(*ppRawDexFile)->pDvmDex = pDvmDex;,不用多解释,大家明白了这个赋值操作的含义,现在就来看看这个函数的中间部分到底
做了什么呢,还不是dvmPrepareDexInMemory(pBytes, length, &pDvmDex)这个东西惹的祸吗,我们继续进入其中作战,
bool dvmPrepareDexInMemory(u1* addr, size_t len, DvmDex** ppDvmDex)
{
    DexClassLookup* pClassLookup = NULL;
    if (!rewriteDex(addr, len, false, false, &pClassLookup, ppDvmDex)) {
        return false;
    }

    (*ppDvmDex)->pDexFile->pClassLookup = pClassLookup;

    return true;
}

先来看下DexClassLookup这个数据结构长啥模样吧,
struct DexClassLookup {
    int     size;                       
    int     numEntries;                 
    struct {
        u4      classDescriptorHash;    
        int     classDescriptorOffset;  
        int     classDefOffset;         
    } table[1];
};

其实很简单,都是一些最基本的数据类型,也不知道这些代码代码什么意思,黑灯瞎火的,继续向下走吧,
现在来看下rewriteDex这个函数干了些什么,
static bool rewriteDex(u1* addr, int len, bool doVerify, bool doOpt,
    DexClassLookup** ppClassLookup, DvmDex** ppDvmDex)
{
    DexClassLookup* pClassLookup = NULL;
    u8 prepWhen, loadWhen, verifyOptWhen;
    DvmDex* pDvmDex = NULL;
    bool result = false;
    const char* msgStr = "???";

    if (dexSwapAndVerify(addr, len) != 0)
        goto bail;

    if (dvmDexFileOpenPartial(addr, len, &pDvmDex) != 0) {
        LOGE("Unable to create DexFile");
        goto bail;
    }

    pClassLookup = dexCreateClassLookup(pDvmDex->pDexFile);
    if (pClassLookup == NULL)
        goto bail;
    pDvmDex->pDexFile->pClassLookup = pClassLookup;
    //doVerify和doOpt的值都为false,所以直接跳转到bail,于是这个函数就又执行完了,下面再回溯到前面为执行完的代码
    if (!doVerify && !doOpt) {
        result = true;
        goto bail;
    }

    prepWhen = dvmGetRelativeTimeUsec();

    if (!loadAllClasses(pDvmDex))
        goto bail;
    loadWhen = dvmGetRelativeTimeUsec();

    if (!dvmCreateInlineSubsTable())
        goto bail;

    verifyAndOptimizeClasses(pDvmDex->pDexFile, doVerify, doOpt);
    verifyOptWhen = dvmGetRelativeTimeUsec();

    if (doVerify && doOpt)
        msgStr = "verify+opt";
    else if (doVerify)
        msgStr = "verify";
    else if (doOpt)
        msgStr = "opt";
    LOGD("DexOpt: load %dms, %s %dms",
        (int) (loadWhen - prepWhen) / 1000,
        msgStr,
        (int) (verifyOptWhen - loadWhen) / 1000);

    result = true;

bail:
    if (pDvmDex != NULL) {
        pDvmDex->pDexFile->pClassLookup = NULL;
    }
    if (ppDvmDex == NULL || !result) {
        dvmDexFileFree(pDvmDex);
    } else {
        *ppDvmDex = pDvmDex;
    }

    if (ppClassLookup == NULL || !result) {
        free(pClassLookup);
    } else {
        *ppClassLookup = pClassLookup;
    }

    return result;
}

一看可能先吓了一跳,怎么这个函数一下子多了那么多代码,有点不敢看了,其实我想说这是好事啊,这说明你离成功已经不远啦,战士们,Come On吧,
dexSwapAndVerify这个函数就不详细讲了,有兴趣的可以自己详细看,主要是用来交换Dex文件的的字节码的顺序的,这个和你使用的系统处理器是大端的还是小端的有密切
的关系;
接下来看dvmDexFileOpenPartial(addr, len, &pDvmDex)这个函数:
int dvmDexFileOpenPartial(const void* addr, int len, DvmDex** ppDvmDex)
{
    DvmDex* pDvmDex;
    DexFile* pDexFile;
    int parseFlags = kDexParseDefault;
    int result = -1;

    pDexFile = dexFileParse((u1*)addr, len, parseFlags);
    if (pDexFile == NULL) {
        LOGE("DEX parse failed");
        goto bail;
    }
    pDvmDex = allocateAuxStructures(pDexFile);
    if (pDvmDex == NULL) {
        dexFileFree(pDexFile);
        goto bail;
    }

    pDvmDex->isMappedReadOnly = false;
    *ppDvmDex = pDvmDex;
    result = 0;

bail:
    return result;
}
这里可以看到新建了一个DexFile类型的对象,这个主要是用来描述Dex的整个文件的信息,上面已经介绍过了,

接下来看其中的pDexFile = dexFileParse((u1*)addr, len, parseFlags)这个函数,
(这里先说明吓,parseFlags这个参数的值是kDexParseDefault赋予的,kDexParseDefault是一个枚举变量,它的值为0,所以parseFlags的值为0;)
DexFile* dexFileParse(const u1* data, size_t length, int flags)
{
    DexFile* pDexFile = NULL;
    const DexHeader* pHeader;
    const u1* magic;
    int result = -1;

    //判断dex文件得长度是不是大于dex头部得长度,如果比头部的长度都小,那就什么都可以免谈了,好吗!!!
    if (length < sizeof(DexHeader)) {
        LOGE("too short to be a valid .dex");
        goto bail;      /* bad file format */
    }
    //如果dex文件长度是合法的,那么可以给这个还未初始化的pDexFile对象进行全0的初始化了
    pDexFile = (DexFile*) malloc(sizeof(DexFile));
    if (pDexFile == NULL)
        goto bail;      /* alloc failure */
    memset(pDexFile, 0, sizeof(DexFile));

    //这里主要是用来判断是否这个dex文件是一个优化过的dex文件,如果是优化过的dex文件,那么就执行里面的操作,如果是未优化过的,直接可以跳过这一整个
    //if操作了,为了简单起见,暂时就先跳过这个处理dex opt头部的操作吧
      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)",
                 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",
            pDexFile->pOptHeader->dexOffset, pDexFile->pOptHeader->flags);

        /* parse the optimized dex file tables */
        if (!dexParseOptData(data, length, 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",
                pDexFile->pOptHeader->dexLength, (int) length);
            goto bail;
        }
        length = pDexFile->pOptHeader->dexLength;
    }
    //好了,刚才我们已经跳过了这个处理dex opt头部的操作,下面我们就继续战斗,离结束不远啦,坚持住阿!!!
    //下面将来看dexFileSetupBasicPointers(pDexFile,data)这个函数,相信有意识的都应该此刻开始兴奋了,因为这就是关键点了!详细分析请看下面
    dexFileSetupBasicPointers(pDexFile, data);
    pHeader = pDexFile->pHeader;

    //再一次判断头部的magic的8个字节是否是合法的
    if (!dexHasValidMagic(pHeader)) {
        goto bail;
    }

     //这里flags为0,不用再纠结了,跳过吧
     if (flags & kDexParseVerifyChecksum) {
        u4 adler = dexComputeChecksum(pHeader);
        if (adler != pHeader->checksum) {
            LOGE("ERROR: bad checksum (%08x vs %08x)",
                adler, pHeader->checksum);
            if (!(flags & kDexParseContinueOnError))
                goto bail;
        } else {
            LOGV("+++ adler32 checksum (%08x) verified", adler);
        }

        const DexOptHeader* pOptHeader = pDexFile->pOptHeader;
        if (pOptHeader != NULL) {
            adler = dexComputeOptChecksum(pOptHeader);
            if (adler != pOptHeader->checksum) {
                LOGE("ERROR: bad opt checksum (%08x vs %08x)",
                    adler, pOptHeader->checksum);
                if (!(flags & kDexParseContinueOnError))
                    goto bail;
            } else {
                LOGV("+++ adler32 opt checksum (%08x) verified", adler);
            }
        }
    }

    //这里kVerifySignature为0,不用纠结了,跳过吧
    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)",
                dexSHA1DigestToStr(sha1Digest, tmpBuf1),
                dexSHA1DigestToStr(pHeader->signature, tmpBuf2));
            if (!(flags & kDexParseContinueOnError))
                goto bail;
        } else {
            LOGV("+++ sha1 digest verified");
        }
    }
    //继续判断dex文件的大小是否合法
    if (pHeader->fileSize != length) {
        LOGE("ERROR: stored file size (%d) != expected (%d)",
            (int) pHeader->fileSize, (int) length);
        if (!(flags & kDexParseContinueOnError))
            goto bail;
    }
    //判断dex文件中累定义的个数
    if (pHeader->classDefsSize == 0) {
        LOGE("ERROR: DEX file has no classes in it, failing");
        goto bail;
    }

    /*
     * Success!
     */
    result = 0;

bail:
    if (result != 0 && pDexFile != NULL) {
        dexFileFree(pDexFile);
        pDexFile = NULL;
    }
    return pDexFile;
}

***********************************************************************************************************************************
承接上部分对dexFileSetupBasicPointers(pDexFile, data)的分析:
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);
}
可以看到如此简单的几条语句,难道就是核心部分嘛,是的,可以很开心地告诉你,这是非常核心的部分:
Dex总共可以分八个部分,Header,StringID,TypeID,FieldID,MethodID,ProtoID,ClassDefID,CODE,这八个部分本来就是连在一块的大肉饼,
千里迢迢地从java层一直跑到C++层,但是从这一刻起,就在调用完dexFileSetupBasicPointers函数地这一刻起,Dex的整个结构一下子被“大卸八块”了,完全充斥着
pDexFile这个结构体了,也可以很光荣地告诉你要是再想访问Dex中地任何内容,你只需访问pDexFile这个结构体对象即可!!!,好了,我们继续回到上面的下一条语句开始
分析,不要让兴奋冲昏了头脑,毕竟这还没有大获全胜阿,加油,Comn on!!!
***********************************************************************************************************************************

分析完了这个dexFileParse((u1*)addr, len, parseFlags)函数过后,我们可以返回上一层的dvmDexFileOpenPartial这个函数的下一条语句了,
从这里开始:
 if (pDexFile == NULL) {
        LOGE("DEX parse failed");
        goto bail;
    }
    pDvmDex = allocateAuxStructures(pDexFile);
    if (pDvmDex == NULL) {
        dexFileFree(pDexFile);
        goto bail;
    }

    pDvmDex->isMappedReadOnly = false;
    *ppDvmDex = pDvmDex;
    result = 0;

bail:
    return result;
}

好了,这里我们又要分析一个关键的函数了,刚才把pDexFile喂饱了,那么干脆好人做到底啦,是不是应该要把pDvmDex这个对象也要喂饱呢??
我们这就来分析allocateAuxStructures(pDexFile)这个函数吧,
static DvmDex* allocateAuxStructures(DexFile* pDexFile)
{
//前三行初始化对象,不用多说了,就等着待会儿被赋值吧
    DvmDex* pDvmDex;
    const DexHeader* pHeader;
    u4 stringCount, classCount, methodCount, fieldCount;

//给pDvmDex这个对象分配内存,赋值为全1
    pDvmDex = (DvmDex*) calloc(1, sizeof(DvmDex));
    if (pDvmDex == NULL)
        return NULL;

//这两句语开始给pDvmDex这个结构体中的变量赋值
    pDvmDex->pDexFile = pDexFile;
    pDvmDex->pHeader = pDexFile->pHeader;

//这五条语句主要是给这个函数的5个局部变量赋值
    pHeader = pDvmDex->pHeader;

    stringCount = pHeader->stringIdsSize;
    classCount = pHeader->typeIdsSize;
    methodCount = pHeader->methodIdsSize;
    fieldCount = pHeader->fieldIdsSize;

//下面这四条语句给pDvmDex这个对象中的关键的四个字段进行分配空间
    pDvmDex->pResStrings = (struct StringObject**)
        calloc(stringCount, sizeof(struct StringObject*));

    pDvmDex->pResClasses = (struct ClassObject**)
        calloc(classCount, sizeof(struct ClassObject*));

    pDvmDex->pResMethods = (struct Method**)
        calloc(methodCount, sizeof(struct Method*));

    pDvmDex->pResFields = (struct Field**)
        calloc(fieldCount, sizeof(struct Field*));

    LOGV("+++ DEX %p: allocateAux %d+%d+%d+%d * 4 = %d bytes",
        pDvmDex, stringCount, classCount, methodCount, fieldCount,
        (stringCount + classCount + methodCount + fieldCount) * 4);
//这条语句其实也是一样的,也是给pDvmDex中的pInterfaceCache对象分配空间,以及赋值而已
    pDvmDex->pInterfaceCache = dvmAllocAtomicCache(DEX_INTERFACE_CACHE_SIZE);

    if (pDvmDex->pResStrings == NULL ||
        pDvmDex->pResClasses == NULL ||
        pDvmDex->pResMethods == NULL ||
        pDvmDex->pResFields == NULL ||
        pDvmDex->pInterfaceCache == NULL)
    {
        LOGE("Alloc failure in allocateAuxStructures");
        free(pDvmDex->pResStrings);
        free(pDvmDex->pResClasses);
        free(pDvmDex->pResMethods);
        free(pDvmDex->pResFields);
        free(pDvmDex);
        return NULL;
    }

    return pDvmDex;

}
看到这里,你觉得pDvmDex这个对象被喂饱了吗,有没有喂饱就决定了你到底对这个源代码理解了多少,我们继续向下:
刚才dexFileParse((u1*)addr, len, parseFlags) 剩下的部分是这些:
 if (pDvmDex == NULL) {
        dexFileFree(pDexFile);
        goto bail;
    }

    pDvmDex->isMappedReadOnly = false;
    *ppDvmDex = pDvmDex;
    result = 0;

bail:
    return result;
}
显然可以明白是什么意思,不用多说了,那么我们要返回上上个函数没执行完多部分了,就是rewriteDex这个函数,
我们还是从这个函数的上次没执行玩的第一条语句开始吧:
//回顾下,pClassLoopup是DexClassLookup类型的对象,这个对象的主要是用来后续方便查找和加载类的,见下面详细分析dexCreateClassLookup这个函数:
pClassLookup = dexCreateClassLookup(pDvmDex->pDexFile);
    if (pClassLookup == NULL)
        goto bail;
    pDvmDex->pDexFile->pClassLookup = pClassLookup;
    //这里的doVeriry和doOpt的值为false,所以可以直接跳进入bail了
    if (!doVerify && !doOpt) {
        result = true;
        goto bail;
    }

    prepWhen = dvmGetRelativeTimeUsec();

    if (!loadAllClasses(pDvmDex))
        goto bail;
    loadWhen = dvmGetRelativeTimeUsec();

    if (!dvmCreateInlineSubsTable())
        goto bail;

    verifyAndOptimizeClasses(pDvmDex->pDexFile, doVerify, doOpt);
    verifyOptWhen = dvmGetRelativeTimeUsec();

    if (doVerify && doOpt)
        msgStr = "verify+opt";
    else if (doVerify)
        msgStr = "verify";
    else if (doOpt)
        msgStr = "opt";
    LOGD("DexOpt: load %dms, %s %dms",
        (int) (loadWhen - prepWhen) / 1000,
        msgStr,
        (int) (verifyOptWhen - loadWhen) / 1000);

    result = true;

bail:
    if (pDvmDex != NULL) {
        pDvmDex->pDexFile->pClassLookup = NULL;
    }

    if (ppDvmDex == NULL || !result) {
        dvmDexFileFree(pDvmDex);
    } else {
        *ppDvmDex = pDvmDex;
    }

    if (ppClassLookup == NULL || !result) {
        free(pClassLookup);
    } else {
        *ppClassLookup = pClassLookup;
    }

    return result;
}

**************************************************************
DexClassLookup* dexCreateClassLookup(DexFile* pDexFile)
{
    DexClassLookup* pLookup;
    int allocSize;
    int i, numEntries;
    int numProbes, totalProbes, maxProbes;

    numProbes = totalProbes = maxProbes = 0;

    assert(pDexFile != NULL);
    //dexRoundUpPower2的函数的作用是把一个整数向上转化为一个2的幂,比如:1就是1,2就是2,3就是4,5就是8等等......
    numEntries = dexRoundUpPower2(pDexFile->pHeader->classDefsSize * 2);
    //整个LoopUp表的大小,这里可以看到,有多少类,就有多大的空间,当然numEnties已经在现有的类的个数上翻了一番
    allocSize = offsetof(DexClassLookup, table)
                    + numEntries * sizeof(pLookup->table[0]);
    //为pLookup这个对象分配存储空间
    pLookup = (DexClassLookup*) calloc(1, allocSize);
    if (pLookup == NULL)
        return NULL;
    //给pLookup结构体内的字段size,numEntries赋值
    pLookup->size = allocSize;
    pLookup->numEntries = numEntries;
    //下面开始给pLookup这个对象中的table字段赋值,循环的对把各个类的信息加入到pLookup这张表中
    for (i = 0; i < (int)pDexFile->pHeader->classDefsSize; i++) {
        const DexClassDef* pClassDef;
        const char* pString;
        //通过索引i来获得一个DexClassDef类型的对象
        pClassDef = dexGetClassDef(pDexFile, i);
        //通过类中的类型索引来找到类类型,返回一个字符串
        pString = dexStringByTypeIdx(pDexFile, pClassDef->classIdx);
        //classLookupAdd函数就是把第一个类的加入到pLookup这张表中
        //下面先来分析下这个函数,详细分析见下面
        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",
        pDexFile->pHeader->classDefsSize, numEntries,
        (100 * pDexFile->pHeader->classDefsSize) / numEntries,
        allocSize, totalProbes, maxProbes);

    return pLookup;
}
//好了,到这里为止,dexCreateClassLookup这个函数建立pLookup这个表的过程算是结束了,我们开始回溯到上面的未完成的代码中
 **************************************************************
//下面来解释classLoopupAdd这个函数
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);
    //将类描述符通过这个hash函数进行hash,返回一个无符号整形的hash值
    u4 hash = classDescriptorHash(classDescriptor);
    int mask = pLookup->numEntries-1;
    int idx = hash & mask;

    int probes = 0;
    //这里就开始查找pLookup这张表中空余的位置,来放置上面得到的类的信息
    while (pLookup->table[idx].classDescriptorOffset != 0) {
        idx = (idx + 1) & mask;
        probes++;
    }

    pLookup->table[idx].classDescriptorHash = hash;
    pLookup->table[idx].classDescriptorOffset = stringOff;
    pLookup->table[idx].classDefOffset = classDefOff;
    *pNumProbes = probes;
}
//好了,到这里为止,已经把第一个类的信息放在了pLookup这张表中了,我们继续返回上面的代码
*************************************************************** 









来来回回地终于把内存加载字节码的功能分析完了,中间可能漏了很多东西没有细讲,还有一些可能讲的不对,还望大牛多多批评指教,第一次分析源码,写的有点乱,
请看不懂的朋友随时联系我,我一定会改正的;
希望通过这个过程能够帮助有需要的人,也是对我自己的一次磨练!谢谢
请各位大牛批评指教!!!

    

Android动态加载dex技术初探

今天不忙,研究了下Android动态加载dex的技术,主要参考:            1、http://www.cnblogs.com/over140/archive/2011/11/23/2259...
  • u013478336
  • u013478336
  • 2016年02月25日 00:19
  • 11239

动态加载Dex的原理

1 问题 在Android系统中,一个App的所有代码都在一个Dex文件里面。Dex是一个类似Jar的存 储了多有Java编译字节码的归档文件。因为Android系统使用Dalvik虚拟机,所以...
  • dxddxd1987
  • dxddxd1987
  • 2016年06月06日 20:37
  • 614

android APK加固篇-2.动态加载dex及dex的方法的调用

1.用于动态加载的dex可以放在sdcard中进行加载,但是为了安全起见还是觉得放在asset中, 加载之前把dex复制到app的data空间中更好。 String copyDex(String d...
  • csdn49532
  • csdn49532
  • 2016年02月02日 11:02
  • 1659

Android动态加载Dex机制解析

什么是类加载器?    类加载器(class loader)是 Java™中的一个很重要的概念。类加载器负责加载 Java 类的字节代码到 Java 虚拟机中。 Java 虚拟机使用 Java 类的方...
  • wy353208214
  • wy353208214
  • 2016年04月12日 12:45
  • 9980

android中apk/dex的动态加载

终于忍不住开博了,本来自己有一个BLOG
  • lephones
  • lephones
  • 2014年10月21日 23:59
  • 2613

c语言动态加载动态库(dlopen、dlsym)

EPDKcreate_parser create_parser; handle->dl_handle = dlopen("libdemux_rmvb.so", RTLD_NOW); if(ha...
  • opentld
  • opentld
  • 2014年04月28日 13:49
  • 1197

动态加载dex笔记

参考:http://blog.csdn.net/androidsecurity/article/details/8809542(Android APK加壳技术方案【2】) 想要完成的功能:我想简单的...
  • lgl1170860350
  • lgl1170860350
  • 2015年04月30日 13:11
  • 900

Android中apk加固完善篇之内存加载dex方案实现原理(不落地方式加载)

时隔半年,困扰的问题始终是需要解决的,之前也算是没时间弄,今天因为有人在此提起这个问题,那么就不能不解决了,这里写一篇文章记录一下吧。那么是什么问题呢?就是关于之前的一个话题:Android中apk加...
  • jiangwei0910410003
  • jiangwei0910410003
  • 2016年06月02日 08:22
  • 16200

Android插件化开发之DexClassLoader动态加载dex、jar小Demo

一、温故动态加载ClassLoader机制 如果对Android的ClassLoader加载机制不熟悉,猛戳Android插件化开发动态加载基础之ClassLoader工作机制 http://blog...
  • u011068702
  • u011068702
  • 2016年11月21日 20:55
  • 4071

解析 dex 文件结构 - DexHeader

原文: http://kiya-z.github.io/2015/11/17/parse-dex-file-part-dex-header/ 解析 dex 文件结构 - DexHea...
  • u011282069
  • u011282069
  • 2015年11月18日 11:02
  • 1303
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Dex动态加载的C语言部分
举报原因:
原因补充:

(最多只允许输入30个字)