ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-06-01 15:10:54 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

staticly type GcClassLoader instances

Browse Source
This commit is contained in:
Joshua Warner 2014-06-28 15:11:31 -06:00 committed by Joshua Warner
parent 6a0502bbfe
commit 9ffbd7e9fe
11 changed files with 349 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
src/avian/classpath-common.h
View File

@ -343,7 +343,7 @@ translateInvokeResult(Thread* t, unsigned returnCode, object o)
} }
GcClass* GcClass*
resolveClassBySpec(Thread* t, object loader, const char* spec, resolveClassBySpec(Thread* t, GcClassLoader* loader, const char* spec,
unsigned specLength) unsigned specLength)
{ {
switch (*spec) { switch (*spec) {
@ -367,13 +367,13 @@ resolveClassBySpec(Thread* t, object loader, const char* spec,
} }
GcJclass* GcJclass*
resolveJType(Thread* t, object loader, const char* spec, unsigned specLength) resolveJType(Thread* t, GcClassLoader* loader, const char* spec, unsigned specLength)
{ {
return getJClass(t, resolveClassBySpec(t, loader, spec, specLength)); return getJClass(t, resolveClassBySpec(t, loader, spec, specLength));
} }
object object
resolveParameterTypes(Thread* t, object loader, object spec, resolveParameterTypes(Thread* t, GcClassLoader* loader, GcByteArray* spec,
unsigned* parameterCount, unsigned* returnTypeSpec) unsigned* parameterCount, unsigned* returnTypeSpec)
{ {
PROTECT(t, loader); PROTECT(t, loader);
@ -384,16 +384,16 @@ resolveParameterTypes(Thread* t, object loader, object spec,
unsigned offset = 1; unsigned offset = 1;
unsigned count = 0; unsigned count = 0;
while (byteArrayBody(t, spec, offset) != ')') { while (spec->body()[offset] != ')') {
switch (byteArrayBody(t, spec, offset)) { switch (spec->body()[offset]) {
case 'L': { case 'L': {
unsigned start = offset; unsigned start = offset;
++ offset; ++ offset;
while (byteArrayBody(t, spec, offset) != ';') ++ offset; while (spec->body()[offset] != ';') ++ offset;
++ offset; ++ offset;
GcClass* type = resolveClassBySpec GcClass* type = resolveClassBySpec
(t, loader, reinterpret_cast<char*>(&byteArrayBody(t, spec, start)), (t, loader, reinterpret_cast<char*>(&spec->body()[start]),
offset - start); offset - start);
list = reinterpret_cast<object>(makePair(t, reinterpret_cast<object>(type), list)); list = reinterpret_cast<object>(makePair(t, reinterpret_cast<object>(type), list));
@ -403,11 +403,11 @@ resolveParameterTypes(Thread* t, object loader, object spec,
case '[': { case '[': {
unsigned start = offset; unsigned start = offset;
while (byteArrayBody(t, spec, offset) == '[') ++ offset; while (spec->body()[offset] == '[') ++ offset;
switch (byteArrayBody(t, spec, offset)) { switch (spec->body()[offset]) {
case 'L': case 'L':
++ offset; ++ offset;
while (byteArrayBody(t, spec, offset) != ';') ++ offset; while (spec->body()[offset] != ';') ++ offset;
++ offset; ++ offset;
break; break;
@ -417,7 +417,7 @@ resolveParameterTypes(Thread* t, object loader, object spec,
} }
GcClass* type = resolveClassBySpec GcClass* type = resolveClassBySpec
(t, loader, reinterpret_cast<char*>(&byteArrayBody(t, spec, start)), (t, loader, reinterpret_cast<char*>(&spec->body()[start]),
offset - start); offset - start);
list = reinterpret_cast<object>(makePair(t, reinterpret_cast<object>(type), list)); list = reinterpret_cast<object>(makePair(t, reinterpret_cast<object>(type), list));
@ -426,7 +426,7 @@ resolveParameterTypes(Thread* t, object loader, object spec,
default: default:
list = reinterpret_cast<object>(makePair list = reinterpret_cast<object>(makePair
(t, reinterpret_cast<object>(primitiveClass(t, byteArrayBody(t, spec, offset))), list)); (t, reinterpret_cast<object>(primitiveClass(t, spec->body()[offset])), list));
++ offset; ++ offset;
++ count; ++ count;
break; break;
@ -439,7 +439,7 @@ resolveParameterTypes(Thread* t, object loader, object spec,
} }
object object
resolveParameterJTypes(Thread* t, object loader, object spec, resolveParameterJTypes(Thread* t, GcClassLoader* loader, GcByteArray* spec,
unsigned* parameterCount, unsigned* returnTypeSpec) unsigned* parameterCount, unsigned* returnTypeSpec)
{ {
object list = resolveParameterTypes object list = resolveParameterTypes
@ -461,9 +461,9 @@ resolveParameterJTypes(Thread* t, object loader, object spec,
} }
object object
resolveExceptionJTypes(Thread* t, object loader, object addendum) resolveExceptionJTypes(Thread* t, GcClassLoader* loader, GcMethodAddendum* addendum)
{ {
if (addendum == 0 or methodAddendumExceptionTable(t, addendum) == 0) { if (addendum == 0 or addendum->exceptionTable() == 0) {
return makeObjectArray(t, type(t, GcJclass::Type), 0); return makeObjectArray(t, type(t, GcJclass::Type), 0);
} }
@ -472,21 +472,21 @@ resolveExceptionJTypes(Thread* t, object loader, object addendum)
object array = makeObjectArray object array = makeObjectArray
(t, type(t, GcJclass::Type), (t, type(t, GcJclass::Type),
shortArrayLength(t, methodAddendumExceptionTable(t, addendum))); shortArrayLength(t, addendum->exceptionTable()));
PROTECT(t, array); PROTECT(t, array);
for (unsigned i = 0; i < shortArrayLength for (unsigned i = 0; i < shortArrayLength
(t, methodAddendumExceptionTable(t, addendum)); ++i) (t, addendum->exceptionTable()); ++i)
{ {
uint16_t index = shortArrayBody uint16_t index = shortArrayBody
(t, methodAddendumExceptionTable(t, addendum), i) - 1; (t, addendum->exceptionTable(), i) - 1;
object o = singletonObject(t, cast<GcSingleton>(t, addendumPool(t, addendum)), index); object o = singletonObject(t, addendum->pool(), index);
if (objectClass(t, o) == type(t, GcReference::Type)) { if (objectClass(t, o) == type(t, GcReference::Type)) {
o = reinterpret_cast<object>(resolveClass(t, loader, referenceName(t, o))); o = reinterpret_cast<object>(resolveClass(t, loader, referenceName(t, o)));
set(t, addendumPool(t, addendum), SingletonBody + (index * BytesPerWord), set(t, reinterpret_cast<object>(addendum->pool()), SingletonBody + (index * BytesPerWord),
o); o);
} }
@ -549,7 +549,7 @@ invoke(Thread* t, GcMethod* method, object instance, object args)
memcpy(RUNTIME_ARRAY_BODY(name), p, nameLength - 1); memcpy(RUNTIME_ARRAY_BODY(name), p, nameLength - 1);
RUNTIME_ARRAY_BODY(name)[nameLength - 1] = 0; RUNTIME_ARRAY_BODY(name)[nameLength - 1] = 0;
type = resolveClass type = resolveClass
(t, reinterpret_cast<object>(method->class_()->loader()), (t, method->class_()->loader(),
RUNTIME_ARRAY_BODY(name)); RUNTIME_ARRAY_BODY(name));
} break; } break;
@ -710,7 +710,7 @@ getDeclaredClasses(Thread* t, object c, bool publicOnly)
t, t,
resolveClass( resolveClass(
t, t,
classLoader(t, c), cast<GcClassLoader>(t, classLoader(t, c)),
innerClassReferenceInner(t, arrayBody(t, table, i))))); innerClassReferenceInner(t, arrayBody(t, table, i)))));
-- count; -- count;
@ -741,7 +741,7 @@ getDeclaringClass(Thread* t, object c)
return getJClass( return getJClass(
t, t,
resolveClass(t, resolveClass(t,
classLoader(t, c), cast<GcClassLoader>(t, classLoader(t, c)),
innerClassReferenceOuter(t, reference))); innerClassReferenceOuter(t, reference)));
} }
} }

38
src/avian/machine.h
View File

@ -2620,7 +2620,7 @@ scanMethodSpec(Thread* t, const char* s, bool static_,
} }
GcClass* GcClass*
findLoadedClass(Thread* t, object loader, object spec); findLoadedClass(Thread* t, GcClassLoader* loader, object spec);
inline bool inline bool
emptyMethod(Thread* t UNUSED, GcMethod* method) emptyMethod(Thread* t UNUSED, GcMethod* method)
@ -2637,15 +2637,15 @@ object
parseUtf8(Thread* t, object array); parseUtf8(Thread* t, object array);
GcClass* GcClass*
parseClass(Thread* t, object loader, const uint8_t* data, unsigned length, parseClass(Thread* t, GcClassLoader* loader, const uint8_t* data, unsigned length,
Gc::Type throwType = GcNoClassDefFoundError::Type); Gc::Type throwType = GcNoClassDefFoundError::Type);
GcClass* GcClass*
resolveClass(Thread* t, object loader, object name, bool throw_ = true, resolveClass(Thread* t, GcClassLoader* loader, object name, bool throw_ = true,
Gc::Type throwType = GcNoClassDefFoundError::Type); Gc::Type throwType = GcNoClassDefFoundError::Type);
inline GcClass* inline GcClass*
resolveClass(Thread* t, object loader, const char* name, bool throw_ = true, resolveClass(Thread* t, GcClassLoader* loader, const char* name, bool throw_ = true,
Gc::Type throwType = GcNoClassDefFoundError::Type) Gc::Type throwType = GcNoClassDefFoundError::Type)
{ {
PROTECT(t, loader); PROTECT(t, loader);
@ -2655,24 +2655,24 @@ resolveClass(Thread* t, object loader, const char* name, bool throw_ = true,
GcClass* GcClass*
resolveSystemClass resolveSystemClass
(Thread* t, object loader, object name, bool throw_ = true, (Thread* t, GcClassLoader* loader, object name, bool throw_ = true,
Gc::Type throwType = GcNoClassDefFoundError::Type); Gc::Type throwType = GcNoClassDefFoundError::Type);
inline GcClass* inline GcClass*
resolveSystemClass(Thread* t, object loader, const char* name) resolveSystemClass(Thread* t, GcClassLoader* loader, const char* name)
{ {
return resolveSystemClass(t, loader, makeByteArray(t, "%s", name)); return resolveSystemClass(t, loader, makeByteArray(t, "%s", name));
} }
void void
linkClass(Thread* t, object loader, GcClass* class_); linkClass(Thread* t, GcClassLoader* loader, GcClass* class_);
GcMethod* GcMethod*
resolveMethod(Thread* t, GcClass* class_, const char* methodName, resolveMethod(Thread* t, GcClass* class_, const char* methodName,
const char* methodSpec); const char* methodSpec);
inline GcMethod* inline GcMethod*
resolveMethod(Thread* t, object loader, const char* className, resolveMethod(Thread* t, GcClassLoader* loader, const char* className,
const char* methodName, const char* methodSpec) const char* methodName, const char* methodSpec)
{ {
return resolveMethod return resolveMethod
@ -2684,7 +2684,7 @@ resolveField(Thread* t, GcClass* class_, const char* fieldName,
const char* fieldSpec); const char* fieldSpec);
inline object inline object
resolveField(Thread* t, object loader, const char* className, resolveField(Thread* t, GcClassLoader* loader, const char* className,
const char* fieldName, const char* fieldSpec) const char* fieldName, const char* fieldSpec)
{ {
return resolveField return resolveField
@ -2704,7 +2704,7 @@ void
initClass(Thread* t, GcClass* c); initClass(Thread* t, GcClass* c);
GcClass* GcClass*
resolveObjectArrayClass(Thread* t, object loader, object elementClass); resolveObjectArrayClass(Thread* t, GcClassLoader* loader, object elementClass);
object object
makeObjectArray(Thread* t, GcClass* elementClass, unsigned count); makeObjectArray(Thread* t, GcClass* elementClass, unsigned count);
@ -3613,7 +3613,7 @@ poolSize(Thread* t, GcSingleton* pool)
} }
inline GcClass* inline GcClass*
resolveClassInObject(Thread* t, object loader, object container, resolveClassInObject(Thread* t, GcClassLoader* loader, object container,
unsigned classOffset, bool throw_ = true) unsigned classOffset, bool throw_ = true)
{ {
object o = fieldAtOffset<object>(container, classOffset); object o = fieldAtOffset<object>(container, classOffset);
@ -3637,7 +3637,7 @@ resolveClassInObject(Thread* t, object loader, object container,
} }
inline GcClass* inline GcClass*
resolveClassInPool(Thread* t, object loader, GcMethod* method, unsigned index, resolveClassInPool(Thread* t, GcClassLoader* loader, GcMethod* method, unsigned index,
bool throw_ = true) bool throw_ = true)
{ {
object o = singletonObject(t, method->code()->pool(), index); object o = singletonObject(t, method->code()->pool(), index);
@ -3664,12 +3664,12 @@ inline GcClass*
resolveClassInPool(Thread* t, GcMethod* method, unsigned index, resolveClassInPool(Thread* t, GcMethod* method, unsigned index,
bool throw_ = true) bool throw_ = true)
{ {
return resolveClassInPool(t, reinterpret_cast<object>(method->class_()->loader()), return resolveClassInPool(t, method->class_()->loader(),
method, index, throw_); method, index, throw_);
} }
inline object inline object
resolve(Thread* t, object loader, GcMethod* method, unsigned index, resolve(Thread* t, GcClassLoader* loader, GcMethod* method, unsigned index,
object (*find)(vm::Thread*, GcClass*, object, object), object (*find)(vm::Thread*, GcClass*, object, object),
Gc::Type errorType, bool throw_ = true) Gc::Type errorType, bool throw_ = true)
{ {
@ -3705,7 +3705,7 @@ resolve(Thread* t, object loader, GcMethod* method, unsigned index,
} }
inline object inline object
resolveField(Thread* t, object loader, GcMethod* method, unsigned index, resolveField(Thread* t, GcClassLoader* loader, GcMethod* method, unsigned index,
bool throw_ = true) bool throw_ = true)
{ {
return resolve(t, loader, method, index, findFieldInClass, return resolve(t, loader, method, index, findFieldInClass,
@ -3716,7 +3716,7 @@ inline object
resolveField(Thread* t, GcMethod* method, unsigned index, bool throw_ = true) resolveField(Thread* t, GcMethod* method, unsigned index, bool throw_ = true)
{ {
return resolveField return resolveField
(t, reinterpret_cast<object>(method->class_()->loader()), method, index, throw_); (t, method->class_()->loader(), method, index, throw_);
} }
inline void inline void
@ -3807,7 +3807,7 @@ class FieldWriteResource {
}; };
inline GcMethod* inline GcMethod*
resolveMethod(Thread* t, object loader, GcMethod* method, unsigned index, resolveMethod(Thread* t, GcClassLoader* loader, GcMethod* method, unsigned index,
bool throw_ = true) bool throw_ = true)
{ {
return cast<GcMethod>(t, resolve(t, loader, method, index, findMethodInClass, return cast<GcMethod>(t, resolve(t, loader, method, index, findMethodInClass,
@ -3818,7 +3818,7 @@ inline GcMethod*
resolveMethod(Thread* t, GcMethod* method, unsigned index, bool throw_ = true) resolveMethod(Thread* t, GcMethod* method, unsigned index, bool throw_ = true)
{ {
return resolveMethod return resolveMethod
(t, reinterpret_cast<object>(method->class_()->loader()), method, index, throw_); (t, method->class_()->loader(), method, index, throw_);
} }
GcVector* GcVector*
@ -3969,7 +3969,7 @@ GcMethod*
getCaller(Thread* t, unsigned target, bool skipMethodInvoke = false); getCaller(Thread* t, unsigned target, bool skipMethodInvoke = false);
object object
defineClass(Thread* t, object loader, const uint8_t* buffer, unsigned length); defineClass(Thread* t, GcClassLoader* loader, const uint8_t* buffer, unsigned length);
inline GcMethod* inline GcMethod*
methodClone(Thread* t, GcMethod* method) methodClone(Thread* t, GcMethod* method)

22
src/builtin.cpp
View File

@ -20,8 +20,8 @@ using namespace vm;
namespace { namespace {
int64_t int64_t
search(Thread* t, object loader, object name, search(Thread* t, GcClassLoader* loader, object name,
GcClass* (*op)(Thread*, object, object), bool replaceDots) GcClass* (*op)(Thread*, GcClassLoader*, object), bool replaceDots)
{ {
if (LIKELY(name)) { if (LIKELY(name)) {
PROTECT(t, loader); PROTECT(t, loader);
@ -42,7 +42,7 @@ search(Thread* t, object loader, object name,
} }
GcClass* GcClass*
resolveSystemClassThrow(Thread* t, object loader, object spec) resolveSystemClassThrow(Thread* t, GcClassLoader* loader, object spec)
{ {
return resolveSystemClass return resolveSystemClass
(t, loader, spec, true, GcClassNotFoundException::Type); (t, loader, spec, true, GcClassNotFoundException::Type);
@ -131,7 +131,7 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_avian_Classes_resolveVMClass Avian_avian_Classes_resolveVMClass
(Thread* t, object, uintptr_t* arguments) (Thread* t, object, uintptr_t* arguments)
{ {
object loader = reinterpret_cast<object>(arguments[0]); GcClassLoader* loader = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[0]));
object spec = reinterpret_cast<object>(arguments[1]); object spec = reinterpret_cast<object>(arguments[1]);
return reinterpret_cast<int64_t> return reinterpret_cast<int64_t>
@ -142,7 +142,7 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_avian_Classes_defineVMClass Avian_avian_Classes_defineVMClass
(Thread* t, object, uintptr_t* arguments) (Thread* t, object, uintptr_t* arguments)
{ {
object loader = reinterpret_cast<object>(arguments[0]); GcClassLoader* loader = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[0]));
object b = reinterpret_cast<object>(arguments[1]); object b = reinterpret_cast<object>(arguments[1]);
int offset = arguments[2]; int offset = arguments[2];
int length = arguments[3]; int length = arguments[3];
@ -162,7 +162,7 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_avian_SystemClassLoader_findLoadedVMClass Avian_avian_SystemClassLoader_findLoadedVMClass
(Thread* t, object, uintptr_t* arguments) (Thread* t, object, uintptr_t* arguments)
{ {
object loader = reinterpret_cast<object>(arguments[0]); GcClassLoader* loader = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[0]));
object name = reinterpret_cast<object>(arguments[1]); object name = reinterpret_cast<object>(arguments[1]);
return search(t, loader, name, findLoadedClass, true); return search(t, loader, name, findLoadedClass, true);
@ -180,7 +180,7 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_avian_SystemClassLoader_findVMClass Avian_avian_SystemClassLoader_findVMClass
(Thread* t, object, uintptr_t* arguments) (Thread* t, object, uintptr_t* arguments)
{ {
object loader = reinterpret_cast<object>(arguments[0]); GcClassLoader* loader = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[0]));
object name = reinterpret_cast<object>(arguments[1]); object name = reinterpret_cast<object>(arguments[1]);
return search(t, loader, name, resolveSystemClassThrow, true); return search(t, loader, name, resolveSystemClassThrow, true);
@ -190,7 +190,7 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_avian_SystemClassLoader_resourceURLPrefix Avian_avian_SystemClassLoader_resourceURLPrefix
(Thread* t, object, uintptr_t* arguments) (Thread* t, object, uintptr_t* arguments)
{ {
object loader = reinterpret_cast<object>(arguments[0]); GcClassLoader* loader = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[0]));
object name = reinterpret_cast<object>(arguments[1]); object name = reinterpret_cast<object>(arguments[1]);
if (LIKELY(name)) { if (LIKELY(name)) {
@ -198,7 +198,7 @@ Avian_avian_SystemClassLoader_resourceURLPrefix
stringChars(t, name, RUNTIME_ARRAY_BODY(n)); stringChars(t, name, RUNTIME_ARRAY_BODY(n));
const char* name = static_cast<Finder*> const char* name = static_cast<Finder*>
(systemClassLoaderFinder(t, loader))->urlPrefix(RUNTIME_ARRAY_BODY(n)); (loader->as<GcSystemClassLoader>(t)->finder())->urlPrefix(RUNTIME_ARRAY_BODY(n));
return name ? reinterpret_cast<uintptr_t>(makeString(t, "%s", name)) : 0; return name ? reinterpret_cast<uintptr_t>(makeString(t, "%s", name)) : 0;
} else { } else {
@ -210,7 +210,7 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_avian_SystemClassLoader_00024ResourceEnumeration_nextResourceURLPrefix Avian_avian_SystemClassLoader_00024ResourceEnumeration_nextResourceURLPrefix
(Thread* t, object, uintptr_t* arguments) (Thread* t, object, uintptr_t* arguments)
{ {
object loader = reinterpret_cast<object>(arguments[1]); GcClassLoader* loader = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[1]));
object name = reinterpret_cast<object>(arguments[2]); object name = reinterpret_cast<object>(arguments[2]);
object finderElementPtrPtr = reinterpret_cast<object>(arguments[3]); object finderElementPtrPtr = reinterpret_cast<object>(arguments[3]);
@ -221,7 +221,7 @@ Avian_avian_SystemClassLoader_00024ResourceEnumeration_nextResourceURLPrefix
void *&finderElementPtr = reinterpret_cast<void *&>(longArrayBody(t, void *&finderElementPtr = reinterpret_cast<void *&>(longArrayBody(t,
finderElementPtrPtr, 0)); finderElementPtrPtr, 0));
const char* name = static_cast<Finder*> const char* name = static_cast<Finder*>
(systemClassLoaderFinder(t, loader))->nextUrlPrefix(RUNTIME_ARRAY_BODY(n), (loader->as<GcSystemClassLoader>(t)->finder())->nextUrlPrefix(RUNTIME_ARRAY_BODY(n),
finderElementPtr); finderElementPtr);
return name ? reinterpret_cast<uintptr_t>(makeString(t, "%s", name)) : 0; return name ? reinterpret_cast<uintptr_t>(makeString(t, "%s", name)) : 0;

225
src/classpath-android.cpp
View File

@ -43,11 +43,11 @@ getDirectBufferAddress(Thread* t, object b)
{ {
PROTECT(t, b); PROTECT(t, b);
object field = resolveField GcField* field = cast<GcField>(t, resolveField
(t, objectClass(t, b), "effectiveDirectAddress", "J"); (t, objectClass(t, b), "effectiveDirectAddress", "J"));
return reinterpret_cast<void*> return reinterpret_cast<void*>
(fieldAtOffset<int64_t>(b, fieldOffset(t, field))); (fieldAtOffset<int64_t>(b, field->offset()));
} }
void JNICALL void JNICALL
@ -111,35 +111,35 @@ makeMethodOrConstructor(Thread* t, GcJclass* c, unsigned index)
{ {
PROTECT(t, c); PROTECT(t, c);
object method = arrayBody GcMethod* method = cast<GcMethod>(t, arrayBody
(t, classMethodTable(t, c->vmClass()), index); (t, classMethodTable(t, c->vmClass()), index));
PROTECT(t, method); PROTECT(t, method);
unsigned parameterCount; unsigned parameterCount;
unsigned returnTypeSpec; unsigned returnTypeSpec;
object parameterTypes = resolveParameterJTypes object parameterTypes = resolveParameterJTypes
(t, classLoader(t, methodClass(t, method)), methodSpec(t, method), (t, method->class_()->loader(), method->spec(),
&parameterCount, &returnTypeSpec); &parameterCount, &returnTypeSpec);
PROTECT(t, parameterTypes); PROTECT(t, parameterTypes);
GcJclass* returnType = resolveJType GcJclass* returnType = resolveJType
(t, classLoader(t, methodClass(t, method)), reinterpret_cast<char*> (t, method->class_()->loader(), reinterpret_cast<char*>
(&byteArrayBody(t, methodSpec(t, method), returnTypeSpec)), (&method->spec()->body()[returnTypeSpec]),
byteArrayLength(t, methodSpec(t, method)) - 1 - returnTypeSpec); method->spec()->length() - 1 - returnTypeSpec);
PROTECT(t, returnType); PROTECT(t, returnType);
object exceptionTypes = resolveExceptionJTypes object exceptionTypes = resolveExceptionJTypes
(t, classLoader(t, methodClass(t, method)), methodAddendum(t, method)); (t, method->class_()->loader(), method->addendum());
if (byteArrayBody(t, methodName(t, method), 0) == '<') { if (method->name()->body()[0] == '<') {
return reinterpret_cast<object>(makeJconstructor return reinterpret_cast<object>(makeJconstructor
(t, 0, c, parameterTypes, exceptionTypes, 0, 0, 0, 0, index)); (t, 0, c, parameterTypes, exceptionTypes, 0, 0, 0, 0, index));
} else { } else {
PROTECT(t, exceptionTypes); PROTECT(t, exceptionTypes);
GcString* name = cast<GcString>(t, t->m->classpath->makeString GcString* name = cast<GcString>(t, t->m->classpath->makeString
(t, methodName(t, method), 0, (t, reinterpret_cast<object>(method->name()), 0,
byteArrayLength(t, methodName(t, method)) - 1)); method->name()->length() - 1));
return reinterpret_cast<object>(makeJmethod return reinterpret_cast<object>(makeJmethod
(t, 0, index, c, name, parameterTypes, exceptionTypes, returnType, 0, 0, (t, 0, index, c, name, parameterTypes, exceptionTypes, returnType, 0, 0,
@ -152,22 +152,22 @@ makeField(Thread* t, GcJclass* c, unsigned index)
{ {
PROTECT(t, c); PROTECT(t, c);
object field = arrayBody GcField* field = cast<GcField>(t, arrayBody
(t, classFieldTable(t, c->vmClass()), index); (t, classFieldTable(t, c->vmClass()), index));
PROTECT(t, field); PROTECT(t, field);
GcJclass* type = getJClass GcJclass* type = getJClass
(t, resolveClassBySpec (t, resolveClassBySpec
(t, classLoader(t, fieldClass(t, field)), (t, field->class_()->loader(),
reinterpret_cast<char*> reinterpret_cast<char*>
(&byteArrayBody(t, fieldSpec(t, field), 0)), (field->spec()->body().begin()),
byteArrayLength(t, fieldSpec(t, field)) - 1)); field->spec()->length() - 1));
PROTECT(t, type); PROTECT(t, type);
GcString* name = cast<GcString>(t, t->m->classpath->makeString GcString* name = cast<GcString>(t, t->m->classpath->makeString
(t, fieldName(t, field), 0, (t, reinterpret_cast<object>(field->name()), 0,
byteArrayLength(t, fieldName(t, field)) - 1)); field->name()->length() - 1));
return reinterpret_cast<object>(makeJfield(t, 0, c, type, 0, 0, name, index)); return reinterpret_cast<object>(makeJfield(t, 0, c, type, 0, 0, name, index));
} }
@ -178,7 +178,7 @@ void initVmThread(Thread* t, GcThread* thread, unsigned offset)
if (fieldAtOffset<object>(thread, offset) == 0) { if (fieldAtOffset<object>(thread, offset) == 0) {
GcClass* c = resolveClass GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "java/lang/VMThread"); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/VMThread");
PROTECT(t, c); PROTECT(t, c);
object instance = makeNew(t, c); object instance = makeNew(t, c);
@ -216,7 +216,7 @@ translateStackTrace(Thread* t, object raw)
object array = makeObjectArray object array = makeObjectArray
(t, resolveClass (t, resolveClass
(t, root(t, Machine::BootLoader), "java/lang/StackTraceElement"), (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/StackTraceElement"),
objectArrayLength(t, raw)); objectArrayLength(t, raw));
PROTECT(t, array); PROTECT(t, array);
@ -279,7 +279,7 @@ class MyClasspath : public Classpath {
group = threadGroup(t, parent->javaThread); group = threadGroup(t, parent->javaThread);
} else { } else {
resolveSystemClass resolveSystemClass
(t, root(t, Machine::BootLoader), (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
reinterpret_cast<object>(type(t, GcThreadGroup::Type)->name()), false); reinterpret_cast<object>(type(t, GcThreadGroup::Type)->name()), false);
group = makeNew(t, type(t, GcThreadGroup::Type)); group = makeNew(t, type(t, GcThreadGroup::Type));
@ -291,7 +291,7 @@ class MyClasspath : public Classpath {
} }
resolveSystemClass resolveSystemClass
(t, root(t, Machine::BootLoader), (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
reinterpret_cast<object>(type(t, GcThread::Type)->name()), false); reinterpret_cast<object>(type(t, GcThread::Type)->name()), false);
GcThread* thread = cast<GcThread>(t, makeNew(t, type(t, GcThread::Type))); GcThread* thread = cast<GcThread>(t, makeNew(t, type(t, GcThread::Type)));
@ -372,10 +372,10 @@ class MyClasspath : public Classpath {
// later when we try to acquire it: // later when we try to acquire it:
objectMonitor(t, t->javaThread, true); objectMonitor(t, t->javaThread, true);
object field = resolveField( GcField* field = cast<GcField>(t, resolveField(
t, objectClass(t, t->javaThread), "vmThread", "Ljava/lang/VMThread;"); t, objectClass(t, t->javaThread), "vmThread", "Ljava/lang/VMThread;"));
unsigned offset = fieldOffset(t, field); unsigned offset = field->offset();
THREAD_RESOURCE(t, unsigned, offset, { THREAD_RESOURCE(t, unsigned, offset, {
object vmt = fieldAtOffset<object>(t->javaThread, offset); object vmt = fieldAtOffset<object>(t->javaThread, offset);
@ -396,7 +396,7 @@ class MyClasspath : public Classpath {
initVmThread(t, cast<GcThread>(t, t->javaThread), offset); initVmThread(t, cast<GcThread>(t, t->javaThread), offset);
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, root(t, Machine::BootLoader), "java/lang/Thread", "run", "()V"); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/Thread", "run", "()V");
t->m->processor->invoke(t, method, t->javaThread); t->m->processor->invoke(t, method, t->javaThread);
} }
@ -411,7 +411,7 @@ class MyClasspath : public Classpath {
interceptMethods(Thread* t, bool updateRuntimeData) interceptMethods(Thread* t, bool updateRuntimeData)
{ {
{ GcClass* c = resolveClass { GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "java/lang/Runtime", false); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/Runtime", false);
if (c) { if (c) {
PROTECT(t, c); PROTECT(t, c);
@ -423,7 +423,7 @@ class MyClasspath : public Classpath {
} }
{ GcClass* c = resolveClass { GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "java/lang/ref/FinalizerReference", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/ref/FinalizerReference",
false); false);
if (c) { if (c) {
@ -435,7 +435,7 @@ class MyClasspath : public Classpath {
} }
{ GcClass* c = resolveClass { GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "java/lang/ClassLoader", false); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/ClassLoader", false);
if (c) { if (c) {
PROTECT(t, c); PROTECT(t, c);
@ -450,7 +450,7 @@ class MyClasspath : public Classpath {
} }
{ GcClass* c = resolveClass { GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "libcore/util/ZoneInfoDB", false); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "libcore/util/ZoneInfoDB", false);
if (c) { if (c) {
PROTECT(t, c); PROTECT(t, c);
@ -461,7 +461,7 @@ class MyClasspath : public Classpath {
} }
{ GcClass* c = resolveClass { GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "libcore/io/MemoryMappedFile", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "libcore/io/MemoryMappedFile",
false); false);
if (c) { if (c) {
@ -508,7 +508,7 @@ class MyClasspath : public Classpath {
boot(Thread* t) boot(Thread* t)
{ {
GcClass* c = resolveClass GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "java/lang/ClassLoader"); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/ClassLoader");
PROTECT(t, c); PROTECT(t, c);
GcMethod* constructor = resolveMethod GcMethod* constructor = resolveMethod
@ -533,7 +533,7 @@ class MyClasspath : public Classpath {
makeDirectByteBuffer(Thread* t, void* p, jlong capacity) makeDirectByteBuffer(Thread* t, void* p, jlong capacity)
{ {
GcClass* c = resolveClass GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "java/nio/DirectByteBuffer"); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/nio/DirectByteBuffer");
PROTECT(t, c); PROTECT(t, c);
object instance = makeNew(t, c); object instance = makeNew(t, c);
@ -559,10 +559,10 @@ class MyClasspath : public Classpath {
{ {
PROTECT(t, b); PROTECT(t, b);
object field = resolveField GcField* field = cast<GcField>(t, resolveField
(t, objectClass(t, b), "capacity", "I"); (t, objectClass(t, b), "capacity", "I"));
return fieldAtOffset<int32_t>(b, fieldOffset(t, field)); return fieldAtOffset<int32_t>(b, field->offset());
} }
virtual bool virtual bool
@ -606,7 +606,7 @@ int64_t JNICALL
mapData(Thread* t, object, uintptr_t*) mapData(Thread* t, object, uintptr_t*)
{ {
GcClass* c = resolveClass GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "libcore/io/MemoryMappedFile"); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "libcore/io/MemoryMappedFile");
PROTECT(t, c); PROTECT(t, c);
object instance = makeNew(t, c); object instance = makeNew(t, c);
@ -645,15 +645,15 @@ closeMemoryMappedFile(Thread* t, GcMethod* method, uintptr_t* arguments)
MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath); MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
if (cp->tzdata) { if (cp->tzdata) {
object field = resolveField(t, objectClass(t, file), "address", "J"); GcField* field = cast<GcField>(t, resolveField(t, objectClass(t, file), "address", "J"));
if (fieldAtOffset<int64_t>(file, fieldOffset(t, field)) if (fieldAtOffset<int64_t>(file, field->offset())
== reinterpret_cast<int64_t>(cp->tzdata->start())) == reinterpret_cast<int64_t>(cp->tzdata->start()))
{ {
cp->tzdata->dispose(); cp->tzdata->dispose();
cp->tzdata = 0; cp->tzdata = 0;
fieldAtOffset<int64_t>(file, fieldOffset(t, field)) = 0; fieldAtOffset<int64_t>(file, field->offset()) = 0;
return; return;
} }
} }
@ -665,9 +665,9 @@ closeMemoryMappedFile(Thread* t, GcMethod* method, uintptr_t* arguments)
} }
bool bool
matchType(Thread* t, object field, object o) matchType(Thread* t, GcField* field, object o)
{ {
switch (fieldCode(t, field)) { switch (field->code()) {
case ByteField: case ByteField:
return objectClass(t, o) == type(t, GcByte::Type); return objectClass(t, o) == type(t, GcByte::Type);
@ -698,22 +698,21 @@ matchType(Thread* t, object field, object o)
} else { } else {
PROTECT(t, o); PROTECT(t, o);
object spec; GcByteArray* spec;
if (byteArrayBody(t, fieldSpec(t, field), 0) == '[') { if (field->spec()->body()[0] == '[') {
spec = fieldSpec(t, field);; spec = field->spec();
} else { } else {
spec = reinterpret_cast<object>(makeByteArray(t, byteArrayLength(t, fieldSpec(t, field)) - 2)); spec = makeByteArray(t, field->spec()->length() - 2);
memcpy(&byteArrayBody(t, spec, 0), memcpy(spec->body().begin(),
&byteArrayBody(t, fieldSpec(t, field), 1), &field->spec()->body()[1],
byteArrayLength(t, fieldSpec(t, field)) - 3); field->spec()->length() - 3);
byteArrayBody spec->body()[field->spec()->length() - 3] = 0;
(t, spec, byteArrayLength(t, fieldSpec(t, field)) - 3) = 0;
} }
return instanceOf return instanceOf
(t, resolveClass(t, classLoader(t, fieldClass(t, field)), spec), o); (t, resolveClass(t, field->class_()->loader(), reinterpret_cast<object>(spec)), o);
} }
default: abort(t); default: abort(t);
@ -721,24 +720,24 @@ matchType(Thread* t, object field, object o)
} }
object object
getField(Thread* t, object field, object instance) getField(Thread* t, GcField* field, object instance)
{ {
PROTECT(t, field); PROTECT(t, field);
PROTECT(t, instance); PROTECT(t, instance);
initClass(t, cast<GcClass>(t, fieldClass(t, field))); initClass(t, field->class_());
object target; object target;
if (fieldFlags(t, field) & ACC_STATIC) { if (field->flags() & ACC_STATIC) {
target = classStaticTable(t, fieldClass(t, field)); target = reinterpret_cast<object>(field->class_()->staticTable());
} else if (instanceOf(t, cast<GcClass>(t, fieldClass(t, field)), instance)){ } else if (instanceOf(t, field->class_(), instance)){
target = instance; target = instance;
} else { } else {
throwNew(t, GcIllegalArgumentException::Type); throwNew(t, GcIllegalArgumentException::Type);
} }
unsigned offset = fieldOffset(t, field); unsigned offset = field->offset();
switch (fieldCode(t, field)) { switch (field->code()) {
case ByteField: case ByteField:
return reinterpret_cast<object>(makeByte(t, fieldAtOffset<int8_t>(target, offset))); return reinterpret_cast<object>(makeByte(t, fieldAtOffset<int8_t>(target, offset)));
@ -771,7 +770,7 @@ getField(Thread* t, object field, object instance)
} }
void void
setField(Thread* t, object field, object instance, object value) setField(Thread* t, GcField* field, object instance, object value)
{ {
PROTECT(t, field); PROTECT(t, field);
PROTECT(t, instance); PROTECT(t, instance);
@ -782,19 +781,19 @@ setField(Thread* t, object field, object instance, object value)
} }
object target; object target;
if ((fieldFlags(t, field) & ACC_STATIC) != 0) { if ((field->flags() & ACC_STATIC) != 0) {
target = classStaticTable(t, fieldClass(t, field)); target = reinterpret_cast<object>(field->class_()->staticTable());
} else if (instanceOf(t, cast<GcClass>(t, fieldClass(t, field)), instance)){ } else if (instanceOf(t, field->class_(), instance)){
target = instance; target = instance;
} else { } else {
throwNew(t, GcIllegalArgumentException::Type); throwNew(t, GcIllegalArgumentException::Type);
} }
PROTECT(t, target); PROTECT(t, target);
initClass(t, cast<GcClass>(t, fieldClass(t, field))); initClass(t, field->class_());
unsigned offset = fieldOffset(t, field); unsigned offset = field->offset();
switch (fieldCode(t, field)) { switch (field->code()) {
case ByteField: case ByteField:
fieldAtOffset<int8_t>(target, offset) = byteValue(t, value); fieldAtOffset<int8_t>(target, offset) = byteValue(t, value);
break; break;
@ -1220,11 +1219,11 @@ Avian_java_lang_Class_classForName
object name = reinterpret_cast<object>(arguments[0]); object name = reinterpret_cast<object>(arguments[0]);
PROTECT(t, name); PROTECT(t, name);
object loader = reinterpret_cast<object>(arguments[2]); GcClassLoader* loader = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[2]));
PROTECT(t, loader); PROTECT(t, loader);
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Classes", "forName", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "forName",
"(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;"); "(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;");
return reinterpret_cast<uintptr_t> return reinterpret_cast<uintptr_t>
@ -1243,7 +1242,7 @@ Avian_java_lang_Class_getDeclaredField
PROTECT(t, name); PROTECT(t, name);
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Classes", "findField", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "findField",
"(Lavian/VMClass;Ljava/lang/String;)I"); "(Lavian/VMClass;Ljava/lang/String;)I");
int index = intValue int index = intValue
@ -1271,7 +1270,7 @@ Avian_java_lang_Class_getDeclaredConstructorOrMethod
PROTECT(t, parameterTypes); PROTECT(t, parameterTypes);
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Classes", "findMethod", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "findMethod",
"(Lavian/VMClass;Ljava/lang/String;[Ljava/lang/Class;)I"); "(Lavian/VMClass;Ljava/lang/String;[Ljava/lang/Class;)I");
int index = intValue int index = intValue
@ -1420,12 +1419,12 @@ Avian_java_lang_VMThread_interrupt
object vmThread = reinterpret_cast<object>(arguments[0]); object vmThread = reinterpret_cast<object>(arguments[0]);
PROTECT(t, vmThread); PROTECT(t, vmThread);
object field = resolveField GcField* field = cast<GcField>(t, resolveField
(t, objectClass(t, vmThread), "thread", "Ljava/lang/Thread;"); (t, objectClass(t, vmThread), "thread", "Ljava/lang/Thread;"));
interrupt interrupt
(t, reinterpret_cast<Thread*> (t, reinterpret_cast<Thread*>
(threadPeer(t, fieldAtOffset<object>(vmThread, fieldOffset(t, field))))); (threadPeer(t, fieldAtOffset<object>(vmThread, field->offset()))));
} }
extern "C" AVIAN_EXPORT int64_t JNICALL extern "C" AVIAN_EXPORT int64_t JNICALL
@ -1442,11 +1441,11 @@ Avian_java_lang_VMThread_isInterrupted
object vmThread = reinterpret_cast<object>(arguments[0]); object vmThread = reinterpret_cast<object>(arguments[0]);
PROTECT(t, vmThread); PROTECT(t, vmThread);
object field = resolveField GcField* field = cast<GcField>(t, resolveField
(t, objectClass(t, vmThread), "thread", "Ljava/lang/Thread;"); (t, objectClass(t, vmThread), "thread", "Ljava/lang/Thread;"));
return threadInterrupted return threadInterrupted
(t, fieldAtOffset<object>(vmThread, fieldOffset(t, field))); (t, fieldAtOffset<object>(vmThread, field->offset()));
} }
extern "C" AVIAN_EXPORT int64_t JNICALL extern "C" AVIAN_EXPORT int64_t JNICALL
@ -1835,7 +1834,7 @@ Avian_java_lang_Class_getDeclaredMethods
bool publicOnly = arguments[1]; bool publicOnly = arguments[1];
GcMethod* get = resolveMethod GcMethod* get = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Classes", "getMethods", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "getMethods",
"(Lavian/VMClass;Z)[Ljava/lang/reflect/Method;"); "(Lavian/VMClass;Z)[Ljava/lang/reflect/Method;");
return reinterpret_cast<uintptr_t> return reinterpret_cast<uintptr_t>
@ -1852,7 +1851,7 @@ Avian_java_lang_Class_getDeclaredFields
bool publicOnly = arguments[1]; bool publicOnly = arguments[1];
GcMethod* get = resolveMethod GcMethod* get = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Classes", "getFields", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "getFields",
"(Lavian/VMClass;Z)[Ljava/lang/reflect/Field;"); "(Lavian/VMClass;Z)[Ljava/lang/reflect/Field;");
return reinterpret_cast<uintptr_t> return reinterpret_cast<uintptr_t>
@ -1931,7 +1930,7 @@ Avian_java_lang_reflect_Method_getAnnotation
PROTECT(t, table); PROTECT(t, table);
GcMethod* get = resolveMethod GcMethod* get = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Classes", "getAnnotation", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "getAnnotation",
"(Ljava/lang/ClassLoader;[Ljava/lang/Object;)" "(Ljava/lang/ClassLoader;[Ljava/lang/Object;)"
"Ljava/lang/annotation/Annotation;"); "Ljava/lang/annotation/Annotation;");
@ -1965,12 +1964,12 @@ Avian_java_lang_reflect_Method_getDeclaredAnnotations
object array = makeObjectArray object array = makeObjectArray
(t, resolveClass (t, resolveClass
(t, root(t, Machine::BootLoader), "java/lang/annotation/Annotation"), (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/annotation/Annotation"),
objectArrayLength(t, table)); objectArrayLength(t, table));
PROTECT(t, array); PROTECT(t, array);
GcMethod* get = resolveMethod GcMethod* get = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Classes", "getAnnotation", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "getAnnotation",
"(Ljava/lang/ClassLoader;[Ljava/lang/Object;)" "(Ljava/lang/ClassLoader;[Ljava/lang/Object;)"
"Ljava/lang/annotation/Annotation;"); "Ljava/lang/annotation/Annotation;");
PROTECT(t, get); PROTECT(t, get);
@ -1990,7 +1989,7 @@ Avian_java_lang_reflect_Method_getDeclaredAnnotations
return reinterpret_cast<uintptr_t> return reinterpret_cast<uintptr_t>
(makeObjectArray (makeObjectArray
(t, resolveClass (t, resolveClass
(t, root(t, Machine::BootLoader), "java/lang/annotation/Annotation"), (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/annotation/Annotation"),
0)); 0));
} }
@ -1999,13 +1998,13 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
object, object,
uintptr_t* arguments) uintptr_t* arguments)
{ {
object field = arrayBody( GcField* field = cast<GcField>(t, arrayBody(
t, t,
classFieldTable( classFieldTable(
t, jclassVmClass(t, reinterpret_cast<object>(arguments[0]))), t, jclassVmClass(t, reinterpret_cast<object>(arguments[0]))),
arguments[1]); arguments[1]));
object addendum = fieldAddendum(t, field); object addendum = reinterpret_cast<object>(field->addendum());
if (addendum) { if (addendum) {
object table = addendumAnnotationTable(t, addendum); object table = addendumAnnotationTable(t, addendum);
if (table) { if (table) {
@ -2015,13 +2014,13 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
object array object array
= makeObjectArray(t, = makeObjectArray(t,
resolveClass(t, resolveClass(t,
root(t, Machine::BootLoader), cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
"java/lang/annotation/Annotation"), "java/lang/annotation/Annotation"),
objectArrayLength(t, table)); objectArrayLength(t, table));
PROTECT(t, array); PROTECT(t, array);
GcMethod* get = resolveMethod(t, GcMethod* get = resolveMethod(t,
root(t, Machine::BootLoader), cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
"avian/Classes", "avian/Classes",
"getAnnotation", "getAnnotation",
"(Ljava/lang/ClassLoader;[Ljava/lang/Object;)" "(Ljava/lang/ClassLoader;[Ljava/lang/Object;)"
@ -2046,7 +2045,7 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
return reinterpret_cast<uintptr_t>(makeObjectArray( return reinterpret_cast<uintptr_t>(makeObjectArray(
t, t,
resolveClass( resolveClass(
t, root(t, Machine::BootLoader), "java/lang/annotation/Annotation"), t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/annotation/Annotation"),
0)); 0));
} }
@ -2062,7 +2061,7 @@ Avian_java_lang_reflect_Method_getDefaultValue
object addendum = methodAddendum(t, method); object addendum = methodAddendum(t, method);
if (addendum) { if (addendum) {
GcMethod* get = resolveMethod GcMethod* get = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Classes", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes",
"getAnnotationDefaultValue", "getAnnotationDefaultValue",
"(Ljava/lang/ClassLoader;Lavian/MethodAddendum;)" "(Ljava/lang/ClassLoader;Lavian/MethodAddendum;)"
"Ljava/lang/Object;"); "Ljava/lang/Object;");
@ -2102,10 +2101,10 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_java_lang_reflect_Field_getField Avian_java_lang_reflect_Field_getField
(Thread* t, object, uintptr_t* arguments) (Thread* t, object, uintptr_t* arguments)
{ {
object field = arrayBody GcField* field = cast<GcField>(t, arrayBody
(t, classFieldTable (t, classFieldTable
(t, jclassVmClass(t, reinterpret_cast<object>(arguments[2]))), (t, jclassVmClass(t, reinterpret_cast<object>(arguments[2]))),
arguments[4]); arguments[4]));
PROTECT(t, field); PROTECT(t, field);
@ -2119,10 +2118,10 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_java_lang_reflect_Field_getIField Avian_java_lang_reflect_Field_getIField
(Thread* t, object, uintptr_t* arguments) (Thread* t, object, uintptr_t* arguments)
{ {
object field = arrayBody GcField* field = cast<GcField>(t, arrayBody
(t, classFieldTable (t, classFieldTable
(t, jclassVmClass(t, reinterpret_cast<object>(arguments[2]))), (t, jclassVmClass(t, reinterpret_cast<object>(arguments[2]))),
arguments[4]); arguments[4]));
PROTECT(t, field); PROTECT(t, field);
@ -2136,10 +2135,10 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_java_lang_reflect_Field_getJField Avian_java_lang_reflect_Field_getJField
(Thread* t, object, uintptr_t* arguments) (Thread* t, object, uintptr_t* arguments)
{ {
object field = arrayBody GcField* field = cast<GcField>(t, arrayBody
(t, classFieldTable (t, classFieldTable
(t, jclassVmClass(t, reinterpret_cast<object>(arguments[2]))), (t, jclassVmClass(t, reinterpret_cast<object>(arguments[2]))),
arguments[4]); arguments[4]));
PROTECT(t, field); PROTECT(t, field);
@ -2153,10 +2152,10 @@ extern "C" AVIAN_EXPORT void JNICALL
Avian_java_lang_reflect_Field_setField Avian_java_lang_reflect_Field_setField
(Thread* t, object, uintptr_t* arguments) (Thread* t, object, uintptr_t* arguments)
{ {
object field = arrayBody GcField* field = cast<GcField>(t, arrayBody
(t, classFieldTable (t, classFieldTable
(t, jclassVmClass(t, reinterpret_cast<object>(arguments[2]))), (t, jclassVmClass(t, reinterpret_cast<object>(arguments[2]))),
arguments[4]); arguments[4]));
PROTECT(t, field); PROTECT(t, field);
@ -2173,10 +2172,10 @@ extern "C" AVIAN_EXPORT void JNICALL
Avian_java_lang_reflect_Field_setIField Avian_java_lang_reflect_Field_setIField
(Thread* t, object, uintptr_t* arguments) (Thread* t, object, uintptr_t* arguments)
{ {
object field = arrayBody GcField* field = cast<GcField>(t, arrayBody
(t, classFieldTable (t, classFieldTable
(t, jclassVmClass(t, reinterpret_cast<object>(arguments[2]))), (t, jclassVmClass(t, reinterpret_cast<object>(arguments[2]))),
arguments[4]); arguments[4]));
object instance = reinterpret_cast<object>(arguments[1]); object instance = reinterpret_cast<object>(arguments[1]);
PROTECT(t, instance); PROTECT(t, instance);
@ -2201,12 +2200,12 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_java_lang_reflect_Field_getAnnotation Avian_java_lang_reflect_Field_getAnnotation
(Thread* t, object, uintptr_t* arguments) (Thread* t, object, uintptr_t* arguments)
{ {
object field = arrayBody GcField* field = cast<GcField>(t, arrayBody
(t, classFieldTable (t, classFieldTable
(t, jclassVmClass(t, reinterpret_cast<object>(arguments[0]))), (t, jclassVmClass(t, reinterpret_cast<object>(arguments[0]))),
arguments[1]); arguments[1]));
object addendum = fieldAddendum(t, field); object addendum = reinterpret_cast<object>(field->addendum());
if (addendum) { if (addendum) {
object table = addendumAnnotationTable(t, addendum); object table = addendumAnnotationTable(t, addendum);
if (table) { if (table) {
@ -2218,13 +2217,13 @@ Avian_java_lang_reflect_Field_getAnnotation
PROTECT(t, table); PROTECT(t, table);
GcMethod* get = resolveMethod GcMethod* get = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Classes", "getAnnotation", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "getAnnotation",
"(Ljava/lang/ClassLoader;[Ljava/lang/Object;)" "(Ljava/lang/ClassLoader;[Ljava/lang/Object;)"
"Ljava/lang/annotation/Annotation;"); "Ljava/lang/annotation/Annotation;");
return reinterpret_cast<uintptr_t> return reinterpret_cast<uintptr_t>
(t->m->processor->invoke (t->m->processor->invoke
(t, get, 0, classLoader(t, fieldClass(t, field)), (t, get, 0, field->class_()->loader(),
objectArrayBody(t, table, i))); objectArrayBody(t, table, i)));
} }
} }
@ -2238,12 +2237,12 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_java_lang_reflect_Field_getSignatureAnnotation Avian_java_lang_reflect_Field_getSignatureAnnotation
(Thread* t, object, uintptr_t* arguments) (Thread* t, object, uintptr_t* arguments)
{ {
object field = arrayBody GcField* field = cast<GcField>(t, arrayBody
(t, classFieldTable (t, classFieldTable
(t, jclassVmClass(t, reinterpret_cast<object>(arguments[1]))), (t, jclassVmClass(t, reinterpret_cast<object>(arguments[1]))),
arguments[2]); arguments[2]));
object addendum = fieldAddendum(t, field); object addendum = reinterpret_cast<object>(field->addendum());
if (addendum) { if (addendum) {
object signature = addendumSignature(t, addendum); object signature = addendumSignature(t, addendum);
if (signature) { if (signature) {
@ -2460,14 +2459,14 @@ Avian_libcore_io_OsConstants_initConstants
object table = classStaticTable(t, c); object table = classStaticTable(t, c);
PROTECT(t, table); PROTECT(t, table);
object field = resolveField(t, c, "STDIN_FILENO", "I"); GcField* field = cast<GcField>(t, resolveField(t, c, "STDIN_FILENO", "I");
fieldAtOffset<jint>(table, fieldOffset(t, field)) = 0; fieldAtOffset<jint>(table, field->offset()) = 0;
field = resolveField(t, c, "STDOUT_FILENO", "I"); field = resolveField(t, c, "STDOUT_FILENO", "I");
fieldAtOffset<jint>(table, fieldOffset(t, field)) = 1; fieldAtOffset<jint>(table, field->offset()) = 1;
field = resolveField(t, c, "STDERR_FILENO", "I"); field = resolveField(t, c, "STDERR_FILENO", "I");
fieldAtOffset<jint>(table, fieldOffset(t, field)) = 2; fieldAtOffset<jint>(table, field->offset()) = 2;
} }
extern "C" AVIAN_EXPORT int64_t JNICALL extern "C" AVIAN_EXPORT int64_t JNICALL

8
src/classpath-avian.cpp
View File

@ -97,7 +97,7 @@ class MyClasspath : public Classpath {
runThread(Thread* t) runThread(Thread* t)
{ {
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, root(t, Machine::BootLoader), "java/lang/Thread", "run", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/Thread", "run",
"(Ljava/lang/Thread;)V"); "(Ljava/lang/Thread;)V");
t->m->processor->invoke(t, method, 0, t->javaThread); t->m->processor->invoke(t, method, 0, t->javaThread);
@ -142,7 +142,7 @@ class MyClasspath : public Classpath {
makeDirectByteBuffer(Thread* t, void* p, jlong capacity) makeDirectByteBuffer(Thread* t, void* p, jlong capacity)
{ {
GcClass* c = resolveClass GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "java/nio/DirectByteBuffer"); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/nio/DirectByteBuffer");
PROTECT(t, c); PROTECT(t, c);
object instance = makeNew(t, c); object instance = makeNew(t, c);
@ -793,7 +793,7 @@ Avian_avian_Classes_makeMethod
PROTECT(t, method); PROTECT(t, method);
GcClass* c = resolveClass GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "java/lang/reflect/Method"); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/reflect/Method");
PROTECT(t, c); PROTECT(t, c);
object instance = makeNew(t, c); object instance = makeNew(t, c);
@ -807,7 +807,7 @@ Avian_avian_Classes_makeMethod
method = instance; method = instance;
c = resolveClass c = resolveClass
(t, root(t, Machine::BootLoader), "java/lang/reflect/Constructor"); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/reflect/Constructor");
object instance = makeNew(t, c); object instance = makeNew(t, c);

197
src/classpath-openjdk.cpp
View File

@ -345,10 +345,10 @@ makeClassNameString(Thread* t, object name)
} }
object object
makeJmethod(Thread* t, object vmMethod, int index = -1); makeJmethod(Thread* t, GcMethod* vmMethod, int index = -1);
object object
makeJconstructor(Thread* t, object vmMethod, int index = -1); makeJconstructor(Thread* t, GcMethod* vmMethod, int index = -1);
object object
makeJfield(Thread* t, object vmField, int index = -1); makeJfield(Thread* t, object vmField, int index = -1);
@ -580,8 +580,8 @@ class MyClasspath : public Classpath {
PROTECT(t, vmMethod); PROTECT(t, vmMethod);
return vmMethod->name()->body()[0] == '<' return vmMethod->name()->body()[0] == '<'
? reinterpret_cast<object>(makeJconstructor(t, reinterpret_cast<object>(vmMethod))) ? reinterpret_cast<object>(makeJconstructor(t, vmMethod))
: reinterpret_cast<object>(makeJmethod(t, reinterpret_cast<object>(vmMethod))); : reinterpret_cast<object>(makeJmethod(t, vmMethod));
} }
virtual object virtual object
@ -644,7 +644,7 @@ class MyClasspath : public Classpath {
}); });
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, root(t, Machine::BootLoader), "java/lang/Thread", "run", "()V"); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/Thread", "run", "()V");
t->m->processor->invoke(t, method, t->javaThread); t->m->processor->invoke(t, method, t->javaThread);
} }
@ -691,11 +691,11 @@ class MyClasspath : public Classpath {
{ {
globalMachine = t->m; globalMachine = t->m;
resolveSystemClass(t, root(t, Machine::BootLoader), resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
reinterpret_cast<object>(type(t, GcClassLoader::Type)->name())); reinterpret_cast<object>(type(t, GcClassLoader::Type)->name()));
setRoot(t, Machine::ThreadTerminated, reinterpret_cast<object>(resolveMethod setRoot(t, Machine::ThreadTerminated, reinterpret_cast<object>(resolveMethod
(t, root(t, Machine::BootLoader), "java/lang/ThreadGroup", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/ThreadGroup",
"threadTerminated", "(Ljava/lang/Thread;)V"))); "threadTerminated", "(Ljava/lang/Thread;)V")));
#ifdef AVIAN_OPENJDK_SRC #ifdef AVIAN_OPENJDK_SRC
@ -709,12 +709,12 @@ class MyClasspath : public Classpath {
(t, type(t, GcClassLoader::Type), "assertionLock", (t, type(t, GcClassLoader::Type), "assertionLock",
"Ljava/lang/Object;"); "Ljava/lang/Object;");
set(t, root(t, Machine::BootLoader), fieldOffset(t, assertionLock), set(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), fieldOffset(t, assertionLock),
root(t, Machine::BootLoader)); cast<GcClassLoader>(t, root(t, Machine::BootLoader)));
} }
{ GcClass* class_ = resolveClass { GcClass* class_ = resolveClass
(t, root(t, Machine::BootLoader), "java/util/Properties", true, (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/util/Properties", true,
GcNoClassDefFoundError::Type); GcNoClassDefFoundError::Type);
PROTECT(t, class_); PROTECT(t, class_);
@ -742,7 +742,7 @@ class MyClasspath : public Classpath {
t->m->processor->invoke t->m->processor->invoke
(t, constructor, root(t, Machine::AppLoader), (t, constructor, root(t, Machine::AppLoader),
root(t, Machine::BootLoader)); cast<GcClassLoader>(t, root(t, Machine::BootLoader)));
} }
{ object scl = resolveField { object scl = resolveField
@ -783,7 +783,7 @@ class MyClasspath : public Classpath {
makeDirectByteBuffer(Thread* t, void* p, jlong capacity) makeDirectByteBuffer(Thread* t, void* p, jlong capacity)
{ {
GcClass* c = resolveClass GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "java/nio/DirectByteBuffer"); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/nio/DirectByteBuffer");
PROTECT(t, c); PROTECT(t, c);
object instance = makeNew(t, c); object instance = makeNew(t, c);
@ -872,7 +872,7 @@ class MyClasspath : public Classpath {
shutDown(Thread* t) shutDown(Thread* t)
{ {
GcClass* c = resolveClass GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "java/lang/Shutdown", false); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/Shutdown", false);
if (c) { if (c) {
GcMethod* m = findMethodOrNull(t, c, "shutdown", "()V"); GcMethod* m = findMethodOrNull(t, c, "shutdown", "()V");
@ -1836,7 +1836,7 @@ getBootstrapResource(Thread* t, object, uintptr_t* arguments)
if (m) { if (m) {
return reinterpret_cast<int64_t> return reinterpret_cast<int64_t>
(t->m->processor->invoke(t, m, root(t, Machine::BootLoader), name)); (t->m->processor->invoke(t, m, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name));
} else { } else {
return 0; return 0;
} }
@ -1854,7 +1854,7 @@ getBootstrapResources(Thread* t, object, uintptr_t* arguments)
if (m) { if (m) {
return reinterpret_cast<int64_t> return reinterpret_cast<int64_t>
(t->m->processor->invoke(t, m, root(t, Machine::BootLoader), name)); (t->m->processor->invoke(t, m, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name));
} else { } else {
return 0; return 0;
} }
@ -1932,7 +1932,7 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath); MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
{ object fileClass = resolveClass { object fileClass = resolveClass
(t, root(t, Machine::BootLoader), "java/io/File", false); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/io/File", false);
if (fileClass) { if (fileClass) {
object filePathField = findFieldInClass2 object filePathField = findFieldInClass2
@ -1945,7 +1945,7 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
} }
{ object fileDescriptorClass = resolveClass { object fileDescriptorClass = resolveClass
(t, root(t, Machine::BootLoader), "java/io/FileDescriptor", false); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/io/FileDescriptor", false);
if (fileDescriptorClass) { if (fileDescriptorClass) {
object fileDescriptorFdField = findFieldInClass2 object fileDescriptorFdField = findFieldInClass2
@ -1958,7 +1958,7 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
} }
{ object fileInputStreamClass = resolveClass { object fileInputStreamClass = resolveClass
(t, root(t, Machine::BootLoader), "java/io/FileInputStream", false); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/io/FileInputStream", false);
if (fileInputStreamClass) { if (fileInputStreamClass) {
PROTECT(t, fileInputStreamClass); PROTECT(t, fileInputStreamClass);
@ -1996,7 +1996,7 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
} }
{ object zipFileClass = resolveClass { object zipFileClass = resolveClass
(t, root(t, Machine::BootLoader), "java/util/zip/ZipFile", false); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/util/zip/ZipFile", false);
if (zipFileClass) { if (zipFileClass) {
PROTECT(t, zipFileClass); PROTECT(t, zipFileClass);
@ -2049,7 +2049,7 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
} }
{ object jarFileClass = resolveClass { object jarFileClass = resolveClass
(t, root(t, Machine::BootLoader), "java/util/jar/JarFile", false); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/util/jar/JarFile", false);
if (jarFileClass) { if (jarFileClass) {
intercept(t, jarFileClass, "getMetaInfEntryNames", intercept(t, jarFileClass, "getMetaInfEntryNames",
@ -2068,7 +2068,7 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
#endif #endif
object fsClass = resolveClass object fsClass = resolveClass
(t, root(t, Machine::BootLoader), fsClassName, false); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), fsClassName, false);
if (fsClass) { if (fsClass) {
PROTECT(t, fsClass); PROTECT(t, fsClass);
@ -2118,9 +2118,9 @@ countMethods(Thread* t, object c, bool publicOnly)
object table = classMethodTable(t, c); object table = classMethodTable(t, c);
unsigned count = 0; unsigned count = 0;
for (unsigned i = 0, j = classDeclaredMethodCount(t, c); i < j; ++i) { for (unsigned i = 0, j = classDeclaredMethodCount(t, c); i < j; ++i) {
object vmMethod = arrayBody(t, table, i); GcMethod* vmMethod = cast<GcMethod>(t, arrayBody(t, table, i));
if (((not publicOnly) or (methodFlags(t, vmMethod) & ACC_PUBLIC)) if (((not publicOnly) or (vmMethod->flags() & ACC_PUBLIC))
and byteArrayBody(t, methodName(t, vmMethod), 0) != '<') and vmMethod->name()->body()[0] != '<')
{ {
++ count; ++ count;
} }
@ -2152,10 +2152,10 @@ countConstructors(Thread* t, object c, bool publicOnly)
object table = classMethodTable(t, c); object table = classMethodTable(t, c);
unsigned count = 0; unsigned count = 0;
for (unsigned i = 0, j = classDeclaredMethodCount(t, c); i < j; ++i) { for (unsigned i = 0, j = classDeclaredMethodCount(t, c); i < j; ++i) {
object vmMethod = arrayBody(t, table, i); GcMethod* vmMethod = cast<GcMethod>(t, arrayBody(t, table, i));
if (((not publicOnly) or (methodFlags(t, vmMethod) & ACC_PUBLIC)) if (((not publicOnly) or (vmMethod->flags() & ACC_PUBLIC))
and strcmp(reinterpret_cast<char*> and strcmp(reinterpret_cast<char*>
(&byteArrayBody(t, methodName(t, vmMethod), 0)), (vmMethod->name()->body().begin()),
"<init>") == 0) "<init>") == 0)
{ {
++ count; ++ count;
@ -2217,39 +2217,38 @@ makeJconstructor(Thread* t,
#endif // HAVE_JexecutableHasRealParameterData #endif // HAVE_JexecutableHasRealParameterData
object object
makeJmethod(Thread* t, object vmMethod, int index) makeJmethod(Thread* t, GcMethod* vmMethod, int index)
{ {
PROTECT(t, vmMethod); PROTECT(t, vmMethod);
object name = intern object name = intern
(t, t->m->classpath->makeString (t, t->m->classpath->makeString
(t, methodName(t, vmMethod), 0, byteArrayLength (t, reinterpret_cast<object>(vmMethod->name()), 0, vmMethod->name()->length() - 1));
(t, methodName(t, vmMethod)) - 1));
PROTECT(t, name); PROTECT(t, name);
unsigned parameterCount; unsigned parameterCount;
unsigned returnTypeSpec; unsigned returnTypeSpec;
object parameterTypes = resolveParameterJTypes object parameterTypes = resolveParameterJTypes
(t, classLoader(t, methodClass(t, vmMethod)), methodSpec(t, vmMethod), (t, vmMethod->class_()->loader(), vmMethod->spec(),
&parameterCount, &returnTypeSpec); &parameterCount, &returnTypeSpec);
PROTECT(t, parameterTypes); PROTECT(t, parameterTypes);
GcJclass* returnType = resolveJType GcJclass* returnType = resolveJType
(t, classLoader(t, methodClass(t, vmMethod)), reinterpret_cast<char*> (t, vmMethod->class_()->loader(), reinterpret_cast<char*>
(&byteArrayBody(t, methodSpec(t, vmMethod), returnTypeSpec)), (&vmMethod->spec()->body()[returnTypeSpec]),
byteArrayLength(t, methodSpec(t, vmMethod)) - 1 - returnTypeSpec); vmMethod->spec()->length() - 1 - returnTypeSpec);
PROTECT(t, returnType); PROTECT(t, returnType);
object exceptionTypes = resolveExceptionJTypes object exceptionTypes = resolveExceptionJTypes
(t, classLoader(t, methodClass(t, vmMethod)), (t, vmMethod->class_()->loader(),
methodAddendum(t, vmMethod)); vmMethod->addendum());
PROTECT(t, exceptionTypes); PROTECT(t, exceptionTypes);
object signature; object signature;
object annotationTable; object annotationTable;
object parameterAnnotationTable; object parameterAnnotationTable;
object annotationDefault; object annotationDefault;
object addendum = methodAddendum(t, vmMethod); object addendum = reinterpret_cast<object>(vmMethod->addendum());
if (addendum) { if (addendum) {
signature = addendumSignature(t, addendum); signature = addendumSignature(t, addendum);
if (signature) { if (signature) {
@ -2278,16 +2277,16 @@ makeJmethod(Thread* t, object vmMethod, int index)
PROTECT(t, annotationDefault); PROTECT(t, annotationDefault);
if (annotationTable or parameterAnnotationTable or annotationDefault) { if (annotationTable or parameterAnnotationTable or annotationDefault) {
object runtimeData = getClassRuntimeData(t, cast<GcClass>(t, methodClass(t, vmMethod))); object runtimeData = getClassRuntimeData(t, vmMethod->class_());
set(t, runtimeData, ClassRuntimeDataPool, set(t, runtimeData, ClassRuntimeDataPool,
addendumPool(t, methodAddendum(t, vmMethod))); reinterpret_cast<object>(vmMethod->addendum()->pool()));
} }
if (index == -1) { if (index == -1) {
object table = classMethodTable(t, methodClass(t, vmMethod)); object table = vmMethod->class_()->methodTable();
for (unsigned i = 0; i < arrayLength(t, table); ++i) { for (unsigned i = 0; i < arrayLength(t, table); ++i) {
if (vmMethod == arrayBody(t, table, i)) { if (reinterpret_cast<object>(vmMethod) == arrayBody(t, table, i)) {
index = i; index = i;
break; break;
} }
@ -2296,35 +2295,35 @@ makeJmethod(Thread* t, object vmMethod, int index)
expect(t, index != -1); expect(t, index != -1);
GcJclass* jclass = getJClass(t, cast<GcClass>(t, methodClass(t, vmMethod))); GcJclass* jclass = getJClass(t, vmMethod->class_());
return reinterpret_cast<object>(makeJmethod return reinterpret_cast<object>(makeJmethod
(t, true, 0, jclass, index, cast<GcString>(t, name), returnType, parameterTypes, (t, true, 0, jclass, index, cast<GcString>(t, name), returnType, parameterTypes,
exceptionTypes, methodFlags(t, vmMethod), cast<GcString>(t, signature), 0, cast<GcByteArray>(t, annotationTable), exceptionTypes, vmMethod->flags(), cast<GcString>(t, signature), 0, cast<GcByteArray>(t, annotationTable),
cast<GcByteArray>(t, parameterAnnotationTable), cast<GcByteArray>(t, annotationDefault), 0, 0, 0)); cast<GcByteArray>(t, parameterAnnotationTable), cast<GcByteArray>(t, annotationDefault), 0, 0, 0));
} }
object object
makeJconstructor(Thread* t, object vmMethod, int index) makeJconstructor(Thread* t, GcMethod* vmMethod, int index)
{ {
PROTECT(t, vmMethod); PROTECT(t, vmMethod);
unsigned parameterCount; unsigned parameterCount;
unsigned returnTypeSpec; unsigned returnTypeSpec;
object parameterTypes = resolveParameterJTypes object parameterTypes = resolveParameterJTypes
(t, classLoader(t, methodClass(t, vmMethod)), methodSpec(t, vmMethod), (t, vmMethod->class_()->loader(), vmMethod->spec(),
&parameterCount, &returnTypeSpec); &parameterCount, &returnTypeSpec);
PROTECT(t, parameterTypes); PROTECT(t, parameterTypes);
object exceptionTypes = resolveExceptionJTypes object exceptionTypes = resolveExceptionJTypes
(t, classLoader(t, methodClass(t, vmMethod)), (t, vmMethod->class_()->loader(),
methodAddendum(t, vmMethod)); vmMethod->addendum());
PROTECT(t, exceptionTypes); PROTECT(t, exceptionTypes);
object signature; object signature;
object annotationTable; object annotationTable;
object parameterAnnotationTable; object parameterAnnotationTable;
object addendum = methodAddendum(t, vmMethod); object addendum = reinterpret_cast<object>(vmMethod->addendum());
if (addendum) { if (addendum) {
signature = addendumSignature(t, addendum); signature = addendumSignature(t, addendum);
if (signature) { if (signature) {
@ -2348,16 +2347,16 @@ makeJconstructor(Thread* t, object vmMethod, int index)
PROTECT(t, parameterAnnotationTable); PROTECT(t, parameterAnnotationTable);
if (annotationTable or parameterAnnotationTable) { if (annotationTable or parameterAnnotationTable) {
object runtimeData = getClassRuntimeData(t, cast<GcClass>(t, methodClass(t, vmMethod))); object runtimeData = getClassRuntimeData(t, vmMethod->class_());
set(t, runtimeData, ClassRuntimeDataPool, set(t, runtimeData, ClassRuntimeDataPool,
addendumPool(t, methodAddendum(t, vmMethod))); reinterpret_cast<object>(vmMethod->addendum()->pool()));
} }
if (index == -1) { if (index == -1) {
object table = classMethodTable(t, methodClass(t, vmMethod)); object table = vmMethod->class_()->methodTable();
for (unsigned i = 0; i < arrayLength(t, table); ++i) { for (unsigned i = 0; i < arrayLength(t, table); ++i) {
if (vmMethod == arrayBody(t, table, i)) { if (reinterpret_cast<object>(vmMethod) == arrayBody(t, table, i)) {
index = i; index = i;
break; break;
} }
@ -2366,12 +2365,24 @@ makeJconstructor(Thread* t, object vmMethod, int index)
expect(t, index != -1); expect(t, index != -1);
GcJclass* jclass = getJClass(t, cast<GcClass>(t, methodClass(t, vmMethod))); GcJclass* jclass = getJClass(t, vmMethod->class_());
return reinterpret_cast<object>(makeJconstructor return reinterpret_cast<object>(
(t, true, 0, jclass, index, parameterTypes, exceptionTypes, methodFlags makeJconstructor(t,
(t, vmMethod), cast<GcString>(t, signature), 0, cast<GcByteArray>(t, annotationTable), cast<GcByteArray>(t, parameterAnnotationTable), true,
0, 0, 0)); 0,
jclass,
index,
parameterTypes,
exceptionTypes,
vmMethod->flags(),
cast<GcString>(t, signature),
0,
cast<GcByteArray>(t, annotationTable),
cast<GcByteArray>(t, parameterAnnotationTable),
0,
0,
0));
} }
object object
@ -2386,7 +2397,7 @@ makeJfield(Thread* t, object vmField, int index)
PROTECT(t, name); PROTECT(t, name);
GcClass* type = resolveClassBySpec GcClass* type = resolveClassBySpec
(t, classLoader(t, fieldClass(t, vmField)), (t, cast<GcClassLoader>(t, classLoader(t, fieldClass(t, vmField))),
reinterpret_cast<char*> reinterpret_cast<char*>
(&byteArrayBody(t, fieldSpec(t, vmField), 0)), (&byteArrayBody(t, fieldSpec(t, vmField), 0)),
byteArrayLength(t, fieldSpec(t, vmField)) - 1); byteArrayLength(t, fieldSpec(t, vmField)) - 1);
@ -2531,7 +2542,7 @@ Avian_sun_misc_Perf_createLong
return reinterpret_cast<int64_t> return reinterpret_cast<int64_t>
(t->m->processor->invoke (t->m->processor->invoke
(t, resolveMethod (t, resolveMethod
(t, root(t, Machine::BootLoader), "java/nio/ByteBuffer", "allocate", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/nio/ByteBuffer", "allocate",
"(I)Ljava/nio/ByteBuffer;"), 0, 8)); "(I)Ljava/nio/ByteBuffer;"), 0, 8));
} }
@ -2550,7 +2561,7 @@ Avian_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BIILjava_lang_ClassLoade
object data = reinterpret_cast<object>(arguments[2]); object data = reinterpret_cast<object>(arguments[2]);
int32_t offset = arguments[3]; int32_t offset = arguments[3];
int32_t length = arguments[4]; int32_t length = arguments[4];
object loader = reinterpret_cast<object>(arguments[5]); GcClassLoader* loader = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[5]));
//object domain = reinterpret_cast<object>(arguments[6]); //object domain = reinterpret_cast<object>(arguments[6]);
uint8_t* buffer = static_cast<uint8_t*>(t->m->heap->allocate(length)); uint8_t* buffer = static_cast<uint8_t*>(t->m->heap->allocate(length));
@ -2941,7 +2952,7 @@ jvmInitProperties(Thread* t, uintptr_t* arguments)
jobject properties = reinterpret_cast<jobject>(arguments[0]); jobject properties = reinterpret_cast<jobject>(arguments[0]);
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, root(t, Machine::BootLoader), "java/util/Properties", "setProperty", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/util/Properties", "setProperty",
"(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;"); "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;");
PROTECT(t, method); PROTECT(t, method);
@ -3009,7 +3020,7 @@ jvmInitProperties(Thread* t, uintptr_t* arguments)
local::setProperty local::setProperty
(t, method, *properties, "sun.boot.class.path", (t, method, *properties, "sun.boot.class.path",
static_cast<Finder*> static_cast<Finder*>
(systemClassLoaderFinder(t, root(t, Machine::BootLoader)))->path()); (cast<GcSystemClassLoader>(t, root(t, Machine::BootLoader))->finder())->path());
local::setProperty(t, method, *properties, "file.encoding", "UTF-8"); local::setProperty(t, method, *properties, "file.encoding", "UTF-8");
#ifdef ARCH_x86_32 #ifdef ARCH_x86_32
@ -3412,7 +3423,7 @@ jvmDumpThreads(Thread* t, uintptr_t* arguments)
unsigned threadsLength = objectArrayLength(t, *threads); unsigned threadsLength = objectArrayLength(t, *threads);
GcClass* arrayClass = resolveObjectArrayClass GcClass* arrayClass = resolveObjectArrayClass
(t, reinterpret_cast<object>(type(t, GcStackTraceElement::Type)->loader()), (t, type(t, GcStackTraceElement::Type)->loader(),
reinterpret_cast<object>(type(t, GcStackTraceElement::Type))); reinterpret_cast<object>(type(t, GcStackTraceElement::Type)));
object result = makeObjectArray(t, arrayClass, threadsLength); object result = makeObjectArray(t, arrayClass, threadsLength);
PROTECT(t, result); PROTECT(t, result);
@ -3542,7 +3553,7 @@ jvmGetSystemPackages(Thread* t, uintptr_t*)
makeObjectArray( makeObjectArray(
t, t,
resolveClass( resolveClass(
t, root(t, Machine::BootLoader), "java/lang/Package"), t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/Package"),
0))); 0)));
} }
@ -3572,9 +3583,9 @@ EXPORT(JVM_LatestUserDefinedLoader)(Thread* t)
{ } { }
virtual bool visit(Processor::StackWalker* walker) { virtual bool visit(Processor::StackWalker* walker) {
object loader = reinterpret_cast<object>(walker->method()->class_()->loader()); GcClassLoader* loader = walker->method()->class_()->loader();
if (loader if (loader
and loader != root(t, Machine::BootLoader) and loader != cast<GcClassLoader>(t, root(t, Machine::BootLoader))
and strcmp and strcmp
(objectClass(t, loader)->name()->body().begin(), (objectClass(t, loader)->name()->body().begin(),
reinterpret_cast<const int8_t*> reinterpret_cast<const int8_t*>
@ -3588,12 +3599,12 @@ EXPORT(JVM_LatestUserDefinedLoader)(Thread* t)
} }
Thread* t; Thread* t;
object loader; GcClassLoader* loader;
} v(t); } v(t);
t->m->processor->walkStack(t, &v); t->m->processor->walkStack(t, &v);
return makeLocalReference(t, v.loader); return makeLocalReference(t, reinterpret_cast<object>(v.loader));
} }
extern "C" AVIAN_EXPORT jclass JNICALL extern "C" AVIAN_EXPORT jclass JNICALL
@ -3853,7 +3864,7 @@ jvmResolveClass(Thread* t, uintptr_t* arguments)
jclass c = reinterpret_cast<jclass>(arguments[0]); jclass c = reinterpret_cast<jclass>(arguments[0]);
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Classes", "link", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "link",
"(Lavian/VMClass;)V"); "(Lavian/VMClass;)V");
t->m->processor->invoke(t, method, 0, jclassVmClass(t, *c)); t->m->processor->invoke(t, method, 0, jclassVmClass(t, *c));
@ -3878,7 +3889,7 @@ jvmFindClassFromClassLoader(Thread* t, uintptr_t* arguments)
jboolean throwError = arguments[3]; jboolean throwError = arguments[3];
GcClass* c = resolveClass GcClass* c = resolveClass
(t, loader ? *loader : root(t, Machine::BootLoader), name, true, (t, cast<GcClassLoader>(t, loader ? *loader : root(t, Machine::BootLoader)), name, true,
throwError ? static_cast<Gc::Type>(GcNoClassDefFoundError::Type) throwError ? static_cast<Gc::Type>(GcNoClassDefFoundError::Type)
: static_cast<Gc::Type>(GcClassNotFoundException::Type)); : static_cast<Gc::Type>(GcClassNotFoundException::Type));
@ -3893,7 +3904,7 @@ jvmFindClassFromClassLoader(Thread* t, uintptr_t* arguments)
extern "C" AVIAN_EXPORT jclass JNICALL extern "C" AVIAN_EXPORT jclass JNICALL
EXPORT(JVM_FindClassFromClassLoader)(Thread* t, const char* name, EXPORT(JVM_FindClassFromClassLoader)(Thread* t, const char* name,
jboolean init, jobject loader, jboolean init, jobject* loader,
jboolean throwError) jboolean throwError)
{ {
uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(name), uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(name),
@ -3928,14 +3939,14 @@ jvmFindLoadedClass(Thread* t, uintptr_t* arguments)
replace('.', '/', s); replace('.', '/', s);
} }
GcClass* c = findLoadedClass(t, *loader, spec); GcClass* c = findLoadedClass(t, cast<GcClassLoader>(t, *loader), spec);
return reinterpret_cast<uint64_t> return reinterpret_cast<uint64_t>
(c ? makeLocalReference(t, reinterpret_cast<object>(getJClass(t, c))) : 0); (c ? makeLocalReference(t, reinterpret_cast<object>(getJClass(t, c))) : 0);
} }
extern "C" AVIAN_EXPORT jclass JNICALL extern "C" AVIAN_EXPORT jclass JNICALL
EXPORT(JVM_FindLoadedClass)(Thread* t, jobject loader, jstring name) EXPORT(JVM_FindLoadedClass)(Thread* t, jobject* loader, jstring name)
{ {
uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(loader), uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(loader),
reinterpret_cast<uintptr_t>(name) }; reinterpret_cast<uintptr_t>(name) };
@ -3952,11 +3963,11 @@ jvmDefineClass(Thread* t, uintptr_t* arguments)
return reinterpret_cast<uint64_t> return reinterpret_cast<uint64_t>
(makeLocalReference (makeLocalReference
(t, reinterpret_cast<object>(getJClass(t, cast<GcClass>(t, defineClass(t, *loader, data, length)))))); (t, reinterpret_cast<object>(getJClass(t, cast<GcClass>(t, defineClass(t, cast<GcClassLoader>(t, *loader), data, length))))));
} }
extern "C" AVIAN_EXPORT jclass JNICALL extern "C" AVIAN_EXPORT jclass JNICALL
EXPORT(JVM_DefineClass)(Thread* t, const char*, jobject loader, EXPORT(JVM_DefineClass)(Thread* t, const char*, jobject* loader,
const uint8_t* data, jsize length, jobject) const uint8_t* data, jsize length, jobject)
{ {
uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(loader), uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(loader),
@ -3967,7 +3978,7 @@ EXPORT(JVM_DefineClass)(Thread* t, const char*, jobject loader,
} }
extern "C" AVIAN_EXPORT jclass JNICALL extern "C" AVIAN_EXPORT jclass JNICALL
EXPORT(JVM_DefineClassWithSource)(Thread* t, const char*, jobject loader, EXPORT(JVM_DefineClassWithSource)(Thread* t, const char*, jobject* loader,
const uint8_t* data, jsize length, jobject, const uint8_t* data, jsize length, jobject,
const char*) const char*)
{ {
@ -3975,7 +3986,7 @@ EXPORT(JVM_DefineClassWithSource)(Thread* t, const char*, jobject loader,
} }
extern "C" AVIAN_EXPORT jclass JNICALL extern "C" AVIAN_EXPORT jclass JNICALL
EXPORT(JVM_DefineClassWithSourceCond)(Thread* t, const char*, jobject loader, EXPORT(JVM_DefineClassWithSourceCond)(Thread* t, const char*, jobject* loader,
const uint8_t* data, jsize length, const uint8_t* data, jsize length,
jobject, const char*, jboolean) jobject, const char*, jboolean)
{ {
@ -4032,9 +4043,9 @@ EXPORT(JVM_GetClassLoader)(Thread* t, jclass c)
{ {
ENTER(t, Thread::ActiveState); ENTER(t, Thread::ActiveState);
object loader = classLoader(t, jclassVmClass(t, *c)); GcClassLoader* loader = cast<GcClassLoader>(t, classLoader(t, jclassVmClass(t, *c)));
if (loader == root(t, Machine::BootLoader)) { if (loader == cast<GcClassLoader>(t, root(t, Machine::BootLoader))) {
// sun.misc.Unsafe.getUnsafe expects a null result if the class // sun.misc.Unsafe.getUnsafe expects a null result if the class
// loader is the boot classloader and will throw a // loader is the boot classloader and will throw a
// SecurityException otherwise. // SecurityException otherwise.
@ -4049,7 +4060,7 @@ EXPORT(JVM_GetClassLoader)(Thread* t, jclass c)
return makeLocalReference(t, root(t, Machine::BootLoader)); return makeLocalReference(t, root(t, Machine::BootLoader));
} }
} else { } else {
return makeLocalReference(t, loader); return makeLocalReference(t, reinterpret_cast<object>(loader));
} }
} }
@ -4106,7 +4117,7 @@ jvmGetProtectionDomain(Thread* t, uintptr_t* arguments)
jclass c = reinterpret_cast<jclass>(arguments[0]); jclass c = reinterpret_cast<jclass>(arguments[0]);
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Classes", "getProtectionDomain", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "getProtectionDomain",
"(Lavian/VMClass;)Ljava/security/ProtectionDomain;"); "(Lavian/VMClass;)Ljava/security/ProtectionDomain;");
return reinterpret_cast<uint64_t> return reinterpret_cast<uint64_t>
@ -4273,11 +4284,11 @@ jvmGetClassDeclaredMethods(Thread* t, uintptr_t* arguments)
for (unsigned i = 0, j = classDeclaredMethodCount(t, jclassVmClass(t, *c)); for (unsigned i = 0, j = classDeclaredMethodCount(t, jclassVmClass(t, *c));
i < j; ++i) i < j; ++i)
{ {
object vmMethod = arrayBody(t, table, i); GcMethod* vmMethod = cast<GcMethod>(t, arrayBody(t, table, i));
PROTECT(t, vmMethod); PROTECT(t, vmMethod);
if (((not publicOnly) or (methodFlags(t, vmMethod) & ACC_PUBLIC)) if (((not publicOnly) or (vmMethod->flags() & ACC_PUBLIC))
and byteArrayBody(t, methodName(t, vmMethod), 0) != '<') and vmMethod->name()->body()[0] != '<')
{ {
object method = makeJmethod(t, vmMethod, i); object method = makeJmethod(t, vmMethod, i);
@ -4369,12 +4380,12 @@ jvmGetClassDeclaredConstructors(Thread* t, uintptr_t* arguments)
for (unsigned i = 0, j = classDeclaredMethodCount(t, jclassVmClass(t, *c)); for (unsigned i = 0, j = classDeclaredMethodCount(t, jclassVmClass(t, *c));
i < j; ++i) i < j; ++i)
{ {
object vmMethod = arrayBody(t, table, i); GcMethod* vmMethod = cast<GcMethod>(t, arrayBody(t, table, i));
PROTECT(t, vmMethod); PROTECT(t, vmMethod);
if (((not publicOnly) or (methodFlags(t, vmMethod) & ACC_PUBLIC)) if (((not publicOnly) or (vmMethod->flags() & ACC_PUBLIC))
and strcmp(reinterpret_cast<char*> and strcmp(reinterpret_cast<char*>
(&byteArrayBody(t, methodName(t, vmMethod), 0)), (vmMethod->name()->body().begin()),
"<init>") == 0) "<init>") == 0)
{ {
object method = makeJconstructor(t, vmMethod, i); object method = makeJconstructor(t, vmMethod, i);
@ -4621,7 +4632,7 @@ maybeWrap(Thread* t, bool wrapException)
PROTECT(t, exception); PROTECT(t, exception);
GcClass* paeClass = resolveClass GcClass* paeClass = resolveClass
(t, root(t, Machine::BootLoader), (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
"java/security/PrivilegedActionException"); "java/security/PrivilegedActionException");
PROTECT(t, paeClass); PROTECT(t, paeClass);
@ -4648,7 +4659,7 @@ jvmDoPrivileged(Thread* t, uintptr_t* arguments)
// object: // object:
GcClass* privilegedAction = resolveClass GcClass* privilegedAction = resolveClass
(t, root(t, Machine::BootLoader), "java/security/PrivilegedAction"); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/security/PrivilegedAction");
GcMethod* method; GcMethod* method;
if (instanceOf(t, privilegedAction, *action)) { if (instanceOf(t, privilegedAction, *action)) {
@ -4656,7 +4667,7 @@ jvmDoPrivileged(Thread* t, uintptr_t* arguments)
(t, privilegedAction, "run", "()Ljava/lang/Object;"); (t, privilegedAction, "run", "()Ljava/lang/Object;");
} else { } else {
GcClass* privilegedExceptionAction = resolveClass GcClass* privilegedExceptionAction = resolveClass
(t, root(t, Machine::BootLoader), (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
"java/security/PrivilegedExceptionAction"); "java/security/PrivilegedExceptionAction");
method = resolveMethod method = resolveMethod
@ -5186,7 +5197,7 @@ getMemoryManagers(Thread* t, uintptr_t*)
t, t,
makeObjectArray(t, makeObjectArray(t,
resolveClass(t, resolveClass(t,
root(t, Machine::BootLoader), cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
"java/lang/management/MemoryManagerMXBean"), "java/lang/management/MemoryManagerMXBean"),
0))); 0)));
} }
@ -5204,7 +5215,7 @@ getMemoryPools(Thread* t, uintptr_t*)
t, t,
makeObjectArray(t, makeObjectArray(t,
resolveClass(t, resolveClass(t,
root(t, Machine::BootLoader), cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
"java/lang/management/MemoryPoolMXBean"), "java/lang/management/MemoryPoolMXBean"),
0))); 0)));
} }
@ -5259,7 +5270,7 @@ getEnclosingMethodInfo(Thread* t, uintptr_t* arguments)
PROTECT(t, array); PROTECT(t, array);
enclosingClass = reinterpret_cast<object>(getJClass enclosingClass = reinterpret_cast<object>(getJClass
(t, resolveClass(t, classLoader(t, class_), enclosingClass))); (t, resolveClass(t, cast<GcClassLoader>(t, classLoader(t, class_)), enclosingClass)));
set(t, array, ArrayBody, enclosingClass); set(t, array, ArrayBody, enclosingClass);

34
src/compile.cpp
View File

@ -336,7 +336,7 @@ resolveTarget(MyThread* t, void* stack, GcMethod* method)
PROTECT(t, method); PROTECT(t, method);
PROTECT(t, class_); PROTECT(t, class_);
resolveSystemClass(t, root(t, Machine::BootLoader), reinterpret_cast<object>(class_->name())); resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), reinterpret_cast<object>(class_->name()));
} }
if (method->class_()->flags() & ACC_INTERFACE) { if (method->class_()->flags() & ACC_INTERFACE) {
@ -352,7 +352,7 @@ resolveTarget(MyThread* t, GcClass* class_, unsigned index)
if (class_->vmFlags() & BootstrapFlag) { if (class_->vmFlags() & BootstrapFlag) {
PROTECT(t, class_); PROTECT(t, class_);
resolveSystemClass(t, root(t, Machine::BootLoader), reinterpret_cast<object>(class_->name())); resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), reinterpret_cast<object>(class_->name()));
} }
return cast<GcMethod>(t, arrayBody(t, class_->virtualTable(), index)); return cast<GcMethod>(t, arrayBody(t, class_->virtualTable(), index));
@ -2281,7 +2281,7 @@ resolveMethod(Thread* t, object pair)
PROTECT(t, reference); PROTECT(t, reference);
GcClass* class_ = resolveClassInObject GcClass* class_ = resolveClassInObject
(t, classLoader(t, methodClass(t, pairFirst(t, pair))), reference, (t, cast<GcMethod>(t, cast<GcPair>(t, pair)->first())->class_()->loader(), reference,
ReferenceClass); ReferenceClass);
return cast<GcMethod>(t, findInHierarchy return cast<GcMethod>(t, findInHierarchy
@ -2419,7 +2419,7 @@ getJClassFromReference(MyThread* t, object pair)
return reinterpret_cast<intptr_t>(getJClass( return reinterpret_cast<intptr_t>(getJClass(
t, t,
resolveClass(t, resolveClass(t,
classLoader(t, methodClass(t, pairFirst(t, pair))), cast<GcMethod>(t, cast<GcPair>(t, pair)->first())->class_()->loader(),
referenceName(t, pairSecond(t, pair))))); referenceName(t, pairSecond(t, pair)))));
} }
@ -2512,7 +2512,7 @@ makeBlankObjectArrayFromReference(MyThread* t, object pair,
return makeBlankObjectArray( return makeBlankObjectArray(
t, t,
resolveClass(t, resolveClass(t,
classLoader(t, methodClass(t, pairFirst(t, pair))), cast<GcMethod>(t, cast<GcPair>(t, pair)->first())->class_()->loader(),
referenceName(t, pairSecond(t, pair))), referenceName(t, pairSecond(t, pair))),
length); length);
} }
@ -2651,7 +2651,7 @@ makeMultidimensionalArrayFromReference(MyThread* t, object pair,
{ {
return makeMultidimensionalArray return makeMultidimensionalArray
(t, resolveClass (t, resolveClass
(t, classLoader(t, methodClass(t, pairFirst(t, pair))), (t, cast<GcMethod>(t, cast<GcPair>(t, pair)->first())->class_()->loader(),
referenceName(t, pairSecond(t, pair))), dimensions, offset); referenceName(t, pairSecond(t, pair))), dimensions, offset);
} }
@ -2710,7 +2710,7 @@ checkCastFromReference(MyThread* t, object pair, object o)
PROTECT(t, o); PROTECT(t, o);
GcClass* c = resolveClass GcClass* c = resolveClass
(t, classLoader(t, methodClass(t, pairFirst(t, pair))), (t, cast<GcMethod>(t, cast<GcPair>(t, pair)->first())->class_()->loader(),
referenceName(t, pairSecond(t, pair))); referenceName(t, pairSecond(t, pair)));
checkCast(t, c, o); checkCast(t, c, o);
@ -2723,7 +2723,7 @@ resolveField(Thread* t, object pair)
PROTECT(t, reference); PROTECT(t, reference);
GcClass* class_ = resolveClassInObject GcClass* class_ = resolveClassInObject
(t, classLoader(t, methodClass(t, pairFirst(t, pair))), reference, (t, cast<GcMethod>(t, cast<GcPair>(t, pair)->first())->class_()->loader(), reference,
ReferenceClass); ReferenceClass);
return findInHierarchy return findInHierarchy
@ -2906,7 +2906,7 @@ instanceOfFromReference(Thread* t, object pair, object o)
PROTECT(t, o); PROTECT(t, o);
GcClass* c = resolveClass GcClass* c = resolveClass
(t, classLoader(t, methodClass(t, pairFirst(t, pair))), (t, cast<GcMethod>(t, cast<GcPair>(t, pair)->first())->class_()->loader(),
referenceName(t, pairSecond(t, pair))); referenceName(t, pairSecond(t, pair)));
return instanceOf64(t, c, o); return instanceOf64(t, c, o);
@ -2936,7 +2936,7 @@ uint64_t
makeNewFromReference(Thread* t, object pair) makeNewFromReference(Thread* t, object pair)
{ {
GcClass* class_ = resolveClass GcClass* class_ = resolveClass
(t, classLoader(t, methodClass(t, pairFirst(t, pair))), (t, cast<GcMethod>(t, cast<GcPair>(t, pair)->first())->class_()->loader(),
referenceName(t, pairSecond(t, pair))); referenceName(t, pairSecond(t, pair)));
PROTECT(t, class_); PROTECT(t, class_);
@ -7593,7 +7593,7 @@ returnClass(MyThread* t, GcMethod* method)
memcpy(&byteArrayBody(t, name, 0), spec + 1, length - 2); memcpy(&byteArrayBody(t, name, 0), spec + 1, length - 2);
} }
return resolveClass(t, reinterpret_cast<object>(method->class_()->loader()), name); return resolveClass(t, method->class_()->loader(), name);
} }
bool bool
@ -7717,7 +7717,7 @@ callContinuation(MyThread* t, object continuation, object result,
PROTECT(t, nextContinuation); PROTECT(t, nextContinuation);
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Continuations", "rewind", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Continuations", "rewind",
"(Ljava/lang/Runnable;Lavian/Callback;Ljava/lang/Object;" "(Ljava/lang/Runnable;Lavian/Callback;Ljava/lang/Object;"
"Ljava/lang/Throwable;)V"); "Ljava/lang/Throwable;)V");
@ -7777,7 +7777,7 @@ callWithCurrentContinuation(MyThread* t, object receiver)
if (root(t, ReceiveMethod) == 0) { if (root(t, ReceiveMethod) == 0) {
GcMethod* m = resolveMethod GcMethod* m = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Function", "call", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Function", "call",
"(Ljava/lang/Object;)Ljava/lang/Object;"); "(Ljava/lang/Object;)Ljava/lang/Object;");
if (m) { if (m) {
@ -7787,7 +7787,7 @@ callWithCurrentContinuation(MyThread* t, object receiver)
if (classVmFlags(t, continuationClass) & BootstrapFlag) { if (classVmFlags(t, continuationClass) & BootstrapFlag) {
resolveSystemClass resolveSystemClass
(t, root(t, Machine::BootLoader), (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
vm::className(t, continuationClass)); vm::className(t, continuationClass));
} }
} }
@ -7817,7 +7817,7 @@ dynamicWind(MyThread* t, object before, object thunk, object after)
if (root(t, WindMethod) == 0) { if (root(t, WindMethod) == 0) {
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Continuations", "wind", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Continuations", "wind",
"(Ljava/lang/Runnable;Ljava/util/concurrent/Callable;" "(Ljava/lang/Runnable;Ljava/util/concurrent/Callable;"
"Ljava/lang/Runnable;)Lavian/Continuations$UnwindResult;"); "Ljava/lang/Runnable;)Lavian/Continuations$UnwindResult;");
@ -8024,7 +8024,7 @@ invoke(Thread* thread, GcMethod* method, ArgumentList* arguments)
compile(t, local::codeAllocator(static_cast<MyThread*>(t)), 0, compile(t, local::codeAllocator(static_cast<MyThread*>(t)), 0,
resolveMethod resolveMethod
(t, root(t, Machine::AppLoader), (t, cast<GcClassLoader>(t, root(t, Machine::AppLoader)),
"foo/ClassName", "foo/ClassName",
"methodName", "methodName",
"()V")); "()V"));
@ -8664,7 +8664,7 @@ class MyProcessor: public Processor {
this_, methodSpec, false, arguments); this_, methodSpec, false, arguments);
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, reinterpret_cast<object>(loader), className, methodName, methodSpec); (t, loader, className, methodName, methodSpec);
assertT(t, ((method->flags() & ACC_STATIC) == 0) xor (this_ == 0)); assertT(t, ((method->flags() & ACC_STATIC) == 0) xor (this_ == 0));

6
src/interpret.cpp
View File

@ -2665,7 +2665,7 @@ interpret3(Thread* t, const int base)
GcClass* class_ = objectClass(t, peekObject(t, sp - parameterFootprint)); GcClass* class_ = objectClass(t, peekObject(t, sp - parameterFootprint));
assertT(t, class_->vmFlags() & BootstrapFlag); assertT(t, class_->vmFlags() & BootstrapFlag);
resolveClass(t, reinterpret_cast<object>(frameMethod(t, frame)->class_()->loader()), resolveClass(t, frameMethod(t, frame)->class_()->loader(),
reinterpret_cast<object>(class_->name())); reinterpret_cast<object>(class_->name()));
ip -= 3; ip -= 3;
@ -2891,7 +2891,7 @@ invoke(Thread* t, GcMethod* method)
class_ = objectClass(t, peekObject(t, t->sp - parameterFootprint)); class_ = objectClass(t, peekObject(t, t->sp - parameterFootprint));
if (class_->vmFlags() & BootstrapFlag) { if (class_->vmFlags() & BootstrapFlag) {
resolveClass(t, root(t, Machine::BootLoader), reinterpret_cast<object>(class_->name())); resolveClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), reinterpret_cast<object>(class_->name()));
} }
if (method->class_()->flags() & ACC_INTERFACE) { if (method->class_()->flags() & ACC_INTERFACE) {
@ -3219,7 +3219,7 @@ class MyProcessor: public Processor {
pushArguments(t, this_, methodSpec, false, arguments); pushArguments(t, this_, methodSpec, false, arguments);
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, reinterpret_cast<object>(loader), className, methodName, methodSpec); (t, loader, className, methodName, methodSpec);
assertT(t, ((method->flags() & ACC_STATIC) == 0) xor (this_ == 0)); assertT(t, ((method->flags() & ACC_STATIC) == 0) xor (this_ == 0));

9
src/jnienv.cpp
View File

@ -325,7 +325,7 @@ defineClass(Thread* t, uintptr_t* arguments)
t, t,
reinterpret_cast<object>(getJClass(t, reinterpret_cast<object>(getJClass(t,
cast<GcClass>(t, defineClass(t, cast<GcClass>(t, defineClass(t,
loader ? *loader : root(t, Machine::BootLoader), cast<GcClassLoader>(t, loader ? *loader : root(t, Machine::BootLoader)),
buffer, buffer,
length)))))); length))))));
} }
@ -353,9 +353,8 @@ findClass(Thread* t, uintptr_t* arguments)
GcClass* c = resolveClass( GcClass* c = resolveClass(
t, t,
caller ? reinterpret_cast caller ? t->m->classpath->libraryClassLoader(t, caller) : cast
<object>(t->m->classpath->libraryClassLoader(t, caller)) <GcClassLoader>(t, root(t, Machine::AppLoader)),
: root(t, Machine::AppLoader),
n); n);
if (t->m->classpath->mayInitClasses()) { if (t->m->classpath->mayInitClasses()) {
@ -3564,7 +3563,7 @@ boot(Thread* t, uintptr_t*)
PROTECT(t, host); PROTECT(t, host);
GcMethod* method = resolveMethod GcMethod* method = resolveMethod
(t, root(t, Machine::BootLoader), "avian/Traces", "startTraceListener", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Traces", "startTraceListener",
"(Ljava/lang/String;I)V"); "(Ljava/lang/String;I)V");
t->m->processor->invoke(t, method, 0, host, atoi(port)); t->m->processor->invoke(t, method, 0, host, atoi(port));

74
src/machine.cpp
View File

@ -1253,7 +1253,7 @@ parseInterfaceTable(Thread* t, Stream& s, GcClass* class_, GcSingleton* pool,
PROTECT(t, name); PROTECT(t, name);
GcClass* interface = resolveClass GcClass* interface = resolveClass
(t, reinterpret_cast<object>(class_->loader()), name, true, throwType); (t, class_->loader(), name, true, throwType);
PROTECT(t, interface); PROTECT(t, interface);
@ -2523,7 +2523,7 @@ updateBootstrapClass(Thread* t, GcClass* bootstrapClass, GcClass* class_)
} }
GcClass* GcClass*
makeArrayClass(Thread* t, object loader, unsigned dimensions, object spec, makeArrayClass(Thread* t, GcClassLoader* loader, unsigned dimensions, object spec,
object elementClass) object elementClass)
{ {
if (type(t, GcJobject::Type)->vmFlags() & BootstrapFlag) { if (type(t, GcJobject::Type)->vmFlags() & BootstrapFlag) {
@ -2536,7 +2536,7 @@ makeArrayClass(Thread* t, object loader, unsigned dimensions, object spec,
// avoid infinite recursion due to trying to create an array to // avoid infinite recursion due to trying to create an array to
// make a stack trace for a ClassNotFoundException. // make a stack trace for a ClassNotFoundException.
resolveSystemClass resolveSystemClass
(t, root(t, Machine::BootLoader), (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
reinterpret_cast<object>(type(t, GcJobject::Type)->name()), false); reinterpret_cast<object>(type(t, GcJobject::Type)->name()), false);
} }
@ -2560,7 +2560,7 @@ makeArrayClass(Thread* t, object loader, unsigned dimensions, object spec,
0, 0,
0, 0,
0, 0,
cast<GcClassLoader>(t, loader), loader,
arrayLength(t, vtable)); arrayLength(t, vtable));
PROTECT(t, c); PROTECT(t, c);
@ -2571,27 +2571,27 @@ makeArrayClass(Thread* t, object loader, unsigned dimensions, object spec,
} }
void void
saveLoadedClass(Thread* t, object loader, GcClass* c) saveLoadedClass(Thread* t, GcClassLoader* loader, GcClass* c)
{ {
PROTECT(t, loader); PROTECT(t, loader);
PROTECT(t, c); PROTECT(t, c);
ACQUIRE(t, t->m->classLock); ACQUIRE(t, t->m->classLock);
if (classLoaderMap(t, loader) == 0) { if (loader->map() == 0) {
GcHashMap* map = makeHashMap(t, 0, 0); GcHashMap* map = makeHashMap(t, 0, 0);
set(t, loader, ClassLoaderMap, reinterpret_cast<object>(map)); set(t, reinterpret_cast<object>(loader), ClassLoaderMap, reinterpret_cast<object>(map));
} }
hashMapInsert(t, hashMapInsert(t,
cast<GcHashMap>(t, classLoaderMap(t, loader)), cast<GcHashMap>(t, loader->map()),
reinterpret_cast<object>(c->name()), reinterpret_cast<object>(c->name()),
reinterpret_cast<object>(c), reinterpret_cast<object>(c),
byteArrayHash); byteArrayHash);
} }
GcClass* GcClass*
makeArrayClass(Thread* t, object loader, object spec, bool throw_, makeArrayClass(Thread* t, GcClassLoader* loader, object spec, bool throw_,
Gc::Type throwType) Gc::Type throwType)
{ {
PROTECT(t, loader); PROTECT(t, loader);
@ -2649,23 +2649,23 @@ makeArrayClass(Thread* t, object loader, object spec, bool throw_,
ACQUIRE(t, t->m->classLock); ACQUIRE(t, t->m->classLock);
GcClass* class_ = findLoadedClass(t, reinterpret_cast<object>(elementClass->loader()), spec); GcClass* class_ = findLoadedClass(t, elementClass->loader(), spec);
if (class_) { if (class_) {
return class_; return class_;
} }
class_ = makeArrayClass class_ = makeArrayClass
(t, reinterpret_cast<object>(elementClass->loader()), dimensions, spec, reinterpret_cast<object>(elementClass)); (t, elementClass->loader(), dimensions, spec, reinterpret_cast<object>(elementClass));
PROTECT(t, class_); PROTECT(t, class_);
saveLoadedClass(t, reinterpret_cast<object>(elementClass->loader()), class_); saveLoadedClass(t, elementClass->loader(), class_);
return class_; return class_;
} }
GcClass* GcClass*
resolveArrayClass(Thread* t, object loader, object spec, bool throw_, resolveArrayClass(Thread* t, GcClassLoader* loader, object spec, bool throw_,
Gc::Type throwType) Gc::Type throwType)
{ {
GcClass* c = cast<GcClass>(t, GcClass* c = cast<GcClass>(t,
@ -2684,7 +2684,7 @@ resolveArrayClass(Thread* t, object loader, object spec, bool throw_,
PROTECT(t, loader); PROTECT(t, loader);
PROTECT(t, spec); PROTECT(t, spec);
c = findLoadedClass(t, root(t, Machine::BootLoader), spec); c = findLoadedClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), spec);
if (c) { if (c) {
return c; return c;
@ -2899,13 +2899,13 @@ boot(Thread* t)
set(t, root(t, Machine::BootLoader), ClassLoaderMap, reinterpret_cast<object>(map)); set(t, root(t, Machine::BootLoader), ClassLoaderMap, reinterpret_cast<object>(map));
} }
systemClassLoaderFinder(t, root(t, Machine::BootLoader)) = m->bootFinder; cast<GcSystemClassLoader>(t, root(t, Machine::BootLoader))->finder() = m->bootFinder;
{ GcHashMap* map = makeHashMap(t, 0, 0); { GcHashMap* map = makeHashMap(t, 0, 0);
set(t, root(t, Machine::AppLoader), ClassLoaderMap, reinterpret_cast<object>(map)); set(t, root(t, Machine::AppLoader), ClassLoaderMap, reinterpret_cast<object>(map));
} }
systemClassLoaderFinder(t, root(t, Machine::AppLoader)) = m->appFinder; cast<GcSystemClassLoader>(t, root(t, Machine::AppLoader))->finder() = m->appFinder;
set(t, root(t, Machine::AppLoader), ClassLoaderParent, set(t, root(t, Machine::AppLoader), ClassLoaderParent,
root(t, Machine::BootLoader)); root(t, Machine::BootLoader));
@ -4081,7 +4081,7 @@ resolveBootstrap(Thread* t, uintptr_t* arguments)
{ {
object name = reinterpret_cast<object>(arguments[0]); object name = reinterpret_cast<object>(arguments[0]);
resolveSystemClass(t, root(t, Machine::BootLoader), name); resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name);
return 1; return 1;
} }
@ -4238,7 +4238,7 @@ primitiveSize(Thread* t, unsigned code)
} }
GcClass* GcClass*
parseClass(Thread* t, object loader, const uint8_t* data, unsigned size, parseClass(Thread* t, GcClassLoader* loader, const uint8_t* data, unsigned size,
Gc::Type throwType) Gc::Type throwType)
{ {
PROTECT(t, loader); PROTECT(t, loader);
@ -4289,7 +4289,7 @@ parseClass(Thread* t, object loader, const uint8_t* data, unsigned size,
0, // methods 0, // methods
0, // addendum 0, // addendum
0, // static table 0, // static table
cast<GcClassLoader>(t, loader), loader,
0, // source 0, // source
0);// vtable length 0);// vtable length
PROTECT(t, class_); PROTECT(t, class_);
@ -4369,7 +4369,7 @@ parseClass(Thread* t, object loader, const uint8_t* data, unsigned size,
uint64_t uint64_t
runParseClass(Thread* t, uintptr_t* arguments) runParseClass(Thread* t, uintptr_t* arguments)
{ {
object loader = reinterpret_cast<object>(arguments[0]); GcClassLoader* loader = cast<GcClassLoader>(t, reinterpret_cast<object>(arguments[0]));
System::Region* region = reinterpret_cast<System::Region*>(arguments[1]); System::Region* region = reinterpret_cast<System::Region*>(arguments[1]);
Gc::Type throwType = static_cast<Gc::Type>(arguments[2]); Gc::Type throwType = static_cast<Gc::Type>(arguments[2]);
@ -4378,7 +4378,7 @@ runParseClass(Thread* t, uintptr_t* arguments)
} }
GcClass* GcClass*
resolveSystemClass(Thread* t, object loader, object spec, bool throw_, resolveSystemClass(Thread* t, GcClassLoader* loader, object spec, bool throw_,
Gc::Type throwType) Gc::Type throwType)
{ {
PROTECT(t, loader); PROTECT(t, loader);
@ -4387,14 +4387,14 @@ resolveSystemClass(Thread* t, object loader, object spec, bool throw_,
ACQUIRE(t, t->m->classLock); ACQUIRE(t, t->m->classLock);
GcClass* class_ = cast<GcClass>(t, hashMapFind GcClass* class_ = cast<GcClass>(t, hashMapFind
(t, cast<GcHashMap>(t, classLoaderMap(t, loader)), spec, byteArrayHash, byteArrayEqual)); (t, cast<GcHashMap>(t, loader->map()), spec, byteArrayHash, byteArrayEqual));
if (class_ == 0) { if (class_ == 0) {
PROTECT(t, class_); PROTECT(t, class_);
if (classLoaderParent(t, loader)) { if (loader->parent()) {
class_ = resolveSystemClass class_ = resolveSystemClass
(t, classLoaderParent(t, loader), spec, false); (t, loader->parent(), spec, false);
if (class_) { if (class_) {
return class_; return class_;
} }
@ -4412,7 +4412,7 @@ resolveSystemClass(Thread* t, object loader, object spec, bool throw_,
7); 7);
System::Region* region = static_cast<Finder*> System::Region* region = static_cast<Finder*>
(systemClassLoaderFinder(t, loader))->find (loader->as<GcSystemClassLoader>(t)->finder())->find
(RUNTIME_ARRAY_BODY(file)); (RUNTIME_ARRAY_BODY(file));
if (region) { if (region) {
@ -4449,7 +4449,7 @@ resolveSystemClass(Thread* t, object loader, object spec, bool throw_,
} }
{ const char* source = static_cast<Finder*> { const char* source = static_cast<Finder*>
(systemClassLoaderFinder(t, loader))->sourceUrl (loader->as<GcSystemClassLoader>(t)->finder())->sourceUrl
(RUNTIME_ARRAY_BODY(file)); (RUNTIME_ARRAY_BODY(file));
if (source) { if (source) {
@ -4476,7 +4476,7 @@ resolveSystemClass(Thread* t, object loader, object spec, bool throw_,
} }
if (class_) { if (class_) {
hashMapInsert(t, cast<GcHashMap>(t, classLoaderMap(t, loader)), spec, reinterpret_cast<object>(class_), byteArrayHash); hashMapInsert(t, cast<GcHashMap>(t, loader->map()), spec, reinterpret_cast<object>(class_), byteArrayHash);
updatePackageMap(t, class_); updatePackageMap(t, class_);
} else if (throw_) { } else if (throw_) {
@ -4488,19 +4488,19 @@ resolveSystemClass(Thread* t, object loader, object spec, bool throw_,
} }
GcClass* GcClass*
findLoadedClass(Thread* t, object loader, object spec) findLoadedClass(Thread* t, GcClassLoader* loader, object spec)
{ {
PROTECT(t, loader); PROTECT(t, loader);
PROTECT(t, spec); PROTECT(t, spec);
ACQUIRE(t, t->m->classLock); ACQUIRE(t, t->m->classLock);
return classLoaderMap(t, loader) ? cast<GcClass>(t, hashMapFind return loader->map() ? cast<GcClass>(t, hashMapFind
(t, cast<GcHashMap>(t, classLoaderMap(t, loader)), spec, byteArrayHash, byteArrayEqual)) : 0; (t, cast<GcHashMap>(t, loader->map()), spec, byteArrayHash, byteArrayEqual)) : 0;
} }
GcClass* GcClass*
resolveClass(Thread* t, object loader, object spec, bool throw_, resolveClass(Thread* t, GcClassLoader* loader, object spec, bool throw_,
Gc::Type throwType) Gc::Type throwType)
{ {
if (objectClass(t, loader) == type(t, GcSystemClassLoader::Type)) { if (objectClass(t, loader) == type(t, GcSystemClassLoader::Type)) {
@ -4519,7 +4519,7 @@ resolveClass(Thread* t, object loader, object spec, bool throw_,
} else { } else {
if (root(t, Machine::LoadClassMethod) == 0) { if (root(t, Machine::LoadClassMethod) == 0) {
GcMethod* m = resolveMethod GcMethod* m = resolveMethod
(t, root(t, Machine::BootLoader), "java/lang/ClassLoader", (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/ClassLoader",
"loadClass", "(Ljava/lang/String;)Ljava/lang/Class;"); "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
if (m) { if (m) {
@ -4529,7 +4529,7 @@ resolveClass(Thread* t, object loader, object spec, bool throw_,
if (classLoaderClass->vmFlags() & BootstrapFlag) { if (classLoaderClass->vmFlags() & BootstrapFlag) {
resolveSystemClass resolveSystemClass
(t, root(t, Machine::BootLoader), (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
reinterpret_cast<object>(classLoaderClass->name())); reinterpret_cast<object>(classLoaderClass->name()));
} }
} }
@ -4740,7 +4740,7 @@ initClass(Thread* t, GcClass* c)
} }
GcClass* GcClass*
resolveObjectArrayClass(Thread* t, object loader, object elementClass) resolveObjectArrayClass(Thread* t, GcClassLoader* loader, object elementClass)
{ {
PROTECT(t, loader); PROTECT(t, loader);
PROTECT(t, elementClass); PROTECT(t, elementClass);
@ -4785,7 +4785,7 @@ object
makeObjectArray(Thread* t, GcClass* elementClass, unsigned count) makeObjectArray(Thread* t, GcClass* elementClass, unsigned count)
{ {
GcClass* arrayClass = resolveObjectArrayClass GcClass* arrayClass = resolveObjectArrayClass
(t, reinterpret_cast<object>(elementClass->loader()), reinterpret_cast<object>(elementClass)); (t, elementClass->loader(), reinterpret_cast<object>(elementClass));
PROTECT(t, arrayClass); PROTECT(t, arrayClass);
@ -5315,7 +5315,7 @@ getCaller(Thread* t, unsigned target, bool skipMethodInvoke)
} }
object object
defineClass(Thread* t, object loader, const uint8_t* buffer, unsigned length) defineClass(Thread* t, GcClassLoader* loader, const uint8_t* buffer, unsigned length)
{ {
PROTECT(t, loader); PROTECT(t, loader);
@ -5362,7 +5362,7 @@ populateMultiArray(Thread* t, object array, int32_t* counts,
byteArrayLength(t, spec) - 1); byteArrayLength(t, spec) - 1);
GcClass* class_ = resolveClass GcClass* class_ = resolveClass
(t, reinterpret_cast<object>(objectClass(t, array)->loader()), elementSpec); (t, objectClass(t, array)->loader(), elementSpec);
PROTECT(t, class_); PROTECT(t, class_);
for (int32_t i = 0; i < counts[index]; ++i) { for (int32_t i = 0; i < counts[index]; ++i) {

30
src/tools/bootimage-generator/main.cpp
View File

@ -311,7 +311,7 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
} resolver(&typeMaps); } resolver(&typeMaps);
Finder* finder = static_cast<Finder*> Finder* finder = static_cast<Finder*>
(systemClassLoaderFinder(t, root(t, Machine::BootLoader))); (cast<GcSystemClassLoader>(t, root(t, Machine::BootLoader))->finder());
for (Finder::Iterator it(finder); it.hasMore();) { for (Finder::Iterator it(finder); it.hasMore();) {
unsigned nameSize = 0; unsigned nameSize = 0;
@ -322,7 +322,7 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
{ {
// fprintf(stderr, "pass 1 %.*s\n", nameSize - 6, name); // fprintf(stderr, "pass 1 %.*s\n", nameSize - 6, name);
object c = reinterpret_cast<object>(resolveSystemClass object c = reinterpret_cast<object>(resolveSystemClass
(t, root(t, Machine::BootLoader), (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
makeByteArray(t, "%.*s", nameSize - 6, name), true)); makeByteArray(t, "%.*s", nameSize - 6, name), true));
PROTECT(t, c); PROTECT(t, c);
@ -607,7 +607,7 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
{ {
// fprintf(stderr, "pass 2 %.*s\n", nameSize - 6, name); // fprintf(stderr, "pass 2 %.*s\n", nameSize - 6, name);
object c = reinterpret_cast<object>(resolveSystemClass object c = reinterpret_cast<object>(resolveSystemClass
(t, root(t, Machine::BootLoader), (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
makeByteArray(t, "%.*s", nameSize - 6, name), true)); makeByteArray(t, "%.*s", nameSize - 6, name), true));
PROTECT(t, c); PROTECT(t, c);
@ -655,7 +655,7 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
if (objectClass(t, o) == type(t, GcReference::Type)) { if (objectClass(t, o) == type(t, GcReference::Type)) {
o = reinterpret_cast<object>(resolveClass o = reinterpret_cast<object>(resolveClass
(t, root(t, Machine::BootLoader), referenceName(t, o))); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), referenceName(t, o)));
set(t, reinterpret_cast<object>(addendum->pool()), set(t, reinterpret_cast<object>(addendum->pool()),
SingletonBody + (index * BytesPerWord), o); SingletonBody + (index * BytesPerWord), o);
@ -704,7 +704,7 @@ visitRoots(Thread* t, BootImage* image, HeapWalker* w, object constants)
{ {
Machine* m = t->m; Machine* m = t->m;
for (HashMapIterator it(t, cast<GcHashMap>(t, classLoaderMap(t, root(t, Machine::BootLoader)))); for (HashMapIterator it(t, cast<GcHashMap>(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader))->map()));
it.hasMore();) it.hasMore();)
{ {
w->visitRoot(it.next()->second()); w->visitRoot(it.next()->second());
@ -1523,28 +1523,28 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
// resolve primitive array classes in case they are needed at // resolve primitive array classes in case they are needed at
// runtime: // runtime:
{ object name = reinterpret_cast<object>(makeByteArray(t, "[B")); { object name = reinterpret_cast<object>(makeByteArray(t, "[B"));
resolveSystemClass(t, root(t, Machine::BootLoader), name, true); resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
name = reinterpret_cast<object>(makeByteArray(t, "[Z")); name = reinterpret_cast<object>(makeByteArray(t, "[Z"));
resolveSystemClass(t, root(t, Machine::BootLoader), name, true); resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
name = reinterpret_cast<object>(makeByteArray(t, "[S")); name = reinterpret_cast<object>(makeByteArray(t, "[S"));
resolveSystemClass(t, root(t, Machine::BootLoader), name, true); resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
name = reinterpret_cast<object>(makeByteArray(t, "[C")); name = reinterpret_cast<object>(makeByteArray(t, "[C"));
resolveSystemClass(t, root(t, Machine::BootLoader), name, true); resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
name = reinterpret_cast<object>(makeByteArray(t, "[I")); name = reinterpret_cast<object>(makeByteArray(t, "[I"));
resolveSystemClass(t, root(t, Machine::BootLoader), name, true); resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
name = reinterpret_cast<object>(makeByteArray(t, "[J")); name = reinterpret_cast<object>(makeByteArray(t, "[J"));
resolveSystemClass(t, root(t, Machine::BootLoader), name, true); resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
name = reinterpret_cast<object>(makeByteArray(t, "[F")); name = reinterpret_cast<object>(makeByteArray(t, "[F"));
resolveSystemClass(t, root(t, Machine::BootLoader), name, true); resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
name = reinterpret_cast<object>(makeByteArray(t, "[D")); name = reinterpret_cast<object>(makeByteArray(t, "[D"));
resolveSystemClass(t, root(t, Machine::BootLoader), name, true); resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
} }
} }
@ -1561,14 +1561,14 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
updateConstants(t, constants, heapWalker->map()); updateConstants(t, constants, heapWalker->map());
image->bootClassCount = hashMapSize image->bootClassCount = hashMapSize
(t, classLoaderMap(t, root(t, Machine::BootLoader))); (t, cast<GcClassLoader>(t, root(t, Machine::BootLoader))->map());
unsigned* bootClassTable = static_cast<unsigned*> unsigned* bootClassTable = static_cast<unsigned*>
(t->m->heap->allocate(image->bootClassCount * sizeof(unsigned))); (t->m->heap->allocate(image->bootClassCount * sizeof(unsigned)));
{ unsigned i = 0; { unsigned i = 0;
for (HashMapIterator it for (HashMapIterator it
(t, cast<GcHashMap>(t, classLoaderMap(t, root(t, Machine::BootLoader)))); (t, cast<GcHashMap>(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader))->map()));
it.hasMore();) it.hasMore();)
{ {
bootClassTable[i++] = targetVW bootClassTable[i++] = targetVW