/* * 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. */ /* * Perform some simple bytecode optimizations, chiefly "quickening" of * opcodes. */ #include "Dalvik.h" #include "libdex/InstrUtils.h" #include "Optimize.h" #include #include /* * Virtual/direct calls to "method" are replaced with an execute-inline * instruction with index "idx". */ struct InlineSub { Method* method; int inlineIdx; }; /* fwd */ static void optimizeMethod(Method* method, bool essentialOnly); static void rewriteInstField(Method* method, u2* insns, Opcode quickOpc, Opcode volatileOpc); static void rewriteStaticField(Method* method, u2* insns, Opcode volatileOpc); static void rewriteVirtualInvoke(Method* method, u2* insns, Opcode newOpc); static bool rewriteInvokeObjectInit(Method* method, u2* insns); static bool rewriteExecuteInline(Method* method, u2* insns, MethodType methodType); static bool rewriteExecuteInlineRange(Method* method, u2* insns, MethodType methodType); static void rewriteReturnVoid(Method* method, u2* insns); static bool needsReturnBarrier(Method* method); /* * Create a table of inline substitutions. Sets gDvm.inlineSubs. * * TODO: this is currently just a linear array. We will want to put this * into a hash table as the list size increases. */ bool dvmCreateInlineSubsTable() { const InlineOperation* ops = dvmGetInlineOpsTable(); const int count = dvmGetInlineOpsTableLength(); InlineSub* table; int i, tableIndex; assert(gDvm.inlineSubs == NULL); /* * One slot per entry, plus an end-of-list marker. */ table = (InlineSub*) calloc(count + 1, sizeof(InlineSub)); tableIndex = 0; for (i = 0; i < count; i++) { Method* method = dvmFindInlinableMethod(ops[i].classDescriptor, ops[i].methodName, ops[i].methodSignature); if (method == NULL) { /* * Not expected. We only use this for key methods in core * classes, so we should always be able to find them. */ ALOGE("Unable to find method for inlining: %s.%s:%s", ops[i].classDescriptor, ops[i].methodName, ops[i].methodSignature); free(table); return false; } table[tableIndex].method = method; table[tableIndex].inlineIdx = i; tableIndex++; } /* mark end of table */ table[tableIndex].method = NULL; gDvm.inlineSubs = table; return true; } /* * Release inline sub data structure. */ void dvmFreeInlineSubsTable() { free(gDvm.inlineSubs); gDvm.inlineSubs = NULL; } /* * Optimize the specified class. * * If "essentialOnly" is true, we only do essential optimizations. For * example, accesses to volatile 64-bit fields must be replaced with * "-wide-volatile" instructions or the program could behave incorrectly. * (Skipping non-essential optimizations makes us a little bit faster, and * more importantly avoids dirtying DEX pages.) */ void dvmOptimizeClass(ClassObject* clazz, bool essentialOnly) { int i; for (i = 0; i < clazz->directMethodCount; i++) { optimizeMethod(&clazz->directMethods[i], essentialOnly); } for (i = 0; i < clazz->virtualMethodCount; i++) { optimizeMethod(&clazz->virtualMethods[i], essentialOnly); } } /* * Optimize instructions in a method. * * This does a single pass through the code, examining each instruction. * * This is not expected to fail if the class was successfully verified. * The only significant failure modes on unverified code occur when an * "essential" update fails, but we can't generally identify those: if we * can't look up a field, we can't know if the field access was supposed * to be handled as volatile. * * Instead, we give it our best effort, and hope for the best. For 100% * reliability, only optimize a class after verification succeeds. */ static void optimizeMethod(Method* method, bool essentialOnly) { bool needRetBar, forSmp; u4 insnsSize; u2* insns; if (dvmIsNativeMethod(method) || dvmIsAbstractMethod(method)) return; forSmp = gDvm.dexOptForSmp; needRetBar = needsReturnBarrier(method); insns = (u2*) method->insns; assert(insns != NULL); insnsSize = dvmGetMethodInsnsSize(method); while (insnsSize > 0) { Opcode opc, quickOpc, volatileOpc; size_t width; bool matched = true; opc = dexOpcodeFromCodeUnit(*insns); width = dexGetWidthFromInstruction(insns); volatileOpc = OP_NOP; /* * Each instruction may have: * - "volatile" replacement * - may be essential or essential-on-SMP * - correctness replacement * - may be essential or essential-on-SMP * - performance replacement * - always non-essential * * Replacements are considered in the order shown, and the first * match is applied. For example, iget-wide will convert to * iget-wide-volatile rather than iget-wide-quick if the target * field is volatile. */ /* * essential substitutions: * {iget,iput,sget,sput}-wide --> {op}-wide-volatile * invoke-direct[/range] --> invoke-object-init/range * * essential-on-SMP substitutions: * {iget,iput,sget,sput}-* --> {op}-volatile * return-void --> return-void-barrier * * non-essential substitutions: * {iget,iput}-* --> {op}-quick * * TODO: might be time to merge this with the other two switches */ switch (opc) { case OP_IGET: case OP_IGET_BOOLEAN: case OP_IGET_BYTE: case OP_IGET_CHAR: case OP_IGET_SHORT: quickOpc = OP_IGET_QUICK; if (forSmp) volatileOpc = OP_IGET_VOLATILE; goto rewrite_inst_field; case OP_IGET_WIDE: quickOpc = OP_IGET_WIDE_QUICK; volatileOpc = OP_IGET_WIDE_VOLATILE; goto rewrite_inst_field; case OP_IGET_OBJECT: quickOpc = OP_IGET_OBJECT_QUICK; if (forSmp) volatileOpc = OP_IGET_OBJECT_VOLATILE; goto rewrite_inst_field; case OP_IPUT: case OP_IPUT_BOOLEAN: case OP_IPUT_BYTE: case OP_IPUT_CHAR: case OP_IPUT_SHORT: quickOpc = OP_IPUT_QUICK; if (forSmp) volatileOpc = OP_IPUT_VOLATILE; goto rewrite_inst_field; case OP_IPUT_WIDE: quickOpc = OP_IPUT_WIDE_QUICK; volatileOpc = OP_IPUT_WIDE_VOLATILE; goto rewrite_inst_field; case OP_IPUT_OBJECT: quickOpc = OP_IPUT_OBJECT_QUICK; if (forSmp) volatileOpc = OP_IPUT_OBJECT_VOLATILE; /* fall through */ rewrite_inst_field: if (essentialOnly) quickOpc = OP_NOP; /* if essential-only, no "-quick" sub */ if (quickOpc != OP_NOP || volatileOpc != OP_NOP) rewriteInstField(method, insns, quickOpc, volatileOpc); break; case OP_SGET: case OP_SGET_BOOLEAN: case OP_SGET_BYTE: case OP_SGET_CHAR: case OP_SGET_SHORT: if (forSmp) volatileOpc = OP_SGET_VOLATILE; goto rewrite_static_field; case OP_SGET_WIDE: volatileOpc = OP_SGET_WIDE_VOLATILE; goto rewrite_static_field; case OP_SGET_OBJECT: if (forSmp) volatileOpc = OP_SGET_OBJECT_VOLATILE; goto rewrite_static_field; case OP_SPUT: case OP_SPUT_BOOLEAN: case OP_SPUT_BYTE: case OP_SPUT_CHAR: case OP_SPUT_SHORT: if (forSmp) volatileOpc = OP_SPUT_VOLATILE; goto rewrite_static_field; case OP_SPUT_WIDE: volatileOpc = OP_SPUT_WIDE_VOLATILE; goto rewrite_static_field; case OP_SPUT_OBJECT: if (forSmp) volatileOpc = OP_SPUT_OBJECT_VOLATILE; /* fall through */ rewrite_static_field: if (volatileOpc != OP_NOP) rewriteStaticField(method, insns, volatileOpc); break; case OP_INVOKE_DIRECT: case OP_INVOKE_DIRECT_RANGE: if (!rewriteInvokeObjectInit(method, insns)) { /* may want to try execute-inline, below */ matched = false; } break; case OP_RETURN_VOID: if (needRetBar) rewriteReturnVoid(method, insns); break; default: matched = false; break; } /* * non-essential substitutions: * invoke-{virtual,direct,static}[/range] --> execute-inline * invoke-{virtual,super}[/range] --> invoke-*-quick */ if (!matched && !essentialOnly) { switch (opc) { case OP_INVOKE_VIRTUAL: if (!rewriteExecuteInline(method, insns, METHOD_VIRTUAL)) { rewriteVirtualInvoke(method, insns, OP_INVOKE_VIRTUAL_QUICK); } break; case OP_INVOKE_VIRTUAL_RANGE: if (!rewriteExecuteInlineRange(method, insns, METHOD_VIRTUAL)) { rewriteVirtualInvoke(method, insns, OP_INVOKE_VIRTUAL_QUICK_RANGE); } break; case OP_INVOKE_SUPER: rewriteVirtualInvoke(method, insns, OP_INVOKE_SUPER_QUICK); break; case OP_INVOKE_SUPER_RANGE: rewriteVirtualInvoke(method, insns, OP_INVOKE_SUPER_QUICK_RANGE); break; case OP_INVOKE_DIRECT: rewriteExecuteInline(method, insns, METHOD_DIRECT); break; case OP_INVOKE_DIRECT_RANGE: rewriteExecuteInlineRange(method, insns, METHOD_DIRECT); break; case OP_INVOKE_STATIC: rewriteExecuteInline(method, insns, METHOD_STATIC); break; case OP_INVOKE_STATIC_RANGE: rewriteExecuteInlineRange(method, insns, METHOD_STATIC); break; default: /* nothing to do for this instruction */ ; } } assert(width > 0); assert(width <= insnsSize); assert(width == dexGetWidthFromInstruction(insns)); insns += width; insnsSize -= width; } assert(insnsSize == 0); } /* * Update a 16-bit code unit in "meth". The way in which the DEX data was * loaded determines how we go about the write. * * This will be operating on post-byte-swap DEX data, so values will * be in host order. */ void dvmUpdateCodeUnit(const Method* meth, u2* ptr, u2 newVal) { DvmDex* pDvmDex = meth->clazz->pDvmDex; if (!pDvmDex->isMappedReadOnly) { /* in-memory DEX (dexopt or byte[]), alter the output directly */ *ptr = newVal; } else { /* memory-mapped file, toggle the page read/write status */ dvmDexChangeDex2(pDvmDex, ptr, newVal); } } /* * Update an instruction's opcode. * * If "opcode" is an 8-bit op, we just replace that portion. If it's a * 16-bit op, we convert the opcode from "packed" form (e.g. 0x0108) to * bytecode form (e.g. 0x08ff). */ static inline void updateOpcode(const Method* meth, u2* ptr, u2 opcode) { if (opcode >= 256) { /* opcode low byte becomes high byte, low byte becomes 0xff */ assert((ptr[0] & 0xff) == 0xff); dvmUpdateCodeUnit(meth, ptr, (opcode << 8) | 0x00ff); } else { /* 8-bit op, just replace the low byte */ assert((ptr[0] & 0xff) != 0xff); dvmUpdateCodeUnit(meth, ptr, (ptr[0] & 0xff00) | opcode); } } /* * If "referrer" and "resClass" don't come from the same DEX file, and * the DEX we're working on is not destined for the bootstrap class path, * tweak the class loader so package-access checks work correctly. * * Only do this if we're doing pre-verification or optimization. */ static void tweakLoader(ClassObject* referrer, ClassObject* resClass) { if (!gDvm.optimizing) return; assert(referrer->classLoader == NULL); assert(resClass->classLoader == NULL); if (!gDvm.optimizingBootstrapClass) { /* class loader for an array class comes from element type */ if (dvmIsArrayClass(resClass)) resClass = resClass->elementClass; if (referrer->pDvmDex != resClass->pDvmDex) resClass->classLoader = (Object*) 0xdead3333; } } /* * Undo the effects of tweakLoader. */ static void untweakLoader(ClassObject* referrer, ClassObject* resClass) { if (!gDvm.optimizing || gDvm.optimizingBootstrapClass) return; if (dvmIsArrayClass(resClass)) resClass = resClass->elementClass; resClass->classLoader = NULL; } /* * 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; } /* * Alternate version of dvmResolveInstField(). * * On failure, returns NULL, and sets *pFailure if pFailure is not NULL. */ InstField* dvmOptResolveInstField(ClassObject* referrer, u4 ifieldIdx, VerifyError* pFailure) { DvmDex* pDvmDex = referrer->pDvmDex; InstField* resField; resField = (InstField*) dvmDexGetResolvedField(pDvmDex, ifieldIdx); if (resField == NULL) { const DexFieldId* pFieldId; ClassObject* resClass; pFieldId = dexGetFieldId(pDvmDex->pDexFile, ifieldIdx); /* * Find the field's class. */ resClass = dvmOptResolveClass(referrer, pFieldId->classIdx, pFailure); if (resClass == NULL) { //dvmClearOptException(dvmThreadSelf()); assert(!dvmCheckException(dvmThreadSelf())); if (pFailure != NULL) { assert(!VERIFY_OK(*pFailure)); } return NULL; } resField = (InstField*)dvmFindFieldHier(resClass, dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx), dexStringByTypeIdx(pDvmDex->pDexFile, pFieldId->typeIdx)); if (resField == NULL) { ALOGD("DexOpt: couldn't find field %s.%s", resClass->descriptor, dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx)); if (pFailure != NULL) *pFailure = VERIFY_ERROR_NO_FIELD; return NULL; } if (dvmIsStaticField(resField)) { ALOGD("DexOpt: wanted instance, got static for field %s.%s", resClass->descriptor, dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx)); if (pFailure != NULL) *pFailure = VERIFY_ERROR_CLASS_CHANGE; return NULL; } /* * Add it to the resolved table so we're faster on the next lookup. */ dvmDexSetResolvedField(pDvmDex, ifieldIdx, (Field*) resField); } /* access allowed? */ tweakLoader(referrer, resField->clazz); bool allowed = dvmCheckFieldAccess(referrer, (Field*)resField); untweakLoader(referrer, resField->clazz); if (!allowed) { ALOGI("DexOpt: access denied from %s to field %s.%s", referrer->descriptor, resField->clazz->descriptor, resField->name); if (pFailure != NULL) *pFailure = VERIFY_ERROR_ACCESS_FIELD; return NULL; } return resField; } /* * Alternate version of dvmResolveStaticField(). * * Does not force initialization of the resolved field's class. * * On failure, returns NULL, and sets *pFailure if pFailure is not NULL. */ StaticField* dvmOptResolveStaticField(ClassObject* referrer, u4 sfieldIdx, VerifyError* pFailure) { DvmDex* pDvmDex = referrer->pDvmDex; StaticField* resField; resField = (StaticField*)dvmDexGetResolvedField(pDvmDex, sfieldIdx); if (resField == NULL) { const DexFieldId* pFieldId; ClassObject* resClass; pFieldId = dexGetFieldId(pDvmDex->pDexFile, sfieldIdx); /* * Find the field's class. */ resClass = dvmOptResolveClass(referrer, pFieldId->classIdx, pFailure); if (resClass == NULL) { //dvmClearOptException(dvmThreadSelf()); assert(!dvmCheckException(dvmThreadSelf())); if (pFailure != NULL) { assert(!VERIFY_OK(*pFailure)); } return NULL; } const char* fieldName = dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx); resField = (StaticField*)dvmFindFieldHier(resClass, fieldName, dexStringByTypeIdx(pDvmDex->pDexFile, pFieldId->typeIdx)); if (resField == NULL) { ALOGD("DexOpt: couldn't find static field %s.%s", resClass->descriptor, fieldName); if (pFailure != NULL) *pFailure = VERIFY_ERROR_NO_FIELD; return NULL; } if (!dvmIsStaticField(resField)) { ALOGD("DexOpt: wanted static, got instance for field %s.%s", resClass->descriptor, fieldName); if (pFailure != NULL) *pFailure = VERIFY_ERROR_CLASS_CHANGE; return NULL; } /* * Add it to the resolved table so we're faster on the next lookup. * * We can only do this if we're in "dexopt", because the presence * of a valid value in the resolution table implies that the class * containing the static field has been initialized. */ if (gDvm.optimizing) dvmDexSetResolvedField(pDvmDex, sfieldIdx, (Field*) resField); } /* access allowed? */ tweakLoader(referrer, resField->clazz); bool allowed = dvmCheckFieldAccess(referrer, (Field*)resField); untweakLoader(referrer, resField->clazz); if (!allowed) { ALOGI("DexOpt: access denied from %s to field %s.%s", referrer->descriptor, resField->clazz->descriptor, resField->name); if (pFailure != NULL) *pFailure = VERIFY_ERROR_ACCESS_FIELD; return NULL; } return resField; } /* * Rewrite an iget/iput instruction if appropriate. These all have the form: * op vA, vB, field@CCCC * * Where vA holds the value, vB holds the object reference, and CCCC is * the field reference constant pool offset. For a non-volatile field, * we want to replace the opcode with "quickOpc" and replace CCCC with * the byte offset from the start of the object. For a volatile field, * we just want to replace the opcode with "volatileOpc". * * If "volatileOpc" is OP_NOP we don't check to see if it's a volatile * field. If "quickOpc" is OP_NOP, and this is a non-volatile field, * we don't do anything. * * "method" is the referring method. */ static void rewriteInstField(Method* method, u2* insns, Opcode quickOpc, Opcode volatileOpc) { ClassObject* clazz = method->clazz; u2 fieldIdx = insns[1]; InstField* instField; instField = dvmOptResolveInstField(clazz, fieldIdx, NULL); if (instField == NULL) { ALOGI("DexOpt: unable to optimize instance field ref " "0x%04x at 0x%02x in %s.%s", fieldIdx, (int) (insns - method->insns), clazz->descriptor, method->name); return; } if (volatileOpc != OP_NOP && dvmIsVolatileField(instField)) { updateOpcode(method, insns, volatileOpc); ALOGV("DexOpt: rewrote ifield access %s.%s --> volatile", instField->clazz->descriptor, instField->name); } else if (quickOpc != OP_NOP && instField->byteOffset < 65536) { updateOpcode(method, insns, quickOpc); dvmUpdateCodeUnit(method, insns+1, (u2) instField->byteOffset); ALOGV("DexOpt: rewrote ifield access %s.%s --> %d", instField->clazz->descriptor, instField->name, instField->byteOffset); } else { ALOGV("DexOpt: no rewrite of ifield access %s.%s", instField->clazz->descriptor, instField->name); } return; } /* * Rewrite a static field access instruction if appropriate. If * the target field is volatile, we replace the opcode with "volatileOpc". * * "method" is the referring method. */ static void rewriteStaticField0(Method* method, u2* insns, Opcode volatileOpc, u4 fieldIdx) { ClassObject* clazz = method->clazz; StaticField* staticField; assert(volatileOpc != OP_NOP); staticField = dvmOptResolveStaticField(clazz, fieldIdx, NULL); if (staticField == NULL) { ALOGI("DexOpt: unable to optimize static field ref " "0x%04x at 0x%02x in %s.%s", fieldIdx, (int) (insns - method->insns), clazz->descriptor, method->name); return; } if (dvmIsVolatileField(staticField)) { updateOpcode(method, insns, volatileOpc); ALOGV("DexOpt: rewrote sfield access %s.%s --> volatile", staticField->clazz->descriptor, staticField->name); } } static void rewriteStaticField(Method* method, u2* insns, Opcode volatileOpc) { u2 fieldIdx = insns[1]; rewriteStaticField0(method, insns, volatileOpc, fieldIdx); } /* * Alternate version of dvmResolveMethod(). * * Doesn't throw exceptions, and checks access on every lookup. * * On failure, returns NULL, and sets *pFailure if pFailure is not NULL. */ Method* dvmOptResolveMethod(ClassObject* referrer, u4 methodIdx, MethodType methodType, VerifyError* pFailure) { DvmDex* pDvmDex = referrer->pDvmDex; Method* resMethod; assert(methodType == METHOD_DIRECT || methodType == METHOD_VIRTUAL || methodType == METHOD_STATIC); LOGVV("--- resolving method %u (referrer=%s)", methodIdx, referrer->descriptor); resMethod = dvmDexGetResolvedMethod(pDvmDex, methodIdx); if (resMethod == NULL) { const DexMethodId* pMethodId; ClassObject* resClass; pMethodId = dexGetMethodId(pDvmDex->pDexFile, methodIdx); resClass = dvmOptResolveClass(referrer, pMethodId->classIdx, pFailure); if (resClass == NULL) { /* * Can't find the class that the method is a part of, or don't * have permission to access the class. */ ALOGV("DexOpt: can't find called method's class (?.%s)", dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx)); if (pFailure != NULL) { assert(!VERIFY_OK(*pFailure)); } return NULL; } if (dvmIsInterfaceClass(resClass)) { /* method is part of an interface; this is wrong method for that */ ALOGW("DexOpt: method is in an interface"); if (pFailure != NULL) *pFailure = VERIFY_ERROR_GENERIC; return NULL; } /* * We need to chase up the class hierarchy to find methods defined * in super-classes. (We only want to check the current class * if we're looking for a constructor.) */ DexProto proto; dexProtoSetFromMethodId(&proto, pDvmDex->pDexFile, pMethodId); if (methodType == METHOD_DIRECT) { resMethod = dvmFindDirectMethod(resClass, dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx), &proto); } else { /* METHOD_STATIC or METHOD_VIRTUAL */ resMethod = dvmFindMethodHier(resClass, dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx), &proto); } if (resMethod == NULL) { ALOGV("DexOpt: couldn't find method '%s'", dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx)); if (pFailure != NULL) *pFailure = VERIFY_ERROR_NO_METHOD; return NULL; } if (methodType == METHOD_STATIC) { if (!dvmIsStaticMethod(resMethod)) { ALOGD("DexOpt: wanted static, got instance for method %s.%s", resClass->descriptor, resMethod->name); if (pFailure != NULL) *pFailure = VERIFY_ERROR_CLASS_CHANGE; return NULL; } } else if (methodType == METHOD_VIRTUAL) { if (dvmIsStaticMethod(resMethod)) { ALOGD("DexOpt: wanted instance, got static for method %s.%s", resClass->descriptor, resMethod->name); if (pFailure != NULL) *pFailure = VERIFY_ERROR_CLASS_CHANGE; return NULL; } } /* see if this is a pure-abstract method */ if (dvmIsAbstractMethod(resMethod) && !dvmIsAbstractClass(resClass)) { ALOGW("DexOpt: pure-abstract method '%s' in %s", dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx), resClass->descriptor); if (pFailure != NULL) *pFailure = VERIFY_ERROR_GENERIC; return NULL; } /* * Add it to the resolved table so we're faster on the next lookup. * * We can only do this for static methods if we're not in "dexopt", * because the presence of a valid value in the resolution table * implies that the class containing the static field has been * initialized. */ if (methodType != METHOD_STATIC || gDvm.optimizing) dvmDexSetResolvedMethod(pDvmDex, methodIdx, resMethod); } LOGVV("--- found method %d (%s.%s)", methodIdx, resMethod->clazz->descriptor, resMethod->name); /* access allowed? */ tweakLoader(referrer, resMethod->clazz); bool allowed = dvmCheckMethodAccess(referrer, resMethod); untweakLoader(referrer, resMethod->clazz); if (!allowed) { IF_ALOGI() { char* desc = dexProtoCopyMethodDescriptor(&resMethod->prototype); ALOGI("DexOpt: illegal method access (call %s.%s %s from %s)", resMethod->clazz->descriptor, resMethod->name, desc, referrer->descriptor); free(desc); } if (pFailure != NULL) *pFailure = VERIFY_ERROR_ACCESS_METHOD; return NULL; } return resMethod; } /* * Rewrite invoke-virtual, invoke-virtual/range, invoke-super, and * invoke-super/range if appropriate. These all have the form: * op vAA, meth@BBBB, reg stuff @CCCC * * We want to replace the method constant pool index BBBB with the * vtable index. */ static void rewriteVirtualInvoke(Method* method, u2* insns, Opcode newOpc) { ClassObject* clazz = method->clazz; Method* baseMethod; u2 methodIdx = insns[1]; baseMethod = dvmOptResolveMethod(clazz, methodIdx, METHOD_VIRTUAL, NULL); if (baseMethod == NULL) { ALOGD("DexOpt: unable to optimize virt call 0x%04x at 0x%02x in %s.%s", methodIdx, (int) (insns - method->insns), clazz->descriptor, method->name); return; } assert((insns[0] & 0xff) == OP_INVOKE_VIRTUAL || (insns[0] & 0xff) == OP_INVOKE_VIRTUAL_RANGE || (insns[0] & 0xff) == OP_INVOKE_SUPER || (insns[0] & 0xff) == OP_INVOKE_SUPER_RANGE); /* * Note: Method->methodIndex is a u2 and is range checked during the * initial load. */ updateOpcode(method, insns, newOpc); dvmUpdateCodeUnit(method, insns+1, baseMethod->methodIndex); //ALOGI("DexOpt: rewrote call to %s.%s --> %s.%s", // method->clazz->descriptor, method->name, // baseMethod->clazz->descriptor, baseMethod->name); return; } /* * Rewrite invoke-direct[/range] if the target is Object.. * * This is useful as an optimization, because otherwise every object * instantiation will cause us to call a method that does nothing. * It also allows us to inexpensively mark objects as finalizable at the * correct time. * * TODO: verifier should ensure Object. contains only return-void, * and issue a warning if not. */ static bool rewriteInvokeObjectInit(Method* method, u2* insns) { ClassObject* clazz = method->clazz; Method* calledMethod; u2 methodIdx = insns[1]; calledMethod = dvmOptResolveMethod(clazz, methodIdx, METHOD_DIRECT, NULL); if (calledMethod == NULL) { ALOGD("DexOpt: unable to opt direct call 0x%04x at 0x%02x in %s.%s", methodIdx, (int) (insns - method->insns), clazz->descriptor, method->name); return false; } if (calledMethod->clazz == gDvm.classJavaLangObject && dvmCompareNameDescriptorAndMethod("", "()V", calledMethod) == 0) { /* * Replace the instruction. If the debugger is attached, the * interpreter will forward execution to the invoke-direct/range * handler. If this was an invoke-direct/range instruction we can * just replace the opcode, but if it was an invoke-direct we * have to set the argument count (high 8 bits of first code unit) * to 1. */ u1 origOp = insns[0] & 0xff; if (origOp == OP_INVOKE_DIRECT) { dvmUpdateCodeUnit(method, insns, OP_INVOKE_OBJECT_INIT_RANGE | 0x100); } else { assert(origOp == OP_INVOKE_DIRECT_RANGE); assert((insns[0] >> 8) == 1); updateOpcode(method, insns, OP_INVOKE_OBJECT_INIT_RANGE); } LOGVV("DexOpt: replaced Object. in %s.%s", method->clazz->descriptor, method->name); }else{ return false; } return true; } /* * Resolve an interface method reference. * * No method access check here -- interface methods are always public. * * Returns NULL if the method was not found. Does not throw an exception. */ Method* dvmOptResolveInterfaceMethod(ClassObject* referrer, u4 methodIdx) { DvmDex* pDvmDex = referrer->pDvmDex; Method* resMethod; LOGVV("--- resolving interface method %d (referrer=%s)", methodIdx, referrer->descriptor); resMethod = dvmDexGetResolvedMethod(pDvmDex, methodIdx); if (resMethod == NULL) { const DexMethodId* pMethodId; ClassObject* resClass; pMethodId = dexGetMethodId(pDvmDex->pDexFile, methodIdx); resClass = dvmOptResolveClass(referrer, pMethodId->classIdx, NULL); if (resClass == NULL) { /* can't find the class that the method is a part of */ dvmClearOptException(dvmThreadSelf()); return NULL; } if (!dvmIsInterfaceClass(resClass)) { /* whoops */ ALOGI("Interface method not part of interface class"); return NULL; } const char* methodName = dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx); DexProto proto; dexProtoSetFromMethodId(&proto, pDvmDex->pDexFile, pMethodId); LOGVV("+++ looking for '%s' '%s' in resClass='%s'", methodName, methodSig, resClass->descriptor); resMethod = dvmFindInterfaceMethodHier(resClass, methodName, &proto); if (resMethod == NULL) { return NULL; } /* we're expecting this to be abstract */ if (!dvmIsAbstractMethod(resMethod)) { char* desc = dexProtoCopyMethodDescriptor(&resMethod->prototype); ALOGW("Found non-abstract interface method %s.%s %s", resMethod->clazz->descriptor, resMethod->name, desc); free(desc); return NULL; } /* * Add it to the resolved table so we're faster on the next lookup. */ dvmDexSetResolvedMethod(pDvmDex, methodIdx, resMethod); } LOGVV("--- found interface method %d (%s.%s)", methodIdx, resMethod->clazz->descriptor, resMethod->name); /* interface methods are always public; no need to check access */ return resMethod; } /* * Replace invoke-virtual, invoke-direct, or invoke-static with an * execute-inline operation if appropriate. * * Returns "true" if we replace it. */ static bool rewriteExecuteInline(Method* method, u2* insns, MethodType methodType) { const InlineSub* inlineSubs = gDvm.inlineSubs; ClassObject* clazz = method->clazz; Method* calledMethod; u2 methodIdx = insns[1]; //return false; calledMethod = dvmOptResolveMethod(clazz, methodIdx, methodType, NULL); if (calledMethod == NULL) { ALOGV("+++ DexOpt inline: can't find %d", methodIdx); return false; } while (inlineSubs->method != NULL) { /* if (extra) { ALOGI("comparing %p vs %p %s.%s %s", inlineSubs->method, calledMethod, inlineSubs->method->clazz->descriptor, inlineSubs->method->name, inlineSubs->method->signature); } */ if (inlineSubs->method == calledMethod) { assert((insns[0] & 0xff) == OP_INVOKE_DIRECT || (insns[0] & 0xff) == OP_INVOKE_STATIC || (insns[0] & 0xff) == OP_INVOKE_VIRTUAL); updateOpcode(method, insns, OP_EXECUTE_INLINE); dvmUpdateCodeUnit(method, insns+1, (u2) inlineSubs->inlineIdx); //ALOGI("DexOpt: execute-inline %s.%s --> %s.%s", // method->clazz->descriptor, method->name, // calledMethod->clazz->descriptor, calledMethod->name); return true; } inlineSubs++; } return false; } /* * Replace invoke-virtual/range, invoke-direct/range, or invoke-static/range * with an execute-inline operation if appropriate. * * Returns "true" if we replace it. */ static bool rewriteExecuteInlineRange(Method* method, u2* insns, MethodType methodType) { const InlineSub* inlineSubs = gDvm.inlineSubs; ClassObject* clazz = method->clazz; Method* calledMethod; u2 methodIdx = insns[1]; calledMethod = dvmOptResolveMethod(clazz, methodIdx, methodType, NULL); if (calledMethod == NULL) { ALOGV("+++ DexOpt inline/range: can't find %d", methodIdx); return false; } while (inlineSubs->method != NULL) { if (inlineSubs->method == calledMethod) { assert((insns[0] & 0xff) == OP_INVOKE_DIRECT_RANGE || (insns[0] & 0xff) == OP_INVOKE_STATIC_RANGE || (insns[0] & 0xff) == OP_INVOKE_VIRTUAL_RANGE); updateOpcode(method, insns, OP_EXECUTE_INLINE_RANGE); dvmUpdateCodeUnit(method, insns+1, (u2) inlineSubs->inlineIdx); //ALOGI("DexOpt: execute-inline/range %s.%s --> %s.%s", // method->clazz->descriptor, method->name, // calledMethod->clazz->descriptor, calledMethod->name); return true; } inlineSubs++; } return false; } /* * Returns "true" if the return-void instructions in this method should * be converted to return-void-barrier. * * This is needed to satisfy a Java Memory Model requirement regarding * the construction of objects with final fields. (This does not apply * to or static fields, since appropriate barriers are guaranteed * by the class initialization process.) */ static bool needsReturnBarrier(Method* method) { if (!gDvm.dexOptForSmp) return false; if (strcmp(method->name, "") != 0) return false; /* * Check to see if the class is finalizable. The loader sets a flag * if the class or one of its superclasses overrides finalize(). */ const ClassObject* clazz = method->clazz; if (IS_CLASS_FLAG_SET(clazz, CLASS_ISFINALIZABLE)) return true; /* * Check to see if the class has any final fields. If not, we don't * need to generate a barrier instruction. * * In theory, we only need to do this if the method actually modifies * a final field. In practice, non-constructor methods are allowed * to modify final fields, and there are 3rd-party tools that rely on * this behavior. (The compiler does not allow it, but the VM does.) * * If we alter the verifier to restrict final-field updates to * constructors, we can tighten this up as well. */ int idx = clazz->ifieldCount; while (--idx >= 0) { if (dvmIsFinalField(&clazz->ifields[idx])) return true; } return false; } /* * Convert a return-void to a return-void-barrier. */ static void rewriteReturnVoid(Method* method, u2* insns) { assert((insns[0] & 0xff) == OP_RETURN_VOID); updateOpcode(method, insns, OP_RETURN_VOID_BARRIER); }