X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fcacaoh%2Fheaders.c;h=fca1676476e505fab38fa23b69029df726c055c3;hb=7eb9565b4da854fc6ced7220cb19040df0033573;hp=03f24011eaa7ba9002f2be7d84d1a5880c16df8a;hpb=0546330a4913c19450e41bf3732639952f148ff2;p=cacao.git

diff --git a/src/cacaoh/headers.c b/src/cacaoh/headers.c
index 03f24011e..fca167647 100644
--- a/src/cacaoh/headers.c
+++ b/src/cacaoh/headers.c
@@ -1,9 +1,9 @@
-/* headers.c - main for header generation (cacaoh)
+/* src/cacaoh/headers.c - functions for header generation
 
-   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
-   R. Grafl, A. Krall, C. Kruegel, C. Oates, R. Obermaisser,
-   M. Probst, S. Ring, E. Steiner, C. Thalinger, D. Thuernbeck,
-   P. Tomsich, J. Wenninger
+   Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+   C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
+   E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
+   J. Wenninger, Institut f. Computersprachen - TU Wien
 
    This file is part of CACAO.
 
@@ -19,186 +19,473 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA.
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA.
 
-   Contact: cacao@complang.tuwien.ac.at
+   Contact: cacao@cacaojvm.org
 
    Authors: Reinhard Grafl
 
    Changes: Mark Probst
             Philipp Tomsich
+            Christian Thalinger
 
-   $Id: headers.c 1053 2004-05-05 12:27:04Z stefan $
+   $Id: headers.c 4559 2006-03-05 23:24:50Z twisti $
 
 */
 
 
+#include <assert.h>
+#include <ctype.h>
+#include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
+
 #include "config.h"
-#include "global.h"
-#include "tables.h"
-#include "loader.h"
-#include "builtin.h"
+#include "vm/types.h"
+
+#if defined(USE_THREADS) && defined(NATIVE_THREADS)
+# if defined(__DARWIN__)
+#  include <signal.h>
+# endif
+# include <ucontext.h>
+#endif
+
 #include "mm/boehm.h"
+#include "mm/memory.h"
+#include "native/include/java_lang_String.h"
+#include "native/include/java_lang_Throwable.h"
 #include "toolbox/chain.h"
-#include "toolbox/memory.h"
-#include "toolbox/loging.h"
-#include "nat/java_lang_String.h"
+#include "toolbox/logging.h"
+#include "vm/builtin.h"
+#include "vm/class.h"
+#include "vm/global.h"
+#include "vm/method.h"
+#include "vm/loader.h"
+#include "vm/options.h"
+#include "vm/stringlocal.h"
+#include "vm/jit/asmpart.h"
 
 
-/* replace command line options */
+#if defined(ENABLE_INTRP)
+/* dummy interpreter stack to keep the compiler happy */
 
-bool verbose =  false;
-bool verboseexception =  false;
-bool compileall = false;
-bool runverbose = false;
-bool collectverbose = false;
+u1 intrp_main_stack[1];
+#endif
 
-bool loadverbose = false;
-bool linkverbose = false;
-bool initverbose = false;
 
-bool opt_rt = false;            /* true if RTA parse should be used     RT-CO */
-bool opt_xta = false;           /* true if XTA parse should be used    XTA-CO */
-bool opt_vta = false;           /* true if VTA parse should be used    VTA-CO */
-bool opt_verify = true;        /* true if classfiles should be verified      */
-bool opt_liberalutf = false;   /* Don't check overlong UTF-8 sequences       */
+/* for raising exceptions from native methods *********************************/
 
-bool showmethods = false;
-bool showconstantpool = false;
-bool showutf = false;
+#if !defined(USE_THREADS) || !defined(NATIVE_THREADS)
+java_objectheader *_no_threads_exceptionptr = NULL;
+#endif
 
-bool makeinitializations = true;
 
-bool getloadingtime = false;
-s8 loadingtime = 0;
+/* replace some non-vmcore functions ******************************************/
 
+functionptr native_findfunction(utf *cname, utf *mname, utf *desc,
+								bool isstatic)
+{
+	/* return something different than NULL, otherwise we get an exception */
 
-/******* replace some external functions  *********/
- 
-functionptr native_findfunction(utf *cname, utf *mname, utf *desc, bool isstatic)
-{ return NULL; }
+	return (functionptr) 1;
+}
+
+java_objectheader *native_new_and_init(classinfo *c) { return NULL; }
+java_objectheader *native_new_and_init_string(classinfo *c, java_lang_String *s) { return NULL; }
+java_objectheader *native_new_and_init_int(classinfo *c, s4 i) { return NULL; }
+java_objectheader *native_new_and_init_throwable(classinfo *c, java_lang_Throwable *t) { return NULL; }
 
-java_objectheader *javastring_new(utf *text)
-{ return NULL; }
 
-utf *javastring_toutf(java_lang_String *string, bool isclassname)
+java_objectheader *vm_call_method(methodinfo *m, java_objectheader *o, ...)
 { return NULL; }
 
 
-/* some exception stuff */
+/* code patching functions */
+void patcher_builtin_arraycheckcast(u1 *sp) {}
+
+#if defined(__MIPS__)
+long compare_and_swap(long *p, long oldval, long newval)
+{
+	if (*p == oldval) {
+		*p = newval;
+		return oldval;
+	} else
+		return *p;
+}
+#endif
+
+
+u1 *createcompilerstub(methodinfo *m) { return NULL; }
+#if defined(ENABLE_INTRP)
+u1 *intrp_createcompilerstub(methodinfo *m) { return NULL; }
+#endif
+
+u1 *codegen_createnativestub(functionptr f, methodinfo *m) { return NULL; }
 
-char *string_java_lang_ClassCircularityError =
-    "java/lang/ClassCircularityError";
+void removecompilerstub(u1 *stub) {}
+void removenativestub(u1 *stub) {}
 
-char *string_java_lang_ClassFormatError =
-    "java/lang/ClassFormatError";
+void asm_perform_threadswitch(u1 **from, u1 **to, u1 **stackTop) {}
+u1* asm_initialize_thread_stack(void *func, u1 *stack) { return NULL; }
 
-char *string_java_lang_IllegalMonitorStateException =
-    "java/lang/IllegalMonitorStateException";
+void *asm_switchstackandcall(void *stack, void *func, void **stacktopsave, void * p) { return NULL; }
 
-char *string_java_lang_LinkageError =
-    "java/lang/LinkageError";
+void asm_handle_builtin_exception(classinfo *c) {}
 
-char *string_java_lang_NegativeArraySizeException =
-    "java/lang/NegativeArraySizeException";
 
-char *string_java_lang_NoClassDefFoundError =
-    "java/lang/NoClassDefFoundError";
+#if defined(ENABLE_JIT)
+void asm_getclassvalues_atomic(vftbl_t *super, vftbl_t *sub, castinfo *out) {}
+#endif
+
+#if defined(ENABLE_INTRP)
+void intrp_asm_getclassvalues_atomic(vftbl_t *super, vftbl_t *sub, castinfo *out) {}
+#endif
 
-char *string_java_lang_OutOfMemoryError =
-    "java/lang/OutOfMemoryError";
 
+void *Java_java_lang_VMObject_clone(void *env, void *clazz, void * this)
+{
+	return NULL;
+}
 
-void throw_exception_exit() {}
-void new_exception(char *classname) {}
-void new_exception_message(char *classname, char *message) {}
-void new_exception_throwable(char *classname, java_objectheader *t) {}
-void new_exception_utfmessage(char *classname, utf *message)
+typecheck_result typeinfo_is_assignable_to_class(typeinfo *value,classref_or_classinfo dest)
 {
-	printf("%s: ", classname);
+	return typecheck_TRUE;
+}
+
+void typeinfo_init_classinfo(typeinfo *info,classinfo *c)
+{
+}
+
+bool typeinfo_init_class(typeinfo *info,classref_or_classinfo c)
+{
+	return true;
+}
+
+void typeinfo_print(FILE *file,typeinfo *info,int indent) {}
+
+void exceptions_print_exception(java_objectheader *xptr) {}
+void stacktrace_print_trace(java_objectheader *xptr) {}
+
+
+/* exception functions ********************************************************/
+
+/* these should not be called */
+
+void throw_main_exception_exit(void) { assert(0); }
+void throw_exception(void) { assert(0); }
+void throw_exception_exit(void) { assert(0); }
+
+java_objectheader *new_verifyerror(methodinfo *m, const char *message)
+{
+	assert(0);
+
+	/* keep compiler happy */
+
+	return NULL;
+}
+
+java_objectheader *new_exception_throwable(const char *classname, java_lang_Throwable *throwable)
+{
+	assert(0);
+
+	/* keep compiler happy */
+
+	return NULL;
+}
+
+
+void throw_cacao_exception_exit(const char *exception, const char *message, ...)
+{
+	va_list ap;
+
+	fprintf(stderr, "%s: ", exception);
+
+	va_start(ap, message);
+	vfprintf(stderr, message, ap);
+	va_end(ap);
+
+	fputc('\n', stderr);
+
+	exit(1);
+}
+
+
+void exceptions_throw_outofmemory_exit(void)
+{
+	fprintf(stderr, "java.lang.InternalError: Out of memory\n");
+	exit(1);
+}
+
+
+java_objectheader *new_exception(const char *classname)
+{
+	fprintf(stderr, "%s\n", classname);
+	exit(1);
+
+	/* keep compiler happy */
+
+	return NULL;
+}
+
+
+java_objectheader *new_exception_message(const char *classname, const char *message)
+{
+	fprintf(stderr, "%s: %s\n", classname, message);
+	exit(1);
+
+	/* keep compiler happy */
+
+	return NULL;
+}
+
+
+java_objectheader *new_exception_utfmessage(const char *classname, utf *message)
+{
+	fprintf(stderr, "%s: ", classname);
 	utf_display(message);
-	printf("\n");
+	fputc('\n', stderr);
+
 	exit(1);
+
+	/* keep compiler happy */
+
+	return NULL;
 }
 
-java_objectheader *literalstring_new(utf *u) { return NULL; }  
 
+java_objectheader *new_exception_javastring(const char *classname,
+											java_lang_String *message)
+{
+	fprintf(stderr, "%s: ", classname);
+	/* TODO print message */
+	fputc('\n', stderr);
 
-void literalstring_free(java_objectheader *o) { }
-void stringtable_update() { }
-void synchronize_caches() { }
-void asm_call_jit_compiler() { }
-void asm_calljavafunction() { }
-s4 asm_builtin_checkcast(java_objectheader *obj, classinfo *class) { return 0; }
+	exit(1);
 
-s4 asm_builtin_idiv(s4 a, s4 b) {return 0;}
-s4 asm_builtin_irem(s4 a, s4 b) {return 0;}
-s8 asm_builtin_ldiv(s8 a, s8 b) {return 0;}
-s8 asm_builtin_lrem(s8 a, s8 b) {return 0;}
+	/* keep compiler happy */
 
-s4 asm_builtin_f2i(float a) { return 0; }
-s8 asm_builtin_f2l(float a) { return 0; }
-s4 asm_builtin_d2i(double a) { return 0; }
-s8 asm_builtin_d2l(double a) { return 0; }
+	return NULL;
+}
 
-void asm_builtin_monitorenter(java_objectheader *o) {}
-void asm_builtin_monitorexit(java_objectheader *o) {}
 
-s4 asm_builtin_checkarraycast(java_objectheader *obj, vftbl *target) {return 0;}
+java_objectheader *new_classformaterror(classinfo *c, const char *message, ...)
+{
+	va_list ap;
 
+	utf_display(c->name);
+	fprintf(stderr, ": ");
 
-#if defined(__I386__)
-s4 asm_builtin_arrayinstanceof(java_objectheader *obj, classinfo *class) { return 0; }
-void asm_builtin_newarray(s4 size, vftbl *arrayvftbl) {}
-#endif
+	va_start(ap, message);
+	vfprintf(stderr, message, ap);
+	va_end(ap);
 
-void asm_builtin_aastore(java_objectarray *a, s4 index, java_objectheader *o) {}
+	fputc('\n', stderr);
 
-u1 *createcompilerstub(methodinfo *m) {return NULL;}
-u1 *createnativestub(functionptr f, methodinfo *m) {return NULL;}
-u1 *oldcreatenativestub(functionptr f, methodinfo *m) {return NULL;}
+	exit(1);
 
-void removecompilerstub(u1 *stub) {}
-void removenativestub(u1 *stub) {}
+	/* keep compiler happy */
 
-void asm_perform_threadswitch(u1 **from, u1 **to, u1 **stackTop) {}
-u1* asm_initialize_thread_stack(void *func, u1 *stack) { return NULL; }
-void thread_restartcriticalsection() {}
-void asm_switchstackandcall() {}
-void asm_handle_builtin_exception(classinfo *c) {}
+	return NULL;
+}
 
-java_objectheader *native_new_and_init(void *p) { return NULL; }
 
+void exceptions_throw_classformaterror(classinfo *c, const char *message, ...)
+{
+	va_list ap;
 
-/************************ global variables **********************/
+	va_start(ap, message);
+	(void) new_classformaterror(c, message, ap);
+	va_end(ap);
+}
+
+
+java_objectheader *new_classnotfoundexception(utf *name)
+{
+	fprintf(stderr, "java.lang.ClassNotFoundException: ");
+	utf_fprint(stderr, name);
+	fputc('\n', stderr);
+
+	exit(1);
+
+	/* keep compiler happy */
+
+	return NULL;
+}
+
+
+java_objectheader *new_noclassdeffounderror(utf *name)
+{
+	fprintf(stderr, "java.lang.NoClassDefFoundError: ");
+	utf_fprint(stderr, name);
+	fputc('\n', stderr);
+
+	exit(1);
+
+	/* keep compiler happy */
+
+	return NULL;
+}
+
+
+java_objectheader *exceptions_new_linkageerror(const char *message,
+											   classinfo *c)
+{
+	fprintf(stderr, "java.lang.LinkageError: %s",message);
+	if (c) {
+		utf_fprint_classname(stderr, c->name);
+	}
+	fputc('\n', stderr);
 
-THREADSPECIFIC java_objectheader *_exceptionptr;
+	exit(1);
+
+	/* keep compiler happy */
+
+	return NULL;
+}
+
+java_objectheader *exceptions_new_nosuchmethoderror(classinfo *c,
+													utf *name, utf *desc)
+{
+	fprintf(stderr, "java.lang.NoSuchMethodError: ");
+	utf_fprint(stderr, c->name);
+	fprintf(stderr, ".");
+	utf_fprint(stderr, name);
+	utf_fprint(stderr, desc);
+	fputc('\n', stderr);
+
+	exit(1);
+
+	/* keep compiler happy */
+
+	return NULL;
+}
+
+
+java_objectheader *new_internalerror(const char *message, ...)
+{
+	va_list ap;
+
+	fprintf(stderr, "%s: ", string_java_lang_InternalError);
+
+	va_start(ap, message);
+	vfprintf(stderr, message, ap);
+	va_end(ap);
+
+	exit(1);
+
+	/* keep compiler happy */
+
+	return NULL;
+}
 
-static chain *nativemethod_chain;    /* chain with native methods     */
-static chain *nativeclass_chain;		               /* chain with processed classes  */	
-static chain *ident_chain;        /* chain with method and field names in current class */
-static FILE *file = NULL;
+
+java_objectheader *new_unsupportedclassversionerror(classinfo *c, const char *message, ...)
+{
+	va_list ap;
+
+	fprintf(stderr, "%s: ", string_java_lang_UnsupportedClassVersionError);
+
+	utf_display(c->name);
+	fprintf(stderr, ": ");
+
+	va_start(ap, message);
+	vfprintf(stderr, message, ap);
+	va_end(ap);
+
+	exit(1);
+
+	/* keep compiler happy */
+
+	return NULL;
+}
+
+
+java_objectheader *new_illegalmonitorstateexception(void)
+{
+	fprintf(stderr, "%s", string_java_lang_IllegalMonitorStateException);
+	exit(1);
+
+	/* keep compiler happy */
+
+	return NULL;
+}
+
+
+java_objectheader *new_negativearraysizeexception(void)
+{
+	fprintf(stderr, "%s", string_java_lang_NegativeArraySizeException);
+	exit(1);
+
+	/* keep compiler happy */
+
+	return NULL;
+}
+
+
+void exceptions_throw_negativearraysizeexception(void)
+{
+	(void) new_negativearraysizeexception();
+}
+
+
+java_objectheader *new_nullpointerexception(void)
+{
+	fprintf(stderr, "%s", string_java_lang_NullPointerException);
+	exit(1);
+
+	/* keep compiler happy */
+
+	return NULL;
+}
+
+
+void exceptions_throw_nullpointerexception(void)
+{
+	(void) new_nullpointerexception();
+}
+
+
+void classnotfoundexception_to_noclassdeffounderror(void)
+{
+}
+
+/* machine dependent stuff ****************************************************/
+
+#if defined(USE_THREADS) && defined(NATIVE_THREADS)
+threadcritnode asm_criticalsections;
+void thread_restartcriticalsection(ucontext_t *uc) {}
+#endif
+
+void md_param_alloc(methoddesc *md) {}
+
+
+#if defined(ENABLE_INTRP)
+void print_dynamic_super_statistics(void) {}
+#endif
+
+
+/************************ global variables **********************/
+
+chain *ident_chain;     /* chain with method and field names in current class */
+FILE *file = NULL;
 static u4 outputsize;
 static bool dopadding;
 
 
-static void printIDpart(int c) 
+static void printIDpart(int c)
 {
-	if ((c >= 'a' && c <= 'z')
-		|| (c >= 'A' && c <= 'Z')
-		|| (c >= '0' && c <= '9')
-		|| (c == '_'))
+	if ((c >= 'a' && c <= 'z') ||
+		(c >= 'A' && c <= 'Z') ||
+		(c >= '0' && c <= '9') ||
+		(c == '_'))
 		putc(c, file);
 	else
 		putc('_', file);
 }
 
 
-static void printID(utf *u)
+void printID(utf *u)
 {
 	char *utf_ptr = u->text;
 	int i;
@@ -220,6 +507,43 @@ static void addoutputsize (int len)
 }
 
 
+void printOverloadPart(utf *desc)
+{
+	char *utf_ptr=desc->text;
+	u2 c;
+
+	fprintf(file, "__");
+
+	while ((c = utf_nextu2(&utf_ptr)) != ')') {
+		switch (c) {
+		case 'I':
+		case 'S':
+		case 'B':
+		case 'C':
+		case 'Z':
+		case 'J':
+		case 'F':
+		case 'D': 
+			fprintf(file, "%c", (char) c);
+			break;
+		case '[':
+			fprintf(file, "_3");
+			break;
+		case 'L':
+			putc('L', file);
+			while ((c = utf_nextu2(&utf_ptr)) != ';')
+				printIDpart(c);
+			fprintf(file, "_2");
+			break;
+		case '(':
+			break;
+		default: 
+			log_text("invalid method descriptor");
+			assert(0);
+		}
+	}
+}
+
 static char *printtype(char *utf_ptr)
 {
 	u2 c;
@@ -255,16 +579,18 @@ static char *printtype(char *utf_ptr)
 		case 'F':  fprintf (file, "java_floatarray*"); break;
 		case 'D':  fprintf (file, "java_doublearray*"); break;
 				
-		case '[':  fprintf (file, "java_objectarray*");					       
-			while ((c = utf_nextu2(&utf_ptr)) == '[') ;
-			if (c=='L') 
+		case '[': fprintf(file, "java_objectarray*");
+			while ((c = utf_nextu2(&utf_ptr)) == '[');
+			if (c == 'L')
 				while (utf_nextu2(&utf_ptr) != ';');
 			break;
                            
-		case 'L':  fprintf (file, "java_objectarray*");
-			while ( utf_nextu2(&utf_ptr) != ';');
+		case 'L':  fprintf(file, "java_objectarray*");
+			while (utf_nextu2(&utf_ptr) != ';');
 			break;
-		default: panic ("invalid type descriptor");
+		default:
+			log_text("invalid type descriptor");
+			assert(0);
 		}
 		break;
 		
@@ -275,7 +601,9 @@ static char *printtype(char *utf_ptr)
 		fprintf (file, "*");
 		break;
 					
-	default:  panic ("Unknown type in field descriptor");
+	default:
+		log_text("Unknown type in field descriptor");
+		assert(0);
 	}
 	
 	return utf_ptr;
@@ -312,7 +640,7 @@ static void printfields(classinfo *c)
 		return;
 	}
 		
-	printfields(c->super);
+	printfields(c->super.cls);
 	
 	for (i = 0; i < c->fieldscount; i++) {
 		f = &(c->fields[i]);
@@ -336,11 +664,10 @@ static void printfields(classinfo *c)
 
 /***************** store prototype for native method in file ******************/
 
-static void printmethod(methodinfo *m)
+void printmethod(methodinfo *m)
 {
 	char *utf_ptr;
 	u2 paramnum = 1;
-	u2 ident_count;
 
 	/* search for return-type in descriptor */	
 	utf_ptr = m->descriptor->text;
@@ -353,21 +680,26 @@ static void printmethod(methodinfo *m)
 	utf_fprint(file, m->name);
 	fprintf(file, "\n * Signature: ");
 	utf_fprint(file, m->descriptor);
-	fprintf(file, "\n */\n");	
+	fprintf(file, "\n */\n");
 
 	/* create prototype */ 			
-	fprintf(file, "JNIEXPORT ");				
+	fprintf(file, "JNIEXPORT ");
 	printtype(utf_ptr);
 	fprintf(file, " JNICALL Java_");
-	printID(m->class->name);           
+	printID(m->class->name);
 
-	/* rename overloaded method */
-	if ((ident_count = searchidentchain_utf(m->name)))
-		fprintf(file, "%d", ident_count - 1);		
-	chain_addlast(ident_chain, m->name);	
+	chain_addlast(ident_chain, m->name);
 
 	fprintf(file, "_");
 	printID(m->name);
+
+	/* ATTENTION: We use the methodinfo's isleafmethod variable as
+	   nativelyoverloaded, so we can save some space during
+	   runtime. */
+
+	if (m->isleafmethod)
+		printOverloadPart(m->descriptor);
+
 	fprintf(file, "(JNIEnv *env");
 	
 	utf_ptr = m->descriptor->text + 1;
@@ -395,13 +727,17 @@ static void printmethod(methodinfo *m)
 
 /******* remove package-name in fully-qualified classname *********************/
 
-static void gen_header_filename(char *buffer, utf *u)
+void gen_header_filename(char *buffer, utf *u)
 {
-	int i;
+	s4 i;
   
-	for (i = 0;i < utf_strlen(u); i++) {
-		if ((u->text[i] == '/') || (u->text[i] == '$')) buffer[i] = '_';  /* convert '$' and '/' to '_' */
-		else buffer[i] = u->text[i];
+	for (i = 0; i < utf_strlen(u); i++) {
+		if ((u->text[i] == '/') || (u->text[i] == '$')) {
+			buffer[i] = '_';  /* convert '$' and '/' to '_' */
+
+		} else {
+			buffer[i] = u->text[i];
+		}
 	}
 	buffer[utf_strlen(u)] = '\0';
 }
@@ -409,28 +745,41 @@ static void gen_header_filename(char *buffer, utf *u)
 
 /* create headerfile for classes and store native methods in chain ************/
 
-static void headerfile_generate(classinfo *c)
+void headerfile_generate(classinfo *c, char *opt_directory)
 {
 	char header_filename[1024] = "";
 	char classname[1024]; 
 	char uclassname[1024];
 	u2 i;
 	methodinfo *m;	      		
-		      
-	/* store class in chain */		      
-	chain_addlast(nativeclass_chain, c);
-			    	
+	u2 j;
+	methodinfo *m2;
+	bool nativelyoverloaded;
+
+	/* prevent compiler warnings */
+
+	nativelyoverloaded = false;
+
 	/* open headerfile for class */
 	gen_header_filename(classname, c->name);
 
 	/* create chain for renaming fields */
 	ident_chain = chain_new();
 	
-	sprintf(header_filename, "nat/%s.h", classname);
+	if (opt_directory) {
+		sprintf(header_filename, "%s/%s.h", opt_directory, classname);
+
+	} else {
+		sprintf(header_filename, "%s.h", classname);
+	}
+
    	file = fopen(header_filename, "w");
-   	if (!file) panic("Can not open file to store header information");
+   	if (!file) {
+		log_text("Can not open file to store header information");
+		assert(0);
+	}
 
-   	fprintf(file, "/* This file is machine generated, don't edit it !*/\n\n");
+   	fprintf(file, "/* This file is machine generated, don't edit it! */\n\n");
 
 	/* convert to uppercase */
 	for (i = 0; classname[i]; i++) {
@@ -462,14 +811,42 @@ static void headerfile_generate(classinfo *c)
 
 	/* create method-prototypes */
 		      		
+	/* find overloaded methods */
+
 	for (i = 0; i < c->methodscount; i++) {
+		m = &(c->methods[i]);
+
+		if (!(m->flags & ACC_NATIVE))
+			continue;
+
+		/* We use the methodinfo's isleafmethod variable as
+		   nativelyoverloaded, so we can save some space during
+		   runtime. */
+
+		if (!m->isleafmethod) {
+			nativelyoverloaded = false;
+
+			for (j = i + 1; j < c->methodscount; j++) {
+				m2 = &(c->methods[j]);
+
+				if (!(m2->flags & ACC_NATIVE))
+					continue;
+
+				if (m->name == m2->name) {
+					m2->isleafmethod = true;
+					nativelyoverloaded = true;
+				}
+			}
+		}
+
+		m->isleafmethod = nativelyoverloaded;
+	}
 
+	for (i = 0; i < c->methodscount; i++) {
 		m = &(c->methods[i]);
 
-		if (m->flags & ACC_NATIVE) {
-			chain_addlast(nativemethod_chain, m);
+		if (m->flags & ACC_NATIVE)
 			printmethod(m);
-		}
 	}
 
 	chain_free(ident_chain);
@@ -490,251 +867,14 @@ void print_classname(classinfo *clazz)
 	u2 c;
 
     while (utf_ptr < endpos) {
-		if ((c = utf_nextu2(&utf_ptr)) == '_') {
+		if ((c = utf_nextu2(&utf_ptr)) == '_')
 			putc('$', file);
-
-		} else {
+		else
 			putc(c, file);
-		}
 	}
 } 
 
 
-/*************** create table for locating native functions ****************/
-
-static void printnativetableentry(methodinfo *m)
-{
-	fprintf(file, "   { \"");
-	print_classname(m->class);
-	fprintf(file, "\",\n     \"");
-	utf_fprint(file, m->name);
-	fprintf(file, "\",\n     \"");
-	utf_fprint(file, m->descriptor);
-	fprintf(file, "\",\n     ");
-
-	if ((m->flags & ACC_STATIC) != 0)
-		fprintf(file, "true");
-	else
-		fprintf(file, "false");
-
-	fprintf(file, ",\n     ");
-	fprintf(file, "(functionptr) Java_");
-	printID(m->class->name);
-	fprintf(file,"_");
-	printID(m->name);
-	fprintf(file,"\n   },\n");
-}
-
-
-/***************************************************************************
-
-	create the nativetypes-headerfile which includes 
-	the headerfiles of the classes stored in the classes-chain 
-
-****************************************************************************/
-
-static void headers_finish()
-{
-	methodinfo *m;
-	classinfo *c;
-	char classname[1024];
-	
-	file = fopen("nativetypes.hh", "w");
-
-	if (!file)
-		panic("Can not open file 'native.h' to store header information");
-	
-	fprintf(file, "/* Headerfile for native methods: nativetypes.hh */\n");
-	fprintf(file, "/* This file is machine generated, don't edit it !*/\n\n"); 	
-	fprintf(file, "\n/* include native-Headerfiles */\n\n");
-			
-	c = chain_first(nativeclass_chain);
-	while (c) {
-		dopadding = false;
-		gen_header_filename(classname, c->name);										    													
-		fprintf(file, "#include \"nat/%s.h\"\n", classname);		
-		c = chain_next(nativeclass_chain);		
-	}
-
-    fclose(file);
-	chain_free(nativeclass_chain);
-	
-	/* create table of native-methods */
-
-	file = fopen("nativetable.hh", "w");
-
-	if (!file)
-		panic("Can not open file 'nativetable' to store native-link-table");
-
-	fprintf(file, "/* Table of native methods: nativetables.hh */\n");
-	fprintf(file, "/* This file is machine generated, don't edit it !*/\n\n"); 
-
-	while ((m = chain_first(nativemethod_chain)) != NULL) {
-		chain_remove(nativemethod_chain);		
-		printnativetableentry(m);
-	}
-		
-	chain_free(nativemethod_chain);
-	fclose(file);
-}
-
-
-/******************** internal function: print_usage ************************
-
-Prints usage information for the JAVA header generator to stdout.
-
-***************************************************************************/
-
-static void print_usage()
-{
-	printf("Usage: cacaoh class [class..]\n");
-}   
-
-
-
-/************************** Function: main *******************************
-
-   Main program.
-   
-**************************************************************************/
-
-int main(int argc, char **argv)
-{
-	s4 i,a;
-	char *cp;
-	classinfo *topclass;
-		
-
-	/********** internal (only used by main) *****************************/
-   
-	char classpath[500] = "";
-	char offsets_filename[1024] = ""; /* phil */
-	u4 heapmaxsize = 1000000;
-	u4 heapstartsize = 100000;
-
-	/*********** options so only headers are generated *******************/
-   
-	makeinitializations = false;
-   
-
-	/************ Collect some info from the environment *****************/
-
-	cp = getenv("CLASSPATH");
-	if (cp) {
-		strcpy(classpath + strlen(classpath), ":");
-		strcpy(classpath + strlen(classpath), cp);
-	}
-
-	if (argc < 2) {
-   		print_usage();
-   		exit(10);
-	}
-
-
-	/**************************** Program start **************************/
-
-	log_init(NULL);
-	log_text("Java - header-generator started"); 
-	
-	sprintf(offsets_filename, "jit/%s/offsets.h", ARCH_DIR);
-	file = fopen(offsets_filename, "w");
-	if (file == NULL) {
-		fprintf(stderr, "Can not open file '%s' for write", offsets_filename);
-		exit(-1);
-	}
-	
-	fprintf(file, "/* This file is machine generated, don't edit it !*/\n\n"); 
-
-	fprintf(file, "#define offobjvftbl    %3d\n", (int) OFFSET(java_objectheader, vftbl));
-	fprintf(file, "#define offarraysize   %3d\n", (int) OFFSET(java_arrayheader, size));
-	fprintf(file, "#define offobjarrdata  %3d\n\n", (int) OFFSET(java_objectarray, data[0]));
-	fprintf(file, "#define offbaseval     %3d\n", (int) OFFSET(vftbl, baseval));
-	fprintf(file, "#define offdiffval     %3d\n\n", (int) OFFSET(vftbl, diffval));
-
-	fprintf(file, "#define offclassvftbl  %3d\n", (int) OFFSET(classinfo, vftbl));
-	fprintf(file, "#define offclassinit   %3d\n", (int) OFFSET(classinfo, initialized));
-	fprintf(file, "#define offclassloaded %3d\n", (int) OFFSET(classinfo, loaded));
-	fprintf(file, "#define offclasslinked %3d\n\n", (int) OFFSET(classinfo, linked));
-
-	fprintf(file, "#define offjniitemtype %3d\n", (int) OFFSET(jni_callblock, itemtype));
-	fprintf(file, "#define offjniitem     %3d\n", (int) OFFSET(jni_callblock, item));
-	fprintf(file, "#define sizejniblock   %3d\n\n", (int) sizeof(jni_callblock));
-
-	fprintf(file, "#define offclassmethodinfo   %3d\n\n", (int) OFFSET(methodinfo,class));
-
-	fprintf(file, "#define offmethodnative %3d\n", (int) OFFSET(native_stackframeinfo,method));
-	fprintf(file, "#define offreturnfromnative %3d\n", (int) OFFSET(native_stackframeinfo,returnFromNative));
-	fprintf(file, "#define offaddrreturnfromnative %3d\n", (int) OFFSET(native_stackframeinfo,addrReturnFromNative));
-	fprintf(file, "#define offprevnative %3d\n", (int) OFFSET(native_stackframeinfo,prev));
-	fprintf(file, "#define offnextnative %3d\n", (int) OFFSET(native_stackframeinfo,next));
-	
-
-	fclose(file);
-
-	/* initialize the garbage collector */
-	gc_init(heapmaxsize, heapstartsize);
-
-	suck_init(classpath);
-   
-	tables_init();
-
-#if defined(USE_THREADS) && defined(NATIVE_THREADS)
-	initThreadsEarly();
-#endif
-	loader_init();
-
-
-	/*********************** Load JAVA classes  **************************/
-   	
-	nativemethod_chain = chain_new();
-	nativeclass_chain = chain_new();
-	
-	for (a = 1; a < argc; a++) {
-   		cp = argv[a];
-
-		/* convert classname */
-   		for (i = strlen(cp) - 1; i >= 0; i--) {
-			switch (cp[i]) {
-			case '.': cp[i]='/';
-				break;
-			case '_': cp[i]='$';    
-  	 		}
-		}
-	
-/*  		topclass = loader_load(utf_new_char(cp)); */
-		topclass = class_load(class_new(utf_new_char(cp)));
-		class_link(topclass);
-
-        headerfile_generate(topclass);
-	}
-
-	headers_finish();
-
-	/************************ Release all resources **********************/
-
-	loader_close();
-	tables_close(literalstring_free);
-
-	/* Print "finished" message */
-
-	log_text("Java - header-generator stopped");
-	log_cputime();
-	mem_usagelog(1);
-	
-	return 0;
-}
-
-
-void setVMClassField(classinfo *c)
-{
-}
-
-
-void *Java_java_lang_VMObject_clone(void *env, void *clazz, void * this) {
-	return 0;
-}
-
-
 /*
  * These are local overrides for various environment variables in Emacs.
  * Please do not remove this and leave it at the end of the file, where