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 * Basic reflection calls and utility functions.
18 */
19 #ifndef DALVIK_REFLECT_REFLECT_H_
20 #define DALVIK_REFLECT_REFLECT_H_
21
22 /*
23 * During startup, validate the "box" classes, e.g. java/lang/Integer.
24 */
25 bool dvmValidateBoxClasses();
26
27 /*
28 * Get all fields declared by a class.
29 *
30 * Includes both class and instance fields.
31 */
32 ArrayObject* dvmGetDeclaredFields(ClassObject* clazz, bool publicOnly);
33
34 /*
35 * Get the named field.
36 */
37 Object* dvmGetDeclaredField(ClassObject* clazz, StringObject* nameObj);
38
39 /*
40 * Get all constructors declared by a class.
41 */
42 ArrayObject* dvmGetDeclaredConstructors(ClassObject* clazz, bool publicOnly);
43
44 /*
45 * Get all methods declared by a class.
46 *
47 * This includes both static and virtual methods, and can include private
48 * members if "publicOnly" is false. It does not include Miranda methods,
49 * since those weren't declared in the class, or constructors.
50 */
51 ArrayObject* dvmGetDeclaredMethods(ClassObject* clazz, bool publicOnly);
52
53 /*
54 * Get the named method.
55 */
56 Object* dvmGetDeclaredConstructorOrMethod(ClassObject* clazz,
57 StringObject* nameObj, ArrayObject* args);
58
59 /*
60 * Get all interfaces a class implements. If this is unable to allocate
61 * the result array, this raises an OutOfMemoryError and returns NULL.
62 */
63 ArrayObject* dvmGetInterfaces(ClassObject* clazz);
64
65 /*
66 * Convert slot numbers back to objects.
67 */
68 Field* dvmSlotToField(ClassObject* clazz, int slot);
69 Method* dvmSlotToMethod(ClassObject* clazz, int slot);
70
71 /*
72 * Convert a primitive value, performing a widening conversion if necessary.
73 */
74 int dvmConvertPrimitiveValue(PrimitiveType srcType,
75 PrimitiveType dstType, const s4* srcPtr, s4* dstPtr);
76
77 /*
78 * Convert the argument to the specified type.
79 *
80 * Returns the width of the argument (1 for most types, 2 for J/D, -1 on
81 * error).
82 */
83 int dvmConvertArgument(DataObject* arg, ClassObject* type, s4* ins);
84
85 /*
86 * Box a primitive value into an object. If "returnType" is
87 * not primitive, this just returns "value" cast to an object.
88 */
89 DataObject* dvmBoxPrimitive(JValue value, ClassObject* returnType);
90
91 /*
92 * Unwrap a boxed primitive. If "returnType" is not primitive, this just
93 * returns "value" cast into a JValue.
94 */
95 bool dvmUnboxPrimitive(Object* value, ClassObject* returnType,
96 JValue* pResult);
97
98 /*
99 * Return the class object that matches the method's signature. For
100 * primitive types, returns the box class.
101 */
102 ClassObject* dvmGetBoxedReturnType(const Method* meth);
103
104 /*
105 * JNI reflection support.
106 */
107 Field* dvmGetFieldFromReflectObj(Object* obj);
108 Method* dvmGetMethodFromReflectObj(Object* obj);
109 Object* dvmCreateReflectObjForField(const ClassObject* clazz, Field* field);
110 Object* dvmCreateReflectObjForMethod(const ClassObject* clazz, Method* method);
111
112 /*
113 * Quick test to determine if the method in question is a reflection call.
114 * Used for some stack parsing. Currently defined as "the method's declaring
115 * class is java.lang.reflect.Method".
116 */
dvmIsReflectionMethod(const Method * method)117 INLINE bool dvmIsReflectionMethod(const Method* method)
118 {
119 return (method->clazz == gDvm.classJavaLangReflectMethod);
120 }
121
122 /*
123 * Proxy class generation.
124 */
125 ClassObject* dvmGenerateProxyClass(StringObject* str, ArrayObject* interfaces,
126 Object* loader);
127
128 /*
129 * Create a new java.lang.reflect.Method object based on "meth".
130 */
131 Object* dvmCreateReflectMethodObject(const Method* meth);
132
133 /*
134 * Return an array of Annotation objects for the specified piece. For method
135 * parameters this is an array of arrays of Annotation objects.
136 *
137 * Method also applies to Constructor.
138 */
139 ArrayObject* dvmGetClassAnnotations(const ClassObject* clazz);
140 ArrayObject* dvmGetMethodAnnotations(const Method* method);
141 ArrayObject* dvmGetFieldAnnotations(const Field* field);
142 ArrayObject* dvmGetParameterAnnotations(const Method* method);
143
144 /*
145 * Return the annotation if it exists.
146 */
147 Object* dvmGetClassAnnotation(const ClassObject* clazz, const ClassObject* annotationClazz);
148 Object* dvmGetMethodAnnotation(const ClassObject* clazz, const Method* method,
149 const ClassObject* annotationClazz);
150 Object* dvmGetFieldAnnotation(const ClassObject* clazz, const Field* method,
151 const ClassObject* annotationClazz);
152
153 /*
154 * Return true if the annotation exists.
155 */
156 bool dvmIsClassAnnotationPresent(const ClassObject* clazz, const ClassObject* annotationClazz);
157 bool dvmIsMethodAnnotationPresent(const ClassObject* clazz, const Method* method,
158 const ClassObject* annotationClazz);
159 bool dvmIsFieldAnnotationPresent(const ClassObject* clazz, const Field* method,
160 const ClassObject* annotationClazz);
161
162 /*
163 * Find the default value for an annotation member.
164 */
165 Object* dvmGetAnnotationDefaultValue(const Method* method);
166
167 /*
168 * Get the list of thrown exceptions for a method. Returns NULL if there
169 * are no exceptions listed.
170 */
171 ArrayObject* dvmGetMethodThrows(const Method* method);
172
173 /*
174 * Get the Signature annotation.
175 */
176 ArrayObject* dvmGetClassSignatureAnnotation(const ClassObject* clazz);
177 ArrayObject* dvmGetMethodSignatureAnnotation(const Method* method);
178 ArrayObject* dvmGetFieldSignatureAnnotation(const Field* field);
179
180 /*
181 * Get the EnclosingMethod attribute from an annotation. Returns a Method
182 * object, or NULL.
183 */
184 Object* dvmGetEnclosingMethod(const ClassObject* clazz);
185
186 /*
187 * Return clazz's declaring class, or NULL if there isn't one.
188 */
189 ClassObject* dvmGetDeclaringClass(const ClassObject* clazz);
190
191 /*
192 * Return clazz's enclosing class, or NULL if there isn't one.
193 */
194 ClassObject* dvmGetEnclosingClass(const ClassObject* clazz);
195
196 /*
197 * Get the EnclosingClass attribute from an annotation. If found, returns
198 * "true". A String with the original name of the class and the original
199 * access flags are returned through the arguments. (The name will be NULL
200 * for an anonymous inner class.)
201 */
202 bool dvmGetInnerClass(const ClassObject* clazz, StringObject** pName,
203 int* pAccessFlags);
204
205 /*
206 * Get an array of class objects from the MemberClasses annotation. Returns
207 * NULL if none found.
208 */
209 ArrayObject* dvmGetDeclaredClasses(const ClassObject* clazz);
210
211 /*
212 * Used to pass values out of annotation (and encoded array) processing
213 * functions.
214 */
215 struct AnnotationValue {
216 JValue value;
217 u1 type;
218 };
219
220
221 /**
222 * Iterator structure for iterating over DexEncodedArray instances. The
223 * structure should be treated as opaque.
224 */
225 struct EncodedArrayIterator {
226 const u1* cursor; /* current cursor */
227 u4 elementsLeft; /* number of elements left to read */
228 const DexEncodedArray* encodedArray; /* instance being iterated over */
229 u4 size; /* number of elements in instance */
230 const ClassObject* clazz; /* class to resolve with respect to */
231 };
232
233 /**
234 * Initializes an encoded array iterator.
235 *
236 * @param iterator iterator to initialize
237 * @param encodedArray encoded array to iterate over
238 * @param clazz class to use when resolving strings and types
239 */
240 void dvmEncodedArrayIteratorInitialize(EncodedArrayIterator* iterator,
241 const DexEncodedArray* encodedArray, const ClassObject* clazz);
242
243 /**
244 * Returns whether there are more elements to be read.
245 */
246 bool dvmEncodedArrayIteratorHasNext(const EncodedArrayIterator* iterator);
247
248 /**
249 * Returns the next decoded value from the iterator, advancing its
250 * cursor. This returns primitive values in their corresponding union
251 * slots, and returns everything else (including nulls) as object
252 * references in the "l" union slot.
253 *
254 * The caller must call dvmReleaseTrackedAlloc() on any returned reference.
255 *
256 * @param value pointer to store decoded value into
257 * @returns true if a value was decoded and the cursor advanced; false if
258 * the last value had already been decoded or if there was a problem decoding
259 */
260 bool dvmEncodedArrayIteratorGetNext(EncodedArrayIterator* iterator,
261 AnnotationValue* value);
262
263 #endif // DALVIK_REFLECT_REFLECT_H_
264