1 /* src/native/vm/openjdk/jvm.cpp - HotSpot VM interface functions
3 Copyright (C) 1996-2011
4 CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
5 Copyright (C) 2009 Theobroma Systems Ltd.
7 This file is part of CACAO.
9 This program is free software; you can redistribute it and/or
10 modify it under the terms of the GNU General Public License as
11 published by the Free Software Foundation; either version 2, or (at
12 your option) any later version.
14 This program is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
36 #if defined(HAVE_SYS_IOCTL_H)
37 #define BSD_COMP /* Get FIONREAD on Solaris2 */
38 #include <sys/ioctl.h>
41 #include <sys/types.h>
43 // Include our JNI header before the JVM headers, because the JVM
44 // headers include jni.h and we want to override the typedefs in
46 #include "native/jni.hpp"
48 // We include jvm_md.h before jvm.h as the latter includes the former.
49 #include INCLUDE_JVM_MD_H
50 #include INCLUDE_JVM_H
52 #include "fdlibm/fdlibm.h"
54 #include "mm/memory.hpp"
56 #include "native/llni.h"
57 #include "native/native.hpp"
59 #include "native/vm/reflection.hpp"
61 #include "native/vm/openjdk/hpi.hpp"
62 #include "native/vm/openjdk/management.hpp"
64 #include "threads/lock.hpp"
65 #include "threads/thread.hpp"
66 #include "threads/threadlist.hpp"
68 #include "toolbox/logging.hpp"
69 #include "toolbox/list.hpp"
71 #include "vm/array.hpp"
73 #if defined(ENABLE_ASSERTION)
74 #include "vm/assertion.hpp"
77 #include "vm/jit/builtin.hpp"
78 #include "vm/classcache.hpp"
79 #include "vm/exceptions.hpp"
80 #include "vm/global.h"
81 #include "vm/globals.hpp"
82 #include "vm/initialize.hpp"
83 #include "vm/javaobjects.hpp"
84 #include "vm/options.h"
86 #include "vm/package.hpp"
87 #include "vm/primitive.hpp"
88 #include "vm/properties.hpp"
89 #include "vm/resolve.hpp"
90 #include "vm/signallocal.hpp"
91 #include "vm/string.hpp"
94 #include "vm/jit/stacktrace.hpp"
97 /* debugging macros ***********************************************************/
101 # define TRACEJVMCALLS(x) \
103 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
108 # define TRACEJVMCALLSENTER(x) \
110 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
116 # define TRACEJVMCALLSEXIT(x) \
118 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
124 # define TRACEJVMCALLSVERBOSE(x) \
126 if (opt_TraceJVMCallsVerbose) { \
131 # define PRINTJVMWARNINGS(x) \
133 if (opt_PrintWarnings) { \
140 # define TRACEJVMCALLS(x)
141 # define TRACEJVMCALLSENTER(x)
142 # define TRACEJVMCALLSEXIT(x)
143 # define TRACEJVMCALLSVERBOSE(x)
144 # define PRINTJVMWARNINGS(x)
149 // Interface functions are exported as C functions.
152 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
154 if ((intptr_t) count <= 0)
157 return vsnprintf(str, count, fmt, args);
161 int jio_snprintf(char *str, size_t count, const char *fmt, ...)
167 len = jio_vsnprintf(str, count, fmt, ap);
174 int jio_fprintf(FILE* f, const char *fmt, ...)
176 log_println("jio_fprintf: IMPLEMENT ME!");
182 int jio_vfprintf(FILE* f, const char *fmt, va_list args)
184 log_println("jio_vfprintf: IMPLEMENT ME!");
190 int jio_printf(const char *fmt, ...)
192 log_println("jio_printf: IMPLEMENT ME!");
198 /* JVM_GetInterfaceVersion */
200 jint JVM_GetInterfaceVersion()
202 /* This is defined in hotspot/src/share/vm/prims/jvm.h */
204 #define JVM_INTERFACE_VERSION 4
206 return JVM_INTERFACE_VERSION;
210 /* JVM_CurrentTimeMillis */
212 jlong JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)
214 TRACEJVMCALLS(("JVM_CurrentTimeMillis(env=%p, ignored=%p)", env, ignored));
216 return (jlong) builtin_currenttimemillis();
222 jlong JVM_NanoTime(JNIEnv *env, jclass ignored)
224 TRACEJVMCALLS(("JVM_NanoTime(env=%p, ignored=%p)", env, ignored));
226 return (jlong) builtin_nanotime();
232 void JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos, jobject dst, jint dst_pos, jint length)
237 s = (java_handle_t *) src;
238 d = (java_handle_t *) dst;
240 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));
242 builtin_arraycopy(s, src_pos, d, dst_pos, length);
246 /* JVM_InitProperties */
248 jobject JVM_InitProperties(JNIEnv *env, jobject properties)
253 TRACEJVMCALLS(("JVM_InitProperties(env=%p, properties=%p)", env, properties));
255 h = (java_handle_t *) properties;
257 /* Convert the -XX:MaxDirectMemorySize= command line flag to the
258 sun.nio.MaxDirectMemorySize property. Do this after setting
259 user properties to prevent people from setting the value with a
260 -D option, as requested. */
262 jio_snprintf(buf, sizeof(buf), PRINTF_FORMAT_INT64_T, opt_MaxDirectMemorySize);
263 VM::get_current()->get_properties().put("sun.nio.MaxDirectMemorySize", buf);
265 // Fill the java.util.Properties object.
266 VM::get_current()->get_properties().fill(h);
274 void JVM_Exit(jint code)
276 log_println("JVM_Exit: IMPLEMENT ME!");
282 void JVM_Halt(jint code)
284 TRACEJVMCALLS(("JVM_Halt(code=%d)", code));
291 /* JVM_OnExit(void (*func)) */
293 void JVM_OnExit(void (*func)(void))
295 log_println("JVM_OnExit(void (*func): IMPLEMENT ME!");
303 TRACEJVMCALLS(("JVM_GC()"));
309 /* JVM_MaxObjectInspectionAge */
311 jlong JVM_MaxObjectInspectionAge(void)
313 log_println("JVM_MaxObjectInspectionAge: IMPLEMENT ME!");
319 /* JVM_TraceInstructions */
321 void JVM_TraceInstructions(jboolean on)
323 log_println("JVM_TraceInstructions: IMPLEMENT ME!");
327 /* JVM_TraceMethodCalls */
329 void JVM_TraceMethodCalls(jboolean on)
331 log_println("JVM_TraceMethodCalls: IMPLEMENT ME!");
335 /* JVM_TotalMemory */
337 jlong JVM_TotalMemory(void)
339 TRACEJVMCALLS(("JVM_TotalMemory()"));
341 return gc_get_heap_size();
347 jlong JVM_FreeMemory(void)
349 TRACEJVMCALLS(("JVM_FreeMemory()"));
351 return gc_get_free_bytes();
357 jlong JVM_MaxMemory(void)
359 TRACEJVMCALLS(("JVM_MaxMemory()"));
361 return gc_get_max_heap_size();
365 /* JVM_ActiveProcessorCount */
367 jint JVM_ActiveProcessorCount(void)
369 TRACEJVMCALLS(("JVM_ActiveProcessorCount()"));
371 return os::processors_online();
375 /* JVM_FillInStackTrace */
377 void JVM_FillInStackTrace(JNIEnv *env, jobject receiver)
379 TRACEJVMCALLS(("JVM_FillInStackTrace(env=%p, receiver=%p)", env, receiver));
381 java_handle_bytearray_t* ba = stacktrace_get_current();
386 java_lang_Throwable jlt(receiver, ba);
390 /* JVM_PrintStackTrace */
392 void JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable)
394 log_println("JVM_PrintStackTrace: IMPLEMENT ME!");
398 /* JVM_GetStackTraceDepth */
400 jint JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable)
402 TRACEJVMCALLS(("JVM_GetStackTraceDepth(env=%p, throwable=%p)", env, throwable));
404 java_lang_Throwable jlt(throwable);
407 exceptions_throw_nullpointerexception();
411 ByteArray ba(jlt.get_backtrace());
416 // We need a critical section here as the stacktrace structure is
417 // mapped onto a Java byte-array.
421 stacktrace_t* st = (stacktrace_t *) ba.get_raw_data_ptr();
423 int32_t depth = st->length;
431 /* JVM_GetStackTraceElement */
433 jobject JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index)
435 TRACEJVMCALLS(("JVM_GetStackTraceElement(env=%p, throwable=%p, index=%d)", env, throwable, index));
437 java_lang_Throwable jlt(throwable);
438 ByteArray ba(jlt.get_backtrace());
440 // XXX We need a critical section here as the stacktrace structure is
441 // mapped onto a Java byte-array.
442 stacktrace_t* st = (stacktrace_t *) ba.get_raw_data_ptr();
444 return stacktrace_get_StackTraceElement(st, index);
450 jint JVM_IHashCode(JNIEnv* env, jobject handle)
452 TRACEJVMCALLS(("JVM_IHashCode(env=%p, jobject=%p)", env, handle));
454 java_lang_Object o(handle);
456 return o.get_hashcode();
460 /* JVM_MonitorWait */
462 void JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms)
464 #if defined(ENABLE_THREADS)
468 TRACEJVMCALLS(("JVM_MonitorWait(env=%p, handle=%p, ms=%ld)", env, handle, ms));
470 /* exceptions_throw_illegalargumentexception("argument out of range"); */
471 exceptions_throw_illegalargumentexception();
475 #if defined(ENABLE_THREADS)
476 o = (java_handle_t *) handle;
478 lock_wait_for_object(o, ms, 0);
483 /* JVM_MonitorNotify */
485 void JVM_MonitorNotify(JNIEnv* env, jobject handle)
487 #if defined(ENABLE_THREADS)
491 TRACEJVMCALLS(("JVM_MonitorNotify(env=%p, handle=%p)", env, handle));
493 #if defined(ENABLE_THREADS)
494 o = (java_handle_t *) handle;
496 lock_notify_object(o);
501 /* JVM_MonitorNotifyAll */
503 void JVM_MonitorNotifyAll(JNIEnv* env, jobject handle)
505 #if defined(ENABLE_THREADS)
509 TRACEJVMCALLS(("JVM_MonitorNotifyAll(env=%p, handle=%p)", env, handle));
511 #if defined(ENABLE_THREADS)
512 o = (java_handle_t *) handle;
514 lock_notify_all_object(o);
521 jobject JVM_Clone(JNIEnv* env, jobject handle)
523 TRACEJVMCALLS(("JVM_Clone(env=%p, handle=%p)", env, handle));
525 return (jobject) builtin_clone(env, (java_handle_t *) handle);
529 /* JVM_InitializeCompiler */
531 void JVM_InitializeCompiler (JNIEnv *env, jclass compCls)
533 log_println("JVM_InitializeCompiler : IMPLEMENT ME!");
537 /* JVM_IsSilentCompiler */
539 jboolean JVM_IsSilentCompiler(JNIEnv *env, jclass compCls)
541 log_println("JVM_IsSilentCompiler: IMPLEMENT ME!");
547 /* JVM_CompileClass */
549 jboolean JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls)
551 log_println("JVM_CompileClass: IMPLEMENT ME!");
557 /* JVM_CompileClasses */
559 jboolean JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname)
561 log_println("JVM_CompileClasses: IMPLEMENT ME!");
567 /* JVM_CompilerCommand */
569 jobject JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg)
571 log_println("JVM_CompilerCommand: IMPLEMENT ME!");
577 /* JVM_EnableCompiler */
579 void JVM_EnableCompiler(JNIEnv *env, jclass compCls)
581 TRACEJVMCALLS(("JVM_EnableCompiler(env=%p, compCls=%p)", env, compCls));
582 PRINTJVMWARNINGS(("JVM_EnableCompiler not supported"));
586 /* JVM_DisableCompiler */
588 void JVM_DisableCompiler(JNIEnv *env, jclass compCls)
590 TRACEJVMCALLS(("JVM_DisableCompiler(env=%p, compCls=%p)", env, compCls));
591 PRINTJVMWARNINGS(("JVM_DisableCompiler not supported"));
595 /* JVM_GetLastErrorString */
597 jint JVM_GetLastErrorString(char* buf, int len)
599 TRACEJVMCALLS(("JVM_GetLastErrorString(buf=%p, len=%d", buf, len));
601 HPI& hpi = VM::get_current()->get_hpi();
602 return hpi.get_system().GetLastErrorString(buf, len);
608 char *JVM_NativePath(char* path)
610 TRACEJVMCALLS(("JVM_NativePath(path=%s)", path));
612 HPI& hpi = VM::get_current()->get_hpi();
613 return hpi.get_file().NativePath(path);
617 /* JVM_GetCallerClass */
619 jclass JVM_GetCallerClass(JNIEnv* env, int depth)
623 TRACEJVMCALLS(("JVM_GetCallerClass(env=%p, depth=%d)", env, depth));
625 c = stacktrace_get_caller_class(depth);
631 /* JVM_FindPrimitiveClass */
633 jclass JVM_FindPrimitiveClass(JNIEnv* env, const char* s)
638 TRACEJVMCALLS(("JVM_FindPrimitiveClass(env=%p, s=%s)", env, s));
641 c = Primitive::get_class_by_name(u);
643 return (jclass) LLNI_classinfo_wrap(c);
647 /* JVM_ResolveClass */
649 void JVM_ResolveClass(JNIEnv* env, jclass cls)
651 TRACEJVMCALLS(("JVM_ResolveClass(env=%p, cls=%p)", env, cls));
652 PRINTJVMWARNINGS(("JVM_ResolveClass not implemented"));
656 /* JVM_FindClassFromBootLoader */
658 jclass JVM_FindClassFromBootLoader(JNIEnv* env, const char* name)
663 TRACEJVMCALLS(("JVM_FindClassFromBootLoader(name=%s)", name));
665 u = utf_new_char(name);
666 c = load_class_from_classloader(u, NULL);
671 return (jclass) LLNI_classinfo_wrap(c);
675 /* JVM_FindClassFromClassLoader */
677 jclass JVM_FindClassFromClassLoader(JNIEnv* env, const char* name, jboolean init, jobject loader, jboolean throwError)
683 TRACEJVMCALLS(("JVM_FindClassFromClassLoader(name=%s, init=%d, loader=%p, throwError=%d)", name, init, loader, throwError));
685 /* As of now, OpenJDK does not call this function with throwError
688 assert(throwError == false);
690 u = utf_new_char(name);
691 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
693 c = load_class_from_classloader(u, cl);
699 if (!(c->state & CLASS_INITIALIZED))
700 if (!initialize_class(c))
703 return (jclass) LLNI_classinfo_wrap(c);
707 /* JVM_FindClassFromClass */
709 jclass JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init, jclass from)
711 log_println("JVM_FindClassFromClass: IMPLEMENT ME!");
717 /* JVM_DefineClass */
719 jclass JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)
721 log_println("JVM_DefineClass: IMPLEMENT ME!");
727 /* JVM_DefineClassWithSource */
729 jclass JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)
735 TRACEJVMCALLS(("JVM_DefineClassWithSource(env=%p, name=%s, loader=%p, buf=%p, len=%d, pd=%p, source=%s)", env, name, loader, buf, len, pd, source));
738 u = utf_new_char(name);
742 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
744 /* XXX do something with source */
746 c = class_define(u, cl, len, (uint8_t *) buf, (java_handle_t *) pd);
748 return (jclass) LLNI_classinfo_wrap(c);
752 /* JVM_FindLoadedClass */
754 jclass JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name)
760 TRACEJVMCALLS(("JVM_FindLoadedClass(env=%p, loader=%p, name=%p)", env, loader, name));
762 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
764 u = javastring_toutf((java_handle_t *) name, true);
765 c = classcache_lookup(cl, u);
767 return (jclass) LLNI_classinfo_wrap(c);
771 /* JVM_GetClassName */
773 jstring JVM_GetClassName(JNIEnv *env, jclass cls)
777 TRACEJVMCALLS(("JVM_GetClassName(env=%p, cls=%p)", env, cls));
779 c = LLNI_classinfo_unwrap(cls);
781 return (jstring) class_get_classname(c);
785 /* JVM_GetClassInterfaces */
787 jobjectArray JVM_GetClassInterfaces(JNIEnv *env, jclass cls)
790 java_handle_objectarray_t *oa;
792 TRACEJVMCALLS(("JVM_GetClassInterfaces(env=%p, cls=%p)", env, cls));
794 c = LLNI_classinfo_unwrap(cls);
796 oa = class_get_interfaces(c);
802 /* JVM_GetClassLoader */
804 jobject JVM_GetClassLoader(JNIEnv *env, jclass cls)
809 TRACEJVMCALLSENTER(("JVM_GetClassLoader(env=%p, cls=%p)", env, cls));
811 c = LLNI_classinfo_unwrap(cls);
812 cl = class_get_classloader(c);
814 TRACEJVMCALLSEXIT(("->%p", cl));
820 /* JVM_IsInterface */
822 jboolean JVM_IsInterface(JNIEnv *env, jclass cls)
826 TRACEJVMCALLS(("JVM_IsInterface(env=%p, cls=%p)", env, cls));
828 c = LLNI_classinfo_unwrap(cls);
830 return class_is_interface(c);
834 /* JVM_GetClassSigners */
836 jobjectArray JVM_GetClassSigners(JNIEnv *env, jclass cls)
838 log_println("JVM_GetClassSigners: IMPLEMENT ME!");
844 /* JVM_SetClassSigners */
846 void JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers)
848 TRACEJVMCALLS(("JVM_SetClassSigners(env=%p, cls=%p, signers=%p)", env, cls, signers));
850 classinfo* c = LLNI_classinfo_unwrap(cls);
852 ObjectArray oa(signers);
854 /* This call is ignored for primitive types and arrays. Signers
855 are only set once, ClassLoader.java, and thus shouldn't be
856 called with an array. Only the bootstrap loader creates
859 if (class_is_primitive(c) || class_is_array(c))
863 LLNI_classinfo_field_set(c, signers, (java_objectarray_t*) oa.get_handle());
867 /* JVM_GetProtectionDomain */
869 jobject JVM_GetProtectionDomain(JNIEnv *env, jclass cls)
873 TRACEJVMCALLS(("JVM_GetProtectionDomain(env=%p, cls=%p)", env, cls));
875 c = LLNI_classinfo_unwrap(cls);
878 exceptions_throw_nullpointerexception();
882 /* Primitive types do not have a protection domain. */
884 if (class_is_primitive(c))
887 return (jobject) c->protectiondomain;
891 /* JVM_SetProtectionDomain */
893 void JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain)
895 log_println("JVM_SetProtectionDomain: IMPLEMENT ME!");
899 /* JVM_DoPrivileged */
901 jobject JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, jobject context, jboolean wrapException)
906 java_handle_t *result;
909 TRACEJVMCALLS(("JVM_DoPrivileged(env=%p, cls=%p, action=%p, context=%p, wrapException=%d)", env, cls, action, context, wrapException));
911 h = (java_handle_t *) action;
912 LLNI_class_get(h, c);
914 if (action == NULL) {
915 exceptions_throw_nullpointerexception();
919 /* lookup run() method (throw no exceptions) */
921 m = class_resolveclassmethod(c, utf_run, utf_void__java_lang_Object, c,
924 if ((m == NULL) || !(m->flags & ACC_PUBLIC) || (m->flags & ACC_STATIC)) {
925 exceptions_throw_internalerror("No run method");
929 /* XXX It seems something with a privileged stack needs to be done
932 result = vm_call_method(m, h);
934 e = exceptions_get_exception();
937 if ( builtin_instanceof(e, class_java_lang_Exception) &&
938 !builtin_instanceof(e, class_java_lang_RuntimeException)) {
939 exceptions_clear_exception();
940 exceptions_throw_privilegedactionexception(e);
946 return (jobject) result;
950 /* JVM_GetInheritedAccessControlContext */
952 jobject JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls)
954 log_println("JVM_GetInheritedAccessControlContext: IMPLEMENT ME!");
960 /* JVM_GetStackAccessControlContext */
962 jobject JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls)
964 TRACEJVMCALLS(("JVM_GetStackAccessControlContext(env=%p, cls=%p): IMPLEMENT ME!", env, cls));
966 /* XXX All stuff I tested so far works without that function. At
967 some point we have to implement it, but I disable the output
968 for now to make IcedTea happy. */
974 /* JVM_IsArrayClass */
976 jboolean JVM_IsArrayClass(JNIEnv *env, jclass cls)
980 TRACEJVMCALLS(("JVM_IsArrayClass(env=%p, cls=%p)", env, cls));
982 c = LLNI_classinfo_unwrap(cls);
984 return class_is_array(c);
988 /* JVM_IsPrimitiveClass */
990 jboolean JVM_IsPrimitiveClass(JNIEnv *env, jclass cls)
994 TRACEJVMCALLS(("JVM_IsPrimitiveClass(env=%p, cls=%p)", env, cls));
996 c = LLNI_classinfo_unwrap(cls);
998 return class_is_primitive(c);
1002 /* JVM_GetComponentType */
1004 jclass JVM_GetComponentType(JNIEnv *env, jclass cls)
1006 classinfo *component;
1009 TRACEJVMCALLS(("JVM_GetComponentType(env=%p, cls=%p)", env, cls));
1011 c = LLNI_classinfo_unwrap(cls);
1013 component = class_get_componenttype(c);
1015 return (jclass) LLNI_classinfo_wrap(component);
1019 /* JVM_GetClassModifiers */
1021 jint JVM_GetClassModifiers(JNIEnv *env, jclass cls)
1026 TRACEJVMCALLS(("JVM_GetClassModifiers(env=%p, cls=%p)", env, cls));
1028 c = LLNI_classinfo_unwrap(cls);
1030 flags = class_get_modifiers(c, false);
1036 /* JVM_GetDeclaredClasses */
1038 jobjectArray JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)
1041 java_handle_objectarray_t *oa;
1043 TRACEJVMCALLS(("JVM_GetDeclaredClasses(env=%p, ofClass=%p)", env, ofClass));
1045 c = LLNI_classinfo_unwrap(ofClass);
1047 oa = class_get_declaredclasses(c, false);
1053 /* JVM_GetDeclaringClass */
1055 jclass JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass)
1060 TRACEJVMCALLS(("JVM_GetDeclaringClass(env=%p, ofClass=%p)", env, ofClass));
1062 c = LLNI_classinfo_unwrap(ofClass);
1064 dc = class_get_declaringclass(c);
1066 return (jclass) LLNI_classinfo_wrap(dc);
1070 /* JVM_GetClassSignature */
1072 jstring JVM_GetClassSignature(JNIEnv *env, jclass cls)
1078 TRACEJVMCALLS(("JVM_GetClassSignature(env=%p, cls=%p)", env, cls));
1080 c = LLNI_classinfo_unwrap(cls);
1082 /* Get the signature of the class. */
1084 u = class_get_signature(c);
1089 /* Convert UTF-string to a Java-string. */
1091 s = javastring_new(u);
1097 /* JVM_GetClassAnnotations */
1099 jbyteArray JVM_GetClassAnnotations(JNIEnv *env, jclass cls)
1101 TRACEJVMCALLS(("JVM_GetClassAnnotations(env=%p, cls=%p)", env, cls));
1104 exceptions_throw_nullpointerexception();
1108 classinfo* c = LLNI_classinfo_unwrap(cls);
1110 /* get annotations: */
1111 java_handle_bytearray_t* annotations = class_get_annotations(c);
1113 return (jbyteArray) annotations;
1117 /* JVM_GetFieldAnnotations */
1119 jbyteArray JVM_GetFieldAnnotations(JNIEnv *env, jobject field)
1121 TRACEJVMCALLS(("JVM_GetFieldAnnotations(env=%p, field=%p)", env, field));
1123 java_lang_reflect_Field jlrf(field);
1125 if (jlrf.is_null()) {
1126 exceptions_throw_nullpointerexception();
1130 return (jbyteArray) jlrf.get_annotations();
1134 /* JVM_GetMethodAnnotations */
1136 jbyteArray JVM_GetMethodAnnotations(JNIEnv *env, jobject method)
1138 TRACEJVMCALLS(("JVM_GetMethodAnnotations(env=%p, method=%p)", env, method));
1140 java_lang_reflect_Method jlrm(method);
1142 if (jlrm.is_null()) {
1143 exceptions_throw_nullpointerexception();
1147 return (jbyteArray) jlrm.get_annotations();
1151 /* JVM_GetMethodDefaultAnnotationValue */
1153 jbyteArray JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method)
1155 TRACEJVMCALLS(("JVM_GetMethodDefaultAnnotationValue(env=%p, method=%p)", env, method));
1157 java_lang_reflect_Method jlrm(method);
1159 if (jlrm.is_null()) {
1160 exceptions_throw_nullpointerexception();
1164 return (jbyteArray) jlrm.get_annotationDefault();
1168 /* JVM_GetMethodParameterAnnotations */
1170 jbyteArray JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method)
1172 TRACEJVMCALLS(("JVM_GetMethodParameterAnnotations(env=%p, method=%p)", env, method));
1174 java_lang_reflect_Method jlrm(method);
1176 if (jlrm.is_null()) {
1177 exceptions_throw_nullpointerexception();
1181 return (jbyteArray) jlrm.get_parameterAnnotations();
1185 /* JVM_GetClassDeclaredFields */
1187 jobjectArray JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1190 java_handle_objectarray_t *oa;
1192 TRACEJVMCALLS(("JVM_GetClassDeclaredFields(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1194 c = LLNI_classinfo_unwrap(ofClass);
1196 oa = class_get_declaredfields(c, publicOnly);
1202 /* JVM_GetClassDeclaredMethods */
1204 jobjectArray JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1206 TRACEJVMCALLS(("JVM_GetClassDeclaredMethods(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1208 classinfo* c = LLNI_classinfo_unwrap(ofClass);
1210 java_handle_objectarray_t* oa = class_get_declaredmethods(c, publicOnly);
1216 /* JVM_GetClassDeclaredConstructors */
1218 jobjectArray JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1221 java_handle_objectarray_t *oa;
1223 TRACEJVMCALLS(("JVM_GetClassDeclaredConstructors(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1225 c = LLNI_classinfo_unwrap(ofClass);
1227 oa = class_get_declaredconstructors(c, publicOnly);
1233 /* JVM_GetClassAccessFlags */
1235 jint JVM_GetClassAccessFlags(JNIEnv *env, jclass cls)
1239 TRACEJVMCALLS(("JVM_GetClassAccessFlags(env=%p, cls=%p)", env, cls));
1241 c = LLNI_classinfo_unwrap(cls);
1243 /* Primitive type classes have the correct access flags. */
1245 return c->flags & ACC_CLASS_REFLECT_MASK;
1249 /* JVM_GetClassConstantPool */
1251 jobject JVM_GetClassConstantPool(JNIEnv *env, jclass cls)
1253 #if defined(ENABLE_ANNOTATIONS)
1254 TRACEJVMCALLS(("JVM_GetClassConstantPool(env=%p, cls=%p)", env, cls));
1256 java_handle_t* h = native_new_and_init(class_sun_reflect_ConstantPool);
1257 sun_reflect_ConstantPool cp(h, cls);
1263 return (jobject) cp.get_handle();
1265 log_println("JVM_GetClassConstantPool(env=%p, cls=%p): not implemented in this configuration!", env, cls);
1271 /* JVM_ConstantPoolGetSize */
1273 jint JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool)
1275 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1277 TRACEJVMCALLS(("JVM_ConstantPoolGetSize(env=%p, unused=%p, jcpool=%p)", env, unused, jcpool));
1279 c = LLNI_classinfo_unwrap(jcpool);
1285 /* JVM_ConstantPoolGetClassAt */
1287 jclass JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1289 constant_classref *ref; /* classref to the class at constant pool index 'index' */
1290 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1291 classinfo *result; /* classinfo of the class at constant pool index 'index' */
1293 TRACEJVMCALLS(("JVM_ConstantPoolGetClassAt(env=%p, jcpool=%p, index=%d)", env, jcpool, index));
1295 c = LLNI_classinfo_unwrap(jcpool);
1297 ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1300 exceptions_throw_illegalargumentexception();
1304 result = resolve_classref_eager(ref);
1306 return (jclass) LLNI_classinfo_wrap(result);
1310 /* JVM_ConstantPoolGetClassAtIfLoaded */
1312 jclass JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1314 constant_classref *ref; /* classref to the class at constant pool index 'index' */
1315 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1316 classinfo *result; /* classinfo of the class at constant pool index 'index' */
1318 TRACEJVMCALLS(("JVM_ConstantPoolGetClassAtIfLoaded(env=%p, unused=%p, jcpool=%p, index=%d)", env, unused, jcpool, index));
1320 c = LLNI_classinfo_unwrap(jcpool);
1322 ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1325 exceptions_throw_illegalargumentexception();
1329 if (!resolve_classref(NULL, ref, resolveLazy, true, true, &result)) {
1333 if ((result == NULL) || !(result->state & CLASS_LOADED)) {
1337 return (jclass) LLNI_classinfo_wrap(result);
1341 /* JVM_ConstantPoolGetMethodAt */
1343 jobject JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1345 constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
1346 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1348 TRACEJVMCALLS(("JVM_ConstantPoolGetMethodAt: jcpool=%p, index=%d", jcpool, index));
1350 cls = LLNI_classinfo_unwrap(jcpool);
1351 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1354 exceptions_throw_illegalargumentexception();
1358 // Create a new java.lang.reflect.Method Java object.
1359 /* XXX: is that right? or do I have to use resolve_method_*? */
1360 java_lang_reflect_Method jlrm(ref->p.method);
1362 return (jobject) jlrm.get_handle();
1366 /* JVM_ConstantPoolGetMethodAtIfLoaded */
1368 jobject JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1370 constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
1371 classinfo *c = NULL; /* resolved declaring class of the method */
1372 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1374 TRACEJVMCALLS(("JVM_ConstantPoolGetMethodAtIfLoaded: jcpool=%p, index=%d", jcpool, index));
1376 cls = LLNI_classinfo_unwrap(jcpool);
1377 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1380 exceptions_throw_illegalargumentexception();
1384 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1388 if (c == NULL || !(c->state & CLASS_LOADED)) {
1392 // Create a new java.lang.reflect.Method Java object.
1393 java_lang_reflect_Method jlrm(ref->p.method);
1395 return (jobject) jlrm.get_handle();
1399 /* JVM_ConstantPoolGetFieldAt */
1401 jobject JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1403 constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
1404 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1406 TRACEJVMCALLS(("JVM_ConstantPoolGetFieldAt: jcpool=%p, index=%d", jcpool, index));
1408 cls = LLNI_classinfo_unwrap(jcpool);
1409 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1412 exceptions_throw_illegalargumentexception();
1416 // Create a new java.lang.reflect.Field Java object.
1417 java_lang_reflect_Field jlrf(ref->p.field);
1419 return (jobject) jlrf.get_handle();
1423 /* JVM_ConstantPoolGetFieldAtIfLoaded */
1425 jobject JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1427 constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
1428 classinfo *c; /* resolved declaring class for the field */
1429 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1431 TRACEJVMCALLS(("JVM_ConstantPoolGetFieldAtIfLoaded: jcpool=%p, index=%d", jcpool, index));
1433 cls = LLNI_classinfo_unwrap(jcpool);
1434 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1437 exceptions_throw_illegalargumentexception();
1441 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1445 if (c == NULL || !(c->state & CLASS_LOADED)) {
1449 // Create a new java.lang.reflect.Field Java object.
1450 java_lang_reflect_Field jlrf(ref->p.field);
1452 return (jobject) jlrf.get_handle();
1456 /* JVM_ConstantPoolGetMemberRefInfoAt */
1458 jobjectArray JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1460 log_println("JVM_ConstantPoolGetMemberRefInfoAt: jcpool=%p, index=%d, IMPLEMENT ME!", jcpool, index);
1462 /* TODO: implement. (this is yet unused be OpenJDK but, so very low priority) */
1468 /* JVM_ConstantPoolGetIntAt */
1470 jint JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1472 constant_integer *ref; /* reference to the int value in constant pool at index 'index' */
1473 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1475 TRACEJVMCALLS(("JVM_ConstantPoolGetIntAt: jcpool=%p, index=%d", jcpool, index));
1477 cls = LLNI_classinfo_unwrap(jcpool);
1478 ref = (constant_integer*)class_getconstant(cls, index, CONSTANT_Integer);
1481 exceptions_throw_illegalargumentexception();
1489 /* JVM_ConstantPoolGetLongAt */
1491 jlong JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1493 constant_long *ref; /* reference to the long value in constant pool at index 'index' */
1494 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1496 TRACEJVMCALLS(("JVM_ConstantPoolGetLongAt: jcpool=%p, index=%d", jcpool, index));
1498 cls = LLNI_classinfo_unwrap(jcpool);
1499 ref = (constant_long*)class_getconstant(cls, index, CONSTANT_Long);
1502 exceptions_throw_illegalargumentexception();
1510 /* JVM_ConstantPoolGetFloatAt */
1512 jfloat JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1514 constant_float *ref; /* reference to the float value in constant pool at index 'index' */
1515 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1517 TRACEJVMCALLS(("JVM_ConstantPoolGetFloatAt: jcpool=%p, index=%d", jcpool, index));
1519 cls = LLNI_classinfo_unwrap(jcpool);
1520 ref = (constant_float*)class_getconstant(cls, index, CONSTANT_Float);
1523 exceptions_throw_illegalargumentexception();
1531 /* JVM_ConstantPoolGetDoubleAt */
1533 jdouble JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1535 constant_double *ref; /* reference to the double value in constant pool at index 'index' */
1536 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1538 TRACEJVMCALLS(("JVM_ConstantPoolGetDoubleAt: jcpool=%p, index=%d", jcpool, index));
1540 cls = LLNI_classinfo_unwrap(jcpool);
1541 ref = (constant_double*)class_getconstant(cls, index, CONSTANT_Double);
1544 exceptions_throw_illegalargumentexception();
1552 /* JVM_ConstantPoolGetStringAt */
1554 jstring JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1556 utf *ref; /* utf object for the string in constant pool at index 'index' */
1557 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1559 TRACEJVMCALLS(("JVM_ConstantPoolGetStringAt: jcpool=%p, index=%d", jcpool, index));
1561 cls = LLNI_classinfo_unwrap(jcpool);
1562 ref = (utf*)class_getconstant(cls, index, CONSTANT_String);
1565 exceptions_throw_illegalargumentexception();
1569 /* XXX: I hope literalstring_new is the right Function. */
1570 return (jstring)literalstring_new(ref);
1574 /* JVM_ConstantPoolGetUTF8At */
1576 jstring JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1578 utf *ref; /* utf object for the utf8 data in constant pool at index 'index' */
1579 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1581 TRACEJVMCALLS(("JVM_ConstantPoolGetUTF8At: jcpool=%p, index=%d", jcpool, index));
1583 cls = LLNI_classinfo_unwrap(jcpool);
1584 ref = (utf*)class_getconstant(cls, index, CONSTANT_Utf8);
1587 exceptions_throw_illegalargumentexception();
1591 /* XXX: I hope literalstring_new is the right Function. */
1592 return (jstring)literalstring_new(ref);
1596 /* JVM_DesiredAssertionStatus */
1598 jboolean JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls)
1600 #if defined(ENABLE_ASSERTION)
1605 TRACEJVMCALLS(("JVM_DesiredAssertionStatus(env=%p, unused=%p, cls=%p)", env, unused, cls));
1607 c = LLNI_classinfo_unwrap(cls);
1609 if (c->classloader == NULL) {
1610 status = (jboolean)assertion_system_enabled;
1613 status = (jboolean)assertion_user_enabled;
1616 if (list_assertion_names != NULL) {
1617 for (List<assertion_name_t*>::iterator it = list_assertion_names->begin();
1618 it != list_assertion_names->end(); it++) {
1619 assertion_name_t* item = *it;
1621 name = utf_new_char(item->name);
1622 if (name == c->packagename) {
1623 status = (jboolean)item->enabled;
1625 else if (name == c->name) {
1626 status = (jboolean)item->enabled;
1633 return (jboolean)false;
1638 /* JVM_AssertionStatusDirectives */
1640 jobject JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)
1642 #if defined(ENABLE_ASSERTION)
1647 TRACEJVMCALLS(("JVM_AssertionStatusDirectives(env=%p, unused=%p)", env, unused));
1649 #if defined(ENABLE_ASSERTION)
1650 ObjectArray classes(assertion_class_count, class_java_lang_Object);
1652 ObjectArray classes(0, class_java_lang_Object);
1654 if (classes.is_null())
1657 #if defined(ENABLE_ASSERTION)
1658 ObjectArray packages(assertion_package_count, class_java_lang_Object);
1660 ObjectArray packages(0, class_java_lang_Object);
1662 if (packages.is_null())
1665 #if defined(ENABLE_ASSERTION)
1666 BooleanArray classEnabled(assertion_class_count);
1668 BooleanArray classEnabled(0);
1670 if (classEnabled.is_null())
1673 #if defined(ENABLE_ASSERTION)
1674 BooleanArray packageEnabled(assertion_package_count);
1676 BooleanArray packageEnabled(0);
1678 if (packageEnabled.is_null())
1681 #if defined(ENABLE_ASSERTION)
1682 /* initialize arrays */
1684 if (list_assertion_names != NULL) {
1688 for (List<assertion_name_t*>::iterator it = list_assertion_names->begin(); it != list_assertion_names->end(); it++) {
1689 assertion_name_t* item = *it;
1691 js = javastring_new_from_ascii(item->name);
1696 if (item->package == false) {
1697 classes.set_element(i, js);
1698 classEnabled.set_element(i, (jboolean) item->enabled);
1702 packages.set_element(j, js);
1703 packageEnabled.set_element(j, (jboolean) item->enabled);
1710 /* set instance fields */
1712 java_lang_AssertionStatusDirectives jlasd(
1713 classes.get_handle(),
1714 classEnabled.get_handle(),
1715 packages.get_handle(),
1716 packageEnabled.get_handle());
1718 return (jobject) jlasd.get_handle();
1722 /* JVM_GetClassNameUTF */
1724 const char *JVM_GetClassNameUTF(JNIEnv *env, jclass cls)
1726 log_println("JVM_GetClassNameUTF: IMPLEMENT ME!");
1732 /* JVM_GetClassCPTypes */
1734 void JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types)
1736 log_println("JVM_GetClassCPTypes: IMPLEMENT ME!");
1740 /* JVM_GetClassCPEntriesCount */
1742 jint JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)
1744 log_println("JVM_GetClassCPEntriesCount: IMPLEMENT ME!");
1750 /* JVM_GetClassFieldsCount */
1752 jint JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)
1754 log_println("JVM_GetClassFieldsCount: IMPLEMENT ME!");
1760 /* JVM_GetClassMethodsCount */
1762 jint JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)
1764 log_println("JVM_GetClassMethodsCount: IMPLEMENT ME!");
1770 /* JVM_GetMethodIxExceptionIndexes */
1772 void JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions)
1774 log_println("JVM_GetMethodIxExceptionIndexes: IMPLEMENT ME!");
1778 /* JVM_GetMethodIxExceptionsCount */
1780 jint JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)
1782 log_println("JVM_GetMethodIxExceptionsCount: IMPLEMENT ME!");
1788 /* JVM_GetMethodIxByteCode */
1790 void JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code)
1792 log_println("JVM_GetMethodIxByteCode: IMPLEMENT ME!");
1796 /* JVM_GetMethodIxByteCodeLength */
1798 jint JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)
1800 log_println("JVM_GetMethodIxByteCodeLength: IMPLEMENT ME!");
1806 /* JVM_GetMethodIxExceptionTableEntry */
1808 void JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry)
1810 log_println("JVM_GetMethodIxExceptionTableEntry: IMPLEMENT ME!");
1814 /* JVM_GetMethodIxExceptionTableLength */
1816 jint JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)
1818 log_println("JVM_GetMethodIxExceptionTableLength: IMPLEMENT ME!");
1824 /* JVM_GetMethodIxModifiers */
1826 jint JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)
1828 log_println("JVM_GetMethodIxModifiers: IMPLEMENT ME!");
1834 /* JVM_GetFieldIxModifiers */
1836 jint JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)
1838 log_println("JVM_GetFieldIxModifiers: IMPLEMENT ME!");
1844 /* JVM_GetMethodIxLocalsCount */
1846 jint JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)
1848 log_println("JVM_GetMethodIxLocalsCount: IMPLEMENT ME!");
1854 /* JVM_GetMethodIxArgsSize */
1856 jint JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)
1858 log_println("JVM_GetMethodIxArgsSize: IMPLEMENT ME!");
1864 /* JVM_GetMethodIxMaxStack */
1866 jint JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)
1868 log_println("JVM_GetMethodIxMaxStack: IMPLEMENT ME!");
1874 /* JVM_IsConstructorIx */
1876 jboolean JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)
1878 log_println("JVM_IsConstructorIx: IMPLEMENT ME!");
1884 /* JVM_GetMethodIxNameUTF */
1886 const char *JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)
1888 log_println("JVM_GetMethodIxNameUTF: IMPLEMENT ME!");
1894 /* JVM_GetMethodIxSignatureUTF */
1896 const char *JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)
1898 log_println("JVM_GetMethodIxSignatureUTF: IMPLEMENT ME!");
1904 /* JVM_GetCPFieldNameUTF */
1906 const char *JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1908 log_println("JVM_GetCPFieldNameUTF: IMPLEMENT ME!");
1914 /* JVM_GetCPMethodNameUTF */
1916 const char *JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1918 log_println("JVM_GetCPMethodNameUTF: IMPLEMENT ME!");
1924 /* JVM_GetCPMethodSignatureUTF */
1926 const char *JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
1928 log_println("JVM_GetCPMethodSignatureUTF: IMPLEMENT ME!");
1934 /* JVM_GetCPFieldSignatureUTF */
1936 const char *JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
1938 log_println("JVM_GetCPFieldSignatureUTF: IMPLEMENT ME!");
1944 /* JVM_GetCPClassNameUTF */
1946 const char *JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1948 log_println("JVM_GetCPClassNameUTF: IMPLEMENT ME!");
1954 /* JVM_GetCPFieldClassNameUTF */
1956 const char *JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1958 log_println("JVM_GetCPFieldClassNameUTF: IMPLEMENT ME!");
1964 /* JVM_GetCPMethodClassNameUTF */
1966 const char *JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1968 log_println("JVM_GetCPMethodClassNameUTF: IMPLEMENT ME!");
1974 /* JVM_GetCPFieldModifiers */
1976 jint JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
1978 log_println("JVM_GetCPFieldModifiers: IMPLEMENT ME!");
1984 /* JVM_GetCPMethodModifiers */
1986 jint JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
1988 log_println("JVM_GetCPMethodModifiers: IMPLEMENT ME!");
1994 /* JVM_ReleaseUTF */
1996 void JVM_ReleaseUTF(const char *utf)
1998 log_println("JVM_ReleaseUTF: IMPLEMENT ME!");
2002 /* JVM_IsSameClassPackage */
2004 jboolean JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2)
2006 log_println("JVM_IsSameClassPackage: IMPLEMENT ME!");
2014 /* Taken from: hotspot/src/share/vm/prims/jvm.h */
2017 * JVM I/O error codes
2019 #define JVM_EEXIST -100
2021 jint JVM_Open(const char* fname, jint flags, jint mode)
2025 TRACEJVMCALLS(("JVM_Open(fname=%s, flags=%d, mode=%d)", fname, flags, mode));
2027 HPI& hpi = VM::get_current()->get_hpi();
2028 result = hpi.get_file().Open(fname, flags, mode);
2046 jint JVM_Close(jint fd)
2048 TRACEJVMCALLS(("JVM_Close(fd=%d)", fd));
2050 HPI& hpi = VM::get_current()->get_hpi();
2051 return hpi.get_file().Close(fd);
2057 jint JVM_Read(jint fd, char* buf, jint nbytes)
2059 TRACEJVMCALLS(("JVM_Read(fd=%d, buf=%p, nbytes=%d)", fd, buf, nbytes));
2061 HPI& hpi = VM::get_current()->get_hpi();
2062 return (jint) hpi.get_file().Read(fd, buf, nbytes);
2068 jint JVM_Write(jint fd, char* buf, jint nbytes)
2070 TRACEJVMCALLS(("JVM_Write(fd=%d, buf=%s, nbytes=%d)", fd, buf, nbytes));
2072 HPI& hpi = VM::get_current()->get_hpi();
2073 return (jint) hpi.get_file().Write(fd, buf, nbytes);
2079 jint JVM_Available(jint fd, jlong* pbytes)
2081 TRACEJVMCALLS(("JVM_Available(fd=%d, pbytes=%p)", fd, pbytes));
2083 HPI& hpi = VM::get_current()->get_hpi();
2084 return hpi.get_file().Available(fd, pbytes);
2090 jlong JVM_Lseek(jint fd, jlong offset, jint whence)
2092 TRACEJVMCALLS(("JVM_Lseek(fd=%d, offset=%ld, whence=%d)", fd, offset, whence));
2094 HPI& hpi = VM::get_current()->get_hpi();
2095 return hpi.get_file().Seek(fd, (off_t) offset, whence);
2101 jint JVM_SetLength(jint fd, jlong length)
2103 TRACEJVMCALLS(("JVM_SetLength(fd=%d, length=%ld)", length));
2105 HPI& hpi = VM::get_current()->get_hpi();
2106 return hpi.get_file().SetLength(fd, length);
2112 jint JVM_Sync(jint fd)
2114 TRACEJVMCALLS(("JVM_Sync(fd=%d)", fd));
2116 HPI& hpi = VM::get_current()->get_hpi();
2117 return hpi.get_file().Sync(fd);
2121 /* JVM_StartThread */
2123 void JVM_StartThread(JNIEnv* env, jobject jthread)
2125 TRACEJVMCALLS(("JVM_StartThread(env=%p, jthread=%p)", env, jthread));
2127 threads_thread_start((java_handle_t *) jthread);
2131 /* JVM_StopThread */
2133 void JVM_StopThread(JNIEnv* env, jobject jthread, jobject throwable)
2135 log_println("JVM_StopThread: Deprecated. Not implemented.");
2139 /* JVM_IsThreadAlive */
2141 jboolean JVM_IsThreadAlive(JNIEnv* env, jobject jthread)
2147 TRACEJVMCALLS(("JVM_IsThreadAlive(env=%p, jthread=%p)", env, jthread));
2149 h = (java_handle_t *) jthread;
2150 t = thread_get_thread(h);
2152 /* The threadobject is null when a thread is created in Java. */
2157 result = threads_thread_is_alive(t);
2163 /* JVM_SuspendThread */
2165 void JVM_SuspendThread(JNIEnv* env, jobject jthread)
2170 TRACEJVMCALLS(("JVM_SuspendThread(env=%p, jthread=%p)", env, jthread));
2172 if (opt_PrintWarnings)
2173 log_println("JVM_SuspendThread: Deprecated, do not use!");
2175 h = (java_handle_t *) jthread;
2176 t = thread_get_thread(h);
2178 /* The threadobject is null when a thread is created in Java. */
2183 threads_suspend_thread(t, SUSPEND_REASON_JAVA);
2187 /* JVM_ResumeThread */
2189 void JVM_ResumeThread(JNIEnv* env, jobject jthread)
2194 TRACEJVMCALLS(("JVM_ResumeThread(env=%p, jthread=%p)", env, jthread));
2196 if (opt_PrintWarnings)
2197 log_println("JVM_ResumeThread: Deprecated, do not use!");
2199 h = (java_handle_t *) jthread;
2200 t = thread_get_thread(h);
2202 /* The threadobject is null when a thread is created in Java. */
2207 threads_resume_thread(t, SUSPEND_REASON_JAVA);
2211 /* JVM_SetThreadPriority */
2213 void JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio)
2218 TRACEJVMCALLS(("JVM_SetThreadPriority(env=%p, jthread=%p, prio=%d)", env, jthread, prio));
2220 h = (java_handle_t *) jthread;
2221 t = thread_get_thread(h);
2223 /* The threadobject is null when a thread is created in Java. The
2224 priority is set later during startup. */
2229 threads_set_thread_priority(t->tid, prio);
2235 void JVM_Yield(JNIEnv *env, jclass threadClass)
2237 TRACEJVMCALLS(("JVM_Yield(env=%p, threadClass=%p)", env, threadClass));
2245 void JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis)
2247 TRACEJVMCALLS(("JVM_Sleep(env=%p, threadClass=%p, millis=%ld)", env, threadClass, millis));
2249 threads_sleep(millis, 0);
2253 /* JVM_CurrentThread */
2255 jobject JVM_CurrentThread(JNIEnv* env, jclass threadClass)
2259 TRACEJVMCALLSVERBOSE(("JVM_CurrentThread(env=%p, threadClass=%p)", env, threadClass));
2261 o = thread_get_current_object();
2267 /* JVM_CountStackFrames */
2269 jint JVM_CountStackFrames(JNIEnv* env, jobject jthread)
2271 log_println("JVM_CountStackFrames: Deprecated. Not implemented.");
2279 void JVM_Interrupt(JNIEnv* env, jobject jthread)
2284 TRACEJVMCALLS(("JVM_Interrupt(env=%p, jthread=%p)", env, jthread));
2286 h = (java_handle_t *) jthread;
2287 t = thread_get_thread(h);
2289 /* The threadobject is null when a thread is created in Java. */
2294 threads_thread_interrupt(t);
2298 /* JVM_IsInterrupted */
2300 jboolean JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted)
2304 jboolean interrupted;
2306 TRACEJVMCALLS(("JVM_IsInterrupted(env=%p, jthread=%p, clear_interrupted=%d)", env, jthread, clear_interrupted));
2308 h = (java_handle_t *) jthread;
2309 t = thread_get_thread(h);
2311 /* The threadobject is null when a thread is created in Java. */
2316 interrupted = thread_is_interrupted(t);
2318 if (interrupted && clear_interrupted)
2319 thread_set_interrupted(t, false);
2327 jboolean JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj)
2332 TRACEJVMCALLS(("JVM_HoldsLock(env=%p, threadClass=%p, obj=%p)", env, threadClass, obj));
2334 h = (java_handle_t *) obj;
2337 exceptions_throw_nullpointerexception();
2341 result = lock_is_held_by_current_thread(h);
2347 /* JVM_DumpAllStacks */
2349 void JVM_DumpAllStacks(JNIEnv* env, jclass unused)
2351 log_println("JVM_DumpAllStacks: IMPLEMENT ME!");
2355 /* JVM_CurrentLoadedClass */
2357 jclass JVM_CurrentLoadedClass(JNIEnv *env)
2359 log_println("JVM_CurrentLoadedClass: IMPLEMENT ME!");
2365 /* JVM_CurrentClassLoader */
2367 jobject JVM_CurrentClassLoader(JNIEnv *env)
2369 TRACEJVMCALLS(("JVM_CurrentClassLoader(env=%p)", env));
2370 PRINTJVMWARNINGS(("JVM_CurrentClassLoader is deprecated, do not use it."));
2372 return stacktrace_first_nonsystem_classloader();
2376 /* JVM_GetClassContext */
2378 jobjectArray JVM_GetClassContext(JNIEnv *env)
2380 TRACEJVMCALLS(("JVM_GetClassContext(env=%p)", env));
2382 return stacktrace_getClassContext();
2386 /* JVM_ClassDepth */
2388 jint JVM_ClassDepth(JNIEnv *env, jstring name)
2390 log_println("JVM_ClassDepth: IMPLEMENT ME!");
2396 /* JVM_ClassLoaderDepth */
2398 jint JVM_ClassLoaderDepth(JNIEnv *env)
2400 log_println("JVM_ClassLoaderDepth: IMPLEMENT ME!");
2406 /* JVM_GetSystemPackage */
2408 jstring JVM_GetSystemPackage(JNIEnv *env, jstring name)
2414 TRACEJVMCALLS(("JVM_GetSystemPackage(env=%p, name=%p)", env, name));
2416 /* s = Package::find(name); */
2417 u = javastring_toutf((java_handle_t *) name, false);
2419 result = Package::find(u);
2422 s = javastring_new(result);
2430 /* JVM_GetSystemPackages */
2432 jobjectArray JVM_GetSystemPackages(JNIEnv *env)
2434 log_println("JVM_GetSystemPackages: IMPLEMENT ME!");
2440 /* JVM_AllocateNewObject */
2442 jobject JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass)
2444 log_println("JVM_AllocateNewObject: IMPLEMENT ME!");
2450 /* JVM_AllocateNewArray */
2452 jobject JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length)
2454 log_println("JVM_AllocateNewArray: IMPLEMENT ME!");
2460 /* JVM_LatestUserDefinedLoader */
2462 jobject JVM_LatestUserDefinedLoader(JNIEnv *env)
2464 TRACEJVMCALLS(("JVM_LatestUserDefinedLoader(env=%p)", env));
2466 return stacktrace_first_nonnull_classloader();
2470 /* JVM_LoadClass0 */
2472 jclass JVM_LoadClass0(JNIEnv *env, jobject receiver, jclass currClass, jstring currClassName)
2474 log_println("JVM_LoadClass0: IMPLEMENT ME!");
2480 /* JVM_GetArrayLength */
2482 jint JVM_GetArrayLength(JNIEnv *env, jobject arr)
2484 TRACEJVMCALLS(("JVM_GetArrayLength(arr=%p)", arr));
2487 exceptions_throw_nullpointerexception();
2493 // Check for exception in constructor.
2498 return a.get_length();
2502 /* JVM_GetArrayElement */
2504 jobject JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index)
2506 TRACEJVMCALLS(("JVM_GetArrayElement(env=%p, arr=%p, index=%d)", env, arr, index));
2510 /* if (!class_is_array(a->objheader.vftbl->class)) { */
2511 /* exceptions_throw_illegalargumentexception(); */
2515 return a.get_boxed_element(index);
2519 /* JVM_GetPrimitiveArrayElement */
2521 jvalue JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode)
2525 log_println("JVM_GetPrimitiveArrayElement: IMPLEMENT ME!");
2533 /* JVM_SetArrayElement */
2535 void JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val)
2537 TRACEJVMCALLS(("JVM_SetArrayElement(env=%p, arr=%p, index=%d, val=%p)", env, arr, index, val));
2541 a.set_boxed_element(index, val);
2545 /* JVM_SetPrimitiveArrayElement */
2547 void JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode)
2549 log_println("JVM_SetPrimitiveArrayElement: IMPLEMENT ME!");
2555 jobject JVM_NewArray(JNIEnv *env, jclass eltClass, jint length)
2557 TRACEJVMCALLS(("JVM_NewArray(env=%p, eltClass=%p, length=%d)", env, eltClass, length));
2559 if (eltClass == NULL) {
2560 exceptions_throw_nullpointerexception();
2564 /* NegativeArraySizeException is checked by array constructor. */
2566 classinfo* c = LLNI_classinfo_unwrap(eltClass);
2568 /* Create primitive or object array. */
2570 if (class_is_primitive(c)) {
2571 classinfo* pc = Primitive::get_arrayclass_by_name(c->name);
2573 /* void arrays are not allowed. */
2576 exceptions_throw_illegalargumentexception();
2580 Array a(length, pc);
2582 return (jobject) a.get_handle();
2585 ObjectArray oa(length, c);
2587 return (jobject) oa.get_handle();
2592 /* JVM_NewMultiArray */
2594 jobject JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim)
2602 java_handle_objectarray_t *a;
2604 TRACEJVMCALLS(("JVM_NewMultiArray(env=%p, eltClass=%p, dim=%p)", env, eltClass, dim));
2606 if (eltClass == NULL) {
2607 exceptions_throw_nullpointerexception();
2611 /* NegativeArraySizeException is checked in builtin_newarray. */
2613 c = LLNI_classinfo_unwrap(eltClass);
2617 /* We check here for exceptions thrown in array_length_get,
2618 otherwise these exceptions get overwritten by the following
2619 IllegalArgumentException. */
2624 length = ia.get_length();
2626 if ((length <= 0) || (length > /* MAX_DIM */ 255)) {
2627 exceptions_throw_illegalargumentexception();
2631 /* XXX This is just a quick hack to get it working. */
2633 dims = MNEW(long, length);
2635 for (i = 0; i < length; i++) {
2636 value = ia.get_element(i);
2637 dims[i] = (long) value;
2640 /* Create an array-class if necessary. */
2642 if (class_is_primitive(c)) {
2643 ac = Primitive::get_arrayclass_by_name(c->name);
2645 // Arrays of void are not allowed.
2647 exceptions_throw_illegalargumentexception();
2652 ac = class_multiarray_of((length - 1), ac, true);
2655 ac = class_multiarray_of(length, c, true);
2660 /* Allocate a new array on the heap. */
2662 a = builtin_multianewarray(length, (java_handle_t *) ac, dims);
2668 /* JVM_InitializeSocketLibrary */
2670 jint JVM_InitializeSocketLibrary()
2672 TRACEJVMCALLS(("JVM_InitializeSocketLibrary()"));
2674 HPI& hpi = VM::get_current()->get_hpi();
2675 return hpi.initialize_socket_library();
2681 jint JVM_Socket(jint domain, jint type, jint protocol)
2683 TRACEJVMCALLS(("JVM_Socket(domain=%d, type=%d, protocol=%d)", domain, type, protocol));
2685 return os::socket(domain, type, protocol);
2689 /* JVM_SocketClose */
2691 jint JVM_SocketClose(jint fd)
2693 TRACEJVMCALLS(("JVM_SocketClose(fd=%d)", fd));
2695 return os::close(fd);
2699 /* JVM_SocketShutdown */
2701 jint JVM_SocketShutdown(jint fd, jint howto)
2703 TRACEJVMCALLS(("JVM_SocketShutdown(fd=%d, howto=%d)", fd, howto));
2705 return os::shutdown(fd, howto);
2711 jint JVM_Recv(jint fd, char *buf, jint nBytes, jint flags)
2713 log_println("JVM_Recv: IMPLEMENT ME!");
2721 jint JVM_Send(jint fd, char *buf, jint nBytes, jint flags)
2723 TRACEJVMCALLSENTER(("JVM_Send(fd=%d, buf=%p, nBytes=%d, flags=%d", fd, buf, nBytes, flags));
2725 int result = os::send(fd, buf, nBytes, flags);
2727 TRACEJVMCALLSEXIT(("->%d", result));
2735 jint JVM_Timeout(int fd, long timeout)
2737 log_println("JVM_Timeout: IMPLEMENT ME!");
2745 jint JVM_Listen(jint fd, jint count)
2747 TRACEJVMCALLS(("JVM_Listen(fd=%d, count=%d)", fd, count));
2749 return os::listen(fd, count);
2755 jint JVM_Connect(jint fd, struct sockaddr *him, jint len)
2757 TRACEJVMCALLS(("JVM_Connect(fd=%d, him=%p, len=%d)", fd, him, len));
2759 return os::connect(fd, him, len);
2765 jint JVM_Bind(jint fd, struct sockaddr *him, jint len)
2767 log_println("JVM_Bind: IMPLEMENT ME!");
2775 jint JVM_Accept(jint fd, struct sockaddr *him, jint *len)
2777 TRACEJVMCALLS(("JVM_Accept(fd=%d, him=%p, len=%p)", fd, him, len));
2779 return os::accept(fd, him, (socklen_t *) len);
2785 jint JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen)
2787 log_println("JVM_RecvFrom: IMPLEMENT ME!");
2793 /* JVM_GetSockName */
2795 jint JVM_GetSockName(jint fd, struct sockaddr *him, int *len)
2797 TRACEJVMCALLS(("JVM_GetSockName(fd=%d, him=%p, len=%p)", fd, him, len));
2799 return os::getsockname(fd, him, (socklen_t *) len);
2805 jint JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen)
2807 log_println("JVM_SendTo: IMPLEMENT ME!");
2813 /* JVM_SocketAvailable */
2815 jint JVM_SocketAvailable(jint fd, jint *pbytes)
2817 #if defined(FIONREAD)
2821 TRACEJVMCALLS(("JVM_SocketAvailable(fd=%d, pbytes=%p)", fd, pbytes));
2825 result = ioctl(fd, FIONREAD, &bytes);
2834 # error FIONREAD not defined
2839 /* JVM_GetSockOpt */
2841 jint JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen)
2843 TRACEJVMCALLS(("JVM_GetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%p)", fd, level, optname, optval, optlen));
2845 return os::getsockopt(fd, level, optname, optval, (socklen_t *) optlen);
2849 /* JVM_SetSockOpt */
2851 jint JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen)
2853 TRACEJVMCALLS(("JVM_SetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%d)", fd, level, optname, optval, optlen));
2855 return os::setsockopt(fd, level, optname, optval, optlen);
2859 /* JVM_GetHostName */
2861 int JVM_GetHostName(char *name, int namelen)
2865 TRACEJVMCALLSENTER(("JVM_GetHostName(name=%s, namelen=%d)", name, namelen));
2867 result = os::gethostname(name, namelen);
2869 TRACEJVMCALLSEXIT(("->%d (name=%s)", result, name));
2875 /* JVM_GetHostByAddr */
2877 struct hostent *JVM_GetHostByAddr(const char* name, int len, int type)
2879 log_println("JVM_GetHostByAddr: IMPLEMENT ME!");
2885 /* JVM_GetHostByName */
2887 struct hostent *JVM_GetHostByName(char* name)
2889 log_println("JVM_GetHostByName: IMPLEMENT ME!");
2895 /* JVM_GetProtoByName */
2897 struct protoent *JVM_GetProtoByName(char* name)
2899 log_println("JVM_GetProtoByName: IMPLEMENT ME!");
2905 /* JVM_LoadLibrary */
2907 void* JVM_LoadLibrary(const char* name)
2909 TRACEJVMCALLSENTER(("JVM_LoadLibrary(name=%s)", name));
2911 utf* u = utf_new_char(name);
2913 NativeLibrary nl(u);
2914 void* handle = nl.open();
2916 TRACEJVMCALLSEXIT(("->%p", handle));
2922 /* JVM_UnloadLibrary */
2924 void JVM_UnloadLibrary(void* handle)
2926 TRACEJVMCALLS(("JVM_UnloadLibrary(handle=%p)", handle));
2928 NativeLibrary nl(handle);
2933 /* JVM_FindLibraryEntry */
2935 void *JVM_FindLibraryEntry(void* handle, const char* name)
2939 TRACEJVMCALLSENTER(("JVM_FindLibraryEntry(handle=%p, name=%s)", handle, name));
2941 HPI& hpi = VM::get_current()->get_hpi();
2942 symbol = hpi.get_library().FindLibraryEntry(handle, name);
2944 TRACEJVMCALLSEXIT(("->%p", symbol));
2952 jboolean JVM_IsNaN(jdouble d)
2956 TRACEJVMCALLSENTER(("JVM_IsNaN(d=%f)", d));
2960 TRACEJVMCALLSEXIT(("->%d", result));
2966 /* JVM_IsSupportedJNIVersion */
2968 jboolean JVM_IsSupportedJNIVersion(jint version)
2970 TRACEJVMCALLS(("JVM_IsSupportedJNIVersion(version=%d)", version));
2972 return jni_version_check(version);
2976 /* JVM_InternString */
2978 jstring JVM_InternString(JNIEnv *env, jstring str)
2980 TRACEJVMCALLS(("JVM_InternString(env=%p, str=%p)", env, str));
2982 return (jstring) javastring_intern((java_handle_t *) str);
2986 /* JVM_RawMonitorCreate */
2988 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void)
2990 TRACEJVMCALLS(("JVM_RawMonitorCreate()"));
2992 Mutex* m = new Mutex();
2998 /* JVM_RawMonitorDestroy */
3000 JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void* mon)
3002 TRACEJVMCALLS(("JVM_RawMonitorDestroy(mon=%p)", mon));
3004 delete ((Mutex*) mon);
3008 /* JVM_RawMonitorEnter */
3010 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void* mon)
3012 TRACEJVMCALLS(("JVM_RawMonitorEnter(mon=%p)", mon));
3014 ((Mutex*) mon)->lock();
3020 /* JVM_RawMonitorExit */
3022 JNIEXPORT void JNICALL JVM_RawMonitorExit(void* mon)
3024 TRACEJVMCALLS(("JVM_RawMonitorExit(mon=%p)", mon));
3026 ((Mutex*) mon)->unlock();
3030 /* JVM_SetPrimitiveFieldValues */
3032 void JVM_SetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
3034 log_println("JVM_SetPrimitiveFieldValues: IMPLEMENT ME!");
3038 /* JVM_GetPrimitiveFieldValues */
3040 void JVM_GetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
3042 log_println("JVM_GetPrimitiveFieldValues: IMPLEMENT ME!");
3046 /* JVM_AccessVMBooleanFlag */
3048 jboolean JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get)
3050 log_println("JVM_AccessVMBooleanFlag: IMPLEMENT ME!");
3056 /* JVM_AccessVMIntFlag */
3058 jboolean JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get)
3060 log_println("JVM_AccessVMIntFlag: IMPLEMENT ME!");
3066 /* JVM_VMBreakPoint */
3068 void JVM_VMBreakPoint(JNIEnv *env, jobject obj)
3070 log_println("JVM_VMBreakPoint: IMPLEMENT ME!");
3074 /* JVM_GetClassFields */
3076 jobjectArray JVM_GetClassFields(JNIEnv *env, jclass cls, jint which)
3078 log_println("JVM_GetClassFields: IMPLEMENT ME!");
3084 /* JVM_GetClassMethods */
3086 jobjectArray JVM_GetClassMethods(JNIEnv *env, jclass cls, jint which)
3088 log_println("JVM_GetClassMethods: IMPLEMENT ME!");
3094 /* JVM_GetClassConstructors */
3096 jobjectArray JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which)
3098 log_println("JVM_GetClassConstructors: IMPLEMENT ME!");
3104 /* JVM_GetClassField */
3106 jobject JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which)
3108 log_println("JVM_GetClassField: IMPLEMENT ME!");
3114 /* JVM_GetClassMethod */
3116 jobject JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types, jint which)
3118 log_println("JVM_GetClassMethod: IMPLEMENT ME!");
3124 /* JVM_GetClassConstructor */
3126 jobject JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types, jint which)
3128 log_println("JVM_GetClassConstructor: IMPLEMENT ME!");
3134 /* JVM_NewInstance */
3136 jobject JVM_NewInstance(JNIEnv *env, jclass cls)
3138 log_println("JVM_NewInstance: IMPLEMENT ME!");
3146 jobject JVM_GetField(JNIEnv *env, jobject field, jobject obj)
3148 log_println("JVM_GetField: IMPLEMENT ME!");
3154 /* JVM_GetPrimitiveField */
3156 jvalue JVM_GetPrimitiveField(JNIEnv *env, jobject field, jobject obj, unsigned char wCode)
3160 log_println("JVM_GetPrimitiveField: IMPLEMENT ME!");
3170 void JVM_SetField(JNIEnv *env, jobject field, jobject obj, jobject val)
3172 log_println("JVM_SetField: IMPLEMENT ME!");
3176 /* JVM_SetPrimitiveField */
3178 void JVM_SetPrimitiveField(JNIEnv *env, jobject field, jobject obj, jvalue v, unsigned char vCode)
3180 log_println("JVM_SetPrimitiveField: IMPLEMENT ME!");
3184 /* JVM_InvokeMethod */
3186 jobject JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)
3188 TRACEJVMCALLS(("JVM_InvokeMethod(env=%p, method=%p, obj=%p, args0=%p)", env, method, obj, args0));
3190 java_lang_reflect_Method jlrm(method);
3192 java_handle_t* result = jlrm.invoke((java_handle_t*) obj, (java_handle_objectarray_t*) args0);
3194 return (jobject) result;
3198 /* JVM_NewInstanceFromConstructor */
3200 jobject JVM_NewInstanceFromConstructor(JNIEnv *env, jobject con, jobjectArray args0)
3202 TRACEJVMCALLS(("JVM_NewInstanceFromConstructor(env=%p, c=%p, args0=%p)", env, con, args0));
3204 java_lang_reflect_Constructor jlrc(con);
3205 java_handle_t* o = jlrc.new_instance((java_handle_objectarray_t*) args0);
3211 /* JVM_SupportsCX8 */
3213 jboolean JVM_SupportsCX8()
3215 TRACEJVMCALLS(("JVM_SupportsCX8()"));
3225 jboolean JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal)
3227 log_println("JVM_CX8Field: IMPLEMENT ME!");
3233 /* JVM_GetAllThreads */
3235 jobjectArray JVM_GetAllThreads(JNIEnv *env, jclass dummy)
3237 // Get a list of all active threads.
3238 List<threadobject*> active_threads;
3239 ThreadList::get_active_java_threads(active_threads);
3241 // Allocate array to hold the java.lang.Thread objects.
3242 int32_t length = active_threads.size();
3243 ObjectArray oa(length, class_java_lang_Thread);
3248 // Iterate over all threads (which were active just a second ago).
3250 for (List<threadobject*>::iterator it = active_threads.begin(); it != active_threads.end(); it++) {
3251 threadobject* t = *it;
3253 java_handle_t* h = LLNI_WRAP(t->object);
3256 oa.set_element(index, h);
3261 return oa.get_handle();
3265 /* JVM_DumpThreads */
3267 jobjectArray JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads)
3271 TRACEJVMCALLS(("JVM_DumpThreads((env=%p, threadClass=%p, threads=%p)", env, threadClass, threads));
3273 if (threads == NULL) {
3274 exceptions_throw_nullpointerexception();
3278 ObjectArray oa(threads);
3280 // Get length of the threads array.
3281 int32_t length = oa.get_length();
3284 exceptions_throw_illegalargumentexception();
3288 // Allocate array to hold stacktraces.
3289 classinfo* arrayclass = class_array_of(class_java_lang_StackTraceElement, true);
3290 ObjectArray oaresult(length, arrayclass);
3292 if (oaresult.is_null()) {
3296 // Iterate over all passed thread objects.
3297 for (i = 0; i < length; i++) {
3298 java_handle_t* thread = oa.get_element(i);
3300 // Get thread for the given thread object.
3301 threadobject* t = thread_get_thread(thread);
3303 // The threadobject is null when a thread is created in Java.
3307 // Get stacktrace for given thread.
3308 stacktrace_t* st = stacktrace_get_of_thread(t);
3310 // Convert stacktrace into array of StackTraceElements.
3311 java_handle_objectarray_t* oaste = stacktrace_get_StackTraceElements(st);
3316 oaresult.set_element(i, oaste);
3319 return oaresult.get_handle();
3323 /* JVM_GetManagement */
3325 void *JVM_GetManagement(jint version)
3327 TRACEJVMCALLS(("JVM_GetManagement(version=%d)", version));
3329 return Management::get_jmm_interface(version);
3333 /* JVM_InitAgentProperties */
3335 jobject JVM_InitAgentProperties(JNIEnv *env, jobject properties)
3337 log_println("JVM_InitAgentProperties: IMPLEMENT ME!");
3343 /* JVM_GetEnclosingMethodInfo */
3345 jobjectArray JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass)
3347 TRACEJVMCALLS(("JVM_GetEnclosingMethodInfo(env=%p, ofClass=%p)", env, ofClass));
3349 classinfo* c = LLNI_classinfo_unwrap(ofClass);
3351 if ((c == NULL) || class_is_primitive(c))
3354 methodinfo* m = class_get_enclosingmethod_raw(c);
3359 ObjectArray oa(3, class_java_lang_Object);
3364 oa.set_element(0, (java_handle_t *) LLNI_classinfo_wrap(m->clazz));
3365 oa.set_element(1, javastring_new(m->name));
3366 oa.set_element(2, javastring_new(m->descriptor));
3368 return oa.get_handle();
3372 /* JVM_GetThreadStateValues */
3374 jintArray JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState)
3376 TRACEJVMCALLS(("JVM_GetThreadStateValues(env=%p, javaThreadState=%d)",
3377 env, javaThreadState));
3379 /* If new thread states are added in future JDK and VM versions,
3380 this should check if the JDK version is compatible with thread
3381 states supported by the VM. Return NULL if not compatible.
3383 This function must map the VM java_lang_Thread::ThreadStatus
3384 to the Java thread state that the JDK supports. */
3386 switch (javaThreadState) {
3387 case THREAD_STATE_NEW:
3394 ia.set_element(0, THREAD_STATE_NEW);
3395 return ia.get_handle();
3398 case THREAD_STATE_RUNNABLE:
3405 ia.set_element(0, THREAD_STATE_RUNNABLE);
3406 return ia.get_handle();
3409 case THREAD_STATE_BLOCKED:
3416 ia.set_element(0, THREAD_STATE_BLOCKED);
3417 return ia.get_handle();
3420 case THREAD_STATE_WAITING:
3427 ia.set_element(0, THREAD_STATE_WAITING);
3428 ia.set_element(1, THREAD_STATE_PARKED);
3429 return ia.get_handle();
3432 case THREAD_STATE_TIMED_WAITING:
3439 /* XXX Not sure about that one. */
3440 /* ia.set_element(0, SLEEPING); */
3441 ia.set_element(0, THREAD_STATE_TIMED_WAITING);
3442 ia.set_element(1, THREAD_STATE_TIMED_PARKED);
3443 return ia.get_handle();
3446 case THREAD_STATE_TERMINATED:
3453 ia.set_element(0, THREAD_STATE_TERMINATED);
3454 return ia.get_handle();
3458 /* Unknown state - probably incompatible JDK version */
3464 /* JVM_GetThreadStateNames */
3466 jobjectArray JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values)
3470 TRACEJVMCALLS(("JVM_GetThreadStateNames(env=%p, javaThreadState=%d, values=%p)",
3471 env, javaThreadState, values));
3473 IntArray ia(values);
3475 /* If new thread states are added in future JDK and VM versions,
3476 this should check if the JDK version is compatible with thread
3477 states supported by the VM. Return NULL if not compatible.
3479 This function must map the VM java_lang_Thread::ThreadStatus
3480 to the Java thread state that the JDK supports. */
3482 if (values == NULL) {
3483 exceptions_throw_nullpointerexception();
3487 switch (javaThreadState) {
3488 case THREAD_STATE_NEW:
3490 assert(ia.get_length() == 1 && ia.get_element(0) == THREAD_STATE_NEW);
3492 ObjectArray oa(1, class_java_lang_String);
3497 s = javastring_new(utf_new_char("NEW"));
3502 oa.set_element(0, s);
3503 return oa.get_handle();
3506 case THREAD_STATE_RUNNABLE:
3508 ObjectArray oa(1, class_java_lang_String);
3513 s = javastring_new(utf_new_char("RUNNABLE"));
3518 oa.set_element(0, s);
3519 return oa.get_handle();
3522 case THREAD_STATE_BLOCKED:
3524 ObjectArray oa(1, class_java_lang_String);
3529 s = javastring_new(utf_new_char("BLOCKED"));
3534 oa.set_element(0, s);
3535 return oa.get_handle();
3538 case THREAD_STATE_WAITING:
3540 ObjectArray oa(2, class_java_lang_String);
3545 s = javastring_new(utf_new_char("WAITING.OBJECT_WAIT"));
3550 oa.set_element(0, s);
3552 s = javastring_new(utf_new_char("WAITING.PARKED"));
3557 oa.set_element(1, s);
3558 return oa.get_handle();
3561 case THREAD_STATE_TIMED_WAITING:
3563 ObjectArray oa(2, class_java_lang_String);
3568 /* s = javastring_new(utf_new_char("TIMED_WAITING.SLEEPING")); */
3569 s = javastring_new(utf_new_char("TIMED_WAITING.OBJECT_WAIT"));
3574 oa.set_element(0, s);
3576 s = javastring_new(utf_new_char("TIMED_WAITING.PARKED"));
3581 oa.set_element(1, s);
3582 return oa.get_handle();
3585 case THREAD_STATE_TERMINATED:
3587 ObjectArray oa(1, class_java_lang_String);
3592 s = javastring_new(utf_new_char("TERMINATED"));
3597 oa.set_element(0, s);
3598 return oa.get_handle();
3602 /* Unknown state - probably incompatible JDK version */
3608 /* JVM_GetVersionInfo */
3610 void JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size)
3612 TRACEJVMCALLS(("JVM_GetVersionInfo(env=%p, info=%p, info_size=%zd)", env, info, info_size));
3614 memset(info, 0, info_size);
3616 info->jvm_version = ((VERSION_MAJOR & 0xff) << 24) | ((VERSION_MINOR & 0xff) << 16) | (VERSION_MICRO & 0xff);
3617 info->update_version = 0;
3618 info->special_update_version = 0;
3619 info->is_attach_supported = 0;
3620 info->is_kernel_jvm = 0;
3624 /* OS: JVM_RegisterSignal */
3626 void *JVM_RegisterSignal(jint sig, void *handler)
3628 functionptr newHandler;
3630 TRACEJVMCALLS(("JVM_RegisterSignal(sig=%d, handler=%p)", sig, handler));
3632 if (handler == (void *) 2)
3633 newHandler = (functionptr) signal_thread_handler;
3635 newHandler = (functionptr) (uintptr_t) handler;
3642 /* These signals are already used by the VM. */
3646 /* This signal is used by the VM to dump thread stacks unless
3647 ReduceSignalUsage is set, in which case the user is allowed
3648 to set his own _native_ handler for this signal; thus, in
3649 either case, we do not allow JVM_RegisterSignal to change
3659 signal_register_signal(sig, newHandler, SA_RESTART | SA_SIGINFO);
3661 /* XXX Should return old handler. */
3667 /* OS: JVM_RaiseSignal */
3669 jboolean JVM_RaiseSignal(jint sig)
3671 log_println("JVM_RaiseSignal: IMPLEMENT ME! sig=%s", sig);
3677 /* OS: JVM_FindSignal */
3679 jint JVM_FindSignal(const char *name)
3681 TRACEJVMCALLS(("JVM_FindSignal(name=%s)", name));
3683 #if defined(__LINUX__)
3684 if (strcmp(name, "HUP") == 0)
3687 if (strcmp(name, "INT") == 0)
3690 if (strcmp(name, "TERM") == 0)
3692 #elif defined(__SOLARIS__)
3695 if (os::str2sig(name, &signum) == -1)
3700 # error Not implemented for this OS.
3710 * These are local overrides for various environment variables in Emacs.
3711 * Please do not remove this and leave it at the end of the file, where
3712 * Emacs will automagically detect them.
3713 * ---------------------------------------------------------------------
3716 * indent-tabs-mode: t
3720 * vim:noexpandtab:sw=4:ts=4: