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