Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

222 lines (161 sloc) 5.311 kB
Quick Start
-----------
on Linux:
$ export JAVA_HOME=/usr/local/java
$ make
$ build/linux-i386-compile-fast/avian -cp build/test Hello
on Mac OS X:
$ export JAVA_HOME=/Library/Java/Home
$ make
$ build/darwin-i386-compile-fast/avian -cp build/test Hello
Supported Platforms
-------------------
Avian can currently target the following platforms:
Linux (i386 and x86_64)
Win32 (i386)
Mac OS X (i386)
The Win32 port may be built on Linux using a MinGW cross compiler and
build environment. Builds on MSYS or Cygwin are not yet supported,
but patches to enable them are welcome.
Building
--------
The build is directed by a single makefile and may be influenced via
certain flags described below.
$ make platform={linux,windows,darwin} arch={i386,x86_64} \
process={compile,interpret} mode={debug,debug-fast,fast}
* platform - the target platform
default: output of $(uname -s | tr [:upper:] [:lower:])
* arch - the target architecture
default: output of $(uname -m)
* mode - which set of compilation flags to use, which determine
optimization level, debug symbols, and whether to enable
assertions.
default: fast
* process - choice between pure interpreter or JIT compiler
default: compile
Installing
----------
$ cp build/${platform}-${arch}-${process}-${mode}/avian ~/bin/
Embedding
---------
The following series of commands illustrates how to produce a
stand-alone executable out of a Java application using Avian.
Step 1: Build Avian, create a new directory, and populate it with the
VM object files and bootstrap classpath jar.
$ make
$ mkdir hello
$ cd hello
$ ar x ../build/${platform}-${arch}-${process}-${mode}/libavian.a
$ cp ../build/classpath.jar boot.jar
Step 2: Build the Java code and add it to the jar.
$ cat >Hello.java <<EOF
public class Hello {
public static void main(String[] args) {
System.out.println("hello, world!");
}
}
EOF
$ javac -bootclasspath boot.jar Hello.java
$ jar u0f boot.jar Hello.class
Step 3: Make an object file out of the jar.
for linux-i386:
$ objcopy -I binary boot.jar -O elf32-i386 -B i386 boot-jar.o
for linux-x86_64:
$ objcopy -I binary boot.jar -O elf64-x86-64 -B i386:x86-64 boot-jar.o
for windows-i386:
$ objcopy -I binary boot.jar -O pe-i386 -B i386 boot-jar.o
for darwin-i386: (objcopy is not currently supported on this platform,
so we use the binaryToMacho utility instead)
$ ../build/darwin-i386-compile-fast/binaryToMacho boot.jar \
__binary_boot_jar_start __binary_boot_jar_size > boot-jar.o
Step 4: Write a driver which starts the VM and runs the desired main
method. Note the bootJar function, which will be called by the VM to
get a handle to the embedded jar. We tell the VM about this jar by
setting the classpath to "[bootJar]".
$ cat >main.cpp <<EOF
#include "stdint.h"
#include "jni.h"
#ifdef __MINGW32__
# define EXPORT __declspec(dllexport)
# define SYMBOL(x) binary_boot_jar_##x
#else
# define EXPORT __attribute__ ((visibility("default")))
# define SYMBOL(x) _binary_boot_jar_##x
#endif
extern "C" {
extern const uint8_t SYMBOL(start)[];
extern const uint8_t SYMBOL(size)[];
EXPORT const uint8_t*
bootJar(unsigned* size)
{
*size = reinterpret_cast<uintptr_t>(SYMBOL(size));
return SYMBOL(start);
}
} // extern "C"
#ifdef JNI_VERSION_1_6
typedef struct JDK1_1InitArgs {
jint version;
char **properties;
jint checkSource;
jint nativeStackSize;
jint javaStackSize;
jint minHeapSize;
jint maxHeapSize;
jint verifyMode;
char *classpath;
jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
void (JNICALL *exit)(jint code);
void (JNICALL *abort)(void);
jint enableClassGC;
jint enableVerboseGC;
jint disableAsyncGC;
jint verbose;
jboolean debugging;
jint debugPort;
} JDK1_1InitArgs;
#endif
int
main(int ac, const char** av)
{
JDK1_1InitArgs vmArgs;
vmArgs.version = 0x00010001;
JNI_GetDefaultJavaVMInitArgs(&vmArgs);
vmArgs.classpath = const_cast<char*>("[bootJar]");
JavaVM* vm;
void* env;
JNI_CreateJavaVM(&vm, &env, &vmArgs);
JNIEnv* e = static_cast<JNIEnv*>(env);
jclass c = e->FindClass("Hello");
if (not e->ExceptionOccurred()) {
jmethodID m = e->GetStaticMethodID(c, "main", "([Ljava/lang/String;)V");
if (not e->ExceptionOccurred()) {
jclass stringClass = e->FindClass("java/lang/String");
if (not e->ExceptionOccurred()) {
jobjectArray a = e->NewObjectArray(ac-1, stringClass, 0);
if (not e->ExceptionOccurred()) {
for (int i = 1; i < ac; ++i) {
e->SetObjectArrayElement(a, i-1, e->NewStringUTF(av[i]));
}
e->CallStaticVoidMethod(c, m, a);
}
}
}
}
int exitCode = 0;
if (e->ExceptionOccurred()) {
exitCode = -1;
e->ExceptionDescribe();
}
vm->DestroyJavaVM();
return exitCode;
}
EOF
$ g++ -I$JAVA_HOME/include -c main.cpp -o main.o
Step 5: Link the objects produced above to produce the final
executable, and optionally strip its symbols.
on Linux:
$ g++ -rdynamic *.o -ldl -lpthread -lz -o hello
$ strip --strip-all hello
on Mac OS X:
$ g++ -rdynamic *.o -ldl -lpthread -lz -o hello -framework CoreFoundation
$ strip -S -x hello
Jump to Line
Something went wrong with that request. Please try again.