Home | History | Annotate | Download | only in oo
      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 /*
     18  * Declaration of the fundamental Object type and refinements thereof, plus
     19  * some functions for manipulating them.
     20  */
     21 #ifndef DALVIK_OO_OBJECT_H_
     22 #define DALVIK_OO_OBJECT_H_
     23 
     24 #include <stddef.h>
     25 #include "Atomic.h"
     26 
     27 /* fwd decl */
     28 struct DataObject;
     29 struct InitiatingLoaderList;
     30 struct ClassObject;
     31 struct StringObject;
     32 struct ArrayObject;
     33 struct Method;
     34 struct ExceptionEntry;
     35 struct LineNumEntry;
     36 struct StaticField;
     37 struct InstField;
     38 struct Field;
     39 struct RegisterMap;
     40 
     41 /*
     42  * Native function pointer type.
     43  *
     44  * "args[0]" holds the "this" pointer for virtual methods.
     45  *
     46  * The "Bridge" form is a super-set of the "Native" form; in many places
     47  * they are used interchangeably.  Currently, all functions have all
     48  * arguments passed in, but some functions only care about the first two.
     49  * Passing extra arguments to a C function is (mostly) harmless.
     50  */
     51 typedef void (*DalvikBridgeFunc)(const u4* args, JValue* pResult,
     52     const Method* method, struct Thread* self);
     53 typedef void (*DalvikNativeFunc)(const u4* args, JValue* pResult);
     54 
     55 
     56 /* vm-internal access flags and related definitions */
     57 enum AccessFlags {
     58     ACC_MIRANDA         = 0x8000,       // method (internal to VM)
     59     JAVA_FLAGS_MASK     = 0xffff,       // bits set from Java sources (low 16)
     60 };
     61 
     62 /* Use the top 16 bits of the access flags field for
     63  * other class flags.  Code should use the *CLASS_FLAG*()
     64  * macros to set/get these flags.
     65  */
     66 enum ClassFlags {
     67     CLASS_ISFINALIZABLE        = (1<<31), // class/ancestor overrides finalize()
     68     CLASS_ISARRAY              = (1<<30), // class is a "[*"
     69     CLASS_ISOBJECTARRAY        = (1<<29), // class is a "[L*" or "[[*"
     70     CLASS_ISCLASS              = (1<<28), // class is *the* class Class
     71 
     72     CLASS_ISREFERENCE          = (1<<27), // class is a soft/weak/phantom ref
     73                                           // only ISREFERENCE is set --> soft
     74     CLASS_ISWEAKREFERENCE      = (1<<26), // class is a weak reference
     75     CLASS_ISFINALIZERREFERENCE = (1<<25), // class is a finalizer reference
     76     CLASS_ISPHANTOMREFERENCE   = (1<<24), // class is a phantom reference
     77 
     78     CLASS_MULTIPLE_DEFS        = (1<<23), // DEX verifier: defs in multiple DEXs
     79 
     80     /* unlike the others, these can be present in the optimized DEX file */
     81     CLASS_ISOPTIMIZED          = (1<<17), // class may contain opt instrs
     82     CLASS_ISPREVERIFIED        = (1<<16), // class has been pre-verified
     83 };
     84 
     85 /* bits we can reasonably expect to see set in a DEX access flags field */
     86 #define EXPECTED_FILE_FLAGS \
     87     (ACC_CLASS_MASK | CLASS_ISPREVERIFIED | CLASS_ISOPTIMIZED)
     88 
     89 /*
     90  * Get/set class flags.
     91  */
     92 #define SET_CLASS_FLAG(clazz, flag) \
     93     do { (clazz)->accessFlags |= (flag); } while (0)
     94 
     95 #define CLEAR_CLASS_FLAG(clazz, flag) \
     96     do { (clazz)->accessFlags &= ~(flag); } while (0)
     97 
     98 #define IS_CLASS_FLAG_SET(clazz, flag) \
     99     (((clazz)->accessFlags & (flag)) != 0)
    100 
    101 #define GET_CLASS_FLAG_GROUP(clazz, flags) \
    102     ((u4)((clazz)->accessFlags & (flags)))
    103 
    104 /*
    105  * Use the top 16 bits of the access flags field for other method flags.
    106  * Code should use the *METHOD_FLAG*() macros to set/get these flags.
    107  */
    108 enum MethodFlags {
    109     METHOD_ISWRITABLE       = (1<<31),  // the method's code is writable
    110 };
    111 
    112 /*
    113  * Get/set method flags.
    114  */
    115 #define SET_METHOD_FLAG(method, flag) \
    116     do { (method)->accessFlags |= (flag); } while (0)
    117 
    118 #define CLEAR_METHOD_FLAG(method, flag) \
    119     do { (method)->accessFlags &= ~(flag); } while (0)
    120 
    121 #define IS_METHOD_FLAG_SET(method, flag) \
    122     (((method)->accessFlags & (flag)) != 0)
    123 
    124 #define GET_METHOD_FLAG_GROUP(method, flags) \
    125     ((u4)((method)->accessFlags & (flags)))
    126 
    127 /* current state of the class, increasing as we progress */
    128 enum ClassStatus {
    129     CLASS_ERROR         = -1,
    130 
    131     CLASS_NOTREADY      = 0,
    132     CLASS_IDX           = 1,    /* loaded, DEX idx in super or ifaces */
    133     CLASS_LOADED        = 2,    /* DEX idx values resolved */
    134     CLASS_RESOLVED      = 3,    /* part of linking */
    135     CLASS_VERIFYING     = 4,    /* in the process of being verified */
    136     CLASS_VERIFIED      = 5,    /* logically part of linking; done pre-init */
    137     CLASS_INITIALIZING  = 6,    /* class init in progress */
    138     CLASS_INITIALIZED   = 7,    /* ready to go */
    139 };
    140 
    141 /*
    142  * Definitions for packing refOffsets in ClassObject.
    143  */
    144 /*
    145  * A magic value for refOffsets. Ignore the bits and walk the super
    146  * chain when this is the value.
    147  * [This is an unlikely "natural" value, since it would be 30 non-ref instance
    148  * fields followed by 2 ref instance fields.]
    149  */
    150 #define CLASS_WALK_SUPER ((unsigned int)(3))
    151 #define CLASS_SMALLEST_OFFSET (sizeof(struct Object))
    152 #define CLASS_BITS_PER_WORD (sizeof(unsigned long int) * 8)
    153 #define CLASS_OFFSET_ALIGNMENT 4
    154 #define CLASS_HIGH_BIT ((unsigned int)1 << (CLASS_BITS_PER_WORD - 1))
    155 /*
    156  * Given an offset, return the bit number which would encode that offset.
    157  * Local use only.
    158  */
    159 #define _CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset) \
    160     (((unsigned int)(byteOffset) - CLASS_SMALLEST_OFFSET) / \
    161      CLASS_OFFSET_ALIGNMENT)
    162 /*
    163  * Is the given offset too large to be encoded?
    164  */
    165 #define CLASS_CAN_ENCODE_OFFSET(byteOffset) \
    166     (_CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset) < CLASS_BITS_PER_WORD)
    167 /*
    168  * Return a single bit, encoding the offset.
    169  * Undefined if the offset is too large, as defined above.
    170  */
    171 #define CLASS_BIT_FROM_OFFSET(byteOffset) \
    172     (CLASS_HIGH_BIT >> _CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset))
    173 /*
    174  * Return an offset, given a bit number as returned from CLZ.
    175  */
    176 #define CLASS_OFFSET_FROM_CLZ(rshift) \
    177     (((int)(rshift) * CLASS_OFFSET_ALIGNMENT) + CLASS_SMALLEST_OFFSET)
    178 
    179 
    180 /*
    181  * Used for iftable in ClassObject.
    182  */
    183 struct InterfaceEntry {
    184     /* pointer to interface class */
    185     ClassObject*    clazz;
    186 
    187     /*
    188      * Index into array of vtable offsets.  This points into the ifviPool,
    189      * which holds the vtables for all interfaces declared by this class.
    190      */
    191     int*            methodIndexArray;
    192 };
    193 
    194 
    195 
    196 /*
    197  * There are three types of objects:
    198  *  Class objects - an instance of java.lang.Class
    199  *  Array objects - an object created with a "new array" instruction
    200  *  Data objects - an object that is neither of the above
    201  *
    202  * We also define String objects.  At present they're equivalent to
    203  * DataObject, but that may change.  (Either way, they make some of the
    204  * code more obvious.)
    205  *
    206  * All objects have an Object header followed by type-specific data.
    207  */
    208 struct Object {
    209     /* ptr to class object */
    210     ClassObject*    clazz;
    211 
    212     /*
    213      * A word containing either a "thin" lock or a "fat" monitor.  See
    214      * the comments in Sync.c for a description of its layout.
    215      */
    216     u4              lock;
    217 };
    218 
    219 /*
    220  * Properly initialize an Object.
    221  * void DVM_OBJECT_INIT(Object *obj, ClassObject *clazz_)
    222  */
    223 #define DVM_OBJECT_INIT(obj, clazz_) \
    224     dvmSetFieldObject(obj, OFFSETOF_MEMBER(Object, clazz), clazz_)
    225 
    226 /*
    227  * Data objects have an Object header followed by their instance data.
    228  */
    229 struct DataObject : Object {
    230     /* variable #of u4 slots; u8 uses 2 slots */
    231     u4              instanceData[1];
    232 };
    233 
    234 /*
    235  * Strings are used frequently enough that we may want to give them their
    236  * own unique type.
    237  *
    238  * Using a dedicated type object to access the instance data provides a
    239  * performance advantage but makes the java/lang/String.java implementation
    240  * fragile.
    241  *
    242  * Currently this is just equal to DataObject, and we pull the fields out
    243  * like we do for any other object.
    244  */
    245 struct StringObject : Object {
    246     /* variable #of u4 slots; u8 uses 2 slots */
    247     u4              instanceData[1];
    248 
    249     /** Returns this string's length in characters. */
    250     int length() const;
    251 
    252     /**
    253      * Returns this string's length in bytes when encoded as modified UTF-8.
    254      * Does not include a terminating NUL byte.
    255      */
    256     int utfLength() const;
    257 
    258     /** Returns this string's char[] as an ArrayObject. */
    259     ArrayObject* array() const;
    260 
    261     /** Returns this string's char[] as a u2*. */
    262     const u2* chars() const;
    263 };
    264 
    265 
    266 /*
    267  * Array objects have these additional fields.
    268  *
    269  * We don't currently store the size of each element.  Usually it's implied
    270  * by the instruction.  If necessary, the width can be derived from
    271  * the first char of obj->clazz->descriptor.
    272  */
    273 struct ArrayObject : Object {
    274     /* number of elements; immutable after init */
    275     u4              length;
    276 
    277     /*
    278      * Array contents; actual size is (length * sizeof(type)).  This is
    279      * declared as u8 so that the compiler inserts any necessary padding
    280      * (e.g. for EABI); the actual allocation may be smaller than 8 bytes.
    281      */
    282     u8              contents[1];
    283 };
    284 
    285 /*
    286  * For classes created early and thus probably in the zygote, the
    287  * InitiatingLoaderList is kept in gDvm. Later classes use the structure in
    288  * Object Class. This helps keep zygote pages shared.
    289  */
    290 struct InitiatingLoaderList {
    291     /* a list of initiating loader Objects; grown and initialized on demand */
    292     Object**  initiatingLoaders;
    293     /* count of loaders in the above list */
    294     int       initiatingLoaderCount;
    295 };
    296 
    297 /*
    298  * Generic field header.  We pass this around when we want a generic Field
    299  * pointer (e.g. for reflection stuff).  Testing the accessFlags for
    300  * ACC_STATIC allows a proper up-cast.
    301  */
    302 struct Field {
    303     ClassObject*    clazz;          /* class in which the field is declared */
    304     const char*     name;
    305     const char*     signature;      /* e.g. "I", "[C", "Landroid/os/Debug;" */
    306     u4              accessFlags;
    307 };
    308 
    309 /*
    310  * Static field.
    311  */
    312 struct StaticField : Field {
    313     JValue          value;          /* initially set from DEX for primitives */
    314 };
    315 
    316 /*
    317  * Instance field.
    318  */
    319 struct InstField : Field {
    320     /*
    321      * This field indicates the byte offset from the beginning of the
    322      * (Object *) to the actual instance data; e.g., byteOffset==0 is
    323      * the same as the object pointer (bug!), and byteOffset==4 is 4
    324      * bytes farther.
    325      */
    326     int             byteOffset;
    327 };
    328 
    329 /*
    330  * This defines the amount of space we leave for field slots in the
    331  * java.lang.Class definition.  If we alter the class to have more than
    332  * this many fields, the VM will abort at startup.
    333  */
    334 #define CLASS_FIELD_SLOTS   4
    335 
    336 /*
    337  * Class objects have many additional fields.  This is used for both
    338  * classes and interfaces, including synthesized classes (arrays and
    339  * primitive types).
    340  *
    341  * Class objects are unusual in that they have some fields allocated with
    342  * the system malloc (or LinearAlloc), rather than on the GC heap.  This is
    343  * handy during initialization, but does require special handling when
    344  * discarding java.lang.Class objects.
    345  *
    346  * The separation of methods (direct vs. virtual) and fields (class vs.
    347  * instance) used in Dalvik works out pretty well.  The only time it's
    348  * annoying is when enumerating or searching for things with reflection.
    349  */
    350 struct ClassObject : Object {
    351     /* leave space for instance data; we could access fields directly if we
    352        freeze the definition of java/lang/Class */
    353     u4              instanceData[CLASS_FIELD_SLOTS];
    354 
    355     /* UTF-8 descriptor for the class; from constant pool, or on heap
    356        if generated ("[C") */
    357     const char*     descriptor;
    358     char*           descriptorAlloc;
    359 
    360     /* access flags; low 16 bits are defined by VM spec */
    361     u4              accessFlags;
    362 
    363     /* VM-unique class serial number, nonzero, set very early */
    364     u4              serialNumber;
    365 
    366     /* DexFile from which we came; needed to resolve constant pool entries */
    367     /* (will be NULL for VM-generated, e.g. arrays and primitive classes) */
    368     DvmDex*         pDvmDex;
    369 
    370     /* state of class initialization */
    371     ClassStatus     status;
    372 
    373     /* if class verify fails, we must return same error on subsequent tries */
    374     ClassObject*    verifyErrorClass;
    375 
    376     /* threadId, used to check for recursive <clinit> invocation */
    377     u4              initThreadId;
    378 
    379     /*
    380      * Total object size; used when allocating storage on gc heap.  (For
    381      * interfaces and abstract classes this will be zero.)
    382      */
    383     size_t          objectSize;
    384 
    385     /* arrays only: class object for base element, for instanceof/checkcast
    386        (for String[][][], this will be String) */
    387     ClassObject*    elementClass;
    388 
    389     /* arrays only: number of dimensions, e.g. int[][] is 2 */
    390     int             arrayDim;
    391 
    392     /* primitive type index, or PRIM_NOT (-1); set for generated prim classes */
    393     PrimitiveType   primitiveType;
    394 
    395     /* superclass, or NULL if this is java.lang.Object */
    396     ClassObject*    super;
    397 
    398     /* defining class loader, or NULL for the "bootstrap" system loader */
    399     Object*         classLoader;
    400 
    401     /* initiating class loader list */
    402     /* NOTE: for classes with low serialNumber, these are unused, and the
    403        values are kept in a table in gDvm. */
    404     InitiatingLoaderList initiatingLoaderList;
    405 
    406     /* array of interfaces this class implements directly */
    407     int             interfaceCount;
    408     ClassObject**   interfaces;
    409 
    410     /* static, private, and <init> methods */
    411     int             directMethodCount;
    412     Method*         directMethods;
    413 
    414     /* virtual methods defined in this class; invoked through vtable */
    415     int             virtualMethodCount;
    416     Method*         virtualMethods;
    417 
    418     /*
    419      * Virtual method table (vtable), for use by "invoke-virtual".  The
    420      * vtable from the superclass is copied in, and virtual methods from
    421      * our class either replace those from the super or are appended.
    422      */
    423     int             vtableCount;
    424     Method**        vtable;
    425 
    426     /*
    427      * Interface table (iftable), one entry per interface supported by
    428      * this class.  That means one entry for each interface we support
    429      * directly, indirectly via superclass, or indirectly via
    430      * superinterface.  This will be null if neither we nor our superclass
    431      * implement any interfaces.
    432      *
    433      * Why we need this: given "class Foo implements Face", declare
    434      * "Face faceObj = new Foo()".  Invoke faceObj.blah(), where "blah" is
    435      * part of the Face interface.  We can't easily use a single vtable.
    436      *
    437      * For every interface a concrete class implements, we create a list of
    438      * virtualMethod indices for the methods in the interface.
    439      */
    440     int             iftableCount;
    441     InterfaceEntry* iftable;
    442 
    443     /*
    444      * The interface vtable indices for iftable get stored here.  By placing
    445      * them all in a single pool for each class that implements interfaces,
    446      * we decrease the number of allocations.
    447      */
    448     int             ifviPoolCount;
    449     int*            ifviPool;
    450 
    451     /* instance fields
    452      *
    453      * These describe the layout of the contents of a DataObject-compatible
    454      * Object.  Note that only the fields directly defined by this class
    455      * are listed in ifields;  fields defined by a superclass are listed
    456      * in the superclass's ClassObject.ifields.
    457      *
    458      * All instance fields that refer to objects are guaranteed to be
    459      * at the beginning of the field list.  ifieldRefCount specifies
    460      * the number of reference fields.
    461      */
    462     int             ifieldCount;
    463     int             ifieldRefCount; // number of fields that are object refs
    464     InstField*      ifields;
    465 
    466     /* bitmap of offsets of ifields */
    467     u4 refOffsets;
    468 
    469     /* source file name, if known */
    470     const char*     sourceFile;
    471 
    472     /* static fields */
    473     int             sfieldCount;
    474     StaticField     sfields[0]; /* MUST be last item */
    475 };
    476 
    477 /*
    478  * A method.  We create one of these for every method in every class
    479  * we load, so try to keep the size to a minimum.
    480  *
    481  * Much of this comes from and could be accessed in the data held in shared
    482  * memory.  We hold it all together here for speed.  Everything but the
    483  * pointers could be held in a shared table generated by the optimizer;
    484  * if we're willing to convert them to offsets and take the performance
    485  * hit (e.g. "meth->insns" becomes "baseAddr + meth->insnsOffset") we
    486  * could move everything but "nativeFunc".
    487  */
    488 struct Method {
    489     /* the class we are a part of */
    490     ClassObject*    clazz;
    491 
    492     /* access flags; low 16 bits are defined by spec (could be u2?) */
    493     u4              accessFlags;
    494 
    495     /*
    496      * For concrete virtual methods, this is the offset of the method
    497      * in "vtable".
    498      *
    499      * For abstract methods in an interface class, this is the offset
    500      * of the method in "iftable[n]->methodIndexArray".
    501      */
    502     u2             methodIndex;
    503 
    504     /*
    505      * Method bounds; not needed for an abstract method.
    506      *
    507      * For a native method, we compute the size of the argument list, and
    508      * set "insSize" and "registerSize" equal to it.
    509      */
    510     u2              registersSize;  /* ins + locals */
    511     u2              outsSize;
    512     u2              insSize;
    513 
    514     /* method name, e.g. "<init>" or "eatLunch" */
    515     const char*     name;
    516 
    517     /*
    518      * Method prototype descriptor string (return and argument types).
    519      *
    520      * TODO: This currently must specify the DexFile as well as the proto_ids
    521      * index, because generated Proxy classes don't have a DexFile.  We can
    522      * remove the DexFile* and reduce the size of this struct if we generate
    523      * a DEX for proxies.
    524      */
    525     DexProto        prototype;
    526 
    527     /* short-form method descriptor string */
    528     const char*     shorty;
    529 
    530     /*
    531      * The remaining items are not used for abstract or native methods.
    532      * (JNI is currently hijacking "insns" as a function pointer, set
    533      * after the first call.  For internal-native this stays null.)
    534      */
    535 
    536     /* the actual code */
    537     const u2*       insns;          /* instructions, in memory-mapped .dex */
    538 
    539     /* JNI: cached argument and return-type hints */
    540     int             jniArgInfo;
    541 
    542     /*
    543      * JNI: native method ptr; could be actual function or a JNI bridge.  We
    544      * don't currently discriminate between DalvikBridgeFunc and
    545      * DalvikNativeFunc; the former takes an argument superset (i.e. two
    546      * extra args) which will be ignored.  If necessary we can use
    547      * insns==NULL to detect JNI bridge vs. internal native.
    548      */
    549     DalvikBridgeFunc nativeFunc;
    550 
    551     /*
    552      * JNI: true if this static non-synchronized native method (that has no
    553      * reference arguments) needs a JNIEnv* and jclass/jobject. Libcore
    554      * uses this.
    555      */
    556     bool fastJni;
    557 
    558     /*
    559      * JNI: true if this method has no reference arguments. This lets the JNI
    560      * bridge avoid scanning the shorty for direct pointers that need to be
    561      * converted to local references.
    562      *
    563      * TODO: replace this with a list of indexes of the reference arguments.
    564      */
    565     bool noRef;
    566 
    567     /*
    568      * JNI: true if we should log entry and exit. This is the only way
    569      * developers can log the local references that are passed into their code.
    570      * Used for debugging JNI problems in third-party code.
    571      */
    572     bool shouldTrace;
    573 
    574     /*
    575      * Register map data, if available.  This will point into the DEX file
    576      * if the data was computed during pre-verification, or into the
    577      * linear alloc area if not.
    578      */
    579     const RegisterMap* registerMap;
    580 
    581     /* set if method was called during method profiling */
    582     bool            inProfile;
    583 };
    584 
    585 
    586 /*
    587  * Find a method within a class.  The superclass is not searched.
    588  */
    589 Method* dvmFindDirectMethodByDescriptor(const ClassObject* clazz,
    590     const char* methodName, const char* signature);
    591 Method* dvmFindVirtualMethodByDescriptor(const ClassObject* clazz,
    592     const char* methodName, const char* signature);
    593 Method* dvmFindVirtualMethodByName(const ClassObject* clazz,
    594     const char* methodName);
    595 Method* dvmFindDirectMethod(const ClassObject* clazz, const char* methodName,
    596     const DexProto* proto);
    597 Method* dvmFindVirtualMethod(const ClassObject* clazz, const char* methodName,
    598     const DexProto* proto);
    599 
    600 
    601 /*
    602  * Find a method within a class hierarchy.
    603  */
    604 Method* dvmFindDirectMethodHierByDescriptor(const ClassObject* clazz,
    605     const char* methodName, const char* descriptor);
    606 Method* dvmFindVirtualMethodHierByDescriptor(const ClassObject* clazz,
    607     const char* methodName, const char* signature);
    608 Method* dvmFindDirectMethodHier(const ClassObject* clazz,
    609     const char* methodName, const DexProto* proto);
    610 Method* dvmFindVirtualMethodHier(const ClassObject* clazz,
    611     const char* methodName, const DexProto* proto);
    612 Method* dvmFindMethodHier(const ClassObject* clazz, const char* methodName,
    613     const DexProto* proto);
    614 
    615 /*
    616  * Find a method in an interface hierarchy.
    617  */
    618 Method* dvmFindInterfaceMethodHierByDescriptor(const ClassObject* iface,
    619     const char* methodName, const char* descriptor);
    620 Method* dvmFindInterfaceMethodHier(const ClassObject* iface,
    621     const char* methodName, const DexProto* proto);
    622 
    623 /*
    624  * Find the implementation of "meth" in "clazz".
    625  *
    626  * Returns NULL and throws an exception if not found.
    627  */
    628 const Method* dvmGetVirtualizedMethod(const ClassObject* clazz,
    629     const Method* meth);
    630 
    631 /*
    632  * Get the source file associated with a method.
    633  */
    634 extern "C" const char* dvmGetMethodSourceFile(const Method* meth);
    635 
    636 /*
    637  * Find a field within a class.  The superclass is not searched.
    638  */
    639 InstField* dvmFindInstanceField(const ClassObject* clazz,
    640     const char* fieldName, const char* signature);
    641 StaticField* dvmFindStaticField(const ClassObject* clazz,
    642     const char* fieldName, const char* signature);
    643 
    644 /*
    645  * Find a field in a class/interface hierarchy.
    646  */
    647 InstField* dvmFindInstanceFieldHier(const ClassObject* clazz,
    648     const char* fieldName, const char* signature);
    649 StaticField* dvmFindStaticFieldHier(const ClassObject* clazz,
    650     const char* fieldName, const char* signature);
    651 Field* dvmFindFieldHier(const ClassObject* clazz, const char* fieldName,
    652     const char* signature);
    653 
    654 /*
    655  * Find a field and return the byte offset from the object pointer.  Only
    656  * searches the specified class, not the superclass.
    657  *
    658  * Returns -1 on failure.
    659  */
    660 INLINE int dvmFindFieldOffset(const ClassObject* clazz,
    661     const char* fieldName, const char* signature)
    662 {
    663     InstField* pField = dvmFindInstanceField(clazz, fieldName, signature);
    664     if (pField == NULL)
    665         return -1;
    666     else
    667         return pField->byteOffset;
    668 }
    669 
    670 /*
    671  * Helpers.
    672  */
    673 INLINE bool dvmIsPublicMethod(const Method* method) {
    674     return (method->accessFlags & ACC_PUBLIC) != 0;
    675 }
    676 INLINE bool dvmIsPrivateMethod(const Method* method) {
    677     return (method->accessFlags & ACC_PRIVATE) != 0;
    678 }
    679 INLINE bool dvmIsStaticMethod(const Method* method) {
    680     return (method->accessFlags & ACC_STATIC) != 0;
    681 }
    682 INLINE bool dvmIsSynchronizedMethod(const Method* method) {
    683     return (method->accessFlags & ACC_SYNCHRONIZED) != 0;
    684 }
    685 INLINE bool dvmIsDeclaredSynchronizedMethod(const Method* method) {
    686     return (method->accessFlags & ACC_DECLARED_SYNCHRONIZED) != 0;
    687 }
    688 INLINE bool dvmIsFinalMethod(const Method* method) {
    689     return (method->accessFlags & ACC_FINAL) != 0;
    690 }
    691 INLINE bool dvmIsNativeMethod(const Method* method) {
    692     return (method->accessFlags & ACC_NATIVE) != 0;
    693 }
    694 INLINE bool dvmIsAbstractMethod(const Method* method) {
    695     return (method->accessFlags & ACC_ABSTRACT) != 0;
    696 }
    697 INLINE bool dvmIsSyntheticMethod(const Method* method) {
    698     return (method->accessFlags & ACC_SYNTHETIC) != 0;
    699 }
    700 INLINE bool dvmIsMirandaMethod(const Method* method) {
    701     return (method->accessFlags & ACC_MIRANDA) != 0;
    702 }
    703 INLINE bool dvmIsConstructorMethod(const Method* method) {
    704     return *method->name == '<';
    705 }
    706 /* Dalvik puts private, static, and constructors into non-virtual table */
    707 INLINE bool dvmIsDirectMethod(const Method* method) {
    708     return dvmIsPrivateMethod(method) ||
    709            dvmIsStaticMethod(method) ||
    710            dvmIsConstructorMethod(method);
    711 }
    712 /* Get whether the given method has associated bytecode. This is the
    713  * case for methods which are neither native nor abstract. */
    714 INLINE bool dvmIsBytecodeMethod(const Method* method) {
    715     return (method->accessFlags & (ACC_NATIVE | ACC_ABSTRACT)) == 0;
    716 }
    717 
    718 INLINE bool dvmIsProtectedField(const Field* field) {
    719     return (field->accessFlags & ACC_PROTECTED) != 0;
    720 }
    721 INLINE bool dvmIsStaticField(const Field* field) {
    722     return (field->accessFlags & ACC_STATIC) != 0;
    723 }
    724 INLINE bool dvmIsFinalField(const Field* field) {
    725     return (field->accessFlags & ACC_FINAL) != 0;
    726 }
    727 INLINE bool dvmIsVolatileField(const Field* field) {
    728     return (field->accessFlags & ACC_VOLATILE) != 0;
    729 }
    730 
    731 INLINE bool dvmIsInterfaceClass(const ClassObject* clazz) {
    732     return (clazz->accessFlags & ACC_INTERFACE) != 0;
    733 }
    734 INLINE bool dvmIsPublicClass(const ClassObject* clazz) {
    735     return (clazz->accessFlags & ACC_PUBLIC) != 0;
    736 }
    737 INLINE bool dvmIsFinalClass(const ClassObject* clazz) {
    738     return (clazz->accessFlags & ACC_FINAL) != 0;
    739 }
    740 INLINE bool dvmIsAbstractClass(const ClassObject* clazz) {
    741     return (clazz->accessFlags & ACC_ABSTRACT) != 0;
    742 }
    743 INLINE bool dvmIsAnnotationClass(const ClassObject* clazz) {
    744     return (clazz->accessFlags & ACC_ANNOTATION) != 0;
    745 }
    746 INLINE bool dvmIsPrimitiveClass(const ClassObject* clazz) {
    747     return clazz->primitiveType != PRIM_NOT;
    748 }
    749 
    750 /* linked, here meaning prepared and resolved */
    751 INLINE bool dvmIsClassLinked(const ClassObject* clazz) {
    752     return clazz->status >= CLASS_RESOLVED;
    753 }
    754 /* has class been verified? */
    755 INLINE bool dvmIsClassVerified(const ClassObject* clazz) {
    756     return clazz->status >= CLASS_VERIFIED;
    757 }
    758 
    759 /*
    760  * Return whether the given object is an instance of Class.
    761  */
    762 INLINE bool dvmIsClassObject(const Object* obj) {
    763     assert(obj != NULL);
    764     assert(obj->clazz != NULL);
    765     return IS_CLASS_FLAG_SET(obj->clazz, CLASS_ISCLASS);
    766 }
    767 
    768 /*
    769  * Return whether the given object is the class Class (that is, the
    770  * unique class which is an instance of itself).
    771  */
    772 INLINE bool dvmIsTheClassClass(const ClassObject* clazz) {
    773     assert(clazz != NULL);
    774     return IS_CLASS_FLAG_SET(clazz, CLASS_ISCLASS);
    775 }
    776 
    777 /*
    778  * Get the associated code struct for a method. This returns NULL
    779  * for non-bytecode methods.
    780  */
    781 INLINE const DexCode* dvmGetMethodCode(const Method* meth) {
    782     if (dvmIsBytecodeMethod(meth)) {
    783         /*
    784          * The insns field for a bytecode method actually points at
    785          * &(DexCode.insns), so we can subtract back to get at the
    786          * DexCode in front.
    787          */
    788         return (const DexCode*)
    789             (((const u1*) meth->insns) - offsetof(DexCode, insns));
    790     } else {
    791         return NULL;
    792     }
    793 }
    794 
    795 /*
    796  * Get the size of the insns associated with a method. This returns 0
    797  * for non-bytecode methods.
    798  */
    799 INLINE u4 dvmGetMethodInsnsSize(const Method* meth) {
    800     const DexCode* pCode = dvmGetMethodCode(meth);
    801     return (pCode == NULL) ? 0 : pCode->insnsSize;
    802 }
    803 
    804 /* debugging */
    805 void dvmDumpObject(const Object* obj);
    806 
    807 #endif  // DALVIK_OO_OBJECT_H_
    808