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

formalize Machine::roots in types.def

Browse Source
This commit is contained in:
Joshua Warner 2014-06-29 19:44:41 -06:00
parent 75f2dd013c
commit 052f2498aa
12 changed files with 436 additions and 372 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -642,7 +642,7 @@ getFinder(Thread* t, const char* name, unsigned nameLength)
{
ACQUIRE(t, t->m->referenceLock);
for (GcFinder* p = cast<GcFinder>(t, root(t, Machine::VirtualFileFinders));
for (GcFinder* p = roots(t)->virtualFileFinders();
p; p = p->next())
{
if (p->name()->length() == nameLength
@ -669,9 +669,9 @@ getFinder(Thread* t, const char* name, unsigned nameLength)
if (data) {
Finder* f = makeFinder(t->m->system, t->m->heap, data, size);
GcFinder* finder = makeFinder
(t, f, n, cast<GcFinder>(t, root(t, Machine::VirtualFileFinders)));
(t, f, n, roots(t)->virtualFileFinders());
setRoot(t, Machine::VirtualFileFinders, reinterpret_cast<object>(finder));
set(t, roots(t), RootsVirtualFileFinders, finder);
return f;
}

107
src/avian/machine.h
View File

@ -1211,6 +1211,7 @@ class GcClassLoader;
class GcJreference;
class GcArray;
class GcThrowable;
class GcRoots;
class Machine {
public:
@ -1221,38 +1222,6 @@ class Machine {
ImmortalAllocation
};
enum Root {
BootLoader,
AppLoader,
BootstrapClassMap,
PackageMap,
FindLoadedClassMethod,
LoadClassMethod,
MonitorMap,
StringMap,
ByteArrayMap,
PoolMap,
ClassRuntimeDataTable,
MethodRuntimeDataTable,
JNIMethodTable,
JNIFieldTable,
ShutdownHooks,
FinalizerThread,
ObjectsToFinalize,
ObjectsToClean,
NullPointerException,
ArithmeticException,
ArrayIndexOutOfBoundsException,
OutOfMemoryError,
Shutdown,
VirtualFileFinders,
VirtualFiles,
ArrayInterfaceTable,
ThreadTerminated
};
static const unsigned RootCount = ThreadTerminated + 1;
Machine(System* system, Heap* heap, Finder* bootFinder, Finder* appFinder,
Processor* processor, Classpath* classpath, const char** properties,
unsigned propertyCount, const char** arguments,
@ -1296,7 +1265,7 @@ class Machine {
FILE* errorLog;
BootImage* bootimage;
GcArray* types;
GcArray* roots;
GcRoots* roots;
GcFinalizer* finalizers;
GcFinalizer* tenuredFinalizers;
GcFinalizer* finalizeQueue;
@ -1340,8 +1309,8 @@ run(Thread* t, uint64_t (*function)(Thread*, uintptr_t*),
void
checkDaemon(Thread* t);
object&
root(Thread* t, Machine::Root root);
GcRoots*
roots(Thread* t);
extern "C" uint64_t
vmRun(uint64_t (*function)(Thread*, uintptr_t*), uintptr_t* arguments,
@ -1524,17 +1493,7 @@ class Thread {
t->systemThread = st;
}
virtual void run() {
enterActiveState(t);
vm::run(t, runThread, 0);
if (t->exception and reinterpret_cast<object>(t->exception) != root(t, Machine::Shutdown)) {
printTrace(t, t->exception);
}
t->exit();
}
virtual void run();
virtual bool interrupted();
@ -2011,6 +1970,18 @@ arrayBodyUnsafe(Thread*, GcArray* a, unsigned index)
return a->body()[index];
}
inline void Thread::Runnable::run() {
enterActiveState(t);
vm::run(t, runThread, 0);
if (t->exception and t->exception != roots(t)->shutdownInProgress()) {
printTrace(t, t->exception);
}
t->exit();
}
inline bool Thread::Runnable::interrupted() {
return t->javaThread and t->javaThread->interrupted();
}
@ -2194,16 +2165,10 @@ attachThread(Machine* m, bool daemon)
}
}
inline object&
root(Thread* t, Machine::Root root)
inline GcRoots*
roots(Thread* t)
{
return t->m->roots->body()[root];
}
inline void
setRoot(Thread* t, Machine::Root root, object value)
{
set(t, reinterpret_cast<object>(t->m->roots), ArrayBody + (root * BytesPerWord), value);
return t->m->roots;
}
inline GcClass*
@ -3392,7 +3357,7 @@ wait(Thread* t, object o, int64_t milliseconds)
t->m->classpath->clearInterrupted(t);
throwNew(t, GcInterruptedException::Type);
} else {
throw_(t, cast<GcThrowable>(t, root(t, Machine::Shutdown)));
throw_(t, roots(t)->shutdownInProgress());
}
}
} else {
@ -3471,7 +3436,7 @@ inline bool
exceptionMatch(Thread* t, GcClass* type, GcThrowable* exception)
{
return type == 0
or (reinterpret_cast<object>(exception) != root(t, Machine::Shutdown)
or (exception != roots(t)->shutdownInProgress()
and instanceOf(t, type, reinterpret_cast<object>(t->exception)));
}
@ -3847,7 +3812,9 @@ inline GcClassRuntimeData*
getClassRuntimeDataIfExists(Thread* t, GcClass* c)
{
if (c->runtimeDataIndex()) {
return cast<GcClassRuntimeData>(t, cast<GcVector>(t, root(t, Machine::ClassRuntimeDataTable))->body()[c->runtimeDataIndex() - 1]);
return cast<GcClassRuntimeData>(
t,
roots(t)->classRuntimeDataTable()->body()[c->runtimeDataIndex() - 1]);
} else {
return 0;
}
@ -3864,16 +3831,20 @@ getClassRuntimeData(Thread* t, GcClass* c)
if (c->runtimeDataIndex() == 0) {
object runtimeData = reinterpret_cast<object>(makeClassRuntimeData(t, 0, 0, 0, 0));
setRoot(t, Machine::ClassRuntimeDataTable, reinterpret_cast<object>(vectorAppend
(t, cast<GcVector>(t, root(t, Machine::ClassRuntimeDataTable)), runtimeData)));
{
GcVector* v
= vectorAppend(t, roots(t)->classRuntimeDataTable(), runtimeData);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsClassRuntimeDataTable, v);
}
c->runtimeDataIndex() = cast<GcVector>(t, root(t, Machine::ClassRuntimeDataTable))->size();
c->runtimeDataIndex() = roots(t)->classRuntimeDataTable()->size();
}
}
return cast<GcClassRuntimeData>(
t,
cast<GcVector>(t, root(t, Machine::ClassRuntimeDataTable))
roots(t)->classRuntimeDataTable()
->body()[c->runtimeDataIndex() - 1]);
}
@ -3892,18 +3863,22 @@ getMethodRuntimeData(Thread* t, GcMethod* method)
if (method->runtimeDataIndex() == 0) {
object runtimeData = reinterpret_cast<object>(makeMethodRuntimeData(t, 0));
setRoot(t, Machine::MethodRuntimeDataTable, reinterpret_cast<object>(vectorAppend
(t, cast<GcVector>(t, root(t, Machine::MethodRuntimeDataTable)), runtimeData)));
{
GcVector* v
= vectorAppend(t, roots(t)->methodRuntimeDataTable(), runtimeData);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsMethodRuntimeDataTable, v);
}
storeStoreMemoryBarrier();
method->runtimeDataIndex() = cast<GcVector>(t, root(t, Machine::MethodRuntimeDataTable))->size();
method->runtimeDataIndex() = roots(t)->methodRuntimeDataTable()->size();
}
}
return cast<GcMethodRuntimeData>(
t,
cast<GcVector>(t, root(t, Machine::MethodRuntimeDataTable))
roots(t)->methodRuntimeDataTable()
->body()[method->runtimeDataIndex() - 1]);
}

2
src/builtin.cpp
View File

@ -255,7 +255,7 @@ Avian_avian_SystemClassLoader_getPackageSource
GcByteArray* key = makeByteArray(t, RUNTIME_ARRAY_BODY(chars));
GcByteArray* array = cast<GcByteArray>(t, hashMapFind
(t, cast<GcHashMap>(t, root(t, Machine::PackageMap)), reinterpret_cast<object>(key), byteArrayHash, byteArrayEqual));
(t, roots(t)->packageMap(), reinterpret_cast<object>(key), byteArrayHash, byteArrayEqual));
if (array) {
return reinterpret_cast<uintptr_t>(makeLocalReference(

70
src/classpath-android.cpp
View File

@ -81,7 +81,7 @@ finalizeAllEnqueued(Thread*, object, uintptr_t*)
int64_t JNICALL
appLoader(Thread* t, object, uintptr_t*)
{
return reinterpret_cast<uintptr_t>(root(t, Machine::AppLoader));
return reinterpret_cast<uintptr_t>(roots(t)->appLoader());
}
int64_t JNICALL
@ -177,7 +177,7 @@ void initVmThread(Thread* t, GcThread* thread, unsigned offset)
if (fieldAtOffset<object>(thread, offset) == 0) {
GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/VMThread");
(t, roots(t)->bootLoader(), "java/lang/VMThread");
PROTECT(t, c);
object instance = makeNew(t, c);
@ -213,7 +213,7 @@ translateStackTrace(Thread* t, object raw)
object array = makeObjectArray
(t, resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/StackTraceElement"),
(t, roots(t)->bootLoader(), "java/lang/StackTraceElement"),
objectArrayLength(t, raw));
PROTECT(t, array);
@ -278,7 +278,7 @@ class MyClasspath : public Classpath {
group = parent->javaThread->group();
} else {
resolveSystemClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
(t, roots(t)->bootLoader(),
type(t, GcThreadGroup::Type)->name(), false);
group = cast<GcThreadGroup>(t, makeNew(t, type(t, GcThreadGroup::Type)));
@ -290,7 +290,7 @@ class MyClasspath : public Classpath {
}
resolveSystemClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
(t, roots(t)->bootLoader(),
type(t, GcThread::Type)->name(), false);
GcThread* thread = cast<GcThread>(t, makeNew(t, type(t, GcThread::Type)));
@ -303,7 +303,7 @@ class MyClasspath : public Classpath {
t->m->processor->invoke
(t, constructor, reinterpret_cast<object>(thread), group, 0, NormalPriority, false);
set(t, reinterpret_cast<object>(thread), ThreadContextClassLoader, root(t, Machine::AppLoader));
set(t, thread, ThreadContextClassLoader, roots(t)->appLoader());
initVmThread(t, thread);
@ -392,7 +392,7 @@ class MyClasspath : public Classpath {
initVmThread(t, t->javaThread, offset);
GcMethod* method = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/Thread", "run", "()V");
(t, roots(t)->bootLoader(), "java/lang/Thread", "run", "()V");
t->m->processor->invoke(t, method, reinterpret_cast<object>(t->javaThread));
}
@ -407,7 +407,7 @@ class MyClasspath : public Classpath {
interceptMethods(Thread* t, bool updateRuntimeData)
{
{ GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/Runtime", false);
(t, roots(t)->bootLoader(), "java/lang/Runtime", false);
if (c) {
PROTECT(t, c);
@ -419,7 +419,7 @@ class MyClasspath : public Classpath {
}
{ GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/ref/FinalizerReference",
(t, roots(t)->bootLoader(), "java/lang/ref/FinalizerReference",
false);
if (c) {
@ -431,7 +431,7 @@ class MyClasspath : public Classpath {
}
{ GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/ClassLoader", false);
(t, roots(t)->bootLoader(), "java/lang/ClassLoader", false);
if (c) {
PROTECT(t, c);
@ -446,7 +446,7 @@ class MyClasspath : public Classpath {
}
{ GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "libcore/util/ZoneInfoDB", false);
(t, roots(t)->bootLoader(), "libcore/util/ZoneInfoDB", false);
if (c) {
PROTECT(t, c);
@ -457,7 +457,7 @@ class MyClasspath : public Classpath {
}
{ GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "libcore/io/MemoryMappedFile",
(t, roots(t)->bootLoader(), "libcore/io/MemoryMappedFile",
false);
if (c) {
@ -504,7 +504,7 @@ class MyClasspath : public Classpath {
boot(Thread* t)
{
GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/ClassLoader");
(t, roots(t)->bootLoader(), "java/lang/ClassLoader");
PROTECT(t, c);
GcMethod* constructor = resolveMethod
@ -512,11 +512,11 @@ class MyClasspath : public Classpath {
PROTECT(t, constructor);
t->m->processor->invoke
(t, constructor, root(t, Machine::BootLoader), 0, true);
(t, constructor, reinterpret_cast<object>(roots(t)->bootLoader()), 0, true);
t->m->processor->invoke
(t, constructor, root(t, Machine::AppLoader),
root(t, Machine::BootLoader), false);
(t, constructor, reinterpret_cast<object>(roots(t)->appLoader()),
roots(t)->bootLoader(), false);
}
virtual const char*
@ -529,7 +529,7 @@ class MyClasspath : public Classpath {
makeDirectByteBuffer(Thread* t, void* p, jlong capacity)
{
GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/nio/DirectByteBuffer");
(t, roots(t)->bootLoader(), "java/nio/DirectByteBuffer");
PROTECT(t, c);
object instance = makeNew(t, c);
@ -602,7 +602,7 @@ int64_t JNICALL
mapData(Thread* t, object, uintptr_t*)
{
GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "libcore/io/MemoryMappedFile");
(t, roots(t)->bootLoader(), "libcore/io/MemoryMappedFile");
PROTECT(t, c);
object instance = makeNew(t, c);
@ -1219,7 +1219,7 @@ Avian_java_lang_Class_classForName
PROTECT(t, loader);
GcMethod* method = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "forName",
(t, roots(t)->bootLoader(), "avian/Classes", "forName",
"(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;");
return reinterpret_cast<uintptr_t>
@ -1238,7 +1238,7 @@ Avian_java_lang_Class_getDeclaredField
PROTECT(t, name);
GcMethod* method = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "findField",
(t, roots(t)->bootLoader(), "avian/Classes", "findField",
"(Lavian/VMClass;Ljava/lang/String;)I");
int index = cast<GcInt>
@ -1266,7 +1266,7 @@ Avian_java_lang_Class_getDeclaredConstructorOrMethod
PROTECT(t, parameterTypes);
GcMethod* method = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "findMethod",
(t, roots(t)->bootLoader(), "avian/Classes", "findMethod",
"(Lavian/VMClass;Ljava/lang/String;[Ljava/lang/Class;)I");
int index = cast<GcInt>
@ -1321,14 +1321,14 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_dalvik_system_VMRuntime_bootClassPath
(Thread* t, object, uintptr_t*)
{
return reinterpret_cast<uintptr_t>(root(t, Machine::BootLoader));
return reinterpret_cast<uintptr_t>(roots(t)->bootLoader());
}
extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_dalvik_system_VMRuntime_classPath
(Thread* t, object, uintptr_t*)
{
return reinterpret_cast<uintptr_t>(root(t, Machine::AppLoader));
return reinterpret_cast<uintptr_t>(roots(t)->appLoader());
}
extern "C" AVIAN_EXPORT int64_t JNICALL
@ -1823,7 +1823,7 @@ Avian_java_lang_Class_getDeclaredMethods
bool publicOnly = arguments[1];
GcMethod* get = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "getMethods",
(t, roots(t)->bootLoader(), "avian/Classes", "getMethods",
"(Lavian/VMClass;Z)[Ljava/lang/reflect/Method;");
return reinterpret_cast<uintptr_t>
@ -1840,7 +1840,7 @@ Avian_java_lang_Class_getDeclaredFields
bool publicOnly = arguments[1];
GcMethod* get = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "getFields",
(t, roots(t)->bootLoader(), "avian/Classes", "getFields",
"(Lavian/VMClass;Z)[Ljava/lang/reflect/Field;");
return reinterpret_cast<uintptr_t>
@ -1915,7 +1915,7 @@ Avian_java_lang_reflect_Method_getAnnotation
PROTECT(t, table);
GcMethod* get = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "getAnnotation",
(t, roots(t)->bootLoader(), "avian/Classes", "getAnnotation",
"(Ljava/lang/ClassLoader;[Ljava/lang/Object;)"
"Ljava/lang/annotation/Annotation;");
@ -1948,12 +1948,12 @@ Avian_java_lang_reflect_Method_getDeclaredAnnotations
object array = makeObjectArray
(t, resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/annotation/Annotation"),
(t, roots(t)->bootLoader(), "java/lang/annotation/Annotation"),
objectArrayLength(t, table));
PROTECT(t, array);
GcMethod* get = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "getAnnotation",
(t, roots(t)->bootLoader(), "avian/Classes", "getAnnotation",
"(Ljava/lang/ClassLoader;[Ljava/lang/Object;)"
"Ljava/lang/annotation/Annotation;");
PROTECT(t, get);
@ -1973,7 +1973,7 @@ Avian_java_lang_reflect_Method_getDeclaredAnnotations
return reinterpret_cast<uintptr_t>
(makeObjectArray
(t, resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/annotation/Annotation"),
(t, roots(t)->bootLoader(), "java/lang/annotation/Annotation"),
0));
}
@ -1997,13 +1997,13 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
object array
= makeObjectArray(t,
resolveClass(t,
cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
roots(t)->bootLoader(),
"java/lang/annotation/Annotation"),
objectArrayLength(t, table));
PROTECT(t, array);
GcMethod* get = resolveMethod(t,
cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
roots(t)->bootLoader(),
"avian/Classes",
"getAnnotation",
"(Ljava/lang/ClassLoader;[Ljava/lang/Object;)"
@ -2028,7 +2028,7 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
return reinterpret_cast<uintptr_t>(makeObjectArray(
t,
resolveClass(
t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/annotation/Annotation"),
t, roots(t)->bootLoader(), "java/lang/annotation/Annotation"),
0));
}
@ -2043,7 +2043,7 @@ Avian_java_lang_reflect_Method_getDefaultValue
GcMethodAddendum* addendum = method->addendum();
if (addendum) {
GcMethod* get = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes",
(t, roots(t)->bootLoader(), "avian/Classes",
"getAnnotationDefaultValue",
"(Ljava/lang/ClassLoader;Lavian/MethodAddendum;)"
"Ljava/lang/Object;");
@ -2192,7 +2192,7 @@ Avian_java_lang_reflect_Field_getAnnotation
PROTECT(t, table);
GcMethod* get = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "getAnnotation",
(t, roots(t)->bootLoader(), "avian/Classes", "getAnnotation",
"(Ljava/lang/ClassLoader;[Ljava/lang/Object;)"
"Ljava/lang/annotation/Annotation;");
@ -2473,7 +2473,7 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
Avian_libcore_io_Posix_uname(Thread* t, object, uintptr_t*)
{
GcClass* c = resolveClass
(t, root(t, Machine::BootLoader), "libcore/io/StructUtsname");
(t, roots(t)->bootLoader(), "libcore/io/StructUtsname");
PROTECT(t, c);
object instance = makeNew(t, c);

14
src/classpath-avian.cpp
View File

@ -53,7 +53,7 @@ class MyClasspath : public Classpath {
return vm::makeThread
(t, 0, 0, 0, 0, 0, NewState, NormalPriority, 0, 0, 0,
cast<GcClassLoader>(t, root(t, Machine::AppLoader)), 0, 0, group, 0);
roots(t)->appLoader(), 0, 0, group, 0);
}
virtual object
@ -97,7 +97,7 @@ class MyClasspath : public Classpath {
runThread(Thread* t)
{
GcMethod* method = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/Thread", "run",
(t, roots(t)->bootLoader(), "java/lang/Thread", "run",
"(Ljava/lang/Thread;)V");
t->m->processor->invoke(t, method, 0, t->javaThread);
@ -142,7 +142,7 @@ class MyClasspath : public Classpath {
makeDirectByteBuffer(Thread* t, void* p, jlong capacity)
{
GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/nio/DirectByteBuffer");
(t, roots(t)->bootLoader(), "java/nio/DirectByteBuffer");
PROTECT(t, c);
object instance = makeNew(t, c);
@ -618,8 +618,8 @@ Avian_java_lang_Runtime_addShutdownHook
ACQUIRE(t, t->m->shutdownLock);
setRoot(t, Machine::ShutdownHooks,
reinterpret_cast<object>(makePair(t, hook, root(t, Machine::ShutdownHooks))));
GcPair* p = makePair(t, hook, reinterpret_cast<object>(roots(t)->shutdownHooks()));
set(t, roots(t), RootsShutdownHooks, p);
}
extern "C" AVIAN_EXPORT int64_t JNICALL
@ -793,7 +793,7 @@ Avian_avian_Classes_makeMethod
PROTECT(t, method);
GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/reflect/Method");
(t, roots(t)->bootLoader(), "java/lang/reflect/Method");
PROTECT(t, c);
object instance = makeNew(t, c);
@ -807,7 +807,7 @@ Avian_avian_Classes_makeMethod
object oldInstance = instance;
c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/reflect/Constructor");
(t, roots(t)->bootLoader(), "java/lang/reflect/Constructor");
object instance = makeNew(t, c);

116
src/classpath-openjdk.cpp
View File

@ -560,7 +560,7 @@ class MyClasspath : public Classpath {
thread->group() = group;
// TODO: use set / write barrier?
thread->contextClassLoader() = cast<GcClassLoader>(t, root(t, Machine::AppLoader));
thread->contextClassLoader() = roots(t)->appLoader();
PROTECT(t, thread);
@ -649,14 +649,14 @@ class MyClasspath : public Classpath {
t->exception = 0;
t->m->processor->invoke
(t, cast<GcMethod>(t, root(t, Machine::ThreadTerminated)),
(t, cast<GcMethod>(t, roots(t)->threadTerminated()),
reinterpret_cast<object>(t->javaThread->group()), t->javaThread);
t->exception = e;
});
GcMethod* method = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/Thread", "run", "()V");
(t, roots(t)->bootLoader(), "java/lang/Thread", "run", "()V");
t->m->processor->invoke(t, method, reinterpret_cast<object>(t->javaThread));
}
@ -703,12 +703,14 @@ class MyClasspath : public Classpath {
{
globalMachine = t->m;
resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
resolveSystemClass(t, roots(t)->bootLoader(),
type(t, GcClassLoader::Type)->name());
setRoot(t, Machine::ThreadTerminated, reinterpret_cast<object>(resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/ThreadGroup",
"threadTerminated", "(Ljava/lang/Thread;)V")));
GcMethod* method = resolveMethod
(t, roots(t)->bootLoader(), "java/lang/ThreadGroup",
"threadTerminated", "(Ljava/lang/Thread;)V");
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsThreadTerminated, method);
#ifdef AVIAN_OPENJDK_SRC
interceptFileOperations(t, true);
@ -721,12 +723,12 @@ class MyClasspath : public Classpath {
(t, type(t, GcClassLoader::Type), "assertionLock",
"Ljava/lang/Object;");
set(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), assertionLock->offset(),
cast<GcClassLoader>(t, root(t, Machine::BootLoader)));
set(t, roots(t)->bootLoader(), assertionLock->offset(),
roots(t)->bootLoader());
}
{ GcClass* class_ = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/util/Properties", true,
(t, roots(t)->bootLoader(), "java/util/Properties", true,
GcNoClassDefFoundError::Type);
PROTECT(t, class_);
@ -740,7 +742,7 @@ class MyClasspath : public Classpath {
t->m->processor->invoke(t, constructor, instance);
t->m->processor->invoke
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/System",
(t, roots(t)->bootLoader(), "java/lang/System",
"setProperties", "(Ljava/util/Properties;)V", 0, instance);
}
@ -750,11 +752,11 @@ class MyClasspath : public Classpath {
PROTECT(t, constructor);
t->m->processor->invoke(t, constructor, root(t, Machine::BootLoader), 0);
t->m->processor->invoke(t, constructor, reinterpret_cast<object>(roots(t)->bootLoader()), 0);
t->m->processor->invoke
(t, constructor, root(t, Machine::AppLoader),
cast<GcClassLoader>(t, root(t, Machine::BootLoader)));
(t, constructor, reinterpret_cast<object>(roots(t)->appLoader()),
roots(t)->bootLoader());
}
{ GcField* scl = resolveField
@ -766,23 +768,23 @@ class MyClasspath : public Classpath {
GcField* sclSet = resolveField
(t, type(t, GcClassLoader::Type), "sclSet", "Z");
set(t, reinterpret_cast<object>(type(t, GcClassLoader::Type)->staticTable()),
scl->offset(), root(t, Machine::AppLoader));
set(t, type(t, GcClassLoader::Type)->staticTable(),
scl->offset(), roots(t)->appLoader());
fieldAtOffset<uint8_t>(type(t, GcClassLoader::Type)->staticTable(),
sclSet->offset()) = true;
}
t->m->processor->invoke
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/System",
(t, roots(t)->bootLoader(), "java/lang/System",
"initializeSystemClass", "()V", 0);
t->m->processor->invoke
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "sun/misc/Launcher",
(t, roots(t)->bootLoader(), "sun/misc/Launcher",
"getLauncher", "()Lsun/misc/Launcher;", 0);
set(t, reinterpret_cast<object>(t->javaThread), ThreadContextClassLoader,
root(t, Machine::AppLoader));
set(t, t->javaThread, ThreadContextClassLoader,
roots(t)->appLoader());
}
virtual const char*
@ -795,7 +797,7 @@ class MyClasspath : public Classpath {
makeDirectByteBuffer(Thread* t, void* p, jlong capacity)
{
GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/nio/DirectByteBuffer");
(t, roots(t)->bootLoader(), "java/nio/DirectByteBuffer");
PROTECT(t, c);
object instance = makeNew(t, c);
@ -884,7 +886,7 @@ class MyClasspath : public Classpath {
shutDown(Thread* t)
{
GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/Shutdown", false);
(t, roots(t)->bootLoader(), "java/lang/Shutdown", false);
if (c) {
GcMethod* m = findMethodOrNull(t, c, "shutdown", "()V");
@ -1168,24 +1170,24 @@ openFile(Thread* t, object method, uintptr_t* arguments)
ACQUIRE(t, t->m->referenceLock);
int index = -1;
unsigned oldLength = root(t, Machine::VirtualFiles)
? arrayLength(t, root(t, Machine::VirtualFiles)) : 0;
unsigned oldLength = roots(t)->virtualFiles()
? arrayLength(t, roots(t)->virtualFiles()) : 0;
for (unsigned i = 0; i < oldLength; ++i) {
if (arrayBody(t, root(t, Machine::VirtualFiles), i) == 0) {
if (arrayBody(t, roots(t)->virtualFiles(), i) == 0) {
index = i;
break;
}
}
if (index == -1) {
object newArray = growArray(t, root(t, Machine::VirtualFiles));
object newArray = growArray(t, roots(t)->virtualFiles());
setRoot(t, Machine::VirtualFiles, newArray);
index = oldLength;
}
object region = makeRegion(t, r, 0);
set(t, root(t, Machine::VirtualFiles), ArrayBody + (index * BytesPerWord),
set(t, roots(t)->virtualFiles(), ArrayBody + (index * BytesPerWord),
region);
fieldAtOffset<int32_t>
@ -1215,7 +1217,7 @@ readByteFromFile(Thread* t, object method, uintptr_t* arguments)
ACQUIRE(t, t->m->referenceLock);
object region = arrayBody
(t, root(t, Machine::VirtualFiles), fd - VirtualFileBase);
(t, roots(t)->virtualFiles(), fd - VirtualFileBase);
if (region) {
System::Region* r = static_cast<System::Region*>
@ -1258,7 +1260,7 @@ readBytesFromFile(Thread* t, object method, uintptr_t* arguments)
ACQUIRE(t, t->m->referenceLock);
object region = arrayBody
(t, root(t, Machine::VirtualFiles), fd - VirtualFileBase);
(t, roots(t)->virtualFiles(), fd - VirtualFileBase);
if (region) {
System::Region* r = static_cast<System::Region*>
@ -1308,7 +1310,7 @@ skipBytesInFile(Thread* t, object method, uintptr_t* arguments)
ACQUIRE(t, t->m->referenceLock);
object region = arrayBody
(t, root(t, Machine::VirtualFiles), fd - VirtualFileBase);
(t, roots(t)->virtualFiles(), fd - VirtualFileBase);
if (region) {
System::Region* r = static_cast<System::Region*>
@ -1349,7 +1351,7 @@ availableBytesInFile(Thread* t, object method, uintptr_t* arguments)
ACQUIRE(t, t->m->referenceLock);
object region = arrayBody
(t, root(t, Machine::VirtualFiles), fd - VirtualFileBase);
(t, roots(t)->virtualFiles(), fd - VirtualFileBase);
if (region) {
return static_cast<System::Region*>(regionRegion(t, region))->length()
@ -1382,13 +1384,13 @@ closeFile(Thread* t, object method, uintptr_t* arguments)
ACQUIRE(t, t->m->referenceLock);
int index = fd - VirtualFileBase;
object region = arrayBody(t, root(t, Machine::VirtualFiles), index);
object region = arrayBody(t, roots(t)->virtualFiles(), index);
if (region) {
static_cast<System::Region*>(regionRegion(t, region))->dispose();
}
set(t, root(t, Machine::VirtualFiles), ArrayBody + (index * BytesPerWord),
set(t, roots(t)->virtualFiles(), ArrayBody + (index * BytesPerWord),
0);
} else {
t->m->processor->invoke
@ -1848,7 +1850,7 @@ getBootstrapResource(Thread* t, object, uintptr_t* arguments)
if (m) {
return reinterpret_cast<int64_t>
(t->m->processor->invoke(t, m, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name));
(t->m->processor->invoke(t, m, roots(t)->bootLoader(), name));
} else {
return 0;
}
@ -1866,7 +1868,7 @@ getBootstrapResources(Thread* t, object, uintptr_t* arguments)
if (m) {
return reinterpret_cast<int64_t>
(t->m->processor->invoke(t, m, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name));
(t->m->processor->invoke(t, m, roots(t)->bootLoader(), name));
} else {
return 0;
}
@ -1944,7 +1946,7 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
{ object fileClass = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/io/File", false);
(t, roots(t)->bootLoader(), "java/io/File", false);
if (fileClass) {
object filePathField = findFieldInClass2
@ -1957,7 +1959,7 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
}
{ object fileDescriptorClass = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/io/FileDescriptor", false);
(t, roots(t)->bootLoader(), "java/io/FileDescriptor", false);
if (fileDescriptorClass) {
object fileDescriptorFdField = findFieldInClass2
@ -1970,7 +1972,7 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
}
{ object fileInputStreamClass = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/io/FileInputStream", false);
(t, roots(t)->bootLoader(), "java/io/FileInputStream", false);
if (fileInputStreamClass) {
PROTECT(t, fileInputStreamClass);
@ -2008,7 +2010,7 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
}
{ object zipFileClass = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/util/zip/ZipFile", false);
(t, roots(t)->bootLoader(), "java/util/zip/ZipFile", false);
if (zipFileClass) {
PROTECT(t, zipFileClass);
@ -2061,7 +2063,7 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
}
{ object jarFileClass = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/util/jar/JarFile", false);
(t, roots(t)->bootLoader(), "java/util/jar/JarFile", false);
if (jarFileClass) {
intercept(t, jarFileClass, "getMetaInfEntryNames",
@ -2080,7 +2082,7 @@ interceptFileOperations(Thread* t, bool updateRuntimeData)
#endif
object fsClass = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), fsClassName, false);
(t, roots(t)->bootLoader(), fsClassName, false);
if (fsClass) {
PROTECT(t, fsClass);
@ -2550,7 +2552,7 @@ Avian_sun_misc_Perf_createLong
return reinterpret_cast<int64_t>
(t->m->processor->invoke
(t, resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/nio/ByteBuffer", "allocate",
(t, roots(t)->bootLoader(), "java/nio/ByteBuffer", "allocate",
"(I)Ljava/nio/ByteBuffer;"), 0, 8));
}
@ -2956,7 +2958,7 @@ jvmInitProperties(Thread* t, uintptr_t* arguments)
jobject properties = reinterpret_cast<jobject>(arguments[0]);
GcMethod* method = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/util/Properties", "setProperty",
(t, roots(t)->bootLoader(), "java/util/Properties", "setProperty",
"(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;");
PROTECT(t, method);
@ -3024,7 +3026,7 @@ jvmInitProperties(Thread* t, uintptr_t* arguments)
local::setProperty
(t, method, *properties, "sun.boot.class.path",
static_cast<Finder*>
(cast<GcSystemClassLoader>(t, root(t, Machine::BootLoader))->finder())->path());
(roots(t)->bootLoader()->as<GcSystemClassLoader>(t)->finder())->path());
local::setProperty(t, method, *properties, "file.encoding", "UTF-8");
#ifdef ARCH_x86_32
@ -3526,7 +3528,7 @@ jvmGetSystemPackage(Thread* t, uintptr_t* arguments)
object key = reinterpret_cast<object>(makeByteArray(t, RUNTIME_ARRAY_BODY(chars)));
GcByteArray* array = cast<GcByteArray>(t, hashMapFind
(t, cast<GcHashMap>(t, root(t, Machine::PackageMap)), key, byteArrayHash, byteArrayEqual));
(t, roots(t)->packageMap(), key, byteArrayHash, byteArrayEqual));
if (array) {
return reinterpret_cast<uintptr_t>
@ -3554,7 +3556,7 @@ jvmGetSystemPackages(Thread* t, uintptr_t*)
makeObjectArray(
t,
resolveClass(
t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/Package"),
t, roots(t)->bootLoader(), "java/lang/Package"),
0)));
}
@ -3586,7 +3588,7 @@ EXPORT(JVM_LatestUserDefinedLoader)(Thread* t)
virtual bool visit(Processor::StackWalker* walker) {
GcClassLoader* loader = walker->method()->class_()->loader();
if (loader
and loader != cast<GcClassLoader>(t, root(t, Machine::BootLoader))
and loader != roots(t)->bootLoader()
and strcmp
(objectClass(t, loader)->name()->body().begin(),
reinterpret_cast<const int8_t*>
@ -3865,7 +3867,7 @@ jvmResolveClass(Thread* t, uintptr_t* arguments)
jclass c = reinterpret_cast<jclass>(arguments[0]);
GcMethod* method = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "link",
(t, roots(t)->bootLoader(), "avian/Classes", "link",
"(Lavian/VMClass;)V");
t->m->processor->invoke(t, method, 0, (*c)->vmClass());
@ -3890,7 +3892,7 @@ jvmFindClassFromClassLoader(Thread* t, uintptr_t* arguments)
jboolean throwError = arguments[3];
GcClass* c = resolveClass
(t, cast<GcClassLoader>(t, loader ? *loader : root(t, Machine::BootLoader)), name, true,
(t, loader ? cast<GcClassLoader>(t, *loader) : roots(t)->bootLoader(), name, true,
throwError ? static_cast<Gc::Type>(GcNoClassDefFoundError::Type)
: static_cast<Gc::Type>(GcClassNotFoundException::Type));
@ -4046,7 +4048,7 @@ EXPORT(JVM_GetClassLoader)(Thread* t, jclass c)
GcClassLoader* loader = (*c)->vmClass()->loader();
if (loader == cast<GcClassLoader>(t, root(t, Machine::BootLoader))) {
if (loader == roots(t)->bootLoader()) {
// sun.misc.Unsafe.getUnsafe expects a null result if the class
// loader is the boot classloader and will throw a
// SecurityException otherwise.
@ -4058,7 +4060,7 @@ EXPORT(JVM_GetClassLoader)(Thread* t, jclass c)
{
return 0;
} else {
return makeLocalReference(t, root(t, Machine::BootLoader));
return makeLocalReference(t, reinterpret_cast<object>(roots(t)->bootLoader()));
}
} else {
return makeLocalReference(t, reinterpret_cast<object>(loader));
@ -4118,7 +4120,7 @@ jvmGetProtectionDomain(Thread* t, uintptr_t* arguments)
jclass c = reinterpret_cast<jclass>(arguments[0]);
GcMethod* method = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Classes", "getProtectionDomain",
(t, roots(t)->bootLoader(), "avian/Classes", "getProtectionDomain",
"(Lavian/VMClass;)Ljava/security/ProtectionDomain;");
return reinterpret_cast<uint64_t>
@ -4631,7 +4633,7 @@ maybeWrap(Thread* t, bool wrapException)
PROTECT(t, exception);
GcClass* paeClass = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
(t, roots(t)->bootLoader(),
"java/security/PrivilegedActionException");
PROTECT(t, paeClass);
@ -4658,7 +4660,7 @@ jvmDoPrivileged(Thread* t, uintptr_t* arguments)
// object:
GcClass* privilegedAction = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/security/PrivilegedAction");
(t, roots(t)->bootLoader(), "java/security/PrivilegedAction");
GcMethod* method;
if (instanceOf(t, privilegedAction, *action)) {
@ -4666,7 +4668,7 @@ jvmDoPrivileged(Thread* t, uintptr_t* arguments)
(t, privilegedAction, "run", "()Ljava/lang/Object;");
} else {
GcClass* privilegedExceptionAction = resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
(t, roots(t)->bootLoader(),
"java/security/PrivilegedExceptionAction");
method = resolveMethod
@ -5196,7 +5198,7 @@ getMemoryManagers(Thread* t, uintptr_t*)
t,
makeObjectArray(t,
resolveClass(t,
cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
roots(t)->bootLoader(),
"java/lang/management/MemoryManagerMXBean"),
0)));
}
@ -5214,7 +5216,7 @@ getMemoryPools(Thread* t, uintptr_t*)
t,
makeObjectArray(t,
resolveClass(t,
cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
roots(t)->bootLoader(),
"java/lang/management/MemoryPoolMXBean"),
0)));
}

69
src/compile.cpp
View File

@ -336,7 +336,7 @@ resolveTarget(MyThread* t, void* stack, GcMethod* method)
PROTECT(t, method);
PROTECT(t, class_);
resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), class_->name());
resolveSystemClass(t, roots(t)->bootLoader(), class_->name());
}
if (method->class_()->flags() & ACC_INTERFACE) {
@ -352,7 +352,7 @@ resolveTarget(MyThread* t, GcClass* class_, unsigned index)
if (class_->vmFlags() & BootstrapFlag) {
PROTECT(t, class_);
resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), class_->name());
resolveSystemClass(t, roots(t)->bootLoader(), class_->name());
}
return cast<GcMethod>(t, cast<GcArray>(t, class_->virtualTable())->body()[index]);
@ -2460,7 +2460,7 @@ throwArithmetic(MyThread* t)
} else {
// not enough memory available for a new exception and stack trace
// -- use a preallocated instance instead
throw_(t, cast<GcThrowable>(t, root(t, Machine::ArithmeticException)));
throw_(t, roots(t)->arithmeticException());
}
}
@ -2671,7 +2671,7 @@ throwArrayIndexOutOfBounds(MyThread* t)
} else {
// not enough memory available for a new exception and stack trace
// -- use a preallocated instance instead
throw_(t, cast<GcThrowable>(t, root(t, Machine::ArrayIndexOutOfBoundsException)));
throw_(t, roots(t)->arrayIndexOutOfBoundsException());
}
}
@ -7726,7 +7726,7 @@ callContinuation(MyThread* t, GcContinuation* continuation, object result,
PROTECT(t, nextContinuation);
GcMethod* method = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Continuations", "rewind",
(t, roots(t)->bootLoader(), "avian/Continuations", "rewind",
"(Ljava/lang/Runnable;Lavian/Callback;Ljava/lang/Object;"
"Ljava/lang/Throwable;)V");
@ -7786,7 +7786,7 @@ callWithCurrentContinuation(MyThread* t, object receiver)
if (root(t, ReceiveMethod) == 0) {
GcMethod* m = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Function", "call",
(t, roots(t)->bootLoader(), "avian/Function", "call",
"(Ljava/lang/Object;)Ljava/lang/Object;");
if (m) {
@ -7796,7 +7796,7 @@ callWithCurrentContinuation(MyThread* t, object receiver)
if (continuationClass->vmFlags() & BootstrapFlag) {
resolveSystemClass(
t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), continuationClass->name());
t, roots(t)->bootLoader(), continuationClass->name());
}
}
}
@ -7825,7 +7825,7 @@ dynamicWind(MyThread* t, object before, object thunk, object after)
if (root(t, WindMethod) == 0) {
GcMethod* method = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Continuations", "wind",
(t, roots(t)->bootLoader(), "avian/Continuations", "wind",
"(Ljava/lang/Runnable;Ljava/util/concurrent/Callable;"
"Ljava/lang/Runnable;)Lavian/Continuations$UnwindResult;");
@ -8032,7 +8032,7 @@ invoke(Thread* thread, GcMethod* method, ArgumentList* arguments)
compile(t, local::codeAllocator(static_cast<MyThread*>(t)), 0,
resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::AppLoader)),
(t, roots(t)->appLoader(),
"foo/ClassName",
"methodName",
"()V"));
@ -8113,8 +8113,9 @@ invoke(Thread* thread, GcMethod* method, ArgumentList* arguments)
class SignalHandler: public SignalRegistrar::Handler {
public:
SignalHandler(Gc::Type type, Machine::Root root, unsigned fixedSize):
m(0), type(type), root(root), fixedSize(fixedSize) { }
typedef GcThrowable*& (GcRoots::*ExceptionGetter)();
SignalHandler(Gc::Type type, ExceptionGetter exc, unsigned fixedSize):
m(0), type(type), exc(exc), fixedSize(fixedSize) { }
virtual bool handleSignal(void** ip, void** frame, void** stack,
void** thread)
@ -8137,7 +8138,7 @@ class SignalHandler: public SignalRegistrar::Handler {
} else {
// not enough memory available for a new exception and stack
// trace -- use a preallocated instance instead
t->exception = cast<GcThrowable>(t, vm::root(t, root));
t->exception = (vm::roots(t)->*exc)();
}
// printTrace(t, t->exception);
@ -8162,7 +8163,7 @@ class SignalHandler: public SignalRegistrar::Handler {
Machine* m;
Gc::Type type;
Machine::Root root;
ExceptionGetter exc;
unsigned fixedSize;
};
@ -8258,10 +8259,10 @@ class MyProcessor: public Processor {
codeImage(0),
codeImageSize(0),
segFaultHandler(GcNullPointerException::Type,
Machine::NullPointerException,
&GcRoots::nullPointerException,
GcNullPointerException::FixedSize),
divideByZeroHandler(GcArithmeticException::Type,
Machine::ArithmeticException,
&GcRoots::arithmeticException,
GcArithmeticException::FixedSize),
codeAllocator(s, Slice<uint8_t>(0, 0)),
callTableSize(0),
@ -9530,10 +9531,10 @@ boot(MyThread* t, BootImage* image, uint8_t* code)
t->m->types = reinterpret_cast<GcArray*>(bootObject(heap, image->types));
t->m->roots = makeArray(t, Machine::RootCount);
t->m->roots = makeRoots(t, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);;
setRoot(t, Machine::BootLoader, bootObject(heap, image->bootLoader));
setRoot(t, Machine::AppLoader, bootObject(heap, image->appLoader));
set(t, reinterpret_cast<object>(roots(t)), RootsBootLoader, bootObject(heap, image->bootLoader));
set(t, reinterpret_cast<object>(roots(t)), RootsAppLoader, bootObject(heap, image->appLoader));
p->roots = makeArray(t, RootCount);
@ -9542,20 +9543,24 @@ boot(MyThread* t, BootImage* image, uint8_t* code)
setRoot(t, VirtualThunks, bootObject(heap, image->virtualThunks));
{ object map = reinterpret_cast<object>(makeClassMap(t, bootClassTable, image->bootClassCount, heap));
set(t, root(t, Machine::BootLoader), ClassLoaderMap, map);
{
GcHashMap* map = makeClassMap(t, bootClassTable, image->bootClassCount, heap);
// sequence point, for gc (don't recombine statements)
set(t, roots(t)->bootLoader(), ClassLoaderMap, map);
}
cast<GcSystemClassLoader>(t, root(t, Machine::BootLoader))->finder() = t->m->bootFinder;
roots(t)->bootLoader()->as<GcSystemClassLoader>(t)->finder() = t->m->bootFinder;
{ object map = reinterpret_cast<object>(makeClassMap(t, appClassTable, image->appClassCount, heap));
set(t, root(t, Machine::AppLoader), ClassLoaderMap, map);
{
GcHashMap* map = makeClassMap(t, appClassTable, image->appClassCount, heap);
// sequence point, for gc (don't recombine statements)
set(t, roots(t)->appLoader(), ClassLoaderMap, map);
}
cast<GcSystemClassLoader>(t, root(t, Machine::AppLoader))->finder() = t->m->appFinder;
roots(t)->appLoader()->as<GcSystemClassLoader>(t)->finder() = t->m->appFinder;
setRoot(t, Machine::StringMap, reinterpret_cast<object>(makeStringMap
(t, stringTable, image->stringCount, heap)));
set(t, roots(t), RootsStringMap, makeStringMap
(t, stringTable, image->stringCount, heap));
p->callTableSize = image->callCount;
@ -9571,11 +9576,11 @@ boot(MyThread* t, BootImage* image, uint8_t* code)
if (image->initialized) {
resetRuntimeState
(t, cast<GcHashMap>(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader))->map()), heap,
(t, cast<GcHashMap>(t, roots(t)->bootLoader()->map()), heap,
image->heapSize);
resetRuntimeState
(t, cast<GcHashMap>(t, cast<GcClassLoader>(t, root(t, Machine::AppLoader))->map()), heap,
(t, cast<GcHashMap>(t, roots(t)->appLoader()->map()), heap,
image->heapSize);
for (unsigned i = 0; i < t->m->types->length(); ++i) {
@ -9586,15 +9591,17 @@ boot(MyThread* t, BootImage* image, uint8_t* code)
fixupVirtualThunks(t, code);
fixupMethods
(t, cast<GcHashMap>(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader))->map()), image, code);
(t, cast<GcHashMap>(t, roots(t)->bootLoader()->map()), image, code);
fixupMethods
(t, cast<GcHashMap>(t, cast<GcClassLoader>(t, root(t, Machine::AppLoader))->map()), image, code);
(t, cast<GcHashMap>(t, roots(t)->appLoader()->map()), image, code);
}
image->initialized = true;
setRoot(t, Machine::BootstrapClassMap, reinterpret_cast<object>(makeHashMap(t, 0, 0)));
GcHashMap* map = makeHashMap(t, 0, 0);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsBootstrapClassMap, map);
}
intptr_t

2
src/interpret.cpp
View File

@ -2909,7 +2909,7 @@ invoke(Thread* t, GcMethod* method)
class_ = objectClass(t, peekObject(t, t->sp - parameterFootprint));
if (class_->vmFlags() & BootstrapFlag) {
resolveClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), class_->name());
resolveClass(t, roots(t)->bootLoader(), class_->name());
}
if (method->class_()->flags() & ACC_INTERFACE) {

75
src/jnienv.cpp
View File

@ -330,8 +330,7 @@ defineClass(Thread* t, uintptr_t* arguments)
t,
defineClass(t,
loader ? cast<GcClassLoader>(t, *loader)
: cast<GcClassLoader>(
t, root(t, Machine::BootLoader)),
: roots(t)->bootLoader(),
buffer,
length))))));
}
@ -357,11 +356,11 @@ findClass(Thread* t, uintptr_t* arguments)
GcMethod* caller = getCaller(t, 0);
GcClass* c = resolveClass(
t,
caller ? t->m->classpath->libraryClassLoader(t, caller) : cast
<GcClassLoader>(t, root(t, Machine::AppLoader)),
n);
GcClass* c
= resolveClass(t,
caller ? t->m->classpath->libraryClassLoader(t, caller)
: roots(t)->appLoader(),
n);
if (t->m->classpath->mayInitClasses()) {
PROTECT(t, c);
@ -549,13 +548,14 @@ methodID(Thread* t, GcMethod* method)
ACQUIRE(t, t->m->referenceLock);
if (method->nativeID() == 0) {
setRoot(t, Machine::JNIMethodTable, reinterpret_cast<object>(vectorAppend
(t, cast<GcVector>(t, root(t, Machine::JNIMethodTable)), reinterpret_cast<object>(method))));
GcVector* v = vectorAppend(
t, roots(t)->jNIMethodTable(), reinterpret_cast<object>(method));
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsJNIMethodTable, v);
storeStoreMemoryBarrier();
method->nativeID() = cast<GcVector>
(t, root(t, Machine::JNIMethodTable))->size();
method->nativeID() = roots(t)->jNIMethodTable()->size();
}
}
@ -615,7 +615,7 @@ getMethod(Thread* t, jmethodID m)
{
assertT(t, m);
GcMethod* method = cast<GcMethod>(t, cast<GcVector>(t, root(t, Machine::JNIMethodTable))->body()[m - 1]);
GcMethod* method = cast<GcMethod>(t, roots(t)->jNIMethodTable()->body()[m - 1]);
assertT(t, (method->flags() & ACC_STATIC) == 0);
@ -1110,7 +1110,7 @@ getStaticMethod(Thread* t, jmethodID m)
{
assertT(t, m);
GcMethod* method = cast<GcMethod>(t, cast<GcVector>(t, root(t, Machine::JNIMethodTable))->body()[m - 1]);
GcMethod* method = cast<GcMethod>(t, roots(t)->jNIMethodTable()->body()[m - 1]);
assertT(t, method->flags() & ACC_STATIC);
@ -1502,12 +1502,14 @@ fieldID(Thread* t, GcField* field)
ACQUIRE(t, t->m->referenceLock);
if (field->nativeID() == 0) {
setRoot(t, Machine::JNIFieldTable, reinterpret_cast<object>(vectorAppend
(t, cast<GcVector>(t, root(t, Machine::JNIFieldTable)), reinterpret_cast<object>(field))));
GcVector* v = vectorAppend(
t, roots(t)->jNIFieldTable(), reinterpret_cast<object>(field));
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsJNIFieldTable, v);
storeStoreMemoryBarrier();
field->nativeID() = cast<GcVector>(t, root(t, Machine::JNIFieldTable))->size();
field->nativeID() = roots(t)->jNIFieldTable()->size();
}
}
@ -1549,7 +1551,7 @@ getField(Thread* t, jfieldID f)
{
assertT(t, f);
GcField* field = cast<GcField>(t, cast<GcVector>(t, root(t, Machine::JNIFieldTable))->body()[f - 1]);
GcField* field = cast<GcField>(t, roots(t)->jNIFieldTable()->body()[f - 1]);
assertT(t, (field->flags() & ACC_STATIC) == 0);
@ -1978,7 +1980,7 @@ getStaticField(Thread* t, jfieldID f)
{
assertT(t, f);
GcField* field = cast<GcField>(t, cast<GcVector>(t, root(t, Machine::JNIFieldTable))->body()[f - 1]);
GcField* field = cast<GcField>(t, roots(t)->jNIFieldTable()->body()[f - 1]);
assertT(t, field->flags() & ACC_STATIC);
@ -3399,7 +3401,7 @@ pushLocalFrame(Thread* t, uintptr_t* arguments)
if (t->m->processor->pushLocalFrame(t, arguments[0])) {
return 1;
} else {
throw_(t, cast<GcThrowable>(t, root(t, Machine::OutOfMemoryError)));
throw_(t, roots(t)->outOfMemoryError());
}
}
@ -3537,22 +3539,25 @@ append(char** p, const char* value, unsigned length, char tail)
uint64_t
boot(Thread* t, uintptr_t*)
{
setRoot(t,
Machine::NullPointerException,
reinterpret_cast<object>(makeThrowable(t, GcNullPointerException::Type)));
GcThrowable* throwable = makeThrowable(t, GcNullPointerException::Type);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsNullPointerException, throwable);
setRoot(t,
Machine::ArithmeticException,
reinterpret_cast<object>(makeThrowable(t, GcArithmeticException::Type)));
throwable = makeThrowable(t, GcArithmeticException::Type);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsArithmeticException, throwable);
setRoot(t,
Machine::ArrayIndexOutOfBoundsException,
reinterpret_cast<object>(makeThrowable(t, GcArrayIndexOutOfBoundsException::Type)));
throwable = makeThrowable(t, GcArrayIndexOutOfBoundsException::Type);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsArrayIndexOutOfBoundsException, throwable);
setRoot(
t, Machine::OutOfMemoryError, reinterpret_cast<object>(makeThrowable(t, GcOutOfMemoryError::Type)));
throwable = makeThrowable(t, GcOutOfMemoryError::Type);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsOutOfMemoryError, throwable);
setRoot(t, Machine::Shutdown, reinterpret_cast<object>(makeThrowable(t, GcThrowable::Type)));
throwable = makeThrowable(t, GcThrowable::Type);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsShutdownInProgress, throwable);
t->m->classpath->preBoot(t);
@ -3560,9 +3565,11 @@ boot(Thread* t, uintptr_t*)
t->javaThread->peer() = reinterpret_cast<jlong>(t);
setRoot(t, Machine::FinalizerThread, reinterpret_cast<object>(t->m->classpath->makeThread(t, t)));
GcThread* jthread = t->m->classpath->makeThread(t, t);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsFinalizerThread, jthread);
cast<GcThread>(t, root(t, Machine::FinalizerThread))->daemon() = true;
roots(t)->finalizerThread()->daemon() = true;
t->m->classpath->boot(t);
@ -3572,7 +3579,7 @@ boot(Thread* t, uintptr_t*)
PROTECT(t, host);
GcMethod* method = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "avian/Traces", "startTraceListener",
(t, roots(t)->bootLoader(), "avian/Traces", "startTraceListener",
"(Ljava/lang/String;I)V");
t->m->processor->invoke(t, method, 0, host, atoi(port));

249
src/machine.cpp
View File

@ -215,7 +215,7 @@ turnOffTheLights(Thread* t)
}
}
if (GcArray* files = cast<GcArray>(t, root(t, Machine::VirtualFiles))) {
if (GcArray* files = roots(t)->virtualFiles()) {
PROTECT(t, files);
for (unsigned i = 0; i < files->length();
++i)
@ -227,7 +227,7 @@ turnOffTheLights(Thread* t)
}
}
for (GcFinder* p = cast<GcFinder>(t, root(t, Machine::VirtualFileFinders));
for (GcFinder* p = roots(t)->virtualFileFinders();
p; p = p->next())
{
static_cast<Finder*>(p->finder())->dispose();
@ -402,8 +402,8 @@ finalizerTargetUnreachable(Thread* t, Heap::Visitor* v, GcFinalizer** p)
t->m->finalizeQueue = finalizer;
} else {
set(t, reinterpret_cast<object>(finalizer), FinalizerQueueTarget, finalizer->target());
set(t, reinterpret_cast<object>(finalizer), FinalizerQueueNext, root(t, Machine::ObjectsToFinalize));
setRoot(t, Machine::ObjectsToFinalize, reinterpret_cast<object>(finalizer));
set(t, finalizer, FinalizerQueueNext, roots(t)->objectsToFinalize());
set(t, roots(t), RootsObjectsToFinalize, finalizer);
}
}
@ -422,8 +422,8 @@ referenceTargetUnreachable(Thread* t, Heap::Visitor* v, GcJreference** p)
GcJreference* reference = *p;
*p = cast<GcJreference>(t, reference->vmNext());
set(t, reinterpret_cast<object>(reference), CleanerQueueNext, root(t, Machine::ObjectsToClean));
setRoot(t, Machine::ObjectsToClean, reinterpret_cast<object>(reference));
set(t, reference, CleanerQueueNext, roots(t)->objectsToClean());
set(t, roots(t), RootsObjectsToClean, reference);
} else {
if ((*p)->queue()
and t->m->heap->status((*p)->queue()) != Heap::Unreachable)
@ -437,9 +437,9 @@ referenceTargetUnreachable(Thread* t, Heap::Visitor* v, GcJreference** p)
if (q->front()) {
set(t, reinterpret_cast<object>(*p), JreferenceJNext, reinterpret_cast<object>(q->front()));
} else {
set(t, reinterpret_cast<object>(*p), JreferenceJNext, reinterpret_cast<object>(*p));
set(t, *p, JreferenceJNext, *p);
}
set(t, reinterpret_cast<object>(q), ReferenceQueueFront, reinterpret_cast<object>(*p));
set(t, q, ReferenceQueueFront, *p);
(*p)->queue() = 0;
}
@ -880,7 +880,7 @@ void
removeByteArray(Thread* t, object o)
{
hashMapRemove(t,
cast<GcHashMap>(t, root(t, Machine::ByteArrayMap)),
roots(t)->byteArrayMap(),
o,
byteArrayHash,
objectEqual);
@ -894,11 +894,11 @@ internByteArray(Thread* t, GcByteArray* array)
ACQUIRE(t, t->m->referenceLock);
GcTriple* n = hashMapFindNode
(t, cast<GcHashMap>(t, root(t, Machine::ByteArrayMap)), reinterpret_cast<object>(array), byteArrayHash, byteArrayEqual);
(t, roots(t)->byteArrayMap(), reinterpret_cast<object>(array), byteArrayHash, byteArrayEqual);
if (n) {
return cast<GcByteArray>(t, cast<GcJreference>(t, n->first())->target());
} else {
hashMapInsert(t, cast<GcHashMap>(t, root(t, Machine::ByteArrayMap)), reinterpret_cast<object>(array), 0, byteArrayHash);
hashMapInsert(t, roots(t)->byteArrayMap(), reinterpret_cast<object>(array), 0, byteArrayHash);
addFinalizer(t, reinterpret_cast<object>(array), removeByteArray);
return array;
}
@ -2546,7 +2546,7 @@ makeArrayClass(Thread* t, GcClassLoader* loader, unsigned dimensions, GcByteArra
// avoid infinite recursion due to trying to create an array to
// make a stack trace for a ClassNotFoundException.
resolveSystemClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
(t, roots(t)->bootLoader(),
type(t, GcJobject::Type)->name(), false);
}
@ -2564,7 +2564,7 @@ makeArrayClass(Thread* t, GcClassLoader* loader, unsigned dimensions, GcByteArra
spec,
0,
type(t, GcJobject::Type),
root(t, Machine::ArrayInterfaceTable),
reinterpret_cast<object>(roots(t)->arrayInterfaceTable()),
reinterpret_cast<object>(vtable),
0,
0,
@ -2647,7 +2647,7 @@ makeArrayClass(Thread* t, GcClassLoader* loader, GcByteArray* spec, bool throw_,
}
GcClass* elementClass = cast<GcClass>(t, hashMapFind
(t, cast<GcHashMap>(t, root(t, Machine::BootstrapClassMap)), reinterpret_cast<object>(elementSpec), byteArrayHash,
(t, roots(t)->bootstrapClassMap(), reinterpret_cast<object>(elementSpec), byteArrayHash,
byteArrayEqual));
if (elementClass == 0) {
@ -2680,7 +2680,7 @@ resolveArrayClass(Thread* t, GcClassLoader* loader, GcByteArray* spec, bool thro
{
GcClass* c = cast<GcClass>(t,
hashMapFind(t,
cast<GcHashMap>(t, root(t, Machine::BootstrapClassMap)),
roots(t)->bootstrapClassMap(),
reinterpret_cast<object>(spec),
byteArrayHash,
byteArrayEqual));
@ -2694,7 +2694,7 @@ resolveArrayClass(Thread* t, GcClassLoader* loader, GcByteArray* spec, bool thro
PROTECT(t, loader);
PROTECT(t, spec);
c = findLoadedClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), spec);
c = findLoadedClass(t, roots(t)->bootLoader(), spec);
if (c) {
return c;
@ -2713,7 +2713,7 @@ removeMonitor(Thread* t, object o)
}
object m = hashMapRemove
(t, cast<GcHashMap>(t, root(t, Machine::MonitorMap)), o, objectHash, objectEqual);
(t, roots(t)->monitorMap(), o, objectHash, objectEqual);
if (DebugMonitors) {
fprintf(stderr, "dispose monitor %p for object %x\n", m, hash);
@ -2723,7 +2723,7 @@ removeMonitor(Thread* t, object o)
void
removeString(Thread* t, object o)
{
hashMapRemove(t, cast<GcHashMap>(t, root(t, Machine::StringMap)), o, stringHash, objectEqual);
hashMapRemove(t, roots(t)->stringMap(), o, stringHash, objectEqual);
}
void
@ -2755,7 +2755,7 @@ bootClass(Thread* t, Gc::Type type, int superType, uint32_t objectMask,
GcClass* class_ = t->m->processor->makeClass
(t, 0, BootstrapFlag, fixedSize, arrayElementSize,
arrayElementSize ? 1 : 0, 0, mask, 0, 0, super, 0, 0, 0, 0, 0, 0,
cast<GcClassLoader>(t, root(t, Machine::BootLoader)), vtableLength);
roots(t)->bootLoader(), vtableLength);
setType(t, type, class_);
}
@ -2789,7 +2789,7 @@ bootJavaClass(Thread* t, Gc::Type type, int superType, const char* name,
t->m->processor->initVtable(t, class_);
hashMapInsert
(t, cast<GcHashMap>(t, root(t, Machine::BootstrapClassMap)), reinterpret_cast<object>(n), reinterpret_cast<object>(class_), byteArrayHash);
(t, roots(t)->bootstrapClassMap(), reinterpret_cast<object>(n), reinterpret_cast<object>(class_), byteArrayHash);
}
void
@ -2810,7 +2810,7 @@ makeArrayInterfaceTable(Thread* t)
set(t, interfaceTable, ArrayBody + (2 * BytesPerWord),
type(t, GcCloneable::Type));
setRoot(t, Machine::ArrayInterfaceTable, reinterpret_cast<object>(interfaceTable));
set(t, roots(t), RootsArrayInterfaceTable, interfaceTable);
}
void
@ -2820,14 +2820,15 @@ boot(Thread* t)
m->unsafe = true;
m->roots = reinterpret_cast<GcArray*>(allocate(t, pad((Machine::RootCount + 2) * BytesPerWord), true));
m->roots->length() = Machine::RootCount;
m->roots = reinterpret_cast<GcRoots*>(allocate(t, GcRoots::FixedSize, true));
setRoot(t, Machine::BootLoader,
allocate(t, GcSystemClassLoader::FixedSize, true));
object classLoader = allocate(t, GcSystemClassLoader::FixedSize, true);
// sequence point, for gc (don't recombine statements)
set(t, reinterpret_cast<object>(roots(t)), RootsBootLoader, classLoader);
setRoot(t, Machine::AppLoader,
allocate(t, GcSystemClassLoader::FixedSize, true));
classLoader = allocate(t, GcSystemClassLoader::FixedSize, true);
// sequence point, for gc (don't recombine statements)
set(t, reinterpret_cast<object>(roots(t)), RootsAppLoader, classLoader);
m->types = reinterpret_cast<GcArray*>(allocate(t, pad((TypeCount + 2) * BytesPerWord), true));
m->types->length() = TypeCount;
@ -2836,21 +2837,23 @@ boot(Thread* t)
GcClass* arrayClass = type(t, GcArray::Type);
set(t, m->types, 0, arrayClass);
set(t, m->roots, 0, arrayClass);
GcClass* rootsClass = type(t, GcRoots::Type);
set(t, m->roots, 0, rootsClass);
GcClass* loaderClass = type(t, GcSystemClassLoader::Type);
set(t, root(t, Machine::BootLoader), 0, reinterpret_cast<object>(loaderClass));
set(t, root(t, Machine::AppLoader), 0, reinterpret_cast<object>(loaderClass));
set(t, roots(t)->bootLoader(), 0, loaderClass);
set(t, roots(t)->appLoader(), 0, loaderClass);
GcClass* objectClass = type(t, GcJobject::Type);
GcClass* classClass = type(t, GcClass::Type);
set(t, reinterpret_cast<object>(classClass), 0, reinterpret_cast<object>(classClass));
set(t, reinterpret_cast<object>(classClass), ClassSuper, reinterpret_cast<object>(objectClass));
set(t, classClass, 0, classClass);
set(t, classClass, ClassSuper, objectClass);
GcClass* intArrayClass = type(t, GcIntArray::Type);
set(t, reinterpret_cast<object>(intArrayClass), 0, reinterpret_cast<object>(classClass));
set(t, reinterpret_cast<object>(intArrayClass), ClassSuper, reinterpret_cast<object>(objectClass));
set(t, intArrayClass, 0, classClass);
set(t, intArrayClass, ClassSuper, objectClass);
m->unsafe = false;
@ -2888,60 +2891,68 @@ boot(Thread* t)
type(t, GcJvoid::Type)->vmFlags()
|= PrimitiveFlag;
set(t, reinterpret_cast<object>(type(t, GcBooleanArray::Type)), ClassArrayElementClass,
reinterpret_cast<object>(type(t, GcJboolean::Type)));
set(t, reinterpret_cast<object>(type(t, GcByteArray::Type)), ClassArrayElementClass,
reinterpret_cast<object>(type(t, GcJbyte::Type)));
set(t, reinterpret_cast<object>(type(t, GcCharArray::Type)), ClassArrayElementClass,
reinterpret_cast<object>(type(t, GcJchar::Type)));
set(t, reinterpret_cast<object>(type(t, GcShortArray::Type)), ClassArrayElementClass,
reinterpret_cast<object>(type(t, GcJshort::Type)));
set(t, reinterpret_cast<object>(type(t, GcIntArray::Type)), ClassArrayElementClass,
reinterpret_cast<object>(type(t, GcJint::Type)));
set(t, reinterpret_cast<object>(type(t, GcLongArray::Type)), ClassArrayElementClass,
reinterpret_cast<object>(type(t, GcJlong::Type)));
set(t, reinterpret_cast<object>(type(t, GcFloatArray::Type)), ClassArrayElementClass,
reinterpret_cast<object>(type(t, GcJfloat::Type)));
set(t, reinterpret_cast<object>(type(t, GcDoubleArray::Type)), ClassArrayElementClass,
reinterpret_cast<object>(type(t, GcJdouble::Type)));
set(t, type(t, GcBooleanArray::Type), ClassArrayElementClass,
type(t, GcJboolean::Type));
set(t, type(t, GcByteArray::Type), ClassArrayElementClass,
type(t, GcJbyte::Type));
set(t, type(t, GcCharArray::Type), ClassArrayElementClass,
type(t, GcJchar::Type));
set(t, type(t, GcShortArray::Type), ClassArrayElementClass,
type(t, GcJshort::Type));
set(t, type(t, GcIntArray::Type), ClassArrayElementClass,
type(t, GcJint::Type));
set(t, type(t, GcLongArray::Type), ClassArrayElementClass,
type(t, GcJlong::Type));
set(t, type(t, GcFloatArray::Type), ClassArrayElementClass,
type(t, GcJfloat::Type));
set(t, type(t, GcDoubleArray::Type), ClassArrayElementClass,
type(t, GcJdouble::Type));
{ GcHashMap* map = makeHashMap(t, 0, 0);
set(t, root(t, Machine::BootLoader), ClassLoaderMap, reinterpret_cast<object>(map));
set(t, roots(t)->bootLoader(), ClassLoaderMap, map);
}
cast<GcSystemClassLoader>(t, root(t, Machine::BootLoader))->finder() = m->bootFinder;
roots(t)->bootLoader()->as<GcSystemClassLoader>(t)->finder() = m->bootFinder;
{ GcHashMap* map = makeHashMap(t, 0, 0);
set(t, root(t, Machine::AppLoader), ClassLoaderMap, reinterpret_cast<object>(map));
set(t, roots(t)->appLoader(), ClassLoaderMap, map);
}
cast<GcSystemClassLoader>(t, root(t, Machine::AppLoader))->finder() = m->appFinder;
roots(t)->appLoader()->as<GcSystemClassLoader>(t)->finder() = m->appFinder;
set(t, root(t, Machine::AppLoader), ClassLoaderParent,
root(t, Machine::BootLoader));
set(t, roots(t)->appLoader(), ClassLoaderParent,
roots(t)->bootLoader());
setRoot(t, Machine::BootstrapClassMap, reinterpret_cast<object>(makeHashMap(t, 0, 0)));
{
GcHashMap* map = makeHashMap(t, 0, 0);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsBootstrapClassMap, map);
}
setRoot(t, Machine::StringMap, reinterpret_cast<object>(makeWeakHashMap(t, 0, 0)));
{
GcWeakHashMap* map = makeWeakHashMap(t, 0, 0);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsStringMap, map);
}
makeArrayInterfaceTable(t);
set(t, reinterpret_cast<object>(type(t, GcBooleanArray::Type)), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, reinterpret_cast<object>(type(t, GcByteArray::Type)), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, reinterpret_cast<object>(type(t, GcCharArray::Type)), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, reinterpret_cast<object>(type(t, GcShortArray::Type)), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, reinterpret_cast<object>(type(t, GcIntArray::Type)), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, reinterpret_cast<object>(type(t, GcLongArray::Type)), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, reinterpret_cast<object>(type(t, GcFloatArray::Type)), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, reinterpret_cast<object>(type(t, GcDoubleArray::Type)), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, type(t, GcBooleanArray::Type), ClassInterfaceTable,
roots(t)->arrayInterfaceTable());
set(t, type(t, GcByteArray::Type), ClassInterfaceTable,
roots(t)->arrayInterfaceTable());
set(t, type(t, GcCharArray::Type), ClassInterfaceTable,
roots(t)->arrayInterfaceTable());
set(t, type(t, GcShortArray::Type), ClassInterfaceTable,
roots(t)->arrayInterfaceTable());
set(t, type(t, GcIntArray::Type), ClassInterfaceTable,
roots(t)->arrayInterfaceTable());
set(t, type(t, GcLongArray::Type), ClassInterfaceTable,
roots(t)->arrayInterfaceTable());
set(t, type(t, GcFloatArray::Type), ClassInterfaceTable,
roots(t)->arrayInterfaceTable());
set(t, type(t, GcDoubleArray::Type), ClassInterfaceTable,
roots(t)->arrayInterfaceTable());
m->processor->boot(t, 0, 0);
@ -3090,12 +3101,12 @@ doCollect(Thread* t, Heap::CollectionType type, int pendingAllocation)
function(t, finalizeQueue->target());
}
if ((root(t, Machine::ObjectsToFinalize) or root(t, Machine::ObjectsToClean))
if ((roots(t)->objectsToFinalize() or roots(t)->objectsToClean())
and m->finalizeThread == 0
and t->state != Thread::ExitState)
{
m->finalizeThread = m->processor->makeThread
(m, cast<GcThread>(t, root(t, Machine::FinalizerThread)), m->rootThread);
(m, roots(t)->finalizerThread(), m->rootThread);
addThread(t, m->finalizeThread);
@ -3165,8 +3176,10 @@ updatePackageMap(Thread* t, GcClass* class_)
{
PROTECT(t, class_);
if (root(t, Machine::PackageMap) == 0) {
setRoot(t, Machine::PackageMap, reinterpret_cast<object>(makeHashMap(t, 0, 0)));
if (roots(t)->packageMap() == 0) {
GcHashMap* map = makeHashMap(t, 0, 0);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsPackageMap, map);
}
GcByteArray* className = class_->name();
@ -3189,7 +3202,7 @@ updatePackageMap(Thread* t, GcClass* class_)
PROTECT(t, key);
hashMapRemove
(t, cast<GcHashMap>(t, root(t, Machine::PackageMap)), reinterpret_cast<object>(key), byteArrayHash,
(t, roots(t)->packageMap(), reinterpret_cast<object>(key), byteArrayHash,
byteArrayEqual);
GcByteArray* source = class_->source();
@ -3210,7 +3223,7 @@ updatePackageMap(Thread* t, GcClass* class_)
}
hashMapInsert
(t, cast<GcHashMap>(t, root(t, Machine::PackageMap)), reinterpret_cast<object>(key), reinterpret_cast<object>(source), byteArrayHash);
(t, roots(t)->packageMap(), reinterpret_cast<object>(key), reinterpret_cast<object>(source), byteArrayHash);
}
}
}
@ -3453,13 +3466,29 @@ Thread::init()
boot(this);
}
setRoot(this, Machine::ByteArrayMap, reinterpret_cast<object>(makeWeakHashMap(this, 0, 0)));
setRoot(this, Machine::MonitorMap, reinterpret_cast<object>(makeWeakHashMap(this, 0, 0)));
GcWeakHashMap* map = makeWeakHashMap(this, 0, 0);
// sequence point, for gc (don't recombine statements)
set(this, roots(this), RootsByteArrayMap, map);
setRoot(this, Machine::ClassRuntimeDataTable, reinterpret_cast<object>(makeVector(this, 0, 0)));
setRoot(this, Machine::MethodRuntimeDataTable, reinterpret_cast<object>(makeVector(this, 0, 0)));
setRoot(this, Machine::JNIMethodTable, reinterpret_cast<object>(makeVector(this, 0, 0)));
setRoot(this, Machine::JNIFieldTable, reinterpret_cast<object>(makeVector(this, 0, 0)));
map = makeWeakHashMap(this, 0, 0);
// sequence point, for gc (don't recombine statements)
set(this, roots(this), RootsMonitorMap, map);
GcVector* v = makeVector(this, 0, 0);
// sequence point, for gc (don't recombine statements)
set(this, roots(this), RootsClassRuntimeDataTable, v);
v = makeVector(this, 0, 0);
// sequence point, for gc (don't recombine statements)
set(this, roots(this), RootsMethodRuntimeDataTable, v);
v = makeVector(this, 0, 0);
// sequence point, for gc (don't recombine statements)
set(this, roots(this), RootsJNIMethodTable, v);
v = makeVector(this, 0, 0);
// sequence point, for gc (don't recombine statements)
set(this, roots(this), RootsJNIFieldTable, v);
m->localThread->set(this);
}
@ -3508,10 +3537,10 @@ shutDown(Thread* t)
{
ACQUIRE(t, t->m->shutdownLock);
GcPair* hooks = cast<GcPair>(t, root(t, Machine::ShutdownHooks));
GcPair* hooks = roots(t)->shutdownHooks();
PROTECT(t, hooks);
setRoot(t, Machine::ShutdownHooks, 0);
set(t, roots(t), RootsShutdownHooks, 0);
GcPair* h = hooks;
PROTECT(t, h);
@ -3835,7 +3864,7 @@ allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type,
}
if (t->m->heap->limitExceeded(pendingAllocation)) {
throw_(t, cast<GcThrowable>(t, root(t, Machine::OutOfMemoryError)));
throw_(t, roots(t)->outOfMemoryError());
}
} while (type == Machine::MovableAllocation
and t->heapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
@ -4093,7 +4122,7 @@ resolveBootstrap(Thread* t, uintptr_t* arguments)
{
GcByteArray* name = cast<GcByteArray>(t, reinterpret_cast<object>(arguments[0]));
resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name);
resolveSystemClass(t, roots(t)->bootLoader(), name);
return 1;
}
@ -4363,14 +4392,14 @@ parseClass(Thread* t, GcClassLoader* loader, const uint8_t* data, unsigned size,
updateClassTables(t, real, class_);
if (root(t, Machine::PoolMap)) {
if (roots(t)->poolMap()) {
object bootstrapClass = hashMapFind
(t, cast<GcHashMap>(t, root(t, Machine::BootstrapClassMap)), reinterpret_cast<object>(class_->name()),
(t, roots(t)->bootstrapClassMap(), reinterpret_cast<object>(class_->name()),
byteArrayHash, byteArrayEqual);
hashMapInsert(
t,
cast<GcHashMap>(t, root(t, Machine::PoolMap)),
roots(t)->poolMap(),
bootstrapClass ? bootstrapClass : reinterpret_cast<object>(real),
reinterpret_cast<object>(pool),
objectHash);
@ -4479,7 +4508,7 @@ resolveSystemClass(Thread* t, GcClassLoader* loader, GcByteArray* spec, bool thr
}
GcClass* bootstrapClass = cast<GcClass>(t, hashMapFind
(t, cast<GcHashMap>(t, root(t, Machine::BootstrapClassMap)), reinterpret_cast<object>(spec), byteArrayHash,
(t, roots(t)->bootstrapClassMap(), reinterpret_cast<object>(spec), byteArrayHash,
byteArrayEqual));
if (bootstrapClass) {
@ -4533,26 +4562,26 @@ resolveClass(Thread* t, GcClassLoader* loader, GcByteArray* spec, bool throw_,
if (spec->body()[0] == '[') {
c = resolveArrayClass(t, loader, spec, throw_, throwType);
} else {
if (root(t, Machine::LoadClassMethod) == 0) {
if (roots(t)->loadClassMethod() == 0) {
GcMethod* m = resolveMethod
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), "java/lang/ClassLoader",
(t, roots(t)->bootLoader(), "java/lang/ClassLoader",
"loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
if (m) {
setRoot(t, Machine::LoadClassMethod, reinterpret_cast<object>(m));
set(t, roots(t), RootsLoadClassMethod, m);
GcClass* classLoaderClass = type(t, GcClassLoader::Type);
if (classLoaderClass->vmFlags() & BootstrapFlag) {
resolveSystemClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
(t, roots(t)->bootLoader(),
classLoaderClass->name());
}
}
}
GcMethod* method = findVirtualMethod
(t, cast<GcMethod>(t, root(t, Machine::LoadClassMethod)), objectClass(t, loader));
(t, roots(t)->loadClassMethod(), objectClass(t, loader));
PROTECT(t, method);
@ -4912,7 +4941,7 @@ objectMonitor(Thread* t, object o, bool createNew)
assertT(t, t->state == Thread::ActiveState);
object m = hashMapFind
(t, cast<GcHashMap>(t, root(t, Machine::MonitorMap)), o, objectHash, objectEqual);
(t, roots(t)->monitorMap(), o, objectHash, objectEqual);
if (m) {
if (DebugMonitors) {
@ -4927,7 +4956,7 @@ objectMonitor(Thread* t, object o, bool createNew)
{ ENTER(t, Thread::ExclusiveState);
m = hashMapFind
(t, cast<GcHashMap>(t, root(t, Machine::MonitorMap)), o, objectHash, objectEqual);
(t, roots(t)->monitorMap(), o, objectHash, objectEqual);
if (m) {
if (DebugMonitors) {
@ -4946,7 +4975,7 @@ objectMonitor(Thread* t, object o, bool createNew)
objectHash(t, o));
}
hashMapInsert(t, cast<GcHashMap>(t, root(t, Machine::MonitorMap)), o, m, objectHash);
hashMapInsert(t, roots(t)->monitorMap(), o, m, objectHash);
addFinalizer(t, o, removeMonitor);
}
@ -4965,12 +4994,12 @@ intern(Thread* t, object s)
ACQUIRE(t, t->m->referenceLock);
GcTriple* n = hashMapFindNode
(t, cast<GcHashMap>(t, root(t, Machine::StringMap)), s, stringHash, stringEqual);
(t, roots(t)->stringMap(), s, stringHash, stringEqual);
if (n) {
return reinterpret_cast<object>(cast<GcJreference>(t, n->first())->target());
} else {
hashMapInsert(t, cast<GcHashMap>(t, root(t, Machine::StringMap)), s, 0, stringHash);
hashMapInsert(t, roots(t)->stringMap(), s, 0, stringHash);
addFinalizer(t, s, removeString);
return s;
}
@ -5196,8 +5225,8 @@ runFinalizeThread(Thread* t)
{ ACQUIRE(t, t->m->stateLock);
while (t->m->finalizeThread
and root(t, Machine::ObjectsToFinalize) == 0
and root(t, Machine::ObjectsToClean) == 0)
and roots(t)->objectsToFinalize() == 0
and roots(t)->objectsToClean() == 0)
{
ENTER(t, Thread::IdleState);
t->m->stateLock->wait(t->systemThread, 0);
@ -5206,11 +5235,11 @@ runFinalizeThread(Thread* t)
if (t->m->finalizeThread == 0) {
return;
} else {
finalizeList = cast<GcFinalizer>(t, root(t, Machine::ObjectsToFinalize));
setRoot(t, Machine::ObjectsToFinalize, 0);
finalizeList = roots(t)->objectsToFinalize();
set(t, roots(t), RootsObjectsToFinalize, 0);
cleanList = cast<GcCleaner>(t, root(t, Machine::ObjectsToClean));
setRoot(t, Machine::ObjectsToClean, 0);
cleanList = roots(t)->objectsToClean();
set(t, roots(t), RootsObjectsToClean, 0);
}
}

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

@ -312,7 +312,7 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
} resolver(&typeMaps);
Finder* finder = static_cast<Finder*>
(cast<GcSystemClassLoader>(t, root(t, Machine::BootLoader))->finder());
(roots(t)->bootLoader()->as<GcSystemClassLoader>(t)->finder());
for (Finder::Iterator it(finder); it.hasMore();) {
unsigned nameSize = 0;
@ -323,7 +323,7 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
{
// fprintf(stderr, "pass 1 %.*s\n", nameSize - 6, name);
GcClass* c = resolveSystemClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
(t, roots(t)->bootLoader(),
makeByteArray(t, "%.*s", nameSize - 6, name), true);
PROTECT(t, c);
@ -419,7 +419,7 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
hashMapInsert
(t, typeMaps, reinterpret_cast<object>(hashMapFind
(t, cast<GcHashMap>(t, root(t, Machine::PoolMap)), reinterpret_cast<object>(c), objectHash, objectEqual)), reinterpret_cast<object>(array),
(t, roots(t)->poolMap(), reinterpret_cast<object>(c), objectHash, objectEqual)), reinterpret_cast<object>(array),
objectHash);
}
}
@ -611,7 +611,7 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
PROTECT(t, c);
c = resolveSystemClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)),
(t, roots(t)->bootLoader(),
makeByteArray(t, "%.*s", nameSize - 6, name), true);
if (GcArray* mtable = cast<GcArray>(t, c->methodTable())) {
@ -657,7 +657,7 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
if (objectClass(t, o) == type(t, GcReference::Type)) {
o = reinterpret_cast<object>(resolveClass
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), cast<GcReference>(t, o)->name()));
(t, roots(t)->bootLoader(), cast<GcReference>(t, o)->name()));
set(t, reinterpret_cast<object>(addendum->pool()),
SingletonBody + (index * BytesPerWord), o);
@ -706,14 +706,14 @@ visitRoots(Thread* t, BootImage* image, HeapWalker* w, GcTriple* constants)
{
Machine* m = t->m;
for (HashMapIterator it(t, cast<GcHashMap>(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader))->map()));
for (HashMapIterator it(t, cast<GcHashMap>(t, roots(t)->bootLoader()->map()));
it.hasMore();)
{
w->visitRoot(it.next()->second());
}
image->bootLoader = w->visitRoot(root(t, Machine::BootLoader));
image->appLoader = w->visitRoot(root(t, Machine::AppLoader));
image->bootLoader = w->visitRoot(reinterpret_cast<object>(roots(t)->bootLoader()));
image->appLoader = w->visitRoot(reinterpret_cast<object>(roots(t)->appLoader()));
image->types = w->visitRoot(reinterpret_cast<object>(m->types));
m->processor->visitRoots(t, w);
@ -1288,8 +1288,9 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
const char* codeimageStart, const char* codeimageEnd,
bool useLZMA)
{
setRoot(t, Machine::OutOfMemoryError,
make(t, type(t, GcOutOfMemoryError::Type)));
GcThrowable* throwable = cast<GcThrowable>(t, make(t, type(t, GcOutOfMemoryError::Type)));
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsOutOfMemoryError, throwable);
Zone zone(t->m->system, t->m->heap, 64 * 1024);
@ -1331,7 +1332,7 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
{ classPoolMap = makeHashMap(t, 0, 0);
PROTECT(t, classPoolMap);
setRoot(t, Machine::PoolMap, reinterpret_cast<object>(classPoolMap));
set(t, roots(t), RootsPoolMap, classPoolMap);
typeMaps = makeHashMap(t, 0, 0);
PROTECT(t, typeMaps);
@ -1493,8 +1494,11 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
// these roots will not be used when the bootimage is loaded, so
// there's no need to preserve them:
setRoot(t, Machine::PoolMap, 0);
setRoot(t, Machine::ByteArrayMap, reinterpret_cast<object>(makeWeakHashMap(t, 0, 0)));
set(t, roots(t), RootsPoolMap, 0);
GcWeakHashMap* map = makeWeakHashMap(t, 0, 0);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsByteArrayMap, map);
// name all primitive classes so we don't try to update immutable
// references at runtime:
@ -1529,28 +1533,28 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
// resolve primitive array classes in case they are needed at
// runtime:
{ GcByteArray* name = makeByteArray(t, "[B");
resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
resolveSystemClass(t, roots(t)->bootLoader(), name, true);
name = makeByteArray(t, "[Z");
resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
resolveSystemClass(t, roots(t)->bootLoader(), name, true);
name = makeByteArray(t, "[S");
resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
resolveSystemClass(t, roots(t)->bootLoader(), name, true);
name = makeByteArray(t, "[C");
resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
resolveSystemClass(t, roots(t)->bootLoader(), name, true);
name = makeByteArray(t, "[I");
resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
resolveSystemClass(t, roots(t)->bootLoader(), name, true);
name = makeByteArray(t, "[J");
resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
resolveSystemClass(t, roots(t)->bootLoader(), name, true);
name = makeByteArray(t, "[F");
resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
resolveSystemClass(t, roots(t)->bootLoader(), name, true);
name = makeByteArray(t, "[D");
resolveSystemClass(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader)), name, true);
resolveSystemClass(t, roots(t)->bootLoader(), name, true);
}
}
@ -1567,14 +1571,14 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
updateConstants(t, constants, heapWalker->map());
image->bootClassCount = cast<GcHashMap>
(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader))->map())->size();
(t, roots(t)->bootLoader()->map())->size();
unsigned* bootClassTable = static_cast<unsigned*>
(t->m->heap->allocate(image->bootClassCount * sizeof(unsigned)));
{ unsigned i = 0;
for (HashMapIterator it
(t, cast<GcHashMap>(t, cast<GcClassLoader>(t, root(t, Machine::BootLoader))->map()));
(t, cast<GcHashMap>(t, roots(t)->bootLoader()->map()));
it.hasMore();)
{
bootClassTable[i++] = targetVW
@ -1583,14 +1587,14 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
}
image->appClassCount = cast<GcHashMap>
(t, cast<GcClassLoader>(t, root(t, Machine::AppLoader))->map())->size();
(t, roots(t)->appLoader()->map())->size();
unsigned* appClassTable = static_cast<unsigned*>
(t->m->heap->allocate(image->appClassCount * sizeof(unsigned)));
{ unsigned i = 0;
for (HashMapIterator it
(t, cast<GcHashMap>(t, cast<GcClassLoader>(t, root(t, Machine::AppLoader))->map()));
(t, cast<GcHashMap>(t, roots(t)->appLoader()->map()));
it.hasMore();)
{
appClassTable[i++] = targetVW
@ -1598,12 +1602,12 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
}
}
image->stringCount = cast<GcHashMap>(t, root(t, Machine::StringMap))->size();
image->stringCount = roots(t)->stringMap()->size();
unsigned* stringTable = static_cast<unsigned*>
(t->m->heap->allocate(image->stringCount * sizeof(unsigned)));
{ unsigned i = 0;
for (HashMapIterator it(t, cast<GcHashMap>(t, root(t, Machine::StringMap))); it.hasMore();) {
for (HashMapIterator it(t, roots(t)->stringMap()); it.hasMore();) {
stringTable[i++] = targetVW
(heapWalker->map()->find
(reinterpret_cast<object>(cast<GcJreference>(t, it.next()->first())->target())));

40
src/types.def
View File

@ -376,3 +376,43 @@
(type jvoid
(extends jobject))
(type roots
(classLoader bootLoader)
(classLoader appLoader)
(hashMap bootstrapClassMap)
(hashMap packageMap)
(method findLoadedClassMethod)
(method loadClassMethod)
(hashMap monitorMap)
(hashMap stringMap)
(hashMap byteArrayMap)
(hashMap poolMap)
(vector classRuntimeDataTable)
(vector methodRuntimeDataTable)
(vector jNIMethodTable)
(vector jNIFieldTable)
(pair shutdownHooks)
(thread finalizerThread)
(finalizer objectsToFinalize)
(cleaner objectsToClean)
(throwable nullPointerException)
(throwable arithmeticException)
(throwable arrayIndexOutOfBoundsException)
(throwable outOfMemoryError)
(throwable shutdownInProgress)
(finder virtualFileFinders)
(field array virtualFiles)
(field array arrayInterfaceTable)
(object threadTerminated))
(type compileRoots
(field array callTable)
(treeNode methodTree)
(treeNode methodTreeSentinal)
(object objectPools)
(object staticTableArray)
(wordArray virtualThunks)
(method receiveMethod)
(method windMethod)
(method rewindMethod))