jamvm-amiga-openjdk.patch

diff --git a/src/alloc.c b/src/alloc.c
index 536c720..eb601f0 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -191,6 +191,12 @@ static VMLock registered_refs_lock;
 static VMWaitLock run_finaliser_lock;
 static VMWaitLock reference_lock;
 
+/* Cooperative VM-thread shutdown (AmigaOS/clib4 can't async-stop threads via
+   signals).  Set TRUE by terminateVMThreads(); the finalizer / reference-handler
+   loops check it after each condvar wait and exit, so clib4 exit() -- which waits
+   for all threads -- can complete instead of hanging on the never-ending daemons. */
+volatile int vm_exiting = FALSE;
+
 /* A pointer to the finalizer thread. */
 static Thread *finalizer_thread;
 
@@ -286,9 +292,40 @@ void clearMarkBits() {
     memset(markbits, 0, markbit_size * sizeof(*markbits));
 }
 
+#ifdef __amigaos4__
+#include <proto/exec.h>
+#endif
+
 int initialiseAlloc(InitArgs *args) {
     char *mem = (char*)mmap(0, args->max_heap, PROT_READ|PROT_WRITE,
                                                MAP_PRIVATE|MAP_ANON, -1, 0);
+
+#ifdef __amigaos4__
+    /* The whole max_heap is mapped here, once, and the heap only ever grows
+       INSIDE it -- so max_heap is really "how big a single MAP_ANON can we
+       get".  clib4 refuses large ones, and the VM used to just abort, which is
+       why nativePhysicalMemory() reported a fake 64MB and left every AmigaOS
+       user with a 16MB heap that could not grow.
+
+       Halve and retry instead.  The default can then be sized from real memory
+       and simply settles on whatever this machine can actually map, rather than
+       everyone paying for the worst case.  Stop at MIN_MIN_HEAP: below that the
+       VM cannot run anyway, and the original error is the right one to report. */
+    while(mem == MAP_FAILED && args->max_heap > MIN_MIN_HEAP) {
+        args->max_heap /= 2;
+
+        if(args->min_heap > args->max_heap)
+            args->min_heap = args->max_heap;
+
+        mem = (char*)mmap(0, args->max_heap, PROT_READ|PROT_WRITE,
+                                             MAP_PRIVATE|MAP_ANON, -1, 0);
+        if(mem != MAP_FAILED)
+            jam_fprintf(stderr, "Note: could not map the default heap; "
+                                "settled on %ldMB (-Xmx overrides)\n",
+                                (long)(args->max_heap / MB));
+    }
+#endif
+
     if(mem == MAP_FAILED) {
         perror("Couldn't allocate the heap; try reducing the max "
                "heap size (-Xmx)");
@@ -309,6 +346,24 @@ int initialiseAlloc(InitArgs *args) {
     freelist->next = NULL;
 
     TRACE_GC("Alloced heap size %p\n", heaplimit-heapbase);
+
+#ifdef __amigaos4__
+    /*
+     * The heap's address range, on the serial line, once.
+     *
+     * A DSI exception gives a faulting address and nothing else, and the first
+     * question about it is always the same: is that address a Java object at
+     * all?  Answering it has twice meant reasoning backwards from a register
+     * dump.  With this line the answer is a comparison -- inside [heapbase,
+     * heapmax) means the object is real and something about its LAYOUT is
+     * wrong; outside means the pointer never belonged to the heap and the
+     * fault is a stale or corrupted reference.  Those two lead opposite ways.
+     */
+    DebugPrintF("[HEAP] base=%p limit=%p max=%p (map %p..%p, %ldMB)\n",
+                heapbase, heaplimit, heapmax, mem, mem + args->max_heap,
+                (long)(args->max_heap / MB));
+#endif
+
     allocMarkBits();
 
     /* Initialise GC locks */
@@ -1788,6 +1843,13 @@ void asyncGCThreadLoop(Thread *self) {
     for(;;) {                                                                 \
         waitVMWaitLock(list##_lock, self);                                    \
                                                                               \
+        /* VM is shutting down: exit the loop so the thread terminates        \
+           (cooperative shutdown -- see vm_exiting / terminateVMThreads). */  \
+        if(vm_exiting) {                                                      \
+            unlockVMWaitLock(list##_lock, self);                              \
+            break;                                                            \
+        }                                                                     \
+                                                                              \
         if((list##_start == list##_size) && (list##_end == 0))                \
             continue;                                                         \
                                                                               \
@@ -1846,6 +1908,28 @@ void referenceHandlerThreadLoop(Thread *self) {
                         "<GC: enqueuing %d references>\n", self, &self);
 }
 
+/* Cooperative VM-thread shutdown.  Signal the finalizer and reference-handler
+   daemon threads to exit their loops (they wait on a condvar, so a normal notify
+   wakes them -- no signals needed), letting clib4 exit() complete.  Called from
+   the exit hook before the process terminates. */
+void terminateVMThreads() {
+    Thread *self = threadSelf();
+
+    vm_exiting = TRUE;
+
+    /* If main is blocked in mainThreadWaitToExitVM(), wake it so it can
+       observe vm_exiting and take the process down from the main thread. */
+    requestExitVMWaitBreak();
+
+    lockVMWaitLock(run_finaliser_lock, self);
+    notifyAllVMWaitLock(run_finaliser_lock, self);
+    unlockVMWaitLock(run_finaliser_lock, self);
+
+    lockVMWaitLock(reference_lock, self);
+    notifyAllVMWaitLock(reference_lock, self);
+    unlockVMWaitLock(reference_lock, self);
+}
+
 int initialiseGC(InitArgs *args) {
     /* Pre-allocate an OutOfMemoryError exception object - we throw it
      * when we're really low on heap space, and can create FA... */
@@ -2023,7 +2107,8 @@ void *gcMalloc(int len) {
 
                 state = throw_oom;
                 unlockVMLock(heap_lock, self);
-                signalException(java_lang_OutOfMemoryError, NULL);
+                /* the genuinely-out-of-heap case; say which one this is */
+                signalException(java_lang_OutOfMemoryError, "Java heap space");
                 return NULL;
                 break;
 
@@ -2075,8 +2160,14 @@ got_it:
     Thread *self;                                                             \
     disableSuspend(self = threadSelf());                                      \
     lockVMLock(has_fnlzr_lock, self);                                         \
-    TRACE_FNLZ(("Object @%p type %s has a finalize method...\n",              \
-                                             ob, CLASS_CB(ob->class)->name)); \
+    /* C99 variadic macro, so NO outer parentheses: with them the whole thing
+       is one comma expression whose value is the last operand, and this
+       degrades to jam_printf(CLASS_CB(ob->class)->name) -- the class name used
+       as the format string, printed bare with no newline.  That is what
+       flooded the serial line with "sun/java2d/SunGraphics2D" on every draw,
+       and it would read junk varargs the day a name contained a '%'. */      \
+    TRACE_FNLZ("Object @%p type %s has a finalize method...\n",               \
+                                              ob, CLASS_CB(ob->class)->name); \
     if(has_finaliser_count == has_finaliser_size) {                           \
         has_finaliser_size += LIST_INCREMENT;                                 \
         has_finaliser_list = sysRealloc(has_finaliser_list,                   \
@@ -2116,9 +2207,17 @@ Object *allocObject(Class *class) {
 Object *allocArray(Class *class, int size, int el_size) {
     Object *ob;
 
-    /* Special check to protect against integer overflow */
+    /* Special check to protect against integer overflow.  Say so: this is NOT
+       heap exhaustion -- no GC has even been attempted -- but a request for an
+       impossible array length, and a bare OutOfMemoryError with no message is
+       indistinguishable from the real thing.  That cost a long hunt once, when
+       a bad `new Node[n]` length out of ConcurrentHashMap's constructor looked
+       exactly like a heap too small to hold java.util.Locale. */
     if(size > (INT_MAX - sizeof(uintptr_t) - sizeof(Object)) / el_size) {
-        signalException(java_lang_OutOfMemoryError, NULL);
+        char buff[64];
+
+        snprintf(buff, sizeof(buff), "array length %d too large", size);
+        signalException(java_lang_OutOfMemoryError, buff);
         return NULL;
     }
 
@@ -2309,7 +2408,32 @@ void *gcMemRealloc(void *addr, int size) {
         uintptr_t old_size = *--mem;
         uintptr_t new_size = size + sizeof(uintptr_t);
 
+        /*
+         * Grow in place only when the block demonstrably already holds the new
+         * size.
+         *
+         * The test below this one is "do both sizes land in the same page?",
+         * which is sound only where mmap rounds an allocation UP to a whole
+         * page -- as Linux does -- so that a block of 100 bytes really owns
+         * 4096 and can be relabelled as 4000 for free.
+         *
+         * clib4's mmap does not round.  It allocates MMAP_PAGE_SIZE + len and
+         * spends that extra page on alignment and its own header, so a 100-byte
+         * request owns 100 usable bytes plus whatever alignment slack happens
+         * to be left.  Relabelling it 4000 hands the caller a pointer to memory
+         * it does not own, and the fault comes later, from whoever reads the
+         * far end -- which is why this presented as an intermittent DSI inside
+         * findHashedUtf8 during class loading, at an entry index near the top
+         * of a hash table that resizeHash had just "grown".
+         *
+         * Shrinking is always safe: the block is at least old_size already.
+         * Growing takes the allocate-copy-free path below, every time.
+         */
+#ifdef __amigaos4__
+        if(new_size <= old_size) {
+#else
         if(old_size/sys_page_size == new_size/sys_page_size) {
+#endif
             *mem = new_size;
             return addr;
         } else {
diff --git a/src/class.c b/src/class.c
index af81530..0523294 100644
--- a/src/class.c
+++ b/src/class.c
@@ -260,6 +260,27 @@ Class *parseClass(char *classname, char *data, int offset, int len,
     READ_U2(minor_version, ptr, len);
     READ_U2(major_version, ptr, len);
 
+    /* Java 8 (class-file major 52) is the newest bytecode this VM's class
+       library supports.  Reject anything newer up front with a clear
+       UnsupportedClassVersionError -- otherwise a Java 9+ class loads here and
+       dies far away with a mysterious BootstrapMethodError the first time it
+       executes an indy string-concat (java.lang.invoke.StringConcatFactory is
+       absent from the Java 8 rt.jar), which is exactly the kind of failure
+       that reads as "it just freezes".  (minor_version only flags preview
+       features -- ignore it.) */
+    if(major_version > 52) {
+        char msg[256];
+        snprintf(msg, sizeof(msg),
+                 "%s has been compiled by a more recent version of the Java "
+                 "Runtime (class file version %d.0); this Java 8 runtime only "
+                 "recognizes class file versions up to 52.0 -- recompile with "
+                 "javac --release 8", classname ? classname : "A class",
+                 major_version);
+        signalChainedExceptionName("java/lang/UnsupportedClassVersionError",
+                                   msg, NULL);
+        return NULL;
+    }
+
     if((class = allocClass()) == NULL)
         return NULL;
 
@@ -1480,6 +1501,10 @@ unlock:
    objectUnlock(class);
 }
 
+#ifdef __amigaos4__
+#include <proto/exec.h>
+#endif
+
 Class *initClass(Class *class) {
    ClassBlock *cb = CLASS_CB(class);
    ConstantPool *cp = &cb->constant_pool;
@@ -1549,8 +1574,51 @@ Class *initClass(Class *class) {
 
    if((excep = exceptionOccurred())) {
        Class *error;
+#ifdef __amigaos4__
+       {
+           /* detailMessage/vmState are inherited from java.lang.Throwable, so use
+              lookupField (searches superclasses), NOT findField (own fields only). */
+           FieldBlock *msgfb = lookupField(excep->class, newUtf8("detailMessage"),
+                                           newUtf8("Ljava/lang/String;"));
+           Object *msg = msgfb ? INST_DATA(excep, Object*, msgfb->u.offset)
+                               : NULL;
+           if(msg != NULL) {
+               char *c = String2Cstr(msg);
+               DebugPrintF("[CLINIT] %s <clinit> threw %s: %s\n",
+                           CLASS_CB(class)->name,
+                           CLASS_CB(excep->class)->name, c);
+               sysFree(c);
+           } else
+               DebugPrintF("[CLINIT] %s <clinit> threw %s (no message)\n",
+                           CLASS_CB(class)->name, CLASS_CB(excep->class)->name);
 
-       clearException(); 
+           /* Dump the stack trace: Throwable.vmState (VMThrowable) -> backtrace,
+              an int[] of (MethodBlock*, pc) pairs (see classlib .../excep.c). */
+           {
+               FieldBlock *vmsfb = lookupField(excep->class, newUtf8("vmState"),
+                                       newUtf8("Ljava/lang/VMThrowable;"));
+               Object *vmt = vmsfb ? INST_DATA(excep, Object*, vmsfb->u.offset)
+                                   : NULL;
+               FieldBlock *btfb = vmt ? findField(vmt->class, SYMBOL(backtrace),
+                                                  newUtf8("[I")) : NULL;
+               Object *bt = btfb ? INST_DATA(vmt, Object*, btfb->u.offset) : NULL;
+               if(bt != NULL) {
+                   uintptr_t *d = ARRAY_DATA(bt, uintptr_t);
+                   int i, len = ARRAY_LEN(bt);
+                   for(i = 0; i < len && i < 24; i += 2) {
+                       MethodBlock *m = (MethodBlock*)d[i];
+                       if(m == NULL) break;
+                       DebugPrintF("[CLINIT]   at %s.%s\n",
+                                   CLASS_CB(m->class)->name, m->name);
+                   }
+               } else
+                   DebugPrintF("[CLINIT]   (no backtrace: vmt=%p btfb=%p)\n",
+                               vmt, btfb);
+           }
+       }
+#endif
+
+       clearException();
 
        /* Don't wrap exceptions of type java.lang.Error... */
        error = findSystemClass0(SYMBOL(java_lang_Error));
@@ -1592,6 +1660,10 @@ char *findFileEntry(char *path, int *file_len) {
     char *data;
     FILE *fd;
 
+#ifdef __amigaos4__
+    path = (char*)amigaPath(path);
+#endif
+
     if((fd = fopen(path, "r")) == NULL)
         return NULL;
 
@@ -2135,21 +2207,38 @@ void freeClassLoaderData(Object *class_loader) {
     }
 }
 
+#ifdef __amigaos4__
+#include <proto/exec.h>
+
+/* ':' is the AmigaDOS volume separator as well as the path-list separator
+   everyone types, so deciding where one entry ends is not a character test --
+   see amigaIsPathListSep() in os/amiga/classpath.c. */
+#define IS_PATH_LIST_SEP(list, start, i, seen_vol) \
+            amigaIsPathListSep(list, start, i, seen_vol)
+#else
+#define IS_PATH_LIST_SEP(list, start, i, seen_vol) ((list)[i] == ':')
+#endif
+
 void parseBootClassPath() {
     char *cp, *pntr, *start;
     int i, j, len, max = 0;
+    int seen_vol = FALSE;
     struct stat info;
 
     cp = sysMalloc(strlen(bootpath)+1);
     strcpy(cp, bootpath);
+#ifdef __amigaos4__
+    DebugPrintF("[BCP] bootpath='%s'\n", bootpath);
+#endif
 
     for(i = 0, start = pntr = cp; *pntr; pntr++) {
-        if(*pntr == ':') {
+        if(IS_PATH_LIST_SEP(cp, start - cp, pntr - cp, &seen_vol)) {
             if(start != pntr) {
                 *pntr = '\0';
                 i++;
             }
             start = pntr+1;
+            seen_vol = FALSE;
         }
     }
     if(start != pntr)
@@ -2158,32 +2247,113 @@ void parseBootClassPath() {
     bootclasspath = sysMalloc(sizeof(BCPEntry)*i);
 
     for(j = 0, pntr = cp; i > 0; i--) {
+#ifdef __amigaos4__
+        while(*pntr == ':' || *pntr == ';')
+#else
         while(*pntr == ':')
+#endif
             pntr++;
 
         start = pntr;
         pntr += (len = strlen(pntr))+1;
 
-        if(stat(start, &info) == 0) {
+      {
+#ifdef __amigaos4__
+        int _sr = stat(amigaPath(start), &info);
+        DebugPrintF("[BCP] entry='%s' stat=%d\n", start, _sr);
+#else
+        int _sr = stat(start, &info);
+#endif
+        if(_sr == 0) {
             if(S_ISDIR(info.st_mode)) {
                 bootclasspath[j].zip = NULL;
                 if(len > max)
                     max = len;
             } else
-                if((bootclasspath[j].zip = processArchive(start)) == NULL)
+                if((bootclasspath[j].zip = processArchive(start)) == NULL) {
+#ifdef __amigaos4__
+                    DebugPrintF("[BCP] processArchive FAILED '%s'\n", start);
+#endif
                     continue;
+                }
             bootclasspath[j++].path = start;
         }
+      }
     }
 
     max_cp_element_len = max;
     bcp_entries = j;
 }
 
+#ifdef __amigaos4__
+/* Build the Java-facing value of the "sun.boot.class.path" property from the
+   C-level boot path.  Two things have to change on the way out:
+
+     - the separator.  path.separator is ';' on AmigaOS (':' is the volume
+       separator), and sun.misc.Launcher.getBootstrapClassPath() splits this
+       property on File.pathSeparator.  Hand it a ':'-joined list and Java reads
+       the whole thing as ONE entry whose leading "niopatch.zip:" AmigaDOS takes
+       for a missing volume -- the "Please insert volume niopatch.zip" requester,
+       after which every getBootstrapResource() fails.  (That is what used to
+       break sun.reflect.misc.MethodUtil: unable to read Trampoline.class through
+       the boot URLClassPath, loadClass fell through to the bootstrap loader,
+       which defined it with the null loader, and Trampoline's initialiser threw
+       "must not be defined by the bootstrap class loader".)
+
+     - the leading '/'.  java.io.File and sun.nio.fs only treat a path as
+       absolute when it starts with one; amigaPath() strips it again at the
+       native chokepoints.
+
+   Entries arrive already java.home-absolute (classlibDefaultBootClassPath), so
+   this only re-spells them.  Separate string: it does NOT touch the global
+   bootpath the VM's own class search uses. */
+char *amigaBootClassPathProperty(void) {
+    char *bcp = getBootClassPath();
+    char *out;
+    int n, len = 0, start, seen_vol = FALSE, i;
+
+    if(bcp == NULL)
+        return NULL;
+
+    n = strlen(bcp);
+    out = sysMalloc(n * 2 + 2);       /* worst case: a '/' added per entry */
+
+    for(start = 0, i = 0; i <= n; i++) {
+        if(i != n && !amigaIsPathListSep(bcp, start, i, &seen_vol))
+            continue;
+
+        if(i != start) {
+            if(len != 0)
+                out[len++] = ';';
+            if(bcp[start] != '/')
+                out[len++] = '/';
+            memcpy(out + len, &bcp[start], i - start);
+            len += i - start;
+        }
+
+        start = i + 1;
+        seen_vol = FALSE;
+    }
+
+    out[len] = '\0';
+    return out;
+}
+#endif
+
 void setClassPath(InitArgs *args) {
     char *env;
-    classpath = args->classpath ? args->classpath : 
+#ifdef __amigaos4__
+    /* Rewrite the -cp: ':' or ';' separated, wildcards expanded, entries made
+       launch-anchored absolute Unix paths -- see os/amiga/classpath.c.  Empty
+       when none given (on AmigaOS "." canonicalises to a volume path the
+       URLClassPath mis-handles). */
+    char *raw = args->classpath ? args->classpath :
+                 ((env = getenv("CLASSPATH")) ? env : NULL);
+    classpath = raw != NULL ? amigaClassPath(raw) : "";
+#else
+    classpath = args->classpath ? args->classpath :
                  ((env = getenv("CLASSPATH")) ? env : ".");
+#endif
 }
 
 char *getClassPath() {
diff --git a/src/classlib/gnuclasspath/natives.c b/src/classlib/gnuclasspath/natives.c
index ca95e00..f99f293 100644
--- a/src/classlib/gnuclasspath/natives.c
+++ b/src/classlib/gnuclasspath/natives.c
@@ -39,6 +39,10 @@
 #include "reflect.h"
 #include "gnuclasspath.h"
 
+#ifdef __amigaos4__
+#include <proto/exec.h>
+#endif
+
 static int pd_offset;
 
 int classlibInitialiseNatives() {
diff --git a/src/classlib/openjdk/class.c b/src/classlib/openjdk/class.c
index 3206ed0..c22e5f7 100644
--- a/src/classlib/openjdk/class.c
+++ b/src/classlib/openjdk/class.c
@@ -117,6 +117,60 @@ Object *classlibSkipReflectionLoader(Object *loader) {
     return loader;
 }
 
+#ifdef __amigaos4__
+/* Amiga runtime layout is FLAT (jars beside the VM) and JamVM's boot-classpath
+   parser splits on ':' which collides with "Volume:" -- so the default is a
+   RELATIVE flat list (no volume colons), resolved against the CWD, which the
+   standard launch sets to the install dir.  niopatch.zip FIRST: it prepends the
+   patched sun.nio.fs.DefaultFileSystemProvider needed for -classpath. */
+/* The Amiga runtime layout is FLAT -- the boot jars sit beside the VM, not in a
+   Unix <java.home>/lib tree.  Entries are java.home-ABSOLUTE and ';'-separated:
+   they used to be bare relative names resolved against the current directory,
+   which forced the VM to chdir into its own install drawer at startup, and that
+   in turn made every relative path an application handed to a native call
+   resolve in the WRONG place -- e.g. new ZipFile("Invoicex.jar") looked in JAVA:
+   instead of the drawer the user ran java from, because java.util.zip passes
+   File.getPath() (not getAbsolutePath()) straight to open().  With the boot path
+   absolute the chdir is gone and the process cwd stays where the user is.
+
+   ';' rather than ':' as the separator: parseBootClassPath() resolves ':'
+   volume-aware (amigaIsPathListSep), so ':' would work too, but the entries here
+   all carry a volume and ';' leaves nothing to infer.  This is the C-level path,
+   in plain AmigaDOS form; amigaBootClassPathProperty() derives the Java-facing
+   sun.boot.class.path from it. */
+char *classlibDefaultBootClassPath() {
+    static char *entries[] = {"niopatch.zip",
+                              "resources.jar",
+                              "rt.jar",
+                              "sunrsasign.jar",
+                              "jsse.jar",
+                              "jce.jar",
+                              "charsets.jar",
+                              "amigatoolkit.zip",
+                              "classes",
+                              NULL};
+    char *java_home = getJavaHome();
+    const char *sep;
+    char *path, *pntr;
+    int i, len = 0;
+
+    if(java_home == NULL)
+        java_home = "";
+    /* "Volume:" IS the directory -- a '/' after it means its PARENT */
+    sep = (*java_home != '\0' && java_home[strlen(java_home) - 1] != ':') ? "/" : "";
+
+    for(i = 0; entries[i] != NULL; i++)
+        len += strlen(java_home) + strlen(sep) + strlen(entries[i]) + 1;
+
+    pntr = path = sysMalloc(len + 1);
+
+    for(i = 0; entries[i] != NULL; i++)
+        pntr += sprintf(pntr, "%s%s%s%s", i != 0 ? ";" : "",
+                        java_home, sep, entries[i]);
+
+    return path;
+}
+#else
 char *classlibDefaultBootClassPath() {
     static char *entries[] = {"lib/resources.jar",
                               "lib/rt.jar",
@@ -130,6 +184,10 @@ char *classlibDefaultBootClassPath() {
     char *path, *pntr;
     int i, j, len = 0;
 
+    /* Pre-init (java -version), getJavaHome() is NULL -- avoid sprintf("%s",NULL). */
+    if(java_home == NULL)
+        return NULL;
+
     for(i = 0; entries[i] != NULL; i++)
         len += strlen(entries[i]);
 
@@ -142,19 +200,58 @@ char *classlibDefaultBootClassPath() {
         pntr += sprintf(pntr, "%s/%s:", java_home, entries[j]);
 
     sprintf(pntr, "%s/%s", java_home, entries[j]);
-    
+
     return path;
 }
+#endif
+
+#ifdef __amigaos4__
+/* "/<java.home>/<tail>": java.home is an AmigaDOS path ("SYS:Java") and the
+   leading '/' is Java's absolute marker, stripped again by amigaPath() at the
+   native chokepoints.  "Volume:" IS the directory, so no '/' follows a trailing
+   ':'.  These lists used to be relative (resolved against user.dir = the install
+   drawer); now that user.dir is the directory the user ran `java` from they must
+   be absolute.  The embedded ':' is safe: path.separator is ';' on AmigaOS. */
+char *amigaJavaHomePath(const char *tail) {
+    char *home = getJavaHome();
+    int hlen, tlen = strlen(tail);
+    char *out;
+
+    if(home == NULL)
+        home = "";
+    hlen = strlen(home);
+
+    out = sysMalloc(hlen + tlen + 3);
+    out[0] = '/';
+    memcpy(out + 1, home, hlen);
+    hlen++;
+
+    if(tlen != 0 && hlen > 1 && out[hlen - 1] != ':')
+        out[hlen++] = '/';
+    strcpy(out + hlen, tail);
+
+    return out;
+}
 
+char *classlibDefaultExtDirs() {
+    return amigaJavaHomePath("lib/ext");
+}
+#else
 char *classlibDefaultExtDirs() {
     char *java_home = getJavaHome();
-    char *ext_dirs = sysMalloc(strlen(java_home) + 
+    char *ext_dirs = sysMalloc(strlen(java_home) +
                                sizeof("/lib/ext:/usr/java/packages/lib/ext"));
 
     return strcat(strcpy(ext_dirs, java_home),
                   "/lib/ext:/usr/java/packages/lib/ext");
 }
+#endif
 
+#ifdef __amigaos4__
+char *classlibDefaultEndorsedDirs() {
+    return amigaJavaHomePath("lib/endorsed");
+}
+#else
 char *classlibDefaultEndorsedDirs() {
     char *java_home = getJavaHome();
     char *endorsed_dirs = sysMalloc(strlen(java_home) +
@@ -162,6 +259,7 @@ char *classlibDefaultEndorsedDirs() {
 
     return strcat(strcpy(endorsed_dirs, java_home), "/lib/endorsed");
 }
+#endif
 
 char *classlibExternalClassName(Class *class) {
     ClassBlock *cb = CLASS_CB(class);
diff --git a/src/classlib/openjdk/classlib-defs.h b/src/classlib/openjdk/classlib-defs.h
index 5433ff3..a8f7048 100644
--- a/src/classlib/openjdk/classlib-defs.h
+++ b/src/classlib/openjdk/classlib-defs.h
@@ -42,7 +42,20 @@
     Object *class_loader;                      \
     char pad2[3*sizeof(Object*)+1*sizeof(int)];
 #elif OPENJDK_VERSION == 8
-#define CLASSLIB_CLASS_PAD char pad[11*sizeof(Object*)+1*sizeof(int)];
+/* Temurin/late-8u backported the VM-injected java.lang.Class.classLoader
+   field (getClassLoader0() reads the FIELD; no longer a native).  Shadow it
+   in the ClassBlock padding at its Java-field offset, like the OpenJDK 9
+   support above.  Temurin 8 Class field order: cachedConstructor,
+   newInstanceCallerCache, name, classLoader, reflectionData,
+   classRedefinedCount(int), genericInfo, enumConstants,
+   enumConstantDirectory, annotationData, annotationType, classValueMap
+   (11 refs + 1 int = the original pad size).  JamVM lays the reference
+   fields out in REVERSE declaration order from the object base (verified
+   empirically: classLoader = object byte-offset 36 = ClassBlock word 7). */
+#define CLASSLIB_CLASS_PAD                     \
+    char pad1[7*sizeof(Object*)];              \
+    Object *class_loader;                      \
+    char pad2[3*sizeof(Object*)+1*sizeof(int)];
 #elif OPENJDK_VERSION == 7
 #define CLASSLIB_CLASS_PAD char pad[18*sizeof(Object*)+2*sizeof(int)];
 #else
@@ -61,15 +74,15 @@
 #define CLASSLIB_ARRAY_CLASS_EXTRA_FIELDS
 #define CLASSLIB_CLASSBLOCK_ARRAY_REFS_DO(action, cb, ...)
 #else
+/* NOTE: for OpenJDK 8 (Temurin) class_loader lives in the CLASS_PAD
+   shadow above; only the openjdk-8 build consumes this branch. */
 #define CLASSLIB_CLASS_EXTRA_FIELDS  \
    Object *protection_domain;        \
-   Object *class_loader;             \
    Object *host_class;               \
    Object *signers;
 
 #define CLASSLIB_CLASSBLOCK_REFS_DO(action, cb, ...) \
     action(cb, protection_domain, ## __VA_ARGS__);   \
-    action(cb, class_loader, ## __VA_ARGS__);        \
     action(cb, host_class, ## __VA_ARGS__);          \
     action(cb, signers, ## __VA_ARGS__)
 
diff --git a/src/classlib/openjdk/classlib.h b/src/classlib/openjdk/classlib.h
index 054afe4..6d0f58c 100644
--- a/src/classlib/openjdk/classlib.h
+++ b/src/classlib/openjdk/classlib.h
@@ -35,7 +35,12 @@ extern Object *classlibMarkThreadTerminated(Object *jThread);
 
 #define classlibThreadIdName() SYMBOL(tid)
 #define classlibAddThreadName() SYMBOL(add)
+#if OPENJDK_VERSION >= 8
+/* OpenJDK 8 changed java.lang.Thread.name from char[] to String. */
+#define classlibThreadNameType() SYMBOL(sig_java_lang_String)
+#else
 #define classlibThreadNameType() SYMBOL(array_C)
+#endif
 #define classlibRemoveThreadName() SYMBOL(removeThreadName)
 #define classlibExceptionHandlerName() SYMBOL(uncaughtExceptionHandler)
 
@@ -46,6 +51,7 @@ extern void classlibThreadName2Buff(Object *jThread, char *buffer,
 
 extern int classlibInitialiseSignals();
 extern void classlibSignalThread(Thread *self);
+extern void classlibSignalThreadExit(void);
 
 /* Class */
 
@@ -109,8 +115,28 @@ extern Object *classlibCheckIfOnLoad(Frame *last);
 
 /* Properties */
 
+#ifdef __amigaos4__
+/* sun.nio.fs.chdirAllowed=true makes UnixFileSystem's constructor skip the
+   UnixNativeDispatcher.getcwd() native, so the (niopatch.zip-supplied) default
+   NIO.2 provider constructs without libnio -- required for URLClassLoader /
+   -classpath.  A command-line -D still overrides (added after defaults). */
+#define classlibAddDefaultProperties(properties) \
+    do { \
+        setProperty(properties, "sun.nio.fs.chdirAllowed", "true"); \
+        setProperty(properties, "awt.toolkit", \
+                    "sun.awt.amiga.AmigaToolkit"); \
+        setProperty(properties, "java.awt.graphicsenv", \
+                    "sun.awt.amiga.AmigaGraphicsEnvironment"); \
+        setProperty(properties, "sun.java2d.renderer", \
+                    "sun.java2d.marlin.MarlinRenderingEngine"); \
+        setProperty(properties, "awt.useSystemAAFontSettings", "on"); \
+        setProperty(properties, "swing.aatext", "true"); \
+        setProperty(properties, "sun.java2d.pmoffscreen", "false"); \
+    } while(0)
+#else
 #define classlibAddDefaultProperties(properties) \
     /* NOTHING TO DO */
+#endif
 
 extern char *classlibDefaultJavaHome();
 
diff --git a/src/classlib/openjdk/dll.c b/src/classlib/openjdk/dll.c
index 1d9cc9c..c05537e 100644
--- a/src/classlib/openjdk/dll.c
+++ b/src/classlib/openjdk/dll.c
@@ -41,12 +41,35 @@ int classlibInitialiseDll() {
     return TRUE;
 }
 
+#ifdef __amigaos4__
+/* The native .so files live beside the VM (flat layout), so the boot library
+   path is just java.home, absolute: "/SYS:Java".  It used to be "." -- resolved
+   by java.lang.ClassLoader against user.dir, which had to be forced to the
+   install drawer for it to work.  user.dir is now the directory the user ran
+   `java` from (so an application's own relative paths behave), hence the boot
+   library path has to stand on its own.  The embedded volume ':' is safe:
+   path.separator is ';' on AmigaOS, and amigaPath() strips the leading '/'
+   before dlopen. */
+char *classlibDefaultBootDllPath() {
+    extern char *amigaJavaHomePath(const char *tail);
+
+    return amigaJavaHomePath("");
+}
+#else
 char *classlibDefaultBootDllPath() {
     char *java_home = getJavaHome();
-    char *dll_path = sysMalloc(strlen(java_home) + sizeof("/lib/"OS_ARCH));
+    char *dll_path;
+
+    /* java.home is only set during initVM; showVersionAndCopyright() (java
+       -version) calls this pre-init, when getJavaHome() returns NULL.  Return
+       NULL rather than strlen(NULL)-crashing -- the caller handles it. */
+    if(java_home == NULL)
+        return NULL;
 
+    dll_path = sysMalloc(strlen(java_home) + sizeof("/lib/"OS_ARCH));
     return strcat(strcpy(dll_path, java_home), "/lib/"OS_ARCH);
 }
+#endif
 
 void *classlibLookupLoadedDlls(char *name, Object *loader) {
     Object *name_string;
diff --git a/src/classlib/openjdk/jvm.c b/src/classlib/openjdk/jvm.c
index 971ac75..63a5373 100644
--- a/src/classlib/openjdk/jvm.c
+++ b/src/classlib/openjdk/jvm.c
@@ -1525,6 +1525,75 @@ jboolean JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2) {
 }
 
 
+/* JVM_CopySwapMemory -- backs java.nio.Bits.copySwapMemory0, which the
+   ByteBuffer bulk get/put of short/int/long arrays uses whenever the buffer's
+   byte order differs from the platform's.  JamVM never defined it, so libjava.so
+   carried an unresolved reference; the AmigaOS ELF loader binds lazily, which
+   means that did not break the build or startup -- it would have killed the
+   process the first time such a buffer was used.
+
+   Object+offset pairs are resolved exactly as Unsafe does here (base pointer
+   plus raw byte offset, base NULL for an off-heap address) -- see
+   copyMemoryOpenJDK7() in natives.c.  Elements are staged through a local buffer
+   so an in-place swap (src == dst) is safe, and overlapping regions are walked
+   in the direction that memmove would. */
+
+static void swapElement(char *dst, const char *src, int size) {
+    char buff[8];
+    int i;
+
+    for(i = 0; i < size; i++)
+        buff[i] = src[size - 1 - i];
+
+    memcpy(dst, buff, size);
+}
+
+void JVM_CopySwapMemory(JNIEnv *env, jobject srcObj, jlong srcOffset,
+                        jobject dstObj, jlong dstOffset, jlong size,
+                        jlong elemSize) {
+
+    char *src = (char *)srcObj + srcOffset;
+    char *dst = (char *)dstObj + dstOffset;
+    jlong i;
+
+    TRACE("JVM_CopySwapMemory(size=%lld, elemSize=%lld)", size, elemSize);
+
+    if(elemSize != 2 && elemSize != 4 && elemSize != 8) {
+        signalException(java_lang_IllegalArgumentException,
+                        "wrong element size");
+        return;
+    }
+
+    if(size < 0 || (size % elemSize) != 0) {
+        signalException(java_lang_IllegalArgumentException,
+                        "size must be a multiple of the element size");
+        return;
+    }
+
+    if(dst > src && dst < src + size)
+        for(i = size - elemSize; i >= 0; i -= elemSize)
+            swapElement(dst + i, src + i, (int)elemSize);
+    else
+        for(i = 0; i < size; i += elemSize)
+            swapElement(dst + i, src + i, (int)elemSize);
+}
+
+
+/* JVM_GetTemporaryDirectory -- sun.misc.VMSupport.getVMTemporaryDirectory().
+   HotSpot returns the OS temp directory, not the java.io.tmpdir property; keep
+   the two in step (see addDefaultProperties() in properties.c). */
+
+jstring JVM_GetTemporaryDirectory(JNIEnv *env) {
+    TRACE("JVM_GetTemporaryDirectory(env=%p)", env);
+
+#ifdef __amigaos4__
+    return (jstring)createString("/T:");
+#else
+    return (jstring)createString("/tmp");
+#endif
+}
+
+
 /* JVM_Open */
 
 #define JVM_EEXIST       -100
@@ -1533,6 +1602,12 @@ jboolean JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2) {
 jint JVM_Open(const char *fname, jint flags, jint mode) {
     int result;
 
+#ifdef __amigaos4__
+    /* ZipFile/JarFile and friends open through JVM_Open, so this is the central
+       Java-form -> AmigaDOS-form conversion for the VM's own file access. */
+    fname = amigaPath(fname);
+#endif
+
     TRACE("JVM_Open(fname=%s, flags=%d, mode=%d)", fname, flags, mode);
 
     /* O_DELETE is a special classlib flag which indicates that
@@ -3034,7 +3109,28 @@ jint JVM_FindSignal(const char *name) {
 
     TRACE("JVM_FindSignal(name=%s)", name);
 
-    for(i = 0; signals[i].name != NULL && strcmp(signals[i].name, name); i++); 
+    for(i = 0; signals[i].name != NULL && strcmp(signals[i].name, name); i++);
 
     return signals[i].number;
 }
+
+/* Class-Data-Sharing (CDS) shared class-path lookup cache.  JamVM has no CDS, so
+   report "no cache": getLookupCacheURLs returning NULL makes sun.misc.URLClassPath
+   disable the cache cleanly (URLClassPath.java:322->331).  These JVM_* were missing
+   from the classlib -- libjava.so's sun/misc/URLClassPath.c calls them, so the
+   unresolved symbols crashed sun.misc.Launcher init on AmigaOS. */
+jobjectArray JVM_GetResourceLookupCacheURLs(JNIEnv *env, jobject loader) {
+    TRACE("JVM_GetResourceLookupCacheURLs(loader=%p)", loader);
+    return NULL;
+}
+
+jintArray JVM_GetResourceLookupCache(JNIEnv *env, jobject loader,
+                                     const char *resource_name) {
+    TRACE("JVM_GetResourceLookupCache(loader=%p, name=%s)", loader, resource_name);
+    return NULL;
+}
+
+jboolean JVM_KnownToNotExist(JNIEnv *env, jobject loader, const char *classname) {
+    TRACE("JVM_KnownToNotExist(loader=%p, name=%s)", loader, classname);
+    return JNI_FALSE;
+}
diff --git a/src/classlib/openjdk/management.c b/src/classlib/openjdk/management.c
index 822f41e..b24c039 100644
--- a/src/classlib/openjdk/management.c
+++ b/src/classlib/openjdk/management.c
@@ -54,9 +54,50 @@ jobject jmm_GetInputArguments(JNIEnv *env) {
     return NULL;
 }
 
+/*
+ * The arguments the VM was started with -- what RuntimeMXBean.getInputArguments()
+ * reports.  sun.management.VMManagementImpl.getVmArguments0() calls straight
+ * through to here.
+ *
+ * This used to be UNIMPLEMENTED, which returned NULL after printing its own name
+ * on stdout.  Neither half was harmless: RuntimeImpl wraps the result in a List
+ * without checking, so a caller got a null it could not tell from "started with
+ * no arguments", and the trace landed in the middle of the application's own
+ * output.  It only became reachable when libmanagement.so started being built --
+ * before that, getRuntimeMXBean() died earlier, with UnsatisfiedLinkError.
+ *
+ * An EMPTY array when nothing was recorded, never NULL: a VM created through
+ * JNI_CreateJavaVM does not go through parseCommandLine, and "no arguments" is
+ * the truthful answer there rather than a failure.
+ */
 jobjectArray jmm_GetInputArgumentArray(JNIEnv *env) {
-    UNIMPLEMENTED("jmm_GetInputArgumentArray");
-    return NULL;
+    extern char **vm_input_args;
+    extern int vm_input_args_count;
+
+    Class *array_class = findArrayClass(SYMBOL(array_java_lang_String));
+    int count = vm_input_args == NULL ? 0 : vm_input_args_count;
+    Object *array;
+    int i;
+
+    if(array_class == NULL)
+        return NULL;
+
+    array = allocArray(array_class, count, sizeof(Object*));
+    if(array == NULL)
+        return NULL;
+
+    for(i = 0; i < count; i++) {
+        Object *str = createString(vm_input_args[i]);
+
+        if(str == NULL)
+            return NULL;
+
+        /* The body is addressed through `array` on each pass rather than cached
+           in a local, since createString allocates in between. */
+        ARRAY_DATA(array, Object*)[i] = str;
+    }
+
+    return array;
 }
 
 jobjectArray jmm_GetMemoryPools(JNIEnv *env, jobject obj) {
diff --git a/src/classlib/openjdk/properties.c b/src/classlib/openjdk/properties.c
index 2391e61..fc8877e 100644
--- a/src/classlib/openjdk/properties.c
+++ b/src/classlib/openjdk/properties.c
@@ -21,6 +21,44 @@
 #include <string.h>
 #include "jam.h"
 
+#ifdef __amigaos4__
+/* On AmigaOS the runtime layout is FLAT -- libjvm.so, libjava.so and the boot
+   jars all live in one directory (e.g. SYS:Test/), not the Unix
+   <java.home>/lib/<arch>/<vmtype>/libjvm.so tree.  So java.home is simply the
+   directory containing libjvm.so (strip the trailing filename after the last
+   '/' or ':' volume separator).  Boot class/library paths are supplied
+   explicitly via -Xbootclasspath and -Dsun.boot.library.path, so they don't
+   depend on the (Unix-shaped) java.home/lib/... derivation. */
+char *classlibDefaultJavaHome() {
+    /* java.home = the VM's program directory (PROGDIR:, e.g. "SYS:Java"), where
+       libjvm.so + the boot jars + lib/ all live (flat layout).  Resolve it from
+       PROGDIR: so it is independent of the current dir (the launcher no longer
+       CDs there).  Fall back to deriving it from libjvm.so's own path. */
+    extern char *amigaProgramDir(void);
+    char *pd = amigaProgramDir();
+    char *path, *pntr, *home;
+
+    if(pd != NULL)
+        return strcpy(sysMalloc(strlen(pd) + 1), pd);
+
+    path = nativeJVMPath();
+    if(path == NULL)
+        return NULL;
+
+    pntr = path + strlen(path);
+    while(pntr > path && pntr[-1] != '/' && pntr[-1] != ':')
+        pntr--;
+    if(pntr > path && pntr[-1] == '/')   /* keep volume ':' but drop dir '/' */
+        pntr--;
+
+    home = sysMalloc(pntr - path + 1);
+    memcpy(home, path, pntr - path);
+    home[pntr - path] = '\0';
+    sysFree(path);
+
+    return home;
+}
+#else
 char *classlibDefaultJavaHome() {
     char *path = nativeJVMPath();
     char *pntr = path + strlen(path);
@@ -42,4 +80,5 @@ char *classlibDefaultJavaHome() {
 
     return home;
 }
+#endif
 
diff --git a/src/classlib/openjdk/thread.c b/src/classlib/openjdk/thread.c
index 71fc8aa..0ee57ac 100644
--- a/src/classlib/openjdk/thread.c
+++ b/src/classlib/openjdk/thread.c
@@ -160,6 +160,13 @@ void classlibSetThreadState(Thread *thread, int state) {
 
 void classlibThreadName2Buff(Object *jThread, char *buffer, int buff_len) {
     Object *name = INST_DATA(jThread, Object*, name_offset);
+#if OPENJDK_VERSION >= 8
+    /* OpenJDK 8: Thread.name is a String, not a char[]. */
+    if(name == NULL)
+        buffer[0] = '\0';
+    else
+        String2Buff(name, buffer, buff_len);
+#else
     unsigned short *unicode = ARRAY_DATA(name, unsigned short);
     int i, len = ARRAY_LEN(name) < buff_len ? ARRAY_LEN(name)
                                             : buff_len - 1;
@@ -168,6 +175,7 @@ void classlibThreadName2Buff(Object *jThread, char *buffer, int buff_len) {
         buffer[i] = unicode[i];
 
     buffer[len] = '\0';
+#endif
 }
 
 static sem_t signal_sem;
@@ -179,6 +187,20 @@ void signalHandler(int sig) {
     sem_post(&signal_sem);
 }
 
+/*
+ * Set by classlibSignalThreadExit() so the loop below can return instead of
+ * waiting on the semaphore for a signal that will never come.  Without it the
+ * thread outlives every other one and clib4's exit(), which waits for all
+ * pthread children, wedges on it -- which is why this thread used to be left
+ * uncreated on AmigaOS altogether.
+ */
+static volatile sig_atomic_t signal_thread_exit = FALSE;
+
+void classlibSignalThreadExit(void) {
+    signal_thread_exit = TRUE;
+    sem_post(&signal_sem);
+}
+
 void classlibSignalThread(Thread *self) {
     int sig;
 
@@ -187,6 +209,13 @@ void classlibSignalThread(Thread *self) {
         do {
             sem_wait(&signal_sem);
 
+            if(signal_thread_exit) {
+                /* Balance the disableSuspend0 above: shell() is about to tear
+                   this thread down and must not find it suspend-disabled. */
+                enableSuspend(self);
+                return;
+            }
+
             for(sig = 0; sig < NSIG && !pending_signals[sig]; sig++);
         } while(sig == NSIG);
 
diff --git a/src/classlib/openjdk/trace.h b/src/classlib/openjdk/trace.h
index ce3041b..739e599 100644
--- a/src/classlib/openjdk/trace.h
+++ b/src/classlib/openjdk/trace.h
@@ -21,19 +21,39 @@
 #if 1
 #define TRACE(fmt, ...)
 #else
-#define TRACE(fmt, ...) { printf(fmt "\n", ## __VA_ARGS__); fflush(stdout); }
+/* jam_printf, not printf -- see the note below.  This branch is off, but
+   turning it on should not start writing into the application's output. */
+#define TRACE(fmt, ...) jam_printf(fmt "\n", ## __VA_ARGS__)
 #endif
 
+/*
+ * These four are developer traces, and the #if 0 above means they are ON in
+ * every build, including released ones.  They used to write with printf(), i.e.
+ * straight into the APPLICATION's stdout -- so a program that touched an
+ * unimplemented corner of the management interface got a bare
+ *
+ *     jmm_GetInputArgumentArray
+ *
+ * in the middle of its own output, attributable to nothing.  That is a real
+ * fault in a runtime, not merely untidy: an application whose output is parsed
+ * by something else gets corrupted by a line it never wrote.
+ *
+ * jam_printf instead, which is where every other VM diagnostic already goes --
+ * through args->vfprintf, which on AmigaOS is the serial debug log.  The traces
+ * keep their whole value to whoever is debugging the VM, and leave the
+ * application's stdout alone.  Left enabled deliberately: they are how an
+ * unimplemented jmm call gets noticed at all, and the reason this one was.
+ */
 #if 0
 #define TBD(fmt, ...)
 #define UNUSED(fmt, ...)
 #define DEPRECATED(fmt, ...)
 #define UNIMPLEMENTED(fmt, ...)
 #else
-#define TBD(fmt, ...) { printf(fmt "\n", ## __VA_ARGS__); fflush(stdout); }
-#define UNUSED(fmt, ...) { printf(fmt "\n", ## __VA_ARGS__); fflush(stdout); }
-#define DEPRECATED(fmt, ...) { printf(fmt "\n", ## __VA_ARGS__); fflush(stdout); }
-#define UNIMPLEMENTED(fmt, ...) { printf(fmt "\n", ## __VA_ARGS__); fflush(stdout); }
+#define TBD(fmt, ...) jam_printf(fmt "\n", ## __VA_ARGS__)
+#define UNUSED(fmt, ...) jam_printf(fmt "\n", ## __VA_ARGS__)
+#define DEPRECATED(fmt, ...) jam_printf(fmt "\n", ## __VA_ARGS__)
+#define UNIMPLEMENTED(fmt, ...) jam_printf(fmt "\n", ## __VA_ARGS__)
 #endif
 
 #define IGNORED(fmt, ...)
diff --git a/src/config.h b/src/config.h
index dd2b875..a001b80 100644
--- a/src/config.h
+++ b/src/config.h
@@ -27,8 +27,7 @@
 /* Define to 1 if using `alloca.c'. */
 /* #undef C_ALLOCA */
 
-/* interpreter direct */
-/* #undef DIRECT */
+/* interpreter direct -- see the engine block near THREADED below */
 /* Define to 1 if you have `alloca', as a function or macro. */
 //#define HAVE_ALLOCA 1
 
@@ -115,8 +114,7 @@
 /* Define to 1 if you have the <unistd.h> header file. */
 #define HAVE_UNISTD_H 1
 
-/* interpreter inlining */
-/* #undef INLINING */
+/* interpreter inlining -- see the engine block near THREADED below */
 
 /* Installation directory (prefix) */
 #define INSTALL_DIR "JAmiga:jvm"
@@ -140,12 +138,12 @@
 /* Define to the version of this package. */
 #define PACKAGE_VERSION ""
 
-/* interpreter uses prefetching */
-/* #undef PREFETCH */
+/* interpreter uses prefetching -- see the engine block near THREADED below */
 
-/* compute relocatability at runtime */
-#undef RUNTIME_RELOC_CHECKS
-/*#define RUNTIME_RELOC_CHECKS */
+/* Compute the relocatability of each handler at runtime rather than at build
+   time.  Upstream defaults this to on when cross-compiling, which we always
+   are: the build machine cannot run the ppc handlers to measure them. */
+#define RUNTIME_RELOC_CHECKS 1
 
 /* If using the C implementation of alloca, define if you know the
    direction of stack growth for your system; otherwise it will be
@@ -158,17 +156,59 @@
 /* Define to 1 if you have the ANSI C header files. */
 #define STDC_HEADERS 1
 
-/* interpreter threaded */
-#undef THREADED
-/* comment these, and we're back to normal (change makefiles also*/
-/*
-*/
-
-// Something's wrong wioht the INLINING
-//#define INLINING
-#undef INLINING
-/*#define THREADED*/
-#undef DIRECT
+/* Interpreter engine selection -- JAMVM_ENGINE_LEVEL, set by tools/build-jamvm-*.sh
+ * from the JAMVM_ENGINE environment variable so the level can be changed without
+ * editing this file:
+ *
+ *   0 switch    plain switch dispatch.  What this port used to build, and the
+ *               slowest thing JamVM can do.
+ *   1 threaded  computed-goto dispatch + stack caching (top of the operand
+ *               stack kept in registers)
+ *   2 direct    + bytecode rewritten to handler addresses on first execution,
+ *               so dispatch costs no decode, + prefetching (which upstream
+ *               enables only on powerpc)
+ *   3 inline    + the code-copying engine: it copies the handlers' own machine
+ *               code into a per-block buffer, so dispatch disappears entirely
+ *               inside a basic block.  This is as close to a JIT as JamVM has.
+ *               PowerPC supports it: arch/powerpc.h implements the two things
+ *               it needs, FLUSH_CACHE (icache sync after copying code) and
+ *               GEN_REL_JMP (the relative branch it patches in).
+ *
+ * Upstream enables level 3 by default for powerpc.  We default to 2, because
+ * level 3 has been observed on AmigaOS 4 to compute WRONG ANSWERS -- see
+ * docs/ppc32-performance.md.  It is intermittent (inlining is profile-driven,
+ * so a block is only copied once it has run often enough) and it corrupts
+ * floating point rather than crashing: ConcurrentHashMap's constructor computed
+ * a capacity of 2^30 out of `(long)(1.0 + initialCapacity / loadFactor)` and
+ * every run died differently.  Silent wrong arithmetic is not something to ship
+ * as a default.
+ *
+ * Level 2 keeps everything except the code copying, which is where the risk is.
+ * To experiment with 3:
+ *
+ *     JAMVM_ENGINE=3 make -f Makefile.local vm
+ *
+ * Level 3 also needs -fno-reorder-blocks on the interpreter translation units
+ * (the build scripts add it) so gcc keeps each handler body contiguous and does
+ * not splice shared tails between them.
+ */
+#ifndef JAMVM_ENGINE_LEVEL
+#define JAMVM_ENGINE_LEVEL 2
+#endif
+
+#if JAMVM_ENGINE_LEVEL >= 1
+#define THREADED 1
+#define USE_CACHE 1
+#endif
+
+#if JAMVM_ENGINE_LEVEL >= 2
+#define DIRECT 1
+#define PREFETCH 1
+#endif
+
+#if JAMVM_ENGINE_LEVEL >= 3
+#define INLINING 1
+#endif
 
 /* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
 #define TIME_WITH_SYS_TIME 1
@@ -186,7 +226,12 @@
 #undef TRACEDLL
 
 /* defined if object finalisation tracing enabled for debugging */
-#define TRACEFNLZ 1
+/* Left ON by accident, unlike every other trace here.  ADD_FINALIZED_OBJECT
+   fires on each allocation of an object whose class has finalize(), which on
+   AmigaOS meant a serial write per java.awt.Graphics, per ColorModel and per
+   URLConnection -- a line of debug for every single draw, and DebugPrintF to
+   the serial port is not cheap.  See the call site in alloc.c. */
+//#define TRACEFNLZ 1
 
 /* defined if gc tracing enabled for debugging */
 //#define TRACEGC 0
@@ -200,8 +245,7 @@
 /* defined if thread creation tracing enabled for debugging */
 #undef TRACETHREAD
 
-/* interpreter uses caching */
-/* #undef USE_CACHE */
+/* interpreter uses caching -- see the engine block near THREADED below */
 
 /* use FFI */
 /* #undef USE_FFI */
diff --git a/src/dll.c b/src/dll.c
index 3604fcf..654c63c 100644
--- a/src/dll.c
+++ b/src/dll.c
@@ -224,6 +224,8 @@ uintptr_t *resolveNativeWrapper(Class *class, MethodBlock *mb,
     NativeMethod method = resolveNativeMethod(mb);
 
     if(method == NULL) {
+        jam_fprintf(stderr, "[UNSATISFIED] %s.%s %s\n",
+                    CLASS_CB(mb->class)->name, mb->name, mb->type);
         signalException(java_lang_UnsatisfiedLinkError, mb->name);
         return ostack;
     }
diff --git a/src/excep.c b/src/excep.c
index bf88d59..c663143 100644
--- a/src/excep.c
+++ b/src/excep.c
@@ -151,10 +151,46 @@ Object *exceptionEnumToException(int excep_enum) {
     return exceptions[excep_enum];
 }
 
+#ifdef __amigaos4__
+#include <proto/exec.h>
+#endif
+
 void printException() {
     ExecEnv *ee = getExecEnv();
     Object *excep = ee->exception;
 
+#ifdef __amigaos4__
+    /* clib4 bring-up: Java printStackTrace fails when System.err isn't set up,
+       hiding the real cause. Dump the exception chain (class names) to serial. */
+    if(excep != NULL) {
+        Object *e = excep;
+        int d;
+        for(d = 0; e != NULL && d < 8; d++) {
+            FieldBlock *fb;
+            Object *c;
+            DebugPrintF("[EXC] %d: %s\n", d, CLASS_CB(e->class)->name);
+            {
+                FieldBlock *mfb = findField(e->class, newUtf8("detailMessage"),
+                                            newUtf8("Ljava/lang/String;"));
+                Object *msg = mfb ? INST_DATA(e, Object*, mfb->u.offset) : NULL;
+                if(msg != NULL) {
+                    char *m = String2Cstr(msg);
+                    DebugPrintF("[EXC]    msg: %s\n", m);
+                    sysFree(m);
+                }
+            }
+            fb = findField(e->class, newUtf8("cause"),
+                           newUtf8("Ljava/lang/Throwable;"));
+            if(fb == NULL)
+                break;
+            c = INST_DATA(e, Object*, fb->u.offset);
+            if(c == NULL || c == e)
+                break;
+            e = c;
+        }
+    }
+#endif
+
     if(excep != NULL) {
         MethodBlock *mb = lookupMethod(excep->class, SYMBOL(printStackTrace),
                                                      SYMBOL(___V));
diff --git a/src/init.c b/src/init.c
index 32539cf..205a6a8 100644
--- a/src/init.c
+++ b/src/init.c
@@ -26,7 +26,20 @@
 
 #include "jam.h"
 
-static int VM_initing = TRUE;
+/*
+ * The VM's own command-line arguments, for RuntimeMXBean.getInputArguments().
+ *
+ * Defined here rather than in jam.c because jam.c is linked into the
+ * jamvm-openjdk EXECUTABLE while the reader (jmm_GetInputArgumentArray) is in
+ * libjvm.so: a shared library resolving a symbol out of the program that loaded
+ * it is backwards, and works only where the loader puts the executable's
+ * symbols in the global scope.  parseCommandLine fills these in.
+ */
+char **vm_input_args = NULL;
+int vm_input_args_count = 0;
+
+/* Not static: os/amiga/scanprocess.c references VM_initing via `extern int`. */
+int VM_initing = TRUE;
 extern void initialisePlatform();
 
 unsigned long clampHeapLimit(long long limit) {
@@ -34,6 +47,208 @@ unsigned long clampHeapLimit(long long limit) {
     return (unsigned long)MIN(clamp, MAX_MAX_HEAP);
 }
 
+/* clib4 bring-up: route all JamVM messages (args->vfprintf) to the serial
+   debug log, since AmigaDOS stderr isn't easily captured. Remove once stable. */
+#ifdef __amigaos4__
+#include <proto/exec.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <pthread.h>
+static int amiga_vfprintf(FILE *stream, const char *fmt, va_list ap) {
+    char buf[1024];
+    int n = vsnprintf(buf, sizeof(buf), fmt, ap);
+    (void)stream;
+    DebugPrintF("%s", buf);
+    return n;
+}
+
+/* clib4 exit() HANGS during VM shutdown: it waits for all threads to terminate
+   before tearing down the shared clib4 context, but JamVM's daemon threads loop
+   forever and can't be async-stopped (clib4 pthread_kill only Signal()s a raw
+   Exec bit, never running the sigaction handler).  Cooperative fix: tell the
+   finalizer/reference-handler threads to exit (terminateVMThreads notifies their
+   condvars; vm_exiting makes the loops return), and release the signal-handler
+   thread from its semaphore (classlibSignalThreadExit).  That thread used to be
+   skipped altogether here for want of an exit path, which is what left Ctrl-C
+   with nowhere to go.  With the daemons exiting, clib4 exit() can complete
+   cleanly.  Output already went out via raw write() syscalls. */
+extern void terminateVMThreads(void);
+extern void exitWakeAllThreads(void);
+extern void exitDumpRemainingThreads(void);
+extern void classlibSignalThreadExit(void);
+extern void exitDetachAndDieSelf(void);
+extern int getThreadsCount(void);
+
+static void (*amiga_awt_cleanup_fn)(void) = NULL;
+void registerAmigaAwtCleanup(void (*fn)(void)) {
+    amiga_awt_cleanup_fn = fn;
+}
+
+/* Parked here by amiga_exit() when the exit was started by a thread other than
+   the main one, and completed by amigaMainThreadExitIfRequested() below. */
+static volatile int amiga_main_exit_requested = FALSE;
+static volatile int amiga_main_exit_status = 0;
+
+static void amiga_exit(int status);
+
+/*
+ * Called from threadPollSuspend(), i.e. at a bytecode dispatch point, so the
+ * main thread is at a safe point rather than somewhere arbitrary.
+ *
+ * Only the main task may take an AmigaOS 4 process down, so a non-main thread
+ * that reaches exitVM (Ctrl-C arrives on the Signal Handler thread, runs the
+ * shutdown hooks, then calls Shutdown.halt) can only ask.  This is where the
+ * main thread answers.
+ *
+ * It runs the ORDINARY main-thread shutdown -- amiga_exit(), which waits for
+ * every other thread to leave and then closes the AWT windows -- and only then
+ * exits.  It must not shortcut to realAmigaExit(): that one Signal()s each
+ * surviving child with SIGKILL and then loops on Wait(SIGBREAKF_CTRL_F) until
+ * they are gone, and a clib4 pthread does not die from a raw Exec signal.  Used
+ * here it did not take the process down, it parked the main thread in that loop
+ * forever -- Ctrl-C stopped the transfer and never returned to the prompt.
+ *
+ * exit() rather than a return: we are many Java frames below main(), so there
+ * is nothing to unwind to.  Legal because this IS the main task and, by the
+ * time amiga_exit() has returned, it is the only one left.
+ */
+void amigaMainThreadExitIfRequested(void) {
+    if(!amiga_main_exit_requested)
+        return;
+
+    /* Once: a second poll must not re-enter the shutdown. */
+    amiga_main_exit_requested = FALSE;
+
+    DebugPrintF("[EXIT] main thread taking the process down (status=%d)\n",
+                amiga_main_exit_status);
+
+    /* Takes the main_exit path: drains every other thread, then AWT cleanup. */
+    amiga_exit(amiga_main_exit_status);
+
+    DebugPrintF("[EXIT] main thread: exit(%d)\n", amiga_main_exit_status);
+    exit(amiga_main_exit_status);
+}
+
+static void amiga_exit(int status) {
+    int tries = 0;
+    int main_exit = isMainVMThread();
+    int target_threads = main_exit ? 1 : 2;
+
+    DebugPrintF("[EXIT] amiga_exit(%d): terminating VM threads\n", status);
+
+    /* Publish the request BEFORE waking anyone: exitWakeAllThreads() below
+       opens the dispatch-poll gate, and the main thread may reach its next poll
+       immediately.  If the flag were set later it would simply be picked up on
+       a subsequent poll, but there is no reason to leave that to chance. */
+    if(!main_exit) {
+        amiga_main_exit_status = status;
+        amiga_main_exit_requested = TRUE;
+        MBARRIER();
+
+        /* Hand over and get out of the way.  Draining here would be the wrong
+           thread doing it -- main is the one that must see the count reach 1
+           before it exits -- and this thread is itself part of what main is
+           waiting for.  So: tell everyone to go, then leave properly.
+           exitDetachAndDieSelf() unlinks us and drops threads_count before
+           pthread_exit(); a bare pthread_exit() leaves the entry linked and
+           counted, and main would then wait for a thread that no longer runs. */
+        terminateVMThreads();
+        classlibSignalThreadExit();
+        exitWakeAllThreads();
+
+        DebugPrintF("[EXIT] amiga_exit: non-main thread leaving; main will "
+                    "drain and exit (threads=%d)\n", getThreadsCount());
+        exitDetachAndDieSelf();
+        return;                 /* not reached */
+    }
+
+    terminateVMThreads();
+
+    /* The Signal Handler thread parks on a semaphore, not on Object.wait, so
+       terminateVMThreads/exitWakeAllThreads below cannot reach it.  Release it
+       explicitly or the drain loop spins out its 300 tries and clib4's exit()
+       then waits forever for the pthread. */
+    classlibSignalThreadExit();
+
+    /* Wake every remaining Java thread (EDT, AWT pump, Disposer, ...) out of
+       Object.wait/sleep; they self-terminate at the next dispatch poll
+       (threadPollSuspend).  clib4 exit() waits for ALL pthread children, so
+       drain the count (bounded) before exiting or the process wedges with
+       "Parent suspended, waiting for child to exit". */
+    DebugPrintF("[EXIT] amiga_exit: wait target=%d current=%d main_exit=%d\n",
+                target_threads, getThreadsCount(), main_exit);
+    exitWakeAllThreads();
+    while(getThreadsCount() > target_threads && tries++ < 300) {
+        if(tries == 1 || (tries % 10) == 0) {
+            DebugPrintF("[EXIT] wait loop try=%d threads=%d target=%d\n",
+                        tries, getThreadsCount(), target_threads);
+        }
+        /* a woken thread can re-enter Object.wait before its next dispatch
+           poll -- re-interrupt periodically until everyone is gone */
+        if(tries % 50 == 0) {
+            DebugPrintF("[EXIT] wait loop: forcing wake-all + thread dump\n");
+            exitWakeAllThreads();
+            exitDumpRemainingThreads();
+        }
+        usleep(10000);
+    }
+
+    DebugPrintF("[EXIT] wait loop done tries=%d threads=%d target=%d\n",
+                tries, getThreadsCount(), target_threads);
+
+    DebugPrintF("[EXIT] amiga_exit: %s (threads left=%d)\n",
+                "calling exit()", getThreadsCount());
+    if(getThreadsCount() > target_threads)
+        exitDumpRemainingThreads();
+
+    /*
+     * How many descriptors are still open, reported because it is the number
+     * that separates two very different complaints.
+     *
+     * AmigaOS does not reclaim DOS locks from an exiting process the way a Unix
+     * kernel does -- whatever is still open stays locked, and the file cannot be
+     * deleted or replaced afterwards, from any program.  Applications have hit
+     * this as ".tmp files that survive Java" and as "Device busy" on the NEXT
+     * run, which look like path bugs and are not.
+     *
+     * Counting is not fixing: closing them here, with application threads still
+     * running (the dump above says how many), would pull descriptors out from
+     * under code still using them.  But a count at the moment of exit says
+     * whether anything was left at all, which is what tells a leak in the
+     * runtime apart from an application that never closed its own files.
+     */
+    {
+        long max = sysconf(_SC_OPEN_MAX);
+        int open_count = 0;
+        int fd;
+
+        if(max < 0 || max > 4096)
+            max = 4096;
+
+        for(fd = 0; fd < (int)max; fd++)
+            if(fcntl(fd, F_GETFD) != -1)
+                open_count++;
+
+        DebugPrintF("[EXIT] descriptors still open: %d "
+                    "(3 = stdin/stdout/stderr, i.e. none leaked)\n", open_count);
+    }
+
+    /* Close any Intuition windows before returning to main().  The atexit
+       handler registered by libamigaawt is bypassed if anything later calls
+       _Exit(), so invoke its cleanup directly if the library registered one. */
+    if(amiga_awt_cleanup_fn != NULL) {
+        DebugPrintF("[EXIT] amiga_exit: closing AWT windows\n");
+        amiga_awt_cleanup_fn();
+    }
+
+    /* Return to the caller (exitVM -> main).  The main thread will then return
+       from main() and let the C runtime perform a clean process exit.  Do NOT
+       call _Exit() or signal/kill child tasks from here: AmigaOS4 requires the
+       executable's main task to drive shutdown. */
+    DebugPrintF("[EXIT] amiga_exit: returning to main (status=%d)\n", status);
+}
+#endif
+
 /* Setup default values for command line args */
 
 void setDefaultInitArgs(InitArgs *args) {
@@ -60,14 +275,45 @@ void setDefaultInitArgs(InitArgs *args) {
     args->java_stack = DEFAULT_STACK;
     args->max_heap   = phys_mem == 0 ? DEFAULT_MAX_HEAP
                                      : clampHeapLimit(phys_mem/4);
+    /*
+     * phys_mem/8, not the phys_mem/64 this used to be.
+     *
+     * min_heap is not a starting size here.  expandHeap() is reached only when
+     * a collection fails to free enough for the allocation that triggered it,
+     * and that does not happen with a healthy live set -- during a TLS download
+     * every collection returned 97% of the heap, so it never grew.  min_heap is
+     * therefore the working size, permanently.
+     *
+     * /64 is HotSpot's ratio for the INITIAL heap, and HotSpot then raises it
+     * from GC time ratio.  Copying the ratio without the policy gave the worst
+     * of both: as cautious as a starting value and as fixed as a final one.  On
+     * a 1GB machine it meant 16MB, and TLS allocates about seven bytes per byte
+     * transferred -- so a 77MB download collected forty times, once every two
+     * seconds, and the transfer rate swung between a quarter and twice its
+     * average.  At 128MB the same download collected twice, ran 44s instead of
+     * 78, and held 1.3-1.8 MB/s with no sample below a quarter of peak.
+     *
+     * Capped at 256MB so a large machine does not dirty half a gigabyte to run
+     * Hello World.  The whole of max_heap is mapped at startup regardless (see
+     * initialiseAlloc), so this changes how much gets touched, not reserved.
+     */
     args->min_heap   = phys_mem == 0 ? DEFAULT_MIN_HEAP
-                                     : clampHeapLimit(phys_mem/64);
+                                     : clampHeapLimit(MIN(phys_mem/8,
+                                                          (long long)256*MB));
 
     args->props_count = 0;
 
+#ifdef __amigaos4__
+    args->vfprintf = amiga_vfprintf;
+#else
     args->vfprintf = vfprintf;
+#endif
     args->abort    = abort;
+#ifdef __amigaos4__
+    args->exit     = amiga_exit;
+#else
     args->exit     = exit;
+#endif
 
 #ifdef INLINING
     args->replication_threshold = 10;
@@ -89,34 +335,46 @@ int VMInitialising() {
     return VM_initing;
 }
 
+/* Temporary clib4 bring-up tracing: emit each initVM stage to the serial
+   debug log (DebugPrintF) so the last printed stage identifies a failing one.
+   Remove once Hello World runs. */
+#ifdef __amigaos4__
+#include <proto/exec.h>
+#define JVTRACE(s) DebugPrintF("[JV] %s\n", (s))
+#else
+#define JVTRACE(s)
+#endif
+
 int initVM(InitArgs *args) {
     int status;
 
     /* Perform platform dependent initialisation */
+    JVTRACE("initialisePlatform");
     initialisePlatform();
 
     /* Initialise the VM modules -- ordering is important! */
 
-    status = initialiseHooks(args) &&
-             initialiseProperties(args) &&
-             initialiseAlloc(args) &&
-             initialiseThreadStage1(args) &&
-             initialiseUtf8() &&
-             initialiseSymbol() &&
-             initialiseClassStage1(args) &&
-             initialiseDll(args) &&
-             initialiseMonitor() &&
-             initialiseString() &&
-             initialiseException() &&
-             initialiseNatives() &&
-             initialiseAccess() &&
-             initialiseFrame() &&
-             initialiseJNI() &&
-             initialiseInterpreter(args) &&
-             initialiseClassStage2() &&
-             initialiseThreadStage2(args) &&
-             initialiseGC(args);
-
+    status = (JVTRACE("hooks"),          initialiseHooks(args)) &&
+             (JVTRACE("properties"),     initialiseProperties(args)) &&
+             (JVTRACE("alloc"),          initialiseAlloc(args)) &&
+             (JVTRACE("threadStage1"),   initialiseThreadStage1(args)) &&
+             (JVTRACE("utf8"),           initialiseUtf8()) &&
+             (JVTRACE("symbol"),         initialiseSymbol()) &&
+             (JVTRACE("classStage1"),    initialiseClassStage1(args)) &&
+             (JVTRACE("dll"),            initialiseDll(args)) &&
+             (JVTRACE("monitor"),        initialiseMonitor()) &&
+             (JVTRACE("string"),         initialiseString()) &&
+             (JVTRACE("exception"),      initialiseException()) &&
+             (JVTRACE("natives"),        initialiseNatives()) &&
+             (JVTRACE("access"),         initialiseAccess()) &&
+             (JVTRACE("frame"),          initialiseFrame()) &&
+             (JVTRACE("jni"),            initialiseJNI()) &&
+             (JVTRACE("interpreter"),    initialiseInterpreter(args)) &&
+             (JVTRACE("classStage2"),    initialiseClassStage2()) &&
+             (JVTRACE("threadStage2"),   initialiseThreadStage2(args)) &&
+             (JVTRACE("gc"),             initialiseGC(args));
+
+    JVTRACE("initVM done");
     VM_initing = FALSE;
     return status;
 }
diff --git a/src/interp/engine/interp-direct.h b/src/interp/engine/interp-direct.h
index 7df2e62..8d90223 100644
--- a/src/interp/engine/interp-direct.h
+++ b/src/interp/engine/interp-direct.h
@@ -236,9 +236,19 @@ opc##x##_##y##_##z:
 
 #endif /* USE_CACHE */
 
+/*
+ * DISPATCH_FIRST -- and only DISPATCH_FIRST -- carries the AmigaOS safepoint
+ * (see interp.h).  It is reached at method entry (INTERPRETER_PROLOGUE), on
+ * every taken branch, on return (DISPATCH_RET) and out of a switch, which is
+ * the classic safepoint set: no loop and no call can run unbounded without
+ * crossing one.  Deliberately NOT in DISPATCH, the straight-line path -- that
+ * is the hot one, and polling per taken branch already bounds the wait far
+ * more cheaply than interp-indirect.h did by polling every single opcode.
+ */
 #ifdef PREFETCH
 #define DISPATCH_FIRST                          \
 {                                               \
+    AMIGA_SAFEPOINT                             \
     next_handler = pc[1].handler;               \
     REDISPATCH                                  \
 }
@@ -251,6 +261,7 @@ opc##x##_##y##_##z:
 }
 #else
 #define DISPATCH_FIRST                          \
+    AMIGA_SAFEPOINT                             \
     REDISPATCH
 
 #define DISPATCH(level, ins_len)                \
diff --git a/src/interp/engine/interp-indirect.h b/src/interp/engine/interp-indirect.h
index 6a9f7c0..6380ae7 100644
--- a/src/interp/engine/interp-indirect.h
+++ b/src/interp/engine/interp-indirect.h
@@ -41,10 +41,26 @@ unused:
 #define INTERPRETER_DEFINITIONS                            \
     /* none */
 
+#ifdef __amigaos4__
+/* Cooperative GC stop-the-world (clib4 pthread_kill cannot async-interrupt a
+   thread executing bytecode): poll the global suspend-pending gate each
+   dispatch; only when a suspension is in progress do we look up threadSelf()
+   and park (thread.c suspendLoop). */
+extern volatile int suspend_pending_count;
+extern void threadPollSuspend();
+
 #define DISPATCH_PROLOGUE                                  \
     while(TRUE) {                                          \
+        if(suspend_pending_count)                          \
+            threadPollSuspend();                           \
         switch(*pc) {                                      \
             default:
+#else
+#define DISPATCH_PROLOGUE                                  \
+    while(TRUE) {                                          \
+        switch(*pc) {                                      \
+            default:
+#endif
 
 #endif /* THREADED */
 
diff --git a/src/interp/engine/interp-inlining.h b/src/interp/engine/interp-inlining.h
index 3339b0e..92777bd 100644
--- a/src/interp/engine/interp-inlining.h
+++ b/src/interp/engine/interp-inlining.h
@@ -348,7 +348,11 @@ opc##x##_##y##_##z:
 
 #endif /* USE_CACHE */
 
+/* Same safepoint contract as interp-direct.h -- see interp.h.  This engine is
+   only built at JAMVM_ENGINE_LEVEL 3, which we do not ship, but leaving it
+   without a poll would hand the next person a VM that hangs its collector. */
 #define DISPATCH_FIRST                          \
+    AMIGA_SAFEPOINT                             \
     goto *pc->handler;
 
 #define DISPATCH_SWITCH
@@ -359,6 +363,7 @@ opc##x##_##y##_##z:
     pc++;
 
 #define DISPATCH_METHOD_RET(ins_len)            \
+    AMIGA_SAFEPOINT                             \
     goto *(++pc)->handler;
 
 #define DISPATCH(level, ins_len)                \
@@ -368,6 +373,7 @@ opc##x##_##y##_##z:
     if(TEST) {                                  \
         pc = (Instruction*) pc->operand.pntr;   \
 branch_##level##_##type:                        \
+        AMIGA_SAFEPOINT                         \
         goto *pc->handler;                      \
     } else                                      \
         pc++;
diff --git a/src/interp/engine/interp.h b/src/interp/engine/interp.h
index e560f69..74fff16 100644
--- a/src/interp/engine/interp.h
+++ b/src/interp/engine/interp.h
@@ -99,6 +99,39 @@
 #define resolvePolyMethod(class, idx) ({ NULL; })
 #endif
 
+/*
+ * Cooperative safepoint.
+ *
+ * clib4's pthread_kill cannot async-interrupt a thread executing bytecode, so
+ * on AmigaOS a thread can only be stopped where it agrees to stop.  Two things
+ * depend on that and BOTH break silently without it:
+ *
+ *   - GC stop-the-world.  suspendThread/suspendAllThreads bump the gate and
+ *     then spin in "while(suspend_state != SUSP_BLOCKING) sched_yield()".  A
+ *     thread running bytecode that never polls never parks, and the collector
+ *     spins there forever.
+ *   - VM shutdown.  exitWakeAllThreads opens the gate permanently and every
+ *     thread is meant to reach threadPollSuspend and exitDetachAndDie; without
+ *     it amiga_exit's drain loop times out and main exits over the top of
+ *     threads that are still running, which then crash on a torn-down context.
+ *
+ * interp-indirect.h has carried this in its DISPATCH_PROLOGUE all along, so it
+ * worked as long as the switch interpreter was the only engine built.  Raising
+ * JAMVM_ENGINE_LEVEL to 2 moved us to interp-direct.h and left the poll behind.
+ * It belongs here, next to the variant selection, so that adding an engine
+ * cannot quietly drop it again.
+ */
+#ifdef __amigaos4__
+extern volatile int suspend_pending_count;
+extern void threadPollSuspend();
+
+#define AMIGA_SAFEPOINT                                    \
+    if(suspend_pending_count)                              \
+        threadPollSuspend();
+#else
+#define AMIGA_SAFEPOINT
+#endif
+
 /* Include the interpreter variant header */
 
 #ifdef DIRECT
diff --git a/src/jam.c b/src/jam.c
index 052f84a..3ac5146 100644
--- a/src/jam.c
+++ b/src/jam.c
@@ -32,10 +32,19 @@
 #include "thread.h"
 #include "classlib.h"
 
+/* On AmigaOS ':' is the volume separator, so path.separator is ';' -- but a
+   ':'-separated list is accepted too and disambiguated per colon (see
+   amigaIsPathListSep in os/amiga/classpath.c).  Say so in the help. */
+#ifdef __amigaos4__
+#define CP_SEPARATORS "; or :"
+#else
+#define CP_SEPARATORS ":"
+#endif
+
 #ifdef USE_ZIP
-#define BCP_MESSAGE "<jar/zip files and directories separated by :>"
+#define BCP_MESSAGE "<jar/zip files and directories separated by " CP_SEPARATORS ">"
 #else
-#define BCP_MESSAGE "<directories separated by :>"
+#define BCP_MESSAGE "<directories separated by " CP_SEPARATORS ">"
 #endif
 
 void showNonStandardOptions() {
@@ -80,9 +89,13 @@ void showUsage(char *name) {
     printf("\nwhere options include:\n");
     printf("  -client\t   compatibility (ignored)\n");
     printf("  -server\t   compatibility (ignored)\n\n");
-    printf("  -cp\t\t   <jar/zip files and directories separated by :>\n");
-    printf("  -classpath\t   <jar/zip files and directories separated by :>\n");
+    printf("  -cp\t\t   %s\n", BCP_MESSAGE);
+    printf("  -classpath\t   %s\n", BCP_MESSAGE);
     printf("\t\t   locations where to find application classes\n");
+#ifdef __amigaos4__
+    printf("\t\t   an entry of \"*\", or a drawer followed by \"/*\",\n");
+    printf("\t\t   expands to the jars in that drawer\n");
+#endif
     printf("  -D<name>=<value> set a system property\n");
     printf("  -verbose[:class|gc|jni]\n");
     printf("\t\t   :class print out information about class loading, etc.\n");
@@ -107,21 +120,51 @@ void showVersionAndCopyright() {
     printf("but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
     printf("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n");
     printf("GNU General Public License for more details.\n");
-    printf("\nBuild information:\n\nExecution Engine: %s\n",
-           getExecutionEngineName());
+    {
+        /* These classlib accessors can return NULL before the VM is initialised
+           (the openjdk classlib derives them from java.home/VM state set up in
+           initVM, but -version is handled here in parseCommandLine, pre-init).
+           printf("%s", NULL) crashes clib4's vfprintf, so guard them. */
+        char *engine = getExecutionEngineName();
+        char *boot_dll = classlibDefaultBootDllPath();
+        char *boot_cp = classlibDefaultBootClassPath();
+
+        printf("\nBuild information:\n\nExecution Engine: %s\n",
+               engine ? engine : "(unknown)");
 
 #if defined(__GNUC__) && defined(__VERSION__)
-    printf("Compiled with: gcc %s\n", __VERSION__);
+        printf("Compiled with: gcc %s\n", __VERSION__);
 #endif
 
-    printf("\nBoot Library Path: %s\n", classlibDefaultBootDllPath());
-    printf("Boot Class Path: %s\n", classlibDefaultBootClassPath());
+        printf("\nBoot Library Path: %s\n", boot_dll ? boot_dll : "(unset)");
+        printf("Boot Class Path: %s\n", boot_cp ? boot_cp : "(unset)");
+    }
 }
 
 void showFullVersion() {
     printf("java full version \"jamvm-%s\"\n", JAVA_COMPAT_VERSION);
 }
 
+/*
+ * The VM options, kept for RuntimeMXBean.getInputArguments().
+ *
+ * jmm_GetInputArgumentArray has to answer with the arguments the VM was given
+ * -- everything before the main class, so `-Xms128M` but not `Main` and not its
+ * arguments.  Nothing was recording them, and the stub returned NULL, which
+ * getInputArguments() then wraps in a List and hands back as a null a caller
+ * cannot distinguish from "no arguments".
+ *
+ * Pointers into argv rather than copies: argv outlives the VM.  Only argv[i] --
+ * the main class, past the end of this range -- is ever rewritten (for -jar).
+ */
+/* DEFINED in init.c, which is part of libjvm.so.  This file is linked into the
+   jamvm-openjdk executable instead, and a shared library must not depend on a
+   symbol from the program that loaded it -- the packaging symbol sweep caught
+   exactly that ("libjvm.so references symbols nothing provides").  The
+   executable writing to the library's variable is the sound direction. */
+extern char **vm_input_args;
+extern int vm_input_args_count;
+
 int parseCommandLine(int argc, char *argv[], InitArgs *args) {
     Property props[argc-1];
     int is_jar = FALSE;
@@ -132,6 +175,9 @@ int parseCommandLine(int argc, char *argv[], InitArgs *args) {
 
     for(i = 1; i < argc; i++) {
         if(*argv[i] != '-') {
+            /* First non-option: everything before it was for the VM. */
+            vm_input_args = &argv[1];
+            vm_input_args_count = i - 1;
             if(args->min_heap > args->max_heap) {
                 printf("Minimum heap size greater than max!\n");
                 status = 1;
@@ -212,6 +258,18 @@ int parseCommandLine(int argc, char *argv[], InitArgs *args) {
                 } else if(strncmp(argv[i], "-Xbootclasspath/v:", 18) == 0) {
                     args->bootpath_v = argv[i] + 18;
 
+                /* These plain/append/prepend forms were missing in the JAmiga
+                   fork, so -Xbootclasspath: was silently ignored and the VM
+                   fell back to the (non-existent) default JAmiga: boot path. */
+                } else if(strncmp(argv[i], "-Xbootclasspath/a:", 18) == 0) {
+                    args->bootpath_a = argv[i] + 18;
+
+                } else if(strncmp(argv[i], "-Xbootclasspath/p:", 18) == 0) {
+                    args->bootpath_p = argv[i] + 18;
+
+                } else if(strncmp(argv[i], "-Xbootclasspath:", 16) == 0) {
+                    args->bootpath = argv[i] + 16;
+
                 /* Compatibility options */
                 } else if(strcmp(argv[i], "-client") == 0 ||
                           strcmp(argv[i], "-server") == 0) {
@@ -251,10 +309,40 @@ int main(int argc, char *argv[]) {
         exit(1);
     }
 
-   if((system_loader = getSystemClassLoader()) == NULL)
+
+#ifdef __amigaos4__
+    /* The OpenJDK system classloader (sun.misc.Launcher) now initialises reliably on
+       AmigaOS -- the earlier "heisenbug" was missing openjdk natives (CDS stubs,
+       VM.latestUserDefinedLoader0, TimeZone, ...), now supplied.  Use the real system
+       loader; classes on -Xbootclasspath load via delegation.  Fall back to the
+       bootstrap loader if it ever fails to init.  KNOWN GAP: loading an app class from
+       a -classpath entry (URLClassPath) still fails -- Amiga "volume:" path -> URL
+       (Phase 3 TODO); -Xbootclasspath is the working path meanwhile. */
+    system_loader = getSystemClassLoader();
+    if(system_loader == NULL) {
+        /* Keep the fallback -- classes on -Xbootclasspath still load through the
+           bootstrap loader -- but do NOT swallow the reason, as this used to.
+           Without the system loader the -classpath is not searched at all, so
+           the main-class lookup below fails and reports "NoClassDefFoundError:
+           <your class>", sending you after a classpath bug that does not exist.
+           The -jar path disguises it further: JarLauncher lives on the boot
+           class path, so it loads anyway and the run only breaks later, which
+           makes -cp look broken and -jar look fine.  (Seen for real: a 16MB
+           non-growable heap made sun.misc.Launcher's initialiser throw
+           OutOfMemoryError, and every symptom pointed somewhere else.) */
+        jam_fprintf(stderr, "Warning: the system class loader failed to "
+                            "initialise, so -classpath will NOT be searched "
+                            "and only -Xbootclasspath classes can load.  "
+                            "The underlying error was:\n");
+        printException();
+    } else
+        mainThreadSetContextClassLoader(system_loader);
+#else
+    if((system_loader = getSystemClassLoader()) == NULL)
         goto error;
 
     mainThreadSetContextClassLoader(system_loader);
+#endif
 
     for(cpntr = argv[class_arg]; *cpntr; cpntr++)
         if(*cpntr == '.')
@@ -301,6 +389,5 @@ error:
     mainThreadWaitToExitVM();
     exitVM(status);
 
-   /* Keep the compiler happy */
-    return 0;
+    return status;
 }
diff --git a/src/jam.h b/src/jam.h
index ce73df6..858bfc8 100644
--- a/src/jam.h
+++ b/src/jam.h
@@ -879,7 +879,11 @@ typedef struct InitArgs {
    a StackOverflow exception */
 #define STACK_RED_ZONE_SIZE 1*KB
 
+#if defined(OPENJDK_VERSION) && OPENJDK_VERSION >= 8
+#define JAVA_COMPAT_VERSION "1.8.0"
+#else
 #define JAVA_COMPAT_VERSION "1.5.0"
+#endif
 
 #ifndef MIN
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
@@ -1178,6 +1182,8 @@ extern ExecEnv *getExecEnv();
 extern void createJavaThread(Object *jThread, long long stack_size);
 extern void mainThreadSetContextClassLoader(Object *loader);
 extern void mainThreadWaitToExitVM();
+extern int isMainVMThread();
+extern void requestExitVMWaitBreak();
 extern void uncaughtException();
 extern void exitVM(int status);
 extern void scanThreads();
@@ -1209,6 +1215,18 @@ extern char *getExecutionEngineName();
 extern char *getJavaHome();
 extern char *getCwd();
 
+#ifdef __amigaos4__
+/* os/amiga/os.c -- see the "AmigaDOS path model" comment there */
+extern const char *amigaPath(const char *path);
+extern int amigaIsDosName(const char *name, int len);
+extern char *amigaProgramDir(void);
+extern char *amiga_launch_cwd;
+
+/* os/amiga/classpath.c */
+extern char *amigaClassPath(const char *cp);
+extern int amigaIsPathListSep(const char *list, int start, int i, int *seen_vol);
+#endif
+
 /* access */
 
 extern int initialiseAccess();
diff --git a/src/jni.c b/src/jni.c
index 6edb60b..6886837 100644
--- a/src/jni.c
+++ b/src/jni.c
@@ -517,6 +517,16 @@ jclass Jam_FindClass(JNIEnv *env, const char *name) {
 
     class = findClassFromClassLoader((char*) name, loader);
 
+    /* JNI FindClass must also INITIALIZE the class (HotSpot does); native
+       code depends on the clinit side-effects -- e.g. libawt's
+       Disposer_AddRecord lazily FindClass-es sun.java2d.Disposer expecting
+       its clinit to run initIDs and cache addRecordMID. */
+    if(class != NULL) {
+        initClass(class);
+        if(exceptionOccurred())
+            return NULL;
+    }
+
     return addJNILref(class);
 }
 
diff --git a/src/lock.c b/src/lock.c
index 5fdec27..93bd591 100644
--- a/src/lock.c
+++ b/src/lock.c
@@ -146,7 +146,66 @@ void monitorLock(Monitor *mon, Thread *self) {
             self->blocked_count++;
             classlibSetThreadState(self, BLOCKED);
 
+#ifdef __amigaos4__
+            /*
+             * Wait in slices, so a thread blocked here can still leave when the
+             * VM is shutting down.
+             *
+             * pthread_mutex_lock() is an unbounded block inside clib4: the
+             * thread is not executing bytecode, so it never reaches a dispatch
+             * safepoint, and exitWakeAllThreads() cannot reach it either --
+             * that notifies condition variables, and this is monitor entry.  A
+             * thread stuck here is therefore one the VM cannot drain.
+             *
+             * What that costs is not a slow exit.  amiga_exit() gives up after
+             * 300 tries and returns to main ANYWAY, so the process tears its
+             * clib4 context down while those threads are still running -- and
+             * on AmigaOS, where every process shares one address space, they
+             * then write into whatever has since been given to somebody else.
+             * That is reproducible: SpawnSurvive with a thread blocked here
+             * kills the CHILD process, in its own heap, mid Thread.sleep.
+             *
+             * So: try, look at whether the VM is going down, try again.  A
+             * thread that finds the VM exiting leaves through the same door as
+             * every other -- unlinked and counted out -- instead of being
+             * abandoned still running.
+             */
+            {
+                extern volatile int vm_exiting;
+                extern void exitDetachAndDieSelf(void);
+
+                while(pthread_mutex_trylock(&mon->lock) != 0) {
+                    struct timespec deadline;
+
+                    /* Plain blocking lock while the VM runs: polling every
+                       contended monitor at 20Hz costs the whole runtime, and
+                       this is not where an undrainable thread ends up anyway
+                       -- it parks in monitorWait, one frame further in. */
+                    if(!vm_exiting) {
+                        pthread_mutex_lock(&mon->lock);
+                        break;
+                    }
+
+                    if(!isMainVMThread()) {
+                        classlibSetThreadState(self, RUNNING);
+                        self->blocked_mon = NULL;
+                        enableSuspend(self);
+                        exitDetachAndDieSelf();
+                        return TRUE;            /* not reached */
+                    }
+
+                    clock_gettime(CLOCK_REALTIME, &deadline);
+                    deadline.tv_nsec += 50000000;      /* 50ms */
+                    if(deadline.tv_nsec >= 1000000000) {
+                        deadline.tv_nsec -= 1000000000;
+                        deadline.tv_sec++;
+                    }
+                    pthread_mutex_timedlock(&mon->lock, &deadline);
+                }
+            }
+#else
             pthread_mutex_lock(&mon->lock);
+#endif
 
             classlibSetThreadState(self, RUNNING);
             self->blocked_mon = NULL;
@@ -238,8 +297,71 @@ int monitorWait(Monitor *mon, Thread *self, long long ms, int ns,
                    empty for sane platforms. */ 
 
                 FPU_HACK;
-            } else
+            } else {
+#ifdef __amigaos4__
+                /*
+                 * Wait in slices, so an untimed wait can still be left when the
+                 * VM is shutting down.
+                 *
+                 * This is where a thread contending for a monitor actually
+                 * parks: objectLock's slow path calls monitorWait(.., 0, 0, ..)
+                 * and lands in an unbounded pthread_cond_wait on the thread's
+                 * OWN wait_cv.  Only the monitor's owner ever signals that, so
+                 * if the owner never releases -- an application deadlock, or
+                 * simply a thread that outlives the work -- nothing can wake it.
+                 * exitWakeAllThreads does not reach it either: that notifies
+                 * the VM's own wait locks, not a per-thread condvar.
+                 *
+                 * Such a thread is undrainable, and amiga_exit gives up after
+                 * 300 tries and returns to main anyway.  The process then tears
+                 * its clib4 context down with those threads still running, and
+                 * on AmigaOS -- one address space for everything -- they write
+                 * into memory since handed to someone else.  Reproduced by
+                 * SpawnSurvive dirty, which kills the CHILD process, in the
+                 * child's own heap, mid Thread.sleep.
+                 *
+                 * The first attempt at this put the poll in monitorLock, which
+                 * was the wrong line: the thread passes THROUGH monitorLock and
+                 * stops here.  The thread dump said BLOCKED either way, which is
+                 * what made them look alike.
+                 */
+                {
+                    extern volatile int vm_exiting;
+                    extern void exitDetachAndDieSelf(void);
+                    struct timespec slice;
+
+                    if(vm_exiting && !isMainVMThread()) {
+                        pthread_mutex_unlock(&mon->lock);
+                        exitDetachAndDieSelf();
+                        return TRUE;                 /* not reached */
+                    }
+
+                    /*
+                     * Untimed while the VM is RUNNING.  Slicing here
+                     * unconditionally was a bad trade paid by everything else:
+                     * every Object.wait() in the runtime became a 20Hz wakeup,
+                     * each one re-acquiring the monitor mutex, and an
+                     * application with dozens of waiting threads spent its
+                     * whole CPU on the herd.  InvoiceX hung at startup on it.
+                     *
+                     * Nothing is lost by waiting properly: threadInterrupt
+                     * signals this very condvar (wait_mon is set just above),
+                     * so shutdown wakes the thread, and the check above then
+                     * gets it out on the next pass.  The slice is only for the
+                     * case where it is already exiting.
+                     */
+                    if(vm_exiting) {
+                        getTimeoutRelative(&slice, 50, 0);   /* 50ms */
+                        pthread_cond_timedwait(&self->wait_cv, &mon->lock,
+                                               &slice);
+                    } else {
+                        pthread_cond_wait(&self->wait_cv, &mon->lock);
+                    }
+                }
+#else
                 pthread_cond_wait(&self->wait_cv, &mon->lock);
+#endif
+            }
 
         /* If we've been interrupted or timed-out, we will not have been
            removed from the wait set.  If we have, we must have been
diff --git a/src/os/amiga/os.c b/src/os/amiga/os.c
index 5561c20..04303a0 100644
--- a/src/os/amiga/os.c
+++ b/src/os/amiga/os.c
@@ -19,241 +19,226 @@
  * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
+/*
+ * AmigaOS 4 os layer, clib4 variant.
+ *
+ * Reworked for the clib4 migration: native library loading now uses standard
+ * clib4 dlopen/dlsym (ELF .so), replacing JAmiga's lost nativelib.library ABI.
+ * Threads/signals/mmap/scandir are provided by clib4 directly (the JAmiga
+ * pthread.c/signal.c/scandir.c/memory.c shims are no longer built). This mirrors
+ * JamVM's os/linux/os.c.
+ */
+
 #include "jamvm_rev.h"
 #undef VERSION
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #define USE_MALLOC 1
 #define JA_TARGETOS JA_AMIGAOS4
 
 #include "../../jam.h"
 
-//#include "MemGuardian.h"
 #include <proto/exec.h>
-#include <proto/utility.h>
 #include <proto/dos.h>
-#include <proto/nativelib.h>
-#define VERSIONTAG VERSTAG" AmigaOS 4 build of "PACKAGE" "VERSION" "
-STRPTR USED ver = (STRPTR)VERSIONTAG;
 
-/**
- * Struct from JAmiga JNI library definition.
- */
-struct JNINativeMethod {
-    char *className;
-    char *methodName;
-    char *methodDescriptor;
-    void *fnPtr;
-    int flags;
-};
-
-struct JNINativeLibrary {
-    char *name;
-    int version;
-    int numberOfMethods;
-    struct JNINativeMethod *methods;
-};
-
-
-/**
- * Internal struct for native methods
- * with mangled symbol name.
- */
-struct JamNativeMethodSymbol {
-    char *symbolName;
-    void *fnPtr;
-};
+#define __USE_GNU
+#include <dlfcn.h>
+#include <pthread.h>
 
+#define VERSIONTAG VERSTAG" AmigaOS 4 build of "PACKAGE" "VERSION" "
+STRPTR USED ver = (STRPTR)VERSIONTAG;
 
-/**
- * Internal struct for list of native methods
- * with mangled symbol names.
- */
-struct JamLibraryInfo {
-    char *name;
-    int numberOfMethods;
-    //
-    struct JamNativeMethodSymbol * nativeMethods;
-    struct Library *osLib;
-#if (JA_TARGETOS==JA_AMIGAOS4)
-        struct Interface *osIFace;
-#endif
-} JamLibraryInfo ;
+long long nativePhysicalMemory() {
+    /* Drives the default heap: JamVM takes max_heap = phys/4, min_heap = phys/64
+       (both clamped to >= MIN_MIN_HEAP = 16MB, <= MAX_MAX_HEAP = 1GB).
+
+       This used to return a flat 64MB, which looks conservative but is worse
+       than it reads: 64/4 = 16MB max, and 64/64 = 1MB min clamps UP to 16MB, so
+       min == max and the heap could never grow past 16MB.  Anything that needed
+       more died with OutOfMemoryError -- java.util.Locale's class initialiser
+       was enough, and the NoClassDefFoundError that followed named Locale while
+       the actual fault was the heap.
+
+       The flat number was there because initialiseAlloc() mmaps the WHOLE
+       max_heap in one go at startup, and reporting true RAM on a 2GB machine
+       asked clib4 for a 512MB MAP_ANON, which fails and aborts the VM.  That is
+       now handled where it belongs -- initialiseAlloc halves and retries -- so
+       report the real figure and let it settle on what the system can actually
+       give.  Capped at 1GB so the first attempt stays sane on a big machine;
+       -Xmx still overrides everything. */
+    uint64 total = AvailMem(MEMF_TOTAL);
+
+    if(total == 0)                       /* AvailMem should not fail; be safe */
+        return 256LL * 1024 * 1024;
+
+    if(total > 1024LL * 1024 * 1024)
+        total = 1024LL * 1024 * 1024;
+
+    return (long long)total;
+}
 
 void *nativeStackBase() {
-    DebugPrintF("Native stack base\n");
+    /* No portable pthread_getattr_np in clib4; let JamVM fall back (as the
+       uclibc path does).  Revisit if main-thread GC root scanning needs it. */
     return NULL;
 }
 
 int nativeAvailableProcessors() {
-    DebugPrintF("Native avail processorn");
     return 1;
 }
 
-char *nativeLibPath() {
-    return getenv("LD_LIBRARY_PATH");
+char *nativeLibError() {
+    return dlerror();
 }
 
+/* Java -> AmigaDOS path conversion: single source of truth in
+   src/openjdk/amiga_path.h (the jamvm build scripts add -I src/openjdk), shared
+   with the OpenJDK natives, tested on the host by tools/test-amiga-path.c.
+   Exported here under the VM's name for JVM_Open, nativeLibOpen, processArchive
+   and the boot-classpath stat. */
+#include "amiga_path.h"
 
-char* nativeLibError() {
-    return "Misc error";
+const char *amigaPath(const char *path) {
+    return amiga_path(path);
 }
 
-extern char *mangleString(char *utf8);
-/**
- *
- */
-void *nativeLibOpen(char *path) {
-    char * tempName;
-    char * tempType;
-    char * osName = NULL;
-    struct JNINativeLibrary * nativeInfo;
-    struct JamLibraryInfo* libraryInfo;
-    struct Library *myLib;
-    int j, len, i;
-#if (JA_TARGETOS==JA_AMIGAOS4)
-    struct NativelibIFace *INativelib;
-#endif
-    
-    myLib = OpenLibrary(path, 0);
-    if(!myLib) {
-
-        JA_TRACE("Cannot open Library %s\n", path);
-        return NULL;
-    }
-    #if (JA_TARGETOS==JA_AMIGAOS4)
-    // Get Interface
-    INativelib = (struct NativelibIFace*)GetInterface(myLib, "main", 1, NULL);
-    if(!INativelib) {
-        JA_TRACE("Cannot get interface for library %s\n", osName);
-        CloseLibrary(myLib);
-        return NULL;
-    }
-    #endif
+/* TRUE if `name` (len chars, no trailing ':') names a mounted volume, an assign
+   or a device.  This is what lets us tell an AmigaDOS volume separator
+   ("Work:lib/x.jar") apart from a Java path-list separator ("app.jar:lib/x.jar")
+   -- on AmigaOS both are spelt ':'.  Asking DOS is exact and, unlike stat()ing
+   the name, never pops an "insert volume" requester. */
+int amigaIsDosName(const char *name, int len) {
+    const ULONG flags = LDF_VOLUMES | LDF_ASSIGNS | LDF_DEVICES;
+    struct DosList *list, *entry;
+    char buff[128];
+
+    if(name == NULL || len <= 0 || len >= (int)sizeof(buff))
+        return FALSE;
 
+    memcpy(buff, name, len);
+    buff[len] = '\0';
 
-    // Obtain pointer array to native methods
-    nativeInfo = (APTR)GetLibraryContent();
+    if((list = LockDosList(flags | LDF_READ)) == NULL)
+        return FALSE;
 
-    if(!nativeInfo) {
-        #if (JA_TARGETOS==JA_AMIGAOS4)
-        DropInterface(INativelib);
-        INativelib = NULL;
-        #endif
-        CloseLibrary(myLib);
-        sysFree(libraryInfo);
+    entry = FindDosEntry(list, (STRPTR)buff, flags);
+    UnLockDosList(flags | LDF_READ);
+
+    return entry != NULL;
+}
+
+/* The VM's own program directory (PROGDIR:) as a real, absolute AmigaDOS path
+   (e.g. "SYS:Java"), resolved once and cached.  Lets the boot jars, java.home
+   and the bundled native libraries be found relative to where jamvm-openjdk
+   lives -- INDEPENDENT of the current directory, so the `java` launcher no
+   longer has to `CD JAVA:` (which leaked into the caller's shell and re-based
+   the user's relative -cp).  NULL if PROGDIR: can't be resolved -- callers then
+   fall back to their old cwd-relative behaviour. */
+char *amigaProgramDir(void) {
+    static char *cached = NULL;
+    static int tried = FALSE;
+    BPTR lock;
+    char buff[1024];
+
+    if(tried)
+        return cached;
+    tried = TRUE;
+
+    lock = GetProgramDir();
+    if(lock != 0 && NameFromLock(lock, (STRPTR)buff, sizeof(buff)))
+        cached = strcpy(sysMalloc(strlen(buff) + 1), buff);   /* "Volume:dir" */
+
+    return cached;
+}
+
+/* The directory `java` was launched from -- user.dir, and the anchor for
+   relative -cp entries.  Also the process's current directory: see below. */
+char *amiga_launch_cwd = NULL;
+
+/* The VM used to chdir() into its own install drawer here, because the boot
+   classpath, sun.boot.library.path and the ext dirs were all relative names
+   resolved against the current directory.  They are java.home-absolute now, so
+   the chdir is gone and the process cwd stays where the user launched from.
+
+   That matters more than it looks.  java.io does resolve relative paths against
+   user.dir before reaching a native call -- but not everything goes through
+   java.io: java.util.zip.ZipFile hands File.getPath() (the path AS GIVEN, not
+   absolutised) straight to open().  With the cwd pointing at the install drawer,
+   an application's own `new ZipFile("App.jar")` therefore looked for App.jar
+   under JAVA: and failed, while every java.io.File call on the same name worked.
+   cwd == user.dir is what a Unix JVM gives you, and now so do we. */
+void amigaSetupCwd(void) {
+    amiga_launch_cwd = getCwd();
+}
+
+char *nativeLibPath() {
+    return getenv("LD_LIBRARY_PATH");
+}
+
+void *nativeLibOpen(char *path) {
+    /* ClassLoader hands us the Unix-absolute form ("/Volume:dir/libzip.so");
+       clib4's dlopen wants the AmigaDOS one. */
+    const char *p = amigaPath(path);
+    void *h;
+
+    if(p == NULL)
         return NULL;
-    }
-    libraryInfo = sysMalloc(sizeof(struct JamLibraryInfo));
-
-    #if (JA_TARGETOS==JA_AMIGAOS4)
-    libraryInfo->osIFace = (struct Interface*)INativelib;
-    #endif
-    JA_TRACE("Openend \"%s\", version %ld.%ld\n", myLib->lib_Node.ln_Name, myLib->lib_Version, myLib->lib_Revision);
-    libraryInfo->osLib = myLib;
-    libraryInfo->name = myLib->lib_Node.ln_Name;
-
-
-    libraryInfo->numberOfMethods = nativeInfo->numberOfMethods;
-
-    len=(sizeof(struct JamNativeMethodSymbol)) * libraryInfo->numberOfMethods;
-    libraryInfo->nativeMethods = sysMalloc(len);
-    for(j=0; j < libraryInfo->numberOfMethods; j++) {
-        // calculate length of the full method descriptor. Add 3 to cater fot separators
-        len = strlen(nativeInfo->methods[j].className)+
-                                strlen(nativeInfo->methods[j].methodDescriptor)+
-                                strlen(nativeInfo->methods[j].methodName)+3;
-        tempName = sysMalloc(len);
-        tempName[0] = '\0';
-        strcat(tempName, nativeInfo->methods[j].className);
-        strcat(tempName, "/");
-        strcat(tempName, nativeInfo->methods[j].methodName);
-
-        strcat(tempName, "/");
-        strcat(tempName, "/");
-        // find the last (
-        strcat(tempName, nativeInfo->methods[j].methodDescriptor+1);
-
-        for(i = strlen(tempName)-1; tempName[i] != ')'; i--);
-        tempName[i] = '\0';
-        if(tempName[i - 1] == '(') {
-            // we have sig (), which measn no sig, and no need
-            // for the two extra // added above.
-            tempName[i - 3] = '\0';
-        }
-
-        
-        libraryInfo->nativeMethods[j].fnPtr = nativeInfo->methods[j].fnPtr;
-        libraryInfo->nativeMethods[j].symbolName = mangleString(tempName);
-        sysFree(tempName);
-    }
-
-    return libraryInfo;
+
+    /*
+     * RTLD_GLOBAL, not the bare RTLD_LAZY this used to pass.
+     *
+     * The JDK's native libraries reference each other: libfontmanager calls
+     * GetNativePrim in libawt, libamigaawt calls registerAmigaAwtCleanup in
+     * libjvm, and upstream expresses that with DT_NEEDED between them.  We
+     * cannot: our libraries live in JAVA: while the rpath points at
+     * JAVA:Sobjs, and a second rpath entry is not expressible -- the separator
+     * would be ':', which is already the volume separator here.
+     *
+     * Loading them into one shared namespace instead is what every Unix JVM
+     * ends up doing anyway, and clib4 supports it (dlopen maps RTLD_GLOBAL to
+     * ELF32_RTLD_GLOBAL).  Without it each library is an island and the
+     * cross-references fail at the first call, not at load time.
+     */
+    h = dlopen(p, RTLD_LAZY | RTLD_GLOBAL);
+    DebugPrintF("[DLOPEN] '%s' -> %p%s\n", p, h,
+                h ? "" : " FAILED");
+    return h;
 }
 
 void nativeLibClose(void *handle) {
-    struct JamLibraryInfo* libraryInfo = handle;
-    int j = 0;
-    
-#if (JA_TARGETOS==JA_AMIGAOS4)
-    DropInterface(libraryInfo->osIFace);
-#endif
-    CloseLibrary(libraryInfo->osLib);
-    for(j=0; j < libraryInfo->numberOfMethods; j++) {
-        sysFree(libraryInfo->nativeMethods[j].symbolName);
-    }
-    sysFree(libraryInfo);
+    dlclose(handle);
 }
 
 void *nativeLibSym(void *handle, char *symbol) {
-    struct JamLibraryInfo * libInfo = (struct JamLibraryInfo*)handle;
-    //   Class *class;
-   //char *name;
-   //char *type;
-   //char *signature;
-    #if __amigaos4__
-    struct NativelibIFace *INativelib;
-    #endif
-
-    int i,j, len, srcptr;
-    int checkHex;
-    char * copy = NULL;
-    char * className = NULL;
-    char * methodName = NULL;
-    char * sig = NULL;
-    char hex[5];
-    char lastChar = '\0';
-    BOOL isJni = FALSE;
-    #ifdef __amigaos4__
-    INativelib = libInfo->osIFace;
-    #endif
-
-    if(strstr(symbol, "Java_") == symbol) {
-        i = 5;
-        isJni = FALSE;
-
-    } else if(strstr(symbol, "JNI_") == symbol) {
-        // These are the two JNI_OnLoad and JNI_Onload functions
-        isJni = TRUE;
-        i = 0;
-    } else {
-        // Don't know what this could be, shouldn't happen
-        i = 0;
-    }
-    for(j=0; j < libInfo->numberOfMethods; j++) {
-        if(isJni && (strstr(libInfo->nativeMethods[j].symbolName, symbol) == libInfo->nativeMethods[j].symbolName)) {
-            return libInfo->nativeMethods[j].fnPtr;
-        } else if(strcmp(symbol + i, libInfo->nativeMethods[j].symbolName) == 0) {
-            return libInfo->nativeMethods[j].fnPtr;
-        } else {
-            //JA_TRACE("NO match %s == %s\n", symbol+i, libInfo->nativeMethods[j].symbolName);
-        }
-    }
-    return NULL;
+    return dlsym(handle, symbol);
 }
 
 char *nativeLibMapName(char *name) {
-    char *buff = sysMalloc(strlen(name) + sizeof(".library") + 1);
-    sprintf(buff,"%s.library", name);
+    char *buff = sysMalloc(strlen(name) + sizeof("lib.so") + 1);
+
+    sprintf(buff, "lib%s.so", name);
     return buff;
 }
+
+char *nativeJVMPath() {
+    Dl_info info;
+    char *path;
+
+    if(dladdr(nativeJVMPath, &info) == 0)
+        return NULL;
+
+    path = sysMalloc(strlen(info.dli_fname) + 1);
+    strcpy(path, info.dli_fname);
+
+    return path;
+}
+
+/* The -classpath / -Xbootclasspath rewriter: accepts ':' as well as ';' and
+   expands wildcards.  The logic lives in the Java-OS4 tree (src/jamvm/, added to
+   the include path by tools/build-jamvm-*.sh) rather than here, so that
+   tools/test-amiga-classpath.c can compile and test the very same code on the
+   host -- see the header for why it is not a .c file in this tree. */
+#define CP_TRACE DebugPrintF
+#include "amiga_classpath.h"
diff --git a/src/os/amiga/powerpc/init.c b/src/os/amiga/powerpc/init.c
index 075b0ef..cd42452 100644
--- a/src/os/amiga/powerpc/init.c
+++ b/src/os/amiga/powerpc/init.c
@@ -18,3 +18,46 @@
  * along with this program; if not, write to the Free Software
  * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
+
+#include <proto/exec.h>
+#include <proto/dos.h>
+#include <dos/dos.h>
+
+/* JamVM's per-platform init hook (called from src/init.c:initVM).
+ *
+ * clib4's pthread_create() duplicates the parent's Input(), Output() and
+ * ErrorOutput() DOS streams for every new thread and FAILS with EAGAIN if any
+ * of them is unset (DupFileHandle(0) fails).  When JamVM is launched
+ * non-interactively (e.g. via the mcpd test harness) the error and/or input
+ * streams can be NULL, so the very first createVMThread() would deadlock.
+ * Ensure all three streams are valid before any thread is created. */
+void initialisePlatform() {
+    if(ErrorOutput() == 0)
+        SelectErrorOutput(Output());
+
+    if(Input() == 0) {
+        BPTR nil = Open("NIL:", MODE_OLDFILE);
+        if(nil != 0)
+            SelectInput(nil);
+    }
+
+    if(Output() == 0) {
+        BPTR nil = Open("NIL:", MODE_NEWFILE);
+        if(nil != 0)
+            SelectOutput(nil);
+    }
+
+    /* Re-point error output once more in case Output() was just created. */
+    if(ErrorOutput() == 0)
+        SelectErrorOutput(Output());
+
+    /* Switch the current dir to the VM's own program directory so the colon-free
+       runtime paths (boot classpath, sun.boot.library.path, java.home) resolve
+       there regardless of where `java` was launched -- without leaking the dir
+       change into the caller's shell, and keeping user.dir = the launch dir.
+       See amigaSetupCwd() in os/amiga/os.c. */
+    {
+        extern void amigaSetupCwd(void);
+        amigaSetupCwd();
+    }
+}
diff --git a/src/os/amiga/pthread.h b/src/os/amiga/pthread.h
deleted file mode 100644
index 914c979..0000000
--- a/src/os/amiga/pthread.h
+++ /dev/null
@@ -1,130 +0,0 @@
-
-#ifndef AMIGA_PTHREAD_H
-#define AMIGA_PTHREAD_H
-
-#include "signal.h"
-
-//
-#include <time.h>
-#include <sys/time.h>
-//#include <sys/errno.h>
-// Blargh: Hardcodin this here, sincve I get timeval issues.. *sigh*
-#define ESRCH 3     /* No such process */
-#include <proto/exec.h>
-#include <proto/utility.h>
-#include <proto/timezone.h>
-#include <proto/dos.h>
-#include <proto/timer.h>
-#include <exec/semaphores.h>
-
-/* Define our trace here aswell */
-#define JA_TRACE(x, y...)
-//Forbid(); DebugPrintF("TRACE %-5ld %15s:%-5d", ((struct Process *)FindTask(NULL))->pr_ProcessID,__FILE__,__LINE__); DebugPrintF(x, ## y); Permit();
-
-#define ETIMEDOUT 60
-
-/*struct timespec
-{
-    unsigned int tv_sec;
-    unsigned int tv_nsec;
-};*/
-
-//typedef struct {
-//    APTR lock;
-//    struct CondVariable cv;
-//    struct Semaphore *semaphore;
-//    enum CondType cv;
-//} VMWaitLock;
-
-//typedef APTR VMLock;
-
-
-enum CondType {
-    NONE,
-    SIGNAL,
-    BROADCAST
-};
-struct ProcessNode {
-    struct MinNode node;
-    struct Process * process;
-};
-struct CondVariable {
-    struct MinList waitingProcessList;
-    enum CondType condType;
-    struct SignalSemaphore semaphore;
-} CondVariable;
-
-struct PthreadInitData {
-//    void * (*pd_Func)(void*);
-    void *pd_Args;
-    APTR pd_ExceptCode;
-    APTR pd_ExceptData;
-    char pd_Dummy;
-    uint32 pd_SigMask;
-    void * pd_Specific;
-    //struct TimeRequest *pd_timerIO;
-    //struct MsgPort *pd_timerMP;
-
-} PthreadInitData;
-//void SignalThreads(enum CondType type, struct CondVariable cv, struct thread *self);
-int CondWait(struct CondVariable * cv, struct SignalSemaphore * lock, struct timespec * ts);
-
-
-
-
-/* Defines to override pthread stuff */
-#define pthread_t APTR
-#define pthread_mutex_t struct SignalSemaphore
-#define pthread_cond_t struct CondVariable
-#define pthread_key_t APTR
-#define pthread_attr_t APTR
-#define PTHREAD_CREATE_DETACHED 1
-
-void pthread_sigmask(int blocktype, uint32 * mask_ptr, void *unused1);
-void pthread_mutex_init(pthread_mutex_t *lock, void*used);
-int pthread_mutex_lock(struct SignalSemaphore *lock);
-int pthread_mutex_unlock(struct SignalSemaphore * lock);
-int pthread_mutex_trylock(struct SignalSemaphore * lock);
-void pthread_cond_init(struct CondVariable *cv, void * unused);
-
-int pthread_cond_signal(struct CondVariable * cv);
-int pthread_cond_broadcast(struct CondVariable * cv);
-#define pthread_attr_init(attr) {}
-#define pthread_attr_getstacksize(unused, unused2) 1*MB
-#define pthread_attr_setstacksize(unused, unused2) {}
-#define pthread_attr_setdetachstate {}
-#define pthread_key_create(pt_key_t, unused) { *pt_key_t = FindTask(NULL); }
-void* pthread_getspecific(void * self);
-void pthread_setspecific(void * self, void *value);// { JA_TRACE("set spec\n"); FindTask(NULL)->tc_UserData = value;}
-#define pthread_self() FindTask(NULL)
-
-
-#define MAGIC_SECRET_PROCESSDATA 999
-#define MAGIC_SECRET_JAVATHREADDATA 998
-int pthread_create2(pthread_t * tid, void * attributes, void * (*func)(void*), void ** thread, char *name);
-int pthread_create(pthread_t * tid, void * attributes, void * (*func)(void*), void * thread);
-/*
-#define pthread_create(tid, attributes, func, thread) \
-    (*(tid) = CreateNewProcTags(\
-            NP_Entry, &(func),        \
-            NP_Name, "Java thread",  \
-            NP_Child, TRUE,           \
-            NP_ExitData, thread,       \
-            NP_FinalData, MAGIC_SECRET_PROCESSDATA,\
-            TAG_END))!=NULL?0:1
-#define pthread_create(tid, attributes, func, thread, name) \
-    (*(tid) = CreateNewProcTags(\
-            NP_Entry, &(func),        \
-            NP_Name, name,  \
-            NP_Child, TRUE,           \
-            NP_ExitData, thread,       \
-            NP_FinalData, MAGIC_SECRET_PROCESSDATA,\
-            TAG_END))!=NULL?0:1
-*/
-
- 
-
-int pthread_cond_wait(struct CondVariable *cv, struct SignalSemaphore * lock);
-int pthread_cond_timedwait(struct CondVariable * cv, struct SignalSemaphore * lock, struct timespec * absoluteTime);
-
-#endif
diff --git a/src/os/amiga/sched.h b/src/os/amiga/sched.h
deleted file mode 100644
index cfe68d2..0000000
--- a/src/os/amiga/sched.h
+++ /dev/null
@@ -1,5 +0,0 @@
-
-#ifndef AMIGA_SCHED_H
-#define AMIGA_SCHED_H
-// dummy
-#endif
diff --git a/src/os/amiga/signal.h b/src/os/amiga/signal.h
deleted file mode 100644
index a5f3af5..0000000
--- a/src/os/amiga/signal.h
+++ /dev/null
@@ -1,89 +0,0 @@
-
-#ifndef AMIGA_SIGNAL_H
-#define AMIGA_SIGNAL_H
-
-//#include "sys/signal.h"
-
-#include <proto/exec.h>
-#include <proto/dos.h>
-#include <exec/semaphores.h>
-#include "pthread.h"
-
-#define BYTETOBINARYPATTERN "%d%d%d%d %d%d%d%d %d%d%d%d %d%d%d%d.%d%d%d%d %d%d%d%d %d%d%d%d %d%d%d%d\n"
-#define BYTETOBINARY(byte)  \
-  (byte & 0x80000000 ? 1 : 0), \
-  (byte & 0x40000000 ? 1 : 0), \
-  (byte & 0x20000000 ? 1 : 0), \
-  (byte & 0x10000000 ? 1 : 0), \
-  (byte & 0x8000000 ? 1 : 0), \
-  (byte & 0x4000000 ? 1 : 0), \
-  (byte & 0x2000000 ? 1 : 0), \
-  (byte & 0x1000000 ? 1 : 0), \
-  (byte & 0x800000 ? 1 : 0), \
-  (byte & 0x400000 ? 1 : 0), \
-  (byte & 0x200000 ? 1 : 0), \
-  (byte & 0x100000 ? 1 : 0), \
-  (byte & 0x80000 ? 1 : 0), \
-  (byte & 0x40000 ? 1 : 0), \
-  (byte & 0x20000 ? 1 : 0), \
-  (byte & 0x10000 ? 1 : 0), \
-  (byte & 0x8000 ? 1 : 0), \
-  (byte & 0x4000 ? 1 : 0), \
-  (byte & 0x2000 ? 1 : 0), \
-  (byte & 0x1000 ? 1 : 0), \
-  (byte & 0x0800 ? 1 : 0), \
-  (byte & 0x0400 ? 1 : 0), \
-  (byte & 0x0200 ? 1 : 0), \
-  (byte & 0x0100 ? 1 : 0), \
-  (byte & 0x0080 ? 1 : 0), \
-  (byte & 0x0040 ? 1 : 0), \
-  (byte & 0x0020 ? 1 : 0), \
-  (byte & 0x0010 ? 1 : 0), \
-  (byte & 0x0008 ? 1 : 0), \
-  (byte & 0x0004 ? 1 : 0), \
-  (byte & 0x0002 ? 1 : 0), \
-  (byte & 0x0001 ? 1 : 0)
-
-typedef unsigned long sigset_t;
-
-typedef void (*_sig_func_ptr)(int);
-
-/* These depend upon the type of sigset_t, which right now
-   is always a long.. They're in the POSIX namespace, but
-   are not ANSI. */
-#define sigaddset(what,sig) (*(what) |= (1<<(sig)), 0)
-#define sigdelset(what,sig) (*(what) &= ~(1<<(sig)), 0)
-#define sigemptyset(what)   (*(what) = 0, 0)
-#define sigfillset(what)    (*(what) = ~(0), 0)
-#define sigismember(what,sig) (((*(what)) & (1<<(sig))) != 0)
-
-#define SIGKILL 2
-#define SIGINT  SIGBREAKB_CTRL_C
-#define SIGUSR1 16
-#define SIGQUIT 6
-#define SIGTERM 9
-#define SIGPIPE 10
-#define SIGUSR2 17      // used for JAmiga specific CondWait
-
-/* Define our trace here aswell */
-//#define JA_TRACE(x, y...) Forbid(); DebugPrintF("TRACE %-5ld %15s:%-5d", ((struct Process *)FindTask(NULL))->pr_ProcessID,__FILE__,__LINE__); DebugPrintF(x, ## y); Permit();
-#define SIG_UNBLOCK 1001
-#define SIG_BLOCK 1002
-#define SIG_SETMASK 1003        /* unused by jamvm, here for completeness */
-#define SA_RESTART 3000
-/* A normal pointer */
-#define sigjmp_buf long
-//#define alloca(size) AllocMem(size, MEMF_PUBLIC)
-struct sigaction {
-    void (*sa_handler)(int);
-    uint32 sa_flags;
-    uint32 sa_mask;
-};
-
-void sigprocmask(int blocktype, uint32 * mask_ptr, void *unused1);
-void sigsuspend(uint32 * maskptr);
-void sigaction(uint32 sig, struct sigaction * act, void *unused);
-void sigwait(uint32 * maskptr, uint32 * sigptr);
-int sigsetjmp(sigjmp_buf env, int savemask);
-#endif
-
diff --git a/src/os/amiga/stdlib.h b/src/os/amiga/stdlib.h
deleted file mode 100644
index 5dfc5bf..0000000
--- a/src/os/amiga/stdlib.h
+++ /dev/null
@@ -1,30 +0,0 @@
-
-#ifndef JAMIGA_STDLIB_H
-#define JAMIGA_STDLIB_H
-
-#include <proto/exec.h>
-#include <proto/timer.h>
-#include <sys/time.h>
-#ifdef _SYS_CLIB2_STDC_H
-#include "/SDK/clib2/include/stdlib.h"
-#else
-#include "/SDK/newlib/include/stdlib.h"
-#endif
-
-#define PROT_READ 1
-#define PROT_WRITE 2
-#define PROT_EXEC 4
-
-#define MAP_PRIVATE 3
-#define MAP_ANON 4
-#define MAP_FAILED NULL
-#define MT_MALLOC 1
-#define mmap(addr, length, prot, flags, fd, offset) mymmap(addr, length, prot, flags, fd, offset, __FILE__, __LINE__)
-#define munmap(addr,size) mymunmap(addr, size, __FILE__, __LINE__)
-//#define malloc(x) mymalloc(x, MT_MALLOC, __FILE__, __LINE__)
-//#define realloc(oldptr, size) myrealloc(oldptr, size, __FILE__, __LINE__)
-//#define free(x) myfree(x, MT_MALLOC, __FILE__, __LINE__)
-
-
-
-#endif
diff --git a/src/os/amiga/time.h b/src/os/amiga/time.h
deleted file mode 100644
index d0e45f6..0000000
--- a/src/os/amiga/time.h
+++ /dev/null
@@ -1,20 +0,0 @@
-
-#ifndef AMIGA_TIME_H
-#define AMIGA_TIME_H
-
-#include <sys/time.h>
-#include <sys/select.h>
-#include <proto/exec.h>
-#include <proto/timer.h>
-
-#ifdef _SYS_CLIB2_STDC_H
-#define gettimeofday amiga_gettimeofday
-void amiga_gettimeofday(struct timeval *__p, struct timezone *__z);
-#endif
-
-struct timespec {
-    unsigned int tv_sec;
-    unsigned int tv_nsec;
-} timespec;
-
-#endif
diff --git a/src/properties.c b/src/properties.c
index b453d7b..9793439 100644
--- a/src/properties.c
+++ b/src/properties.c
@@ -150,12 +150,96 @@ char *getExecutionEngineName() {
 }
 
 void setUserDirProperty(Object *properties) {
-    char *cwd = getCwd();
+    char *cwd;
+
+#ifdef __amigaos4__
+    /* user.dir = the directory the user ran `java` from, captured before the VM
+       chdir'd into its own install drawer (amigaSetupCwd).  An application's
+       relative paths -- its config files, its data drawer -- must resolve THERE,
+       not in the runtime's install drawer; getting this wrong is what made a
+       plain `java -jar App.jar` go looking for the app's files under JAVA: (and,
+       via the Unix-absolute spelling, pop "Please insert volume /Work:").  The
+       runtime's own lists no longer depend on user.dir: sun.boot.library.path,
+       java.ext.dirs and java.endorsed.dirs are java.home-absolute.  Presented
+       Unix-absolute ("/Volume:dir") because sun.nio.fs rejects a default
+       directory that does not start with '/'; amigaPath() strips it back off at
+       the native chokepoints. */
+    cwd = amiga_launch_cwd != NULL
+              ? strcpy(sysMalloc(strlen(amiga_launch_cwd) + 1), amiga_launch_cwd)
+              : getCwd();
+    if(cwd != NULL && cwd[0] != '/') {
+        char *slashed = sysMalloc(strlen(cwd) + 2);
+        slashed[0] = '/';
+        strcpy(slashed + 1, cwd);
+        sysFree(cwd);
+        cwd = slashed;
+    }
+#else
+    cwd = getCwd();
+#endif
 
     setProperty(properties, "user.dir", cwd);
     sysFree(cwd);
 }
 
+#ifdef __amigaos4__
+/* AmigaOS has no per-user home directory, but Java applications very much
+   expect user.home to be a real, writable, STABLE one: java.util.prefs puts
+   .java/.userPrefs there, applications put their own dot-drawer there, and they
+   typically create only the LAST component (Invoicex does a single-level
+   File.mkdir()), so the parent has to exist already.  With no value at all
+   setProperty() above substitutes "?" -- and '?' is an AmigaDOS pattern
+   character, so every such path blew up ("?/.invoicex/finestre.txt (No such
+   file or directory)").
+
+   ENV: is the AmigaOS global settings drawer, so that is what we use.  Note it
+   is normally an assign to RAM:Env, rebuilt from ENVARC: at every boot -- what
+   applications write there does NOT survive a reboot unless something copies it
+   back to ENVARC:.
+
+   Order: an explicit HOME wins (so `SetEnv HOME Work:MyHome` overrides all of
+   this), then ENV:, then java.home as a last resort for a system where ENV: is
+   somehow not assigned.
+
+   Unlike user.dir this is given in PLAIN AmigaDOS form ("ENV:", not "/ENV:"):
+   the niopatch java.io.UnixFileSystem already treats a "Volume:" prefix as
+   absolute and joins it without a separator, and it keeps the paths users see in
+   messages looking like AmigaOS paths.  The one place the leading '/' still
+   buys something is sun.nio.fs, whose UnixPath calls a path relative unless it
+   starts with '/' -- so Paths.get(user.home).toAbsolutePath() would resolve
+   against user.dir.  Nothing in the JDK does that with user.home (java.util.prefs
+   and friends go through java.io.File), but keep it in mind. */
+static char *amigaUserHome(void) {
+    char *env = getenv("HOME");
+    char *home;
+
+    if(env != NULL && *env != '\0')
+        return strcpy(sysMalloc(strlen(env) + 1), env);
+
+    if(amigaIsDosName("ENV", 3))
+        return strcpy(sysMalloc(sizeof("ENV:")), "ENV:");
+
+    home = getJavaHome();
+    if(home == NULL || *home == '\0')
+        return NULL;
+
+    /* java.home is already AmigaDOS form ("Work:Java") */
+    return strcpy(sysMalloc(strlen(home) + 1), home);
+}
+
+/* Likewise user.name: AmigaOS is single-user and sets neither USER nor
+   USERNAME, and java.util.prefs embeds the value in file names
+   (".userRootModFile." + user.name), so "?" produced unopenable files. */
+static char *amigaUserName(void) {
+    char *env = getenv("USER");
+
+    if(env == NULL || *env == '\0')
+        env = getenv("USERNAME");
+
+    return (env != NULL && *env != '\0') ? env : "amiga";
+}
+#endif
+
 void setOSProperties(Object *properties) {
     struct utsname info;
 
@@ -183,17 +267,58 @@ void addDefaultProperties(Object *properties) {
 
     setProperty(properties, "java.home", getJavaHome());
     setProperty(properties, "java.class.path", getClassPath());
+#ifdef __amigaos4__
+    /* sun.boot.class.path must use the Java path.separator (';' on AmigaOS) with
+       resolvable absolute entries, NOT the raw ':'-joined C boot path -- otherwise
+       sun.misc.Launcher misreads it as one "niopatch.zip:..." entry, popping a bogus
+       "Please insert volume niopatch.zip" requester and breaking getBootstrapResource()
+       (which in turn makes sun.reflect.misc.MethodUtil's Trampoline lookup fall back to
+       the bootstrap loader and throw).  See amigaBootClassPathProperty() in class.c. */
+    {
+        extern char *amigaBootClassPathProperty(void);
+        char *bcp = amigaBootClassPathProperty();
+        setProperty(properties, "sun.boot.class.path", bcp);
+        sysFree(bcp);
+    }
+#else
     setProperty(properties, "sun.boot.class.path", getBootClassPath());
+#endif
     setProperty(properties, "sun.boot.library.path", getBootDllPath());
     setProperty(properties, "java.library.path", getDllPath());
     setProperty(properties, "java.endorsed.dirs", getEndorsedDirs());
     setProperty(properties, "java.ext.dirs", classlibDefaultExtDirs());
+#ifdef __amigaos4__
+    /* T: is AmigaOS's temporary drawer; "/tmp" would be read by AmigaDOS as
+       "tmp in the parent directory".  Unix-absolute spelling as everywhere else. */
+    setProperty(properties, "java.io.tmpdir", "/T:");
+#else
     setProperty(properties, "java.io.tmpdir", "/tmp");
+#endif
     setProperty(properties, "file.separator", "/");
+#ifdef __amigaos4__
+    /* On AmigaOS ':' is the volume separator (RAM:, Work:), so it cannot also be
+       the path-list separator -- absolute paths in java.class.path /
+       java.library.path / sun.boot.library.path would be mangled.  Use ';' like
+       Windows (whose ':' is the drive separator).  ':' is still ACCEPTED in a
+       -cp / -Xbootclasspath the user types: see isPathListSep() in class.c. */
+    setProperty(properties, "path.separator", ";");
+#else
     setProperty(properties, "path.separator", ":");
+#endif
     setProperty(properties, "line.separator", "\n");
+#ifdef __amigaos4__
+    /* AmigaOS sets neither, and a NULL here becomes "?" -- see amigaUserHome() */
+    setProperty(properties, "user.name", amigaUserName());
+    {
+        char *home = amigaUserHome();
+
+        setProperty(properties, "user.home", home);
+        sysFree(home);
+    }
+#else
     setProperty(properties, "user.name", getenv("USER"));
     setProperty(properties, "user.home", getenv("HOME"));
+#endif
 
     setOSProperties(properties);
     setUserDirProperty(properties);
diff --git a/src/thread.c b/src/thread.c
index e4fb7d1..b5b4200 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -110,6 +110,12 @@ static int threads_waiting_to_start = 0;
 
 static int main_exited = FALSE;
 
+#ifdef __amigaos4__
+/* Cooperative-suspension gate, polled by the interpreter dispatch loop
+   (see suspendLoop below + interp-indirect.h THREAD_POLL_SUSPEND). */
+volatile int suspend_pending_count = 0;
+#endif
+
 /* Bitmap - used for generating unique thread ID's */
 #define MAP_INC 32
 static unsigned int *tidBitmap = NULL;
@@ -407,6 +413,16 @@ int getThreadsCount() {
     return threads_count;
 }
 
+int isMainVMThread() {
+    return threadSelf() == &main_thread;
+}
+
+void requestExitVMWaitBreak() {
+    pthread_mutex_lock(&exit_lock);
+    pthread_cond_broadcast(&exit_cv);
+    pthread_mutex_unlock(&exit_lock);
+}
+
 int getPeakThreadsCount() {
     return peak_threads_count;
 }
@@ -613,8 +629,33 @@ void *detachThread(Thread *thread) {
     Object *group = INST_DATA(java_thread, Object*, group_offset);
 
     /* If there's an exception pending, it is uncaught */
-    if(exceptionOccurred0(ee))
+    if(exceptionOccurred0(ee)) {
+#ifdef __amigaos4__
+        /* ...unless we are the ones who caused it.  Shutting the VM down here
+           means interrupting every thread out of Object.wait/sleep so it can
+           self-terminate (see exitWakeAllThreads: clib4's exit() waits for all
+           pthread children, so a thread left alive wedges the process).  A
+           thread woken that way sees an InterruptedException and gets to run its
+           catch block first, and code that treats an interrupt as impossible
+           turns it into something alarming --
+
+             Exception in thread "SeedGenerator Thread" java.lang.InternalError:
+               internal error: SeedGenerator thread generated an exception.
+               Caused by: java.lang.InterruptedException
+
+           printed AFTER a run that succeeded.  A stock JVM never shows this:
+           daemon threads are simply abandoned, never resumed to unwind.  Stay
+           quiet once vm_exiting is set -- the VM is going away and this is our
+           own interrupt coming back to us.  Exceptions during normal running
+           are unaffected. */
+        extern volatile int vm_exiting;
+
+        if(vm_exiting)
+            clearException();
+        else
+#endif
         uncaughtException();
+    }
 
     /* Don't do anything if this is the main thread */
     if(thread->prev == NULL)
@@ -787,10 +828,18 @@ void detachJNIThread(Thread *thread) {
     detachThread(thread);
 }
 
+#ifdef __amigaos4__
+#include <proto/exec.h>
+#define VMT(s) DebugPrintF("[VMT] %s\n", (s))
+#else
+#define VMT(s)
+#endif
+
 static void *shell(void *args) {
     void *start = ((void**)args)[1];
     Thread *self = ((Thread**)args)[2];
 
+    VMT("shell entered");
     if(main_exited)
         return NULL;
 
@@ -798,9 +847,32 @@ static void *shell(void *args) {
        exist.  As the root group is main, we add it to that for now... */
     attachThread(((char**)args)[0], TRUE, &self, self,
                  INST_DATA(main_ee.thread, Object*, group_offset));
+    VMT("shell attached");
 
     sysFree(args);
     (*(void(*)(Thread*))start)(self);
+
+#ifdef __amigaos4__
+    /* A VM helper thread (Finalizer/Reference Handler) reaches here when its loop
+       returns during cooperative VM shutdown -- shell() does NOT call detachThread,
+       so without this the struct stays LINKED in the thread list (and threads_count
+       is not dropped) after the pthread is gone.  The exit re-interrupt walk
+       (exitWakeAllThreads, called repeatedly from amiga_exit) then traverses the
+       dead struct -> use-after-free crash.  Unlink it and drop the count under the
+       list lock so the re-walk skips it and amiga_exit's getThreadsCount() drains. */
+    {
+        extern volatile int vm_exiting;
+        if(vm_exiting) {
+            pthread_mutex_lock(&lock);
+            if(self->prev != NULL && (self->prev->next = self->next))
+                self->next->prev = self->prev;
+            if(threads_count > 0)
+                threads_count--;
+            pthread_mutex_unlock(&lock);
+        }
+    }
+#endif
+
     return NULL;
 }
 
@@ -814,7 +886,14 @@ void createVMThread(char *name, void (*start)(Thread*)) {
     args[2] = thread;
 
     memset(thread, 0, sizeof(Thread));
-    pthread_create(&tid, &attributes, shell, args);
+    {
+        int _pc = pthread_create(&tid, &attributes, shell, args);
+        DebugPrintF("[VMT] pthread_create(&attributes) rc=%ld\n", (long)_pc);
+        if(_pc != 0) {
+            int _pc2 = pthread_create(&tid, NULL, shell, args);
+            DebugPrintF("[VMT] pthread_create(NULL) rc=%ld\n", (long)_pc2);
+        }
+    }
 
     /* Wait for thread to start */
 
@@ -822,6 +901,7 @@ void createVMThread(char *name, void (*start)(Thread*)) {
     while(classlibGetThreadState(thread) == CREATING)
         pthread_cond_wait(&cv, &lock);
     pthread_mutex_unlock(&lock);
+    VMT("createVMThread done");
 }
 
 Object *runningThreadStackTrace(Thread *thread, int max_depth,
@@ -868,6 +948,9 @@ Object *runningThreadStackTrace(Thread *thread, int max_depth,
 }
 
 void suspendThread(Thread *thread) {
+#ifdef __amigaos4__
+    suspend_pending_count++;
+#endif
     thread->suspend = TRUE;
     MBARRIER();
 
@@ -900,6 +983,9 @@ void resumeThread(Thread *thread) {
               thread->id);
         sched_yield();
     }
+#ifdef __amigaos4__
+    suspend_pending_count--;
+#endif
 }
 
 void suspendAllThreads(Thread *self) {
@@ -907,6 +993,9 @@ void suspendAllThreads(Thread *self) {
 
     TRACE("Thread %p id: %d is suspending all threads\n", self, self->id);
     pthread_mutex_lock(&lock);
+#ifdef __amigaos4__
+    suspend_pending_count++;
+#endif
 
     for(thread = &main_thread; thread != NULL; thread = thread->next) {
         if(thread == self)
@@ -982,6 +1071,9 @@ void resumeAllThreads(Thread *self) {
     }
 
     all_threads_suspended = FALSE;
+#ifdef __amigaos4__
+    suspend_pending_count--;
+#endif
     if(threads_waiting_to_start) {
         TRACE("%d threads waiting to start...\n", threads_waiting_to_start);
         pthread_cond_broadcast(&cv);
@@ -991,6 +1083,129 @@ void resumeAllThreads(Thread *self) {
     pthread_mutex_unlock(&lock);
 }
 
+#ifdef __amigaos4__
+/* COOPERATIVE suspension (Amiga/clib4): pthread_kill() only sets a raw Exec
+   signal bit -- the SIGUSR1 handler never runs, so signal-based stop-the-world
+   cannot stop a thread executing bytecode.  Instead, running threads POLL their
+   suspend flag from the interpreter dispatch loop (THREAD_POLL_SUSPEND in
+   interp-indirect.h, gated on suspend_pending_count) and park here.  sigsetjmp
+   still spills the registers into env on the stack for GC root scanning.
+   (suspend_pending_count is defined near the top of this file.) */
+static void suspendLoop(Thread *thread) {
+    char old_state = thread->suspend_state;
+    sigjmp_buf env;
+
+    sigsetjmp(env, FALSE);
+
+    thread->stack_top = &env;
+    thread->suspend_state = SUSP_SUSPENDED;
+    MBARRIER();
+
+    while(thread->suspend && old_state == SUSP_NONE)
+        usleep(1000);
+
+    thread->suspend_state = old_state;
+    MBARRIER();
+}
+
+/* VM exit (AmigaOS): clib4 exit() waits for ALL pthread children, so any Java
+   thread still alive when the exiting thread calls exit() wedges the process
+   ("Parent suspended, waiting for child to exit").  exitWakeAllThreads()
+   (called from terminateVMThreads) interrupts every thread out of
+   Object.wait/sleep; back in the dispatch loop they hit this poll and
+   self-terminate.  Only the thread-list/count bookkeeping is updated --
+   Java-level state no longer matters, but threads_count must drain so
+   amiga_exit knows when it is safe to call exit(). */
+extern volatile int vm_exiting;
+static Thread *vm_exit_thread = NULL;
+
+void exitWakeAllThreads() {
+    static int gate_opened = FALSE;
+    Thread *self = threadSelf();
+    Thread *thread;
+
+    vm_exit_thread = self;
+    /* the dispatch-loop poll (THREAD_POLL_SUSPEND) is gated on
+       suspend_pending_count -- open the gate permanently so every thread
+       still executing bytecode reaches threadPollSuspend and dies there */
+    if(!gate_opened) {
+        gate_opened = TRUE;
+        suspend_pending_count++;
+    }
+    MBARRIER();
+
+    pthread_mutex_lock(&lock);
+    for(thread = &main_thread; thread != NULL; thread = thread->next)
+        if(thread != self)
+            threadInterrupt(thread);
+    pthread_mutex_unlock(&lock);
+}
+
+/* diagnostic: name+state of every thread still attached (exit-wedge hunts) */
+void exitDumpRemainingThreads() {
+    Thread *thread;
+    char buffer[80];
+
+    pthread_mutex_lock(&lock);
+    for(thread = &main_thread; thread != NULL; thread = thread->next) {
+        classlibThreadName2Buff(thread->ee->thread, buffer, sizeof(buffer));
+        jam_fprintf(stderr, "[EXIT]   live thread \"%s\" state=%s\n",
+                    buffer, getThreadStateString(thread));
+    }
+    pthread_mutex_unlock(&lock);
+}
+
+/* Same as exitDetachAndDie for the calling thread: used by amiga_exit() when a
+   non-main thread starts the shutdown and has to remove itself from the count
+   main is waiting on.  A plain pthread_exit() there would leave the Thread
+   linked and threads_count too high, and main would wait out its whole timeout
+   for a thread that had already gone. */
+void exitDetachAndDieSelf(void);
+
+static void exitDetachAndDie(Thread *thread) {
+    pthread_mutex_lock(&lock);
+    if((thread->prev->next = thread->next))
+        thread->next->prev = thread->prev;
+    threads_count--;
+    pthread_mutex_unlock(&lock);
+    pthread_exit(NULL);
+}
+
+void exitDetachAndDieSelf(void) {
+    Thread *self = threadSelf();
+
+    /* main is the list head and has no prev; it must never unlink itself. */
+    if(self == NULL || self == &main_thread || self->prev == NULL)
+        pthread_exit(NULL);
+
+    exitDetachAndDie(self);
+}
+
+void threadPollSuspend() {
+    Thread *thread = threadSelf();
+
+#ifdef __amigaos4__
+    /* The main thread is excluded from exitDetachAndDie below because only the
+       main task may take an AmigaOS 4 process down -- but that also means a
+       shutdown started anywhere else (Ctrl-C arrives on the Signal Handler
+       thread) has no way to finish.  This is where the main thread picks the
+       request up, at a dispatch point, and completes it.  No-op unless one is
+       pending; does not return when there is. */
+    if(vm_exiting && thread == &main_thread) {
+        extern void amigaMainThreadExitIfRequested(void);
+        amigaMainThreadExitIfRequested();
+    }
+#endif
+
+    if(vm_exiting && thread != NULL && thread != vm_exit_thread
+                  && thread != &main_thread)
+        exitDetachAndDie(thread);
+
+    if(thread != NULL && thread->suspend
+                      && thread->suspend_state == SUSP_NONE)
+        suspendLoop(thread);
+}
+#else
 static void suspendLoop(Thread *thread) {
     char old_state = thread->suspend_state;
     sigjmp_buf env;
@@ -1012,6 +1227,7 @@ static void suspendLoop(Thread *thread) {
     thread->suspend_state = old_state;
     MBARRIER();
 }
+#endif
 
 static void suspendHandler(int sig) {
     Thread *thread = threadSelf();
@@ -1138,8 +1354,21 @@ static void initialiseSignalMask() {
     sigset_t mask;
 
     sigemptyset(&mask);
+#ifndef __amigaos4__
+    /* Blocking these is right for the gnuclasspath classlib, whose signal
+       thread consumes them with sigwait() -- there the block is what makes the
+       sigwait work.  It is WRONG for the openjdk classlib, which instead
+       installs ordinary sigaction handlers (classlibInitialiseSignals for
+       SIGQUIT, JVM_RegisterSignal for whatever java.lang.Terminator asks for,
+       i.e. SIGINT): a blocked signal never reaches its handler, and nothing
+       here ever unblocks them again -- the only other sigmask calls in this
+       file are enable/disableSuspend, and those touch SIGUSR1 alone.
+       Ctrl-C was therefore dropped before it could do anything, which on
+       AmigaOS meant no way at all to interrupt a running program. */
     sigaddset(&mask, SIGQUIT);
     sigaddset(&mask, SIGINT);
+#endif
+    /* SIGPIPE stays blocked everywhere: we want EPIPE from write(), not death. */
     sigaddset(&mask, SIGPIPE);
     sigprocmask(SIG_BLOCK, &mask, NULL);
 }
@@ -1234,6 +1463,21 @@ Object *runningThreadObjects() {
 
 void exitVM(int status) {
     main_exited = TRUE;
+#ifdef __amigaos4__
+    DebugPrintF("[EXIT] exitVM enter status=%d\n", status);
+
+    /* On AmigaOS4 the final process exit must happen on the main thread.
+       Calling System.exit() here can re-enter jamvm_exit from non-main JVM
+       threads (e.g. AWT shutdown path), which then delegates.  In practice,
+       classlibVMShutdown() can also block in this phase; use the direct VM
+       shutdown path and terminate from main deterministically. */
+    DebugPrintF("[EXIT] exitVM shutdownVM begin [main-only path]\n");
+    shutdownVM();
+    DebugPrintF("[EXIT] exitVM shutdownVM done [main-only path]\n");
+    DebugPrintF("[EXIT] exitVM calling jamvm_exit(%d) [main-only path]\n", status);
+    jamvm_exit(status);
+    return;
+#endif
 
     /* Execute System.exit() to run any registered shutdown hooks.
        In the unlikely event that System.exit() can't be found, or
@@ -1248,22 +1492,37 @@ void exitVM(int status) {
         }
     }
 
+#ifdef __amigaos4__
+    DebugPrintF("[EXIT] exitVM calling jamvm_exit(%d)\n", status);
+#endif
     jamvm_exit(status);
 }
 
 void mainThreadWaitToExitVM() {
     Thread *self = threadSelf();
     TRACE("Waiting for %d non-daemon threads to exit\n", non_daemon_thrds);
+#ifdef __amigaos4__
+    extern volatile int vm_exiting;
+    DebugPrintF("[EXIT] mainThreadWaitToExitVM enter non_daemon=%d\n",
+                non_daemon_thrds);
+#endif
 
     disableSuspend(self);
     pthread_mutex_lock(&exit_lock);
 
     classlibSetThreadState(self, WAITING);
+#ifdef __amigaos4__
+    while(non_daemon_thrds && !vm_exiting)
+#else
     while(non_daemon_thrds)
+#endif
         pthread_cond_wait(&exit_cv, &exit_lock);
 
     pthread_mutex_unlock(&exit_lock);
     enableSuspend(self);
+#ifdef __amigaos4__
+    DebugPrintF("[EXIT] mainThreadWaitToExitVM done\n");
+#endif
 }
 
 void mainThreadSetContextClassLoader(Object *loader) {
@@ -1324,6 +1583,13 @@ int initialiseThreadStage1(InitArgs *args) {
     return TRUE;
 }
 
+#ifdef __amigaos4__
+#include <proto/exec.h>
+#define TS2(s) DebugPrintF("[TS2] %s\n", (s))
+#else
+#define TS2(s)
+#endif
+
 int initialiseThreadStage2(InitArgs *args) {
     Class *thrdGrp_class;
     Object *main_group, *java_thread;
@@ -1332,9 +1598,11 @@ int initialiseThreadStage2(InitArgs *args) {
     MethodBlock *run, *remove_thread;
 
     /* Load thread class and register reference for compaction threading */
+    TS2("load Thread");
     if((thread_class = findSystemClass0(SYMBOL(java_lang_Thread))) == NULL)
         goto error;
 
+    TS2("Thread loaded");
     registerStaticClassRef(&thread_class);
 
     name = findField(thread_class, SYMBOL(name), classlibThreadNameType());
@@ -1378,11 +1646,13 @@ int initialiseThreadStage2(InitArgs *args) {
 
     /* Classlib specific initialisation prior to main thread being
        setup */
+    TS2("classlibThreadPreInit");
     main_group = classlibThreadPreInit(thread_class, thrdGrp_class);
     if(main_group == NULL)
         goto error;
 
     /* Initialise the Java-level thread objects for the main thread */
+    TS2("initJavaThread");
     java_thread = initJavaThread(&main_thread, FALSE, "main", main_group);
     if(java_thread == NULL)
         goto error;
@@ -1391,19 +1661,33 @@ int initialiseThreadStage2(InitArgs *args) {
 
     /* Setup signal handling.  This will be inherited by all
        threads created within Java */
+    TS2("initialiseSignals");
     if(!initialiseSignals())
         goto error;
 
     /* Classlib specific initialisation once main thread has been
        setup */
+    TS2("classlibThreadPostInit");
     if(!classlibThreadPostInit())
         goto error;
+    TS2("createVMThread(Signal Handler)");
 
     /* Create the signal handler thread.  It is responsible for
        catching and handling SIGQUIT (thread dump) and SIGINT
        (user-termination of the VM, e.g. via Ctrl-C).  Note it
        must be a valid Java-level thread as it needs to run the
        shutdown hooks in the event of user-termination */
+    /* This used to be skipped on AmigaOS, on the grounds that it blocks forever
+       in sigwait() and so could not be shut down without hanging clib4's exit().
+       That reasoning belongs to the gnuclasspath classlib: the openjdk one we
+       build does not sigwait at all, it waits on a POSIX semaphore that
+       signalHandler() posts from whichever thread took the signal.  Without the
+       thread, nothing ever drains pending_signals[] and Ctrl-C went nowhere even
+       once the mask above stopped swallowing it.
+       The shutdown objection was real though, so the loop now has an exit:
+       amiga_exit() calls classlibSignalThreadExit() before draining the thread
+       count, and shell() already unlinks a helper thread whose loop returns
+       while vm_exiting. */
     createVMThread("Signal Handler", classlibSignalThread);
 
     return TRUE;
diff --git a/src/zip.c b/src/zip.c
index b901856..e7a9e68 100644
--- a/src/zip.c
+++ b/src/zip.c
@@ -120,6 +120,10 @@ int zipComp(char *path1, char *path2) {
     return path1_len == path2_len && !memcmp(path1, path2, path1_len);
 }
 
+#ifdef __amigaos4__
+#include <proto/exec.h>
+#endif
+
 ZipFile *processArchive(char *path) {
     unsigned char magic[SIG_LEN];
     unsigned char *data, *pntr;
@@ -128,21 +132,47 @@ ZipFile *processArchive(char *path) {
     HashTable *hash_table;
     ZipFile *zip;
 
-    if((fd = open(path, O_RDONLY)) == -1)
+#ifdef __amigaos4__
+    /* an -Xbootclasspath entry may arrive in the Unix-absolute Java form */
+    path = (char*)amigaPath(path);
+#endif
+
+    if((fd = open(path, O_RDONLY)) == -1) {
+#ifdef __amigaos4__
+        DebugPrintF("[ZIP] open FAILED '%s'\n", path);
+#endif
         return NULL;
+    }
 
     /* First 4 bytes must be the signature for the first local file header */
-    if(read(fd, &magic[0], SIG_LEN) != SIG_LEN ||
-                    READ_LE_INT(magic) != LOC_FILE_HEADER_SIG)
-        goto error;
+    {
+        int _n = read(fd, &magic[0], SIG_LEN);
+#ifdef __amigaos4__
+        DebugPrintF("[ZIP] '%s' fd=%d read=%d sig=%08x want=%08x\n", path, fd,
+                    _n, (unsigned)READ_LE_INT(magic),
+                    (unsigned)LOC_FILE_HEADER_SIG);
+#endif
+        if(_n != SIG_LEN || READ_LE_INT(magic) != LOC_FILE_HEADER_SIG)
+            goto error;
+    }
 
     /* Get the length */
     len = lseek(fd, 0, SEEK_END);
+#ifdef __amigaos4__
+    DebugPrintF("[ZIP] '%s' len=%d\n", path, len);
+#endif
 
-    /* Mmap the file into memory */
-    if((data = (unsigned char*)mmap(0, len, PROT_READ, MAP_FILE |
-                                            MAP_PRIVATE, fd, 0)) == MAP_FAILED)
-        goto error;
+    /* Read the whole file into memory.  JamVM originally mmap'd the file, but
+       clib4 has no file-backed mmap (only anonymous); a malloc'd buffer works
+       fine since the rest of the code just indexes into zip->data. */
+    data = (unsigned char*)sysMalloc(len);
+    {
+        int got = 0, r;
+        if(lseek(fd, 0, SEEK_SET) != 0) { sysFree(data); goto error; }
+        while(got < len && (r = read(fd, data + got, len - got)) > 0)
+            got += r;
+        if(got != len) { sysFree(data); goto error; }
+    }
 
     /* Locate the end of central directory record by searching backwards for
        the record signature. */
@@ -216,7 +246,7 @@ ZipFile *processArchive(char *path) {
     return zip;
 
 error2:
-    munmap(data, len);
+    sysFree(data);
 
 error:
     close(fd);