vm/oo/Object.h

   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 u4 dvmGetFieldIdx(const Field* field);
 310
 311 /*
 312  * Static field.
 313  */
 314 struct StaticField : Field {
 315     JValue          value;          /* initially set from DEX for primitives */
 316 };
 317
 318 /*
 319  * Instance field.
 320  */
 321 struct InstField : Field {
 322     /*
 323      * This field indicates the byte offset from the beginning of the
 324      * (Object *) to the actual instance data; e.g., byteOffset==0 is
 325      * the same as the object pointer (bug!), and byteOffset==4 is 4
 326      * bytes farther.
 327      */
 328     int             byteOffset;
 329 };
 330
 331 /*
 332  * This defines the amount of space we leave for field slots in the
 333  * java.lang.Class definition.  If we alter the class to have more than
 334  * this many fields, the VM will abort at startup.
 335  */
 336 #define CLASS_FIELD_SLOTS   4
 337
 338 /*
 339  * Class objects have many additional fields.  This is used for both
 340  * classes and interfaces, including synthesized classes (arrays and
 341  * primitive types).
 342  *
 343  * Class objects are unusual in that they have some fields allocated with
 344  * the system malloc (or LinearAlloc), rather than on the GC heap.  This is
 345  * handy during initialization, but does require special handling when
 346  * discarding java.lang.Class objects.
 347  *
 348  * The separation of methods (direct vs. virtual) and fields (class vs.
 349  * instance) used in Dalvik works out pretty well.  The only time it's
 350  * annoying is when enumerating or searching for things with reflection.
 351  */
 352 struct ClassObject : Object {
 353     /* leave space for instance data; we could access fields directly if we
 354        freeze the definition of java/lang/Class */
 355     u4              instanceData[CLASS_FIELD_SLOTS];
 356
 357     /* UTF-8 descriptor for the class; from constant pool, or on heap
 358        if generated ("[C") */
 359     const char*     descriptor;
 360     char*           descriptorAlloc;
 361
 362     /* access flags; low 16 bits are defined by VM spec */
 363     u4              accessFlags;
 364
 365     /* VM-unique class serial number, nonzero, set very early */
 366     u4              serialNumber;
 367
 368     /* DexFile from which we came; needed to resolve constant pool entries */
 369     /* (will be NULL for VM-generated, e.g. arrays and primitive classes) */
 370     DvmDex*         pDvmDex;
 371
 372     /* state of class initialization */
 373     ClassStatus     status;
 374
 375     /* if class verify fails, we must return same error on subsequent tries */
 376     ClassObject*    verifyErrorClass;
 377
 378     /* threadId, used to check for recursive <clinit> invocation */
 379     u4              initThreadId;
 380
 381     /*
 382      * Total object size; used when allocating storage on gc heap.  (For
 383      * interfaces and abstract classes this will be zero.)
 384      */
 385     size_t          objectSize;
 386
 387     /* arrays only: class object for base element, for instanceof/checkcast
 388        (for String[][][], this will be String) */
 389     ClassObject*    elementClass;
 390
 391     /* arrays only: number of dimensions, e.g. int[][] is 2 */
 392     int             arrayDim;
 393
 394     /* primitive type index, or PRIM_NOT (-1); set for generated prim classes */
 395     PrimitiveType   primitiveType;
 396
 397     /* superclass, or NULL if this is java.lang.Object */
 398     ClassObject*    super;
 399
 400     /* defining class loader, or NULL for the "bootstrap" system loader */
 401     Object*         classLoader;
 402
 403     /* initiating class loader list */
 404     /* NOTE: for classes with low serialNumber, these are unused, and the
 405        values are kept in a table in gDvm. */
 406     InitiatingLoaderList initiatingLoaderList;
 407
 408     /* array of interfaces this class implements directly */
 409     int             interfaceCount;
 410     ClassObject**   interfaces;
 411
 412     /* static, private, and <init> methods */
 413     int             directMethodCount;
 414     Method*         directMethods;
 415
 416     /* virtual methods defined in this class; invoked through vtable */
 417     int             virtualMethodCount;
 418     Method*         virtualMethods;
 419
 420     /*
 421      * Virtual method table (vtable), for use by "invoke-virtual".  The
 422      * vtable from the superclass is copied in, and virtual methods from
 423      * our class either replace those from the super or are appended.
 424      */
 425     int             vtableCount;
 426     Method**        vtable;
 427
 428     /*
 429      * Interface table (iftable), one entry per interface supported by
 430      * this class.  That means one entry for each interface we support
 431      * directly, indirectly via superclass, or indirectly via
 432      * superinterface.  This will be null if neither we nor our superclass
 433      * implement any interfaces.
 434      *
 435      * Why we need this: given "class Foo implements Face", declare
 436      * "Face faceObj = new Foo()".  Invoke faceObj.blah(), where "blah" is
 437      * part of the Face interface.  We can't easily use a single vtable.
 438      *
 439      * For every interface a concrete class implements, we create a list of
 440      * virtualMethod indices for the methods in the interface.
 441      */
 442     int             iftableCount;
 443     InterfaceEntry* iftable;
 444
 445     /*
 446      * The interface vtable indices for iftable get stored here.  By placing
 447      * them all in a single pool for each class that implements interfaces,
 448      * we decrease the number of allocations.
 449      */
 450     int             ifviPoolCount;
 451     int*            ifviPool;
 452
 453     /* instance fields
 454      *
 455      * These describe the layout of the contents of a DataObject-compatible
 456      * Object.  Note that only the fields directly defined by this class
 457      * are listed in ifields;  fields defined by a superclass are listed
 458      * in the superclass's ClassObject.ifields.
 459      *
 460      * All instance fields that refer to objects are guaranteed to be
 461      * at the beginning of the field list.  ifieldRefCount specifies
 462      * the number of reference fields.
 463      */
 464     int             ifieldCount;
 465     int             ifieldRefCount; // number of fields that are object refs
 466     InstField*      ifields;
 467
 468     /* bitmap of offsets of ifields */
 469     u4 refOffsets;
 470
 471     /* source file name, if known */
 472     const char*     sourceFile;
 473
 474     /* static fields */
 475     int             sfieldCount;
 476     StaticField     sfields[0]; /* MUST be last item */
 477 };
 478
 479 /*
 480  * A method.  We create one of these for every method in every class
 481  * we load, so try to keep the size to a minimum.
 482  *
 483  * Much of this comes from and could be accessed in the data held in shared
 484  * memory.  We hold it all together here for speed.  Everything but the
 485  * pointers could be held in a shared table generated by the optimizer;
 486  * if we're willing to convert them to offsets and take the performance
 487  * hit (e.g. "meth->insns" becomes "baseAddr + meth->insnsOffset") we
 488  * could move everything but "nativeFunc".
 489  */
 490 struct Method {
 491     /* the class we are a part of */
 492     ClassObject*    clazz;
 493
 494     /* access flags; low 16 bits are defined by spec (could be u2?) */
 495     u4              accessFlags;
 496
 497     /*
 498      * For concrete virtual methods, this is the offset of the method
 499      * in "vtable".
 500      *
 501      * For abstract methods in an interface class, this is the offset
 502      * of the method in "iftable[n]->methodIndexArray".
 503      */
 504     u2             methodIndex;
 505
 506     /*
 507      * Method bounds; not needed for an abstract method.
 508      *
 509      * For a native method, we compute the size of the argument list, and
 510      * set "insSize" and "registerSize" equal to it.
 511      */
 512     u2              registersSize;  /* ins + locals */
 513     u2              outsSize;
 514     u2              insSize;
 515
 516     /* method name, e.g. "<init>" or "eatLunch" */
 517     const char*     name;
 518
 519     /*
 520      * Method prototype descriptor string (return and argument types).
 521      *
 522      * TODO: This currently must specify the DexFile as well as the proto_ids
 523      * index, because generated Proxy classes don't have a DexFile.  We can
 524      * remove the DexFile* and reduce the size of this struct if we generate
 525      * a DEX for proxies.
 526      */
 527     DexProto        prototype;
 528
 529     /* short-form method descriptor string */
 530     const char*     shorty;
 531
 532     /*
 533      * The remaining items are not used for abstract or native methods.
 534      * (JNI is currently hijacking "insns" as a function pointer, set
 535      * after the first call.  For internal-native this stays null.)
 536      */
 537
 538     /* the actual code */
 539     const u2*       insns;          /* instructions, in memory-mapped .dex */
 540
 541     /* JNI: cached argument and return-type hints */
 542     int             jniArgInfo;
 543
 544     /*
 545      * JNI: native method ptr; could be actual function or a JNI bridge.  We
 546      * don't currently discriminate between DalvikBridgeFunc and
 547      * DalvikNativeFunc; the former takes an argument superset (i.e. two
 548      * extra args) which will be ignored.  If necessary we can use
 549      * insns==NULL to detect JNI bridge vs. internal native.
 550      */
 551     DalvikBridgeFunc nativeFunc;
 552
 553     /*
 554      * JNI: true if this static non-synchronized native method (that has no
 555      * reference arguments) needs a JNIEnv* and jclass/jobject. Libcore
 556      * uses this.
 557      */
 558     bool fastJni;
 559
 560     /*
 561      * JNI: true if this method has no reference arguments. This lets the JNI
 562      * bridge avoid scanning the shorty for direct pointers that need to be
 563      * converted to local references.
 564      *
 565      * TODO: replace this with a list of indexes of the reference arguments.
 566      */
 567     bool noRef;
 568
 569     /*
 570      * JNI: true if we should log entry and exit. This is the only way
 571      * developers can log the local references that are passed into their code.
 572      * Used for debugging JNI problems in third-party code.
 573      */
 574     bool shouldTrace;
 575
 576     /*
 577      * Register map data, if available.  This will point into the DEX file
 578      * if the data was computed during pre-verification, or into the
 579      * linear alloc area if not.
 580      */
 581     const RegisterMap* registerMap;
 582
 583     /* set if method was called during method profiling */
 584     bool            inProfile;
 585 };
 586
 587 u4 dvmGetMethodIdx(const Method* method);
 588
 589
 590 /*
 591  * Find a method within a class.  The superclass is not searched.
 592  */
 593 Method* dvmFindDirectMethodByDescriptor(const ClassObject* clazz,
 594     const char* methodName, const char* signature);
 595 Method* dvmFindVirtualMethodByDescriptor(const ClassObject* clazz,
 596     const char* methodName, const char* signature);
 597 Method* dvmFindVirtualMethodByName(const ClassObject* clazz,
 598     const char* methodName);
 599 Method* dvmFindDirectMethod(const ClassObject* clazz, const char* methodName,
 600     const DexProto* proto);
 601 Method* dvmFindVirtualMethod(const ClassObject* clazz, const char* methodName,
 602     const DexProto* proto);
 603
 604
 605 /*
 606  * Find a method within a class hierarchy.
 607  */
 608 Method* dvmFindDirectMethodHierByDescriptor(const ClassObject* clazz,
 609     const char* methodName, const char* descriptor);
 610 Method* dvmFindVirtualMethodHierByDescriptor(const ClassObject* clazz,
 611     const char* methodName, const char* signature);
 612 Method* dvmFindDirectMethodHier(const ClassObject* clazz,
 613     const char* methodName, const DexProto* proto);
 614 Method* dvmFindVirtualMethodHier(const ClassObject* clazz,
 615     const char* methodName, const DexProto* proto);
 616 Method* dvmFindMethodHier(const ClassObject* clazz, const char* methodName,
 617     const DexProto* proto);
 618
 619 /*
 620  * Find a method in an interface hierarchy.
 621  */
 622 Method* dvmFindInterfaceMethodHierByDescriptor(const ClassObject* iface,
 623     const char* methodName, const char* descriptor);
 624 Method* dvmFindInterfaceMethodHier(const ClassObject* iface,
 625     const char* methodName, const DexProto* proto);
 626
 627 /*
 628  * Find the implementation of "meth" in "clazz".
 629  *
 630  * Returns NULL and throws an exception if not found.
 631  */
 632 const Method* dvmGetVirtualizedMethod(const ClassObject* clazz,
 633     const Method* meth);
 634
 635 /*
 636  * Get the source file associated with a method.
 637  */
 638 extern "C" const char* dvmGetMethodSourceFile(const Method* meth);
 639
 640 /*
 641  * Find a field within a class.  The superclass is not searched.
 642  */
 643 InstField* dvmFindInstanceField(const ClassObject* clazz,
 644     const char* fieldName, const char* signature);
 645 StaticField* dvmFindStaticField(const ClassObject* clazz,
 646     const char* fieldName, const char* signature);
 647
 648 /*
 649  * Find a field in a class/interface hierarchy.
 650  */
 651 InstField* dvmFindInstanceFieldHier(const ClassObject* clazz,
 652     const char* fieldName, const char* signature);
 653 StaticField* dvmFindStaticFieldHier(const ClassObject* clazz,
 654     const char* fieldName, const char* signature);
 655 Field* dvmFindFieldHier(const ClassObject* clazz, const char* fieldName,
 656     const char* signature);
 657
 658 /*
 659  * Find a field and return the byte offset from the object pointer.  Only
 660  * searches the specified class, not the superclass.
 661  *
 662  * Returns -1 on failure.
 663  */
 664 INLINE int dvmFindFieldOffset(const ClassObject* clazz,
 665     const char* fieldName, const char* signature)
 666 {
 667     InstField* pField = dvmFindInstanceField(clazz, fieldName, signature);
 668     if (pField == NULL)
 669         return -1;
 670     else
 671         return pField->byteOffset;
 672 }
 673
 674 /*
 675  * Helpers.
 676  */
 677 INLINE bool dvmIsPublicMethod(const Method* method) {
 678     return (method->accessFlags & ACC_PUBLIC) != 0;
 679 }
 680 INLINE bool dvmIsPrivateMethod(const Method* method) {
 681     return (method->accessFlags & ACC_PRIVATE) != 0;
 682 }
 683 INLINE bool dvmIsStaticMethod(const Method* method) {
 684     return (method->accessFlags & ACC_STATIC) != 0;
 685 }
 686 INLINE bool dvmIsSynchronizedMethod(const Method* method) {
 687     return (method->accessFlags & ACC_SYNCHRONIZED) != 0;
 688 }
 689 INLINE bool dvmIsDeclaredSynchronizedMethod(const Method* method) {
 690     return (method->accessFlags & ACC_DECLARED_SYNCHRONIZED) != 0;
 691 }
 692 INLINE bool dvmIsFinalMethod(const Method* method) {
 693     return (method->accessFlags & ACC_FINAL) != 0;
 694 }
 695 INLINE bool dvmIsNativeMethod(const Method* method) {
 696     return (method->accessFlags & ACC_NATIVE) != 0;
 697 }
 698 INLINE bool dvmIsAbstractMethod(const Method* method) {
 699     return (method->accessFlags & ACC_ABSTRACT) != 0;
 700 }
 701 INLINE bool dvmIsSyntheticMethod(const Method* method) {
 702     return (method->accessFlags & ACC_SYNTHETIC) != 0;
 703 }
 704 INLINE bool dvmIsMirandaMethod(const Method* method) {
 705     return (method->accessFlags & ACC_MIRANDA) != 0;
 706 }
 707 INLINE bool dvmIsConstructorMethod(const Method* method) {
 708     return *method->name == '<';
 709 }
 710 /* Dalvik puts private, static, and constructors into non-virtual table */
 711 INLINE bool dvmIsDirectMethod(const Method* method) {
 712     return dvmIsPrivateMethod(method) ||
 713            dvmIsStaticMethod(method) ||
 714            dvmIsConstructorMethod(method);
 715 }
 716 /* Get whether the given method has associated bytecode. This is the
 717  * case for methods which are neither native nor abstract. */
 718 INLINE bool dvmIsBytecodeMethod(const Method* method) {
 719     return (method->accessFlags & (ACC_NATIVE | ACC_ABSTRACT)) == 0;
 720 }
 721
 722 INLINE bool dvmIsProtectedField(const Field* field) {
 723     return (field->accessFlags & ACC_PROTECTED) != 0;
 724 }
 725 INLINE bool dvmIsStaticField(const Field* field) {
 726     return (field->accessFlags & ACC_STATIC) != 0;
 727 }
 728 INLINE bool dvmIsFinalField(const Field* field) {
 729     return (field->accessFlags & ACC_FINAL) != 0;
 730 }
 731 INLINE bool dvmIsVolatileField(const Field* field) {
 732     return (field->accessFlags & ACC_VOLATILE) != 0;
 733 }
 734
 735 INLINE bool dvmIsInterfaceClass(const ClassObject* clazz) {
 736     return (clazz->accessFlags & ACC_INTERFACE) != 0;
 737 }
 738 INLINE bool dvmIsPublicClass(const ClassObject* clazz) {
 739     return (clazz->accessFlags & ACC_PUBLIC) != 0;
 740 }
 741 INLINE bool dvmIsFinalClass(const ClassObject* clazz) {
 742     return (clazz->accessFlags & ACC_FINAL) != 0;
 743 }
 744 INLINE bool dvmIsAbstractClass(const ClassObject* clazz) {
 745     return (clazz->accessFlags & ACC_ABSTRACT) != 0;
 746 }
 747 INLINE bool dvmIsAnnotationClass(const ClassObject* clazz) {
 748     return (clazz->accessFlags & ACC_ANNOTATION) != 0;
 749 }
 750 INLINE bool dvmIsPrimitiveClass(const ClassObject* clazz) {
 751     return clazz->primitiveType != PRIM_NOT;
 752 }
 753
 754 /* linked, here meaning prepared and resolved */
 755 INLINE bool dvmIsClassLinked(const ClassObject* clazz) {
 756     return clazz->status >= CLASS_RESOLVED;
 757 }
 758 /* has class been verified? */
 759 INLINE bool dvmIsClassVerified(const ClassObject* clazz) {
 760     return clazz->status >= CLASS_VERIFIED;
 761 }
 762
 763 /*
 764  * Return whether the given object is an instance of Class.
 765  */
 766 INLINE bool dvmIsClassObject(const Object* obj) {
 767     assert(obj != NULL);
 768     assert(obj->clazz != NULL);
 769     return IS_CLASS_FLAG_SET(obj->clazz, CLASS_ISCLASS);
 770 }
 771
 772 /*
 773  * Return whether the given object is the class Class (that is, the
 774  * unique class which is an instance of itself).
 775  */
 776 INLINE bool dvmIsTheClassClass(const ClassObject* clazz) {
 777     assert(clazz != NULL);
 778     return IS_CLASS_FLAG_SET(clazz, CLASS_ISCLASS);
 779 }
 780
 781 /*
 782  * Get the associated code struct for a method. This returns NULL
 783  * for non-bytecode methods.
 784  */
 785 INLINE const DexCode* dvmGetMethodCode(const Method* meth) {
 786     if (dvmIsBytecodeMethod(meth)) {
 787         /*
 788          * The insns field for a bytecode method actually points at
 789          * &(DexCode.insns), so we can subtract back to get at the
 790          * DexCode in front.
 791          */
 792         return (const DexCode*)
 793             (((const u1*) meth->insns) - offsetof(DexCode, insns));
 794     } else {
 795         return NULL;
 796     }
 797 }
 798
 799 /*
 800  * Get the size of the insns associated with a method. This returns 0
 801  * for non-bytecode methods.
 802  */
 803 INLINE u4 dvmGetMethodInsnsSize(const Method* meth) {
 804     const DexCode* pCode = dvmGetMethodCode(meth);
 805     return (pCode == NULL) ? 0 : pCode->insnsSize;
 806 }
 807
 808 /* debugging */
 809 void dvmDumpObject(const Object* obj);
 810
 811 #endif  // DALVIK_OO_OBJECT_H_