jamvm-amiga-openjdk.patch

From 87c87fbe99dc7a6c185c6eb16b177ff0ddd105a4 Mon Sep 17 00:00:00 2001
From: Richard Gibbs <wofderfs@googlemail.com>
Date: Tue, 9 Jun 2026 22:30:57 +0100
Subject: [PATCH 01/13] Amiga OS4 / clib4 port + OpenJDK 8 classlib bring-up

JAmiga JamVM revival on ppc-amigaos-gcc 11.5 + clib4, plus OpenJDK 8
(Temurin 8 rt.jar) class-library integration:
- clib4 migration of os/amiga (dlopen natives, drop JAmiga pthread/signal shim)
- openjdk classlib fixes: Amiga flat java.home, Thread.name char[]->String,
  loadLibrary statMode "./", CDS JVM_GetResourceLookupCacheURLs/KnownToNotExist
  stubs, NULL-safe boot-path accessors
- cooperative VM exit (vm_exiting/terminateVMThreads), -Xbootclasspath handlers,
  USE_ZIP malloc-read, [EXC] detailMessage diagnostic
- runs `java -version`, headless HelloWorld, and a 25/25 conformance probe
  (collections, threads, regex, reflection, lambdas/streams, zip, text/date)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .gitignore                          |   8 +
 src/alloc.c                         |  31 ++++
 src/arch.h                          | 139 +++++++++++++++
 src/class.c                         |  83 ++++++++-
 src/classlib/gnuclasspath/natives.c |   4 +
 src/classlib/openjdk/class.c        |   4 +
 src/classlib/openjdk/classlib.h     |   5 +
 src/classlib/openjdk/dll.c          |   9 +-
 src/classlib/openjdk/jvm.c          |  23 ++-
 src/classlib/openjdk/properties.c   |  30 ++++
 src/classlib/openjdk/thread.c       |   8 +
 src/dll.c                           |   2 +
 src/excep.c                         |  36 ++++
 src/init.c                          |  93 +++++++---
 src/jam.c                           |  48 +++++-
 src/os/amiga/baseline_glue.c        |  28 ++++
 src/os/amiga/os.c                   | 252 ++++++----------------------
 src/os/amiga/powerpc/init.c         |  33 ++++
 src/os/amiga/pthread.h              | 130 --------------
 src/os/amiga/sched.h                |   5 -
 src/os/amiga/signal.h               |  89 ----------
 src/os/amiga/stdlib.h               |  30 ----
 src/os/amiga/time.h                 |  20 ---
 src/thread.c                        |  53 +++++-
 src/zip.c                           |  43 ++++-
 25 files changed, 690 insertions(+), 516 deletions(-)
 create mode 100644 .gitignore
 create mode 100644 src/arch.h
 create mode 100644 src/os/amiga/baseline_glue.c
 delete mode 100644 src/os/amiga/pthread.h
 delete mode 100644 src/os/amiga/sched.h
 delete mode 100644 src/os/amiga/signal.h
 delete mode 100644 src/os/amiga/stdlib.h
 delete mode 100644 src/os/amiga/time.h

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..976d81c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,8 @@
+
+# Build-generated (copied into src/ by tools/build-jamvm-*.sh per classlib variant)
+/src/classlib.h
+/src/classlib-defs.h
+/src/classlib-excep.h
+/src/classlib-symbol.h
+# Shelved JAmiga shim headers (backups)
+*.jamiga-shim-bak
diff --git a/src/alloc.c b/src/alloc.c
index 536c720..a1d972d 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;
 
@@ -1788,6 +1794,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 +1859,24 @@ 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;
+
+    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... */
diff --git a/src/arch.h b/src/arch.h
new file mode 100644
index 0000000..0d2fe78
--- /dev/null
+++ b/src/arch.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ * Robert Lougher <rob@jamvm.org.uk>.
+ *
+ * This file is part of JamVM.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2,
+ * or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#define OS_ARCH "ppc"
+
+#define HANDLER_TABLE_T static const void
+#define DOUBLE_1_BITS 0x3ff0000000000000LL
+
+#define READ_DBL(v,p,l)	v = ((u8)p[0]<<56)|((u8)p[1]<<48)|((u8)p[2]<<40) \
+                            |((u8)p[3]<<32)|((u8)p[4]<<24)|((u8)p[5]<<16) \
+                            |((u8)p[6]<<8)|(u8)p[7]; p+=8
+
+/* Needed for i386 -- empty here */
+#define FPU_HACK
+
+#define COMPARE_AND_SWAP_32(addr, old_val, new_val) \
+({                                                  \
+    int result, read_val;                           \
+    __asm__ __volatile__ ("                         \
+                li %0,0\n                           \
+        1:      lwarx %1,0,%2\n                     \
+                cmpw %3,%1\n                        \
+                bne- 2f\n                           \
+                stwcx. %4,0,%2\n                    \
+                bne- 1b\n                           \
+                li %0,1\n                           \
+        2:"                                         \
+    : "=&r" (result), "=&r" (read_val)              \
+    : "r" (addr), "r" (old_val), "r" (new_val)      \
+    : "cc", "memory");                              \
+    result;                                         \
+})
+
+#ifdef __ppc64__
+#define COMPARE_AND_SWAP_64(addr, old_val, new_val) \
+({                                                  \
+    int result, read_val;                           \
+    __asm__ __volatile__ ("                         \
+                li %0,0\n                           \
+        1:      ldarx %1,0,%2\n                     \
+                cmpd %3,%1\n                        \
+                bne- 2f\n                           \
+                stdcx. %4,0,%2\n                    \
+                bne- 1b\n                           \
+                li %0,1\n                           \
+        2:"                                         \
+    : "=&r" (result), "=&r" (read_val)              \
+    : "r" (addr), "r" (old_val), "r" (new_val)      \
+    : "cc", "memory");                              \
+    result;                                         \
+})
+
+#define COMPARE_AND_SWAP(addr, old_val, new_val)    \
+        COMPARE_AND_SWAP_64(addr, old_val, new_val)
+#else
+#define COMPARE_AND_SWAP(addr, old_val, new_val)    \
+        COMPARE_AND_SWAP_32(addr, old_val, new_val)
+#endif
+
+#define LOCKWORD_READ(addr) *addr
+#define LOCKWORD_WRITE(addr, value) *addr = value
+#define LOCKWORD_COMPARE_AND_SWAP(addr, old_val, new_val) \
+        COMPARE_AND_SWAP(addr, old_val, new_val)
+
+#define CACHE_LINE_LEN 32
+
+#define FLUSH_CACHE(addr, length)                   \
+{                                                   \
+    uintptr_t end = ((uintptr_t) (addr)) + length;  \
+    uintptr_t start = ((uintptr_t) (addr))          \
+                      & ~(CACHE_LINE_LEN - 1);      \
+    uintptr_t i;                                    \
+                                                    \
+    for(i = start; i < end; i += CACHE_LINE_LEN)    \
+        __asm__ ("dcbst 0, %0" :: "r" (i));         \
+                                                    \
+    __asm__ ("sync");                               \
+                                                    \
+    for(i = start; i < end; i += CACHE_LINE_LEN)    \
+        __asm__ ("icbi 0, %0" :: "r" (i));          \
+                                                    \
+    __asm__ ("sync; isync");                        \
+}
+
+#define GEN_REL_JMP(target_addr, patch_addr, patch_size)     \
+({                                                           \
+    int patched = FALSE;                                     \
+                                                             \
+    if(patch_size >= 4) {                                    \
+        /* The check is done in two parts to ensure the      \
+           result is always positive, to guard against       \
+           the pointer difference being larger than the      \
+           signed range */                                   \
+        if(target_addr > patch_addr) {                       \
+            uintptr_t offset = (target_addr) - (patch_addr); \
+                                                             \
+            if(offset < 1<<25) {                             \
+                *(int*)(patch_addr) = offset & 0x3ffffff     \
+                                             | 0x48000000;   \
+                patched = TRUE;                              \
+            }                                                \
+        } else {                                             \
+            uintptr_t offset = (patch_addr) - (target_addr); \
+                                                             \
+            if(offset <= 1<<25) {                            \
+                *(int*)(patch_addr) = -offset & 0x3ffffff    \
+                                              | 0x48000000;  \
+                patched = TRUE;                              \
+            }                                                \
+        }                                                    \
+    }                                                        \
+    patched;                                                 \
+})
+
+#define MBARRIER() __asm__ __volatile__ ("sync" ::: "memory")
+#define JMM_LOCK_MBARRIER() __asm__ __volatile__ ("isync" ::: "memory")
+#ifdef __NO_LWSYNC__
+#define JMM_UNLOCK_MBARRIER() __asm__ __volatile__ ("sync" ::: "memory")
+#else
+#define JMM_UNLOCK_MBARRIER() __asm__ __volatile__ ("lwsync" ::: "memory")
+#endif
diff --git a/src/class.c b/src/class.c
index af81530..e0f4873 100644
--- a/src/class.c
+++ b/src/class.c
@@ -1480,6 +1480,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 +1553,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);
+
+           /* 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(); 
+       clearException();
 
        /* Don't wrap exceptions of type java.lang.Error... */
        error = findSystemClass0(SYMBOL(java_lang_Error));
@@ -2135,6 +2182,10 @@ void freeClassLoaderData(Object *class_loader) {
     }
 }
 
+#ifdef __amigaos4__
+#include <proto/exec.h>
+#endif
+
 void parseBootClassPath() {
     char *cp, *pntr, *start;
     int i, j, len, max = 0;
@@ -2142,6 +2193,9 @@ void parseBootClassPath() {
 
     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 == ':') {
@@ -2164,16 +2218,26 @@ void parseBootClassPath() {
         start = pntr;
         pntr += (len = strlen(pntr))+1;
 
-        if(stat(start, &info) == 0) {
+      {
+        int _sr = stat(start, &info);
+#ifdef __amigaos4__
+        DebugPrintF("[BCP] entry='%s' stat=%d\n", start, _sr);
+#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;
@@ -2182,8 +2246,19 @@ void parseBootClassPath() {
 
 void setClassPath(InitArgs *args) {
     char *env;
-    classpath = args->classpath ? args->classpath : 
+#ifdef __amigaos4__
+    /* Default to an EMPTY app classpath, not "." -- on AmigaOS "." canonicalises
+       to the volume path (e.g. "AmigaOS:Test"), which sun.misc.Launcher's
+       URLClassPath then mangles (':' = path.separator vs Amiga "volume:") /
+       mis-converts to a URL ("volume:" looks like a scheme).  An empty
+       java.class.path gives the AppClassLoader no entries to choke on; the app
+       class is supplied on -Xbootclasspath and found via bootstrap delegation. */
+    classpath = args->classpath ? args->classpath :
+                 ((env = getenv("CLASSPATH")) ? env : "");
+#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..09fc556 100644
--- a/src/classlib/openjdk/class.c
+++ b/src/classlib/openjdk/class.c
@@ -130,6 +130,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]);
 
diff --git a/src/classlib/openjdk/classlib.h b/src/classlib/openjdk/classlib.h
index 054afe4..8e85682 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)
 
diff --git a/src/classlib/openjdk/dll.c b/src/classlib/openjdk/dll.c
index 1d9cc9c..bd9a8b8 100644
--- a/src/classlib/openjdk/dll.c
+++ b/src/classlib/openjdk/dll.c
@@ -43,8 +43,15 @@ int classlibInitialiseDll() {
 
 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);
 }
 
diff --git a/src/classlib/openjdk/jvm.c b/src/classlib/openjdk/jvm.c
index 971ac75..bfbbb93 100644
--- a/src/classlib/openjdk/jvm.c
+++ b/src/classlib/openjdk/jvm.c
@@ -3034,7 +3034,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/properties.c b/src/classlib/openjdk/properties.c
index 2391e61..481963b 100644
--- a/src/classlib/openjdk/properties.c
+++ b/src/classlib/openjdk/properties.c
@@ -21,6 +21,35 @@
 #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() {
+    char *path = nativeJVMPath();
+    char *pntr, *home;
+
+    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 +71,5 @@ char *classlibDefaultJavaHome() {
 
     return home;
 }
+#endif
 
diff --git a/src/classlib/openjdk/thread.c b/src/classlib/openjdk/thread.c
index 71fc8aa..8a7c303 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;
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..0ca5ee1 100644
--- a/src/init.c
+++ b/src/init.c
@@ -26,7 +26,8 @@
 
 #include "jam.h"
 
-static int VM_initing = TRUE;
+/* 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 +35,36 @@ 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>
+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 skip the signal-handler thread
+   entirely on AmigaOS (see thread.c).  With the daemons exiting, clib4 exit() can
+   complete cleanly.  Output already went out via raw write() syscalls. */
+extern void terminateVMThreads(void);
+static void amiga_exit(int status) {
+    DebugPrintF("[EXIT] amiga_exit(%d): terminating VM threads\n", status);
+    terminateVMThreads();
+    DebugPrintF("[EXIT] amiga_exit: calling exit()\n");
+    exit(status);
+}
+#endif
+
 /* Setup default values for command line args */
 
 void setDefaultInitArgs(InitArgs *args) {
@@ -65,9 +96,17 @@ void setDefaultInitArgs(InitArgs *args) {
 
     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 +128,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/jam.c b/src/jam.c
index 052f84a..2951d20 100644
--- a/src/jam.c
+++ b/src/jam.c
@@ -107,15 +107,25 @@ 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() {
@@ -212,6 +222,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 +273,24 @@ int main(int argc, char *argv[]) {
         exit(1);
     }
 
-   if((system_loader = getSystemClassLoader()) == NULL)
+#ifdef __amigaos4__
+    /* The OpenJDK system classloader (sun.misc.Launcher) now INITIALISES cleanly
+       on AmigaOS -- the hard crash in getSystemClassLoader was the missing CDS
+       JVM_GetResourceLookupCacheURLs/JVM_KnownToNotExist (libjava.so called the
+       unresolved symbols); those are now stubbed (return NULL/FALSE) in jvm.c.
+       HOWEVER running the app class THROUGH the system loader still has a latent
+       bug (HelloWorld loads + main returns but produces no output; a heisenbug
+       that the [NM] debug trace masked -> suspect memory corruption / GC on the
+       much larger Launcher/URLClassPath code path).  So for now keep the reliable
+       BOOTSTRAP path (app class on -Xbootclasspath).  TODO(Phase 3): debug the
+       system-loader run path + Amiga path->URL for real -classpath. */
+    system_loader = NULL;
+#else
+    if((system_loader = getSystemClassLoader()) == NULL)
         goto error;
 
     mainThreadSetContextClassLoader(system_loader);
+#endif
 
     for(cpntr = argv[class_arg]; *cpntr; cpntr++)
         if(*cpntr == '.')
diff --git a/src/os/amiga/baseline_glue.c b/src/os/amiga/baseline_glue.c
new file mode 100644
index 0000000..c15dc04
--- /dev/null
+++ b/src/os/amiga/baseline_glue.c
@@ -0,0 +1,28 @@
+/*
+ * baseline_glue.c -- small definitions needed to complete the newlib baseline
+ * link of JAmiga JamVM that are absent from the 2016 Amiga port / the current
+ * SDK.  Keep these together so they are easy to find and remove/replace as the
+ * real implementations land (clib4 migration, JNI native loading, etc.).
+ * See docs/revival-notes.md.
+ */
+#include <stdint.h>
+
+/* init.c uses this for default heap sizing.  bsd/darwin os.c return 0 ("TBD");
+ * the Amiga os.c never defined it.  0 keeps JamVM on its built-in defaults. */
+long long nativePhysicalMemory(void) {
+    return 0;
+}
+
+/* interp.c (executeJava: tableswitch/lookupswitch) calls ntohl to read
+ * big-endian bytecode operands.  <arpa/inet.h> declares it but no impl is
+ * linked under newlib.  AmigaOS 4 PPC is big-endian, so these are identities. */
+uint32_t ntohl(uint32_t x) { return x; }
+uint16_t ntohs(uint16_t x) { return x; }
+uint32_t htonl(uint32_t x) { return x; }
+uint16_t htons(uint16_t x) { return x; }
+
+/* scanprocess.c calls this at shutdown to unload boot-classloader native libs.
+ * Not defined in the JAmiga tree; stub for the baseline (native lib loading is
+ * itself stubbed via proto/nativelib.h until restored). */
+void unloadBootClassLoaderDlls(void) {
+}
diff --git a/src/os/amiga/os.c b/src/os/amiga/os.c
index 5561c20..aa1237b 100644
--- a/src/os/amiga/os.c
+++ b/src/os/amiga/os.c
@@ -19,241 +19,95 @@
  * 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;
-};
 
+#define __USE_GNU
+#include <dlfcn.h>
+#include <pthread.h>
 
-/**
- * Internal struct for native methods
- * with mangled symbol name.
- */
-struct JamNativeMethodSymbol {
-    char *symbolName;
-    void *fnPtr;
-};
-
+#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() {
+    /* Report a modest figure so the default heap (phys/4) stays small: clib4's
+       mmap currently fails for very large MAP_ANON regions (a multi-hundred-MB
+       default heap from reporting true RAM aborts initialiseAlloc). 64 MB ->
+       16 MB default max heap, which clib4 mmap handles. -Xmx overrides this.
+       TODO: investigate clib4 large-mmap limit and raise this. */
+    return 64LL * 1024 * 1024;
+}
 
 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();
 }
 
-
-char* nativeLibError() {
-    return "Misc error";
+char *nativeLibPath() {
+    return getenv("LD_LIBRARY_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
-
-
-    // Obtain pointer array to native methods
-    nativeInfo = (APTR)GetLibraryContent();
-
-    if(!nativeInfo) {
-        #if (JA_TARGETOS==JA_AMIGAOS4)
-        DropInterface(INativelib);
-        INativelib = NULL;
-        #endif
-        CloseLibrary(myLib);
-        sysFree(libraryInfo);
-        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;
+    void *h = dlopen(path, RTLD_LAZY);
+    DebugPrintF("[DLOPEN] '%s' -> %p%s\n", path, 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;
+}
diff --git a/src/os/amiga/powerpc/init.c b/src/os/amiga/powerpc/init.c
index 075b0ef..60d01ae 100644
--- a/src/os/amiga/powerpc/init.c
+++ b/src/os/amiga/powerpc/init.c
@@ -18,3 +18,36 @@
  * 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());
+}
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/thread.c b/src/thread.c
index e4fb7d1..6f4ccfc 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -787,10 +787,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,6 +806,7 @@ 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);
@@ -814,7 +823,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 +838,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,
@@ -1234,6 +1251,9 @@ Object *runningThreadObjects() {
 
 void exitVM(int status) {
     main_exited = TRUE;
+#ifdef __amigaos4__
+    DebugPrintF("[EXIT] exitVM enter status=%d\n", status);
+#endif
 
     /* Execute System.exit() to run any registered shutdown hooks.
        In the unlikely event that System.exit() can't be found, or
@@ -1248,12 +1268,19 @@ 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__
+    DebugPrintF("[EXIT] mainThreadWaitToExitVM enter non_daemon=%d\n",
+                non_daemon_thrds);
+#endif
 
     disableSuspend(self);
     pthread_mutex_lock(&exit_lock);
@@ -1264,6 +1291,9 @@ void mainThreadWaitToExitVM() {
 
     pthread_mutex_unlock(&exit_lock);
     enableSuspend(self);
+#ifdef __amigaos4__
+    DebugPrintF("[EXIT] mainThreadWaitToExitVM done\n");
+#endif
 }
 
 void mainThreadSetContextClassLoader(Object *loader) {
@@ -1324,6 +1354,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 +1369,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 +1417,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,20 +1432,30 @@ 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 */
+#ifndef __amigaos4__
     createVMThread("Signal Handler", classlibSignalThread);
+#else
+    /* AmigaOS/clib4: skip the signal-handler thread.  It blocks forever in
+       sigwait() (cross-thread signal delivery is broken on clib4), so it can't
+       be cleanly shut down and would hang clib4 exit().  SIGQUIT/SIGINT (Ctrl-C)
+       handling isn't needed for the headless qemu/Run workflow. */
+#endif
 
     return TRUE;
 
diff --git a/src/zip.c b/src/zip.c
index b901856..eb21865 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,42 @@ ZipFile *processArchive(char *path) {
     HashTable *hash_table;
     ZipFile *zip;
 
-    if((fd = open(path, O_RDONLY)) == -1)
+    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 +241,7 @@ ZipFile *processArchive(char *path) {
     return zip;
 
 error2:
-    munmap(data, len);
+    sysFree(data);
 
 error:
     close(fd);
-- 
2.49.0.windows.1


From 79fb4ab57ff81a7279be88cf0334bd584109de78 Mon Sep 17 00:00:00 2001
From: Richard Gibbs <wofderfs@googlemail.com>
Date: Tue, 9 Jun 2026 23:20:17 +0100
Subject: [PATCH 02/13] jam.c: enable the real sun.misc.Launcher system
 classloader on AmigaOS

The earlier "no-output heisenbug" was missing openjdk natives (CDS stubs,
VM.latestUserDefinedLoader0, TimeZone, getManifestNum), not memory corruption;
with those supplied the system loader initialises reliably.  Use it (with a
bootstrap-loader fallback if init fails); -Xbootclasspath classes load via
delegation.  Known gap: app classes from a -classpath entry (URLClassPath) still
fail on Amiga volume:->URL conversion.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 src/jam.c | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/jam.c b/src/jam.c
index 2951d20..eccffab 100644
--- a/src/jam.c
+++ b/src/jam.c
@@ -274,17 +274,18 @@ int main(int argc, char *argv[]) {
     }
 
 #ifdef __amigaos4__
-    /* The OpenJDK system classloader (sun.misc.Launcher) now INITIALISES cleanly
-       on AmigaOS -- the hard crash in getSystemClassLoader was the missing CDS
-       JVM_GetResourceLookupCacheURLs/JVM_KnownToNotExist (libjava.so called the
-       unresolved symbols); those are now stubbed (return NULL/FALSE) in jvm.c.
-       HOWEVER running the app class THROUGH the system loader still has a latent
-       bug (HelloWorld loads + main returns but produces no output; a heisenbug
-       that the [NM] debug trace masked -> suspect memory corruption / GC on the
-       much larger Launcher/URLClassPath code path).  So for now keep the reliable
-       BOOTSTRAP path (app class on -Xbootclasspath).  TODO(Phase 3): debug the
-       system-loader run path + Amiga path->URL for real -classpath. */
-    system_loader = NULL;
+    /* 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)
+        clearException();
+    else
+        mainThreadSetContextClassLoader(system_loader);
 #else
     if((system_loader = getSystemClassLoader()) == NULL)
         goto error;
-- 
2.49.0.windows.1


From e2b4d148d6b362166ce208582d557202a455130c Mon Sep 17 00:00:00 2001
From: Richard Gibbs <wofderfs@googlemail.com>
Date: Wed, 10 Jun 2026 07:36:47 +0100
Subject: [PATCH 03/13] Amiga path model: strip leading "/Volume:" in JVM_Open
 + nativeLibOpen

java.io presents canonical paths as Unix-absolute ("/Volume:dir/file") so
File.isAbsolute()/toURI() don't double the Amiga path (the -classpath/URL bug).
The native file-open chokepoints strip the leading '/' (and "./") back to a real
AmigaDOS path: JVM_Open (ZipFile/JarFile and friends open through it) and
nativeLibOpen (loadLibrary/dlopen).  With this + the openjdk-natives path
adaptations, File/URL round-trips and direct JarFile/ZipFile opens work on Amiga.
(Full URLClassLoader -classpath still blocked by sun.nio.fs platform detection.)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 src/classlib/openjdk/jvm.c | 13 +++++++++++++
 src/os/amiga/os.c          | 15 +++++++++++++--
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/src/classlib/openjdk/jvm.c b/src/classlib/openjdk/jvm.c
index bfbbb93..668a476 100644
--- a/src/classlib/openjdk/jvm.c
+++ b/src/classlib/openjdk/jvm.c
@@ -1533,6 +1533,19 @@ jboolean JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2) {
 jint JVM_Open(const char *fname, jint flags, jint mode) {
     int result;
 
+#ifdef __amigaos4__
+    /* java.io presents canonical paths as Unix-absolute ("/Volume:dir/...") so
+       File.toURI()/isAbsolute() behave; strip the leading '/' for volume paths
+       (and a leading "./") so clib4/AmigaDOS open() gets a real path.  Central
+       fix: ZipFile/JarFile and friends open via JVM_Open. */
+    if(fname[0] == '.' && fname[1] == '/')
+        fname += 2;
+    else if(fname[0] == '/') {
+        const char *c = fname + 1;
+        while(*c && *c != '/') { if(*c == ':') { fname++; break; } c++; }
+    }
+#endif
+
     TRACE("JVM_Open(fname=%s, flags=%d, mode=%d)", fname, flags, mode);
 
     /* O_DELETE is a special classlib flag which indicates that
diff --git a/src/os/amiga/os.c b/src/os/amiga/os.c
index aa1237b..1a6f5be 100644
--- a/src/os/amiga/os.c
+++ b/src/os/amiga/os.c
@@ -78,8 +78,19 @@ char *nativeLibPath() {
 }
 
 void *nativeLibOpen(char *path) {
-    void *h = dlopen(path, RTLD_LAZY);
-    DebugPrintF("[DLOPEN] '%s' -> %p%s\n", path, h,
+    /* java.io presents canonical paths as Unix-absolute ("/Volume:dir/...") so
+       File.toURI()/isAbsolute() behave; strip the leading '/' for volume paths
+       (and a leading "./") so clib4 dlopen gets a real AmigaDOS path. */
+    char *p = path;
+    void *h;
+    if(p[0] == '.' && p[1] == '/')
+        p += 2;
+    else if(p[0] == '/') {
+        char *c = p + 1;
+        while(*c && *c != '/') { if(*c == ':') { p++; break; } c++; }
+    }
+    h = dlopen(p, RTLD_LAZY);
+    DebugPrintF("[DLOPEN] '%s' -> %p%s\n", p, h,
                 h ? "" : " FAILED");
     return h;
 }
-- 
2.49.0.windows.1


From 416f0e4d756e8a94ac74c1718b8edb6ea4dcaf9b Mon Sep 17 00:00:00 2001
From: Richard Gibbs <wofderfs@googlemail.com>
Date: Wed, 10 Jun 2026 08:00:59 +0100
Subject: [PATCH 04/13] properties.c: present user.dir as Unix-absolute
 ("/Volume:dir") on AmigaOS

Part of the Amiga path model: java.io/java.nio see '/'-prefixed absolute paths
(File.isAbsolute()/toURI()/sun.nio.fs.UnixFileSystem all require it; without
this UnixFileSystem rejects user.dir and File.getAbsolutePath() doubles paths),
and the native open/stat chokepoints strip the '/' back off.  With the
niopatch.zip bootclasspath prepend + -Dsun.nio.fs.chdirAllowed=true this makes
full `java -classpath` (URLClassLoader) work on AmigaOS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 src/properties.c | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/properties.c b/src/properties.c
index b453d7b..19169ff 100644
--- a/src/properties.c
+++ b/src/properties.c
@@ -152,6 +152,22 @@ char *getExecutionEngineName() {
 void setUserDirProperty(Object *properties) {
     char *cwd = getCwd();
 
+#ifdef __amigaos4__
+    /* Present user.dir as Unix-absolute ("/Volume:dir") -- part of the Amiga
+       path model: java.io/java.nio see '/'-prefixed absolute paths (so
+       File.isAbsolute()/toURI()/UnixFileSystem don't mis-handle "Volume:"),
+       and the native open/stat chokepoints strip the '/' back off.  Without
+       this, sun.nio.fs.UnixFileSystem rejects user.dir ("default directory
+       must be absolute") and File.getAbsolutePath() doubles paths. */
+    if(cwd != NULL && cwd[0] != '/') {
+        char *slashed = sysMalloc(strlen(cwd) + 2);
+        slashed[0] = '/';
+        strcpy(slashed + 1, cwd);
+        sysFree(cwd);
+        cwd = slashed;
+    }
+#endif
+
     setProperty(properties, "user.dir", cwd);
     sysFree(cwd);
 }
-- 
2.49.0.windows.1


From 2552a6f5e94a3b271cf352ed72b887b4efd161f3 Mon Sep 17 00:00:00 2001
From: Richard Gibbs <wofderfs@googlemail.com>
Date: Wed, 10 Jun 2026 08:17:32 +0100
Subject: [PATCH 05/13] Amiga launcher defaults: zero-flag -cp, java version
 "1.8.0"

`jamvm-openjdk -cp app.jar Main` and `-version` now work with no extra flags
in the standard flat install (CWD = install dir):
- classlibDefaultBootClassPath: flat RELATIVE list with niopatch.zip first
  (no volume colons -- JamVM's boot-path parser splits on ':')
- classlibDefaultBootDllPath: "." (flat layout; ClassLoader splits the
  property on ':' so "Volume:dir" can't be used)
- classlibDefaultExtDirs: "lib/ext" (relative, stops the ':'-split noise)
- classlibAddDefaultProperties: sun.nio.fs.chdirAllowed=true (NIO.2 default
  provider constructs without libnio; -D still overrides)
- JAVA_COMPAT_VERSION "1.8.0" when OPENJDK_VERSION >= 8 (was "1.5.0")

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 src/classlib/openjdk/class.c    | 27 +++++++++++++++++++++++++--
 src/classlib/openjdk/classlib.h |  9 +++++++++
 src/classlib/openjdk/dll.c      | 12 ++++++++++++
 src/jam.h                       |  4 ++++
 4 files changed, 50 insertions(+), 2 deletions(-)

diff --git a/src/classlib/openjdk/class.c b/src/classlib/openjdk/class.c
index 09fc556..9b5c540 100644
--- a/src/classlib/openjdk/class.c
+++ b/src/classlib/openjdk/class.c
@@ -117,6 +117,19 @@ 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. */
+char *classlibDefaultBootClassPath() {
+    static char def[] = "niopatch.zip:resources.jar:rt.jar:sunrsasign.jar:"
+                        "jsse.jar:jce.jar:charsets.jar:classes";
+    char *path = sysMalloc(sizeof(def));
+    return strcpy(path, def);
+}
+#else
 char *classlibDefaultBootClassPath() {
     static char *entries[] = {"lib/resources.jar",
                               "lib/rt.jar",
@@ -146,18 +159,28 @@ char *classlibDefaultBootClassPath() {
         pntr += sprintf(pntr, "%s/%s:", java_home, entries[j]);
 
     sprintf(pntr, "%s/%s", java_home, entries[j]);
-    
+
     return path;
 }
+#endif
 
+#ifdef __amigaos4__
+/* Relative (CWD = install dir): a "Volume:"-prefixed dir here would be split
+   on its ':' by the Java-side path.separator parsing. */
+char *classlibDefaultExtDirs() {
+    char *ext_dirs = sysMalloc(sizeof("lib/ext"));
+    return strcpy(ext_dirs, "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
 
 char *classlibDefaultEndorsedDirs() {
     char *java_home = getJavaHome();
diff --git a/src/classlib/openjdk/classlib.h b/src/classlib/openjdk/classlib.h
index 8e85682..7777ada 100644
--- a/src/classlib/openjdk/classlib.h
+++ b/src/classlib/openjdk/classlib.h
@@ -114,8 +114,17 @@ 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) \
+    setProperty(properties, "sun.nio.fs.chdirAllowed", "true")
+#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 bd9a8b8..11d2088 100644
--- a/src/classlib/openjdk/dll.c
+++ b/src/classlib/openjdk/dll.c
@@ -41,6 +41,17 @@ int classlibInitialiseDll() {
     return TRUE;
 }
 
+#ifdef __amigaos4__
+/* Flat Amiga layout: the native .so files live beside the VM, and the standard
+   launch CDs to the install dir -- so the default boot library path is ".".
+   ("Volume:dir" here would be split on its ':' by java.lang.ClassLoader's
+   path.separator parsing; the "./lib.so" form is normalised by the native
+   open/dlopen chokepoints.) */
+char *classlibDefaultBootDllPath() {
+    char *dll_path = sysMalloc(2);
+    return strcpy(dll_path, ".");
+}
+#else
 char *classlibDefaultBootDllPath() {
     char *java_home = getJavaHome();
     char *dll_path;
@@ -54,6 +65,7 @@ char *classlibDefaultBootDllPath() {
     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/jam.h b/src/jam.h
index ce73df6..742fc9c 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))
-- 
2.49.0.windows.1


From 4c1743055b88fd221bba7c481b03dee40e337b1a Mon Sep 17 00:00:00 2001
From: Richard Gibbs <wofderfs@googlemail.com>
Date: Wed, 10 Jun 2026 10:04:13 +0100
Subject: [PATCH 06/13] Cooperative GC safepoints for AmigaOS/clib4
 (multi-threaded stop-the-world)

clib4's pthread_kill only sets a raw Exec signal bit -- the SIGUSR1 handler
never runs, so signal-based suspension could not stop a thread executing
bytecode (a pure-compute thread hung GC forever; verified by a MT allocation
stress with a spinner thread).  Replace delivery with cooperative polling:

- thread.c: amiga suspendLoop parks by polling thread->suspend (usleep loop;
  sigsetjmp still spills registers for GC root scanning); threadPollSuspend()
  exported; suspend_pending_count gates the poll, bumped in
  suspendThread/suspendAllThreads, dropped in resume*.
- interp-indirect.h (switch interpreter): poll the gate each dispatch; only
  when a suspension is pending is threadSelf() consulted.

Verified: 4 allocator threads + a 1.3e9-iteration compute spinner + System.gc()
complete correctly (sums equal, spinner stops, exit 0); 37/37 conformance and
the zero-flag -cp launch unaffected.  Note: only the (default) switch
interpreter variant polls; THREADED/DIRECT builds would need the same hook.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 src/interp/engine/interp-indirect.h | 16 +++++++++
 src/thread.c                        | 52 +++++++++++++++++++++++++++++
 2 files changed, 68 insertions(+)

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/thread.c b/src/thread.c
index 6f4ccfc..84cc4ce 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;
@@ -885,6 +891,9 @@ Object *runningThreadStackTrace(Thread *thread, int max_depth,
 }
 
 void suspendThread(Thread *thread) {
+#ifdef __amigaos4__
+    suspend_pending_count++;
+#endif
     thread->suspend = TRUE;
     MBARRIER();
 
@@ -917,6 +926,9 @@ void resumeThread(Thread *thread) {
               thread->id);
         sched_yield();
     }
+#ifdef __amigaos4__
+    suspend_pending_count--;
+#endif
 }
 
 void suspendAllThreads(Thread *self) {
@@ -924,6 +936,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)
@@ -999,6 +1014,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);
@@ -1008,6 +1026,39 @@ 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();
+}
+
+void threadPollSuspend() {
+    Thread *thread = threadSelf();
+
+    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;
@@ -1029,6 +1080,7 @@ static void suspendLoop(Thread *thread) {
     thread->suspend_state = old_state;
     MBARRIER();
 }
+#endif
 
 static void suspendHandler(int sig) {
     Thread *thread = threadSelf();
-- 
2.49.0.windows.1


From e1c4e649d0f5647519fbb9dbd2a3cf2b41a2e8c8 Mon Sep 17 00:00:00 2001
From: Richard Gibbs <wofderfs@googlemail.com>
Date: Wed, 10 Jun 2026 11:59:19 +0100
Subject: [PATCH 07/13] jni.c: FindClass must initialize the class (HotSpot
 semantics)

Jam_FindClass only loaded/linked; HotSpot's JNI FindClass also runs static
initializers, and native code depends on the clinit side-effects -- libawt's
Disposer_AddRecord lazily FindClass-es sun.java2d.Disposer expecting initIDs
to have cached addRecordMID (it called CallStaticVoidMethod with a NULL
methodID otherwise -> crash).  Run initClass() on the result; return NULL on
initializer exception.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 src/jni.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

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);
 }
 
-- 
2.49.0.windows.1


From 39516d34e8f801ac02e12960b60dbf432b47b304 Mon Sep 17 00:00:00 2001
From: Richard Gibbs <wofderfs@googlemail.com>
Date: Wed, 10 Jun 2026 17:51:22 +0100
Subject: [PATCH 08/13] Shadow java.lang.Class.classLoader in ClassBlock pad
 (Temurin 8)

Temurin/late-8u backported the VM-injected java.lang.Class.classLoader field
(JDK-8212201): getClassLoader0() reads the FIELD and is no longer a native.
JamVM never populated it, so every class looked bootstrap-loaded Java-side --
System.loadLibrary from a -cp class registered its library under
systemNativeLibraries while the VM-side native lookup passed the real loader
to ClassLoader.findNative, which searched the (empty) per-loader list ->
UnsatisfiedLinkError for all app-classloader natives.

Fix mirrors the existing OpenJDK 9 support: place class_loader inside
CLASSLIB_CLASS_PAD at the Java field's offset (object byte-offset 36 =
ClassBlock word 7 -- JamVM lays reference fields in reverse declaration order;
verified empirically), drop it from the GC extra-fields/REFS_DO (as part of
the Java object it is scanned like any other reference).  All existing
cb->class_loader code is unchanged.

Also: nativeLibOpen strips the Unix-absolute "/Volume:" path form (Amiga path
model) before dlopen.

Verified: AmigaWindow (-cp class with JNI lib) resolves its natives; an
Intuition window opens, a Java2D ARGB frame blits into it via
graphics.library WritePixelArray, and IDCMP events are received (486 polled
in one run).  getClassLoader() now returns sun.misc.Launcher$AppClassLoader.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 src/classlib/openjdk/classlib-defs.h | 19 ++++++++++++++++---
 src/jam.c                            |  1 +
 2 files changed, 17 insertions(+), 3 deletions(-)

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/jam.c b/src/jam.c
index eccffab..014d937 100644
--- a/src/jam.c
+++ b/src/jam.c
@@ -273,6 +273,7 @@ int main(int argc, char *argv[]) {
         exit(1);
     }
 
+
 #ifdef __amigaos4__
     /* The OpenJDK system classloader (sun.misc.Launcher) now initialises reliably on
        AmigaOS -- the earlier "heisenbug" was missing openjdk natives (CDS stubs,
-- 
2.49.0.windows.1


From e38273c93d95600366610a2afd88f8ebd1773d23 Mon Sep 17 00:00:00 2001
From: Richard Gibbs <wofderfs@googlemail.com>
Date: Wed, 10 Jun 2026 22:28:11 +0100
Subject: [PATCH 09/13] Fix clib4 exit wedge: self-terminate all Java threads
 on VM exit

clib4 exit() waits for every pthread child process to terminate before
tearing down the shared context; a Java thread still alive when the
exiting thread calls exit() suspends the process forever ("Parent
suspended, waiting for child to exit").  Headless runs were fine (the
finalizer/reference-handler condvar notify from terminateVMThreads
sufficed), but an AWT/Swing run leaves the EDT, AWT-Shutdown, the Amiga
event pump and the Java2D Disposer alive at System.exit().

Fix (cooperative, no async thread kill exists on clib4):
- exitWakeAllThreads() (thread.c): interrupt every attached thread out
  of Object.wait/sleep, and open the interpreter's dispatch-poll gate --
  THREAD_POLL_SUSPEND is gated on suspend_pending_count, so vm_exiting
  alone was never observed by running threads (the key bug).
- threadPollSuspend(): with vm_exiting set, any thread except the
  exiting one self-terminates (exitDetachAndDie: unlink from the thread
  list, drop threads_count, pthread_exit).
- amiga_exit() (init.c): wake-all, then drain getThreadsCount() to 1
  (re-interrupting periodically -- a woken thread can re-enter wait
  before its next poll), bounded at 3s, with a remaining-thread name
  dump diagnostic before exit().

Verified on qemu-java: SwingTest (full AWT thread complement) exits with
no Cleanup_hook wedge and no zombie CLI; headless -cp HelloWorld
regression unaffected.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 src/init.c   | 25 +++++++++++++++++++++-
 src/thread.c | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+), 1 deletion(-)

diff --git a/src/init.c b/src/init.c
index 0ca5ee1..8a2f303 100644
--- a/src/init.c
+++ b/src/init.c
@@ -57,10 +57,33 @@ static int amiga_vfprintf(FILE *stream, const char *fmt, va_list ap) {
    entirely on AmigaOS (see thread.c).  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 int getThreadsCount(void);
 static void amiga_exit(int status) {
+    int tries = 0;
+
     DebugPrintF("[EXIT] amiga_exit(%d): terminating VM threads\n", status);
     terminateVMThreads();
-    DebugPrintF("[EXIT] amiga_exit: calling exit()\n");
+
+    /* 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". */
+    exitWakeAllThreads();
+    while(getThreadsCount() > 1 && tries++ < 300) {
+        /* a woken thread can re-enter Object.wait before its next dispatch
+           poll -- re-interrupt periodically until everyone is gone */
+        if(tries % 50 == 0)
+            exitWakeAllThreads();
+        usleep(10000);
+    }
+
+    DebugPrintF("[EXIT] amiga_exit: calling exit() (threads left=%d)\n",
+                getThreadsCount());
+    if(getThreadsCount() > 1)
+        exitDumpRemainingThreads();
     exit(status);
 }
 #endif
diff --git a/src/thread.c b/src/thread.c
index 84cc4ce..44d3d79 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -1051,9 +1051,69 @@ static void suspendLoop(Thread *thread) {
     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);
+}
+
+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 threadPollSuspend() {
     Thread *thread = threadSelf();
 
+    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);
-- 
2.49.0.windows.1


From 891ebfe73b01e23a67f7d5556e28cd2829b4bfdc Mon Sep 17 00:00:00 2001
From: Richard Gibbs <wofderfs@googlemail.com>
Date: Wed, 10 Jun 2026 23:43:39 +0100
Subject: [PATCH 10/13] GUI defaults: a Swing app runs with zero flags

classlibDefaultBootClassPath gains amigatoolkit.zip (the sun.awt.amiga
toolkit, flat-relative like the rest), and classlibAddDefaultProperties sets
awt.toolkit=sun.awt.amiga.AmigaToolkit +
java.awt.graphicsenv=sun.awt.amiga.AmigaGraphicsEnvironment (command-line -D
still overrides; a missing zip is skipped harmlessly and only matters when
AWT is actually touched).

Canonical GUI launch is now identical to headless:
    jamvm-openjdk -cp app.jar Main

Verified on qemu-java: zero-flag SwingTest passes fully (window + action
pipeline + clean exit); zero-flag headless HelloWorld regression unaffected.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 src/classlib/openjdk/class.c    | 3 ++-
 src/classlib/openjdk/classlib.h | 8 +++++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/classlib/openjdk/class.c b/src/classlib/openjdk/class.c
index 9b5c540..ef9c885 100644
--- a/src/classlib/openjdk/class.c
+++ b/src/classlib/openjdk/class.c
@@ -125,7 +125,8 @@ Object *classlibSkipReflectionLoader(Object *loader) {
    patched sun.nio.fs.DefaultFileSystemProvider needed for -classpath. */
 char *classlibDefaultBootClassPath() {
     static char def[] = "niopatch.zip:resources.jar:rt.jar:sunrsasign.jar:"
-                        "jsse.jar:jce.jar:charsets.jar:classes";
+                        "jsse.jar:jce.jar:charsets.jar:amigatoolkit.zip:"
+                        "classes";
     char *path = sysMalloc(sizeof(def));
     return strcpy(path, def);
 }
diff --git a/src/classlib/openjdk/classlib.h b/src/classlib/openjdk/classlib.h
index 7777ada..c490688 100644
--- a/src/classlib/openjdk/classlib.h
+++ b/src/classlib/openjdk/classlib.h
@@ -120,7 +120,13 @@ extern Object *classlibCheckIfOnLoad(Frame *last);
    NIO.2 provider constructs without libnio -- required for URLClassLoader /
    -classpath.  A command-line -D still overrides (added after defaults). */
 #define classlibAddDefaultProperties(properties) \
-    setProperty(properties, "sun.nio.fs.chdirAllowed", "true")
+    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"); \
+    } while(0)
 #else
 #define classlibAddDefaultProperties(properties) \
     /* NOTHING TO DO */
-- 
2.49.0.windows.1


From 642958d7da0d8a8b851c3dc0d26ffae9c6e5ba48 Mon Sep 17 00:00:00 2001
From: Richard Gibbs <rich_gibbs@hotmail.com>
Date: Sat, 20 Jun 2026 13:59:13 +0100
Subject: [PATCH 11/13] class.c: reject class-file major > 52
 (UnsupportedClassVersionError)

Java 8 (class-file major 52) is the newest bytecode this VM's class library supports. parseClass now rejects newer class files up front, instead of letting them load and die far away with a BootstrapMethodError (the typical 'it just freezes' failure for Java 9+ code built without --release 8).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/class.c | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/src/class.c b/src/class.c
index e0f4873..261ef81 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;
 
-- 
2.49.0.windows.1


From c28250c77b2a9e195b98739b0eaff77e0515a183 Mon Sep 17 00:00:00 2001
From: Richard Gibbs <rich_gibbs@hotmail.com>
Date: Mon, 22 Jun 2026 13:10:33 +0100
Subject: [PATCH 12/13] amiga: fix `java -cp` for relative + Volume:
 classpaths, and an exit-path UAF

Reworks the AmigaOS path model so `jamvm-openjdk -cp <app> Main` works from any
current directory (amigans.net topic 10124):

- chdir to the program dir at startup (amigaSetupCwd in os/amiga/os.c, called
  from os/amiga/powerpc/init.c) so boot jars / java.home / on-demand natives
  (libzip, ...) resolve at the install dir no matter where the user ran `java`.
  clib4's chdir auto-restores the shell CurrentDir at exit, so there is no leak.
- user.dir = the install (program) dir; the on-demand natives that the
  ClassLoader loads are resolved relative to it.
- path.separator = ";" on AmigaOS -- ":" is the volume separator, so it cannot
  also separate path lists; ";" lets absolute "Volume:dir" entries survive in
  java.class.path / java.library.path / sun.boot.library.path.
- rewrite each -cp entry to an absolute Unix-form path (class.c amigaClassPath):
  a relative entry anchors at the launch dir (#1); a "Volume:dir" entry gets a
  leading '/' (#3).  The native open chokepoint strips the '/' back off.
- shell() (the VM-helper-thread wrapper) now unlinks the Finalizer / Reference
  Handler threads from the thread list and drops threads_count on exit while
  vm_exiting, so amiga_exit's re-interrupt walk no longer traverses a
  freed-but-linked Thread struct (a DSI use-after-free on shutdown that surfaced
  once the real app classloader runs and spawns those threads).

Verified on QEMU: relative + absolute Volume: -cp run from any cwd, no cwd leak,
clean exit; regression Conf 13/13, Conf2 12/12, Conf3 12/12, NioTest 10/10,
PathTest / PathT2 / ExecTest pass.  (Conf4 MT-GC stress hangs on the pre-change
baseline too -- pre-existing, unrelated to this change.)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 src/class.c                       | 53 ++++++++++++++++++++++++++-----
 src/classlib/openjdk/dll.c        | 10 +++---
 src/classlib/openjdk/properties.c | 13 ++++++--
 src/os/amiga/os.c                 | 46 +++++++++++++++++++++++++++
 src/os/amiga/powerpc/init.c       | 10 ++++++
 src/properties.c                  | 29 +++++++++++++----
 src/thread.c                      | 22 +++++++++++++
 7 files changed, 161 insertions(+), 22 deletions(-)

diff --git a/src/class.c b/src/class.c
index 261ef81..4a09e67 100644
--- a/src/class.c
+++ b/src/class.c
@@ -2265,17 +2265,54 @@ void parseBootClassPath() {
     bcp_entries = j;
 }
 
+#ifdef __amigaos4__
+/* Make each app -cp entry an ABSOLUTE Unix-form path.  user.dir is the install dir
+   (the VM chdir'd there), so a *relative* entry would wrongly resolve against the
+   install dir -- anchor it at the directory `java` was launched from instead.  An
+   Amiga "Volume:dir" entry just gets a leading '/' (UnixFileSystem then treats it
+   as absolute, and the native open chokepoint strips the '/' back off) -- this is
+   also what makes absolute "Volume:" classpaths work.  path.separator is ';' on
+   AmigaOS so the embedded ':' (and any spaces) are not re-split. */
+static char *amigaClassPath(char *cp) {
+    extern char *amiga_launch_cwd;            /* the launch dir "Volume:dir", or NULL */
+    char *launch = amiga_launch_cwd;
+    int llen = launch ? strlen(launch) : 0;
+    int n = strlen(cp), e = 1, i;
+    char *out, *o;
+
+    for(i = 0; i < n; i++)
+        if(cp[i] == ';') e++;
+    out = o = sysMalloc(n + e * (llen + 2) + 1);
+
+    for(i = 0; i < n; ) {
+        int s = i, hasvol = 0, k;
+        while(i < n && cp[i] != ';') i++;       /* entry = cp[s..i) */
+        for(k = s; k < i && cp[k] != '/'; k++)
+            if(cp[k] == ':') { hasvol = 1; break; }
+        if(cp[s] != '/') {                      /* make it absolute */
+            *o++ = '/';
+            if(!hasvol && launch != NULL) {     /* relative -> anchor at launch dir */
+                memcpy(o, launch, llen); o += llen;
+                *o++ = '/';
+            }
+        }
+        memcpy(o, &cp[s], i - s); o += i - s;
+        if(i < n) *o++ = cp[i++];               /* keep the ';' separator */
+    }
+    *o = '\0';
+    return out;
+}
+#endif
+
 void setClassPath(InitArgs *args) {
     char *env;
 #ifdef __amigaos4__
-    /* Default to an EMPTY app classpath, not "." -- on AmigaOS "." canonicalises
-       to the volume path (e.g. "AmigaOS:Test"), which sun.misc.Launcher's
-       URLClassPath then mangles (':' = path.separator vs Amiga "volume:") /
-       mis-converts to a URL ("volume:" looks like a scheme).  An empty
-       java.class.path gives the AppClassLoader no entries to choke on; the app
-       class is supplied on -Xbootclasspath and found via bootstrap delegation. */
-    classpath = args->classpath ? args->classpath :
-                 ((env = getenv("CLASSPATH")) ? env : "");
+    /* Rewrite the -cp to launch-anchored absolute Unix paths (see amigaClassPath);
+       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 : ".");
diff --git a/src/classlib/openjdk/dll.c b/src/classlib/openjdk/dll.c
index 11d2088..5f78abd 100644
--- a/src/classlib/openjdk/dll.c
+++ b/src/classlib/openjdk/dll.c
@@ -42,11 +42,11 @@ int classlibInitialiseDll() {
 }
 
 #ifdef __amigaos4__
-/* Flat Amiga layout: the native .so files live beside the VM, and the standard
-   launch CDs to the install dir -- so the default boot library path is ".".
-   ("Volume:dir" here would be split on its ':' by java.lang.ClassLoader's
-   path.separator parsing; the "./lib.so" form is normalised by the native
-   open/dlopen chokepoints.) */
+/* The native .so files live beside the VM, and the VM chdir's to its own program
+   dir at startup (amigaSetupCwd) -- and user.dir is that same install dir -- so the
+   boot library path is ".".  java.lang.ClassLoader resolves "." against user.dir =
+   the install dir, finding the natives there.  Colon-free, so path.separator (';')
+   does not split it; the "./lib.so" form is normalised by the native open chokepoint. */
 char *classlibDefaultBootDllPath() {
     char *dll_path = sysMalloc(2);
     return strcpy(dll_path, ".");
diff --git a/src/classlib/openjdk/properties.c b/src/classlib/openjdk/properties.c
index 481963b..fc8877e 100644
--- a/src/classlib/openjdk/properties.c
+++ b/src/classlib/openjdk/properties.c
@@ -30,9 +30,18 @@
    explicitly via -Xbootclasspath and -Dsun.boot.library.path, so they don't
    depend on the (Unix-shaped) java.home/lib/... derivation. */
 char *classlibDefaultJavaHome() {
-    char *path = nativeJVMPath();
-    char *pntr, *home;
+    /* 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;
 
diff --git a/src/os/amiga/os.c b/src/os/amiga/os.c
index 1a6f5be..0bae66a 100644
--- a/src/os/amiga/os.c
+++ b/src/os/amiga/os.c
@@ -73,6 +73,50 @@ char *nativeLibError() {
     return dlerror();
 }
 
+/* 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 (the user's cwd), captured before the
+   startup chdir -- setUserDirProperty() uses it for java.io's user.dir so a
+   relative -cp resolves against the USER's dir, not the install drawer. */
+char *amiga_launch_cwd = NULL;
+
+/* Run the VM with its current dir = its own program directory, so the colon-free,
+   cwd-relative boot classpath / sun.boot.library.path / java.home resolve against
+   the install drawer.  (On AmigaOS ':' is BOTH the volume separator and Java's
+   path.separator, so absolute paths cannot be used in those path *lists*.)  clib4
+   saves the entry CurrentDir and its destructor restores it at exit, so this does
+   NOT leak into the caller's shell.  Called once from initialisePlatform(). */
+void amigaSetupCwd(void) {
+    char *pd;
+
+    amiga_launch_cwd = getCwd();        /* the launch cwd -- BEFORE the chdir */
+    pd = amigaProgramDir();
+    if(pd != NULL)
+        chdir(pd);
+}
+
 char *nativeLibPath() {
     return getenv("LD_LIBRARY_PATH");
 }
@@ -83,6 +127,8 @@ void *nativeLibOpen(char *path) {
        (and a leading "./") so clib4 dlopen gets a real AmigaDOS path. */
     char *p = path;
     void *h;
+    if(path == NULL)
+        return NULL;
     if(p[0] == '.' && p[1] == '/')
         p += 2;
     else if(p[0] == '/') {
diff --git a/src/os/amiga/powerpc/init.c b/src/os/amiga/powerpc/init.c
index 60d01ae..cd42452 100644
--- a/src/os/amiga/powerpc/init.c
+++ b/src/os/amiga/powerpc/init.c
@@ -50,4 +50,14 @@ void initialisePlatform() {
     /* 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/properties.c b/src/properties.c
index 19169ff..9dd6bca 100644
--- a/src/properties.c
+++ b/src/properties.c
@@ -150,15 +150,20 @@ char *getExecutionEngineName() {
 }
 
 void setUserDirProperty(Object *properties) {
-    char *cwd = getCwd();
+    char *cwd;
 
 #ifdef __amigaos4__
-    /* Present user.dir as Unix-absolute ("/Volume:dir") -- part of the Amiga
-       path model: java.io/java.nio see '/'-prefixed absolute paths (so
-       File.isAbsolute()/toURI()/UnixFileSystem don't mis-handle "Volume:"),
-       and the native open/stat chokepoints strip the '/' back off.  Without
-       this, sun.nio.fs.UnixFileSystem rejects user.dir ("default directory
-       must be absolute") and File.getAbsolutePath() doubles paths. */
+    /* user.dir = the install dir (= the VM's program dir, which it chdir'd to at
+       startup).  The on-demand natives (libzip, ...) are loaded by ClassLoader
+       RELATIVE TO user.dir, so user.dir must be the install dir for them to
+       resolve.  The user's -cp is made launch-absolute in setClassPath, so it
+       still resolves where `java` was run.  (getCwd() does not reliably reflect
+       the startup chdir, so derive it from the program dir.)  Present it
+       Unix-absolute ("/Volume:dir") so java.io/java.nio accept it -- the native
+       open/stat chokepoints strip the '/' back off. */
+    extern char *amigaProgramDir(void);
+    char *pd = amigaProgramDir();
+    cwd = pd != NULL ? strcpy(sysMalloc(strlen(pd) + 1), pd) : getCwd();
     if(cwd != NULL && cwd[0] != '/') {
         char *slashed = sysMalloc(strlen(cwd) + 2);
         slashed[0] = '/';
@@ -166,6 +171,8 @@ void setUserDirProperty(Object *properties) {
         sysFree(cwd);
         cwd = slashed;
     }
+#else
+    cwd = getCwd();
 #endif
 
     setProperty(properties, "user.dir", cwd);
@@ -206,7 +213,15 @@ void addDefaultProperties(Object *properties) {
     setProperty(properties, "java.ext.dirs", classlibDefaultExtDirs());
     setProperty(properties, "java.io.tmpdir", "/tmp");
     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); multiple -cp entries use ';'. */
+    setProperty(properties, "path.separator", ";");
+#else
     setProperty(properties, "path.separator", ":");
+#endif
     setProperty(properties, "line.separator", "\n");
     setProperty(properties, "user.name", getenv("USER"));
     setProperty(properties, "user.home", getenv("HOME"));
diff --git a/src/thread.c b/src/thread.c
index 44d3d79..9d7f66f 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -816,6 +816,28 @@ static void *shell(void *args) {
 
     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;
 }
 
-- 
2.49.0.windows.1


From 416f0762908ab750cbc623cc6d0a744fad194766 Mon Sep 17 00:00:00 2001
From: Richard Gibbs <rich_gibbs@hotmail.com>
Date: Tue, 23 Jun 2026 19:37:56 +0100
Subject: [PATCH 13/13] amiga: sun.boot.class.path uses ';' + absolute paths
 (fix niopatch requester / Trampoline)

On AmigaOS path.separator is ';' (':' is the volume separator), but JamVM exposed
sun.boot.class.path as its raw ':'-joined C boot path.  OpenJDK's
sun.misc.Launcher.getBootstrapClassPath() splits sun.boot.class.path on
path.separator, so the whole value was read as ONE entry "niopatch.zip:...":
AmigaDOS treated the leading "niopatch.zip:" as a missing volume (the "Please
insert volume niopatch.zip" requester), and every getBootstrapResource() failed.
That broke sun.reflect.misc.MethodUtil -- unable to read sun/reflect/misc/
Trampoline.class via the boot URLClassPath it fell back to the bootstrap loader,
which defined Trampoline with the null loader, so Trampoline.<clinit> threw
"Trampoline must not be defined by the bootstrap class loader" (forum 0.5.3,
running SwingDemo / VmSuite).

Fix: expose sun.boot.class.path as ';'-separated ABSOLUTE Unix-form entries
anchored at java.home (amigaBootClassPathProperty in class.c), the same shape
setClassPath gives the app -cp.  The raw C bootpath stays ':'-joined
(parseBootClassPath still splits on ':' for the VM's own loader) -- this builds a
SEPARATE property string.  Also make classlibDefaultEndorsedDirs Amiga-relative
("lib/endorsed") like classlibDefaultExtDirs, so java.endorsed.dirs carries no
volume ':' either.

Verified on QEMU: sun.boot.class.path now ';'-joined absolute; getSystemResource
("java/lang/Object.class") resolves; java.beans.Expression->MethodUtil->Trampoline
returns 5; SwingDemo opens with no requester.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/class.c                  | 56 ++++++++++++++++++++++++++++++++++++
 src/classlib/openjdk/class.c | 11 +++++++
 src/properties.c             | 15 ++++++++++
 3 files changed, 82 insertions(+)

diff --git a/src/class.c b/src/class.c
index 4a09e67..4f988b8 100644
--- a/src/class.c
+++ b/src/class.c
@@ -2302,6 +2302,62 @@ static char *amigaClassPath(char *cp) {
     *o = '\0';
     return out;
 }
+
+/* Build the Java-facing value of the "sun.boot.class.path" property.  The C-level
+   boot path (getBootClassPath()) is a ':'-separated list of colon-free RELATIVE
+   names (niopatch.zip, rt.jar, ..., classes) -- ':' is what JamVM's own
+   parseBootClassPath() splits on, so the raw bootpath MUST stay ':'-joined for the
+   VM's intrinsic boot class search.  But on AmigaOS path.separator is ';' (':' is
+   the volume separator), and OpenJDK's sun.misc.Launcher.getBootstrapClassPath()
+   splits sun.boot.class.path on File.pathSeparator (= path.separator).  Exposing
+   the raw ':'-joined value therefore makes Java read it as ONE bogus entry
+   "niopatch.zip:resources.jar:..." -- whose leading "niopatch.zip:" AmigaDOS treats
+   as a missing volume (the "Please insert volume niopatch.zip" requester), and every
+   getBootstrapResource() then fails.  That in turn breaks sun.reflect.misc.MethodUtil:
+   its findClass can't read sun/reflect/misc/Trampoline.class via the (broken) boot
+   URLClassPath, so loadClass falls through to the bootstrap loader, which DOES find
+   Trampoline in rt.jar and defines it with the null loader -- and Trampoline.<clinit>
+   throws "Trampoline must not be defined by the bootstrap class loader".
+     Re-emit the list as ';'-separated ABSOLUTE Unix-form entries anchored at
+   java.home ("/<java.home>/<name>") -- the same shape setClassPath gives the app -cp
+   (amigaClassPath) -- so the boot URLClassPath resolves each jar to the real file
+   (the native open chokepoint strips the leading '/'), with no volume in leading
+   position.  This is a SEPARATE string: it does not mutate the global bootpath the
+   VM's own class loading relies on. */
+char *amigaBootClassPathProperty(void) {
+    char *bcp  = getBootClassPath();
+    char *home = getJavaHome();
+    int hlen, n, entries, i;
+    char *out, *o;
+
+    if(bcp == NULL)
+        return NULL;
+    if(home == NULL)
+        home = "";
+    hlen = strlen(home);
+    n = strlen(bcp);
+
+    for(entries = 1, i = 0; i < n; i++)   /* one entry per ':' plus one */
+        if(bcp[i] == ':') entries++;
+    out = o = sysMalloc(n + entries * (hlen + 2) + 1);
+
+    for(i = 0; i < n; ) {
+        int s = i;
+        while(i < n && bcp[i] != ':') i++;        /* entry = bcp[s..i) (colon-free) */
+        if(i > s && bcp[s] != '/') {              /* make absolute, anchored at java.home */
+            *o++ = '/';
+            if(hlen) {
+                memcpy(o, home, hlen); o += hlen;
+                if(home[hlen - 1] != ':')         /* "Volume:" already ends in the sep */
+                    *o++ = '/';
+            }
+        }
+        memcpy(o, &bcp[s], i - s); o += i - s;
+        if(i < n) { *o++ = ';'; i++; }            /* ':' list separator -> ';' */
+    }
+    *o = '\0';
+    return out;
+}
 #endif
 
 void setClassPath(InitArgs *args) {
diff --git a/src/classlib/openjdk/class.c b/src/classlib/openjdk/class.c
index ef9c885..b4ce04f 100644
--- a/src/classlib/openjdk/class.c
+++ b/src/classlib/openjdk/class.c
@@ -183,6 +183,16 @@ char *classlibDefaultExtDirs() {
 }
 #endif
 
+#ifdef __amigaos4__
+/* Relative (CWD = install dir), colon-free -- like classlibDefaultExtDirs above.
+   The Unix "<java.home>/lib/endorsed" form would carry a volume ':' (e.g.
+   "SYS:Java/lib/endorsed"); exposed as java.endorsed.dirs under path.separator ';'
+   that leading "SYS:" token is a volume reference sun.misc.Launcher would resolve. */
+char *classlibDefaultEndorsedDirs() {
+    char *endorsed_dirs = sysMalloc(sizeof("lib/endorsed"));
+    return strcpy(endorsed_dirs, "lib/endorsed");
+}
+#else
 char *classlibDefaultEndorsedDirs() {
     char *java_home = getJavaHome();
     char *endorsed_dirs = sysMalloc(strlen(java_home) +
@@ -190,6 +200,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/properties.c b/src/properties.c
index 9dd6bca..acd5e05 100644
--- a/src/properties.c
+++ b/src/properties.c
@@ -206,7 +206,22 @@ 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());
-- 
2.49.0.windows.1