static void preloadDexCachesStatsFilled(DexCacheStats* filled) {
if (!kPreloadDexCachesCollectStats) {
return;
}
for (ClassPathEntry* cpe = gDvm.bootClassPath; cpe->kind != kCpeLastEntry; cpe++) {
DvmDex* pDvmDex = getDvmDexFromClassPathEntry(cpe);
const DexHeader* pHeader = pDvmDex->pHeader;
for (size_t i = 0; i < pHeader->stringIdsSize; i++) {
StringObject* string = dvmDexGetResolvedString(pDvmDex, i);
if (string != NULL) {
filled->numStrings++;
}
}
for (size_t i = 0; i < pHeader->typeIdsSize; i++) {
ClassObject* clazz = dvmDexGetResolvedClass(pDvmDex, i);
if (clazz != NULL) {
filled->numTypes++;
}
}
for (size_t i = 0; i < pHeader->fieldIdsSize; i++) {
Field* field = dvmDexGetResolvedField(pDvmDex, i);
if (field != NULL) {
filled->numFields++;
}
}
for (size_t i = 0; i < pHeader->methodIdsSize; i++) {
Method* method = dvmDexGetResolvedMethod(pDvmDex, i);
if (method != NULL) {
filled->numMethods++;
}
}
}
}
// Based on dvmResolveInstField/dvmResolveStaticField.
static void preloadDexCachesResolveField(DvmDex* pDvmDex, uint32_t fieldIdx, bool instance) {
Field* field = dvmDexGetResolvedField(pDvmDex, fieldIdx);
if (field != NULL) {
return;
}
const DexFile* pDexFile = pDvmDex->pDexFile;
const DexFieldId* pFieldId = dexGetFieldId(pDexFile, fieldIdx);
ClassObject* clazz = dvmDexGetResolvedClass(pDvmDex, pFieldId->classIdx);
if (clazz == NULL) {
return;
}
// Skip static fields for uninitialized classes because a filled
// cache entry implies the class is initialized.
if (!instance && !dvmIsClassInitialized(clazz)) {
return;
}
const char* fieldName = dexStringById(pDexFile, pFieldId->nameIdx);
const char* signature = dexStringByTypeIdx(pDexFile, pFieldId->typeIdx);
if (instance) {
field = dvmFindInstanceFieldHier(clazz, fieldName, signature);
} else {
field = dvmFindStaticFieldHier(clazz, fieldName, signature);
}
if (field == NULL) {
return;
}
// ALOGI("VMRuntime.preloadDexCaches found field %s %s.%s",
// signature, clazz->descriptor, fieldName);
dvmDexSetResolvedField(pDvmDex, fieldIdx, field);
}
// Based on dvmResolveMethod.
static void preloadDexCachesResolveMethod(DvmDex* pDvmDex,
uint32_t methodIdx,
MethodType methodType) {
Method* method = dvmDexGetResolvedMethod(pDvmDex, methodIdx);
if (method != NULL) {
return;
}
const DexFile* pDexFile = pDvmDex->pDexFile;
const DexMethodId* pMethodId = dexGetMethodId(pDexFile, methodIdx);
ClassObject* clazz = dvmDexGetResolvedClass(pDvmDex, pMethodId->classIdx);
if (clazz == NULL) {
return;
}
// Skip static methods for uninitialized classes because a filled
// cache entry implies the class is initialized.
if ((methodType == METHOD_STATIC) && !dvmIsClassInitialized(clazz)) {
return;
}
const char* methodName = dexStringById(pDexFile, pMethodId->nameIdx);
DexProto proto;
dexProtoSetFromMethodId(&proto, pDexFile, pMethodId);
if (methodType == METHOD_DIRECT) {
method = dvmFindDirectMethod(clazz, methodName, &proto);
} else if (methodType == METHOD_STATIC) {
method = dvmFindDirectMethodHier(clazz, methodName, &proto);
} else {
method = dvmFindVirtualMethodHier(clazz, methodName, &proto);
}
if (method == NULL) {
return;
}
// ALOGI("VMRuntime.preloadDexCaches found method %s.%s",
// clazz->descriptor, methodName);
dvmDexSetResolvedMethod(pDvmDex, methodIdx, method);
}
// Based on dvmResolveClass.
static void preloadDexCachesResolveType(DvmDex* pDvmDex, uint32_t typeIdx) {
ClassObject* clazz = dvmDexGetResolvedClass(pDvmDex, typeIdx);
if (clazz != NULL) {
return;
}
const DexFile* pDexFile = pDvmDex->pDexFile;
const char* className = dexStringByTypeIdx(pDexFile, typeIdx);
if (className[0] != '\0' && className[1] == '\0') {
/* primitive type */
clazz = dvmFindPrimitiveClass(className[0]);
} else {
clazz = dvmLookupClass(className, NULL, true);
}
if (clazz == NULL) {
return;
}
// Skip uninitialized classes because filled cache entry implies it is initialized.
if (!dvmIsClassInitialized(clazz)) {
// ALOGI("VMRuntime.preloadDexCaches uninitialized clazz=%s", className);
return;
}
// ALOGI("VMRuntime.preloadDexCaches found clazz=%s", className);
dvmDexSetResolvedClass(pDvmDex, typeIdx, clazz);
}
GOTO_TARGET(filledNewArray, bool methodCallRange)
{
ClassObject* arrayClass;
ArrayObject* newArray;
u4* contents;
char typeCh;
int i;
u4 arg5;
EXPORT_PC();
ref = FETCH(1); /* class ref */
vdst = FETCH(2); /* first 4 regs -or- range base */
if (methodCallRange) {
vsrc1 = INST_AA(inst); /* #of elements */
arg5 = -1; /* silence compiler warning */
ILOGV("|filled-new-array-range args=%d @0x%04x {regs=v%d-v%d}",
vsrc1, ref, vdst, vdst+vsrc1-1);
} else {
arg5 = INST_A(inst);
vsrc1 = INST_B(inst); /* #of elements */
ILOGV("|filled-new-array args=%d @0x%04x {regs=0x%04x %x}",
vsrc1, ref, vdst, arg5);
}
/*
* Resolve the array class.
*/
arrayClass = dvmDexGetResolvedClass(methodClassDex, ref);
if (arrayClass == NULL) {
arrayClass = dvmResolveClass(curMethod->clazz, ref, false);
if (arrayClass == NULL)
GOTO_exceptionThrown();
}
/*
if (!dvmIsArrayClass(arrayClass)) {
dvmThrowException("Ljava/lang/RuntimeError;",
"filled-new-array needs array class");
GOTO_exceptionThrown();
}
*/
/* verifier guarantees this is an array class */
assert(dvmIsArrayClass(arrayClass));
assert(dvmIsClassInitialized(arrayClass));
/*
* Create an array of the specified type.
*/
LOGVV("+++ filled-new-array type is '%s'\n", arrayClass->descriptor);
typeCh = arrayClass->descriptor[1];
if (typeCh == 'D' || typeCh == 'J') {
/* category 2 primitives not allowed */
dvmThrowException("Ljava/lang/RuntimeError;",
"bad filled array req");
GOTO_exceptionThrown();
} else if (typeCh != 'L' && typeCh != '[' && typeCh != 'I') {
/* TODO: requires multiple "fill in" loops with different widths */
LOGE("non-int primitives not implemented\n");
dvmThrowException("Ljava/lang/InternalError;",
"filled-new-array not implemented for anything but 'int'");
GOTO_exceptionThrown();
}
newArray = dvmAllocArrayByClass(arrayClass, vsrc1, ALLOC_DONT_TRACK);
if (newArray == NULL)
GOTO_exceptionThrown();
/*
* Fill in the elements. It's legal for vsrc1 to be zero.
*/
contents = (u4*) newArray->contents;
if (methodCallRange) {
for (i = 0; i < vsrc1; i++)
contents[i] = GET_REGISTER(vdst+i);
} else {
assert(vsrc1 <= 5);
if (vsrc1 == 5) {
contents[4] = GET_REGISTER(arg5);
vsrc1--;
}
for (i = 0; i < vsrc1; i++) {
contents[i] = GET_REGISTER(vdst & 0x0f);
vdst >>= 4;
}
}
retval.l = newArray;
}
/*
* Find the class corresponding to "classIdx", which maps to a class name
* string. It might be in the same DEX file as "referrer", in a different
* DEX file, generated by a class loader, or generated by the VM (e.g.
* array classes).
*
* Because the DexTypeId is associated with the referring class' DEX file,
* we may have to resolve the same class more than once if it's referred
* to from classes in multiple DEX files. This is a necessary property for
* DEX files associated with different class loaders.
*
* We cache a copy of the lookup in the DexFile's "resolved class" table,
* so future references to "classIdx" are faster.
*
* Note that "referrer" may be in the process of being linked.
*
* Traditional VMs might do access checks here, but in Dalvik the class
* "constant pool" is shared between all classes in the DEX file. We rely
* on the verifier to do the checks for us.
*
* Does not initialize the class.
*
* "fromUnverifiedConstant" should only be set if this call is the direct
* result of executing a "const-class" or "instance-of" instruction, which
* use class constants not resolved by the bytecode verifier.
*
* Returns NULL with an exception raised on failure.
*/
ClassObject* dvmResolveClass(const ClassObject* referrer, u4 classIdx,
bool fromUnverifiedConstant)
{
DvmDex* pDvmDex = referrer->pDvmDex;
ClassObject* resClass;
const char* className;
/*
* Check the table first -- this gets called from the other "resolve"
* methods.
*/
resClass = dvmDexGetResolvedClass(pDvmDex, classIdx);
if (resClass != NULL)
return resClass;
LOGVV("--- resolving class %u (referrer=%s cl=%p)\n",
classIdx, referrer->descriptor, referrer->classLoader);
/*
* Class hasn't been loaded yet, or is in the process of being loaded
* and initialized now. Try to get a copy. If we find one, put the
* pointer in the DexTypeId. There isn't a race condition here --
* 32-bit writes are guaranteed atomic on all target platforms. Worst
* case we have two threads storing the same value.
*
* If this is an array class, we'll generate it here.
*/
className = dexStringByTypeIdx(pDvmDex->pDexFile, classIdx);
if (className[0] != '\0' && className[1] == '\0') {
/* primitive type */
resClass = dvmFindPrimitiveClass(className[0]);
} else {
resClass = dvmFindClassNoInit(className, referrer->classLoader);
}
if (resClass != NULL) {
/*
* If the referrer was pre-verified, the resolved class must come
* from the same DEX or from a bootstrap class. The pre-verifier
* makes assumptions that could be invalidated by a wacky class
* loader. (See the notes at the top of oo/Class.c.)
*
* The verifier does *not* fail a class for using a const-class
* or instance-of instruction referring to an unresolveable class,
* because the result of the instruction is simply a Class object
* or boolean -- there's no need to resolve the class object during
* verification. Instance field and virtual method accesses can
* break dangerously if we get the wrong class, but const-class and
* instance-of are only interesting at execution time. So, if we
* we got here as part of executing one of the "unverified class"
* instructions, we skip the additional check.
*
* Ditto for class references from annotations and exception
* handler lists.
*/
if (!fromUnverifiedConstant &&
IS_CLASS_FLAG_SET(referrer, CLASS_ISPREVERIFIED))
{
ClassObject* resClassCheck = resClass;
if (dvmIsArrayClass(resClassCheck))
resClassCheck = resClassCheck->elementClass;
if (referrer->pDvmDex != resClassCheck->pDvmDex &&
resClassCheck->classLoader != NULL)
{
LOGW("Class resolved by unexpected DEX:"
" %s(%p):%p ref [%s] %s(%p):%p\n",
referrer->descriptor, referrer->classLoader,
referrer->pDvmDex,
resClass->descriptor, resClassCheck->descriptor,
resClassCheck->classLoader, resClassCheck->pDvmDex);
LOGW("(%s had used a different %s during pre-verification)\n",
referrer->descriptor, resClass->descriptor);
dvmThrowException("Ljava/lang/IllegalAccessError;",
"Class ref in pre-verified class resolved to unexpected "
"implementation");
return NULL;
}
}
LOGVV("##### +ResolveClass(%s): referrer=%s dex=%p ldr=%p ref=%d\n",
resClass->descriptor, referrer->descriptor, referrer->pDvmDex,
referrer->classLoader, classIdx);
/*
* Add what we found to the list so we can skip the class search
* next time through.
*
* TODO: should we be doing this when fromUnverifiedConstant==true?
* (see comments at top of oo/Class.c)
*/
dvmDexSetResolvedClass(pDvmDex, classIdx, resClass);
} else {
/* not found, exception should be raised */
LOGVV("Class not found: %s\n",
dexStringByTypeIdx(pDvmDex->pDexFile, classIdx));
assert(dvmCheckException(dvmThreadSelf()));
}
return resClass;
}
/*
* Alternate version of dvmResolveClass for use with verification and
* optimization. Performs access checks on every resolve, and refuses
* to acknowledge the existence of classes defined in more than one DEX
* file.
*
* Exceptions caused by failures are cleared before returning.
*
* On failure, returns NULL, and sets *pFailure if pFailure is not NULL.
*/
ClassObject* dvmOptResolveClass(ClassObject* referrer, u4 classIdx,
VerifyError* pFailure)
{
DvmDex* pDvmDex = referrer->pDvmDex;
ClassObject* resClass;
/*
* Check the table first. If not there, do the lookup by name.
*/
resClass = dvmDexGetResolvedClass(pDvmDex, classIdx);
if (resClass == NULL) {
const char* className = dexStringByTypeIdx(pDvmDex->pDexFile, classIdx);
if (className[0] != '\0' && className[1] == '\0') {
/* primitive type */
resClass = dvmFindPrimitiveClass(className[0]);
} else {
resClass = dvmFindClassNoInit(className, referrer->classLoader);
}
if (resClass == NULL) {
/* not found, exception should be raised */
ALOGV("DexOpt: class %d (%s) not found",
classIdx,
dexStringByTypeIdx(pDvmDex->pDexFile, classIdx));
if (pFailure != NULL) {
/* dig through the wrappers to find the original failure */
Object* excep = dvmGetException(dvmThreadSelf());
while (true) {
Object* cause = dvmGetExceptionCause(excep);
if (cause == NULL)
break;
excep = cause;
}
if (strcmp(excep->clazz->descriptor,
"Ljava/lang/IncompatibleClassChangeError;") == 0)
{
*pFailure = VERIFY_ERROR_CLASS_CHANGE;
} else {
*pFailure = VERIFY_ERROR_NO_CLASS;
}
}
dvmClearOptException(dvmThreadSelf());
return NULL;
}
/*
* Add it to the resolved table so we're faster on the next lookup.
*/
dvmDexSetResolvedClass(pDvmDex, classIdx, resClass);
}
/* multiple definitions? */
if (IS_CLASS_FLAG_SET(resClass, CLASS_MULTIPLE_DEFS)) {
ALOGI("DexOpt: not resolving ambiguous class '%s'",
resClass->descriptor);
if (pFailure != NULL)
*pFailure = VERIFY_ERROR_NO_CLASS;
return NULL;
}
/* access allowed? */
tweakLoader(referrer, resClass);
bool allowed = dvmCheckClassAccess(referrer, resClass);
untweakLoader(referrer, resClass);
if (!allowed) {
ALOGW("DexOpt: resolve class illegal access: %s -> %s",
referrer->descriptor, resClass->descriptor);
if (pFailure != NULL)
*pFailure = VERIFY_ERROR_ACCESS_CLASS;
return NULL;
}
return resClass;
}
/*
* 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;
}
