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