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 }