/* * Allocate cache. */ bool dvmInstanceofStartup() { gDvm.instanceofCache = dvmAllocAtomicCache(INSTANCEOF_CACHE_SIZE); if (gDvm.instanceofCache == NULL) return false; return true; }
/* * Create auxillary data structures. * * We need a 4-byte pointer for every reference to a class, method, field, * or string constant. Summed up over all loaded DEX files (including the * whoppers in the boostrap class path), this adds up to be quite a bit * of native memory. * * For more traditional VMs these values could be stuffed into the loaded * class file constant pool area, but we don't have that luxury since our * classes are memory-mapped read-only. * * The DEX optimizer will remove the need for some of these (e.g. we won't * use the entry for virtual methods that are only called through * invoke-virtual-quick), creating the possibility of some space reduction * at dexopt time. */ static DvmDex* allocateAuxStructures(DexFile* pDexFile) { DvmDex* pDvmDex; const DexHeader* pHeader; u4 stringCount, classCount, methodCount, fieldCount; pDvmDex = (DvmDex*) calloc(1, sizeof(DvmDex)); if (pDvmDex == NULL) return NULL; pDvmDex->pDexFile = pDexFile; pDvmDex->pHeader = pDexFile->pHeader; pHeader = pDvmDex->pHeader; stringCount = pHeader->stringIdsSize; classCount = pHeader->typeIdsSize; methodCount = pHeader->methodIdsSize; fieldCount = pHeader->fieldIdsSize; 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\n", pDvmDex, stringCount, classCount, methodCount, fieldCount, (stringCount + classCount + methodCount + fieldCount) * 4); 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\n"); free(pDvmDex->pResStrings); free(pDvmDex->pResClasses); free(pDvmDex->pResMethods); free(pDvmDex->pResFields); free(pDvmDex); return NULL; } return pDvmDex; }
static DvmDex* allocateAuxStructures(DexFile* pDexFile) { DvmDex* pDvmDex; const DexHeader* pHeader; u4 stringSize, classSize, methodSize, fieldSize; pHeader = pDexFile->pHeader; stringSize = pHeader->stringIdsSize * sizeof(struct StringObject*); classSize = pHeader->typeIdsSize * sizeof(struct ClassObject*); methodSize = pHeader->methodIdsSize * sizeof(struct Method*); fieldSize = pHeader->fieldIdsSize * sizeof(struct Field*); u4 totalSize = sizeof(DvmDex) + stringSize + classSize + methodSize + fieldSize; u1 *blob = (u1 *)dvmAllocRegion(totalSize, PROT_READ | PROT_WRITE, "dalvik-aux-structure"); if ((void *)blob == MAP_FAILED) return NULL; pDvmDex = (DvmDex*)blob; blob += sizeof(DvmDex); pDvmDex->pDexFile = pDexFile; pDvmDex->pHeader = pHeader; pDvmDex->pResStrings = (struct StringObject**)blob; blob += stringSize; pDvmDex->pResClasses = (struct ClassObject**)blob; blob += classSize; pDvmDex->pResMethods = (struct Method**)blob; blob += methodSize; pDvmDex->pResFields = (struct Field**)blob; ALOGV("+++ DEX %p: allocateAux (%d+%d+%d+%d)*4 = %d bytes", pDvmDex, stringSize/4, classSize/4, methodSize/4, fieldSize/4, stringSize + classSize + methodSize + fieldSize); pDvmDex->pInterfaceCache = dvmAllocAtomicCache(DEX_INTERFACE_CACHE_SIZE); dvmInitMutex(&pDvmDex->modLock); return pDvmDex; }