static Field* loadFields(Env* env, Class* clazz) { ClassInfoHeader* header = lookupClassInfo(env, clazz->name, !clazz->classLoader || !clazz->classLoader->parent ? _bcBootClassesHash : _bcClassesHash); if (!header) return NULL; ClassInfo ci; jint i; void* p = header; readClassInfo(&p, &ci); skipInterfaceNames(&p, &ci); Field* first = NULL; for (i = 0; i < ci.fieldCount; i++) { FieldInfo fi; readFieldInfo(&p, &fi); Field* f = rvmAllocateField(env, clazz, fi.name, fi.desc, fi.access, fi.offset, fi.attributes); if (!f) goto error; LL_PREPEND(first, f); } return first; error: while (first) { Field* next = first->next; rvmFreeMemoryUncollectable(env, first); first = next; } return NULL; }
static void loadMethods(Env* env, Class* clazz) { ClassInfoHeader* header = lookupClassInfo(env, clazz->name, !clazz->classLoader || !clazz->classLoader->parent ? _bcBootClassesHash : _bcClassesHash); if (!header) return; ClassInfo ci; jint i; void* p = header; readClassInfo(&p, &ci); skipInterfaceNames(&p, &ci); skipFieldInfos(&p, &ci); for (i = 0; i < ci.methodCount; i++) { MethodInfo mi; readMethodInfo(&p, &mi); if (mi.targetFnPtr) { if (!rvmAddBridgeMethod(env, clazz, mi.name, mi.desc, mi.access, mi.size, mi.impl, mi.synchronizedImpl, mi.targetFnPtr, mi.attributes)) return; } else if (mi.callbackImpl) { if (!rvmAddCallbackMethod(env, clazz, mi.name, mi.desc, mi.access, mi.size, mi.impl, mi.synchronizedImpl, mi.callbackImpl, mi.attributes)) return; } else { if (!rvmAddMethod(env, clazz, mi.name, mi.desc, mi.access, mi.size, mi.impl, mi.synchronizedImpl, mi.attributes)) return; } } }
static Interface* loadInterfaces(Env* env, Class* clazz) { ClassInfoHeader* header = lookupClassInfo(env, clazz->name, !clazz->classLoader || !clazz->classLoader->parent ? _bcBootClassesHash : _bcClassesHash); if (!header) return NULL; ClassInfo ci; jint i; void* p = header; readClassInfo(&p, &ci); Interface* first = NULL; for (i = 0; i < ci.interfaceCount; i++) { const char* interfaceName = readInterfaceName(&p); Class* interfaceClass = rvmFindClassUsingLoader(env, interfaceName, clazz->classLoader); if (!interfaceClass) goto error; Interface* interf = rvmAllocateInterface(env, interfaceClass); if (!interf) goto error; LL_APPEND(first, interf); // Interfaces has to be in the correct order so we need to use the slower LL_APPEND } return first; error: while (first) { Interface* next = first->next; rvmFreeMemoryUncollectable(env, first); first = next; } return NULL; }
static Class* ldcClass(Env* env, ClassInfoHeader* header) { Class* clazz = header->clazz; if (!clazz) { ClassLoader* loader = NULL; if (lookupClassInfo(env, header->className, _bcClassesHash) == header) { loader = systemClassLoader; } clazz = rvmFindClassUsingLoader(env, header->className, loader); if (!clazz) wrapClassNotFoundException(env, header->className); } return clazz; }
Class* findClassAt(Env* env, void* pc) { AddressClassLookup* lookups = getAddressClassLookups(env); if (!lookups) return NULL; AddressClassLookup needle = {NULL, pc, pc}; AddressClassLookup* result = bsearch(&needle, lookups, addressClassLookupsCount, sizeof(AddressClassLookup), addressClassLookupCompareBSearch); if (!result) return NULL; ClassInfoHeader* header = result->classInfoHeader; Class* clazz = header->clazz; if (!clazz) { ClassLoader* loader = NULL; if (lookupClassInfo(env, header->className, _bcClassesHash) == header) { loader = systemClassLoader; } clazz = rvmFindClassUsingLoader(env, header->className, loader); } return clazz; }
static void loadFields(Env* env, Class* clazz) { ClassInfoHeader* header = lookupClassInfo(env, clazz->name, !clazz->classLoader || !clazz->classLoader->parent ? _bcBootClassesHash : _bcClassesHash); if (!header) return; ClassInfo ci; jint i; void* p = header; readClassInfo(&p, &ci); skipInterfaceNames(&p, &ci); for (i = 0; i < ci.fieldCount; i++) { FieldInfo fi; readFieldInfo(&p, &fi); if (!rvmAddField(env, clazz, fi.name, fi.desc, fi.access, fi.offset, fi.attributes)) return; } }
static void loadInterfaces(Env* env, Class* clazz) { ClassInfoHeader* header = lookupClassInfo(env, clazz->name, !clazz->classLoader || !clazz->classLoader->parent ? _bcBootClassesHash : _bcClassesHash); if (!header) return; ClassInfo ci; jint i; void* p = header; readClassInfo(&p, &ci); for (i = 0; i < ci.interfaceCount; i++) { const char* interfaceName = readInterfaceName(&p); Class* interface = rvmFindClassUsingLoader(env, interfaceName, clazz->classLoader); if (!interface) return; rvmAddInterface(env, clazz, interface); if (rvmExceptionCheck(env)) return; } }
static Class* loadClass(Env* env, const char* className, ClassLoader* classLoader, void* hash) { ClassInfoHeader* header = lookupClassInfo(env, className, hash); if (!header) return NULL; if (header->flags & CI_ERROR) { ClassInfoError* error = (ClassInfoError*) header; switch (error->errorType) { case CI_ERROR_TYPE_NO_CLASS_DEF_FOUND: rvmThrowNoClassDefFoundError(env, error->errorMessage); break; case CI_ERROR_TYPE_ILLEGAL_ACCESS: rvmThrowIllegalAccessError(env, error->errorMessage); break; case CI_ERROR_TYPE_INCOMPATIBLE_CLASS_CHANGE: rvmThrowIncompatibleClassChangeError(env, error->errorMessage); break; } return NULL; } if (header->clazz) return header->clazz; return createClass(env, header, classLoader); }
static Method* loadMethods(Env* env, Class* clazz) { ClassInfoHeader* header = lookupClassInfo(env, clazz->name, !clazz->classLoader || !rvmGetParentClassLoader(env, clazz->classLoader) ? _bcBootClassesHash : _bcClassesHash); if (!header) return NULL; ClassInfo ci; jint i; void* p = header; readClassInfo(&p, &ci); skipInterfaceNames(&p, &ci); skipFieldInfos(&p, &ci); Method* first = NULL; for (i = 0; i < ci.methodCount; i++) { MethodInfo mi; readMethodInfo(&p, &mi); if (!isStrippedMethod(&mi)) { Method* m = NULL; if (mi.targetFnPtr) { m = (Method*) rvmAllocateBridgeMethod(env, clazz, mi.name, mi.desc, mi.vtableIndex, mi.access, mi.size, mi.impl, mi.synchronizedImpl, mi.targetFnPtr, mi.attributes); } else if (mi.callbackImpl) { m = (Method*) rvmAllocateCallbackMethod(env, clazz, mi.name, mi.desc, mi.vtableIndex, mi.access, mi.size, mi.impl, mi.synchronizedImpl, mi.linetable, mi.callbackImpl, mi.attributes); } else { m = rvmAllocateMethod(env, clazz, mi.name, mi.desc, mi.vtableIndex, mi.access, mi.size, mi.impl, mi.synchronizedImpl, mi.linetable, mi.attributes); } if (!m) goto error; LL_PREPEND(first, m); } } return first; error: while (first) { Method* next = first->next; rvmFreeMemoryUncollectable(env, first); first = next; } return NULL; }
static void classInitialized(Env* env, Class* clazz) { ClassInfoHeader* header = lookupClassInfo(env, clazz->name, !clazz->classLoader || !clazz->classLoader->parent ? _bcBootClassesHash : _bcClassesHash); if (!header) return; rvmAtomicStoreInt(&header->flags, header->flags | CI_INITIALIZED); }