src/native/vm/openjdk/jvm.cpp

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