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
ca84dd26f1
corda/src/machine.cpp

5220 lines
138 KiB
C++
Raw Normal View History

update copyright years
2012-05-11 23:43:27 +00:00
/* Copyright (c) 2008-2012, Avian Contributors
prepend copyright notice and license to all source files; add license.txt and readme.txt
2008-02-19 18:06:52 +00:00
Permission to use, copy, modify, and/or distribute this software
for any purpose with or without fee is hereby granted, provided
that the above copyright notice and this permission notice appear
in all copies.
There is NO WARRANTY for this software. See license.txt for
details. */
move headers from src to src/avian This is necessary to avoid name conflicts on various platforms. For example, iOS has its own util.h, and Windows has a process.h. By including our version as e.g. "avian/util.h", we avoid confusion with the system version.
2013-02-27 20:25:50 +00:00
#include "avian/jnienv.h"
#include "avian/machine.h"
#include "avian/util.h"
move stream.h to include, and type-generator to src/tools
2013-02-21 04:26:34 +00:00
#include <avian/util/stream.h>
move headers from src to src/avian This is necessary to avoid name conflicts on various platforms. For example, iOS has its own util.h, and Windows has a process.h. By including our version as e.g. "avian/util.h", we avoid confusion with the system version.
2013-02-27 20:25:50 +00:00
#include "avian/constants.h"
#include "avian/processor.h"
#include "avian/arch.h"
#include "avian/lzma.h"
more refactoring
2007-07-06 23:50:26 +00:00
move runtime-array to include
2013-02-20 05:56:05 +00:00
#include <avian/util/runtime-array.h>
move math functions out of common.h, and into include/avian/util/math.h
2013-02-20 14:51:57 +00:00
#include <avian/util/math.h>
move RUNTIME_ARRAY into it's own header
2013-02-11 00:51:59 +00:00
Allow output of exceptions to debugger. Generate WinMD file
2013-01-30 08:42:05 +00:00
#if defined(PLATFORM_WINDOWS)
# define WIN32_LEAN_AND_MEAN
fix cross-compile windows build
2013-02-15 16:53:02 +00:00
# include <windows.h>
Allow output of exceptions to debugger. Generate WinMD file
2013-01-30 08:42:05 +00:00
#endif
more refactoring
2007-07-06 23:50:26 +00:00
using namespace vm;
move math functions out of common.h, and into include/avian/util/math.h
2013-02-20 14:51:57 +00:00
using namespace avian::util;
more refactoring
2007-07-06 23:50:26 +00:00
namespace {
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
const bool DebugClassReader = false;
fix reading 2-byte UTF-8 constants
2009-08-14 14:52:31 +00:00
const unsigned NoByte = 0xFFFF;
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
#ifdef USE_ATOMIC_OPERATIONS
void
fix race conditions in atomic operations
2009-11-29 16:08:07 +00:00
atomicIncrement(uint32_t* p, int v)
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
{
fix race conditions in atomic operations
2009-11-29 16:08:07 +00:00
for (uint32_t old = *p;
not atomicCompareAndSwap32(p, old, old + v);
old = *p)
{ }
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
}
#endif
progress on thread support
2007-07-07 18:09:16 +00:00
void
join(Thread* t, Thread* o)
{
if (t != o) {
avoid running out of OS resources due to zombie thread accumulation (part 2) My previous attempt wasn't quite sufficient, since it was too late to call join on a thread which had already exited given the code was written to aggressively dispose of system handles as soon as the thread exited. The solution is to delay disposing these handles until after we're able to join the thread.
2012-02-04 00:20:20 +00:00
assert(t, o->state != Thread::JoinedState);
assert(t, (o->flags & Thread::SystemFlag) == 0);
if (o->flags & Thread::JoinFlag) {
clean up OS resources immediately upon thread exit Previously, we waited until the next GC to do this, but that can be too long for workloads which create a lot of short-lived threads but don't do much allocation.
2010-11-09 22:46:16 +00:00
o->systemThread->join();
}
more GC stress fixes
2007-07-18 01:33:00 +00:00
o->state = Thread::JoinedState;
progress on thread support
2007-07-07 18:09:16 +00:00
}
}
add optional LZMA support for compressing embedded JARs, boot images, and shared objects
2012-06-02 15:06:22 +00:00
#ifndef NDEBUG
bool
find(Thread* t, Thread* o)
{
return (t == o)
or (t->peer and find(t->peer, o))
or (t->child and find(t->child, o));
}
unsigned
count(Thread* t, Thread* o)
{
unsigned c = 0;
if (t != o) ++ c;
if (t->peer) c += count(t->peer, o);
if (t->child) c += count(t->child, o);
return c;
}
Thread**
fill(Thread* t, Thread* o, Thread** array)
{
if (t != o) *(array++) = t;
if (t->peer) array = fill(t->peer, o, array);
if (t->child) array = fill(t->child, o, array);
return array;
}
#endif // not NDEBUG
progress on thread support
2007-07-07 18:09:16 +00:00
void
dispose(Thread* t, Thread* o, bool remove)
{
if (remove) {
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
#ifndef NDEBUG
various threading bugfixes
2007-11-27 22:23:00 +00:00
expect(t, find(t->m->rootThread, o));
unsigned c = count(t->m->rootThread, o);
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
THREAD_RUNTIME_ARRAY(t, Thread*, threads, c);
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
fill(t->m->rootThread, o, RUNTIME_ARRAY_BODY(threads));
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
#endif
various threading bugfixes
2007-11-27 22:23:00 +00:00
progress on thread support
2007-07-07 18:09:16 +00:00
if (o->parent) {
avoid uninitialized value warnings
2007-11-27 23:04:15 +00:00
Thread* previous = 0;
various threading bugfixes
2007-11-27 22:23:00 +00:00
for (Thread* p = o->parent->child; p;) {
if (p == o) {
if (p == o->parent->child) {
o->parent->child = p->peer;
} else {
previous->peer = p->peer;
}
break;
} else {
previous = p;
p = p->peer;
progress on thread support
2007-07-07 18:09:16 +00:00
}
various threading bugfixes
2007-11-27 22:23:00 +00:00
}
for (Thread* p = o->child; p;) {
Thread* next = p->peer;
p->peer = o->parent->child;
o->parent->child = p;
p->parent = o->parent;
p = next;
progress on thread support
2007-07-07 18:09:16 +00:00
}
} else if (o->child) {
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
t->m->rootThread = o->child;
various threading bugfixes
2007-11-27 22:23:00 +00:00
for (Thread* p = o->peer; p;) {
Thread* next = p->peer;
p->peer = t->m->rootThread;
t->m->rootThread = p;
p = next;
}
progress on thread support
2007-07-07 18:09:16 +00:00
} else if (o->peer) {
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
t->m->rootThread = o->peer;
progress on thread support
2007-07-07 18:09:16 +00:00
} else {
abort(t);
}
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
#ifndef NDEBUG
various threading bugfixes
2007-11-27 22:23:00 +00:00
expect(t, not find(t->m->rootThread, o));
for (unsigned i = 0; i < c; ++i) {
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
expect(t, find(t->m->rootThread, RUNTIME_ARRAY_BODY(threads)[i]));
various threading bugfixes
2007-11-27 22:23:00 +00:00
}
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
#endif
progress on thread support
2007-07-07 18:09:16 +00:00
}
o->dispose();
}
void
support multiple sequential VM instances with bootimage build Until now, the bootimage build hasn't supported using the Java invocation API to create a VM, destroy it, and create another in the same process. Ideally, we would be able to create multiple VMs simultaneously without any interference between them. In fact, Avian is designed to support this for the most part, but there are a few places we use global, mutable state which prevent this from working. Most notably, the bootimage is modified in-place at runtime, so the best we can do without extensive changes is to clean up the bootimage when the VM is destroyed so it's ready for later instances. Hence this commit. Ultimately, we can move towards a fully reentrant VM by making the bootimage immutable, but this will require some care to avoid performance regressions. Another challenge is our Posix signal handlers, which currently rely on a global handle to the VM, since you can't, to my knowledge, pass a context pointer when registering a signal handler. Thread local variables won't necessarily help, since a thread might attatch to more than one VM at a time.
2011-11-10 20:10:53 +00:00
visitAll(Thread* m, Thread* o, void (*visit)(Thread*, Thread*))
progress on thread support
2007-07-07 18:09:16 +00:00
{
for (Thread* p = o->child; p;) {
Thread* child = p;
p = p->peer;
support multiple sequential VM instances with bootimage build Until now, the bootimage build hasn't supported using the Java invocation API to create a VM, destroy it, and create another in the same process. Ideally, we would be able to create multiple VMs simultaneously without any interference between them. In fact, Avian is designed to support this for the most part, but there are a few places we use global, mutable state which prevent this from working. Most notably, the bootimage is modified in-place at runtime, so the best we can do without extensive changes is to clean up the bootimage when the VM is destroyed so it's ready for later instances. Hence this commit. Ultimately, we can move towards a fully reentrant VM by making the bootimage immutable, but this will require some care to avoid performance regressions. Another challenge is our Posix signal handlers, which currently rely on a global handle to the VM, since you can't, to my knowledge, pass a context pointer when registering a signal handler. Thread local variables won't necessarily help, since a thread might attatch to more than one VM at a time.
2011-11-10 20:10:53 +00:00
visitAll(m, child, visit);
progress on thread support
2007-07-07 18:09:16 +00:00
}
support multiple sequential VM instances with bootimage build Until now, the bootimage build hasn't supported using the Java invocation API to create a VM, destroy it, and create another in the same process. Ideally, we would be able to create multiple VMs simultaneously without any interference between them. In fact, Avian is designed to support this for the most part, but there are a few places we use global, mutable state which prevent this from working. Most notably, the bootimage is modified in-place at runtime, so the best we can do without extensive changes is to clean up the bootimage when the VM is destroyed so it's ready for later instances. Hence this commit. Ultimately, we can move towards a fully reentrant VM by making the bootimage immutable, but this will require some care to avoid performance regressions. Another challenge is our Posix signal handlers, which currently rely on a global handle to the VM, since you can't, to my knowledge, pass a context pointer when registering a signal handler. Thread local variables won't necessarily help, since a thread might attatch to more than one VM at a time.
2011-11-10 20:10:53 +00:00
visit(m, o);
progress on thread support
2007-07-07 18:09:16 +00:00
}
void
support multiple sequential VM instances with bootimage build Until now, the bootimage build hasn't supported using the Java invocation API to create a VM, destroy it, and create another in the same process. Ideally, we would be able to create multiple VMs simultaneously without any interference between them. In fact, Avian is designed to support this for the most part, but there are a few places we use global, mutable state which prevent this from working. Most notably, the bootimage is modified in-place at runtime, so the best we can do without extensive changes is to clean up the bootimage when the VM is destroyed so it's ready for later instances. Hence this commit. Ultimately, we can move towards a fully reentrant VM by making the bootimage immutable, but this will require some care to avoid performance regressions. Another challenge is our Posix signal handlers, which currently rely on a global handle to the VM, since you can't, to my knowledge, pass a context pointer when registering a signal handler. Thread local variables won't necessarily help, since a thread might attatch to more than one VM at a time.
2011-11-10 20:10:53 +00:00
disposeNoRemove(Thread* m, Thread* o)
progress on thread support
2007-07-07 18:09:16 +00:00
{
dispose(m, o, false);
}
support multiple sequential VM instances with bootimage build Until now, the bootimage build hasn't supported using the Java invocation API to create a VM, destroy it, and create another in the same process. Ideally, we would be able to create multiple VMs simultaneously without any interference between them. In fact, Avian is designed to support this for the most part, but there are a few places we use global, mutable state which prevent this from working. Most notably, the bootimage is modified in-place at runtime, so the best we can do without extensive changes is to clean up the bootimage when the VM is destroyed so it's ready for later instances. Hence this commit. Ultimately, we can move towards a fully reentrant VM by making the bootimage immutable, but this will require some care to avoid performance regressions. Another challenge is our Posix signal handlers, which currently rely on a global handle to the VM, since you can't, to my knowledge, pass a context pointer when registering a signal handler. Thread local variables won't necessarily help, since a thread might attatch to more than one VM at a time.
2011-11-10 20:10:53 +00:00
void
interruptDaemon(Thread* m, Thread* o)
{
if (o->flags & Thread::DaemonFlag) {
interrupt(m, o);
}
}
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
void
turnOffTheLights(Thread* t)
{
expect(t, t->m->liveCount == 1);
support multiple sequential VM instances with bootimage build Until now, the bootimage build hasn't supported using the Java invocation API to create a VM, destroy it, and create another in the same process. Ideally, we would be able to create multiple VMs simultaneously without any interference between them. In fact, Avian is designed to support this for the most part, but there are a few places we use global, mutable state which prevent this from working. Most notably, the bootimage is modified in-place at runtime, so the best we can do without extensive changes is to clean up the bootimage when the VM is destroyed so it's ready for later instances. Hence this commit. Ultimately, we can move towards a fully reentrant VM by making the bootimage immutable, but this will require some care to avoid performance regressions. Another challenge is our Posix signal handlers, which currently rely on a global handle to the VM, since you can't, to my knowledge, pass a context pointer when registering a signal handler. Thread local variables won't necessarily help, since a thread might attatch to more than one VM at a time.
2011-11-10 20:10:53 +00:00
visitAll(t, t->m->rootThread, join);
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
enter(t, Thread::ExitState);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
{ object p = 0;
PROTECT(t, p);
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
for (p = t->m->finalizers; p;) {
object f = p;
p = finalizerNext(t, p);
void (*function)(Thread*, object);
memcpy(&function, &finalizerFinalize(t, f), BytesPerWord);
if (function) {
function(t, finalizerTarget(t, f));
}
fix GNU Classpath build
2009-12-06 02:40:46 +00:00
}
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
for (p = t->m->tenuredFinalizers; p;) {
object f = p;
p = finalizerNext(t, p);
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
void (*function)(Thread*, object);
memcpy(&function, &finalizerFinalize(t, f), BytesPerWord);
if (function) {
function(t, finalizerTarget(t, f));
}
fix GNU Classpath build
2009-12-06 02:40:46 +00:00
}
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
}
add support for accessing embedded JARs as if they were directories This allows OpenJDK to access time zone data which is normally found under java.home, but which we must embed in the executable itself to create a self-contained build. The VM intercepts various file operations, looking for paths which start with a prefix specified by the avian.embed.prefix property and redirecting those operations to an embedded JAR. For example, if avian.embed.prefix is "/avian-embedded", and code calls File.exists() with a path of "/avian-embedded/javahomeJar/foo.txt", the VM looks for a function named javahomeJar via dlsym, calls the function to find the memory region containing the embeded JAR, and finally consults the JAR to see if the file "foo.txt" exists.
2010-11-05 19:18:28 +00:00
if (root(t, Machine::VirtualFiles)) {
for (unsigned i = 0; i < arrayLength(t, root(t, Machine::VirtualFiles));
++i)
{
object region = arrayBody(t, root(t, Machine::VirtualFiles), i);
if (region) {
static_cast<System::Region*>(regionRegion(t, region))->dispose();
}
}
}
for (object p = root(t, Machine::VirtualFileFinders);
p; p = finderNext(t, p))
{
static_cast<Finder*>(finderFinder(t, p))->dispose();
}
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
Machine* m = t->m;
support multiple sequential VM instances with bootimage build Until now, the bootimage build hasn't supported using the Java invocation API to create a VM, destroy it, and create another in the same process. Ideally, we would be able to create multiple VMs simultaneously without any interference between them. In fact, Avian is designed to support this for the most part, but there are a few places we use global, mutable state which prevent this from working. Most notably, the bootimage is modified in-place at runtime, so the best we can do without extensive changes is to clean up the bootimage when the VM is destroyed so it's ready for later instances. Hence this commit. Ultimately, we can move towards a fully reentrant VM by making the bootimage immutable, but this will require some care to avoid performance regressions. Another challenge is our Posix signal handlers, which currently rely on a global handle to the VM, since you can't, to my knowledge, pass a context pointer when registering a signal handler. Thread local variables won't necessarily help, since a thread might attatch to more than one VM at a time.
2011-11-10 20:10:53 +00:00
visitAll(t, t->m->rootThread, disposeNoRemove);
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
System* s = m->system;
avoid running out of OS resources due to zombie thread accumulation The bug here is that when a thread exits and becomes a "zombie", the OS resources associated with it are not necessarily released until we actually join and dispose of that thread. Since that only happens during garbage collection, and collection normally only happens in response to heap memory pressure, there's no guarantee that we'll GC frequently enough to clean up zombies promptly and avoid running out of resources. The solution is to force a GC whenever we start a new thread and there are at least N zombies waiting to be disposed, where N=16 for now.
2012-02-03 19:00:02 +00:00
expect(s, m->threadCount == 0);
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
Heap* h = m->heap;
Processor* p = m->processor;
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
Classpath* c = m->classpath;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
Finder* bf = m->bootFinder;
Finder* af = m->appFinder;
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
add support for accessing embedded JARs as if they were directories This allows OpenJDK to access time zone data which is normally found under java.home, but which we must embed in the executable itself to create a self-contained build. The VM intercepts various file operations, looking for paths which start with a prefix specified by the avian.embed.prefix property and redirecting those operations to an embedded JAR. For example, if avian.embed.prefix is "/avian-embedded", and code calls File.exists() with a path of "/avian-embedded/javahomeJar/foo.txt", the VM looks for a function named javahomeJar via dlsym, calls the function to find the memory region containing the embeded JAR, and finally consults the JAR to see if the file "foo.txt" exists.
2010-11-05 19:18:28 +00:00
c->dispose();
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
h->disposeFixies();
add optional LZMA support for compressing embedded JARs, boot images, and shared objects
2012-06-02 15:06:22 +00:00
m->dispose();
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
p->dispose();
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
bf->dispose();
af->dispose();
add support for accessing embedded JARs as if they were directories This allows OpenJDK to access time zone data which is normally found under java.home, but which we must embed in the executable itself to create a self-contained build. The VM intercepts various file operations, looking for paths which start with a prefix specified by the avian.embed.prefix property and redirecting those operations to an embedded JAR. For example, if avian.embed.prefix is "/avian-embedded", and code calls File.exists() with a path of "/avian-embedded/javahomeJar/foo.txt", the VM looks for a function named javahomeJar via dlsym, calls the function to find the memory region containing the embeded JAR, and finally consults the JAR to see if the file "foo.txt" exists.
2010-11-05 19:18:28 +00:00
h->dispose();
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
s->dispose();
}
more refactoring
2007-07-06 23:50:26 +00:00
void
progress on thread support
2007-07-07 18:09:16 +00:00
killZombies(Thread* t, Thread* o)
more refactoring
2007-07-06 23:50:26 +00:00
{
progress on thread support
2007-07-07 18:09:16 +00:00
for (Thread* p = o->child; p;) {
Thread* child = p;
p = p->peer;
killZombies(t, child);
}
avoid running out of OS resources due to zombie thread accumulation (part 2) My previous attempt wasn't quite sufficient, since it was too late to call join on a thread which had already exited given the code was written to aggressively dispose of system handles as soon as the thread exited. The solution is to delay disposing these handles until after we're able to join the thread.
2012-02-04 00:20:20 +00:00
if ((o->flags & Thread::SystemFlag) == 0) {
switch (o->state) {
case Thread::ZombieState:
join(t, o);
// fall through
case Thread::JoinedState:
dispose(t, o, true);
default: break;
}
progress on thread support
2007-07-07 18:09:16 +00:00
}
}
simplify heap.cpp by allocating segments pessimistically
2007-08-18 21:24:29 +00:00
unsigned
footprint(Thread* t)
{
fix incorrect reporting of fixie collection status in heap.cpp (part 2) My earlier fix (f8e8609) was almost -- but not quite -- sufficient. It asked the heap to mark the dead fixies too early, so some of them were marked dead even though they ultimately survived, causing us to clear weak JNI references when we shouldn't.
2012-09-12 23:23:19 +00:00
expect(t, t->criticalLevel == 0);
include Thread::backupHeapIndex in heap footprint calculation
2008-07-12 01:21:53 +00:00
unsigned n = t->heapOffset + t->heapIndex + t->backupHeapIndex;
simplify heap.cpp by allocating segments pessimistically
2007-08-18 21:24:29 +00:00
for (Thread* c = t->child; c; c = c->peer) {
n += footprint(c);
}
return n;
}
bugfixes
2007-07-07 23:47:35 +00:00
void
visitRoots(Thread* t, Heap::Visitor* v)
{
if (t->state != Thread::ZombieState) {
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
v->visit(&(t->javaThread));
v->visit(&(t->exception));
bugfixes
2007-07-07 23:47:35 +00:00
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
t->m->processor->visitObjects(t, v);
bugfixes
2007-07-07 23:47:35 +00:00
for (Thread::Protector* p = t->protector; p; p = p->next) {
JIT GC progress; fix interface method lookup bug
2007-10-12 17:56:43 +00:00
p->visit(v);
bugfixes
2007-07-07 23:47:35 +00:00
}
}
for (Thread* c = t->child; c; c = c->peer) {
visitRoots(c, v);
}
}
GC bugfixes
2009-05-17 23:43:48 +00:00
bool
initial sketch of singleton support
2007-11-02 14:15:06 +00:00
walk(Thread*, Heap::Walker* w, uint32_t* mask, unsigned fixedSize,
Merge branch 'master' into powerpc Conflicts: makefile src/assembler.h src/compile.cpp src/compiler.cpp src/compiler.h src/finder.cpp
2008-11-11 15:20:49 +00:00
unsigned arrayElementSize, unsigned arrayLength, unsigned start)
initial sketch of singleton support
2007-11-02 14:15:06 +00:00
{
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
unsigned fixedSizeInWords = ceilingDivide(fixedSize, BytesPerWord);
initial sketch of singleton support
2007-11-02 14:15:06 +00:00
unsigned arrayElementSizeInWords
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
= ceilingDivide(arrayElementSize, BytesPerWord);
initial sketch of singleton support
2007-11-02 14:15:06 +00:00
Merge branch 'master' into powerpc Conflicts: makefile src/assembler.h src/compile.cpp src/compiler.cpp src/compiler.h src/finder.cpp
2008-11-11 15:20:49 +00:00
for (unsigned i = start; i < fixedSizeInWords; ++i) {
initial sketch of singleton support
2007-11-02 14:15:06 +00:00
if (mask[i / 32] & (static_cast<uint32_t>(1) << (i % 32))) {
if (not w->visit(i)) {
GC bugfixes
2009-05-17 23:43:48 +00:00
return false;
initial sketch of singleton support
2007-11-02 14:15:06 +00:00
}
}
}
bool arrayObjectElements = false;
for (unsigned j = 0; j < arrayElementSizeInWords; ++j) {
unsigned k = fixedSizeInWords + j;
if (mask[k / 32] & (static_cast<uint32_t>(1) << (k % 32))) {
arrayObjectElements = true;
break;
}
}
if (arrayObjectElements) {
Merge branch 'master' into powerpc Conflicts: makefile src/assembler.h src/compile.cpp src/compiler.cpp src/compiler.h src/finder.cpp
2008-11-11 15:20:49 +00:00
unsigned arrayStart;
unsigned elementStart;
if (start > fixedSizeInWords) {
unsigned s = start - fixedSizeInWords;
arrayStart = s / arrayElementSizeInWords;
elementStart = s % arrayElementSizeInWords;
} else {
arrayStart = 0;
elementStart = 0;
}
for (unsigned i = arrayStart; i < arrayLength; ++i) {
for (unsigned j = elementStart; j < arrayElementSizeInWords; ++j) {
initial sketch of singleton support
2007-11-02 14:15:06 +00:00
unsigned k = fixedSizeInWords + j;
if (mask[k / 32] & (static_cast<uint32_t>(1) << (k % 32))) {
if (not w->visit
(fixedSizeInWords + (i * arrayElementSizeInWords) + j))
{
GC bugfixes
2009-05-17 23:43:48 +00:00
return false;
initial sketch of singleton support
2007-11-02 14:15:06 +00:00
}
}
}
}
}
GC bugfixes
2009-05-17 23:43:48 +00:00
return true;
initial sketch of singleton support
2007-11-02 14:15:06 +00:00
}
check superinterfaces when looking up methods and fields
2009-08-03 22:16:41 +00:00
object
findInInterfaces(Thread* t, object class_, object name, object spec,
object (*find)(Thread*, object, object, object))
{
object result = 0;
if (classInterfaceTable(t, class_)) {
for (unsigned i = 0;
i < arrayLength(t, classInterfaceTable(t, class_)) and result == 0;
i += 2)
{
result = find
(t, arrayBody(t, classInterfaceTable(t, class_), i), name, spec);
}
}
return result;
}
implement fixed object support
2007-10-28 01:54:30 +00:00
void
finalizerTargetUnreachable(Thread* t, Heap::Visitor* v, object* p)
GC stress fixes and other bugfixes; classpath progress
2007-07-29 23:32:23 +00:00
{
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
v->visit(&finalizerTarget(t, *p));
GC stress fixes and other bugfixes; classpath progress
2007-07-29 23:32:23 +00:00
object finalizer = *p;
*p = finalizerNext(t, finalizer);
avoid calling doCollect recursively We must not allocate heap objects from doCollect, since it might trigger a GC while one is already in progress, which can cause trouble when we're still queuing up objects to finalize, among other things. To avoid this, I've added extra fields to the finalizer and cleaner types which we can use to link instances up during GC without allocating new memory.
2011-03-26 01:11:38 +00:00
void (*function)(Thread*, object);
memcpy(&function, &finalizerFinalize(t, finalizer), BytesPerWord);
if (function) {
finalizerNext(t, finalizer) = t->m->finalizeQueue;
t->m->finalizeQueue = finalizer;
} else {
set(t, finalizer, FinalizerQueueTarget, finalizerTarget(t, finalizer));
set(t, finalizer, FinalizerQueueNext, root(t, Machine::ObjectsToFinalize));
setRoot(t, Machine::ObjectsToFinalize, finalizer);
}
GC stress fixes and other bugfixes; classpath progress
2007-07-29 23:32:23 +00:00
}
more work on java/lang/ref/* support
2007-07-20 01:07:30 +00:00
void
implement fixed object support
2007-10-28 01:54:30 +00:00
referenceTargetUnreachable(Thread* t, Heap::Visitor* v, object* p)
more work on java/lang/ref/* support
2007-07-20 01:07:30 +00:00
{
GC stress fixes and other bugfixes; classpath progress
2007-07-29 23:32:23 +00:00
if (DebugReferences) {
fprintf(stderr, "target %p unreachable for reference %p\n",
jreferenceTarget(t, *p), *p);
}
add a bunch of classes to classpath and flesh out a few existing ones
2007-07-21 17:50:26 +00:00
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
v->visit(p);
more work on java/lang/ref/* support
2007-07-20 01:07:30 +00:00
jreferenceTarget(t, *p) = 0;
check for and handle instances of sun.misc.Cleaner during GC OpenJDK uses an alternative to Object.finalize for resource cleanup in the form of sun.misc.Cleaner. Normally, OpenJDK's java.lang.ref.Reference.ReferenceHandler thread handles this, calling Cleaner.clean on any instances it finds in its "pending" queue. However, Avian handles reference queuing internally, so it never actually adds anything to that queue, so the VM must call Cleaner.clean itself.
2011-03-19 21:10:52 +00:00
if (objectClass(t, *p) == type(t, Machine::CleanerType)) {
object reference = *p;
*p = jreferenceVmNext(t, reference);
avoid calling doCollect recursively We must not allocate heap objects from doCollect, since it might trigger a GC while one is already in progress, which can cause trouble when we're still queuing up objects to finalize, among other things. To avoid this, I've added extra fields to the finalizer and cleaner types which we can use to link instances up during GC without allocating new memory.
2011-03-26 01:11:38 +00:00
set(t, reference, CleanerQueueNext, root(t, Machine::ObjectsToClean));
setRoot(t, Machine::ObjectsToClean, reference);
check for and handle instances of sun.misc.Cleaner during GC OpenJDK uses an alternative to Object.finalize for resource cleanup in the form of sun.misc.Cleaner. Normally, OpenJDK's java.lang.ref.Reference.ReferenceHandler thread handles this, calling Cleaner.clean on any instances it finds in its "pending" queue. However, Avian handles reference queuing internally, so it never actually adds anything to that queue, so the VM must call Cleaner.clean itself.
2011-03-19 21:10:52 +00:00
} else {
if (jreferenceQueue(t, *p)
and t->m->heap->status(jreferenceQueue(t, *p)) != Heap::Unreachable)
{
// queue is reachable - add the reference
more work on java/lang/ref/* support
2007-07-20 01:07:30 +00:00
check for and handle instances of sun.misc.Cleaner during GC OpenJDK uses an alternative to Object.finalize for resource cleanup in the form of sun.misc.Cleaner. Normally, OpenJDK's java.lang.ref.Reference.ReferenceHandler thread handles this, calling Cleaner.clean on any instances it finds in its "pending" queue. However, Avian handles reference queuing internally, so it never actually adds anything to that queue, so the VM must call Cleaner.clean itself.
2011-03-19 21:10:52 +00:00
v->visit(&jreferenceQueue(t, *p));
more work on java/lang/ref/* support
2007-07-20 01:07:30 +00:00
check for and handle instances of sun.misc.Cleaner during GC OpenJDK uses an alternative to Object.finalize for resource cleanup in the form of sun.misc.Cleaner. Normally, OpenJDK's java.lang.ref.Reference.ReferenceHandler thread handles this, calling Cleaner.clean on any instances it finds in its "pending" queue. However, Avian handles reference queuing internally, so it never actually adds anything to that queue, so the VM must call Cleaner.clean itself.
2011-03-19 21:10:52 +00:00
object q = jreferenceQueue(t, *p);
more work on java/lang/ref/* support
2007-07-20 01:07:30 +00:00
check for and handle instances of sun.misc.Cleaner during GC OpenJDK uses an alternative to Object.finalize for resource cleanup in the form of sun.misc.Cleaner. Normally, OpenJDK's java.lang.ref.Reference.ReferenceHandler thread handles this, calling Cleaner.clean on any instances it finds in its "pending" queue. However, Avian handles reference queuing internally, so it never actually adds anything to that queue, so the VM must call Cleaner.clean itself.
2011-03-19 21:10:52 +00:00
if (referenceQueueFront(t, q)) {
set(t, *p, JreferenceJNext, referenceQueueFront(t, q));
} else {
set(t, *p, JreferenceJNext, *p);
}
set(t, q, ReferenceQueueFront, *p);
jreferenceQueue(t, *p) = 0;
more work on java/lang/ref/* support
2007-07-20 01:07:30 +00:00
}
check for and handle instances of sun.misc.Cleaner during GC OpenJDK uses an alternative to Object.finalize for resource cleanup in the form of sun.misc.Cleaner. Normally, OpenJDK's java.lang.ref.Reference.ReferenceHandler thread handles this, calling Cleaner.clean on any instances it finds in its "pending" queue. However, Avian handles reference queuing internally, so it never actually adds anything to that queue, so the VM must call Cleaner.clean itself.
2011-03-19 21:10:52 +00:00
*p = jreferenceVmNext(t, *p);
more work on java/lang/ref/* support
2007-07-20 01:07:30 +00:00
}
}
finish java/lang/ref/* support; add wrapper classes for primitives
2007-07-20 03:18:25 +00:00
void
implement fixed object support
2007-10-28 01:54:30 +00:00
referenceUnreachable(Thread* t, Heap::Visitor* v, object* p)
finish java/lang/ref/* support; add wrapper classes for primitives
2007-07-20 03:18:25 +00:00
{
follow reference pointer before using in in refrenceTargetUnreachable in case it points to a moved object
2009-09-02 00:32:21 +00:00
object r = static_cast<object>(t->m->heap->follow(*p));
GC stress fixes and other bugfixes; classpath progress
2007-07-29 23:32:23 +00:00
if (DebugReferences) {
fprintf(stderr, "reference %p unreachable (target %p)\n",
follow reference pointer before using in in refrenceTargetUnreachable in case it points to a moved object
2009-09-02 00:32:21 +00:00
*p, jreferenceTarget(t, r));
GC stress fixes and other bugfixes; classpath progress
2007-07-29 23:32:23 +00:00
}
add a bunch of classes to classpath and flesh out a few existing ones
2007-07-21 17:50:26 +00:00
follow reference pointer before using in in refrenceTargetUnreachable in case it points to a moved object
2009-09-02 00:32:21 +00:00
if (jreferenceQueue(t, r)
and t->m->heap->status(jreferenceQueue(t, r)) != Heap::Unreachable)
finish java/lang/ref/* support; add wrapper classes for primitives
2007-07-20 03:18:25 +00:00
{
// queue is reachable - add the reference
implement fixed object support
2007-10-28 01:54:30 +00:00
referenceTargetUnreachable(t, v, p);
GC stress fixes and other bugfixes; classpath progress
2007-07-29 23:32:23 +00:00
} else {
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
*p = jreferenceVmNext(t, *p);
finish java/lang/ref/* support; add wrapper classes for primitives
2007-07-20 03:18:25 +00:00
}
}
more work on java/lang/ref/* support
2007-07-20 01:07:30 +00:00
void
implement fixed object support
2007-10-28 01:54:30 +00:00
referenceTargetReachable(Thread* t, Heap::Visitor* v, object* p)
more work on java/lang/ref/* support
2007-07-20 01:07:30 +00:00
{
GC stress fixes and other bugfixes; classpath progress
2007-07-29 23:32:23 +00:00
if (DebugReferences) {
fprintf(stderr, "target %p reachable for reference %p\n",
jreferenceTarget(t, *p), *p);
}
add a bunch of classes to classpath and flesh out a few existing ones
2007-07-21 17:50:26 +00:00
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
v->visit(p);
v->visit(&jreferenceTarget(t, *p));
more work on java/lang/ref/* support
2007-07-20 01:07:30 +00:00
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
if (t->m->heap->status(jreferenceQueue(t, *p)) == Heap::Unreachable) {
more work on java/lang/ref/* support
2007-07-20 01:07:30 +00:00
jreferenceQueue(t, *p) = 0;
} else {
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
v->visit(&jreferenceQueue(t, *p));
more work on java/lang/ref/* support
2007-07-20 01:07:30 +00:00
}
}
clear any weak/soft/phantom references to finalizable objects before queuing If we don't clear these references, we risk finalizing objects which can still be reached by one of the special reference types. It's a bit of a chicken-and-egg problem. We need to visit finalizable objects before visiting weak references, since some of the weak references and/or their targets may become reachable once the finalizable objects are visited. However, that ordering means we have no efficient way of distinguishing between objects which are reachable from one or more normal GC roots and those which are only reachable via the finalization queue. The solution is to clear all weak references to finalizable objects before visiting them.
2012-10-05 16:06:01 +00:00
bool
isFinalizable(Thread* t, object o)
{
return t->m->heap->status(o) == Heap::Unreachable
and (classVmFlags
(t, static_cast<object>(t->m->heap->follow(objectClass(t, o))))
& HasFinalizerFlag);
}
void
clearTargetIfFinalizable(Thread* t, object r)
{
if (isFinalizable
(t, static_cast<object>(t->m->heap->follow(jreferenceTarget(t, r)))))
{
jreferenceTarget(t, r) = 0;
}
}
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
void
postVisit(Thread* t, Heap::Visitor* v)
{
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
Machine* m = t->m;
implement fixed object support
2007-10-28 01:54:30 +00:00
bool major = m->heap->collectionType() == Heap::MajorCollection;
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
remove obsolete code from postVisit; upgrade assert to expect for debugging
2008-08-11 21:16:55 +00:00
assert(t, m->finalizeQueue == 0);
GC stress fixes and other bugfixes; classpath progress
2007-07-29 23:32:23 +00:00
clear any weak/soft/phantom references to finalizable objects before queuing If we don't clear these references, we risk finalizing objects which can still be reached by one of the special reference types. It's a bit of a chicken-and-egg problem. We need to visit finalizable objects before visiting weak references, since some of the weak references and/or their targets may become reachable once the finalizable objects are visited. However, that ordering means we have no efficient way of distinguishing between objects which are reachable from one or more normal GC roots and those which are only reachable via the finalization queue. The solution is to clear all weak references to finalizable objects before visiting them.
2012-10-05 16:06:01 +00:00
m->heap->postVisit();
for (object p = m->weakReferences; p;) {
object r = static_cast<object>(m->heap->follow(p));
p = jreferenceVmNext(t, r);
clearTargetIfFinalizable(t, r);
}
if (major) {
for (object p = m->tenuredWeakReferences; p;) {
object r = static_cast<object>(m->heap->follow(p));
p = jreferenceVmNext(t, r);
clearTargetIfFinalizable(t, r);
}
}
for (Reference* r = m->jniReferences; r; r = r->next) {
if (r->weak and isFinalizable
(t, static_cast<object>(t->m->heap->follow(r->target))))
{
r->target = 0;
}
}
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
object firstNewTenuredFinalizer = 0;
object lastNewTenuredFinalizer = 0;
for (object* p = &(m->finalizers); *p;) {
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
v->visit(p);
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
if (m->heap->status(finalizerTarget(t, *p)) == Heap::Unreachable) {
// target is unreachable - queue it up for finalization
implement fixed object support
2007-10-28 01:54:30 +00:00
finalizerTargetUnreachable(t, v, p);
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
} else {
// target is reachable
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
v->visit(&finalizerTarget(t, *p));
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
if (m->heap->status(*p) == Heap::Tenured) {
// the finalizer is tenured, so we remove it from
// m->finalizers and later add it to m->tenuredFinalizers
if (lastNewTenuredFinalizer == 0) {
lastNewTenuredFinalizer = *p;
}
object finalizer = *p;
*p = finalizerNext(t, finalizer);
finalizerNext(t, finalizer) = firstNewTenuredFinalizer;
firstNewTenuredFinalizer = finalizer;
} else {
p = &finalizerNext(t, *p);
}
}
}
object firstNewTenuredWeakReference = 0;
object lastNewTenuredWeakReference = 0;
for (object* p = &(m->weakReferences); *p;) {
if (m->heap->status(*p) == Heap::Unreachable) {
finish java/lang/ref/* support; add wrapper classes for primitives
2007-07-20 03:18:25 +00:00
// reference is unreachable
implement fixed object support
2007-10-28 01:54:30 +00:00
referenceUnreachable(t, v, p);
fix handling of reachable, moved weak references in postVisit
2009-09-01 23:23:30 +00:00
} else if (m->heap->status
(jreferenceTarget
(t, static_cast<object>(m->heap->follow(*p))))
various bugfixes
2007-08-14 00:37:00 +00:00
== Heap::Unreachable)
{
finish java/lang/ref/* support; add wrapper classes for primitives
2007-07-20 03:18:25 +00:00
// target is unreachable
implement fixed object support
2007-10-28 01:54:30 +00:00
referenceTargetUnreachable(t, v, p);
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
} else {
// both reference and target are reachable
implement fixed object support
2007-10-28 01:54:30 +00:00
referenceTargetReachable(t, v, p);
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
if (m->heap->status(*p) == Heap::Tenured) {
// the reference is tenured, so we remove it from
// m->weakReferences and later add it to
// m->tenuredWeakReferences
if (lastNewTenuredWeakReference == 0) {
lastNewTenuredWeakReference = *p;
}
object reference = *p;
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
*p = jreferenceVmNext(t, reference);
jreferenceVmNext(t, reference) = firstNewTenuredWeakReference;
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
firstNewTenuredWeakReference = reference;
} else {
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
p = &jreferenceVmNext(t, *p);
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
}
}
}
implement fixed object support
2007-10-28 01:54:30 +00:00
if (major) {
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
for (object* p = &(m->tenuredFinalizers); *p;) {
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
v->visit(p);
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
if (m->heap->status(finalizerTarget(t, *p)) == Heap::Unreachable) {
// target is unreachable - queue it up for finalization
implement fixed object support
2007-10-28 01:54:30 +00:00
finalizerTargetUnreachable(t, v, p);
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
} else {
// target is reachable
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
v->visit(&finalizerTarget(t, *p));
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
p = &finalizerNext(t, *p);
}
}
for (object* p = &(m->tenuredWeakReferences); *p;) {
if (m->heap->status(*p) == Heap::Unreachable) {
finish java/lang/ref/* support; add wrapper classes for primitives
2007-07-20 03:18:25 +00:00
// reference is unreachable
implement fixed object support
2007-10-28 01:54:30 +00:00
referenceUnreachable(t, v, p);
fix handling of reachable, moved weak references in postVisit
2009-09-01 23:23:30 +00:00
} else if (m->heap->status
(jreferenceTarget
(t, static_cast<object>(m->heap->follow(*p))))
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
== Heap::Unreachable)
{
finish java/lang/ref/* support; add wrapper classes for primitives
2007-07-20 03:18:25 +00:00
// target is unreachable
implement fixed object support
2007-10-28 01:54:30 +00:00
referenceTargetUnreachable(t, v, p);
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
} else {
finish java/lang/ref/* support; add wrapper classes for primitives
2007-07-20 03:18:25 +00:00
// both reference and target are reachable
implement fixed object support
2007-10-28 01:54:30 +00:00
referenceTargetReachable(t, v, p);
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
p = &jreferenceVmNext(t, *p);
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
}
}
}
if (lastNewTenuredFinalizer) {
finalizerNext(t, lastNewTenuredFinalizer) = m->tenuredFinalizers;
fix handling of newly-tenured finalizers and weak references in postVisit()
2007-07-11 13:35:28 +00:00
m->tenuredFinalizers = firstNewTenuredFinalizer;
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
}
if (lastNewTenuredWeakReference) {
remove obsolete code from postVisit; upgrade assert to expect for debugging
2008-08-11 21:16:55 +00:00
jreferenceVmNext(t, lastNewTenuredWeakReference)
= m->tenuredWeakReferences;
fix handling of newly-tenured finalizers and weak references in postVisit()
2007-07-11 13:35:28 +00:00
m->tenuredWeakReferences = firstNewTenuredWeakReference;
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
}
implement JNI methods NewWeakGlobalRef and DeleteWeakGlobalRef
2012-02-29 18:51:30 +00:00
for (Reference* r = m->jniReferences; r; r = r->next) {
if (r->weak) {
if (m->heap->status(r->target) == Heap::Unreachable) {
r->target = 0;
} else {
v->visit(&(r->target));
}
}
}
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
}
bugfixes
2007-07-07 23:47:35 +00:00
void
postCollect(Thread* t)
{
fix various bugs uncovered in GC stress test
2007-07-16 23:58:37 +00:00
#ifdef VM_STRESS
increase heap pool size and fixed footprint threshold constants based on performance profiling and experimentation
2008-11-22 21:47:18 +00:00
t->m->heap->free(t->defaultHeap, ThreadHeapSizeInBytes);
bugfixes
2007-09-13 03:15:16 +00:00
t->defaultHeap = static_cast<uintptr_t*>
increase heap pool size and fixed footprint threshold constants based on performance profiling and experimentation
2008-11-22 21:47:18 +00:00
(t->m->heap->allocate(ThreadHeapSizeInBytes));
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
memset(t->defaultHeap, 0, ThreadHeapSizeInBytes);
fix various bugs uncovered in GC stress test
2007-07-16 23:58:37 +00:00
#endif
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
if (t->heap == t->defaultHeap) {
memset(t->defaultHeap, 0, t->heapIndex * BytesPerWord);
} else {
memset(t->defaultHeap, 0, ThreadHeapSizeInBytes);
t->heap = t->defaultHeap;
}
fix bug in calculating GC footprint in new heap pool code
2007-08-23 02:24:25 +00:00
t->heapOffset = 0;
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
if (t->m->heap->limitExceeded()) {
// if we're out of memory, pretend the thread-local heap is
// already full so we don't make things worse:
t->heapIndex = ThreadHeapSizeInWords;
} else {
t->heapIndex = 0;
}
bugfixes
2007-07-07 23:47:35 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
if (t->flags & Thread::UseBackupHeapFlag) {
pre-allocate Thread::backupHeap for signal safety It's not safe to use malloc from a signal handler, so we can't allocate new memory when handling segfaults or Thread.getStackTrace signals. Instead, we allocate a fixed-size backup heap for each thread ahead of time and use it if there's no space left in the normal heap pool. In the rare case that the backup heap isn't large enough, we fall back to using a preallocated exception without a stack trace as a last resort.
2010-06-19 22:40:21 +00:00
memset(t->backupHeap, 0, ThreadBackupHeapSizeInBytes);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
t->flags &= ~Thread::UseBackupHeapFlag;
more progress on general stack tracing
2008-04-09 19:08:13 +00:00
t->backupHeapIndex = 0;
}
bugfixes
2007-07-07 23:47:35 +00:00
for (Thread* c = t->child; c; c = c->peer) {
postCollect(c);
}
}
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
uint64_t
invoke(Thread* t, uintptr_t* arguments)
{
fix mode=stress thinko and GC safety issue in machine.cpp
2011-03-17 14:49:41 +00:00
object m = *reinterpret_cast<object*>(arguments[0]);
object o = *reinterpret_cast<object*>(arguments[1]);
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
t->m->processor->invoke(t, m, o);
return 1;
}
implement basic finalization support This implementation does not conform to the Java standard in that finalize methods are called from whichever thread happens to be garbage collecting, and that thread may hold locks, whereas the standard guarantees that finalize will be run from a thread which holds no locks. Also, an object will never be finalized more than once, even if its finalize method "rescues" (i.e. makes reachable) the object such that it might become unreachable a second time and thus a candidate for finalization once more. It's not clear to me from the standard if this is OK or not. Nonwithstanding the above, this implementation is useful for "normal" finalize methods which simply release resources associated with an object.
2009-07-22 00:57:55 +00:00
void
check for and handle instances of sun.misc.Cleaner during GC OpenJDK uses an alternative to Object.finalize for resource cleanup in the form of sun.misc.Cleaner. Normally, OpenJDK's java.lang.ref.Reference.ReferenceHandler thread handles this, calling Cleaner.clean on any instances it finds in its "pending" queue. However, Avian handles reference queuing internally, so it never actually adds anything to that queue, so the VM must call Cleaner.clean itself.
2011-03-19 21:10:52 +00:00
finalizeObject(Thread* t, object o, const char* name)
implement basic finalization support This implementation does not conform to the Java standard in that finalize methods are called from whichever thread happens to be garbage collecting, and that thread may hold locks, whereas the standard guarantees that finalize will be run from a thread which holds no locks. Also, an object will never be finalized more than once, even if its finalize method "rescues" (i.e. makes reachable) the object such that it might become unreachable a second time and thus a candidate for finalization once more. It's not clear to me from the standard if this is OK or not. Nonwithstanding the above, this implementation is useful for "normal" finalize methods which simply release resources associated with an object.
2009-07-22 00:57:55 +00:00
{
for (object c = objectClass(t, o); c; c = classSuper(t, c)) {
for (unsigned i = 0; i < arrayLength(t, classMethodTable(t, c)); ++i) {
object m = arrayBody(t, classMethodTable(t, c), i);
check for and handle instances of sun.misc.Cleaner during GC OpenJDK uses an alternative to Object.finalize for resource cleanup in the form of sun.misc.Cleaner. Normally, OpenJDK's java.lang.ref.Reference.ReferenceHandler thread handles this, calling Cleaner.clean on any instances it finds in its "pending" queue. However, Avian handles reference queuing internally, so it never actually adds anything to that queue, so the VM must call Cleaner.clean itself.
2011-03-19 21:10:52 +00:00
if (vm::strcmp(reinterpret_cast<const int8_t*>(name),
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
&byteArrayBody(t, methodName(t, m), 0)) == 0
and vm::strcmp(reinterpret_cast<const int8_t*>("()V"),
&byteArrayBody(t, methodSpec(t, m), 0)) == 0)
implement basic finalization support This implementation does not conform to the Java standard in that finalize methods are called from whichever thread happens to be garbage collecting, and that thread may hold locks, whereas the standard guarantees that finalize will be run from a thread which holds no locks. Also, an object will never be finalized more than once, even if its finalize method "rescues" (i.e. makes reachable) the object such that it might become unreachable a second time and thus a candidate for finalization once more. It's not clear to me from the standard if this is OK or not. Nonwithstanding the above, this implementation is useful for "normal" finalize methods which simply release resources associated with an object.
2009-07-22 00:57:55 +00:00
{
fix mode=stress thinko and GC safety issue in machine.cpp
2011-03-17 14:49:41 +00:00
PROTECT(t, m);
PROTECT(t, o);
uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(&m),
reinterpret_cast<uintptr_t>(&o) };
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
run(t, invoke, arguments);
implement basic finalization support This implementation does not conform to the Java standard in that finalize methods are called from whichever thread happens to be garbage collecting, and that thread may hold locks, whereas the standard guarantees that finalize will be run from a thread which holds no locks. Also, an object will never be finalized more than once, even if its finalize method "rescues" (i.e. makes reachable) the object such that it might become unreachable a second time and thus a candidate for finalization once more. It's not clear to me from the standard if this is OK or not. Nonwithstanding the above, this implementation is useful for "normal" finalize methods which simply release resources associated with an object.
2009-07-22 00:57:55 +00:00
t->exception = 0;
return;
}
}
}
abort(t);
}
fix reading 2-byte UTF-8 constants
2009-08-14 14:52:31 +00:00
unsigned
fix handling of classe, method, and field names with non-ASCII characters
2013-02-03 21:09:29 +00:00
readByte(AbstractStream& s, unsigned* value)
fix reading 2-byte UTF-8 constants
2009-08-14 14:52:31 +00:00
{
if (*value == NoByte) {
return s.read1();
} else {
unsigned r = *value;
*value = NoByte;
return r;
}
}
primitive parseUtf8() implementation to ensure we handle null characters correctly, at least
2007-10-24 21:05:15 +00:00
object
fix handling of classe, method, and field names with non-ASCII characters
2013-02-03 21:09:29 +00:00
parseUtf8NonAscii(Thread* t, AbstractStream& s, object bytesSoFar,
unsigned byteCount, unsigned sourceIndex, unsigned byteA,
unsigned byteB)
primitive parseUtf8() implementation to ensure we handle null characters correctly, at least
2007-10-24 21:05:15 +00:00
{
more progress on GNU Classpath compatibility
2009-06-04 23:21:42 +00:00
PROTECT(t, bytesSoFar);
unsigned length = byteArrayLength(t, bytesSoFar) - 1;
object value = makeCharArray(t, length + 1);
primitive parseUtf8() implementation to ensure we handle null characters correctly, at least
2007-10-24 21:05:15 +00:00
unsigned vi = 0;
more progress on GNU Classpath compatibility
2009-06-04 23:21:42 +00:00
for (; vi < byteCount; ++vi) {
charArrayBody(t, value, vi) = byteArrayBody(t, bytesSoFar, vi);
}
fix reading 2-byte UTF-8 constants
2009-08-14 14:52:31 +00:00
for (unsigned si = sourceIndex; si < length; ++si) {
unsigned a = readByte(s, &byteA);
primitive parseUtf8() implementation to ensure we handle null characters correctly, at least
2007-10-24 21:05:15 +00:00
if (a & 0x80) {
Read 2- and 3-byte UTF8 constants gracefully (but not correctly)
2007-10-25 23:58:53 +00:00
if (a & 0x20) {
// 3 bytes
si += 2;
assert(t, si < length);
fix reading 2-byte UTF-8 constants
2009-08-14 14:52:31 +00:00
unsigned b = readByte(s, &byteB);
more progress on GNU Classpath compatibility
2009-06-04 23:21:42 +00:00
unsigned c = s.read1();
charArrayBody(t, value, vi++)
= ((a & 0xf) << 12) | ((b & 0x3f) << 6) | (c & 0x3f);
primitive parseUtf8() implementation to ensure we handle null characters correctly, at least
2007-10-24 21:05:15 +00:00
} else {
Read 2- and 3-byte UTF8 constants gracefully (but not correctly)
2007-10-25 23:58:53 +00:00
// 2 bytes
++ si;
assert(t, si < length);
fix reading 2-byte UTF-8 constants
2009-08-14 14:52:31 +00:00
unsigned b = readByte(s, &byteB);
Read 2- and 3-byte UTF8 constants gracefully (but not correctly)
2007-10-25 23:58:53 +00:00
if (a == 0xC0 and b == 0x80) {
more progress on GNU Classpath compatibility
2009-06-04 23:21:42 +00:00
charArrayBody(t, value, vi++) = 0;
} else {
charArrayBody(t, value, vi++) = ((a & 0x1f) << 6) | (b & 0x3f);
}
}
} else {
charArrayBody(t, value, vi++) = a;
}
}
if (vi < length) {
PROTECT(t, value);
object v = makeCharArray(t, vi + 1);
memcpy(&charArrayBody(t, v, 0), &charArrayBody(t, value, 0), vi * 2);
value = v;
}
return value;
}
object
fix handling of classe, method, and field names with non-ASCII characters
2013-02-03 21:09:29 +00:00
parseUtf8(Thread* t, AbstractStream& s, unsigned length)
more progress on GNU Classpath compatibility
2009-06-04 23:21:42 +00:00
{
object value = makeByteArray(t, length + 1);
unsigned vi = 0;
for (unsigned si = 0; si < length; ++si) {
unsigned a = s.read1();
if (a & 0x80) {
if (a & 0x20) {
// 3 bytes
fix reading 2-byte UTF-8 constants
2009-08-14 14:52:31 +00:00
return parseUtf8NonAscii(t, s, value, vi, si, a, NoByte);
more progress on GNU Classpath compatibility
2009-06-04 23:21:42 +00:00
} else {
// 2 bytes
unsigned b = s.read1();
if (a == 0xC0 and b == 0x80) {
++ si;
assert(t, si < length);
Read 2- and 3-byte UTF8 constants gracefully (but not correctly)
2007-10-25 23:58:53 +00:00
byteArrayBody(t, value, vi++) = 0;
} else {
fix reading 2-byte UTF-8 constants
2009-08-14 14:52:31 +00:00
return parseUtf8NonAscii(t, s, value, vi, si, a, b);
Read 2- and 3-byte UTF8 constants gracefully (but not correctly)
2007-10-25 23:58:53 +00:00
}
primitive parseUtf8() implementation to ensure we handle null characters correctly, at least
2007-10-24 21:05:15 +00:00
}
} else {
superficial tweak
2007-10-24 23:05:14 +00:00
byteArrayBody(t, value, vi++) = a;
primitive parseUtf8() implementation to ensure we handle null characters correctly, at least
2007-10-24 21:05:15 +00:00
}
}
if (vi < length) {
PROTECT(t, value);
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
object v = makeByteArray(t, vi + 1);
primitive parseUtf8() implementation to ensure we handle null characters correctly, at least
2007-10-24 21:05:15 +00:00
memcpy(&byteArrayBody(t, v, 0), &byteArrayBody(t, value, 0), vi);
value = v;
}
return value;
}
fix handling of classe, method, and field names with non-ASCII characters
2013-02-03 21:09:29 +00:00
object
makeByteArray(Thread* t, Stream& s, unsigned length)
{
object value = makeByteArray(t, length + 1);
s.read(reinterpret_cast<uint8_t*>(&byteArrayBody(t, value, 0)), length);
return value;
}
intern CONSTANT_Utf8 pool entries to save memory and reduce bootimage size
2009-06-07 00:26:23 +00:00
void
removeByteArray(Thread* t, object o)
{
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
hashMapRemove
(t, root(t, Machine::ByteArrayMap), o, byteArrayHash, objectEqual);
intern CONSTANT_Utf8 pool entries to save memory and reduce bootimage size
2009-06-07 00:26:23 +00:00
}
object
internByteArray(Thread* t, object array)
{
PROTECT(t, array);
fix custom-classloader-related concurrency problems and other bugs The main changes in this commit ensure that we don't hold the global class lock when doing class resolution using application-defined classloaders. Such classloaders may do their own locking (in fact, it's almost certain), making deadlock likely when mixed with VM-level locking in various orders. Other changes include a fix to avoid overflow when waiting for extremely long intervals and a GC root stack mapping bug.
2010-09-17 01:43:27 +00:00
ACQUIRE(t, t->m->referenceLock);
intern CONSTANT_Utf8 pool entries to save memory and reduce bootimage size
2009-06-07 00:26:23 +00:00
object n = hashMapFindNode
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
(t, root(t, Machine::ByteArrayMap), array, byteArrayHash, byteArrayEqual);
intern CONSTANT_Utf8 pool entries to save memory and reduce bootimage size
2009-06-07 00:26:23 +00:00
if (n) {
return jreferenceTarget(t, tripleFirst(t, n));
} else {
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
hashMapInsert(t, root(t, Machine::ByteArrayMap), array, 0, byteArrayHash);
intern CONSTANT_Utf8 pool entries to save memory and reduce bootimage size
2009-06-07 00:26:23 +00:00
addFinalizer(t, array, removeByteArray);
return array;
}
}
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
unsigned
parsePoolEntry(Thread* t, Stream& s, uint32_t* index, object pool, unsigned i)
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
{
PROTECT(t, pool);
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
s.setPosition(index[i]);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
switch (s.read1()) {
case CONSTANT_Integer:
case CONSTANT_Float: {
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
uint32_t v = s.read4();
singletonValue(t, pool, i) = v;
if(DebugClassReader) {
fprintf(stderr, " consts[%d] = int/float 0x%x\n", i, v);
}
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
} return 1;
case CONSTANT_Long:
case CONSTANT_Double: {
uint64_t v = s.read8();
memcpy(&singletonValue(t, pool, i), &v, 8);
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
if(DebugClassReader) {
fprintf(stderr, " consts[%d] = long/double <todo>\n", i);
}
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
} return 2;
case CONSTANT_Utf8: {
if (singletonObject(t, pool, i) == 0) {
fix handling of classe, method, and field names with non-ASCII characters
2013-02-03 21:09:29 +00:00
object value = internByteArray(t, makeByteArray(t, s, s.read2()));
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
set(t, pool, SingletonBody + (i * BytesPerWord), value);
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
if(DebugClassReader) {
fprintf(stderr, " consts[%d] = utf8 %s\n", i, &byteArrayBody(t, value, 0));
}
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
}
} return 1;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
case CONSTANT_Class: {
if (singletonObject(t, pool, i) == 0) {
unsigned si = s.read2() - 1;
parsePoolEntry(t, s, index, pool, si);
implement ClassLoader.resolveClass and ensure class is linked in e.g. Class.getMethods; minor bugfixes
2009-08-18 20:26:28 +00:00
object value = makeReference(t, 0, singletonObject(t, pool, si), 0);
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
set(t, pool, SingletonBody + (i * BytesPerWord), value);
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
if(DebugClassReader) {
fprintf(stderr, " consts[%d] = class <todo>\n", i);
}
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
}
} return 1;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
case CONSTANT_String: {
if (singletonObject(t, pool, i) == 0) {
unsigned si = s.read2() - 1;
parsePoolEntry(t, s, index, pool, si);
fix handling of classe, method, and field names with non-ASCII characters
2013-02-03 21:09:29 +00:00
object value = parseUtf8(t, singletonObject(t, pool, si));
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
value = t->m->classpath->makeString
rename cast -> fieldAtOffset
2013-02-11 00:38:51 +00:00
(t, value, 0, fieldAtOffset<uintptr_t>(value, BytesPerWord) - 1);
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
value = intern(t, value);
set(t, pool, SingletonBody + (i * BytesPerWord), value);
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
if(DebugClassReader) {
fprintf(stderr, " consts[%d] = string <todo>\n", i);
}
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
}
} return 1;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
case CONSTANT_NameAndType: {
if (singletonObject(t, pool, i) == 0) {
unsigned ni = s.read2() - 1;
unsigned ti = s.read2() - 1;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
parsePoolEntry(t, s, index, pool, ni);
parsePoolEntry(t, s, index, pool, ti);
object name = singletonObject(t, pool, ni);
object type = singletonObject(t, pool, ti);
object value = makePair(t, name, type);
set(t, pool, SingletonBody + (i * BytesPerWord), value);
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
if(DebugClassReader) {
fprintf(stderr, " consts[%d] = nameAndType %s%s\n", i, &byteArrayBody(t, name, 0), &byteArrayBody(t, type, 0));
}
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
}
} return 1;
case CONSTANT_Fieldref:
case CONSTANT_Methodref:
case CONSTANT_InterfaceMethodref: {
if (singletonObject(t, pool, i) == 0) {
unsigned ci = s.read2() - 1;
unsigned nti = s.read2() - 1;
parsePoolEntry(t, s, index, pool, ci);
parsePoolEntry(t, s, index, pool, nti);
fix bug in isAssignableFrom such that primitive array types were considered to be subclasses of the Object array type
2012-02-28 01:16:01 +00:00
implement ClassLoader.resolveClass and ensure class is linked in e.g. Class.getMethods; minor bugfixes
2009-08-18 20:26:28 +00:00
object class_ = referenceName(t, singletonObject(t, pool, ci));
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
object nameAndType = singletonObject(t, pool, nti);
fix bug in isAssignableFrom such that primitive array types were considered to be subclasses of the Object array type
2012-02-28 01:16:01 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
object value = makeReference
(t, class_, pairFirst(t, nameAndType), pairSecond(t, nameAndType));
set(t, pool, SingletonBody + (i * BytesPerWord), value);
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
if(DebugClassReader) {
fprintf(stderr, " consts[%d] = method %s.%s%s\n", i, &byteArrayBody(t, class_, 0), &byteArrayBody(t, pairFirst(t, nameAndType), 0), &byteArrayBody(t, pairSecond(t, nameAndType), 0));
}
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
}
} return 1;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
default: abort(t);
}
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
object
parsePool(Thread* t, Stream& s)
{
unsigned count = s.read2() - 1;
clean up float-vs.-int tracking in constant pools
2009-10-18 02:11:03 +00:00
object pool = makeSingletonOfSize(t, count + poolMaskSize(count));
refactor memory allocation to allow better detection and handling of low-memory conditions
2008-01-13 22:05:08 +00:00
PROTECT(t, pool);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
if(DebugClassReader) {
fprintf(stderr, " const pool entries %d\n", count);
}
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
if (count) {
simplify memory allocation interfaces
2008-04-13 18:15:04 +00:00
uint32_t* index = static_cast<uint32_t*>(t->m->heap->allocate(count * 4));
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
THREAD_RESOURCE2(t, uint32_t*, index, unsigned, count,
t->m->heap->free(index, count * 4));
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
for (unsigned i = 0; i < count; ++i) {
index[i] = s.position();
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
switch (s.read1()) {
case CONSTANT_Class:
case CONSTANT_String:
singletonMarkObject(t, pool, i);
s.skip(2);
break;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
case CONSTANT_Integer:
Merge branch 'master' of git://oss.readytalk.com/avian, fixed problems that occured in broader testing Conflicts: src/compile.cpp src/compiler.cpp src/powerpc.cpp src/x86.S src/x86.cpp
2009-08-10 19:20:23 +00:00
s.skip(4);
break;
clean up float-vs.-int tracking in constant pools
2009-10-18 02:11:03 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
case CONSTANT_Float:
clean up float-vs.-int tracking in constant pools
2009-10-18 02:11:03 +00:00
singletonSetBit(t, pool, count, i);
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
s.skip(4);
break;
case CONSTANT_NameAndType:
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
case CONSTANT_Fieldref:
case CONSTANT_Methodref:
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
case CONSTANT_InterfaceMethodref:
singletonMarkObject(t, pool, i);
s.skip(4);
break;
case CONSTANT_Long:
Merge branch 'master' of git://oss.readytalk.com/avian, fixed problems that occured in broader testing Conflicts: src/compile.cpp src/compiler.cpp src/powerpc.cpp src/x86.S src/x86.cpp
2009-08-10 19:20:23 +00:00
s.skip(8);
++ i;
break;
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
case CONSTANT_Double:
clean up float-vs.-int tracking in constant pools
2009-10-18 02:11:03 +00:00
singletonSetBit(t, pool, count, i);
singletonSetBit(t, pool, count, i + 1);
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
s.skip(8);
++ i;
break;
case CONSTANT_Utf8:
singletonMarkObject(t, pool, i);
s.skip(s.read2());
break;
default: abort(t);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
}
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
unsigned end = s.position();
for (unsigned i = 0; i < count;) {
i += parsePoolEntry(t, s, index, pool, i);
}
s.setPosition(end);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
return pool;
}
void
addInterfaces(Thread* t, object class_, object map)
{
object table = classInterfaceTable(t, class_);
if (table) {
unsigned increment = 2;
if (classFlags(t, class_) & ACC_INTERFACE) {
increment = 1;
}
PROTECT(t, map);
PROTECT(t, table);
for (unsigned i = 0; i < arrayLength(t, table); i += increment) {
object interface = arrayBody(t, table, i);
object name = className(t, interface);
hashMapInsertMaybe(t, map, name, interface, byteArrayHash,
byteArrayEqual);
}
}
}
fix Class.getDeclaredMethods Internally, the VM augments the method tables for abstract classes with any inherited abstract methods to make code simpler elsewhere, but that means we can't use that table to construct the result of Class.getDeclaredMethods since it would include methods not actually declared in the class. This commit ensures that we preserve and use the original, un-augmented table for that purpose.
2011-04-10 03:20:56 +00:00
object
getClassAddendum(Thread* t, object class_, object pool)
{
object addendum = classAddendum(t, class_);
if (addendum == 0) {
fix GC safety bugs in getClassAddendum and makeArrayClass
2011-07-10 00:01:00 +00:00
PROTECT(t, class_);
fix Class.getDeclaredMethods Internally, the VM augments the method tables for abstract classes with any inherited abstract methods to make code simpler elsewhere, but that means we can't use that table to construct the result of Class.getDeclaredMethods since it would include methods not actually declared in the class. This commit ensures that we preserve and use the original, un-augmented table for that purpose.
2011-04-10 03:20:56 +00:00
addendum = makeClassAddendum(t, pool, 0, 0, 0, 0, 0);
set(t, class_, ClassAddendum, addendum);
}
return addendum;
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
void
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
parseInterfaceTable(Thread* t, Stream& s, object class_, object pool,
Machine::Type throwType)
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
{
PROTECT(t, class_);
PROTECT(t, pool);
break native hashMap type into hashMap and weakHashMap; start investgating GC stress failures related to or uncovered by new string interning support
2007-07-29 18:52:08 +00:00
object map = makeHashMap(t, 0, 0);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
PROTECT(t, map);
if (classSuper(t, class_)) {
addInterfaces(t, classSuper(t, class_), map);
}
various threading bugfixes
2007-11-27 22:23:00 +00:00
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
unsigned count = s.read2();
only return declared interfaces from Class.getInterfaces The result of Class.getInterfaces should not include interfaces declared to be implemented/extended by superclasses/superinterfaces, only those declared by the class itself. This is important because it influences how java.io.ObjectStreamClass calculates serial version IDs.
2011-03-28 02:29:31 +00:00
object table = 0;
PROTECT(t, table);
if (count) {
table = makeArray(t, count);
fix Class.getDeclaredMethods Internally, the VM augments the method tables for abstract classes with any inherited abstract methods to make code simpler elsewhere, but that means we can't use that table to construct the result of Class.getDeclaredMethods since it would include methods not actually declared in the class. This commit ensures that we preserve and use the original, un-augmented table for that purpose.
2011-04-10 03:20:56 +00:00
object addendum = getClassAddendum(t, class_, pool);
set(t, addendum, ClassAddendumInterfaceTable, table);
only return declared interfaces from Class.getInterfaces The result of Class.getInterfaces should not include interfaces declared to be implemented/extended by superclasses/superinterfaces, only those declared by the class itself. This is important because it influences how java.io.ObjectStreamClass calculates serial version IDs.
2011-03-28 02:29:31 +00:00
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
for (unsigned i = 0; i < count; ++i) {
implement ClassLoader.resolveClass and ensure class is linked in e.g. Class.getMethods; minor bugfixes
2009-08-18 20:26:28 +00:00
object name = referenceName(t, singletonObject(t, pool, s.read2() - 1));
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
PROTECT(t, name);
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
object interface = resolveClass
(t, classLoader(t, class_), name, true, throwType);
check for exception after calling resolveClass in parseInterfaceTable
2009-08-04 14:50:04 +00:00
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
PROTECT(t, interface);
only return declared interfaces from Class.getInterfaces The result of Class.getInterfaces should not include interfaces declared to be implemented/extended by superclasses/superinterfaces, only those declared by the class itself. This is important because it influences how java.io.ObjectStreamClass calculates serial version IDs.
2011-03-28 02:29:31 +00:00
set(t, table, ArrayBody + (i * BytesPerWord), interface);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
hashMapInsertMaybe(t, map, name, interface, byteArrayHash, byteArrayEqual);
addInterfaces(t, interface, map);
}
object interfaceTable = 0;
if (hashMapSize(t, map)) {
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
unsigned length = hashMapSize(t, map);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
if ((classFlags(t, class_) & ACC_INTERFACE) == 0) {
length *= 2;
}
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
interfaceTable = makeArray(t, length);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
PROTECT(t, interfaceTable);
unsigned i = 0;
avoid creating garbage when iterating over hashmaps
2008-11-22 23:38:41 +00:00
for (HashMapIterator it(t, map); it.hasMore();) {
cache array class lookups in element class; misc. bugfixes
2010-09-25 21:54:01 +00:00
object interface = tripleSecond(t, it.next());
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, interfaceTable, ArrayBody + (i * BytesPerWord), interface);
++ i;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
if ((classFlags(t, class_) & ACC_INTERFACE) == 0) {
various bugfixes
2007-08-14 00:37:00 +00:00
if (classVirtualTable(t, interface)) {
// we'll fill in this table in parseMethodTable():
object vtable = makeArray
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
(t, arrayLength(t, classVirtualTable(t, interface)));
various bugfixes
2007-08-14 00:37:00 +00:00
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, interfaceTable, ArrayBody + (i * BytesPerWord), vtable);
various bugfixes
2007-08-14 00:37:00 +00:00
}
++i;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
}
}
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, class_, ClassInterfaceTable, interfaceTable);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
void
parseFieldTable(Thread* t, Stream& s, object class_, object pool)
{
PROTECT(t, class_);
PROTECT(t, pool);
unsigned memberOffset = BytesPerWord;
if (classSuper(t, class_)) {
memberOffset = classFixedSize(t, classSuper(t, class_));
}
unsigned count = s.read2();
if (count) {
fix sun.misc.Unsafe.getLongVolatile for static fields on 32-bit platforms The existing code did not handle static field lookups for synchronization on 32-bit systems, which is necessary because such systems generally don't support atomic operations on 64-bit values.
2012-09-12 01:21:51 +00:00
unsigned staticOffset = BytesPerWord * 3;
sketch of singleton support
2007-11-02 21:08:14 +00:00
unsigned staticCount = 0;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
object fieldTable = makeArray(t, count);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
PROTECT(t, fieldTable);
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
object staticValueTable = makeIntArray(t, count);
handle ConstantValue attributes for static fields
2007-10-25 19:20:39 +00:00
PROTECT(t, staticValueTable);
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
object addendum = 0;
PROTECT(t, addendum);
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
THREAD_RUNTIME_ARRAY(t, uint8_t, staticTypes, count);
sketch of singleton support
2007-11-02 21:08:14 +00:00
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
for (unsigned i = 0; i < count; ++i) {
unsigned flags = s.read2();
unsigned name = s.read2();
unsigned spec = s.read2();
minor tweaks to reduce memory usage
2007-11-06 15:29:05 +00:00
unsigned value = 0;
handle ConstantValue attributes for static fields
2007-10-25 19:20:39 +00:00
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
addendum = 0;
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
unsigned code = fieldCode
(t, byteArrayBody(t, singletonObject(t, pool, spec - 1), 0));
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
unsigned attributeCount = s.read2();
for (unsigned j = 0; j < attributeCount; ++j) {
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
object name = singletonObject(t, pool, s.read2() - 1);
handle ConstantValue attributes for static fields
2007-10-25 19:20:39 +00:00
unsigned length = s.read4();
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
if (vm::strcmp(reinterpret_cast<const int8_t*>("ConstantValue"),
&byteArrayBody(t, name, 0)) == 0)
handle ConstantValue attributes for static fields
2007-10-25 19:20:39 +00:00
{
minor tweaks to reduce memory usage
2007-11-06 15:29:05 +00:00
value = s.read2();
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
} else if (vm::strcmp(reinterpret_cast<const int8_t*>("Signature"),
&byteArrayBody(t, name, 0)) == 0)
{
if (addendum == 0) {
addendum = makeFieldAddendum(t, pool, 0, 0);
}
set(t, addendum, AddendumSignature,
singletonObject(t, pool, s.read2() - 1));
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
} else if (vm::strcmp(reinterpret_cast<const int8_t*>
("RuntimeVisibleAnnotations"),
&byteArrayBody(t, name, 0)) == 0)
{
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
if (addendum == 0) {
addendum = makeFieldAddendum(t, pool, 0, 0);
}
move proxy and annotation code from C++ to Java This allows code shrinkers to remove it if it's not used by the application.
2009-09-19 22:21:15 +00:00
object body = makeByteArray(t, length);
s.read(reinterpret_cast<uint8_t*>(&byteArrayBody(t, body, 0)),
length);
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
set(t, addendum, AddendumAnnotationTable, body);
handle ConstantValue attributes for static fields
2007-10-25 19:20:39 +00:00
} else {
s.skip(length);
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
object field = makeField
(t,
add a bunch of classes to classpath and flesh out a few existing ones
2007-07-21 17:50:26 +00:00
0, // vm flags
sketch of singleton support
2007-11-02 21:08:14 +00:00
code,
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
flags,
0, // offset
handle volatile fields properly in JNI Get/Set methods This commit ensures that we use the proper memory barriers or locking necessary to preserve volatile semantics for such fields when accessed or updated via JNI.
2011-03-16 01:34:00 +00:00
0, // native ID
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
singletonObject(t, pool, name - 1),
singletonObject(t, pool, spec - 1),
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
addendum,
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
class_);
progress towards cross-architecture bootimage builds This monster commit is the first step towards supporting cross-architecture bootimage builds. The challenge is to build a heap and code image for the target platform where the word size and endianess may differ from those of the build architecture. That means the memory layout of objects may differ due to alignment and size differences, so we can't just copy objects into the heap image unchanged; we must copy field by field, resizing values, reversing endianess and shifting offsets as necessary. This commit also removes POD (plain old data) type support from the type generator because it added a lot of complication and little value.
2011-08-30 01:00:17 +00:00
unsigned size = fieldSize(t, code);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
if (flags & ACC_STATIC) {
fix static field alignment calculation The previous code caused overlap between 64-bit fields and subsequent fields under certain circumstances on 32-bit systems.
2012-03-18 04:45:35 +00:00
while (staticOffset % size) {
++ staticOffset;
sketch of singleton support
2007-11-02 21:08:14 +00:00
}
fieldOffset(t, field) = staticOffset;
staticOffset += size;
minor tweaks to reduce memory usage
2007-11-06 15:29:05 +00:00
intArrayBody(t, staticValueTable, staticCount) = value;
sketch of singleton support
2007-11-02 21:08:14 +00:00
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
RUNTIME_ARRAY_BODY(staticTypes)[staticCount++] = code;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
} else {
implement support for volatile fields
2009-03-03 03:18:15 +00:00
if (flags & ACC_FINAL) {
implement ClassLoader.resolveClass and ensure class is linked in e.g. Class.getMethods; minor bugfixes
2009-08-18 20:26:28 +00:00
classVmFlags(t, class_) |= HasFinalMemberFlag;
implement support for volatile fields
2009-03-03 03:18:15 +00:00
}
progress towards cross-architecture bootimage builds This monster commit is the first step towards supporting cross-architecture bootimage builds. The challenge is to build a heap and code image for the target platform where the word size and endianess may differ from those of the build architecture. That means the memory layout of objects may differ due to alignment and size differences, so we can't just copy objects into the heap image unchanged; we must copy field by field, resizing values, reversing endianess and shifting offsets as necessary. This commit also removes POD (plain old data) type support from the type generator because it added a lot of complication and little value.
2011-08-30 01:00:17 +00:00
while (memberOffset % size) {
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
++ memberOffset;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
fieldOffset(t, field) = memberOffset;
progress towards cross-architecture bootimage builds This monster commit is the first step towards supporting cross-architecture bootimage builds. The challenge is to build a heap and code image for the target platform where the word size and endianess may differ from those of the build architecture. That means the memory layout of objects may differ due to alignment and size differences, so we can't just copy objects into the heap image unchanged; we must copy field by field, resizing values, reversing endianess and shifting offsets as necessary. This commit also removes POD (plain old data) type support from the type generator because it added a lot of complication and little value.
2011-08-30 01:00:17 +00:00
memberOffset += size;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, fieldTable, ArrayBody + (i * BytesPerWord), field);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, class_, ClassFieldTable, fieldTable);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
sketch of singleton support
2007-11-02 21:08:14 +00:00
if (staticCount) {
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
unsigned footprint = ceilingDivide(staticOffset - (BytesPerWord * 2),
sketch of singleton support
2007-11-02 21:08:14 +00:00
BytesPerWord);
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
object staticTable = makeSingletonOfSize(t, footprint);
sketch of singleton support
2007-11-02 21:08:14 +00:00
uint8_t* body = reinterpret_cast<uint8_t*>
(&singletonBody(t, staticTable, 0));
fix sun.misc.Unsafe.getLongVolatile for static fields on 32-bit platforms The existing code did not handle static field lookups for synchronization on 32-bit systems, which is necessary because such systems generally don't support atomic operations on 64-bit values.
2012-09-12 01:21:51 +00:00
memcpy(body, &class_, BytesPerWord);
singletonMarkObject(t, staticTable, 0);
for (unsigned i = 0, offset = BytesPerWord; i < staticCount; ++i) {
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
unsigned size = fieldSize(t, RUNTIME_ARRAY_BODY(staticTypes)[i]);
fix static field alignment calculation The previous code caused overlap between 64-bit fields and subsequent fields under certain circumstances on 32-bit systems.
2012-03-18 04:45:35 +00:00
while (offset % size) {
++ offset;
sketch of singleton support
2007-11-02 21:08:14 +00:00
}
minor tweaks to reduce memory usage
2007-11-06 15:29:05 +00:00
unsigned value = intArrayBody(t, staticValueTable, i);
sketch of singleton support
2007-11-02 21:08:14 +00:00
if (value) {
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
switch (RUNTIME_ARRAY_BODY(staticTypes)[i]) {
sketch of singleton support
2007-11-02 21:08:14 +00:00
case ByteField:
case BooleanField:
minor tweaks to reduce memory usage
2007-11-06 15:29:05 +00:00
body[offset] = singletonValue(t, pool, value - 1);
sketch of singleton support
2007-11-02 21:08:14 +00:00
break;
case CharField:
case ShortField:
minor tweaks to reduce memory usage
2007-11-06 15:29:05 +00:00
*reinterpret_cast<uint16_t*>(body + offset)
= singletonValue(t, pool, value - 1);
sketch of singleton support
2007-11-02 21:08:14 +00:00
break;
case IntField:
case FloatField:
minor tweaks to reduce memory usage
2007-11-06 15:29:05 +00:00
*reinterpret_cast<uint32_t*>(body + offset)
= singletonValue(t, pool, value - 1);
sketch of singleton support
2007-11-02 21:08:14 +00:00
break;
case LongField:
case DoubleField:
minor tweaks to reduce memory usage
2007-11-06 15:29:05 +00:00
memcpy(body + offset, &singletonValue(t, pool, value - 1), 8);
sketch of singleton support
2007-11-02 21:08:14 +00:00
break;
case ObjectField:
minor tweaks to reduce memory usage
2007-11-06 15:29:05 +00:00
memcpy(body + offset,
&singletonObject(t, pool, value - 1),
BytesPerWord);
sketch of singleton support
2007-11-02 21:08:14 +00:00
break;
default: abort(t);
}
}
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
if (RUNTIME_ARRAY_BODY(staticTypes)[i] == ObjectField) {
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
singletonMarkObject(t, staticTable, offset / BytesPerWord);
sketch of singleton support
2007-11-02 21:08:14 +00:00
}
offset += size;
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, class_, ClassStaticTable, staticTable);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
}
classFixedSize(t, class_) = pad(memberOffset);
if (classSuper(t, class_)
and memberOffset == classFixedSize(t, classSuper(t, class_)))
{
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, class_, ClassObjectMask,
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
classObjectMask(t, classSuper(t, class_)));
} else {
object mask = makeIntArray
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
(t, ceilingDivide(classFixedSize(t, class_), 32 * BytesPerWord));
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
intArrayBody(t, mask, 0) = 1;
various bugfixes
2007-08-14 00:37:00 +00:00
object superMask = 0;
if (classSuper(t, class_)) {
superMask = classObjectMask(t, classSuper(t, class_));
if (superMask) {
memcpy(&intArrayBody(t, mask, 0),
&intArrayBody(t, superMask, 0),
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
ceilingDivide(classFixedSize(t, classSuper(t, class_)),
fix math bug in parseFieldTable which lead to incorrect objectMasks
2007-09-15 17:22:22 +00:00
32 * BytesPerWord)
various bugfixes
2007-08-14 00:37:00 +00:00
* 4);
}
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
bool sawReferenceField = false;
various bugfixes
2007-08-14 00:37:00 +00:00
object fieldTable = classFieldTable(t, class_);
if (fieldTable) {
for (int i = arrayLength(t, fieldTable) - 1; i >= 0; --i) {
object field = arrayBody(t, fieldTable, i);
if ((fieldFlags(t, field) & ACC_STATIC) == 0
and fieldCode(t, field) == ObjectField)
{
unsigned index = fieldOffset(t, field) / BytesPerWord;
intArrayBody(t, mask, (index / 32)) |= 1 << (index % 32);
sawReferenceField = true;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
}
}
various bugfixes
2007-08-14 00:37:00 +00:00
if (superMask or sawReferenceField) {
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, class_, ClassObjectMask, mask);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
}
}
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
uint16_t read16(uint8_t* code, unsigned& ip) {
uint16_t a = code[ip++];
uint16_t b = code[ip++];
return (a << 8) | b;
}
uint32_t read32(uint8_t* code, unsigned& ip) {
uint32_t b = code[ip++];
uint32_t a = code[ip++];
uint32_t c = code[ip++];
uint32_t d = code[ip++];
return (a << 24) | (b << 16) | (c << 8) | d;
}
void
disassembleCode(const char* prefix, uint8_t* code, unsigned length)
{
unsigned ip = 0;
while(ip < length) {
unsigned instr;
fprintf(stderr, "%s%x:\t", prefix, ip);
switch (instr = code[ip++]) {
case aaload: fprintf(stderr, "aaload\n"); break;
case aastore: fprintf(stderr, "aastore\n"); break;
case aconst_null: fprintf(stderr, "aconst_null\n"); break;
case aload: fprintf(stderr, "aload %02x\n", code[ip++]); break;
case aload_0: fprintf(stderr, "aload_0\n"); break;
case aload_1: fprintf(stderr, "aload_1\n"); break;
case aload_2: fprintf(stderr, "aload_2\n"); break;
case aload_3: fprintf(stderr, "aload_3\n"); break;
case anewarray: fprintf(stderr, "anewarray %04x\n", read16(code, ip)); break;
case areturn: fprintf(stderr, "areturn\n"); break;
case arraylength: fprintf(stderr, "arraylength\n"); break;
case astore: fprintf(stderr, "astore %02x\n", code[ip++]); break;
case astore_0: fprintf(stderr, "astore_0\n"); break;
case astore_1: fprintf(stderr, "astore_1\n"); break;
case astore_2: fprintf(stderr, "astore_2\n"); break;
case astore_3: fprintf(stderr, "astore_3\n"); break;
case athrow: fprintf(stderr, "athrow\n"); break;
case baload: fprintf(stderr, "baload\n"); break;
case bastore: fprintf(stderr, "bastore\n"); break;
case bipush: fprintf(stderr, "bipush %02x\n", code[ip++]); break;
case caload: fprintf(stderr, "caload\n"); break;
case castore: fprintf(stderr, "castore\n"); break;
case checkcast: fprintf(stderr, "checkcast %04x\n", read16(code, ip)); break;
case d2f: fprintf(stderr, "d2f\n"); break;
case d2i: fprintf(stderr, "d2i\n"); break;
case d2l: fprintf(stderr, "d2l\n"); break;
case dadd: fprintf(stderr, "dadd\n"); break;
case daload: fprintf(stderr, "daload\n"); break;
case dastore: fprintf(stderr, "dastore\n"); break;
case dcmpg: fprintf(stderr, "dcmpg\n"); break;
case dcmpl: fprintf(stderr, "dcmpl\n"); break;
case dconst_0: fprintf(stderr, "dconst_0\n"); break;
case dconst_1: fprintf(stderr, "dconst_1\n"); break;
case ddiv: fprintf(stderr, "ddiv\n"); break;
case dmul: fprintf(stderr, "dmul\n"); break;
case dneg: fprintf(stderr, "dneg\n"); break;
case vm::drem: fprintf(stderr, "drem\n"); break;
case dsub: fprintf(stderr, "dsub\n"); break;
case dup: fprintf(stderr, "dup\n"); break;
case dup_x1: fprintf(stderr, "dup_x1\n"); break;
case dup_x2: fprintf(stderr, "dup_x2\n"); break;
case dup2: fprintf(stderr, "dup2\n"); break;
case dup2_x1: fprintf(stderr, "dup2_x1\n"); break;
case dup2_x2: fprintf(stderr, "dup2_x2\n"); break;
case f2d: fprintf(stderr, "f2d\n"); break;
case f2i: fprintf(stderr, "f2i\n"); break;
case f2l: fprintf(stderr, "f2l\n"); break;
case fadd: fprintf(stderr, "fadd\n"); break;
case faload: fprintf(stderr, "faload\n"); break;
case fastore: fprintf(stderr, "fastore\n"); break;
case fcmpg: fprintf(stderr, "fcmpg\n"); break;
case fcmpl: fprintf(stderr, "fcmpl\n"); break;
case fconst_0: fprintf(stderr, "fconst_0\n"); break;
case fconst_1: fprintf(stderr, "fconst_1\n"); break;
case fconst_2: fprintf(stderr, "fconst_2\n"); break;
case fdiv: fprintf(stderr, "fdiv\n"); break;
case fmul: fprintf(stderr, "fmul\n"); break;
case fneg: fprintf(stderr, "fneg\n"); break;
case frem: fprintf(stderr, "frem\n"); break;
case fsub: fprintf(stderr, "fsub\n"); break;
case getfield: fprintf(stderr, "getfield %04x\n", read16(code, ip)); break;
case getstatic: fprintf(stderr, "getstatic %04x\n", read16(code, ip)); break;
case goto_: {
int16_t offset = read16(code, ip);
fprintf(stderr, "goto %04x\n", offset + ip - 3);
} break;
case goto_w: {
int32_t offset = read32(code, ip);
fprintf(stderr, "goto_w %08x\n", offset + ip - 5);
} break;
case i2b: fprintf(stderr, "i2b\n"); break;
case i2c: fprintf(stderr, "i2c\n"); break;
case i2d: fprintf(stderr, "i2d\n"); break;
case i2f: fprintf(stderr, "i2f\n"); break;
case i2l: fprintf(stderr, "i2l\n"); break;
case i2s: fprintf(stderr, "i2s\n"); break;
case iadd: fprintf(stderr, "iadd\n"); break;
case iaload: fprintf(stderr, "iaload\n"); break;
case iand: fprintf(stderr, "iand\n"); break;
case iastore: fprintf(stderr, "iastore\n"); break;
case iconst_m1: fprintf(stderr, "iconst_m1\n"); break;
case iconst_0: fprintf(stderr, "iconst_0\n"); break;
case iconst_1: fprintf(stderr, "iconst_1\n"); break;
case iconst_2: fprintf(stderr, "iconst_2\n"); break;
case iconst_3: fprintf(stderr, "iconst_3\n"); break;
case iconst_4: fprintf(stderr, "iconst_4\n"); break;
case iconst_5: fprintf(stderr, "iconst_5\n"); break;
case idiv: fprintf(stderr, "idiv\n"); break;
case if_acmpeq: {
int16_t offset = read16(code, ip);
fprintf(stderr, "if_acmpeq %04x\n", offset + ip - 3);
} break;
case if_acmpne: {
int16_t offset = read16(code, ip);
fprintf(stderr, "if_acmpne %04x\n", offset + ip - 3);
} break;
case if_icmpeq: {
int16_t offset = read16(code, ip);
fprintf(stderr, "if_icmpeq %04x\n", offset + ip - 3);
} break;
case if_icmpne: {
int16_t offset = read16(code, ip);
fprintf(stderr, "if_icmpne %04x\n", offset + ip - 3);
} break;
case if_icmpgt: {
int16_t offset = read16(code, ip);
fprintf(stderr, "if_icmpgt %04x\n", offset + ip - 3);
} break;
case if_icmpge: {
int16_t offset = read16(code, ip);
fprintf(stderr, "if_icmpge %04x\n", offset + ip - 3);
} break;
case if_icmplt: {
int16_t offset = read16(code, ip);
fprintf(stderr, "if_icmplt %04x\n", offset + ip - 3);
} break;
case if_icmple: {
int16_t offset = read16(code, ip);
fprintf(stderr, "if_icmple %04x\n", offset + ip - 3);
} break;
case ifeq: {
int16_t offset = read16(code, ip);
fprintf(stderr, "ifeq %04x\n", offset + ip - 3);
} break;
case ifne: {
int16_t offset = read16(code, ip);
fprintf(stderr, "ifne %04x\n", offset + ip - 3);
} break;
case ifgt: {
int16_t offset = read16(code, ip);
fprintf(stderr, "ifgt %04x\n", offset + ip - 3);
} break;
case ifge: {
int16_t offset = read16(code, ip);
fprintf(stderr, "ifge %04x\n", offset + ip - 3);
} break;
case iflt: {
int16_t offset = read16(code, ip);
fprintf(stderr, "iflt %04x\n", offset + ip - 3);
} break;
case ifle: {
int16_t offset = read16(code, ip);
fprintf(stderr, "ifle %04x\n", offset + ip - 3);
} break;
case ifnonnull: {
int16_t offset = read16(code, ip);
fprintf(stderr, "ifnonnull %04x\n", offset + ip - 3);
} break;
case ifnull: {
int16_t offset = read16(code, ip);
fprintf(stderr, "ifnull %04x\n", offset + ip - 3);
} break;
case iinc: {
uint8_t a = code[ip++];
uint8_t b = code[ip++];
fprintf(stderr, "iinc %02x %02x\n", a, b);
} break;
case iload: fprintf(stderr, "iload %02x\n", code[ip++]); break;
case fload: fprintf(stderr, "fload %02x\n", code[ip++]); break;
case iload_0: fprintf(stderr, "iload_0\n"); break;
case fload_0: fprintf(stderr, "fload_0\n"); break;
case iload_1: fprintf(stderr, "iload_1\n"); break;
case fload_1: fprintf(stderr, "fload_1\n"); break;
case iload_2: fprintf(stderr, "iload_2\n"); break;
case fload_2: fprintf(stderr, "fload_2\n"); break;
case iload_3: fprintf(stderr, "iload_3\n"); break;
case fload_3: fprintf(stderr, "fload_3\n"); break;
case imul: fprintf(stderr, "imul\n"); break;
case ineg: fprintf(stderr, "ineg\n"); break;
case instanceof: fprintf(stderr, "instanceof %04x\n", read16(code, ip)); break;
case invokeinterface: fprintf(stderr, "invokeinterface %04x\n", read16(code, ip)); break;
case invokespecial: fprintf(stderr, "invokespecial %04x\n", read16(code, ip)); break;
case invokestatic: fprintf(stderr, "invokestatic %04x\n", read16(code, ip)); break;
case invokevirtual: fprintf(stderr, "invokevirtual %04x\n", read16(code, ip)); break;
case ior: fprintf(stderr, "ior\n"); break;
case irem: fprintf(stderr, "irem\n"); break;
case ireturn: fprintf(stderr, "ireturn\n"); break;
case freturn: fprintf(stderr, "freturn\n"); break;
case ishl: fprintf(stderr, "ishl\n"); break;
case ishr: fprintf(stderr, "ishr\n"); break;
case istore: fprintf(stderr, "istore %02x\n", code[ip++]); break;
case fstore: fprintf(stderr, "fstore %02x\n", code[ip++]); break;
case istore_0: fprintf(stderr, "istore_0\n"); break;
case fstore_0: fprintf(stderr, "fstore_0\n"); break;
case istore_1: fprintf(stderr, "istore_1\n"); break;
case fstore_1: fprintf(stderr, "fstore_1\n"); break;
case istore_2: fprintf(stderr, "istore_2\n"); break;
case fstore_2: fprintf(stderr, "fstore_2\n"); break;
case istore_3: fprintf(stderr, "istore_3\n"); break;
case fstore_3: fprintf(stderr, "fstore_3\n"); break;
case isub: fprintf(stderr, "isub\n"); break;
case iushr: fprintf(stderr, "iushr\n"); break;
case ixor: fprintf(stderr, "ixor\n"); break;
case jsr: fprintf(stderr, "jsr %04x\n", read16(code, ip)); break;
case jsr_w: fprintf(stderr, "jsr_w %08x\n", read32(code, ip)); break;
case l2d: fprintf(stderr, "l2d\n"); break;
case l2f: fprintf(stderr, "l2f\n"); break;
case l2i: fprintf(stderr, "l2i\n"); break;
case ladd: fprintf(stderr, "ladd\n"); break;
case laload: fprintf(stderr, "laload\n"); break;
case land: fprintf(stderr, "land\n"); break;
case lastore: fprintf(stderr, "lastore\n"); break;
case lcmp: fprintf(stderr, "lcmp\n"); break;
case lconst_0: fprintf(stderr, "lconst_0\n"); break;
case lconst_1: fprintf(stderr, "lconst_1\n"); break;
case ldc: fprintf(stderr, "ldc %04x\n", read16(code, ip)); break;
case ldc_w: fprintf(stderr, "ldc_w %08x\n", read32(code, ip)); break;
case ldc2_w: fprintf(stderr, "ldc2_w %04x\n", read16(code, ip)); break;
case ldiv_: fprintf(stderr, "ldiv_\n"); break;
case lload: fprintf(stderr, "lload %02x\n", code[ip++]); break;
case dload: fprintf(stderr, "dload %02x\n", code[ip++]); break;
case lload_0: fprintf(stderr, "lload_0\n"); break;
case dload_0: fprintf(stderr, "dload_0\n"); break;
case lload_1: fprintf(stderr, "lload_1\n"); break;
case dload_1: fprintf(stderr, "dload_1\n"); break;
case lload_2: fprintf(stderr, "lload_2\n"); break;
case dload_2: fprintf(stderr, "dload_2\n"); break;
case lload_3: fprintf(stderr, "lload_3\n"); break;
case dload_3: fprintf(stderr, "dload_3\n"); break;
case lmul: fprintf(stderr, "lmul\n"); break;
case lneg: fprintf(stderr, "lneg\n"); break;
case lookupswitch: {
int32_t default_ = read32(code, ip);
int32_t pairCount = read32(code, ip);
fprintf(stderr, "lookupswitch default: %d pairCount: %d\n", default_, pairCount);
for (int i = 0; i < pairCount; i++) {
int32_t k = read32(code, ip);
int32_t d = read32(code, ip);
fprintf(stderr, "%s key: %02x dest: %2x\n", prefix, k, d);
}
} break;
case lor: fprintf(stderr, "lor\n"); break;
case lrem: fprintf(stderr, "lrem\n"); break;
case lreturn: fprintf(stderr, "lreturn\n"); break;
case dreturn: fprintf(stderr, "dreturn\n"); break;
case lshl: fprintf(stderr, "lshl\n"); break;
case lshr: fprintf(stderr, "lshr\n"); break;
case lstore: fprintf(stderr, "lstore %02x\n", code[ip++]); break;
case dstore: fprintf(stderr, "dstore %02x\n", code[ip++]); break;
case lstore_0: fprintf(stderr, "lstore_0\n"); break;
case dstore_0: fprintf(stderr, "dstore_0\n"); break;
case lstore_1: fprintf(stderr, "lstore_1\n"); break;
case dstore_1: fprintf(stderr, "dstore_1\n"); break;
case lstore_2: fprintf(stderr, "lstore_2\n"); break;
case dstore_2: fprintf(stderr, "dstore_2\n"); break;
case lstore_3: fprintf(stderr, "lstore_3\n"); break;
case dstore_3: fprintf(stderr, "dstore_3\n"); break;
case lsub: fprintf(stderr, "lsub\n"); break;
case lushr: fprintf(stderr, "lushr\n"); break;
case lxor: fprintf(stderr, "lxor\n"); break;
case monitorenter: fprintf(stderr, "monitorenter\n"); break;
case monitorexit: fprintf(stderr, "monitorexit\n"); break;
fix warning in disassembler code Apple's GCC is more picky about undefined ordering (and rightfully so)...
2012-05-24 14:34:46 +00:00
case multianewarray: {
unsigned type = read16(code, ip);
fprintf(stderr, "multianewarray %04x %02x\n", type, code[ip++]);
} break;
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
case new_: fprintf(stderr, "new %04x\n", read16(code, ip)); break;
case newarray: fprintf(stderr, "newarray %02x\n", code[ip++]); break;
case nop: fprintf(stderr, "nop\n"); break;
case pop_: fprintf(stderr, "pop\n"); break;
case pop2: fprintf(stderr, "pop2\n"); break;
case putfield: fprintf(stderr, "putfield %04x\n", read16(code, ip)); break;
case putstatic: fprintf(stderr, "putstatic %04x\n", read16(code, ip)); break;
case ret: fprintf(stderr, "ret %02x\n", code[ip++]); break;
case return_: fprintf(stderr, "return_\n"); break;
case saload: fprintf(stderr, "saload\n"); break;
case sastore: fprintf(stderr, "sastore\n"); break;
case sipush: fprintf(stderr, "sipush %04x\n", read16(code, ip)); break;
case swap: fprintf(stderr, "swap\n"); break;
case tableswitch: {
int32_t default_ = read32(code, ip);
int32_t bottom = read32(code, ip);
int32_t top = read32(code, ip);
fprintf(stderr, "tableswitch default: %d bottom: %d top: %d\n", default_, bottom, top);
for (int i = 0; i < top - bottom + 1; i++) {
int32_t d = read32(code, ip);
fprintf(stderr, "%s key: %d dest: %2x\n", prefix, i + bottom, d);
}
} break;
case wide: {
switch (code[ip++]) {
case aload: fprintf(stderr, "wide aload %04x\n", read16(code, ip)); break;
case astore: fprintf(stderr, "wide astore %04x\n", read16(code, ip)); break;
case iinc: fprintf(stderr, "wide iinc %04x %04x\n", read16(code, ip), read16(code, ip)); break;
case iload: fprintf(stderr, "wide iload %04x\n", read16(code, ip)); break;
case istore: fprintf(stderr, "wide istore %04x\n", read16(code, ip)); break;
case lload: fprintf(stderr, "wide lload %04x\n", read16(code, ip)); break;
case lstore: fprintf(stderr, "wide lstore %04x\n", read16(code, ip)); break;
case ret: fprintf(stderr, "wide ret %04x\n", read16(code, ip)); break;
default: {
fprintf(stderr, "unknown wide instruction %02x %04x\n", instr, read16(code, ip));
}
}
} break;
default: {
fprintf(stderr, "unknown instruction %02x\n", instr);
}
}
}
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
object
parseCode(Thread* t, Stream& s, object pool)
{
GC stress fixes
2007-07-19 23:45:44 +00:00
PROTECT(t, pool);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
unsigned maxStack = s.read2();
unsigned maxLocals = s.read2();
unsigned length = s.read4();
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
if(DebugClassReader) {
fprintf(stderr, " code: maxStack %d maxLocals %d length %d\n", maxStack, maxLocals, length);
}
fix a couple of subtle Thread.getStackTrace bugs The first problem was that, on x86, we failed to properly keep track of whether to expect the return address to be on the stack or not when unwinding through a frame. We were relying on a "stackLimit" pointer to tell us whether we were looking at the most recently-called frame by comparing it with the stack pointer for that frame. That was inaccurate in the case of a thread executing at the beginning of a method before a new frame is allocated, in which case the most recent two frames share a stack pointer, confusing the unwinder. The solution involves keeping track of how many frames we've looked at while walking the stack. The other problem was that compareIpToMethodBounds assumed every method was followed by at least one byte of padding before the next method started. That assumption was usually valid because we were storing the size following method code prior to the code itself. However, the last method of an AOT-compiled code image is not followed by any such method header and may instead be followed directly by native code with no intervening padding. In that case, we risk interpreting that native code as part of the preceding method, with potentially bizarre results. The reason for the compareIpToMethodBounds assumption was that methods which throw exceptions as their last instruction generate a non-returning call, which nonetheless push a return address on the stack which points past the end of the method, and the unwinder needs to know that return address belongs to that method. A better solution is to add an extra trap instruction to the end of such methods, which is what this patch does.
2012-05-05 00:35:13 +00:00
object code = makeCode(t, pool, 0, 0, 0, 0, maxStack, maxLocals, length);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
s.read(&codeBody(t, code, 0), length);
fix various bugs uncovered in GC stress test
2007-07-16 23:58:37 +00:00
PROTECT(t, code);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
if(DebugClassReader) {
disassembleCode(" ", &codeBody(t, code, 0), length);
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
unsigned ehtLength = s.read2();
if (ehtLength) {
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
object eht = makeExceptionHandlerTable(t, ehtLength);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
for (unsigned i = 0; i < ehtLength; ++i) {
progress towards cross-architecture bootimage builds This monster commit is the first step towards supporting cross-architecture bootimage builds. The challenge is to build a heap and code image for the target platform where the word size and endianess may differ from those of the build architecture. That means the memory layout of objects may differ due to alignment and size differences, so we can't just copy objects into the heap image unchanged; we must copy field by field, resizing values, reversing endianess and shifting offsets as necessary. This commit also removes POD (plain old data) type support from the type generator because it added a lot of complication and little value.
2011-08-30 01:00:17 +00:00
unsigned start = s.read2();
unsigned end = s.read2();
unsigned ip = s.read2();
unsigned catchType = s.read2();
exceptionHandlerTableBody(t, eht, i) = exceptionHandler
(start, end, ip, catchType);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, code, CodeExceptionHandlerTable, eht);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
unsigned attributeCount = s.read2();
for (unsigned j = 0; j < attributeCount; ++j) {
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
object name = singletonObject(t, pool, s.read2() - 1);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
unsigned length = s.read4();
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
if (vm::strcmp(reinterpret_cast<const int8_t*>("LineNumberTable"),
&byteArrayBody(t, name, 0)) == 0)
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
{
unsigned lntLength = s.read2();
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
object lnt = makeLineNumberTable(t, lntLength);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
for (unsigned i = 0; i < lntLength; ++i) {
progress towards cross-architecture bootimage builds This monster commit is the first step towards supporting cross-architecture bootimage builds. The challenge is to build a heap and code image for the target platform where the word size and endianess may differ from those of the build architecture. That means the memory layout of objects may differ due to alignment and size differences, so we can't just copy objects into the heap image unchanged; we must copy field by field, resizing values, reversing endianess and shifting offsets as necessary. This commit also removes POD (plain old data) type support from the type generator because it added a lot of complication and little value.
2011-08-30 01:00:17 +00:00
unsigned ip = s.read2();
unsigned line = s.read2();
lineNumberTableBody(t, lnt, i) = lineNumber(ip, line);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, code, CodeLineNumberTable, lnt);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
} else {
s.skip(length);
}
}
return code;
}
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
object
addInterfaceMethods(Thread* t, object class_, object virtualMap,
unsigned* virtualCount, bool makeList)
{
object itable = classInterfaceTable(t, class_);
if (itable) {
PROTECT(t, class_);
PROTECT(t, virtualMap);
PROTECT(t, itable);
object list = 0;
PROTECT(t, list);
object method = 0;
PROTECT(t, method);
object vtable = 0;
PROTECT(t, vtable);
unsigned stride = (classFlags(t, class_) & ACC_INTERFACE) ? 1 : 2;
for (unsigned i = 0; i < arrayLength(t, itable); i += stride) {
vtable = classVirtualTable(t, arrayBody(t, itable, i));
if (vtable) {
for (unsigned j = 0; j < arrayLength(t, vtable); ++j) {
method = arrayBody(t, vtable, j);
object n = hashMapFindNode
(t, virtualMap, method, methodHash, methodEqual);
if (n == 0) {
method = makeMethod
(t,
methodVmFlags(t, method),
methodReturnCode(t, method),
methodParameterCount(t, method),
methodParameterFootprint(t, method),
methodFlags(t, method),
(*virtualCount)++,
0,
fix openjdk-src bootimage build The main change here is to use a lazily-populated vector to associate runtime data with classes instead of referencing them directly from the class which requires updating immutable references in the heap image. The other changes employ other strategies to avoid trying to update immutable references.
2010-11-26 19:41:31 +00:00
0,
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
methodName(t, method),
methodSpec(t, method),
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
0,
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
class_,
0);
hashMapInsert(t, virtualMap, method, method, methodHash);
if (makeList) {
if (list == 0) {
list = vm::makeList(t, 0, 0, 0);
}
listAppend(t, list, method);
}
}
}
}
}
return list;
}
return 0;
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
void
parseMethodTable(Thread* t, Stream& s, object class_, object pool)
{
PROTECT(t, class_);
PROTECT(t, pool);
break native hashMap type into hashMap and weakHashMap; start investgating GC stress failures related to or uncovered by new string interning support
2007-07-29 18:52:08 +00:00
object virtualMap = makeHashMap(t, 0, 0);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
PROTECT(t, virtualMap);
unsigned virtualCount = 0;
unsigned declaredVirtualCount = 0;
object superVirtualTable = 0;
PROTECT(t, superVirtualTable);
if (classFlags(t, class_) & ACC_INTERFACE) {
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
addInterfaceMethods(t, class_, virtualMap, &virtualCount, false);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
} else {
if (classSuper(t, class_)) {
superVirtualTable = classVirtualTable(t, classSuper(t, class_));
}
if (superVirtualTable) {
virtualCount = arrayLength(t, superVirtualTable);
for (unsigned i = 0; i < virtualCount; ++i) {
object method = arrayBody(t, superVirtualTable, i);
hashMapInsert(t, virtualMap, method, method, methodHash);
}
}
}
object newVirtuals = makeList(t, 0, 0, 0);
PROTECT(t, newVirtuals);
unsigned count = s.read2();
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
if(DebugClassReader) {
fprintf(stderr, " method count %d\n", count);
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
if (count) {
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
object methodTable = makeArray(t, count);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
PROTECT(t, methodTable);
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
object addendum = 0;
PROTECT(t, addendum);
object code = 0;
PROTECT(t, code);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
for (unsigned i = 0; i < count; ++i) {
unsigned flags = s.read2();
unsigned name = s.read2();
unsigned spec = s.read2();
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
if(DebugClassReader) {
fprintf(stderr, " method flags %d name %d spec %d '%s%s'\n", flags, name, spec,
&byteArrayBody(t, singletonObject(t, pool, name - 1), 0),
&byteArrayBody(t, singletonObject(t, pool, spec - 1), 0));
}
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
addendum = 0;
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
code = 0;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
unsigned attributeCount = s.read2();
for (unsigned j = 0; j < attributeCount; ++j) {
change local variable name to avoid shadowing another variable
2011-09-01 03:15:41 +00:00
object attributeName = singletonObject(t, pool, s.read2() - 1);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
unsigned length = s.read4();
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
if (vm::strcmp(reinterpret_cast<const int8_t*>("Code"),
change local variable name to avoid shadowing another variable
2011-09-01 03:15:41 +00:00
&byteArrayBody(t, attributeName, 0)) == 0)
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
{
code = parseCode(t, s, pool);
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
} else if (vm::strcmp(reinterpret_cast<const int8_t*>("Exceptions"),
change local variable name to avoid shadowing another variable
2011-09-01 03:15:41 +00:00
&byteArrayBody(t, attributeName, 0)) == 0)
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
{
if (addendum == 0) {
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
addendum = makeMethodAddendum(t, pool, 0, 0, 0, 0);
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
}
unsigned exceptionCount = s.read2();
object body = makeShortArray(t, exceptionCount);
for (unsigned i = 0; i < exceptionCount; ++i) {
shortArrayBody(t, body, i) = s.read2();
}
set(t, addendum, MethodAddendumExceptionTable, body);
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
} else if (vm::strcmp(reinterpret_cast<const int8_t*>
("AnnotationDefault"),
change local variable name to avoid shadowing another variable
2011-09-01 03:15:41 +00:00
&byteArrayBody(t, attributeName, 0)) == 0)
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
{
if (addendum == 0) {
addendum = makeMethodAddendum(t, pool, 0, 0, 0, 0);
}
object body = makeByteArray(t, length);
s.read(reinterpret_cast<uint8_t*>(&byteArrayBody(t, body, 0)),
length);
set(t, addendum, MethodAddendumAnnotationDefault, body);
} else if (vm::strcmp(reinterpret_cast<const int8_t*>("Signature"),
change local variable name to avoid shadowing another variable
2011-09-01 03:15:41 +00:00
&byteArrayBody(t, attributeName, 0)) == 0)
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
{
if (addendum == 0) {
addendum = makeMethodAddendum(t, pool, 0, 0, 0, 0);
}
set(t, addendum, AddendumSignature,
singletonObject(t, pool, s.read2() - 1));
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
} else if (vm::strcmp(reinterpret_cast<const int8_t*>
("RuntimeVisibleAnnotations"),
change local variable name to avoid shadowing another variable
2011-09-01 03:15:41 +00:00
&byteArrayBody(t, attributeName, 0)) == 0)
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
{
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
if (addendum == 0) {
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
addendum = makeMethodAddendum(t, pool, 0, 0, 0, 0);
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
}
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
move proxy and annotation code from C++ to Java This allows code shrinkers to remove it if it's not used by the application.
2009-09-19 22:21:15 +00:00
object body = makeByteArray(t, length);
s.read(reinterpret_cast<uint8_t*>(&byteArrayBody(t, body, 0)),
length);
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
set(t, addendum, AddendumAnnotationTable, body);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
} else {
s.skip(length);
}
}
clean up compile.cpp and support both x86_64 and i386; further refactoring to support JIT
2007-09-26 23:23:03 +00:00
const char* specString = reinterpret_cast<const char*>
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
(&byteArrayBody(t, singletonObject(t, pool, spec - 1), 0));
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
clean up compile.cpp and support both x86_64 and i386; further refactoring to support JIT
2007-09-26 23:23:03 +00:00
unsigned parameterCount;
unsigned returnCode;
scanMethodSpec(t, specString, &parameterCount, &returnCode);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
object method = t->m->processor->makeMethod
(t,
0, // vm flags
returnCode,
parameterCount,
handle weak maps properly in hashMapResize, hashMapRemove, etc.; move Processor::parameterFootprint() into machine.h/machine.cpp
2007-11-20 22:24:02 +00:00
parameterFootprint(t, specString, flags & ACC_STATIC),
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
flags,
0, // offset
singletonObject(t, pool, name - 1),
singletonObject(t, pool, spec - 1),
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
addendum,
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
class_,
code);
invoke native methods using a common routine, instead of compiling code specific to each method
2007-10-01 15:19:15 +00:00
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
PROTECT(t, method);
snapshot
2007-11-05 14:28:46 +00:00
if (methodVirtual(t, method)) {
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
++ declaredVirtualCount;
object p = hashMapFindNode
(t, virtualMap, method, methodHash, methodEqual);
if (p) {
methodOffset(t, method) = methodOffset(t, tripleFirst(t, p));
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, p, TripleSecond, method);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
} else {
methodOffset(t, method) = virtualCount++;
listAppend(t, newVirtuals, method);
hashMapInsert(t, virtualMap, method, method, methodHash);
}
implement basic finalization support This implementation does not conform to the Java standard in that finalize methods are called from whichever thread happens to be garbage collecting, and that thread may hold locks, whereas the standard guarantees that finalize will be run from a thread which holds no locks. Also, an object will never be finalized more than once, even if its finalize method "rescues" (i.e. makes reachable) the object such that it might become unreachable a second time and thus a candidate for finalization once more. It's not clear to me from the standard if this is OK or not. Nonwithstanding the above, this implementation is useful for "normal" finalize methods which simply release resources associated with an object.
2009-07-22 00:57:55 +00:00
treat SoftReferences as WeakReferences; do vtable or interface table lookups as necessary in MyProcessor::invoke; various bugfixes
2009-08-13 15:17:05 +00:00
if (UNLIKELY((classFlags(t, class_) & ACC_INTERFACE) == 0
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
and vm::strcmp
implement basic finalization support This implementation does not conform to the Java standard in that finalize methods are called from whichever thread happens to be garbage collecting, and that thread may hold locks, whereas the standard guarantees that finalize will be run from a thread which holds no locks. Also, an object will never be finalized more than once, even if its finalize method "rescues" (i.e. makes reachable) the object such that it might become unreachable a second time and thus a candidate for finalization once more. It's not clear to me from the standard if this is OK or not. Nonwithstanding the above, this implementation is useful for "normal" finalize methods which simply release resources associated with an object.
2009-07-22 00:57:55 +00:00
(reinterpret_cast<const int8_t*>("finalize"),
&byteArrayBody(t, methodName(t, method), 0)) == 0
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
and vm::strcmp
implement basic finalization support This implementation does not conform to the Java standard in that finalize methods are called from whichever thread happens to be garbage collecting, and that thread may hold locks, whereas the standard guarantees that finalize will be run from a thread which holds no locks. Also, an object will never be finalized more than once, even if its finalize method "rescues" (i.e. makes reachable) the object such that it might become unreachable a second time and thus a candidate for finalization once more. It's not clear to me from the standard if this is OK or not. Nonwithstanding the above, this implementation is useful for "normal" finalize methods which simply release resources associated with an object.
2009-07-22 00:57:55 +00:00
(reinterpret_cast<const int8_t*>("()V"),
&byteArrayBody(t, methodSpec(t, method), 0)) == 0
and (not emptyMethod(t, method))))
{
classVmFlags(t, class_) |= HasFinalizerFlag;
}
snapshot
2007-11-05 14:28:46 +00:00
} else {
methodOffset(t, method) = i;
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
if (vm::strcmp(reinterpret_cast<const int8_t*>("<clinit>"),
&byteArrayBody(t, methodName(t, method), 0)) == 0)
snapshot
2007-11-05 14:28:46 +00:00
{
methodVmFlags(t, method) |= ClassInitFlag;
classVmFlags(t, class_) |= NeedInitFlag;
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
} else if (vm::strcmp
(reinterpret_cast<const int8_t*>("<init>"),
&byteArrayBody(t, methodName(t, method), 0)) == 0)
implement support for volatile fields
2009-03-03 03:18:15 +00:00
{
methodVmFlags(t, method) |= ConstructorFlag;
snapshot
2007-11-05 14:28:46 +00:00
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, methodTable, ArrayBody + (i * BytesPerWord), method);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, class_, ClassMethodTable, methodTable);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
object abstractVirtuals;
if (classFlags(t, class_) & ACC_INTERFACE) {
abstractVirtuals = 0;
} else {
abstractVirtuals = addInterfaceMethods
(t, class_, virtualMap, &virtualCount, true);
}
PROTECT(t, abstractVirtuals);
ensure that we populate the interface vtables of a class which does not declare any new virtual methods but does implement new interfaces relative to its superclass
2008-01-28 15:12:06 +00:00
bool populateInterfaceVtables = false;
more bugfixes
2007-08-14 13:27:10 +00:00
if (declaredVirtualCount == 0
fix failure to add abstract virtuals to class with no declared virtuals
2010-09-25 22:35:18 +00:00
and abstractVirtuals == 0
more bugfixes
2007-08-14 13:27:10 +00:00
and (classFlags(t, class_) & ACC_INTERFACE) == 0)
{
allow java.lang.Object with no virtual methods, which may occur due to code shrinking
2008-01-21 23:42:12 +00:00
if (classSuper(t, class_)) {
// inherit virtual table from superclass
set(t, class_, ClassVirtualTable, superVirtualTable);
if (classInterfaceTable(t, classSuper(t, class_))
and arrayLength(t, classInterfaceTable(t, class_))
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
== arrayLength
(t, classInterfaceTable(t, classSuper(t, class_))))
allow java.lang.Object with no virtual methods, which may occur due to code shrinking
2008-01-21 23:42:12 +00:00
{
// inherit interface table from superclass
set(t, class_, ClassInterfaceTable,
classInterfaceTable(t, classSuper(t, class_)));
ensure that we populate the interface vtables of a class which does not declare any new virtual methods but does implement new interfaces relative to its superclass
2008-01-28 15:12:06 +00:00
} else {
populateInterfaceVtables = true;
}
allow java.lang.Object with no virtual methods, which may occur due to code shrinking
2008-01-21 23:42:12 +00:00
} else {
ensure that we populate the interface vtables of a class which does not declare any new virtual methods but does implement new interfaces relative to its superclass
2008-01-28 15:12:06 +00:00
// apparently, Object does not have any virtual methods. We
// give it a vtable anyway so code doesn't break elsewhere.
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
object vtable = makeArray(t, 0);
allow java.lang.Object with no virtual methods, which may occur due to code shrinking
2008-01-21 23:42:12 +00:00
set(t, class_, ClassVirtualTable, vtable);
various threading bugfixes
2007-11-27 22:23:00 +00:00
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
} else if (virtualCount) {
// generate class vtable
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
object vtable = makeArray(t, virtualCount);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
various bugfixes
2007-08-14 00:37:00 +00:00
unsigned i = 0;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
if (classFlags(t, class_) & ACC_INTERFACE) {
fix various bugs uncovered in GC stress test
2007-07-16 23:58:37 +00:00
PROTECT(t, vtable);
avoid creating garbage when iterating over hashmaps
2008-11-22 23:38:41 +00:00
for (HashMapIterator it(t, virtualMap); it.hasMore();) {
object method = tripleFirst(t, it.next());
various bugfixes
2007-08-14 00:37:00 +00:00
assert(t, arrayBody(t, vtable, methodOffset(t, method)) == 0);
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, vtable, ArrayBody + (methodOffset(t, method) * BytesPerWord),
method);
various bugfixes
2007-08-14 00:37:00 +00:00
++ i;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
} else {
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
populateInterfaceVtables = true;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
if (superVirtualTable) {
for (; i < arrayLength(t, superVirtualTable); ++i) {
object method = arrayBody(t, superVirtualTable, i);
method = hashMapFind(t, virtualMap, method, methodHash, methodEqual);
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, vtable, ArrayBody + (i * BytesPerWord), method);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
}
for (object p = listFront(t, newVirtuals); p; p = pairSecond(t, p)) {
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, vtable, ArrayBody + (i * BytesPerWord), pairFirst(t, p));
++ i;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
if (abstractVirtuals) {
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
PROTECT(t, vtable);
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
fix Class.getDeclaredMethods Internally, the VM augments the method tables for abstract classes with any inherited abstract methods to make code simpler elsewhere, but that means we can't use that table to construct the result of Class.getDeclaredMethods since it would include methods not actually declared in the class. This commit ensures that we preserve and use the original, un-augmented table for that purpose.
2011-04-10 03:20:56 +00:00
object addendum = getClassAddendum(t, class_, pool);
set(t, addendum, ClassAddendumMethodTable,
classMethodTable(t, class_));
avoid crash when parsing certain abstract classes which declare no methods
2012-01-13 23:51:39 +00:00
unsigned oldLength = classMethodTable(t, class_) ?
arrayLength(t, classMethodTable(t, class_)) : 0;
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
object newMethodTable = makeArray
(t, oldLength + listSize(t, abstractVirtuals));
avoid crash when parsing certain abstract classes which declare no methods
2012-01-13 23:51:39 +00:00
if (oldLength) {
memcpy(&arrayBody(t, newMethodTable, 0),
&arrayBody(t, classMethodTable(t, class_), 0),
oldLength * sizeof(object));
}
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
mark(t, newMethodTable, ArrayBody, oldLength);
unsigned mti = oldLength;
for (object p = listFront(t, abstractVirtuals);
p; p = pairSecond(t, p))
{
set(t, newMethodTable,
ArrayBody + ((mti++) * BytesPerWord), pairFirst(t, p));
set(t, vtable,
ArrayBody + ((i++) * BytesPerWord), pairFirst(t, p));
}
assert(t, arrayLength(t, newMethodTable) == mti);
set(t, class_, ClassMethodTable, newMethodTable);
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
various bugfixes
2007-08-14 00:37:00 +00:00
assert(t, arrayLength(t, vtable) == i);
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, class_, ClassVirtualTable, vtable);
ensure that we populate the interface vtables of a class which does not declare any new virtual methods but does implement new interfaces relative to its superclass
2008-01-28 15:12:06 +00:00
}
fix handling of interface vtables for abstract classes
2008-03-21 23:42:36 +00:00
if (populateInterfaceVtables) {
ensure that we populate the interface vtables of a class which does not declare any new virtual methods but does implement new interfaces relative to its superclass
2008-01-28 15:12:06 +00:00
// generate interface vtables
object itable = classInterfaceTable(t, class_);
if (itable) {
PROTECT(t, itable);
for (unsigned i = 0; i < arrayLength(t, itable); i += 2) {
object ivtable = classVirtualTable(t, arrayBody(t, itable, i));
if (ivtable) {
object vtable = arrayBody(t, itable, i + 1);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
ensure that we populate the interface vtables of a class which does not declare any new virtual methods but does implement new interfaces relative to its superclass
2008-01-28 15:12:06 +00:00
for (unsigned j = 0; j < arrayLength(t, ivtable); ++j) {
object method = arrayBody(t, ivtable, j);
method = hashMapFind
(t, virtualMap, method, methodHash, methodEqual);
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
assert(t, method);
various bugfixes
2007-08-14 00:37:00 +00:00
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
set(t, vtable, ArrayBody + (j * BytesPerWord), method);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
}
}
}
}
}
implement StackTraceElement.getFileName properly
2009-08-27 22:26:25 +00:00
void
parseAttributeTable(Thread* t, Stream& s, object class_, object pool)
{
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
PROTECT(t, class_);
PROTECT(t, pool);
implement StackTraceElement.getFileName properly
2009-08-27 22:26:25 +00:00
unsigned attributeCount = s.read2();
for (unsigned j = 0; j < attributeCount; ++j) {
object name = singletonObject(t, pool, s.read2() - 1);
unsigned length = s.read4();
if (vm::strcmp(reinterpret_cast<const int8_t*>("SourceFile"),
&byteArrayBody(t, name, 0)) == 0)
{
set(t, class_, ClassSourceFile, singletonObject(t, pool, s.read2() - 1));
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
} else if (vm::strcmp(reinterpret_cast<const int8_t*>("Signature"),
&byteArrayBody(t, name, 0)) == 0)
{
fix Class.getDeclaredMethods Internally, the VM augments the method tables for abstract classes with any inherited abstract methods to make code simpler elsewhere, but that means we can't use that table to construct the result of Class.getDeclaredMethods since it would include methods not actually declared in the class. This commit ensures that we preserve and use the original, un-augmented table for that purpose.
2011-04-10 03:20:56 +00:00
object addendum = getClassAddendum(t, class_, pool);
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
set(t, addendum, AddendumSignature,
singletonObject(t, pool, s.read2() - 1));
provide proper implementations of JVM_GetDeclaredClasses, JVM_GetDeclaringClass
2011-04-01 01:47:26 +00:00
} else if (vm::strcmp(reinterpret_cast<const int8_t*>("InnerClasses"),
&byteArrayBody(t, name, 0)) == 0)
{
unsigned innerClassCount = s.read2();
object table = makeArray(t, innerClassCount);
PROTECT(t, table);
for (unsigned i = 0; i < innerClassCount; ++i) {
int16_t inner = s.read2();
int16_t outer = s.read2();
int16_t name = s.read2();
int16_t flags = s.read2();
object reference = makeInnerClassReference
(t, inner ? singletonObject(t, pool, inner - 1) : 0,
outer ? singletonObject(t, pool, outer - 1) : 0,
name ? singletonObject(t, pool, name - 1) : 0,
flags);
set(t, table, ArrayBody + (i * BytesPerWord), reference);
}
fix Class.getDeclaredMethods Internally, the VM augments the method tables for abstract classes with any inherited abstract methods to make code simpler elsewhere, but that means we can't use that table to construct the result of Class.getDeclaredMethods since it would include methods not actually declared in the class. This commit ensures that we preserve and use the original, un-augmented table for that purpose.
2011-04-10 03:20:56 +00:00
object addendum = getClassAddendum(t, class_, pool);
provide proper implementations of JVM_GetDeclaredClasses, JVM_GetDeclaringClass
2011-04-01 01:47:26 +00:00
set(t, addendum, ClassAddendumInnerClassTable, table);
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
} else if (vm::strcmp(reinterpret_cast<const int8_t*>
("RuntimeVisibleAnnotations"),
&byteArrayBody(t, name, 0)) == 0)
{
move proxy and annotation code from C++ to Java This allows code shrinkers to remove it if it's not used by the application.
2009-09-19 22:21:15 +00:00
object body = makeByteArray(t, length);
fix Class.getDeclaredMethods Internally, the VM augments the method tables for abstract classes with any inherited abstract methods to make code simpler elsewhere, but that means we can't use that table to construct the result of Class.getDeclaredMethods since it would include methods not actually declared in the class. This commit ensures that we preserve and use the original, un-augmented table for that purpose.
2011-04-10 03:20:56 +00:00
PROTECT(t, body);
move proxy and annotation code from C++ to Java This allows code shrinkers to remove it if it's not used by the application.
2009-09-19 22:21:15 +00:00
s.read(reinterpret_cast<uint8_t*>(&byteArrayBody(t, body, 0)), length);
fix Class.getDeclaredMethods Internally, the VM augments the method tables for abstract classes with any inherited abstract methods to make code simpler elsewhere, but that means we can't use that table to construct the result of Class.getDeclaredMethods since it would include methods not actually declared in the class. This commit ensures that we preserve and use the original, un-augmented table for that purpose.
2011-04-10 03:20:56 +00:00
object addendum = getClassAddendum(t, class_, pool);
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
set(t, addendum, AddendumAnnotationTable, body);
implement StackTraceElement.getFileName properly
2009-08-27 22:26:25 +00:00
} else {
s.skip(length);
}
}
}
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
void
updateClassTables(Thread* t, object newClass, object oldClass)
{
object fieldTable = classFieldTable(t, newClass);
if (fieldTable) {
for (unsigned i = 0; i < arrayLength(t, fieldTable); ++i) {
set(t, arrayBody(t, fieldTable, i), FieldClass, newClass);
}
}
update static table class reference in updateClassTables Commit c918cbc added this reference to ensure sun.misc.Unsafe.getLongVolatile could be implemented efficiently on 32-bit platforms. However, I neglected to ensure the reference was updated to point to the final class instance instead of the temporary one used in parseClass. This led to extra memory usage and inconsistent locking behavior, plus broken bootimage builds.
2012-10-06 21:25:12 +00:00
object staticTable = classStaticTable(t, newClass);
if (staticTable) {
set(t, staticTable, SingletonBody, newClass);
}
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
if (classFlags(t, newClass) & ACC_INTERFACE) {
object virtualTable = classVirtualTable(t, newClass);
if (virtualTable) {
for (unsigned i = 0; i < arrayLength(t, virtualTable); ++i) {
if (methodClass(t, arrayBody(t, virtualTable, i)) == oldClass) {
set(t, arrayBody(t, virtualTable, i), MethodClass, newClass);
}
}
}
} else {
object methodTable = classMethodTable(t, newClass);
if (methodTable) {
for (unsigned i = 0; i < arrayLength(t, methodTable); ++i) {
set(t, arrayBody(t, methodTable, i), MethodClass, newClass);
}
}
}
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
void
updateBootstrapClass(Thread* t, object bootstrapClass, object class_)
{
expect(t, bootstrapClass != class_);
// verify that the classes have the same layout
expect(t, classSuper(t, bootstrapClass) == classSuper(t, class_));
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
expect(t, classFixedSize(t, bootstrapClass) >= classFixedSize(t, class_));
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
implement basic finalization support This implementation does not conform to the Java standard in that finalize methods are called from whichever thread happens to be garbage collecting, and that thread may hold locks, whereas the standard guarantees that finalize will be run from a thread which holds no locks. Also, an object will never be finalized more than once, even if its finalize method "rescues" (i.e. makes reachable) the object such that it might become unreachable a second time and thus a candidate for finalization once more. It's not clear to me from the standard if this is OK or not. Nonwithstanding the above, this implementation is useful for "normal" finalize methods which simply release resources associated with an object.
2009-07-22 00:57:55 +00:00
expect(t, (classVmFlags(t, class_) & HasFinalizerFlag) == 0);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
PROTECT(t, bootstrapClass);
PROTECT(t, class_);
ENTER(t, Thread::ExclusiveState);
preserve vm flags of bootstrap class (except for BootstrapFlag) in updateBootstrapClass()
2007-11-05 15:39:48 +00:00
classVmFlags(t, bootstrapClass) &= ~BootstrapFlag;
classVmFlags(t, bootstrapClass) |= classVmFlags(t, class_);
various bugfixes to get Continuations test working
2009-05-16 08:03:03 +00:00
classFlags(t, bootstrapClass) |= classFlags(t, class_);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, bootstrapClass, ClassSuper, classSuper(t, class_));
set(t, bootstrapClass, ClassInterfaceTable, classInterfaceTable(t, class_));
set(t, bootstrapClass, ClassVirtualTable, classVirtualTable(t, class_));
set(t, bootstrapClass, ClassFieldTable, classFieldTable(t, class_));
set(t, bootstrapClass, ClassMethodTable, classMethodTable(t, class_));
set(t, bootstrapClass, ClassStaticTable, classStaticTable(t, class_));
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
set(t, bootstrapClass, ClassAddendum, classAddendum(t, class_));
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
updateClassTables(t, bootstrapClass, class_);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
object
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
makeArrayClass(Thread* t, object loader, unsigned dimensions, object spec,
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
object elementClass)
{
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
if (classVmFlags(t, type(t, Machine::JobjectType)) & BootstrapFlag) {
fix custom-classloader-related concurrency problems and other bugs The main changes in this commit ensure that we don't hold the global class lock when doing class resolution using application-defined classloaders. Such classloaders may do their own locking (in fact, it's almost certain), making deadlock likely when mixed with VM-level locking in various orders. Other changes include a fix to avoid overflow when waiting for extremely long intervals and a GC root stack mapping bug.
2010-09-17 01:43:27 +00:00
PROTECT(t, loader);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
PROTECT(t, spec);
PROTECT(t, elementClass);
avoid inifinite recursion if java.lang.Object is missing; refactoring When trying to create an array class, we try to resolve java.lang.Object so we can use its vtable in the array class. However, if Object is missing, we'll try to create and throw a ClassNotFoundException, which requires creating an array to store the stack trace, which requires creating an array class, which requires resolving Object, etc.. This commit short-circuits this process by telling resolveClass not to create and throw an exception if it can't find Object. While doing the above work, I noticed that the implementations of Classpath::makeThrowable in classpath-avian.cpp and classpath-openjdk.cpp were identical, so I made makeThrowable a top-level function. Finally, I discovered that Thread.setDaemon can only be called before the target thread has been started, which allowed me to simplify the code to track daemon threads in the VM.
2010-12-10 02:38:12 +00:00
// Load java.lang.Object if present so we can use its vtable, but
// don't throw an exception if we can't find it. This way, we
// avoid infinite recursion due to trying to create an array to
// make a stack trace for a ClassNotFoundException.
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
resolveSystemClass
(t, root(t, Machine::BootLoader),
avoid inifinite recursion if java.lang.Object is missing; refactoring When trying to create an array class, we try to resolve java.lang.Object so we can use its vtable in the array class. However, if Object is missing, we'll try to create and throw a ClassNotFoundException, which requires creating an array to store the stack trace, which requires creating an array class, which requires resolving Object, etc.. This commit short-circuits this process by telling resolveClass not to create and throw an exception if it can't find Object. While doing the above work, I noticed that the implementations of Classpath::makeThrowable in classpath-avian.cpp and classpath-openjdk.cpp were identical, so I made makeThrowable a top-level function. Finally, I discovered that Thread.setDaemon can only be called before the target thread has been started, which allowed me to simplify the code to track daemon threads in the VM.
2010-12-10 02:38:12 +00:00
className(t, type(t, Machine::JobjectType)), false);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
}
object vtable = classVirtualTable(t, type(t, Machine::JobjectType));
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
2+2 test now works with new JIT code
2007-12-11 21:26:59 +00:00
object c = t->m->processor->makeClass
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
(t,
0,
0,
2 * BytesPerWord,
BytesPerWord,
implement ClassLoader.resolveClass and ensure class is linked in e.g. Class.getMethods; minor bugfixes
2009-08-18 20:26:28 +00:00
dimensions,
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classObjectMask(t, type(t, Machine::ArrayType)),
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
spec,
implement StackTraceElement.getFileName properly
2009-08-27 22:26:25 +00:00
0,
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
type(t, Machine::JobjectType),
more Android class library work
2013-02-21 22:37:17 +00:00
root(t, Machine::ArrayInterfaceTable),
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
vtable,
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
0,
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
0,
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
0,
heap o' bugfixes
2007-08-20 02:57:32 +00:00
elementClass,
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
loader,
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
arrayLength(t, vtable));
2+2 test now works with new JIT code
2007-12-11 21:26:59 +00:00
fix GC safety bugs in getClassAddendum and makeArrayClass
2011-07-10 00:01:00 +00:00
PROTECT(t, c);
2+2 test now works with new JIT code
2007-12-11 21:26:59 +00:00
t->m->processor->initVtable(t, c);
return c;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
update class loader map when creating new array class This ensures that we don't create redundant array classes later.
2011-03-27 05:21:37 +00:00
void
saveLoadedClass(Thread* t, object loader, object c)
{
PROTECT(t, loader);
PROTECT(t, c);
ACQUIRE(t, t->m->classLock);
if (classLoaderMap(t, loader) == 0) {
object map = makeHashMap(t, 0, 0);
set(t, loader, ClassLoaderMap, map);
}
hashMapInsert
(t, classLoaderMap(t, loader), className(t, c), c, byteArrayHash);
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
object
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
makeArrayClass(Thread* t, object loader, object spec, bool throw_,
Machine::Type throwType)
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
{
fix GC safety bugs in parseMethodTable and makeArrayClass
2009-09-18 18:20:35 +00:00
PROTECT(t, loader);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
PROTECT(t, spec);
const char* s = reinterpret_cast<const char*>(&byteArrayBody(t, spec, 0));
const char* start = s;
unsigned dimensions = 0;
for (; *s == '['; ++s) ++ dimensions;
object elementSpec;
switch (*s) {
case 'L': {
++ s;
const char* elementSpecStart = s;
while (*s and *s != ';') ++ s;
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
elementSpec = makeByteArray(t, s - elementSpecStart + 1);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
memcpy(&byteArrayBody(t, elementSpec, 0),
&byteArrayBody(t, spec, elementSpecStart - start),
s - elementSpecStart);
byteArrayBody(t, elementSpec, s - elementSpecStart) = 0;
} break;
default:
if (dimensions > 1) {
char c = *s;
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
elementSpec = makeByteArray(t, 3);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
byteArrayBody(t, elementSpec, 0) = '[';
byteArrayBody(t, elementSpec, 1) = c;
byteArrayBody(t, elementSpec, 2) = 0;
-- dimensions;
} else {
abort(t);
}
}
implement Throwable.resolveTrace(); bugfixes
2007-07-14 18:37:04 +00:00
object elementClass = hashMapFind
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
(t, root(t, Machine::BootstrapClassMap), elementSpec, byteArrayHash,
byteArrayEqual);
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
implement Throwable.resolveTrace(); bugfixes
2007-07-14 18:37:04 +00:00
if (elementClass == 0) {
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
elementClass = resolveClass(t, loader, elementSpec, throw_, throwType);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
if (elementClass == 0) return 0;
implement Throwable.resolveTrace(); bugfixes
2007-07-14 18:37:04 +00:00
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
PROTECT(t, elementClass);
update class loader map when creating new array class This ensures that we don't create redundant array classes later.
2011-03-27 05:21:37 +00:00
ACQUIRE(t, t->m->classLock);
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
object class_ = findLoadedClass(t, classLoader(t, elementClass), spec);
update class loader map when creating new array class This ensures that we don't create redundant array classes later.
2011-03-27 05:21:37 +00:00
if (class_) {
return class_;
}
implement more JVM_* methods and avoid duplicate array class loading
2010-09-15 00:52:57 +00:00
update class loader map when creating new array class This ensures that we don't create redundant array classes later.
2011-03-27 05:21:37 +00:00
class_ = makeArrayClass
implement more JVM_* methods and avoid duplicate array class loading
2010-09-15 00:52:57 +00:00
(t, classLoader(t, elementClass), dimensions, spec, elementClass);
update class loader map when creating new array class This ensures that we don't create redundant array classes later.
2011-03-27 05:21:37 +00:00
PROTECT(t, class_);
saveLoadedClass(t, classLoader(t, elementClass), class_);
return class_;
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
}
object
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
resolveArrayClass(Thread* t, object loader, object spec, bool throw_,
Machine::Type throwType)
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
{
object c = hashMapFind
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
(t, root(t, Machine::BootstrapClassMap), spec, byteArrayHash,
byteArrayEqual);
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
if (c) {
set(t, c, ClassVirtualTable,
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVirtualTable(t, type(t, Machine::JobjectType)));
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
return c;
} else {
fix VM abort when ClassLoader.defineClass is used in bootimage build When loading a class which extends another class that contained a field of primitive array type using defineClass in a bootimage=true build, the VM was unable to find the primitive array class, and makeArrayClass refused to create one since it should already have existed. The problem was that the bootimage=true build uses an empty Machine::BootstrapClassMap, and resolveArrayClass expected to find the primitive array classes there. The fix is to check the Machine::BootLoader map if we can't find it in Machine::BootstrapClassMap.
2011-01-17 16:36:03 +00:00
PROTECT(t, loader);
PROTECT(t, spec);
c = findLoadedClass(t, root(t, Machine::BootLoader), spec);
if (c) {
return c;
} else {
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
return makeArrayClass(t, loader, spec, throw_, throwType);
fix VM abort when ClassLoader.defineClass is used in bootimage build When loading a class which extends another class that contained a field of primitive array type using defineClass in a bootimage=true build, the VM was unable to find the primitive array class, and makeArrayClass refused to create one since it should already have existed. The problem was that the bootimage=true build uses an empty Machine::BootstrapClassMap, and resolveArrayClass expected to find the primitive array classes there. The fix is to check the Machine::BootLoader map if we can't find it in Machine::BootstrapClassMap.
2011-01-17 16:36:03 +00:00
}
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
void
removeMonitor(Thread* t, object o)
{
fix subtle bug in hashMapInsert which caused us to update the old array previously associated with the hash map, whereas a GC causes the table to be resized when a weak reference is removed and thus a new array used
2008-01-19 20:12:16 +00:00
unsigned hash;
if (DebugMonitors) {
hash = objectHash(t, o);
}
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
object m = hashMapRemove
(t, root(t, Machine::MonitorMap), o, objectHash, objectEqual);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
if (DebugMonitors) {
reimplement Java object monitors (second try) See commit 8120bee4dc5f9ae2dec75a907778f1479ad398bd for the original problem description and solution. That commit and a couple of related ones had to be reverted when we found they had introduced GC-safety regressions leading to crashes. This commit restores the reverted code and fixes the regressions.
2010-02-05 00:56:21 +00:00
fprintf(stderr, "dispose monitor %p for object %x\n", m, hash);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
}
implement String.intern()
2007-07-29 00:02:32 +00:00
void
removeString(Thread* t, object o)
{
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
hashMapRemove(t, root(t, Machine::StringMap), o, stringHash, objectEqual);
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
}
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
void
bootClass(Thread* t, Machine::Type type, int superType, uint32_t objectMask,
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
unsigned fixedSize, unsigned arrayElementSize, unsigned vtableLength)
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
{
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
object super = (superType >= 0
? vm::type(t, static_cast<Machine::Type>(superType)) : 0);
minor tweaks to reduce memory usage
2007-11-06 15:29:05 +00:00
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
object mask;
if (objectMask) {
minor tweaks to reduce memory usage
2007-11-06 15:29:05 +00:00
if (super
and classObjectMask(t, super)
and intArrayBody(t, classObjectMask(t, super), 0)
== static_cast<int32_t>(objectMask))
{
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
mask = classObjectMask
(t, vm::type(t, static_cast<Machine::Type>(superType)));
minor tweaks to reduce memory usage
2007-11-06 15:29:05 +00:00
} else {
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
mask = makeIntArray(t, 1);
minor tweaks to reduce memory usage
2007-11-06 15:29:05 +00:00
intArrayBody(t, mask, 0) = objectMask;
}
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
} else {
mask = 0;
}
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
super = (superType >= 0
? vm::type(t, static_cast<Machine::Type>(superType)) : 0);
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
object class_ = t->m->processor->makeClass
fix GNU Classpath build
2009-12-06 02:40:46 +00:00
(t, 0, BootstrapFlag, fixedSize, arrayElementSize,
arrayElementSize ? 1 : 0, mask, 0, 0, super, 0, 0, 0, 0, 0, 0,
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
root(t, Machine::BootLoader), vtableLength);
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
setType(t, type, class_);
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
}
void
snapshot
2007-11-05 14:28:46 +00:00
bootJavaClass(Thread* t, Machine::Type type, int superType, const char* name,
int vtableLength, object bootMethod)
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
{
PROTECT(t, bootMethod);
object n = makeByteArray(t, name);
fix GC safety bugs
2010-12-10 05:17:57 +00:00
PROTECT(t, n);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
object class_ = vm::type(t, type);
fix GC safety bugs
2010-12-10 05:17:57 +00:00
PROTECT(t, class_);
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
set(t, class_, ClassName, n);
snapshot
2007-11-05 14:28:46 +00:00
object vtable;
if (vtableLength >= 0) {
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
vtable = makeArray(t, vtableLength);
snapshot
2007-11-05 14:28:46 +00:00
for (int i = 0; i < vtableLength; ++ i) {
arrayBody(t, vtable, i) = bootMethod;
}
} else {
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
vtable = classVirtualTable
(t, vm::type(t, static_cast<Machine::Type>(superType)));
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
}
set(t, class_, ClassVirtualTable, vtable);
2+2 test now works with new JIT code
2007-12-11 21:26:59 +00:00
t->m->processor->initVtable(t, class_);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
hashMapInsert
(t, root(t, Machine::BootstrapClassMap), n, class_, byteArrayHash);
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
}
name VM-internal classes for heapdump=true builds This makes heap dumps more useful since these classes are now refered to by name instead of number. This commit also adds a couple of utilities for parsing heap dumps: PrintDump and DumpStats.
2010-11-16 16:31:49 +00:00
void
nameClass(Thread* t, Machine::Type type, const char* name)
{
object n = makeByteArray(t, name);
set(t, arrayBody(t, t->m->types, type), ClassName, n);
}
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
void
boot(Thread* t)
{
Machine* m = t->m;
update makefile to optionally build and use a boot image; various bugfixes
2008-11-29 23:08:14 +00:00
m->unsafe = true;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
m->roots = allocate(t, pad((Machine::RootCount + 2) * BytesPerWord), true);
arrayLength(t, m->roots) = Machine::RootCount;
setRoot(t, Machine::BootLoader,
allocate(t, FixedSizeOfSystemClassLoader, true));
setRoot(t, Machine::AppLoader,
allocate(t, FixedSizeOfSystemClassLoader, true));
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
m->types = allocate(t, pad((TypeCount + 2) * BytesPerWord), true);
arrayLength(t, m->types) = TypeCount;
#include "type-initializations.cpp"
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
object arrayClass = type(t, Machine::ArrayType);
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
set(t, m->types, 0, arrayClass);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
set(t, m->roots, 0, arrayClass);
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
object loaderClass = type(t, Machine::SystemClassLoaderType);
set(t, root(t, Machine::BootLoader), 0, loaderClass);
set(t, root(t, Machine::AppLoader), 0, loaderClass);
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
object objectClass = type(t, Machine::JobjectType);
mark system classloader initialized when using GNU Classpath to avoid security exceptions; only look for field in interfaces after looking in class and superclasses
2009-12-25 00:57:07 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
object classClass = type(t, Machine::ClassType);
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
set(t, classClass, 0, classClass);
set(t, classClass, ClassSuper, objectClass);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
object intArrayClass = type(t, Machine::IntArrayType);
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
set(t, intArrayClass, 0, classClass);
set(t, intArrayClass, ClassSuper, objectClass);
m->unsafe = false;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::SingletonType))
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
|= SingletonFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::ContinuationType))
early sketch of continuation support
2009-05-03 20:57:11 +00:00
|= ContinuationFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::JreferenceType))
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
|= ReferenceFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::WeakReferenceType))
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
|= ReferenceFlag | WeakReferenceFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::SoftReferenceType))
treat SoftReferences as WeakReferences; do vtable or interface table lookups as necessary in MyProcessor::invoke; various bugfixes
2009-08-13 15:17:05 +00:00
|= ReferenceFlag | WeakReferenceFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::PhantomReferenceType))
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
|= ReferenceFlag | WeakReferenceFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::JbooleanType))
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
|= PrimitiveFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::JbyteType))
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
|= PrimitiveFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::JcharType))
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
|= PrimitiveFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::JshortType))
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
|= PrimitiveFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::JintType))
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
|= PrimitiveFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::JlongType))
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
|= PrimitiveFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::JfloatType))
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
|= PrimitiveFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::JdoubleType))
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
|= PrimitiveFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
classVmFlags(t, type(t, Machine::JvoidType))
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
|= PrimitiveFlag;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
set(t, type(t, Machine::BooleanArrayType), ClassStaticTable,
type(t, Machine::JbooleanType));
set(t, type(t, Machine::ByteArrayType), ClassStaticTable,
type(t, Machine::JbyteType));
set(t, type(t, Machine::CharArrayType), ClassStaticTable,
type(t, Machine::JcharType));
set(t, type(t, Machine::ShortArrayType), ClassStaticTable,
type(t, Machine::JshortType));
set(t, type(t, Machine::IntArrayType), ClassStaticTable,
type(t, Machine::JintType));
set(t, type(t, Machine::LongArrayType), ClassStaticTable,
type(t, Machine::JlongType));
set(t, type(t, Machine::FloatArrayType), ClassStaticTable,
type(t, Machine::JfloatType));
set(t, type(t, Machine::DoubleArrayType), ClassStaticTable,
type(t, Machine::JdoubleType));
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
{ object map = makeHashMap(t, 0, 0);
set(t, root(t, Machine::BootLoader), ClassLoaderMap, map);
}
systemClassLoaderFinder(t, root(t, Machine::BootLoader)) = m->bootFinder;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
{ object map = makeHashMap(t, 0, 0);
set(t, root(t, Machine::AppLoader), ClassLoaderMap, map);
}
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
systemClassLoaderFinder(t, root(t, Machine::AppLoader)) = m->appFinder;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
set(t, root(t, Machine::AppLoader), ClassLoaderParent,
root(t, Machine::BootLoader));
setRoot(t, Machine::BootstrapClassMap, makeHashMap(t, 0, 0));
setRoot(t, Machine::StringMap, makeWeakHashMap(t, 0, 0));
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
more Android class library work
2013-02-21 22:37:17 +00:00
{ object interfaceTable = makeArray(t, 4);
set(t, interfaceTable, ArrayBody, type(t, Machine::SerializableType));
set(t, interfaceTable, ArrayBody + (2 * BytesPerWord),
type(t, Machine::CloneableType));
setRoot(t, Machine::ArrayInterfaceTable, interfaceTable);
}
set(t, type(t, Machine::BooleanArrayType), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, type(t, Machine::ByteArrayType), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, type(t, Machine::CharArrayType), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, type(t, Machine::ShortArrayType), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, type(t, Machine::IntArrayType), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, type(t, Machine::LongArrayType), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, type(t, Machine::FloatArrayType), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
set(t, type(t, Machine::DoubleArrayType), ClassInterfaceTable,
root(t, Machine::ArrayInterfaceTable));
generate read-only code image in bootimage build This avoids the requirement of putting the code image in a section/segment which is both writable and executable, which is good for security and avoids trouble with systems like iOS which disallow such things. The implementation relies on relative addressing such that the offset of the desired address is fixed as a compile-time constant relative to the start of the memory area of interest (e.g. the code image, heap image, or thunk table). At runtime, the base pointer to the memory area is retrieved from the thread structure and added to the offset to compute the final address. Using the thread pointer allows us to generate read-only, position-independent code while avoiding the use of IP-relative addressing, which is not available on all architectures.
2011-09-20 22:30:30 +00:00
m->processor->boot(t, 0, 0);
fix regressions for non-bootimage case
2008-12-04 02:09:57 +00:00
fix a couple of subtle Thread.getStackTrace bugs The first problem was that, on x86, we failed to properly keep track of whether to expect the return address to be on the stack or not when unwinding through a frame. We were relying on a "stackLimit" pointer to tell us whether we were looking at the most recently-called frame by comparing it with the stack pointer for that frame. That was inaccurate in the case of a thread executing at the beginning of a method before a new frame is allocated, in which case the most recent two frames share a stack pointer, confusing the unwinder. The solution involves keeping track of how many frames we've looked at while walking the stack. The other problem was that compareIpToMethodBounds assumed every method was followed by at least one byte of padding before the next method started. That assumption was usually valid because we were storing the size following method code prior to the code itself. However, the last method of an AOT-compiled code image is not followed by any such method header and may instead be followed directly by native code with no intervening padding. In that case, we risk interpreting that native code as part of the preceding method, with potentially bizarre results. The reason for the compareIpToMethodBounds assumption was that methods which throw exceptions as their last instruction generate a non-returning call, which nonetheless push a return address on the stack which points past the end of the method, and the unwinder needs to know that return address belongs to that method. A better solution is to add an extra trap instruction to the end of such methods, which is what this patch does.
2012-05-05 00:35:13 +00:00
{ object bootCode = makeCode(t, 0, 0, 0, 0, 0, 0, 0, 1);
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
codeBody(t, bootCode, 0) = impdep1;
object bootMethod = makeMethod
fix openjdk-src bootimage build The main change here is to use a lazily-populated vector to associate runtime data with classes instead of referencing them directly from the class which requires updating immutable references in the heap image. The other changes employ other strategies to avoid trying to update immutable references.
2010-11-26 19:41:31 +00:00
(t, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, bootCode);
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
PROTECT(t, bootMethod);
#include "type-java-initializations.cpp"
name VM-internal classes for heapdump=true builds This makes heap dumps more useful since these classes are now refered to by name instead of number. This commit also adds a couple of utilities for parsing heap dumps: PrintDump and DumpStats.
2010-11-16 16:31:49 +00:00
progress towards cross-architecture bootimage builds This monster commit is the first step towards supporting cross-architecture bootimage builds. The challenge is to build a heap and code image for the target platform where the word size and endianess may differ from those of the build architecture. That means the memory layout of objects may differ due to alignment and size differences, so we can't just copy objects into the heap image unchanged; we must copy field by field, resizing values, reversing endianess and shifting offsets as necessary. This commit also removes POD (plain old data) type support from the type generator because it added a lot of complication and little value.
2011-08-30 01:00:17 +00:00
//#ifdef AVIAN_HEAPDUMP
name VM-internal classes for heapdump=true builds This makes heap dumps more useful since these classes are now refered to by name instead of number. This commit also adds a couple of utilities for parsing heap dumps: PrintDump and DumpStats.
2010-11-16 16:31:49 +00:00
# include "type-name-initializations.cpp"
progress towards cross-architecture bootimage builds This monster commit is the first step towards supporting cross-architecture bootimage builds. The challenge is to build a heap and code image for the target platform where the word size and endianess may differ from those of the build architecture. That means the memory layout of objects may differ due to alignment and size differences, so we can't just copy objects into the heap image unchanged; we must copy field by field, resizing values, reversing endianess and shifting offsets as necessary. This commit also removes POD (plain old data) type support from the type generator because it added a lot of complication and little value.
2011-08-30 01:00:17 +00:00
//#endif
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
}
}
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
class HeapClient: public Heap::Client {
public:
HeapClient(Machine* m): m(m) { }
virtual void visitRoots(Heap::Visitor* v) {
Merge branch 'master' into powerpc Conflicts: makefile src/assembler.h src/compile.cpp src/compiler.cpp src/compiler.h src/finder.cpp
2008-11-11 15:20:49 +00:00
::visitRoots(m, v);
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
postVisit(m->rootThread, v);
}
refactor memory allocation to allow better detection and handling of low-memory conditions
2008-01-13 22:05:08 +00:00
virtual void collect(void* context, Heap::CollectionType type) {
enter exclusive state in collect function instead of requiring caller to enter that state before calling
2008-05-05 13:04:53 +00:00
collect(static_cast<Thread*>(context), type);
refactor memory allocation to allow better detection and handling of low-memory conditions
2008-01-13 22:05:08 +00:00
}
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
virtual bool isFixed(void* p) {
return objectFixed(m->rootThread, static_cast<object>(p));
}
virtual unsigned sizeInWords(void* p) {
Thread* t = m->rootThread;
rename mask -> maskAlignedPointer
2013-02-11 00:14:16 +00:00
object o = static_cast<object>(m->heap->follow(maskAlignedPointer(p)));
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
unsigned n = baseSize(t, o, static_cast<object>
(m->heap->follow(objectClass(t, o))));
if (objectExtended(t, o)) {
++ n;
}
return n;
}
virtual unsigned copiedSizeInWords(void* p) {
Thread* t = m->rootThread;
rename mask -> maskAlignedPointer
2013-02-11 00:14:16 +00:00
object o = static_cast<object>(m->heap->follow(maskAlignedPointer(p)));
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
assert(t, not objectFixed(t, o));
unsigned n = baseSize(t, o, static_cast<object>
(m->heap->follow(objectClass(t, o))));
if (objectExtended(t, o) or hashTaken(t, o)) {
++ n;
}
return n;
}
virtual void copy(void* srcp, void* dstp) {
Thread* t = m->rootThread;
rename mask -> maskAlignedPointer
2013-02-11 00:14:16 +00:00
object src = static_cast<object>(m->heap->follow(maskAlignedPointer(srcp)));
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
assert(t, not objectFixed(t, src));
object class_ = static_cast<object>
(m->heap->follow(objectClass(t, src)));
unsigned base = baseSize(t, src, class_);
unsigned n = extendedSize(t, src, base);
object dst = static_cast<object>(dstp);
memcpy(dst, src, n * BytesPerWord);
if (hashTaken(t, src)) {
work around GCC name mangling bug It seems that older versions of GCC (4.0 and older, at least) generate assembly files with duplicate symbols for function templates which differ only by the attributes of the templated types. Newer versions have no such problem, but we need to support both, hence the workaround in this commit of using a dedicated, non-template "alias" function where we previously used "cast<alias_t>".
2011-02-14 18:47:59 +00:00
alias(dst, 0) &= PointerMask;
alias(dst, 0) |= ExtendedMark;
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
extendedWord(t, dst, base) = takeHash(t, src);
}
}
virtual void walk(void* p, Heap::Walker* w) {
rename mask -> maskAlignedPointer
2013-02-11 00:14:16 +00:00
object o = static_cast<object>(m->heap->follow(maskAlignedPointer(p)));
Merge branch 'master' into powerpc Conflicts: makefile src/assembler.h src/compile.cpp src/compiler.cpp src/compiler.h src/finder.cpp
2008-11-11 15:20:49 +00:00
::walk(m->rootThread, w, o, 0);
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
}
refactor memory allocation to allow better detection and handling of low-memory conditions
2008-01-13 22:05:08 +00:00
void dispose() {
simplify memory allocation interfaces
2008-04-13 18:15:04 +00:00
m->heap->free(this, sizeof(*this));
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
}
private:
Machine* m;
};
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
void
doCollect(Thread* t, Heap::CollectionType type)
{
avoid calling doCollect recursively We must not allocate heap objects from doCollect, since it might trigger a GC while one is already in progress, which can cause trouble when we're still queuing up objects to finalize, among other things. To avoid this, I've added extra fields to the finalizer and cleaner types which we can use to link instances up during GC without allocating new memory.
2011-03-26 01:11:38 +00:00
expect(t, not t->m->collecting);
t->m->collecting = true;
THREAD_RESOURCE0(t, t->m->collecting = false);
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
#ifdef VM_STRESS
fix mode=stress thinko and GC safety issue in machine.cpp
2011-03-17 14:49:41 +00:00
bool stress = (t->flags & Thread::StressFlag) != 0;
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
if (not stress) atomicOr(&(t->flags), Thread::StressFlag);
#endif
Machine* m = t->m;
m->unsafe = true;
m->heap->collect(type, footprint(m->rootThread));
m->unsafe = false;
postCollect(m->rootThread);
killZombies(t, m->rootThread);
for (unsigned i = 0; i < m->heapPoolIndex; ++i) {
m->heap->free(m->heapPool[i], ThreadHeapSizeInBytes);
}
m->heapPoolIndex = 0;
if (m->heap->limitExceeded()) {
// if we're out of memory, disallow further allocations of fixed
// objects:
m->fixedFootprint = FixedFootprintThresholdInBytes;
} else {
m->fixedFootprint = 0;
}
#ifdef VM_STRESS
if (not stress) atomicAnd(&(t->flags), ~Thread::StressFlag);
#endif
check for and handle instances of sun.misc.Cleaner during GC OpenJDK uses an alternative to Object.finalize for resource cleanup in the form of sun.misc.Cleaner. Normally, OpenJDK's java.lang.ref.Reference.ReferenceHandler thread handles this, calling Cleaner.clean on any instances it finds in its "pending" queue. However, Avian handles reference queuing internally, so it never actually adds anything to that queue, so the VM must call Cleaner.clean itself.
2011-03-19 21:10:52 +00:00
object finalizeQueue = t->m->finalizeQueue;
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
t->m->finalizeQueue = 0;
check for and handle instances of sun.misc.Cleaner during GC OpenJDK uses an alternative to Object.finalize for resource cleanup in the form of sun.misc.Cleaner. Normally, OpenJDK's java.lang.ref.Reference.ReferenceHandler thread handles this, calling Cleaner.clean on any instances it finds in its "pending" queue. However, Avian handles reference queuing internally, so it never actually adds anything to that queue, so the VM must call Cleaner.clean itself.
2011-03-19 21:10:52 +00:00
for (; finalizeQueue; finalizeQueue = finalizerNext(t, finalizeQueue)) {
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
void (*function)(Thread*, object);
check for and handle instances of sun.misc.Cleaner during GC OpenJDK uses an alternative to Object.finalize for resource cleanup in the form of sun.misc.Cleaner. Normally, OpenJDK's java.lang.ref.Reference.ReferenceHandler thread handles this, calling Cleaner.clean on any instances it finds in its "pending" queue. However, Avian handles reference queuing internally, so it never actually adds anything to that queue, so the VM must call Cleaner.clean itself.
2011-03-19 21:10:52 +00:00
memcpy(&function, &finalizerFinalize(t, finalizeQueue), BytesPerWord);
avoid calling doCollect recursively We must not allocate heap objects from doCollect, since it might trigger a GC while one is already in progress, which can cause trouble when we're still queuing up objects to finalize, among other things. To avoid this, I've added extra fields to the finalizer and cleaner types which we can use to link instances up during GC without allocating new memory.
2011-03-26 01:11:38 +00:00
function(t, finalizerTarget(t, finalizeQueue));
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
}
avoid calling doCollect recursively We must not allocate heap objects from doCollect, since it might trigger a GC while one is already in progress, which can cause trouble when we're still queuing up objects to finalize, among other things. To avoid this, I've added extra fields to the finalizer and cleaner types which we can use to link instances up during GC without allocating new memory.
2011-03-26 01:11:38 +00:00
if ((root(t, Machine::ObjectsToFinalize) or root(t, Machine::ObjectsToClean))
prevent garbage collection as vm shuts down
2013-02-22 23:33:07 +00:00
and m->finalizeThread == 0
and t->state != Thread::ExitState)
avoid calling doCollect recursively We must not allocate heap objects from doCollect, since it might trigger a GC while one is already in progress, which can cause trouble when we're still queuing up objects to finalize, among other things. To avoid this, I've added extra fields to the finalizer and cleaner types which we can use to link instances up during GC without allocating new memory.
2011-03-26 01:11:38 +00:00
{
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
m->finalizeThread = m->processor->makeThread
(m, root(t, Machine::FinalizerThread), m->rootThread);
addThread(t, m->finalizeThread);
if (not startThread(t, m->finalizeThread)) {
removeThread(t, m->finalizeThread);
m->finalizeThread = 0;
}
}
}
implement lazy class/field/method resolution in JIT compiler Unlike the interpreter, the JIT compiler tries to resolve all the symbols referenced by a method when compiling that method. However, this can backfire if a symbol cannot be resolved: we end up throwing an e.g. NoClassDefFoundError for code which may never be executed. This is particularly troublesome for code which supports multiple APIs, choosing one at runtime. The solution is to defer to stub code for symbols which can't be resolved at JIT compile time. Such a stub will try again at runtime to resolve the needed symbol and throw an appropriate error if it still can't be found.
2011-03-15 23:52:02 +00:00
uint64_t
invokeLoadClass(Thread* t, uintptr_t* arguments)
{
object method = reinterpret_cast<object>(arguments[0]);
object loader = reinterpret_cast<object>(arguments[1]);
object specString = reinterpret_cast<object>(arguments[2]);
return reinterpret_cast<uintptr_t>
(t->m->processor->invoke(t, method, loader, specString));
}
call static initializer of superclass before that of class itself Also, assume any class which has an ancestor class which has a static initializer needs initialization even if it doesn't have one itself, per the Java Language Spec.
2011-04-01 01:43:49 +00:00
bool
isInitializing(Thread* t, object c)
{
for (Thread::ClassInitStack* s = t->classInitStack; s; s = s->next) {
if (s->class_ == c) {
return true;
}
}
return false;
}
make find[Field|Method]InClass non-inline functions It seems that GCC 4.6.1 gets confused at LTO time when we take the address of inline functions, so I'm switching them to non-inline linkage to make it happy.
2012-03-27 00:06:16 +00:00
object
findInTable(Thread* t, object table, object name, object spec,
object& (*getName)(Thread*, object),
object& (*getSpec)(Thread*, object))
{
if (table) {
for (unsigned i = 0; i < arrayLength(t, table); ++i) {
object o = arrayBody(t, table, i);
if (vm::strcmp(&byteArrayBody(t, getName(t, o), 0),
&byteArrayBody(t, name, 0)) == 0 and
vm::strcmp(&byteArrayBody(t, getSpec(t, o), 0),
&byteArrayBody(t, spec, 0)) == 0)
{
return o;
}
}
// fprintf(stderr, "%s %s not in\n",
// &byteArrayBody(t, name, 0),
// &byteArrayBody(t, spec, 0));
// for (unsigned i = 0; i < arrayLength(t, table); ++i) {
// object o = arrayBody(t, table, i);
// fprintf(stderr, "\t%s %s\n",
// &byteArrayBody(t, getName(t, o), 0),
// &byteArrayBody(t, getSpec(t, o), 0));
// }
}
return 0;
}
more refactoring
2007-07-06 23:50:26 +00:00
} // namespace
namespace vm {
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
Machine::Machine(System* system, Heap* heap, Finder* bootFinder,
Finder* appFinder, Processor* processor, Classpath* classpath,
enable JMX support for openjdk-src build and implement GetInputArgumentArray
2011-08-06 00:06:29 +00:00
const char** properties, unsigned propertyCount,
implement -Xss command line option
2012-03-14 18:36:42 +00:00
const char** arguments, unsigned argumentCount,
unsigned stackSizeInBytes):
JNIEnv and JavaVM method implementations
2007-09-10 23:33:58 +00:00
vtable(&javaVMVTable),
more refactoring
2007-07-06 23:50:26 +00:00
system(system),
simplify memory allocation interfaces
2008-04-13 18:15:04 +00:00
heapClient(new (heap->allocate(sizeof(HeapClient)))
refactor memory allocation to allow better detection and handling of low-memory conditions
2008-01-13 22:05:08 +00:00
HeapClient(this)),
heap(heap),
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
bootFinder(bootFinder),
appFinder(appFinder),
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
processor(processor),
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
classpath(classpath),
more refactoring
2007-07-06 23:50:26 +00:00
rootThread(0),
exclusive(0),
run java finalizers in a separate thread to guarantee no application locks are held when doing so
2009-08-24 23:51:31 +00:00
finalizeThread(0),
more JNIEnvVTable entries
2007-09-07 23:20:21 +00:00
jniReferences(0),
Merge branch 'master' into powerpc Conflicts: makefile src/assembler.h src/compile.cpp src/compiler.cpp src/compiler.h src/finder.cpp
2008-11-11 15:20:49 +00:00
properties(properties),
propertyCount(propertyCount),
enable JMX support for openjdk-src build and implement GetInputArgumentArray
2011-08-06 00:06:29 +00:00
arguments(arguments),
argumentCount(argumentCount),
avoid running out of OS resources due to zombie thread accumulation The bug here is that when a thread exits and becomes a "zombie", the OS resources associated with it are not necessarily released until we actually join and dispose of that thread. Since that only happens during garbage collection, and collection normally only happens in response to heap memory pressure, there's no guarantee that we'll GC frequently enough to clean up zombies promptly and avoid running out of resources. The solution is to force a GC whenever we start a new thread and there are at least N zombies waiting to be disposed, where N=16 for now.
2012-02-03 19:00:02 +00:00
threadCount(0),
more refactoring
2007-07-06 23:50:26 +00:00
activeCount(0),
liveCount(0),
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
daemonCount(0),
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
fixedFootprint(0),
implement -Xss command line option
2012-03-14 18:36:42 +00:00
stackSizeInBytes(stackSizeInBytes),
JNIEnv and JavaVM method implementations
2007-09-10 23:33:58 +00:00
localThread(0),
more refactoring
2007-07-06 23:50:26 +00:00
stateLock(0),
heapLock(0),
classLock(0),
finish java/lang/ref/* support; add wrapper classes for primitives
2007-07-20 03:18:25 +00:00
referenceLock(0),
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
shutdownLock(0),
remove Machine::lastLibrary and rename firstLibrary to libraries
2008-01-29 15:19:15 +00:00
libraries(0),
add optional avian.error.log system property This property may be used to specify a file name to use for printing stack traces for unhandled exceptions. The default is stderr.
2011-03-15 23:27:17 +00:00
errorLog(0),
add support for LZMA on Windows
2012-06-02 21:43:42 +00:00
bootimage(0),
more refactoring
2007-07-06 23:50:26 +00:00
types(0),
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
roots(0),
more refactoring
2007-07-06 23:50:26 +00:00
finalizers(0),
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
tenuredFinalizers(0),
finalizeQueue(0),
more weak reference work, plus debug logging
2007-07-10 03:04:49 +00:00
weakReferences(0),
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
tenuredWeakReferences(0),
add Machine::heapPool, allowing threads to acquire replacement heaps up to a point before forcing a GC
2007-08-22 14:50:29 +00:00
unsafe(false),
avoid calling doCollect recursively We must not allocate heap objects from doCollect, since it might trigger a GC while one is already in progress, which can cause trouble when we're still queuing up objects to finalize, among other things. To avoid this, I've added extra fields to the finalizer and cleaner types which we can use to link instances up during GC without allocating new memory.
2011-03-26 01:11:38 +00:00
collecting(false),
implement NewDirectByteBuffer etc. properly when building against Classpath; call JNI_OnLoad if found in newly-loaded libraries
2009-06-11 00:15:00 +00:00
triedBuiltinOnLoad(false),
remove unused Heap::Client::outOfMemory method The heap-dump-on-OOM feature has been moved to the collect function.
2011-02-02 15:46:20 +00:00
dumpedHeapOnOOM(false),
support multiple sequential VM instances with bootimage build Until now, the bootimage build hasn't supported using the Java invocation API to create a VM, destroy it, and create another in the same process. Ideally, we would be able to create multiple VMs simultaneously without any interference between them. In fact, Avian is designed to support this for the most part, but there are a few places we use global, mutable state which prevent this from working. Most notably, the bootimage is modified in-place at runtime, so the best we can do without extensive changes is to clean up the bootimage when the VM is destroyed so it's ready for later instances. Hence this commit. Ultimately, we can move towards a fully reentrant VM by making the bootimage immutable, but this will require some care to avoid performance regressions. Another challenge is our Posix signal handlers, which currently rely on a global handle to the VM, since you can't, to my knowledge, pass a context pointer when registering a signal handler. Thread local variables won't necessarily help, since a thread might attatch to more than one VM at a time.
2011-11-10 20:10:53 +00:00
alive(true),
add Machine::heapPool, allowing threads to acquire replacement heaps up to a point before forcing a GC
2007-08-22 14:50:29 +00:00
heapPoolIndex(0)
more refactoring
2007-07-06 23:50:26 +00:00
{
refactor memory allocation to allow better detection and handling of low-memory conditions
2008-01-13 22:05:08 +00:00
heap->setClient(heapClient);
JNIEnv and JavaVM method implementations
2007-09-10 23:33:58 +00:00
populateJNITables(&javaVMVTable, &jniEnvVTable);
more refactoring
2007-07-06 23:50:26 +00:00
Fix crash if no avian.boostrap is specified
2013-01-31 20:06:35 +00:00
const char* bootstrapProperty = findProperty(this, BOOTSTRAP_PROPERTY);
const char* bootstrapPropertyDup = bootstrapProperty ? strdup(bootstrapProperty) : 0;
Fix crash if no avian.boostrap is specified (oops)
2013-01-31 20:08:26 +00:00
const char* bootstrapPropertyEnd = bootstrapPropertyDup + (bootstrapPropertyDup ? strlen(bootstrapPropertyDup) : 0);
Fix crash if no avian.boostrap is specified (oops)
2013-01-31 20:07:56 +00:00
char* codeLibraryName = (char*)bootstrapPropertyDup;
Allow avian.bootstrap to accept multiple libraries
2013-01-31 12:54:23 +00:00
char* codeLibraryNameEnd = 0;
if (codeLibraryName && (codeLibraryNameEnd = strchr(codeLibraryName, system->pathSeparator())))
*codeLibraryNameEnd = 0;
JNIEnv and JavaVM method implementations
2007-09-10 23:33:58 +00:00
if (not system->success(system->make(&localThread)) or
not system->success(system->make(&stateLock)) or
more refactoring
2007-07-06 23:50:26 +00:00
not system->success(system->make(&heapLock)) or
not system->success(system->make(&classLock)) or
use dlopen()/dlsym() to resolve builtin JNI methods
2007-09-18 23:30:09 +00:00
not system->success(system->make(&referenceLock)) or
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
not system->success(system->make(&shutdownLock)) or
Merge branch 'master' into powerpc Conflicts: makefile src/assembler.h src/compile.cpp src/compiler.cpp src/compiler.h src/finder.cpp
2008-11-11 15:20:49 +00:00
not system->success
Fix crash if no avian.boostrap is specified (oops)
2013-01-31 20:10:42 +00:00
(system->load(&libraries, bootstrapPropertyDup)))
more refactoring
2007-07-06 23:50:26 +00:00
{
system->abort();
}
Allow avian.bootstrap to accept multiple libraries
2013-01-31 12:54:23 +00:00
System::Library* additionalLibrary = 0;
while (codeLibraryNameEnd && codeLibraryNameEnd + 1 < bootstrapPropertyEnd) {
codeLibraryName = codeLibraryNameEnd + 1;
codeLibraryNameEnd = strchr(codeLibraryName, system->pathSeparator());
if (codeLibraryNameEnd)
*codeLibraryNameEnd = 0;
if (!system->success(system->load(&additionalLibrary, codeLibraryName)))
system->abort();
libraries->setNext(additionalLibrary);
}
Fix crash if no avian.boostrap is specified
2013-01-31 20:06:35 +00:00
if(bootstrapPropertyDup)
free((void*)bootstrapPropertyDup);
more refactoring
2007-07-06 23:50:26 +00:00
}
void
Machine::dispose()
{
JNIEnv and JavaVM method implementations
2007-09-10 23:33:58 +00:00
localThread->dispose();
more refactoring
2007-07-06 23:50:26 +00:00
stateLock->dispose();
heapLock->dispose();
classLock->dispose();
finish java/lang/ref/* support; add wrapper classes for primitives
2007-07-20 03:18:25 +00:00
referenceLock->dispose();
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
shutdownLock->dispose();
more refactoring
2007-07-06 23:50:26 +00:00
remove Machine::lastLibrary and rename firstLibrary to libraries
2008-01-29 15:19:15 +00:00
if (libraries) {
libraries->disposeAll();
more refactoring
2007-07-06 23:50:26 +00:00
}
more JNIEnvVTable entries
2007-09-07 23:20:21 +00:00
for (Reference* r = jniReferences; r;) {
refactor memory allocation to allow better detection and handling of low-memory conditions
2008-01-13 22:05:08 +00:00
Reference* tmp = r;
more JNIEnvVTable entries
2007-09-07 23:20:21 +00:00
r = r->next;
simplify memory allocation interfaces
2008-04-13 18:15:04 +00:00
heap->free(tmp, sizeof(*tmp));
more JNIEnvVTable entries
2007-09-07 23:20:21 +00:00
}
implement fixed object support
2007-10-28 01:54:30 +00:00
for (unsigned i = 0; i < heapPoolIndex; ++i) {
increase heap pool size and fixed footprint threshold constants based on performance profiling and experimentation
2008-11-22 21:47:18 +00:00
heap->free(heapPool[i], ThreadHeapSizeInBytes);
implement fixed object support
2007-10-28 01:54:30 +00:00
}
add optional LZMA support for compressing embedded JARs, boot images, and shared objects
2012-06-02 15:06:22 +00:00
if (bootimage) {
heap->free(bootimage, bootimageSize);
}
enable JMX support for openjdk-src build and implement GetInputArgumentArray
2011-08-06 00:06:29 +00:00
heap->free(arguments, sizeof(const char*) * argumentCount);
Merge branch 'master' into powerpc Conflicts: makefile src/assembler.h src/compile.cpp src/compiler.cpp src/compiler.h src/finder.cpp
2008-11-11 15:20:49 +00:00
heap->free(properties, sizeof(const char*) * propertyCount);
refactor memory allocation to allow better detection and handling of low-memory conditions
2008-01-13 22:05:08 +00:00
static_cast<HeapClient*>(heapClient)->dispose();
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
simplify memory allocation interfaces
2008-04-13 18:15:04 +00:00
heap->free(this, sizeof(*this));
more refactoring
2007-07-06 23:50:26 +00:00
}
start work on reflection; bugfixes
2007-07-24 01:44:20 +00:00
Thread::Thread(Machine* m, object javaThread, Thread* parent):
more refactoring
2007-07-06 23:50:26 +00:00
vtable(&(m->jniEnvVTable)),
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
m(m),
progress on thread support
2007-07-07 18:09:16 +00:00
parent(parent),
fix race condition leading to deadlock on exit There is a delay between when we tell the OS to start a thread and when it actually starts, and during that time a thread might mistakenly think it was the last to exit, try to shut down the VM, and then block in joinAll when it finds it wasn't the last one after all. The solution is to increment Machine::liveCount and add the new thread to the process tree before starting it -- all while holding Machine::stateLock for atomicity. This helps guarantee that when liveCount is one, we can be sure there's really only one thread running or staged to run.
2010-12-21 02:00:23 +00:00
peer(0),
more refactoring
2007-07-06 23:50:26 +00:00
child(0),
reimplement Java object monitors (second try) See commit 8120bee4dc5f9ae2dec75a907778f1479ad398bd for the original problem description and solution. That commit and a couple of related ones had to be reverted when we found they had introduced GC-safety regressions leading to crashes. This commit restores the reverted code and fixes the regressions.
2010-02-05 00:56:21 +00:00
waitNext(0),
more refactoring
2007-07-06 23:50:26 +00:00
state(NoState),
more JNIEnvVTable entries
2007-09-07 23:20:21 +00:00
criticalLevel(0),
progress on thread support
2007-07-07 18:09:16 +00:00
systemThread(0),
reimplement Java object monitors (second try) See commit 8120bee4dc5f9ae2dec75a907778f1479ad398bd for the original problem description and solution. That commit and a couple of related ones had to be reverted when we found they had introduced GC-safety regressions leading to crashes. This commit restores the reverted code and fixes the regressions.
2010-02-05 00:56:21 +00:00
lock(0),
progress on thread support
2007-07-07 18:09:16 +00:00
javaThread(javaThread),
more refactoring
2007-07-06 23:50:26 +00:00
exception(0),
heapIndex(0),
fix bug in calculating GC footprint in new heap pool code
2007-08-23 02:24:25 +00:00
heapOffset(0),
implement Thread.interrupt()
2007-07-28 21:28:25 +00:00
protector(0),
fix deadlocks and other misbehaviors in class initialization code
2009-07-20 20:12:38 +00:00
classInitStack(0),
fix use of uninitialized values at root thread creation time when running in stress mode; allocate Thread::defaultHeap on the heap instead of as part of the Thread structure
2007-10-14 01:18:25 +00:00
runnable(this),
refactor memory allocation to allow better detection and handling of low-memory conditions
2008-01-13 22:05:08 +00:00
defaultHeap(static_cast<uintptr_t*>
increase heap pool size and fixed footprint threshold constants based on performance profiling and experimentation
2008-11-22 21:47:18 +00:00
(m->heap->allocate(ThreadHeapSizeInBytes))),
more progress on general stack tracing
2008-04-09 19:08:13 +00:00
heap(defaultHeap),
backupHeapIndex(0),
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
flags(ActiveFlag)
support classloading from jar files compiled into the executable
2007-10-25 22:06:05 +00:00
{ }
void
Thread::init()
more refactoring
2007-07-06 23:50:26 +00:00
{
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
memset(defaultHeap, 0, ThreadHeapSizeInBytes);
pre-allocate Thread::backupHeap for signal safety It's not safe to use malloc from a signal handler, so we can't allocate new memory when handling segfaults or Thread.getStackTrace signals. Instead, we allocate a fixed-size backup heap for each thread ahead of time and use it if there's no space left in the normal heap pool. In the rare case that the backup heap isn't large enough, we fall back to using a preallocated exception without a stack trace as a last resort.
2010-06-19 22:40:21 +00:00
memset(backupHeap, 0, ThreadBackupHeapSizeInBytes);
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
progress on thread support
2007-07-07 18:09:16 +00:00
if (parent == 0) {
assert(this, m->rootThread == 0);
assert(this, javaThread == 0);
more refactoring
2007-07-06 23:50:26 +00:00
m->rootThread = this;
m->unsafe = true;
implement Thread.interrupt()
2007-07-28 21:28:25 +00:00
if (not m->system->success(m->system->attach(&runnable))) {
progress on thread support
2007-07-07 18:09:16 +00:00
abort(this);
}
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
BootImage* image = 0;
generate read-only code image in bootimage build This avoids the requirement of putting the code image in a section/segment which is both writable and executable, which is good for security and avoids trouble with systems like iOS which disallow such things. The implementation relies on relative addressing such that the offset of the desired address is fixed as a compile-time constant relative to the start of the memory area of interest (e.g. the code image, heap image, or thunk table). At runtime, the base pointer to the memory area is retrieved from the thread structure and added to the offset to compute the final address. Using the thread pointer allows us to generate read-only, position-independent code while avoiding the use of IP-relative addressing, which is not available on all architectures.
2011-09-20 22:30:30 +00:00
uint8_t* code = 0;
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
const char* imageFunctionName = findProperty(m, "avian.bootimage");
if (imageFunctionName) {
add optional LZMA support for compressing embedded JARs, boot images, and shared objects
2012-06-02 15:06:22 +00:00
bool lzma = strncmp("lzma:", imageFunctionName, 5) == 0;
const char* symbolName
= lzma ? imageFunctionName + 5 : imageFunctionName;
void* imagep = m->libraries->resolve(symbolName);
generate read-only code image in bootimage build This avoids the requirement of putting the code image in a section/segment which is both writable and executable, which is good for security and avoids trouble with systems like iOS which disallow such things. The implementation relies on relative addressing such that the offset of the desired address is fixed as a compile-time constant relative to the start of the memory area of interest (e.g. the code image, heap image, or thunk table). At runtime, the base pointer to the memory area is retrieved from the thread structure and added to the offset to compute the final address. Using the thread pointer allows us to generate read-only, position-independent code while avoiding the use of IP-relative addressing, which is not available on all architectures.
2011-09-20 22:30:30 +00:00
if (imagep) {
add optional LZMA support for compressing embedded JARs, boot images, and shared objects
2012-06-02 15:06:22 +00:00
uint8_t* (*imageFunction)(unsigned*);
generate read-only code image in bootimage build This avoids the requirement of putting the code image in a section/segment which is both writable and executable, which is good for security and avoids trouble with systems like iOS which disallow such things. The implementation relies on relative addressing such that the offset of the desired address is fixed as a compile-time constant relative to the start of the memory area of interest (e.g. the code image, heap image, or thunk table). At runtime, the base pointer to the memory area is retrieved from the thread structure and added to the offset to compute the final address. Using the thread pointer allows us to generate read-only, position-independent code while avoiding the use of IP-relative addressing, which is not available on all architectures.
2011-09-20 22:30:30 +00:00
memcpy(&imageFunction, &imagep, BytesPerWord);
more refactoring
2007-07-06 23:50:26 +00:00
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
unsigned size;
add optional LZMA support for compressing embedded JARs, boot images, and shared objects
2012-06-02 15:06:22 +00:00
uint8_t* imageBytes = imageFunction(&size);
if (lzma) {
#ifdef AVIAN_USE_LZMA
m->bootimage = image = reinterpret_cast<BootImage*>
(decodeLZMA
(m->system, m->heap, imageBytes, size, &(m->bootimageSize)));
#else
abort(this);
#endif
} else {
image = reinterpret_cast<BootImage*>(imageBytes);
}
generate read-only code image in bootimage build This avoids the requirement of putting the code image in a section/segment which is both writable and executable, which is good for security and avoids trouble with systems like iOS which disallow such things. The implementation relies on relative addressing such that the offset of the desired address is fixed as a compile-time constant relative to the start of the memory area of interest (e.g. the code image, heap image, or thunk table). At runtime, the base pointer to the memory area is retrieved from the thread structure and added to the offset to compute the final address. Using the thread pointer allows us to generate read-only, position-independent code while avoiding the use of IP-relative addressing, which is not available on all architectures.
2011-09-20 22:30:30 +00:00
const char* codeFunctionName = findProperty(m, "avian.codeimage");
if (codeFunctionName) {
void* codep = m->libraries->resolve(codeFunctionName);
if (codep) {
uint8_t* (*codeFunction)(unsigned*);
memcpy(&codeFunction, &codep, BytesPerWord);
code = codeFunction(&size);
}
}
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
}
}
more refactoring
2007-07-06 23:50:26 +00:00
m->unsafe = false;
fix openjdk-src bootimage build The main change here is to use a lazily-populated vector to associate runtime data with classes instead of referencing them directly from the class which requires updating immutable references in the heap image. The other changes employ other strategies to avoid trying to update immutable references.
2010-11-26 19:41:31 +00:00
enter(this, ActiveState);
fix thinko in machine.cpp
2011-10-03 14:04:58 +00:00
if (image and code) {
generate read-only code image in bootimage build This avoids the requirement of putting the code image in a section/segment which is both writable and executable, which is good for security and avoids trouble with systems like iOS which disallow such things. The implementation relies on relative addressing such that the offset of the desired address is fixed as a compile-time constant relative to the start of the memory area of interest (e.g. the code image, heap image, or thunk table). At runtime, the base pointer to the memory area is retrieved from the thread structure and added to the offset to compute the final address. Using the thread pointer allows us to generate read-only, position-independent code while avoiding the use of IP-relative addressing, which is not available on all architectures.
2011-09-20 22:30:30 +00:00
m->processor->boot(this, image, code);
initial work on booting from boot image
2008-11-28 22:02:45 +00:00
} else {
boot(this);
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
}
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
setRoot(this, Machine::ByteArrayMap, makeWeakHashMap(this, 0, 0));
setRoot(this, Machine::MonitorMap, makeWeakHashMap(this, 0, 0));
pre-allocate Thread::backupHeap for signal safety It's not safe to use malloc from a signal handler, so we can't allocate new memory when handling segfaults or Thread.getStackTrace signals. Instead, we allocate a fixed-size backup heap for each thread ahead of time and use it if there's no space left in the normal heap pool. In the rare case that the backup heap isn't large enough, we fall back to using a preallocated exception without a stack trace as a last resort.
2010-06-19 22:40:21 +00:00
fix openjdk-src bootimage build The main change here is to use a lazily-populated vector to associate runtime data with classes instead of referencing them directly from the class which requires updating immutable references in the heap image. The other changes employ other strategies to avoid trying to update immutable references.
2010-11-26 19:41:31 +00:00
setRoot(this, Machine::ClassRuntimeDataTable, makeVector(this, 0, 0));
setRoot(this, Machine::MethodRuntimeDataTable, makeVector(this, 0, 0));
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
setRoot(this, Machine::JNIMethodTable, makeVector(this, 0, 0));
handle volatile fields properly in JNI Get/Set methods This commit ensures that we use the proper memory barriers or locking necessary to preserve volatile semantics for such fields when accessed or updated via JNI.
2011-03-16 01:34:00 +00:00
setRoot(this, Machine::JNIFieldTable, makeVector(this, 0, 0));
pre-allocate Thread::backupHeap for signal safety It's not safe to use malloc from a signal handler, so we can't allocate new memory when handling segfaults or Thread.getStackTrace signals. Instead, we allocate a fixed-size backup heap for each thread ahead of time and use it if there's no space left in the normal heap pool. In the rare case that the backup heap isn't large enough, we fall back to using a preallocated exception without a stack trace as a last resort.
2010-06-19 22:40:21 +00:00
JNIEnv and JavaVM method implementations
2007-09-10 23:33:58 +00:00
m->localThread->set(this);
progress on thread support
2007-07-07 18:09:16 +00:00
}
JNIEnv and JavaVM method implementations
2007-09-10 23:33:58 +00:00
reimplement Java object monitors (second try) See commit 8120bee4dc5f9ae2dec75a907778f1479ad398bd for the original problem description and solution. That commit and a couple of related ones had to be reverted when we found they had introduced GC-safety regressions leading to crashes. This commit restores the reverted code and fixes the regressions.
2010-02-05 00:56:21 +00:00
expect(this, m->system->success(m->system->make(&lock)));
progress on thread support
2007-07-07 18:09:16 +00:00
}
void
Thread::exit()
{
if (state != Thread::ExitState and
state != Thread::ZombieState)
{
enter(this, Thread::ExclusiveState);
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
if (m->liveCount == 1) {
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
turnOffTheLights(this);
progress on thread support
2007-07-07 18:09:16 +00:00
} else {
clear Thread::javaThread before entering zombie state, since clearing it in Thread::dispose is too late - the reference may already be invalid since we don't visit GC roots for zombie threads
2009-08-20 14:49:01 +00:00
threadPeer(this, javaThread) = 0;
fix race condition in interrupting/joining threads as they are exiting My recent commit to ensure that OS resources are released immediately upon thread exit introduced a race condition where interrupting or joining a thread as it exited could lead to attempts to use already-released resources. This commit adds locking to avoid the race.
2010-11-16 17:50:19 +00:00
avoid running out of OS resources due to zombie thread accumulation (part 2) My previous attempt wasn't quite sufficient, since it was too late to call join on a thread which had already exited given the code was written to aggressively dispose of system handles as soon as the thread exited. The solution is to delay disposing these handles until after we're able to join the thread.
2012-02-04 00:20:20 +00:00
enter(this, Thread::ZombieState);
progress on thread support
2007-07-07 18:09:16 +00:00
}
more refactoring
2007-07-06 23:50:26 +00:00
}
}
void
Thread::dispose()
{
avoid running out of OS resources due to zombie thread accumulation (part 2) My previous attempt wasn't quite sufficient, since it was too late to call join on a thread which had already exited given the code was written to aggressively dispose of system handles as soon as the thread exited. The solution is to delay disposing these handles until after we're able to join the thread.
2012-02-04 00:20:20 +00:00
if (lock) {
lock->dispose();
}
if (systemThread) {
systemThread->dispose();
progress on thread support
2007-07-07 18:09:16 +00:00
}
avoid running out of OS resources due to zombie thread accumulation The bug here is that when a thread exits and becomes a "zombie", the OS resources associated with it are not necessarily released until we actually join and dispose of that thread. Since that only happens during garbage collection, and collection normally only happens in response to heap memory pressure, there's no guarantee that we'll GC frequently enough to clean up zombies promptly and avoid running out of resources. The solution is to force a GC whenever we start a new thread and there are at least N zombies waiting to be disposed, where N=16 for now.
2012-02-03 19:00:02 +00:00
-- m->threadCount;
increase heap pool size and fixed footprint threshold constants based on performance profiling and experimentation
2008-11-22 21:47:18 +00:00
m->heap->free(defaultHeap, ThreadHeapSizeInBytes);
more GC stress fixes
2007-07-17 00:23:23 +00:00
refactor memory management code We now support immortal objects, which the GC will scan for references but not consider for collection. On x86_64, we allocate JIT code memory via mmap, which lets us map memory into the bottom 2GB of the address space, ensuring that 32-bit relative jumps and calls work.
2008-01-10 01:20:36 +00:00
m->processor->dispose(this);
more refactoring
2007-07-06 23:50:26 +00:00
}
progress on thread support
2007-07-07 18:09:16 +00:00
void
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
shutDown(Thread* t)
progress on thread support
2007-07-07 18:09:16 +00:00
{
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
ACQUIRE(t, t->m->shutdownLock);
progress on thread support
2007-07-07 18:09:16 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
object hooks = root(t, Machine::ShutdownHooks);
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
PROTECT(t, hooks);
progress on thread support
2007-07-07 18:09:16 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
setRoot(t, Machine::ShutdownHooks, 0);
more GC stress fixes
2007-07-17 01:55:49 +00:00
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
object h = hooks;
PROTECT(t, h);
for (; h; h = pairSecond(t, h)) {
startThread(t, pairFirst(t, h));
progress on thread support
2007-07-07 18:09:16 +00:00
}
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
// wait for hooks to exit
h = hooks;
for (; h; h = pairSecond(t, h)) {
while (true) {
Thread* ht = reinterpret_cast<Thread*>(threadPeer(t, pairFirst(t, h)));
more GC stress fixes
2007-07-17 01:55:49 +00:00
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
{ ACQUIRE(t, t->m->stateLock);
more bugfixes, mainly monitor-related
2007-07-11 04:19:26 +00:00
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
if (ht == 0
or ht->state == Thread::ZombieState
or ht->state == Thread::JoinedState)
{
break;
} else {
ENTER(t, Thread::IdleState);
t->m->stateLock->wait(t->systemThread, 0);
}
}
}
}
run java finalizers in a separate thread to guarantee no application locks are held when doing so
2009-08-24 23:51:31 +00:00
// tell finalize thread to exit and wait for it to do so
{ ACQUIRE(t, t->m->stateLock);
Thread* finalizeThread = t->m->finalizeThread;
if (finalizeThread) {
t->m->finalizeThread = 0;
t->m->stateLock->notifyAll(t->systemThread);
while (finalizeThread->state != Thread::ZombieState
and finalizeThread->state != Thread::JoinedState)
{
ENTER(t, Thread::IdleState);
t->m->stateLock->wait(t->systemThread, 0);
}
}
}
support multiple sequential VM instances with bootimage build Until now, the bootimage build hasn't supported using the Java invocation API to create a VM, destroy it, and create another in the same process. Ideally, we would be able to create multiple VMs simultaneously without any interference between them. In fact, Avian is designed to support this for the most part, but there are a few places we use global, mutable state which prevent this from working. Most notably, the bootimage is modified in-place at runtime, so the best we can do without extensive changes is to clean up the bootimage when the VM is destroyed so it's ready for later instances. Hence this commit. Ultimately, we can move towards a fully reentrant VM by making the bootimage immutable, but this will require some care to avoid performance regressions. Another challenge is our Posix signal handlers, which currently rely on a global handle to the VM, since you can't, to my knowledge, pass a context pointer when registering a signal handler. Thread local variables won't necessarily help, since a thread might attatch to more than one VM at a time.
2011-11-10 20:10:53 +00:00
// interrupt daemon threads and tell them to die
// todo: be more aggressive about killing daemon threads, e.g. at
// any GC point, not just at waits/sleeps
{ ACQUIRE(t, t->m->stateLock);
t->m->alive = false;
visitAll(t, t->m->rootThread, interruptDaemon);
}
progress on thread support
2007-07-07 18:09:16 +00:00
}
more refactoring
2007-07-06 23:50:26 +00:00
void
enter(Thread* t, Thread::State s)
{
implement primitive testing framework and provide for GC stress testing
2007-07-16 01:03:02 +00:00
stress(t);
more refactoring
2007-07-06 23:50:26 +00:00
if (s == t->state) return;
more GC stress fixes
2007-07-18 01:33:00 +00:00
if (t->state == Thread::ExitState) {
// once in exit state, we stay that way
return;
}
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
#ifdef USE_ATOMIC_OPERATIONS
# define INCREMENT atomicIncrement
# define ACQUIRE_LOCK ACQUIRE_RAW(t, t->m->stateLock)
refine memory barrier implementation and usage
2009-11-30 15:38:16 +00:00
# define STORE_LOAD_MEMORY_BARRIER storeLoadMemoryBarrier()
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
#else
# define INCREMENT(pointer, value) *(pointer) += value;
# define ACQUIRE_LOCK
refine memory barrier implementation and usage
2009-11-30 15:38:16 +00:00
# define STORE_LOAD_MEMORY_BARRIER
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
ACQUIRE_RAW(t, t->m->stateLock);
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
#endif // not USE_ATOMIC_OPERATIONS
more refactoring
2007-07-06 23:50:26 +00:00
switch (s) {
case Thread::ExclusiveState: {
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
ACQUIRE_LOCK;
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
while (t->m->exclusive) {
more refactoring
2007-07-06 23:50:26 +00:00
// another thread got here first.
progress on thread support
2007-07-07 18:09:16 +00:00
ENTER(t, Thread::IdleState);
avoid busy wait when entering "exclusive" state
2009-11-29 23:53:05 +00:00
t->m->stateLock->wait(t->systemThread, 0);
more refactoring
2007-07-06 23:50:26 +00:00
}
permit state transitions from idle to exclusive
2008-01-18 01:47:32 +00:00
switch (t->state) {
case Thread::ActiveState: break;
case Thread::IdleState: {
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
INCREMENT(&(t->m->activeCount), 1);
permit state transitions from idle to exclusive
2008-01-18 01:47:32 +00:00
} break;
default: abort(t);
}
more refactoring
2007-07-06 23:50:26 +00:00
t->state = Thread::ExclusiveState;
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
t->m->exclusive = t;
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
refine memory barrier implementation and usage
2009-11-30 15:38:16 +00:00
STORE_LOAD_MEMORY_BARRIER;
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
while (t->m->activeCount > 1) {
t->m->stateLock->wait(t->systemThread, 0);
more refactoring
2007-07-06 23:50:26 +00:00
}
} break;
case Thread::IdleState:
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
if (LIKELY(t->state == Thread::ActiveState)) {
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
// fast path
assert(t, t->m->activeCount > 0);
INCREMENT(&(t->m->activeCount), -1);
t->state = s;
if (t->m->exclusive) {
ACQUIRE_LOCK;
t->m->stateLock->notifyAll(t->systemThread);
}
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
break;
} else {
// fall through to slow path
}
more refactoring
2007-07-06 23:50:26 +00:00
case Thread::ZombieState: {
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
ACQUIRE_LOCK;
more refactoring
2007-07-06 23:50:26 +00:00
switch (t->state) {
case Thread::ExclusiveState: {
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
assert(t, t->m->exclusive == t);
t->m->exclusive = 0;
more refactoring
2007-07-06 23:50:26 +00:00
} break;
case Thread::ActiveState: break;
default: abort(t);
}
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
assert(t, t->m->activeCount > 0);
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
INCREMENT(&(t->m->activeCount), -1);
more GC stress fixes
2007-07-18 01:33:00 +00:00
more refactoring
2007-07-06 23:50:26 +00:00
if (s == Thread::ZombieState) {
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
assert(t, t->m->liveCount > 0);
-- t->m->liveCount;
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
avoid inifinite recursion if java.lang.Object is missing; refactoring When trying to create an array class, we try to resolve java.lang.Object so we can use its vtable in the array class. However, if Object is missing, we'll try to create and throw a ClassNotFoundException, which requires creating an array to store the stack trace, which requires creating an array class, which requires resolving Object, etc.. This commit short-circuits this process by telling resolveClass not to create and throw an exception if it can't find Object. While doing the above work, I noticed that the implementations of Classpath::makeThrowable in classpath-avian.cpp and classpath-openjdk.cpp were identical, so I made makeThrowable a top-level function. Finally, I discovered that Thread.setDaemon can only be called before the target thread has been started, which allowed me to simplify the code to track daemon threads in the VM.
2010-12-10 02:38:12 +00:00
if (t->flags & Thread::DaemonFlag) {
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
-- t->m->daemonCount;
}
more refactoring
2007-07-06 23:50:26 +00:00
}
fix race condition leading to deadlock on exit There is a delay between when we tell the OS to start a thread and when it actually starts, and during that time a thread might mistakenly think it was the last to exit, try to shut down the VM, and then block in joinAll when it finds it wasn't the last one after all. The solution is to increment Machine::liveCount and add the new thread to the process tree before starting it -- all while holding Machine::stateLock for atomicity. This helps guarantee that when liveCount is one, we can be sure there's really only one thread running or staged to run.
2010-12-21 02:00:23 +00:00
more refactoring
2007-07-06 23:50:26 +00:00
t->state = s;
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
t->m->stateLock->notifyAll(t->systemThread);
more refactoring
2007-07-06 23:50:26 +00:00
} break;
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
case Thread::ActiveState:
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
if (LIKELY(t->state == Thread::IdleState and t->m->exclusive == 0)) {
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
// fast path
INCREMENT(&(t->m->activeCount), 1);
fix race condition introduced in previous commit
2009-11-28 22:24:02 +00:00
second attempt to fix "idle to active" fast path If another thread succeeds in entering the "exclusive" state while we use the fast path to transition the current thread to "active", we must switch back to "idle" temporarily to allow the exclusive thread a chance to continue, and then retry the transition to "active" via the slow path.
2009-11-28 22:35:15 +00:00
t->state = s;
fix race condition introduced in previous commit
2009-11-28 22:24:02 +00:00
if (t->m->exclusive) {
second attempt to fix "idle to active" fast path If another thread succeeds in entering the "exclusive" state while we use the fast path to transition the current thread to "active", we must switch back to "idle" temporarily to allow the exclusive thread a chance to continue, and then retry the transition to "active" via the slow path.
2009-11-28 22:35:15 +00:00
// another thread has entered the exclusive state, so we
// return to idle and use the slow path to become active
enter(t, Thread::IdleState);
fix race condition introduced in previous commit
2009-11-28 22:24:02 +00:00
} else {
break;
}
}
{ ACQUIRE_LOCK;
more refactoring
2007-07-06 23:50:26 +00:00
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
switch (t->state) {
case Thread::ExclusiveState: {
assert(t, t->m->exclusive == t);
more refactoring
2007-07-06 23:50:26 +00:00
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
t->state = s;
t->m->exclusive = 0;
t->m->stateLock->notifyAll(t->systemThread);
} break;
case Thread::NoState:
case Thread::IdleState: {
while (t->m->exclusive) {
t->m->stateLock->wait(t->systemThread, 0);
}
INCREMENT(&(t->m->activeCount), 1);
if (t->state == Thread::NoState) {
++ t->m->liveCount;
avoid running out of OS resources due to zombie thread accumulation The bug here is that when a thread exits and becomes a "zombie", the OS resources associated with it are not necessarily released until we actually join and dispose of that thread. Since that only happens during garbage collection, and collection normally only happens in response to heap memory pressure, there's no guarantee that we'll GC frequently enough to clean up zombies promptly and avoid running out of resources. The solution is to force a GC whenever we start a new thread and there are at least N zombies waiting to be disposed, where N=16 for now.
2012-02-03 19:00:02 +00:00
++ t->m->threadCount;
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
}
t->state = s;
} break;
more refactoring
2007-07-06 23:50:26 +00:00
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
default: abort(t);
more refactoring
2007-07-06 23:50:26 +00:00
}
} break;
case Thread::ExitState: {
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
ACQUIRE_LOCK;
more refactoring
2007-07-06 23:50:26 +00:00
switch (t->state) {
case Thread::ExclusiveState: {
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
assert(t, t->m->exclusive == t);
prevent garbage collection as vm shuts down
2013-02-22 23:33:07 +00:00
// exit state should also be exclusive, so don't set exclusive = 0
various threading bugfixes
2007-11-27 22:23:00 +00:00
t->m->stateLock->notifyAll(t->systemThread);
more refactoring
2007-07-06 23:50:26 +00:00
} break;
case Thread::ActiveState: break;
default: abort(t);
}
more GC stress fixes
2007-07-18 01:33:00 +00:00
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
assert(t, t->m->activeCount > 0);
provide fast paths for common thread state transitions These paths reduce contention among threads by using atomic operations and memory barriers instead of mutexes where possible. This is especially important for JNI calls, since each such call involves two state transitions: from "active" to "idle" and back.
2009-11-28 22:01:54 +00:00
INCREMENT(&(t->m->activeCount), -1);
more GC stress fixes
2007-07-18 01:33:00 +00:00
more refactoring
2007-07-06 23:50:26 +00:00
t->state = s;
implement Runtime.addShutdownHook and Thread.setDaemon; avoid segfaults due to an application calling e.g. CallStaticBooleanMethod when it really meant CallStaticVoidMethod
2009-08-19 20:27:03 +00:00
while (t->m->liveCount - t->m->daemonCount > 1) {
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
t->m->stateLock->wait(t->systemThread, 0);
more refactoring
2007-07-06 23:50:26 +00:00
}
} break;
default: abort(t);
}
}
object
refactor memory management code We now support immortal objects, which the GC will scan for references but not consider for collection. On x86_64, we allocate JIT code memory via mmap, which lets us map memory into the bottom 2GB of the address space, ensuring that 32-bit relative jumps and calls work.
2008-01-10 01:20:36 +00:00
allocate2(Thread* t, unsigned sizeInBytes, bool objectMask)
{
return allocate3
refactor memory allocation to allow better detection and handling of low-memory conditions
2008-01-13 22:05:08 +00:00
(t, t->m->heap,
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
ceilingDivide(sizeInBytes, BytesPerWord) > ThreadHeapSizeInWords ?
refactor memory management code We now support immortal objects, which the GC will scan for references but not consider for collection. On x86_64, we allocate JIT code memory via mmap, which lets us map memory into the bottom 2GB of the address space, ensuring that 32-bit relative jumps and calls work.
2008-01-10 01:20:36 +00:00
Machine::FixedAllocation : Machine::MovableAllocation,
simplify memory allocation interfaces
2008-04-13 18:15:04 +00:00
sizeInBytes, objectMask);
refactor memory management code We now support immortal objects, which the GC will scan for references but not consider for collection. On x86_64, we allocate JIT code memory via mmap, which lets us map memory into the bottom 2GB of the address space, ensuring that 32-bit relative jumps and calls work.
2008-01-10 01:20:36 +00:00
}
object
allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type,
simplify memory allocation interfaces
2008-04-13 18:15:04 +00:00
unsigned sizeInBytes, bool objectMask)
implement fixed object support
2007-10-28 01:54:30 +00:00
{
assert that there are no outstanding Get*Critical requests during allocation When GetStringCritical or GetPrimitiveArrayCritical are called, the VM cannot risk new Java heap allocations until the corresponding release method is called because allocations may result in GC, which cannot happen while a string or array is pinned in memory. We already have a check for this latter in the footprint function used during GC, but it's best to catch the problem as early as possible.
2013-02-05 16:48:20 +00:00
expect(t, t->criticalLevel == 0);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
if (UNLIKELY(t->flags & Thread::UseBackupHeapFlag)) {
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
expect(t, t->backupHeapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
pre-allocate Thread::backupHeap for signal safety It's not safe to use malloc from a signal handler, so we can't allocate new memory when handling segfaults or Thread.getStackTrace signals. Instead, we allocate a fixed-size backup heap for each thread ahead of time and use it if there's no space left in the normal heap pool. In the rare case that the backup heap isn't large enough, we fall back to using a preallocated exception without a stack trace as a last resort.
2010-06-19 22:40:21 +00:00
<= ThreadBackupHeapSizeInWords);
more progress on general stack tracing
2008-04-09 19:08:13 +00:00
object o = reinterpret_cast<object>(t->backupHeap + t->backupHeapIndex);
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
t->backupHeapIndex += ceilingDivide(sizeInBytes, BytesPerWord);
rename cast -> fieldAtOffset
2013-02-11 00:38:51 +00:00
fieldAtOffset<object>(o, 0) = 0;
more progress on general stack tracing
2008-04-09 19:08:13 +00:00
return o;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
} else if (UNLIKELY(t->flags & Thread::TracingFlag)) {
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
expect(t, t->heapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
increase heap pool size and fixed footprint threshold constants based on performance profiling and experimentation
2008-11-22 21:47:18 +00:00
<= ThreadHeapSizeInWords);
various bugfixes concerning Thread.getStackTrace
2008-04-21 22:36:13 +00:00
return allocateSmall(t, sizeInBytes);
more progress on general stack tracing
2008-04-09 19:08:13 +00:00
}
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
ACQUIRE_RAW(t, t->m->stateLock);
more refactoring
2007-07-06 23:50:26 +00:00
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
while (t->m->exclusive and t->m->exclusive != t) {
more refactoring
2007-07-06 23:50:26 +00:00
// another thread wants to enter the exclusive state, either for a
// collection or some other reason. We give it a chance here.
progress on thread support
2007-07-07 18:09:16 +00:00
ENTER(t, Thread::IdleState);
fix deadlock in allocate3 when another thread wants to enter the exclusive state
2009-07-16 17:51:35 +00:00
while (t->m->exclusive) {
t->m->stateLock->wait(t->systemThread, 0);
}
more refactoring
2007-07-06 23:50:26 +00:00
}
never trigger a GC due to an immortal allocation
2008-11-23 18:48:39 +00:00
fix thread heap overflow corner case in allocate3 The previous code relied on the invalid assumption that the thread-local heaps for all threads would have been cleared immediately following a garbage collection. However, the last thing the garbage collection function does is run finalizers which may allocate new objects. This can lead allocate3 to call allocateSmall with a size which is too large to accomodate, overflowing the heap. The solution is to iterate until there really is enough room for the original allocation request.
2009-07-18 01:37:46 +00:00
do {
switch (type) {
case Machine::MovableAllocation:
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
if (t->heapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
fix thread heap overflow corner case in allocate3 The previous code relied on the invalid assumption that the thread-local heaps for all threads would have been cleared immediately following a garbage collection. However, the last thing the garbage collection function does is run finalizers which may allocate new objects. This can lead allocate3 to call allocateSmall with a size which is too large to accomodate, overflowing the heap. The solution is to iterate until there really is enough room for the original allocation request.
2009-07-18 01:37:46 +00:00
> ThreadHeapSizeInWords)
{
t->heap = 0;
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
if ((not t->m->heap->limitExceeded())
and t->m->heapPoolIndex < ThreadHeapPoolSize)
{
fix thread heap overflow corner case in allocate3 The previous code relied on the invalid assumption that the thread-local heaps for all threads would have been cleared immediately following a garbage collection. However, the last thing the garbage collection function does is run finalizers which may allocate new objects. This can lead allocate3 to call allocateSmall with a size which is too large to accomodate, overflowing the heap. The solution is to iterate until there really is enough room for the original allocation request.
2009-07-18 01:37:46 +00:00
t->heap = static_cast<uintptr_t*>
(t->m->heap->tryAllocate(ThreadHeapSizeInBytes));
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
fix thread heap overflow corner case in allocate3 The previous code relied on the invalid assumption that the thread-local heaps for all threads would have been cleared immediately following a garbage collection. However, the last thing the garbage collection function does is run finalizers which may allocate new objects. This can lead allocate3 to call allocateSmall with a size which is too large to accomodate, overflowing the heap. The solution is to iterate until there really is enough room for the original allocation request.
2009-07-18 01:37:46 +00:00
if (t->heap) {
memset(t->heap, 0, ThreadHeapSizeInBytes);
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
fix thread heap overflow corner case in allocate3 The previous code relied on the invalid assumption that the thread-local heaps for all threads would have been cleared immediately following a garbage collection. However, the last thing the garbage collection function does is run finalizers which may allocate new objects. This can lead allocate3 to call allocateSmall with a size which is too large to accomodate, overflowing the heap. The solution is to iterate until there really is enough room for the original allocation request.
2009-07-18 01:37:46 +00:00
t->m->heapPool[t->m->heapPoolIndex++] = t->heap;
t->heapOffset += t->heapIndex;
t->heapIndex = 0;
}
never trigger a GC due to an immortal allocation
2008-11-23 18:48:39 +00:00
}
add Machine::heapPool, allowing threads to acquire replacement heaps up to a point before forcing a GC
2007-08-22 14:50:29 +00:00
}
fix thread heap overflow corner case in allocate3 The previous code relied on the invalid assumption that the thread-local heaps for all threads would have been cleared immediately following a garbage collection. However, the last thing the garbage collection function does is run finalizers which may allocate new objects. This can lead allocate3 to call allocateSmall with a size which is too large to accomodate, overflowing the heap. The solution is to iterate until there really is enough room for the original allocation request.
2009-07-18 01:37:46 +00:00
break;
more refactoring
2007-07-06 23:50:26 +00:00
fix thread heap overflow corner case in allocate3 The previous code relied on the invalid assumption that the thread-local heaps for all threads would have been cleared immediately following a garbage collection. However, the last thing the garbage collection function does is run finalizers which may allocate new objects. This can lead allocate3 to call allocateSmall with a size which is too large to accomodate, overflowing the heap. The solution is to iterate until there really is enough room for the original allocation request.
2009-07-18 01:37:46 +00:00
case Machine::FixedAllocation:
if (t->m->fixedFootprint + sizeInBytes > FixedFootprintThresholdInBytes)
{
t->heap = 0;
}
break;
never trigger a GC due to an immortal allocation
2008-11-23 18:48:39 +00:00
fix thread heap overflow corner case in allocate3 The previous code relied on the invalid assumption that the thread-local heaps for all threads would have been cleared immediately following a garbage collection. However, the last thing the garbage collection function does is run finalizers which may allocate new objects. This can lead allocate3 to call allocateSmall with a size which is too large to accomodate, overflowing the heap. The solution is to iterate until there really is enough room for the original allocation request.
2009-07-18 01:37:46 +00:00
case Machine::ImmortalAllocation:
break;
}
add Machine::heapPool, allowing threads to acquire replacement heaps up to a point before forcing a GC
2007-08-22 14:50:29 +00:00
force a GC in allocate3 if the heap limit has been exceeded Otherwise, we'll throw an OOME even though there may be enough unreachable objects eligible for collection to get back below the limit.
2013-02-03 22:20:53 +00:00
if (t->heap == 0 or t->m->heap->limitExceeded()) {
fix thread heap overflow corner case in allocate3 The previous code relied on the invalid assumption that the thread-local heaps for all threads would have been cleared immediately following a garbage collection. However, the last thing the garbage collection function does is run finalizers which may allocate new objects. This can lead allocate3 to call allocateSmall with a size which is too large to accomodate, overflowing the heap. The solution is to iterate until there really is enough room for the original allocation request.
2009-07-18 01:37:46 +00:00
// fprintf(stderr, "gc");
// vmPrintTrace(t);
collect(t, Heap::MinorCollection);
}
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
if (t->m->heap->limitExceeded()) {
throw_(t, root(t, Machine::OutOfMemoryError));
}
fix thread heap overflow corner case in allocate3 The previous code relied on the invalid assumption that the thread-local heaps for all threads would have been cleared immediately following a garbage collection. However, the last thing the garbage collection function does is run finalizers which may allocate new objects. This can lead allocate3 to call allocateSmall with a size which is too large to accomodate, overflowing the heap. The solution is to iterate until there really is enough room for the original allocation request.
2009-07-18 01:37:46 +00:00
} while (type == Machine::MovableAllocation
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
and t->heapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
fix thread heap overflow corner case in allocate3 The previous code relied on the invalid assumption that the thread-local heaps for all threads would have been cleared immediately following a garbage collection. However, the last thing the garbage collection function does is run finalizers which may allocate new objects. This can lead allocate3 to call allocateSmall with a size which is too large to accomodate, overflowing the heap. The solution is to iterate until there really is enough room for the original allocation request.
2009-07-18 01:37:46 +00:00
> ThreadHeapSizeInWords);
fail quickly if an object allocation cannot be satisfied Previously, we would blithely exceed the heap ceiling and force the next allocation to deal with the problem, including a major GC and possible OutOfMemoryError. As of this commit, we throw an error immediately if we find that the allocation will push us over the ceiling.
2013-02-03 22:53:36 +00:00
refactor memory management code We now support immortal objects, which the GC will scan for references but not consider for collection. On x86_64, we allocate JIT code memory via mmap, which lets us map memory into the bottom 2GB of the address space, ensuring that 32-bit relative jumps and calls work.
2008-01-10 01:20:36 +00:00
switch (type) {
case Machine::MovableAllocation: {
return allocateSmall(t, sizeInBytes);
}
more refactoring
2007-07-06 23:50:26 +00:00
refactor memory management code We now support immortal objects, which the GC will scan for references but not consider for collection. On x86_64, we allocate JIT code memory via mmap, which lets us map memory into the bottom 2GB of the address space, ensuring that 32-bit relative jumps and calls work.
2008-01-10 01:20:36 +00:00
case Machine::FixedAllocation: {
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
unsigned total;
object o = static_cast<object>
fail quickly if an object allocation cannot be satisfied Previously, we would blithely exceed the heap ceiling and force the next allocation to deal with the problem, including a major GC and possible OutOfMemoryError. As of this commit, we throw an error immediately if we find that the allocation will push us over the ceiling.
2013-02-03 22:53:36 +00:00
(t->m->heap->tryAllocateFixed
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
(allocator, ceilingDivide(sizeInBytes, BytesPerWord), objectMask, &total));
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
fail quickly if an object allocation cannot be satisfied Previously, we would blithely exceed the heap ceiling and force the next allocation to deal with the problem, including a major GC and possible OutOfMemoryError. As of this commit, we throw an error immediately if we find that the allocation will push us over the ceiling.
2013-02-03 22:53:36 +00:00
if (o) {
memset(o, 0, sizeInBytes);
move fixed object (mark and sweep) support into heap.cpp and refine algorithms for determining when and how much to GC
2007-10-28 19:14:53 +00:00
fail quickly if an object allocation cannot be satisfied Previously, we would blithely exceed the heap ceiling and force the next allocation to deal with the problem, including a major GC and possible OutOfMemoryError. As of this commit, we throw an error immediately if we find that the allocation will push us over the ceiling.
2013-02-03 22:53:36 +00:00
alias(o, 0) = FixedMark;
t->m->fixedFootprint += total;
return o;
} else {
throw_(t, root(t, Machine::OutOfMemoryError));
}
refactor memory management code We now support immortal objects, which the GC will scan for references but not consider for collection. On x86_64, we allocate JIT code memory via mmap, which lets us map memory into the bottom 2GB of the address space, ensuring that 32-bit relative jumps and calls work.
2008-01-10 01:20:36 +00:00
}
case Machine::ImmortalAllocation: {
unsigned total;
object o = static_cast<object>
fail quickly if an object allocation cannot be satisfied Previously, we would blithely exceed the heap ceiling and force the next allocation to deal with the problem, including a major GC and possible OutOfMemoryError. As of this commit, we throw an error immediately if we find that the allocation will push us over the ceiling.
2013-02-03 22:53:36 +00:00
(t->m->heap->tryAllocateImmortalFixed
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
(allocator, ceilingDivide(sizeInBytes, BytesPerWord), objectMask, &total));
refactor memory management code We now support immortal objects, which the GC will scan for references but not consider for collection. On x86_64, we allocate JIT code memory via mmap, which lets us map memory into the bottom 2GB of the address space, ensuring that 32-bit relative jumps and calls work.
2008-01-10 01:20:36 +00:00
fail quickly if an object allocation cannot be satisfied Previously, we would blithely exceed the heap ceiling and force the next allocation to deal with the problem, including a major GC and possible OutOfMemoryError. As of this commit, we throw an error immediately if we find that the allocation will push us over the ceiling.
2013-02-03 22:53:36 +00:00
if (o) {
memset(o, 0, sizeInBytes);
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
fail quickly if an object allocation cannot be satisfied Previously, we would blithely exceed the heap ceiling and force the next allocation to deal with the problem, including a major GC and possible OutOfMemoryError. As of this commit, we throw an error immediately if we find that the allocation will push us over the ceiling.
2013-02-03 22:53:36 +00:00
alias(o, 0) = FixedMark;
refactor memory management code We now support immortal objects, which the GC will scan for references but not consider for collection. On x86_64, we allocate JIT code memory via mmap, which lets us map memory into the bottom 2GB of the address space, ensuring that 32-bit relative jumps and calls work.
2008-01-10 01:20:36 +00:00
fail quickly if an object allocation cannot be satisfied Previously, we would blithely exceed the heap ceiling and force the next allocation to deal with the problem, including a major GC and possible OutOfMemoryError. As of this commit, we throw an error immediately if we find that the allocation will push us over the ceiling.
2013-02-03 22:53:36 +00:00
return o;
} else {
throw_(t, root(t, Machine::OutOfMemoryError));
}
refactor memory management code We now support immortal objects, which the GC will scan for references but not consider for collection. On x86_64, we allocate JIT code memory via mmap, which lets us map memory into the bottom 2GB of the address space, ensuring that 32-bit relative jumps and calls work.
2008-01-10 01:20:36 +00:00
}
default: abort(t);
more refactoring
2007-07-06 23:50:26 +00:00
}
}
implement basic finalization support This implementation does not conform to the Java standard in that finalize methods are called from whichever thread happens to be garbage collecting, and that thread may hold locks, whereas the standard guarantees that finalize will be run from a thread which holds no locks. Also, an object will never be finalized more than once, even if its finalize method "rescues" (i.e. makes reachable) the object such that it might become unreachable a second time and thus a candidate for finalization once more. It's not clear to me from the standard if this is OK or not. Nonwithstanding the above, this implementation is useful for "normal" finalize methods which simply release resources associated with an object.
2009-07-22 00:57:55 +00:00
object
makeNewGeneral(Thread* t, object class_)
{
assert(t, t->state == Thread::ActiveState);
fix GC safety bug in makeNewGeneral
2009-08-10 23:35:44 +00:00
PROTECT(t, class_);
implement basic finalization support This implementation does not conform to the Java standard in that finalize methods are called from whichever thread happens to be garbage collecting, and that thread may hold locks, whereas the standard guarantees that finalize will be run from a thread which holds no locks. Also, an object will never be finalized more than once, even if its finalize method "rescues" (i.e. makes reachable) the object such that it might become unreachable a second time and thus a candidate for finalization once more. It's not clear to me from the standard if this is OK or not. Nonwithstanding the above, this implementation is useful for "normal" finalize methods which simply release resources associated with an object.
2009-07-22 00:57:55 +00:00
object instance = makeNew(t, class_);
PROTECT(t, instance);
if (classVmFlags(t, class_) & WeakReferenceFlag) {
ACQUIRE(t, t->m->referenceLock);
jreferenceVmNext(t, instance) = t->m->weakReferences;
t->m->weakReferences = instance;
}
if (classVmFlags(t, class_) & HasFinalizerFlag) {
run java finalizers in a separate thread to guarantee no application locks are held when doing so
2009-08-24 23:51:31 +00:00
addFinalizer(t, instance, 0);
implement basic finalization support This implementation does not conform to the Java standard in that finalize methods are called from whichever thread happens to be garbage collecting, and that thread may hold locks, whereas the standard guarantees that finalize will be run from a thread which holds no locks. Also, an object will never be finalized more than once, even if its finalize method "rescues" (i.e. makes reachable) the object such that it might become unreachable a second time and thus a candidate for finalization once more. It's not clear to me from the standard if this is OK or not. Nonwithstanding the above, this implementation is useful for "normal" finalize methods which simply release resources associated with an object.
2009-07-22 00:57:55 +00:00
}
return instance;
}
fix continuations=true build
2011-01-27 18:54:41 +00:00
void
popResources(Thread* t)
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
{
fix continuations=true build
2011-01-27 18:54:41 +00:00
while (t->resource != t->checkpoint->resource) {
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
Thread::Resource* r = t->resource;
t->resource = r->next;
r->release();
}
fix continuations=true build
2011-01-27 18:54:41 +00:00
t->protector = t->checkpoint->protector;
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
}
object
fix recent throwNew/makeThrowable regression 6fceca9 introduced a string formatting regression in these methods, which this commit fixes.
2012-03-04 01:37:27 +00:00
makeByteArrayV(Thread* t, const char* format, va_list a, int size)
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
{
fix makeByteArray and makeString for strings longer than 256 characters
2012-02-29 18:49:13 +00:00
THREAD_RUNTIME_ARRAY(t, char, buffer, size);
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
fix makeByteArray and makeString for strings longer than 256 characters
2012-02-29 18:49:13 +00:00
int r = vm::vsnprintf(RUNTIME_ARRAY_BODY(buffer), size - 1, format, a);
if (r >= 0 and r < size - 1) {
object s = makeByteArray(t, strlen(RUNTIME_ARRAY_BODY(buffer)) + 1);
memcpy(&byteArrayBody(t, s, 0), RUNTIME_ARRAY_BODY(buffer),
byteArrayLength(t, s));
return s;
} else {
return 0;
handle strings of arbitrary size in makeByteArray
2011-07-10 00:00:19 +00:00
}
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
}
more refactoring
2007-07-06 23:50:26 +00:00
object
makeByteArray(Thread* t, const char* format, ...)
{
fix makeByteArray and makeString for strings longer than 256 characters
2012-02-29 18:49:13 +00:00
int size = 256;
while (true) {
va_list a;
va_start(a, format);
fix recent throwNew/makeThrowable regression 6fceca9 introduced a string formatting regression in these methods, which this commit fixes.
2012-03-04 01:37:27 +00:00
object s = makeByteArrayV(t, format, a, size);
fix makeByteArray and makeString for strings longer than 256 characters
2012-02-29 18:49:13 +00:00
va_end(a);
more refactoring
2007-07-06 23:50:26 +00:00
fix makeByteArray and makeString for strings longer than 256 characters
2012-02-29 18:49:13 +00:00
if (s) {
return s;
} else {
size *= 2;
}
}
more refactoring
2007-07-06 23:50:26 +00:00
}
object
makeString(Thread* t, const char* format, ...)
{
fix makeByteArray and makeString for strings longer than 256 characters
2012-02-29 18:49:13 +00:00
int size = 256;
while (true) {
va_list a;
va_start(a, format);
fix recent throwNew/makeThrowable regression 6fceca9 introduced a string formatting regression in these methods, which this commit fixes.
2012-03-04 01:37:27 +00:00
object s = makeByteArrayV(t, format, a, size);
fix makeByteArray and makeString for strings longer than 256 characters
2012-02-29 18:49:13 +00:00
va_end(a);
more refactoring
2007-07-06 23:50:26 +00:00
fix makeByteArray and makeString for strings longer than 256 characters
2012-02-29 18:49:13 +00:00
if (s) {
return t->m->classpath->makeString(t, s, 0, byteArrayLength(t, s) - 1);
} else {
size *= 2;
}
}
more refactoring
2007-07-06 23:50:26 +00:00
}
Improved (should now be complete) Unicode support (UTF-8 for *nix and UTF-16 for Windows).
2010-04-20 16:03:07 +00:00
int
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
stringUTFLength(Thread* t, object string, unsigned start, unsigned length)
{
unsigned result = 0;
Improved (should now be complete) Unicode support (UTF-8 for *nix and UTF-16 for Windows).
2010-04-20 16:03:07 +00:00
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
if (length) {
Improved (should now be complete) Unicode support (UTF-8 for *nix and UTF-16 for Windows).
2010-04-20 16:03:07 +00:00
object data = stringData(t, string);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
if (objectClass(t, data) == type(t, Machine::ByteArrayType)) {
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
result = length;
Improved (should now be complete) Unicode support (UTF-8 for *nix and UTF-16 for Windows).
2010-04-20 16:03:07 +00:00
} else {
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
for (unsigned i = 0; i < length; ++i) {
uint16_t c = charArrayBody
(t, data, stringOffset(t, string) + start + i);
if (c == 0) result += 1; // null char (was 2 bytes in Java)
else if (c < 0x80) result += 1; // ASCII char
else if (c < 0x800) result += 2; // two-byte char
else result += 3; // three-byte char
Improved (should now be complete) Unicode support (UTF-8 for *nix and UTF-16 for Windows).
2010-04-20 16:03:07 +00:00
}
}
}
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
return result;
Improved (should now be complete) Unicode support (UTF-8 for *nix and UTF-16 for Windows).
2010-04-20 16:03:07 +00:00
}
snapshot; known bug: finalizers and weak references don't work correctly wrt tenured objects
2007-07-08 01:06:32 +00:00
void
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
stringChars(Thread* t, object string, unsigned start, unsigned length,
char* chars)
snapshot; known bug: finalizers and weak references don't work correctly wrt tenured objects
2007-07-08 01:06:32 +00:00
{
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
if (length) {
treat SoftReferences as WeakReferences; do vtable or interface table lookups as necessary in MyProcessor::invoke; various bugfixes
2009-08-13 15:17:05 +00:00
object data = stringData(t, string);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
if (objectClass(t, data) == type(t, Machine::ByteArrayType)) {
treat SoftReferences as WeakReferences; do vtable or interface table lookups as necessary in MyProcessor::invoke; various bugfixes
2009-08-13 15:17:05 +00:00
memcpy(chars,
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
&byteArrayBody(t, data, stringOffset(t, string) + start),
length);
treat SoftReferences as WeakReferences; do vtable or interface table lookups as necessary in MyProcessor::invoke; various bugfixes
2009-08-13 15:17:05 +00:00
} else {
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
for (unsigned i = 0; i < length; ++i) {
chars[i] = charArrayBody(t, data, stringOffset(t, string) + start + i);
treat SoftReferences as WeakReferences; do vtable or interface table lookups as necessary in MyProcessor::invoke; various bugfixes
2009-08-13 15:17:05 +00:00
}
snapshot; known bug: finalizers and weak references don't work correctly wrt tenured objects
2007-07-08 01:06:32 +00:00
}
}
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
chars[length] = 0;
snapshot; known bug: finalizers and weak references don't work correctly wrt tenured objects
2007-07-08 01:06:32 +00:00
}
implement GetStringLength, GetStringChars, and ReleaseStringChars
2008-04-01 23:24:43 +00:00
void
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
stringChars(Thread* t, object string, unsigned start, unsigned length,
uint16_t* chars)
implement GetStringLength, GetStringChars, and ReleaseStringChars
2008-04-01 23:24:43 +00:00
{
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
if (length) {
treat SoftReferences as WeakReferences; do vtable or interface table lookups as necessary in MyProcessor::invoke; various bugfixes
2009-08-13 15:17:05 +00:00
object data = stringData(t, string);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
if (objectClass(t, data) == type(t, Machine::ByteArrayType)) {
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
for (unsigned i = 0; i < length; ++i) {
chars[i] = byteArrayBody(t, data, stringOffset(t, string) + start + i);
treat SoftReferences as WeakReferences; do vtable or interface table lookups as necessary in MyProcessor::invoke; various bugfixes
2009-08-13 15:17:05 +00:00
}
} else {
memcpy(chars,
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
&charArrayBody(t, data, stringOffset(t, string) + start),
length * sizeof(uint16_t));
implement GetStringLength, GetStringChars, and ReleaseStringChars
2008-04-01 23:24:43 +00:00
}
}
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
chars[length] = 0;
implement GetStringLength, GetStringChars, and ReleaseStringChars
2008-04-01 23:24:43 +00:00
}
Improved (should now be complete) Unicode support (UTF-8 for *nix and UTF-16 for Windows).
2010-04-20 16:03:07 +00:00
void
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
stringUTFChars(Thread* t, object string, unsigned start, unsigned length,
char* chars, unsigned charsLength UNUSED)
Improved (should now be complete) Unicode support (UTF-8 for *nix and UTF-16 for Windows).
2010-04-20 16:03:07 +00:00
{
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
assert(t, static_cast<unsigned>
(stringUTFLength(t, string, start, length)) == charsLength);
Improved (should now be complete) Unicode support (UTF-8 for *nix and UTF-16 for Windows).
2010-04-20 16:03:07 +00:00
terminate zero-length char array with null char in stringUTFChars
2012-08-04 18:36:18 +00:00
object data = stringData(t, string);
if (objectClass(t, data) == type(t, Machine::ByteArrayType)) {
memcpy(chars,
&byteArrayBody(t, data, stringOffset(t, string) + start),
length);
chars[length] = 0;
} else {
int j = 0;
for (unsigned i = 0; i < length; ++i) {
uint16_t c = charArrayBody
(t, data, stringOffset(t, string) + start + i);
if(!c) { // null char
chars[j++] = 0;
} else if (c < 0x80) { // ASCII char
chars[j++] = static_cast<char>(c);
} else if (c < 0x800) { // two-byte char
chars[j++] = static_cast<char>(0x0c0 | (c >> 6));
chars[j++] = static_cast<char>(0x080 | (c & 0x03f));
} else { // three-byte char
chars[j++] = static_cast<char>(0x0e0 | ((c >> 12) & 0x0f));
chars[j++] = static_cast<char>(0x080 | ((c >> 6) & 0x03f));
chars[j++] = static_cast<char>(0x080 | (c & 0x03f));
Improved (should now be complete) Unicode support (UTF-8 for *nix and UTF-16 for Windows).
2010-04-20 16:03:07 +00:00
}
terminate zero-length char array with null char in stringUTFChars
2012-08-04 18:36:18 +00:00
}
chars[j] = 0;
}
Improved (should now be complete) Unicode support (UTF-8 for *nix and UTF-16 for Windows).
2010-04-20 16:03:07 +00:00
}
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
uint64_t
resolveBootstrap(Thread* t, uintptr_t* arguments)
{
object name = reinterpret_cast<object>(arguments[0]);
resolveSystemClass(t, root(t, Machine::BootLoader), name);
return 1;
}
start work on reflection; bugfixes
2007-07-24 01:44:20 +00:00
bool
isAssignableFrom(Thread* t, object a, object b)
{
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
assert(t, a);
assert(t, b);
snapshot
2007-11-05 14:28:46 +00:00
if (a == b) return true;
if (classFlags(t, a) & ACC_INTERFACE) {
snapshot
2007-11-04 23:10:33 +00:00
if (classVmFlags(t, b) & BootstrapFlag) {
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(className(t, b)) };
if (run(t, resolveBootstrap, arguments) == 0) {
if we can't resolve a bootstrap class in isAssignableFrom(), we swallow the exception and return false
2007-11-05 16:08:08 +00:00
t->exception = 0;
return false;
}
snapshot
2007-11-04 23:10:33 +00:00
}
heap o' bugfixes
2007-08-20 02:57:32 +00:00
fix handling of interfaces in isAssignableFrom The old version was both incorrect (in the case where both arguments are interfaces) and inefficient.
2011-04-10 03:09:59 +00:00
object itable = classInterfaceTable(t, b);
if (itable) {
unsigned stride = (classFlags(t, b) & ACC_INTERFACE) ? 1 : 2;
for (unsigned i = 0; i < arrayLength(t, itable); i += stride) {
if (arrayBody(t, itable, i) == a) {
return true;
start work on reflection; bugfixes
2007-07-24 01:44:20 +00:00
}
}
}
heap o' bugfixes
2007-08-20 02:57:32 +00:00
} else if (classArrayDimensions(t, a)) {
if (classArrayDimensions(t, b)) {
return isAssignableFrom
(t, classStaticTable(t, a), classStaticTable(t, b));
}
fix bug in isAssignableFrom such that primitive array types were considered to be subclasses of the Object array type
2012-02-28 01:16:01 +00:00
} else if ((classVmFlags(t, a) & PrimitiveFlag)
== (classVmFlags(t, b) & PrimitiveFlag))
{
start work on reflection; bugfixes
2007-07-24 01:44:20 +00:00
for (; b; b = classSuper(t, b)) {
if (b == a) {
return true;
}
}
}
return false;
}
snapshot
2008-07-05 20:21:13 +00:00
bool
start work on reflection; bugfixes
2007-07-24 01:44:20 +00:00
instanceOf(Thread* t, object class_, object o)
{
if (o == 0) {
return false;
working reflection
2007-07-24 03:16:59 +00:00
} else {
return isAssignableFrom(t, class_, objectClass(t, o));
start work on reflection; bugfixes
2007-07-24 01:44:20 +00:00
}
}
misc. bugfixes and tweaks
2007-07-28 16:10:13 +00:00
object
classInitializer(Thread* t, object class_)
{
handle case of class with no methods in classInitializer
2011-07-18 01:51:48 +00:00
if (classMethodTable(t, class_)) {
for (unsigned i = 0; i < arrayLength(t, classMethodTable(t, class_)); ++i)
misc. bugfixes and tweaks
2007-07-28 16:10:13 +00:00
{
handle case of class with no methods in classInitializer
2011-07-18 01:51:48 +00:00
object o = arrayBody(t, classMethodTable(t, class_), i);
support multiple sequential VM instances with bootimage build Until now, the bootimage build hasn't supported using the Java invocation API to create a VM, destroy it, and create another in the same process. Ideally, we would be able to create multiple VMs simultaneously without any interference between them. In fact, Avian is designed to support this for the most part, but there are a few places we use global, mutable state which prevent this from working. Most notably, the bootimage is modified in-place at runtime, so the best we can do without extensive changes is to clean up the bootimage when the VM is destroyed so it's ready for later instances. Hence this commit. Ultimately, we can move towards a fully reentrant VM by making the bootimage immutable, but this will require some care to avoid performance regressions. Another challenge is our Posix signal handlers, which currently rely on a global handle to the VM, since you can't, to my knowledge, pass a context pointer when registering a signal handler. Thread local variables won't necessarily help, since a thread might attatch to more than one VM at a time.
2011-11-10 20:10:53 +00:00
if (methodVmFlags(t, o) & ClassInitFlag) {
handle case of class with no methods in classInitializer
2011-07-18 01:51:48 +00:00
return o;
}
}
misc. bugfixes and tweaks
2007-07-28 16:10:13 +00:00
}
call static initializer of superclass before that of class itself Also, assume any class which has an ancestor class which has a static initializer needs initialization even if it doesn't have one itself, per the Java Language Spec.
2011-04-01 01:43:49 +00:00
return 0;
misc. bugfixes and tweaks
2007-07-28 16:10:13 +00:00
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
unsigned
fieldCode(Thread* t, unsigned javaCode)
more refactoring
2007-07-06 23:50:26 +00:00
{
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
switch (javaCode) {
case 'B':
return ByteField;
case 'C':
return CharField;
case 'D':
return DoubleField;
case 'F':
return FloatField;
case 'I':
return IntField;
case 'J':
return LongField;
case 'S':
return ShortField;
case 'V':
return VoidField;
case 'Z':
return BooleanField;
case 'L':
case '[':
return ObjectField;
more refactoring
2007-07-06 23:50:26 +00:00
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
default: abort(t);
}
}
more refactoring
2007-07-06 23:50:26 +00:00
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
unsigned
fieldType(Thread* t, unsigned code)
{
switch (code) {
case VoidField:
return VOID_TYPE;
case ByteField:
case BooleanField:
return INT8_TYPE;
case CharField:
case ShortField:
return INT16_TYPE;
case DoubleField:
return DOUBLE_TYPE;
case FloatField:
return FLOAT_TYPE;
case IntField:
return INT32_TYPE;
case LongField:
return INT64_TYPE;
case ObjectField:
return POINTER_TYPE;
default: abort(t);
}
more refactoring
2007-07-06 23:50:26 +00:00
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
unsigned
primitiveSize(Thread* t, unsigned code)
more bugfixes, mainly monitor-related
2007-07-11 04:19:26 +00:00
{
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
switch (code) {
case VoidField:
return 0;
case ByteField:
case BooleanField:
return 1;
case CharField:
case ShortField:
return 2;
case FloatField:
case IntField:
return 4;
case DoubleField:
case LongField:
return 8;
more bugfixes, mainly monitor-related
2007-07-11 04:19:26 +00:00
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
default: abort(t);
}
}
more bugfixes, mainly monitor-related
2007-07-11 04:19:26 +00:00
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
object
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
parseClass(Thread* t, object loader, const uint8_t* data, unsigned size,
Machine::Type throwType)
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
{
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
PROTECT(t, loader);
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
class Client: public Stream::Client {
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
public:
Client(Thread* t): t(t) { }
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
virtual void NO_RETURN handleError() {
factor out assert / abort / expect implementations
2013-02-12 01:51:39 +00:00
abort(t);
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
}
private:
Thread* t;
} client(t);
Stream s(&client, data, size);
uint32_t magic = s.read4();
various performance tweaks and bugfixes
2007-08-19 19:45:51 +00:00
expect(t, magic == 0xCAFEBABE);
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
unsigned minorVer = s.read2(); // minor version
unsigned majorVer = s.read2(); // major version
if(DebugClassReader) {
fprintf(stderr, "read class (minor %d major %d)\n", minorVer, majorVer);
}
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
object pool = parsePool(t, s);
PROTECT(t, pool);
unsigned flags = s.read2();
unsigned name = s.read2();
object class_ = makeClass(t,
flags,
0, // VM flags
0, // fixed size
0, // array size
implement ClassLoader.resolveClass and ensure class is linked in e.g. Class.getMethods; minor bugfixes
2009-08-18 20:26:28 +00:00
0, // array dimensions
fix openjdk-src bootimage build The main change here is to use a lazily-populated vector to associate runtime data with classes instead of referencing them directly from the class which requires updating immutable references in the heap image. The other changes employ other strategies to avoid trying to update immutable references.
2010-11-26 19:41:31 +00:00
0, // runtime data index
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
0, // object mask
implement ClassLoader.resolveClass and ensure class is linked in e.g. Class.getMethods; minor bugfixes
2009-08-18 20:26:28 +00:00
referenceName
(t, singletonObject(t, pool, name - 1)),
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
0, // source file
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
0, // super
0, // interfaces
0, // vtable
0, // fields
0, // methods
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
0, // addendum
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
0, // static table
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
loader,
specify valid code source for system classes This enables use of a class's protection domain to determine what JAR or directory it came from.
2011-04-01 01:16:57 +00:00
0, // source
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
0);// vtable length
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
PROTECT(t, class_);
unsigned super = s.read2();
if (super) {
implement ClassLoader.resolveClass and ensure class is linked in e.g. Class.getMethods; minor bugfixes
2009-08-18 20:26:28 +00:00
object sc = resolveClass
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
(t, loader, referenceName(t, singletonObject(t, pool, super - 1)),
true, throwType);
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
revise signatures of mark() and set() to take a target object and offset instead of a target object reference, paving the way for immovable objects
2007-10-22 17:22:30 +00:00
set(t, class_, ClassSuper, sc);
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
classVmFlags(t, class_)
implement basic finalization support This implementation does not conform to the Java standard in that finalize methods are called from whichever thread happens to be garbage collecting, and that thread may hold locks, whereas the standard guarantees that finalize will be run from a thread which holds no locks. Also, an object will never be finalized more than once, even if its finalize method "rescues" (i.e. makes reachable) the object such that it might become unreachable a second time and thus a candidate for finalization once more. It's not clear to me from the standard if this is OK or not. Nonwithstanding the above, this implementation is useful for "normal" finalize methods which simply release resources associated with an object.
2009-07-22 00:57:55 +00:00
|= (classVmFlags(t, sc)
call static initializer of superclass before that of class itself Also, assume any class which has an ancestor class which has a static initializer needs initialization even if it doesn't have one itself, per the Java Language Spec.
2011-04-01 01:43:49 +00:00
& (ReferenceFlag | WeakReferenceFlag | HasFinalizerFlag
| NeedInitFlag));
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
}
add simple disassembler for debugging
2012-05-22 19:53:32 +00:00
if(DebugClassReader) {
fprintf(stderr, " flags %d name %d super %d\n", flags, name, super);
}
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
parseInterfaceTable(t, s, class_, pool, throwType);
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
parseFieldTable(t, s, class_, pool);
parseMethodTable(t, s, class_, pool);
implement StackTraceElement.getFileName properly
2009-08-27 22:26:25 +00:00
parseAttributeTable(t, s, class_, pool);
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
object vtable = classVirtualTable(t, class_);
unsigned vtableLength = (vtable ? arrayLength(t, vtable) : 0);
object real = t->m->processor->makeClass
(t,
classFlags(t, class_),
classVmFlags(t, class_),
classFixedSize(t, class_),
classArrayElementSize(t, class_),
implement ClassLoader.resolveClass and ensure class is linked in e.g. Class.getMethods; minor bugfixes
2009-08-18 20:26:28 +00:00
classArrayDimensions(t, class_),
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
classObjectMask(t, class_),
className(t, class_),
implement StackTraceElement.getFileName properly
2009-08-27 22:26:25 +00:00
classSourceFile(t, class_),
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
classSuper(t, class_),
classInterfaceTable(t, class_),
classVirtualTable(t, class_),
classFieldTable(t, class_),
classMethodTable(t, class_),
support runtime-visible annotations and java.lang.reflect.Proxy
2009-09-19 00:01:54 +00:00
classAddendum(t, class_),
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
classStaticTable(t, class_),
classLoader(t, class_),
vtableLength);
more progress on GNU Classpath compatibility
2009-06-04 23:21:42 +00:00
PROTECT(t, real);
2+2 test now works with new JIT code
2007-12-11 21:26:59 +00:00
t->m->processor->initVtable(t, real);
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
updateClassTables(t, real, class_);
progress towards cross-architecture bootimage builds This monster commit is the first step towards supporting cross-architecture bootimage builds. The challenge is to build a heap and code image for the target platform where the word size and endianess may differ from those of the build architecture. That means the memory layout of objects may differ due to alignment and size differences, so we can't just copy objects into the heap image unchanged; we must copy field by field, resizing values, reversing endianess and shifting offsets as necessary. This commit also removes POD (plain old data) type support from the type generator because it added a lot of complication and little value.
2011-08-30 01:00:17 +00:00
if (root(t, Machine::PoolMap)) {
object bootstrapClass = hashMapFind
(t, root(t, Machine::BootstrapClassMap), className(t, class_),
byteArrayHash, byteArrayEqual);
hashMapInsert
(t, root(t, Machine::PoolMap), bootstrapClass ? bootstrapClass : real,
pool, objectHash);
}
finish support for inline vtables in class objects; convert constant pools from arrays to singletons to reduce memory footprint
2007-11-05 21:40:17 +00:00
return real;
flesh out ClassLoader, etc.
2007-07-30 23:19:05 +00:00
}
don't throw an exception from resolveClass when throw_ == false resolveClass was correctly respecting throw_ == false if the requested class was not found, but it still threw an exception if e.g. the superclass was missing. Now we catch such exceptions and return null as appropriate.
2012-08-30 00:34:51 +00:00
uint64_t
runParseClass(Thread* t, uintptr_t* arguments)
{
object loader = reinterpret_cast<object>(arguments[0]);
System::Region* region = reinterpret_cast<System::Region*>(arguments[1]);
Machine::Type throwType = static_cast<Machine::Type>(arguments[2]);
return reinterpret_cast<uintptr_t>
(parseClass(t, loader, region->start(), region->length(), throwType));
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
object
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
resolveSystemClass(Thread* t, object loader, object spec, bool throw_,
Machine::Type throwType)
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
{
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
PROTECT(t, loader);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
PROTECT(t, spec);
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
ACQUIRE(t, t->m->classLock);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
lots of bugfixes and refactoring
2008-12-02 02:38:00 +00:00
object class_ = hashMapFind
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
(t, classLoaderMap(t, loader), spec, byteArrayHash, byteArrayEqual);
lots of bugfixes and refactoring
2008-12-02 02:38:00 +00:00
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
if (class_ == 0) {
specify valid code source for system classes This enables use of a class's protection domain to determine what JAR or directory it came from.
2011-04-01 01:16:57 +00:00
PROTECT(t, class_);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
if (classLoaderParent(t, loader)) {
class_ = resolveSystemClass
(t, classLoaderParent(t, loader), spec, false);
if (class_) {
return class_;
}
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
if (byteArrayBody(t, spec, 0) == '[') {
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
class_ = resolveArrayClass(t, loader, spec, throw_, throwType);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
} else {
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
THREAD_RUNTIME_ARRAY(t, char, file, byteArrayLength(t, spec) + 6);
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
memcpy(RUNTIME_ARRAY_BODY(file),
&byteArrayBody(t, spec, 0),
byteArrayLength(t, spec) - 1);
memcpy(RUNTIME_ARRAY_BODY(file) + byteArrayLength(t, spec) - 1,
".class",
7);
flesh out resource URL scheme implementation
2007-08-10 23:45:47 +00:00
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
System::Region* region = static_cast<Finder*>
(systemClassLoaderFinder(t, loader))->find
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
(RUNTIME_ARRAY_BODY(file));
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
sketch of JAR support in Finder
2007-09-17 00:13:36 +00:00
if (region) {
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
if (Verbose) {
bugfixes; add NullPointerException.java
2007-07-24 03:31:28 +00:00
fprintf(stderr, "parsing %s\n", &byteArrayBody(t, spec, 0));
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
{ THREAD_RESOURCE(t, System::Region*, region, region->dispose());
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
don't throw an exception from resolveClass when throw_ == false resolveClass was correctly respecting throw_ == false if the requested class was not found, but it still threw an exception if e.g. the superclass was missing. Now we catch such exceptions and return null as appropriate.
2012-08-30 00:34:51 +00:00
uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(loader),
reinterpret_cast<uintptr_t>(region),
static_cast<uintptr_t>(throwType) };
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
// parse class file
don't throw an exception from resolveClass when throw_ == false resolveClass was correctly respecting throw_ == false if the requested class was not found, but it still threw an exception if e.g. the superclass was missing. Now we catch such exceptions and return null as appropriate.
2012-08-30 00:34:51 +00:00
class_ = reinterpret_cast<object>
(runRaw(t, runParseClass, arguments));
if (UNLIKELY(t->exception)) {
if (throw_) {
object e = t->exception;
t->exception = 0;
vm::throw_(t, e);
} else {
t->exception = 0;
return 0;
}
}
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
}
if (Verbose) {
fprintf(stderr, "done parsing %s: %p\n",
&byteArrayBody(t, spec, 0),
class_);
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
specify valid code source for system classes This enables use of a class's protection domain to determine what JAR or directory it came from.
2011-04-01 01:16:57 +00:00
{ const char* source = static_cast<Finder*>
(systemClassLoaderFinder(t, loader))->sourceUrl
(RUNTIME_ARRAY_BODY(file));
if (source) {
unsigned length = strlen(source);
object array = makeByteArray(t, length + 1);
memcpy(&byteArrayBody(t, array, 0), source, length);
array = internByteArray(t, array);
set(t, class_, ClassSource, array);
}
}
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
object bootstrapClass = hashMapFind
(t, root(t, Machine::BootstrapClassMap), spec, byteArrayHash,
byteArrayEqual);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
if (bootstrapClass) {
PROTECT(t, bootstrapClass);
updateBootstrapClass(t, bootstrapClass, class_);
class_ = bootstrapClass;
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
}
}
if (class_) {
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
hashMapInsert(t, classLoaderMap(t, loader), spec, class_, byteArrayHash);
make JVM_GetSystemPackage a bit smarter The original stub implementation just echoed back its argument, but that confused URLClassLoader when dealing with sealed JARs -- returning a non-null value for a non-system class from JVM_GetSystemPackage made URLClassloader think it had already loaded a class from a package which was supposed to be sealed, resulting in SecurityExceptions which ultimately triggered NoClassDefFoundErrors. The solution is to only return non-null values for actual system classes.
2012-09-24 23:43:34 +00:00
t->m->classpath->updatePackageMap(t, class_);
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
} else if (throw_) {
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
throwNew(t, throwType, "%s", &byteArrayBody(t, spec, 0));
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
}
more bugfixes, mainly monitor-related
2007-07-11 04:19:26 +00:00
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
return class_;
}
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
object
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
findLoadedClass(Thread* t, object loader, object spec)
{
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
PROTECT(t, loader);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
PROTECT(t, spec);
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
ACQUIRE(t, t->m->classLock);
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
return classLoaderMap(t, loader) ? hashMapFind
(t, classLoaderMap(t, loader), spec, byteArrayHash, byteArrayEqual) : 0;
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
}
object
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
resolveClass(Thread* t, object loader, object spec, bool throw_,
Machine::Type throwType)
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
{
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
if (objectClass(t, loader) == type(t, Machine::SystemClassLoaderType)) {
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
return resolveSystemClass(t, loader, spec, throw_, throwType);
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
} else {
fix GC safety bug in resolveClass
2010-11-27 21:44:49 +00:00
PROTECT(t, loader);
PROTECT(t, spec);
add new array classes to classloader map upon creation We were already doing this for non-array classes; we need to do it for all classes or else risk creating duplicates.
2010-12-01 03:27:36 +00:00
object c = findLoadedClass(t, loader, spec);
if (c) {
return c;
fix custom-classloader-related concurrency problems and other bugs The main changes in this commit ensure that we don't hold the global class lock when doing class resolution using application-defined classloaders. Such classloaders may do their own locking (in fact, it's almost certain), making deadlock likely when mixed with VM-level locking in various orders. Other changes include a fix to avoid overflow when waiting for extremely long intervals and a GC root stack mapping bug.
2010-09-17 01:43:27 +00:00
}
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
fix custom-classloader-related concurrency problems and other bugs The main changes in this commit ensure that we don't hold the global class lock when doing class resolution using application-defined classloaders. Such classloaders may do their own locking (in fact, it's almost certain), making deadlock likely when mixed with VM-level locking in various orders. Other changes include a fix to avoid overflow when waiting for extremely long intervals and a GC root stack mapping bug.
2010-09-17 01:43:27 +00:00
if (byteArrayBody(t, spec, 0) == '[') {
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
c = resolveArrayClass(t, loader, spec, throw_, throwType);
fix custom-classloader-related concurrency problems and other bugs The main changes in this commit ensure that we don't hold the global class lock when doing class resolution using application-defined classloaders. Such classloaders may do their own locking (in fact, it's almost certain), making deadlock likely when mixed with VM-level locking in various orders. Other changes include a fix to avoid overflow when waiting for extremely long intervals and a GC root stack mapping bug.
2010-09-17 01:43:27 +00:00
} else {
if (root(t, Machine::LoadClassMethod) == 0) {
object m = resolveMethod
(t, root(t, Machine::BootLoader), "java/lang/ClassLoader",
"loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
if (m) {
setRoot(t, Machine::LoadClassMethod, m);
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
fix custom-classloader-related concurrency problems and other bugs The main changes in this commit ensure that we don't hold the global class lock when doing class resolution using application-defined classloaders. Such classloaders may do their own locking (in fact, it's almost certain), making deadlock likely when mixed with VM-level locking in various orders. Other changes include a fix to avoid overflow when waiting for extremely long intervals and a GC root stack mapping bug.
2010-09-17 01:43:27 +00:00
object classLoaderClass = type(t, Machine::ClassLoaderType);
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
fix custom-classloader-related concurrency problems and other bugs The main changes in this commit ensure that we don't hold the global class lock when doing class resolution using application-defined classloaders. Such classloaders may do their own locking (in fact, it's almost certain), making deadlock likely when mixed with VM-level locking in various orders. Other changes include a fix to avoid overflow when waiting for extremely long intervals and a GC root stack mapping bug.
2010-09-17 01:43:27 +00:00
if (classVmFlags(t, classLoaderClass) & BootstrapFlag) {
resolveSystemClass
(t, root(t, Machine::BootLoader),
vm::className(t, classLoaderClass));
}
}
}
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
object method = findVirtualMethod
(t, root(t, Machine::LoadClassMethod), objectClass(t, loader));
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
PROTECT(t, method);
THREAD_RUNTIME_ARRAY(t, char, s, byteArrayLength(t, spec));
replace('/', '.', RUNTIME_ARRAY_BODY(s), reinterpret_cast<char*>
(&byteArrayBody(t, spec, 0)));
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
object specString = makeString(t, "%s", RUNTIME_ARRAY_BODY(s));
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
PROTECT(t, specString);
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
implement lazy class/field/method resolution in JIT compiler Unlike the interpreter, the JIT compiler tries to resolve all the symbols referenced by a method when compiling that method. However, this can backfire if a symbol cannot be resolved: we end up throwing an e.g. NoClassDefFoundError for code which may never be executed. This is particularly troublesome for code which supports multiple APIs, choosing one at runtime. The solution is to defer to stub code for symbols which can't be resolved at JIT compile time. Such a stub will try again at runtime to resolve the needed symbol and throw an appropriate error if it still can't be found.
2011-03-15 23:52:02 +00:00
uintptr_t arguments[] = { reinterpret_cast<uintptr_t>(method),
reinterpret_cast<uintptr_t>(loader),
reinterpret_cast<uintptr_t>(specString) };
object jc = reinterpret_cast<object>
(runRaw(t, invokeLoadClass, arguments));
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
if (LIKELY(jc)) {
c = jclassVmClass(t, jc);
implement lazy class/field/method resolution in JIT compiler Unlike the interpreter, the JIT compiler tries to resolve all the symbols referenced by a method when compiling that method. However, this can backfire if a symbol cannot be resolved: we end up throwing an e.g. NoClassDefFoundError for code which may never be executed. This is particularly troublesome for code which supports multiple APIs, choosing one at runtime. The solution is to defer to stub code for symbols which can't be resolved at JIT compile time. Such a stub will try again at runtime to resolve the needed symbol and throw an appropriate error if it still can't be found.
2011-03-15 23:52:02 +00:00
} else if (t->exception) {
if (throw_) {
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
object e = type(t, throwType) == objectClass(t, t->exception)
? t->exception
: makeThrowable(t, throwType, specString, 0, t->exception);
implement lazy class/field/method resolution in JIT compiler Unlike the interpreter, the JIT compiler tries to resolve all the symbols referenced by a method when compiling that method. However, this can backfire if a symbol cannot be resolved: we end up throwing an e.g. NoClassDefFoundError for code which may never be executed. This is particularly troublesome for code which supports multiple APIs, choosing one at runtime. The solution is to defer to stub code for symbols which can't be resolved at JIT compile time. Such a stub will try again at runtime to resolve the needed symbol and throw an appropriate error if it still can't be found.
2011-03-15 23:52:02 +00:00
t->exception = 0;
vm::throw_(t, e);
} else {
t->exception = 0;
}
add new array classes to classloader map upon creation We were already doing this for non-array classes; we need to do it for all classes or else risk creating duplicates.
2010-12-01 03:27:36 +00:00
}
}
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
if (LIKELY(c)) {
add new array classes to classloader map upon creation We were already doing this for non-array classes; we need to do it for all classes or else risk creating duplicates.
2010-12-01 03:27:36 +00:00
PROTECT(t, c);
replace slashes with dots in class name before passing it to ClassLoader.loadClass
2009-08-11 15:20:49 +00:00
update class loader map when creating new array class This ensures that we don't create redundant array classes later.
2011-03-27 05:21:37 +00:00
saveLoadedClass(t, loader, c);
implement lazy class/field/method resolution in JIT compiler Unlike the interpreter, the JIT compiler tries to resolve all the symbols referenced by a method when compiling that method. However, this can backfire if a symbol cannot be resolved: we end up throwing an e.g. NoClassDefFoundError for code which may never be executed. This is particularly troublesome for code which supports multiple APIs, choosing one at runtime. The solution is to defer to stub code for symbols which can't be resolved at JIT compile time. Such a stub will try again at runtime to resolve the needed symbol and throw an appropriate error if it still can't be found.
2011-03-15 23:52:02 +00:00
} else if (throw_) {
various fixes and additions to increase app compatiblity The main changes here are: * fixes for runtime annotation support * proper support for runtime generic type introspection * throw NoClassDefFoundErrors instead of ClassNotFoundExceptions where appropriate
2011-03-18 03:42:15 +00:00
throwNew(t, throwType, "%s", &byteArrayBody(t, spec, 0));
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
}
implement lazy class/field/method resolution in JIT compiler Unlike the interpreter, the JIT compiler tries to resolve all the symbols referenced by a method when compiling that method. However, this can backfire if a symbol cannot be resolved: we end up throwing an e.g. NoClassDefFoundError for code which may never be executed. This is particularly troublesome for code which supports multiple APIs, choosing one at runtime. The solution is to defer to stub code for symbols which can't be resolved at JIT compile time. Such a stub will try again at runtime to resolve the needed symbol and throw an appropriate error if it still can't be found.
2011-03-15 23:52:02 +00:00
return c;
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
}
}
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
object
implement NewDirectByteBuffer etc. properly when building against Classpath; call JNI_OnLoad if found in newly-loaded libraries
2009-06-11 00:15:00 +00:00
resolveMethod(Thread* t, object class_, const char* methodName,
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
const char* methodSpec)
{
implement NewDirectByteBuffer etc. properly when building against Classpath; call JNI_OnLoad if found in newly-loaded libraries
2009-06-11 00:15:00 +00:00
PROTECT(t, class_);
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
implement NewDirectByteBuffer etc. properly when building against Classpath; call JNI_OnLoad if found in newly-loaded libraries
2009-06-11 00:15:00 +00:00
object name = makeByteArray(t, methodName);
PROTECT(t, name);
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
implement NewDirectByteBuffer etc. properly when building against Classpath; call JNI_OnLoad if found in newly-loaded libraries
2009-06-11 00:15:00 +00:00
object spec = makeByteArray(t, methodSpec);
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
implement NewDirectByteBuffer etc. properly when building against Classpath; call JNI_OnLoad if found in newly-loaded libraries
2009-06-11 00:15:00 +00:00
object method = findMethodInClass(t, class_, name, spec);
throw NoSuchMethodError in resolveMethod if method not found
2009-06-03 00:55:12 +00:00
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
if (method == 0) {
throwNew(t, Machine::NoSuchMethodErrorType, "%s %s not found in %s",
methodName, methodSpec, &byteArrayBody
(t, className(t, class_), 0));
implement NewDirectByteBuffer etc. properly when building against Classpath; call JNI_OnLoad if found in newly-loaded libraries
2009-06-11 00:15:00 +00:00
} else {
return method;
}
}
object
resolveField(Thread* t, object class_, const char* fieldName,
const char* fieldSpec)
{
PROTECT(t, class_);
object name = makeByteArray(t, fieldName);
PROTECT(t, name);
object spec = makeByteArray(t, fieldSpec);
PROTECT(t, spec);
check superinterfaces when looking up methods and fields
2009-08-03 22:16:41 +00:00
object field = findInInterfaces(t, class_, name, spec, findFieldInClass);
keep track of original class in resolveField so we can throw an exception with a useful message
2010-10-24 17:49:59 +00:00
object c = class_;
PROTECT(t, c);
for (; c != 0 and field == 0; c = classSuper(t, c)) {
field = findFieldInClass(t, c, name, spec);
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
}
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
if (field == 0) {
throwNew(t, Machine::NoSuchFieldErrorType, "%s %s not found in %s",
fieldName, fieldSpec, &byteArrayBody(t, className(t, class_), 0));
implement NewDirectByteBuffer etc. properly when building against Classpath; call JNI_OnLoad if found in newly-loaded libraries
2009-06-11 00:15:00 +00:00
} else {
return field;
}
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
}
fix deadlocks and other misbehaviors in class initialization code
2009-07-20 20:12:38 +00:00
bool
classNeedsInit(Thread* t, object c)
{
if (classVmFlags(t, c) & NeedInitFlag) {
if (classVmFlags(t, c) & InitFlag) {
// the class is currently being initialized. If this the thread
// which is initializing it, we should not try to initialize it
// recursively. Otherwise, we must wait for the responsible
// thread to finish.
for (Thread::ClassInitStack* s = t->classInitStack; s; s = s->next) {
if (s->class_ == c) {
return false;
}
}
}
return true;
} else {
return false;
}
}
bool
preInitClass(Thread* t, object c)
{
add appropriate memory barriers to double-checked locking code
2011-04-10 20:46:53 +00:00
int flags = classVmFlags(t, c);
loadMemoryBarrier();
if (flags & NeedInitFlag) {
fix deadlocks and other misbehaviors in class initialization code
2009-07-20 20:12:38 +00:00
PROTECT(t, c);
ACQUIRE(t, t->m->classLock);
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
fix deadlocks and other misbehaviors in class initialization code
2009-07-20 20:12:38 +00:00
if (classVmFlags(t, c) & NeedInitFlag) {
if (classVmFlags(t, c) & InitFlag) {
fix process=interpret class initialization regression A long time ago, I refactored the class initialization code in the VM, but did not notice until today that it had caused the process=interpret build to break on certain recursive initializations. In particular, we were not always detecting when a thread recursively tried to initialize a class it was already in the process of initializing, leading to the mistaken assumption that another thread was initializing it and that we should wait until it was done, in which case we would wait forever. This commit ensures that we always detect recursive initialization and short-circuit it.
2010-08-05 00:27:54 +00:00
// If the class is currently being initialized and this the thread
// which is initializing it, we should not try to initialize it
// recursively.
call static initializer of superclass before that of class itself Also, assume any class which has an ancestor class which has a static initializer needs initialization even if it doesn't have one itself, per the Java Language Spec.
2011-04-01 01:43:49 +00:00
if (isInitializing(t, c)) {
fix process=interpret class initialization regression A long time ago, I refactored the class initialization code in the VM, but did not notice until today that it had caused the process=interpret build to break on certain recursive initializations. In particular, we were not always detecting when a thread recursively tried to initialize a class it was already in the process of initializing, leading to the mistaken assumption that another thread was initializing it and that we should wait until it was done, in which case we would wait forever. This commit ensures that we always detect recursive initialization and short-circuit it.
2010-08-05 00:27:54 +00:00
return false;
fix deadlocks and other misbehaviors in class initialization code
2009-07-20 20:12:38 +00:00
}
// some other thread is on the job - wait for it to finish.
while (classVmFlags(t, c) & InitFlag) {
ENTER(t, Thread::IdleState);
t->m->classLock->wait(t->systemThread, 0);
}
} else if (classVmFlags(t, c) & InitErrorFlag) {
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
throwNew(t, Machine::NoClassDefFoundErrorType, "%s",
&byteArrayBody(t, className(t, c), 0));
fix deadlocks and other misbehaviors in class initialization code
2009-07-20 20:12:38 +00:00
} else {
classVmFlags(t, c) |= InitFlag;
return true;
}
}
}
return false;
}
void
postInitClass(Thread* t, object c)
{
PROTECT(t, c);
ACQUIRE(t, t->m->classLock);
fix various classloading deadlocks and races
2010-09-22 19:58:46 +00:00
fix deadlocks and other misbehaviors in class initialization code
2009-07-20 20:12:38 +00:00
if (t->exception) {
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
classVmFlags(t, c) |= NeedInitFlag | InitErrorFlag;
classVmFlags(t, c) &= ~InitFlag;
set Thread::exception to null before creating ExceptionInInitializerError If we don't do this, the VM will crash when it tries to create a stack trace for the error because makeObjectArray will return null immediately when it sees there is a pending exception.
2010-12-20 23:49:45 +00:00
object exception = t->exception;
t->exception = 0;
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
fix various regressions due to 0.5 work
2011-02-12 04:13:11 +00:00
throwNew(t, Machine::ExceptionInInitializerErrorType,
static_cast<object>(0), 0, exception);
fix deadlocks and other misbehaviors in class initialization code
2009-07-20 20:12:38 +00:00
} else {
classVmFlags(t, c) &= ~(NeedInitFlag | InitFlag);
}
t->m->classLock->notifyAll(t->systemThread);
}
void
initClass(Thread* t, object c)
{
PROTECT(t, c);
call static initializer of superclass before that of class itself Also, assume any class which has an ancestor class which has a static initializer needs initialization even if it doesn't have one itself, per the Java Language Spec.
2011-04-01 01:43:49 +00:00
object super = classSuper(t, c);
if (super) {
initClass(t, super);
}
fix deadlocks and other misbehaviors in class initialization code
2009-07-20 20:12:38 +00:00
if (preInitClass(t, c)) {
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
OBJECT_RESOURCE(t, c, postInitClass(t, c));
call static initializer of superclass before that of class itself Also, assume any class which has an ancestor class which has a static initializer needs initialization even if it doesn't have one itself, per the Java Language Spec.
2011-04-01 01:43:49 +00:00
object initializer = classInitializer(t, c);
if (initializer) {
Thread::ClassInitStack stack(t, c);
fix deadlocks and other misbehaviors in class initialization code
2009-07-20 20:12:38 +00:00
call static initializer of superclass before that of class itself Also, assume any class which has an ancestor class which has a static initializer needs initialization even if it doesn't have one itself, per the Java Language Spec.
2011-04-01 01:43:49 +00:00
t->m->processor->invoke(t, initializer, 0);
}
fix deadlocks and other misbehaviors in class initialization code
2009-07-20 20:12:38 +00:00
}
}
fix time==0 case in Unsafe.park and implement JVM_DumpThreads Also, set name field on system threads for OpenJDK build to avoid NPEs in Thread.getName.
2010-11-27 23:27:30 +00:00
object
resolveObjectArrayClass(Thread* t, object loader, object elementClass)
{
fix GC safety bug in resolveObjectArrayClass The call to getClassRuntimeData may trigger a GC, so we must mark the local variables to be visited.
2011-11-18 15:38:19 +00:00
PROTECT(t, loader);
PROTECT(t, elementClass);
fix time==0 case in Unsafe.park and implement JVM_DumpThreads Also, set name field on system threads for OpenJDK build to avoid NPEs in Thread.getName.
2010-11-27 23:27:30 +00:00
{ object arrayClass = classRuntimeDataArrayClass
(t, getClassRuntimeData(t, elementClass));
if (arrayClass) {
return arrayClass;
}
}
object elementSpec = className(t, elementClass);
PROTECT(t, elementSpec);
object spec;
if (byteArrayBody(t, elementSpec, 0) == '[') {
spec = makeByteArray(t, byteArrayLength(t, elementSpec) + 1);
byteArrayBody(t, spec, 0) = '[';
memcpy(&byteArrayBody(t, spec, 1),
&byteArrayBody(t, elementSpec, 0),
byteArrayLength(t, elementSpec));
} else {
spec = makeByteArray(t, byteArrayLength(t, elementSpec) + 3);
byteArrayBody(t, spec, 0) = '[';
byteArrayBody(t, spec, 1) = 'L';
memcpy(&byteArrayBody(t, spec, 2),
&byteArrayBody(t, elementSpec, 0),
byteArrayLength(t, elementSpec) - 1);
byteArrayBody(t, spec, byteArrayLength(t, elementSpec) + 1) = ';';
byteArrayBody(t, spec, byteArrayLength(t, elementSpec) + 2) = 0;
}
object arrayClass = resolveClass(t, loader, spec);
set(t, getClassRuntimeData(t, elementClass), ClassRuntimeDataArrayClass,
arrayClass);
return arrayClass;
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
object
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
makeObjectArray(Thread* t, object elementClass, unsigned count)
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
{
add classloader parameter to functions which may directly or indirectly load classes; include methods inherited from interfaces (but not explicitly declared) in method tables and virtual tables of abstract classes
2009-08-10 13:56:16 +00:00
object arrayClass = resolveObjectArrayClass
cache array class lookups in element class; misc. bugfixes
2010-09-25 21:54:01 +00:00
(t, classLoader(t, elementClass), elementClass);
avoid inifinite recursion if java.lang.Object is missing; refactoring When trying to create an array class, we try to resolve java.lang.Object so we can use its vtable in the array class. However, if Object is missing, we'll try to create and throw a ClassNotFoundException, which requires creating an array to store the stack trace, which requires creating an array class, which requires resolving Object, etc.. This commit short-circuits this process by telling resolveClass not to create and throw an exception if it can't find Object. While doing the above work, I noticed that the implementations of Classpath::makeThrowable in classpath-avian.cpp and classpath-openjdk.cpp were identical, so I made makeThrowable a top-level function. Finally, I discovered that Thread.setDaemon can only be called before the target thread has been started, which allowed me to simplify the code to track daemon threads in the VM.
2010-12-10 02:38:12 +00:00
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
PROTECT(t, arrayClass);
zero heap space ahead of time when allocating raw storage and garbage collecting, not when allocating individual objects This helps us support the Java Memory Model without adding a memory barrier to every object allocation. It's also potentially more efficient, since we zero out each heap segment all at once instead of bit-by-bit with each object allocation.
2009-03-04 03:05:48 +00:00
object array = makeArray(t, count);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
setObjectClass(t, array, arrayClass);
return array;
}
several things: change object typedef to Object* instead of void* to improve type safety; add JNICALL attributes to JNI functions; implement additional JavaVM methods
2007-09-07 00:21:52 +00:00
object
make find[Field|Method]InClass non-inline functions It seems that GCC 4.6.1 gets confused at LTO time when we take the address of inline functions, so I'm switching them to non-inline linkage to make it happy.
2012-03-27 00:06:16 +00:00
findFieldInClass(Thread* t, object class_, object name, object spec)
several things: change object typedef to Object* instead of void* to improve type safety; add JNICALL attributes to JNI functions; implement additional JavaVM methods
2007-09-07 00:21:52 +00:00
{
make find[Field|Method]InClass non-inline functions It seems that GCC 4.6.1 gets confused at LTO time when we take the address of inline functions, so I'm switching them to non-inline linkage to make it happy.
2012-03-27 00:06:16 +00:00
return findInTable
(t, classFieldTable(t, class_), name, spec, fieldName, fieldSpec);
}
several things: change object typedef to Object* instead of void* to improve type safety; add JNICALL attributes to JNI functions; implement additional JavaVM methods
2007-09-07 00:21:52 +00:00
make find[Field|Method]InClass non-inline functions It seems that GCC 4.6.1 gets confused at LTO time when we take the address of inline functions, so I'm switching them to non-inline linkage to make it happy.
2012-03-27 00:06:16 +00:00
object
findMethodInClass(Thread* t, object class_, object name, object spec)
{
return findInTable
(t, classMethodTable(t, class_), name, spec, methodName, methodSpec);
several things: change object typedef to Object* instead of void* to improve type safety; add JNICALL attributes to JNI functions; implement additional JavaVM methods
2007-09-07 00:21:52 +00:00
}
object
enable standalone OpenJDK builds As described in readme.txt, a standalone OpenJDK build embeds all libraries, classes, and other files needed at runtime in the resulting binary, eliminating dependencies on external resources.
2010-11-04 17:02:09 +00:00
findInHierarchyOrNull(Thread* t, object class_, object name, object spec,
object (*find)(Thread*, object, object, object))
several things: change object typedef to Object* instead of void* to improve type safety; add JNICALL attributes to JNI functions; implement additional JavaVM methods
2007-09-07 00:21:52 +00:00
{
object originalClass = class_;
object o = 0;
Merge branch 'master' into powerpc Conflicts: makefile src/assembler.h src/compile.cpp src/compiler.cpp src/compiler.h src/finder.cpp
2008-11-11 15:20:49 +00:00
if ((classFlags(t, class_) & ACC_INTERFACE)
and classVirtualTable(t, class_))
{
o = findInTable
(t, classVirtualTable(t, class_), name, spec, methodName, methodSpec);
}
if (o == 0) {
several things: change object typedef to Object* instead of void* to improve type safety; add JNICALL attributes to JNI functions; implement additional JavaVM methods
2007-09-07 00:21:52 +00:00
for (; o == 0 and class_; class_ = classSuper(t, class_)) {
o = find(t, class_, name, spec);
}
mark system classloader initialized when using GNU Classpath to avoid security exceptions; only look for field in interfaces after looking in class and superclasses
2009-12-25 00:57:07 +00:00
if (o == 0 and find == findFieldInClass) {
o = findInInterfaces(t, originalClass, name, spec, find);
}
several things: change object typedef to Object* instead of void* to improve type safety; add JNICALL attributes to JNI functions; implement additional JavaVM methods
2007-09-07 00:21:52 +00:00
}
return o;
}
handle weak maps properly in hashMapResize, hashMapRemove, etc.; move Processor::parameterFootprint() into machine.h/machine.cpp
2007-11-20 22:24:02 +00:00
unsigned
parameterFootprint(Thread* t, const char* s, bool static_)
{
unsigned footprint = 0;
for (MethodSpecIterator it(t, s); it.hasNext();) {
switch (*it.next()) {
case 'J':
case 'D':
footprint += 2;
break;
default:
++ footprint;
break;
}
}
if (not static_) {
++ footprint;
}
return footprint;
}
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
void
addFinalizer(Thread* t, object target, void (*finalize)(Thread*, object))
{
PROTECT(t, target);
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
ACQUIRE(t, t->m->referenceLock);
support object arrays of various element types and dimensions; clean up weak hash map support
2007-07-14 17:31:01 +00:00
refactor build system to support cross-compiling
2007-10-22 20:56:27 +00:00
void* function;
memcpy(&function, &finalize, BytesPerWord);
avoid calling doCollect recursively We must not allocate heap objects from doCollect, since it might trigger a GC while one is already in progress, which can cause trouble when we're still queuing up objects to finalize, among other things. To avoid this, I've added extra fields to the finalizer and cleaner types which we can use to link instances up during GC without allocating new memory.
2011-03-26 01:11:38 +00:00
object f = makeFinalizer(t, 0, function, 0, 0, 0);
various bugfixes
2007-08-14 00:37:00 +00:00
finalizerTarget(t, f) = target;
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
finalizerNext(t, f) = t->m->finalizers;
t->m->finalizers = f;
more bugfixes, mainly monitor-related
2007-07-11 04:19:26 +00:00
}
reimplement Java object monitors (second try) See commit 8120bee4dc5f9ae2dec75a907778f1479ad398bd for the original problem description and solution. That commit and a couple of related ones had to be reverted when we found they had introduced GC-safety regressions leading to crashes. This commit restores the reverted code and fixes the regressions.
2010-02-05 00:56:21 +00:00
object
various threading bugfixes
2007-11-27 22:23:00 +00:00
objectMonitor(Thread* t, object o, bool createNew)
more refactoring
2007-07-06 23:50:26 +00:00
{
remove unused function and add some thread state assertions
2008-01-18 01:27:44 +00:00
assert(t, t->state == Thread::ActiveState);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
object m = hashMapFind
(t, root(t, Machine::MonitorMap), o, objectHash, objectEqual);
more refactoring
2007-07-06 23:50:26 +00:00
reimplement Java object monitors (second try) See commit 8120bee4dc5f9ae2dec75a907778f1479ad398bd for the original problem description and solution. That commit and a couple of related ones had to be reverted when we found they had introduced GC-safety regressions leading to crashes. This commit restores the reverted code and fixes the regressions.
2010-02-05 00:56:21 +00:00
if (m) {
replace Debug constant in machine.h with DebugMonitors
2007-07-10 23:34:53 +00:00
if (DebugMonitors) {
reimplement Java object monitors (second try) See commit 8120bee4dc5f9ae2dec75a907778f1479ad398bd for the original problem description and solution. That commit and a couple of related ones had to be reverted when we found they had introduced GC-safety regressions leading to crashes. This commit restores the reverted code and fixes the regressions.
2010-02-05 00:56:21 +00:00
fprintf(stderr, "found monitor %p for object %x\n", m, objectHash(t, o));
replace Debug constant in machine.h with DebugMonitors
2007-07-10 23:34:53 +00:00
}
more weak reference work, plus debug logging
2007-07-10 03:04:49 +00:00
reimplement Java object monitors (second try) See commit 8120bee4dc5f9ae2dec75a907778f1479ad398bd for the original problem description and solution. That commit and a couple of related ones had to be reverted when we found they had introduced GC-safety regressions leading to crashes. This commit restores the reverted code and fixes the regressions.
2010-02-05 00:56:21 +00:00
return m;
various threading bugfixes
2007-11-27 22:23:00 +00:00
} else if (createNew) {
more refactoring
2007-07-06 23:50:26 +00:00
PROTECT(t, o);
reimplement Java object monitors (second try) See commit 8120bee4dc5f9ae2dec75a907778f1479ad398bd for the original problem description and solution. That commit and a couple of related ones had to be reverted when we found they had introduced GC-safety regressions leading to crashes. This commit restores the reverted code and fixes the regressions.
2010-02-05 00:56:21 +00:00
PROTECT(t, m);
{ ENTER(t, Thread::ExclusiveState);
more refactoring
2007-07-06 23:50:26 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
m = hashMapFind
(t, root(t, Machine::MonitorMap), o, objectHash, objectEqual);
reimplement Java object monitors (second try) See commit 8120bee4dc5f9ae2dec75a907778f1479ad398bd for the original problem description and solution. That commit and a couple of related ones had to be reverted when we found they had introduced GC-safety regressions leading to crashes. This commit restores the reverted code and fixes the regressions.
2010-02-05 00:56:21 +00:00
if (m) {
if (DebugMonitors) {
fprintf(stderr, "found monitor %p for object %x\n",
m, objectHash(t, o));
}
return m;
}
object head = makeMonitorNode(t, 0, 0);
m = makeMonitor(t, 0, 0, 0, head, head, 0);
more refactoring
2007-07-06 23:50:26 +00:00
check again for entry in monitorMap after entering the exclusive state in objectMonitor() in case another thread beat us to creating a monitor for the object
2007-11-29 15:03:45 +00:00
if (DebugMonitors) {
reimplement Java object monitors (second try) See commit 8120bee4dc5f9ae2dec75a907778f1479ad398bd for the original problem description and solution. That commit and a couple of related ones had to be reverted when we found they had introduced GC-safety regressions leading to crashes. This commit restores the reverted code and fixes the regressions.
2010-02-05 00:56:21 +00:00
fprintf(stderr, "made monitor %p for object %x\n", m,
revert recent commits to reimplement Java object monitors We're seeing race conditions which occasionally lead to assertion failures and thus crashes, so I'm reverting these changes for now: 29309fb4149ec02f993f84ffe4675e95c98db832 e92674cb7337355dc4dd6317219010e5d1ce7e1c 8120bee4dc5f9ae2dec75a907778f1479ad398bd
2010-02-04 15:18:39 +00:00
objectHash(t, o));
check again for entry in monitorMap after entering the exclusive state in objectMonitor() in case another thread beat us to creating a monitor for the object
2007-11-29 15:03:45 +00:00
}
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
hashMapInsert(t, root(t, Machine::MonitorMap), o, m, objectHash);
more refactoring
2007-07-06 23:50:26 +00:00
reimplement Java object monitors (second try) See commit 8120bee4dc5f9ae2dec75a907778f1479ad398bd for the original problem description and solution. That commit and a couple of related ones had to be reverted when we found they had introduced GC-safety regressions leading to crashes. This commit restores the reverted code and fixes the regressions.
2010-02-05 00:56:21 +00:00
addFinalizer(t, o, removeMonitor);
replace Debug constant in machine.h with DebugMonitors
2007-07-10 23:34:53 +00:00
}
more refactoring
2007-07-06 23:50:26 +00:00
return m;
various threading bugfixes
2007-11-27 22:23:00 +00:00
} else {
return 0;
more refactoring
2007-07-06 23:50:26 +00:00
}
}
implement String.intern()
2007-07-29 00:02:32 +00:00
object
intern(Thread* t, object s)
{
break native hashMap type into hashMap and weakHashMap; start investgating GC stress failures related to or uncovered by new string interning support
2007-07-29 18:52:08 +00:00
PROTECT(t, s);
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
ACQUIRE(t, t->m->referenceLock);
implement String.intern()
2007-07-29 00:02:32 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
object n = hashMapFindNode
(t, root(t, Machine::StringMap), s, stringHash, stringEqual);
implement String.intern()
2007-07-29 00:02:32 +00:00
if (n) {
return jreferenceTarget(t, tripleFirst(t, n));
} else {
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
hashMapInsert(t, root(t, Machine::StringMap), s, 0, stringHash);
implement String.intern()
2007-07-29 00:02:32 +00:00
addFinalizer(t, s, removeString);
return s;
}
}
implement primitive testing framework and provide for GC stress testing
2007-07-16 01:03:02 +00:00
void
collect(Thread* t, Heap::CollectionType type)
{
enter exclusive state in collect function instead of requiring caller to enter that state before calling
2008-05-05 13:04:53 +00:00
ENTER(t, Thread::ExclusiveState);
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
if (t->m->heap->limitExceeded()) {
type = Heap::MajorCollection;
add Machine::heapPool, allowing threads to acquire replacement heaps up to a point before forcing a GC
2007-08-22 14:50:29 +00:00
}
implement fixed object support
2007-10-28 01:54:30 +00:00
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
doCollect(t, type);
JIT-related GC safety fixes
2007-12-16 22:41:07 +00:00
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
if (t->m->heap->limitExceeded()) {
// try once more, giving the heap a chance to squeeze everything
// into the smallest possible space:
doCollect(t, Heap::MajorCollection);
rearrange finalization code in collect to avoid inifinite recursion when finalizer allocates memory
2009-07-17 15:29:24 +00:00
}
remove unused Heap::Client::outOfMemory method The heap-dump-on-OOM feature has been moved to the collect function.
2011-02-02 15:46:20 +00:00
#ifdef AVIAN_HEAPDUMP
if ((not t->m->dumpedHeapOnOOM) and t->m->heap->limitExceeded()) {
t->m->dumpedHeapOnOOM = true;
const char* path = findProperty(t, "avian.heap.dump");
if (path) {
FILE* out = vm::fopen(path, "wb");
if (out) {
dumpHeap(t, out);
fclose(out);
}
}
}
#endif//AVIAN_HEAPDUMP
implement primitive testing framework and provide for GC stress testing
2007-07-16 01:03:02 +00:00
}
initial work to support boot image creation and use
2008-11-21 23:20:35 +00:00
void
walk(Thread* t, Heap::Walker* w, object o, unsigned start)
{
object class_ = static_cast<object>(t->m->heap->follow(objectClass(t, o)));
object objectMask = static_cast<object>
(t->m->heap->follow(classObjectMask(t, class_)));
GC bugfixes
2009-05-17 23:43:48 +00:00
bool more = true;
initial work to support boot image creation and use
2008-11-21 23:20:35 +00:00
if (objectMask) {
unsigned fixedSize = classFixedSize(t, class_);
unsigned arrayElementSize = classArrayElementSize(t, class_);
unsigned arrayLength
= (arrayElementSize ?
rename cast -> fieldAtOffset
2013-02-11 00:38:51 +00:00
fieldAtOffset<uintptr_t>(o, fixedSize - BytesPerWord) : 0);
initial work to support boot image creation and use
2008-11-21 23:20:35 +00:00
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
THREAD_RUNTIME_ARRAY(t, uint32_t, mask, intArrayLength(t, objectMask));
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
memcpy(RUNTIME_ARRAY_BODY(mask), &intArrayBody(t, objectMask, 0),
initial work to support boot image creation and use
2008-11-21 23:20:35 +00:00
intArrayLength(t, objectMask) * 4);
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
more = ::walk(t, w, RUNTIME_ARRAY_BODY(mask), fixedSize, arrayElementSize,
arrayLength, start);
implement ClassLoader.resolveClass and ensure class is linked in e.g. Class.getMethods; minor bugfixes
2009-08-18 20:26:28 +00:00
} else if (classVmFlags(t, class_) & SingletonFlag) {
initial work to support boot image creation and use
2008-11-21 23:20:35 +00:00
unsigned length = singletonLength(t, o);
if (length) {
GC bugfixes
2009-05-17 23:43:48 +00:00
more = ::walk(t, w, singletonMask(t, o),
(singletonCount(t, o) + 2) * BytesPerWord, 0, 0, start);
initial work to support boot image creation and use
2008-11-21 23:20:35 +00:00
} else if (start == 0) {
GC bugfixes
2009-05-17 23:43:48 +00:00
more = w->visit(0);
initial work to support boot image creation and use
2008-11-21 23:20:35 +00:00
}
} else if (start == 0) {
GC bugfixes
2009-05-17 23:43:48 +00:00
more = w->visit(0);
initial work to support boot image creation and use
2008-11-21 23:20:35 +00:00
}
early sketch of continuation support
2009-05-03 20:57:11 +00:00
implement ClassLoader.resolveClass and ensure class is linked in e.g. Class.getMethods; minor bugfixes
2009-08-18 20:26:28 +00:00
if (more and classVmFlags(t, class_) & ContinuationFlag) {
early sketch of continuation support
2009-05-03 20:57:11 +00:00
t->m->processor->walkContinuationBody(t, w, o, start);
}
initial work to support boot image creation and use
2008-11-21 23:20:35 +00:00
}
Merge branch 'master' into powerpc Conflicts: makefile src/assembler.h src/compile.cpp src/compiler.cpp src/compiler.h src/finder.cpp
2008-11-11 15:20:49 +00:00
int
walkNext(Thread* t, object o, int previous)
{
class Walker: public Heap::Walker {
public:
Walker(): value(-1) { }
bool visit(unsigned offset) {
value = offset;
return false;
}
int value;
} walker;
walk(t, &walker, o, previous + 1);
return walker.value;
}
void
visitRoots(Machine* m, Heap::Visitor* v)
{
v->visit(&(m->types));
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
v->visit(&(m->roots));
Merge branch 'master' into powerpc Conflicts: makefile src/assembler.h src/compile.cpp src/compiler.cpp src/compiler.h src/finder.cpp
2008-11-11 15:20:49 +00:00
for (Thread* t = m->rootThread; t; t = t->peer) {
::visitRoots(t, v);
}
early sketch of continuation support
2009-05-03 20:57:11 +00:00
for (Reference* r = m->jniReferences; r; r = r->next) {
implement JNI methods NewWeakGlobalRef and DeleteWeakGlobalRef
2012-02-29 18:51:30 +00:00
if (not r->weak) {
v->visit(&(r->target));
}
early sketch of continuation support
2009-05-03 20:57:11 +00:00
}
Merge branch 'master' into powerpc Conflicts: makefile src/assembler.h src/compile.cpp src/compiler.cpp src/compiler.h src/finder.cpp
2008-11-11 15:20:49 +00:00
}
Trace writeout refactor
2013-02-05 06:41:37 +00:00
void
logTrace(FILE* f, const char* fmt, ...)
{
va_list a;
va_start(a, fmt);
#ifdef PLATFORM_WINDOWS
const unsigned length = _vscprintf(fmt, a);
#else
const unsigned length = vsnprintf(0, 0, fmt, a);
#endif
fix SIGSEGV and off-by-one error in logDebug We must use separate va_start/va_end pairs for each call to vsnprintf on Linux and possibly other platforms in order to avoid a crash. Also, we need to give it room to null terminate the string at the right point.
2013-02-06 18:40:06 +00:00
va_end(a);
Trace writeout refactor
2013-02-05 06:41:37 +00:00
RUNTIME_ARRAY(char, buffer, length + 1);
fix SIGSEGV and off-by-one error in logDebug We must use separate va_start/va_end pairs for each call to vsnprintf on Linux and possibly other platforms in order to avoid a crash. Also, we need to give it room to null terminate the string at the right point.
2013-02-06 18:40:06 +00:00
va_start(a, fmt);
modify (THREAD_)RUNTIME_ARRAY definition so RUNTIME_ARRAY_BODY must be used Previously, if you forgot to use RUNTIME_ARRAY_BODY to reference an array declared with (THREAD_)RUNTIME_ARRAY, you wouldn't get a compiler error until you tried to build on e.g. MSVC, where runtime-sized stack arrays aren't supported. This change ensures you find out regardless of what compiler you're using, which ought to protect us from regressions going forward.
2013-02-21 00:20:17 +00:00
vsnprintf(RUNTIME_ARRAY_BODY(buffer), length + 1, fmt, a);
Trace writeout refactor
2013-02-05 06:41:37 +00:00
va_end(a);
modify (THREAD_)RUNTIME_ARRAY definition so RUNTIME_ARRAY_BODY must be used Previously, if you forgot to use RUNTIME_ARRAY_BODY to reference an array declared with (THREAD_)RUNTIME_ARRAY, you wouldn't get a compiler error until you tried to build on e.g. MSVC, where runtime-sized stack arrays aren't supported. This change ensures you find out regardless of what compiler you're using, which ought to protect us from regressions going forward.
2013-02-21 00:20:17 +00:00
RUNTIME_ARRAY_BODY(buffer)[length] = 0;
Trace writeout refactor
2013-02-05 06:41:37 +00:00
modify (THREAD_)RUNTIME_ARRAY definition so RUNTIME_ARRAY_BODY must be used Previously, if you forgot to use RUNTIME_ARRAY_BODY to reference an array declared with (THREAD_)RUNTIME_ARRAY, you wouldn't get a compiler error until you tried to build on e.g. MSVC, where runtime-sized stack arrays aren't supported. This change ensures you find out regardless of what compiler you're using, which ought to protect us from regressions going forward.
2013-02-21 00:20:17 +00:00
::fprintf(f, "%s", RUNTIME_ARRAY_BODY(buffer));
Trace writeout refactor
2013-02-05 06:41:37 +00:00
#ifdef PLATFORM_WINDOWS
modify (THREAD_)RUNTIME_ARRAY definition so RUNTIME_ARRAY_BODY must be used Previously, if you forgot to use RUNTIME_ARRAY_BODY to reference an array declared with (THREAD_)RUNTIME_ARRAY, you wouldn't get a compiler error until you tried to build on e.g. MSVC, where runtime-sized stack arrays aren't supported. This change ensures you find out regardless of what compiler you're using, which ought to protect us from regressions going forward.
2013-02-21 00:20:17 +00:00
::OutputDebugStringA(RUNTIME_ARRAY_BODY(buffer));
Trace writeout refactor
2013-02-05 06:41:37 +00:00
#endif
}
working reflection
2007-07-24 03:16:59 +00:00
void
printTrace(Thread* t, object exception)
{
If you pass 0 to printTrace, it will print the stack trace of a null pointer exception. This dramatically simplifies debugging in GDB: p vm::printTrace(t, 0)
2007-10-12 20:54:37 +00:00
if (exception == 0) {
avoid inifinite recursion if java.lang.Object is missing; refactoring When trying to create an array class, we try to resolve java.lang.Object so we can use its vtable in the array class. However, if Object is missing, we'll try to create and throw a ClassNotFoundException, which requires creating an array to store the stack trace, which requires creating an array class, which requires resolving Object, etc.. This commit short-circuits this process by telling resolveClass not to create and throw an exception if it can't find Object. While doing the above work, I noticed that the implementations of Classpath::makeThrowable in classpath-avian.cpp and classpath-openjdk.cpp were identical, so I made makeThrowable a top-level function. Finally, I discovered that Thread.setDaemon can only be called before the target thread has been started, which allowed me to simplify the code to track daemon threads in the VM.
2010-12-10 02:38:12 +00:00
exception = makeThrowable(t, Machine::NullPointerExceptionType);
If you pass 0 to printTrace, it will print the stack trace of a null pointer exception. This dramatically simplifies debugging in GDB: p vm::printTrace(t, 0)
2007-10-12 20:54:37 +00:00
}
superficial code cleanup
2007-10-13 00:22:52 +00:00
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
for (object e = exception; e; e = throwableCause(t, e)) {
working reflection
2007-07-24 03:16:59 +00:00
if (e != exception) {
Trace writeout refactor
2013-02-05 06:41:37 +00:00
logTrace(errorLog(t), "caused by: ");
working reflection
2007-07-24 03:16:59 +00:00
}
Trace writeout refactor
2013-02-05 06:41:37 +00:00
logTrace(errorLog(t), "%s", &byteArrayBody
working reflection
2007-07-24 03:16:59 +00:00
(t, className(t, objectClass(t, e)), 0));
Allow output of exceptions to debugger. Generate WinMD file
2013-01-30 08:42:05 +00:00
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
if (throwableMessage(t, e)) {
object m = throwableMessage(t, e);
rework VM exception handling; throw OOMEs when appropriate This rather large commit modifies the VM to use non-local returns to throw exceptions instead of simply setting Thread::exception and returning frame-by-frame as it used to. This has several benefits: * Functions no longer need to check Thread::exception after each call which might throw an exception (which would be especially tedious and error-prone now that any function which allocates objects directly or indirectly might throw an OutOfMemoryError) * There's no need to audit the code for calls to functions which previously did not throw exceptions but later do * Performance should be improved slightly due to both the reduced need for conditionals and because undwinding now occurs in a single jump instead of a series of returns The main disadvantages are: * Slightly higher overhead for entering and leaving the VM via the JNI and JDK methods * Non-local returns can make the code harder to read * We must be careful to register destructors for stack-allocated resources with the Thread so they can be called prior to a non-local return The non-local return implementation is similar to setjmp/longjmp, except it uses continuation-passing style to avoid the need for cooperation from the C/C++ compiler. Native C++ exceptions would have also been an option, but that would introduce a dependence on libstdc++, which we're trying to avoid for portability reasons. Finally, this commit ensures that the VM throws an OutOfMemoryError instead of aborting when it reaches its memory ceiling. Currently, we treat the ceiling as a soft limit and temporarily exceed it as necessary to allow garbage collection and certain internal allocations to succeed, but refuse to allocate any Java objects until the heap size drops back below the ceiling.
2010-12-27 22:55:23 +00:00
THREAD_RUNTIME_ARRAY(t, char, message, stringLength(t, m) + 1);
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
stringChars(t, m, RUNTIME_ARRAY_BODY(message));
Trace writeout refactor
2013-02-05 06:41:37 +00:00
logTrace(errorLog(t), ": %s\n", RUNTIME_ARRAY_BODY(message));
working reflection
2007-07-24 03:16:59 +00:00
} else {
Trace writeout refactor
2013-02-05 06:41:37 +00:00
logTrace(errorLog(t), "\n");
working reflection
2007-07-24 03:16:59 +00:00
}
clean up bootstrap type generation to eliminate redundancy (broken)
2007-11-04 21:15:28 +00:00
object trace = throwableTrace(t, e);
don't try to print null exception trace in printTrace It is possible to create an Exception with no stack trace by overriding Throwable.fillInStackTrace, so we can't assume any given instance will have one.
2011-03-04 22:58:10 +00:00
if (trace) {
for (unsigned i = 0; i < objectArrayLength(t, trace); ++i) {
object e = objectArrayBody(t, trace, i);
const int8_t* class_ = &byteArrayBody
(t, className(t, methodClass(t, traceElementMethod(t, e))), 0);
const int8_t* method = &byteArrayBody
(t, methodName(t, traceElementMethod(t, e)), 0);
int line = t->m->processor->lineNumber
(t, traceElementMethod(t, e), traceElementIp(t, e));
Trace writeout refactor
2013-02-05 06:41:37 +00:00
logTrace(errorLog(t), " at %s.%s ", class_, method);
don't try to print null exception trace in printTrace It is possible to create an Exception with no stack trace by overriding Throwable.fillInStackTrace, so we can't assume any given instance will have one.
2011-03-04 22:58:10 +00:00
switch (line) {
case NativeLine:
Trace writeout refactor
2013-02-05 06:41:37 +00:00
logTrace(errorLog(t), "(native)\n");
don't try to print null exception trace in printTrace It is possible to create an Exception with no stack trace by overriding Throwable.fillInStackTrace, so we can't assume any given instance will have one.
2011-03-04 22:58:10 +00:00
break;
case UnknownLine:
Trace writeout refactor
2013-02-05 06:41:37 +00:00
logTrace(errorLog(t), "(unknown line)\n");
don't try to print null exception trace in printTrace It is possible to create an Exception with no stack trace by overriding Throwable.fillInStackTrace, so we can't assume any given instance will have one.
2011-03-04 22:58:10 +00:00
break;
default:
Trace writeout refactor
2013-02-05 06:41:37 +00:00
logTrace(errorLog(t), "(line %d)\n", line);
don't try to print null exception trace in printTrace It is possible to create an Exception with no stack trace by overriding Throwable.fillInStackTrace, so we can't assume any given instance will have one.
2011-03-04 22:58:10 +00:00
}
working reflection
2007-07-24 03:16:59 +00:00
}
}
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
if (e == throwableCause(t, e)) {
break;
}
working reflection
2007-07-24 03:16:59 +00:00
}
add new array classes to classloader map upon creation We were already doing this for non-array classes; we need to do it for all classes or else risk creating duplicates.
2010-12-01 03:27:36 +00:00
Trace writeout refactor
2013-02-05 06:41:37 +00:00
::fflush(errorLog(t));
working reflection
2007-07-24 03:16:59 +00:00
}
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
object
refactor stack walking interface in processor.h and sketch stack walking implementation in compile2.cpp
2007-11-25 23:00:55 +00:00
makeTrace(Thread* t, Processor::StackWalker* walker)
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
{
refactor stack walking interface in processor.h and sketch stack walking implementation in compile2.cpp
2007-11-25 23:00:55 +00:00
class Visitor: public Processor::StackVisitor {
public:
Visitor(Thread* t): t(t), trace(0), index(0), protector(t, &trace) { }
bugfixes for recent refactoring effort
2007-09-24 13:46:48 +00:00
refactor stack walking interface in processor.h and sketch stack walking implementation in compile2.cpp
2007-11-25 23:00:55 +00:00
virtual bool visit(Processor::StackWalker* walker) {
if (trace == 0) {
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
trace = makeObjectArray(t, walker->count());
factor out assert / abort / expect implementations
2013-02-12 01:51:39 +00:00
assert(t, trace);
refactor stack walking interface in processor.h and sketch stack walking implementation in compile2.cpp
2007-11-25 23:00:55 +00:00
}
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
refactor stack walking interface in processor.h and sketch stack walking implementation in compile2.cpp
2007-11-25 23:00:55 +00:00
object e = makeTraceElement(t, walker->method(), walker->ip());
factor out assert / abort / expect implementations
2013-02-12 01:51:39 +00:00
assert(t, index < objectArrayLength(t, trace));
refactor stack walking interface in processor.h and sketch stack walking implementation in compile2.cpp
2007-11-25 23:00:55 +00:00
set(t, trace, ArrayBody + (index * BytesPerWord), e);
++ index;
return true;
}
Thread* t;
object trace;
unsigned index;
Thread::SingleProtector protector;
} v(t);
walker->walk(&v);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
return v.trace ? v.trace : makeObjectArray(t, 0);
refactor stack walking interface in processor.h and sketch stack walking implementation in compile2.cpp
2007-11-25 23:00:55 +00:00
}
object
more progress on general stack tracing
2008-04-09 19:08:13 +00:00
makeTrace(Thread* t, Thread* target)
refactor stack walking interface in processor.h and sketch stack walking implementation in compile2.cpp
2007-11-25 23:00:55 +00:00
{
class Visitor: public Processor::StackVisitor {
public:
Visitor(Thread* t): t(t), trace(0) { }
virtual bool visit(Processor::StackWalker* walker) {
add support for building with MSVC on Windows
2009-08-27 00:26:44 +00:00
trace = vm::makeTrace(t, walker);
refactor stack walking interface in processor.h and sketch stack walking implementation in compile2.cpp
2007-11-25 23:00:55 +00:00
return false;
}
Thread* t;
object trace;
} v(t);
more progress on general stack tracing
2008-04-09 19:08:13 +00:00
t->m->processor->walkStack(target, &v);
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
return v.trace ? v.trace : makeObjectArray(t, 0);
refactoring effort to pave the way for JIT compilation
2007-09-24 01:39:03 +00:00
}
run java finalizers in a separate thread to guarantee no application locks are held when doing so
2009-08-24 23:51:31 +00:00
void
runFinalizeThread(Thread* t)
{
avoid calling doCollect recursively We must not allocate heap objects from doCollect, since it might trigger a GC while one is already in progress, which can cause trouble when we're still queuing up objects to finalize, among other things. To avoid this, I've added extra fields to the finalizer and cleaner types which we can use to link instances up during GC without allocating new memory.
2011-03-26 01:11:38 +00:00
object finalizeList = 0;
PROTECT(t, finalizeList);
object cleanList = 0;
PROTECT(t, cleanList);
run java finalizers in a separate thread to guarantee no application locks are held when doing so
2009-08-24 23:51:31 +00:00
while (true) {
{ ACQUIRE(t, t->m->stateLock);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
while (t->m->finalizeThread
avoid calling doCollect recursively We must not allocate heap objects from doCollect, since it might trigger a GC while one is already in progress, which can cause trouble when we're still queuing up objects to finalize, among other things. To avoid this, I've added extra fields to the finalizer and cleaner types which we can use to link instances up during GC without allocating new memory.
2011-03-26 01:11:38 +00:00
and root(t, Machine::ObjectsToFinalize) == 0
and root(t, Machine::ObjectsToClean) == 0)
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
{
run java finalizers in a separate thread to guarantee no application locks are held when doing so
2009-08-24 23:51:31 +00:00
ENTER(t, Thread::IdleState);
t->m->stateLock->wait(t->systemThread, 0);
}
if (t->m->finalizeThread == 0) {
return;
} else {
avoid calling doCollect recursively We must not allocate heap objects from doCollect, since it might trigger a GC while one is already in progress, which can cause trouble when we're still queuing up objects to finalize, among other things. To avoid this, I've added extra fields to the finalizer and cleaner types which we can use to link instances up during GC without allocating new memory.
2011-03-26 01:11:38 +00:00
finalizeList = root(t, Machine::ObjectsToFinalize);
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
setRoot(t, Machine::ObjectsToFinalize, 0);
avoid calling doCollect recursively We must not allocate heap objects from doCollect, since it might trigger a GC while one is already in progress, which can cause trouble when we're still queuing up objects to finalize, among other things. To avoid this, I've added extra fields to the finalizer and cleaner types which we can use to link instances up during GC without allocating new memory.
2011-03-26 01:11:38 +00:00
cleanList = root(t, Machine::ObjectsToClean);
setRoot(t, Machine::ObjectsToClean, 0);
run java finalizers in a separate thread to guarantee no application locks are held when doing so
2009-08-24 23:51:31 +00:00
}
}
avoid calling doCollect recursively We must not allocate heap objects from doCollect, since it might trigger a GC while one is already in progress, which can cause trouble when we're still queuing up objects to finalize, among other things. To avoid this, I've added extra fields to the finalizer and cleaner types which we can use to link instances up during GC without allocating new memory.
2011-03-26 01:11:38 +00:00
for (; finalizeList; finalizeList = finalizerQueueNext(t, finalizeList)) {
finalizeObject(t, finalizerQueueTarget(t, finalizeList), "finalize");
}
for (; cleanList; cleanList = cleanerQueueNext(t, cleanList)) {
finalizeObject(t, cleanList, "clean");
run java finalizers in a separate thread to guarantee no application locks are held when doing so
2009-08-24 23:51:31 +00:00
}
}
}
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
object
parseUtf8(Thread* t, const char* data, unsigned length)
{
class Client: public Stream::Client {
public:
Client(Thread* t): t(t) { }
don't abort when parsing malformed UTF8 strings Previously, we would abort the process if we encountered a truncated multibyte character in parseUtf8NonAscii (called by the JNI method NewStringUTF). Now we simply terminate the string at that point.
2011-04-07 20:26:54 +00:00
virtual void handleError() {
// vm::abort(t);
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
}
private:
Thread* t;
} client(t);
Stream s(&client, reinterpret_cast<const uint8_t*>(data), length);
return ::parseUtf8(t, s, length);
}
fix handling of classe, method, and field names with non-ASCII characters
2013-02-03 21:09:29 +00:00
object
parseUtf8(Thread* t, object array)
{
for (unsigned i = 0; i < byteArrayLength(t, array) - 1; ++i) {
if (byteArrayBody(t, array, i) & 0x80) {
goto slow_path;
}
}
return array;
slow_path:
class Client: public Stream::Client {
public:
Client(Thread* t): t(t) { }
virtual void handleError() {
// vm::abort(t);
}
private:
Thread* t;
} client(t);
class MyStream: public AbstractStream {
public:
class MyProtector: public Thread::Protector {
public:
MyProtector(Thread* t, MyStream* s):
Protector(t), s(s)
{ }
virtual void visit(Heap::Visitor* v) {
v->visit(&(s->array));
}
MyStream* s;
};
MyStream(Thread* t, Client* client, object array):
AbstractStream(client, byteArrayLength(t, array) - 1),
array(array),
protector(t, this)
{ }
virtual void copy(uint8_t* dst, unsigned offset, unsigned size) {
memcpy(dst, &byteArrayBody(protector.t, array, offset), size);
}
object array;
MyProtector protector;
} s(t, &client, array);
return ::parseUtf8(t, s, byteArrayLength(t, array) - 1);
}
cache array class lookups in element class; misc. bugfixes
2010-09-25 21:54:01 +00:00
object
fix a couple of OpenJDK reflection bugs We weren't wrapping exceptions thrown by invoked methods in InvocationTargetExceptions in JVM_InvokeMethod or JVM_NewInstanceFromConstructor. Also, JVM_GetCallerClass is supposed to ignore Method.invoke frames when walking the stack.
2012-09-23 02:22:33 +00:00
getCaller(Thread* t, unsigned target, bool skipMethodInvoke)
cache array class lookups in element class; misc. bugfixes
2010-09-25 21:54:01 +00:00
{
class Visitor: public Processor::StackVisitor {
public:
fix a couple of OpenJDK reflection bugs We weren't wrapping exceptions thrown by invoked methods in InvocationTargetExceptions in JVM_InvokeMethod or JVM_NewInstanceFromConstructor. Also, JVM_GetCallerClass is supposed to ignore Method.invoke frames when walking the stack.
2012-09-23 02:22:33 +00:00
Visitor(Thread* t, unsigned target, bool skipMethodInvoke):
t(t), method(0), count(0), target(target),
skipMethodInvoke(skipMethodInvoke)
cache array class lookups in element class; misc. bugfixes
2010-09-25 21:54:01 +00:00
{ }
virtual bool visit(Processor::StackWalker* walker) {
fix a couple of OpenJDK reflection bugs We weren't wrapping exceptions thrown by invoked methods in InvocationTargetExceptions in JVM_InvokeMethod or JVM_NewInstanceFromConstructor. Also, JVM_GetCallerClass is supposed to ignore Method.invoke frames when walking the stack.
2012-09-23 02:22:33 +00:00
if (skipMethodInvoke
and methodClass
(t, walker->method()) == type(t, Machine::JmethodType)
and strcmp
(&byteArrayBody(t, methodName(t, walker->method()), 0),
reinterpret_cast<const int8_t*>("invoke"))
== 0)
{
return true;
}
cache array class lookups in element class; misc. bugfixes
2010-09-25 21:54:01 +00:00
if (count == target) {
method = walker->method();
return false;
} else {
++ count;
return true;
}
}
Thread* t;
object method;
unsigned count;
unsigned target;
fix a couple of OpenJDK reflection bugs We weren't wrapping exceptions thrown by invoked methods in InvocationTargetExceptions in JVM_InvokeMethod or JVM_NewInstanceFromConstructor. Also, JVM_GetCallerClass is supposed to ignore Method.invoke frames when walking the stack.
2012-09-23 02:22:33 +00:00
bool skipMethodInvoke;
} v(t, target, skipMethodInvoke);
cache array class lookups in element class; misc. bugfixes
2010-09-25 21:54:01 +00:00
t->m->processor->walkStack(t, &v);
return v.method;
}
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
object
defineClass(Thread* t, object loader, const uint8_t* buffer, unsigned length)
{
PROTECT(t, loader);
object c = parseClass(t, loader, buffer, length);
add some commented-out debug code to defineClass When uncommented, this code will write each defined class to disk, which allows one to examine e.g. dynamically-generated classes using e.g. javap.
2011-04-09 00:46:43 +00:00
// char name[byteArrayLength(t, className(t, c))];
// memcpy(name, &byteArrayBody(t, className(t, c), 0),
// byteArrayLength(t, className(t, c)));
// replace('/', '-', name);
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
add some commented-out debug code to defineClass When uncommented, this code will write each defined class to disk, which allows one to examine e.g. dynamically-generated classes using e.g. javap.
2011-04-09 00:46:43 +00:00
// const unsigned BufferSize = 1024;
// char path[BufferSize];
// snprintf(path, BufferSize, "/tmp/avian-define-class/%s.class", name);
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
add some commented-out debug code to defineClass When uncommented, this code will write each defined class to disk, which allows one to examine e.g. dynamically-generated classes using e.g. javap.
2011-04-09 00:46:43 +00:00
// FILE* file = fopen(path, "wb");
// if (file) {
// fwrite(buffer, length, 1, file);
// fclose(file);
// }
PROTECT(t, c);
saveLoadedClass(t, loader, c);
preliminary support for using OpenJDK's class library Whereas the GNU Classpath port used the strategy of patching Classpath with core classes from Avian so as to minimize changes to the VM, this port uses the opposite strategy: abstract and isolate classpath-specific features in the VM similar to how we abstract away platform-specific features in system.h. This allows us to use an unmodified copy of OpenJDK's class library, including its core classes and augmented by a few VM-specific classes in the "avian" package.
2010-09-10 21:05:29 +00:00
return c;
}
implement various JVM_* methods This includes a proper implementation of JVM_ActiveProcessorCount, as well as JVM_SetLength and JVM_NewMultiArray. Also, we now accept up to JNI_VERSION_1_6 in JVM_IsSupportedJNIVersion.
2011-03-26 17:15:52 +00:00
void
populateMultiArray(Thread* t, object array, int32_t* counts,
unsigned index, unsigned dimensions)
{
if (index + 1 == dimensions or counts[index] == 0) {
return;
}
PROTECT(t, array);
object spec = className(t, objectClass(t, array));
PROTECT(t, spec);
object elementSpec = makeByteArray(t, byteArrayLength(t, spec) - 1);
memcpy(&byteArrayBody(t, elementSpec, 0),
&byteArrayBody(t, spec, 1),
byteArrayLength(t, spec) - 1);
object class_ = resolveClass
(t, classLoader(t, objectClass(t, array)), elementSpec);
PROTECT(t, class_);
for (int32_t i = 0; i < counts[index]; ++i) {
fix incorrect array sizing in populateMultiArray We were assuming the array element size was always the native word size, which is not correct in general for primitive arrays, and this led to wasted space at best and memory corruption at worst.
2012-06-26 16:43:47 +00:00
object a = makeArray
rename ceiling -> ceilingDivide
2013-02-11 01:06:15 +00:00
(t, ceilingDivide
fix incorrect array sizing in populateMultiArray We were assuming the array element size was always the native word size, which is not correct in general for primitive arrays, and this led to wasted space at best and memory corruption at worst.
2012-06-26 16:43:47 +00:00
(counts[index + 1] * classArrayElementSize(t, class_), BytesPerWord));
arrayLength(t, a) = counts[index + 1];
implement various JVM_* methods This includes a proper implementation of JVM_ActiveProcessorCount, as well as JVM_SetLength and JVM_NewMultiArray. Also, we now accept up to JNI_VERSION_1_6 in JVM_IsSupportedJNIVersion.
2011-03-26 17:15:52 +00:00
setObjectClass(t, a, class_);
set(t, array, ArrayBody + (i * BytesPerWord), a);
populateMultiArray(t, a, counts, index + 1, dimensions);
}
}
sketch of finalizer/weak reference overhaul; type generator bugfixes involving array member layout
2007-07-10 01:43:43 +00:00
void
noop()
{ }
more refactoring
2007-07-06 23:50:26 +00:00
#include "type-constructors.cpp"
} // namespace vm
add vmPrintTrace function which can print a Java stack trace without allocating memory
2008-01-16 17:30:12 +00:00
// for debugging
ensure debug helper functions are retained by linker Apple's linker tends to remove functions which are never called, which is not what we want for e.g. vmPrintTrace, since that function is only intended to be called interactively from within GDB.
2012-02-04 22:42:19 +00:00
JNIEXPORT void
add vmPrintTrace function which can print a Java stack trace without allocating memory
2008-01-16 17:30:12 +00:00
vmPrintTrace(Thread* t)
{
class Visitor: public Processor::StackVisitor {
public:
Visitor(Thread* t): t(t) { }
virtual bool visit(Processor::StackWalker* walker) {
const int8_t* class_ = &byteArrayBody
(t, className(t, methodClass(t, walker->method())), 0);
const int8_t* method = &byteArrayBody
(t, methodName(t, walker->method()), 0);
int line = t->m->processor->lineNumber
(t, walker->method(), walker->ip());
more work towards OpenJDK classpath support The biggest change in this commit is to split the system classloader into two: one for boot classes (e.g. java.lang.*) and another for application classes. This is necessary to make OpenJDK's security checks happy. The rest of the changes include bugfixes and additional JVM method implementations in classpath-openjdk.cpp.
2010-09-14 16:49:41 +00:00
fprintf(stderr, " at %s.%s ", class_, method);
add vmPrintTrace function which can print a Java stack trace without allocating memory
2008-01-16 17:30:12 +00:00
switch (line) {
case NativeLine:
fprintf(stderr, "(native)\n");
break;
case UnknownLine:
fprintf(stderr, "(unknown line)\n");
break;
default:
fprintf(stderr, "(line %d)\n", line);
}
return true;
}
Thread* t;
} v(t);
fix custom-classloader-related concurrency problems and other bugs The main changes in this commit ensure that we don't hold the global class lock when doing class resolution using application-defined classloaders. Such classloaders may do their own locking (in fact, it's almost certain), making deadlock likely when mixed with VM-level locking in various orders. Other changes include a fix to avoid overflow when waiting for extremely long intervals and a GC root stack mapping bug.
2010-09-17 01:43:27 +00:00
fprintf(stderr, "debug trace for thread %p\n", t);
add vmPrintTrace function which can print a Java stack trace without allocating memory
2008-01-16 17:30:12 +00:00
t->m->processor->walkStack(t, &v);
add new array classes to classloader map upon creation We were already doing this for non-array classes; we need to do it for all classes or else risk creating duplicates.
2010-12-01 03:27:36 +00:00
fflush(stderr);
add vmPrintTrace function which can print a Java stack trace without allocating memory
2008-01-16 17:30:12 +00:00
}
added debugging method 'vmAddressFromLine'
2009-06-11 15:44:37 +00:00
// also for debugging
ensure debug helper functions are retained by linker Apple's linker tends to remove functions which are never called, which is not what we want for e.g. vmPrintTrace, since that function is only intended to be called interactively from within GDB.
2012-02-04 22:42:19 +00:00
JNIEXPORT void*
added debugging method 'vmAddressFromLine'
2009-06-11 15:44:37 +00:00
vmAddressFromLine(Thread* t, object m, unsigned line)
{
fix custom-classloader-related concurrency problems and other bugs The main changes in this commit ensure that we don't hold the global class lock when doing class resolution using application-defined classloaders. Such classloaders may do their own locking (in fact, it's almost certain), making deadlock likely when mixed with VM-level locking in various orders. Other changes include a fix to avoid overflow when waiting for extremely long intervals and a GC root stack mapping bug.
2010-09-17 01:43:27 +00:00
object code = methodCode(t, m);
printf("code: %p\n", code);
object lnt = codeLineNumberTable(t, code);
printf("lnt: %p\n", lnt);
added debugging method 'vmAddressFromLine'
2009-06-11 15:44:37 +00:00
fix custom-classloader-related concurrency problems and other bugs The main changes in this commit ensure that we don't hold the global class lock when doing class resolution using application-defined classloaders. Such classloaders may do their own locking (in fact, it's almost certain), making deadlock likely when mixed with VM-level locking in various orders. Other changes include a fix to avoid overflow when waiting for extremely long intervals and a GC root stack mapping bug.
2010-09-17 01:43:27 +00:00
if (lnt) {
unsigned last = 0;
unsigned bottom = 0;
unsigned top = lineNumberTableLength(t, lnt);
for(unsigned i = bottom; i < top; i++)
{
progress towards cross-architecture bootimage builds This monster commit is the first step towards supporting cross-architecture bootimage builds. The challenge is to build a heap and code image for the target platform where the word size and endianess may differ from those of the build architecture. That means the memory layout of objects may differ due to alignment and size differences, so we can't just copy objects into the heap image unchanged; we must copy field by field, resizing values, reversing endianess and shifting offsets as necessary. This commit also removes POD (plain old data) type support from the type generator because it added a lot of complication and little value.
2011-08-30 01:00:17 +00:00
uint64_t ln = lineNumberTableBody(t, lnt, i);
fix custom-classloader-related concurrency problems and other bugs The main changes in this commit ensure that we don't hold the global class lock when doing class resolution using application-defined classloaders. Such classloaders may do their own locking (in fact, it's almost certain), making deadlock likely when mixed with VM-level locking in various orders. Other changes include a fix to avoid overflow when waiting for extremely long intervals and a GC root stack mapping bug.
2010-09-17 01:43:27 +00:00
if(lineNumberLine(ln) == line)
return reinterpret_cast<void*>(lineNumberIp(ln));
else if(lineNumberLine(ln) > line)
return reinterpret_cast<void*>(last);
last = lineNumberIp(ln);
}
}
return 0;
added debugging method 'vmAddressFromLine'
2009-06-11 15:44:37 +00:00
}
Reference in New Issue Copy Permalink