projects / cacao.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fixed ICMD_FCMPx
[cacao.git] / main.c
diff --git a/main.c b/main.c
index 40673045c156eb87b8ff2ba5d73d2ae71b744245..a2708f6666328016095fd7d1b116cb8c846fdab2 100644 (file)
--- a/main.c
+++ b/main.c
@@ -1,51 +1,60 @@
-/* -*- mode: c; tab-width: 4; c-basic-offset: 4 -*- */
-/******************************* main.c ****************************************
+/* main.c **********************************************************************
 
        Copyright (c) 1997 A. Krall, R. Grafl, M. Gschwind, M. Probst
 
        See file COPYRIGHT for information on usage and disclaimer of warranties
 
 
        Copyright (c) 1997 A. Krall, R. Grafl, M. Gschwind, M. Probst
 
        See file COPYRIGHT for information on usage and disclaimer of warranties
 
-       Enthaelt die Funktion main() und die Variablen fuer die 
-       globalen Optionen.
-       Dieser Modul erledigt folgende Aufgaben:
-          - Bearbeiten der command-line-options
-          - Aufrufen aller Initialisierungsroutinen
-          - Aufrufen des Classloaders
-          - Starten der main - Methode
+       Contains main() and variables for the global options.
+       This module does the following tasks:
+          - Command line option handling
+          - Calling initialization routines
+          - Calling the class loader
+          - Running the main method
 
        Authors: Reinhard Grafl      EMAIL: cacao@complang.tuwien.ac.at
        Changes: Andi Krall          EMAIL: cacao@complang.tuwien.ac.at
                 Mark Probst         EMAIL: cacao@complang.tuwien.ac.at
 
        Authors: Reinhard Grafl      EMAIL: cacao@complang.tuwien.ac.at
        Changes: Andi Krall          EMAIL: cacao@complang.tuwien.ac.at
                 Mark Probst         EMAIL: cacao@complang.tuwien.ac.at
+                        Philipp Tomsich     EMAIL: cacao@complang.tuwien.ac.at
 
 
-       Last Change: 1997/10/29
+       Last Change: $Id: main.c 200 2003-01-21 12:37:13Z stefan $
 
 *******************************************************************************/
 
 #include "global.h"
 
 #include "tables.h"
 
 *******************************************************************************/
 
 #include "global.h"
 
 #include "tables.h"
-#include "compiler.h"
-#include "ncomp/ncomp.h"
 #include "loader.h"
 #include "loader.h"
+#include "jit.h"
+#ifdef OLD_COMPILER
+#include "compiler.h"
+#endif
 
 #include "asmpart.h"
 #include "builtin.h"
 #include "native.h"
 
 
 #include "asmpart.h"
 #include "builtin.h"
 #include "native.h"
 
-#include "threads/thread.h"            /* schani */
+#include "threads/thread.h"
 
 bool compileall = false;
 int  newcompiler = true;               
 bool verbose =  false;
 
 bool compileall = false;
 int  newcompiler = true;               
 bool verbose =  false;
+#ifdef NEW_GC
+bool new_gc = false;
+#endif
+
+static bool showmethods = false;
+static bool showconstantpool = false;
+static bool showutf = false;
+static classinfo *topclass;
 
 #ifndef USE_THREADS
 void **stackbottom = 0;
 #endif
 
 
 
 #ifndef USE_THREADS
 void **stackbottom = 0;
 #endif
 
 
-/********************* interne Funktion: get_opt *****************************
+/* internal function: get_opt *************************************************
        
        
-       liest die n"achste Option aus der Kommandozeile
+       decodes the next command line option
        
 ******************************************************************************/
 
        
 ******************************************************************************/
 
@@ -54,52 +63,66 @@ void **stackbottom = 0;
 #define OPT_IGNORE 1
 
 #define OPT_CLASSPATH   2
 #define OPT_IGNORE 1
 
 #define OPT_CLASSPATH   2
-#define OPT_D           3  
-#define OPT_MS          4  
-#define OPT_MX          5  
-#define OPT_VERBOSE1    6  
-#define OPT_VERBOSE     7  
-#define OPT_VERBOSEGC   8         
-#define OPT_VERBOSECALL 9          
+#define OPT_D           3
+#define OPT_MS          4
+#define OPT_MX          5
+#define OPT_VERBOSE1    6
+#define OPT_VERBOSE     7
+#define OPT_VERBOSEGC   8
+#define OPT_VERBOSECALL 9
 #define OPT_IEEE        10
 #define OPT_SOFTNULL    11
 #define OPT_TIME        12
 #define OPT_STAT        13
 #define OPT_IEEE        10
 #define OPT_SOFTNULL    11
 #define OPT_TIME        12
 #define OPT_STAT        13
-#define OPT_LOG         14  
+#define OPT_LOG         14
 #define OPT_CHECK       15
 #define OPT_CHECK       15
-#define OPT_LOAD        16  
-#define OPT_METHOD      17  
-#define OPT_SIGNATURE   18  
-#define OPT_SHOW        19 
-#define OPT_ALL         20 
-#define OPT_OLD         21 
-
-struct { char *name; bool arg; int value; } opts[] = {
-  { "classpath",   true,   OPT_CLASSPATH },
-  { "D",           true,   OPT_D },
-  { "ms",          true,   OPT_MS },
-  { "mx",          true,   OPT_MX },
-  { "noasyncgc",   false,  OPT_IGNORE },  
-  { "noverify",    false,  OPT_IGNORE },  
-  { "oss",         true,   OPT_IGNORE },  
-  { "ss",          true,   OPT_IGNORE },  
-  { "v",           false,  OPT_VERBOSE1 },
-  { "verbose",     false,  OPT_VERBOSE },
-  { "verbosegc",   false,  OPT_VERBOSEGC },
-  { "verbosecall", false,  OPT_VERBOSECALL },
-  { "ieee",        false,  OPT_IEEE },
-  { "softnull",    false,  OPT_SOFTNULL },
-  { "time",        false,  OPT_TIME },
-  { "stat",        false,  OPT_STAT },
-  { "log",         true,   OPT_LOG },
-  { "c",           true,   OPT_CHECK },
-  { "l",           false,  OPT_LOAD },
-  { "m",           true,   OPT_METHOD },
-  { "sig",         true,   OPT_SIGNATURE },
-  { "s",           true,   OPT_SHOW },          
-  { "all",         false,  OPT_ALL },          
-  { "old",         false,  OPT_OLD },          
-  { NULL,  false, 0 }
+#define OPT_LOAD        16
+#define OPT_METHOD      17
+#define OPT_SIGNATURE   18
+#define OPT_SHOW        19
+#define OPT_ALL         20
+#ifdef OLD_COMPILER
+#define OPT_OLD         21
+#endif
+#ifdef NEW_GC
+#define OPT_GC1         22
+#define OPT_GC2         23
+#endif
+#define OPT_OLOOP       24
+
+struct {char *name; bool arg; int value;} opts[] = {
+       {"classpath",   true,   OPT_CLASSPATH},
+       {"D",           true,   OPT_D},
+       {"ms",          true,   OPT_MS},
+       {"mx",          true,   OPT_MX},
+       {"noasyncgc",   false,  OPT_IGNORE},
+       {"noverify",    false,  OPT_IGNORE},
+       {"oss",         true,   OPT_IGNORE},
+       {"ss",          true,   OPT_IGNORE},
+       {"v",           false,  OPT_VERBOSE1},
+       {"verbose",     false,  OPT_VERBOSE},
+       {"verbosegc",   false,  OPT_VERBOSEGC},
+       {"verbosecall", false,  OPT_VERBOSECALL},
+       {"ieee",        false,  OPT_IEEE},
+       {"softnull",    false,  OPT_SOFTNULL},
+       {"time",        false,  OPT_TIME},
+       {"stat",        false,  OPT_STAT},
+       {"log",         true,   OPT_LOG},
+       {"c",           true,   OPT_CHECK},
+       {"l",           false,  OPT_LOAD},
+       {"m",           true,   OPT_METHOD},
+       {"sig",         true,   OPT_SIGNATURE},
+       {"s",           true,   OPT_SHOW},
+       {"all",         false,  OPT_ALL},
+#ifdef OLD_COMPILER
+       {"old",         false,  OPT_OLD},
+#endif
+#ifdef NEW_GC
+       {"gc1",         false,  OPT_GC1},
+       {"gc2",         false,  OPT_GC2},
+#endif
+       {"oloop",       false,  OPT_OLOOP},
+       {NULL,  false, 0}
 };
 
 static int opt_ind = 1;
 };
 
 static int opt_ind = 1;
@@ -120,8 +143,8 @@ static int get_opt (int argc, char **argv)
                        if (strcmp(a+1, opts[i].name) == 0) {  /* boolean option found */
                                opt_ind++;
                                return opts[i].value;
                        if (strcmp(a+1, opts[i].name) == 0) {  /* boolean option found */
                                opt_ind++;
                                return opts[i].value;
-                               }
                        }
                        }
+               }
                else {
                        if (strcmp(a+1, opts[i].name) == 0) { /* parameter option found */
                                opt_ind++;
                else {
                        if (strcmp(a+1, opts[i].name) == 0) { /* parameter option found */
                                opt_ind++;
@@ -129,9 +152,9 @@ static int get_opt (int argc, char **argv)
                                        opt_arg = argv[opt_ind];
                                        opt_ind++;
                                        return opts[i].value;
                                        opt_arg = argv[opt_ind];
                                        opt_ind++;
                                        return opts[i].value;
-                                       }
-                               return OPT_ERROR;
                                }
                                }
+                               return OPT_ERROR;
+                       }
                        else {
                                size_t l = strlen(opts[i].name);
                                if (strlen(a+1) > l) {
                        else {
                                size_t l = strlen(opts[i].name);
                                if (strlen(a+1) > l) {
@@ -139,11 +162,11 @@ static int get_opt (int argc, char **argv)
                                                opt_ind++;
                                                opt_arg = a+1+l;
                                                return opts[i].value;
                                                opt_ind++;
                                                opt_arg = a+1+l;
                                                return opts[i].value;
-                                               }
                                        }
                                }
                        }
                                        }
                                }
                        }
-               } /* end for */ 
+               }
+       } /* end for */ 
 
        return OPT_ERROR;
 }
 
        return OPT_ERROR;
 }
@@ -151,9 +174,9 @@ static int get_opt (int argc, char **argv)
 
 
 
 
 
 
-/******************** interne Funktion: print_usage ************************
+/******************** interne Function: print_usage ************************
 
 
-Gibt die richtige Aufrufsyntax des JavaVM-Compilers auf stdout aus.
+Prints the correct usage syntax to stdout.
 
 ***************************************************************************/
 
 
 ***************************************************************************/
 
@@ -174,27 +197,36 @@ static void print_usage()
        printf ("          -time ................ measure the runtime\n");
        printf ("          -stat ................ detailed compiler statistics\n");
        printf ("          -log logfile ......... specify a name for the logfile\n");
        printf ("          -time ................ measure the runtime\n");
        printf ("          -stat ................ detailed compiler statistics\n");
        printf ("          -log logfile ......... specify a name for the logfile\n");
-       printf ("          -c(heck) b(ounds...... don't check array bounds\n");
-       printf ("                   s(ync) ...... don't check for synchronization\n");
+       printf ("          -c(heck)b(ounds) ..... don't check array bounds\n");
+       printf ("                  s(ync) ....... don't check for synchronization\n");
+       printf ("          -oloop ............... optimize array accesses in loops\n"); 
        printf ("          -l ................... don't start the class after loading\n");
        printf ("          -all ................. compile all methods, no execution\n");
        printf ("          -l ................... don't start the class after loading\n");
        printf ("          -all ................. compile all methods, no execution\n");
+#ifdef OLD_COMPILER
        printf ("          -old ................. use old JIT compiler\n");
        printf ("          -old ................. use old JIT compiler\n");
+#endif
+#ifdef NEW_GC
+       printf ("          -gc1 ................. use the old garbage collector (default)\n");
+       printf ("          -gc2 ................. use the new garbage collector\n");
+#endif
        printf ("          -m ................... compile only a specific method\n");
        printf ("          -sig ................. specify signature for a specific method\n");
        printf ("          -m ................... compile only a specific method\n");
        printf ("          -sig ................. specify signature for a specific method\n");
-       printf ("          -s(how)m(ethods) ..... show all methods&fields of a class\n");
+       printf ("          -s(how)a(ssembler) ... show disassembled listing\n");
        printf ("                 c(onstants) ... show the constant pool\n");
        printf ("                 c(onstants) ... show the constant pool\n");
-       printf ("                 a(ssembler) ... show disassembled listing\n");
        printf ("                 d(atasegment).. show data segment listing\n");
        printf ("                 d(atasegment).. show data segment listing\n");
-       printf ("                 s(tack) ....... show stack for every javaVM-command\n");
        printf ("                 i(ntermediate). show intermediate representation\n");
        printf ("                 i(ntermediate). show intermediate representation\n");
-       printf ("                 u(nicode) ..... show the unicode - hash\n");
+       printf ("                 m(ethods)...... show class fields and methods\n");
+#ifdef OLD_COMPILER
+       printf ("                 s(tack) ....... show stack for every javaVM-command\n");
+#endif
+       printf ("                 u(tf) ......... show the utf - hash\n");
 }   
 
 
 
 }   
 
 
 
-/***************************** Funktion: print_times *********************
+/***************************** Function: print_times *********************
 
 
-       gibt eine Aufstellung der verwendeten CPU-Zeit aus
+       Prints a summary of CPU time usage.
 
 **************************************************************************/
 
 
 **************************************************************************/
 
@@ -222,7 +254,7 @@ static void print_times()
 
 
 
 
 
 
-/***************************** Funktion: print_stats *********************
+/***************************** Function: print_stats *********************
 
        outputs detailed compiler statistics
 
 
        outputs detailed compiler statistics
 
@@ -348,7 +380,7 @@ static void print_stats()
        sprintf (logtext, "Distribution of basic block sizes");
        dolog();
        sprintf (logtext,
        sprintf (logtext, "Distribution of basic block sizes");
        dolog();
        sprintf (logtext,
-       "  1    2    3    4   5   6   7   8   9  10 <13 <15 <17 <19 <21 <26 <31 >30");
+       "  0    1    2    3    4   5   6   7   8   9 <13 <15 <17 <19 <21 <26 <31 >30");
        dolog();
        sprintf (logtext, "%3d%5d%5d%5d%4d%4d%4d%4d%4d%4d%4d%4d%4d%4d%4d%4d%4d%4d",
                count_block_size_distribution[0], count_block_size_distribution[1], count_block_size_distribution[2],
        dolog();
        sprintf (logtext, "%3d%5d%5d%5d%4d%4d%4d%4d%4d%4d%4d%4d%4d%4d%4d%4d%4d%4d",
                count_block_size_distribution[0], count_block_size_distribution[1], count_block_size_distribution[2],
@@ -364,7 +396,7 @@ static void print_stats()
        dolog();
        sprintf (logtext, "Size of Class Infos (Kb):%10.3f", (float) (count_class_infos) / 1024);
        dolog();
        dolog();
        sprintf (logtext, "Size of Class Infos (Kb):%10.3f", (float) (count_class_infos) / 1024);
        dolog();
-       sprintf (logtext, "Size of Const Pool (Kb): %10.3f", (float) (count_const_pool_len + count_unicode_len) / 1024);
+       sprintf (logtext, "Size of Const Pool (Kb): %10.3f", (float) (count_const_pool_len + count_utf_len) / 1024);
        dolog();
        sprintf (logtext, "Size of Vftbl (Kb):      %10.3f", (float) count_vftbl_len / 1024);
        dolog();
        dolog();
        sprintf (logtext, "Size of Vftbl (Kb):      %10.3f", (float) count_vftbl_len / 1024);
        dolog();
@@ -372,19 +404,28 @@ static void print_stats()
        dolog();
        sprintf (logtext, "Size of native stub (Kb):%10.3f", (float) count_nstub_len / 1024);
        dolog();
        dolog();
        sprintf (logtext, "Size of native stub (Kb):%10.3f", (float) count_nstub_len / 1024);
        dolog();
-       sprintf (logtext, "Size of Unicode (Kb):    %10.3f", (float) count_unicode_len / 1024);
+       sprintf (logtext, "Size of Utf (Kb):        %10.3f", (float) count_utf_len / 1024);
        dolog();
        sprintf (logtext, "Size of VMCode (Kb):     %10.3f(%d)", (float) count_vmcode_len / 1024,
                                                      count_vmcode_len - 18 * count_all_methods);
        dolog();
        sprintf (logtext, "Size of ExTable (Kb):    %10.3f", (float) count_extable_len / 1024);
        dolog();
        dolog();
        sprintf (logtext, "Size of VMCode (Kb):     %10.3f(%d)", (float) count_vmcode_len / 1024,
                                                      count_vmcode_len - 18 * count_all_methods);
        dolog();
        sprintf (logtext, "Size of ExTable (Kb):    %10.3f", (float) count_extable_len / 1024);
        dolog();
+       sprintf (logtext, "Number of class loads:   %d", count_class_loads);
+       dolog();
+       sprintf (logtext, "Number of class inits:   %d", count_class_inits);
+       dolog();
        sprintf (logtext, "Number of loaded Methods: %d\n\n", count_all_methods);
        dolog();
        sprintf (logtext, "Number of loaded Methods: %d\n\n", count_all_methods);
        dolog();
+
+       sprintf (logtext, "Calls of utf_new: %22d", count_utf_new);
+       dolog();
+       sprintf (logtext, "Calls of utf_new (element found): %6d\n\n", count_utf_new_found);
+       dolog();
 }
 
 
 }
 
 
-/********** Funktion: class_compile_methods   (nur f"ur Debug-Zwecke) ********/
+/********** Function: class_compile_methods   (debugging only) ********/
 
 void class_compile_methods ()
 {
 
 void class_compile_methods ()
 {
@@ -397,42 +438,81 @@ void class_compile_methods ()
                for (i = 0; i < c -> methodscount; i++) {
                        m = &(c->methods[i]);
                        if (m->jcode) {
                for (i = 0; i < c -> methodscount; i++) {
                        m = &(c->methods[i]);
                        if (m->jcode) {
+#ifdef OLD_COMPILER
                                if (newcompiler)
                                if (newcompiler)
-                                       (void) new_compile(m);
+#endif
+                                       (void) jit_compile(m);
+#ifdef OLD_COMPILER
                                else
                                        (void) compiler_compile(m);
                                else
                                        (void) compiler_compile(m);
+#endif
                                }
                        }
                c = list_next (&linkedclasses, c);
                }
 }
 
                                }
                        }
                c = list_next (&linkedclasses, c);
                }
 }
 
+/*
+ * void exit_handler(void)
+ * -----------------------
+ * The exit_handler function is called upon program termination to shutdown
+ * the various subsystems and release the resources allocated to the VM.
+ */
 
 
-/************************** Funktion: main *******************************
+void exit_handler(void)
+{
+       /********************* Print debug tables ************************/
+                               
+       if (showmethods) class_showmethods (topclass);
+       if (showconstantpool)  class_showconstantpool (topclass);
+       if (showutf)           utf_show ();
+
+#ifdef USE_THREADS
+       clear_thread_flags();           /* restores standard file descriptor
+                                                                  flags */
+#endif
+
+       /************************ Free all resources *******************/
+
+       heap_close ();                          /* must be called before compiler_close and
+                                                                  loader_close because finalization occurs
+                                                                  here */
+
+#ifdef OLD_COMPILER
+       compiler_close ();
+#endif
+       loader_close ();
+       tables_close ( literalstring_free );
+
+       if (verbose || getcompilingtime || statistics) {
+               log_text ("CACAO terminated");
+               if (statistics)
+                       print_stats ();
+               if (getcompilingtime)
+                       print_times ();
+               mem_usagelog(1);
+       }
+}
 
 
-   Das Hauptprogramm.
-   Wird vom System zu Programstart aufgerufen (eh klar).
+/************************** Function: main *******************************
+
+   The main program.
    
 **************************************************************************/
 
    
 **************************************************************************/
 
-
 int main(int argc, char **argv)
 {
        s4 i,j;
        char *cp;
 int main(int argc, char **argv)
 {
        s4 i,j;
        char *cp;
-       classinfo *topclass;
-       java_objectheader *exceptionptr;
+       java_objectheader *local_exceptionptr = 0;
        void *dummy;
        
        void *dummy;
        
-   /********** interne (nur fuer main relevante Optionen) **************/
+       /********** interne (nur fuer main relevante Optionen) **************/
    
        char logfilename[200] = "";
    
        char logfilename[200] = "";
-       u4 heapsize = 16000000;
+       u4 heapsize = 64000000;
        u4 heapstartsize = 200000;
        char classpath[500] = ".:/usr/local/lib/java/classes";
        u4 heapstartsize = 200000;
        char classpath[500] = ".:/usr/local/lib/java/classes";
-       bool showmethods = false;
-       bool showconstantpool = false;
-       bool showunicode = false;
        bool startit = true;
        char *specificmethodname = NULL;
        char *specificsignature = NULL;
        bool startit = true;
        char *specificmethodname = NULL;
        char *specificsignature = NULL;
@@ -440,203 +520,235 @@ int main(int argc, char **argv)
 #ifndef USE_THREADS
        stackbottom = &dummy;
 #endif
 #ifndef USE_THREADS
        stackbottom = &dummy;
 #endif
+       
+       if (0 != atexit(exit_handler))
+               panic("unable to register exit_handler");
 
 
-
-#ifdef USE_THREADS
-       atexit(clear_thread_flags);
-#endif
-
-   /************ Infos aus der Environment lesen ************************/
+       /************ Collect info from the environment ************************/
 
        cp = getenv ("CLASSPATH");
        if (cp) {
                strcpy (classpath, cp);
 
        cp = getenv ("CLASSPATH");
        if (cp) {
                strcpy (classpath, cp);
-               }
+       }
 
 
-   /***************** Interpretieren der Kommandozeile *****************/
+       /***************** Interpret the command line *****************/
    
    
-   checknull = false;
-   checkfloats = false;
+       checknull = false;
+       checkfloats = false;
 
        while ( (i = get_opt(argc,argv)) != OPT_DONE) {
 
                switch (i) {
 
        while ( (i = get_opt(argc,argv)) != OPT_DONE) {
 
                switch (i) {
-                       case OPT_IGNORE: break;
+               case OPT_IGNORE: break;
                        
                        
-                       case OPT_CLASSPATH:    
-                               strcpy (classpath + strlen(classpath), ":");
-                               strcpy (classpath + strlen(classpath), opt_arg);
-                               break;
+               case OPT_CLASSPATH:    
+                       strcpy (classpath + strlen(classpath), ":");
+                       strcpy (classpath + strlen(classpath), opt_arg);
+                       break;
                                
                                
-                       case OPT_D:
-                               {
+               case OPT_D:
+                       {
                                int n,l=strlen(opt_arg);
                                for (n=0; n<l; n++) {
                                        if (opt_arg[n]=='=') {
                                                opt_arg[n] = '\0';
                                                attach_property (opt_arg, opt_arg+n+1);
                                                goto didit;
                                int n,l=strlen(opt_arg);
                                for (n=0; n<l; n++) {
                                        if (opt_arg[n]=='=') {
                                                opt_arg[n] = '\0';
                                                attach_property (opt_arg, opt_arg+n+1);
                                                goto didit;
-                                               }
                                        }
                                        }
+                               }
                                print_usage();
                                exit(10);
                                        
                                print_usage();
                                exit(10);
                                        
-                               didit: ;
-                               }       
-                               break;
+                       didit: ;
+                       }       
+               break;
                                
                                
-                       case OPT_MS:
-                       case OPT_MX:
-                               if (opt_arg[strlen(opt_arg)-1] == 'k') {
-                                       j = 1024 * atoi(opt_arg);
-                                       }
-                               else if (opt_arg[strlen(opt_arg)-1] == 'm') {
-                                       j = 1024 * 1024 * atoi(opt_arg);
-                                       }
-                               else j = atoi(opt_arg);
+               case OPT_MS:
+               case OPT_MX:
+                       if (opt_arg[strlen(opt_arg)-1] == 'k') {
+                               j = 1024 * atoi(opt_arg);
+                       }
+                       else if (opt_arg[strlen(opt_arg)-1] == 'm') {
+                               j = 1024 * 1024 * atoi(opt_arg);
+                       }
+                       else j = atoi(opt_arg);
                                
                                
-                               if (i==OPT_MX) heapsize = j;
-                               else heapstartsize = j;
-                               break;
+                       if (i==OPT_MX) heapsize = j;
+                       else heapstartsize = j;
+                       break;
 
 
-                       case OPT_VERBOSE1:
-                               verbose = true;
-                               break;
+               case OPT_VERBOSE1:
+                       verbose = true;
+                       break;
                                                                
                                                                
-                       case OPT_VERBOSE:
-                               verbose = true;
-                               loadverbose = true;
-                               initverbose = true;
-                               compileverbose = true;
-                               break;
+               case OPT_VERBOSE:
+                       verbose = true;
+                       loadverbose = true;
+                       initverbose = true;
+                       compileverbose = true;
+                       break;
                                
                                
-                       case OPT_VERBOSEGC:
-                               collectverbose = true;
-                               break;
+               case OPT_VERBOSEGC:
+                       collectverbose = true;
+                       break;
                                
                                
-                       case OPT_VERBOSECALL:
-                               runverbose = true;
-                               break;
+               case OPT_VERBOSECALL:
+                       runverbose = true;
+                       break;
                                
                                
-                       case OPT_IEEE:
-                               checkfloats = true;
-                               break;
-
-                       case OPT_SOFTNULL:
-                               checknull = true;
-                               break;
-
-                       case OPT_TIME:
-                               getcompilingtime = true;
-                               getloadingtime = true;
-                               break;
+               case OPT_IEEE:
+                       checkfloats = true;
+                       break;
+
+               case OPT_SOFTNULL:
+                       checknull = true;
+                       break;
+
+               case OPT_TIME:
+                       getcompilingtime = true;
+                       getloadingtime = true;
+                       break;
                                        
                                        
-                       case OPT_STAT:
-                               statistics = true;
-                               break;
+               case OPT_STAT:
+                       statistics = true;
+                       break;
                                        
                                        
-                       case OPT_LOG:
-                               strcpy (logfilename, opt_arg);
-                               break;
+               case OPT_LOG:
+                       strcpy (logfilename, opt_arg);
+                       break;
                        
                        
                        
                        
-                       case OPT_CHECK:
-                       for (j=0; j<strlen(opt_arg); j++) {
-                               switch (opt_arg[j]) {
-                               case 'b': checkbounds=false; break;
-                                       case 's': checksync=false; break;
-                               default:  print_usage();
-                                         exit(10);
-                               }
-                               }
-                       break;
+               case OPT_CHECK:
+                       for (j=0; j<strlen(opt_arg); j++) {
+                               switch (opt_arg[j]) {
+                               case 'b': checkbounds=false; break;
+                               case 's': checksync=false; break;
+                               default:  print_usage();
+                                       exit(10);
+                               }
+                       }
+                       break;
                        
                        
-                       case OPT_LOAD:
-                               startit = false;
-                               makeinitializations = false;
-                               break;
-
-                       case OPT_METHOD:
-                               startit = false;
-                               specificmethodname = opt_arg;                   
-                               makeinitializations = false;
-                       break;
+               case OPT_LOAD:
+                       startit = false;
+                       makeinitializations = false;
+                       break;
+
+               case OPT_METHOD:
+                       startit = false;
+                       specificmethodname = opt_arg;                   
+                       makeinitializations = false;
+                       break;
                        
                        
-                       case OPT_SIGNATURE:
-                               specificsignature = opt_arg;                    
-                       break;
+               case OPT_SIGNATURE:
+                       specificsignature = opt_arg;                    
+                       break;
                        
                        
-                       case OPT_ALL:
-                               compileall = true;              
-                               startit = false;
-                               makeinitializations = false;
-                       break;
+               case OPT_ALL:
+                       compileall = true;              
+                       startit = false;
+                       makeinitializations = false;
+                       break;
                        
                        
-                       case OPT_OLD:
-                               newcompiler = false;                    
-                               checknull = true;
-                       break;
+#ifdef OLD_COMPILER
+               case OPT_OLD:
+                       newcompiler = false;                    
+                       checknull = true;
+                       break;
+#endif
+
+#ifdef NEW_GC
+               case OPT_GC2:
+                       new_gc = true;
+                       break;
+
+               case OPT_GC1:
+                       new_gc = false;
+                       break;
+#endif
                        
                        
-               case OPT_SHOW:       /* Anzeigeoptionen */
-                       for (j=0; j<strlen(opt_arg); j++) {             
-                               switch (opt_arg[j]) {
-                               case 'm':  showmethods=true; break;
-                               case 'c':  showconstantpool=true; break;
-                               case 'a':  showdisassemble=true; compileverbose=true; break;
-                               case 's':  showstack=true; compileverbose=true; break;
-                               case 'i':  showintermediate=true; compileverbose=true; break;
-                               case 'u':  showunicode=true; break;
-                               default:   print_usage();
-                                      exit(10);
-                               }
-                               }
-                       break;
-                       
-                       default:
-                               print_usage();
-                               exit(10);
+               case OPT_SHOW:       /* Display options */
+                       for (j=0; j<strlen(opt_arg); j++) {             
+                               switch (opt_arg[j]) {
+                               case 'a':  showdisassemble=true; compileverbose=true; break;
+                               case 'c':  showconstantpool=true; break;
+                               case 'd':  showddatasegment=true; break;
+                               case 'i':  showintermediate=true; compileverbose=true; break;
+                               case 'm':  showmethods=true; break;
+#ifdef OLD_COMPILER
+                               case 's':  showstack=true; compileverbose=true; break;
+#endif
+                               case 'u':  showutf=true; break;
+                               default:   print_usage();
+                                       exit(10);
+                               }
                        }
                        }
+                       break;
                        
                        
-                       
+               case OPT_OLOOP:
+                       opt_loops = true;
+                       break;
+
+               default:
+                       print_usage();
+                       exit(10);
                }
                }
+                       
+                       
+       }
    
    
        if (opt_ind >= argc) {
                print_usage ();
                exit(10);
    
    
        if (opt_ind >= argc) {
                print_usage ();
                exit(10);
-               }
+       }
 
 
 
 
-   /**************************** Programmstart *****************************/
+       /**************************** Program start *****************************/
 
        log_init (logfilename);
        if (verbose) {
                log_text (
 
        log_init (logfilename);
        if (verbose) {
                log_text (
-               "CACAO started -------------------------------------------------------");
-               }
+                                 "CACAO started -------------------------------------------------------");
+       }
        
        suck_init (classpath);
        native_setclasspath (classpath);
                
        
        suck_init (classpath);
        native_setclasspath (classpath);
                
-       unicode_init();
+       tables_init();
        heap_init(heapsize, heapstartsize, &dummy);
        heap_init(heapsize, heapstartsize, &dummy);
-       loader_init();
+#ifdef OLD_COMPILER
        compiler_init();
        compiler_init();
-       ncomp_init();
+#endif
+       jit_init();
+       loader_init();
 
        native_loadclasses ();
 
 
 
        native_loadclasses ();
 
 
-   /*********************** JAVA-Klassen laden  ***************************/
+       /*********************** Load JAVA classes  ***************************/
    
        cp = argv[opt_ind++];
    
        cp = argv[opt_ind++];
-       for (i=strlen(cp)-1; i>=0; i--) {     /* Punkte im Klassennamen */
-               if (cp[i]=='.') cp[i]='/';        /* auf slashes umbauen */
-               }
+       for (i=strlen(cp)-1; i>=0; i--) {     /* Transform dots into slashes */
+               if (cp[i]=='.') cp[i]='/';        /* in the class name */
+       }
+
+       topclass = loader_load ( utf_new_char (cp) );
+
+       if (exceptionptr != 0)
+       {
+               printf ("#### Class loader has thrown: ");
+               utf_display (exceptionptr->vftbl->class->name);
+               printf ("\n");
 
 
-       topclass = loader_load ( unicode_new_char (cp) );
+               exceptionptr = 0;
+       }
 
 
-       loader_compute_subclasses();
+       if (topclass == 0)
+       {
+               printf("#### Could not find top class - exiting\n");
+               exit(1);
+       }
 
        gc_init();
 
 
        gc_init();
 
@@ -644,7 +756,7 @@ int main(int argc, char **argv)
        initThreads((u1*)&dummy);                   /* schani */
 #endif
 
        initThreads((u1*)&dummy);                   /* schani */
 #endif
 
-   /************************* Arbeitsroutinen starten ********************/
+       /************************* Start worker routines ********************/
 
        if (startit) {
                methodinfo *mainmethod;
 
        if (startit) {
                methodinfo *mainmethod;
@@ -653,92 +765,69 @@ int main(int argc, char **argv)
                heap_addreference((void**) &a);
 
                mainmethod = class_findmethod (
                heap_addreference((void**) &a);
 
                mainmethod = class_findmethod (
-                               topclass,
-                               unicode_new_char ("main"), 
-                               unicode_new_char ("([Ljava/lang/String;)V")
-                               );
+                                                                          topclass,
+                                                                          utf_new_char ("main"), 
+                                                                          utf_new_char ("([Ljava/lang/String;)V")
+                                                                          );
                if (!mainmethod) panic ("Can not find method 'void main(String[])'");
                if ((mainmethod->flags & ACC_STATIC) != ACC_STATIC) panic ("main is not static!");
                        
                a = builtin_anewarray (argc - opt_ind, class_java_lang_String);
                for (i=opt_ind; i<argc; i++) {
                if (!mainmethod) panic ("Can not find method 'void main(String[])'");
                if ((mainmethod->flags & ACC_STATIC) != ACC_STATIC) panic ("main is not static!");
                        
                a = builtin_anewarray (argc - opt_ind, class_java_lang_String);
                for (i=opt_ind; i<argc; i++) {
-                       a->data[i-opt_ind] = javastring_new (unicode_new_char (argv[i]) );
-                       }
-               exceptionptr = asm_calljavamethod (mainmethod, a, NULL,NULL,NULL );
+                       a->data[i-opt_ind] = javastring_new (utf_new_char (argv[i]) );
+               }
+               local_exceptionptr = asm_calljavamethod (mainmethod, a, NULL,NULL,NULL );
        
        
-               if (exceptionptr) {
+               if (local_exceptionptr) {
                        printf ("#### Program has thrown: ");
                        printf ("#### Program has thrown: ");
-                       unicode_display (exceptionptr->vftbl->class->name);
+                       utf_display (local_exceptionptr->vftbl->class->name);
                        printf ("\n");
                        printf ("\n");
-                       }
-
-/*             killThread(currentThread); */
-
                }
 
                }
 
-       /************* Auf Wunsch alle Methode "ubersetzen ********************/
+#ifdef USE_THREADS
+               killThread(currentThread);
+#endif
+               fprintf(stderr, "still here\n");
+       }
+
+       /************* If requested, compile all methods ********************/
 
        if (compileall) {
                class_compile_methods();
 
        if (compileall) {
                class_compile_methods();
-               }
+       }
 
 
 
 
-       /******** Auf Wunsch eine spezielle Methode "ubersetzen ***************/
+       /******** If requested, compile a specific method ***************/
 
        if (specificmethodname) {
                methodinfo *m;
                if (specificsignature)
                        m = class_findmethod(topclass, 
 
        if (specificmethodname) {
                methodinfo *m;
                if (specificsignature)
                        m = class_findmethod(topclass, 
-                                       unicode_new_char(specificmethodname),
-                                       unicode_new_char(specificsignature));
+                                                                utf_new_char(specificmethodname),
+                                                                utf_new_char(specificsignature));
                else
                        m = class_findmethod(topclass, 
                else
                        m = class_findmethod(topclass, 
-                                       unicode_new_char(specificmethodname), NULL);
+                                                                utf_new_char(specificmethodname), NULL);
                if (!m) panic ("Specific method not found");
                if (!m) panic ("Specific method not found");
+#ifdef OLD_COMPILER
                if (newcompiler)
                if (newcompiler)
-                       (void) new_compile(m);
+#endif
+                       (void) jit_compile(m);
+#ifdef OLD_COMPILER
                else
                        (void) compiler_compile(m);
                else
                        (void) compiler_compile(m);
-               }
-
-       /********************* Debug-Tabellen ausgeben ************************/
-                               
-       if (showmethods) class_showmethods (topclass);
-       if (showconstantpool)  class_showconstantpool (topclass);
-       if (showunicode)       unicode_show ();
-
-   
-
-   /************************ Freigeben aller Resourcen *******************/
-
-       compiler_close ();
-       loader_close ();
-       heap_close ();
-       unicode_close ( literalstring_free );
-
-
-   /* Endemeldung ausgeben und mit entsprechendem exit-Status terminieren */
+#endif
+       }
 
 
-       if (verbose || getcompilingtime || statistics) {
-               log_text ("CACAO terminated");
-               if (statistics)
-                       print_stats ();
-               if (getcompilingtime)
-                       print_times ();
-               mem_usagelog(1);
-               }
-               
        exit(0);
        exit(0);
-       return 1;
 }
 
 
 
 }
 
 
 
-/************************************ SHUTDOWN-Funktion *********************************
+/************************************ Shutdown function *********************************
 
 
-       Terminiert das System augenblicklich, ohne den Speicher
-       explizit freizugeben (eigentlich nur f"ur abnorme 
-       Programmterminierung)
+       Terminates the system immediately without freeing memory explicitly (to be
+       used only for abnormal termination)
        
 *****************************************************************************************/
 
        
 *****************************************************************************************/
 
@@ -754,6 +843,20 @@ void cacao_shutdown(s4 status)
                sprintf (logtext, "Exit status: %d\n", (int) status);
                dolog();
                }
                sprintf (logtext, "Exit status: %d\n", (int) status);
                dolog();
                }
-               
+
        exit(status);
 }
        exit(status);
 }
+
+
+/*
+ * 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
+ * Emacs will automagically detect them.
+ * ---------------------------------------------------------------------
+ * Local variables:
+ * mode: c
+ * indent-tabs-mode: t
+ * c-basic-offset: 4
+ * tab-width: 4
+ * End:
+ */
inofficial http://www.cacaojvm.org/ git mirror