vm/oo/Object.c - platform/dalvik - Git at Google

 /*
  * 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.
  */

 /*
  * Operations on an Object.
  */
 #include "Dalvik.h"

 /*
  * Find a matching field, in the current class only.
  *
  * Returns NULL if the field can't be found.  (Does not throw an exception.)
  */
 InstField* dvmFindInstanceField(const ClassObject* clazz,
     const char* fieldName, const char* signature)
 {
     InstField* pField;
     int i;

     assert(clazz != NULL);

     /*
      * Find a field with a matching name and signature.  The Java programming
      * language does not allow you to have two fields with the same name
      * and different types, but the Java VM spec does allow it, so we can't
      * bail out early when the name matches.
      */
     pField = clazz->ifields;
     for (i = 0; i < clazz->ifieldCount; i++, pField++) {
         if (strcmp(fieldName, pField->field.name) == 0 &&
             strcmp(signature, pField->field.signature) == 0)
         {
             return pField;
         }
     }

     return NULL;
 }

 /*
  * Find a matching field, in this class or a superclass.
  *
  * Searching through interfaces isn't necessary, because interface fields
  * are inherently public/static/final.
  *
  * Returns NULL if the field can't be found.  (Does not throw an exception.)
  */
 InstField* dvmFindInstanceFieldHier(const ClassObject* clazz,
     const char* fieldName, const char* signature)
 {
     InstField* pField;

     /*
      * Search for a match in the current class.
      */
     pField = dvmFindInstanceField(clazz, fieldName, signature);
     if (pField != NULL)
         return pField;

     if (clazz->super != NULL)
         return dvmFindInstanceFieldHier(clazz->super, fieldName, signature);
     else
         return NULL;
 }


 /*
  * Find a matching field, in this class or an interface.
  *
  * Returns NULL if the field can't be found.  (Does not throw an exception.)
  */
 StaticField* dvmFindStaticField(const ClassObject* clazz,
     const char* fieldName, const char* signature)
 {
     const StaticField* pField;
     int i;

     assert(clazz != NULL);

     /*
      * Find a field with a matching name and signature.  As with instance
      * fields, the VM allows you to have two fields with the same name so
      * long as they have different types.
      */
     pField = &clazz->sfields[0];
     for (i = 0; i < clazz->sfieldCount; i++, pField++) {
         if (strcmp(fieldName, pField->field.name) == 0 &&
             strcmp(signature, pField->field.signature) == 0)
         {
             return (StaticField*) pField;
         }
     }

     return NULL;
 }

 /*
  * Find a matching field, in this class or a superclass.
  *
  * Returns NULL if the field can't be found.  (Does not throw an exception.)
  */
 StaticField* dvmFindStaticFieldHier(const ClassObject* clazz,
     const char* fieldName, const char* signature)
 {
     StaticField* pField;

     /*
      * Search for a match in the current class.
      */
     pField = dvmFindStaticField(clazz, fieldName, signature);
     if (pField != NULL)
         return pField;

     /*
      * See if it's in any of our interfaces.  We don't check interfaces
      * inherited from the superclass yet.
      *
      * (Note the set may have been stripped down because of redundancy with
      * the superclass; see notes in createIftable.)
      */
     int i = 0;
     if (clazz->super != NULL) {
         assert(clazz->iftableCount >= clazz->super->iftableCount);
         i = clazz->super->iftableCount;
     }
     for ( ; i < clazz->iftableCount; i++) {
         ClassObject* iface = clazz->iftable[i].clazz;
         pField = dvmFindStaticField(iface, fieldName, signature);
         if (pField != NULL)
             return pField;
     }

     if (clazz->super != NULL)
         return dvmFindStaticFieldHier(clazz->super, fieldName, signature);
     else
         return NULL;
 }

 /*
  * Find a matching field, in this class or a superclass.
  *
  * We scan both the static and instance field lists in the class.  If it's
  * not found there, we check the direct interfaces, and then recursively
  * scan the superclasses.  This is the order prescribed in the VM spec
  * (v2 5.4.3.2).
  *
  * In most cases we know that we're looking for either a static or an
  * instance field and there's no value in searching through both types.
  * During verification we need to recognize and reject certain unusual
  * situations, and we won't see them unless we walk the lists this way.
  */
 Field* dvmFindFieldHier(const ClassObject* clazz, const char* fieldName,
     const char* signature)
 {
     Field* pField;

     /*
      * Search for a match in the current class.  Which set we scan first
      * doesn't really matter.
      */
     pField = (Field*) dvmFindStaticField(clazz, fieldName, signature);
     if (pField != NULL)
         return pField;
     pField = (Field*) dvmFindInstanceField(clazz, fieldName, signature);
     if (pField != NULL)
         return pField;

     /*
      * See if it's in any of our interfaces.  We don't check interfaces
      * inherited from the superclass yet.
      */
     int i = 0;
     if (clazz->super != NULL) {
         assert(clazz->iftableCount >= clazz->super->iftableCount);
         i = clazz->super->iftableCount;
     }
     for ( ; i < clazz->iftableCount; i++) {
         ClassObject* iface = clazz->iftable[i].clazz;
         pField = (Field*) dvmFindStaticField(iface, fieldName, signature);
         if (pField != NULL)
             return pField;
     }

     if (clazz->super != NULL)
         return dvmFindFieldHier(clazz->super, fieldName, signature);
     else
         return NULL;
 }


 /*
  * Compare the given name, return type, and argument types with the contents
  * of the given method. This returns 0 if they are equal and non-zero if not.
  */
 static inline int compareMethodHelper(Method* method, const char* methodName,
     const char* returnType, size_t argCount, const char** argTypes)
 {
     DexParameterIterator iterator;
     const DexProto* proto;

     if (strcmp(methodName, method->name) != 0) {
         return 1;
     }

     proto = &method->prototype;

     if (strcmp(returnType, dexProtoGetReturnType(proto)) != 0) {
         return 1;
     }

     if (dexProtoGetParameterCount(proto) != argCount) {
         return 1;
     }

     dexParameterIteratorInit(&iterator, proto);

     for (/*argCount*/; argCount != 0; argCount--, argTypes++) {
         const char* argType = *argTypes;
         const char* paramType = dexParameterIteratorNextDescriptor(&iterator);

         if (paramType == NULL) {
             /* Param list ended early; no match */
             break;
         } else if (strcmp(argType, paramType) != 0) {
             /* Types aren't the same; no match. */
             break;
         }
     }

     if (argCount == 0) {
         /* We ran through all the given arguments... */
         if (dexParameterIteratorNextDescriptor(&iterator) == NULL) {
             /* ...and through all the method's arguments; success! */
             return 0;
         }
     }

     return 1;
 }

 /*
  * Get the count of arguments in the given method descriptor string,
  * and also find a pointer to the return type.
  */
 static inline size_t countArgsAndFindReturnType(const char* descriptor,
     const char** pReturnType)
 {
     size_t count = 0;
     bool bogus = false;
     bool done = false;

     assert(*descriptor == '(');
     descriptor++;

     while (!done) {
         switch (*descriptor) {
             case 'B': case 'C': case 'D': case 'F':
             case 'I': case 'J': case 'S': case 'Z': {
                 count++;
                 break;
             }
             case '[': {
                 do {
                     descriptor++;
                 } while (*descriptor == '[');
                 /*
                  * Don't increment count, as it will be taken care of
                  * by the next iteration. Also, decrement descriptor
                  * to compensate for the increment below the switch.
                  */
                 descriptor--;
                 break;
             }
             case 'L': {
                 do {
                     descriptor++;
                 } while ((*descriptor != ';') && (*descriptor != '\0'));
                 count++;
                 if (*descriptor == '\0') {
                     /* Bogus descriptor. */
                     done = true;
                     bogus = true;
                 }
                 break;
             }
             case ')': {
                 /*
                  * Note: The loop will exit after incrementing descriptor
                  * one more time, so it then points at the return type.
                  */
                 done = true;
                 break;
             }
             default: {
                 /* Bogus descriptor. */
                 done = true;
                 bogus = true;
                 break;
             }
         }

         descriptor++;
     }

     if (bogus) {
         *pReturnType = NULL;
         return 0;
     }

     *pReturnType = descriptor;
     return count;
 }

 /*
  * Copy the argument types into the given array using the given buffer
  * for the contents.
  */
 static inline void copyTypes(char* buffer, const char** argTypes,
     size_t argCount, const char* descriptor)
 {
     size_t i;
     char c;

     /* Skip the '('. */
     descriptor++;

     for (i = 0; i < argCount; i++) {
         argTypes[i] = buffer;

         /* Copy all the array markers and one extra character. */
         do {
             c = *(descriptor++);
             *(buffer++) = c;
         } while (c == '[');

         if (c == 'L') {
             /* Copy the rest of a class name. */
             do {
                 c = *(descriptor++);
                 *(buffer++) = c;
             } while (c != ';');
         }

         *(buffer++) = '\0';
     }
 }

 /*
  * Look for a match in the given class. Returns the match if found
  * or NULL if not.
  */
 static Method* findMethodInListByDescriptor(const ClassObject* clazz,
     bool findVirtual, bool isHier, const char* name, const char* descriptor)
 {
     const char* returnType;
     size_t argCount = countArgsAndFindReturnType(descriptor, &returnType);

     if (returnType == NULL) {
         LOGW("Bogus method descriptor: %s\n", descriptor);
         return NULL;
     }

     /*
      * Make buffer big enough for all the argument type characters and
      * one '\0' per argument. The "- 2" is because "returnType -
      * descriptor" includes two parens.
      */
     char buffer[argCount + (returnType - descriptor) - 2];
     const char* argTypes[argCount];

     copyTypes(buffer, argTypes, argCount, descriptor);

     while (clazz != NULL) {
         Method* methods;
         size_t methodCount;
         size_t i;

         if (findVirtual) {
             methods = clazz->virtualMethods;
             methodCount = clazz->virtualMethodCount;
         } else {
             methods = clazz->directMethods;
             methodCount = clazz->directMethodCount;
         }

         for (i = 0; i < methodCount; i++) {
             Method* method = &methods[i];
             if (compareMethodHelper(method, name, returnType, argCount,
                             argTypes) == 0) {
                 return method;
             }
         }

         if (! isHier) {
             break;
         }

         clazz = clazz->super;
     }

     return NULL;
 }

 /*
  * Look for a match in the given clazz. Returns the match if found
  * or NULL if not.
  *
  * "wantedType" should be METHOD_VIRTUAL or METHOD_DIRECT to indicate the
  * list to search through.  If the match can come from either list, use
  * MATCH_UNKNOWN to scan both.
  */
 static Method* findMethodInListByProto(const ClassObject* clazz,
     MethodType wantedType, bool isHier, const char* name, const DexProto* proto)
 {
     while (clazz != NULL) {
         int i;

         /*
          * Check the virtual and/or direct method lists.
          */
         if (wantedType == METHOD_VIRTUAL || wantedType == METHOD_UNKNOWN) {
             for (i = 0; i < clazz->virtualMethodCount; i++) {
                 Method* method = &clazz->virtualMethods[i];
                 if (dvmCompareNameProtoAndMethod(name, proto, method) == 0) {
                     return method;
                 }
             }
         }
         if (wantedType == METHOD_DIRECT || wantedType == METHOD_UNKNOWN) {
             for (i = 0; i < clazz->directMethodCount; i++) {
                 Method* method = &clazz->directMethods[i];
                 if (dvmCompareNameProtoAndMethod(name, proto, method) == 0) {
                     return method;
                 }
             }
         }

         if (! isHier) {
             break;
         }

         clazz = clazz->super;
     }

     return NULL;
 }

 /*
  * Find a "virtual" method in a class.
  *
  * Does not chase into the superclass.
  *
  * Returns NULL if the method can't be found.  (Does not throw an exception.)
  */
 Method* dvmFindVirtualMethodByDescriptor(const ClassObject* clazz,
     const char* methodName, const char* descriptor)
 {
     return findMethodInListByDescriptor(clazz, true, false,
             methodName, descriptor);

     // TODO? - throw IncompatibleClassChangeError if a match is
     // found in the directMethods list, rather than NotFoundError.
     // Note we could have been called by dvmFindVirtualMethodHier though.
 }


 /*
  * Find a "virtual" method in a class, knowing only the name.  This is
  * only useful in limited circumstances, e.g. when searching for a member
  * of an annotation class.
  *
  * Does not chase into the superclass.
  *
  * Returns NULL if the method can't be found.  (Does not throw an exception.)
  */
 Method* dvmFindVirtualMethodByName(const ClassObject* clazz,
     const char* methodName)
 {
     Method* methods = clazz->virtualMethods;
     int methodCount = clazz->virtualMethodCount;
     int i;

     for (i = 0; i < methodCount; i++) {
         if (strcmp(methods[i].name, methodName) == 0)
             return &methods[i];
     }

     return NULL;
 }

 /*
  * Find a "virtual" method in a class.
  *
  * Does not chase into the superclass.
  *
  * Returns NULL if the method can't be found.  (Does not throw an exception.)
  */
 Method* dvmFindVirtualMethod(const ClassObject* clazz, const char* methodName,
     const DexProto* proto)
 {
     return findMethodInListByProto(clazz, METHOD_VIRTUAL, false, methodName,
             proto);
 }

 /*
  * Find a "virtual" method in a class.  If we don't find it, try the
  * superclass.
  *
  * Returns NULL if the method can't be found.  (Does not throw an exception.)
  */
 Method* dvmFindVirtualMethodHierByDescriptor(const ClassObject* clazz,
     const char* methodName, const char* descriptor)
 {
     return findMethodInListByDescriptor(clazz, true, true,
             methodName, descriptor);
 }

 /*
  * Find a "virtual" method in a class.  If we don't find it, try the
  * superclass.
  *
  * Returns NULL if the method can't be found.  (Does not throw an exception.)
  */
 Method* dvmFindVirtualMethodHier(const ClassObject* clazz,
     const char* methodName, const DexProto* proto)
 {
     return findMethodInListByProto(clazz, METHOD_VIRTUAL, true, methodName,
             proto);
 }

 /*
  * Find a "direct" method (static, private, or "<*init>").
  *
  * Returns NULL if the method can't be found.  (Does not throw an exception.)
  */
 Method* dvmFindDirectMethodByDescriptor(const ClassObject* clazz,
     const char* methodName, const char* descriptor)
 {
     return findMethodInListByDescriptor(clazz, false, false,
             methodName, descriptor);
 }

 /*
  * Find a "direct" method.  If we don't find it, try the superclass.  This
  * is only appropriate for static methods, but will work for all direct
  * methods.
  *
  * Returns NULL if the method can't be found.  (Does not throw an exception.)
  */
 Method* dvmFindDirectMethodHierByDescriptor(const ClassObject* clazz,
     const char* methodName, const char* descriptor)
 {
     return findMethodInListByDescriptor(clazz, false, true,
             methodName, descriptor);
 }

 /*
  * Find a "direct" method (static or "<*init>").
  *
  * Returns NULL if the method can't be found.  (Does not throw an exception.)
  */
 Method* dvmFindDirectMethod(const ClassObject* clazz, const char* methodName,
     const DexProto* proto)
 {
     return findMethodInListByProto(clazz, METHOD_DIRECT, false, methodName,
             proto);
 }

 /*
  * Find a "direct" method in a class.  If we don't find it, try the
  * superclass.
  *
  * Returns NULL if the method can't be found.  (Does not throw an exception.)
  */
 Method* dvmFindDirectMethodHier(const ClassObject* clazz,
     const char* methodName, const DexProto* proto)
 {
     return findMethodInListByProto(clazz, METHOD_DIRECT, true, methodName,
             proto);
 }

 /*
  * Find a virtual or static method in a class.  If we don't find it, try the
  * superclass.  This is compatible with the VM spec (v2 5.4.3.3) method
  * search order, but it stops short of scanning through interfaces (which
  * should be done after this function completes).
  *
  * In most cases we know that we're looking for either a static or an
  * instance field and there's no value in searching through both types.
  * During verification we need to recognize and reject certain unusual
  * situations, and we won't see them unless we walk the lists this way.
  *
  * Returns NULL if the method can't be found.  (Does not throw an exception.)
  */
 Method* dvmFindMethodHier(const ClassObject* clazz, const char* methodName,
     const DexProto* proto)
 {
     return findMethodInListByProto(clazz, METHOD_UNKNOWN, true, methodName,
             proto);
 }


 /*
  * We have a method pointer for a method in "clazz", but it might be
  * pointing to a method in a derived class.  We want to find the actual entry
  * from the class' vtable.  If "clazz" is an interface, we have to do a
  * little more digging.
  *
  * (This is used for reflection and JNI "call method" calls.)
  */
 const Method* dvmGetVirtualizedMethod(const ClassObject* clazz,
     const Method* meth)
 {
     Method* actualMeth;
     int methodIndex;

     assert(!dvmIsStaticMethod(meth));

     if (dvmIsPrivateMethod(meth))   // no vtable entry for these
         return meth;

     /*
      * If the method was declared in an interface, we need to scan through
      * the class' list of interfaces for it, and find the vtable index
      * from that.
      *
      * TODO: use the interface cache.
      */
     if (dvmIsInterfaceClass(meth->clazz)) {
         int i;

         for (i = 0; i < clazz->iftableCount; i++) {
             if (clazz->iftable[i].clazz == meth->clazz)
                 break;
         }
         if (i == clazz->iftableCount) {
             dvmThrowException("Ljava/lang/IncompatibleClassChangeError;",
                 "invoking method from interface not implemented by class");
             return NULL;
         }

         methodIndex = clazz->iftable[i].methodIndexArray[meth->methodIndex];
     } else {
         methodIndex = meth->methodIndex;
     }

     assert(methodIndex >= 0 && methodIndex < clazz->vtableCount);
     actualMeth = clazz->vtable[methodIndex];

     /*
      * Make sure there's code to execute.
      */
     if (dvmIsAbstractMethod(actualMeth)) {
         dvmThrowException("Ljava/lang/AbstractMethodError;", NULL);
         return NULL;
     }
     assert(!dvmIsMirandaMethod(actualMeth));

     return actualMeth;
 }

 /*
  * Get the source file for a method.
  */
 const char* dvmGetMethodSourceFile(const Method* meth)
 {
     /*
      * TODO: A method's debug info can override the default source
      * file for a class, so we should account for that possibility
      * here.
      */
     return meth->clazz->sourceFile;
 }

 /*
  * Dump some information about an object.
  */
 void dvmDumpObject(const Object* obj)
 {
     ClassObject* clazz;
     int i;

     if (obj == NULL || obj->clazz == NULL) {
         LOGW("Null or malformed object not dumped");
         return;
     }

     clazz = obj->clazz;
     LOGD("----- Object dump: %p (%s, %d bytes) -----",
         obj, clazz->descriptor, (int) clazz->objectSize);
     //printHexDump(obj, clazz->objectSize);
     LOGD("  Fields:");
     while (clazz != NULL) {
         LOGD("    -- %s", clazz->descriptor);
         for (i = 0; i < clazz->ifieldCount; i++) {
             const InstField* pField = &clazz->ifields[i];
             char type = pField->field.signature[0];

             if (type == 'F' || type == 'D') {
                 double dval;

                 if (type == 'F')
                     dval = dvmGetFieldFloat(obj, pField->byteOffset);
                 else
                     dval = dvmGetFieldDouble(obj, pField->byteOffset);

                 LOGD("    %2d: '%s' '%s' af=%04x off=%d %.3f", i,
                     pField->field.name, pField->field.signature,
                     pField->field.accessFlags, pField->byteOffset, dval);
             } else {
                 u8 lval;

                 if (type == 'J')
                     lval = dvmGetFieldLong(obj, pField->byteOffset);
                 else if (type == 'Z')
                     lval = dvmGetFieldBoolean(obj, pField->byteOffset);
                 else
                     lval = dvmGetFieldInt(obj, pField->byteOffset);

                 LOGD("    %2d: '%s' '%s' af=%04x off=%d 0x%08llx", i,
                     pField->field.name, pField->field.signature,
                     pField->field.accessFlags, pField->byteOffset, lval);
             }
         }

         clazz = clazz->super;
     }
     if (obj->clazz == gDvm.classJavaLangClass) {
         LOGD("  Static fields:");
         const StaticField* sfields = &((ClassObject *)obj)->sfields[0];
         for (i = 0; i < ((ClassObject *)obj)->sfieldCount; ++i) {
             const StaticField* pField = &sfields[i];
             size_t byteOffset = (size_t)pField - (size_t)sfields;
             char type = pField->field.signature[0];

             if (type == 'F' || type == 'D') {
                 double dval;

                 if (type == 'F')
                     dval = pField->value.f;
                 else
                     dval = pField->value.d;

                 LOGD("    %2d: '%s' '%s' af=%04x off=%zd %.3f", i,
                      pField->field.name, pField->field.signature,
                      pField->field.accessFlags, byteOffset, dval);
             } else {
                 u8 lval;

                 if (type == 'J')
                     lval = pField->value.j;
                 else if (type == 'Z')
                     lval = pField->value.z;
                 else
                     lval = pField->value.i;

                 LOGD("    %2d: '%s' '%s' af=%04x off=%zd 0x%08llx", i,
                      pField->field.name, pField->field.signature,
                      pField->field.accessFlags, byteOffset, lval);
             }
         }
     }
 }
	/*
	* 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.
	*/

	/*
	* Operations on an Object.
	*/
	#include "Dalvik.h"

	/*
	* Find a matching field, in the current class only.
	*
	* Returns NULL if the field can't be found. (Does not throw an exception.)
	*/
	InstField* dvmFindInstanceField(const ClassObject* clazz,
	const char* fieldName, const char* signature)
	{
	InstField* pField;
	int i;

	assert(clazz != NULL);

	/*
	* Find a field with a matching name and signature. The Java programming
	* language does not allow you to have two fields with the same name
	* and different types, but the Java VM spec does allow it, so we can't
	* bail out early when the name matches.
	*/
	pField = clazz->ifields;
	for (i = 0; i < clazz->ifieldCount; i++, pField++) {
	if (strcmp(fieldName, pField->field.name) == 0 &&
	strcmp(signature, pField->field.signature) == 0)
	{
	return pField;
	}
	}

	return NULL;
	}

	/*
	* Find a matching field, in this class or a superclass.
	*
	* Searching through interfaces isn't necessary, because interface fields
	* are inherently public/static/final.
	*
	* Returns NULL if the field can't be found. (Does not throw an exception.)
	*/
	InstField* dvmFindInstanceFieldHier(const ClassObject* clazz,
	const char* fieldName, const char* signature)
	{
	InstField* pField;

	/*
	* Search for a match in the current class.
	*/
	pField = dvmFindInstanceField(clazz, fieldName, signature);
	if (pField != NULL)
	return pField;

	if (clazz->super != NULL)
	return dvmFindInstanceFieldHier(clazz->super, fieldName, signature);
	else
	return NULL;
	}


	/*
	* Find a matching field, in this class or an interface.
	*
	* Returns NULL if the field can't be found. (Does not throw an exception.)
	*/
	StaticField* dvmFindStaticField(const ClassObject* clazz,
	const char* fieldName, const char* signature)
	{
	const StaticField* pField;
	int i;

	assert(clazz != NULL);

	/*
	* Find a field with a matching name and signature. As with instance
	* fields, the VM allows you to have two fields with the same name so
	* long as they have different types.
	*/
	pField = &clazz->sfields[0];
	for (i = 0; i < clazz->sfieldCount; i++, pField++) {
	if (strcmp(fieldName, pField->field.name) == 0 &&
	strcmp(signature, pField->field.signature) == 0)
	{
	return (StaticField*) pField;
	}
	}

	return NULL;
	}

	/*
	* Find a matching field, in this class or a superclass.
	*
	* Returns NULL if the field can't be found. (Does not throw an exception.)
	*/
	StaticField* dvmFindStaticFieldHier(const ClassObject* clazz,
	const char* fieldName, const char* signature)
	{
	StaticField* pField;

	/*
	* Search for a match in the current class.
	*/
	pField = dvmFindStaticField(clazz, fieldName, signature);
	if (pField != NULL)
	return pField;

	/*
	* See if it's in any of our interfaces. We don't check interfaces
	* inherited from the superclass yet.
	*
	* (Note the set may have been stripped down because of redundancy with
	* the superclass; see notes in createIftable.)
	*/
	int i = 0;
	if (clazz->super != NULL) {
	assert(clazz->iftableCount >= clazz->super->iftableCount);
	i = clazz->super->iftableCount;
	}
	for ( ; i < clazz->iftableCount; i++) {
	ClassObject* iface = clazz->iftable[i].clazz;
	pField = dvmFindStaticField(iface, fieldName, signature);
	if (pField != NULL)
	return pField;
	}

	if (clazz->super != NULL)
	return dvmFindStaticFieldHier(clazz->super, fieldName, signature);
	else
	return NULL;
	}

	/*
	* Find a matching field, in this class or a superclass.
	*
	* We scan both the static and instance field lists in the class. If it's
	* not found there, we check the direct interfaces, and then recursively
	* scan the superclasses. This is the order prescribed in the VM spec
	* (v2 5.4.3.2).
	*
	* In most cases we know that we're looking for either a static or an
	* instance field and there's no value in searching through both types.
	* During verification we need to recognize and reject certain unusual
	* situations, and we won't see them unless we walk the lists this way.
	*/
	Field* dvmFindFieldHier(const ClassObject* clazz, const char* fieldName,
	const char* signature)
	{
	Field* pField;

	/*
	* Search for a match in the current class. Which set we scan first
	* doesn't really matter.
	*/
	pField = (Field*) dvmFindStaticField(clazz, fieldName, signature);
	if (pField != NULL)
	return pField;
	pField = (Field*) dvmFindInstanceField(clazz, fieldName, signature);
	if (pField != NULL)
	return pField;

	/*
	* See if it's in any of our interfaces. We don't check interfaces
	* inherited from the superclass yet.
	*/
	int i = 0;
	if (clazz->super != NULL) {
	assert(clazz->iftableCount >= clazz->super->iftableCount);
	i = clazz->super->iftableCount;
	}
	for ( ; i < clazz->iftableCount; i++) {
	ClassObject* iface = clazz->iftable[i].clazz;
	pField = (Field*) dvmFindStaticField(iface, fieldName, signature);
	if (pField != NULL)
	return pField;
	}

	if (clazz->super != NULL)
	return dvmFindFieldHier(clazz->super, fieldName, signature);
	else
	return NULL;
	}


	/*
	* Compare the given name, return type, and argument types with the contents
	* of the given method. This returns 0 if they are equal and non-zero if not.
	*/
	static inline int compareMethodHelper(Method* method, const char* methodName,
	const char* returnType, size_t argCount, const char** argTypes)
	{
	DexParameterIterator iterator;
	const DexProto* proto;

	if (strcmp(methodName, method->name) != 0) {
	return 1;
	}

	proto = &method->prototype;

	if (strcmp(returnType, dexProtoGetReturnType(proto)) != 0) {
	return 1;
	}

	if (dexProtoGetParameterCount(proto) != argCount) {
	return 1;
	}

	dexParameterIteratorInit(&iterator, proto);

	for (/argCount/; argCount != 0; argCount--, argTypes++) {
	const char* argType = *argTypes;
	const char* paramType = dexParameterIteratorNextDescriptor(&iterator);

	if (paramType == NULL) {
	/* Param list ended early; no match */
	break;
	} else if (strcmp(argType, paramType) != 0) {
	/* Types aren't the same; no match. */
	break;
	}
	}

	if (argCount == 0) {
	/* We ran through all the given arguments... */
	if (dexParameterIteratorNextDescriptor(&iterator) == NULL) {
	/* ...and through all the method's arguments; success! */
	return 0;
	}
	}

	return 1;
	}

	/*
	* Get the count of arguments in the given method descriptor string,
	* and also find a pointer to the return type.
	*/
	static inline size_t countArgsAndFindReturnType(const char* descriptor,
	const char** pReturnType)
	{
	size_t count = 0;
	bool bogus = false;
	bool done = false;

	assert(*descriptor == '(');
	descriptor++;

	while (!done) {
	switch (*descriptor) {
	case 'B': case 'C': case 'D': case 'F':
	case 'I': case 'J': case 'S': case 'Z': {
	count++;
	break;
	}
	case '[': {
	do {
	descriptor++;
	} while (*descriptor == '[');
	/*
	* Don't increment count, as it will be taken care of
	* by the next iteration. Also, decrement descriptor
	* to compensate for the increment below the switch.
	*/
	descriptor--;
	break;
	}
	case 'L': {
	do {
	descriptor++;
	} while ((descriptor != ';') && (descriptor != '\0'));
	count++;
	if (*descriptor == '\0') {
	/* Bogus descriptor. */
	done = true;
	bogus = true;
	}
	break;
	}
	case ')': {
	/*
	* Note: The loop will exit after incrementing descriptor
	* one more time, so it then points at the return type.
	*/
	done = true;
	break;
	}
	default: {
	/* Bogus descriptor. */
	done = true;
	bogus = true;
	break;
	}
	}

	descriptor++;
	}

	if (bogus) {
	*pReturnType = NULL;
	return 0;
	}

	*pReturnType = descriptor;
	return count;
	}

	/*
	* Copy the argument types into the given array using the given buffer
	* for the contents.
	*/
	static inline void copyTypes(char* buffer, const char** argTypes,
	size_t argCount, const char* descriptor)
	{
	size_t i;
	char c;

	/* Skip the '('. */
	descriptor++;

	for (i = 0; i < argCount; i++) {
	argTypes[i] = buffer;

	/* Copy all the array markers and one extra character. */
	do {
	c = *(descriptor++);
	*(buffer++) = c;
	} while (c == '[');

	if (c == 'L') {
	/* Copy the rest of a class name. */
	do {
	c = *(descriptor++);
	*(buffer++) = c;
	} while (c != ';');
	}

	*(buffer++) = '\0';
	}
	}

	/*
	* Look for a match in the given class. Returns the match if found
	* or NULL if not.
	*/
	static Method* findMethodInListByDescriptor(const ClassObject* clazz,
	bool findVirtual, bool isHier, const char* name, const char* descriptor)
	{
	const char* returnType;
	size_t argCount = countArgsAndFindReturnType(descriptor, &returnType);

	if (returnType == NULL) {
	LOGW("Bogus method descriptor: %s\n", descriptor);
	return NULL;
	}

	/*
	* Make buffer big enough for all the argument type characters and
	* one '\0' per argument. The "- 2" is because "returnType -
	* descriptor" includes two parens.
	*/
	char buffer[argCount + (returnType - descriptor) - 2];
	const char* argTypes[argCount];

	copyTypes(buffer, argTypes, argCount, descriptor);

	while (clazz != NULL) {
	Method* methods;
	size_t methodCount;
	size_t i;

	if (findVirtual) {
	methods = clazz->virtualMethods;
	methodCount = clazz->virtualMethodCount;
	} else {
	methods = clazz->directMethods;
	methodCount = clazz->directMethodCount;
	}

	for (i = 0; i < methodCount; i++) {
	Method* method = &methods[i];
	if (compareMethodHelper(method, name, returnType, argCount,
	argTypes) == 0) {
	return method;
	}
	}

	if (! isHier) {
	break;
	}

	clazz = clazz->super;
	}

	return NULL;
	}

	/*
	* Look for a match in the given clazz. Returns the match if found
	* or NULL if not.
	*
	* "wantedType" should be METHOD_VIRTUAL or METHOD_DIRECT to indicate the
	* list to search through. If the match can come from either list, use
	* MATCH_UNKNOWN to scan both.
	*/
	static Method* findMethodInListByProto(const ClassObject* clazz,
	MethodType wantedType, bool isHier, const char* name, const DexProto* proto)
	{
	while (clazz != NULL) {
	int i;

	/*
	* Check the virtual and/or direct method lists.
	*/
	if (wantedType == METHOD_VIRTUAL \|\| wantedType == METHOD_UNKNOWN) {
	for (i = 0; i < clazz->virtualMethodCount; i++) {
	Method* method = &clazz->virtualMethods[i];
	if (dvmCompareNameProtoAndMethod(name, proto, method) == 0) {
	return method;
	}
	}
	}
	if (wantedType == METHOD_DIRECT \|\| wantedType == METHOD_UNKNOWN) {
	for (i = 0; i < clazz->directMethodCount; i++) {
	Method* method = &clazz->directMethods[i];
	if (dvmCompareNameProtoAndMethod(name, proto, method) == 0) {
	return method;
	}
	}
	}

	if (! isHier) {
	break;
	}

	clazz = clazz->super;
	}

	return NULL;
	}

	/*
	* Find a "virtual" method in a class.
	*
	* Does not chase into the superclass.
	*
	* Returns NULL if the method can't be found. (Does not throw an exception.)
	*/
	Method* dvmFindVirtualMethodByDescriptor(const ClassObject* clazz,
	const char* methodName, const char* descriptor)
	{
	return findMethodInListByDescriptor(clazz, true, false,
	methodName, descriptor);

	// TODO? - throw IncompatibleClassChangeError if a match is
	// found in the directMethods list, rather than NotFoundError.
	// Note we could have been called by dvmFindVirtualMethodHier though.
	}


	/*
	* Find a "virtual" method in a class, knowing only the name. This is
	* only useful in limited circumstances, e.g. when searching for a member
	* of an annotation class.
	*
	* Does not chase into the superclass.
	*
	* Returns NULL if the method can't be found. (Does not throw an exception.)
	*/
	Method* dvmFindVirtualMethodByName(const ClassObject* clazz,
	const char* methodName)
	{
	Method* methods = clazz->virtualMethods;
	int methodCount = clazz->virtualMethodCount;
	int i;

	for (i = 0; i < methodCount; i++) {
	if (strcmp(methods[i].name, methodName) == 0)
	return &methods[i];
	}

	return NULL;
	}

	/*
	* Find a "virtual" method in a class.
	*
	* Does not chase into the superclass.
	*
	* Returns NULL if the method can't be found. (Does not throw an exception.)
	*/
	Method* dvmFindVirtualMethod(const ClassObject* clazz, const char* methodName,
	const DexProto* proto)
	{
	return findMethodInListByProto(clazz, METHOD_VIRTUAL, false, methodName,
	proto);
	}

	/*
	* Find a "virtual" method in a class. If we don't find it, try the
	* superclass.
	*
	* Returns NULL if the method can't be found. (Does not throw an exception.)
	*/
	Method* dvmFindVirtualMethodHierByDescriptor(const ClassObject* clazz,
	const char* methodName, const char* descriptor)
	{
	return findMethodInListByDescriptor(clazz, true, true,
	methodName, descriptor);
	}

	/*
	* Find a "virtual" method in a class. If we don't find it, try the
	* superclass.
	*
	* Returns NULL if the method can't be found. (Does not throw an exception.)
	*/
	Method* dvmFindVirtualMethodHier(const ClassObject* clazz,
	const char* methodName, const DexProto* proto)
	{
	return findMethodInListByProto(clazz, METHOD_VIRTUAL, true, methodName,
	proto);
	}

	/*
	* Find a "direct" method (static, private, or "<*init>").
	*
	* Returns NULL if the method can't be found. (Does not throw an exception.)
	*/
	Method* dvmFindDirectMethodByDescriptor(const ClassObject* clazz,
	const char* methodName, const char* descriptor)
	{
	return findMethodInListByDescriptor(clazz, false, false,
	methodName, descriptor);
	}

	/*
	* Find a "direct" method. If we don't find it, try the superclass. This
	* is only appropriate for static methods, but will work for all direct
	* methods.
	*
	* Returns NULL if the method can't be found. (Does not throw an exception.)
	*/
	Method* dvmFindDirectMethodHierByDescriptor(const ClassObject* clazz,
	const char* methodName, const char* descriptor)
	{
	return findMethodInListByDescriptor(clazz, false, true,
	methodName, descriptor);
	}

	/*
	* Find a "direct" method (static or "<*init>").
	*
	* Returns NULL if the method can't be found. (Does not throw an exception.)
	*/
	Method* dvmFindDirectMethod(const ClassObject* clazz, const char* methodName,
	const DexProto* proto)
	{
	return findMethodInListByProto(clazz, METHOD_DIRECT, false, methodName,
	proto);
	}

	/*
	* Find a "direct" method in a class. If we don't find it, try the
	* superclass.
	*
	* Returns NULL if the method can't be found. (Does not throw an exception.)
	*/
	Method* dvmFindDirectMethodHier(const ClassObject* clazz,
	const char* methodName, const DexProto* proto)
	{
	return findMethodInListByProto(clazz, METHOD_DIRECT, true, methodName,
	proto);
	}

	/*
	* Find a virtual or static method in a class. If we don't find it, try the
	* superclass. This is compatible with the VM spec (v2 5.4.3.3) method
	* search order, but it stops short of scanning through interfaces (which
	* should be done after this function completes).
	*
	* In most cases we know that we're looking for either a static or an
	* instance field and there's no value in searching through both types.
	* During verification we need to recognize and reject certain unusual
	* situations, and we won't see them unless we walk the lists this way.
	*
	* Returns NULL if the method can't be found. (Does not throw an exception.)
	*/
	Method* dvmFindMethodHier(const ClassObject* clazz, const char* methodName,
	const DexProto* proto)
	{
	return findMethodInListByProto(clazz, METHOD_UNKNOWN, true, methodName,
	proto);
	}


	/*
	* We have a method pointer for a method in "clazz", but it might be
	* pointing to a method in a derived class. We want to find the actual entry
	* from the class' vtable. If "clazz" is an interface, we have to do a
	* little more digging.
	*
	* (This is used for reflection and JNI "call method" calls.)
	*/
	const Method* dvmGetVirtualizedMethod(const ClassObject* clazz,
	const Method* meth)
	{
	Method* actualMeth;
	int methodIndex;

	assert(!dvmIsStaticMethod(meth));

	if (dvmIsPrivateMethod(meth)) // no vtable entry for these
	return meth;

	/*
	* If the method was declared in an interface, we need to scan through
	* the class' list of interfaces for it, and find the vtable index
	* from that.
	*
	* TODO: use the interface cache.
	*/
	if (dvmIsInterfaceClass(meth->clazz)) {
	int i;

	for (i = 0; i < clazz->iftableCount; i++) {
	if (clazz->iftable[i].clazz == meth->clazz)
	break;
	}
	if (i == clazz->iftableCount) {
	dvmThrowException("Ljava/lang/IncompatibleClassChangeError;",
	"invoking method from interface not implemented by class");
	return NULL;
	}

	methodIndex = clazz->iftable[i].methodIndexArray[meth->methodIndex];
	} else {
	methodIndex = meth->methodIndex;
	}

	assert(methodIndex >= 0 && methodIndex < clazz->vtableCount);
	actualMeth = clazz->vtable[methodIndex];

	/*
	* Make sure there's code to execute.
	*/
	if (dvmIsAbstractMethod(actualMeth)) {
	dvmThrowException("Ljava/lang/AbstractMethodError;", NULL);
	return NULL;
	}
	assert(!dvmIsMirandaMethod(actualMeth));

	return actualMeth;
	}

	/*
	* Get the source file for a method.
	*/
	const char* dvmGetMethodSourceFile(const Method* meth)
	{
	/*
	* TODO: A method's debug info can override the default source
	* file for a class, so we should account for that possibility
	* here.
	*/
	return meth->clazz->sourceFile;
	}

	/*
	* Dump some information about an object.
	*/
	void dvmDumpObject(const Object* obj)
	{
	ClassObject* clazz;
	int i;

	if (obj == NULL \|\| obj->clazz == NULL) {
	LOGW("Null or malformed object not dumped");
	return;
	}

	clazz = obj->clazz;
	LOGD("----- Object dump: %p (%s, %d bytes) -----",
	obj, clazz->descriptor, (int) clazz->objectSize);
	//printHexDump(obj, clazz->objectSize);
	LOGD(" Fields:");
	while (clazz != NULL) {
	LOGD(" -- %s", clazz->descriptor);
	for (i = 0; i < clazz->ifieldCount; i++) {
	const InstField* pField = &clazz->ifields[i];
	char type = pField->field.signature[0];

	if (type == 'F' \|\| type == 'D') {
	double dval;

	if (type == 'F')
	dval = dvmGetFieldFloat(obj, pField->byteOffset);
	else
	dval = dvmGetFieldDouble(obj, pField->byteOffset);

	LOGD(" %2d: '%s' '%s' af=%04x off=%d %.3f", i,
	pField->field.name, pField->field.signature,
	pField->field.accessFlags, pField->byteOffset, dval);
	} else {
	u8 lval;

	if (type == 'J')
	lval = dvmGetFieldLong(obj, pField->byteOffset);
	else if (type == 'Z')
	lval = dvmGetFieldBoolean(obj, pField->byteOffset);
	else
	lval = dvmGetFieldInt(obj, pField->byteOffset);

	LOGD(" %2d: '%s' '%s' af=%04x off=%d 0x%08llx", i,
	pField->field.name, pField->field.signature,
	pField->field.accessFlags, pField->byteOffset, lval);
	}
	}

	clazz = clazz->super;
	}
	if (obj->clazz == gDvm.classJavaLangClass) {
	LOGD(" Static fields:");
	const StaticField* sfields = &((ClassObject *)obj)->sfields[0];
	for (i = 0; i < ((ClassObject *)obj)->sfieldCount; ++i) {
	const StaticField* pField = &sfields[i];
	size_t byteOffset = (size_t)pField - (size_t)sfields;
	char type = pField->field.signature[0];

	if (type == 'F' \|\| type == 'D') {
	double dval;

	if (type == 'F')
	dval = pField->value.f;
	else
	dval = pField->value.d;

	LOGD(" %2d: '%s' '%s' af=%04x off=%zd %.3f", i,
	pField->field.name, pField->field.signature,
	pField->field.accessFlags, byteOffset, dval);
	} else {
	u8 lval;

	if (type == 'J')
	lval = pField->value.j;
	else if (type == 'Z')
	lval = pField->value.z;
	else
	lval = pField->value.i;

	LOGD(" %2d: '%s' '%s' af=%04x off=%zd 0x%08llx", i,
	pField->field.name, pField->field.signature,
	pField->field.accessFlags, byteOffset, lval);
	}
	}
	}
	}