1 /* src/native/vm/sun/jvm.c - HotSpot JVM interface functions
3 Copyright (C) 2007 R. Grafl, A. Krall, C. Kruegel,
4 C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
5 E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
6 J. Wenninger, Institut f. Computersprachen - TU Wien
8 This file is part of CACAO.
10 This program is free software; you can redistribute it and/or
11 modify it under the terms of the GNU General Public License as
12 published by the Free Software Foundation; either version 2, or (at
13 your option) any later version.
15 This program is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 $Id: jvm.c 8395 2007-08-22 13:12:46Z panzi $
42 #if defined(HAVE_SYS_IOCTL_H)
43 #define BSD_COMP /* Get FIONREAD on Solaris2 */
44 #include <sys/ioctl.h>
47 #include <sys/socket.h>
52 #include "mm/memory.h"
54 #include "native/jni.h"
55 #include "native/llni.h"
56 #include "native/native.h"
58 #include "native/include/java_lang_AssertionStatusDirectives.h"
59 #include "native/include/java_lang_String.h" /* required by j.l.CL */
60 #include "native/include/java_nio_ByteBuffer.h" /* required by j.l.CL */
61 #include "native/include/java_lang_ClassLoader.h" /* required by j.l.C */
62 #include "native/include/java_lang_StackTraceElement.h"
63 #include "native/include/java_lang_Throwable.h"
64 #include "native/include/java_security_ProtectionDomain.h"
65 #include "native/include/java_lang_Integer.h"
66 #include "native/include/java_lang_Long.h"
67 #include "native/include/java_lang_Short.h"
68 #include "native/include/java_lang_Byte.h"
69 #include "native/include/java_lang_Character.h"
70 #include "native/include/java_lang_Boolean.h"
71 #include "native/include/java_lang_Float.h"
72 #include "native/include/java_lang_Double.h"
74 #if defined(ENABLE_ANNOTATIONS)
75 #include "native/include/sun_reflect_ConstantPool.h"
78 #include "native/vm/java_lang_Class.h"
79 #include "native/vm/java_lang_ClassLoader.h"
80 #include "native/vm/java_lang_Object.h"
81 #include "native/vm/java_lang_Runtime.h"
82 #include "native/vm/java_lang_Thread.h"
83 #include "native/vm/java_lang_reflect_Constructor.h"
84 #include "native/vm/java_lang_reflect_Method.h"
85 #include "native/vm/java_util_concurrent_atomic_AtomicLong.h"
86 #include "native/vm/reflect.h"
88 #include "threads/lock-common.h"
89 #include "threads/threads-common.h"
91 #include "toolbox/logging.h"
94 #include "vm/builtin.h"
95 #include "vm/exceptions.h"
96 #include "vm/global.h"
97 #include "vm/initialize.h"
98 #include "vm/primitive.h"
99 #include "vm/properties.h"
100 #include "vm/resolve.h"
101 #include "vm/signallocal.h"
102 #include "vm/stringlocal.h"
105 #include "vm/jit/stacktrace.h"
107 #include "vmcore/classcache.h"
108 #include "vmcore/options.h"
111 /* debugging macros ***********************************************************/
115 # define TRACEJVMCALLS(...) \
117 if (opt_TraceJVMCalls) { \
118 log_println(__VA_ARGS__); \
122 # define PRINTJVMWARNINGS(...)
124 /* if (opt_PrintJVMWarnings) { \ */
125 /* log_println(__VA_ARGS__); \ */
131 # define TRACEJVMCALLS(...)
132 # define PRINTJVMWARNINGS(...)
138 /* Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx */
139 unsigned int jvm_version; /* Consists of major, minor, micro (n.n.n) */
140 /* and build number (xx) */
141 unsigned int update_version : 8; /* Update release version (uu) */
142 unsigned int special_update_version : 8; /* Special update release version (c) */
143 unsigned int reserved1 : 16;
144 unsigned int reserved2;
146 /* The following bits represents JVM supports that JDK has dependency on.
147 * JDK can use these bits to determine which JVM version
148 * and support it has to maintain runtime compatibility.
150 * When a new bit is added in a minor or update release, make sure
151 * the new bit is also added in the main/baseline.
153 unsigned int is_attachable : 1;
161 * A structure used to a capture exception table entry in a Java method.
168 } JVM_ExceptionTableEntryType;
171 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
173 if ((intptr_t) count <= 0)
176 return vsnprintf(str, count, fmt, args);
180 int jio_snprintf(char *str, size_t count, const char *fmt, ...)
186 len = jio_vsnprintf(str, count, fmt, ap);
193 int jio_fprintf(FILE* f, const char *fmt, ...)
195 log_println("jio_fprintf: IMPLEMENT ME!");
199 int jio_vfprintf(FILE* f, const char *fmt, va_list args)
201 log_println("jio_vfprintf: IMPLEMENT ME!");
205 int jio_printf(const char *fmt, ...)
207 log_println("jio_printf: IMPLEMENT ME!");
211 /* JVM_GetInterfaceVersion */
213 jint JVM_GetInterfaceVersion()
215 /* This is defined in hotspot/src/share/vm/prims/jvm.h */
217 #define JVM_INTERFACE_VERSION 4
219 return JVM_INTERFACE_VERSION;
223 /* JVM_CurrentTimeMillis */
225 jlong JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)
228 log_println("JVM_CurrentTimeMillis");
230 return (jlong) builtin_currenttimemillis();
236 jlong JVM_NanoTime(JNIEnv *env, jclass ignored)
239 log_println("JVM_NanoTime");
241 return (jlong) builtin_nanotime();
247 void JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos, jobject dst, jint dst_pos, jint length)
252 s = (java_handle_t *) src;
253 d = (java_handle_t *) dst;
256 log_println("JVM_ArrayCopy: src=%p, src_pos=%d, dst=%p, dst_pos=%d, length=%d", src, src_pos, dst, dst_pos, length);
259 (void) builtin_arraycopy(s, src_pos, d, dst_pos, length);
263 /* JVM_InitProperties */
265 jobject JVM_InitProperties(JNIEnv *env, jobject properties)
268 log_println("JVM_InitProperties: properties=%d", properties);
270 properties_system_add_all((java_handle_t *) properties);
276 void JVM_Exit(jint code)
278 log_println("JVM_Exit: IMPLEMENT ME!");
284 void JVM_Halt(jint code)
287 log_println("JVM_Halt: code=%d", code);
294 /* JVM_OnExit(void (*func)) */
296 void JVM_OnExit(void (*func)(void))
298 log_println("JVM_OnExit(void (*func): IMPLEMENT ME!");
306 TRACEJVMCALLS("JVM_GC()");
312 /* JVM_MaxObjectInspectionAge */
314 jlong JVM_MaxObjectInspectionAge(void)
316 log_println("JVM_MaxObjectInspectionAge: IMPLEMENT ME!");
320 /* JVM_TraceInstructions */
322 void JVM_TraceInstructions(jboolean on)
324 log_println("JVM_TraceInstructions: IMPLEMENT ME!");
328 /* JVM_TraceMethodCalls */
330 void JVM_TraceMethodCalls(jboolean on)
332 log_println("JVM_TraceMethodCalls: IMPLEMENT ME!");
336 /* JVM_TotalMemory */
338 jlong JVM_TotalMemory(void)
340 TRACEJVMCALLS("JVM_TotalMemory()");
342 return gc_get_heap_size();
348 jlong JVM_FreeMemory(void)
350 TRACEJVMCALLS("JVM_FreeMemory()");
352 return gc_get_free_bytes();
358 jlong JVM_MaxMemory(void)
360 TRACEJVMCALLS("JVM_MaxMemory()");
362 return gc_get_max_heap_size();
366 /* JVM_ActiveProcessorCount */
368 jint JVM_ActiveProcessorCount(void)
370 log_println("JVM_ActiveProcessorCount: IMPLEMENT ME!");
374 /* JVM_FillInStackTrace */
376 void JVM_FillInStackTrace(JNIEnv *env, jobject receiver)
378 java_lang_Throwable *o;
379 stacktracecontainer *stc;
382 log_println("JVM_FillInStackTrace: receiver=%p", receiver);
385 o = (java_lang_Throwable *) receiver;
387 stc = stacktrace_fillInStackTrace();
392 o->backtrace = (java_lang_Object *) stc;
396 /* JVM_PrintStackTrace */
398 void JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable)
400 log_println("JVM_PrintStackTrace: IMPLEMENT ME!");
404 /* JVM_GetStackTraceDepth */
406 jint JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable)
408 java_lang_Throwable *o;
409 stacktracecontainer *stc;
410 stacktracebuffer *stb;
413 log_println("JVM_GetStackTraceDepth: throwable=%p", throwable);
416 o = (java_lang_Throwable *) throwable;
417 stc = (stacktracecontainer *) o->backtrace;
424 /* JVM_GetStackTraceElement */
426 jobject JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index)
428 java_lang_Throwable *t;
429 stacktracecontainer *stc;
430 stacktracebuffer *stb;
431 stacktrace_entry *ste;
432 java_lang_StackTraceElement *o;
433 java_lang_String *declaringclass;
434 java_lang_String *filename;
438 log_println("JVM_GetStackTraceElement: throwable=%p, index=%d", throwable, index);
441 t = (java_lang_Throwable *) throwable;
442 stc = (stacktracecontainer *) t->backtrace;
445 if ((index < 0) || (index >= stb->used)) {
446 /* XXX This should be an IndexOutOfBoundsException (check this
449 exceptions_throw_arrayindexoutofboundsexception();
453 ste = &(stb->entries[index]);
455 /* allocate a new StackTraceElement */
457 o = (java_lang_StackTraceElement *)
458 builtin_new(class_java_lang_StackTraceElement);
465 if (!(ste->method->flags & ACC_NATIVE)) {
466 if (ste->method->class->sourcefile)
467 filename = (java_lang_String *) javastring_new(ste->method->class->sourcefile);
474 /* get line number */
476 if (ste->method->flags & ACC_NATIVE)
479 linenumber = (ste->linenumber == 0) ? -1 : ste->linenumber;
481 /* get declaring class name */
484 _Jv_java_lang_Class_getName(LLNI_classinfo_wrap(ste->method->class));
486 /* fill the java.lang.StackTraceElement element */
488 o->declaringClass = declaringclass;
489 o->methodName = (java_lang_String *) javastring_new(ste->method->name);
490 o->fileName = filename;
491 o->lineNumber = linenumber;
499 jint JVM_IHashCode(JNIEnv* env, jobject handle)
502 log_println("JVM_IHashCode: jobject=%p", handle);
504 return (jint) ((ptrint) handle);
508 /* JVM_MonitorWait */
510 void JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms)
513 log_println("JVM_MonitorWait: handle=%p, ms=%ld", handle, ms);
515 _Jv_java_lang_Object_wait((java_lang_Object *) handle, ms, 0);
519 /* JVM_MonitorNotify */
521 void JVM_MonitorNotify(JNIEnv* env, jobject handle)
524 log_println("JVM_MonitorNotify: IMPLEMENT ME!");
526 _Jv_java_lang_Object_notify((java_lang_Object *) handle);
530 /* JVM_MonitorNotifyAll */
532 void JVM_MonitorNotifyAll(JNIEnv* env, jobject handle)
535 log_println("JVM_MonitorNotifyAll: handle=%p", handle);
537 _Jv_java_lang_Object_notifyAll((java_lang_Object *) handle);
543 jobject JVM_Clone(JNIEnv* env, jobject handle)
546 log_println("JVM_Clone: handle=%p", handle);
548 return (jobject) builtin_clone(env, (java_handle_t *) handle);
552 /* JVM_InitializeCompiler */
554 void JVM_InitializeCompiler (JNIEnv *env, jclass compCls)
556 log_println("JVM_InitializeCompiler : IMPLEMENT ME!");
560 /* JVM_IsSilentCompiler */
562 jboolean JVM_IsSilentCompiler(JNIEnv *env, jclass compCls)
564 log_println("JVM_IsSilentCompiler: IMPLEMENT ME!");
568 /* JVM_CompileClass */
570 jboolean JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls)
572 log_println("JVM_CompileClass: IMPLEMENT ME!");
576 /* JVM_CompileClasses */
578 jboolean JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname)
580 log_println("JVM_CompileClasses: IMPLEMENT ME!");
584 /* JVM_CompilerCommand */
586 jobject JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg)
588 log_println("JVM_CompilerCommand: IMPLEMENT ME!");
592 /* JVM_EnableCompiler */
594 void JVM_EnableCompiler(JNIEnv *env, jclass compCls)
596 TRACEJVMCALLS("JVM_EnableCompiler(env=%p, compCls=%p)", env, compCls);
597 PRINTJVMWARNINGS("JVM_EnableCompiler not supported");
601 /* JVM_DisableCompiler */
603 void JVM_DisableCompiler(JNIEnv *env, jclass compCls)
605 TRACEJVMCALLS("JVM_DisableCompiler(env=%p, compCls=%p)", env, compCls);
606 PRINTJVMWARNINGS("JVM_DisableCompiler not supported");
610 /* JVM_GetLastErrorString */
612 jint JVM_GetLastErrorString(char *buf, int len)
638 char *JVM_NativePath(char *path)
640 TRACEJVMCALLS("JVM_NativePath(path=%s)", path);
642 /* XXX is this correct? */
648 /* JVM_GetCallerClass */
650 jclass JVM_GetCallerClass(JNIEnv* env, int depth)
652 java_handle_objectarray_t *oa;
654 TRACEJVMCALLS("JVM_GetCallerClass(env=%p, depth=%d)", env, depth);
656 oa = stacktrace_getClassContext();
661 if (oa->header.size < depth)
664 return (jclass) oa->data[depth - 1];
669 /* JVM_FindPrimitiveClass */
671 jclass JVM_FindPrimitiveClass(JNIEnv* env, const char* s)
676 TRACEJVMCALLS("JVM_FindPrimitiveClass(env=%p, s=%s)", env, s);
679 c = primitive_class_get_by_name(u);
681 return (jclass) LLNI_classinfo_wrap(c);
685 /* JVM_ResolveClass */
687 void JVM_ResolveClass(JNIEnv* env, jclass cls)
689 TRACEJVMCALLS("JVM_ResolveClass(env=%p, cls=%p)", env, cls);
690 PRINTJVMWARNINGS("JVM_ResolveClass not implemented");
694 /* JVM_FindClassFromClassLoader */
696 jclass JVM_FindClassFromClassLoader(JNIEnv* env, const char* name, jboolean init, jobject loader, jboolean throwError)
702 TRACEJVMCALLS("JVM_FindClassFromClassLoader: name=%s, init=%d, loader=%p, throwError=%d", name, init, loader, throwError);
704 u = utf_new_char(name);
705 cl = (classloader *) loader;
707 c = load_class_from_classloader(u, cl);
713 if (!(c->state & CLASS_INITIALIZED))
714 if (!initialize_class(c))
717 return (jclass) LLNI_classinfo_wrap(c);
721 /* JVM_FindClassFromClass */
723 jclass JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init, jclass from)
725 log_println("JVM_FindClassFromClass: IMPLEMENT ME!");
729 /* JVM_DefineClass */
731 jclass JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)
733 log_println("JVM_DefineClass: IMPLEMENT ME!");
737 /* JVM_DefineClassWithSource */
739 jclass JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)
745 TRACEJVMCALLS("JVM_DefineClassWithSource(env=%p, name=%s, loader=%p, buf=%p, len=%d, pd=%p, source=%s)", env, name, loader, buf, len, pd, source);
747 u = utf_new_char(name);
748 cl = (classloader *) loader;
750 /* XXX do something with source */
752 c = class_define(u, cl, len, (const uint8_t *) buf, (java_handle_t *) pd);
754 return (jclass) LLNI_classinfo_wrap(c);
758 /* JVM_FindLoadedClass */
760 jclass JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name)
766 TRACEJVMCALLS("JVM_FindLoadedClass(env=%p, loader=%p, name=%p)", env, loader, name);
768 cl = (classloader *) loader;
770 u = javastring_toutf((java_handle_t *) name, true);
771 c = classcache_lookup(cl, u);
773 return (jclass) LLNI_classinfo_wrap(c);
777 /* JVM_GetClassName */
779 jstring JVM_GetClassName(JNIEnv *env, jclass cls)
782 log_println("JVM_GetClassName: cls=%p", cls);
784 return (jstring) _Jv_java_lang_Class_getName((java_lang_Class *) cls);
788 /* JVM_GetClassInterfaces */
790 jobjectArray JVM_GetClassInterfaces(JNIEnv *env, jclass cls)
793 java_handle_objectarray_t *oa;
795 TRACEJVMCALLS("JVM_GetClassInterfaces(env=%p, cls=%p)", env, cls);
797 c = LLNI_classinfo_unwrap(cls);
799 oa = class_get_interfaces(c);
801 return (jobjectArray) oa;
805 /* JVM_GetClassLoader */
807 jobject JVM_GetClassLoader(JNIEnv *env, jclass cls)
809 TRACEJVMCALLS("JVM_GetClassLoader(env=%p, cls=%p)", env, cls);
811 return (jobject) _Jv_java_lang_Class_getClassLoader((java_lang_Class *) cls);
815 /* JVM_IsInterface */
817 jboolean JVM_IsInterface(JNIEnv *env, jclass cls)
822 log_println("JVM_IsInterface: cls=%p", cls);
825 c = LLNI_classinfo_unwrap(cls);
827 return class_is_interface(c);
831 /* JVM_GetClassSigners */
833 jobjectArray JVM_GetClassSigners(JNIEnv *env, jclass cls)
835 log_println("JVM_GetClassSigners: IMPLEMENT ME!");
839 /* JVM_SetClassSigners */
841 void JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers)
843 log_println("JVM_SetClassSigners: IMPLEMENT ME!");
847 /* JVM_GetProtectionDomain */
849 jobject JVM_GetProtectionDomain(JNIEnv *env, jclass cls)
853 TRACEJVMCALLS("JVM_GetProtectionDomain(env=%p, cls=%p)", env, cls);
855 c = LLNI_classinfo_unwrap(cls);
858 exceptions_throw_nullpointerexception();
862 /* Primitive types do not have a protection domain. */
864 if (class_is_primitive(c))
867 return (jobject) c->protectiondomain;
871 /* JVM_SetProtectionDomain */
873 void JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain)
875 log_println("JVM_SetProtectionDomain: IMPLEMENT ME!");
879 /* JVM_DoPrivileged */
881 jobject JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, jobject context, jboolean wrapException)
886 java_handle_t *result;
890 log_println("JVM_DoPrivileged: action=%p, context=%p, wrapException=%d", action, context, wrapException);
893 o = (java_handle_t *) action;
896 if (action == NULL) {
897 exceptions_throw_nullpointerexception();
901 /* lookup run() method (throw no exceptions) */
903 m = class_resolveclassmethod(c, utf_run, utf_void__java_lang_Object, c,
906 if ((m == NULL) || !(m->flags & ACC_PUBLIC) || (m->flags & ACC_STATIC)) {
907 exceptions_throw_internalerror("No run method");
911 /* XXX It seems something with a privileged stack needs to be done
914 result = vm_call_method(m, o);
916 e = exceptions_get_and_clear_exception();
919 exceptions_throw_privilegedactionexception(e);
923 return (jobject) result;
927 /* JVM_GetInheritedAccessControlContext */
929 jobject JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls)
931 log_println("JVM_GetInheritedAccessControlContext: IMPLEMENT ME!");
935 /* JVM_GetStackAccessControlContext */
937 jobject JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls)
939 log_println("JVM_GetStackAccessControlContext: IMPLEMENT ME!");
943 /* JVM_IsArrayClass */
945 jboolean JVM_IsArrayClass(JNIEnv *env, jclass cls)
948 log_println("JVM_IsArrayClass: cls=%p", cls);
950 return class_is_array(LLNI_classinfo_unwrap(cls));
954 /* JVM_IsPrimitiveClass */
956 jboolean JVM_IsPrimitiveClass(JNIEnv *env, jclass cls)
960 c = LLNI_classinfo_unwrap(cls);
963 log_println("JVM_IsPrimitiveClass(cls=%p)", cls);
966 return class_is_primitive(c);
970 /* JVM_GetComponentType */
972 jclass JVM_GetComponentType(JNIEnv *env, jclass cls)
974 classinfo *component;
977 TRACEJVMCALLS("JVM_GetComponentType(env=%p, cls=%p)", env, cls);
979 c = LLNI_classinfo_unwrap(cls);
981 component = class_get_componenttype(c);
983 return (jclass) LLNI_classinfo_wrap(component);
987 /* JVM_GetClassModifiers */
989 jint JVM_GetClassModifiers(JNIEnv *env, jclass cls)
994 log_println("JVM_GetClassModifiers: cls=%p", cls);
997 c = LLNI_classinfo_unwrap(cls);
999 /* XXX is this correct? */
1001 return c->flags & ACC_CLASS_REFLECT_MASK;
1005 /* JVM_GetDeclaredClasses */
1007 jobjectArray JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)
1010 java_handle_objectarray_t *oa;
1012 TRACEJVMCALLS("JVM_GetDeclaredClasses(env=%p, ofClass=%p)", env, ofClass);
1014 c = LLNI_classinfo_unwrap(ofClass);
1016 oa = class_get_declaredclasses(c, false);
1018 return (jobjectArray) oa;
1022 /* JVM_GetDeclaringClass */
1024 jclass JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass)
1029 TRACEJVMCALLS("JVM_GetDeclaringClass(env=%p, ofClass=%p)", env, ofClass);
1031 c = LLNI_classinfo_unwrap(ofClass);
1033 dc = class_get_declaringclass(c);
1035 return (jclass) LLNI_classinfo_wrap(dc);
1039 /* JVM_GetClassSignature */
1041 jstring JVM_GetClassSignature(JNIEnv *env, jclass cls)
1047 TRACEJVMCALLS("JVM_GetClassSignature(env=%p, cls=%p)", env, cls);
1049 c = (classinfo *) cls;
1051 /* Get the signature of the class. */
1053 u = class_get_signature(c);
1058 /* Convert UTF-string to a Java-string. */
1060 s = javastring_new(u);
1066 /* JVM_GetClassAnnotations */
1068 jbyteArray JVM_GetClassAnnotations(JNIEnv *env, jclass cls)
1070 classinfo *c = NULL;
1071 java_handle_bytearray_t *annotations = NULL;
1073 TRACEJVMCALLS("JVM_GetClassAnnotations: cls=%p", cls);
1076 exceptions_throw_nullpointerexception();
1080 c = LLNI_classinfo_unwrap(cls);
1082 /* get annotations: */
1083 annotations = class_get_annotations(c);
1085 return (jbyteArray)annotations;
1089 /* JVM_GetFieldAnnotations */
1091 jbyteArray JVM_GetFieldAnnotations(JNIEnv *env, jobject field)
1093 java_lang_reflect_Field *rf = (java_lang_reflect_Field*)field;
1094 java_handle_bytearray_t *ba = NULL;
1096 TRACEJVMCALLS("JVM_GetFieldAnnotations: field=%p", field);
1098 if (field == NULL) {
1099 exceptions_throw_nullpointerexception();
1103 LLNI_field_get_ref(rf, annotations, ba);
1105 return (jbyteArray)ba;
1109 /* JVM_GetMethodAnnotations */
1111 jbyteArray JVM_GetMethodAnnotations(JNIEnv *env, jobject method)
1113 java_lang_reflect_Method *rm = (java_lang_reflect_Method*)method;
1114 java_handle_bytearray_t *ba = NULL;
1116 TRACEJVMCALLS("JVM_GetMethodAnnotations: method=%p", method);
1118 if (method == NULL) {
1119 exceptions_throw_nullpointerexception();
1123 LLNI_field_get_ref(rm, annotations, ba);
1125 return (jbyteArray)ba;
1129 /* JVM_GetMethodDefaultAnnotationValue */
1131 jbyteArray JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method)
1133 java_lang_reflect_Method *rm = (java_lang_reflect_Method*)method;
1134 java_handle_bytearray_t *ba = NULL;
1136 TRACEJVMCALLS("JVM_GetMethodDefaultAnnotationValue: method=%p", method);
1138 if (method == NULL) {
1139 exceptions_throw_nullpointerexception();
1143 LLNI_field_get_ref(rm, annotationDefault, ba);
1145 return (jbyteArray)ba;
1149 /* JVM_GetMethodParameterAnnotations */
1151 jbyteArray JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method)
1153 java_lang_reflect_Method *rm = (java_lang_reflect_Method*)method;
1154 java_handle_bytearray_t *ba = NULL;
1156 TRACEJVMCALLS("JVM_GetMethodParameterAnnotations: method=%p", method);
1158 if (method == NULL) {
1159 exceptions_throw_nullpointerexception();
1163 LLNI_field_get_ref(rm, parameterAnnotations, ba);
1165 return (jbyteArray)ba;
1169 /* JVM_GetClassDeclaredFields */
1171 jobjectArray JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1174 log_println("JVM_GetClassDeclaredFields: ofClass=%p, publicOnly=%d", ofClass, publicOnly);
1176 return (jobjectArray) _Jv_java_lang_Class_getDeclaredFields((java_lang_Class *) ofClass, publicOnly);
1180 /* JVM_GetClassDeclaredMethods */
1182 jobjectArray JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1185 log_println("JVM_GetClassDeclaredMethods: ofClass=%p, publicOnly=%d", ofClass, publicOnly);
1187 return (jobjectArray) _Jv_java_lang_Class_getDeclaredMethods((java_lang_Class *) ofClass, publicOnly);
1191 /* JVM_GetClassDeclaredConstructors */
1193 jobjectArray JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1196 log_println("JVM_GetClassDeclaredConstructors: ofClass=%p, publicOnly=%d", ofClass, publicOnly);
1198 return (jobjectArray) _Jv_java_lang_Class_getDeclaredConstructors((java_lang_Class *) ofClass, publicOnly);
1202 /* JVM_GetClassAccessFlags */
1204 jint JVM_GetClassAccessFlags(JNIEnv *env, jclass cls)
1209 log_println("JVM_GetClassAccessFlags: cls=%p", cls);
1212 c = LLNI_classinfo_unwrap(cls);
1214 return c->flags & ACC_CLASS_REFLECT_MASK;
1218 /* JVM_GetClassConstantPool */
1220 jobject JVM_GetClassConstantPool(JNIEnv *env, jclass cls)
1222 #if defined(ENABLE_ANNOTATIONS)
1223 sun_reflect_ConstantPool *constantPool = NULL;
1224 java_lang_Object *constantPoolOop = (java_lang_Object*)cls;
1226 TRACEJVMCALLS("JVM_GetClassConstantPool(env=%p, cls=%p)", env, cls);
1229 (sun_reflect_ConstantPool*)native_new_and_init(
1230 class_sun_reflect_ConstantPool);
1232 if (constantPool == NULL) {
1237 LLNI_field_set_ref(constantPool, constantPoolOop, constantPoolOop);
1239 return (jobject)constantPool;
1241 log_println("JVM_GetClassConstantPool(env=%p, cls=%p): not implemented in this configuration!", env, cls);
1247 /* JVM_ConstantPoolGetSize */
1249 jint JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool)
1253 TRACEJVMCALLS("JVM_ConstantPoolGetSize(env=%p, unused=%p, jcpool=%p)", env, unused, jcpool);
1255 c = LLNI_classinfo_unwrap(jcpool);
1261 /* JVM_ConstantPoolGetClassAt */
1263 jclass JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1265 constant_classref *ref;
1269 TRACEJVMCALLS("JVM_ConstantPoolGetClassAt(env=%p, jcpool=%p, index=%d)", env, jcpool, index);
1271 c = LLNI_classinfo_unwrap(jcpool);
1273 ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1278 result = resolve_classref_eager(ref);
1280 return (jclass) LLNI_classinfo_wrap(result);
1284 /* JVM_ConstantPoolGetClassAtIfLoaded */
1286 jclass JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1288 constant_classref *ref;
1292 TRACEJVMCALLS("JVM_ConstantPoolGetClassAtIfLoaded(env=%p, unused=%p, jcpool=%p, index=%d)", env, unused, jcpool, index);
1294 c = LLNI_classinfo_unwrap(jcpool);
1296 ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1301 if (!resolve_classref(NULL, ref, resolveLazy, true, true, &result))
1304 if ((result == NULL) || !(result->state & CLASS_LOADED)) {
1308 return (jclass) LLNI_classinfo_wrap(result);
1312 /* JVM_ConstantPoolGetMethodAt */
1314 jobject JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1316 constant_FMIref *ref;
1317 classinfo *cls = LLNI_classinfo_unwrap(jcpool);
1319 TRACEJVMCALLS("JVM_ConstantPoolGetMethodAt: jcpool=%p, index=%d", jcpool, index);
1321 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1327 /* XXX: is that right? or do I have to use resolve_method_*? */
1328 return (jobject)reflect_method_new(ref->p.method);
1332 /* JVM_ConstantPoolGetMethodAtIfLoaded */
1334 jobject JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1336 constant_FMIref *ref;
1337 classinfo *c = NULL;
1338 classinfo *cls = LLNI_classinfo_unwrap(jcpool);
1340 TRACEJVMCALLS("JVM_ConstantPoolGetMethodAtIfLoaded: jcpool=%p, index=%d", jcpool, index);
1342 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1348 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1352 if (c == NULL || !(c->state & CLASS_LOADED)) {
1356 return (jobject)reflect_method_new(ref->p.method);
1360 /* JVM_ConstantPoolGetFieldAt */
1362 jobject JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1364 constant_FMIref *ref;
1365 classinfo *cls = LLNI_classinfo_unwrap(jcpool);
1367 TRACEJVMCALLS("JVM_ConstantPoolGetFieldAt: jcpool=%p, index=%d", jcpool, index);
1369 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1375 return (jobject)reflect_field_new(ref->p.field);
1379 /* JVM_ConstantPoolGetFieldAtIfLoaded */
1381 jobject JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1383 constant_FMIref *ref;
1385 classinfo *cls = LLNI_classinfo_unwrap(jcpool);
1387 TRACEJVMCALLS("JVM_ConstantPoolGetFieldAtIfLoaded: jcpool=%p, index=%d", jcpool, index);
1389 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1395 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1399 if (c == NULL || !(c->state & CLASS_LOADED)) {
1403 return (jobject)reflect_field_new(ref->p.field);
1407 /* JVM_ConstantPoolGetMemberRefInfoAt */
1409 jobjectArray JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1411 log_println("JVM_ConstantPoolGetMemberRefInfoAt: jcpool=%p, index=%d, IMPLEMENT ME!", jcpool, index);
1416 /* JVM_ConstantPoolGetIntAt */
1418 jint JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1420 constant_integer *ref;
1421 classinfo *cls = LLNI_classinfo_unwrap(jcpool);
1423 TRACEJVMCALLS("JVM_ConstantPoolGetIntAt: jcpool=%p, index=%d", jcpool, index);
1425 ref = (constant_integer*)class_getconstant(cls, index, CONSTANT_Integer);
1435 /* JVM_ConstantPoolGetLongAt */
1437 jlong JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1440 classinfo *cls = LLNI_classinfo_unwrap(jcpool);
1442 TRACEJVMCALLS("JVM_ConstantPoolGetLongAt: jcpool=%p, index=%d", jcpool, index);
1444 ref = (constant_long*)class_getconstant(cls, index, CONSTANT_Long);
1454 /* JVM_ConstantPoolGetFloatAt */
1456 jfloat JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1458 constant_float *ref;
1459 classinfo *cls = LLNI_classinfo_unwrap(jcpool);
1461 TRACEJVMCALLS("JVM_ConstantPoolGetFloatAt: jcpool=%p, index=%d", jcpool, index);
1463 ref = (constant_float*)class_getconstant(cls, index, CONSTANT_Float);
1473 /* JVM_ConstantPoolGetDoubleAt */
1475 jdouble JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1477 constant_double *ref;
1478 classinfo *cls = LLNI_classinfo_unwrap(jcpool);
1480 TRACEJVMCALLS("JVM_ConstantPoolGetDoubleAt: jcpool=%p, index=%d", jcpool, index);
1482 ref = (constant_double*)class_getconstant(cls, index, CONSTANT_Double);
1492 /* JVM_ConstantPoolGetStringAt */
1494 jstring JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1497 classinfo *cls = LLNI_classinfo_unwrap(jcpool);
1499 TRACEJVMCALLS("JVM_ConstantPoolGetStringAt: jcpool=%p, index=%d", jcpool, index);
1501 ref = (utf*)class_getconstant(cls, index, CONSTANT_String);
1507 /* XXX: I hope literalstring_new is the right Function. */
1508 return (jstring)literalstring_new(ref);
1512 /* JVM_ConstantPoolGetUTF8At */
1514 jstring JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1517 classinfo *cls = LLNI_classinfo_unwrap(jcpool);
1519 TRACEJVMCALLS("JVM_ConstantPoolGetUTF8At: jcpool=%p, index=%d", jcpool, index);
1521 ref = (utf*)class_getconstant(cls, index, CONSTANT_Utf8);
1527 /* XXX: I hope literalstring_new is the right Function. */
1528 return (jstring)literalstring_new(ref);
1532 /* JVM_DesiredAssertionStatus */
1534 jboolean JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls)
1536 TRACEJVMCALLS("JVM_DesiredAssertionStatus(env=%p, unused=%p, cls=%p)", env, unused, cls);
1538 /* TODO: Implement this one, but false should be OK. */
1544 /* JVM_AssertionStatusDirectives */
1546 jobject JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)
1549 java_lang_AssertionStatusDirectives *o;
1550 java_handle_objectarray_t *classes;
1551 java_handle_objectarray_t *packages;
1554 log_println("JVM_AssertionStatusDirectives");
1556 /* XXX this is not completely implemented */
1558 c = load_class_bootstrap(utf_new_char("java/lang/AssertionStatusDirectives"));
1563 o = (java_lang_AssertionStatusDirectives *) builtin_new(c);
1568 classes = builtin_anewarray(0, class_java_lang_Object);
1570 if (classes == NULL)
1573 packages = builtin_anewarray(0, class_java_lang_Object);
1575 if (packages == NULL)
1578 /* set instance fields */
1580 o->classes = classes;
1581 o->packages = packages;
1587 /* JVM_GetClassNameUTF */
1589 const char* JVM_GetClassNameUTF(JNIEnv *env, jclass cls)
1591 log_println("JVM_GetClassNameUTF: IMPLEMENT ME!");
1595 /* JVM_GetClassCPTypes */
1597 void JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types)
1599 log_println("JVM_GetClassCPTypes: IMPLEMENT ME!");
1603 /* JVM_GetClassCPEntriesCount */
1605 jint JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)
1607 log_println("JVM_GetClassCPEntriesCount: IMPLEMENT ME!");
1611 /* JVM_GetClassFieldsCount */
1613 jint JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)
1615 log_println("JVM_GetClassFieldsCount: IMPLEMENT ME!");
1619 /* JVM_GetClassMethodsCount */
1621 jint JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)
1623 log_println("JVM_GetClassMethodsCount: IMPLEMENT ME!");
1627 /* JVM_GetMethodIxExceptionIndexes */
1629 void JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions)
1631 log_println("JVM_GetMethodIxExceptionIndexes: IMPLEMENT ME!");
1635 /* JVM_GetMethodIxExceptionsCount */
1637 jint JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)
1639 log_println("JVM_GetMethodIxExceptionsCount: IMPLEMENT ME!");
1643 /* JVM_GetMethodIxByteCode */
1645 void JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code)
1647 log_println("JVM_GetMethodIxByteCode: IMPLEMENT ME!");
1651 /* JVM_GetMethodIxByteCodeLength */
1653 jint JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)
1655 log_println("JVM_GetMethodIxByteCodeLength: IMPLEMENT ME!");
1659 /* JVM_GetMethodIxExceptionTableEntry */
1661 void JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry)
1663 log_println("JVM_GetMethodIxExceptionTableEntry: IMPLEMENT ME!");
1667 /* JVM_GetMethodIxExceptionTableLength */
1669 jint JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)
1671 log_println("JVM_GetMethodIxExceptionTableLength: IMPLEMENT ME!");
1675 /* JVM_GetMethodIxModifiers */
1677 jint JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)
1679 log_println("JVM_GetMethodIxModifiers: IMPLEMENT ME!");
1683 /* JVM_GetFieldIxModifiers */
1685 jint JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)
1687 log_println("JVM_GetFieldIxModifiers: IMPLEMENT ME!");
1691 /* JVM_GetMethodIxLocalsCount */
1693 jint JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)
1695 log_println("JVM_GetMethodIxLocalsCount: IMPLEMENT ME!");
1699 /* JVM_GetMethodIxArgsSize */
1701 jint JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)
1703 log_println("JVM_GetMethodIxArgsSize: IMPLEMENT ME!");
1707 /* JVM_GetMethodIxMaxStack */
1709 jint JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)
1711 log_println("JVM_GetMethodIxMaxStack: IMPLEMENT ME!");
1715 /* JVM_IsConstructorIx */
1717 jboolean JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)
1719 log_println("JVM_IsConstructorIx: IMPLEMENT ME!");
1723 /* JVM_GetMethodIxNameUTF */
1725 const char* JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)
1727 log_println("JVM_GetMethodIxNameUTF: IMPLEMENT ME!");
1731 /* JVM_GetMethodIxSignatureUTF */
1733 const char* JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)
1735 log_println("JVM_GetMethodIxSignatureUTF: IMPLEMENT ME!");
1739 /* JVM_GetCPFieldNameUTF */
1741 const char* JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1743 log_println("JVM_GetCPFieldNameUTF: IMPLEMENT ME!");
1747 /* JVM_GetCPMethodNameUTF */
1749 const char* JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1751 log_println("JVM_GetCPMethodNameUTF: IMPLEMENT ME!");
1755 /* JVM_GetCPMethodSignatureUTF */
1757 const char* JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
1759 log_println("JVM_GetCPMethodSignatureUTF: IMPLEMENT ME!");
1763 /* JVM_GetCPFieldSignatureUTF */
1765 const char* JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
1767 log_println("JVM_GetCPFieldSignatureUTF: IMPLEMENT ME!");
1771 /* JVM_GetCPClassNameUTF */
1773 const char* JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1775 log_println("JVM_GetCPClassNameUTF: IMPLEMENT ME!");
1779 /* JVM_GetCPFieldClassNameUTF */
1781 const char* JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1783 log_println("JVM_GetCPFieldClassNameUTF: IMPLEMENT ME!");
1787 /* JVM_GetCPMethodClassNameUTF */
1789 const char* JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1791 log_println("JVM_GetCPMethodClassNameUTF: IMPLEMENT ME!");
1795 /* JVM_GetCPFieldModifiers */
1797 jint JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
1799 log_println("JVM_GetCPFieldModifiers: IMPLEMENT ME!");
1803 /* JVM_GetCPMethodModifiers */
1805 jint JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
1807 log_println("JVM_GetCPMethodModifiers: IMPLEMENT ME!");
1811 /* JVM_ReleaseUTF */
1813 void JVM_ReleaseUTF(const char *utf)
1815 log_println("JVM_ReleaseUTF: IMPLEMENT ME!");
1819 /* JVM_IsSameClassPackage */
1821 jboolean JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2)
1823 log_println("JVM_IsSameClassPackage: IMPLEMENT ME!");
1829 jint JVM_Open(const char *fname, jint flags, jint mode)
1834 log_println("JVM_Open: fname=%s, flags=%d, mode=%d", fname, flags, mode);
1837 result = open(fname, flags, mode);
1845 /* XXX don't know what to do here */
1846 /* return JVM_EEXIST; */
1857 jint JVM_Close(jint fd)
1860 log_println("JVM_Close: fd=%d", fd);
1868 jint JVM_Read(jint fd, char *buf, jint nbytes)
1871 log_println("JVM_Read: fd=%d, buf=%p, nbytes=%d", fd, buf, nbytes);
1873 return read(fd, buf, nbytes);
1879 jint JVM_Write(jint fd, char *buf, jint nbytes)
1882 log_println("JVM_Write: fd=%d, buf=%s, nbytes=%d", fd, buf, nbytes);
1884 return write(fd, buf, nbytes);
1890 jint JVM_Available(jint fd, jlong *pbytes)
1892 #if defined(FIONREAD)
1895 TRACEJVMCALLS("JVM_Available(fd=%d, pbytes=%p)", fd, pbytes);
1899 if (ioctl(fd, FIONREAD, &bytes) < 0)
1906 # error FIONREAD not defined
1913 jlong JVM_Lseek(jint fd, jlong offset, jint whence)
1916 log_println("JVM_Lseek: fd=%d, offset=%ld, whence=%d", fd, offset, whence);
1918 return (jlong) lseek(fd, (off_t) offset, whence);
1924 jint JVM_SetLength(jint fd, jlong length)
1926 log_println("JVM_SetLength: IMPLEMENT ME!");
1932 jint JVM_Sync(jint fd)
1934 log_println("JVM_Sync: IMPLEMENT ME!");
1938 /* JVM_StartThread */
1940 void JVM_StartThread(JNIEnv* env, jobject jthread)
1943 log_println("JVM_StartThread: jthread=%p", jthread);
1945 _Jv_java_lang_Thread_start((java_lang_Thread *) jthread, 0);
1949 /* JVM_StopThread */
1951 void JVM_StopThread(JNIEnv* env, jobject jthread, jobject throwable)
1953 log_println("JVM_StopThread: IMPLEMENT ME!");
1957 /* JVM_IsThreadAlive */
1959 jboolean JVM_IsThreadAlive(JNIEnv* env, jobject jthread)
1962 log_println("JVM_IsThreadAlive: jthread=%p", jthread);
1964 return _Jv_java_lang_Thread_isAlive((java_lang_Thread *) jthread);
1968 /* JVM_SuspendThread */
1970 void JVM_SuspendThread(JNIEnv* env, jobject jthread)
1972 log_println("JVM_SuspendThread: IMPLEMENT ME!");
1976 /* JVM_ResumeThread */
1978 void JVM_ResumeThread(JNIEnv* env, jobject jthread)
1980 log_println("JVM_ResumeThread: IMPLEMENT ME!");
1984 /* JVM_SetThreadPriority */
1986 void JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio)
1989 log_println("JVM_SetThreadPriority: jthread=%p, prio=%d", jthread, prio);
1991 _Jv_java_lang_Thread_setPriority((java_lang_Thread *) jthread, prio);
1997 void JVM_Yield(JNIEnv *env, jclass threadClass)
1999 TRACEJVMCALLS("JVM_Yield(env=%p, threadClass=%p)", env, threadClass);
2007 void JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis)
2010 log_println("JVM_Sleep: threadClass=%p, millis=%ld", threadClass, millis);
2012 _Jv_java_lang_Thread_sleep(millis);
2016 /* JVM_CurrentThread */
2018 jobject JVM_CurrentThread(JNIEnv* env, jclass threadClass)
2021 log_println("JVM_CurrentThread: threadClass=%p", threadClass);
2023 return (jobject) _Jv_java_lang_Thread_currentThread();
2027 /* JVM_CountStackFrames */
2029 jint JVM_CountStackFrames(JNIEnv* env, jobject jthread)
2031 log_println("JVM_CountStackFrames: IMPLEMENT ME!");
2037 void JVM_Interrupt(JNIEnv* env, jobject jthread)
2039 log_println("JVM_Interrupt: IMPLEMENT ME!");
2043 /* JVM_IsInterrupted */
2045 jboolean JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted)
2048 log_println("JVM_IsInterrupted: jthread=%p, clear_interrupted=%d", jthread, clear_interrupted);
2050 /* XXX do something with clear_interrupted */
2051 return _Jv_java_lang_Thread_isInterrupted((java_lang_Thread *) jthread);
2057 jboolean JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj)
2059 log_println("JVM_HoldsLock: IMPLEMENT ME!");
2063 /* JVM_DumpAllStacks */
2065 void JVM_DumpAllStacks(JNIEnv* env, jclass unused)
2067 log_println("JVM_DumpAllStacks: IMPLEMENT ME!");
2071 /* JVM_CurrentLoadedClass */
2073 jclass JVM_CurrentLoadedClass(JNIEnv *env)
2075 log_println("JVM_CurrentLoadedClass: IMPLEMENT ME!");
2079 /* JVM_CurrentClassLoader */
2081 jobject JVM_CurrentClassLoader(JNIEnv *env)
2083 /* XXX if a method in a class in a trusted loader is in a
2084 doPrivileged, return NULL */
2086 log_println("JVM_CurrentClassLoader: IMPLEMENT ME!");
2090 /* JVM_GetClassContext */
2092 jobjectArray JVM_GetClassContext(JNIEnv *env)
2095 log_println("JVM_GetClassContext");
2097 return (jobjectArray) stacktrace_getClassContext();
2101 /* JVM_ClassDepth */
2103 jint JVM_ClassDepth(JNIEnv *env, jstring name)
2105 log_println("JVM_ClassDepth: IMPLEMENT ME!");
2109 /* JVM_ClassLoaderDepth */
2111 jint JVM_ClassLoaderDepth(JNIEnv *env)
2113 log_println("JVM_ClassLoaderDepth: IMPLEMENT ME!");
2117 /* JVM_GetSystemPackage */
2119 jstring JVM_GetSystemPackage(JNIEnv *env, jstring name)
2121 log_println("JVM_GetSystemPackage(env=%p, name=%p)");
2122 javastring_print((java_handle_t *) name);
2129 /* JVM_GetSystemPackages */
2131 jobjectArray JVM_GetSystemPackages(JNIEnv *env)
2133 log_println("JVM_GetSystemPackages: IMPLEMENT ME!");
2137 /* JVM_AllocateNewObject */
2139 jobject JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass)
2141 log_println("JVM_AllocateNewObject: IMPLEMENT ME!");
2145 /* JVM_AllocateNewArray */
2147 jobject JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length)
2149 log_println("JVM_AllocateNewArray: IMPLEMENT ME!");
2153 /* JVM_LatestUserDefinedLoader */
2155 jobject JVM_LatestUserDefinedLoader(JNIEnv *env)
2157 log_println("JVM_LatestUserDefinedLoader: IMPLEMENT ME!");
2161 /* JVM_LoadClass0 */
2163 jclass JVM_LoadClass0(JNIEnv *env, jobject receiver, jclass currClass, jstring currClassName)
2165 log_println("JVM_LoadClass0: IMPLEMENT ME!");
2169 /* JVM_GetArrayLength */
2171 jint JVM_GetArrayLength(JNIEnv *env, jobject arr)
2175 TRACEJVMCALLS("JVM_GetArrayLength(arr=%p)", arr);
2177 a = (java_handle_t *) arr;
2179 return array_length_get(a);
2183 /* JVM_GetArrayElement */
2185 jobject JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index)
2190 TRACEJVMCALLS("JVM_GetArrayElement(env=%p, arr=%p, index=%d)", env, arr, index);
2192 a = (java_handle_t *) arr;
2194 /* if (!class_is_array(a->objheader.vftbl->class)) { */
2195 /* exceptions_throw_illegalargumentexception(); */
2199 o = array_element_get(a, index);
2205 /* JVM_GetPrimitiveArrayElement */
2207 jvalue JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode)
2209 log_println("JVM_GetPrimitiveArrayElement: IMPLEMENT ME!");
2213 /* JVM_SetArrayElement */
2215 void JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val)
2218 java_handle_t *value;
2220 TRACEJVMCALLS("JVM_SetArrayElement(env=%p, arr=%p, index=%d, val=%p)", env, arr, index, val);
2222 a = (java_handle_t *) arr;
2223 value = (java_handle_t *) val;
2225 array_element_set(a, index, value);
2229 /* JVM_SetPrimitiveArrayElement */
2231 void JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode)
2233 log_println("JVM_SetPrimitiveArrayElement: IMPLEMENT ME!");
2239 jobject JVM_NewArray(JNIEnv *env, jclass eltClass, jint length)
2244 java_handle_objectarray_t *oa;
2246 TRACEJVMCALLS("JVM_NewArray(env=%p, eltClass=%p, length=%d)", env, eltClass, length);
2248 c = LLNI_classinfo_unwrap(eltClass);
2250 /* create primitive or object array */
2252 if (class_is_primitive(c)) {
2253 pc = primitive_arrayclass_get_by_name(c->name);
2254 a = builtin_newarray(length, pc);
2259 oa = builtin_anewarray(length, c);
2261 return (jobject) oa;
2266 /* JVM_NewMultiArray */
2268 jobject JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim)
2270 log_println("JVM_NewMultiArray: IMPLEMENT ME!");
2274 /* JVM_InitializeSocketLibrary */
2276 jint JVM_InitializeSocketLibrary()
2278 log_println("JVM_InitializeSocketLibrary: IMPLEMENT ME!");
2284 jint JVM_Socket(jint domain, jint type, jint protocol)
2286 TRACEJVMCALLS("JVM_Socket(domain=%d, type=%d, protocol=%d)", domain, type, protocol);
2288 return socket(domain, type, protocol);
2292 /* JVM_SocketClose */
2294 jint JVM_SocketClose(jint fd)
2296 TRACEJVMCALLS("JVM_SocketClose(fd=%d)", fd);
2302 /* JVM_SocketShutdown */
2304 jint JVM_SocketShutdown(jint fd, jint howto)
2306 TRACEJVMCALLS("JVM_SocketShutdown(fd=%d, howto=%d)", fd, howto);
2308 return shutdown(fd, howto);
2314 jint JVM_Recv(jint fd, char *buf, jint nBytes, jint flags)
2316 log_println("JVM_Recv: IMPLEMENT ME!");
2322 jint JVM_Send(jint fd, char *buf, jint nBytes, jint flags)
2324 log_println("JVM_Send: IMPLEMENT ME!");
2330 jint JVM_Timeout(int fd, long timeout)
2332 log_println("JVM_Timeout: IMPLEMENT ME!");
2338 jint JVM_Listen(jint fd, jint count)
2340 TRACEJVMCALLS("JVM_Listen(fd=%d, count=%d)", fd, count);
2342 return listen(fd, count);
2348 jint JVM_Connect(jint fd, struct sockaddr *him, jint len)
2350 TRACEJVMCALLS("JVM_Connect(fd=%d, him=%p, len=%d)", fd, him, len);
2352 return connect(fd, him, len);
2358 jint JVM_Bind(jint fd, struct sockaddr *him, jint len)
2360 log_println("JVM_Bind: IMPLEMENT ME!");
2366 jint JVM_Accept(jint fd, struct sockaddr *him, jint *len)
2368 TRACEJVMCALLS("JVM_Accept(fd=%d, him=%p, len=%p)", fd, him, len);
2370 return accept(fd, him, (socklen_t *) len);
2376 jint JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen)
2378 log_println("JVM_RecvFrom: IMPLEMENT ME!");
2382 /* JVM_GetSockName */
2384 jint JVM_GetSockName(jint fd, struct sockaddr *him, int *len)
2386 TRACEJVMCALLS("JVM_GetSockName(fd=%d, him=%p, len=%p)", fd, him, len);
2388 return getsockname(fd, him, (socklen_t *) len);
2394 jint JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen)
2396 log_println("JVM_SendTo: IMPLEMENT ME!");
2400 /* JVM_SocketAvailable */
2402 jint JVM_SocketAvailable(jint fd, jint *pbytes)
2404 log_println("JVM_SocketAvailable: IMPLEMENT ME!");
2408 /* JVM_GetSockOpt */
2410 jint JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen)
2412 log_println("JVM_GetSockOpt: IMPLEMENT ME!");
2416 /* JVM_SetSockOpt */
2418 jint JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen)
2420 TRACEJVMCALLS("JVM_SetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%d)", fd, level, optname, optval, optlen);
2422 return setsockopt(fd, level, optname, optval, optlen);
2426 /* JVM_GetHostName */
2428 int JVM_GetHostName(char* name, int namelen)
2430 TRACEJVMCALLS("JVM_GetHostName(name=%s, namelen=%d)", name, namelen);
2432 return gethostname(name, namelen);
2436 /* JVM_GetHostByAddr */
2438 struct hostent* JVM_GetHostByAddr(const char* name, int len, int type)
2440 log_println("JVM_GetHostByAddr: IMPLEMENT ME!");
2444 /* JVM_GetHostByName */
2446 struct hostent* JVM_GetHostByName(char* name)
2448 log_println("JVM_GetHostByName: IMPLEMENT ME!");
2452 /* JVM_GetProtoByName */
2454 struct protoent* JVM_GetProtoByName(char* name)
2456 log_println("JVM_GetProtoByName: IMPLEMENT ME!");
2460 /* JVM_LoadLibrary */
2462 void *JVM_LoadLibrary(const char *name)
2466 TRACEJVMCALLS("JVM_LoadLibrary(name=%s)", name);
2468 u = utf_new_char(name);
2470 return native_library_open(u);
2474 /* JVM_UnloadLibrary */
2476 void JVM_UnloadLibrary(void* handle)
2478 log_println("JVM_UnloadLibrary: IMPLEMENT ME!");
2482 /* JVM_FindLibraryEntry */
2484 void *JVM_FindLibraryEntry(void *handle, const char *name)
2488 TRACEJVMCALLS("JVM_FindLibraryEntry(handle=%p, name=%s)", handle, name);
2490 symbol = lt_dlsym(handle, name);
2498 jboolean JVM_IsNaN(jdouble a)
2500 log_println("JVM_IsNaN: IMPLEMENT ME!");
2504 /* JVM_IsSupportedJNIVersion */
2506 jboolean JVM_IsSupportedJNIVersion(jint version)
2508 TRACEJVMCALLS("JVM_IsSupportedJNIVersion(version=%d)", version);
2511 case JNI_VERSION_1_1:
2512 case JNI_VERSION_1_2:
2513 case JNI_VERSION_1_4:
2521 /* JVM_InternString */
2523 jstring JVM_InternString(JNIEnv *env, jstring str)
2525 TRACEJVMCALLS("JVM_InternString(env=%p, str=%p)", env, str);
2527 return (jstring) javastring_intern((java_handle_t *) str);
2531 /* JVM_RawMonitorCreate */
2533 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void)
2538 log_println("JVM_RawMonitorCreate");
2541 o = NEW(java_object_t);
2543 lock_init_object_lock(o);
2549 /* JVM_RawMonitorDestroy */
2551 JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void *mon)
2554 log_println("JVM_RawMonitorDestroy: mon=%p", mon);
2556 FREE(mon, java_object_t);
2560 /* JVM_RawMonitorEnter */
2562 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void *mon)
2565 log_println("JVM_RawMonitorEnter: mon=%p", mon);
2567 (void) lock_monitor_enter((java_object_t *) mon);
2573 /* JVM_RawMonitorExit */
2575 JNIEXPORT void JNICALL JVM_RawMonitorExit(void *mon)
2578 log_println("JVM_RawMonitorExit: mon=%p", mon);
2580 (void) lock_monitor_exit((java_object_t *) mon);
2584 /* JVM_SetPrimitiveFieldValues */
2586 void JVM_SetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
2588 log_println("JVM_SetPrimitiveFieldValues: IMPLEMENT ME!");
2592 /* JVM_GetPrimitiveFieldValues */
2594 void JVM_GetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
2596 log_println("JVM_GetPrimitiveFieldValues: IMPLEMENT ME!");
2600 /* JVM_AccessVMBooleanFlag */
2602 jboolean JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get)
2604 log_println("JVM_AccessVMBooleanFlag: IMPLEMENT ME!");
2608 /* JVM_AccessVMIntFlag */
2610 jboolean JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get)
2612 log_println("JVM_AccessVMIntFlag: IMPLEMENT ME!");
2616 /* JVM_VMBreakPoint */
2618 void JVM_VMBreakPoint(JNIEnv *env, jobject obj)
2620 log_println("JVM_VMBreakPoint: IMPLEMENT ME!");
2624 /* JVM_GetClassFields */
2626 jobjectArray JVM_GetClassFields(JNIEnv *env, jclass cls, jint which)
2628 log_println("JVM_GetClassFields: IMPLEMENT ME!");
2632 /* JVM_GetClassMethods */
2634 jobjectArray JVM_GetClassMethods(JNIEnv *env, jclass cls, jint which)
2636 log_println("JVM_GetClassMethods: IMPLEMENT ME!");
2640 /* JVM_GetClassConstructors */
2642 jobjectArray JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which)
2644 log_println("JVM_GetClassConstructors: IMPLEMENT ME!");
2648 /* JVM_GetClassField */
2650 jobject JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which)
2652 log_println("JVM_GetClassField: IMPLEMENT ME!");
2656 /* JVM_GetClassMethod */
2658 jobject JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types, jint which)
2660 log_println("JVM_GetClassMethod: IMPLEMENT ME!");
2664 /* JVM_GetClassConstructor */
2666 jobject JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types, jint which)
2668 log_println("JVM_GetClassConstructor: IMPLEMENT ME!");
2672 /* JVM_NewInstance */
2674 jobject JVM_NewInstance(JNIEnv *env, jclass cls)
2676 log_println("JVM_NewInstance: IMPLEMENT ME!");
2682 jobject JVM_GetField(JNIEnv *env, jobject field, jobject obj)
2684 log_println("JVM_GetField: IMPLEMENT ME!");
2688 /* JVM_GetPrimitiveField */
2690 jvalue JVM_GetPrimitiveField(JNIEnv *env, jobject field, jobject obj, unsigned char wCode)
2692 log_println("JVM_GetPrimitiveField: IMPLEMENT ME!");
2698 void JVM_SetField(JNIEnv *env, jobject field, jobject obj, jobject val)
2700 log_println("JVM_SetField: IMPLEMENT ME!");
2704 /* JVM_SetPrimitiveField */
2706 void JVM_SetPrimitiveField(JNIEnv *env, jobject field, jobject obj, jvalue v, unsigned char vCode)
2708 log_println("JVM_SetPrimitiveField: IMPLEMENT ME!");
2712 /* JVM_InvokeMethod */
2714 jobject JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)
2717 log_println("JVM_InvokeMethod: method=%p, obj=%p, args0=%p", method, obj, args0);
2719 return (jobject) _Jv_java_lang_reflect_Method_invoke((java_lang_reflect_Method *) method, (java_lang_Object *) obj, (java_handle_objectarray_t *) args0);
2723 /* JVM_NewInstanceFromConstructor */
2725 jobject JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0)
2728 log_println("JVM_NewInstanceFromConstructor: c=%p, args0=%p", c, args0);
2730 return (jobject) _Jv_java_lang_reflect_Constructor_newInstance(env, (java_lang_reflect_Constructor *) c, (java_handle_objectarray_t *) args0);
2734 /* JVM_SupportsCX8 */
2736 jboolean JVM_SupportsCX8()
2739 log_println("JVM_SupportsCX8");
2741 return _Jv_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(NULL, NULL);
2747 jboolean JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal)
2749 log_println("JVM_CX8Field: IMPLEMENT ME!");
2753 /* JVM_GetAllThreads */
2755 jobjectArray JVM_GetAllThreads(JNIEnv *env, jclass dummy)
2757 log_println("JVM_GetAllThreads: IMPLEMENT ME!");
2761 /* JVM_DumpThreads */
2763 jobjectArray JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads)
2765 log_println("JVM_DumpThreads: IMPLEMENT ME!");
2769 /* JVM_GetManagement */
2771 void* JVM_GetManagement(jint version)
2773 log_println("JVM_GetManagement: IMPLEMENT ME!");
2777 /* JVM_InitAgentProperties */
2779 jobject JVM_InitAgentProperties(JNIEnv *env, jobject properties)
2781 log_println("JVM_InitAgentProperties: IMPLEMENT ME!");
2785 /* JVM_GetEnclosingMethodInfo */
2787 jobjectArray JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass)
2789 log_println("JVM_GetEnclosingMethodInfo: IMPLEMENT ME!");
2793 /* JVM_GetThreadStateValues */
2795 jintArray JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState)
2797 java_handle_intarray_t *ia;
2799 TRACEJVMCALLS("JVM_GetThreadStateValues(env=%p, javaThreadState=%d)",
2800 env, javaThreadState);
2802 /* If new thread states are added in future JDK and VM versions,
2803 this should check if the JDK version is compatible with thread
2804 states supported by the VM. Return NULL if not compatible.
2806 This function must map the VM java_lang_Thread::ThreadStatus
2807 to the Java thread state that the JDK supports. */
2809 switch (javaThreadState) {
2810 case THREAD_STATE_NEW:
2811 ia = builtin_newarray_int(1);
2816 array_intarray_element_set(ia, 0, THREAD_STATE_NEW);
2819 case THREAD_STATE_RUNNABLE:
2820 ia = builtin_newarray_int(1);
2825 array_intarray_element_set(ia, 0, THREAD_STATE_RUNNABLE);
2828 case THREAD_STATE_BLOCKED:
2829 ia = builtin_newarray_int(1);
2834 array_intarray_element_set(ia, 0, THREAD_STATE_BLOCKED);
2837 case THREAD_STATE_WAITING:
2838 ia = builtin_newarray_int(2);
2843 array_intarray_element_set(ia, 0, THREAD_STATE_WAITING);
2844 /* XXX Implement parked stuff. */
2845 /* array_intarray_element_set(ia, 1, PARKED); */
2848 case THREAD_STATE_TIMED_WAITING:
2849 ia = builtin_newarray_int(3);
2854 /* XXX Not sure about that one. */
2855 /* array_intarray_element_set(ia, 0, SLEEPING); */
2856 array_intarray_element_set(ia, 0, THREAD_STATE_TIMED_WAITING);
2857 /* XXX Implement parked stuff. */
2858 /* array_intarray_element_set(ia, 2, PARKED); */
2861 case THREAD_STATE_TERMINATED:
2862 ia = builtin_newarray_int(1);
2867 array_intarray_element_set(ia, 0, THREAD_STATE_TERMINATED);
2871 /* Unknown state - probably incompatible JDK version */
2875 return (jintArray) ia;
2879 /* JVM_GetThreadStateNames */
2881 jobjectArray JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values)
2883 java_handle_intarray_t *ia;
2884 java_handle_objectarray_t *oa;
2887 TRACEJVMCALLS("JVM_GetThreadStateNames(env=%p, javaThreadState=%d, values=%p)",
2888 env, javaThreadState, values);
2890 ia = (java_handle_intarray_t *) values;
2892 /* If new thread states are added in future JDK and VM versions,
2893 this should check if the JDK version is compatible with thread
2894 states supported by the VM. Return NULL if not compatible.
2896 This function must map the VM java_lang_Thread::ThreadStatus
2897 to the Java thread state that the JDK supports. */
2899 if (values == NULL) {
2900 exceptions_throw_nullpointerexception();
2904 switch (javaThreadState) {
2905 case THREAD_STATE_NEW:
2906 assert(ia->header.size == 1 && ia->data[0] == THREAD_STATE_NEW);
2908 oa = builtin_anewarray(1, class_java_lang_String);
2913 s = javastring_new(utf_new_char("NEW"));
2918 array_objectarray_element_set(oa, 0, s);
2921 case THREAD_STATE_RUNNABLE:
2922 oa = builtin_anewarray(1, class_java_lang_String);
2927 s = javastring_new(utf_new_char("RUNNABLE"));
2932 array_objectarray_element_set(oa, 0, s);
2935 case THREAD_STATE_BLOCKED:
2936 oa = builtin_anewarray(1, class_java_lang_String);
2941 s = javastring_new(utf_new_char("BLOCKED"));
2946 array_objectarray_element_set(oa, 0, s);
2949 case THREAD_STATE_WAITING:
2950 oa = builtin_anewarray(2, class_java_lang_String);
2955 s = javastring_new(utf_new_char("WAITING.OBJECT_WAIT"));
2956 /* s = javastring_new(utf_new_char("WAITING.PARKED")); */
2961 array_objectarray_element_set(oa, 0, s);
2962 /* array_objectarray_element_set(oa, 1, s); */
2965 case THREAD_STATE_TIMED_WAITING:
2966 oa = builtin_anewarray(3, class_java_lang_String);
2971 /* s = javastring_new(utf_new_char("TIMED_WAITING.SLEEPING")); */
2972 s = javastring_new(utf_new_char("TIMED_WAITING.OBJECT_WAIT"));
2973 /* s = javastring_new(utf_new_char("TIMED_WAITING.PARKED")); */
2978 /* array_objectarray_element_set(oa, 0, s); */
2979 array_objectarray_element_set(oa, 0, s);
2980 /* array_objectarray_element_set(oa, 2, s); */
2983 case THREAD_STATE_TERMINATED:
2984 oa = builtin_anewarray(1, class_java_lang_String);
2989 s = javastring_new(utf_new_char("TERMINATED"));
2994 array_objectarray_element_set(oa, 0, s);
2998 /* Unknown state - probably incompatible JDK version */
3002 return (jobjectArray) oa;
3006 /* JVM_GetVersionInfo */
3008 void JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size)
3010 log_println("JVM_GetVersionInfo: IMPLEMENT ME!");
3014 /* OS: JVM_RegisterSignal */
3016 void *JVM_RegisterSignal(jint sig, void *handler)
3018 functionptr newHandler;
3020 TRACEJVMCALLS("JVM_RegisterSignal(sig=%d, handler=%p)", sig, handler);
3022 if (handler == (void *) 2)
3023 newHandler = (functionptr) signal_thread_handler;
3025 newHandler = (functionptr) (uintptr_t) handler;
3032 /* These signals are already used by the VM. */
3036 /* This signal is used by the VM to dump thread stacks unless
3037 ReduceSignalUsage is set, in which case the user is allowed
3038 to set his own _native_ handler for this signal; thus, in
3039 either case, we do not allow JVM_RegisterSignal to change
3049 signal_register_signal(sig, newHandler, 0);
3051 /* XXX Should return old handler. */
3057 /* OS: JVM_RaiseSignal */
3059 jboolean JVM_RaiseSignal(jint sig)
3061 log_println("JVM_RaiseSignal: IMPLEMENT ME! sig=%s", sig);
3066 /* OS: JVM_FindSignal */
3068 jint JVM_FindSignal(const char *name)
3070 TRACEJVMCALLS("JVM_FindSignal(name=%s)", name);
3072 #if defined(__LINUX__)
3073 if (strcmp(name, "HUP") == 0)
3076 if (strcmp(name, "INT") == 0)
3079 if (strcmp(name, "TERM") == 0)
3082 # error not implemented for this OS
3090 * These are local overrides for various environment variables in Emacs.
3091 * Please do not remove this and leave it at the end of the file, where
3092 * Emacs will automagically detect them.
3093 * ---------------------------------------------------------------------
3096 * indent-tabs-mode: t