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