From 8f444b8c410f6b19e26f5d3fc54f16aa08343da4 Mon Sep 17 00:00:00 2001
From: Rhys Weatherley <rweather@southern-storm.com.au>
Date: Sun, 5 Sep 2004 09:50:57 +0000
Subject: [PATCH] Add a sample program that demonstrates a simple VM based on
 libjit (committed by Rhys).

---
 ChangeLog         |   5 +
 samples/hellovm.c | 242 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 247 insertions(+)
 create mode 100644 samples/hellovm.c

diff --git a/ChangeLog b/ChangeLog
index 3ee8162..7962c33 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,9 @@
 
+2004-09-05  Norbert Bollow  <nb@SoftwareEconomics.biz>
+
+	* samples/hellovm.c: add a sample program that demonstrates a
+	simple VM based on libjit (committed by Rhys).
+
 2004-08-30  Rhys Weatherley  <rweather@southern-storm.com.au>
 
 	* jit-rules-x86.sel: fix x86 code generation for floating-point
diff --git a/samples/hellovm.c b/samples/hellovm.c
new file mode 100644
index 0000000..d89d91a
--- /dev/null
+++ b/samples/hellovm.c
@@ -0,0 +1,242 @@
+/* hellovm.c - a kind of "hello world" for libjit
+ *
+ * Written by Norbert Bollow <nb@SoftwareEconomics.biz>
+ * 
+ * This program is a JIT for the "Hello VM" bytecode language, which
+ * has just one (string) register, and three opcodes: A) load string
+ * constant into register, B) output contents of register, C) exit program.
+ *
+ * Compile with: gcc hellovm.c -ljit -o hellovm
+ *
+ * A valid "Hello VM" bytecode language program, suitable as input file for
+ * this JIT, can be generated by the following perl script
+ *
+ * #!/usr/bin/perl
+ * open TEST, ">test";
+ * $bytecode="AHello World!\n\x00BC";
+ * print TEST "HelloVM\x00", pack('i',length($bytecode)), $bytecode;
+ *
+ * A slightly less trivial example can be generated e.g. with
+ * $bytecode="AHello, \x00BBAWorld!\n\x00BC";
+ *
+ * The contents of this file are in the Public Domain.
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <jit/jit.h>
+char* readbytes(int, int);
+static void hellovm_output(char *);
+static void hellovm_exit();
+static void out_of_memory();
+
+int main(int argc, char *argv[])
+{
+	int fd;
+	char *buf;
+	int len;
+	jit_context_t context;
+	const jit_type_t hellovm_output_arg_type=jit_type_void_ptr;
+	jit_type_t hellovm_signature_main;
+	jit_type_t hellovm_signature_exit, hellovm_signature_output;
+	jit_type_t hellovm_type_string;
+	jit_value_t hellovm_reg;
+	jit_value_t tmp;
+	char *str;
+	jit_function_t hellovm_main;
+	int pos;
+	int willexit=0;
+	int retval;
+
+	if(argc != 2)
+	{
+		printf("Usage: hellovm program\n");
+		return 99;
+	}
+
+	if((fd = open(argv[1], O_RDONLY)) < 0)
+	{
+		perror(argv[1]);
+		return 99;
+	}
+
+	/* read filetype identification string and length field */
+	buf=readbytes(fd, 12);
+
+	/* check filetype identification string */
+	if(jit_strcmp("HelloVM", buf)!=0)
+	{
+		fprintf(stderr, "%s is not in HelloVM format.\n", argv[1]);
+		return 99;
+	}
+
+	/* check length field and read bytecode data */
+	len=*((int*) (buf+8));
+	if(len<0)
+	{
+		fprintf(stderr, "%s: Invalid length field.\n", argv[1]);
+		return 99;
+	}
+	free(buf);
+	buf=readbytes(fd, len);
+	close(fd);
+
+	/* Now the fun begins :) */
+	jit_init();
+	context = jit_context_create();
+	jit_context_build_start(context);
+	/* Build signatures for output and exit functions */
+	hellovm_signature_output = jit_type_create_signature
+		(jit_abi_cdecl, jit_type_void, 
+		 (jit_type_t*)&hellovm_output_arg_type, 1, 0);
+	if (!hellovm_signature_output) out_of_memory();
+	hellovm_signature_exit = jit_type_create_signature
+		(jit_abi_cdecl, jit_type_void, NULL, 0, 0);
+	if (!hellovm_signature_exit) out_of_memory();
+	/* There is always a single function with signature: int main() */
+	hellovm_signature_main = jit_type_create_signature
+		(jit_abi_cdecl, jit_type_int, NULL, 0, 0);
+	if (!hellovm_signature_main) out_of_memory();
+        hellovm_main = jit_function_create(context, hellovm_signature_main);
+	if (!hellovm_main) out_of_memory();
+	/* The HelloVM has a single register holding a NUL-terminated string */
+	hellovm_type_string = jit_type_create_pointer(jit_type_sys_char, 1);
+	if (!hellovm_type_string) out_of_memory();
+	hellovm_reg = jit_value_create(hellovm_main, hellovm_type_string);
+	if (!hellovm_reg) out_of_memory();
+	/* Initialize the string register with "" */
+	tmp=jit_value_create_nint_constant
+		(hellovm_main, hellovm_type_string, (int)"");
+	if (!tmp) out_of_memory();
+	jit_insn_store(hellovm_main, hellovm_reg, tmp);
+	/* Now JIT the supplied bytecodes */
+	pos=0;
+	while(pos<len)
+	{
+		switch(buf[pos])
+		{
+			case 'A':
+			{
+				/* load string constant into hellovm_reg */
+				pos++;
+				str=jit_strndup(buf+pos, len-pos);
+				if (!str && buf[pos] && len-pos)
+					out_of_memory();
+				tmp=jit_value_create_nint_constant
+				      (hellovm_main, hellovm_type_string,
+				       (int)str);
+				if (!tmp) out_of_memory();
+				jit_insn_store(hellovm_main, hellovm_reg, tmp);
+				pos+=jit_strlen(str)+1;
+			}
+			break;
+			case 'B':
+			{
+				/* output contents of hellovm_reg */
+				pos++;
+				jit_insn_call_native
+					(hellovm_main, "hellovm_output",
+					 (void *)hellovm_output, 
+					 hellovm_signature_output,
+					 &hellovm_reg, 1,
+					 JIT_CALL_NOTHROW);
+			}
+			break;
+			case 'C':
+			{
+				/* exit with exit value 0 */
+				pos++;
+				jit_insn_call_native
+					(hellovm_main, "hellovm_exit",
+					 (void *)hellovm_exit, 
+					 hellovm_signature_exit,
+					 NULL, 0,
+					 JIT_CALL_NOTHROW|JIT_CALL_NORETURN);
+				willexit=1;
+			}
+			break;
+			default:
+			{
+				fprintf(stderr, "Error: Illegal opcode\n");
+				return 99;
+			}
+		}
+	}
+	if(willexit)
+	{
+		if (!jit_function_compile(hellovm_main))
+		{
+			fprintf(stderr, "JIT compilation error\n");
+			return 99;
+		}
+		jit_context_build_end(context);
+		free(buf);
+		if (!jit_function_apply(hellovm_main, NULL, &retval))
+		{
+			fprintf(stderr, "Exception during execution\n");
+			return 99;
+		}
+		/* not reached with the current instruction set */
+		return retval;
+	}
+	else
+	{
+		jit_function_abandon(hellovm_main);
+		fprintf(stderr, "Error: program without exit opcode\n");
+		return 99;
+	}
+}
+
+static void hellovm_output(char *value)
+{
+	fputs(value, stdout);
+}
+
+static void hellovm_nulput(char *value)
+{
+	putchar(0);
+}
+
+static void hellovm_exit()
+{
+	exit(0);
+}
+
+static void out_of_memory()
+{
+	fprintf(stderr, "Out of memory.\n");
+	exit(99);	
+}
+
+/* This function will not return unless the specified number of bytes
+ * has been read successfully */
+char* readbytes(int file, int bytestoread)
+{
+	char *buffer;
+	int pos=0;
+	int bytesread;
+
+	if((buffer = jit_malloc(bytestoread)) == NULL)
+	{
+		perror("memory allocation error in readbytes()");
+		exit(99);
+	}
+
+	while (pos<bytestoread)
+	{
+		bytesread=read(file, buffer+pos, bytestoread-pos);
+		if(bytesread==-1)
+		{
+			perror("read error in readbytes()");
+			exit(99);
+		}
+		if(bytesread==0)
+		{
+			fprintf(stderr, "unexpected eof in readbytes()\n");
+			exit(99);
+		}
+		pos+=bytesread;
+	}
+	return buffer;
+}
-- 
2.47.3