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 * Class loader. 18 */ 19 #ifndef DALVIK_OO_CLASS_H_ 20 #define DALVIK_OO_CLASS_H_ 21 22 /* 23 * The classpath and bootclasspath differ in that only the latter is 24 * consulted when looking for classes needed by the VM. When searching 25 * for an arbitrary class definition, we start with the bootclasspath, 26 * look for optional packages (a/k/a standard extensions), and then try 27 * the classpath. 28 * 29 * In Dalvik, a class can be found in one of two ways: 30 * - in a .dex file 31 * - in a .dex file named specifically "classes.dex", which is held 32 * inside a jar file 33 * 34 * These two may be freely intermixed in a classpath specification. 35 * Ordering is significant. 36 */ 37 enum ClassPathEntryKind { 38 kCpeUnknown = 0, 39 kCpeJar, 40 kCpeDex, 41 kCpeLastEntry /* used as sentinel at end of array */ 42 }; 43 44 struct ClassPathEntry { 45 ClassPathEntryKind kind; 46 char* fileName; 47 void* ptr; /* JarFile* or DexFile* */ 48 }; 49 50 bool dvmClassStartup(void); 51 void dvmClassShutdown(void); 52 bool dvmPrepBootClassPath(bool isNormalStart); 53 54 /* 55 * Boot class path accessors, for class loader getResources(). 56 */ 57 int dvmGetBootPathSize(void); 58 StringObject* dvmGetBootPathResource(const char* name, int idx); 59 void dvmDumpBootClassPath(void); 60 61 /* 62 * Determine whether "path" is a member of "cpe". 63 */ 64 bool dvmClassPathContains(const ClassPathEntry* cpe, const char* path); 65 66 /* 67 * Set clazz->serialNumber to the next available value. 68 */ 69 void dvmSetClassSerialNumber(ClassObject* clazz); 70 71 /* 72 * Find the class object representing the primitive type with the 73 * given descriptor. This returns NULL if the given type character 74 * is invalid. 75 */ 76 ClassObject* dvmFindPrimitiveClass(char type); 77 78 /* 79 * Find the class with the given descriptor. Load it if it hasn't already 80 * been. 81 * 82 * "loader" is the initiating class loader. 83 */ 84 ClassObject* dvmFindClass(const char* descriptor, Object* loader); 85 ClassObject* dvmFindClassNoInit(const char* descriptor, Object* loader); 86 87 /* 88 * Like dvmFindClass, but only for system classes. 89 */ 90 ClassObject* dvmFindSystemClass(const char* descriptor); 91 ClassObject* dvmFindSystemClassNoInit(const char* descriptor); 92 93 /* 94 * Find a loaded class by descriptor. Returns the first one found. 95 * Because there can be more than one if class loaders are involved, 96 * this is not an especially good API. (Currently only used by the 97 * debugger and "checking" JNI.) 98 * 99 * "descriptor" should have the form "Ljava/lang/Class;" or 100 * "[Ljava/lang/Class;", i.e. a descriptor and not an internal-form 101 * class name. 102 */ 103 ClassObject* dvmFindLoadedClass(const char* descriptor); 104 105 /* 106 * Load the named class (by descriptor) from the specified DEX file. 107 * Used by class loaders to instantiate a class object from a 108 * VM-managed DEX. 109 */ 110 ClassObject* dvmDefineClass(DvmDex* pDvmDex, const char* descriptor, 111 Object* classLoader); 112 113 /* 114 * Link a loaded class. Normally done as part of one of the "find class" 115 * variations, this is only called explicitly for synthetic class 116 * generation (e.g. reflect.Proxy). 117 */ 118 bool dvmLinkClass(ClassObject* clazz); 119 120 /* 121 * Determine if a class has been initialized. 122 */ 123 INLINE bool dvmIsClassInitialized(const ClassObject* clazz) { 124 return (clazz->status == CLASS_INITIALIZED); 125 } 126 bool dvmIsClassInitializing(const ClassObject* clazz); 127 128 /* 129 * Initialize a class. 130 */ 131 extern "C" bool dvmInitClass(ClassObject* clazz); 132 133 /* 134 * Retrieve the system class loader. 135 */ 136 Object* dvmGetSystemClassLoader(void); 137 138 /* 139 * Utility functions. 140 */ 141 ClassObject* dvmLookupClass(const char* descriptor, Object* loader, 142 bool unprepOkay); 143 void dvmFreeClassInnards(ClassObject* clazz); 144 bool dvmAddClassToHash(ClassObject* clazz); 145 void dvmAddInitiatingLoader(ClassObject* clazz, Object* loader); 146 bool dvmLoaderInInitiatingList(const ClassObject* clazz, const Object* loader); 147 148 /* 149 * Update method's "nativeFunc" and "insns". If "insns" is NULL, the 150 * current method->insns value is not changed. 151 */ 152 void dvmSetNativeFunc(Method* method, DalvikBridgeFunc func, const u2* insns); 153 154 /* 155 * Set the method's "registerMap" field. 156 */ 157 void dvmSetRegisterMap(Method* method, const RegisterMap* pMap); 158 159 /* 160 * Make a method's DexCode (which includes the bytecode) read-write or 161 * read-only. The conversion to read-write may involve making a new copy 162 * of the DexCode, and in normal operation the read-only state is not 163 * actually enforced. 164 */ 165 void dvmMakeCodeReadWrite(Method* meth); 166 void dvmMakeCodeReadOnly(Method* meth); 167 168 /* 169 * During DEX optimizing, add an extra DEX to the bootstrap class path. 170 */ 171 void dvmSetBootPathExtraDex(DvmDex* pDvmDex); 172 173 /* 174 * Debugging. 175 */ 176 void dvmDumpClass(const ClassObject* clazz, int flags); 177 void dvmDumpAllClasses(int flags); 178 void dvmDumpLoaderStats(const char* msg); 179 int dvmGetNumLoadedClasses(); 180 181 /* flags for dvmDumpClass / dvmDumpAllClasses */ 182 #define kDumpClassFullDetail 1 183 #define kDumpClassClassLoader (1 << 1) 184 #define kDumpClassInitialized (1 << 2) 185 186 187 /* 188 * Store a copy of the method prototype descriptor string 189 * for the given method into the given DexStringCache, returning the 190 * stored string for convenience. 191 */ 192 INLINE char* dvmCopyDescriptorStringFromMethod(const Method* method, 193 DexStringCache *pCache) 194 { 195 const char* result = 196 dexProtoGetMethodDescriptor(&method->prototype, pCache); 197 return dexStringCacheEnsureCopy(pCache, result); 198 } 199 200 /* 201 * Compute the number of argument words (u4 units) required by the 202 * given method's prototype. For example, if the method descriptor is 203 * "(IJ)D", this would return 3 (one for the int, two for the long; 204 * return value isn't relevant). 205 */ 206 INLINE int dvmComputeMethodArgsSize(const Method* method) 207 { 208 return dexProtoComputeArgsSize(&method->prototype); 209 } 210 211 /* 212 * Compare the two method prototypes. The two prototypes are compared 213 * as if by strcmp() on the result of dexProtoGetMethodDescriptor(). 214 */ 215 INLINE int dvmCompareMethodProtos(const Method* method1, 216 const Method* method2) 217 { 218 return dexProtoCompare(&method1->prototype, &method2->prototype); 219 } 220 221 /* 222 * Compare the two method prototypes, considering only the parameters 223 * (i.e. ignoring the return types). The two prototypes are compared 224 * as if by strcmp() on the result of dexProtoGetMethodDescriptor(). 225 */ 226 INLINE int dvmCompareMethodParameterProtos(const Method* method1, 227 const Method* method2) 228 { 229 return dexProtoCompareParameters(&method1->prototype, &method2->prototype); 230 } 231 232 /* 233 * Compare the two method names and prototypes, a la strcmp(). The 234 * name is considered the "major" order and the prototype the "minor" 235 * order. The prototypes are compared as if by dexProtoGetMethodDescriptor(). 236 */ 237 int dvmCompareMethodNamesAndProtos(const Method* method1, 238 const Method* method2); 239 240 /* 241 * Compare the two method names and prototypes, a la strcmp(), ignoring 242 * the return type. The name is considered the "major" order and the 243 * prototype the "minor" order. The prototypes are compared as if by 244 * dexProtoGetMethodDescriptor(). 245 */ 246 int dvmCompareMethodNamesAndParameterProtos(const Method* method1, 247 const Method* method2); 248 249 /* 250 * Compare a method descriptor string with the prototype of a method, 251 * as if by converting the descriptor to a DexProto and comparing it 252 * with dexProtoCompare(). 253 */ 254 INLINE int dvmCompareDescriptorAndMethodProto(const char* descriptor, 255 const Method* method) 256 { 257 // Sense is reversed. 258 return -dexProtoCompareToDescriptor(&method->prototype, descriptor); 259 } 260 261 /* 262 * Compare a (name, prototype) pair with the (name, prototype) of 263 * a method, a la strcmp(). The name is considered the "major" order and 264 * the prototype the "minor" order. The descriptor and prototype are 265 * compared as if by dvmCompareDescriptorAndMethodProto(). 266 */ 267 int dvmCompareNameProtoAndMethod(const char* name, 268 const DexProto* proto, const Method* method); 269 270 /* 271 * Compare a (name, method descriptor) pair with the (name, prototype) of 272 * a method, a la strcmp(). The name is considered the "major" order and 273 * the prototype the "minor" order. The descriptor and prototype are 274 * compared as if by dvmCompareDescriptorAndMethodProto(). 275 */ 276 int dvmCompareNameDescriptorAndMethod(const char* name, 277 const char* descriptor, const Method* method); 278 279 /* 280 * Returns the size of the given class object in bytes. 281 */ 282 size_t dvmClassObjectSize(const ClassObject *clazz); 283 284 #endif // DALVIK_OO_CLASS_H_ 285
