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