Home | History | Annotate | Download | only in reflect
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 /*
     17  * Annotations.
     18  *
     19  * We're not expecting to make much use of runtime annotations, so speed vs.
     20  * space choices are weighted heavily toward small size.
     21  *
     22  * It would have been nice to treat "system" annotations in the same way
     23  * we do "real" annotations, but that doesn't work.  The chief difficulty
     24  * is that some of them have member types that are not legal in annotations,
     25  * such as Method and Annotation.  Another source of pain comes from the
     26  * AnnotationDefault annotation, which by virtue of being an annotation
     27  * could itself have default values, requiring some additional checks to
     28  * prevent recursion.
     29  *
     30  * It's simpler, and more efficient, to handle the system annotations
     31  * entirely inside the VM.  There are empty classes defined for the system
     32  * annotation types, but their only purpose is to allow the system
     33  * annotations to share name space with standard annotations.
     34  */
     35 #include "Dalvik.h"
     36 
     37 // fwd
     38 static Object* processEncodedAnnotation(const ClassObject* clazz,\
     39     const u1** pPtr);
     40 static bool skipEncodedAnnotation(const ClassObject* clazz, const u1** pPtr);
     41 
     42 /*
     43  * System annotation descriptors.
     44  */
     45 static const char* kDescrAnnotationDefault
     46                                     = "Ldalvik/annotation/AnnotationDefault;";
     47 static const char* kDescrEnclosingClass
     48                                     = "Ldalvik/annotation/EnclosingClass;";
     49 static const char* kDescrEnclosingMethod
     50                                     = "Ldalvik/annotation/EnclosingMethod;";
     51 static const char* kDescrInnerClass = "Ldalvik/annotation/InnerClass;";
     52 static const char* kDescrMemberClasses
     53                                     = "Ldalvik/annotation/MemberClasses;";
     54 static const char* kDescrSignature  = "Ldalvik/annotation/Signature;";
     55 static const char* kDescrThrows     = "Ldalvik/annotation/Throws;";
     56 
     57 /*
     58  * Read an unsigned LEB128 value from a buffer.  Advances "pBuf".
     59  */
     60 static u4 readUleb128(const u1** pBuf)
     61 {
     62     u4 result = 0;
     63     int shift = 0;
     64     const u1* buf = *pBuf;
     65     u1 val;
     66 
     67     do {
     68         /*
     69          * Worst-case on bad data is we read too much data and return a bogus
     70          * result.  Safe to assume that we will encounter a byte with its
     71          * high bit clear before the end of the mapped file.
     72          */
     73         assert(shift < 32);
     74 
     75         val = *buf++;
     76         result |= (val & 0x7f) << shift;
     77         shift += 7;
     78     } while ((val & 0x80) != 0);
     79 
     80     *pBuf = buf;
     81     return result;
     82 }
     83 
     84 /*
     85  * Get the annotations directory item.
     86  */
     87 static const DexAnnotationsDirectoryItem* getAnnoDirectory(DexFile* pDexFile,
     88     const ClassObject* clazz)
     89 {
     90     const DexClassDef* pClassDef;
     91 
     92     /*
     93      * Find the class def in the DEX file.  For better performance we should
     94      * stash this in the ClassObject.
     95      */
     96     pClassDef = dexFindClass(pDexFile, clazz->descriptor);
     97     assert(pClassDef != NULL);
     98     return dexGetAnnotationsDirectoryItem(pDexFile, pClassDef);
     99 }
    100 
    101 /*
    102  * Return a zero-length array of Annotation objects.
    103  *
    104  * TODO: this currently allocates a new array each time, but I think we
    105  * can get away with returning a canonical copy.
    106  *
    107  * Caller must call dvmReleaseTrackedAlloc().
    108  */
    109 static ArrayObject* emptyAnnoArray()
    110 {
    111     return dvmAllocArrayByClass(
    112         gDvm.classJavaLangAnnotationAnnotationArray, 0, ALLOC_DEFAULT);
    113 }
    114 
    115 /*
    116  * Return an array of empty arrays of Annotation objects.
    117  *
    118  * Caller must call dvmReleaseTrackedAlloc().
    119  */
    120 static ArrayObject* emptyAnnoArrayArray(int numElements)
    121 {
    122     Thread* self = dvmThreadSelf();
    123     ArrayObject* arr;
    124     int i;
    125 
    126     arr = dvmAllocArrayByClass(gDvm.classJavaLangAnnotationAnnotationArrayArray,
    127             numElements, ALLOC_DEFAULT);
    128     if (arr != NULL) {
    129         ArrayObject** elems = (ArrayObject**)(void*)arr->contents;
    130         for (i = 0; i < numElements; i++) {
    131             elems[i] = emptyAnnoArray();
    132             dvmReleaseTrackedAlloc((Object*)elems[i], self);
    133         }
    134     }
    135 
    136     return arr;
    137 }
    138 
    139 /*
    140  * Read a signed integer.  "zwidth" is the zero-based byte count.
    141  */
    142 static s4 readSignedInt(const u1* ptr, int zwidth)
    143 {
    144     s4 val = 0;
    145     int i;
    146 
    147     for (i = zwidth; i >= 0; --i)
    148         val = ((u4)val >> 8) | (((s4)*ptr++) << 24);
    149     val >>= (3 - zwidth) * 8;
    150 
    151     return val;
    152 }
    153 
    154 /*
    155  * Read an unsigned integer.  "zwidth" is the zero-based byte count,
    156  * "fillOnRight" indicates which side we want to zero-fill from.
    157  */
    158 static u4 readUnsignedInt(const u1* ptr, int zwidth, bool fillOnRight)
    159 {
    160     u4 val = 0;
    161     int i;
    162 
    163     if (!fillOnRight) {
    164         for (i = zwidth; i >= 0; --i)
    165             val = (val >> 8) | (((u4)*ptr++) << 24);
    166         val >>= (3 - zwidth) * 8;
    167     } else {
    168         for (i = zwidth; i >= 0; --i)
    169             val = (val >> 8) | (((u4)*ptr++) << 24);
    170     }
    171     return val;
    172 }
    173 
    174 /*
    175  * Read a signed long.  "zwidth" is the zero-based byte count.
    176  */
    177 static s8 readSignedLong(const u1* ptr, int zwidth)
    178 {
    179     s8 val = 0;
    180     int i;
    181 
    182     for (i = zwidth; i >= 0; --i)
    183         val = ((u8)val >> 8) | (((s8)*ptr++) << 56);
    184     val >>= (7 - zwidth) * 8;
    185 
    186     return val;
    187 }
    188 
    189 /*
    190  * Read an unsigned long.  "zwidth" is the zero-based byte count,
    191  * "fillOnRight" indicates which side we want to zero-fill from.
    192  */
    193 static u8 readUnsignedLong(const u1* ptr, int zwidth, bool fillOnRight)
    194 {
    195     u8 val = 0;
    196     int i;
    197 
    198     if (!fillOnRight) {
    199         for (i = zwidth; i >= 0; --i)
    200             val = (val >> 8) | (((u8)*ptr++) << 56);
    201         val >>= (7 - zwidth) * 8;
    202     } else {
    203         for (i = zwidth; i >= 0; --i)
    204             val = (val >> 8) | (((u8)*ptr++) << 56);
    205     }
    206     return val;
    207 }
    208 
    209 
    210 /*
    211  * ===========================================================================
    212  *      Element extraction
    213  * ===========================================================================
    214  */
    215 
    216 /*
    217  * An annotation in "clazz" refers to a method by index.  This just gives
    218  * us the name of the class and the name and signature of the method.  We
    219  * need to find the method's class, and then find the method within that
    220  * class.  If the method has been resolved before, we can just use the
    221  * results of the previous lookup.
    222  *
    223  * Normally we do this as part of method invocation in the interpreter, which
    224  * provides us with a bit of context: is it virtual or direct, do we need
    225  * to initialize the class because it's a static method, etc.  We don't have
    226  * that information here, so we have to do a bit of searching.
    227  *
    228  * Returns NULL if the method was not found (exception may be pending).
    229  */
    230 static Method* resolveAmbiguousMethod(const ClassObject* referrer, u4 methodIdx)
    231 {
    232     DexFile* pDexFile;
    233     ClassObject* resClass;
    234     Method* resMethod;
    235     const DexMethodId* pMethodId;
    236     const char* name;
    237 
    238     /* if we've already resolved this method, return it */
    239     resMethod = dvmDexGetResolvedMethod(referrer->pDvmDex, methodIdx);
    240     if (resMethod != NULL)
    241         return resMethod;
    242 
    243     pDexFile = referrer->pDvmDex->pDexFile;
    244     pMethodId = dexGetMethodId(pDexFile, methodIdx);
    245     resClass = dvmResolveClass(referrer, pMethodId->classIdx, true);
    246     if (resClass == NULL) {
    247         /* note exception will be pending */
    248         ALOGD("resolveAmbiguousMethod: unable to find class %d", methodIdx);
    249         return NULL;
    250     }
    251     if (dvmIsInterfaceClass(resClass)) {
    252         /* method is part of an interface -- not expecting that */
    253         ALOGD("resolveAmbiguousMethod: method in interface?");
    254         return NULL;
    255     }
    256 
    257     // TODO - consider a method access flag that indicates direct vs. virtual
    258     name = dexStringById(pDexFile, pMethodId->nameIdx);
    259 
    260     DexProto proto;
    261     dexProtoSetFromMethodId(&proto, pDexFile, pMethodId);
    262 
    263     if (name[0] == '<') {
    264         /*
    265          * Constructor or class initializer.  Only need to examine the
    266          * "direct" list, and don't need to look up the class hierarchy.
    267          */
    268         resMethod = dvmFindDirectMethod(resClass, name, &proto);
    269     } else {
    270         /*
    271          * Do a hierarchical scan for direct and virtual methods.
    272          *
    273          * This uses the search order from the VM spec (v2 5.4.3.3), which
    274          * seems appropriate here.
    275          */
    276         resMethod = dvmFindMethodHier(resClass, name, &proto);
    277     }
    278 
    279     return resMethod;
    280 }
    281 
    282 /*
    283  * constants for processAnnotationValue indicating what style of
    284  * result is wanted
    285  */
    286 enum AnnotationResultStyle {
    287     kAllObjects,         /* return everything as an object */
    288     kAllRaw,             /* return everything as a raw value or index */
    289     kPrimitivesOrObjects /* return primitives as-is but the rest as objects */
    290 };
    291 
    292 /*
    293  * Recursively process an annotation value.
    294  *
    295  * "clazz" is the class on which the annotations are defined.  It may be
    296  * NULL when "resultStyle" is "kAllRaw".
    297  *
    298  * If "resultStyle" is "kAllObjects", the result will always be an Object of an
    299  * appropriate type (in pValue->value.l).  For primitive types, the usual
    300  * wrapper objects will be created.
    301  *
    302  * If "resultStyle" is "kAllRaw", numeric constants are stored directly into
    303  * "pValue", and indexed values like String and Method are returned as
    304  * indexes.  Complex values like annotations and arrays are not handled.
    305  *
    306  * If "resultStyle" is "kPrimitivesOrObjects", numeric constants are stored
    307  * directly into "pValue", and everything else is constructed as an Object
    308  * of appropriate type (in pValue->value.l).
    309  *
    310  * The caller must call dvmReleaseTrackedAlloc on returned objects, when
    311  * using "kAllObjects" or "kPrimitivesOrObjects".
    312  *
    313  * Returns "true" on success, "false" if the value could not be processed
    314  * or an object could not be allocated.  On allocation failure an exception
    315  * will be raised.
    316  */
    317 static bool processAnnotationValue(const ClassObject* clazz,
    318     const u1** pPtr, AnnotationValue* pValue,
    319     AnnotationResultStyle resultStyle)
    320 {
    321     Thread* self = dvmThreadSelf();
    322     Object* elemObj = NULL;
    323     bool setObject = false;
    324     const u1* ptr = *pPtr;
    325     u1 valueType, valueArg;
    326     int width;
    327     u4 idx;
    328 
    329     valueType = *ptr++;
    330     valueArg = valueType >> kDexAnnotationValueArgShift;
    331     width = valueArg + 1;       /* assume, correct later */
    332 
    333     ALOGV("----- type is 0x%02x %d, ptr=%p [0x%06x]",
    334         valueType & kDexAnnotationValueTypeMask, valueArg, ptr-1,
    335         (ptr-1) - (u1*)clazz->pDvmDex->pDexFile->baseAddr);
    336 
    337     pValue->type = valueType & kDexAnnotationValueTypeMask;
    338 
    339     switch (valueType & kDexAnnotationValueTypeMask) {
    340     case kDexAnnotationByte:
    341         pValue->value.i = (s1) readSignedInt(ptr, valueArg);
    342         if (resultStyle == kAllObjects) {
    343             elemObj = (Object*) dvmBoxPrimitive(pValue->value,
    344                         dvmFindPrimitiveClass('B'));
    345             setObject = true;
    346         }
    347         break;
    348     case kDexAnnotationShort:
    349         pValue->value.i = (s2) readSignedInt(ptr, valueArg);
    350         if (resultStyle == kAllObjects) {
    351             elemObj = (Object*) dvmBoxPrimitive(pValue->value,
    352                         dvmFindPrimitiveClass('S'));
    353             setObject = true;
    354         }
    355         break;
    356     case kDexAnnotationChar:
    357         pValue->value.i = (u2) readUnsignedInt(ptr, valueArg, false);
    358         if (resultStyle == kAllObjects) {
    359             elemObj = (Object*) dvmBoxPrimitive(pValue->value,
    360                         dvmFindPrimitiveClass('C'));
    361             setObject = true;
    362         }
    363         break;
    364     case kDexAnnotationInt:
    365         pValue->value.i = readSignedInt(ptr, valueArg);
    366         if (resultStyle == kAllObjects) {
    367             elemObj = (Object*) dvmBoxPrimitive(pValue->value,
    368                         dvmFindPrimitiveClass('I'));
    369             setObject = true;
    370         }
    371         break;
    372     case kDexAnnotationLong:
    373         pValue->value.j = readSignedLong(ptr, valueArg);
    374         if (resultStyle == kAllObjects) {
    375             elemObj = (Object*) dvmBoxPrimitive(pValue->value,
    376                         dvmFindPrimitiveClass('J'));
    377             setObject = true;
    378         }
    379         break;
    380     case kDexAnnotationFloat:
    381         pValue->value.i = readUnsignedInt(ptr, valueArg, true);
    382         if (resultStyle == kAllObjects) {
    383             elemObj = (Object*) dvmBoxPrimitive(pValue->value,
    384                         dvmFindPrimitiveClass('F'));
    385             setObject = true;
    386         }
    387         break;
    388     case kDexAnnotationDouble:
    389         pValue->value.j = readUnsignedLong(ptr, valueArg, true);
    390         if (resultStyle == kAllObjects) {
    391             elemObj = (Object*) dvmBoxPrimitive(pValue->value,
    392                         dvmFindPrimitiveClass('D'));
    393             setObject = true;
    394         }
    395         break;
    396     case kDexAnnotationBoolean:
    397         pValue->value.i = (valueArg != 0);
    398         if (resultStyle == kAllObjects) {
    399             elemObj = (Object*) dvmBoxPrimitive(pValue->value,
    400                         dvmFindPrimitiveClass('Z'));
    401             setObject = true;
    402         }
    403         width = 0;
    404         break;
    405 
    406     case kDexAnnotationString:
    407         idx = readUnsignedInt(ptr, valueArg, false);
    408         if (resultStyle == kAllRaw) {
    409             pValue->value.i = idx;
    410         } else {
    411             elemObj = (Object*) dvmResolveString(clazz, idx);
    412             setObject = true;
    413             if (elemObj == NULL)
    414                 return false;
    415             dvmAddTrackedAlloc(elemObj, self);      // balance the Release
    416         }
    417         break;
    418     case kDexAnnotationType:
    419         idx = readUnsignedInt(ptr, valueArg, false);
    420         if (resultStyle == kAllRaw) {
    421             pValue->value.i = idx;
    422         } else {
    423             elemObj = (Object*) dvmResolveClass(clazz, idx, true);
    424             setObject = true;
    425             if (elemObj == NULL) {
    426                 /* we're expected to throw a TypeNotPresentException here */
    427                 DexFile* pDexFile = clazz->pDvmDex->pDexFile;
    428                 const char* desc = dexStringByTypeIdx(pDexFile, idx);
    429                 dvmClearException(self);
    430                 dvmThrowTypeNotPresentException(desc);
    431                 return false;
    432             } else {
    433                 dvmAddTrackedAlloc(elemObj, self);      // balance the Release
    434             }
    435         }
    436         break;
    437     case kDexAnnotationMethod:
    438         idx = readUnsignedInt(ptr, valueArg, false);
    439         if (resultStyle == kAllRaw) {
    440             pValue->value.i = idx;
    441         } else {
    442             Method* meth = resolveAmbiguousMethod(clazz, idx);
    443             if (meth == NULL)
    444                 return false;
    445             elemObj = dvmCreateReflectObjForMethod(clazz, meth);
    446             setObject = true;
    447             if (elemObj == NULL)
    448                 return false;
    449         }
    450         break;
    451     case kDexAnnotationField:
    452         idx = readUnsignedInt(ptr, valueArg, false);
    453         assert(false);      // TODO
    454         break;
    455     case kDexAnnotationEnum:
    456         /* enum values are the contents of a static field */
    457         idx = readUnsignedInt(ptr, valueArg, false);
    458         if (resultStyle == kAllRaw) {
    459             pValue->value.i = idx;
    460         } else {
    461             StaticField* sfield;
    462 
    463             sfield = dvmResolveStaticField(clazz, idx);
    464             if (sfield == NULL) {
    465                 return false;
    466             } else {
    467                 assert(sfield->clazz->descriptor[0] == 'L');
    468                 elemObj = sfield->value.l;
    469                 setObject = true;
    470                 dvmAddTrackedAlloc(elemObj, self);      // balance the Release
    471             }
    472         }
    473         break;
    474     case kDexAnnotationArray:
    475         /*
    476          * encoded_array format, which is a size followed by a stream
    477          * of annotation_value.
    478          *
    479          * We create an array of Object, populate it, and return it.
    480          */
    481         if (resultStyle == kAllRaw) {
    482             return false;
    483         } else {
    484             ArrayObject* newArray;
    485             u4 size, count;
    486 
    487             size = readUleb128(&ptr);
    488             LOGVV("--- annotation array, size is %u at %p", size, ptr);
    489             newArray = dvmAllocArrayByClass(gDvm.classJavaLangObjectArray,
    490                 size, ALLOC_DEFAULT);
    491             if (newArray == NULL) {
    492                 ALOGE("annotation element array alloc failed (%d)", size);
    493                 return false;
    494             }
    495 
    496             AnnotationValue avalue;
    497             for (count = 0; count < size; count++) {
    498                 if (!processAnnotationValue(clazz, &ptr, &avalue,
    499                                 kAllObjects)) {
    500                     dvmReleaseTrackedAlloc((Object*)newArray, self);
    501                     return false;
    502                 }
    503                 Object* obj = (Object*)avalue.value.l;
    504                 dvmSetObjectArrayElement(newArray, count, obj);
    505                 dvmReleaseTrackedAlloc(obj, self);
    506             }
    507 
    508             elemObj = (Object*) newArray;
    509             setObject = true;
    510         }
    511         width = 0;
    512         break;
    513     case kDexAnnotationAnnotation:
    514         /* encoded_annotation format */
    515         if (resultStyle == kAllRaw)
    516             return false;
    517         elemObj = processEncodedAnnotation(clazz, &ptr);
    518         setObject = true;
    519         if (elemObj == NULL)
    520             return false;
    521         dvmAddTrackedAlloc(elemObj, self);      // balance the Release
    522         width = 0;
    523         break;
    524     case kDexAnnotationNull:
    525         if (resultStyle == kAllRaw) {
    526             pValue->value.i = 0;
    527         } else {
    528             assert(elemObj == NULL);
    529             setObject = true;
    530         }
    531         width = 0;
    532         break;
    533     default:
    534         ALOGE("Bad annotation element value byte 0x%02x (0x%02x)",
    535             valueType, valueType & kDexAnnotationValueTypeMask);
    536         assert(false);
    537         return false;
    538     }
    539 
    540     ptr += width;
    541 
    542     *pPtr = ptr;
    543     if (setObject)
    544         pValue->value.l = elemObj;
    545     return true;
    546 }
    547 
    548 
    549 /*
    550  * For most object types, we have nothing to do here, and we just return
    551  * "valueObj".
    552  *
    553  * For an array annotation, the type of the extracted object will always
    554  * be java.lang.Object[], but we want it to match the type that the
    555  * annotation member is expected to return.  In some cases this may
    556  * involve un-boxing primitive values.
    557  *
    558  * We allocate a second array with the correct type, then copy the data
    559  * over.  This releases the tracked allocation on "valueObj" and returns
    560  * a new, tracked object.
    561  *
    562  * On failure, this releases the tracking on "valueObj" and returns NULL
    563  * (allowing the call to say "foo = convertReturnType(foo, ..)").
    564  */
    565 static Object* convertReturnType(Object* valueObj, ClassObject* methodReturn)
    566 {
    567     if (valueObj == NULL ||
    568         !dvmIsArray((ArrayObject*)valueObj) || !dvmIsArrayClass(methodReturn))
    569     {
    570         return valueObj;
    571     }
    572 
    573     Thread* self = dvmThreadSelf();
    574     ClassObject* srcElemClass;
    575     ClassObject* dstElemClass;
    576 
    577     /*
    578      * We always extract kDexAnnotationArray into Object[], so we expect to
    579      * find that here.  This means we can skip the FindClass on
    580      * (valueObj->clazz->descriptor+1, valueObj->clazz->classLoader).
    581      */
    582     if (strcmp(valueObj->clazz->descriptor, "[Ljava/lang/Object;") != 0) {
    583         ALOGE("Unexpected src type class (%s)", valueObj->clazz->descriptor);
    584         return NULL;
    585     }
    586     srcElemClass = gDvm.classJavaLangObject;
    587 
    588     /*
    589      * Skip past the '[' to get element class name.  Note this is not always
    590      * the same as methodReturn->elementClass.
    591      */
    592     char firstChar = methodReturn->descriptor[1];
    593     if (firstChar == 'L' || firstChar == '[') {
    594         dstElemClass = dvmFindClass(methodReturn->descriptor+1,
    595             methodReturn->classLoader);
    596     } else {
    597         dstElemClass = dvmFindPrimitiveClass(firstChar);
    598     }
    599     ALOGV("HEY: converting valueObj from [%s to [%s",
    600         srcElemClass->descriptor, dstElemClass->descriptor);
    601 
    602     ArrayObject* srcArray = (ArrayObject*) valueObj;
    603     u4 length = srcArray->length;
    604     ArrayObject* newArray;
    605 
    606     newArray = dvmAllocArrayByClass(methodReturn, length, ALLOC_DEFAULT);
    607     if (newArray == NULL) {
    608         ALOGE("Failed creating duplicate annotation class (%s %d)",
    609             methodReturn->descriptor, length);
    610         goto bail;
    611     }
    612 
    613     bool success;
    614     if (dstElemClass->primitiveType == PRIM_NOT) {
    615         success = dvmCopyObjectArray(newArray, srcArray, dstElemClass);
    616     } else {
    617         success = dvmUnboxObjectArray(newArray, srcArray, dstElemClass);
    618     }
    619     if (!success) {
    620         ALOGE("Annotation array copy failed");
    621         dvmReleaseTrackedAlloc((Object*)newArray, self);
    622         newArray = NULL;
    623         goto bail;
    624     }
    625 
    626 bail:
    627     /* replace old, return new */
    628     dvmReleaseTrackedAlloc(valueObj, self);
    629     return (Object*) newArray;
    630 }
    631 
    632 /*
    633  * Create a new AnnotationMember.
    634  *
    635  * "clazz" is the class on which the annotations are defined.  "pPtr"
    636  * points to a pointer into the annotation data.  "annoClass" is the
    637  * annotation's class.
    638  *
    639  * We extract the annotation's value, create a new AnnotationMember object,
    640  * and construct it.
    641  *
    642  * Returns NULL on failure; an exception may or may not be raised.
    643  */
    644 static Object* createAnnotationMember(const ClassObject* clazz,
    645     const ClassObject* annoClass, const u1** pPtr)
    646 {
    647     Thread* self = dvmThreadSelf();
    648     const DexFile* pDexFile = clazz->pDvmDex->pDexFile;
    649     StringObject* nameObj = NULL;
    650     Object* valueObj = NULL;
    651     Object* newMember = NULL;
    652     Object* methodObj = NULL;
    653     ClassObject* methodReturn = NULL;
    654     u4 elementNameIdx;
    655     const char* name;
    656     AnnotationValue avalue;
    657     JValue unused;
    658     bool failed = true;
    659 
    660     elementNameIdx = readUleb128(pPtr);
    661 
    662     if (!processAnnotationValue(clazz, pPtr, &avalue, kAllObjects)) {
    663         ALOGW("Failed processing annotation value");
    664         goto bail;
    665     }
    666     valueObj = (Object*)avalue.value.l;
    667 
    668     /* new member to hold the element */
    669     newMember =
    670         dvmAllocObject(gDvm.classOrgApacheHarmonyLangAnnotationAnnotationMember,
    671         ALLOC_DEFAULT);
    672     name = dexStringById(pDexFile, elementNameIdx);
    673     nameObj = dvmCreateStringFromCstr(name);
    674 
    675     /* find the method in the annotation class, given only the name */
    676     if (name != NULL) {
    677         Method* annoMeth = dvmFindVirtualMethodByName(annoClass, name);
    678         if (annoMeth == NULL) {
    679             ALOGW("WARNING: could not find annotation member %s in %s",
    680                 name, annoClass->descriptor);
    681         } else {
    682             methodObj = dvmCreateReflectObjForMethod(annoClass, annoMeth);
    683             methodReturn = dvmGetBoxedReturnType(annoMeth);
    684         }
    685     }
    686     if (newMember == NULL || nameObj == NULL || methodObj == NULL ||
    687         methodReturn == NULL)
    688     {
    689         ALOGE("Failed creating annotation element (m=%p n=%p a=%p r=%p)",
    690             newMember, nameObj, methodObj, methodReturn);
    691         goto bail;
    692     }
    693 
    694     /* convert the return type, if necessary */
    695     valueObj = convertReturnType(valueObj, methodReturn);
    696     if (valueObj == NULL)
    697         goto bail;
    698 
    699     /* call 4-argument constructor */
    700     dvmCallMethod(self, gDvm.methOrgApacheHarmonyLangAnnotationAnnotationMember_init,
    701         newMember, &unused, nameObj, valueObj, methodReturn, methodObj);
    702     if (dvmCheckException(self)) {
    703         ALOGD("Failed constructing annotation element");
    704         goto bail;
    705     }
    706 
    707     failed = false;
    708 
    709 bail:
    710     /* release tracked allocations */
    711     dvmReleaseTrackedAlloc(newMember, self);
    712     dvmReleaseTrackedAlloc((Object*)nameObj, self);
    713     dvmReleaseTrackedAlloc(valueObj, self);
    714     dvmReleaseTrackedAlloc(methodObj, self);
    715     if (failed)
    716         return NULL;
    717     else
    718         return newMember;
    719 }
    720 
    721 /*
    722  * Create a new Annotation object from what we find in the annotation item.
    723  *
    724  * "clazz" is the class on which the annotations are defined.  "pPtr"
    725  * points to a pointer into the annotation data.
    726  *
    727  * We use the AnnotationFactory class to create the annotation for us.  The
    728  * method we call is:
    729  *
    730  *  public static Annotation createAnnotation(
    731  *      Class<? extends Annotation> annotationType,
    732  *      AnnotationMember[] elements)
    733  *
    734  * Returns a new Annotation, which will NOT be in the local ref table and
    735  * not referenced elsewhere, so store it away soon.  On failure, returns NULL
    736  * with an exception raised.
    737  */
    738 static Object* processEncodedAnnotation(const ClassObject* clazz,
    739     const u1** pPtr)
    740 {
    741     Thread* self = dvmThreadSelf();
    742     Object* newAnno = NULL;
    743     ArrayObject* elementArray = NULL;
    744     const ClassObject* annoClass;
    745     const u1* ptr;
    746     u4 typeIdx, size, count;
    747 
    748     ptr = *pPtr;
    749     typeIdx = readUleb128(&ptr);
    750     size = readUleb128(&ptr);
    751 
    752     LOGVV("----- processEnc ptr=%p type=%d size=%d", ptr, typeIdx, size);
    753 
    754     annoClass = dvmDexGetResolvedClass(clazz->pDvmDex, typeIdx);
    755     if (annoClass == NULL) {
    756         annoClass = dvmResolveClass(clazz, typeIdx, true);
    757         if (annoClass == NULL) {
    758             ALOGE("Unable to resolve %s annotation class %d",
    759                 clazz->descriptor, typeIdx);
    760             assert(dvmCheckException(self));
    761             return NULL;
    762         }
    763     }
    764 
    765     ALOGV("----- processEnc ptr=%p [0x%06x]  typeIdx=%d size=%d class=%s",
    766         *pPtr, *pPtr - (u1*) clazz->pDvmDex->pDexFile->baseAddr,
    767         typeIdx, size, annoClass->descriptor);
    768 
    769     /*
    770      * Elements are parsed out and stored in an array.  The Harmony
    771      * constructor wants an array with just the declared elements --
    772      * default values get merged in later.
    773      */
    774     JValue result;
    775 
    776     if (size > 0) {
    777         elementArray = dvmAllocArrayByClass(
    778             gDvm.classOrgApacheHarmonyLangAnnotationAnnotationMemberArray,
    779             size, ALLOC_DEFAULT);
    780         if (elementArray == NULL) {
    781             ALOGE("failed to allocate annotation member array (%d elements)",
    782                 size);
    783             goto bail;
    784         }
    785     }
    786 
    787     /*
    788      * "ptr" points to a byte stream with "size" occurrences of
    789      * annotation_element.
    790      */
    791     for (count = 0; count < size; count++) {
    792         Object* newMember = createAnnotationMember(clazz, annoClass, &ptr);
    793         if (newMember == NULL)
    794             goto bail;
    795 
    796         /* add it to the array */
    797         dvmSetObjectArrayElement(elementArray, count, newMember);
    798     }
    799 
    800     dvmCallMethod(self,
    801         gDvm.methOrgApacheHarmonyLangAnnotationAnnotationFactory_createAnnotation,
    802         NULL, &result, annoClass, elementArray);
    803     if (dvmCheckException(self)) {
    804         ALOGD("Failed creating an annotation");
    805         //dvmLogExceptionStackTrace();
    806         goto bail;
    807     }
    808 
    809     newAnno = (Object*)result.l;
    810 
    811 bail:
    812     dvmReleaseTrackedAlloc((Object*) elementArray, NULL);
    813     *pPtr = ptr;
    814     if (newAnno == NULL && !dvmCheckException(self)) {
    815         /* make sure an exception is raised */
    816         dvmThrowRuntimeException("failure in processEncodedAnnotation");
    817     }
    818     return newAnno;
    819 }
    820 
    821 /*
    822  * Run through an annotation set and convert each entry into an Annotation
    823  * object.
    824  *
    825  * Returns an array of Annotation objects, or NULL with an exception raised
    826  * on alloc failure.
    827  */
    828 static ArrayObject* processAnnotationSet(const ClassObject* clazz,
    829     const DexAnnotationSetItem* pAnnoSet, int visibility)
    830 {
    831     DexFile* pDexFile = clazz->pDvmDex->pDexFile;
    832     const DexAnnotationItem* pAnnoItem;
    833     ArrayObject* annoArray;
    834     int i, count;
    835     u4 dstIndex;
    836 
    837     /* we need these later; make sure they're initialized */
    838     if (!dvmIsClassInitialized(gDvm.classOrgApacheHarmonyLangAnnotationAnnotationFactory))
    839         dvmInitClass(gDvm.classOrgApacheHarmonyLangAnnotationAnnotationFactory);
    840     if (!dvmIsClassInitialized(gDvm.classOrgApacheHarmonyLangAnnotationAnnotationMember))
    841         dvmInitClass(gDvm.classOrgApacheHarmonyLangAnnotationAnnotationMember);
    842 
    843     /* count up the number of visible elements */
    844     for (i = count = 0; i < (int) pAnnoSet->size; i++) {
    845         pAnnoItem = dexGetAnnotationItem(pDexFile, pAnnoSet, i);
    846         if (pAnnoItem->visibility == visibility)
    847             count++;
    848     }
    849 
    850     annoArray =
    851         dvmAllocArrayByClass(gDvm.classJavaLangAnnotationAnnotationArray,
    852                              count, ALLOC_DEFAULT);
    853     if (annoArray == NULL)
    854         return NULL;
    855 
    856     /*
    857      * Generate Annotation objects.  We must put them into the array
    858      * immediately (or add them to the tracked ref table).
    859      */
    860     dstIndex = 0;
    861     for (i = 0; i < (int) pAnnoSet->size; i++) {
    862         pAnnoItem = dexGetAnnotationItem(pDexFile, pAnnoSet, i);
    863         if (pAnnoItem->visibility != visibility)
    864             continue;
    865         const u1* ptr = pAnnoItem->annotation;
    866         Object *anno = processEncodedAnnotation(clazz, &ptr);
    867         if (anno == NULL) {
    868             dvmReleaseTrackedAlloc((Object*) annoArray, NULL);
    869             return NULL;
    870         }
    871         dvmSetObjectArrayElement(annoArray, dstIndex, anno);
    872         ++dstIndex;
    873     }
    874 
    875     return annoArray;
    876 }
    877 
    878 /*
    879  * Return the annotation item of the specified type in the annotation set, or
    880  * NULL if the set contains no annotation of that type.
    881  */
    882 static const DexAnnotationItem* getAnnotationItemFromAnnotationSet(
    883         const ClassObject* clazz, const DexAnnotationSetItem* pAnnoSet,
    884         int visibility, const ClassObject* annotationClazz)
    885 {
    886     DexFile* pDexFile = clazz->pDvmDex->pDexFile;
    887     const DexAnnotationItem* pAnnoItem;
    888     int i;
    889     const ClassObject* annoClass;
    890     const u1* ptr;
    891     u4 typeIdx;
    892 
    893     /* we need these later; make sure they're initialized */
    894     if (!dvmIsClassInitialized(gDvm.classOrgApacheHarmonyLangAnnotationAnnotationFactory))
    895         dvmInitClass(gDvm.classOrgApacheHarmonyLangAnnotationAnnotationFactory);
    896     if (!dvmIsClassInitialized(gDvm.classOrgApacheHarmonyLangAnnotationAnnotationMember))
    897         dvmInitClass(gDvm.classOrgApacheHarmonyLangAnnotationAnnotationMember);
    898 
    899     for (i = 0; i < (int) pAnnoSet->size; i++) {
    900         pAnnoItem = dexGetAnnotationItem(pDexFile, pAnnoSet, i);
    901         if (pAnnoItem->visibility != visibility)
    902             continue;
    903 
    904         ptr = pAnnoItem->annotation;
    905         typeIdx = readUleb128(&ptr);
    906 
    907         annoClass = dvmDexGetResolvedClass(clazz->pDvmDex, typeIdx);
    908         if (annoClass == NULL) {
    909             annoClass = dvmResolveClass(clazz, typeIdx, true);
    910             if (annoClass == NULL) {
    911                 return NULL; // an exception is pending
    912             }
    913         }
    914 
    915         if (annoClass == annotationClazz) {
    916             return pAnnoItem;
    917         }
    918     }
    919 
    920     return NULL;
    921 }
    922 
    923 /*
    924  * Return the Annotation object of the specified type in the annotation set, or
    925  * NULL if the set contains no annotation of that type.
    926  */
    927 static Object* getAnnotationObjectFromAnnotationSet(const ClassObject* clazz,
    928         const DexAnnotationSetItem* pAnnoSet, int visibility,
    929         const ClassObject* annotationClazz)
    930 {
    931     const DexAnnotationItem* pAnnoItem = getAnnotationItemFromAnnotationSet(
    932             clazz, pAnnoSet, visibility, annotationClazz);
    933     if (pAnnoItem == NULL) {
    934         return NULL;
    935     }
    936     const u1* ptr = pAnnoItem->annotation;
    937     return processEncodedAnnotation(clazz, &ptr);
    938 }
    939 
    940 /*
    941  * ===========================================================================
    942  *      Skipping and scanning
    943  * ===========================================================================
    944  */
    945 
    946 /*
    947  * Skip past an annotation value.
    948  *
    949  * "clazz" is the class on which the annotations are defined.
    950  *
    951  * Returns "true" on success, "false" on parsing failure.
    952  */
    953 static bool skipAnnotationValue(const ClassObject* clazz, const u1** pPtr)
    954 {
    955     const u1* ptr = *pPtr;
    956     u1 valueType, valueArg;
    957     int width;
    958 
    959     valueType = *ptr++;
    960     valueArg = valueType >> kDexAnnotationValueArgShift;
    961     width = valueArg + 1;       /* assume */
    962 
    963     ALOGV("----- type is 0x%02x %d, ptr=%p [0x%06x]",
    964         valueType & kDexAnnotationValueTypeMask, valueArg, ptr-1,
    965         (ptr-1) - (u1*)clazz->pDvmDex->pDexFile->baseAddr);
    966 
    967     switch (valueType & kDexAnnotationValueTypeMask) {
    968     case kDexAnnotationByte:        break;
    969     case kDexAnnotationShort:       break;
    970     case kDexAnnotationChar:        break;
    971     case kDexAnnotationInt:         break;
    972     case kDexAnnotationLong:        break;
    973     case kDexAnnotationFloat:       break;
    974     case kDexAnnotationDouble:      break;
    975     case kDexAnnotationString:      break;
    976     case kDexAnnotationType:        break;
    977     case kDexAnnotationMethod:      break;
    978     case kDexAnnotationField:       break;
    979     case kDexAnnotationEnum:        break;
    980 
    981     case kDexAnnotationArray:
    982         /* encoded_array format */
    983         {
    984             u4 size = readUleb128(&ptr);
    985             while (size--) {
    986                 if (!skipAnnotationValue(clazz, &ptr))
    987                     return false;
    988             }
    989         }
    990         width = 0;
    991         break;
    992     case kDexAnnotationAnnotation:
    993         /* encoded_annotation format */
    994         if (!skipEncodedAnnotation(clazz, &ptr))
    995             return false;
    996         width = 0;
    997         break;
    998     case kDexAnnotationBoolean:
    999     case kDexAnnotationNull:
   1000         width = 0;
   1001         break;
   1002     default:
   1003         ALOGE("Bad annotation element value byte 0x%02x", valueType);
   1004         assert(false);
   1005         return false;
   1006     }
   1007 
   1008     ptr += width;
   1009 
   1010     *pPtr = ptr;
   1011     return true;
   1012 }
   1013 
   1014 /*
   1015  * Skip past an encoded annotation.  Mainly useful for annotations embedded
   1016  * in other annotations.
   1017  */
   1018 static bool skipEncodedAnnotation(const ClassObject* clazz, const u1** pPtr)
   1019 {
   1020     const u1* ptr;
   1021     u4 size;
   1022 
   1023     ptr = *pPtr;
   1024     (void) readUleb128(&ptr);
   1025     size = readUleb128(&ptr);
   1026 
   1027     /*
   1028      * "ptr" points to a byte stream with "size" occurrences of
   1029      * annotation_element.
   1030      */
   1031     while (size--) {
   1032         (void) readUleb128(&ptr);
   1033 
   1034         if (!skipAnnotationValue(clazz, &ptr))
   1035             return false;
   1036     }
   1037 
   1038     *pPtr = ptr;
   1039     return true;
   1040 }
   1041 
   1042 
   1043 /*
   1044  * Compare the name of the class in the DEX file to the supplied descriptor.
   1045  * Return value is equivalent to strcmp.
   1046  */
   1047 static int compareClassDescriptor(DexFile* pDexFile, u4 typeIdx,
   1048     const char* descriptor)
   1049 {
   1050     const char* str = dexStringByTypeIdx(pDexFile, typeIdx);
   1051 
   1052     return strcmp(str, descriptor);
   1053 }
   1054 
   1055 /*
   1056  * Search through the annotation set for an annotation with a matching
   1057  * descriptor.
   1058  *
   1059  * Comparing the string descriptor is slower than comparing an integer class
   1060  * index.  If annotation lists are expected to be long, we could look up
   1061  * the class' index by name from the DEX file, rather than doing a class
   1062  * lookup and string compare on each entry.  (Note the index will be
   1063  * different for each DEX file, so we can't cache annotation class indices
   1064  * globally.)
   1065  */
   1066 static const DexAnnotationItem* searchAnnotationSet(const ClassObject* clazz,
   1067     const DexAnnotationSetItem* pAnnoSet, const char* descriptor,
   1068     int visibility)
   1069 {
   1070     DexFile* pDexFile = clazz->pDvmDex->pDexFile;
   1071     const DexAnnotationItem* result = NULL;
   1072     u4 typeIdx;
   1073     int i;
   1074 
   1075     //printf("##### searchAnnotationSet %s %d\n", descriptor, visibility);
   1076 
   1077     for (i = 0; i < (int) pAnnoSet->size; i++) {
   1078         const DexAnnotationItem* pAnnoItem;
   1079 
   1080         pAnnoItem = dexGetAnnotationItem(pDexFile, pAnnoSet, i);
   1081         if (pAnnoItem->visibility != visibility)
   1082             continue;
   1083         const u1* ptr = pAnnoItem->annotation;
   1084         typeIdx = readUleb128(&ptr);
   1085 
   1086         if (compareClassDescriptor(pDexFile, typeIdx, descriptor) == 0) {
   1087             //printf("#####  match on %x/%p at %d\n", typeIdx, pDexFile, i);
   1088             result = pAnnoItem;
   1089             break;
   1090         }
   1091     }
   1092 
   1093     return result;
   1094 }
   1095 
   1096 /*
   1097  * Find an annotation value in the annotation_item whose name matches "name".
   1098  * A pointer to the annotation_value is returned, or NULL if it's not found.
   1099  */
   1100 static const u1* searchEncodedAnnotation(const ClassObject* clazz,
   1101     const u1* ptr, const char* name)
   1102 {
   1103     DexFile* pDexFile = clazz->pDvmDex->pDexFile;
   1104     u4 typeIdx, size;
   1105 
   1106     typeIdx = readUleb128(&ptr);
   1107     size = readUleb128(&ptr);
   1108     //printf("#####   searching ptr=%p type=%u size=%u\n", ptr, typeIdx, size);
   1109 
   1110     while (size--) {
   1111         u4 elementNameIdx;
   1112         const char* elemName;
   1113 
   1114         elementNameIdx = readUleb128(&ptr);
   1115         elemName = dexStringById(pDexFile, elementNameIdx);
   1116         if (strcmp(name, elemName) == 0) {
   1117             //printf("#####   item match on %s\n", name);
   1118             return ptr;     /* points to start of value */
   1119         }
   1120 
   1121         skipAnnotationValue(clazz, &ptr);
   1122     }
   1123 
   1124     //printf("#####   no item match on %s\n", name);
   1125     return NULL;
   1126 }
   1127 
   1128 #define GAV_FAILED  ((Object*) 0x10000001)
   1129 
   1130 /*
   1131  * Extract an encoded annotation value from the field specified by "annoName".
   1132  *
   1133  * "expectedType" is an annotation value type, e.g. kDexAnnotationString.
   1134  * "debugAnnoName" is only used in debug messages.
   1135  *
   1136  * Returns GAV_FAILED on failure.  If an allocation failed, an exception
   1137  * will be raised.
   1138  */
   1139 static Object* getAnnotationValue(const ClassObject* clazz,
   1140     const DexAnnotationItem* pAnnoItem, const char* annoName,
   1141     int expectedType, const char* debugAnnoName)
   1142 {
   1143     const u1* ptr;
   1144     AnnotationValue avalue;
   1145 
   1146     /* find the annotation */
   1147     ptr = searchEncodedAnnotation(clazz, pAnnoItem->annotation, annoName);
   1148     if (ptr == NULL) {
   1149         ALOGW("%s annotation lacks '%s' member", debugAnnoName, annoName);
   1150         return GAV_FAILED;
   1151     }
   1152 
   1153     if (!processAnnotationValue(clazz, &ptr, &avalue, kAllObjects))
   1154         return GAV_FAILED;
   1155 
   1156     /* make sure it has the expected format */
   1157     if (avalue.type != expectedType) {
   1158         ALOGW("%s %s has wrong type (0x%02x, expected 0x%02x)",
   1159             debugAnnoName, annoName, avalue.type, expectedType);
   1160         return GAV_FAILED;
   1161     }
   1162 
   1163     return (Object*)avalue.value.l;
   1164 }
   1165 
   1166 
   1167 /*
   1168  * Find the Signature attribute and extract its value.  (Signatures can
   1169  * be found in annotations on classes, constructors, methods, and fields.)
   1170  *
   1171  * Caller must call dvmReleaseTrackedAlloc().
   1172  *
   1173  * Returns NULL if not found.  On memory alloc failure, returns NULL with an
   1174  * exception raised.
   1175  */
   1176 static ArrayObject* getSignatureValue(const ClassObject* clazz,
   1177     const DexAnnotationSetItem* pAnnoSet)
   1178 {
   1179     const DexAnnotationItem* pAnnoItem;
   1180     Object* obj;
   1181 
   1182     pAnnoItem = searchAnnotationSet(clazz, pAnnoSet, kDescrSignature,
   1183         kDexVisibilitySystem);
   1184     if (pAnnoItem == NULL)
   1185         return NULL;
   1186 
   1187     /*
   1188      * The Signature annotation has one member, "String value".
   1189      */
   1190     obj = getAnnotationValue(clazz, pAnnoItem, "value", kDexAnnotationArray,
   1191             "Signature");
   1192     if (obj == GAV_FAILED)
   1193         return NULL;
   1194     assert(obj->clazz == gDvm.classJavaLangObjectArray);
   1195 
   1196     return (ArrayObject*)obj;
   1197 }
   1198 
   1199 
   1200 /*
   1201  * ===========================================================================
   1202  *      Class
   1203  * ===========================================================================
   1204  */
   1205 
   1206 /*
   1207  * Find the DexAnnotationSetItem for this class.
   1208  */
   1209 static const DexAnnotationSetItem* findAnnotationSetForClass(
   1210     const ClassObject* clazz)
   1211 {
   1212     DexFile* pDexFile;
   1213     const DexAnnotationsDirectoryItem* pAnnoDir;
   1214 
   1215     if (clazz->pDvmDex == NULL)         /* generated class (Proxy, array) */
   1216         return NULL;
   1217 
   1218     pDexFile = clazz->pDvmDex->pDexFile;
   1219     pAnnoDir = getAnnoDirectory(pDexFile, clazz);
   1220     if (pAnnoDir != NULL)
   1221         return dexGetClassAnnotationSet(pDexFile, pAnnoDir);
   1222     else
   1223         return NULL;
   1224 }
   1225 
   1226 /*
   1227  * Return an array of Annotation objects for the class.  Returns an empty
   1228  * array if there are no annotations.
   1229  *
   1230  * Caller must call dvmReleaseTrackedAlloc().
   1231  *
   1232  * On allocation failure, this returns NULL with an exception raised.
   1233  */
   1234 ArrayObject* dvmGetClassAnnotations(const ClassObject* clazz)
   1235 {
   1236     ArrayObject* annoArray;
   1237     const DexAnnotationSetItem* pAnnoSet = NULL;
   1238 
   1239     pAnnoSet = findAnnotationSetForClass(clazz);
   1240     if (pAnnoSet == NULL) {
   1241         /* no annotations for anything in class, or no class annotations */
   1242         annoArray = emptyAnnoArray();
   1243     } else {
   1244         annoArray = processAnnotationSet(clazz, pAnnoSet,
   1245                         kDexVisibilityRuntime);
   1246     }
   1247 
   1248     return annoArray;
   1249 }
   1250 
   1251 /*
   1252  * Returns the annotation or NULL if it doesn't exist.
   1253  */
   1254 Object* dvmGetClassAnnotation(const ClassObject* clazz,
   1255         const ClassObject* annotationClazz)
   1256 {
   1257     const DexAnnotationSetItem* pAnnoSet = findAnnotationSetForClass(clazz);
   1258     if (pAnnoSet == NULL) {
   1259         return NULL;
   1260     }
   1261     return getAnnotationObjectFromAnnotationSet(clazz, pAnnoSet,
   1262             kDexVisibilityRuntime, annotationClazz);
   1263 }
   1264 
   1265 /*
   1266  * Returns true if the annotation exists.
   1267  */
   1268 bool dvmIsClassAnnotationPresent(const ClassObject* clazz,
   1269         const ClassObject* annotationClazz)
   1270 {
   1271     const DexAnnotationSetItem* pAnnoSet = findAnnotationSetForClass(clazz);
   1272     if (pAnnoSet == NULL) {
   1273         return NULL;
   1274     }
   1275     const DexAnnotationItem* pAnnoItem = getAnnotationItemFromAnnotationSet(
   1276             clazz, pAnnoSet, kDexVisibilityRuntime, annotationClazz);
   1277     return (pAnnoItem != NULL);
   1278 }
   1279 
   1280 /*
   1281  * Retrieve the Signature annotation, if any.  Returns NULL if no signature
   1282  * exists.
   1283  *
   1284  * Caller must call dvmReleaseTrackedAlloc().
   1285  */
   1286 ArrayObject* dvmGetClassSignatureAnnotation(const ClassObject* clazz)
   1287 {
   1288     ArrayObject* signature = NULL;
   1289     const DexAnnotationSetItem* pAnnoSet;
   1290 
   1291     pAnnoSet = findAnnotationSetForClass(clazz);
   1292     if (pAnnoSet != NULL)
   1293         signature = getSignatureValue(clazz, pAnnoSet);
   1294 
   1295     return signature;
   1296 }
   1297 
   1298 /*
   1299  * Get the EnclosingMethod attribute from an annotation.  Returns a Method
   1300  * object, or NULL.
   1301  *
   1302  * Caller must call dvmReleaseTrackedAlloc().
   1303  */
   1304 Object* dvmGetEnclosingMethod(const ClassObject* clazz)
   1305 {
   1306     const DexAnnotationItem* pAnnoItem;
   1307     const DexAnnotationSetItem* pAnnoSet;
   1308     Object* obj;
   1309 
   1310     pAnnoSet = findAnnotationSetForClass(clazz);
   1311     if (pAnnoSet == NULL)
   1312         return NULL;
   1313 
   1314     pAnnoItem = searchAnnotationSet(clazz, pAnnoSet, kDescrEnclosingMethod,
   1315         kDexVisibilitySystem);
   1316     if (pAnnoItem == NULL)
   1317         return NULL;
   1318 
   1319     /*
   1320      * The EnclosingMethod annotation has one member, "Method value".
   1321      */
   1322     obj = getAnnotationValue(clazz, pAnnoItem, "value", kDexAnnotationMethod,
   1323             "EnclosingMethod");
   1324     if (obj == GAV_FAILED)
   1325         return NULL;
   1326     assert(obj->clazz == gDvm.classJavaLangReflectConstructor ||
   1327            obj->clazz == gDvm.classJavaLangReflectMethod);
   1328 
   1329     return obj;
   1330 }
   1331 
   1332 /*
   1333  * Find a class' enclosing class.  We return what we find in the
   1334  * EnclosingClass attribute.
   1335  *
   1336  * Returns a Class object, or NULL.
   1337  *
   1338  * Caller must call dvmReleaseTrackedAlloc().
   1339  */
   1340 ClassObject* dvmGetDeclaringClass(const ClassObject* clazz)
   1341 {
   1342     const DexAnnotationItem* pAnnoItem;
   1343     const DexAnnotationSetItem* pAnnoSet;
   1344     Object* obj;
   1345 
   1346     pAnnoSet = findAnnotationSetForClass(clazz);
   1347     if (pAnnoSet == NULL)
   1348         return NULL;
   1349 
   1350     pAnnoItem = searchAnnotationSet(clazz, pAnnoSet, kDescrEnclosingClass,
   1351         kDexVisibilitySystem);
   1352     if (pAnnoItem == NULL)
   1353         return NULL;
   1354 
   1355     /*
   1356      * The EnclosingClass annotation has one member, "Class value".
   1357      */
   1358     obj = getAnnotationValue(clazz, pAnnoItem, "value", kDexAnnotationType,
   1359             "EnclosingClass");
   1360     if (obj == GAV_FAILED)
   1361         return NULL;
   1362 
   1363     assert(dvmIsClassObject(obj));
   1364     return (ClassObject*)obj;
   1365 }
   1366 
   1367 /*
   1368  * Find a class' enclosing class.  We first search for an EnclosingClass
   1369  * attribute, and if that's not found we look for an EnclosingMethod.
   1370  *
   1371  * Returns a Class object, or NULL.
   1372  *
   1373  * Caller must call dvmReleaseTrackedAlloc().
   1374  */
   1375 ClassObject* dvmGetEnclosingClass(const ClassObject* clazz)
   1376 {
   1377     const DexAnnotationItem* pAnnoItem;
   1378     const DexAnnotationSetItem* pAnnoSet;
   1379     Object* obj;
   1380 
   1381     pAnnoSet = findAnnotationSetForClass(clazz);
   1382     if (pAnnoSet == NULL)
   1383         return NULL;
   1384 
   1385     pAnnoItem = searchAnnotationSet(clazz, pAnnoSet, kDescrEnclosingClass,
   1386         kDexVisibilitySystem);
   1387     if (pAnnoItem != NULL) {
   1388         /*
   1389          * The EnclosingClass annotation has one member, "Class value".
   1390          */
   1391         obj = getAnnotationValue(clazz, pAnnoItem, "value", kDexAnnotationType,
   1392                 "EnclosingClass");
   1393         if (obj != GAV_FAILED) {
   1394             assert(dvmIsClassObject(obj));
   1395             return (ClassObject*)obj;
   1396         }
   1397     }
   1398 
   1399     /*
   1400      * That didn't work.  Look for an EnclosingMethod.
   1401      *
   1402      * We could create a java.lang.reflect.Method object and extract the
   1403      * declaringClass from it, but that's more work than we want to do.
   1404      * Instead, we find the "value" item and parse the index out ourselves.
   1405      */
   1406     pAnnoItem = searchAnnotationSet(clazz, pAnnoSet, kDescrEnclosingMethod,
   1407         kDexVisibilitySystem);
   1408     if (pAnnoItem == NULL)
   1409         return NULL;
   1410 
   1411     /* find the value member */
   1412     const u1* ptr;
   1413     ptr = searchEncodedAnnotation(clazz, pAnnoItem->annotation, "value");
   1414     if (ptr == NULL) {
   1415         ALOGW("EnclosingMethod annotation lacks 'value' member");
   1416         return NULL;
   1417     }
   1418 
   1419     /* parse it, verify the type */
   1420     AnnotationValue avalue;
   1421     if (!processAnnotationValue(clazz, &ptr, &avalue, kAllRaw)) {
   1422         ALOGW("EnclosingMethod parse failed");
   1423         return NULL;
   1424     }
   1425     if (avalue.type != kDexAnnotationMethod) {
   1426         ALOGW("EnclosingMethod value has wrong type (0x%02x, expected 0x%02x)",
   1427             avalue.type, kDexAnnotationMethod);
   1428         return NULL;
   1429     }
   1430 
   1431     /* pull out the method index and resolve the method */
   1432     Method* meth = resolveAmbiguousMethod(clazz, avalue.value.i);
   1433     if (meth == NULL)
   1434         return NULL;
   1435 
   1436     ClassObject* methClazz = meth->clazz;
   1437     dvmAddTrackedAlloc((Object*) methClazz, NULL);      // balance the Release
   1438     return methClazz;
   1439 }
   1440 
   1441 /*
   1442  * Get the EnclosingClass attribute from an annotation.  If found, returns
   1443  * "true".  A String with the original name of the class and the original
   1444  * access flags are returned through the arguments.  (The name will be NULL
   1445  * for an anonymous inner class.)
   1446  *
   1447  * Caller must call dvmReleaseTrackedAlloc().
   1448  */
   1449 bool dvmGetInnerClass(const ClassObject* clazz, StringObject** pName,
   1450     int* pAccessFlags)
   1451 {
   1452     const DexAnnotationItem* pAnnoItem;
   1453     const DexAnnotationSetItem* pAnnoSet;
   1454 
   1455     pAnnoSet = findAnnotationSetForClass(clazz);
   1456     if (pAnnoSet == NULL)
   1457         return false;
   1458 
   1459     pAnnoItem = searchAnnotationSet(clazz, pAnnoSet, kDescrInnerClass,
   1460         kDexVisibilitySystem);
   1461     if (pAnnoItem == NULL)
   1462         return false;
   1463 
   1464     /*
   1465      * The InnerClass annotation has two members, "String name" and
   1466      * "int accessFlags".  We don't want to get the access flags as an
   1467      * Integer, so we process that as a simple value.
   1468      */
   1469     const u1* ptr;
   1470     ptr = searchEncodedAnnotation(clazz, pAnnoItem->annotation, "name");
   1471     if (ptr == NULL) {
   1472         ALOGW("InnerClass annotation lacks 'name' member");
   1473         return false;
   1474     }
   1475 
   1476     /* parse it into an Object */
   1477     AnnotationValue avalue;
   1478     if (!processAnnotationValue(clazz, &ptr, &avalue, kAllObjects)) {
   1479         ALOGD("processAnnotationValue failed on InnerClass member 'name'");
   1480         return false;
   1481     }
   1482 
   1483     /* make sure it has the expected format */
   1484     if (avalue.type != kDexAnnotationNull &&
   1485         avalue.type != kDexAnnotationString)
   1486     {
   1487         ALOGW("InnerClass name has bad type (0x%02x, expected STRING or NULL)",
   1488             avalue.type);
   1489         return false;
   1490     }
   1491 
   1492     *pName = (StringObject*) avalue.value.l;
   1493     assert(*pName == NULL || (*pName)->clazz == gDvm.classJavaLangString);
   1494 
   1495     ptr = searchEncodedAnnotation(clazz, pAnnoItem->annotation, "accessFlags");
   1496     if (ptr == NULL) {
   1497         ALOGW("InnerClass annotation lacks 'accessFlags' member");
   1498         return false;
   1499     }
   1500 
   1501     /* parse it, verify the type */
   1502     if (!processAnnotationValue(clazz, &ptr, &avalue, kAllRaw)) {
   1503         ALOGW("InnerClass accessFlags parse failed");
   1504         return false;
   1505     }
   1506     if (avalue.type != kDexAnnotationInt) {
   1507         ALOGW("InnerClass value has wrong type (0x%02x, expected 0x%02x)",
   1508             avalue.type, kDexAnnotationInt);
   1509         return false;
   1510     }
   1511 
   1512     *pAccessFlags = avalue.value.i;
   1513 
   1514     return true;
   1515 }
   1516 
   1517 /*
   1518  * Extract an array of Class objects from the MemberClasses annotation
   1519  * for this class.
   1520  *
   1521  * Caller must call dvmReleaseTrackedAlloc().
   1522  *
   1523  * Returns NULL if we don't find any member classes.
   1524  */
   1525 ArrayObject* dvmGetDeclaredClasses(const ClassObject* clazz)
   1526 {
   1527     const DexAnnotationSetItem* pAnnoSet;
   1528     const DexAnnotationItem* pAnnoItem;
   1529     Object* obj;
   1530 
   1531     pAnnoSet = findAnnotationSetForClass(clazz);
   1532     if (pAnnoSet == NULL)
   1533         return NULL;
   1534 
   1535     pAnnoItem = searchAnnotationSet(clazz, pAnnoSet, kDescrMemberClasses,
   1536         kDexVisibilitySystem);
   1537     if (pAnnoItem == NULL)
   1538         return NULL;
   1539 
   1540     /*
   1541      * The MemberClasses annotation has one member, "Class[] value".
   1542      */
   1543     obj = getAnnotationValue(clazz, pAnnoItem, "value",
   1544             kDexAnnotationArray, "MemberClasses");
   1545     if (obj == GAV_FAILED)
   1546         return NULL;
   1547     assert(dvmIsArray((ArrayObject*)obj));
   1548     obj = convertReturnType(obj, gDvm.classJavaLangClassArray);
   1549     return (ArrayObject*)obj;
   1550 }
   1551 
   1552 
   1553 /*
   1554  * ===========================================================================
   1555  *      Method (and Constructor)
   1556  * ===========================================================================
   1557  */
   1558 
   1559 /*
   1560  * Compare the attributes (class name, method name, method signature) of
   1561  * the specified method to "method".
   1562  */
   1563 static int compareMethodStr(DexFile* pDexFile, u4 methodIdx,
   1564     const Method* method)
   1565 {
   1566     const DexMethodId* pMethodId = dexGetMethodId(pDexFile, methodIdx);
   1567     const char* str = dexStringByTypeIdx(pDexFile, pMethodId->classIdx);
   1568     int result = strcmp(str, method->clazz->descriptor);
   1569 
   1570     if (result == 0) {
   1571         str = dexStringById(pDexFile, pMethodId->nameIdx);
   1572         result = strcmp(str, method->name);
   1573         if (result == 0) {
   1574             DexProto proto;
   1575             dexProtoSetFromMethodId(&proto, pDexFile, pMethodId);
   1576             result = dexProtoCompare(&proto, &method->prototype);
   1577         }
   1578     }
   1579 
   1580     return result;
   1581 }
   1582 
   1583 /*
   1584  * Given a method, determine the method's index.
   1585  *
   1586  * We could simply store this in the Method*, but that would cost 4 bytes
   1587  * per method.  Instead we plow through the DEX data.
   1588  *
   1589  * We have two choices: look through the class method data, or look through
   1590  * the global method_ids table.  The former is awkward because the method
   1591  * could have been defined in a superclass or interface.  The latter works
   1592  * out reasonably well because it's in sorted order, though we're still left
   1593  * doing a fair number of string comparisons.
   1594  */
   1595 static u4 getMethodIdx(const Method* method)
   1596 {
   1597     DexFile* pDexFile = method->clazz->pDvmDex->pDexFile;
   1598     u4 hi = pDexFile->pHeader->methodIdsSize -1;
   1599     u4 lo = 0;
   1600     u4 cur;
   1601 
   1602     while (hi >= lo) {
   1603         int cmp;
   1604         cur = (lo + hi) / 2;
   1605 
   1606         cmp = compareMethodStr(pDexFile, cur, method);
   1607         if (cmp < 0) {
   1608             lo = cur + 1;
   1609         } else if (cmp > 0) {
   1610             hi = cur - 1;
   1611         } else {
   1612             break;
   1613         }
   1614     }
   1615 
   1616     if (hi < lo) {
   1617         /* this should be impossible -- the method came out of this DEX */
   1618         char* desc = dexProtoCopyMethodDescriptor(&method->prototype);
   1619         ALOGE("Unable to find method %s.%s %s in DEX file!",
   1620             method->clazz->descriptor, method->name, desc);
   1621         free(desc);
   1622         dvmAbort();
   1623     }
   1624 
   1625     return cur;
   1626 }
   1627 
   1628 /*
   1629  * Find the DexAnnotationSetItem for this method.
   1630  *
   1631  * Returns NULL if none found.
   1632  */
   1633 static const DexAnnotationSetItem* findAnnotationSetForMethod(
   1634     const Method* method)
   1635 {
   1636     ClassObject* clazz = method->clazz;
   1637     DexFile* pDexFile;
   1638     const DexAnnotationsDirectoryItem* pAnnoDir;
   1639     const DexMethodAnnotationsItem* pMethodList;
   1640     const DexAnnotationSetItem* pAnnoSet = NULL;
   1641 
   1642     if (clazz->pDvmDex == NULL)         /* generated class (Proxy, array) */
   1643         return NULL;
   1644     pDexFile = clazz->pDvmDex->pDexFile;
   1645 
   1646     pAnnoDir = getAnnoDirectory(pDexFile, clazz);
   1647     if (pAnnoDir != NULL) {
   1648         pMethodList = dexGetMethodAnnotations(pDexFile, pAnnoDir);
   1649         if (pMethodList != NULL) {
   1650             /*
   1651              * Run through the list and find a matching method.  We compare the
   1652              * method ref indices in the annotation list with the method's DEX
   1653              * method_idx value.
   1654              *
   1655              * TODO: use a binary search for long lists
   1656              *
   1657              * Alternate approach: for each entry in the annotations list,
   1658              * find the method definition in the DEX file and perform string
   1659              * comparisons on class name, method name, and signature.
   1660              */
   1661             u4 methodIdx = getMethodIdx(method);
   1662             u4 count = dexGetMethodAnnotationsSize(pDexFile, pAnnoDir);
   1663             u4 idx;
   1664 
   1665             for (idx = 0; idx < count; idx++) {
   1666                 if (pMethodList[idx].methodIdx == methodIdx) {
   1667                     /* found! */
   1668                     pAnnoSet = dexGetMethodAnnotationSetItem(pDexFile,
   1669                                     &pMethodList[idx]);
   1670                     break;
   1671                 }
   1672             }
   1673         }
   1674     }
   1675 
   1676     return pAnnoSet;
   1677 }
   1678 
   1679 /*
   1680  * Return an array of Annotation objects for the method.  Returns an empty
   1681  * array if there are no annotations.
   1682  *
   1683  * Caller must call dvmReleaseTrackedAlloc().
   1684  *
   1685  * On allocation failure, this returns NULL with an exception raised.
   1686  */
   1687 ArrayObject* dvmGetMethodAnnotations(const Method* method)
   1688 {
   1689     ClassObject* clazz = method->clazz;
   1690     const DexAnnotationSetItem* pAnnoSet;
   1691     ArrayObject* annoArray = NULL;
   1692 
   1693     pAnnoSet = findAnnotationSetForMethod(method);
   1694     if (pAnnoSet == NULL) {
   1695         /* no matching annotations found */
   1696         annoArray = emptyAnnoArray();
   1697     } else {
   1698         annoArray = processAnnotationSet(clazz, pAnnoSet,kDexVisibilityRuntime);
   1699     }
   1700 
   1701     return annoArray;
   1702 }
   1703 
   1704 /*
   1705  * Returns the annotation or NULL if it doesn't exist.
   1706  */
   1707 Object* dvmGetMethodAnnotation(const ClassObject* clazz, const Method* method,
   1708         const ClassObject* annotationClazz)
   1709 {
   1710     const DexAnnotationSetItem* pAnnoSet = findAnnotationSetForMethod(method);
   1711     if (pAnnoSet == NULL) {
   1712         return NULL;
   1713     }
   1714     return getAnnotationObjectFromAnnotationSet(clazz, pAnnoSet,
   1715             kDexVisibilityRuntime, annotationClazz);
   1716 }
   1717 
   1718 /*
   1719  * Returns true if the annotation exists.
   1720  */
   1721 bool dvmIsMethodAnnotationPresent(const ClassObject* clazz,
   1722         const Method* method, const ClassObject* annotationClazz)
   1723 {
   1724     const DexAnnotationSetItem* pAnnoSet = findAnnotationSetForMethod(method);
   1725     if (pAnnoSet == NULL) {
   1726         return NULL;
   1727     }
   1728     const DexAnnotationItem* pAnnoItem = getAnnotationItemFromAnnotationSet(
   1729             clazz, pAnnoSet, kDexVisibilityRuntime, annotationClazz);
   1730     return (pAnnoItem != NULL);
   1731 }
   1732 
   1733 /*
   1734  * Retrieve the Signature annotation, if any.  Returns NULL if no signature
   1735  * exists.
   1736  *
   1737  * Caller must call dvmReleaseTrackedAlloc().
   1738  */
   1739 ArrayObject* dvmGetMethodSignatureAnnotation(const Method* method)
   1740 {
   1741     ClassObject* clazz = method->clazz;
   1742     const DexAnnotationSetItem* pAnnoSet;
   1743     ArrayObject* signature = NULL;
   1744 
   1745     pAnnoSet = findAnnotationSetForMethod(method);
   1746     if (pAnnoSet != NULL)
   1747         signature = getSignatureValue(clazz, pAnnoSet);
   1748 
   1749     return signature;
   1750 }
   1751 
   1752 /*
   1753  * Extract an array of exception classes from the "system" annotation list
   1754  * for this method.
   1755  *
   1756  * Caller must call dvmReleaseTrackedAlloc().
   1757  *
   1758  * Returns NULL if we don't find any exceptions for this method.
   1759  */
   1760 ArrayObject* dvmGetMethodThrows(const Method* method)
   1761 {
   1762     ClassObject* clazz = method->clazz;
   1763     const DexAnnotationSetItem* pAnnoSet;
   1764     const DexAnnotationItem* pAnnoItem;
   1765 
   1766     /* find the set for this method */
   1767     pAnnoSet = findAnnotationSetForMethod(method);
   1768     if (pAnnoSet == NULL)
   1769         return NULL;        /* nothing for this method */
   1770 
   1771     /* find the "Throws" annotation, if any */
   1772     pAnnoItem = searchAnnotationSet(clazz, pAnnoSet, kDescrThrows,
   1773         kDexVisibilitySystem);
   1774     if (pAnnoItem == NULL)
   1775         return NULL;        /* no Throws */
   1776 
   1777     /*
   1778      * The Throws annotation has one member, "Class[] value".
   1779      */
   1780     Object* obj = getAnnotationValue(clazz, pAnnoItem, "value",
   1781         kDexAnnotationArray, "Throws");
   1782     if (obj == GAV_FAILED)
   1783         return NULL;
   1784     assert(dvmIsArray((ArrayObject*)obj));
   1785     obj = convertReturnType(obj, gDvm.classJavaLangClassArray);
   1786     return (ArrayObject*)obj;
   1787 }
   1788 
   1789 /*
   1790  * Given an Annotation's method, find the default value, if any.
   1791  *
   1792  * If this is a CLASS annotation, and we can't find a match for the
   1793  * default class value, we need to throw a TypeNotPresentException.
   1794  *
   1795  * Caller must call dvmReleaseTrackedAlloc().
   1796  */
   1797 Object* dvmGetAnnotationDefaultValue(const Method* method)
   1798 {
   1799     const ClassObject* clazz = method->clazz;
   1800     DexFile* pDexFile = clazz->pDvmDex->pDexFile;
   1801     const DexAnnotationsDirectoryItem* pAnnoDir;
   1802     const DexAnnotationSetItem* pAnnoSet = NULL;
   1803 
   1804     /*
   1805      * The method's declaring class (the annotation) will have an
   1806      * AnnotationDefault "system" annotation associated with it if any
   1807      * of its methods have default values.  Start by finding the
   1808      * DexAnnotationItem associated with the class.
   1809      */
   1810     pAnnoDir = getAnnoDirectory(pDexFile, clazz);
   1811     if (pAnnoDir != NULL)
   1812         pAnnoSet = dexGetClassAnnotationSet(pDexFile, pAnnoDir);
   1813     if (pAnnoSet == NULL) {
   1814         /* no annotations for anything in class, or no class annotations */
   1815         return NULL;
   1816     }
   1817 
   1818     /* find the "AnnotationDefault" annotation, if any */
   1819     const DexAnnotationItem* pAnnoItem;
   1820     pAnnoItem = searchAnnotationSet(clazz, pAnnoSet, kDescrAnnotationDefault,
   1821         kDexVisibilitySystem);
   1822     if (pAnnoItem == NULL) {
   1823         /* no default values for any member in this annotation */
   1824         //printf("##### no default annotations for %s.%s\n",
   1825         //    method->clazz->descriptor, method->name);
   1826         return NULL;
   1827     }
   1828 
   1829     /*
   1830      * The AnnotationDefault annotation has one member, "Annotation value".
   1831      * We need to pull that out.
   1832      */
   1833     const u1* ptr;
   1834     ptr = searchEncodedAnnotation(clazz, pAnnoItem->annotation, "value");
   1835     if (ptr == NULL) {
   1836         ALOGW("AnnotationDefault annotation lacks 'value'");
   1837         return NULL;
   1838     }
   1839     if ((*ptr & kDexAnnotationValueTypeMask) != kDexAnnotationAnnotation) {
   1840         ALOGW("AnnotationDefault value has wrong type (0x%02x)",
   1841             *ptr & kDexAnnotationValueTypeMask);
   1842         return NULL;
   1843     }
   1844 
   1845     /*
   1846      * The value_type byte for VALUE_ANNOTATION is followed by
   1847      * encoded_annotation data.  We want to scan through it to find an
   1848      * entry whose name matches our method name.
   1849      */
   1850     ptr++;
   1851     ptr = searchEncodedAnnotation(clazz, ptr, method->name);
   1852     if (ptr == NULL)
   1853         return NULL;        /* no default annotation for this method */
   1854 
   1855     /* got it, pull it out */
   1856     AnnotationValue avalue;
   1857     if (!processAnnotationValue(clazz, &ptr, &avalue, kAllObjects)) {
   1858         ALOGD("processAnnotationValue failed on default for '%s'",
   1859             method->name);
   1860         return NULL;
   1861     }
   1862 
   1863     /* convert the return type, if necessary */
   1864     ClassObject* methodReturn = dvmGetBoxedReturnType(method);
   1865     Object* obj = (Object*)avalue.value.l;
   1866     obj = convertReturnType(obj, methodReturn);
   1867 
   1868     return obj;
   1869 }
   1870 
   1871 
   1872 /*
   1873  * ===========================================================================
   1874  *      Field
   1875  * ===========================================================================
   1876  */
   1877 
   1878 /*
   1879  * Compare the attributes (class name, field name, field signature) of
   1880  * the specified field to "field".
   1881  */
   1882 static int compareFieldStr(DexFile* pDexFile, u4 idx, const Field* field)
   1883 {
   1884     const DexFieldId* pFieldId = dexGetFieldId(pDexFile, idx);
   1885     const char* str = dexStringByTypeIdx(pDexFile, pFieldId->classIdx);
   1886     int result = strcmp(str, field->clazz->descriptor);
   1887 
   1888     if (result == 0) {
   1889         str = dexStringById(pDexFile, pFieldId->nameIdx);
   1890         result = strcmp(str, field->name);
   1891         if (result == 0) {
   1892             str = dexStringByTypeIdx(pDexFile, pFieldId->typeIdx);
   1893             result = strcmp(str, field->signature);
   1894         }
   1895     }
   1896 
   1897     return result;
   1898 }
   1899 
   1900 /*
   1901  * Given a field, determine the field's index.
   1902  *
   1903  * This has the same tradeoffs as getMethodIdx.
   1904  */
   1905 static u4 getFieldIdx(const Field* field)
   1906 {
   1907     DexFile* pDexFile = field->clazz->pDvmDex->pDexFile;
   1908     u4 hi = pDexFile->pHeader->fieldIdsSize -1;
   1909     u4 lo = 0;
   1910     u4 cur;
   1911 
   1912     while (hi >= lo) {
   1913         int cmp;
   1914         cur = (lo + hi) / 2;
   1915 
   1916         cmp = compareFieldStr(pDexFile, cur, field);
   1917         if (cmp < 0) {
   1918             lo = cur + 1;
   1919         } else if (cmp > 0) {
   1920             hi = cur - 1;
   1921         } else {
   1922             break;
   1923         }
   1924     }
   1925 
   1926     if (hi < lo) {
   1927         /* this should be impossible -- the field came out of this DEX */
   1928         ALOGE("Unable to find field %s.%s %s in DEX file!",
   1929             field->clazz->descriptor, field->name, field->signature);
   1930         dvmAbort();
   1931     }
   1932 
   1933     return cur;
   1934 }
   1935 
   1936 /*
   1937  * Find the DexAnnotationSetItem for this field.
   1938  *
   1939  * Returns NULL if none found.
   1940  */
   1941 static const DexAnnotationSetItem* findAnnotationSetForField(const Field* field)
   1942 {
   1943     ClassObject* clazz = field->clazz;
   1944     DexFile* pDexFile = clazz->pDvmDex->pDexFile;
   1945     const DexAnnotationsDirectoryItem* pAnnoDir;
   1946     const DexFieldAnnotationsItem* pFieldList;
   1947 
   1948     pAnnoDir = getAnnoDirectory(pDexFile, clazz);
   1949     if (pAnnoDir == NULL)
   1950         return NULL;
   1951 
   1952     pFieldList = dexGetFieldAnnotations(pDexFile, pAnnoDir);
   1953     if (pFieldList == NULL)
   1954         return NULL;
   1955 
   1956     /*
   1957      * Run through the list and find a matching field.  We compare the
   1958      * field ref indices in the annotation list with the field's DEX
   1959      * field_idx value.
   1960      *
   1961      * TODO: use a binary search for long lists
   1962      *
   1963      * Alternate approach: for each entry in the annotations list,
   1964      * find the field definition in the DEX file and perform string
   1965      * comparisons on class name, field name, and signature.
   1966      */
   1967     u4 fieldIdx = getFieldIdx(field);
   1968     u4 count = dexGetFieldAnnotationsSize(pDexFile, pAnnoDir);
   1969     u4 idx;
   1970 
   1971     for (idx = 0; idx < count; idx++) {
   1972         if (pFieldList[idx].fieldIdx == fieldIdx) {
   1973             /* found! */
   1974             return dexGetFieldAnnotationSetItem(pDexFile, &pFieldList[idx]);
   1975         }
   1976     }
   1977 
   1978     return NULL;
   1979 }
   1980 
   1981 /*
   1982  * Return an array of Annotation objects for the field.  Returns an empty
   1983  * array if there are no annotations.
   1984  *
   1985  * Caller must call dvmReleaseTrackedAlloc().
   1986  *
   1987  * On allocation failure, this returns NULL with an exception raised.
   1988  */
   1989 ArrayObject* dvmGetFieldAnnotations(const Field* field)
   1990 {
   1991     ClassObject* clazz = field->clazz;
   1992     ArrayObject* annoArray = NULL;
   1993     const DexAnnotationSetItem* pAnnoSet = NULL;
   1994 
   1995     pAnnoSet = findAnnotationSetForField(field);
   1996     if (pAnnoSet == NULL) {
   1997         /* no matching annotations found */
   1998         annoArray = emptyAnnoArray();
   1999     } else {
   2000         annoArray = processAnnotationSet(clazz, pAnnoSet,
   2001                         kDexVisibilityRuntime);
   2002     }
   2003 
   2004     return annoArray;
   2005 }
   2006 
   2007 /*
   2008  * Returns the annotation or NULL if it doesn't exist.
   2009  */
   2010 Object* dvmGetFieldAnnotation(const ClassObject* clazz, const Field* field,
   2011         const ClassObject* annotationClazz)
   2012 {
   2013     const DexAnnotationSetItem* pAnnoSet = findAnnotationSetForField(field);
   2014     if (pAnnoSet == NULL) {
   2015         return NULL;
   2016     }
   2017     return getAnnotationObjectFromAnnotationSet(clazz, pAnnoSet,
   2018             kDexVisibilityRuntime, annotationClazz);
   2019 }
   2020 
   2021 /*
   2022  * Returns true if the annotation exists.
   2023  */
   2024 bool dvmIsFieldAnnotationPresent(const ClassObject* clazz,
   2025         const Field* field, const ClassObject* annotationClazz)
   2026 {
   2027     const DexAnnotationSetItem* pAnnoSet = findAnnotationSetForField(field);
   2028     if (pAnnoSet == NULL) {
   2029         return NULL;
   2030     }
   2031     const DexAnnotationItem* pAnnoItem = getAnnotationItemFromAnnotationSet(
   2032             clazz, pAnnoSet, kDexVisibilityRuntime, annotationClazz);
   2033     return (pAnnoItem != NULL);
   2034 }
   2035 
   2036 /*
   2037  * Retrieve the Signature annotation, if any.  Returns NULL if no signature
   2038  * exists.
   2039  *
   2040  * Caller must call dvmReleaseTrackedAlloc().
   2041  */
   2042 ArrayObject* dvmGetFieldSignatureAnnotation(const Field* field)
   2043 {
   2044     ClassObject* clazz = field->clazz;
   2045     const DexAnnotationSetItem* pAnnoSet;
   2046     ArrayObject* signature = NULL;
   2047 
   2048     pAnnoSet = findAnnotationSetForField(field);
   2049     if (pAnnoSet != NULL)
   2050         signature = getSignatureValue(clazz, pAnnoSet);
   2051 
   2052     return signature;
   2053 }
   2054 
   2055 
   2056 /*
   2057  * ===========================================================================
   2058  *      Parameter
   2059  * ===========================================================================
   2060  */
   2061 
   2062 /*
   2063  * We have an annotation_set_ref_list, which is essentially a list of
   2064  * entries that we pass to processAnnotationSet().
   2065  *
   2066  * The returned object must be released with dvmReleaseTrackedAlloc.
   2067  */
   2068 static ArrayObject* processAnnotationSetRefList(const ClassObject* clazz,
   2069     const DexAnnotationSetRefList* pAnnoSetList, u4 count)
   2070 {
   2071     DexFile* pDexFile = clazz->pDvmDex->pDexFile;
   2072     ArrayObject* annoArrayArray = NULL;
   2073     u4 idx;
   2074 
   2075     /* allocate an array of Annotation arrays to hold results */
   2076     annoArrayArray = dvmAllocArrayByClass(
   2077         gDvm.classJavaLangAnnotationAnnotationArrayArray, count, ALLOC_DEFAULT);
   2078     if (annoArrayArray == NULL) {
   2079         ALOGW("annotation set ref array alloc failed");
   2080         goto bail;
   2081     }
   2082 
   2083     for (idx = 0; idx < count; idx++) {
   2084         Thread* self = dvmThreadSelf();
   2085         const DexAnnotationSetRefItem* pItem;
   2086         const DexAnnotationSetItem* pAnnoSet;
   2087         Object *annoSet;
   2088         DexAnnotationSetItem emptySet;
   2089         emptySet.size = 0;
   2090 
   2091         pItem = dexGetParameterAnnotationSetRef(pAnnoSetList, idx);
   2092         pAnnoSet = dexGetSetRefItemItem(pDexFile, pItem);
   2093         if (pAnnoSet == NULL) {
   2094             pAnnoSet = &emptySet;
   2095         }
   2096 
   2097         annoSet = (Object *)processAnnotationSet(clazz,
   2098                                                  pAnnoSet,
   2099                                                  kDexVisibilityRuntime);
   2100         if (annoSet == NULL) {
   2101             ALOGW("processAnnotationSet failed");
   2102             annoArrayArray = NULL;
   2103             goto bail;
   2104         }
   2105         dvmSetObjectArrayElement(annoArrayArray, idx, annoSet);
   2106         dvmReleaseTrackedAlloc((Object*) annoSet, self);
   2107     }
   2108 
   2109 bail:
   2110     return annoArrayArray;
   2111 }
   2112 
   2113 /*
   2114  * Find the DexAnnotationSetItem for this parameter.
   2115  *
   2116  * Returns NULL if none found.
   2117  */
   2118 static const DexParameterAnnotationsItem* findAnnotationsItemForMethod(
   2119     const Method* method)
   2120 {
   2121     ClassObject* clazz = method->clazz;
   2122     DexFile* pDexFile;
   2123     const DexAnnotationsDirectoryItem* pAnnoDir;
   2124     const DexParameterAnnotationsItem* pParameterList;
   2125 
   2126     if (clazz->pDvmDex == NULL)         /* generated class (Proxy, array) */
   2127         return NULL;
   2128 
   2129     pDexFile = clazz->pDvmDex->pDexFile;
   2130     pAnnoDir = getAnnoDirectory(pDexFile, clazz);
   2131     if (pAnnoDir == NULL)
   2132         return NULL;
   2133 
   2134     pParameterList = dexGetParameterAnnotations(pDexFile, pAnnoDir);
   2135     if (pParameterList == NULL)
   2136         return NULL;
   2137 
   2138     /*
   2139      * Run through the list and find a matching method.  We compare the
   2140      * method ref indices in the annotation list with the method's DEX
   2141      * method_idx value.
   2142      *
   2143      * TODO: use a binary search for long lists
   2144      *
   2145      * Alternate approach: for each entry in the annotations list,
   2146      * find the method definition in the DEX file and perform string
   2147      * comparisons on class name, method name, and signature.
   2148      */
   2149     u4 methodIdx = getMethodIdx(method);
   2150     u4 count = dexGetParameterAnnotationsSize(pDexFile, pAnnoDir);
   2151     u4 idx;
   2152 
   2153     for (idx = 0; idx < count; idx++) {
   2154         if (pParameterList[idx].methodIdx == methodIdx) {
   2155             /* found! */
   2156             return &pParameterList[idx];
   2157         }
   2158     }
   2159 
   2160     return NULL;
   2161 }
   2162 
   2163 
   2164 /*
   2165  * Count up the number of arguments the method takes.  The "this" pointer
   2166  * doesn't count.
   2167  */
   2168 static int countMethodArguments(const Method* method)
   2169 {
   2170     /* method->shorty[0] is the return type */
   2171     return strlen(method->shorty + 1);
   2172 }
   2173 
   2174 /*
   2175  * Return an array of arrays of Annotation objects.  The outer array has
   2176  * one entry per method parameter, the inner array has the list of annotations
   2177  * associated with that parameter.
   2178  *
   2179  * If the method has no parameters, we return an array of length zero.  If
   2180  * the method has one or more parameters, we return an array whose length
   2181  * is equal to the number of parameters; if a given parameter does not have
   2182  * an annotation, the corresponding entry will be null.
   2183  *
   2184  * Caller must call dvmReleaseTrackedAlloc().
   2185  */
   2186 ArrayObject* dvmGetParameterAnnotations(const Method* method)
   2187 {
   2188     ClassObject* clazz = method->clazz;
   2189     const DexParameterAnnotationsItem* pItem;
   2190     ArrayObject* annoArrayArray = NULL;
   2191 
   2192     pItem = findAnnotationsItemForMethod(method);
   2193     if (pItem != NULL) {
   2194         DexFile* pDexFile = clazz->pDvmDex->pDexFile;
   2195         const DexAnnotationSetRefList* pAnnoSetList;
   2196         u4 size;
   2197 
   2198         size = dexGetParameterAnnotationSetRefSize(pDexFile, pItem);
   2199         pAnnoSetList = dexGetParameterAnnotationSetRefList(pDexFile, pItem);
   2200         annoArrayArray = processAnnotationSetRefList(clazz, pAnnoSetList, size);
   2201     } else {
   2202         /* no matching annotations found */
   2203         annoArrayArray = emptyAnnoArrayArray(countMethodArguments(method));
   2204     }
   2205 
   2206     return annoArrayArray;
   2207 }
   2208 
   2209 
   2210 /*
   2211  * ===========================================================================
   2212  *      DexEncodedArray interpretation
   2213  * ===========================================================================
   2214  */
   2215 
   2216 /**
   2217  * Initializes an encoded array iterator.
   2218  *
   2219  * @param iterator iterator to initialize
   2220  * @param encodedArray encoded array to iterate over
   2221  * @param clazz class to use when resolving strings and types
   2222  */
   2223 void dvmEncodedArrayIteratorInitialize(EncodedArrayIterator* iterator,
   2224         const DexEncodedArray* encodedArray, const ClassObject* clazz) {
   2225     iterator->encodedArray = encodedArray;
   2226     iterator->cursor = encodedArray->array;
   2227     iterator->size = readUleb128(&iterator->cursor);
   2228     iterator->elementsLeft = iterator->size;
   2229     iterator->clazz = clazz;
   2230 }
   2231 
   2232 /**
   2233  * Returns whether there are more elements to be read.
   2234  */
   2235 bool dvmEncodedArrayIteratorHasNext(const EncodedArrayIterator* iterator) {
   2236     return (iterator->elementsLeft != 0);
   2237 }
   2238 
   2239 /**
   2240  * Returns the next decoded value from the iterator, advancing its
   2241  * cursor. This returns primitive values in their corresponding union
   2242  * slots, and returns everything else (including nulls) as object
   2243  * references in the "l" union slot.
   2244  *
   2245  * The caller must call dvmReleaseTrackedAlloc() on any returned reference.
   2246  *
   2247  * @param value pointer to store decoded value into
   2248  * @returns true if a value was decoded and the cursor advanced; false if
   2249  * the last value had already been decoded or if there was a problem decoding
   2250  */
   2251 bool dvmEncodedArrayIteratorGetNext(EncodedArrayIterator* iterator,
   2252         AnnotationValue* value) {
   2253     bool processed;
   2254 
   2255     if (iterator->elementsLeft == 0) {
   2256         return false;
   2257     }
   2258 
   2259     processed = processAnnotationValue(iterator->clazz, &iterator->cursor,
   2260             value, kPrimitivesOrObjects);
   2261 
   2262     if (! processed) {
   2263         ALOGE("Failed to process array element %d from %p",
   2264                 iterator->size - iterator->elementsLeft,
   2265                 iterator->encodedArray);
   2266         iterator->elementsLeft = 0;
   2267         return false;
   2268     }
   2269 
   2270     iterator->elementsLeft--;
   2271     return true;
   2272 }
   2273