1 /* src/native/vm/sun/jvm.c - HotSpot JVM interface functions
3 Copyright (C) 2007, 2008
4 CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
6 This file is part of CACAO.
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.
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.
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
36 #if defined(HAVE_SYS_IOCTL_H)
37 #define BSD_COMP /* Get FIONREAD on Solaris2 */
38 #include <sys/ioctl.h>
41 #include <sys/socket.h>
43 #include <sys/types.h>
47 #include "mm/memory.h"
49 #include "native/jni.h"
50 #include "native/llni.h"
51 #include "native/native.h"
53 #include "native/include/java_lang_AssertionStatusDirectives.h"
54 #include "native/include/java_lang_String.h" /* required by j.l.CL */
55 #include "native/include/java_nio_ByteBuffer.h" /* required by j.l.CL */
56 #include "native/include/java_lang_ClassLoader.h" /* required by j.l.C */
57 #include "native/include/java_lang_StackTraceElement.h"
58 #include "native/include/java_lang_Throwable.h"
59 #include "native/include/java_security_ProtectionDomain.h"
61 #if defined(ENABLE_ANNOTATIONS)
62 #include "native/include/sun_reflect_ConstantPool.h"
65 #include "native/vm/reflect.h"
67 #include "native/vm/sun/hpi.h"
69 #include "threads/lock-common.h"
70 #include "threads/thread.h"
72 #include "toolbox/logging.h"
73 #include "toolbox/list.h"
77 #if defined(ENABLE_ASSERTION)
78 #include "vm/assertion.h"
81 #include "vm/builtin.h"
82 #include "vm/exceptions.h"
83 #include "vm/global.h"
84 #include "vm/initialize.h"
85 #include "vm/package.h"
86 #include "vm/primitive.h"
87 #include "vm/properties.h"
88 #include "vm/resolve.h"
89 #include "vm/signallocal.h"
90 #include "vm/stringlocal.h"
93 #include "vm/jit/stacktrace.h"
95 #include "vmcore/classcache.h"
96 #include "vmcore/options.h"
97 #include "vmcore/system.h"
100 /* debugging macros ***********************************************************/
104 # define TRACEJVMCALLS(x) \
106 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
111 # define TRACEJVMCALLSENTER(x) \
113 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
119 # define TRACEJVMCALLSEXIT(x) \
121 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
127 # define TRACEJVMCALLSVERBOSE(x) \
129 if (opt_TraceJVMCallsVerbose) { \
134 # define PRINTJVMWARNINGS(x)
136 /* if (opt_PrintJVMWarnings) { \ */
137 /* log_println x; \ */
143 # define TRACEJVMCALLS(x)
144 # define TRACEJVMCALLSENTER(x)
145 # define TRACEJVMCALLSEXIT(x)
146 # define TRACEJVMCALLSVERBOSE(x)
147 # define PRINTJVMWARNINGS(x)
153 /* Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx */
154 unsigned int jvm_version; /* Consists of major, minor, micro (n.n.n) */
155 /* and build number (xx) */
156 unsigned int update_version : 8; /* Update release version (uu) */
157 unsigned int special_update_version : 8; /* Special update release version (c) */
158 unsigned int reserved1 : 16;
159 unsigned int reserved2;
161 /* The following bits represents JVM supports that JDK has dependency on.
162 * JDK can use these bits to determine which JVM version
163 * and support it has to maintain runtime compatibility.
165 * When a new bit is added in a minor or update release, make sure
166 * the new bit is also added in the main/baseline.
168 unsigned int is_attachable : 1;
176 * A structure used to a capture exception table entry in a Java method.
183 } JVM_ExceptionTableEntryType;
186 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
188 if ((intptr_t) count <= 0)
191 return vsnprintf(str, count, fmt, args);
195 int jio_snprintf(char *str, size_t count, const char *fmt, ...)
201 len = jio_vsnprintf(str, count, fmt, ap);
208 int jio_fprintf(FILE* f, const char *fmt, ...)
210 log_println("jio_fprintf: IMPLEMENT ME!");
216 int jio_vfprintf(FILE* f, const char *fmt, va_list args)
218 log_println("jio_vfprintf: IMPLEMENT ME!");
224 int jio_printf(const char *fmt, ...)
226 log_println("jio_printf: IMPLEMENT ME!");
232 /* JVM_GetInterfaceVersion */
234 jint JVM_GetInterfaceVersion()
236 /* This is defined in hotspot/src/share/vm/prims/jvm.h */
238 #define JVM_INTERFACE_VERSION 4
240 return JVM_INTERFACE_VERSION;
244 /* JVM_CurrentTimeMillis */
246 jlong JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)
248 TRACEJVMCALLS(("JVM_CurrentTimeMillis(env=%p, ignored=%p)", env, ignored));
250 return (jlong) builtin_currenttimemillis();
256 jlong JVM_NanoTime(JNIEnv *env, jclass ignored)
258 TRACEJVMCALLS(("JVM_NanoTime(env=%p, ignored=%p)", env, ignored));
260 return (jlong) builtin_nanotime();
266 void JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos, jobject dst, jint dst_pos, jint length)
271 s = (java_handle_t *) src;
272 d = (java_handle_t *) dst;
274 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));
276 builtin_arraycopy(s, src_pos, d, dst_pos, length);
280 /* JVM_InitProperties */
282 jobject JVM_InitProperties(JNIEnv *env, jobject properties)
287 TRACEJVMCALLS(("JVM_InitProperties(env=%p, properties=%p)", env, properties));
289 h = (java_handle_t *) properties;
291 /* Convert the -XX:MaxDirectMemorySize= command line flag to the
292 sun.nio.MaxDirectMemorySize property. Do this after setting
293 user properties to prevent people from setting the value with a
294 -D option, as requested. */
296 jio_snprintf(buf, sizeof(buf), PRINTF_FORMAT_INT64_T, opt_MaxDirectMemorySize);
297 properties_add("sun.nio.MaxDirectMemorySize", buf);
299 /* Add all properties. */
301 properties_system_add_all(h);
309 void JVM_Exit(jint code)
311 log_println("JVM_Exit: IMPLEMENT ME!");
317 void JVM_Halt(jint code)
319 TRACEJVMCALLS(("JVM_Halt(code=%d)", code));
326 /* JVM_OnExit(void (*func)) */
328 void JVM_OnExit(void (*func)(void))
330 log_println("JVM_OnExit(void (*func): IMPLEMENT ME!");
338 TRACEJVMCALLS(("JVM_GC()"));
344 /* JVM_MaxObjectInspectionAge */
346 jlong JVM_MaxObjectInspectionAge(void)
348 log_println("JVM_MaxObjectInspectionAge: IMPLEMENT ME!");
354 /* JVM_TraceInstructions */
356 void JVM_TraceInstructions(jboolean on)
358 log_println("JVM_TraceInstructions: IMPLEMENT ME!");
362 /* JVM_TraceMethodCalls */
364 void JVM_TraceMethodCalls(jboolean on)
366 log_println("JVM_TraceMethodCalls: IMPLEMENT ME!");
370 /* JVM_TotalMemory */
372 jlong JVM_TotalMemory(void)
374 TRACEJVMCALLS(("JVM_TotalMemory()"));
376 return gc_get_heap_size();
382 jlong JVM_FreeMemory(void)
384 TRACEJVMCALLS(("JVM_FreeMemory()"));
386 return gc_get_free_bytes();
392 jlong JVM_MaxMemory(void)
394 TRACEJVMCALLS(("JVM_MaxMemory()"));
396 return gc_get_max_heap_size();
400 /* JVM_ActiveProcessorCount */
402 jint JVM_ActiveProcessorCount(void)
404 TRACEJVMCALLS(("JVM_ActiveProcessorCount()"));
406 return system_processors_online();
410 /* JVM_FillInStackTrace */
412 void JVM_FillInStackTrace(JNIEnv *env, jobject receiver)
414 java_lang_Throwable *o;
415 java_handle_bytearray_t *ba;
417 TRACEJVMCALLS(("JVM_FillInStackTrace(env=%p, receiver=%p)", env, receiver));
419 o = (java_lang_Throwable *) receiver;
421 ba = stacktrace_get_current();
426 LLNI_field_set_ref(o, backtrace, (java_lang_Object *) ba);
430 /* JVM_PrintStackTrace */
432 void JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable)
434 log_println("JVM_PrintStackTrace: IMPLEMENT ME!");
438 /* JVM_GetStackTraceDepth */
440 jint JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable)
442 java_lang_Throwable *to;
444 java_handle_bytearray_t *ba;
448 TRACEJVMCALLS(("JVM_GetStackTraceDepth(env=%p, throwable=%p)", env, throwable));
450 if (throwable == NULL) {
451 exceptions_throw_nullpointerexception();
455 to = (java_lang_Throwable *) throwable;
457 LLNI_field_get_ref(to, backtrace, o);
459 ba = (java_handle_bytearray_t *) o;
464 /* We need a critical section here as the stacktrace structure is
465 mapped onto a Java byte-array. */
469 st = (stacktrace_t *) LLNI_array_data(ba);
479 /* JVM_GetStackTraceElement */
481 jobject JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index)
483 java_lang_Throwable *to;
485 java_handle_bytearray_t *ba;
487 stacktrace_entry_t *ste;
491 java_lang_StackTraceElement *steo;
492 java_handle_t* declaringclass;
493 java_lang_String *filename;
496 TRACEJVMCALLS(("JVM_GetStackTraceElement(env=%p, throwable=%p, index=%d)", env, throwable, index));
498 to = (java_lang_Throwable *) throwable;
500 LLNI_field_get_ref(to, backtrace, o);
502 ba = (java_handle_bytearray_t *) o;
504 /* FIXME critical section */
506 st = (stacktrace_t *) LLNI_array_data(ba);
508 if ((index < 0) || (index >= st->length)) {
509 /* XXX This should be an IndexOutOfBoundsException (check this
512 exceptions_throw_arrayindexoutofboundsexception();
516 /* Get the stacktrace entry. */
518 ste = &(st->entries[index]);
520 /* Get the codeinfo, methodinfo and classinfo. */
526 /* allocate a new StackTraceElement */
528 steo = (java_lang_StackTraceElement *)
529 builtin_new(class_java_lang_StackTraceElement);
536 if (!(m->flags & ACC_NATIVE)) {
537 if (c->sourcefile != NULL)
538 filename = (java_lang_String *) javastring_new(c->sourcefile);
545 /* get line number */
547 if (m->flags & ACC_NATIVE) {
551 /* FIXME The linenumbertable_linenumber_for_pc could change
552 the methodinfo pointer when hitting an inlined method. */
554 linenumber = linenumbertable_linenumber_for_pc(&m, code, ste->pc);
555 linenumber = (linenumber == 0) ? -1 : linenumber;
558 /* get declaring class name */
560 declaringclass = class_get_classname(c);
562 /* fill the java.lang.StackTraceElement element */
564 /* FIXME critical section */
566 steo->declaringClass = (java_lang_String*) declaringclass;
567 steo->methodName = (java_lang_String*) javastring_new(m->name);
568 steo->fileName = filename;
569 steo->lineNumber = linenumber;
571 return (jobject) steo;
577 jint JVM_IHashCode(JNIEnv* env, jobject handle)
579 TRACEJVMCALLS(("JVM_IHashCode(env=%p, jobject=%p)", env, handle));
581 return (jint) ((ptrint) handle);
585 /* JVM_MonitorWait */
587 void JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms)
589 #if defined(ENABLE_THREADS)
593 TRACEJVMCALLS(("JVM_MonitorWait(env=%p, handle=%p, ms=%ld)", env, handle, ms));
595 /* exceptions_throw_illegalargumentexception("argument out of range"); */
596 exceptions_throw_illegalargumentexception();
600 #if defined(ENABLE_THREADS)
601 o = (java_handle_t *) handle;
603 lock_wait_for_object(o, ms, 0);
608 /* JVM_MonitorNotify */
610 void JVM_MonitorNotify(JNIEnv* env, jobject handle)
612 #if defined(ENABLE_THREADS)
616 TRACEJVMCALLS(("JVM_MonitorNotify(env=%p, handle=%p)", env, handle));
618 #if defined(ENABLE_THREADS)
619 o = (java_handle_t *) handle;
621 lock_notify_object(o);
626 /* JVM_MonitorNotifyAll */
628 void JVM_MonitorNotifyAll(JNIEnv* env, jobject handle)
630 #if defined(ENABLE_THREADS)
634 TRACEJVMCALLS(("JVM_MonitorNotifyAll(env=%p, handle=%p)", env, handle));
636 #if defined(ENABLE_THREADS)
637 o = (java_handle_t *) handle;
639 lock_notify_all_object(o);
646 jobject JVM_Clone(JNIEnv* env, jobject handle)
648 TRACEJVMCALLS(("JVM_Clone(env=%p, handle=%p)", env, handle));
650 return (jobject) builtin_clone(env, (java_handle_t *) handle);
654 /* JVM_InitializeCompiler */
656 void JVM_InitializeCompiler (JNIEnv *env, jclass compCls)
658 log_println("JVM_InitializeCompiler : IMPLEMENT ME!");
662 /* JVM_IsSilentCompiler */
664 jboolean JVM_IsSilentCompiler(JNIEnv *env, jclass compCls)
666 log_println("JVM_IsSilentCompiler: IMPLEMENT ME!");
672 /* JVM_CompileClass */
674 jboolean JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls)
676 log_println("JVM_CompileClass: IMPLEMENT ME!");
682 /* JVM_CompileClasses */
684 jboolean JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname)
686 log_println("JVM_CompileClasses: IMPLEMENT ME!");
692 /* JVM_CompilerCommand */
694 jobject JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg)
696 log_println("JVM_CompilerCommand: IMPLEMENT ME!");
702 /* JVM_EnableCompiler */
704 void JVM_EnableCompiler(JNIEnv *env, jclass compCls)
706 TRACEJVMCALLS(("JVM_EnableCompiler(env=%p, compCls=%p)", env, compCls));
707 PRINTJVMWARNINGS(("JVM_EnableCompiler not supported"));
711 /* JVM_DisableCompiler */
713 void JVM_DisableCompiler(JNIEnv *env, jclass compCls)
715 TRACEJVMCALLS(("JVM_DisableCompiler(env=%p, compCls=%p)", env, compCls));
716 PRINTJVMWARNINGS(("JVM_DisableCompiler not supported"));
720 /* JVM_GetLastErrorString */
722 jint JVM_GetLastErrorString(char *buf, int len)
724 TRACEJVMCALLS(("JVM_GetLastErrorString(buf=%p, len=%d", buf, len));
726 return hpi_system->GetLastErrorString(buf, len);
732 char *JVM_NativePath(char *path)
734 TRACEJVMCALLS(("JVM_NativePath(path=%s)", path));
736 return hpi_file->NativePath(path);
740 /* JVM_GetCallerClass */
742 jclass JVM_GetCallerClass(JNIEnv* env, int depth)
746 TRACEJVMCALLS(("JVM_GetCallerClass(env=%p, depth=%d)", env, depth));
748 c = stacktrace_get_caller_class(depth);
754 /* JVM_FindPrimitiveClass */
756 jclass JVM_FindPrimitiveClass(JNIEnv* env, const char* s)
761 TRACEJVMCALLS(("JVM_FindPrimitiveClass(env=%p, s=%s)", env, s));
764 c = primitive_class_get_by_name(u);
766 return (jclass) LLNI_classinfo_wrap(c);
770 /* JVM_ResolveClass */
772 void JVM_ResolveClass(JNIEnv* env, jclass cls)
774 TRACEJVMCALLS(("JVM_ResolveClass(env=%p, cls=%p)", env, cls));
775 PRINTJVMWARNINGS(("JVM_ResolveClass not implemented"));
779 /* JVM_FindClassFromClassLoader */
781 jclass JVM_FindClassFromClassLoader(JNIEnv* env, const char* name, jboolean init, jobject loader, jboolean throwError)
787 TRACEJVMCALLS(("JVM_FindClassFromClassLoader(name=%s, init=%d, loader=%p, throwError=%d)", name, init, loader, throwError));
789 /* As of now, OpenJDK does not call this function with throwError
792 assert(throwError == false);
794 u = utf_new_char(name);
795 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
797 c = load_class_from_classloader(u, cl);
803 if (!(c->state & CLASS_INITIALIZED))
804 if (!initialize_class(c))
807 return (jclass) LLNI_classinfo_wrap(c);
811 /* JVM_FindClassFromClass */
813 jclass JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init, jclass from)
815 log_println("JVM_FindClassFromClass: IMPLEMENT ME!");
821 /* JVM_DefineClass */
823 jclass JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)
825 log_println("JVM_DefineClass: IMPLEMENT ME!");
831 /* JVM_DefineClassWithSource */
833 jclass JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)
839 TRACEJVMCALLS(("JVM_DefineClassWithSource(env=%p, name=%s, loader=%p, buf=%p, len=%d, pd=%p, source=%s)", env, name, loader, buf, len, pd, source));
842 u = utf_new_char(name);
846 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
848 /* XXX do something with source */
850 c = class_define(u, cl, len, (uint8_t *) buf, (java_handle_t *) pd);
852 return (jclass) LLNI_classinfo_wrap(c);
856 /* JVM_FindLoadedClass */
858 jclass JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name)
864 TRACEJVMCALLS(("JVM_FindLoadedClass(env=%p, loader=%p, name=%p)", env, loader, name));
866 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
868 u = javastring_toutf((java_handle_t *) name, true);
869 c = classcache_lookup(cl, u);
871 return (jclass) LLNI_classinfo_wrap(c);
875 /* JVM_GetClassName */
877 jstring JVM_GetClassName(JNIEnv *env, jclass cls)
881 TRACEJVMCALLS(("JVM_GetClassName(env=%p, cls=%p)", env, cls));
883 c = LLNI_classinfo_unwrap(cls);
885 return (jstring) class_get_classname(c);
889 /* JVM_GetClassInterfaces */
891 jobjectArray JVM_GetClassInterfaces(JNIEnv *env, jclass cls)
894 java_handle_objectarray_t *oa;
896 TRACEJVMCALLS(("JVM_GetClassInterfaces(env=%p, cls=%p)", env, cls));
898 c = LLNI_classinfo_unwrap(cls);
900 oa = class_get_interfaces(c);
902 return (jobjectArray) oa;
906 /* JVM_GetClassLoader */
908 jobject JVM_GetClassLoader(JNIEnv *env, jclass cls)
913 TRACEJVMCALLSENTER(("JVM_GetClassLoader(env=%p, cls=%p)", env, cls));
915 c = LLNI_classinfo_unwrap(cls);
916 cl = class_get_classloader(c);
918 TRACEJVMCALLSEXIT(("->%p", cl));
924 /* JVM_IsInterface */
926 jboolean JVM_IsInterface(JNIEnv *env, jclass cls)
930 TRACEJVMCALLS(("JVM_IsInterface(env=%p, cls=%p)", env, cls));
932 c = LLNI_classinfo_unwrap(cls);
934 return class_is_interface(c);
938 /* JVM_GetClassSigners */
940 jobjectArray JVM_GetClassSigners(JNIEnv *env, jclass cls)
942 log_println("JVM_GetClassSigners: IMPLEMENT ME!");
948 /* JVM_SetClassSigners */
950 void JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers)
953 java_handle_objectarray_t *hoa;
955 TRACEJVMCALLS(("JVM_SetClassSigners(env=%p, cls=%p, signers=%p)", env, cls, signers));
957 c = LLNI_classinfo_unwrap(cls);
959 hoa = (java_handle_objectarray_t *) signers;
961 /* This call is ignored for primitive types and arrays. Signers
962 are only set once, ClassLoader.java, and thus shouldn't be
963 called with an array. Only the bootstrap loader creates
966 if (class_is_primitive(c) || class_is_array(c))
969 LLNI_classinfo_field_set(c, signers, hoa);
973 /* JVM_GetProtectionDomain */
975 jobject JVM_GetProtectionDomain(JNIEnv *env, jclass cls)
979 TRACEJVMCALLS(("JVM_GetProtectionDomain(env=%p, cls=%p)", env, cls));
981 c = LLNI_classinfo_unwrap(cls);
984 exceptions_throw_nullpointerexception();
988 /* Primitive types do not have a protection domain. */
990 if (class_is_primitive(c))
993 return (jobject) c->protectiondomain;
997 /* JVM_SetProtectionDomain */
999 void JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain)
1001 log_println("JVM_SetProtectionDomain: IMPLEMENT ME!");
1005 /* JVM_DoPrivileged */
1007 jobject JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, jobject context, jboolean wrapException)
1012 java_handle_t *result;
1015 TRACEJVMCALLS(("JVM_DoPrivileged(env=%p, cls=%p, action=%p, context=%p, wrapException=%d)", env, cls, action, context, wrapException));
1017 h = (java_handle_t *) action;
1018 LLNI_class_get(h, c);
1020 if (action == NULL) {
1021 exceptions_throw_nullpointerexception();
1025 /* lookup run() method (throw no exceptions) */
1027 m = class_resolveclassmethod(c, utf_run, utf_void__java_lang_Object, c,
1030 if ((m == NULL) || !(m->flags & ACC_PUBLIC) || (m->flags & ACC_STATIC)) {
1031 exceptions_throw_internalerror("No run method");
1035 /* XXX It seems something with a privileged stack needs to be done
1038 result = vm_call_method(m, h);
1040 e = exceptions_get_exception();
1043 if ( builtin_instanceof(e, class_java_lang_Exception) &&
1044 !builtin_instanceof(e, class_java_lang_RuntimeException)) {
1045 exceptions_clear_exception();
1046 exceptions_throw_privilegedactionexception(e);
1052 return (jobject) result;
1056 /* JVM_GetInheritedAccessControlContext */
1058 jobject JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls)
1060 log_println("JVM_GetInheritedAccessControlContext: IMPLEMENT ME!");
1066 /* JVM_GetStackAccessControlContext */
1068 jobject JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls)
1070 TRACEJVMCALLS(("JVM_GetStackAccessControlContext(env=%p, cls=%p): IMPLEMENT ME!", env, cls));
1072 /* XXX All stuff I tested so far works without that function. At
1073 some point we have to implement it, but I disable the output
1074 for now to make IcedTea happy. */
1080 /* JVM_IsArrayClass */
1082 jboolean JVM_IsArrayClass(JNIEnv *env, jclass cls)
1086 TRACEJVMCALLS(("JVM_IsArrayClass(env=%p, cls=%p)", env, cls));
1088 c = LLNI_classinfo_unwrap(cls);
1090 return class_is_array(c);
1094 /* JVM_IsPrimitiveClass */
1096 jboolean JVM_IsPrimitiveClass(JNIEnv *env, jclass cls)
1100 TRACEJVMCALLS(("JVM_IsPrimitiveClass(env=%p, cls=%p)", env, cls));
1102 c = LLNI_classinfo_unwrap(cls);
1104 return class_is_primitive(c);
1108 /* JVM_GetComponentType */
1110 jclass JVM_GetComponentType(JNIEnv *env, jclass cls)
1112 classinfo *component;
1115 TRACEJVMCALLS(("JVM_GetComponentType(env=%p, cls=%p)", env, cls));
1117 c = LLNI_classinfo_unwrap(cls);
1119 component = class_get_componenttype(c);
1121 return (jclass) LLNI_classinfo_wrap(component);
1125 /* JVM_GetClassModifiers */
1127 jint JVM_GetClassModifiers(JNIEnv *env, jclass cls)
1132 TRACEJVMCALLS(("JVM_GetClassModifiers(env=%p, cls=%p)", env, cls));
1134 c = LLNI_classinfo_unwrap(cls);
1136 flags = class_get_modifiers(c, false);
1142 /* JVM_GetDeclaredClasses */
1144 jobjectArray JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)
1147 java_handle_objectarray_t *oa;
1149 TRACEJVMCALLS(("JVM_GetDeclaredClasses(env=%p, ofClass=%p)", env, ofClass));
1151 c = LLNI_classinfo_unwrap(ofClass);
1153 oa = class_get_declaredclasses(c, false);
1155 return (jobjectArray) oa;
1159 /* JVM_GetDeclaringClass */
1161 jclass JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass)
1166 TRACEJVMCALLS(("JVM_GetDeclaringClass(env=%p, ofClass=%p)", env, ofClass));
1168 c = LLNI_classinfo_unwrap(ofClass);
1170 dc = class_get_declaringclass(c);
1172 return (jclass) LLNI_classinfo_wrap(dc);
1176 /* JVM_GetClassSignature */
1178 jstring JVM_GetClassSignature(JNIEnv *env, jclass cls)
1184 TRACEJVMCALLS(("JVM_GetClassSignature(env=%p, cls=%p)", env, cls));
1186 c = LLNI_classinfo_unwrap(cls);
1188 /* Get the signature of the class. */
1190 u = class_get_signature(c);
1195 /* Convert UTF-string to a Java-string. */
1197 s = javastring_new(u);
1203 /* JVM_GetClassAnnotations */
1205 jbyteArray JVM_GetClassAnnotations(JNIEnv *env, jclass cls)
1207 classinfo *c = NULL; /* classinfo for 'cls' */
1208 java_handle_bytearray_t *annotations = NULL; /* unparsed annotations */
1210 TRACEJVMCALLS(("JVM_GetClassAnnotations: cls=%p", cls));
1213 exceptions_throw_nullpointerexception();
1217 c = LLNI_classinfo_unwrap(cls);
1219 /* get annotations: */
1220 annotations = class_get_annotations(c);
1222 return (jbyteArray)annotations;
1226 /* JVM_GetFieldAnnotations */
1228 jbyteArray JVM_GetFieldAnnotations(JNIEnv *env, jobject field)
1230 java_lang_reflect_Field *rf = NULL; /* java.lang.reflect.Field for 'field' */
1231 java_handle_bytearray_t *ba = NULL; /* unparsed annotations */
1233 TRACEJVMCALLS(("JVM_GetFieldAnnotations: field=%p", field));
1235 if (field == NULL) {
1236 exceptions_throw_nullpointerexception();
1240 rf = (java_lang_reflect_Field*)field;
1242 LLNI_field_get_ref(rf, annotations, ba);
1244 return (jbyteArray)ba;
1248 /* JVM_GetMethodAnnotations */
1250 jbyteArray JVM_GetMethodAnnotations(JNIEnv *env, jobject method)
1252 java_lang_reflect_Method *rm = NULL; /* java.lang.reflect.Method for 'method' */
1253 java_handle_bytearray_t *ba = NULL; /* unparsed annotations */
1255 TRACEJVMCALLS(("JVM_GetMethodAnnotations: method=%p", method));
1257 if (method == NULL) {
1258 exceptions_throw_nullpointerexception();
1262 rm = (java_lang_reflect_Method*)method;
1264 LLNI_field_get_ref(rm, annotations, ba);
1266 return (jbyteArray)ba;
1270 /* JVM_GetMethodDefaultAnnotationValue */
1272 jbyteArray JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method)
1274 java_lang_reflect_Method *rm = NULL; /* java.lang.reflect.Method for 'method' */
1275 java_handle_bytearray_t *ba = NULL; /* unparsed annotation default value */
1277 TRACEJVMCALLS(("JVM_GetMethodDefaultAnnotationValue: method=%p", method));
1279 if (method == NULL) {
1280 exceptions_throw_nullpointerexception();
1284 rm = (java_lang_reflect_Method*)method;
1286 LLNI_field_get_ref(rm, annotationDefault, ba);
1288 return (jbyteArray)ba;
1292 /* JVM_GetMethodParameterAnnotations */
1294 jbyteArray JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method)
1296 java_lang_reflect_Method *rm = NULL; /* java.lang.reflect.Method for 'method' */
1297 java_handle_bytearray_t *ba = NULL; /* unparsed parameter annotations */
1299 TRACEJVMCALLS(("JVM_GetMethodParameterAnnotations: method=%p", method));
1301 if (method == NULL) {
1302 exceptions_throw_nullpointerexception();
1306 rm = (java_lang_reflect_Method*)method;
1308 LLNI_field_get_ref(rm, parameterAnnotations, ba);
1310 return (jbyteArray)ba;
1314 /* JVM_GetClassDeclaredFields */
1316 jobjectArray JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1319 java_handle_objectarray_t *oa;
1321 TRACEJVMCALLS(("JVM_GetClassDeclaredFields(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1323 c = LLNI_classinfo_unwrap(ofClass);
1325 oa = class_get_declaredfields(c, publicOnly);
1327 return (jobjectArray) oa;
1331 /* JVM_GetClassDeclaredMethods */
1333 jobjectArray JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1336 java_handle_objectarray_t *oa;
1338 TRACEJVMCALLS(("JVM_GetClassDeclaredMethods(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1340 c = LLNI_classinfo_unwrap(ofClass);
1342 oa = class_get_declaredmethods(c, publicOnly);
1344 return (jobjectArray) oa;
1348 /* JVM_GetClassDeclaredConstructors */
1350 jobjectArray JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1353 java_handle_objectarray_t *oa;
1355 TRACEJVMCALLS(("JVM_GetClassDeclaredConstructors(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1357 c = LLNI_classinfo_unwrap(ofClass);
1359 oa = class_get_declaredconstructors(c, publicOnly);
1361 return (jobjectArray) oa;
1365 /* JVM_GetClassAccessFlags */
1367 jint JVM_GetClassAccessFlags(JNIEnv *env, jclass cls)
1371 TRACEJVMCALLS(("JVM_GetClassAccessFlags(env=%p, cls=%p)", env, cls));
1373 c = LLNI_classinfo_unwrap(cls);
1375 /* Primitive type classes have the correct access flags. */
1377 return c->flags & ACC_CLASS_REFLECT_MASK;
1381 /* JVM_GetClassConstantPool */
1383 jobject JVM_GetClassConstantPool(JNIEnv *env, jclass cls)
1385 #if defined(ENABLE_ANNOTATIONS)
1386 sun_reflect_ConstantPool *constantPool = NULL;
1387 /* constant pool object for the class refered by 'cls' */
1388 java_lang_Object *constantPoolOop = (java_lang_Object*)cls;
1389 /* constantPoolOop field of the constant pool object */
1391 TRACEJVMCALLS(("JVM_GetClassConstantPool(env=%p, cls=%p)", env, cls));
1394 (sun_reflect_ConstantPool*)native_new_and_init(
1395 class_sun_reflect_ConstantPool);
1397 if (constantPool == NULL) {
1402 LLNI_field_set_ref(constantPool, constantPoolOop, constantPoolOop);
1404 return (jobject)constantPool;
1406 log_println("JVM_GetClassConstantPool(env=%p, cls=%p): not implemented in this configuration!", env, cls);
1412 /* JVM_ConstantPoolGetSize */
1414 jint JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool)
1416 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1418 TRACEJVMCALLS(("JVM_ConstantPoolGetSize(env=%p, unused=%p, jcpool=%p)", env, unused, jcpool));
1420 c = LLNI_classinfo_unwrap(jcpool);
1426 /* JVM_ConstantPoolGetClassAt */
1428 jclass JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1430 constant_classref *ref; /* classref to the class at constant pool index 'index' */
1431 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1432 classinfo *result; /* classinfo of the class at constant pool index 'index' */
1434 TRACEJVMCALLS(("JVM_ConstantPoolGetClassAt(env=%p, jcpool=%p, index=%d)", env, jcpool, index));
1436 c = LLNI_classinfo_unwrap(jcpool);
1438 ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1441 exceptions_throw_illegalargumentexception();
1445 result = resolve_classref_eager(ref);
1447 return (jclass) LLNI_classinfo_wrap(result);
1451 /* JVM_ConstantPoolGetClassAtIfLoaded */
1453 jclass JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1455 constant_classref *ref; /* classref to the class at constant pool index 'index' */
1456 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1457 classinfo *result; /* classinfo of the class at constant pool index 'index' */
1459 TRACEJVMCALLS(("JVM_ConstantPoolGetClassAtIfLoaded(env=%p, unused=%p, jcpool=%p, index=%d)", env, unused, jcpool, index));
1461 c = LLNI_classinfo_unwrap(jcpool);
1463 ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1466 exceptions_throw_illegalargumentexception();
1470 if (!resolve_classref(NULL, ref, resolveLazy, true, true, &result)) {
1474 if ((result == NULL) || !(result->state & CLASS_LOADED)) {
1478 return (jclass) LLNI_classinfo_wrap(result);
1482 /* JVM_ConstantPoolGetMethodAt */
1484 jobject JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1486 constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
1487 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1489 TRACEJVMCALLS(("JVM_ConstantPoolGetMethodAt: jcpool=%p, index=%d", jcpool, index));
1491 cls = LLNI_classinfo_unwrap(jcpool);
1492 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1495 exceptions_throw_illegalargumentexception();
1499 /* XXX: is that right? or do I have to use resolve_method_*? */
1500 return (jobject)reflect_method_new(ref->p.method);
1504 /* JVM_ConstantPoolGetMethodAtIfLoaded */
1506 jobject JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1508 constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
1509 classinfo *c = NULL; /* resolved declaring class of the method */
1510 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1512 TRACEJVMCALLS(("JVM_ConstantPoolGetMethodAtIfLoaded: jcpool=%p, index=%d", jcpool, index));
1514 cls = LLNI_classinfo_unwrap(jcpool);
1515 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1518 exceptions_throw_illegalargumentexception();
1522 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1526 if (c == NULL || !(c->state & CLASS_LOADED)) {
1530 return (jobject)reflect_method_new(ref->p.method);
1534 /* JVM_ConstantPoolGetFieldAt */
1536 jobject JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1538 constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
1539 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1541 TRACEJVMCALLS(("JVM_ConstantPoolGetFieldAt: jcpool=%p, index=%d", jcpool, index));
1543 cls = LLNI_classinfo_unwrap(jcpool);
1544 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1547 exceptions_throw_illegalargumentexception();
1551 return (jobject)reflect_field_new(ref->p.field);
1555 /* JVM_ConstantPoolGetFieldAtIfLoaded */
1557 jobject JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1559 constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
1560 classinfo *c; /* resolved declaring class for the field */
1561 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1563 TRACEJVMCALLS(("JVM_ConstantPoolGetFieldAtIfLoaded: jcpool=%p, index=%d", jcpool, index));
1565 cls = LLNI_classinfo_unwrap(jcpool);
1566 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1569 exceptions_throw_illegalargumentexception();
1573 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1577 if (c == NULL || !(c->state & CLASS_LOADED)) {
1581 return (jobject)reflect_field_new(ref->p.field);
1585 /* JVM_ConstantPoolGetMemberRefInfoAt */
1587 jobjectArray JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1589 log_println("JVM_ConstantPoolGetMemberRefInfoAt: jcpool=%p, index=%d, IMPLEMENT ME!", jcpool, index);
1591 /* TODO: implement. (this is yet unused be OpenJDK but, so very low priority) */
1597 /* JVM_ConstantPoolGetIntAt */
1599 jint JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1601 constant_integer *ref; /* reference to the int value in constant pool at index 'index' */
1602 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1604 TRACEJVMCALLS(("JVM_ConstantPoolGetIntAt: jcpool=%p, index=%d", jcpool, index));
1606 cls = LLNI_classinfo_unwrap(jcpool);
1607 ref = (constant_integer*)class_getconstant(cls, index, CONSTANT_Integer);
1610 exceptions_throw_illegalargumentexception();
1618 /* JVM_ConstantPoolGetLongAt */
1620 jlong JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1622 constant_long *ref; /* reference to the long value in constant pool at index 'index' */
1623 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1625 TRACEJVMCALLS(("JVM_ConstantPoolGetLongAt: jcpool=%p, index=%d", jcpool, index));
1627 cls = LLNI_classinfo_unwrap(jcpool);
1628 ref = (constant_long*)class_getconstant(cls, index, CONSTANT_Long);
1631 exceptions_throw_illegalargumentexception();
1639 /* JVM_ConstantPoolGetFloatAt */
1641 jfloat JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1643 constant_float *ref; /* reference to the float value in constant pool at index 'index' */
1644 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1646 TRACEJVMCALLS(("JVM_ConstantPoolGetFloatAt: jcpool=%p, index=%d", jcpool, index));
1648 cls = LLNI_classinfo_unwrap(jcpool);
1649 ref = (constant_float*)class_getconstant(cls, index, CONSTANT_Float);
1652 exceptions_throw_illegalargumentexception();
1660 /* JVM_ConstantPoolGetDoubleAt */
1662 jdouble JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1664 constant_double *ref; /* reference to the double value in constant pool at index 'index' */
1665 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1667 TRACEJVMCALLS(("JVM_ConstantPoolGetDoubleAt: jcpool=%p, index=%d", jcpool, index));
1669 cls = LLNI_classinfo_unwrap(jcpool);
1670 ref = (constant_double*)class_getconstant(cls, index, CONSTANT_Double);
1673 exceptions_throw_illegalargumentexception();
1681 /* JVM_ConstantPoolGetStringAt */
1683 jstring JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1685 utf *ref; /* utf object for the string in constant pool at index 'index' */
1686 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1688 TRACEJVMCALLS(("JVM_ConstantPoolGetStringAt: jcpool=%p, index=%d", jcpool, index));
1690 cls = LLNI_classinfo_unwrap(jcpool);
1691 ref = (utf*)class_getconstant(cls, index, CONSTANT_String);
1694 exceptions_throw_illegalargumentexception();
1698 /* XXX: I hope literalstring_new is the right Function. */
1699 return (jstring)literalstring_new(ref);
1703 /* JVM_ConstantPoolGetUTF8At */
1705 jstring JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1707 utf *ref; /* utf object for the utf8 data in constant pool at index 'index' */
1708 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1710 TRACEJVMCALLS(("JVM_ConstantPoolGetUTF8At: jcpool=%p, index=%d", jcpool, index));
1712 cls = LLNI_classinfo_unwrap(jcpool);
1713 ref = (utf*)class_getconstant(cls, index, CONSTANT_Utf8);
1716 exceptions_throw_illegalargumentexception();
1720 /* XXX: I hope literalstring_new is the right Function. */
1721 return (jstring)literalstring_new(ref);
1725 /* JVM_DesiredAssertionStatus */
1727 jboolean JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls)
1729 #if defined(ENABLE_ASSERTION)
1730 assertion_name_t *item;
1735 TRACEJVMCALLS(("JVM_DesiredAssertionStatus(env=%p, unused=%p, cls=%p)", env, unused, cls));
1737 c = LLNI_classinfo_unwrap(cls);
1739 if (c->classloader == NULL) {
1740 status = (jboolean)assertion_system_enabled;
1743 status = (jboolean)assertion_user_enabled;
1746 if (list_assertion_names != NULL) {
1747 item = (assertion_name_t *)list_first(list_assertion_names);
1748 while (item != NULL) {
1749 name = utf_new_char(item->name);
1750 if (name == c->packagename) {
1751 status = (jboolean)item->enabled;
1753 else if (name == c->name) {
1754 status = (jboolean)item->enabled;
1757 item = (assertion_name_t *)list_next(list_assertion_names, item);
1763 return (jboolean)false;
1768 /* JVM_AssertionStatusDirectives */
1770 jobject JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)
1773 java_lang_AssertionStatusDirectives *o;
1774 java_handle_objectarray_t *classes;
1775 java_handle_objectarray_t *packages;
1776 java_booleanarray_t *classEnabled;
1777 java_booleanarray_t *packageEnabled;
1778 #if defined(ENABLE_ASSERTION)
1779 assertion_name_t *item;
1784 TRACEJVMCALLS(("JVM_AssertionStatusDirectives(env=%p, unused=%p)", env, unused));
1786 c = load_class_bootstrap(utf_new_char("java/lang/AssertionStatusDirectives"));
1791 o = (java_lang_AssertionStatusDirectives *) builtin_new(c);
1796 #if defined(ENABLE_ASSERTION)
1797 classes = builtin_anewarray(assertion_class_count, class_java_lang_Object);
1799 classes = builtin_anewarray(0, class_java_lang_Object);
1801 if (classes == NULL)
1804 #if defined(ENABLE_ASSERTION)
1805 packages = builtin_anewarray(assertion_package_count, class_java_lang_Object);
1807 packages = builtin_anewarray(0, class_java_lang_Object);
1809 if (packages == NULL)
1812 #if defined(ENABLE_ASSERTION)
1813 classEnabled = builtin_newarray_boolean(assertion_class_count);
1815 classEnabled = builtin_newarray_boolean(0);
1817 if (classEnabled == NULL)
1820 #if defined(ENABLE_ASSERTION)
1821 packageEnabled = builtin_newarray_boolean(assertion_package_count);
1823 packageEnabled = builtin_newarray_boolean(0);
1825 if (packageEnabled == NULL)
1828 #if defined(ENABLE_ASSERTION)
1829 /* initialize arrays */
1831 if (list_assertion_names != NULL) {
1835 item = (assertion_name_t *)list_first(list_assertion_names);
1836 while (item != NULL) {
1837 js = javastring_new_from_ascii(item->name);
1842 if (item->package == false) {
1843 classes->data[i] = js;
1844 classEnabled->data[i] = (jboolean) item->enabled;
1848 packages->data[j] = js;
1849 packageEnabled->data[j] = (jboolean) item->enabled;
1853 item = (assertion_name_t *)list_next(list_assertion_names, item);
1858 /* set instance fields */
1860 o->classes = classes;
1861 o->packages = packages;
1862 o->classEnabled = classEnabled;
1863 o->packageEnabled = packageEnabled;
1869 /* JVM_GetClassNameUTF */
1871 const char *JVM_GetClassNameUTF(JNIEnv *env, jclass cls)
1873 log_println("JVM_GetClassNameUTF: IMPLEMENT ME!");
1879 /* JVM_GetClassCPTypes */
1881 void JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types)
1883 log_println("JVM_GetClassCPTypes: IMPLEMENT ME!");
1887 /* JVM_GetClassCPEntriesCount */
1889 jint JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)
1891 log_println("JVM_GetClassCPEntriesCount: IMPLEMENT ME!");
1897 /* JVM_GetClassFieldsCount */
1899 jint JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)
1901 log_println("JVM_GetClassFieldsCount: IMPLEMENT ME!");
1907 /* JVM_GetClassMethodsCount */
1909 jint JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)
1911 log_println("JVM_GetClassMethodsCount: IMPLEMENT ME!");
1917 /* JVM_GetMethodIxExceptionIndexes */
1919 void JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions)
1921 log_println("JVM_GetMethodIxExceptionIndexes: IMPLEMENT ME!");
1925 /* JVM_GetMethodIxExceptionsCount */
1927 jint JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)
1929 log_println("JVM_GetMethodIxExceptionsCount: IMPLEMENT ME!");
1935 /* JVM_GetMethodIxByteCode */
1937 void JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code)
1939 log_println("JVM_GetMethodIxByteCode: IMPLEMENT ME!");
1943 /* JVM_GetMethodIxByteCodeLength */
1945 jint JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)
1947 log_println("JVM_GetMethodIxByteCodeLength: IMPLEMENT ME!");
1953 /* JVM_GetMethodIxExceptionTableEntry */
1955 void JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry)
1957 log_println("JVM_GetMethodIxExceptionTableEntry: IMPLEMENT ME!");
1961 /* JVM_GetMethodIxExceptionTableLength */
1963 jint JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)
1965 log_println("JVM_GetMethodIxExceptionTableLength: IMPLEMENT ME!");
1971 /* JVM_GetMethodIxModifiers */
1973 jint JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)
1975 log_println("JVM_GetMethodIxModifiers: IMPLEMENT ME!");
1981 /* JVM_GetFieldIxModifiers */
1983 jint JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)
1985 log_println("JVM_GetFieldIxModifiers: IMPLEMENT ME!");
1991 /* JVM_GetMethodIxLocalsCount */
1993 jint JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)
1995 log_println("JVM_GetMethodIxLocalsCount: IMPLEMENT ME!");
2001 /* JVM_GetMethodIxArgsSize */
2003 jint JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)
2005 log_println("JVM_GetMethodIxArgsSize: IMPLEMENT ME!");
2011 /* JVM_GetMethodIxMaxStack */
2013 jint JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)
2015 log_println("JVM_GetMethodIxMaxStack: IMPLEMENT ME!");
2021 /* JVM_IsConstructorIx */
2023 jboolean JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)
2025 log_println("JVM_IsConstructorIx: IMPLEMENT ME!");
2031 /* JVM_GetMethodIxNameUTF */
2033 const char *JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)
2035 log_println("JVM_GetMethodIxNameUTF: IMPLEMENT ME!");
2041 /* JVM_GetMethodIxSignatureUTF */
2043 const char *JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)
2045 log_println("JVM_GetMethodIxSignatureUTF: IMPLEMENT ME!");
2051 /* JVM_GetCPFieldNameUTF */
2053 const char *JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2055 log_println("JVM_GetCPFieldNameUTF: IMPLEMENT ME!");
2061 /* JVM_GetCPMethodNameUTF */
2063 const char *JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2065 log_println("JVM_GetCPMethodNameUTF: IMPLEMENT ME!");
2071 /* JVM_GetCPMethodSignatureUTF */
2073 const char *JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
2075 log_println("JVM_GetCPMethodSignatureUTF: IMPLEMENT ME!");
2081 /* JVM_GetCPFieldSignatureUTF */
2083 const char *JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
2085 log_println("JVM_GetCPFieldSignatureUTF: IMPLEMENT ME!");
2091 /* JVM_GetCPClassNameUTF */
2093 const char *JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2095 log_println("JVM_GetCPClassNameUTF: IMPLEMENT ME!");
2101 /* JVM_GetCPFieldClassNameUTF */
2103 const char *JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2105 log_println("JVM_GetCPFieldClassNameUTF: IMPLEMENT ME!");
2111 /* JVM_GetCPMethodClassNameUTF */
2113 const char *JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2115 log_println("JVM_GetCPMethodClassNameUTF: IMPLEMENT ME!");
2121 /* JVM_GetCPFieldModifiers */
2123 jint JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
2125 log_println("JVM_GetCPFieldModifiers: IMPLEMENT ME!");
2131 /* JVM_GetCPMethodModifiers */
2133 jint JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
2135 log_println("JVM_GetCPMethodModifiers: IMPLEMENT ME!");
2141 /* JVM_ReleaseUTF */
2143 void JVM_ReleaseUTF(const char *utf)
2145 log_println("JVM_ReleaseUTF: IMPLEMENT ME!");
2149 /* JVM_IsSameClassPackage */
2151 jboolean JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2)
2153 log_println("JVM_IsSameClassPackage: IMPLEMENT ME!");
2161 /* Taken from: hotspot/src/share/vm/prims/jvm.h */
2164 * JVM I/O error codes
2166 #define JVM_EEXIST -100
2168 jint JVM_Open(const char *fname, jint flags, jint mode)
2172 TRACEJVMCALLS(("JVM_Open(fname=%s, flags=%d, mode=%d)", fname, flags, mode));
2174 result = hpi_file->Open(fname, flags, mode);
2192 jint JVM_Close(jint fd)
2194 TRACEJVMCALLS(("JVM_Close(fd=%d)", fd));
2196 return hpi_file->Close(fd);
2202 jint JVM_Read(jint fd, char *buf, jint nbytes)
2204 TRACEJVMCALLS(("JVM_Read(fd=%d, buf=%p, nbytes=%d)", fd, buf, nbytes));
2206 return (jint) hpi_file->Read(fd, buf, nbytes);
2212 jint JVM_Write(jint fd, char *buf, jint nbytes)
2214 TRACEJVMCALLS(("JVM_Write(fd=%d, buf=%s, nbytes=%d)", fd, buf, nbytes));
2216 return (jint) hpi_file->Write(fd, buf, nbytes);
2222 jint JVM_Available(jint fd, jlong *pbytes)
2224 TRACEJVMCALLS(("JVM_Available(fd=%d, pbytes=%p)", fd, pbytes));
2226 return hpi_file->Available(fd, pbytes);
2232 jlong JVM_Lseek(jint fd, jlong offset, jint whence)
2234 TRACEJVMCALLS(("JVM_Lseek(fd=%d, offset=%ld, whence=%d)", fd, offset, whence));
2236 return hpi_file->Seek(fd, (off_t) offset, whence);
2242 jint JVM_SetLength(jint fd, jlong length)
2244 TRACEJVMCALLS(("JVM_SetLength(fd=%d, length=%ld)", length));
2246 return hpi_file->SetLength(fd, length);
2252 jint JVM_Sync(jint fd)
2254 TRACEJVMCALLS(("JVM_Sync(fd=%d)", fd));
2256 return hpi_file->Sync(fd);
2260 /* JVM_StartThread */
2262 void JVM_StartThread(JNIEnv* env, jobject jthread)
2264 TRACEJVMCALLS(("JVM_StartThread(env=%p, jthread=%p)", env, jthread));
2266 threads_thread_start((java_handle_t *) jthread);
2270 /* JVM_StopThread */
2272 void JVM_StopThread(JNIEnv* env, jobject jthread, jobject throwable)
2274 log_println("JVM_StopThread: IMPLEMENT ME!");
2278 /* JVM_IsThreadAlive */
2280 jboolean JVM_IsThreadAlive(JNIEnv* env, jobject jthread)
2286 TRACEJVMCALLS(("JVM_IsThreadAlive(env=%p, jthread=%p)", env, jthread));
2288 h = (java_handle_t *) jthread;
2289 t = thread_get_thread(h);
2291 /* The threadobject is null when a thread is created in Java. The
2292 priority is set later during startup. */
2297 result = threads_thread_is_alive(t);
2303 /* JVM_SuspendThread */
2305 void JVM_SuspendThread(JNIEnv* env, jobject jthread)
2307 log_println("JVM_SuspendThread: IMPLEMENT ME!");
2311 /* JVM_ResumeThread */
2313 void JVM_ResumeThread(JNIEnv* env, jobject jthread)
2315 log_println("JVM_ResumeThread: IMPLEMENT ME!");
2319 /* JVM_SetThreadPriority */
2321 void JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio)
2326 TRACEJVMCALLS(("JVM_SetThreadPriority(env=%p, jthread=%p, prio=%d)", env, jthread, prio));
2328 h = (java_handle_t *) jthread;
2329 t = thread_get_thread(h);
2331 /* The threadobject is null when a thread is created in Java. The
2332 priority is set later during startup. */
2337 threads_set_thread_priority(t->tid, prio);
2343 void JVM_Yield(JNIEnv *env, jclass threadClass)
2345 TRACEJVMCALLS(("JVM_Yield(env=%p, threadClass=%p)", env, threadClass));
2353 void JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis)
2355 TRACEJVMCALLS(("JVM_Sleep(env=%p, threadClass=%p, millis=%ld)", env, threadClass, millis));
2357 threads_sleep(millis, 0);
2361 /* JVM_CurrentThread */
2363 jobject JVM_CurrentThread(JNIEnv* env, jclass threadClass)
2367 TRACEJVMCALLSVERBOSE(("JVM_CurrentThread(env=%p, threadClass=%p)", env, threadClass));
2369 o = thread_get_current_object();
2375 /* JVM_CountStackFrames */
2377 jint JVM_CountStackFrames(JNIEnv* env, jobject jthread)
2379 log_println("JVM_CountStackFrames: IMPLEMENT ME!");
2387 void JVM_Interrupt(JNIEnv* env, jobject jthread)
2392 TRACEJVMCALLS(("JVM_Interrupt(env=%p, jthread=%p)", env, jthread));
2394 h = (java_handle_t *) jthread;
2395 t = thread_get_thread(h);
2400 threads_thread_interrupt(t);
2404 /* JVM_IsInterrupted */
2406 jboolean JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted)
2410 jboolean interrupted;
2412 TRACEJVMCALLS(("JVM_IsInterrupted(env=%p, jthread=%p, clear_interrupted=%d)", env, jthread, clear_interrupted));
2414 h = (java_handle_t *) jthread;
2415 t = thread_get_thread(h);
2417 interrupted = thread_is_interrupted(t);
2419 if (interrupted && clear_interrupted)
2420 thread_set_interrupted(t, false);
2428 jboolean JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj)
2433 TRACEJVMCALLS(("JVM_HoldsLock(env=%p, threadClass=%p, obj=%p)", env, threadClass, obj));
2435 h = (java_handle_t *) obj;
2438 exceptions_throw_nullpointerexception();
2442 result = lock_is_held_by_current_thread(h);
2448 /* JVM_DumpAllStacks */
2450 void JVM_DumpAllStacks(JNIEnv* env, jclass unused)
2452 log_println("JVM_DumpAllStacks: IMPLEMENT ME!");
2456 /* JVM_CurrentLoadedClass */
2458 jclass JVM_CurrentLoadedClass(JNIEnv *env)
2460 log_println("JVM_CurrentLoadedClass: IMPLEMENT ME!");
2466 /* JVM_CurrentClassLoader */
2468 jobject JVM_CurrentClassLoader(JNIEnv *env)
2470 /* XXX if a method in a class in a trusted loader is in a
2471 doPrivileged, return NULL */
2473 log_println("JVM_CurrentClassLoader: IMPLEMENT ME!");
2479 /* JVM_GetClassContext */
2481 jobjectArray JVM_GetClassContext(JNIEnv *env)
2483 TRACEJVMCALLS(("JVM_GetClassContext(env=%p)", env));
2485 return (jobjectArray) stacktrace_getClassContext();
2489 /* JVM_ClassDepth */
2491 jint JVM_ClassDepth(JNIEnv *env, jstring name)
2493 log_println("JVM_ClassDepth: IMPLEMENT ME!");
2499 /* JVM_ClassLoaderDepth */
2501 jint JVM_ClassLoaderDepth(JNIEnv *env)
2503 log_println("JVM_ClassLoaderDepth: IMPLEMENT ME!");
2509 /* JVM_GetSystemPackage */
2511 jstring JVM_GetSystemPackage(JNIEnv *env, jstring name)
2517 TRACEJVMCALLS(("JVM_GetSystemPackage(env=%p, name=%p)", env, name));
2519 /* s = package_find(name); */
2520 u = javastring_toutf((java_handle_t *) name, false);
2522 result = package_find(u);
2525 s = javastring_new(result);
2533 /* JVM_GetSystemPackages */
2535 jobjectArray JVM_GetSystemPackages(JNIEnv *env)
2537 log_println("JVM_GetSystemPackages: IMPLEMENT ME!");
2543 /* JVM_AllocateNewObject */
2545 jobject JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass)
2547 log_println("JVM_AllocateNewObject: IMPLEMENT ME!");
2553 /* JVM_AllocateNewArray */
2555 jobject JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length)
2557 log_println("JVM_AllocateNewArray: IMPLEMENT ME!");
2563 /* JVM_LatestUserDefinedLoader */
2565 jobject JVM_LatestUserDefinedLoader(JNIEnv *env)
2569 TRACEJVMCALLS(("JVM_LatestUserDefinedLoader(env=%p)", env));
2571 cl = stacktrace_first_nonnull_classloader();
2573 return (jobject) cl;
2577 /* JVM_LoadClass0 */
2579 jclass JVM_LoadClass0(JNIEnv *env, jobject receiver, jclass currClass, jstring currClassName)
2581 log_println("JVM_LoadClass0: IMPLEMENT ME!");
2587 /* JVM_GetArrayLength */
2589 jint JVM_GetArrayLength(JNIEnv *env, jobject arr)
2593 TRACEJVMCALLS(("JVM_GetArrayLength(arr=%p)", arr));
2595 a = (java_handle_t *) arr;
2597 return array_length_get(a);
2601 /* JVM_GetArrayElement */
2603 jobject JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index)
2608 TRACEJVMCALLS(("JVM_GetArrayElement(env=%p, arr=%p, index=%d)", env, arr, index));
2610 a = (java_handle_t *) arr;
2612 /* if (!class_is_array(a->objheader.vftbl->class)) { */
2613 /* exceptions_throw_illegalargumentexception(); */
2617 o = array_element_get(a, index);
2623 /* JVM_GetPrimitiveArrayElement */
2625 jvalue JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode)
2629 log_println("JVM_GetPrimitiveArrayElement: IMPLEMENT ME!");
2637 /* JVM_SetArrayElement */
2639 void JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val)
2642 java_handle_t *value;
2644 TRACEJVMCALLS(("JVM_SetArrayElement(env=%p, arr=%p, index=%d, val=%p)", env, arr, index, val));
2646 a = (java_handle_t *) arr;
2647 value = (java_handle_t *) val;
2649 array_element_set(a, index, value);
2653 /* JVM_SetPrimitiveArrayElement */
2655 void JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode)
2657 log_println("JVM_SetPrimitiveArrayElement: IMPLEMENT ME!");
2663 jobject JVM_NewArray(JNIEnv *env, jclass eltClass, jint length)
2668 java_handle_objectarray_t *oa;
2670 TRACEJVMCALLS(("JVM_NewArray(env=%p, eltClass=%p, length=%d)", env, eltClass, length));
2672 if (eltClass == NULL) {
2673 exceptions_throw_nullpointerexception();
2677 /* NegativeArraySizeException is checked in builtin_newarray. */
2679 c = LLNI_classinfo_unwrap(eltClass);
2681 /* Create primitive or object array. */
2683 if (class_is_primitive(c)) {
2684 pc = primitive_arrayclass_get_by_name(c->name);
2686 /* void arrays are not allowed. */
2689 exceptions_throw_illegalargumentexception();
2693 a = builtin_newarray(length, pc);
2698 oa = builtin_anewarray(length, c);
2700 return (jobject) oa;
2705 /* JVM_NewMultiArray */
2707 jobject JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim)
2710 java_handle_intarray_t *ia;
2716 java_handle_objectarray_t *a;
2718 TRACEJVMCALLS(("JVM_NewMultiArray(env=%p, eltClass=%p, dim=%p)", env, eltClass, dim));
2720 if (eltClass == NULL) {
2721 exceptions_throw_nullpointerexception();
2725 /* NegativeArraySizeException is checked in builtin_newarray. */
2727 c = LLNI_classinfo_unwrap(eltClass);
2729 ia = (java_handle_intarray_t *) dim;
2731 length = array_length_get((java_handle_t *) ia);
2733 /* We check here for exceptions thrown in array_length_get,
2734 otherwise these exceptions get overwritten by the following
2735 IllegalArgumentException. */
2740 if ((length <= 0) || (length > /* MAX_DIM */ 255)) {
2741 exceptions_throw_illegalargumentexception();
2745 /* XXX This is just a quick hack to get it working. */
2747 dims = MNEW(long, length);
2749 for (i = 0; i < length; i++) {
2750 value = LLNI_array_direct(ia, i);
2751 dims[i] = (long) value;
2754 /* Create an array-class if necessary. */
2756 if (class_is_primitive(c))
2757 ac = primitive_arrayclass_get_by_name(c->name);
2759 ac = class_array_of(c, true);
2764 a = builtin_multianewarray(length, (java_handle_t *) ac, dims);
2770 /* JVM_InitializeSocketLibrary */
2772 jint JVM_InitializeSocketLibrary()
2774 TRACEJVMCALLS(("JVM_InitializeSocketLibrary()"));
2776 return hpi_initialize_socket_library();
2782 jint JVM_Socket(jint domain, jint type, jint protocol)
2784 TRACEJVMCALLS(("JVM_Socket(domain=%d, type=%d, protocol=%d)", domain, type, protocol));
2786 return system_socket(domain, type, protocol);
2790 /* JVM_SocketClose */
2792 jint JVM_SocketClose(jint fd)
2794 TRACEJVMCALLS(("JVM_SocketClose(fd=%d)", fd));
2796 return system_close(fd);
2800 /* JVM_SocketShutdown */
2802 jint JVM_SocketShutdown(jint fd, jint howto)
2804 TRACEJVMCALLS(("JVM_SocketShutdown(fd=%d, howto=%d)", fd, howto));
2806 return system_shutdown(fd, howto);
2812 jint JVM_Recv(jint fd, char *buf, jint nBytes, jint flags)
2814 log_println("JVM_Recv: IMPLEMENT ME!");
2822 jint JVM_Send(jint fd, char *buf, jint nBytes, jint flags)
2824 log_println("JVM_Send: IMPLEMENT ME!");
2832 jint JVM_Timeout(int fd, long timeout)
2834 log_println("JVM_Timeout: IMPLEMENT ME!");
2842 jint JVM_Listen(jint fd, jint count)
2844 TRACEJVMCALLS(("JVM_Listen(fd=%d, count=%d)", fd, count));
2846 return system_listen(fd, count);
2852 jint JVM_Connect(jint fd, struct sockaddr *him, jint len)
2854 TRACEJVMCALLS(("JVM_Connect(fd=%d, him=%p, len=%d)", fd, him, len));
2856 return system_connect(fd, him, len);
2862 jint JVM_Bind(jint fd, struct sockaddr *him, jint len)
2864 log_println("JVM_Bind: IMPLEMENT ME!");
2872 jint JVM_Accept(jint fd, struct sockaddr *him, jint *len)
2874 TRACEJVMCALLS(("JVM_Accept(fd=%d, him=%p, len=%p)", fd, him, len));
2876 return system_accept(fd, him, (socklen_t *) len);
2882 jint JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen)
2884 log_println("JVM_RecvFrom: IMPLEMENT ME!");
2890 /* JVM_GetSockName */
2892 jint JVM_GetSockName(jint fd, struct sockaddr *him, int *len)
2894 TRACEJVMCALLS(("JVM_GetSockName(fd=%d, him=%p, len=%p)", fd, him, len));
2896 return system_getsockname(fd, him, (socklen_t *) len);
2902 jint JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen)
2904 log_println("JVM_SendTo: IMPLEMENT ME!");
2910 /* JVM_SocketAvailable */
2912 jint JVM_SocketAvailable(jint fd, jint *pbytes)
2914 #if defined(FIONREAD)
2918 TRACEJVMCALLS(("JVM_SocketAvailable(fd=%d, pbytes=%p)", fd, pbytes));
2922 result = ioctl(fd, FIONREAD, &bytes);
2931 # error FIONREAD not defined
2936 /* JVM_GetSockOpt */
2938 jint JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen)
2940 TRACEJVMCALLS(("JVM_GetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%p)", fd, level, optname, optval, optlen));
2942 return system_getsockopt(fd, level, optname, optval, (socklen_t *) optlen);
2946 /* JVM_SetSockOpt */
2948 jint JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen)
2950 TRACEJVMCALLS(("JVM_SetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%d)", fd, level, optname, optval, optlen));
2952 return system_setsockopt(fd, level, optname, optval, optlen);
2956 /* JVM_GetHostName */
2958 int JVM_GetHostName(char *name, int namelen)
2962 TRACEJVMCALLSENTER(("JVM_GetHostName(name=%s, namelen=%d)", name, namelen));
2964 result = system_gethostname(name, namelen);
2966 TRACEJVMCALLSEXIT(("->%d (name=%s)", result, name));
2972 /* JVM_GetHostByAddr */
2974 struct hostent *JVM_GetHostByAddr(const char* name, int len, int type)
2976 log_println("JVM_GetHostByAddr: IMPLEMENT ME!");
2982 /* JVM_GetHostByName */
2984 struct hostent *JVM_GetHostByName(char* name)
2986 log_println("JVM_GetHostByName: IMPLEMENT ME!");
2992 /* JVM_GetProtoByName */
2994 struct protoent *JVM_GetProtoByName(char* name)
2996 log_println("JVM_GetProtoByName: IMPLEMENT ME!");
3002 /* JVM_LoadLibrary */
3004 void *JVM_LoadLibrary(const char *name)
3009 TRACEJVMCALLSENTER(("JVM_LoadLibrary(name=%s)", name));
3011 u = utf_new_char(name);
3013 handle = native_library_open(u);
3015 TRACEJVMCALLSEXIT(("->%p", handle));
3021 /* JVM_UnloadLibrary */
3023 void JVM_UnloadLibrary(void* handle)
3025 TRACEJVMCALLS(("JVM_UnloadLibrary(handle=%p)", handle));
3027 native_library_close(handle);
3031 /* JVM_FindLibraryEntry */
3033 void *JVM_FindLibraryEntry(void *handle, const char *name)
3037 TRACEJVMCALLSENTER(("JVM_FindLibraryEntry(handle=%p, name=%s)", handle, name));
3039 symbol = lt_dlsym(handle, name);
3041 TRACEJVMCALLSEXIT(("->%p", symbol));
3049 jboolean JVM_IsNaN(jdouble a)
3051 log_println("JVM_IsNaN: IMPLEMENT ME!");
3057 /* JVM_IsSupportedJNIVersion */
3059 jboolean JVM_IsSupportedJNIVersion(jint version)
3061 TRACEJVMCALLS(("JVM_IsSupportedJNIVersion(version=%d)", version));
3063 return jni_version_check(version);
3067 /* JVM_InternString */
3069 jstring JVM_InternString(JNIEnv *env, jstring str)
3071 TRACEJVMCALLS(("JVM_InternString(env=%p, str=%p)", env, str));
3073 return (jstring) javastring_intern((java_handle_t *) str);
3077 /* JVM_RawMonitorCreate */
3079 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void)
3083 TRACEJVMCALLS(("JVM_RawMonitorCreate()"));
3085 o = NEW(java_object_t);
3087 lock_init_object_lock(o);
3093 /* JVM_RawMonitorDestroy */
3095 JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void *mon)
3097 TRACEJVMCALLS(("JVM_RawMonitorDestroy(mon=%p)", mon));
3099 FREE(mon, java_object_t);
3103 /* JVM_RawMonitorEnter */
3105 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void *mon)
3107 TRACEJVMCALLS(("JVM_RawMonitorEnter(mon=%p)", mon));
3109 (void) lock_monitor_enter((java_object_t *) mon);
3115 /* JVM_RawMonitorExit */
3117 JNIEXPORT void JNICALL JVM_RawMonitorExit(void *mon)
3119 TRACEJVMCALLS(("JVM_RawMonitorExit(mon=%p)", mon));
3121 (void) lock_monitor_exit((java_object_t *) mon);
3125 /* JVM_SetPrimitiveFieldValues */
3127 void JVM_SetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
3129 log_println("JVM_SetPrimitiveFieldValues: IMPLEMENT ME!");
3133 /* JVM_GetPrimitiveFieldValues */
3135 void JVM_GetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
3137 log_println("JVM_GetPrimitiveFieldValues: IMPLEMENT ME!");
3141 /* JVM_AccessVMBooleanFlag */
3143 jboolean JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get)
3145 log_println("JVM_AccessVMBooleanFlag: IMPLEMENT ME!");
3151 /* JVM_AccessVMIntFlag */
3153 jboolean JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get)
3155 log_println("JVM_AccessVMIntFlag: IMPLEMENT ME!");
3161 /* JVM_VMBreakPoint */
3163 void JVM_VMBreakPoint(JNIEnv *env, jobject obj)
3165 log_println("JVM_VMBreakPoint: IMPLEMENT ME!");
3169 /* JVM_GetClassFields */
3171 jobjectArray JVM_GetClassFields(JNIEnv *env, jclass cls, jint which)
3173 log_println("JVM_GetClassFields: IMPLEMENT ME!");
3179 /* JVM_GetClassMethods */
3181 jobjectArray JVM_GetClassMethods(JNIEnv *env, jclass cls, jint which)
3183 log_println("JVM_GetClassMethods: IMPLEMENT ME!");
3189 /* JVM_GetClassConstructors */
3191 jobjectArray JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which)
3193 log_println("JVM_GetClassConstructors: IMPLEMENT ME!");
3199 /* JVM_GetClassField */
3201 jobject JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which)
3203 log_println("JVM_GetClassField: IMPLEMENT ME!");
3209 /* JVM_GetClassMethod */
3211 jobject JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types, jint which)
3213 log_println("JVM_GetClassMethod: IMPLEMENT ME!");
3219 /* JVM_GetClassConstructor */
3221 jobject JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types, jint which)
3223 log_println("JVM_GetClassConstructor: IMPLEMENT ME!");
3229 /* JVM_NewInstance */
3231 jobject JVM_NewInstance(JNIEnv *env, jclass cls)
3233 log_println("JVM_NewInstance: IMPLEMENT ME!");
3241 jobject JVM_GetField(JNIEnv *env, jobject field, jobject obj)
3243 log_println("JVM_GetField: IMPLEMENT ME!");
3249 /* JVM_GetPrimitiveField */
3251 jvalue JVM_GetPrimitiveField(JNIEnv *env, jobject field, jobject obj, unsigned char wCode)
3255 log_println("JVM_GetPrimitiveField: IMPLEMENT ME!");
3265 void JVM_SetField(JNIEnv *env, jobject field, jobject obj, jobject val)
3267 log_println("JVM_SetField: IMPLEMENT ME!");
3271 /* JVM_SetPrimitiveField */
3273 void JVM_SetPrimitiveField(JNIEnv *env, jobject field, jobject obj, jvalue v, unsigned char vCode)
3275 log_println("JVM_SetPrimitiveField: IMPLEMENT ME!");
3279 /* JVM_InvokeMethod */
3281 jobject JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)
3283 java_lang_reflect_Method *rm;
3290 TRACEJVMCALLS(("JVM_InvokeMethod(env=%p, method=%p, obj=%p, args0=%p)", env, method, obj, args0));
3292 rm = (java_lang_reflect_Method *) method;
3294 LLNI_field_get_cls(rm, clazz, c);
3295 LLNI_field_get_val(rm, slot, slot);
3296 LLNI_field_get_val(rm, override, override);
3298 m = &(c->methods[slot]);
3300 ro = reflect_method_invoke(m, (java_handle_t *) obj, (java_handle_objectarray_t *) args0, override);
3302 return (jobject) ro;
3306 /* JVM_NewInstanceFromConstructor */
3308 jobject JVM_NewInstanceFromConstructor(JNIEnv *env, jobject con, jobjectArray args0)
3310 java_lang_reflect_Constructor *rc;
3317 TRACEJVMCALLS(("JVM_NewInstanceFromConstructor(env=%p, c=%p, args0=%p)", env, con, args0));
3319 rc = (java_lang_reflect_Constructor *) con;
3321 LLNI_field_get_cls(rc, clazz, c);
3322 LLNI_field_get_val(rc, slot, slot);
3323 LLNI_field_get_val(rc, override, override);
3325 m = &(c->methods[slot]);
3327 o = reflect_constructor_newinstance(m, (java_handle_objectarray_t *) args0, override);
3333 /* JVM_SupportsCX8 */
3335 jboolean JVM_SupportsCX8()
3337 TRACEJVMCALLS(("JVM_SupportsCX8()"));
3347 jboolean JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal)
3349 log_println("JVM_CX8Field: IMPLEMENT ME!");
3355 /* JVM_GetAllThreads */
3357 jobjectArray JVM_GetAllThreads(JNIEnv *env, jclass dummy)
3359 log_println("JVM_GetAllThreads: IMPLEMENT ME!");
3365 /* JVM_DumpThreads */
3367 jobjectArray JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads)
3369 log_println("JVM_DumpThreads: IMPLEMENT ME!");
3375 /* JVM_GetManagement */
3377 void *JVM_GetManagement(jint version)
3379 TRACEJVMCALLS(("JVM_GetManagement(version=%d)", version));
3381 /* TODO We current don't support the management interface. */
3387 /* JVM_InitAgentProperties */
3389 jobject JVM_InitAgentProperties(JNIEnv *env, jobject properties)
3391 log_println("JVM_InitAgentProperties: IMPLEMENT ME!");
3397 /* JVM_GetEnclosingMethodInfo */
3399 jobjectArray JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass)
3403 java_handle_objectarray_t *oa;
3405 TRACEJVMCALLS(("JVM_GetEnclosingMethodInfo(env=%p, ofClass=%p)", env, ofClass));
3407 c = LLNI_classinfo_unwrap(ofClass);
3409 if ((c == NULL) || class_is_primitive(c))
3412 m = class_get_enclosingmethod(c);
3417 oa = builtin_anewarray(3, class_java_lang_Object);
3422 array_objectarray_element_set(oa, 0, (java_handle_t *) LLNI_classinfo_wrap(m->clazz));
3423 array_objectarray_element_set(oa, 1, javastring_new(m->name));
3424 array_objectarray_element_set(oa, 2, javastring_new(m->descriptor));
3426 return (jobjectArray) oa;
3430 /* JVM_GetThreadStateValues */
3432 jintArray JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState)
3434 java_handle_intarray_t *ia;
3436 TRACEJVMCALLS(("JVM_GetThreadStateValues(env=%p, javaThreadState=%d)",
3437 env, javaThreadState));
3439 /* If new thread states are added in future JDK and VM versions,
3440 this should check if the JDK version is compatible with thread
3441 states supported by the VM. Return NULL if not compatible.
3443 This function must map the VM java_lang_Thread::ThreadStatus
3444 to the Java thread state that the JDK supports. */
3446 switch (javaThreadState) {
3447 case THREAD_STATE_NEW:
3448 ia = builtin_newarray_int(1);
3453 array_intarray_element_set(ia, 0, THREAD_STATE_NEW);
3456 case THREAD_STATE_RUNNABLE:
3457 ia = builtin_newarray_int(1);
3462 array_intarray_element_set(ia, 0, THREAD_STATE_RUNNABLE);
3465 case THREAD_STATE_BLOCKED:
3466 ia = builtin_newarray_int(1);
3471 array_intarray_element_set(ia, 0, THREAD_STATE_BLOCKED);
3474 case THREAD_STATE_WAITING:
3475 ia = builtin_newarray_int(2);
3480 array_intarray_element_set(ia, 0, THREAD_STATE_WAITING);
3481 /* XXX Implement parked stuff. */
3482 /* array_intarray_element_set(ia, 1, PARKED); */
3485 case THREAD_STATE_TIMED_WAITING:
3486 ia = builtin_newarray_int(3);
3491 /* XXX Not sure about that one. */
3492 /* array_intarray_element_set(ia, 0, SLEEPING); */
3493 array_intarray_element_set(ia, 0, THREAD_STATE_TIMED_WAITING);
3494 /* XXX Implement parked stuff. */
3495 /* array_intarray_element_set(ia, 2, PARKED); */
3498 case THREAD_STATE_TERMINATED:
3499 ia = builtin_newarray_int(1);
3504 array_intarray_element_set(ia, 0, THREAD_STATE_TERMINATED);
3508 /* Unknown state - probably incompatible JDK version */
3512 return (jintArray) ia;
3516 /* JVM_GetThreadStateNames */
3518 jobjectArray JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values)
3520 java_handle_intarray_t *ia;
3521 java_handle_objectarray_t *oa;
3524 TRACEJVMCALLS(("JVM_GetThreadStateNames(env=%p, javaThreadState=%d, values=%p)",
3525 env, javaThreadState, values));
3527 ia = (java_handle_intarray_t *) values;
3529 /* If new thread states are added in future JDK and VM versions,
3530 this should check if the JDK version is compatible with thread
3531 states supported by the VM. Return NULL if not compatible.
3533 This function must map the VM java_lang_Thread::ThreadStatus
3534 to the Java thread state that the JDK supports. */
3536 if (values == NULL) {
3537 exceptions_throw_nullpointerexception();
3541 switch (javaThreadState) {
3542 case THREAD_STATE_NEW:
3543 assert(ia->header.size == 1 && ia->data[0] == THREAD_STATE_NEW);
3545 oa = builtin_anewarray(1, class_java_lang_String);
3550 s = javastring_new(utf_new_char("NEW"));
3555 array_objectarray_element_set(oa, 0, s);
3558 case THREAD_STATE_RUNNABLE:
3559 oa = builtin_anewarray(1, class_java_lang_String);
3564 s = javastring_new(utf_new_char("RUNNABLE"));
3569 array_objectarray_element_set(oa, 0, s);
3572 case THREAD_STATE_BLOCKED:
3573 oa = builtin_anewarray(1, class_java_lang_String);
3578 s = javastring_new(utf_new_char("BLOCKED"));
3583 array_objectarray_element_set(oa, 0, s);
3586 case THREAD_STATE_WAITING:
3587 oa = builtin_anewarray(2, class_java_lang_String);
3592 s = javastring_new(utf_new_char("WAITING.OBJECT_WAIT"));
3593 /* s = javastring_new(utf_new_char("WAITING.PARKED")); */
3598 array_objectarray_element_set(oa, 0, s);
3599 /* array_objectarray_element_set(oa, 1, s); */
3602 case THREAD_STATE_TIMED_WAITING:
3603 oa = builtin_anewarray(3, class_java_lang_String);
3608 /* s = javastring_new(utf_new_char("TIMED_WAITING.SLEEPING")); */
3609 s = javastring_new(utf_new_char("TIMED_WAITING.OBJECT_WAIT"));
3610 /* s = javastring_new(utf_new_char("TIMED_WAITING.PARKED")); */
3615 /* array_objectarray_element_set(oa, 0, s); */
3616 array_objectarray_element_set(oa, 0, s);
3617 /* array_objectarray_element_set(oa, 2, s); */
3620 case THREAD_STATE_TERMINATED:
3621 oa = builtin_anewarray(1, class_java_lang_String);
3626 s = javastring_new(utf_new_char("TERMINATED"));
3631 array_objectarray_element_set(oa, 0, s);
3635 /* Unknown state - probably incompatible JDK version */
3639 return (jobjectArray) oa;
3643 /* JVM_GetVersionInfo */
3645 void JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size)
3647 log_println("JVM_GetVersionInfo: IMPLEMENT ME!");
3651 /* OS: JVM_RegisterSignal */
3653 void *JVM_RegisterSignal(jint sig, void *handler)
3655 functionptr newHandler;
3657 TRACEJVMCALLS(("JVM_RegisterSignal(sig=%d, handler=%p)", sig, handler));
3659 if (handler == (void *) 2)
3660 newHandler = (functionptr) signal_thread_handler;
3662 newHandler = (functionptr) (uintptr_t) handler;
3669 /* These signals are already used by the VM. */
3673 /* This signal is used by the VM to dump thread stacks unless
3674 ReduceSignalUsage is set, in which case the user is allowed
3675 to set his own _native_ handler for this signal; thus, in
3676 either case, we do not allow JVM_RegisterSignal to change
3686 signal_register_signal(sig, newHandler, 0);
3688 /* XXX Should return old handler. */
3694 /* OS: JVM_RaiseSignal */
3696 jboolean JVM_RaiseSignal(jint sig)
3698 log_println("JVM_RaiseSignal: IMPLEMENT ME! sig=%s", sig);
3704 /* OS: JVM_FindSignal */
3706 jint JVM_FindSignal(const char *name)
3708 TRACEJVMCALLS(("JVM_FindSignal(name=%s)", name));
3710 #if defined(__LINUX__)
3711 if (strcmp(name, "HUP") == 0)
3714 if (strcmp(name, "INT") == 0)
3717 if (strcmp(name, "TERM") == 0)
3720 # error not implemented for this OS
3728 * These are local overrides for various environment variables in Emacs.
3729 * Please do not remove this and leave it at the end of the file, where
3730 * Emacs will automagically detect them.
3731 * ---------------------------------------------------------------------
3734 * indent-tabs-mode: t