1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 /*
18 * Declaration of the fundamental Object type and refinements thereof, plus
19 * some functions for manipulating them.
20 */
21 #ifndef DALVIK_OO_OBJECT_H_
22 #define DALVIK_OO_OBJECT_H_
23
24 #include <stddef.h>
25 #include "Atomic.h"
26
27 /* fwd decl */
28 struct DataObject;
29 struct InitiatingLoaderList;
30 struct ClassObject;
31 struct StringObject;
32 struct ArrayObject;
33 struct Method;
34 struct ExceptionEntry;
35 struct LineNumEntry;
36 struct StaticField;
37 struct InstField;
38 struct Field;
39 struct RegisterMap;
40
41 /*
42 * Native function pointer type.
43 *
44 * "args[0]" holds the "this" pointer for virtual methods.
45 *
46 * The "Bridge" form is a super-set of the "Native" form; in many places
47 * they are used interchangeably. Currently, all functions have all
48 * arguments passed in, but some functions only care about the first two.
49 * Passing extra arguments to a C function is (mostly) harmless.
50 */
51 typedef void (*DalvikBridgeFunc)(const u4* args, JValue* pResult,
52 const Method* method, struct Thread* self);
53 typedef void (*DalvikNativeFunc)(const u4* args, JValue* pResult);
54
55
56 /* vm-internal access flags and related definitions */
57 enum AccessFlags {
58 ACC_MIRANDA = 0x8000, // method (internal to VM)
59 JAVA_FLAGS_MASK = 0xffff, // bits set from Java sources (low 16)
60 };
61
62 /* Use the top 16 bits of the access flags field for
63 * other class flags. Code should use the *CLASS_FLAG*()
64 * macros to set/get these flags.
65 */
66 enum ClassFlags {
67 CLASS_ISFINALIZABLE = (1<<31), // class/ancestor overrides finalize()
68 CLASS_ISARRAY = (1<<30), // class is a "[*"
69 CLASS_ISOBJECTARRAY = (1<<29), // class is a "[L*" or "[[*"
70 CLASS_ISCLASS = (1<<28), // class is *the* class Class
71
72 CLASS_ISREFERENCE = (1<<27), // class is a soft/weak/phantom ref
73 // only ISREFERENCE is set --> soft
74 CLASS_ISWEAKREFERENCE = (1<<26), // class is a weak reference
75 CLASS_ISFINALIZERREFERENCE = (1<<25), // class is a finalizer reference
76 CLASS_ISPHANTOMREFERENCE = (1<<24), // class is a phantom reference
77
78 CLASS_MULTIPLE_DEFS = (1<<23), // DEX verifier: defs in multiple DEXs
79
80 /* unlike the others, these can be present in the optimized DEX file */
81 CLASS_ISOPTIMIZED = (1<<17), // class may contain opt instrs
82 CLASS_ISPREVERIFIED = (1<<16), // class has been pre-verified
83 };
84
85 /* bits we can reasonably expect to see set in a DEX access flags field */
86 #define EXPECTED_FILE_FLAGS \
87 (ACC_CLASS_MASK | CLASS_ISPREVERIFIED | CLASS_ISOPTIMIZED)
88
89 /*
90 * Get/set class flags.
91 */
92 #define SET_CLASS_FLAG(clazz, flag) \
93 do { (clazz)->accessFlags |= (flag); } while (0)
94
95 #define CLEAR_CLASS_FLAG(clazz, flag) \
96 do { (clazz)->accessFlags &= ~(flag); } while (0)
97
98 #define IS_CLASS_FLAG_SET(clazz, flag) \
99 (((clazz)->accessFlags & (flag)) != 0)
100
101 #define GET_CLASS_FLAG_GROUP(clazz, flags) \
102 ((u4)((clazz)->accessFlags & (flags)))
103
104 /*
105 * Use the top 16 bits of the access flags field for other method flags.
106 * Code should use the *METHOD_FLAG*() macros to set/get these flags.
107 */
108 enum MethodFlags {
109 METHOD_ISWRITABLE = (1<<31), // the method's code is writable
110 };
111
112 /*
113 * Get/set method flags.
114 */
115 #define SET_METHOD_FLAG(method, flag) \
116 do { (method)->accessFlags |= (flag); } while (0)
117
118 #define CLEAR_METHOD_FLAG(method, flag) \
119 do { (method)->accessFlags &= ~(flag); } while (0)
120
121 #define IS_METHOD_FLAG_SET(method, flag) \
122 (((method)->accessFlags & (flag)) != 0)
123
124 #define GET_METHOD_FLAG_GROUP(method, flags) \
125 ((u4)((method)->accessFlags & (flags)))
126
127 /* current state of the class, increasing as we progress */
128 enum ClassStatus {
129 CLASS_ERROR = -1,
130
131 CLASS_NOTREADY = 0,
132 CLASS_IDX = 1, /* loaded, DEX idx in super or ifaces */
133 CLASS_LOADED = 2, /* DEX idx values resolved */
134 CLASS_RESOLVED = 3, /* part of linking */
135 CLASS_VERIFYING = 4, /* in the process of being verified */
136 CLASS_VERIFIED = 5, /* logically part of linking; done pre-init */
137 CLASS_INITIALIZING = 6, /* class init in progress */
138 CLASS_INITIALIZED = 7, /* ready to go */
139 };
140
141 /*
142 * Definitions for packing refOffsets in ClassObject.
143 */
144 /*
145 * A magic value for refOffsets. Ignore the bits and walk the super
146 * chain when this is the value.
147 * [This is an unlikely "natural" value, since it would be 30 non-ref instance
148 * fields followed by 2 ref instance fields.]
149 */
150 #define CLASS_WALK_SUPER ((unsigned int)(3))
151 #define CLASS_SMALLEST_OFFSET (sizeof(struct Object))
152 #define CLASS_BITS_PER_WORD (sizeof(unsigned long int) * 8)
153 #define CLASS_OFFSET_ALIGNMENT 4
154 #define CLASS_HIGH_BIT ((unsigned int)1 << (CLASS_BITS_PER_WORD - 1))
155 /*
156 * Given an offset, return the bit number which would encode that offset.
157 * Local use only.
158 */
159 #define _CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset) \
160 (((unsigned int)(byteOffset) - CLASS_SMALLEST_OFFSET) / \
161 CLASS_OFFSET_ALIGNMENT)
162 /*
163 * Is the given offset too large to be encoded?
164 */
165 #define CLASS_CAN_ENCODE_OFFSET(byteOffset) \
166 (_CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset) < CLASS_BITS_PER_WORD)
167 /*
168 * Return a single bit, encoding the offset.
169 * Undefined if the offset is too large, as defined above.
170 */
171 #define CLASS_BIT_FROM_OFFSET(byteOffset) \
172 (CLASS_HIGH_BIT >> _CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset))
173 /*
174 * Return an offset, given a bit number as returned from CLZ.
175 */
176 #define CLASS_OFFSET_FROM_CLZ(rshift) \
177 (((int)(rshift) * CLASS_OFFSET_ALIGNMENT) + CLASS_SMALLEST_OFFSET)
178
179
180 /*
181 * Used for iftable in ClassObject.
182 */
183 struct InterfaceEntry {
184 /* pointer to interface class */
185 ClassObject* clazz;
186
187 /*
188 * Index into array of vtable offsets. This points into the ifviPool,
189 * which holds the vtables for all interfaces declared by this class.
190 */
191 int* methodIndexArray;
192 };
193
194
195
196 /*
197 * There are three types of objects:
198 * Class objects - an instance of java.lang.Class
199 * Array objects - an object created with a "new array" instruction
200 * Data objects - an object that is neither of the above
201 *
202 * We also define String objects. At present they're equivalent to
203 * DataObject, but that may change. (Either way, they make some of the
204 * code more obvious.)
205 *
206 * All objects have an Object header followed by type-specific data.
207 */
208 struct Object {
209 /* ptr to class object */
210 ClassObject* clazz;
211
212 /*
213 * A word containing either a "thin" lock or a "fat" monitor. See
214 * the comments in Sync.c for a description of its layout.
215 */
216 u4 lock;
217 };
218
219 /*
220 * Properly initialize an Object.
221 * void DVM_OBJECT_INIT(Object *obj, ClassObject *clazz_)
222 */
223 #define DVM_OBJECT_INIT(obj, clazz_) \
224 dvmSetFieldObject(obj, OFFSETOF_MEMBER(Object, clazz), clazz_)
225
226 /*
227 * Data objects have an Object header followed by their instance data.
228 */
229 struct DataObject : Object {
230 /* variable #of u4 slots; u8 uses 2 slots */
231 u4 instanceData[1];
232 };
233
234 /*
235 * Strings are used frequently enough that we may want to give them their
236 * own unique type.
237 *
238 * Using a dedicated type object to access the instance data provides a
239 * performance advantage but makes the java/lang/String.java implementation
240 * fragile.
241 *
242 * Currently this is just equal to DataObject, and we pull the fields out
243 * like we do for any other object.
244 */
245 struct StringObject : Object {
246 /* variable #of u4 slots; u8 uses 2 slots */
247 u4 instanceData[1];
248
249 /** Returns this string's length in characters. */
250 int length() const;
251
252 /**
253 * Returns this string's length in bytes when encoded as modified UTF-8.
254 * Does not include a terminating NUL byte.
255 */
256 int utfLength() const;
257
258 /** Returns this string's char[] as an ArrayObject. */
259 ArrayObject* array() const;
260
261 /** Returns this string's char[] as a u2*. */
262 const u2* chars() const;
263 };
264
265
266 /*
267 * Array objects have these additional fields.
268 *
269 * We don't currently store the size of each element. Usually it's implied
270 * by the instruction. If necessary, the width can be derived from
271 * the first char of obj->clazz->descriptor.
272 */
273 struct ArrayObject : Object {
274 /* number of elements; immutable after init */
275 u4 length;
276
277 /*
278 * Array contents; actual size is (length * sizeof(type)). This is
279 * declared as u8 so that the compiler inserts any necessary padding
280 * (e.g. for EABI); the actual allocation may be smaller than 8 bytes.
281 */
282 u8 contents[1];
283 };
284
285 /*
286 * For classes created early and thus probably in the zygote, the
287 * InitiatingLoaderList is kept in gDvm. Later classes use the structure in
288 * Object Class. This helps keep zygote pages shared.
289 */
290 struct InitiatingLoaderList {
291 /* a list of initiating loader Objects; grown and initialized on demand */
292 Object** initiatingLoaders;
293 /* count of loaders in the above list */
294 int initiatingLoaderCount;
295 };
296
297 /*
298 * Generic field header. We pass this around when we want a generic Field
299 * pointer (e.g. for reflection stuff). Testing the accessFlags for
300 * ACC_STATIC allows a proper up-cast.
301 */
302 struct Field {
303 ClassObject* clazz; /* class in which the field is declared */
304 const char* name;
305 const char* signature; /* e.g. "I", "[C", "Landroid/os/Debug;" */
306 u4 accessFlags;
307 };
308
309 /*
310 * Static field.
311 */
312 struct StaticField : Field {
313 JValue value; /* initially set from DEX for primitives */
314 };
315
316 /*
317 * Instance field.
318 */
319 struct 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 */
350 struct 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 */
488 struct 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 /* JNI: cached argument and return-type hints */
540 int jniArgInfo;
541
542 /*
543 * JNI: 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 /*
552 * JNI: true if this static non-synchronized native method (that has no
553 * reference arguments) needs a JNIEnv* and jclass/jobject. Libcore
554 * uses this.
555 */
556 bool fastJni;
557
558 /*
559 * JNI: true if this method has no reference arguments. This lets the JNI
560 * bridge avoid scanning the shorty for direct pointers that need to be
561 * converted to local references.
562 *
563 * TODO: replace this with a list of indexes of the reference arguments.
564 */
565 bool noRef;
566
567 /*
568 * JNI: true if we should log entry and exit. This is the only way
569 * developers can log the local references that are passed into their code.
570 * Used for debugging JNI problems in third-party code.
571 */
572 bool shouldTrace;
573
574 /*
575 * Register map data, if available. This will point into the DEX file
576 * if the data was computed during pre-verification, or into the
577 * linear alloc area if not.
578 */
579 const RegisterMap* registerMap;
580
581 /* set if method was called during method profiling */
582 bool inProfile;
583 };
584
585
586 /*
587 * Find a method within a class. The superclass is not searched.
588 */
589 Method* dvmFindDirectMethodByDescriptor(const ClassObject* clazz,
590 const char* methodName, const char* signature);
591 Method* dvmFindVirtualMethodByDescriptor(const ClassObject* clazz,
592 const char* methodName, const char* signature);
593 Method* dvmFindVirtualMethodByName(const ClassObject* clazz,
594 const char* methodName);
595 Method* dvmFindDirectMethod(const ClassObject* clazz, const char* methodName,
596 const DexProto* proto);
597 Method* dvmFindVirtualMethod(const ClassObject* clazz, const char* methodName,
598 const DexProto* proto);
599
600
601 /*
602 * Find a method within a class hierarchy.
603 */
604 Method* dvmFindDirectMethodHierByDescriptor(const ClassObject* clazz,
605 const char* methodName, const char* descriptor);
606 Method* dvmFindVirtualMethodHierByDescriptor(const ClassObject* clazz,
607 const char* methodName, const char* signature);
608 Method* dvmFindDirectMethodHier(const ClassObject* clazz,
609 const char* methodName, const DexProto* proto);
610 Method* dvmFindVirtualMethodHier(const ClassObject* clazz,
611 const char* methodName, const DexProto* proto);
612 Method* dvmFindMethodHier(const ClassObject* clazz, const char* methodName,
613 const DexProto* proto);
614
615 /*
616 * Find a method in an interface hierarchy.
617 */
618 Method* dvmFindInterfaceMethodHierByDescriptor(const ClassObject* iface,
619 const char* methodName, const char* descriptor);
620 Method* dvmFindInterfaceMethodHier(const ClassObject* iface,
621 const char* methodName, const DexProto* proto);
622
623 /*
624 * Find the implementation of "meth" in "clazz".
625 *
626 * Returns NULL and throws an exception if not found.
627 */
628 const Method* dvmGetVirtualizedMethod(const ClassObject* clazz,
629 const Method* meth);
630
631 /*
632 * Get the source file associated with a method.
633 */
634 extern "C" const char* dvmGetMethodSourceFile(const Method* meth);
635
636 /*
637 * Find a field within a class. The superclass is not searched.
638 */
639 InstField* dvmFindInstanceField(const ClassObject* clazz,
640 const char* fieldName, const char* signature);
641 StaticField* dvmFindStaticField(const ClassObject* clazz,
642 const char* fieldName, const char* signature);
643
644 /*
645 * Find a field in a class/interface hierarchy.
646 */
647 InstField* dvmFindInstanceFieldHier(const ClassObject* clazz,
648 const char* fieldName, const char* signature);
649 StaticField* dvmFindStaticFieldHier(const ClassObject* clazz,
650 const char* fieldName, const char* signature);
651 Field* dvmFindFieldHier(const ClassObject* clazz, const char* fieldName,
652 const char* signature);
653
654 /*
655 * Find a field and return the byte offset from the object pointer. Only
656 * searches the specified class, not the superclass.
657 *
658 * Returns -1 on failure.
659 */
dvmFindFieldOffset(const ClassObject * clazz,const char * fieldName,const char * signature)660 INLINE int dvmFindFieldOffset(const ClassObject* clazz,
661 const char* fieldName, const char* signature)
662 {
663 InstField* pField = dvmFindInstanceField(clazz, fieldName, signature);
664 if (pField == NULL)
665 return -1;
666 else
667 return pField->byteOffset;
668 }
669
670 /*
671 * Helpers.
672 */
dvmIsPublicMethod(const Method * method)673 INLINE bool dvmIsPublicMethod(const Method* method) {
674 return (method->accessFlags & ACC_PUBLIC) != 0;
675 }
dvmIsPrivateMethod(const Method * method)676 INLINE bool dvmIsPrivateMethod(const Method* method) {
677 return (method->accessFlags & ACC_PRIVATE) != 0;
678 }
dvmIsStaticMethod(const Method * method)679 INLINE bool dvmIsStaticMethod(const Method* method) {
680 return (method->accessFlags & ACC_STATIC) != 0;
681 }
dvmIsSynchronizedMethod(const Method * method)682 INLINE bool dvmIsSynchronizedMethod(const Method* method) {
683 return (method->accessFlags & ACC_SYNCHRONIZED) != 0;
684 }
dvmIsDeclaredSynchronizedMethod(const Method * method)685 INLINE bool dvmIsDeclaredSynchronizedMethod(const Method* method) {
686 return (method->accessFlags & ACC_DECLARED_SYNCHRONIZED) != 0;
687 }
dvmIsFinalMethod(const Method * method)688 INLINE bool dvmIsFinalMethod(const Method* method) {
689 return (method->accessFlags & ACC_FINAL) != 0;
690 }
dvmIsNativeMethod(const Method * method)691 INLINE bool dvmIsNativeMethod(const Method* method) {
692 return (method->accessFlags & ACC_NATIVE) != 0;
693 }
dvmIsAbstractMethod(const Method * method)694 INLINE bool dvmIsAbstractMethod(const Method* method) {
695 return (method->accessFlags & ACC_ABSTRACT) != 0;
696 }
dvmIsSyntheticMethod(const Method * method)697 INLINE bool dvmIsSyntheticMethod(const Method* method) {
698 return (method->accessFlags & ACC_SYNTHETIC) != 0;
699 }
dvmIsMirandaMethod(const Method * method)700 INLINE bool dvmIsMirandaMethod(const Method* method) {
701 return (method->accessFlags & ACC_MIRANDA) != 0;
702 }
dvmIsConstructorMethod(const Method * method)703 INLINE bool dvmIsConstructorMethod(const Method* method) {
704 return *method->name == '<';
705 }
706 /* Dalvik puts private, static, and constructors into non-virtual table */
dvmIsDirectMethod(const Method * method)707 INLINE bool dvmIsDirectMethod(const Method* method) {
708 return dvmIsPrivateMethod(method) ||
709 dvmIsStaticMethod(method) ||
710 dvmIsConstructorMethod(method);
711 }
712 /* Get whether the given method has associated bytecode. This is the
713 * case for methods which are neither native nor abstract. */
dvmIsBytecodeMethod(const Method * method)714 INLINE bool dvmIsBytecodeMethod(const Method* method) {
715 return (method->accessFlags & (ACC_NATIVE | ACC_ABSTRACT)) == 0;
716 }
717
dvmIsProtectedField(const Field * field)718 INLINE bool dvmIsProtectedField(const Field* field) {
719 return (field->accessFlags & ACC_PROTECTED) != 0;
720 }
dvmIsStaticField(const Field * field)721 INLINE bool dvmIsStaticField(const Field* field) {
722 return (field->accessFlags & ACC_STATIC) != 0;
723 }
dvmIsFinalField(const Field * field)724 INLINE bool dvmIsFinalField(const Field* field) {
725 return (field->accessFlags & ACC_FINAL) != 0;
726 }
dvmIsVolatileField(const Field * field)727 INLINE bool dvmIsVolatileField(const Field* field) {
728 return (field->accessFlags & ACC_VOLATILE) != 0;
729 }
730
dvmIsInterfaceClass(const ClassObject * clazz)731 INLINE bool dvmIsInterfaceClass(const ClassObject* clazz) {
732 return (clazz->accessFlags & ACC_INTERFACE) != 0;
733 }
dvmIsPublicClass(const ClassObject * clazz)734 INLINE bool dvmIsPublicClass(const ClassObject* clazz) {
735 return (clazz->accessFlags & ACC_PUBLIC) != 0;
736 }
dvmIsFinalClass(const ClassObject * clazz)737 INLINE bool dvmIsFinalClass(const ClassObject* clazz) {
738 return (clazz->accessFlags & ACC_FINAL) != 0;
739 }
dvmIsAbstractClass(const ClassObject * clazz)740 INLINE bool dvmIsAbstractClass(const ClassObject* clazz) {
741 return (clazz->accessFlags & ACC_ABSTRACT) != 0;
742 }
dvmIsAnnotationClass(const ClassObject * clazz)743 INLINE bool dvmIsAnnotationClass(const ClassObject* clazz) {
744 return (clazz->accessFlags & ACC_ANNOTATION) != 0;
745 }
dvmIsPrimitiveClass(const ClassObject * clazz)746 INLINE bool dvmIsPrimitiveClass(const ClassObject* clazz) {
747 return clazz->primitiveType != PRIM_NOT;
748 }
749
750 /* linked, here meaning prepared and resolved */
dvmIsClassLinked(const ClassObject * clazz)751 INLINE bool dvmIsClassLinked(const ClassObject* clazz) {
752 return clazz->status >= CLASS_RESOLVED;
753 }
754 /* has class been verified? */
dvmIsClassVerified(const ClassObject * clazz)755 INLINE bool dvmIsClassVerified(const ClassObject* clazz) {
756 return clazz->status >= CLASS_VERIFIED;
757 }
758
759 /*
760 * Return whether the given object is an instance of Class.
761 */
dvmIsClassObject(const Object * obj)762 INLINE bool dvmIsClassObject(const Object* obj) {
763 assert(obj != NULL);
764 assert(obj->clazz != NULL);
765 return IS_CLASS_FLAG_SET(obj->clazz, CLASS_ISCLASS);
766 }
767
768 /*
769 * Return whether the given object is the class Class (that is, the
770 * unique class which is an instance of itself).
771 */
dvmIsTheClassClass(const ClassObject * clazz)772 INLINE bool dvmIsTheClassClass(const ClassObject* clazz) {
773 assert(clazz != NULL);
774 return IS_CLASS_FLAG_SET(clazz, CLASS_ISCLASS);
775 }
776
777 /*
778 * Get the associated code struct for a method. This returns NULL
779 * for non-bytecode methods.
780 */
dvmGetMethodCode(const Method * meth)781 INLINE const DexCode* dvmGetMethodCode(const Method* meth) {
782 if (dvmIsBytecodeMethod(meth)) {
783 /*
784 * The insns field for a bytecode method actually points at
785 * &(DexCode.insns), so we can subtract back to get at the
786 * DexCode in front.
787 */
788 return (const DexCode*)
789 (((const u1*) meth->insns) - offsetof(DexCode, insns));
790 } else {
791 return NULL;
792 }
793 }
794
795 /*
796 * Get the size of the insns associated with a method. This returns 0
797 * for non-bytecode methods.
798 */
dvmGetMethodInsnsSize(const Method * meth)799 INLINE u4 dvmGetMethodInsnsSize(const Method* meth) {
800 const DexCode* pCode = dvmGetMethodCode(meth);
801 return (pCode == NULL) ? 0 : pCode->insnsSize;
802 }
803
804 /* debugging */
805 void dvmDumpObject(const Object* obj);
806
807 #endif // DALVIK_OO_OBJECT_H_
808