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 * Internal-native initialization and some common utility functions.
19 */
20 #include "Dalvik.h"
21 #include "native/InternalNativePriv.h"
22
23 /*
24 * Set of classes for which we provide methods.
25 *
26 * The last field, classNameHash, is filled in at startup.
27 */
28 static DalvikNativeClass gDvmNativeMethodSet[] = {
29 { "Ljava/lang/Object;", dvm_java_lang_Object, 0 },
30 { "Ljava/lang/Class;", dvm_java_lang_Class, 0 },
31 { "Ljava/lang/Double;", dvm_java_lang_Double, 0 },
32 { "Ljava/lang/Float;", dvm_java_lang_Float, 0 },
33 { "Ljava/lang/Math;", dvm_java_lang_Math, 0 },
34 { "Ljava/lang/Runtime;", dvm_java_lang_Runtime, 0 },
35 { "Ljava/lang/String;", dvm_java_lang_String, 0 },
36 { "Ljava/lang/System;", dvm_java_lang_System, 0 },
37 { "Ljava/lang/Throwable;", dvm_java_lang_Throwable, 0 },
38 { "Ljava/lang/VMClassLoader;", dvm_java_lang_VMClassLoader, 0 },
39 { "Ljava/lang/VMThread;", dvm_java_lang_VMThread, 0 },
40 { "Ljava/lang/reflect/AccessibleObject;",
41 dvm_java_lang_reflect_AccessibleObject, 0 },
42 { "Ljava/lang/reflect/Array;", dvm_java_lang_reflect_Array, 0 },
43 { "Ljava/lang/reflect/Constructor;",
44 dvm_java_lang_reflect_Constructor, 0 },
45 { "Ljava/lang/reflect/Field;", dvm_java_lang_reflect_Field, 0 },
46 { "Ljava/lang/reflect/Method;", dvm_java_lang_reflect_Method, 0 },
47 { "Ljava/lang/reflect/Proxy;", dvm_java_lang_reflect_Proxy, 0 },
48 { "Ljava/util/concurrent/atomic/AtomicLong;",
49 dvm_java_util_concurrent_atomic_AtomicLong, 0 },
50 { "Ldalvik/bytecode/OpcodeInfo;", dvm_dalvik_bytecode_OpcodeInfo, 0 },
51 { "Ldalvik/system/VMDebug;", dvm_dalvik_system_VMDebug, 0 },
52 { "Ldalvik/system/DexFile;", dvm_dalvik_system_DexFile, 0 },
53 { "Ldalvik/system/VMRuntime;", dvm_dalvik_system_VMRuntime, 0 },
54 { "Ldalvik/system/Zygote;", dvm_dalvik_system_Zygote, 0 },
55 { "Ldalvik/system/VMStack;", dvm_dalvik_system_VMStack, 0 },
56 { "Lorg/apache/harmony/dalvik/ddmc/DdmServer;",
57 dvm_org_apache_harmony_dalvik_ddmc_DdmServer, 0 },
58 { "Lorg/apache/harmony/dalvik/ddmc/DdmVmInternal;",
59 dvm_org_apache_harmony_dalvik_ddmc_DdmVmInternal, 0 },
60 { "Lorg/apache/harmony/dalvik/NativeTestTarget;",
61 dvm_org_apache_harmony_dalvik_NativeTestTarget, 0 },
62 { "Lsun/misc/Unsafe;", dvm_sun_misc_Unsafe, 0 },
63 { NULL, NULL, 0 },
64 };
65
66
67 /*
68 * Set up hash values on the class names.
69 */
70 bool dvmInternalNativeStartup()
71 {
72 DalvikNativeClass* classPtr = gDvmNativeMethodSet;
73
74 while (classPtr->classDescriptor != NULL) {
75 classPtr->classDescriptorHash =
76 dvmComputeUtf8Hash(classPtr->classDescriptor);
77 classPtr++;
78 }
79
80 gDvm.userDexFiles = dvmHashTableCreate(2, dvmFreeDexOrJar);
81 if (gDvm.userDexFiles == NULL)
82 return false;
83
84 return true;
85 }
86
87 /*
88 * Clean up.
89 */
90 void dvmInternalNativeShutdown()
91 {
92 dvmHashTableFree(gDvm.userDexFiles);
93 }
94
95 /*
96 * Search the internal native set for a match.
97 */
98 DalvikNativeFunc dvmLookupInternalNativeMethod(const Method* method)
99 {
100 const char* classDescriptor = method->clazz->descriptor;
101 const DalvikNativeClass* pClass;
102 u4 hash;
103
104 hash = dvmComputeUtf8Hash(classDescriptor);
105 pClass = gDvmNativeMethodSet;
106 while (true) {
107 if (pClass->classDescriptor == NULL)
108 break;
109 if (pClass->classDescriptorHash == hash &&
110 strcmp(pClass->classDescriptor, classDescriptor) == 0)
111 {
112 const DalvikNativeMethod* pMeth = pClass->methodInfo;
113 while (true) {
114 if (pMeth->name == NULL)
115 break;
116
117 if (dvmCompareNameDescriptorAndMethod(pMeth->name,
118 pMeth->signature, method) == 0)
119 {
120 /* match */
121 //ALOGV("+++ match on %s.%s %s at %p",
122 // className, methodName, methodSignature, pMeth->fnPtr);
123 return pMeth->fnPtr;
124 }
125
126 pMeth++;
127 }
128 }
129
130 pClass++;
131 }
132
133 return NULL;
134 }
135
136
137 /*
138 * Magic "internal native" code stub, inserted into abstract method
139 * definitions when a class is first loaded. This throws the expected
140 * exception so we don't have to explicitly check for it in the interpreter.
141 */
142 void dvmAbstractMethodStub(const u4* args, JValue* pResult)
143 {
144 ALOGD("--- called into dvmAbstractMethodStub");
145 dvmThrowAbstractMethodError("abstract method not implemented");
146 }
147
148
149 /*
150 * Verify that "obj" is non-null and is an instance of "clazz".
151 * Used to implement reflection on fields and methods.
152 *
153 * Returns "false" and throws an exception if not.
154 */
155 bool dvmVerifyObjectInClass(Object* obj, ClassObject* clazz) {
156 ClassObject* exceptionClass = NULL;
157 if (obj == NULL) {
158 exceptionClass = gDvm.exNullPointerException;
159 } else if (!dvmInstanceof(obj->clazz, clazz)) {
160 exceptionClass = gDvm.exIllegalArgumentException;
161 }
162
163 if (exceptionClass == NULL) {
164 return true;
165 }
166
167 std::string expectedClassName(dvmHumanReadableDescriptor(clazz->descriptor));
168 std::string actualClassName(dvmHumanReadableType(obj));
169 dvmThrowExceptionFmt(exceptionClass, "expected receiver of type %s, but got %s",
170 expectedClassName.c_str(), actualClassName.c_str());
171 return false;
172 }
173
174 /*
175 * Find a class by name, initializing it if requested.
176 */
177 ClassObject* dvmFindClassByName(StringObject* nameObj, Object* loader,
178 bool doInit)
179 {
180 ClassObject* clazz = NULL;
181 char* name = NULL;
182 char* descriptor = NULL;
183
184 if (nameObj == NULL) {
185 dvmThrowNullPointerException("name == null");
186 goto bail;
187 }
188 name = dvmCreateCstrFromString(nameObj);
189
190 /*
191 * We need to validate and convert the name (from x.y.z to x/y/z). This
192 * is especially handy for array types, since we want to avoid
193 * auto-generating bogus array classes.
194 */
195 if (!dexIsValidClassName(name, true)) {
196 ALOGW("dvmFindClassByName rejecting '%s'", name);
197 dvmThrowClassNotFoundException(name);
198 goto bail;
199 }
200
201 descriptor = dvmDotToDescriptor(name);
202 if (descriptor == NULL) {
203 goto bail;
204 }
205
206 if (doInit)
207 clazz = dvmFindClass(descriptor, loader);
208 else
209 clazz = dvmFindClassNoInit(descriptor, loader);
210
211 if (clazz == NULL) {
212 LOGVV("FAIL: load %s (%d)", descriptor, doInit);
213 Thread* self = dvmThreadSelf();
214 Object* oldExcep = dvmGetException(self);
215 dvmAddTrackedAlloc(oldExcep, self); /* don't let this be GCed */
216 dvmClearException(self);
217 dvmThrowChainedClassNotFoundException(name, oldExcep);
218 dvmReleaseTrackedAlloc(oldExcep, self);
219 } else {
220 LOGVV("GOOD: load %s (%d) --> %p ldr=%p",
221 descriptor, doInit, clazz, clazz->classLoader);
222 }
223
224 bail:
225 free(name);
226 free(descriptor);
227 return clazz;
228 }
229
230 /*
231 * We insert native method stubs for abstract methods so we don't have to
232 * check the access flags at the time of the method call. This results in
233 * "native abstract" methods, which can't exist. If we see the "abstract"
234 * flag set, clear the "native" flag.
235 *
236 * We also move the DECLARED_SYNCHRONIZED flag into the SYNCHRONIZED
237 * position, because the callers of this function are trying to convey
238 * the "traditional" meaning of the flags to their callers.
239 */
240 u4 dvmFixMethodFlags(u4 flags)
241 {
242 if ((flags & ACC_ABSTRACT) != 0) {
243 flags &= ~ACC_NATIVE;
244 }
245
246 flags &= ~ACC_SYNCHRONIZED;
247
248 if ((flags & ACC_DECLARED_SYNCHRONIZED) != 0) {
249 flags |= ACC_SYNCHRONIZED;
250 }
251
252 return flags & JAVA_FLAGS_MASK;
253 }
