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);
}
