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