src/native/vm/sun/jvm.c

   1 /* src/native/vm/sun/jvm.c - HotSpot JVM interface functions
   2
   3    Copyright (C) 2007, 2008
   4    CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
   5
   6    This file is part of CACAO.
   7
   8    This program is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU General Public License as
  10    published by the Free Software Foundation; either version 2, or (at
  11    your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23 */
  24
  25
  26 #include "config.h"
  27
  28 #include <assert.h>
  29 #include <errno.h>
  30 #include <ltdl.h>
  31 #include <stdint.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <unistd.h>
  35
  36 #if defined(HAVE_SYS_IOCTL_H)
  37 #define BSD_COMP /* Get FIONREAD on Solaris2 */
  38 #include <sys/ioctl.h>
  39 #endif
  40
  41 #include <sys/socket.h>
  42 #include <sys/stat.h>
  43 #include <sys/types.h>
  44
  45 #include "vm/types.h"
  46
  47 #include "mm/memory.h"
  48
  49 #include "native/jni.h"
  50 #include "native/llni.h"
  51 #include "native/native.h"
  52
  53 #include "native/include/java_lang_AssertionStatusDirectives.h"
  54 #include "native/include/java_lang_String.h"            /* required by j.l.CL */
  55 #include "native/include/java_nio_ByteBuffer.h"         /* required by j.l.CL */
  56 #include "native/include/java_lang_ClassLoader.h"        /* required by j.l.C */
  57 #include "native/include/java_lang_StackTraceElement.h"
  58 #include "native/include/java_lang_Throwable.h"
  59 #include "native/include/java_security_ProtectionDomain.h"
  60
  61 #if defined(ENABLE_ANNOTATIONS)
  62 #include "native/include/sun_reflect_ConstantPool.h"
  63 #endif
  64
  65 #include "native/vm/java_lang_Class.h"
  66 #include "native/vm/java_lang_reflect_Constructor.h"
  67 #include "native/vm/java_lang_reflect_Method.h"
  68 #include "native/vm/reflect.h"
  69
  70 #include "threads/lock-common.h"
  71 #include "threads/threadlist.h"
  72 #include "threads/threads-common.h"
  73
  74 #include "toolbox/logging.h"
  75 #include "toolbox/list.h"
  76
  77 #include "vm/array.h"
  78
  79 #if defined(ENABLE_ASSERTION)
  80 #include "vm/assertion.h"
  81 #endif
  82
  83 #include "vm/builtin.h"
  84 #include "vm/exceptions.h"
  85 #include "vm/global.h"
  86 #include "vm/initialize.h"
  87 #include "vm/package.h"
  88 #include "vm/primitive.h"
  89 #include "vm/properties.h"
  90 #include "vm/resolve.h"
  91 #include "vm/signallocal.h"
  92 #include "vm/stringlocal.h"
  93 #include "vm/vm.h"
  94
  95 #include "vm/jit/stacktrace.h"
  96
  97 #include "vmcore/classcache.h"
  98 #include "vmcore/options.h"
  99 #include "vmcore/system.h"
 100
 101
 102 /* debugging macros ***********************************************************/
 103
 104 #if !defined(NDEBUG)
 105
 106 # define TRACEJVMCALLS(x)                                                                               \
 107     do {                                                                                                                \
 108         if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) {    \
 109             log_println x;                                                                              \
 110         }                                                                                                               \
 111     } while (0)
 112
 113 # define TRACEJVMCALLSVERBOSE(x)                                \
 114     do {                                                                                \
 115         if (opt_TraceJVMCallsVerbose) {                 \
 116             log_println x;                                              \
 117         }                                                                               \
 118     } while (0)
 119
 120 # define PRINTJVMWARNINGS(x)
 121 /*     do { \ */
 122 /*         if (opt_PrintJVMWarnings) { \ */
 123 /*             log_println x; \ */
 124 /*         } \ */
 125 /*     } while (0) */
 126
 127 #else
 128
 129 # define TRACEJVMCALLS(x)
 130 # define TRACEJVMCALLSVERBOSE(x)
 131 # define PRINTJVMWARNINGS(x)
 132
 133 #endif
 134
 135
 136 typedef struct {
 137     /* Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx */
 138     unsigned int jvm_version;   /* Consists of major, minor, micro (n.n.n) */
 139                                 /* and build number (xx) */
 140     unsigned int update_version : 8;         /* Update release version (uu) */
 141     unsigned int special_update_version : 8; /* Special update release version (c) */
 142     unsigned int reserved1 : 16;
 143     unsigned int reserved2;
 144
 145     /* The following bits represents JVM supports that JDK has dependency on.
 146      * JDK can use these bits to determine which JVM version
 147      * and support it has to maintain runtime compatibility.
 148      *
 149      * When a new bit is added in a minor or update release, make sure
 150      * the new bit is also added in the main/baseline.
 151      */
 152     unsigned int is_attachable : 1;
 153     unsigned int : 31;
 154     unsigned int : 32;
 155     unsigned int : 32;
 156 } jvm_version_info;
 157
 158
 159 /*
 160  * A structure used to a capture exception table entry in a Java method.
 161  */
 162 typedef struct {
 163     jint start_pc;
 164     jint end_pc;
 165     jint handler_pc;
 166     jint catchType;
 167 } JVM_ExceptionTableEntryType;
 168
 169
 170 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
 171 {
 172         if ((intptr_t) count <= 0)
 173                 return -1;
 174
 175         return vsnprintf(str, count, fmt, args);
 176 }
 177
 178
 179 int jio_snprintf(char *str, size_t count, const char *fmt, ...)
 180 {
 181         va_list ap;
 182         int     len;
 183
 184         va_start(ap, fmt);
 185         len = jio_vsnprintf(str, count, fmt, ap);
 186         va_end(ap);
 187
 188         return len;
 189 }
 190
 191
 192 int jio_fprintf(FILE* f, const char *fmt, ...)
 193 {
 194         log_println("jio_fprintf: IMPLEMENT ME!");
 195
 196         return 0;
 197 }
 198
 199
 200 int jio_vfprintf(FILE* f, const char *fmt, va_list args)
 201 {
 202         log_println("jio_vfprintf: IMPLEMENT ME!");
 203
 204         return 0;
 205 }
 206
 207
 208 int jio_printf(const char *fmt, ...)
 209 {
 210         log_println("jio_printf: IMPLEMENT ME!");
 211
 212         return 0;
 213 }
 214
 215
 216 /* JVM_GetInterfaceVersion */
 217
 218 jint JVM_GetInterfaceVersion()
 219 {
 220         /* This is defined in hotspot/src/share/vm/prims/jvm.h */
 221
 222 #define JVM_INTERFACE_VERSION 4
 223
 224         return JVM_INTERFACE_VERSION;
 225 }
 226
 227
 228 /* JVM_CurrentTimeMillis */
 229
 230 jlong JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)
 231 {
 232         TRACEJVMCALLS(("JVM_CurrentTimeMillis(env=%p, ignored=%p)", env, ignored));
 233
 234         return (jlong) builtin_currenttimemillis();
 235 }
 236
 237
 238 /* JVM_NanoTime */
 239
 240 jlong JVM_NanoTime(JNIEnv *env, jclass ignored)
 241 {
 242         TRACEJVMCALLS(("JVM_NanoTime(env=%p, ignored=%p)", env, ignored));
 243
 244         return (jlong) builtin_nanotime();
 245 }
 246
 247
 248 /* JVM_ArrayCopy */
 249
 250 void JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos, jobject dst, jint dst_pos, jint length)
 251 {
 252         java_handle_t *s;
 253         java_handle_t *d;
 254
 255         s = (java_handle_t *) src;
 256         d = (java_handle_t *) dst;
 257
 258         TRACEJVMCALLSVERBOSE(("JVM_ArrayCopy(env=%p, ignored=%p, src=%p, src_pos=%d, dst=%p, dst_pos=%d, length=%d)", env, ignored, src, src_pos, dst, dst_pos, length));
 259
 260         builtin_arraycopy(s, src_pos, d, dst_pos, length);
 261 }
 262
 263
 264 /* JVM_InitProperties */
 265
 266 jobject JVM_InitProperties(JNIEnv *env, jobject properties)
 267 {
 268         java_handle_t *h;
 269
 270         TRACEJVMCALLS(("JVM_InitProperties(env=%p, properties=%p)", env, properties));
 271
 272         h = (java_handle_t *) properties;
 273
 274         properties_system_add_all(h);
 275
 276         return properties;
 277 }
 278
 279
 280 /* JVM_Exit */
 281
 282 void JVM_Exit(jint code)
 283 {
 284         log_println("JVM_Exit: IMPLEMENT ME!");
 285 }
 286
 287
 288 /* JVM_Halt */
 289
 290 void JVM_Halt(jint code)
 291 {
 292         TRACEJVMCALLS(("JVM_Halt(code=%d)", code));
 293
 294 /*      vm_exit(code); */
 295         vm_shutdown(code);
 296 }
 297
 298
 299 /* JVM_OnExit(void (*func)) */
 300
 301 void JVM_OnExit(void (*func)(void))
 302 {
 303         log_println("JVM_OnExit(void (*func): IMPLEMENT ME!");
 304 }
 305
 306
 307 /* JVM_GC */
 308
 309 void JVM_GC(void)
 310 {
 311         TRACEJVMCALLS(("JVM_GC()"));
 312
 313         gc_call();
 314 }
 315
 316
 317 /* JVM_MaxObjectInspectionAge */
 318
 319 jlong JVM_MaxObjectInspectionAge(void)
 320 {
 321         log_println("JVM_MaxObjectInspectionAge: IMPLEMENT ME!");
 322
 323         return 0;
 324 }
 325
 326
 327 /* JVM_TraceInstructions */
 328
 329 void JVM_TraceInstructions(jboolean on)
 330 {
 331         log_println("JVM_TraceInstructions: IMPLEMENT ME!");
 332 }
 333
 334
 335 /* JVM_TraceMethodCalls */
 336
 337 void JVM_TraceMethodCalls(jboolean on)
 338 {
 339         log_println("JVM_TraceMethodCalls: IMPLEMENT ME!");
 340 }
 341
 342
 343 /* JVM_TotalMemory */
 344
 345 jlong JVM_TotalMemory(void)
 346 {
 347         TRACEJVMCALLS(("JVM_TotalMemory()"));
 348
 349         return gc_get_heap_size();
 350 }
 351
 352
 353 /* JVM_FreeMemory */
 354
 355 jlong JVM_FreeMemory(void)
 356 {
 357         TRACEJVMCALLS(("JVM_FreeMemory()"));
 358
 359         return gc_get_free_bytes();
 360 }
 361
 362
 363 /* JVM_MaxMemory */
 364
 365 jlong JVM_MaxMemory(void)
 366 {
 367         TRACEJVMCALLS(("JVM_MaxMemory()"));
 368
 369         return gc_get_max_heap_size();
 370 }
 371
 372
 373 /* JVM_ActiveProcessorCount */
 374
 375 jint JVM_ActiveProcessorCount(void)
 376 {
 377         TRACEJVMCALLS(("JVM_ActiveProcessorCount()"));
 378
 379         return system_processors_online();
 380 }
 381
 382
 383 /* JVM_FillInStackTrace */
 384
 385 void JVM_FillInStackTrace(JNIEnv *env, jobject receiver)
 386 {
 387         java_lang_Throwable     *o;
 388         java_handle_bytearray_t *ba;
 389
 390         TRACEJVMCALLS(("JVM_FillInStackTrace(env=%p, receiver=%p)", env, receiver));
 391
 392         o = (java_lang_Throwable *) receiver;
 393
 394         ba = stacktrace_get_current();
 395
 396         if (ba == NULL)
 397                 return;
 398
 399         LLNI_field_set_ref(o, backtrace, (java_lang_Object *) ba);
 400 }
 401
 402
 403 /* JVM_PrintStackTrace */
 404
 405 void JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable)
 406 {
 407         log_println("JVM_PrintStackTrace: IMPLEMENT ME!");
 408 }
 409
 410
 411 /* JVM_GetStackTraceDepth */
 412
 413 jint JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable)
 414 {
 415         java_lang_Throwable     *to;
 416         java_lang_Object        *o;
 417         java_handle_bytearray_t *ba;
 418         stacktrace_t            *st;
 419         int32_t                  depth;
 420
 421         TRACEJVMCALLS(("JVM_GetStackTraceDepth(env=%p, throwable=%p)", env, throwable));
 422
 423         if (throwable == NULL) {
 424                 exceptions_throw_nullpointerexception();
 425                 return 0;
 426         }
 427
 428         to = (java_lang_Throwable *) throwable;
 429
 430         LLNI_field_get_ref(to, backtrace, o);
 431
 432         ba = (java_handle_bytearray_t *) o;
 433
 434         if (ba == NULL)
 435                 return 0;
 436
 437         /* We need a critical section here as the stacktrace structure is
 438            mapped onto a Java byte-array. */
 439
 440         LLNI_CRITICAL_START;
 441
 442         st = (stacktrace_t *) LLNI_array_data(ba);
 443
 444         depth = st->length;
 445
 446         LLNI_CRITICAL_END;
 447
 448         return depth;
 449 }
 450
 451
 452 /* JVM_GetStackTraceElement */
 453
 454 jobject JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index)
 455 {
 456         java_lang_Throwable         *to;
 457         java_lang_Object            *o;
 458         java_handle_bytearray_t     *ba;
 459         stacktrace_t                *st;
 460         stacktrace_entry_t          *ste;
 461         codeinfo                    *code;
 462         methodinfo                  *m;
 463         classinfo                   *c;
 464         java_lang_StackTraceElement *steo;
 465         java_lang_String            *declaringclass;
 466         java_lang_String            *filename;
 467         int32_t                      linenumber;
 468
 469         TRACEJVMCALLS(("JVM_GetStackTraceElement(env=%p, throwable=%p, index=%d)", env, throwable, index));
 470
 471         to = (java_lang_Throwable *) throwable;
 472
 473         LLNI_field_get_ref(to, backtrace, o);
 474
 475         ba = (java_handle_bytearray_t *) o;
 476
 477         /* FIXME critical section */
 478
 479         st = (stacktrace_t *) LLNI_array_data(ba);
 480
 481         if ((index < 0) || (index >= st->length)) {
 482                 /* XXX This should be an IndexOutOfBoundsException (check this
 483                    again). */
 484
 485                 exceptions_throw_arrayindexoutofboundsexception();
 486                 return NULL;
 487         }
 488
 489         /* Get the stacktrace entry. */
 490
 491         ste = &(st->entries[index]);
 492
 493         /* Get the codeinfo, methodinfo and classinfo. */
 494
 495         code = ste->code;
 496         m    = code->m;
 497         c    = m->class;
 498
 499         /* allocate a new StackTraceElement */
 500
 501         steo = (java_lang_StackTraceElement *)
 502                 builtin_new(class_java_lang_StackTraceElement);
 503
 504         if (steo == NULL)
 505                 return NULL;
 506
 507         /* get filename */
 508
 509         if (!(m->flags & ACC_NATIVE)) {
 510                 if (c->sourcefile != NULL)
 511                         filename = (java_lang_String *) javastring_new(c->sourcefile);
 512                 else
 513                         filename = NULL;
 514         }
 515         else
 516                 filename = NULL;
 517
 518         /* get line number */
 519
 520         if (m->flags & ACC_NATIVE) {
 521                 linenumber = -2;
 522         }
 523         else {
 524                 /* FIXME The linenumbertable_linenumber_for_pc could change
 525                    the methodinfo pointer when hitting an inlined method. */
 526
 527                 linenumber = linenumbertable_linenumber_for_pc(&m, code, ste->pc);
 528                 linenumber = (linenumber == 0) ? -1 : linenumber;
 529         }
 530
 531         /* get declaring class name */
 532
 533         declaringclass = _Jv_java_lang_Class_getName(LLNI_classinfo_wrap(c));
 534
 535         /* fill the java.lang.StackTraceElement element */
 536
 537         /* FIXME critical section */
 538
 539         steo->declaringClass = declaringclass;
 540         steo->methodName     = (java_lang_String *) javastring_new(m->name);
 541         steo->fileName       = filename;
 542         steo->lineNumber     = linenumber;
 543
 544         return (jobject) steo;
 545 }
 546
 547
 548 /* JVM_IHashCode */
 549
 550 jint JVM_IHashCode(JNIEnv* env, jobject handle)
 551 {
 552         TRACEJVMCALLS(("JVM_IHashCode(env=%p, jobject=%p)", env, handle));
 553
 554         return (jint) ((ptrint) handle);
 555 }
 556
 557
 558 /* JVM_MonitorWait */
 559
 560 void JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms)
 561 {
 562 #if defined(ENABLE_THREADS)
 563         java_handle_t *o;
 564 #endif
 565
 566         TRACEJVMCALLS(("JVM_MonitorWait(env=%p, handle=%p, ms=%ld)", env, handle, ms));
 567     if (ms < 0) {
 568 /*              exceptions_throw_illegalargumentexception("argument out of range"); */
 569                 exceptions_throw_illegalargumentexception();
 570                 return;
 571         }
 572
 573 #if defined(ENABLE_THREADS)
 574         o = (java_handle_t *) handle;
 575
 576         lock_wait_for_object(o, ms, 0);
 577 #endif
 578 }
 579
 580
 581 /* JVM_MonitorNotify */
 582
 583 void JVM_MonitorNotify(JNIEnv* env, jobject handle)
 584 {
 585 #if defined(ENABLE_THREADS)
 586         java_handle_t *o;
 587 #endif
 588
 589         TRACEJVMCALLS(("JVM_MonitorNotify(env=%p, handle=%p)", env, handle));
 590
 591 #if defined(ENABLE_THREADS)
 592         o = (java_handle_t *) handle;
 593
 594         lock_notify_object(o);
 595 #endif
 596 }
 597
 598
 599 /* JVM_MonitorNotifyAll */
 600
 601 void JVM_MonitorNotifyAll(JNIEnv* env, jobject handle)
 602 {
 603 #if defined(ENABLE_THREADS)
 604         java_handle_t *o;
 605 #endif
 606
 607         TRACEJVMCALLS(("JVM_MonitorNotifyAll(env=%p, handle=%p)", env, handle));
 608
 609 #if defined(ENABLE_THREADS)
 610         o = (java_handle_t *) handle;
 611
 612         lock_notify_all_object(o);
 613 #endif
 614 }
 615
 616
 617 /* JVM_Clone */
 618
 619 jobject JVM_Clone(JNIEnv* env, jobject handle)
 620 {
 621         TRACEJVMCALLS(("JVM_Clone(env=%p, handle=%p)", env, handle));
 622
 623         return (jobject) builtin_clone(env, (java_handle_t *) handle);
 624 }
 625
 626
 627 /* JVM_InitializeCompiler  */
 628
 629 void JVM_InitializeCompiler (JNIEnv *env, jclass compCls)
 630 {
 631         log_println("JVM_InitializeCompiler : IMPLEMENT ME!");
 632 }
 633
 634
 635 /* JVM_IsSilentCompiler */
 636
 637 jboolean JVM_IsSilentCompiler(JNIEnv *env, jclass compCls)
 638 {
 639         log_println("JVM_IsSilentCompiler: IMPLEMENT ME!");
 640
 641         return 0;
 642 }
 643
 644
 645 /* JVM_CompileClass */
 646
 647 jboolean JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls)
 648 {
 649         log_println("JVM_CompileClass: IMPLEMENT ME!");
 650
 651         return 0;
 652 }
 653
 654
 655 /* JVM_CompileClasses */
 656
 657 jboolean JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname)
 658 {
 659         log_println("JVM_CompileClasses: IMPLEMENT ME!");
 660
 661         return 0;
 662 }
 663
 664
 665 /* JVM_CompilerCommand */
 666
 667 jobject JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg)
 668 {
 669         log_println("JVM_CompilerCommand: IMPLEMENT ME!");
 670
 671         return 0;
 672 }
 673
 674
 675 /* JVM_EnableCompiler */
 676
 677 void JVM_EnableCompiler(JNIEnv *env, jclass compCls)
 678 {
 679         TRACEJVMCALLS(("JVM_EnableCompiler(env=%p, compCls=%p)", env, compCls));
 680         PRINTJVMWARNINGS(("JVM_EnableCompiler not supported"));
 681 }
 682
 683
 684 /* JVM_DisableCompiler */
 685
 686 void JVM_DisableCompiler(JNIEnv *env, jclass compCls)
 687 {
 688         TRACEJVMCALLS(("JVM_DisableCompiler(env=%p, compCls=%p)", env, compCls));
 689         PRINTJVMWARNINGS(("JVM_DisableCompiler not supported"));
 690 }
 691
 692
 693 /* JVM_GetLastErrorString */
 694
 695 jint JVM_GetLastErrorString(char *buf, int len)
 696 {
 697         const char *s;
 698         int n;
 699
 700     if (errno == 0) {
 701                 return 0;
 702     }
 703         else {
 704                 s = strerror(errno);
 705                 n = strlen(s);
 706
 707                 if (n >= len)
 708                         n = len - 1;
 709
 710                 strncpy(buf, s, n);
 711
 712                 buf[n] = '\0';
 713
 714                 return n;
 715     }
 716 }
 717
 718
 719 /* JVM_NativePath */
 720
 721 char *JVM_NativePath(char *path)
 722 {
 723         TRACEJVMCALLS(("JVM_NativePath(path=%s)", path));
 724
 725         /* XXX is this correct? */
 726
 727         return path;
 728 }
 729
 730
 731 /* JVM_GetCallerClass */
 732
 733 jclass JVM_GetCallerClass(JNIEnv* env, int depth)
 734 {
 735         java_handle_objectarray_t *oa;
 736
 737         TRACEJVMCALLS(("JVM_GetCallerClass(env=%p, depth=%d)", env, depth));
 738
 739         oa = stacktrace_getClassContext();
 740
 741         if (oa == NULL)
 742                 return NULL;
 743
 744         if (oa->header.size < depth)
 745                 return NULL;
 746
 747         return (jclass) oa->data[depth - 1];
 748
 749 }
 750
 751
 752 /* JVM_FindPrimitiveClass */
 753
 754 jclass JVM_FindPrimitiveClass(JNIEnv* env, const char* s)
 755 {
 756         classinfo *c;
 757         utf       *u;
 758
 759         TRACEJVMCALLS(("JVM_FindPrimitiveClass(env=%p, s=%s)", env, s));
 760
 761         u = utf_new_char(s);
 762         c = primitive_class_get_by_name(u);
 763
 764         return (jclass) LLNI_classinfo_wrap(c);
 765 }
 766
 767
 768 /* JVM_ResolveClass */
 769
 770 void JVM_ResolveClass(JNIEnv* env, jclass cls)
 771 {
 772         TRACEJVMCALLS(("JVM_ResolveClass(env=%p, cls=%p)", env, cls));
 773         PRINTJVMWARNINGS(("JVM_ResolveClass not implemented"));
 774 }
 775
 776
 777 /* JVM_FindClassFromClassLoader */
 778
 779 jclass JVM_FindClassFromClassLoader(JNIEnv* env, const char* name, jboolean init, jobject loader, jboolean throwError)
 780 {
 781         classinfo   *c;
 782         utf         *u;
 783         classloader *cl;
 784
 785         TRACEJVMCALLS(("JVM_FindClassFromClassLoader(name=%s, init=%d, loader=%p, throwError=%d)", name, init, loader, throwError));
 786
 787         u  = utf_new_char(name);
 788         cl = loader_hashtable_classloader_add((java_handle_t *) loader);
 789
 790         c = load_class_from_classloader(u, cl);
 791
 792         if (c == NULL)
 793                 return NULL;
 794
 795         if (init)
 796                 if (!(c->state & CLASS_INITIALIZED))
 797                         if (!initialize_class(c))
 798                                 return NULL;
 799
 800         return (jclass) LLNI_classinfo_wrap(c);
 801 }
 802
 803
 804 /* JVM_FindClassFromClass */
 805
 806 jclass JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init, jclass from)
 807 {
 808         log_println("JVM_FindClassFromClass: IMPLEMENT ME!");
 809
 810         return NULL;
 811 }
 812
 813
 814 /* JVM_DefineClass */
 815
 816 jclass JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)
 817 {
 818         log_println("JVM_DefineClass: IMPLEMENT ME!");
 819
 820         return NULL;
 821 }
 822
 823
 824 /* JVM_DefineClassWithSource */
 825
 826 jclass JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)
 827 {
 828         classinfo   *c;
 829         utf         *u;
 830         classloader *cl;
 831
 832         TRACEJVMCALLS(("JVM_DefineClassWithSource(env=%p, name=%s, loader=%p, buf=%p, len=%d, pd=%p, source=%s)", env, name, loader, buf, len, pd, source));
 833
 834         if (name != NULL)
 835                 u = utf_new_char(name);
 836         else
 837                 u = NULL;
 838
 839         cl = loader_hashtable_classloader_add((java_handle_t *) loader);
 840
 841         /* XXX do something with source */
 842
 843         c = class_define(u, cl, len, (uint8_t *) buf, (java_handle_t *) pd);
 844
 845         return (jclass) LLNI_classinfo_wrap(c);
 846 }
 847
 848
 849 /* JVM_FindLoadedClass */
 850
 851 jclass JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name)
 852 {
 853         classloader *cl;
 854         utf         *u;
 855         classinfo   *c;
 856
 857         TRACEJVMCALLS(("JVM_FindLoadedClass(env=%p, loader=%p, name=%p)", env, loader, name));
 858
 859         cl = loader_hashtable_classloader_add((java_handle_t *) loader);
 860
 861         u = javastring_toutf((java_handle_t *) name, true);
 862         c = classcache_lookup(cl, u);
 863
 864         return (jclass) LLNI_classinfo_wrap(c);
 865 }
 866
 867
 868 /* JVM_GetClassName */
 869
 870 jstring JVM_GetClassName(JNIEnv *env, jclass cls)
 871 {
 872         TRACEJVMCALLS(("JVM_GetClassName(env=%p, cls=%p)", env, cls));
 873
 874         return (jstring) _Jv_java_lang_Class_getName((java_lang_Class *) cls);
 875 }
 876
 877
 878 /* JVM_GetClassInterfaces */
 879
 880 jobjectArray JVM_GetClassInterfaces(JNIEnv *env, jclass cls)
 881 {
 882         classinfo                 *c;
 883         java_handle_objectarray_t *oa;
 884
 885         TRACEJVMCALLS(("JVM_GetClassInterfaces(env=%p, cls=%p)", env, cls));
 886
 887         c = LLNI_classinfo_unwrap(cls);
 888
 889         oa = class_get_interfaces(c);
 890
 891         return (jobjectArray) oa;
 892 }
 893
 894
 895 /* JVM_GetClassLoader */
 896
 897 jobject JVM_GetClassLoader(JNIEnv *env, jclass cls)
 898 {
 899         classinfo   *c;
 900         classloader *cl;
 901
 902         TRACEJVMCALLS(("JVM_GetClassLoader(env=%p, cls=%p)", env, cls));
 903
 904         c  = LLNI_classinfo_unwrap(cls);
 905         cl = class_get_classloader(c);
 906
 907         return (jobject) cl;
 908 }
 909
 910
 911 /* JVM_IsInterface */
 912
 913 jboolean JVM_IsInterface(JNIEnv *env, jclass cls)
 914 {
 915         classinfo *c;
 916
 917         TRACEJVMCALLS(("JVM_IsInterface(env=%p, cls=%p)", env, cls));
 918
 919         c = LLNI_classinfo_unwrap(cls);
 920
 921         return class_is_interface(c);
 922 }
 923
 924
 925 /* JVM_GetClassSigners */
 926
 927 jobjectArray JVM_GetClassSigners(JNIEnv *env, jclass cls)
 928 {
 929         log_println("JVM_GetClassSigners: IMPLEMENT ME!");
 930
 931         return NULL;
 932 }
 933
 934
 935 /* JVM_SetClassSigners */
 936
 937 void JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers)
 938 {
 939         classinfo                 *c;
 940         java_handle_objectarray_t *hoa;
 941
 942         TRACEJVMCALLS(("JVM_SetClassSigners(env=%p, cls=%p, signers=%p)", env, cls, signers));
 943
 944         c = LLNI_classinfo_unwrap(cls);
 945
 946         hoa = (java_handle_objectarray_t *) signers;
 947
 948     /* This call is ignored for primitive types and arrays.  Signers
 949            are only set once, ClassLoader.java, and thus shouldn't be
 950            called with an array.  Only the bootstrap loader creates
 951            arrays. */
 952
 953         if (class_is_primitive(c) || class_is_array(c))
 954                 return;
 955
 956         LLNI_classinfo_field_set(c, signers, hoa);
 957 }
 958
 959
 960 /* JVM_GetProtectionDomain */
 961
 962 jobject JVM_GetProtectionDomain(JNIEnv *env, jclass cls)
 963 {
 964         classinfo *c;
 965
 966         TRACEJVMCALLS(("JVM_GetProtectionDomain(env=%p, cls=%p)", env, cls));
 967
 968         c = LLNI_classinfo_unwrap(cls);
 969
 970         if (c == NULL) {
 971                 exceptions_throw_nullpointerexception();
 972                 return NULL;
 973         }
 974
 975     /* Primitive types do not have a protection domain. */
 976
 977         if (class_is_primitive(c))
 978                 return NULL;
 979
 980         return (jobject) c->protectiondomain;
 981 }
 982
 983
 984 /* JVM_SetProtectionDomain */
 985
 986 void JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain)
 987 {
 988         log_println("JVM_SetProtectionDomain: IMPLEMENT ME!");
 989 }
 990
 991
 992 /* JVM_DoPrivileged */
 993
 994 jobject JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, jobject context, jboolean wrapException)
 995 {
 996         java_handle_t *o;
 997         classinfo     *c;
 998         methodinfo    *m;
 999         java_handle_t *result;
1000         java_handle_t *e;
1001
1002         TRACEJVMCALLS(("JVM_DoPrivileged(env=%p, cls=%p, action=%p, context=%p, wrapException=%d)", env, cls, action, context, wrapException));
1003
1004         o = (java_handle_t *) action;
1005         c = o->vftbl->class;
1006
1007         if (action == NULL) {
1008                 exceptions_throw_nullpointerexception();
1009                 return NULL;
1010         }
1011
1012         /* lookup run() method (throw no exceptions) */
1013
1014         m = class_resolveclassmethod(c, utf_run, utf_void__java_lang_Object, c,
1015                                                                  false);
1016
1017         if ((m == NULL) || !(m->flags & ACC_PUBLIC) || (m->flags & ACC_STATIC)) {
1018                 exceptions_throw_internalerror("No run method");
1019                 return NULL;
1020         }
1021
1022         /* XXX It seems something with a privileged stack needs to be done
1023            here. */
1024
1025         result = vm_call_method(m, o);
1026
1027         e = exceptions_get_and_clear_exception();
1028
1029         if (e != NULL) {
1030                 exceptions_throw_privilegedactionexception(e);
1031                 return NULL;
1032         }
1033
1034         return (jobject) result;
1035 }
1036
1037
1038 /* JVM_GetInheritedAccessControlContext */
1039
1040 jobject JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls)
1041 {
1042         log_println("JVM_GetInheritedAccessControlContext: IMPLEMENT ME!");
1043
1044         return NULL;
1045 }
1046
1047
1048 /* JVM_GetStackAccessControlContext */
1049
1050 jobject JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls)
1051 {
1052         TRACEJVMCALLS(("JVM_GetStackAccessControlContext(env=%p, cls=%p): IMPLEMENT ME!", env, cls));
1053
1054         /* XXX All stuff I tested so far works without that function.  At
1055            some point we have to implement it, but I disable the output
1056            for now to make IcedTea happy. */
1057
1058         return NULL;
1059 }
1060
1061
1062 /* JVM_IsArrayClass */
1063
1064 jboolean JVM_IsArrayClass(JNIEnv *env, jclass cls)
1065 {
1066         classinfo *c;
1067
1068         TRACEJVMCALLS(("JVM_IsArrayClass(env=%p, cls=%p)", env, cls));
1069
1070         c = LLNI_classinfo_unwrap(cls);
1071
1072         return class_is_array(c);
1073 }
1074
1075
1076 /* JVM_IsPrimitiveClass */
1077
1078 jboolean JVM_IsPrimitiveClass(JNIEnv *env, jclass cls)
1079 {
1080         classinfo *c;
1081
1082         TRACEJVMCALLS(("JVM_IsPrimitiveClass(env=%p, cls=%p)", env, cls));
1083
1084         c = LLNI_classinfo_unwrap(cls);
1085
1086         return class_is_primitive(c);
1087 }
1088
1089
1090 /* JVM_GetComponentType */
1091
1092 jclass JVM_GetComponentType(JNIEnv *env, jclass cls)
1093 {
1094         classinfo *component;
1095         classinfo *c;
1096
1097         TRACEJVMCALLS(("JVM_GetComponentType(env=%p, cls=%p)", env, cls));
1098
1099         c = LLNI_classinfo_unwrap(cls);
1100
1101         component = class_get_componenttype(c);
1102
1103         return (jclass) LLNI_classinfo_wrap(component);
1104 }
1105
1106
1107 /* JVM_GetClassModifiers */
1108
1109 jint JVM_GetClassModifiers(JNIEnv *env, jclass cls)
1110 {
1111         classinfo *c;
1112         int32_t    flags;
1113
1114         TRACEJVMCALLS(("JVM_GetClassModifiers(env=%p, cls=%p)", env, cls));
1115
1116         c = LLNI_classinfo_unwrap(cls);
1117
1118         flags = class_get_modifiers(c, false);
1119
1120         return flags;
1121 }
1122
1123
1124 /* JVM_GetDeclaredClasses */
1125
1126 jobjectArray JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)
1127 {
1128         classinfo                 *c;
1129         java_handle_objectarray_t *oa;
1130
1131         TRACEJVMCALLS(("JVM_GetDeclaredClasses(env=%p, ofClass=%p)", env, ofClass));
1132
1133         c = LLNI_classinfo_unwrap(ofClass);
1134
1135         oa = class_get_declaredclasses(c, false);
1136
1137         return (jobjectArray) oa;
1138 }
1139
1140
1141 /* JVM_GetDeclaringClass */
1142
1143 jclass JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass)
1144 {
1145         classinfo *c;
1146         classinfo *dc;
1147
1148         TRACEJVMCALLS(("JVM_GetDeclaringClass(env=%p, ofClass=%p)", env, ofClass));
1149
1150         c = LLNI_classinfo_unwrap(ofClass);
1151
1152         dc = class_get_declaringclass(c);
1153
1154         return (jclass) LLNI_classinfo_wrap(dc);
1155 }
1156
1157
1158 /* JVM_GetClassSignature */
1159
1160 jstring JVM_GetClassSignature(JNIEnv *env, jclass cls)
1161 {
1162         classinfo     *c;
1163         utf           *u;
1164         java_handle_t *s;
1165
1166         TRACEJVMCALLS(("JVM_GetClassSignature(env=%p, cls=%p)", env, cls));
1167
1168         c = LLNI_classinfo_unwrap(cls);
1169
1170         /* Get the signature of the class. */
1171
1172         u = class_get_signature(c);
1173
1174         if (u == NULL)
1175                 return NULL;
1176
1177         /* Convert UTF-string to a Java-string. */
1178
1179         s = javastring_new(u);
1180
1181         return (jstring) s;
1182 }
1183
1184
1185 /* JVM_GetClassAnnotations */
1186
1187 jbyteArray JVM_GetClassAnnotations(JNIEnv *env, jclass cls)
1188 {
1189         classinfo               *c           = NULL; /* classinfo for 'cls'  */
1190         java_handle_bytearray_t *annotations = NULL; /* unparsed annotations */
1191
1192         TRACEJVMCALLS(("JVM_GetClassAnnotations: cls=%p", cls));
1193
1194         if (cls == NULL) {
1195                 exceptions_throw_nullpointerexception();
1196                 return NULL;
1197         }
1198
1199         c = LLNI_classinfo_unwrap(cls);
1200
1201         /* get annotations: */
1202         annotations = class_get_annotations(c);
1203
1204         return (jbyteArray)annotations;
1205 }
1206
1207
1208 /* JVM_GetFieldAnnotations */
1209
1210 jbyteArray JVM_GetFieldAnnotations(JNIEnv *env, jobject field)
1211 {
1212         java_lang_reflect_Field *rf = NULL; /* java.lang.reflect.Field for 'field' */
1213         java_handle_bytearray_t *ba = NULL; /* unparsed annotations */
1214
1215         TRACEJVMCALLS(("JVM_GetFieldAnnotations: field=%p", field));
1216
1217         if (field == NULL) {
1218                 exceptions_throw_nullpointerexception();
1219                 return NULL;
1220         }
1221
1222         rf = (java_lang_reflect_Field*)field;
1223
1224         LLNI_field_get_ref(rf, annotations, ba);
1225
1226         return (jbyteArray)ba;
1227 }
1228
1229
1230 /* JVM_GetMethodAnnotations */
1231
1232 jbyteArray JVM_GetMethodAnnotations(JNIEnv *env, jobject method)
1233 {
1234         java_lang_reflect_Method *rm = NULL; /* java.lang.reflect.Method for 'method' */
1235         java_handle_bytearray_t  *ba = NULL; /* unparsed annotations */
1236
1237         TRACEJVMCALLS(("JVM_GetMethodAnnotations: method=%p", method));
1238
1239         if (method == NULL) {
1240                 exceptions_throw_nullpointerexception();
1241                 return NULL;
1242         }
1243
1244         rm = (java_lang_reflect_Method*)method;
1245
1246         LLNI_field_get_ref(rm, annotations, ba);
1247
1248         return (jbyteArray)ba;
1249 }
1250
1251
1252 /* JVM_GetMethodDefaultAnnotationValue */
1253
1254 jbyteArray JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method)
1255 {
1256         java_lang_reflect_Method *rm = NULL; /* java.lang.reflect.Method for 'method' */
1257         java_handle_bytearray_t  *ba = NULL; /* unparsed annotation default value */
1258
1259         TRACEJVMCALLS(("JVM_GetMethodDefaultAnnotationValue: method=%p", method));
1260
1261         if (method == NULL) {
1262                 exceptions_throw_nullpointerexception();
1263                 return NULL;
1264         }
1265
1266         rm = (java_lang_reflect_Method*)method;
1267
1268         LLNI_field_get_ref(rm, annotationDefault, ba);
1269
1270         return (jbyteArray)ba;
1271 }
1272
1273
1274 /* JVM_GetMethodParameterAnnotations */
1275
1276 jbyteArray JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method)
1277 {
1278         java_lang_reflect_Method *rm = NULL; /* java.lang.reflect.Method for 'method' */
1279         java_handle_bytearray_t  *ba = NULL; /* unparsed parameter annotations */
1280
1281         TRACEJVMCALLS(("JVM_GetMethodParameterAnnotations: method=%p", method));
1282
1283         if (method == NULL) {
1284                 exceptions_throw_nullpointerexception();
1285                 return NULL;
1286         }
1287
1288         rm = (java_lang_reflect_Method*)method;
1289
1290         LLNI_field_get_ref(rm, parameterAnnotations, ba);
1291
1292         return (jbyteArray)ba;
1293 }
1294
1295
1296 /* JVM_GetClassDeclaredFields */
1297
1298 jobjectArray JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1299 {
1300         TRACEJVMCALLS(("JVM_GetClassDeclaredFields(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1301
1302         return (jobjectArray) _Jv_java_lang_Class_getDeclaredFields((java_lang_Class *) ofClass, publicOnly);
1303 }
1304
1305
1306 /* JVM_GetClassDeclaredMethods */
1307
1308 jobjectArray JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1309 {
1310         TRACEJVMCALLS(("JVM_GetClassDeclaredMethods(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1311
1312         return (jobjectArray) _Jv_java_lang_Class_getDeclaredMethods((java_lang_Class *) ofClass, publicOnly);
1313 }
1314
1315
1316 /* JVM_GetClassDeclaredConstructors */
1317
1318 jobjectArray JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1319 {
1320         TRACEJVMCALLS(("JVM_GetClassDeclaredConstructors(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1321
1322         return (jobjectArray) _Jv_java_lang_Class_getDeclaredConstructors((java_lang_Class *) ofClass, publicOnly);
1323 }
1324
1325
1326 /* JVM_GetClassAccessFlags */
1327
1328 jint JVM_GetClassAccessFlags(JNIEnv *env, jclass cls)
1329 {
1330         classinfo *c;
1331
1332         TRACEJVMCALLS(("JVM_GetClassAccessFlags(env=%p, cls=%p)", env, cls));
1333
1334         c = LLNI_classinfo_unwrap(cls);
1335
1336         /* Primitive type classes have the correct access flags. */
1337
1338         return c->flags & ACC_CLASS_REFLECT_MASK;
1339 }
1340
1341
1342 /* JVM_GetClassConstantPool */
1343
1344 jobject JVM_GetClassConstantPool(JNIEnv *env, jclass cls)
1345 {
1346 #if defined(ENABLE_ANNOTATIONS)
1347         sun_reflect_ConstantPool *constantPool    = NULL;
1348                       /* constant pool object for the class refered by 'cls' */
1349         java_lang_Object         *constantPoolOop = (java_lang_Object*)cls;
1350                       /* constantPoolOop field of the constant pool object   */
1351
1352         TRACEJVMCALLS(("JVM_GetClassConstantPool(env=%p, cls=%p)", env, cls));
1353
1354         constantPool =
1355                 (sun_reflect_ConstantPool*)native_new_and_init(
1356                         class_sun_reflect_ConstantPool);
1357
1358         if (constantPool == NULL) {
1359                 /* out of memory */
1360                 return NULL;
1361         }
1362
1363         LLNI_field_set_ref(constantPool, constantPoolOop, constantPoolOop);
1364
1365         return (jobject)constantPool;
1366 #else
1367         log_println("JVM_GetClassConstantPool(env=%p, cls=%p): not implemented in this configuration!", env, cls);
1368         return NULL;
1369 #endif
1370 }
1371
1372
1373 /* JVM_ConstantPoolGetSize */
1374
1375 jint JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool)
1376 {
1377         classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1378
1379         TRACEJVMCALLS(("JVM_ConstantPoolGetSize(env=%p, unused=%p, jcpool=%p)", env, unused, jcpool));
1380
1381         c = LLNI_classinfo_unwrap(jcpool);
1382
1383         return c->cpcount;
1384 }
1385
1386
1387 /* JVM_ConstantPoolGetClassAt */
1388
1389 jclass JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1390 {
1391         constant_classref *ref;    /* classref to the class at constant pool index 'index' */
1392         classinfo         *c;      /* classinfo of the class for which 'this' is the constant pool */
1393         classinfo         *result; /* classinfo of the class at constant pool index 'index' */
1394
1395         TRACEJVMCALLS(("JVM_ConstantPoolGetClassAt(env=%p, jcpool=%p, index=%d)", env, jcpool, index));
1396
1397         c = LLNI_classinfo_unwrap(jcpool);
1398
1399         ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1400
1401         if (ref == NULL) {
1402                 exceptions_throw_illegalargumentexception();
1403                 return NULL;
1404         }
1405
1406         result = resolve_classref_eager(ref);
1407
1408         return (jclass) LLNI_classinfo_wrap(result);
1409 }
1410
1411
1412 /* JVM_ConstantPoolGetClassAtIfLoaded */
1413
1414 jclass JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1415 {
1416         constant_classref *ref;    /* classref to the class at constant pool index 'index' */
1417         classinfo         *c;      /* classinfo of the class for which 'this' is the constant pool */
1418         classinfo         *result; /* classinfo of the class at constant pool index 'index' */
1419
1420         TRACEJVMCALLS(("JVM_ConstantPoolGetClassAtIfLoaded(env=%p, unused=%p, jcpool=%p, index=%d)", env, unused, jcpool, index));
1421
1422         c = LLNI_classinfo_unwrap(jcpool);
1423
1424         ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1425
1426         if (ref == NULL) {
1427                 exceptions_throw_illegalargumentexception();
1428                 return NULL;
1429         }
1430
1431         if (!resolve_classref(NULL, ref, resolveLazy, true, true, &result)) {
1432                 return NULL;
1433         }
1434
1435         if ((result == NULL) || !(result->state & CLASS_LOADED)) {
1436                 return NULL;
1437         }
1438
1439         return (jclass) LLNI_classinfo_wrap(result);
1440 }
1441
1442
1443 /* JVM_ConstantPoolGetMethodAt */
1444
1445 jobject JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1446 {
1447         constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
1448         classinfo *cls;       /* classinfo of the class for which 'this' is the constant pool */
1449
1450         TRACEJVMCALLS(("JVM_ConstantPoolGetMethodAt: jcpool=%p, index=%d", jcpool, index));
1451
1452         cls = LLNI_classinfo_unwrap(jcpool);
1453         ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1454
1455         if (ref == NULL) {
1456                 exceptions_throw_illegalargumentexception();
1457                 return NULL;
1458         }
1459
1460         /* XXX: is that right? or do I have to use resolve_method_*? */
1461         return (jobject)reflect_method_new(ref->p.method);
1462 }
1463
1464
1465 /* JVM_ConstantPoolGetMethodAtIfLoaded */
1466
1467 jobject JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1468 {
1469         constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
1470         classinfo *c = NULL;  /* resolved declaring class of the method */
1471         classinfo *cls;       /* classinfo of the class for which 'this' is the constant pool */
1472
1473         TRACEJVMCALLS(("JVM_ConstantPoolGetMethodAtIfLoaded: jcpool=%p, index=%d", jcpool, index));
1474
1475         cls = LLNI_classinfo_unwrap(jcpool);
1476         ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1477
1478         if (ref == NULL) {
1479                 exceptions_throw_illegalargumentexception();
1480                 return NULL;
1481         }
1482
1483         if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1484                 return NULL;
1485         }
1486
1487         if (c == NULL || !(c->state & CLASS_LOADED)) {
1488                 return NULL;
1489         }
1490
1491         return (jobject)reflect_method_new(ref->p.method);
1492 }
1493
1494
1495 /* JVM_ConstantPoolGetFieldAt */
1496
1497 jobject JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1498 {
1499         constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
1500         classinfo *cls;       /* classinfo of the class for which 'this' is the constant pool */
1501
1502         TRACEJVMCALLS(("JVM_ConstantPoolGetFieldAt: jcpool=%p, index=%d", jcpool, index));
1503
1504         cls = LLNI_classinfo_unwrap(jcpool);
1505         ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1506
1507         if (ref == NULL) {
1508                 exceptions_throw_illegalargumentexception();
1509                 return NULL;
1510         }
1511
1512         return (jobject)reflect_field_new(ref->p.field);
1513 }
1514
1515
1516 /* JVM_ConstantPoolGetFieldAtIfLoaded */
1517
1518 jobject JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1519 {
1520         constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
1521         classinfo *c;         /* resolved declaring class for the field */
1522         classinfo *cls;       /* classinfo of the class for which 'this' is the constant pool */
1523
1524         TRACEJVMCALLS(("JVM_ConstantPoolGetFieldAtIfLoaded: jcpool=%p, index=%d", jcpool, index));
1525
1526         cls = LLNI_classinfo_unwrap(jcpool);
1527         ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1528
1529         if (ref == NULL) {
1530                 exceptions_throw_illegalargumentexception();
1531                 return NULL;
1532         }
1533
1534         if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1535                 return NULL;
1536         }
1537
1538         if (c == NULL || !(c->state & CLASS_LOADED)) {
1539                 return NULL;
1540         }
1541
1542         return (jobject)reflect_field_new(ref->p.field);
1543 }
1544
1545
1546 /* JVM_ConstantPoolGetMemberRefInfoAt */
1547
1548 jobjectArray JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1549 {
1550         log_println("JVM_ConstantPoolGetMemberRefInfoAt: jcpool=%p, index=%d, IMPLEMENT ME!", jcpool, index);
1551
1552         /* TODO: implement. (this is yet unused be OpenJDK but, so very low priority) */
1553
1554         return NULL;
1555 }
1556
1557
1558 /* JVM_ConstantPoolGetIntAt */
1559
1560 jint JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1561 {
1562         constant_integer *ref; /* reference to the int value in constant pool at index 'index' */
1563         classinfo *cls;        /* classinfo of the class for which 'this' is the constant pool */
1564
1565         TRACEJVMCALLS(("JVM_ConstantPoolGetIntAt: jcpool=%p, index=%d", jcpool, index));
1566
1567         cls = LLNI_classinfo_unwrap(jcpool);
1568         ref = (constant_integer*)class_getconstant(cls, index, CONSTANT_Integer);
1569
1570         if (ref == NULL) {
1571                 exceptions_throw_illegalargumentexception();
1572                 return 0;
1573         }
1574
1575         return ref->value;
1576 }
1577
1578
1579 /* JVM_ConstantPoolGetLongAt */
1580
1581 jlong JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1582 {
1583         constant_long *ref; /* reference to the long value in constant pool at index 'index' */
1584         classinfo *cls;     /* classinfo of the class for which 'this' is the constant pool */
1585
1586         TRACEJVMCALLS(("JVM_ConstantPoolGetLongAt: jcpool=%p, index=%d", jcpool, index));
1587
1588         cls = LLNI_classinfo_unwrap(jcpool);
1589         ref = (constant_long*)class_getconstant(cls, index, CONSTANT_Long);
1590
1591         if (ref == NULL) {
1592                 exceptions_throw_illegalargumentexception();
1593                 return 0;
1594         }
1595
1596         return ref->value;
1597 }
1598
1599
1600 /* JVM_ConstantPoolGetFloatAt */
1601
1602 jfloat JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1603 {
1604         constant_float *ref; /* reference to the float value in constant pool at index 'index' */
1605         classinfo *cls;      /* classinfo of the class for which 'this' is the constant pool */
1606
1607         TRACEJVMCALLS(("JVM_ConstantPoolGetFloatAt: jcpool=%p, index=%d", jcpool, index));
1608
1609         cls = LLNI_classinfo_unwrap(jcpool);
1610         ref = (constant_float*)class_getconstant(cls, index, CONSTANT_Float);
1611
1612         if (ref == NULL) {
1613                 exceptions_throw_illegalargumentexception();
1614                 return 0;
1615         }
1616
1617         return ref->value;
1618 }
1619
1620
1621 /* JVM_ConstantPoolGetDoubleAt */
1622
1623 jdouble JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1624 {
1625         constant_double *ref; /* reference to the double value in constant pool at index 'index' */
1626         classinfo *cls;       /* classinfo of the class for which 'this' is the constant pool */
1627
1628         TRACEJVMCALLS(("JVM_ConstantPoolGetDoubleAt: jcpool=%p, index=%d", jcpool, index));
1629
1630         cls = LLNI_classinfo_unwrap(jcpool);
1631         ref = (constant_double*)class_getconstant(cls, index, CONSTANT_Double);
1632
1633         if (ref == NULL) {
1634                 exceptions_throw_illegalargumentexception();
1635                 return 0;
1636         }
1637
1638         return ref->value;
1639 }
1640
1641
1642 /* JVM_ConstantPoolGetStringAt */
1643
1644 jstring JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1645 {
1646         utf *ref;       /* utf object for the string in constant pool at index 'index' */
1647         classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1648
1649         TRACEJVMCALLS(("JVM_ConstantPoolGetStringAt: jcpool=%p, index=%d", jcpool, index));
1650
1651         cls = LLNI_classinfo_unwrap(jcpool);
1652         ref = (utf*)class_getconstant(cls, index, CONSTANT_String);
1653
1654         if (ref == NULL) {
1655                 exceptions_throw_illegalargumentexception();
1656                 return NULL;
1657         }
1658
1659         /* XXX: I hope literalstring_new is the right Function. */
1660         return (jstring)literalstring_new(ref);
1661 }
1662
1663
1664 /* JVM_ConstantPoolGetUTF8At */
1665
1666 jstring JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1667 {
1668         utf *ref; /* utf object for the utf8 data in constant pool at index 'index' */
1669         classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1670
1671         TRACEJVMCALLS(("JVM_ConstantPoolGetUTF8At: jcpool=%p, index=%d", jcpool, index));
1672
1673         cls = LLNI_classinfo_unwrap(jcpool);
1674         ref = (utf*)class_getconstant(cls, index, CONSTANT_Utf8);
1675
1676         if (ref == NULL) {
1677                 exceptions_throw_illegalargumentexception();
1678                 return NULL;
1679         }
1680
1681         /* XXX: I hope literalstring_new is the right Function. */
1682         return (jstring)literalstring_new(ref);
1683 }
1684
1685
1686 /* JVM_DesiredAssertionStatus */
1687
1688 jboolean JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls)
1689 {
1690 #if defined(ENABLE_ASSERTION)
1691         assertion_name_t  *item;
1692         classinfo         *c;
1693         jboolean           status;
1694         utf               *name;
1695
1696         TRACEJVMCALLS(("JVM_DesiredAssertionStatus(env=%p, unused=%p, cls=%p)", env, unused, cls));
1697
1698         c = LLNI_classinfo_unwrap(cls);
1699
1700         if (c->classloader == NULL) {
1701                 status = (jboolean)assertion_system_enabled;
1702         }
1703         else {
1704                 status = (jboolean)assertion_user_enabled;
1705         }
1706
1707         if (list_assertion_names != NULL) {
1708                 item = (assertion_name_t *)list_first(list_assertion_names);
1709                 while (item != NULL) {
1710                         name = utf_new_char(item->name);
1711                         if (name == c->packagename) {
1712                                 status = (jboolean)item->enabled;
1713                         }
1714                         else if (name == c->name) {
1715                                 status = (jboolean)item->enabled;
1716                         }
1717
1718                         item = (assertion_name_t *)list_next(list_assertion_names, item);
1719                 }
1720         }
1721
1722         return status;
1723 #else
1724         return (jboolean)false;
1725 #endif
1726 }
1727
1728
1729 /* JVM_AssertionStatusDirectives */
1730
1731 jobject JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)
1732 {
1733         classinfo                             *c;
1734         java_lang_AssertionStatusDirectives   *o;
1735         java_handle_objectarray_t             *classes;
1736         java_handle_objectarray_t             *packages;
1737         java_booleanarray_t                   *classEnabled;
1738         java_booleanarray_t                   *packageEnabled;
1739 #if defined(ENABLE_ASSERTION)
1740         assertion_name_t                      *item;
1741         java_handle_t                         *js;
1742         s4                                     i, j;
1743 #endif
1744
1745         TRACEJVMCALLS(("JVM_AssertionStatusDirectives(env=%p, unused=%p)", env, unused));
1746
1747         c = load_class_bootstrap(utf_new_char("java/lang/AssertionStatusDirectives"));
1748
1749         if (c == NULL)
1750                 return NULL;
1751
1752         o = (java_lang_AssertionStatusDirectives *) builtin_new(c);
1753
1754         if (o == NULL)
1755                 return NULL;
1756
1757 #if defined(ENABLE_ASSERTION)
1758         classes = builtin_anewarray(assertion_class_count, class_java_lang_Object);
1759 #else
1760         classes = builtin_anewarray(0, class_java_lang_Object);
1761 #endif
1762         if (classes == NULL)
1763                 return NULL;
1764
1765 #if defined(ENABLE_ASSERTION)
1766         packages = builtin_anewarray(assertion_package_count, class_java_lang_Object);
1767 #else
1768         packages = builtin_anewarray(0, class_java_lang_Object);
1769 #endif
1770         if (packages == NULL)
1771                 return NULL;
1772
1773 #if defined(ENABLE_ASSERTION)
1774         classEnabled = builtin_newarray_boolean(assertion_class_count);
1775 #else
1776         classEnabled = builtin_newarray_boolean(0);
1777 #endif
1778         if (classEnabled == NULL)
1779                 return NULL;
1780
1781 #if defined(ENABLE_ASSERTION)
1782         packageEnabled = builtin_newarray_boolean(assertion_package_count);
1783 #else
1784         packageEnabled = builtin_newarray_boolean(0);
1785 #endif
1786         if (packageEnabled == NULL)
1787                 return NULL;
1788
1789 #if defined(ENABLE_ASSERTION)
1790         /* initialize arrays */
1791
1792         if (list_assertion_names != NULL) {
1793                 i = 0;
1794                 j = 0;
1795
1796                 item = (assertion_name_t *)list_first(list_assertion_names);
1797                 while (item != NULL) {
1798                         js = javastring_new_from_ascii(item->name);
1799                         if (js == NULL) {
1800                                 return NULL;
1801                         }
1802
1803                         if (item->package == false) {
1804                                 classes->data[i] = js;
1805                                 classEnabled->data[i] = (jboolean) item->enabled;
1806                                 i += 1;
1807                         }
1808                         else {
1809                                 packages->data[j] = js;
1810                                 packageEnabled->data[j] = (jboolean) item->enabled;
1811                                 j += 1;
1812                         }
1813
1814                         item = (assertion_name_t *)list_next(list_assertion_names, item);
1815                 }
1816         }
1817 #endif
1818
1819         /* set instance fields */
1820
1821         o->classes  = classes;
1822         o->packages = packages;
1823         o->classEnabled = classEnabled;
1824         o->packageEnabled = packageEnabled;
1825
1826         return (jobject) o;
1827 }
1828
1829
1830 /* JVM_GetClassNameUTF */
1831
1832 const char *JVM_GetClassNameUTF(JNIEnv *env, jclass cls)
1833 {
1834         log_println("JVM_GetClassNameUTF: IMPLEMENT ME!");
1835
1836         return NULL;
1837 }
1838
1839
1840 /* JVM_GetClassCPTypes */
1841
1842 void JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types)
1843 {
1844         log_println("JVM_GetClassCPTypes: IMPLEMENT ME!");
1845 }
1846
1847
1848 /* JVM_GetClassCPEntriesCount */
1849
1850 jint JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)
1851 {
1852         log_println("JVM_GetClassCPEntriesCount: IMPLEMENT ME!");
1853
1854         return 0;
1855 }
1856
1857
1858 /* JVM_GetClassFieldsCount */
1859
1860 jint JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)
1861 {
1862         log_println("JVM_GetClassFieldsCount: IMPLEMENT ME!");
1863
1864         return 0;
1865 }
1866
1867
1868 /* JVM_GetClassMethodsCount */
1869
1870 jint JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)
1871 {
1872         log_println("JVM_GetClassMethodsCount: IMPLEMENT ME!");
1873
1874         return 0;
1875 }
1876
1877
1878 /* JVM_GetMethodIxExceptionIndexes */
1879
1880 void JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions)
1881 {
1882         log_println("JVM_GetMethodIxExceptionIndexes: IMPLEMENT ME!");
1883 }
1884
1885
1886 /* JVM_GetMethodIxExceptionsCount */
1887
1888 jint JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)
1889 {
1890         log_println("JVM_GetMethodIxExceptionsCount: IMPLEMENT ME!");
1891
1892         return 0;
1893 }
1894
1895
1896 /* JVM_GetMethodIxByteCode */
1897
1898 void JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code)
1899 {
1900         log_println("JVM_GetMethodIxByteCode: IMPLEMENT ME!");
1901 }
1902
1903
1904 /* JVM_GetMethodIxByteCodeLength */
1905
1906 jint JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)
1907 {
1908         log_println("JVM_GetMethodIxByteCodeLength: IMPLEMENT ME!");
1909
1910         return 0;
1911 }
1912
1913
1914 /* JVM_GetMethodIxExceptionTableEntry */
1915
1916 void JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry)
1917 {
1918         log_println("JVM_GetMethodIxExceptionTableEntry: IMPLEMENT ME!");
1919 }
1920
1921
1922 /* JVM_GetMethodIxExceptionTableLength */
1923
1924 jint JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)
1925 {
1926         log_println("JVM_GetMethodIxExceptionTableLength: IMPLEMENT ME!");
1927
1928         return 0;
1929 }
1930
1931
1932 /* JVM_GetMethodIxModifiers */
1933
1934 jint JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)
1935 {
1936         log_println("JVM_GetMethodIxModifiers: IMPLEMENT ME!");
1937
1938         return 0;
1939 }
1940
1941
1942 /* JVM_GetFieldIxModifiers */
1943
1944 jint JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)
1945 {
1946         log_println("JVM_GetFieldIxModifiers: IMPLEMENT ME!");
1947
1948         return 0;
1949 }
1950
1951
1952 /* JVM_GetMethodIxLocalsCount */
1953
1954 jint JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)
1955 {
1956         log_println("JVM_GetMethodIxLocalsCount: IMPLEMENT ME!");
1957
1958         return 0;
1959 }
1960
1961
1962 /* JVM_GetMethodIxArgsSize */
1963
1964 jint JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)
1965 {
1966         log_println("JVM_GetMethodIxArgsSize: IMPLEMENT ME!");
1967
1968         return 0;
1969 }
1970
1971
1972 /* JVM_GetMethodIxMaxStack */
1973
1974 jint JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)
1975 {
1976         log_println("JVM_GetMethodIxMaxStack: IMPLEMENT ME!");
1977
1978         return 0;
1979 }
1980
1981
1982 /* JVM_IsConstructorIx */
1983
1984 jboolean JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)
1985 {
1986         log_println("JVM_IsConstructorIx: IMPLEMENT ME!");
1987
1988         return 0;
1989 }
1990
1991
1992 /* JVM_GetMethodIxNameUTF */
1993
1994 const char *JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)
1995 {
1996         log_println("JVM_GetMethodIxNameUTF: IMPLEMENT ME!");
1997
1998         return NULL;
1999 }
2000
2001
2002 /* JVM_GetMethodIxSignatureUTF */
2003
2004 const char *JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)
2005 {
2006         log_println("JVM_GetMethodIxSignatureUTF: IMPLEMENT ME!");
2007
2008         return NULL;
2009 }
2010
2011
2012 /* JVM_GetCPFieldNameUTF */
2013
2014 const char *JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2015 {
2016         log_println("JVM_GetCPFieldNameUTF: IMPLEMENT ME!");
2017
2018         return NULL;
2019 }
2020
2021
2022 /* JVM_GetCPMethodNameUTF */
2023
2024 const char *JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2025 {
2026         log_println("JVM_GetCPMethodNameUTF: IMPLEMENT ME!");
2027
2028         return NULL;
2029 }
2030
2031
2032 /* JVM_GetCPMethodSignatureUTF */
2033
2034 const char *JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
2035 {
2036         log_println("JVM_GetCPMethodSignatureUTF: IMPLEMENT ME!");
2037
2038         return NULL;
2039 }
2040
2041
2042 /* JVM_GetCPFieldSignatureUTF */
2043
2044 const char *JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
2045 {
2046         log_println("JVM_GetCPFieldSignatureUTF: IMPLEMENT ME!");
2047
2048         return NULL;
2049 }
2050
2051
2052 /* JVM_GetCPClassNameUTF */
2053
2054 const char *JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2055 {
2056         log_println("JVM_GetCPClassNameUTF: IMPLEMENT ME!");
2057
2058         return NULL;
2059 }
2060
2061
2062 /* JVM_GetCPFieldClassNameUTF */
2063
2064 const char *JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2065 {
2066         log_println("JVM_GetCPFieldClassNameUTF: IMPLEMENT ME!");
2067
2068         return NULL;
2069 }
2070
2071
2072 /* JVM_GetCPMethodClassNameUTF */
2073
2074 const char *JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2075 {
2076         log_println("JVM_GetCPMethodClassNameUTF: IMPLEMENT ME!");
2077
2078         return NULL;
2079 }
2080
2081
2082 /* JVM_GetCPFieldModifiers */
2083
2084 jint JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
2085 {
2086         log_println("JVM_GetCPFieldModifiers: IMPLEMENT ME!");
2087
2088         return 0;
2089 }
2090
2091
2092 /* JVM_GetCPMethodModifiers */
2093
2094 jint JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
2095 {
2096         log_println("JVM_GetCPMethodModifiers: IMPLEMENT ME!");
2097
2098         return 0;
2099 }
2100
2101
2102 /* JVM_ReleaseUTF */
2103
2104 void JVM_ReleaseUTF(const char *utf)
2105 {
2106         log_println("JVM_ReleaseUTF: IMPLEMENT ME!");
2107 }
2108
2109
2110 /* JVM_IsSameClassPackage */
2111
2112 jboolean JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2)
2113 {
2114         log_println("JVM_IsSameClassPackage: IMPLEMENT ME!");
2115
2116         return 0;
2117 }
2118
2119
2120 /* JVM_Open */
2121
2122 /* Taken from: hotspot/src/share/vm/prims/jvm.h */
2123
2124 /*
2125  * JVM I/O error codes
2126  */
2127 #define JVM_EEXIST       -100
2128
2129 jint JVM_Open(const char *fname, jint flags, jint mode)
2130 {
2131         int result;
2132
2133         TRACEJVMCALLS(("JVM_Open(fname=%s, flags=%d, mode=%d)", fname, flags, mode));
2134
2135         result = system_open(fname, flags, mode);
2136
2137         if (result >= 0) {
2138                 return result;
2139         }
2140         else {
2141                 switch (errno) {
2142                 case EEXIST:
2143                         return JVM_EEXIST;
2144                 default:
2145                         return -1;
2146                 }
2147         }
2148 }
2149
2150
2151 /* JVM_Close */
2152
2153 jint JVM_Close(jint fd)
2154 {
2155         TRACEJVMCALLS(("JVM_Close(fd=%d)", fd));
2156
2157         return system_close(fd);
2158 }
2159
2160
2161 /* JVM_Read */
2162
2163 jint JVM_Read(jint fd, char *buf, jint nbytes)
2164 {
2165         TRACEJVMCALLS(("JVM_Read(fd=%d, buf=%p, nbytes=%d)", fd, buf, nbytes));
2166
2167         return system_read(fd, buf, nbytes);
2168 }
2169
2170
2171 /* JVM_Write */
2172
2173 jint JVM_Write(jint fd, char *buf, jint nbytes)
2174 {
2175         TRACEJVMCALLS(("JVM_Write(fd=%d, buf=%s, nbytes=%d)", fd, buf, nbytes));
2176
2177         return system_write(fd, buf, nbytes);
2178 }
2179
2180
2181 /* JVM_Available */
2182
2183 jint JVM_Available(jint fd, jlong *pbytes)
2184 {
2185 #if defined(FIONREAD)
2186         int bytes;
2187         int result;
2188
2189         TRACEJVMCALLS(("JVM_Available(fd=%d, pbytes=%p)", fd, pbytes));
2190
2191         *pbytes = 0;
2192
2193         result = ioctl(fd, FIONREAD, &bytes);
2194
2195         if (result < 0)
2196                 return 0;
2197
2198         *pbytes = bytes;
2199
2200         return 1;
2201 #else
2202 # error FIONREAD not defined
2203 #endif
2204 }
2205
2206
2207 /* JVM_Lseek */
2208
2209 jlong JVM_Lseek(jint fd, jlong offset, jint whence)
2210 {
2211         TRACEJVMCALLS(("JVM_Lseek(fd=%d, offset=%ld, whence=%d)", fd, offset, whence));
2212
2213         return (jlong) system_lseek(fd, (off_t) offset, whence);
2214 }
2215
2216
2217 /* JVM_SetLength */
2218
2219 jint JVM_SetLength(jint fd, jlong length)
2220 {
2221         TRACEJVMCALLS(("JVM_SetLength(fd=%d, length=%ld)", length));
2222
2223         return system_ftruncate(fd, length);
2224 }
2225
2226
2227 /* JVM_Sync */
2228
2229 jint JVM_Sync(jint fd)
2230 {
2231         TRACEJVMCALLS(("JVM_Sync(fd=%d)", fd));
2232
2233         return system_fsync(fd);
2234 }
2235
2236
2237 /* JVM_StartThread */
2238
2239 void JVM_StartThread(JNIEnv* env, jobject jthread)
2240 {
2241         TRACEJVMCALLS(("JVM_StartThread(env=%p, jthread=%p)", env, jthread));
2242
2243         threads_thread_start((java_handle_t *) jthread);
2244 }
2245
2246
2247 /* JVM_StopThread */
2248
2249 void JVM_StopThread(JNIEnv* env, jobject jthread, jobject throwable)
2250 {
2251         log_println("JVM_StopThread: IMPLEMENT ME!");
2252 }
2253
2254
2255 /* JVM_IsThreadAlive */
2256
2257 jboolean JVM_IsThreadAlive(JNIEnv* env, jobject jthread)
2258 {
2259         java_handle_t *h;
2260         threadobject  *t;
2261         bool           equal;
2262         bool           result;
2263
2264         TRACEJVMCALLS(("JVM_IsThreadAlive(env=%p, jthread=%p)", env, jthread));
2265
2266         h = (java_handle_t *) jthread;
2267
2268         /* XXX this is just a quick hack */
2269
2270         for (t = threadlist_first(); t != NULL; t = threadlist_next(t)) {
2271                 LLNI_equals(t->object, h, equal);
2272
2273                 if (equal == true)
2274                         break;
2275         }
2276
2277         /* The threadobject is null when a thread is created in Java. The
2278            priority is set later during startup. */
2279
2280         if (t == NULL)
2281                 return 0;
2282
2283         result = threads_thread_is_alive(t);
2284
2285         return result;
2286 }
2287
2288
2289 /* JVM_SuspendThread */
2290
2291 void JVM_SuspendThread(JNIEnv* env, jobject jthread)
2292 {
2293         log_println("JVM_SuspendThread: IMPLEMENT ME!");
2294 }
2295
2296
2297 /* JVM_ResumeThread */
2298
2299 void JVM_ResumeThread(JNIEnv* env, jobject jthread)
2300 {
2301         log_println("JVM_ResumeThread: IMPLEMENT ME!");
2302 }
2303
2304
2305 /* JVM_SetThreadPriority */
2306
2307 void JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio)
2308 {
2309         java_handle_t *h;
2310         threadobject  *t;
2311
2312         TRACEJVMCALLS(("JVM_SetThreadPriority(env=%p, jthread=%p, prio=%d)", env, jthread, prio));
2313
2314         h = (java_handle_t *) jthread;
2315
2316         /* XXX this is just a quick hack */
2317
2318         for (t = threadlist_first(); t != NULL; t = threadlist_next(t)) {
2319                 if (t->object == h)
2320                         break;
2321         }
2322
2323         /* The threadobject is null when a thread is created in Java. The
2324            priority is set later during startup. */
2325
2326         if (t == NULL)
2327                 return;
2328
2329         threads_set_thread_priority(t->tid, prio);
2330 }
2331
2332
2333 /* JVM_Yield */
2334
2335 void JVM_Yield(JNIEnv *env, jclass threadClass)
2336 {
2337         TRACEJVMCALLS(("JVM_Yield(env=%p, threadClass=%p)", env, threadClass));
2338
2339         threads_yield();
2340 }
2341
2342
2343 /* JVM_Sleep */
2344
2345 void JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis)
2346 {
2347         TRACEJVMCALLS(("JVM_Sleep(env=%p, threadClass=%p, millis=%ld)", env, threadClass, millis));
2348
2349         threads_sleep(millis, 0);
2350 }
2351
2352
2353 /* JVM_CurrentThread */
2354
2355 jobject JVM_CurrentThread(JNIEnv* env, jclass threadClass)
2356 {
2357         java_object_t *o;
2358
2359         TRACEJVMCALLSVERBOSE(("JVM_CurrentThread(env=%p, threadClass=%p)", env, threadClass));
2360
2361         o = threads_get_current_object();
2362
2363         return (jobject) o;
2364 }
2365
2366
2367 /* JVM_CountStackFrames */
2368
2369 jint JVM_CountStackFrames(JNIEnv* env, jobject jthread)
2370 {
2371         log_println("JVM_CountStackFrames: IMPLEMENT ME!");
2372
2373         return 0;
2374 }
2375
2376
2377 /* JVM_Interrupt */
2378
2379 void JVM_Interrupt(JNIEnv* env, jobject jthread)
2380 {
2381         log_println("JVM_Interrupt: IMPLEMENT ME!");
2382 }
2383
2384
2385 /* JVM_IsInterrupted */
2386
2387 jboolean JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted)
2388 {
2389         java_handle_t *h;
2390         threadobject  *t;
2391
2392         TRACEJVMCALLS(("JVM_IsInterrupted(env=%p, jthread=%p, clear_interrupted=%d)", env, jthread, clear_interrupted));
2393
2394         h = (java_handle_t *) jthread;
2395
2396         /* XXX do something with clear_interrupted */
2397
2398         /* XXX this is just a quick hack */
2399
2400         for (t = threadlist_first(); t != NULL; t = threadlist_next(t)) {
2401                 if (t->object == h)
2402                         break;
2403         }
2404
2405         return threads_thread_has_been_interrupted(t);
2406 }
2407
2408
2409 /* JVM_HoldsLock */
2410
2411 jboolean JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj)
2412 {
2413         java_handle_t *h;
2414         bool           result;
2415
2416         TRACEJVMCALLS(("JVM_HoldsLock(env=%p, threadClass=%p, obj=%p)", env, threadClass, obj));
2417
2418         h = (java_handle_t *) obj;
2419
2420         if (h == NULL) {
2421                 exceptions_throw_nullpointerexception();
2422                 return JNI_FALSE;
2423         }
2424
2425         result = lock_is_held_by_current_thread(h);
2426
2427         return result;
2428 }
2429
2430
2431 /* JVM_DumpAllStacks */
2432
2433 void JVM_DumpAllStacks(JNIEnv* env, jclass unused)
2434 {
2435         log_println("JVM_DumpAllStacks: IMPLEMENT ME!");
2436 }
2437
2438
2439 /* JVM_CurrentLoadedClass */
2440
2441 jclass JVM_CurrentLoadedClass(JNIEnv *env)
2442 {
2443         log_println("JVM_CurrentLoadedClass: IMPLEMENT ME!");
2444
2445         return NULL;
2446 }
2447
2448
2449 /* JVM_CurrentClassLoader */
2450
2451 jobject JVM_CurrentClassLoader(JNIEnv *env)
2452 {
2453     /* XXX if a method in a class in a trusted loader is in a
2454            doPrivileged, return NULL */
2455
2456         log_println("JVM_CurrentClassLoader: IMPLEMENT ME!");
2457
2458         return NULL;
2459 }
2460
2461
2462 /* JVM_GetClassContext */
2463
2464 jobjectArray JVM_GetClassContext(JNIEnv *env)
2465 {
2466         TRACEJVMCALLS(("JVM_GetClassContext(env=%p)", env));
2467
2468         return (jobjectArray) stacktrace_getClassContext();
2469 }
2470
2471
2472 /* JVM_ClassDepth */
2473
2474 jint JVM_ClassDepth(JNIEnv *env, jstring name)
2475 {
2476         log_println("JVM_ClassDepth: IMPLEMENT ME!");
2477
2478         return 0;
2479 }
2480
2481
2482 /* JVM_ClassLoaderDepth */
2483
2484 jint JVM_ClassLoaderDepth(JNIEnv *env)
2485 {
2486         log_println("JVM_ClassLoaderDepth: IMPLEMENT ME!");
2487
2488         return 0;
2489 }
2490
2491
2492 /* JVM_GetSystemPackage */
2493
2494 jstring JVM_GetSystemPackage(JNIEnv *env, jstring name)
2495 {
2496         java_handle_t *s;
2497         utf *u;
2498         utf *result;
2499
2500         TRACEJVMCALLS(("JVM_GetSystemPackage(env=%p, name=%p)", env, name));
2501
2502 /*      s = package_find(name); */
2503         u = javastring_toutf((java_handle_t *) name, false);
2504
2505         result = package_find(u);
2506
2507         if (result != NULL)
2508                 s = javastring_new(result);
2509         else
2510                 s = NULL;
2511
2512         return (jstring) s;
2513 }
2514
2515
2516 /* JVM_GetSystemPackages */
2517
2518 jobjectArray JVM_GetSystemPackages(JNIEnv *env)
2519 {
2520         log_println("JVM_GetSystemPackages: IMPLEMENT ME!");
2521
2522         return NULL;
2523 }
2524
2525
2526 /* JVM_AllocateNewObject */
2527
2528 jobject JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass)
2529 {
2530         log_println("JVM_AllocateNewObject: IMPLEMENT ME!");
2531
2532         return NULL;
2533 }
2534
2535
2536 /* JVM_AllocateNewArray */
2537
2538 jobject JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length)
2539 {
2540         log_println("JVM_AllocateNewArray: IMPLEMENT ME!");
2541
2542         return NULL;
2543 }
2544
2545
2546 /* JVM_LatestUserDefinedLoader */
2547
2548 jobject JVM_LatestUserDefinedLoader(JNIEnv *env)
2549 {
2550         classloader *cl;
2551
2552         TRACEJVMCALLS(("JVM_LatestUserDefinedLoader(env=%p)", env));
2553
2554         cl = stacktrace_first_nonnull_classloader();
2555
2556         return (jobject) cl;
2557 }
2558
2559
2560 /* JVM_LoadClass0 */
2561
2562 jclass JVM_LoadClass0(JNIEnv *env, jobject receiver, jclass currClass, jstring currClassName)
2563 {
2564         log_println("JVM_LoadClass0: IMPLEMENT ME!");
2565
2566         return NULL;
2567 }
2568
2569
2570 /* JVM_GetArrayLength */
2571
2572 jint JVM_GetArrayLength(JNIEnv *env, jobject arr)
2573 {
2574         java_handle_t *a;
2575
2576         TRACEJVMCALLS(("JVM_GetArrayLength(arr=%p)", arr));
2577
2578         a = (java_handle_t *) arr;
2579
2580         return array_length_get(a);
2581 }
2582
2583
2584 /* JVM_GetArrayElement */
2585
2586 jobject JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index)
2587 {
2588         java_handle_t *a;
2589         java_handle_t *o;
2590
2591         TRACEJVMCALLS(("JVM_GetArrayElement(env=%p, arr=%p, index=%d)", env, arr, index));
2592
2593         a = (java_handle_t *) arr;
2594
2595 /*      if (!class_is_array(a->objheader.vftbl->class)) { */
2596 /*              exceptions_throw_illegalargumentexception(); */
2597 /*              return NULL; */
2598 /*      } */
2599
2600         o = array_element_get(a, index);
2601
2602         return (jobject) o;
2603 }
2604
2605
2606 /* JVM_GetPrimitiveArrayElement */
2607
2608 jvalue JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode)
2609 {
2610         jvalue jv;
2611
2612         log_println("JVM_GetPrimitiveArrayElement: IMPLEMENT ME!");
2613
2614         jv.l = NULL;
2615
2616         return jv;
2617 }
2618
2619
2620 /* JVM_SetArrayElement */
2621
2622 void JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val)
2623 {
2624         java_handle_t *a;
2625         java_handle_t *value;
2626
2627         TRACEJVMCALLS(("JVM_SetArrayElement(env=%p, arr=%p, index=%d, val=%p)", env, arr, index, val));
2628
2629         a     = (java_handle_t *) arr;
2630         value = (java_handle_t *) val;
2631
2632         array_element_set(a, index, value);
2633 }
2634
2635
2636 /* JVM_SetPrimitiveArrayElement */
2637
2638 void JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode)
2639 {
2640         log_println("JVM_SetPrimitiveArrayElement: IMPLEMENT ME!");
2641 }
2642
2643
2644 /* JVM_NewArray */
2645
2646 jobject JVM_NewArray(JNIEnv *env, jclass eltClass, jint length)
2647 {
2648         classinfo                 *c;
2649         classinfo                 *pc;
2650         java_handle_t             *a;
2651         java_handle_objectarray_t *oa;
2652
2653         TRACEJVMCALLS(("JVM_NewArray(env=%p, eltClass=%p, length=%d)", env, eltClass, length));
2654
2655         if (eltClass == NULL) {
2656                 exceptions_throw_nullpointerexception();
2657                 return NULL;
2658         }
2659
2660         /* NegativeArraySizeException is checked in builtin_newarray. */
2661
2662         c = LLNI_classinfo_unwrap(eltClass);
2663
2664         /* create primitive or object array */
2665
2666         if (class_is_primitive(c)) {
2667                 pc = primitive_arrayclass_get_by_name(c->name);
2668                 a = builtin_newarray(length, pc);
2669
2670                 return (jobject) a;
2671         }
2672         else {
2673                 oa = builtin_anewarray(length, c);
2674
2675                 return (jobject) oa;
2676         }
2677 }
2678
2679
2680 /* JVM_NewMultiArray */
2681
2682 jobject JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim)
2683 {
2684         classinfo                 *c;
2685         java_handle_intarray_t    *ia;
2686         int32_t                    length;
2687         long                      *dims;
2688         int32_t                    value;
2689         int32_t                    i;
2690         classinfo                 *ac;
2691         java_handle_objectarray_t *a;
2692
2693         TRACEJVMCALLS(("JVM_NewMultiArray(env=%p, eltClass=%p, dim=%p)", env, eltClass, dim));
2694
2695         if (eltClass == NULL) {
2696                 exceptions_throw_nullpointerexception();
2697                 return NULL;
2698         }
2699
2700         /* NegativeArraySizeException is checked in builtin_newarray. */
2701
2702         c = LLNI_classinfo_unwrap(eltClass);
2703
2704         /* XXX This is just a quick hack to get it working. */
2705
2706         ia = (java_handle_intarray_t *) dim;
2707
2708         length = array_length_get((java_handle_t *) ia);
2709
2710         dims = MNEW(long, length);
2711
2712         for (i = 0; i < length; i++) {
2713                 value = LLNI_array_direct(ia, i);
2714                 dims[i] = (long) value;
2715         }
2716
2717         /* Create an array-class if necessary. */
2718
2719         if (class_is_primitive(c))
2720                 ac = primitive_arrayclass_get_by_name(c->name);
2721         else
2722                 ac = class_array_of(c, true);
2723
2724         if (ac == NULL)
2725                 return NULL;
2726
2727         a = builtin_multianewarray(length, (java_handle_t *) ac, dims);
2728
2729         return (jobject) a;
2730 }
2731
2732
2733 /* JVM_InitializeSocketLibrary */
2734
2735 jint JVM_InitializeSocketLibrary()
2736 {
2737         log_println("JVM_InitializeSocketLibrary: IMPLEMENT ME!");
2738
2739         return 0;
2740 }
2741
2742
2743 /* JVM_Socket */
2744
2745 jint JVM_Socket(jint domain, jint type, jint protocol)
2746 {
2747         TRACEJVMCALLS(("JVM_Socket(domain=%d, type=%d, protocol=%d)", domain, type, protocol));
2748
2749         return system_socket(domain, type, protocol);
2750 }
2751
2752
2753 /* JVM_SocketClose */
2754
2755 jint JVM_SocketClose(jint fd)
2756 {
2757         TRACEJVMCALLS(("JVM_SocketClose(fd=%d)", fd));
2758
2759         return system_close(fd);
2760 }
2761
2762
2763 /* JVM_SocketShutdown */
2764
2765 jint JVM_SocketShutdown(jint fd, jint howto)
2766 {
2767         TRACEJVMCALLS(("JVM_SocketShutdown(fd=%d, howto=%d)", fd, howto));
2768
2769         return system_shutdown(fd, howto);
2770 }
2771
2772
2773 /* JVM_Recv */
2774
2775 jint JVM_Recv(jint fd, char *buf, jint nBytes, jint flags)
2776 {
2777         log_println("JVM_Recv: IMPLEMENT ME!");
2778
2779         return 0;
2780 }
2781
2782
2783 /* JVM_Send */
2784
2785 jint JVM_Send(jint fd, char *buf, jint nBytes, jint flags)
2786 {
2787         log_println("JVM_Send: IMPLEMENT ME!");
2788
2789         return 0;
2790 }
2791
2792
2793 /* JVM_Timeout */
2794
2795 jint JVM_Timeout(int fd, long timeout)
2796 {
2797         log_println("JVM_Timeout: IMPLEMENT ME!");
2798
2799         return 0;
2800 }
2801
2802
2803 /* JVM_Listen */
2804
2805 jint JVM_Listen(jint fd, jint count)
2806 {
2807         TRACEJVMCALLS(("JVM_Listen(fd=%d, count=%d)", fd, count));
2808
2809         return system_listen(fd, count);
2810 }
2811
2812
2813 /* JVM_Connect */
2814
2815 jint JVM_Connect(jint fd, struct sockaddr *him, jint len)
2816 {
2817         TRACEJVMCALLS(("JVM_Connect(fd=%d, him=%p, len=%d)", fd, him, len));
2818
2819         return system_connect(fd, him, len);
2820 }
2821
2822
2823 /* JVM_Bind */
2824
2825 jint JVM_Bind(jint fd, struct sockaddr *him, jint len)
2826 {
2827         log_println("JVM_Bind: IMPLEMENT ME!");
2828
2829         return 0;
2830 }
2831
2832
2833 /* JVM_Accept */
2834
2835 jint JVM_Accept(jint fd, struct sockaddr *him, jint *len)
2836 {
2837         TRACEJVMCALLS(("JVM_Accept(fd=%d, him=%p, len=%p)", fd, him, len));
2838
2839         return system_accept(fd, him, (socklen_t *) len);
2840 }
2841
2842
2843 /* JVM_RecvFrom */
2844
2845 jint JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen)
2846 {
2847         log_println("JVM_RecvFrom: IMPLEMENT ME!");
2848
2849         return 0;
2850 }
2851
2852
2853 /* JVM_GetSockName */
2854
2855 jint JVM_GetSockName(jint fd, struct sockaddr *him, int *len)
2856 {
2857         TRACEJVMCALLS(("JVM_GetSockName(fd=%d, him=%p, len=%p)", fd, him, len));
2858
2859         return system_getsockname(fd, him, (socklen_t *) len);
2860 }
2861
2862
2863 /* JVM_SendTo */
2864
2865 jint JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen)
2866 {
2867         log_println("JVM_SendTo: IMPLEMENT ME!");
2868
2869         return 0;
2870 }
2871
2872
2873 /* JVM_SocketAvailable */
2874
2875 jint JVM_SocketAvailable(jint fd, jint *pbytes)
2876 {
2877 #if defined(FIONREAD)
2878         int bytes;
2879         int result;
2880
2881         TRACEJVMCALLS(("JVM_SocketAvailable(fd=%d, pbytes=%p)", fd, pbytes));
2882
2883         *pbytes = 0;
2884
2885         result = ioctl(fd, FIONREAD, &bytes);
2886
2887         if (result < 0)
2888                 return 0;
2889
2890         *pbytes = bytes;
2891
2892         return 1;
2893 #else
2894 # error FIONREAD not defined
2895 #endif
2896 }
2897
2898
2899 /* JVM_GetSockOpt */
2900
2901 jint JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen)
2902 {
2903         TRACEJVMCALLS(("JVM_GetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%p)", fd, level, optname, optval, optlen));
2904
2905         return system_getsockopt(fd, level, optname, optval, (socklen_t *) optlen);
2906 }
2907
2908
2909 /* JVM_SetSockOpt */
2910
2911 jint JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen)
2912 {
2913         TRACEJVMCALLS(("JVM_SetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%d)", fd, level, optname, optval, optlen));
2914
2915         return system_setsockopt(fd, level, optname, optval, optlen);
2916 }
2917
2918
2919 /* JVM_GetHostName */
2920
2921 int JVM_GetHostName(char *name, int namelen)
2922 {
2923         TRACEJVMCALLS(("JVM_GetHostName(name=%s, namelen=%d)", name, namelen));
2924
2925         return system_gethostname(name, namelen);
2926 }
2927
2928
2929 /* JVM_GetHostByAddr */
2930
2931 struct hostent *JVM_GetHostByAddr(const char* name, int len, int type)
2932 {
2933         log_println("JVM_GetHostByAddr: IMPLEMENT ME!");
2934
2935         return NULL;
2936 }
2937
2938
2939 /* JVM_GetHostByName */
2940
2941 struct hostent *JVM_GetHostByName(char* name)
2942 {
2943         log_println("JVM_GetHostByName: IMPLEMENT ME!");
2944
2945         return NULL;
2946 }
2947
2948
2949 /* JVM_GetProtoByName */
2950
2951 struct protoent *JVM_GetProtoByName(char* name)
2952 {
2953         log_println("JVM_GetProtoByName: IMPLEMENT ME!");
2954
2955         return NULL;
2956 }
2957
2958
2959 /* JVM_LoadLibrary */
2960
2961 void *JVM_LoadLibrary(const char *name)
2962 {
2963         utf *u;
2964
2965         TRACEJVMCALLS(("JVM_LoadLibrary(name=%s)", name));
2966
2967         u = utf_new_char(name);
2968
2969         return native_library_open(u);
2970 }
2971
2972
2973 /* JVM_UnloadLibrary */
2974
2975 void JVM_UnloadLibrary(void* handle)
2976 {
2977         TRACEJVMCALLS(("JVM_UnloadLibrary(handle=%p)", handle));
2978
2979         native_library_close(handle);
2980 }
2981
2982
2983 /* JVM_FindLibraryEntry */
2984
2985 void *JVM_FindLibraryEntry(void *handle, const char *name)
2986 {
2987         lt_ptr symbol;
2988
2989         TRACEJVMCALLS(("JVM_FindLibraryEntry(handle=%p, name=%s)", handle, name));
2990
2991         symbol = lt_dlsym(handle, name);
2992
2993         return symbol;
2994 }
2995
2996
2997 /* JVM_IsNaN */
2998
2999 jboolean JVM_IsNaN(jdouble a)
3000 {
3001         log_println("JVM_IsNaN: IMPLEMENT ME!");
3002
3003         return 0;
3004 }
3005
3006
3007 /* JVM_IsSupportedJNIVersion */
3008
3009 jboolean JVM_IsSupportedJNIVersion(jint version)
3010 {
3011         TRACEJVMCALLS(("JVM_IsSupportedJNIVersion(version=%d)", version));
3012
3013         return jni_version_check(version);
3014 }
3015
3016
3017 /* JVM_InternString */
3018
3019 jstring JVM_InternString(JNIEnv *env, jstring str)
3020 {
3021         TRACEJVMCALLS(("JVM_InternString(env=%p, str=%p)", env, str));
3022
3023         return (jstring) javastring_intern((java_handle_t *) str);
3024 }
3025
3026
3027 /* JVM_RawMonitorCreate */
3028
3029 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void)
3030 {
3031         java_object_t *o;
3032
3033         TRACEJVMCALLS(("JVM_RawMonitorCreate()"));
3034
3035         o = NEW(java_object_t);
3036
3037         lock_init_object_lock(o);
3038
3039         return o;
3040 }
3041
3042
3043 /* JVM_RawMonitorDestroy */
3044
3045 JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void *mon)
3046 {
3047         TRACEJVMCALLS(("JVM_RawMonitorDestroy(mon=%p)", mon));
3048
3049         FREE(mon, java_object_t);
3050 }
3051
3052
3053 /* JVM_RawMonitorEnter */
3054
3055 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void *mon)
3056 {
3057         TRACEJVMCALLS(("JVM_RawMonitorEnter(mon=%p)", mon));
3058
3059         (void) lock_monitor_enter((java_object_t *) mon);
3060
3061         return 0;
3062 }
3063
3064
3065 /* JVM_RawMonitorExit */
3066
3067 JNIEXPORT void JNICALL JVM_RawMonitorExit(void *mon)
3068 {
3069         TRACEJVMCALLS(("JVM_RawMonitorExit(mon=%p)", mon));
3070
3071         (void) lock_monitor_exit((java_object_t *) mon);
3072 }
3073
3074
3075 /* JVM_SetPrimitiveFieldValues */
3076
3077 void JVM_SetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
3078 {
3079         log_println("JVM_SetPrimitiveFieldValues: IMPLEMENT ME!");
3080 }
3081
3082
3083 /* JVM_GetPrimitiveFieldValues */
3084
3085 void JVM_GetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
3086 {
3087         log_println("JVM_GetPrimitiveFieldValues: IMPLEMENT ME!");
3088 }
3089
3090
3091 /* JVM_AccessVMBooleanFlag */
3092
3093 jboolean JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get)
3094 {
3095         log_println("JVM_AccessVMBooleanFlag: IMPLEMENT ME!");
3096
3097         return 0;
3098 }
3099
3100
3101 /* JVM_AccessVMIntFlag */
3102
3103 jboolean JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get)
3104 {
3105         log_println("JVM_AccessVMIntFlag: IMPLEMENT ME!");
3106
3107         return 0;
3108 }
3109
3110
3111 /* JVM_VMBreakPoint */
3112
3113 void JVM_VMBreakPoint(JNIEnv *env, jobject obj)
3114 {
3115         log_println("JVM_VMBreakPoint: IMPLEMENT ME!");
3116 }
3117
3118
3119 /* JVM_GetClassFields */
3120
3121 jobjectArray JVM_GetClassFields(JNIEnv *env, jclass cls, jint which)
3122 {
3123         log_println("JVM_GetClassFields: IMPLEMENT ME!");
3124
3125         return NULL;
3126 }
3127
3128
3129 /* JVM_GetClassMethods */
3130
3131 jobjectArray JVM_GetClassMethods(JNIEnv *env, jclass cls, jint which)
3132 {
3133         log_println("JVM_GetClassMethods: IMPLEMENT ME!");
3134
3135         return NULL;
3136 }
3137
3138
3139 /* JVM_GetClassConstructors */
3140
3141 jobjectArray JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which)
3142 {
3143         log_println("JVM_GetClassConstructors: IMPLEMENT ME!");
3144
3145         return NULL;
3146 }
3147
3148
3149 /* JVM_GetClassField */
3150
3151 jobject JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which)
3152 {
3153         log_println("JVM_GetClassField: IMPLEMENT ME!");
3154
3155         return NULL;
3156 }
3157
3158
3159 /* JVM_GetClassMethod */
3160
3161 jobject JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types, jint which)
3162 {
3163         log_println("JVM_GetClassMethod: IMPLEMENT ME!");
3164
3165         return NULL;
3166 }
3167
3168
3169 /* JVM_GetClassConstructor */
3170
3171 jobject JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types, jint which)
3172 {
3173         log_println("JVM_GetClassConstructor: IMPLEMENT ME!");
3174
3175         return NULL;
3176 }
3177
3178
3179 /* JVM_NewInstance */
3180
3181 jobject JVM_NewInstance(JNIEnv *env, jclass cls)
3182 {
3183         log_println("JVM_NewInstance: IMPLEMENT ME!");
3184
3185         return NULL;
3186 }
3187
3188
3189 /* JVM_GetField */
3190
3191 jobject JVM_GetField(JNIEnv *env, jobject field, jobject obj)
3192 {
3193         log_println("JVM_GetField: IMPLEMENT ME!");
3194
3195         return NULL;
3196 }
3197
3198
3199 /* JVM_GetPrimitiveField */
3200
3201 jvalue JVM_GetPrimitiveField(JNIEnv *env, jobject field, jobject obj, unsigned char wCode)
3202 {
3203         jvalue jv;
3204
3205         log_println("JVM_GetPrimitiveField: IMPLEMENT ME!");
3206
3207         jv.l = NULL;
3208
3209         return jv;
3210 }
3211
3212
3213 /* JVM_SetField */
3214
3215 void JVM_SetField(JNIEnv *env, jobject field, jobject obj, jobject val)
3216 {
3217         log_println("JVM_SetField: IMPLEMENT ME!");
3218 }
3219
3220
3221 /* JVM_SetPrimitiveField */
3222
3223 void JVM_SetPrimitiveField(JNIEnv *env, jobject field, jobject obj, jvalue v, unsigned char vCode)
3224 {
3225         log_println("JVM_SetPrimitiveField: IMPLEMENT ME!");
3226 }
3227
3228
3229 /* JVM_InvokeMethod */
3230
3231 jobject JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)
3232 {
3233         TRACEJVMCALLS(("JVM_InvokeMethod(env=%p, method=%p, obj=%p, args0=%p)", env, method, obj, args0));
3234
3235         return (jobject) _Jv_java_lang_reflect_Method_invoke((java_lang_reflect_Method *) method, (java_lang_Object *) obj, (java_handle_objectarray_t *) args0);
3236 }
3237
3238
3239 /* JVM_NewInstanceFromConstructor */
3240
3241 jobject JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0)
3242 {
3243         TRACEJVMCALLS(("JVM_NewInstanceFromConstructor(env=%p, c=%p, args0=%p)", env, c, args0));
3244
3245         return (jobject) _Jv_java_lang_reflect_Constructor_newInstance(env, (java_lang_reflect_Constructor *) c, (java_handle_objectarray_t *) args0);
3246 }
3247
3248
3249 /* JVM_SupportsCX8 */
3250
3251 jboolean JVM_SupportsCX8()
3252 {
3253         TRACEJVMCALLS(("JVM_SupportsCX8()"));
3254
3255         /* IMPLEMENT ME */
3256
3257         return 0;
3258 }
3259
3260
3261 /* JVM_CX8Field */
3262
3263 jboolean JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal)
3264 {
3265         log_println("JVM_CX8Field: IMPLEMENT ME!");
3266
3267         return 0;
3268 }
3269
3270
3271 /* JVM_GetAllThreads */
3272
3273 jobjectArray JVM_GetAllThreads(JNIEnv *env, jclass dummy)
3274 {
3275         log_println("JVM_GetAllThreads: IMPLEMENT ME!");
3276
3277         return NULL;
3278 }
3279
3280
3281 /* JVM_DumpThreads */
3282
3283 jobjectArray JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads)
3284 {
3285         log_println("JVM_DumpThreads: IMPLEMENT ME!");
3286
3287         return NULL;
3288 }
3289
3290
3291 /* JVM_GetManagement */
3292
3293 void *JVM_GetManagement(jint version)
3294 {
3295         TRACEJVMCALLS(("JVM_GetManagement(version=%d)", version));
3296
3297         /* TODO We current don't support the management interface. */
3298
3299         return NULL;
3300 }
3301
3302
3303 /* JVM_InitAgentProperties */
3304
3305 jobject JVM_InitAgentProperties(JNIEnv *env, jobject properties)
3306 {
3307         log_println("JVM_InitAgentProperties: IMPLEMENT ME!");
3308
3309         return NULL;
3310 }
3311
3312
3313 /* JVM_GetEnclosingMethodInfo */
3314
3315 jobjectArray JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass)
3316 {
3317         classinfo                 *c;
3318         methodinfo                *m;
3319         java_handle_objectarray_t *oa;
3320
3321         TRACEJVMCALLS(("JVM_GetEnclosingMethodInfo(env=%p, ofClass=%p)", env, ofClass));
3322
3323         c = LLNI_classinfo_unwrap(ofClass);
3324
3325         if ((c == NULL) || class_is_primitive(c))
3326                 return NULL;
3327
3328         m = class_get_enclosingmethod(c);
3329
3330         if (m == NULL)
3331                 return NULL;
3332
3333         oa = builtin_anewarray(3, class_java_lang_Object);
3334
3335         if (oa == NULL)
3336                 return NULL;
3337
3338         array_objectarray_element_set(oa, 0, (java_handle_t *) LLNI_classinfo_wrap(m->class));
3339         array_objectarray_element_set(oa, 1, javastring_new(m->name));
3340         array_objectarray_element_set(oa, 2, javastring_new(m->descriptor));
3341
3342         return (jobjectArray) oa;
3343 }
3344
3345
3346 /* JVM_GetThreadStateValues */
3347
3348 jintArray JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState)
3349 {
3350         java_handle_intarray_t *ia;
3351
3352         TRACEJVMCALLS(("JVM_GetThreadStateValues(env=%p, javaThreadState=%d)",
3353                                   env, javaThreadState));
3354
3355         /* If new thread states are added in future JDK and VM versions,
3356            this should check if the JDK version is compatible with thread
3357            states supported by the VM.  Return NULL if not compatible.
3358
3359            This function must map the VM java_lang_Thread::ThreadStatus
3360            to the Java thread state that the JDK supports. */
3361
3362         switch (javaThreadState) {
3363     case THREAD_STATE_NEW:
3364                 ia = builtin_newarray_int(1);
3365
3366                 if (ia == NULL)
3367                         return NULL;
3368
3369                 array_intarray_element_set(ia, 0, THREAD_STATE_NEW);
3370                 break;
3371
3372     case THREAD_STATE_RUNNABLE:
3373                 ia = builtin_newarray_int(1);
3374
3375                 if (ia == NULL)
3376                         return NULL;
3377
3378                 array_intarray_element_set(ia, 0, THREAD_STATE_RUNNABLE);
3379                 break;
3380
3381     case THREAD_STATE_BLOCKED:
3382                 ia = builtin_newarray_int(1);
3383
3384                 if (ia == NULL)
3385                         return NULL;
3386
3387                 array_intarray_element_set(ia, 0, THREAD_STATE_BLOCKED);
3388                 break;
3389
3390     case THREAD_STATE_WAITING:
3391                 ia = builtin_newarray_int(2);
3392
3393                 if (ia == NULL)
3394                         return NULL;
3395
3396                 array_intarray_element_set(ia, 0, THREAD_STATE_WAITING);
3397                 /* XXX Implement parked stuff. */
3398 /*              array_intarray_element_set(ia, 1, PARKED); */
3399                 break;
3400
3401     case THREAD_STATE_TIMED_WAITING:
3402                 ia = builtin_newarray_int(3);
3403
3404                 if (ia == NULL)
3405                         return NULL;
3406
3407                 /* XXX Not sure about that one. */
3408 /*              array_intarray_element_set(ia, 0, SLEEPING); */
3409                 array_intarray_element_set(ia, 0, THREAD_STATE_TIMED_WAITING);
3410                 /* XXX Implement parked stuff. */
3411 /*              array_intarray_element_set(ia, 2, PARKED); */
3412                 break;
3413
3414     case THREAD_STATE_TERMINATED:
3415                 ia = builtin_newarray_int(1);
3416
3417                 if (ia == NULL)
3418                         return NULL;
3419
3420                 array_intarray_element_set(ia, 0, THREAD_STATE_TERMINATED);
3421                 break;
3422
3423     default:
3424                 /* Unknown state - probably incompatible JDK version */
3425                 return NULL;
3426         }
3427
3428         return (jintArray) ia;
3429 }
3430
3431
3432 /* JVM_GetThreadStateNames */
3433
3434 jobjectArray JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values)
3435 {
3436         java_handle_intarray_t    *ia;
3437         java_handle_objectarray_t *oa;
3438         java_object_t             *s;
3439
3440         TRACEJVMCALLS(("JVM_GetThreadStateNames(env=%p, javaThreadState=%d, values=%p)",
3441                                   env, javaThreadState, values));
3442
3443         ia = (java_handle_intarray_t *) values;
3444
3445         /* If new thread states are added in future JDK and VM versions,
3446            this should check if the JDK version is compatible with thread
3447            states supported by the VM.  Return NULL if not compatible.
3448
3449            This function must map the VM java_lang_Thread::ThreadStatus
3450            to the Java thread state that the JDK supports. */
3451
3452         if (values == NULL) {
3453                 exceptions_throw_nullpointerexception();
3454                 return NULL;
3455         }
3456
3457         switch (javaThreadState) {
3458     case THREAD_STATE_NEW:
3459                 assert(ia->header.size == 1 && ia->data[0] == THREAD_STATE_NEW);
3460
3461                 oa = builtin_anewarray(1, class_java_lang_String);
3462
3463                 if (oa == NULL)
3464                         return NULL;
3465
3466                 s = javastring_new(utf_new_char("NEW"));
3467
3468                 if (s == NULL)
3469                         return NULL;
3470
3471                 array_objectarray_element_set(oa, 0, s);
3472                 break;
3473
3474     case THREAD_STATE_RUNNABLE:
3475                 oa = builtin_anewarray(1, class_java_lang_String);
3476
3477                 if (oa == NULL)
3478                         return NULL;
3479
3480                 s = javastring_new(utf_new_char("RUNNABLE"));
3481
3482                 if (s == NULL)
3483                         return NULL;
3484
3485                 array_objectarray_element_set(oa, 0, s);
3486                 break;
3487
3488     case THREAD_STATE_BLOCKED:
3489                 oa = builtin_anewarray(1, class_java_lang_String);
3490
3491                 if (oa == NULL)
3492                         return NULL;
3493
3494                 s = javastring_new(utf_new_char("BLOCKED"));
3495
3496                 if (s == NULL)
3497                         return NULL;
3498
3499                 array_objectarray_element_set(oa, 0, s);
3500                 break;
3501
3502     case THREAD_STATE_WAITING:
3503                 oa = builtin_anewarray(2, class_java_lang_String);
3504
3505                 if (oa == NULL)
3506                         return NULL;
3507
3508                 s = javastring_new(utf_new_char("WAITING.OBJECT_WAIT"));
3509 /*              s = javastring_new(utf_new_char("WAITING.PARKED")); */
3510
3511                 if (s == NULL)
3512                         return NULL;
3513
3514                 array_objectarray_element_set(oa, 0, s);
3515 /*              array_objectarray_element_set(oa, 1, s); */
3516                 break;
3517
3518     case THREAD_STATE_TIMED_WAITING:
3519                 oa = builtin_anewarray(3, class_java_lang_String);
3520
3521                 if (oa == NULL)
3522                         return NULL;
3523
3524 /*              s = javastring_new(utf_new_char("TIMED_WAITING.SLEEPING")); */
3525                 s = javastring_new(utf_new_char("TIMED_WAITING.OBJECT_WAIT"));
3526 /*              s = javastring_new(utf_new_char("TIMED_WAITING.PARKED")); */
3527
3528                 if (s == NULL)
3529                         return NULL;
3530
3531 /*              array_objectarray_element_set(oa, 0, s); */
3532                 array_objectarray_element_set(oa, 0, s);
3533 /*              array_objectarray_element_set(oa, 2, s); */
3534                 break;
3535
3536     case THREAD_STATE_TERMINATED:
3537                 oa = builtin_anewarray(1, class_java_lang_String);
3538
3539                 if (oa == NULL)
3540                         return NULL;
3541
3542                 s = javastring_new(utf_new_char("TERMINATED"));
3543
3544                 if (s == NULL)
3545                         return NULL;
3546
3547                 array_objectarray_element_set(oa, 0, s);
3548                 break;
3549
3550         default:
3551                 /* Unknown state - probably incompatible JDK version */
3552                 return NULL;
3553         }
3554
3555         return (jobjectArray) oa;
3556 }
3557
3558
3559 /* JVM_GetVersionInfo */
3560
3561 void JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size)
3562 {
3563         log_println("JVM_GetVersionInfo: IMPLEMENT ME!");
3564 }
3565
3566
3567 /* OS: JVM_RegisterSignal */
3568
3569 void *JVM_RegisterSignal(jint sig, void *handler)
3570 {
3571         functionptr newHandler;
3572
3573         TRACEJVMCALLS(("JVM_RegisterSignal(sig=%d, handler=%p)", sig, handler));
3574
3575         if (handler == (void *) 2)
3576                 newHandler = (functionptr) signal_thread_handler;
3577         else
3578                 newHandler = (functionptr) (uintptr_t) handler;
3579
3580         switch (sig) {
3581     case SIGILL:
3582     case SIGFPE:
3583     case SIGUSR1:
3584     case SIGSEGV:
3585                 /* These signals are already used by the VM. */
3586                 return (void *) -1;
3587
3588     case SIGQUIT:
3589                 /* This signal is used by the VM to dump thread stacks unless
3590                    ReduceSignalUsage is set, in which case the user is allowed
3591                    to set his own _native_ handler for this signal; thus, in
3592                    either case, we do not allow JVM_RegisterSignal to change
3593                    the handler. */
3594                 return (void *) -1;
3595
3596         case SIGHUP:
3597         case SIGINT:
3598         case SIGTERM:
3599                 break;
3600         }
3601
3602         signal_register_signal(sig, newHandler, 0);
3603
3604         /* XXX Should return old handler. */
3605
3606         return (void *) 2;
3607 }
3608
3609
3610 /* OS: JVM_RaiseSignal */
3611
3612 jboolean JVM_RaiseSignal(jint sig)
3613 {
3614         log_println("JVM_RaiseSignal: IMPLEMENT ME! sig=%s", sig);
3615
3616         return false;
3617 }
3618
3619
3620 /* OS: JVM_FindSignal */
3621
3622 jint JVM_FindSignal(const char *name)
3623 {
3624         TRACEJVMCALLS(("JVM_FindSignal(name=%s)", name));
3625
3626 #if defined(__LINUX__)
3627         if (strcmp(name, "HUP") == 0)
3628                 return SIGHUP;
3629
3630         if (strcmp(name, "INT") == 0)
3631                 return SIGINT;
3632
3633         if (strcmp(name, "TERM") == 0)
3634                 return SIGTERM;
3635 #else
3636 # error not implemented for this OS
3637 #endif
3638
3639         return -1;
3640 }
3641
3642
3643 /*
3644  * These are local overrides for various environment variables in Emacs.
3645  * Please do not remove this and leave it at the end of the file, where
3646  * Emacs will automagically detect them.
3647  * ---------------------------------------------------------------------
3648  * Local variables:
3649  * mode: c
3650  * indent-tabs-mode: t
3651  * c-basic-offset: 4
3652  * tab-width: 4
3653  * End:
3654  */