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