OSDN Git Service

e205dbbe521ba4a49202ac72f4f8d33b7825da91
[pf3gnuchains/gcc-fork.git] / libjava / prims.cc
1 // prims.cc - Code for core of runtime environment.
2
3 /* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006  Free Software Foundation
4
5    This file is part of libgcj.
6
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
9 details.  */
10
11 #include <config.h>
12 #include <platform.h>
13
14 #include <stdlib.h>
15 #include <stdarg.h>
16 #include <stdio.h>
17 #include <string.h>
18 #include <signal.h>
19
20 #ifdef HAVE_UNISTD_H
21 #include <unistd.h>
22 #endif
23
24 #include <gcj/cni.h>
25 #include <jvm.h>
26 #include <java-signal.h>
27 #include <java-threads.h>
28 #include <java-interp.h>
29
30 #ifdef ENABLE_JVMPI
31 #include <jvmpi.h>
32 #include <java/lang/ThreadGroup.h>
33 #endif
34
35 #include <jvmti.h>
36 #include "jvmti-int.h"
37
38 #ifndef DISABLE_GETENV_PROPERTIES
39 #include <ctype.h>
40 #include <java-props.h>
41 #define PROCESS_GCJ_PROPERTIES process_gcj_properties()
42 #else
43 #define PROCESS_GCJ_PROPERTIES
44 #endif // DISABLE_GETENV_PROPERTIES
45
46 #include <java/lang/Class.h>
47 #include <java/lang/ClassLoader.h>
48 #include <java/lang/Runtime.h>
49 #include <java/lang/String.h>
50 #include <java/lang/Thread.h>
51 #include <java/lang/ThreadGroup.h>
52 #include <java/lang/ArrayIndexOutOfBoundsException.h>
53 #include <java/lang/ArithmeticException.h>
54 #include <java/lang/ClassFormatError.h>
55 #include <java/lang/ClassNotFoundException.h>
56 #include <java/lang/InternalError.h>
57 #include <java/lang/NegativeArraySizeException.h>
58 #include <java/lang/NoClassDefFoundError.h>
59 #include <java/lang/NullPointerException.h>
60 #include <java/lang/OutOfMemoryError.h>
61 #include <java/lang/System.h>
62 #include <java/lang/VMClassLoader.h>
63 #include <java/lang/reflect/Modifier.h>
64 #include <java/io/PrintStream.h>
65 #include <java/lang/UnsatisfiedLinkError.h>
66 #include <java/lang/VirtualMachineError.h>
67 #include <gnu/gcj/runtime/ExtensionClassLoader.h>
68 #include <gnu/gcj/runtime/FinalizerThread.h>
69 #include <execution.h>
70 #include <gnu/classpath/jdwp/Jdwp.h>
71 #include <gnu/classpath/jdwp/VMVirtualMachine.h>
72 #include <gnu/java/lang/MainThread.h>
73
74 #ifdef USE_LTDL
75 #include <ltdl.h>
76 #endif
77
78 // Execution engine for compiled code.
79 _Jv_CompiledEngine _Jv_soleCompiledEngine;
80
81 // Execution engine for code compiled with -findirect-classes
82 _Jv_IndirectCompiledEngine _Jv_soleIndirectCompiledEngine;
83
84 // We allocate a single OutOfMemoryError exception which we keep
85 // around for use if we run out of memory.
86 static java::lang::OutOfMemoryError *no_memory;
87
88 // Number of bytes in largest array object we create.  This could be
89 // increased to the largest size_t value, so long as the appropriate
90 // functions are changed to take a size_t argument instead of jint.
91 #define MAX_OBJECT_SIZE (((size_t)1<<31) - 1)
92
93 // Properties set at compile time.
94 const char **_Jv_Compiler_Properties = NULL;
95 int _Jv_Properties_Count = 0;
96
97 #ifndef DISABLE_GETENV_PROPERTIES
98 // Property key/value pairs.
99 property_pair *_Jv_Environment_Properties;
100 #endif
101
102 // Stash the argv pointer to benefit native libraries that need it.
103 const char **_Jv_argv;
104 int _Jv_argc;
105
106 // Debugging options
107 static bool remoteDebug = false;
108 static char defaultJdwpOptions[] = "";
109 static char *jdwpOptions = defaultJdwpOptions;
110
111 // Argument support.
112 int
113 _Jv_GetNbArgs (void)
114 {
115   // _Jv_argc is 0 if not explicitly initialized.
116   return _Jv_argc;
117 }
118
119 const char *
120 _Jv_GetSafeArg (int index)
121 {
122   if (index >=0 && index < _Jv_GetNbArgs ())
123     return _Jv_argv[index];
124   else
125     return "";
126 }
127
128 void
129 _Jv_SetArgs (int argc, const char **argv)
130 {
131   _Jv_argc = argc;
132   _Jv_argv = argv;
133 }
134
135 #ifdef ENABLE_JVMPI
136 // Pointer to JVMPI notification functions.
137 void (*_Jv_JVMPI_Notify_OBJECT_ALLOC) (JVMPI_Event *event);
138 void (*_Jv_JVMPI_Notify_THREAD_START) (JVMPI_Event *event);
139 void (*_Jv_JVMPI_Notify_THREAD_END) (JVMPI_Event *event);
140 #endif
141 \f
142
143 #if defined (HANDLE_SEGV) || defined(HANDLE_FPE)
144 /* Unblock a signal.  Unless we do this, the signal may only be sent
145    once.  */
146 static void 
147 unblock_signal (int signum __attribute__ ((__unused__)))
148 {
149 #ifdef _POSIX_VERSION
150   sigset_t sigs;
151
152   sigemptyset (&sigs);
153   sigaddset (&sigs, signum);
154   sigprocmask (SIG_UNBLOCK, &sigs, NULL);
155 #endif
156 }
157 #endif
158
159 #ifdef HANDLE_SEGV
160 SIGNAL_HANDLER (catch_segv)
161 {
162   unblock_signal (SIGSEGV);
163   MAKE_THROW_FRAME (nullp);
164   java::lang::NullPointerException *nullp 
165     = new java::lang::NullPointerException;
166   throw nullp;
167 }
168 #endif
169
170 #ifdef HANDLE_FPE
171 SIGNAL_HANDLER (catch_fpe)
172 {
173   unblock_signal (SIGFPE);
174 #ifdef HANDLE_DIVIDE_OVERFLOW
175   HANDLE_DIVIDE_OVERFLOW;
176 #else
177   MAKE_THROW_FRAME (arithexception);
178 #endif
179   java::lang::ArithmeticException *arithexception 
180     = new java::lang::ArithmeticException (JvNewStringLatin1 ("/ by zero"));
181   throw arithexception;
182 }
183 #endif
184
185
186 jboolean
187 _Jv_equalUtf8Consts (const Utf8Const* a, const Utf8Const *b)
188 {
189   int len;
190   const _Jv_ushort *aptr, *bptr;
191   if (a == b)
192     return true;
193   if (a->hash != b->hash)
194     return false;
195   len = a->length;
196   if (b->length != len)
197     return false;
198   aptr = (const _Jv_ushort *)a->data;
199   bptr = (const _Jv_ushort *)b->data;
200   len = (len + 1) >> 1;
201   while (--len >= 0)
202     if (*aptr++ != *bptr++)
203       return false;
204   return true;
205 }
206
207 /* True iff A is equal to STR.
208    HASH is STR->hashCode().  
209 */
210
211 jboolean
212 _Jv_equal (Utf8Const* a, jstring str, jint hash)
213 {
214   if (a->hash != (_Jv_ushort) hash)
215     return false;
216   jint len = str->length();
217   jint i = 0;
218   jchar *sptr = _Jv_GetStringChars (str);
219   unsigned char* ptr = (unsigned char*) a->data;
220   unsigned char* limit = ptr + a->length;
221   for (;; i++, sptr++)
222     {
223       int ch = UTF8_GET (ptr, limit);
224       if (i == len)
225         return ch < 0;
226       if (ch != *sptr)
227         return false;
228     }
229   return true;
230 }
231
232 /* Like _Jv_equal, but stop after N characters.  */
233 jboolean
234 _Jv_equaln (Utf8Const *a, jstring str, jint n)
235 {
236   jint len = str->length();
237   jint i = 0;
238   jchar *sptr = _Jv_GetStringChars (str);
239   unsigned char* ptr = (unsigned char*) a->data;
240   unsigned char* limit = ptr + a->length;
241   for (; n-- > 0; i++, sptr++)
242     {
243       int ch = UTF8_GET (ptr, limit);
244       if (i == len)
245         return ch < 0;
246       if (ch != *sptr)
247         return false;
248     }
249   return true;
250 }
251
252 // Determines whether the given Utf8Const object contains
253 // a type which is primitive or some derived form of it, eg.
254 // an array or multi-dimensional array variant.
255 jboolean
256 _Jv_isPrimitiveOrDerived(const Utf8Const *a)
257 {
258   unsigned char *aptr = (unsigned char *) a->data;
259   unsigned char *alimit = aptr + a->length;
260   int ac = UTF8_GET(aptr, alimit);
261
262   // Skips any leading array marks.
263   while (ac == '[')
264     ac = UTF8_GET(aptr, alimit);
265
266   // There should not be another character. This implies that
267   // the type name is only one character long.
268   if (UTF8_GET(aptr, alimit) == -1)
269     switch ( ac )
270       {
271         case 'Z':
272         case 'B':
273         case 'C':
274         case 'S':
275         case 'I':
276         case 'J':
277         case 'F':
278         case 'D':
279           return true;
280         default:
281           break;
282        }
283
284    return false;
285 }
286
287 // Find out whether two _Jv_Utf8Const candidates contain the same
288 // classname.
289 // The method is written to handle the different formats of classnames.
290 // Eg. "Ljava/lang/Class;", "Ljava.lang.Class;", "java/lang/Class" and
291 // "java.lang.Class" will be seen as equal.
292 // Warning: This function is not smart enough to declare "Z" and "boolean"
293 // and similar cases as equal (and is not meant to be used this way)!
294 jboolean
295 _Jv_equalUtf8Classnames (const Utf8Const *a, const Utf8Const *b)
296 {
297   // If the class name's length differs by two characters
298   // it is possible that we have candidates which are given
299   // in the two different formats ("Lp1/p2/cn;" vs. "p1/p2/cn")
300   switch (a->length - b->length)
301     {
302       case -2:
303       case 0:
304       case 2:
305         break;
306       default:
307         return false;
308     }
309
310   unsigned char *aptr = (unsigned char *) a->data;
311   unsigned char *alimit = aptr + a->length;
312   unsigned char *bptr = (unsigned char *) b->data;
313   unsigned char *blimit = bptr + b->length;
314
315   if (alimit[-1] == ';')
316     alimit--;
317
318   if (blimit[-1] == ';')
319     blimit--;
320
321   int ac = UTF8_GET(aptr, alimit);
322   int bc = UTF8_GET(bptr, blimit);
323
324   // Checks whether both strings have the same amount of leading [ characters.
325   while (ac == '[')
326     {
327       if (bc == '[')
328         {
329           ac = UTF8_GET(aptr, alimit);
330           bc = UTF8_GET(bptr, blimit);
331           continue;
332         }
333
334       return false;
335     }
336
337   // Skips leading L character.
338   if (ac == 'L')
339     ac = UTF8_GET(aptr, alimit);
340         
341   if (bc == 'L')
342     bc = UTF8_GET(bptr, blimit);
343
344   // Compares the remaining characters.
345   while (ac != -1 && bc != -1)
346     {
347       // Replaces package separating dots with slashes.
348       if (ac == '.')
349         ac = '/';
350
351       if (bc == '.')
352         bc = '/';
353       
354       // Now classnames differ if there is at least one non-matching
355       // character.
356       if (ac != bc)
357         return false;
358
359       ac = UTF8_GET(aptr, alimit);
360       bc = UTF8_GET(bptr, blimit);
361     }
362
363   return (ac == bc);
364 }
365
366 /* Count the number of Unicode chars encoded in a given Ut8 string. */
367 int
368 _Jv_strLengthUtf8(const char* str, int len)
369 {
370   unsigned char* ptr;
371   unsigned char* limit;
372   int str_length;
373
374   ptr = (unsigned char*) str;
375   limit = ptr + len;
376   str_length = 0;
377   for (; ptr < limit; str_length++)
378     {
379       if (UTF8_GET (ptr, limit) < 0)
380         return (-1);
381     }
382   return (str_length);
383 }
384
385 /* Calculate a hash value for a string encoded in Utf8 format.
386  * This returns the same hash value as specified or java.lang.String.hashCode.
387  */
388 jint
389 _Jv_hashUtf8String (const char* str, int len)
390 {
391   unsigned char* ptr = (unsigned char*) str;
392   unsigned char* limit = ptr + len;
393   jint hash = 0;
394
395   for (; ptr < limit;)
396     {
397       int ch = UTF8_GET (ptr, limit);
398       /* Updated specification from
399          http://www.javasoft.com/docs/books/jls/clarify.html. */
400       hash = (31 * hash) + ch;
401     }
402   return hash;
403 }
404
405 void
406 _Jv_Utf8Const::init(const char *s, int len)
407 {
408   ::memcpy (data, s, len);
409   data[len] = 0;
410   length = len;
411   hash = _Jv_hashUtf8String (s, len) & 0xFFFF;
412 }
413
414 _Jv_Utf8Const *
415 _Jv_makeUtf8Const (const char* s, int len)
416 {
417   if (len < 0)
418     len = strlen (s);
419   Utf8Const* m
420     = (Utf8Const*) _Jv_AllocBytes (_Jv_Utf8Const::space_needed(s, len));
421   m->init(s, len);
422   return m;
423 }
424
425 _Jv_Utf8Const *
426 _Jv_makeUtf8Const (jstring string)
427 {
428   jint hash = string->hashCode ();
429   jint len = _Jv_GetStringUTFLength (string);
430
431   Utf8Const* m = (Utf8Const*)
432     _Jv_AllocBytes (sizeof(Utf8Const) + len + 1);
433
434   m->hash = hash;
435   m->length = len;
436
437   _Jv_GetStringUTFRegion (string, 0, string->length (), m->data);
438   m->data[len] = 0;
439   
440   return m;
441 }
442
443 \f
444
445 #ifdef DEBUG
446 void
447 _Jv_Abort (const char *function, const char *file, int line,
448            const char *message)
449 #else
450 void
451 _Jv_Abort (const char *, const char *, int, const char *message)
452 #endif
453 {
454 #ifdef DEBUG
455   fprintf (stderr,
456            "libgcj failure: %s\n   in function %s, file %s, line %d\n",
457            message, function, file, line);
458 #else
459   fprintf (stderr, "libgcj failure: %s\n", message);
460 #endif
461   abort ();
462 }
463
464 static void
465 fail_on_finalization (jobject)
466 {
467   JvFail ("object was finalized");
468 }
469
470 void
471 _Jv_GCWatch (jobject obj)
472 {
473   _Jv_RegisterFinalizer (obj, fail_on_finalization);
474 }
475
476 void
477 _Jv_ThrowBadArrayIndex(jint bad_index)
478 {
479   throw new java::lang::ArrayIndexOutOfBoundsException
480     (java::lang::String::valueOf (bad_index));
481 }
482
483 void
484 _Jv_ThrowNullPointerException ()
485 {
486   throw new java::lang::NullPointerException;
487 }
488
489 // Resolve an entry in the constant pool and return the target
490 // address.
491 void *
492 _Jv_ResolvePoolEntry (jclass this_class, jint index)
493 {
494   _Jv_Constants *pool = &this_class->constants;
495
496   if ((pool->tags[index] & JV_CONSTANT_ResolvedFlag) != 0)
497     return pool->data[index].field->u.addr;
498
499   JvSynchronize sync (this_class);
500   return (_Jv_Linker::resolve_pool_entry (this_class, index))
501     .field->u.addr;
502 }
503
504
505 // Explicitly throw a no memory exception.
506 // The collector calls this when it encounters an out-of-memory condition.
507 void _Jv_ThrowNoMemory()
508 {
509   throw no_memory;
510 }
511
512 #ifdef ENABLE_JVMPI
513 # define JVMPI_NOTIFY_ALLOC(klass,size,obj) \
514     if (__builtin_expect (_Jv_JVMPI_Notify_OBJECT_ALLOC != 0, false)) \
515       jvmpi_notify_alloc(klass,size,obj);
516 static void
517 jvmpi_notify_alloc(jclass klass, jint size, jobject obj)
518 {
519   // Service JVMPI allocation request.
520   JVMPI_Event event;
521
522   event.event_type = JVMPI_EVENT_OBJECT_ALLOC;
523   event.env_id = NULL;
524   event.u.obj_alloc.arena_id = 0;
525   event.u.obj_alloc.class_id = (jobjectID) klass;
526   event.u.obj_alloc.is_array = 0;
527   event.u.obj_alloc.size = size;
528   event.u.obj_alloc.obj_id = (jobjectID) obj;
529
530   // FIXME:  This doesn't look right for the Boehm GC.  A GC may
531   // already be in progress.  _Jv_DisableGC () doesn't wait for it.
532   // More importantly, I don't see the need for disabling GC, since we
533   // blatantly have a pointer to obj on our stack, ensuring that the
534   // object can't be collected.  Even for a nonconservative collector,
535   // it appears to me that this must be true, since we are about to
536   // return obj. Isn't this whole approach way too intrusive for
537   // a useful profiling interface?                      - HB
538   _Jv_DisableGC ();
539   (*_Jv_JVMPI_Notify_OBJECT_ALLOC) (&event);
540   _Jv_EnableGC ();
541 }
542 #else /* !ENABLE_JVMPI */
543 # define JVMPI_NOTIFY_ALLOC(klass,size,obj) /* do nothing */
544 #endif
545
546 // Allocate a new object of class KLASS.
547 // First a version that assumes that we have no finalizer, and that
548 // the class is already initialized.
549 // If we know that JVMPI is disabled, this can be replaced by a direct call
550 // to the allocator for the appropriate GC.
551 jobject
552 _Jv_AllocObjectNoInitNoFinalizer (jclass klass)
553 {
554   jint size = klass->size ();
555   jobject obj = (jobject) _Jv_AllocObj (size, klass);
556   JVMPI_NOTIFY_ALLOC (klass, size, obj);
557   return obj;
558 }
559
560 // And now a version that initializes if necessary.
561 jobject
562 _Jv_AllocObjectNoFinalizer (jclass klass)
563 {
564   if (_Jv_IsPhantomClass(klass) )
565     throw new java::lang::NoClassDefFoundError(klass->getName());
566
567   _Jv_InitClass (klass);
568   jint size = klass->size ();
569   jobject obj = (jobject) _Jv_AllocObj (size, klass);
570   JVMPI_NOTIFY_ALLOC (klass, size, obj);
571   return obj;
572 }
573
574 // And now the general version that registers a finalizer if necessary.
575 jobject
576 _Jv_AllocObject (jclass klass)
577 {
578   jobject obj = _Jv_AllocObjectNoFinalizer (klass);
579   
580   // We assume that the compiler only generates calls to this routine
581   // if there really is an interesting finalizer.
582   // Unfortunately, we still have to the dynamic test, since there may
583   // be cni calls to this routine.
584   // Note that on IA64 get_finalizer() returns the starting address of the
585   // function, not a function pointer.  Thus this still works.
586   if (klass->vtable->get_finalizer ()
587       != java::lang::Object::class$.vtable->get_finalizer ())
588     _Jv_RegisterFinalizer (obj, _Jv_FinalizeObject);
589   return obj;
590 }
591
592 // Allocate a String, including variable length storage.
593 jstring
594 _Jv_AllocString(jsize len)
595 {
596   using namespace java::lang;
597
598   jsize sz = sizeof(java::lang::String) + len * sizeof(jchar);
599
600   // We assert that for strings allocated this way, the data field
601   // will always point to the object itself.  Thus there is no reason
602   // for the garbage collector to scan any of it.
603   // Furthermore, we're about to overwrite the string data, so
604   // initialization of the object is not an issue.
605
606   // String needs no initialization, and there is no finalizer, so
607   // we can go directly to the collector's allocator interface.
608   jstring obj = (jstring) _Jv_AllocPtrFreeObj(sz, &String::class$);
609
610   obj->data = obj;
611   obj->boffset = sizeof(java::lang::String);
612   obj->count = len;
613   obj->cachedHashCode = 0;
614
615   JVMPI_NOTIFY_ALLOC (&String::class$, sz, obj);
616   
617   return obj;
618 }
619
620 // A version of the above that assumes the object contains no pointers,
621 // and requires no finalization.  This can't happen if we need pointers
622 // to locks.
623 #ifdef JV_HASH_SYNCHRONIZATION
624 jobject
625 _Jv_AllocPtrFreeObject (jclass klass)
626 {
627   _Jv_InitClass (klass);
628   jint size = klass->size ();
629
630   jobject obj = (jobject) _Jv_AllocPtrFreeObj (size, klass);
631
632   JVMPI_NOTIFY_ALLOC (klass, size, obj);
633
634   return obj;
635 }
636 #endif /* JV_HASH_SYNCHRONIZATION */
637
638
639 // Allocate a new array of Java objects.  Each object is of type
640 // `elementClass'.  `init' is used to initialize each slot in the
641 // array.
642 jobjectArray
643 _Jv_NewObjectArray (jsize count, jclass elementClass, jobject init)
644 {
645   // Creating an array of an unresolved type is impossible. So we throw
646   // the NoClassDefFoundError.
647   if ( _Jv_IsPhantomClass(elementClass) )
648     throw new java::lang::NoClassDefFoundError(elementClass->getName());
649
650   if (__builtin_expect (count < 0, false))
651     throw new java::lang::NegativeArraySizeException;
652
653   JvAssert (! elementClass->isPrimitive ());
654
655   // Ensure that elements pointer is properly aligned.
656   jobjectArray obj = NULL;
657   size_t size = (size_t) elements (obj);
658   // Check for overflow.
659   if (__builtin_expect ((size_t) count > 
660                         (MAX_OBJECT_SIZE - 1 - size) / sizeof (jobject), false))
661     throw no_memory;
662
663   size += count * sizeof (jobject);
664
665   jclass klass = _Jv_GetArrayClass (elementClass,
666                                     elementClass->getClassLoaderInternal());
667
668   obj = (jobjectArray) _Jv_AllocArray (size, klass);
669   // Cast away const.
670   jsize *lp = const_cast<jsize *> (&obj->length);
671   *lp = count;
672   // We know the allocator returns zeroed memory.  So don't bother
673   // zeroing it again.
674   if (init)
675     {
676       jobject *ptr = elements(obj);
677       while (--count >= 0)
678         *ptr++ = init;
679     }
680   return obj;
681 }
682
683 // Allocate a new array of primitives.  ELTYPE is the type of the
684 // element, COUNT is the size of the array.
685 jobject
686 _Jv_NewPrimArray (jclass eltype, jint count)
687 {
688   int elsize = eltype->size();
689   if (__builtin_expect (count < 0, false))
690     throw new java::lang::NegativeArraySizeException;
691
692   JvAssert (eltype->isPrimitive ());
693   jobject dummy = NULL;
694   size_t size = (size_t) _Jv_GetArrayElementFromElementType (dummy, eltype);
695
696   // Check for overflow.
697   if (__builtin_expect ((size_t) count > 
698                         (MAX_OBJECT_SIZE - size) / elsize, false))
699     throw no_memory;
700
701   jclass klass = _Jv_GetArrayClass (eltype, 0);
702
703 # ifdef JV_HASH_SYNCHRONIZATION
704   // Since the vtable is always statically allocated,
705   // these are completely pointerfree!  Make sure the GC doesn't touch them.
706   __JArray *arr =
707     (__JArray*) _Jv_AllocPtrFreeObj (size + elsize * count, klass);
708   memset((char *)arr + size, 0, elsize * count);
709 # else
710   __JArray *arr = (__JArray*) _Jv_AllocObj (size + elsize * count, klass);
711   // Note that we assume we are given zeroed memory by the allocator.
712 # endif
713   // Cast away const.
714   jsize *lp = const_cast<jsize *> (&arr->length);
715   *lp = count;
716
717   return arr;
718 }
719
720 jobject
721 _Jv_NewArray (jint type, jint size)
722 {
723   switch (type)
724     {
725       case  4:  return JvNewBooleanArray (size);
726       case  5:  return JvNewCharArray (size);
727       case  6:  return JvNewFloatArray (size);
728       case  7:  return JvNewDoubleArray (size);
729       case  8:  return JvNewByteArray (size);
730       case  9:  return JvNewShortArray (size);
731       case 10:  return JvNewIntArray (size);
732       case 11:  return JvNewLongArray (size);
733     }
734   throw new java::lang::InternalError
735     (JvNewStringLatin1 ("invalid type code in _Jv_NewArray"));
736 }
737
738 // Allocate a possibly multi-dimensional array but don't check that
739 // any array length is <0.
740 static jobject
741 _Jv_NewMultiArrayUnchecked (jclass type, jint dimensions, jint *sizes)
742 {
743   JvAssert (type->isArray());
744   jclass element_type = type->getComponentType();
745   jobject result;
746   if (element_type->isPrimitive())
747     result = _Jv_NewPrimArray (element_type, sizes[0]);
748   else
749     result = _Jv_NewObjectArray (sizes[0], element_type, NULL);
750
751   if (dimensions > 1)
752     {
753       JvAssert (! element_type->isPrimitive());
754       JvAssert (element_type->isArray());
755       jobject *contents = elements ((jobjectArray) result);
756       for (int i = 0; i < sizes[0]; ++i)
757         contents[i] = _Jv_NewMultiArrayUnchecked (element_type, dimensions - 1,
758                                                   sizes + 1);
759     }
760
761   return result;
762 }
763
764 jobject
765 _Jv_NewMultiArray (jclass type, jint dimensions, jint *sizes)
766 {
767   for (int i = 0; i < dimensions; ++i)
768     if (sizes[i] < 0)
769       throw new java::lang::NegativeArraySizeException;
770
771   return _Jv_NewMultiArrayUnchecked (type, dimensions, sizes);
772 }
773
774 jobject
775 _Jv_NewMultiArray (jclass array_type, jint dimensions, ...)
776 {
777   // Creating an array of an unresolved type is impossible. So we throw
778   // the NoClassDefFoundError.
779   if (_Jv_IsPhantomClass(array_type))
780     throw new java::lang::NoClassDefFoundError(array_type->getName());
781
782   va_list args;
783   jint sizes[dimensions];
784   va_start (args, dimensions);
785   for (int i = 0; i < dimensions; ++i)
786     {
787       jint size = va_arg (args, jint);
788       if (size < 0)
789         throw new java::lang::NegativeArraySizeException;
790       sizes[i] = size;
791     }
792   va_end (args);
793
794   return _Jv_NewMultiArrayUnchecked (array_type, dimensions, sizes);
795 }
796
797 \f
798
799 // Ensure 8-byte alignment, for hash synchronization.
800 #define DECLARE_PRIM_TYPE(NAME)                 \
801   java::lang::Class _Jv_##NAME##Class __attribute__ ((aligned (8)));
802
803 DECLARE_PRIM_TYPE(byte)
804 DECLARE_PRIM_TYPE(short)
805 DECLARE_PRIM_TYPE(int)
806 DECLARE_PRIM_TYPE(long)
807 DECLARE_PRIM_TYPE(boolean)
808 DECLARE_PRIM_TYPE(char)
809 DECLARE_PRIM_TYPE(float)
810 DECLARE_PRIM_TYPE(double)
811 DECLARE_PRIM_TYPE(void)
812
813 void
814 _Jv_InitPrimClass (jclass cl, const char *cname, char sig, int len)
815 {    
816   using namespace java::lang::reflect;
817
818   // We must set the vtable for the class; the Java constructor
819   // doesn't do this.
820   (*(_Jv_VTable **) cl) = java::lang::Class::class$.vtable;
821
822   // Initialize the fields we care about.  We do this in the same
823   // order they are declared in Class.h.
824   cl->name = _Jv_makeUtf8Const ((char *) cname, -1);
825   cl->accflags = Modifier::PUBLIC | Modifier::FINAL | Modifier::ABSTRACT;
826   cl->method_count = sig;
827   cl->size_in_bytes = len;
828   cl->vtable = JV_PRIMITIVE_VTABLE;
829   cl->state = JV_STATE_DONE;
830   cl->depth = -1;
831 }
832
833 jclass
834 _Jv_FindClassFromSignature (char *sig, java::lang::ClassLoader *loader,
835                             char **endp)
836 {
837   // First count arrays.
838   int array_count = 0;
839   while (*sig == '[')
840     {
841       ++sig;
842       ++array_count;
843     }
844
845   jclass result = NULL;
846   switch (*sig)
847     {
848     case 'B':
849       result = JvPrimClass (byte);
850       break;
851     case 'S':
852       result = JvPrimClass (short);
853       break;
854     case 'I':
855       result = JvPrimClass (int);
856       break;
857     case 'J':
858       result = JvPrimClass (long);
859       break;
860     case 'Z':
861       result = JvPrimClass (boolean);
862       break;
863     case 'C':
864       result = JvPrimClass (char);
865       break;
866     case 'F':
867       result = JvPrimClass (float);
868       break;
869     case 'D':
870       result = JvPrimClass (double);
871       break;
872     case 'V':
873       result = JvPrimClass (void);
874       break;
875     case 'L':
876       {
877         char *save = ++sig;
878         while (*sig && *sig != ';')
879           ++sig;
880         // Do nothing if signature appears to be malformed.
881         if (*sig == ';')
882           {
883             _Jv_Utf8Const *name = _Jv_makeUtf8Const (save, sig - save);
884             result = _Jv_FindClass (name, loader);
885           }
886         break;
887       }
888     default:
889       // Do nothing -- bad signature.
890       break;
891     }
892
893   if (endp)
894     {
895       // Not really the "end", but the last valid character that we
896       // looked at.
897       *endp = sig;
898     }
899
900   if (! result)
901     return NULL;
902
903   // Find arrays.
904   while (array_count-- > 0)
905     result = _Jv_GetArrayClass (result, loader);
906   return result;
907 }
908
909
910 jclass
911 _Jv_FindClassFromSignatureNoException (char *sig, java::lang::ClassLoader *loader,
912                                        char **endp)
913 {
914   jclass klass;
915
916   try
917     {
918       klass = _Jv_FindClassFromSignature(sig, loader, endp);
919     }
920   catch (java::lang::NoClassDefFoundError *ncdfe)
921     {
922       return NULL;
923     }
924   catch (java::lang::ClassNotFoundException *cnfe)
925     {
926       return NULL;
927     }
928
929   return klass;
930 }
931
932 JArray<jstring> *
933 JvConvertArgv (int argc, const char **argv)
934 {
935   if (argc < 0)
936     argc = 0;
937   jobjectArray ar = JvNewObjectArray(argc, &java::lang::String::class$, NULL);
938   jobject *ptr = elements(ar);
939   jbyteArray bytes = NULL;
940   for (int i = 0;  i < argc;  i++)
941     {
942       const char *arg = argv[i];
943       int len = strlen (arg);
944       if (bytes == NULL || bytes->length < len)
945         bytes = JvNewByteArray (len);
946       jbyte *bytePtr = elements (bytes);
947       // We assume jbyte == char.
948       memcpy (bytePtr, arg, len);
949
950       // Now convert using the default encoding.
951       *ptr++ = new java::lang::String (bytes, 0, len);
952     }
953   return (JArray<jstring>*) ar;
954 }
955
956 // FIXME: These variables are static so that they will be
957 // automatically scanned by the Boehm collector.  This is needed
958 // because with qthreads the collector won't scan the initial stack --
959 // it will only scan the qthreads stacks.
960
961 // Command line arguments.
962 static JArray<jstring> *arg_vec;
963
964 // The primary thread.
965 static java::lang::Thread *main_thread;
966
967 #ifndef DISABLE_GETENV_PROPERTIES
968
969 static char *
970 next_property_key (char *s, size_t *length)
971 {
972   size_t l = 0;
973
974   JvAssert (s);
975
976   // Skip over whitespace
977   while (isspace (*s))
978     s++;
979
980   // If we've reached the end, return NULL.  Also return NULL if for
981   // some reason we've come across a malformed property string.
982   if (*s == 0
983       || *s == ':'
984       || *s == '=')
985     return NULL;
986
987   // Determine the length of the property key.
988   while (s[l] != 0
989          && ! isspace (s[l])
990          && s[l] != ':'
991          && s[l] != '=')
992     {
993       if (s[l] == '\\'
994           && s[l+1] != 0)
995         l++;
996       l++;
997     }
998
999   *length = l;
1000
1001   return s;
1002 }
1003
1004 static char *
1005 next_property_value (char *s, size_t *length)
1006 {
1007   size_t l = 0;
1008
1009   JvAssert (s);
1010
1011   while (isspace (*s))
1012     s++;
1013
1014   if (*s == ':'
1015       || *s == '=')
1016     s++;
1017
1018   while (isspace (*s))
1019     s++;
1020
1021   // Determine the length of the property value.
1022   while (s[l] != 0
1023          && ! isspace (s[l])
1024          && s[l] != ':'
1025          && s[l] != '=')
1026     {
1027       if (s[l] == '\\'
1028           && s[l+1] != 0)
1029         l += 2;
1030       else
1031         l++;
1032     }
1033
1034   *length = l;
1035
1036   return s;
1037 }
1038
1039 static void
1040 process_gcj_properties ()
1041 {
1042   char *props = getenv("GCJ_PROPERTIES");
1043
1044   if (NULL == props)
1045     return;
1046
1047   // Later on we will write \0s into this string.  It is simplest to
1048   // just duplicate it here.
1049   props = strdup (props);
1050
1051   char *p = props;
1052   size_t length;
1053   size_t property_count = 0;
1054
1055   // Whip through props quickly in order to count the number of
1056   // property values.
1057   while (p && (p = next_property_key (p, &length)))
1058     {
1059       // Skip to the end of the key
1060       p += length;
1061
1062       p = next_property_value (p, &length);
1063       if (p)
1064         p += length;
1065       
1066       property_count++;
1067     }
1068
1069   // Allocate an array of property value/key pairs.
1070   _Jv_Environment_Properties = 
1071     (property_pair *) malloc (sizeof(property_pair) 
1072                               * (property_count + 1));
1073
1074   // Go through the properties again, initializing _Jv_Properties
1075   // along the way.
1076   p = props;
1077   property_count = 0;
1078   while (p && (p = next_property_key (p, &length)))
1079     {
1080       _Jv_Environment_Properties[property_count].key = p;
1081       _Jv_Environment_Properties[property_count].key_length = length;
1082
1083       // Skip to the end of the key
1084       p += length;
1085
1086       p = next_property_value (p, &length);
1087       
1088       _Jv_Environment_Properties[property_count].value = p;
1089       _Jv_Environment_Properties[property_count].value_length = length;
1090
1091       if (p)
1092         p += length;
1093
1094       property_count++;
1095     }
1096   memset ((void *) &_Jv_Environment_Properties[property_count], 
1097           0, sizeof (property_pair));
1098
1099   // Null terminate the strings.
1100   for (property_pair *prop = &_Jv_Environment_Properties[0];
1101        prop->key != NULL;
1102        prop++)
1103     {
1104       prop->key[prop->key_length] = 0;
1105       prop->value[prop->value_length] = 0;
1106     }
1107 }
1108 #endif // DISABLE_GETENV_PROPERTIES
1109
1110 namespace gcj
1111 {
1112   _Jv_Utf8Const *void_signature;
1113   _Jv_Utf8Const *clinit_name;
1114   _Jv_Utf8Const *init_name;
1115   _Jv_Utf8Const *finit_name;
1116   
1117   bool runtimeInitialized = false;
1118   
1119   // When true, print debugging information about class loading.
1120   bool verbose_class_flag;
1121   
1122   // When true, enable the bytecode verifier and BC-ABI type verification. 
1123   bool verifyClasses = true;
1124
1125   // Thread stack size specified by the -Xss runtime argument.
1126   size_t stack_size = 0;
1127
1128   // Start time of the VM
1129   jlong startTime = 0;
1130
1131   // Arguments passed to the VM
1132   JArray<jstring>* vmArgs;
1133
1134   // Currently loaded classes
1135   jint loadedClasses = 0;
1136
1137   // Unloaded classes
1138   jlong unloadedClasses = 0;
1139 }
1140
1141 // We accept all non-standard options accepted by Sun's java command,
1142 // for compatibility with existing application launch scripts.
1143 static jint
1144 parse_x_arg (char* option_string)
1145 {
1146   if (strlen (option_string) <= 0)
1147     return -1;
1148
1149   if (! strcmp (option_string, "int"))
1150     {
1151       // FIXME: this should cause the vm to never load shared objects
1152     }
1153   else if (! strcmp (option_string, "mixed"))
1154     {
1155       // FIXME: allow interpreted and native code
1156     }
1157   else if (! strcmp (option_string, "batch"))
1158     {
1159       // FIXME: disable background JIT'ing
1160     }
1161   else if (! strcmp (option_string, "debug"))
1162     {
1163       remoteDebug = true;
1164     }
1165   else if (! strncmp (option_string, "runjdwp:", 8))
1166     {
1167       if (strlen (option_string) > 8)
1168           jdwpOptions = &option_string[8];
1169       else
1170         {
1171           fprintf (stderr,
1172                    "libgcj: argument required for JDWP options");
1173           return -1;
1174         }
1175     }
1176   else if (! strncmp (option_string, "bootclasspath:", 14))
1177     {
1178       // FIXME: add a parse_bootclasspath_arg function
1179     }
1180   else if (! strncmp (option_string, "bootclasspath/a:", 16))
1181     {
1182     }
1183   else if (! strncmp (option_string, "bootclasspath/p:", 16))
1184     {
1185     }
1186   else if (! strcmp (option_string, "check:jni"))
1187     {
1188       // FIXME: enable strict JNI checking
1189     }
1190   else if (! strcmp (option_string, "future"))
1191     {
1192       // FIXME: enable strict class file format checks
1193     }
1194   else if (! strcmp (option_string, "noclassgc"))
1195     {
1196       // FIXME: disable garbage collection for classes
1197     }
1198   else if (! strcmp (option_string, "incgc"))
1199     {
1200       // FIXME: incremental garbage collection
1201     }
1202   else if (! strncmp (option_string, "loggc:", 6))
1203     {
1204       if (option_string[6] == '\0')
1205         {
1206           fprintf (stderr,
1207                    "libgcj: filename argument expected for loggc option\n");
1208           return -1;
1209         }
1210       // FIXME: set gc logging filename
1211     }
1212   else if (! strncmp (option_string, "ms", 2))
1213     {
1214       // FIXME: ignore this option until PR 20699 is fixed.
1215       // _Jv_SetInitialHeapSize (option_string + 2);
1216     }
1217   else if (! strncmp (option_string, "mx", 2))
1218     _Jv_SetMaximumHeapSize (option_string + 2);
1219   else if (! strcmp (option_string, "prof"))
1220     {
1221       // FIXME: enable profiling of program running in vm
1222     }
1223   else if (! strncmp (option_string, "runhprof:", 9))
1224     {
1225       // FIXME: enable specific type of vm profiling.  add a
1226       // parse_runhprof_arg function
1227     }
1228   else if (! strcmp (option_string, "rs"))
1229     {
1230       // FIXME: reduced system signal usage.  disable thread dumps,
1231       // only terminate in response to user-initiated calls,
1232       // e.g. System.exit()
1233     }
1234   else if (! strncmp (option_string, "ss", 2))
1235     {
1236       _Jv_SetStackSize (option_string + 2);
1237     }
1238   else if (! strcmp (option_string, "X:+UseAltSigs"))
1239     {
1240       // FIXME: use signals other than SIGUSR1 and SIGUSR2
1241     }
1242   else if (! strcmp (option_string, "share:off"))
1243     {
1244       // FIXME: don't share class data
1245     }
1246   else if (! strcmp (option_string, "share:auto"))
1247     {
1248       // FIXME: share class data where possible
1249     }
1250   else if (! strcmp (option_string, "share:on"))
1251     {
1252       // FIXME: fail if impossible to share class data
1253     }
1254
1255   return 0;
1256 }
1257
1258 static jint
1259 parse_verbose_args (char* option_string,
1260                     bool ignore_unrecognized)
1261 {
1262   size_t len = sizeof ("-verbose") - 1;
1263
1264   if (strlen (option_string) < len)
1265     return -1;
1266
1267   if (option_string[len] == ':'
1268       && option_string[len + 1] != '\0')
1269     {
1270       char* verbose_args = option_string + len + 1;
1271
1272       do
1273         {
1274           if (! strncmp (verbose_args,
1275                          "gc", sizeof ("gc") - 1))
1276             {
1277               if (verbose_args[sizeof ("gc") - 1] == '\0'
1278                   || verbose_args[sizeof ("gc") - 1] == ',')
1279                 {
1280                   // FIXME: we should add functions to boehm-gc that
1281                   // toggle GC_print_stats, GC_PRINT_ADDRESS_MAP and
1282                   // GC_print_back_height.
1283                   verbose_args += sizeof ("gc") - 1;
1284                 }
1285               else
1286                 {
1287                 verbose_arg_err:
1288                   fprintf (stderr, "libgcj: unknown verbose option: %s\n",
1289                            option_string);
1290                   return -1;
1291                 }
1292             }
1293           else if (! strncmp (verbose_args,
1294                               "class",
1295                               sizeof ("class") - 1))
1296             {
1297               if (verbose_args[sizeof ("class") - 1] == '\0'
1298                   || verbose_args[sizeof ("class") - 1] == ',')
1299                 {
1300                   gcj::verbose_class_flag = true;
1301                   verbose_args += sizeof ("class") - 1;
1302                 }
1303               else
1304                 goto verbose_arg_err;
1305             }
1306           else if (! strncmp (verbose_args, "jni",
1307                               sizeof ("jni") - 1))
1308             {
1309               if (verbose_args[sizeof ("jni") - 1] == '\0'
1310                   || verbose_args[sizeof ("jni") - 1] == ',')
1311                 {
1312                   // FIXME: enable JNI messages.
1313                   verbose_args += sizeof ("jni") - 1;
1314                 }
1315               else
1316                 goto verbose_arg_err;
1317             }
1318           else if (ignore_unrecognized
1319                    && verbose_args[0] == 'X')
1320             {
1321               // ignore unrecognized non-standard verbose option
1322               while (verbose_args[0] != '\0'
1323                      && verbose_args[0] != ',')
1324                 verbose_args++;
1325             }
1326           else if (verbose_args[0] == ',')
1327             {
1328               verbose_args++;
1329             }
1330           else
1331             goto verbose_arg_err;
1332
1333           if (verbose_args[0] == ',')
1334             verbose_args++;
1335         }
1336       while (verbose_args[0] != '\0');
1337     }
1338   else if (option_string[len] == 'g'
1339            && option_string[len + 1] == 'c'
1340            && option_string[len + 2] == '\0')
1341     {
1342       // FIXME: we should add functions to boehm-gc that
1343       // toggle GC_print_stats, GC_PRINT_ADDRESS_MAP and
1344       // GC_print_back_height.
1345       return 0;
1346     }
1347   else if (option_string[len] == '\0')
1348     {
1349       gcj::verbose_class_flag = true;
1350       return 0;
1351     }
1352   else
1353     {
1354       // unrecognized option beginning with -verbose
1355       return -1;
1356     }
1357   return 0;
1358 }
1359
1360 static jint
1361 parse_init_args (JvVMInitArgs* vm_args)
1362 {
1363   // if _Jv_Compiler_Properties is non-NULL then it needs to be
1364   // re-allocated dynamically.
1365   if (_Jv_Compiler_Properties)
1366     {
1367       const char** props = _Jv_Compiler_Properties;
1368       _Jv_Compiler_Properties = NULL;
1369
1370       for (int i = 0; props[i]; i++)
1371         {
1372           _Jv_Compiler_Properties = (const char**) _Jv_Realloc
1373             (_Jv_Compiler_Properties,
1374              (_Jv_Properties_Count + 1) * sizeof (const char*));
1375           _Jv_Compiler_Properties[_Jv_Properties_Count++] = props[i];
1376         }
1377     }
1378
1379   if (vm_args == NULL)
1380     return 0;
1381
1382   for (int i = 0; i < vm_args->nOptions; ++i)
1383     {
1384       char* option_string = vm_args->options[i].optionString;
1385       if (! strcmp (option_string, "vfprintf")
1386           || ! strcmp (option_string, "exit")
1387           || ! strcmp (option_string, "abort"))
1388         {
1389           // FIXME: we are required to recognize these, but for
1390           // now we don't handle them in any way.
1391           continue;
1392         }
1393       else if (! strncmp (option_string,
1394                           "-verbose", sizeof ("-verbose") - 1))
1395         {
1396           jint result = parse_verbose_args (option_string,
1397                                             vm_args->ignoreUnrecognized);
1398           if (result < 0)
1399             return result;
1400         }
1401       else if (! strncmp (option_string, "-D", 2))
1402         {
1403           _Jv_Compiler_Properties = (const char**) _Jv_Realloc
1404             (_Jv_Compiler_Properties,
1405              (_Jv_Properties_Count + 1) * sizeof (char*));
1406
1407           _Jv_Compiler_Properties[_Jv_Properties_Count++] =
1408             strdup (option_string + 2);
1409
1410           continue;
1411         }
1412       else if (vm_args->ignoreUnrecognized)
1413         {
1414           if (option_string[0] == '_')
1415             parse_x_arg (option_string + 1);
1416           else if (! strncmp (option_string, "-X", 2))
1417             parse_x_arg (option_string + 2);
1418           else
1419             {
1420             unknown_option:
1421               fprintf (stderr, "libgcj: unknown option: %s\n", option_string);
1422               return -1;
1423             }
1424         }
1425       else
1426         goto unknown_option;
1427     }
1428   return 0;
1429 }
1430
1431 jint
1432 _Jv_CreateJavaVM (JvVMInitArgs* vm_args)
1433 {
1434   using namespace gcj;
1435
1436   if (runtimeInitialized)
1437     return -1;
1438
1439   runtimeInitialized = true;
1440   startTime = _Jv_platform_gettimeofday();
1441
1442   jint result = parse_init_args (vm_args);
1443   if (result < 0)
1444     return -1;
1445
1446   PROCESS_GCJ_PROPERTIES;
1447
1448   /* Threads must be initialized before the GC, so that it inherits the
1449      signal mask.  */
1450   _Jv_InitThreads ();
1451   _Jv_InitGC ();
1452   _Jv_InitializeSyncMutex ();
1453   
1454 #ifdef INTERPRETER
1455   _Jv_InitInterpreter ();
1456 #endif  
1457
1458 #ifdef HANDLE_SEGV
1459   INIT_SEGV;
1460 #endif
1461
1462 #ifdef HANDLE_FPE
1463   INIT_FPE;
1464 #endif
1465
1466   /* Initialize Utf8 constants declared in jvm.h. */
1467   void_signature = _Jv_makeUtf8Const ("()V", 3);
1468   clinit_name = _Jv_makeUtf8Const ("<clinit>", 8);
1469   init_name = _Jv_makeUtf8Const ("<init>", 6);
1470   finit_name = _Jv_makeUtf8Const ("finit$", 6);
1471
1472   /* Initialize built-in classes to represent primitive TYPEs. */
1473   _Jv_InitPrimClass (&_Jv_byteClass,    "byte",    'B', 1);
1474   _Jv_InitPrimClass (&_Jv_shortClass,   "short",   'S', 2);
1475   _Jv_InitPrimClass (&_Jv_intClass,     "int",     'I', 4);
1476   _Jv_InitPrimClass (&_Jv_longClass,    "long",    'J', 8);
1477   _Jv_InitPrimClass (&_Jv_booleanClass, "boolean", 'Z', 1);
1478   _Jv_InitPrimClass (&_Jv_charClass,    "char",    'C', 2);
1479   _Jv_InitPrimClass (&_Jv_floatClass,   "float",   'F', 4);
1480   _Jv_InitPrimClass (&_Jv_doubleClass,  "double",  'D', 8);
1481   _Jv_InitPrimClass (&_Jv_voidClass,    "void",    'V', 0);
1482
1483   // We have to initialize this fairly early, to avoid circular class
1484   // initialization.  In particular we want to start the
1485   // initialization of ClassLoader before we start the initialization
1486   // of VMClassLoader.
1487   _Jv_InitClass (&java::lang::ClassLoader::class$);
1488
1489   // Set up the system class loader and the bootstrap class loader.
1490   gnu::gcj::runtime::ExtensionClassLoader::initialize();
1491   java::lang::VMClassLoader::initialize(JvNewStringLatin1(TOOLEXECLIBDIR));
1492
1493   _Jv_RegisterBootstrapPackages();
1494
1495   no_memory = new java::lang::OutOfMemoryError;
1496
1497 #ifdef USE_LTDL
1498   LTDL_SET_PRELOADED_SYMBOLS ();
1499 #endif
1500
1501   _Jv_platform_initialize ();
1502
1503   _Jv_JNI_Init ();
1504   _Jv_JVMTI_Init ();
1505
1506   _Jv_GCInitializeFinalizers (&::gnu::gcj::runtime::FinalizerThread::finalizerReady);
1507
1508   // Start the GC finalizer thread.  A VirtualMachineError can be
1509   // thrown by the runtime if, say, threads aren't available.
1510   try
1511     {
1512       using namespace gnu::gcj::runtime;
1513       FinalizerThread *ft = new FinalizerThread ();
1514       ft->start ();
1515     }
1516   catch (java::lang::VirtualMachineError *ignore)
1517     {
1518     }
1519
1520   runtimeInitialized = true;
1521
1522   return 0;
1523 }
1524
1525 void
1526 _Jv_RunMain (JvVMInitArgs *vm_args, jclass klass, const char *name, int argc,
1527              const char **argv, bool is_jar)
1528 {
1529 #ifndef DISABLE_MAIN_ARGS
1530   _Jv_SetArgs (argc, argv);
1531 #endif
1532
1533   java::lang::Runtime *runtime = NULL;
1534
1535   try
1536     {
1537       if (_Jv_CreateJavaVM (vm_args) < 0)
1538         {
1539           fprintf (stderr, "libgcj: couldn't create virtual machine\n");
1540           exit (1);
1541         }
1542       
1543       if (vm_args == NULL)
1544         gcj::vmArgs = JvConvertArgv(0, NULL);
1545       else
1546         {
1547           const char* vmArgs[vm_args->nOptions];
1548           const char** vmPtr = vmArgs;
1549           struct _Jv_VMOption* optionPtr = vm_args->options;
1550           for (int i = 0; i < vm_args->nOptions; ++i)
1551             *vmPtr++ = (*optionPtr++).optionString;
1552           gcj::vmArgs = JvConvertArgv(vm_args->nOptions, vmArgs);
1553         }
1554
1555       // Get the Runtime here.  We want to initialize it before searching
1556       // for `main'; that way it will be set up if `main' is a JNI method.
1557       runtime = java::lang::Runtime::getRuntime ();
1558
1559 #ifdef DISABLE_MAIN_ARGS
1560       arg_vec = JvConvertArgv (0, 0);
1561 #else      
1562       arg_vec = JvConvertArgv (argc - 1, argv + 1);
1563 #endif
1564
1565       using namespace gnu::java::lang;
1566       if (klass)
1567         main_thread = new MainThread (klass, arg_vec);
1568       else
1569         main_thread = new MainThread (JvNewStringUTF (name),
1570                                       arg_vec, is_jar);
1571       _Jv_AttachCurrentThread (main_thread);
1572
1573       // Start JDWP
1574       if (remoteDebug)
1575         {
1576           using namespace gnu::classpath::jdwp;
1577           VMVirtualMachine::initialize ();
1578           Jdwp *jdwp = new Jdwp ();
1579           jdwp->setDaemon (true);
1580           jdwp->configure (JvNewStringLatin1 (jdwpOptions));
1581           jdwp->start ();
1582
1583           // Wait for JDWP to initialize and start
1584           jdwp->join ();
1585         }
1586
1587       // Send VMInit
1588       if (JVMTI_REQUESTED_EVENT (VMInit))
1589         _Jv_JVMTI_PostEvent (JVMTI_EVENT_VM_INIT, main_thread);
1590     }
1591   catch (java::lang::Throwable *t)
1592     {
1593       java::lang::System::err->println (JvNewStringLatin1 
1594         ("Exception during runtime initialization"));
1595       t->printStackTrace();
1596       if (runtime)
1597         java::lang::Runtime::exitNoChecksAccessor (1);
1598       // In case the runtime creation failed.
1599       ::exit (1);
1600     }
1601
1602   _Jv_ThreadRun (main_thread);
1603
1604   // Send VMDeath
1605   if (JVMTI_REQUESTED_EVENT (VMDeath))
1606     {
1607       java::lang::Thread *thread = java::lang::Thread::currentThread ();
1608       JNIEnv *jni_env = _Jv_GetCurrentJNIEnv ();
1609       _Jv_JVMTI_PostEvent (JVMTI_EVENT_VM_DEATH, thread, jni_env);
1610     }
1611
1612   // If we got here then something went wrong, as MainThread is not
1613   // supposed to terminate.
1614   ::exit (1);
1615 }
1616
1617 void
1618 _Jv_RunMain (jclass klass, const char *name, int argc, const char **argv, 
1619              bool is_jar)
1620 {
1621   _Jv_RunMain (NULL, klass, name, argc, argv, is_jar);
1622 }
1623
1624 void
1625 JvRunMain (jclass klass, int argc, const char **argv)
1626 {
1627   _Jv_RunMain (klass, NULL, argc, argv, false);
1628 }
1629
1630 void
1631 JvRunMainName (const char *name, int argc, const char **argv)
1632 {
1633   _Jv_RunMain (NULL, name, argc, argv, false);
1634 }
1635
1636 \f
1637
1638 // Parse a string and return a heap size.
1639 static size_t
1640 parse_memory_size (const char *spec)
1641 {
1642   char *end;
1643   unsigned long val = strtoul (spec, &end, 10);
1644   if (*end == 'k' || *end == 'K')
1645     val *= 1024;
1646   else if (*end == 'm' || *end == 'M')
1647     val *= 1048576;
1648   return (size_t) val;
1649 }
1650
1651 // Set the initial heap size.  This might be ignored by the GC layer.
1652 // This must be called before _Jv_RunMain.
1653 void
1654 _Jv_SetInitialHeapSize (const char *arg)
1655 {
1656   size_t size = parse_memory_size (arg);
1657   _Jv_GCSetInitialHeapSize (size);
1658 }
1659
1660 // Set the maximum heap size.  This might be ignored by the GC layer.
1661 // This must be called before _Jv_RunMain.
1662 void
1663 _Jv_SetMaximumHeapSize (const char *arg)
1664 {
1665   size_t size = parse_memory_size (arg);
1666   _Jv_GCSetMaximumHeapSize (size);
1667 }
1668
1669 void
1670 _Jv_SetStackSize (const char *arg)
1671 {
1672   size_t size = parse_memory_size (arg);
1673   gcj::stack_size = size;
1674 }
1675
1676 void *
1677 _Jv_Malloc (jsize size)
1678 {
1679   if (__builtin_expect (size == 0, false))
1680     size = 1;
1681   void *ptr = malloc ((size_t) size);
1682   if (__builtin_expect (ptr == NULL, false))
1683     throw no_memory;
1684   return ptr;
1685 }
1686
1687 void *
1688 _Jv_Realloc (void *ptr, jsize size)
1689 {
1690   if (__builtin_expect (size == 0, false))
1691     size = 1;
1692   ptr = realloc (ptr, (size_t) size);
1693   if (__builtin_expect (ptr == NULL, false))
1694     throw no_memory;
1695   return ptr;
1696 }
1697
1698 void *
1699 _Jv_MallocUnchecked (jsize size)
1700 {
1701   if (__builtin_expect (size == 0, false))
1702     size = 1;
1703   return malloc ((size_t) size);
1704 }
1705
1706 void
1707 _Jv_Free (void* ptr)
1708 {
1709   return free (ptr);
1710 }
1711
1712 \f
1713
1714 // In theory, these routines can be #ifdef'd away on machines which
1715 // support divide overflow signals.  However, we never know if some
1716 // code might have been compiled with "-fuse-divide-subroutine", so we
1717 // always include them in libgcj.
1718
1719 jint
1720 _Jv_divI (jint dividend, jint divisor)
1721 {
1722   if (__builtin_expect (divisor == 0, false))
1723     {
1724       java::lang::ArithmeticException *arithexception 
1725         = new java::lang::ArithmeticException (JvNewStringLatin1 ("/ by zero"));      
1726       throw arithexception;
1727     }
1728   
1729   if (dividend == (jint) 0x80000000L && divisor == -1)
1730     return dividend;
1731
1732   return dividend / divisor;
1733 }
1734
1735 jint
1736 _Jv_remI (jint dividend, jint divisor)
1737 {
1738   if (__builtin_expect (divisor == 0, false))
1739     {
1740       java::lang::ArithmeticException *arithexception 
1741         = new java::lang::ArithmeticException (JvNewStringLatin1 ("/ by zero"));      
1742       throw arithexception;
1743     }
1744   
1745   if (dividend == (jint) 0x80000000L && divisor == -1)
1746     return 0;
1747   
1748   return dividend % divisor;
1749 }
1750
1751 jlong
1752 _Jv_divJ (jlong dividend, jlong divisor)
1753 {
1754   if (__builtin_expect (divisor == 0, false))
1755     {
1756       java::lang::ArithmeticException *arithexception 
1757         = new java::lang::ArithmeticException (JvNewStringLatin1 ("/ by zero"));      
1758       throw arithexception;
1759     }
1760
1761   if (dividend == (jlong) 0x8000000000000000LL && divisor == -1)
1762     return dividend;
1763
1764   return dividend / divisor;
1765 }
1766
1767 jlong
1768 _Jv_remJ (jlong dividend, jlong divisor)
1769 {
1770   if (__builtin_expect (divisor == 0, false))
1771     {
1772       java::lang::ArithmeticException *arithexception 
1773         = new java::lang::ArithmeticException (JvNewStringLatin1 ("/ by zero"));      
1774       throw arithexception;
1775     }
1776
1777   if (dividend == (jlong) 0x8000000000000000LL && divisor == -1)
1778     return 0;
1779
1780   return dividend % divisor;
1781 }
1782
1783 \f
1784
1785 // Return true if SELF_KLASS can access a field or method in
1786 // OTHER_KLASS.  The field or method's access flags are specified in
1787 // FLAGS.
1788 jboolean
1789 _Jv_CheckAccess (jclass self_klass, jclass other_klass, jint flags)
1790 {
1791   using namespace java::lang::reflect;
1792   return ((self_klass == other_klass)
1793           || ((flags & Modifier::PUBLIC) != 0)
1794           || (((flags & Modifier::PROTECTED) != 0)
1795               && _Jv_IsAssignableFromSlow (self_klass, other_klass))
1796           || (((flags & Modifier::PRIVATE) == 0)
1797               && _Jv_ClassNameSamePackage (self_klass->name,
1798                                            other_klass->name)));
1799 }
1800
1801 // Prepend GCJ_VERSIONED_LIBDIR to a module search path stored in a C
1802 // char array, if the path is not already prefixed by
1803 // GCJ_VERSIONED_LIBDIR.  Return a newly JvMalloc'd char buffer.  The
1804 // result should be freed using JvFree.
1805 char*
1806 _Jv_PrependVersionedLibdir (char* libpath)
1807 {
1808   char* retval = 0;
1809
1810   if (libpath && libpath[0] != '\0')
1811     {
1812       if (! strncmp (libpath,
1813                      GCJ_VERSIONED_LIBDIR,
1814                      sizeof (GCJ_VERSIONED_LIBDIR) - 1))
1815         {
1816           // LD_LIBRARY_PATH is already prefixed with
1817           // GCJ_VERSIONED_LIBDIR.
1818           retval = (char*) _Jv_Malloc (strlen (libpath) + 1);
1819           strcpy (retval, libpath);
1820         }
1821       else
1822         {
1823           // LD_LIBRARY_PATH is not prefixed with
1824           // GCJ_VERSIONED_LIBDIR.
1825           char path_sep[2];
1826           path_sep[0] = (char) _Jv_platform_path_separator;
1827           path_sep[1] = '\0';
1828           jsize total = ((sizeof (GCJ_VERSIONED_LIBDIR) - 1)
1829                          + 1 /* path separator */ + strlen (libpath) + 1);
1830           retval = (char*) _Jv_Malloc (total);
1831           strcpy (retval, GCJ_VERSIONED_LIBDIR);
1832           strcat (retval, path_sep);
1833           strcat (retval, libpath);
1834         }
1835     }
1836   else
1837     {
1838       // LD_LIBRARY_PATH was not specified or is empty.
1839       retval = (char*) _Jv_Malloc (sizeof (GCJ_VERSIONED_LIBDIR));
1840       strcpy (retval, GCJ_VERSIONED_LIBDIR);
1841     }
1842
1843   return retval;
1844 }