summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
-rw-r--r--patches/jamvm-2.0.0_pre.local.patch1793
-rw-r--r--vars/build.vars19
-rw-r--r--vars/jamvm.vars9
3 files changed, 1820 insertions, 1 deletions
diff --git a/patches/jamvm-2.0.0_pre.local.patch b/patches/jamvm-2.0.0_pre.local.patch
new file mode 100644
index 00000000..cb400f49
--- /dev/null
+++ b/patches/jamvm-2.0.0_pre.local.patch
@@ -0,0 +1,1793 @@
+diff -Nru jamvm-2.0.0.orig/configure.ac jamvm-2.0.0/configure.ac
+--- jamvm-2.0.0.orig/configure.ac 2014-06-10 22:33:37.000000000 +0200
++++ jamvm-2.0.0/configure.ac 2018-06-03 17:23:55.719602871 +0200
+@@ -32,6 +32,7 @@
+
+ case "$host" in
+ i[[3456]]86-*-linux*) host_cpu=i386 host_os=linux ;;
++i[[3456]]86-*-midipix*) host_cpu=i386 host_os=midipix ;;
+ i[[3456]]86-*-kfreebsd*) host_cpu=i386 host_os=linux ;;
+ i[[3456]]86-*-darwin*) host_cpu=i386 host_os=darwin ;;
+ arm*-*-darwin*) host_cpu=arm host_os=darwin libdl_needed=no ;;
+@@ -39,6 +40,7 @@
+ i386-*-freebsd*) host_os=bsd libdl_needed=no ;;
+ i386-*-solaris*) host_cpu=x86 host_os=solaris ;;
+ x86_64-*-linux*) host_os=linux ;;
++x86_64-*-midipix*) host_os=midipix ;;
+ hppa*-*-linux*) host_cpu=parisc host_os=linux ;;
+ mips*-*-linux*) host_cpu=mips host_os=linux ;;
+ x86_64-*-openbsd*) host_os=bsd libdl_needed=no ;;
+@@ -397,6 +399,7 @@
+ src/arch/Makefile \
+ src/os/Makefile \
+ src/os/linux/Makefile \
++ src/os/midipix/Makefile \
+ src/os/darwin/Makefile \
+ src/os/bsd/Makefile \
+ src/os/solaris/Makefile \
+@@ -407,6 +410,8 @@
+ src/os/linux/x86_64/Makefile \
+ src/os/linux/parisc/Makefile \
+ src/os/linux/mips/Makefile \
++ src/os/midipix/x86_64/Makefile \
++ src/os/midipix/i386/Makefile \
+ src/os/darwin/i386/Makefile \
+ src/os/darwin/arm/Makefile \
+ src/os/darwin/powerpc/Makefile \
+diff -Nru jamvm-2.0.0.orig/src/os/Makefile.am jamvm-2.0.0/src/os/Makefile.am
+--- jamvm-2.0.0.orig/src/os/Makefile.am 2012-05-17 23:01:47.000000000 +0200
++++ jamvm-2.0.0/src/os/Makefile.am 2018-06-03 17:01:50.560924958 +0200
+@@ -20,5 +20,5 @@
+ ##
+
+ SUBDIRS = @os@
+-DIST_SUBDIRS = linux darwin bsd solaris
++DIST_SUBDIRS = linux darwin bsd solaris midipix
+
+diff -Nru jamvm-2.0.0.orig/src/os/midipix/i386/dll_md.c jamvm-2.0.0/src/os/midipix/i386/dll_md.c
+--- jamvm-2.0.0.orig/src/os/midipix/i386/dll_md.c 1970-01-01 01:00:00.000000000 +0100
++++ jamvm-2.0.0/src/os/midipix/i386/dll_md.c 2012-05-17 23:01:47.000000000 +0200
+@@ -0,0 +1,117 @@
++/*
++ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011
++ * 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.
++ */
++
++#include "jam.h"
++
++#ifndef USE_FFI
++#include <string.h>
++#include "sig.h"
++
++#define RET_VOID 0
++#define RET_DOUBLE 1
++#define RET_LONG 2
++#define RET_FLOAT 3
++#define RET_BYTE 4
++#define RET_CHAR 5
++#define RET_SHORT 6
++#define RET_DFLT 7
++
++int nativeExtraArg(MethodBlock *mb) {
++ int len = strlen(mb->type);
++ if(mb->type[len-2] == ')')
++ switch(mb->type[len-1]) {
++ case 'V':
++ return RET_VOID;
++ case 'D':
++ return RET_DOUBLE;
++ case 'J':
++ return RET_LONG;
++ case 'F':
++ return RET_FLOAT;
++ case 'B':
++ case 'Z':
++ return RET_BYTE;
++ case 'C':
++ return RET_CHAR;
++ case 'S':
++ return RET_SHORT;
++ }
++
++ return RET_DFLT;
++}
++
++u4 *callJNIMethod(void *env, Class *class, char *sig, int ret_type,
++ u4 *ostack, unsigned char *f, int args) {
++
++ int i;
++ u4 *sp;
++ u4 method_args[args + (class ? 2 : 1)];
++
++ asm volatile ("movl %%esp,%0" : "=m" (sp) :);
++
++ *sp++ = (u4)env;
++
++ if(class)
++ *sp++ = (u4)class;
++
++ for(i = 0; i < args; i++)
++ sp[i] = ostack[i];
++
++ switch(ret_type) {
++ case RET_VOID:
++ (*(void (*)())f)();
++ break;
++
++ case RET_DOUBLE:
++ *(double*)ostack = (*(double (*)())f)();
++ ostack += 2;
++ break;
++
++ case RET_LONG:
++ *(long long*)ostack = (*(long long (*)())f)();
++ ostack += 2;
++ break;
++
++ case RET_FLOAT:
++ *(float*)ostack = (*(float (*)())f)();
++ ostack++;
++ break;
++
++ case RET_BYTE:
++ *ostack++ = (*(signed char (*)())f)();
++ break;
++
++ case RET_CHAR:
++ *ostack++ = (*(unsigned short (*)())f)();
++ break;
++
++ case RET_SHORT:
++ *ostack++ = (*(signed short (*)())f)();
++ break;
++
++ default:
++ *ostack++ = (*(u4 (*)())f)();
++ break;
++ }
++
++ return ostack;
++}
++#endif
+diff -Nru jamvm-2.0.0.orig/src/os/midipix/i386/init.c jamvm-2.0.0/src/os/midipix/i386/init.c
+--- jamvm-2.0.0.orig/src/os/midipix/i386/init.c 1970-01-01 01:00:00.000000000 +0100
++++ jamvm-2.0.0/src/os/midipix/i386/init.c 2012-05-17 23:01:47.000000000 +0200
+@@ -0,0 +1,38 @@
++/*
++ * Copyright (C) 2003, 2004, 2006, 2007
++ * 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.
++ */
++
++#include <fpu_control.h>
++
++/* Change floating point precision to double (64-bit) from
++ * the extended (80-bit) Linux default. */
++
++void setDoublePrecision() {
++ fpu_control_t cw;
++
++ _FPU_GETCW(cw);
++ cw &= ~_FPU_EXTENDED;
++ cw |= _FPU_DOUBLE;
++ _FPU_SETCW(cw);
++}
++
++void initialisePlatform() {
++ setDoublePrecision();
++}
+diff -Nru jamvm-2.0.0.orig/src/os/midipix/i386/jni-stubs.c jamvm-2.0.0/src/os/midipix/i386/jni-stubs.c
+--- jamvm-2.0.0.orig/src/os/midipix/i386/jni-stubs.c 1970-01-01 01:00:00.000000000 +0100
++++ jamvm-2.0.0/src/os/midipix/i386/jni-stubs.c 2012-06-27 02:35:00.000000000 +0200
+@@ -0,0 +1,927 @@
++/* Generated by gen-stubs.c from signature file sigs (profiling off) */
++
++#include "jam.h"
++
++#ifdef USE_MD_STUBS
++#include "stubs.h"
++#include "properties.h"
++#include "jni-internal.h"
++
++extern void *jni_env;
++
++/* Static signatures */
++
++/* ()I */
++static uintptr_t *static__I(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(uintptr_t (*)(void*, void*))mb->code) (
++ &jni_env,
++ class);
++
++ return ostack + 1;
++}
++
++/* ()J */
++static uintptr_t *static__J(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *(int64_t*)ostack = (*(int64_t (*)(void*, void*))mb->code) (
++ &jni_env,
++ class);
++
++ return ostack + 2;
++}
++
++/* ()L */
++static uintptr_t *static__L(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (uintptr_t)REF_TO_OBJ((*(uintptr_t (*)(void*, void*))mb->code) (
++ &jni_env,
++ class));
++
++ return ostack + 1;
++}
++
++/* ()V */
++static uintptr_t *static__V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*))mb->code) (
++ &jni_env,
++ class);
++
++ return ostack + 0;
++}
++
++/* (I)B */
++static uintptr_t *static_I_B(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(int8_t (*)(void*, void*, uintptr_t))mb->code) (
++ &jni_env,
++ class,
++ *(uintptr_t *)&ostack[0]);
++
++ return ostack + 1;
++}
++
++/* (I)F */
++static uintptr_t *static_I_F(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *((float*)ostack + IS_BE64) = (*(float (*)(void*, void*, uintptr_t))mb->code) (
++ &jni_env,
++ class,
++ *(uintptr_t *)&ostack[0]);
++
++ return ostack + 1;
++}
++
++/* (I)I */
++static uintptr_t *static_I_I(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(uintptr_t (*)(void*, void*, uintptr_t))mb->code) (
++ &jni_env,
++ class,
++ *(uintptr_t *)&ostack[0]);
++
++ return ostack + 1;
++}
++
++/* (I)L */
++static uintptr_t *static_I_L(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (uintptr_t)REF_TO_OBJ((*(uintptr_t (*)(void*, void*, uintptr_t))mb->code) (
++ &jni_env,
++ class,
++ *(uintptr_t *)&ostack[0]));
++
++ return ostack + 1;
++}
++
++/* (J)D */
++static uintptr_t *static_J_D(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *(double*)ostack = (*(double (*)(void*, void*, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0]);
++
++ return ostack + 2;
++}
++
++/* (J)I */
++static uintptr_t *static_J_I(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(uintptr_t (*)(void*, void*, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0]);
++
++ return ostack + 1;
++}
++
++/* (J)J */
++static uintptr_t *static_J_J(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *(int64_t*)ostack = (*(int64_t (*)(void*, void*, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0]);
++
++ return ostack + 2;
++}
++
++/* (J)L */
++static uintptr_t *static_J_L(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (uintptr_t)REF_TO_OBJ((*(uintptr_t (*)(void*, void*, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0]));
++
++ return ostack + 1;
++}
++
++/* (J)V */
++static uintptr_t *static_J_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0]);
++
++ return ostack + 0;
++}
++
++/* (JI)I */
++static uintptr_t *static_JI_I(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(uintptr_t (*)(void*, void*, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(uintptr_t *)&ostack[2]);
++
++ return ostack + 1;
++}
++
++/* (JI)J */
++static uintptr_t *static_JI_J(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *(int64_t*)ostack = (*(int64_t (*)(void*, void*, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(uintptr_t *)&ostack[2]);
++
++ return ostack + 2;
++}
++
++/* (JI)L */
++static uintptr_t *static_JI_L(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (uintptr_t)REF_TO_OBJ((*(uintptr_t (*)(void*, void*, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(uintptr_t *)&ostack[2]));
++
++ return ostack + 1;
++}
++
++/* (JI)V */
++static uintptr_t *static_JI_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(uintptr_t *)&ostack[2]);
++
++ return ostack + 0;
++}
++
++/* (JJ)B */
++static uintptr_t *static_JJ_B(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(int8_t (*)(void*, void*, int64_t, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2]);
++
++ return ostack + 1;
++}
++
++/* (JJ)D */
++static uintptr_t *static_JJ_D(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *(double*)ostack = (*(double (*)(void*, void*, int64_t, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2]);
++
++ return ostack + 2;
++}
++
++/* (JJ)I */
++static uintptr_t *static_JJ_I(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(uintptr_t (*)(void*, void*, int64_t, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2]);
++
++ return ostack + 1;
++}
++
++/* (JJ)J */
++static uintptr_t *static_JJ_J(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *(int64_t*)ostack = (*(int64_t (*)(void*, void*, int64_t, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2]);
++
++ return ostack + 2;
++}
++
++/* (JJ)L */
++static uintptr_t *static_JJ_L(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (uintptr_t)REF_TO_OBJ((*(uintptr_t (*)(void*, void*, int64_t, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2]));
++
++ return ostack + 1;
++}
++
++/* (JJ)V */
++static uintptr_t *static_JJ_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2]);
++
++ return ostack + 0;
++}
++
++/* (JJI)L */
++static uintptr_t *static_JJI_L(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (uintptr_t)REF_TO_OBJ((*(uintptr_t (*)(void*, void*, int64_t, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2],
++ *(uintptr_t *)&ostack[4]));
++
++ return ostack + 1;
++}
++
++/* (JJI)V */
++static uintptr_t *static_JJI_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2],
++ *(uintptr_t *)&ostack[4]);
++
++ return ostack + 0;
++}
++
++/* (JJJI)V */
++static uintptr_t *static_JJJI_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, int64_t, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2],
++ *(int64_t *)&ostack[4],
++ *(uintptr_t *)&ostack[6]);
++
++ return ostack + 0;
++}
++
++/* (JJJJ)V */
++static uintptr_t *static_JJJJ_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, int64_t, int64_t, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2],
++ *(int64_t *)&ostack[4],
++ *(int64_t *)&ostack[6]);
++
++ return ostack + 0;
++}
++
++/* (JJJJI)I */
++static uintptr_t *static_JJJJI_I(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(uintptr_t (*)(void*, void*, int64_t, int64_t, int64_t, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2],
++ *(int64_t *)&ostack[4],
++ *(int64_t *)&ostack[6],
++ *(uintptr_t *)&ostack[8]);
++
++ return ostack + 1;
++}
++
++/* (JJJJJJ)V */
++static uintptr_t *static_JJJJJJ_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2],
++ *(int64_t *)&ostack[4],
++ *(int64_t *)&ostack[6],
++ *(int64_t *)&ostack[8],
++ *(int64_t *)&ostack[10]);
++
++ return ostack + 0;
++}
++
++/* (JJJJJJJJJI)V */
++static uintptr_t *static_JJJJJJJJJI_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2],
++ *(int64_t *)&ostack[4],
++ *(int64_t *)&ostack[6],
++ *(int64_t *)&ostack[8],
++ *(int64_t *)&ostack[10],
++ *(int64_t *)&ostack[12],
++ *(int64_t *)&ostack[14],
++ *(int64_t *)&ostack[16],
++ *(uintptr_t *)&ostack[18]);
++
++ return ostack + 0;
++}
++
++/* (JJJJJJJJJJJJ)I */
++static uintptr_t *static_JJJJJJJJJJJJ_I(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(uintptr_t (*)(void*, void*, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t))mb->code) (
++ &jni_env,
++ class,
++ *(int64_t *)&ostack[0],
++ *(int64_t *)&ostack[2],
++ *(int64_t *)&ostack[4],
++ *(int64_t *)&ostack[6],
++ *(int64_t *)&ostack[8],
++ *(int64_t *)&ostack[10],
++ *(int64_t *)&ostack[12],
++ *(int64_t *)&ostack[14],
++ *(int64_t *)&ostack[16],
++ *(int64_t *)&ostack[18],
++ *(int64_t *)&ostack[20],
++ *(int64_t *)&ostack[22]);
++
++ return ostack + 1;
++}
++
++/* Non-static signatures */
++
++/* ()B */
++static uintptr_t *__B(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(int8_t (*)(void*, void*))mb->code) (
++ &jni_env,
++ (void*)ostack[0]);
++
++ return ostack + 1;
++}
++
++/* ()I */
++static uintptr_t *__I(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(uintptr_t (*)(void*, void*))mb->code) (
++ &jni_env,
++ (void*)ostack[0]);
++
++ return ostack + 1;
++}
++
++/* ()J */
++static uintptr_t *__J(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *(int64_t*)ostack = (*(int64_t (*)(void*, void*))mb->code) (
++ &jni_env,
++ (void*)ostack[0]);
++
++ return ostack + 2;
++}
++
++/* ()L */
++static uintptr_t *__L(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (uintptr_t)REF_TO_OBJ((*(uintptr_t (*)(void*, void*))mb->code) (
++ &jni_env,
++ (void*)ostack[0]));
++
++ return ostack + 1;
++}
++
++/* ()V */
++static uintptr_t *__V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*))mb->code) (
++ &jni_env,
++ (void*)ostack[0]);
++
++ return ostack + 0;
++}
++
++/* (I)B */
++static uintptr_t *_I_B(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(int8_t (*)(void*, void*, uintptr_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(uintptr_t *)&ostack[1]);
++
++ return ostack + 1;
++}
++
++/* (I)I */
++static uintptr_t *_I_I(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(uintptr_t (*)(void*, void*, uintptr_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(uintptr_t *)&ostack[1]);
++
++ return ostack + 1;
++}
++
++/* (I)J */
++static uintptr_t *_I_J(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *(int64_t*)ostack = (*(int64_t (*)(void*, void*, uintptr_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(uintptr_t *)&ostack[1]);
++
++ return ostack + 2;
++}
++
++/* (I)L */
++static uintptr_t *_I_L(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (uintptr_t)REF_TO_OBJ((*(uintptr_t (*)(void*, void*, uintptr_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(uintptr_t *)&ostack[1]));
++
++ return ostack + 1;
++}
++
++/* (I)V */
++static uintptr_t *_I_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, uintptr_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(uintptr_t *)&ostack[1]);
++
++ return ostack + 0;
++}
++
++/* (J)B */
++static uintptr_t *_J_B(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(int8_t (*)(void*, void*, int64_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1]);
++
++ return ostack + 1;
++}
++
++/* (J)J */
++static uintptr_t *_J_J(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *(int64_t*)ostack = (*(int64_t (*)(void*, void*, int64_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1]);
++
++ return ostack + 2;
++}
++
++/* (J)L */
++static uintptr_t *_J_L(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (uintptr_t)REF_TO_OBJ((*(uintptr_t (*)(void*, void*, int64_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1]));
++
++ return ostack + 1;
++}
++
++/* (J)V */
++static uintptr_t *_J_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1]);
++
++ return ostack + 0;
++}
++
++/* (JI)I */
++static uintptr_t *_JI_I(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(uintptr_t (*)(void*, void*, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(uintptr_t *)&ostack[3]);
++
++ return ostack + 1;
++}
++
++/* (JI)J */
++static uintptr_t *_JI_J(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *(int64_t*)ostack = (*(int64_t (*)(void*, void*, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(uintptr_t *)&ostack[3]);
++
++ return ostack + 2;
++}
++
++/* (JI)V */
++static uintptr_t *_JI_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(uintptr_t *)&ostack[3]);
++
++ return ostack + 0;
++}
++
++/* (JJ)V */
++static uintptr_t *_JJ_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, int64_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(int64_t *)&ostack[3]);
++
++ return ostack + 0;
++}
++
++/* (JJI)I */
++static uintptr_t *_JJI_I(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(uintptr_t (*)(void*, void*, int64_t, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(int64_t *)&ostack[3],
++ *(uintptr_t *)&ostack[5]);
++
++ return ostack + 1;
++}
++
++/* (JJI)L */
++static uintptr_t *_JJI_L(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (uintptr_t)REF_TO_OBJ((*(uintptr_t (*)(void*, void*, int64_t, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(int64_t *)&ostack[3],
++ *(uintptr_t *)&ostack[5]));
++
++ return ostack + 1;
++}
++
++/* (JJJ)I */
++static uintptr_t *_JJJ_I(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (*(uintptr_t (*)(void*, void*, int64_t, int64_t, int64_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(int64_t *)&ostack[3],
++ *(int64_t *)&ostack[5]);
++
++ return ostack + 1;
++}
++
++/* (JJJ)J */
++static uintptr_t *_JJJ_J(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *(int64_t*)ostack = (*(int64_t (*)(void*, void*, int64_t, int64_t, int64_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(int64_t *)&ostack[3],
++ *(int64_t *)&ostack[5]);
++
++ return ostack + 2;
++}
++
++/* (JJJ)L */
++static uintptr_t *_JJJ_L(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ *ostack = (uintptr_t)REF_TO_OBJ((*(uintptr_t (*)(void*, void*, int64_t, int64_t, int64_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(int64_t *)&ostack[3],
++ *(int64_t *)&ostack[5]));
++
++ return ostack + 1;
++}
++
++/* (JJJ)V */
++static uintptr_t *_JJJ_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, int64_t, int64_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(int64_t *)&ostack[3],
++ *(int64_t *)&ostack[5]);
++
++ return ostack + 0;
++}
++
++/* (JJJJ)V */
++static uintptr_t *_JJJJ_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, int64_t, int64_t, int64_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(int64_t *)&ostack[3],
++ *(int64_t *)&ostack[5],
++ *(int64_t *)&ostack[7]);
++
++ return ostack + 0;
++}
++
++/* (JJJJJ)V */
++static uintptr_t *_JJJJJ_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, int64_t, int64_t, int64_t, int64_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(int64_t *)&ostack[3],
++ *(int64_t *)&ostack[5],
++ *(int64_t *)&ostack[7],
++ *(int64_t *)&ostack[9]);
++
++ return ostack + 0;
++}
++
++/* (JJJJJJI)V */
++static uintptr_t *_JJJJJJI_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, uintptr_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(int64_t *)&ostack[3],
++ *(int64_t *)&ostack[5],
++ *(int64_t *)&ostack[7],
++ *(int64_t *)&ostack[9],
++ *(int64_t *)&ostack[11],
++ *(uintptr_t *)&ostack[13]);
++
++ return ostack + 0;
++}
++
++/* (JJJJJJJJJ)V */
++static uintptr_t *_JJJJJJJJJ_V(Class *class, MethodBlock *mb, uintptr_t *ostack) {
++ if(!initJNILrefs())
++ return NULL;
++
++ (*(void (*)(void*, void*, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t))mb->code) (
++ &jni_env,
++ (void*)ostack[0],
++ *(int64_t *)&ostack[1],
++ *(int64_t *)&ostack[3],
++ *(int64_t *)&ostack[5],
++ *(int64_t *)&ostack[7],
++ *(int64_t *)&ostack[9],
++ *(int64_t *)&ostack[11],
++ *(int64_t *)&ostack[13],
++ *(int64_t *)&ostack[15],
++ *(int64_t *)&ostack[17]);
++
++ return ostack + 0;
++}
++
++
++JNIStub jni_static_stubs[] = {
++ {"()I", static__I},
++ {"()J", static__J},
++ {"()L", static__L},
++ {"()V", static__V},
++ {"(I)B", static_I_B},
++ {"(I)F", static_I_F},
++ {"(I)I", static_I_I},
++ {"(I)L", static_I_L},
++ {"(J)D", static_J_D},
++ {"(J)I", static_J_I},
++ {"(J)J", static_J_J},
++ {"(J)L", static_J_L},
++ {"(J)V", static_J_V},
++ {"(JI)I", static_JI_I},
++ {"(JI)J", static_JI_J},
++ {"(JI)L", static_JI_L},
++ {"(JI)V", static_JI_V},
++ {"(JJ)B", static_JJ_B},
++ {"(JJ)D", static_JJ_D},
++ {"(JJ)I", static_JJ_I},
++ {"(JJ)J", static_JJ_J},
++ {"(JJ)L", static_JJ_L},
++ {"(JJ)V", static_JJ_V},
++ {"(JJI)L", static_JJI_L},
++ {"(JJI)V", static_JJI_V},
++ {"(JJJI)V", static_JJJI_V},
++ {"(JJJJ)V", static_JJJJ_V},
++ {"(JJJJI)I", static_JJJJI_I},
++ {"(JJJJJJ)V", static_JJJJJJ_V},
++ {"(JJJJJJJJJI)V", static_JJJJJJJJJI_V},
++ {"(JJJJJJJJJJJJ)I", static_JJJJJJJJJJJJ_I},
++ {NULL, NULL}
++};
++
++JNIStub jni_stubs[] = {
++ {"()B", __B},
++ {"()I", __I},
++ {"()J", __J},
++ {"()L", __L},
++ {"()V", __V},
++ {"(I)B", _I_B},
++ {"(I)I", _I_I},
++ {"(I)J", _I_J},
++ {"(I)L", _I_L},
++ {"(I)V", _I_V},
++ {"(J)B", _J_B},
++ {"(J)J", _J_J},
++ {"(J)L", _J_L},
++ {"(J)V", _J_V},
++ {"(JI)I", _JI_I},
++ {"(JI)J", _JI_J},
++ {"(JI)V", _JI_V},
++ {"(JJ)V", _JJ_V},
++ {"(JJI)I", _JJI_I},
++ {"(JJI)L", _JJI_L},
++ {"(JJJ)I", _JJJ_I},
++ {"(JJJ)J", _JJJ_J},
++ {"(JJJ)L", _JJJ_L},
++ {"(JJJ)V", _JJJ_V},
++ {"(JJJJ)V", _JJJJ_V},
++ {"(JJJJJ)V", _JJJJJ_V},
++ {"(JJJJJJI)V", _JJJJJJI_V},
++ {"(JJJJJJJJJ)V", _JJJJJJJJJ_V},
++ {NULL, NULL}
++};
++#endif
+diff -Nru jamvm-2.0.0.orig/src/os/midipix/i386/Makefile.am jamvm-2.0.0/src/os/midipix/i386/Makefile.am
+--- jamvm-2.0.0.orig/src/os/midipix/i386/Makefile.am 1970-01-01 01:00:00.000000000 +0100
++++ jamvm-2.0.0/src/os/midipix/i386/Makefile.am 2012-05-17 23:01:47.000000000 +0200
+@@ -0,0 +1,25 @@
++##
++## Copyright (C) 2003, 2004, 2005, 2006, 2007, 2010
++## 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.
++##
++
++noinst_LTLIBRARIES = libnative.la
++libnative_la_SOURCES = init.c dll_md.c stubs_md.c jni-stubs.c
++
++AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src
+diff -Nru jamvm-2.0.0.orig/src/os/midipix/i386/stubs_md.c jamvm-2.0.0/src/os/midipix/i386/stubs_md.c
+--- jamvm-2.0.0.orig/src/os/midipix/i386/stubs_md.c 1970-01-01 01:00:00.000000000 +0100
++++ jamvm-2.0.0/src/os/midipix/i386/stubs_md.c 2012-06-27 02:35:00.000000000 +0200
+@@ -0,0 +1,63 @@
++/*
++ * Copyright (C) 2010, 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.
++ */
++
++#ifndef GEN_STUBS_INC
++#include "jam.h"
++#endif
++
++#if defined(GEN_STUBS_INC) || defined(USE_MD_STUBS)
++#include <string.h>
++#include "sig.h"
++
++char *convertSig2Simple(char *sig) {
++ char *simple_sig, *simple_pntr;
++ int count = 0;
++ int i;
++
++ SCAN_SIG(sig, count+=2, count++);
++ simple_sig = simple_pntr = sysMalloc((count + 1)/2 + 4);
++
++ *simple_pntr++ = '(';
++ for(i = 0; i < count/2; i++)
++ *simple_pntr++ = 'J';
++
++ if(count&0x1)
++ *simple_pntr++ = 'I';
++ *simple_pntr++ = ')';
++
++ switch(*sig) {
++ case 'Z':
++ *simple_pntr++ = 'B';
++ break;
++
++ case '[':
++ *simple_pntr++ = 'L';
++ break;
++
++ default:
++ *simple_pntr++ = *sig;
++ break;
++ }
++
++ *simple_pntr = '\0';
++ return simple_sig;
++}
++#endif
++
+diff -Nru jamvm-2.0.0.orig/src/os/midipix/Makefile.am jamvm-2.0.0/src/os/midipix/Makefile.am
+--- jamvm-2.0.0.orig/src/os/midipix/Makefile.am 1970-01-01 01:00:00.000000000 +0100
++++ jamvm-2.0.0/src/os/midipix/Makefile.am 2012-05-17 23:01:47.000000000 +0200
+@@ -0,0 +1,28 @@
++##
++## Copyright (C) 2003, 2004, 2005, 2006, 2007
++## 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.
++##
++
++SUBDIRS = @arch@
++DIST_SUBDIRS = i386 x86_64
++
++noinst_LTLIBRARIES = libos.la
++libos_la_SOURCES = os.c
++
++AM_CPPFLAGS = -I$(top_builddir)/src
+diff -Nru jamvm-2.0.0.orig/src/os/midipix/os.c jamvm-2.0.0/src/os/midipix/os.c
+--- jamvm-2.0.0.orig/src/os/midipix/os.c 1970-01-01 01:00:00.000000000 +0100
++++ jamvm-2.0.0/src/os/midipix/os.c 2014-02-03 20:37:36.000000000 +0100
+@@ -0,0 +1,108 @@
++/*
++ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2014
++ * 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.
++ */
++
++#include <stdio.h>
++#include <string.h>
++#include <stdlib.h>
++#include <unistd.h>
++#include <sys/sysinfo.h>
++
++#define __USE_GNU
++#include <dlfcn.h>
++#include <pthread.h>
++
++#include "../../jam.h"
++
++long long nativePhysicalMemory() {
++ /* Long longs are used here because with PAE, a 32-bit
++ machine can have more than 4GB of physical memory */
++
++ long long num_pages = sysconf(_SC_PHYS_PAGES);
++ long long page_size = sysconf(_SC_PAGESIZE);
++
++ return num_pages * page_size;
++}
++
++void *nativeStackBase() {
++#ifdef __UCLIBC__
++ return NULL;
++#else
++ pthread_attr_t attr;
++ void *addr;
++ size_t size;
++
++ pthread_getattr_np(pthread_self(), &attr);
++ pthread_attr_getstack(&attr, &addr, &size);
++
++ return addr+size;
++#endif
++}
++
++int nativeAvailableProcessors() {
++#ifdef __UCLIBC__
++ return 1;
++#else
++ return get_nprocs();
++#endif
++}
++
++char *nativeLibError() {
++ return dlerror();
++}
++
++char *nativeLibPath() {
++ return getenv("LD_LIBRARY_PATH");
++}
++
++void *nativeLibOpen(char *path) {
++ return dlopen(path, RTLD_LAZY);
++}
++
++void nativeLibClose(void *handle) {
++ dlclose(handle);
++}
++
++void *nativeLibSym(void *handle, char *symbol) {
++ return dlsym(handle, symbol);
++}
++
++char *nativeLibMapName(char *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) {
++ printf("Error: dladdr failed. Aborting VM\n");
++ exitVM(1);
++ }
++
++ path = sysMalloc(strlen(info.dli_fname) + 1);
++ strcpy(path, info.dli_fname);
++
++ return path;
++}
++
+diff -Nru jamvm-2.0.0.orig/src/os/midipix/x86_64/callNative.S jamvm-2.0.0/src/os/midipix/x86_64/callNative.S
+--- jamvm-2.0.0.orig/src/os/midipix/x86_64/callNative.S 1970-01-01 01:00:00.000000000 +0100
++++ jamvm-2.0.0/src/os/midipix/x86_64/callNative.S 2018-06-03 16:40:48.062473407 +0200
+@@ -0,0 +1,269 @@
++/*
++ * Copyright (C) 2008, 2009 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.
++ */
++
++#include "config.h"
++
++#ifndef USE_FFI
++.text
++.align 2
++.global callJNIMethod
++.type callJNIMethod,function
++
++/*
++ * Arguments passed in:
++ *
++ * %rdi JNIEnv
++ * %rsi class or NULL
++ * %rdx sig
++ * %rcx extra arg
++ * %r8 ostack
++ * %r9 function pntr
++ */
++
++callJNIMethod:
++ pushq %rbp
++ movq %rsp, %rbp
++
++ pushq %r8
++ pushq %r9
++ pushq %rbx
++ pushq %r12
++ pushq %r14
++ pushq %r15
++
++ testq %rsi, %rsi
++ jne alloc_space
++
++ movq (%r8), %rsi
++ addq $8, %r8
++
++alloc_space:
++ subq %rcx, %rsp
++
++/* Setup argument registers:
++ * rdx, rcx, r8, r9
++ * xmm0 - xmm7
++ *
++ * local register usage:
++ * r10 = int reg count
++ * r11 = double handler
++ * r12 = float handler
++ * r14 = sig pntr
++ * r15 = stack pntr
++ * rbx = ostack pntr
++ */
++
++ leaq double_regs-10(%rip), %r11
++ leaq float_regs-10(%rip), %r12
++ leaq 1(%rdx), %r14
++ movq %rsp, %r15
++ xorq %r10, %r10
++ movq %r8, %rbx
++
++next:
++ movzbq (%r14), %rax
++ incq %r14
++
++ cmpq $41, %rax /* ')' */
++ je done
++ cmpq $68, %rax /* 'D' */
++ je double
++ cmpq $70, %rax /* 'F' */
++ je float
++ cmpq $74, %rax /* 'J' */
++ je long
++
++skip_brackets:
++ cmpq $91, %rax /* '[' */
++ jne check_ref
++ movzbq (%r14), %rax
++ incq %r14
++ jmp skip_brackets
++
++check_ref:
++ cmpq $76, %rax /* 'L' */
++ jne int
++
++skip_ref:
++ movzbq (%r14), %rax
++ incq %r14
++ cmpq $59, %rax /* ';' */
++ jne skip_ref
++
++int:
++ movq (%rbx), %rax
++ addq $8, %rbx
++
++check_regs:
++ incq %r10
++ cmpq $2, %r10
++ jg check_4
++
++ cmovneq %rax, %rdx
++ cmoveq %rax, %rcx
++ jmp next
++
++check_4:
++ cmpq $4, %r10
++ jg stack_push
++
++ cmovneq %rax, %r8
++ cmoveq %rax, %r9
++ jmp next
++
++stack_push:
++ movq %rax, (%r15)
++ addq $8, %r15
++ jmp next
++
++long:
++ movq (%rbx), %rax
++ addq $16, %rbx
++ jmp check_regs
++
++double:
++ addq $10, %r11
++ addq $10, %r12
++ addq $16, %rbx
++ jmp *%r11
++
++double_regs:
++ movsd -16(%rbx), %xmm0
++ jmp next
++ movsd -16(%rbx), %xmm1
++ jmp next
++ movsd -16(%rbx), %xmm2
++ jmp next
++ movsd -16(%rbx), %xmm3
++ jmp next
++ movsd -16(%rbx), %xmm4
++ jmp next
++ movsd -16(%rbx), %xmm5
++ jmp next
++ movsd -16(%rbx), %xmm6
++ jmp next
++ movsd -16(%rbx), %xmm7
++ jmp next
++ movq -16(%rbx), %rax
++ subq $10, %r11
++ subq $10, %r12
++ jmp stack_push
++
++float:
++ addq $10, %r11
++ addq $10, %r12
++ addq $8, %rbx
++ jmp *%r12
++
++float_regs:
++ movss -8(%rbx), %xmm0
++ jmp next
++ movss -8(%rbx), %xmm1
++ jmp next
++ movss -8(%rbx), %xmm2
++ jmp next
++ movss -8(%rbx), %xmm3
++ jmp next
++ movss -8(%rbx), %xmm4
++ jmp next
++ movss -8(%rbx), %xmm5
++ jmp next
++ movss -8(%rbx), %xmm6
++ jmp next
++ movss -8(%rbx), %xmm7
++ jmp next
++ movl -8(%rbx), %eax
++ subq $10, %r11
++ subq $10, %r12
++ jmp stack_push
++
++done:
++ /* Arguments all setup --
++ call the native method */
++
++ callq *-16(%rbp)
++
++ /* Get back ostack for return value */
++ movq -8(%rbp), %rcx
++
++ /* Handle return type */
++
++ movzbq (%r14), %rbx
++ cmpq $86, %rbx /* 'V' */
++ je return
++ cmpq $76, %rbx /* 'L' */
++ je int_ret
++ cmpq $91, %rbx /* '[' */
++ je int_ret
++ cmpq $73, %rbx /* 'I' */
++ je int_ret
++ cmpq $68, %rbx /* 'D' */
++ je double_ret
++ cmpq $70, %rbx /* 'F' */
++ je float_ret
++ cmpq $74, %rbx /* 'J' */
++ je long_ret
++ cmpq $67, %rbx /* 'C' */
++ je char_ret
++ cmpq $83, %rbx /* 'S' */
++ je short_ret
++
++ /* remaining types Z and B */
++ movsbq %al, %rax
++
++int_ret:
++ movq %rax, (%rcx)
++ addq $8, %rcx
++
++return:
++ movq -24(%rbp), %rbx
++ movq -32(%rbp), %r12
++ movq -40(%rbp), %r14
++ movq -48(%rbp), %r15
++
++ movq %rbp, %rsp
++ popq %rbp
++
++ movq %rcx, %rax
++ retq
++
++char_ret:
++ movzwq %ax, %rax
++ jmp int_ret
++
++short_ret:
++ movswq %ax, %rax
++ jmp int_ret
++
++long_ret:
++ movq %rax, (%rcx)
++ addq $16, %rcx
++ jmp return
++
++double_ret:
++ movsd %xmm0, (%rcx)
++ addq $16, %rcx
++ jmp return
++
++float_ret:
++ movss %xmm0, (%rcx)
++ addq $8, %rcx
++ jmp return
++#endif
+diff -Nru jamvm-2.0.0.orig/src/os/midipix/x86_64/dll_md.c jamvm-2.0.0/src/os/midipix/x86_64/dll_md.c
+--- jamvm-2.0.0.orig/src/os/midipix/x86_64/dll_md.c 1970-01-01 01:00:00.000000000 +0100
++++ jamvm-2.0.0/src/os/midipix/x86_64/dll_md.c 2012-05-17 23:01:47.000000000 +0200
+@@ -0,0 +1,57 @@
++/*
++ * Copyright (C) 2008, 2010 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.
++ */
++
++#include "jam.h"
++
++#ifndef USE_FFI
++#include <stdio.h>
++
++int nativeExtraArg(MethodBlock *mb) {
++ char *sig = mb->type;
++ int stack_space;
++ int iargs = 0;
++ int fargs = 0;
++
++ while(*++sig != ')')
++ switch(*sig) {
++ case 'D':
++ case 'F':
++ fargs++;
++ break;
++
++ default:
++ iargs++;
++
++ if(*sig == '[')
++ while(*++sig == '[');
++ if(*sig == 'L')
++ while(*++sig != ';');
++ break;
++ }
++
++ stack_space = ((iargs > 4 ? iargs - 4 : 0) +
++ (fargs > 8 ? fargs - 8 : 0)) << 3;
++
++ /* Ensure the stack remains 16 byte aligned. As
++ callJNIMethod pushes an even number of registers
++ the extra space must also be even. */
++ return (stack_space + 15) & ~15;
++}
++#endif
+diff -Nru jamvm-2.0.0.orig/src/os/midipix/x86_64/init.c jamvm-2.0.0/src/os/midipix/x86_64/init.c
+--- jamvm-2.0.0.orig/src/os/midipix/x86_64/init.c 1970-01-01 01:00:00.000000000 +0100
++++ jamvm-2.0.0/src/os/midipix/x86_64/init.c 2012-05-17 23:01:47.000000000 +0200
+@@ -0,0 +1,45 @@
++/*
++ * Copyright (C) 2003, 2004, 2005, 2006, 2007
++ * 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.
++ */
++
++#ifdef __linux__
++#include <fpu_control.h>
++#endif
++
++/* Change the x87 FPU precision to double (64-bit) from the extended
++ (80-bit) Linux default. Note, unlike on i386, my testcases pass
++ without this. This is probably because gcc assumes and uses SSE
++ by default, not the x87 FPU. However, keep it in to be safe.
++*/
++
++void setDoublePrecision() {
++#ifdef __linux__
++ fpu_control_t cw;
++
++ _FPU_GETCW(cw);
++ cw &= ~_FPU_EXTENDED;
++ cw |= _FPU_DOUBLE;
++ _FPU_SETCW(cw);
++#endif
++}
++
++void initialisePlatform() {
++ setDoublePrecision();
++}
+diff -Nru jamvm-2.0.0.orig/src/os/midipix/x86_64/Makefile.am jamvm-2.0.0/src/os/midipix/x86_64/Makefile.am
+--- jamvm-2.0.0.orig/src/os/midipix/x86_64/Makefile.am 1970-01-01 01:00:00.000000000 +0100
++++ jamvm-2.0.0/src/os/midipix/x86_64/Makefile.am 2012-05-17 23:01:47.000000000 +0200
+@@ -0,0 +1,26 @@
++##
++## Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2010
++## 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.
++##
++
++noinst_LTLIBRARIES = libnative.la
++libnative_la_SOURCES = init.c dll_md.c callNative.S
++
++AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src
++AM_CCASFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src
diff --git a/vars/build.vars b/vars/build.vars
index 90fc9a86..ab089b34 100644
--- a/vars/build.vars
+++ b/vars/build.vars
@@ -1055,7 +1055,7 @@ patch patchutils perl python2 python3 ruby smallbasic tcl";
#
# Packages list native_packages_etc
NATIVE_PACKAGES_ETC_PACKAGES="
-ca_certificates cron debianutils hexcurse htop infounzip infozip john less mc mintty nano ncdu
+ca_certificates cron debianutils hexcurse htop infounzip infozip jamvm classpath john less mc mintty nano ncdu
p7zip procps_ng qpdf rw rxvt_unicode st tmux vim xeyes xorriso xterm xwd";
: ${PKG_CA_CERTIFICATES_URLS_GIT:="ca-certificates=https://github.com/Redfoxmoon3/ca-certificates@master"};
: ${PKG_CA_CERTIFICATES_IN_TREE:=1};
@@ -1080,6 +1080,23 @@ p7zip procps_ng qpdf rw rxvt_unicode st tmux vim xeyes xorriso xterm xwd";
: ${PKG_INFOUNZIP_IN_TREE:=1};
: ${PKG_INFOZIP_URLS_GIT:=infozip=https://github.com/Redfoxmoon3/infozip.git@master};
: ${PKG_INFOZIP_IN_TREE:=1};
+: ${PKG_JAMVM_SHA256SUM:=76428e96df0ae9dd964c7a7c74c1e9a837e2f312c39e9a357fa8178f7eff80da};
+: ${PKG_JAMVM_VERSION:=2.0.0};
+: ${PKG_JAMVM_URL:=http://sourceforge.mirrorservice.org/j/ja/jamvm/jamvm/JamVM%20${PKG_JAMVM_VERSION}/jamvm-${PKG_JAMVM_VERSION}.tar.gz};
+: ${PKG_JAMVM_CONFIGURE_ARGS_EXTRA:="--enable-trace --with-classpath-install-dir= --enable-ffi"};
+: ${PKG_JAMVM_CFLAGS_CONFIGURE_EXTRA:=-I${PREFIX_NATIVE}/lib/libffi-3.2.1/include};
+if ! which ecj gcj javac >/dev/null 2>&1; then
+ : ${PKG_JAMVM_DISABLED:=1};
+fi;
+: ${PKG_JAMVM_IN_TREE:=1};
+: ${PKG_CLASSPATH_SHA256SUM:=f929297f8ae9b613a1a167e231566861893260651d913ad9b6c11933895fecc8};
+: ${PKG_CLASSPATH_VERSION:=0.99};
+: ${PKG_CLASSPATH_URL:=ftp://ftp.gnu.org/gnu/classpath/classpath-${PKG_CLASSPATH_VERSION}.tar.gz};
+: ${PKG_CLASSPATH_CONFIGURE_ARGS_EXTRA:="--disable-plugin --disable-gmp --disable-alsa --disable-gtk-peer --disable-gconf-peer"};
+if ! which ecj gcj javac >/dev/null 2>&1; then
+ : ${PKG_CLASSPATH_DISABLED:=1};
+fi;
+: ${PKG_CLASSPATH_ENV_VARS_EXTRA:="GMP_CFLAGS=-I${PREFIX_NATIVE}/include"};
: ${PKG_JOHN_SHA256SUM:=952cf68369fb5b27f2d112ce7ca1eb16b975c85cbce8c658abb8bc5a20e1b266};
: ${PKG_JOHN_VERSION:=1.8.0};
: ${PKG_JOHN_URL:=http://www.openwall.com/john/j/john-${PKG_JOHN_VERSION}.tar.xz};
diff --git a/vars/jamvm.vars b/vars/jamvm.vars
new file mode 100644
index 00000000..abfe4fcc
--- /dev/null
+++ b/vars/jamvm.vars
@@ -0,0 +1,9 @@
+#
+# set -o errexit -o noglob are assumed.
+#
+
+pkg_jamvm_configure_autotools_pre() {
+ autoreconf -iv;
+};
+
+# vim:filetype=sh