Object.h revision d8a3f9fa1951e552f5f65c2914689083cc0c46c2
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 */ 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(obj, OFFSETOF_MEMBER(Object, clazz), 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 : 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 */ 273struct 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 */ 290struct 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 */ 302struct 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 */ 312struct StaticField : Field { 313 JValue value; /* initially set from DEX for primitives */ 314}; 315 316/* 317 * Instance field. 318 */ 319struct 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 */ 350struct 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[]; /* 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 */ 488struct 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 /* cached JNI argument and return-type hints */ 540 int jniArgInfo; 541 542 /* 543 * 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 /* Whether this native method needs a JNIEnv*. */ 552 bool needsJniEnv; 553 554 /* 555 * Register map data, if available. This will point into the DEX file 556 * if the data was computed during pre-verification, or into the 557 * linear alloc area if not. 558 */ 559 const RegisterMap* registerMap; 560 561 /* set if method was called during method profiling */ 562 bool inProfile; 563}; 564 565 566/* 567 * Find a method within a class. The superclass is not searched. 568 */ 569Method* dvmFindDirectMethodByDescriptor(const ClassObject* clazz, 570 const char* methodName, const char* signature); 571Method* dvmFindVirtualMethodByDescriptor(const ClassObject* clazz, 572 const char* methodName, const char* signature); 573Method* dvmFindVirtualMethodByName(const ClassObject* clazz, 574 const char* methodName); 575Method* dvmFindDirectMethod(const ClassObject* clazz, const char* methodName, 576 const DexProto* proto); 577Method* dvmFindVirtualMethod(const ClassObject* clazz, const char* methodName, 578 const DexProto* proto); 579 580 581/* 582 * Find a method within a class hierarchy. 583 */ 584Method* dvmFindDirectMethodHierByDescriptor(const ClassObject* clazz, 585 const char* methodName, const char* descriptor); 586Method* dvmFindVirtualMethodHierByDescriptor(const ClassObject* clazz, 587 const char* methodName, const char* signature); 588Method* dvmFindDirectMethodHier(const ClassObject* clazz, 589 const char* methodName, const DexProto* proto); 590Method* dvmFindVirtualMethodHier(const ClassObject* clazz, 591 const char* methodName, const DexProto* proto); 592Method* dvmFindMethodHier(const ClassObject* clazz, const char* methodName, 593 const DexProto* proto); 594 595/* 596 * Find a method in an interface hierarchy. 597 */ 598Method* dvmFindInterfaceMethodHierByDescriptor(const ClassObject* iface, 599 const char* methodName, const char* descriptor); 600Method* dvmFindInterfaceMethodHier(const ClassObject* iface, 601 const char* methodName, const DexProto* proto); 602 603/* 604 * Find the implementation of "meth" in "clazz". 605 * 606 * Returns NULL and throws an exception if not found. 607 */ 608const Method* dvmGetVirtualizedMethod(const ClassObject* clazz, 609 const Method* meth); 610 611/* 612 * Get the source file associated with a method. 613 */ 614extern "C" const char* dvmGetMethodSourceFile(const Method* meth); 615 616/* 617 * Find a field within a class. The superclass is not searched. 618 */ 619InstField* dvmFindInstanceField(const ClassObject* clazz, 620 const char* fieldName, const char* signature); 621StaticField* dvmFindStaticField(const ClassObject* clazz, 622 const char* fieldName, const char* signature); 623 624/* 625 * Find a field in a class/interface hierarchy. 626 */ 627InstField* dvmFindInstanceFieldHier(const ClassObject* clazz, 628 const char* fieldName, const char* signature); 629StaticField* dvmFindStaticFieldHier(const ClassObject* clazz, 630 const char* fieldName, const char* signature); 631Field* dvmFindFieldHier(const ClassObject* clazz, const char* fieldName, 632 const char* signature); 633 634/* 635 * Find a field and return the byte offset from the object pointer. Only 636 * searches the specified class, not the superclass. 637 * 638 * Returns -1 on failure. 639 */ 640INLINE int dvmFindFieldOffset(const ClassObject* clazz, 641 const char* fieldName, const char* signature) 642{ 643 InstField* pField = dvmFindInstanceField(clazz, fieldName, signature); 644 if (pField == NULL) 645 return -1; 646 else 647 return pField->byteOffset; 648} 649 650/* 651 * Helpers. 652 */ 653INLINE bool dvmIsPublicMethod(const Method* method) { 654 return (method->accessFlags & ACC_PUBLIC) != 0; 655} 656INLINE bool dvmIsPrivateMethod(const Method* method) { 657 return (method->accessFlags & ACC_PRIVATE) != 0; 658} 659INLINE bool dvmIsStaticMethod(const Method* method) { 660 return (method->accessFlags & ACC_STATIC) != 0; 661} 662INLINE bool dvmIsSynchronizedMethod(const Method* method) { 663 return (method->accessFlags & ACC_SYNCHRONIZED) != 0; 664} 665INLINE bool dvmIsDeclaredSynchronizedMethod(const Method* method) { 666 return (method->accessFlags & ACC_DECLARED_SYNCHRONIZED) != 0; 667} 668INLINE bool dvmIsFinalMethod(const Method* method) { 669 return (method->accessFlags & ACC_FINAL) != 0; 670} 671INLINE bool dvmIsNativeMethod(const Method* method) { 672 return (method->accessFlags & ACC_NATIVE) != 0; 673} 674INLINE bool dvmIsAbstractMethod(const Method* method) { 675 return (method->accessFlags & ACC_ABSTRACT) != 0; 676} 677INLINE bool dvmIsSyntheticMethod(const Method* method) { 678 return (method->accessFlags & ACC_SYNTHETIC) != 0; 679} 680INLINE bool dvmIsMirandaMethod(const Method* method) { 681 return (method->accessFlags & ACC_MIRANDA) != 0; 682} 683INLINE bool dvmIsConstructorMethod(const Method* method) { 684 return *method->name == '<'; 685} 686/* Dalvik puts private, static, and constructors into non-virtual table */ 687INLINE bool dvmIsDirectMethod(const Method* method) { 688 return dvmIsPrivateMethod(method) || 689 dvmIsStaticMethod(method) || 690 dvmIsConstructorMethod(method); 691} 692/* Get whether the given method has associated bytecode. This is the 693 * case for methods which are neither native nor abstract. */ 694INLINE bool dvmIsBytecodeMethod(const Method* method) { 695 return (method->accessFlags & (ACC_NATIVE | ACC_ABSTRACT)) == 0; 696} 697 698INLINE bool dvmIsProtectedField(const Field* field) { 699 return (field->accessFlags & ACC_PROTECTED) != 0; 700} 701INLINE bool dvmIsStaticField(const Field* field) { 702 return (field->accessFlags & ACC_STATIC) != 0; 703} 704INLINE bool dvmIsFinalField(const Field* field) { 705 return (field->accessFlags & ACC_FINAL) != 0; 706} 707INLINE bool dvmIsVolatileField(const Field* field) { 708 return (field->accessFlags & ACC_VOLATILE) != 0; 709} 710 711INLINE bool dvmIsInterfaceClass(const ClassObject* clazz) { 712 return (clazz->accessFlags & ACC_INTERFACE) != 0; 713} 714INLINE bool dvmIsPublicClass(const ClassObject* clazz) { 715 return (clazz->accessFlags & ACC_PUBLIC) != 0; 716} 717INLINE bool dvmIsFinalClass(const ClassObject* clazz) { 718 return (clazz->accessFlags & ACC_FINAL) != 0; 719} 720INLINE bool dvmIsAbstractClass(const ClassObject* clazz) { 721 return (clazz->accessFlags & ACC_ABSTRACT) != 0; 722} 723INLINE bool dvmIsAnnotationClass(const ClassObject* clazz) { 724 return (clazz->accessFlags & ACC_ANNOTATION) != 0; 725} 726INLINE bool dvmIsPrimitiveClass(const ClassObject* clazz) { 727 return clazz->primitiveType != PRIM_NOT; 728} 729 730/* linked, here meaning prepared and resolved */ 731INLINE bool dvmIsClassLinked(const ClassObject* clazz) { 732 return clazz->status >= CLASS_RESOLVED; 733} 734/* has class been verified? */ 735INLINE bool dvmIsClassVerified(const ClassObject* clazz) { 736 return clazz->status >= CLASS_VERIFIED; 737} 738 739/* 740 * Return whether the given object is an instance of Class. 741 */ 742INLINE bool dvmIsClassObject(const Object* obj) { 743 assert(obj != NULL); 744 assert(obj->clazz != NULL); 745 return IS_CLASS_FLAG_SET(obj->clazz, CLASS_ISCLASS); 746} 747 748/* 749 * Return whether the given object is the class Class (that is, the 750 * unique class which is an instance of itself). 751 */ 752INLINE bool dvmIsTheClassClass(const ClassObject* clazz) { 753 assert(clazz != NULL); 754 return IS_CLASS_FLAG_SET(clazz, CLASS_ISCLASS); 755} 756 757/* 758 * Get the associated code struct for a method. This returns NULL 759 * for non-bytecode methods. 760 */ 761INLINE const DexCode* dvmGetMethodCode(const Method* meth) { 762 if (dvmIsBytecodeMethod(meth)) { 763 /* 764 * The insns field for a bytecode method actually points at 765 * &(DexCode.insns), so we can subtract back to get at the 766 * DexCode in front. 767 */ 768 return (const DexCode*) 769 (((const u1*) meth->insns) - offsetof(DexCode, insns)); 770 } else { 771 return NULL; 772 } 773} 774 775/* 776 * Get the size of the insns associated with a method. This returns 0 777 * for non-bytecode methods. 778 */ 779INLINE u4 dvmGetMethodInsnsSize(const Method* meth) { 780 const DexCode* pCode = dvmGetMethodCode(meth); 781 return (pCode == NULL) ? 0 : pCode->insnsSize; 782} 783 784/* debugging */ 785void dvmDumpObject(const Object* obj); 786 787#endif // DALVIK_OO_OBJECT_H_ 788