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 8331 2007-08-16 19:21:39Z 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_String.h"
83 #include "native/vm/java_lang_Thread.h"
84 #include "native/vm/java_lang_reflect_Constructor.h"
85 #include "native/vm/java_lang_reflect_Method.h"
86 #include "native/vm/java_util_concurrent_atomic_AtomicLong.h"
87 #include "native/vm/reflect.h"
89 #include "threads/lock-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/stringlocal.h"
104 #include "vm/jit/stacktrace.h"
106 #include "vmcore/classcache.h"
107 #include "vmcore/options.h"
110 /* debugging macro ************************************************************/
113 # define TRACEJVMCALLS(...) \
115 if (opt_TraceJVMCalls) { \
116 log_println(__VA_ARGS__); \
120 # define TRACEJVMCALLS(...)
125 /* Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx */
126 unsigned int jvm_version; /* Consists of major, minor, micro (n.n.n) */
127 /* and build number (xx) */
128 unsigned int update_version : 8; /* Update release version (uu) */
129 unsigned int special_update_version : 8; /* Special update release version (c) */
130 unsigned int reserved1 : 16;
131 unsigned int reserved2;
133 /* The following bits represents JVM supports that JDK has dependency on.
134 * JDK can use these bits to determine which JVM version
135 * and support it has to maintain runtime compatibility.
137 * When a new bit is added in a minor or update release, make sure
138 * the new bit is also added in the main/baseline.
140 unsigned int is_attachable : 1;
148 * A structure used to a capture exception table entry in a Java method.
155 } JVM_ExceptionTableEntryType;
158 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
160 if ((intptr_t) count <= 0)
163 return vsnprintf(str, count, fmt, args);
167 int jio_snprintf(char *str, size_t count, const char *fmt, ...)
173 len = jio_vsnprintf(str, count, fmt, ap);
180 int jio_fprintf(FILE* f, const char *fmt, ...)
182 log_println("jio_fprintf: IMPLEMENT ME!");
186 int jio_vfprintf(FILE* f, const char *fmt, va_list args)
188 log_println("jio_vfprintf: IMPLEMENT ME!");
192 int jio_printf(const char *fmt, ...)
194 log_println("jio_printf: IMPLEMENT ME!");
198 /* JVM_GetInterfaceVersion */
200 jint JVM_GetInterfaceVersion()
202 /* This is defined in hotspot/src/share/vm/prims/jvm.h */
204 #define JVM_INTERFACE_VERSION 4
206 return JVM_INTERFACE_VERSION;
210 /* JVM_CurrentTimeMillis */
212 jlong JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)
215 log_println("JVM_CurrentTimeMillis");
217 return (jlong) builtin_currenttimemillis();
223 jlong JVM_NanoTime(JNIEnv *env, jclass ignored)
226 log_println("JVM_NanoTime");
228 return (jlong) builtin_nanotime();
234 void JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos, jobject dst, jint dst_pos, jint length)
239 s = (java_handle_t *) src;
240 d = (java_handle_t *) dst;
243 log_println("JVM_ArrayCopy: src=%p, src_pos=%d, dst=%p, dst_pos=%d, length=%d", src, src_pos, dst, dst_pos, length);
246 (void) builtin_arraycopy(s, src_pos, d, dst_pos, length);
250 /* JVM_InitProperties */
252 jobject JVM_InitProperties(JNIEnv *env, jobject properties)
255 log_println("JVM_InitProperties: properties=%d", properties);
257 properties_system_add_all((java_handle_t *) properties);
263 void JVM_Exit(jint code)
265 log_println("JVM_Exit: IMPLEMENT ME!");
271 void JVM_Halt(jint code)
274 log_println("JVM_Halt: code=%d", code);
281 /* JVM_OnExit(void (*func)) */
283 void JVM_OnExit(void (*func)(void))
285 log_println("JVM_OnExit(void (*func): IMPLEMENT ME!");
293 TRACEJVMCALLS("JVM_GC()");
299 /* JVM_MaxObjectInspectionAge */
301 jlong JVM_MaxObjectInspectionAge(void)
303 log_println("JVM_MaxObjectInspectionAge: IMPLEMENT ME!");
307 /* JVM_TraceInstructions */
309 void JVM_TraceInstructions(jboolean on)
311 log_println("JVM_TraceInstructions: IMPLEMENT ME!");
315 /* JVM_TraceMethodCalls */
317 void JVM_TraceMethodCalls(jboolean on)
319 log_println("JVM_TraceMethodCalls: IMPLEMENT ME!");
323 /* JVM_TotalMemory */
325 jlong JVM_TotalMemory(void)
327 TRACEJVMCALLS("JVM_TotalMemory()");
329 return gc_get_heap_size();
335 jlong JVM_FreeMemory(void)
337 TRACEJVMCALLS("JVM_FreeMemory()");
339 return gc_get_free_bytes();
345 jlong JVM_MaxMemory(void)
347 log_println("JVM_MaxMemory: IMPLEMENT ME!");
351 /* JVM_ActiveProcessorCount */
353 jint JVM_ActiveProcessorCount(void)
355 log_println("JVM_ActiveProcessorCount: IMPLEMENT ME!");
359 /* JVM_FillInStackTrace */
361 void JVM_FillInStackTrace(JNIEnv *env, jobject receiver)
363 java_lang_Throwable *o;
364 stacktracecontainer *stc;
367 log_println("JVM_FillInStackTrace: receiver=%p", receiver);
370 o = (java_lang_Throwable *) receiver;
372 stc = stacktrace_fillInStackTrace();
377 o->backtrace = (java_lang_Object *) stc;
381 /* JVM_PrintStackTrace */
383 void JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable)
385 log_println("JVM_PrintStackTrace: IMPLEMENT ME!");
389 /* JVM_GetStackTraceDepth */
391 jint JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable)
393 java_lang_Throwable *o;
394 stacktracecontainer *stc;
395 stacktracebuffer *stb;
398 log_println("JVM_GetStackTraceDepth: throwable=%p", throwable);
401 o = (java_lang_Throwable *) throwable;
402 stc = (stacktracecontainer *) o->backtrace;
409 /* JVM_GetStackTraceElement */
411 jobject JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index)
413 java_lang_Throwable *t;
414 stacktracecontainer *stc;
415 stacktracebuffer *stb;
416 stacktrace_entry *ste;
417 java_lang_StackTraceElement *o;
418 java_lang_String *declaringclass;
419 java_lang_String *filename;
423 log_println("JVM_GetStackTraceElement: throwable=%p, index=%d", throwable, index);
426 t = (java_lang_Throwable *) throwable;
427 stc = (stacktracecontainer *) t->backtrace;
430 if ((index < 0) || (index >= stb->used)) {
431 /* XXX This should be an IndexOutOfBoundsException (check this
434 exceptions_throw_arrayindexoutofboundsexception();
438 ste = &(stb->entries[index]);
440 /* allocate a new StackTraceElement */
442 o = (java_lang_StackTraceElement *)
443 builtin_new(class_java_lang_StackTraceElement);
450 if (!(ste->method->flags & ACC_NATIVE)) {
451 if (ste->method->class->sourcefile)
452 filename = (java_lang_String *) javastring_new(ste->method->class->sourcefile);
459 /* get line number */
461 if (ste->method->flags & ACC_NATIVE)
464 linenumber = (ste->linenumber == 0) ? -1 : ste->linenumber;
466 /* get declaring class name */
469 _Jv_java_lang_Class_getName((java_lang_Class *) ste->method->class);
471 /* fill the java.lang.StackTraceElement element */
473 o->declaringClass = declaringclass;
474 o->methodName = (java_lang_String *) javastring_new(ste->method->name);
475 o->fileName = filename;
476 o->lineNumber = linenumber;
484 jint JVM_IHashCode(JNIEnv* env, jobject handle)
487 log_println("JVM_IHashCode: jobject=%p", handle);
489 return (jint) ((ptrint) handle);
493 /* JVM_MonitorWait */
495 void JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms)
498 log_println("JVM_MonitorWait: handle=%p, ms=%ld", handle, ms);
500 _Jv_java_lang_Object_wait((java_lang_Object *) handle, ms, 0);
504 /* JVM_MonitorNotify */
506 void JVM_MonitorNotify(JNIEnv* env, jobject handle)
509 log_println("JVM_MonitorNotify: IMPLEMENT ME!");
511 _Jv_java_lang_Object_notify((java_lang_Object *) handle);
515 /* JVM_MonitorNotifyAll */
517 void JVM_MonitorNotifyAll(JNIEnv* env, jobject handle)
520 log_println("JVM_MonitorNotifyAll: handle=%p", handle);
522 _Jv_java_lang_Object_notifyAll((java_lang_Object *) handle);
528 jobject JVM_Clone(JNIEnv* env, jobject handle)
531 log_println("JVM_Clone: handle=%p", handle);
533 return (jobject) builtin_clone(env, (java_handle_t *) handle);
537 /* JVM_InitializeCompiler */
539 void JVM_InitializeCompiler (JNIEnv *env, jclass compCls)
541 log_println("JVM_InitializeCompiler : IMPLEMENT ME!");
545 /* JVM_IsSilentCompiler */
547 jboolean JVM_IsSilentCompiler(JNIEnv *env, jclass compCls)
549 log_println("JVM_IsSilentCompiler: IMPLEMENT ME!");
553 /* JVM_CompileClass */
555 jboolean JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls)
557 log_println("JVM_CompileClass: IMPLEMENT ME!");
561 /* JVM_CompileClasses */
563 jboolean JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname)
565 log_println("JVM_CompileClasses: IMPLEMENT ME!");
569 /* JVM_CompilerCommand */
571 jobject JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg)
573 log_println("JVM_CompilerCommand: IMPLEMENT ME!");
577 /* JVM_EnableCompiler */
579 void JVM_EnableCompiler(JNIEnv *env, jclass compCls)
581 log_println("JVM_EnableCompiler: IMPLEMENT ME!");
585 /* JVM_DisableCompiler */
587 void JVM_DisableCompiler(JNIEnv *env, jclass compCls)
589 log_println("JVM_DisableCompiler: IMPLEMENT ME!");
593 /* JVM_GetLastErrorString */
595 jint JVM_GetLastErrorString(char *buf, int len)
621 char* JVM_NativePath(char* path)
624 log_println("JVM_NativePath: path=%s", path);
626 /* XXX is this correct? */
632 /* JVM_GetCallerClass */
634 jclass JVM_GetCallerClass(JNIEnv* env, int depth)
636 java_handle_objectarray_t *oa;
639 log_println("JVM_GetCallerClass: depth=%d", depth);
642 oa = stacktrace_getClassContext();
647 if (oa->header.size < depth)
650 return (jclass) oa->data[depth - 1];
655 /* JVM_FindPrimitiveClass */
657 jclass JVM_FindPrimitiveClass(JNIEnv* env, const char* s)
662 TRACEJVMCALLS("JVM_FindPrimitiveClass(env=%p, s=%s)", env, s);
665 c = primitive_class_get_by_name(u);
671 /* JVM_ResolveClass */
673 void JVM_ResolveClass(JNIEnv* env, jclass cls)
675 log_println("JVM_ResolveClass: IMPLEMENT ME!");
679 /* JVM_FindClassFromClassLoader */
681 jclass JVM_FindClassFromClassLoader(JNIEnv* env, const char* name, jboolean init, jobject loader, jboolean throwError)
686 log_println("JVM_FindClassFromClassLoader: name=%s, init=%d, loader=%p, throwError=%d", name, init, loader, throwError);
689 c = load_class_from_classloader(utf_new_char(name), (classloader *) loader);
695 if (!(c->state & CLASS_INITIALIZED))
696 if (!initialize_class(c))
703 /* JVM_FindClassFromClass */
705 jclass JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init, jclass from)
707 log_println("JVM_FindClassFromClass: IMPLEMENT ME!");
711 /* JVM_DefineClass */
713 jclass JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)
715 log_println("JVM_DefineClass: IMPLEMENT ME!");
719 /* JVM_DefineClassWithSource */
721 jclass JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)
724 log_println("JVM_DefineClassWithSource: name=%s, loader=%p, buf=%p, len=%d, pd=%p, source=%s", name, loader, buf, len, pd, source);
726 /* XXX do something with pd and source */
728 return (jclass) class_define(utf_new_char(name), (classloader *) loader, len, (u1 *) buf);
733 /* JVM_FindLoadedClass */
735 jclass JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name)
741 cl = (classloader *) loader;
744 log_println("JVM_FindLoadedClass(loader=%p, name=%p)", loader, name);
747 u = javastring_toutf((java_handle_t *) name, true);
748 c = classcache_lookup(cl, u);
754 /* JVM_GetClassName */
756 jstring JVM_GetClassName(JNIEnv *env, jclass cls)
759 log_println("JVM_GetClassName: cls=%p", cls);
761 return (jstring) _Jv_java_lang_Class_getName((java_lang_Class *) cls);
765 /* JVM_GetClassInterfaces */
767 jobjectArray JVM_GetClassInterfaces(JNIEnv *env, jclass cls)
770 java_handle_objectarray_t *oa;
772 TRACEJVMCALLS("JVM_GetClassInterfaces(env=%p, cls=%p)", env, cls);
774 c = (classinfo *) cls;
776 oa = class_get_interfaces(c);
778 return (jobjectArray) oa;
782 /* JVM_GetClassLoader */
784 jobject JVM_GetClassLoader(JNIEnv *env, jclass cls)
787 log_println("JVM_GetClassLoader: cls=%p", cls);
789 return (jobject) _Jv_java_lang_Class_getClassLoader((java_lang_Class *) cls);
793 /* JVM_IsInterface */
795 jboolean JVM_IsInterface(JNIEnv *env, jclass cls)
800 log_println("JVM_IsInterface: cls=%p", cls);
803 c = (classinfo *) cls;
805 return class_is_interface(c);
809 /* JVM_GetClassSigners */
811 jobjectArray JVM_GetClassSigners(JNIEnv *env, jclass cls)
813 log_println("JVM_GetClassSigners: IMPLEMENT ME!");
817 /* JVM_SetClassSigners */
819 void JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers)
821 log_println("JVM_SetClassSigners: IMPLEMENT ME!");
825 /* JVM_GetProtectionDomain */
827 jobject JVM_GetProtectionDomain(JNIEnv *env, jclass cls)
832 log_println("JVM_GetProtectionDomain: cls=%p");
835 c = (classinfo *) cls;
838 exceptions_throw_nullpointerexception();
842 /* Primitive types do not have a protection domain. */
844 if (class_is_primitive(c))
849 /* JVM_SetProtectionDomain */
851 void JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain)
853 log_println("JVM_SetProtectionDomain: IMPLEMENT ME!");
857 /* JVM_DoPrivileged */
859 jobject JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, jobject context, jboolean wrapException)
864 java_handle_t *result;
868 log_println("JVM_DoPrivileged: action=%p, context=%p, wrapException=%d", action, context, wrapException);
871 o = (java_handle_t *) action;
874 if (action == NULL) {
875 exceptions_throw_nullpointerexception();
879 /* lookup run() method (throw no exceptions) */
881 m = class_resolveclassmethod(c, utf_run, utf_void__java_lang_Object, c,
884 if ((m == NULL) || !(m->flags & ACC_PUBLIC) || (m->flags & ACC_STATIC)) {
885 exceptions_throw_internalerror("No run method");
889 /* XXX It seems something with a privileged stack needs to be done
892 result = vm_call_method(m, o);
894 e = exceptions_get_and_clear_exception();
897 exceptions_throw_privilegedactionexception(e);
901 return (jobject) result;
905 /* JVM_GetInheritedAccessControlContext */
907 jobject JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls)
909 log_println("JVM_GetInheritedAccessControlContext: IMPLEMENT ME!");
913 /* JVM_GetStackAccessControlContext */
915 jobject JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls)
917 log_println("JVM_GetStackAccessControlContext: IMPLEMENT ME!");
921 /* JVM_IsArrayClass */
923 jboolean JVM_IsArrayClass(JNIEnv *env, jclass cls)
926 log_println("JVM_IsArrayClass: cls=%p", cls);
928 return class_is_array((classinfo *) cls);
932 /* JVM_IsPrimitiveClass */
934 jboolean JVM_IsPrimitiveClass(JNIEnv *env, jclass cls)
938 c = (classinfo *) cls;
941 log_println("JVM_IsPrimitiveClass(cls=%p)", cls);
944 return class_is_primitive(c);
948 /* JVM_GetComponentType */
950 jclass JVM_GetComponentType(JNIEnv *env, jclass cls)
952 classinfo *component;
955 TRACEJVMCALLS("JVM_GetComponentType(env=%p, cls=%p)", env, cls);
957 c = (classinfo *) cls;
959 component = class_get_componenttype(c);
961 return (jclass) component;
965 /* JVM_GetClassModifiers */
967 jint JVM_GetClassModifiers(JNIEnv *env, jclass cls)
972 log_println("JVM_GetClassModifiers: cls=%p", cls);
975 c = (classinfo *) cls;
977 /* XXX is this correct? */
979 return c->flags & ACC_CLASS_REFLECT_MASK;
983 /* JVM_GetDeclaredClasses */
985 jobjectArray JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)
988 java_handle_objectarray_t *oa;
990 TRACEJVMCALLS("JVM_GetDeclaredClasses(env=%p, ofClass=%p)", env, ofClass);
992 c = (classinfo *) ofClass;
994 oa = class_get_declaredclasses(c, false);
996 return (jobjectArray) oa;
1000 /* JVM_GetDeclaringClass */
1002 jclass JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass)
1004 classinfo *c = (classinfo*)ofClass;
1006 TRACEJVMCALLS("JVM_GetDeclaringClass: ofClass=%p", ofClass);
1009 exceptions_throw_nullpointerexception();
1013 return (jclass)class_get_declaringclass(c);
1017 /* JVM_GetClassSignature */
1019 jstring JVM_GetClassSignature(JNIEnv *env, jclass cls)
1021 log_println("JVM_GetClassSignature: IMPLEMENT ME!");
1025 /* JVM_GetClassAnnotations */
1027 jbyteArray JVM_GetClassAnnotations(JNIEnv *env, jclass cls)
1029 #if defined(ENABLE_ANNOTATIONS)
1030 classinfo *c = (classinfo*)cls;
1031 java_handle_bytearray_t *annotations = NULL;
1033 TRACEJVMCALLS("JVM_GetClassAnnotations: cls=%p", cls);
1036 exceptions_throw_nullpointerexception();
1040 /* Return null for arrays and primitives: */
1041 if(class_is_primitive(c) || class_is_array(c))
1046 if(c->annotations != NULL)
1048 uint32_t size = c->annotations->size;
1049 annotations = builtin_newarray_byte(size);
1051 if(annotations != NULL)
1053 MCOPY(annotations->data, c->annotations->data, uint8_t, size);
1057 return (jbyteArray)annotations;
1059 log_println("JVM_GetClassAnnotations: cls=%p, not implemented in this configuration!", cls);
1065 /* JVM_GetFieldAnnotations */
1067 jbyteArray JVM_GetFieldAnnotations(JNIEnv *env, jobject field)
1069 java_lang_reflect_Field *rf = (java_lang_reflect_Field*)field;
1070 java_handle_bytearray_t *ba = NULL;
1072 TRACEJVMCALLS("JVM_GetFieldAnnotations: field=%p", field);
1074 if (field == NULL) {
1075 exceptions_throw_nullpointerexception();
1079 LLNI_field_get_ref(rf, annotations, ba);
1081 return (jbyteArray)ba;
1085 /* JVM_GetMethodAnnotations */
1087 jbyteArray JVM_GetMethodAnnotations(JNIEnv *env, jobject method)
1089 java_lang_reflect_Method *rm = (java_lang_reflect_Method*)method;
1090 java_handle_bytearray_t *ba = NULL;
1092 TRACEJVMCALLS("JVM_GetMethodAnnotations: method=%p", method);
1094 if (method == NULL) {
1095 exceptions_throw_nullpointerexception();
1099 LLNI_field_get_ref(rm, annotations, ba);
1101 return (jbyteArray)ba;
1105 /* JVM_GetMethodDefaultAnnotationValue */
1107 jbyteArray JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method)
1109 java_lang_reflect_Method *rm = (java_lang_reflect_Method*)method;
1110 java_handle_bytearray_t *ba = NULL;
1112 TRACEJVMCALLS("JVM_GetMethodDefaultAnnotationValue: method=%p", method);
1114 if (method == NULL) {
1115 exceptions_throw_nullpointerexception();
1119 LLNI_field_get_ref(rm, annotationDefault, ba);
1121 return (jbyteArray)ba;
1125 /* JVM_GetMethodParameterAnnotations */
1127 jbyteArray JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method)
1129 java_lang_reflect_Method *rm = (java_lang_reflect_Method*)method;
1130 java_handle_bytearray_t *ba = NULL;
1132 TRACEJVMCALLS("JVM_GetMethodParameterAnnotations: method=%p", method);
1134 if (method == NULL) {
1135 exceptions_throw_nullpointerexception();
1139 LLNI_field_get_ref(rm, parameterAnnotations, ba);
1141 return (jbyteArray)ba;
1145 /* JVM_GetClassDeclaredFields */
1147 jobjectArray JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1150 log_println("JVM_GetClassDeclaredFields: ofClass=%p, publicOnly=%d", ofClass, publicOnly);
1152 return (jobjectArray) _Jv_java_lang_Class_getDeclaredFields((java_lang_Class *) ofClass, publicOnly);
1156 /* JVM_GetClassDeclaredMethods */
1158 jobjectArray JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1161 log_println("JVM_GetClassDeclaredMethods: ofClass=%p, publicOnly=%d", ofClass, publicOnly);
1163 return (jobjectArray) _Jv_java_lang_Class_getDeclaredMethods((java_lang_Class *) ofClass, publicOnly);
1167 /* JVM_GetClassDeclaredConstructors */
1169 jobjectArray JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1172 log_println("JVM_GetClassDeclaredConstructors: ofClass=%p, publicOnly=%d", ofClass, publicOnly);
1174 return (jobjectArray) _Jv_java_lang_Class_getDeclaredConstructors((java_lang_Class *) ofClass, publicOnly);
1178 /* JVM_GetClassAccessFlags */
1180 jint JVM_GetClassAccessFlags(JNIEnv *env, jclass cls)
1185 log_println("JVM_GetClassAccessFlags: cls=%p", cls);
1188 c = (classinfo *) cls;
1190 return c->flags & ACC_CLASS_REFLECT_MASK;
1194 /* JVM_GetClassConstantPool */
1196 jobject JVM_GetClassConstantPool(JNIEnv *env, jclass cls)
1198 #if defined(ENABLE_ANNOTATIONS)
1199 sun_reflect_ConstantPool *constantPool = NULL;
1200 java_lang_Object *constantPoolOop = (java_lang_Object*)cls;
1202 TRACEJVMCALLS("JVM_GetClassConstantPool: cls=%p", cls);
1204 assert(cls != NULL);
1207 (sun_reflect_ConstantPool*)native_new_and_init(
1208 class_sun_reflect_ConstantPool);
1210 if (constantPool == NULL) {
1215 LLNI_field_set_ref(constantPool, constantPoolOop, constantPoolOop);
1217 return (jobject)constantPool;
1219 log_println("JVM_GetClassConstantPool: cls=%p, not implemented in this configuration!", cls);
1225 /* JVM_ConstantPoolGetSize */
1227 jint JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool)
1229 classinfo *cls = (classinfo*)jcpool;
1230 TRACEJVMCALLS("JVM_ConstantPoolGetSize: jcpool=%p", jcpool);
1231 return cls->cpcount;
1235 /* JVM_ConstantPoolGetClassAt */
1237 jclass JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1239 constant_classref *ref;
1240 classinfo *cls = (classinfo*)jcpool;
1242 TRACEJVMCALLS("JVM_ConstantPoolGetClassAt: jcpool=%p, index=%d", jcpool, index);
1244 ref = (constant_classref*)class_getconstant(cls, index, CONSTANT_Class);
1250 return (jclass)resolve_classref_eager(ref);
1254 /* JVM_ConstantPoolGetClassAtIfLoaded */
1256 jclass JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1258 constant_classref *ref;
1259 classinfo *c = NULL;
1260 classinfo *cls = (classinfo*)jcpool;
1262 TRACEJVMCALLS("JVM_ConstantPoolGetClassAtIfLoaded: jcpool=%p, index=%d", jcpool, index);
1264 ref = (constant_classref*)class_getconstant(cls, index, CONSTANT_Class);
1270 if (!resolve_classref(NULL, ref, resolveLazy, true, true, &c)) {
1274 if (c == NULL || !(c->state & CLASS_LOADED)) {
1282 /* JVM_ConstantPoolGetMethodAt */
1284 jobject JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1286 constant_FMIref *ref;
1287 classinfo *cls = (classinfo*)jcpool;
1289 TRACEJVMCALLS("JVM_ConstantPoolGetMethodAt: jcpool=%p, index=%d", jcpool, index);
1291 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1297 /* XXX: is that right? or do I have to use resolve_method_*? */
1298 return (jobject)reflect_method_new(ref->p.method);
1302 /* JVM_ConstantPoolGetMethodAtIfLoaded */
1304 jobject JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1306 constant_FMIref *ref;
1307 classinfo *c = NULL;
1308 classinfo *cls = (classinfo*)jcpool;
1310 TRACEJVMCALLS("JVM_ConstantPoolGetMethodAtIfLoaded: jcpool=%p, index=%d", jcpool, index);
1312 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1318 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1322 if (c == NULL || !(c->state & CLASS_LOADED)) {
1326 return (jobject)reflect_method_new(ref->p.method);
1330 /* JVM_ConstantPoolGetFieldAt */
1332 jobject JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1334 constant_FMIref *ref;
1335 classinfo *cls = (classinfo*)jcpool;
1337 TRACEJVMCALLS("JVM_ConstantPoolGetFieldAt: jcpool=%p, index=%d", jcpool, index);
1339 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1345 return (jobject)reflect_field_new(ref->p.field);
1349 /* JVM_ConstantPoolGetFieldAtIfLoaded */
1351 jobject JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1353 constant_FMIref *ref;
1355 classinfo *cls = (classinfo*)jcpool;
1357 TRACEJVMCALLS("JVM_ConstantPoolGetFieldAtIfLoaded: jcpool=%p, index=%d", jcpool, index);
1359 ref = (constant_FMIref*)class_getconstant(
1360 (classinfo*)cls, index, CONSTANT_Fieldref);
1366 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1370 if (c == NULL || !(c->state & CLASS_LOADED)) {
1374 return (jobject)reflect_field_new(ref->p.field);
1378 /* JVM_ConstantPoolGetMemberRefInfoAt */
1380 jobjectArray JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1382 log_println("JVM_ConstantPoolGetMemberRefInfoAt: jcpool=%p, index=%d, IMPLEMENT ME!", jcpool, index);
1387 /* JVM_ConstantPoolGetIntAt */
1389 jint JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1391 constant_integer *ref;
1392 classinfo *cls = (classinfo*)jcpool;
1394 TRACEJVMCALLS("JVM_ConstantPoolGetIntAt: jcpool=%p, index=%d", jcpool, index);
1396 ref = (constant_integer*)class_getconstant(cls, index, CONSTANT_Integer);
1406 /* JVM_ConstantPoolGetLongAt */
1408 jlong JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1411 classinfo *cls = (classinfo*)jcpool;
1413 TRACEJVMCALLS("JVM_ConstantPoolGetLongAt: jcpool=%p, index=%d", jcpool, index);
1415 ref = (constant_long*)class_getconstant(cls, index, CONSTANT_Long);
1425 /* JVM_ConstantPoolGetFloatAt */
1427 jfloat JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1429 constant_float *ref;
1430 classinfo *cls = (classinfo*)jcpool;
1432 TRACEJVMCALLS("JVM_ConstantPoolGetFloatAt: jcpool=%p, index=%d", jcpool, index);
1434 ref = (constant_float*)class_getconstant(cls, index, CONSTANT_Float);
1444 /* JVM_ConstantPoolGetDoubleAt */
1446 jdouble JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1448 constant_double *ref;
1449 classinfo *cls = (classinfo*)jcpool;
1451 TRACEJVMCALLS("JVM_ConstantPoolGetDoubleAt: jcpool=%p, index=%d", jcpool, index);
1453 ref = (constant_double*)class_getconstant(cls, index, CONSTANT_Double);
1463 /* JVM_ConstantPoolGetStringAt */
1465 jstring JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1468 classinfo *cls = (classinfo*)jcpool;
1470 TRACEJVMCALLS("JVM_ConstantPoolGetStringAt: jcpool=%p, index=%d", jcpool, index);
1472 ref = (utf*)class_getconstant(cls, index, CONSTANT_String);
1478 /* XXX: I hope literalstring_new is the right Function. */
1479 return (jstring)literalstring_new(ref);
1483 /* JVM_ConstantPoolGetUTF8At */
1485 jstring JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1488 classinfo *cls = (classinfo*)jcpool;
1490 TRACEJVMCALLS("JVM_ConstantPoolGetUTF8At: jcpool=%p, index=%d", jcpool, index);
1492 ref = (utf*)class_getconstant(cls, index, CONSTANT_Utf8);
1498 /* XXX: I hope literalstring_new is the right Function. */
1499 return (jstring)literalstring_new(ref);
1503 /* JVM_DesiredAssertionStatus */
1505 jboolean JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls)
1507 log_println("JVM_DesiredAssertionStatus: cls=%p, IMPLEMENT ME!", cls);
1513 /* JVM_AssertionStatusDirectives */
1515 jobject JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)
1518 java_lang_AssertionStatusDirectives *o;
1519 java_handle_objectarray_t *classes;
1520 java_handle_objectarray_t *packages;
1523 log_println("JVM_AssertionStatusDirectives");
1525 /* XXX this is not completely implemented */
1527 c = load_class_bootstrap(utf_new_char("java/lang/AssertionStatusDirectives"));
1532 o = (java_lang_AssertionStatusDirectives *) builtin_new(c);
1537 classes = builtin_anewarray(0, class_java_lang_Object);
1539 if (classes == NULL)
1542 packages = builtin_anewarray(0, class_java_lang_Object);
1544 if (packages == NULL)
1547 /* set instance fields */
1549 o->classes = classes;
1550 o->packages = packages;
1556 /* JVM_GetClassNameUTF */
1558 const char* JVM_GetClassNameUTF(JNIEnv *env, jclass cls)
1560 log_println("JVM_GetClassNameUTF: IMPLEMENT ME!");
1564 /* JVM_GetClassCPTypes */
1566 void JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types)
1568 log_println("JVM_GetClassCPTypes: IMPLEMENT ME!");
1572 /* JVM_GetClassCPEntriesCount */
1574 jint JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)
1576 log_println("JVM_GetClassCPEntriesCount: IMPLEMENT ME!");
1580 /* JVM_GetClassFieldsCount */
1582 jint JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)
1584 log_println("JVM_GetClassFieldsCount: IMPLEMENT ME!");
1588 /* JVM_GetClassMethodsCount */
1590 jint JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)
1592 log_println("JVM_GetClassMethodsCount: IMPLEMENT ME!");
1596 /* JVM_GetMethodIxExceptionIndexes */
1598 void JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions)
1600 log_println("JVM_GetMethodIxExceptionIndexes: IMPLEMENT ME!");
1604 /* JVM_GetMethodIxExceptionsCount */
1606 jint JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)
1608 log_println("JVM_GetMethodIxExceptionsCount: IMPLEMENT ME!");
1612 /* JVM_GetMethodIxByteCode */
1614 void JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code)
1616 log_println("JVM_GetMethodIxByteCode: IMPLEMENT ME!");
1620 /* JVM_GetMethodIxByteCodeLength */
1622 jint JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)
1624 log_println("JVM_GetMethodIxByteCodeLength: IMPLEMENT ME!");
1628 /* JVM_GetMethodIxExceptionTableEntry */
1630 void JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry)
1632 log_println("JVM_GetMethodIxExceptionTableEntry: IMPLEMENT ME!");
1636 /* JVM_GetMethodIxExceptionTableLength */
1638 jint JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)
1640 log_println("JVM_GetMethodIxExceptionTableLength: IMPLEMENT ME!");
1644 /* JVM_GetMethodIxModifiers */
1646 jint JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)
1648 log_println("JVM_GetMethodIxModifiers: IMPLEMENT ME!");
1652 /* JVM_GetFieldIxModifiers */
1654 jint JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)
1656 log_println("JVM_GetFieldIxModifiers: IMPLEMENT ME!");
1660 /* JVM_GetMethodIxLocalsCount */
1662 jint JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)
1664 log_println("JVM_GetMethodIxLocalsCount: IMPLEMENT ME!");
1668 /* JVM_GetMethodIxArgsSize */
1670 jint JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)
1672 log_println("JVM_GetMethodIxArgsSize: IMPLEMENT ME!");
1676 /* JVM_GetMethodIxMaxStack */
1678 jint JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)
1680 log_println("JVM_GetMethodIxMaxStack: IMPLEMENT ME!");
1684 /* JVM_IsConstructorIx */
1686 jboolean JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)
1688 log_println("JVM_IsConstructorIx: IMPLEMENT ME!");
1692 /* JVM_GetMethodIxNameUTF */
1694 const char* JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)
1696 log_println("JVM_GetMethodIxNameUTF: IMPLEMENT ME!");
1700 /* JVM_GetMethodIxSignatureUTF */
1702 const char* JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)
1704 log_println("JVM_GetMethodIxSignatureUTF: IMPLEMENT ME!");
1708 /* JVM_GetCPFieldNameUTF */
1710 const char* JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1712 log_println("JVM_GetCPFieldNameUTF: IMPLEMENT ME!");
1716 /* JVM_GetCPMethodNameUTF */
1718 const char* JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1720 log_println("JVM_GetCPMethodNameUTF: IMPLEMENT ME!");
1724 /* JVM_GetCPMethodSignatureUTF */
1726 const char* JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
1728 log_println("JVM_GetCPMethodSignatureUTF: IMPLEMENT ME!");
1732 /* JVM_GetCPFieldSignatureUTF */
1734 const char* JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
1736 log_println("JVM_GetCPFieldSignatureUTF: IMPLEMENT ME!");
1740 /* JVM_GetCPClassNameUTF */
1742 const char* JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1744 log_println("JVM_GetCPClassNameUTF: IMPLEMENT ME!");
1748 /* JVM_GetCPFieldClassNameUTF */
1750 const char* JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1752 log_println("JVM_GetCPFieldClassNameUTF: IMPLEMENT ME!");
1756 /* JVM_GetCPMethodClassNameUTF */
1758 const char* JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1760 log_println("JVM_GetCPMethodClassNameUTF: IMPLEMENT ME!");
1764 /* JVM_GetCPFieldModifiers */
1766 jint JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
1768 log_println("JVM_GetCPFieldModifiers: IMPLEMENT ME!");
1772 /* JVM_GetCPMethodModifiers */
1774 jint JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
1776 log_println("JVM_GetCPMethodModifiers: IMPLEMENT ME!");
1780 /* JVM_ReleaseUTF */
1782 void JVM_ReleaseUTF(const char *utf)
1784 log_println("JVM_ReleaseUTF: IMPLEMENT ME!");
1788 /* JVM_IsSameClassPackage */
1790 jboolean JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2)
1792 log_println("JVM_IsSameClassPackage: IMPLEMENT ME!");
1798 jint JVM_Open(const char *fname, jint flags, jint mode)
1803 log_println("JVM_Open: fname=%s, flags=%d, mode=%d", fname, flags, mode);
1806 result = open(fname, flags, mode);
1814 /* XXX don't know what to do here */
1815 /* return JVM_EEXIST; */
1826 jint JVM_Close(jint fd)
1829 log_println("JVM_Close: fd=%d", fd);
1837 jint JVM_Read(jint fd, char *buf, jint nbytes)
1840 log_println("JVM_Read: fd=%d, buf=%p, nbytes=%d", fd, buf, nbytes);
1842 return read(fd, buf, nbytes);
1848 jint JVM_Write(jint fd, char *buf, jint nbytes)
1851 log_println("JVM_Write: fd=%d, buf=%s, nbytes=%d", fd, buf, nbytes);
1853 return write(fd, buf, nbytes);
1859 jint JVM_Available(jint fd, jlong *pbytes)
1861 TRACEJVMCALLS("JVM_Available(fd=%d, pbytes=%p)", fd, pbytes);
1863 #if defined(FIONREAD)
1866 if (ioctl(fd, FIONREAD, &bytes) < 0)
1872 #elif defined(HAVE_FSTAT)
1873 struct stat statBuffer;
1879 if ((fstat(fd, &statBuffer) == 0) && S_ISREG (statBuffer.st_mode)) {
1880 n = lseek (fd, 0, SEEK_CUR);
1883 *pbytes = statBuffer.st_size - n;
1895 #elif defined(HAVE_SELECT)
1896 fd_set filedescriptset;
1902 FD_ZERO(&filedescriptset);
1903 FD_SET(fd, &filedescriptset);
1904 memset(&tv, 0, sizeof(tv));
1906 switch (select(fd+1, &filedescriptset, NULL, NULL, &tv))
1913 result = CPNATIVE_OK;
1917 result = CPNATIVE_OK;
1930 jlong JVM_Lseek(jint fd, jlong offset, jint whence)
1933 log_println("JVM_Lseek: fd=%d, offset=%ld, whence=%d", fd, offset, whence);
1935 return (jlong) lseek(fd, (off_t) offset, whence);
1941 jint JVM_SetLength(jint fd, jlong length)
1943 log_println("JVM_SetLength: IMPLEMENT ME!");
1949 jint JVM_Sync(jint fd)
1951 log_println("JVM_Sync: IMPLEMENT ME!");
1955 /* JVM_StartThread */
1957 void JVM_StartThread(JNIEnv* env, jobject jthread)
1960 log_println("JVM_StartThread: jthread=%p", jthread);
1962 _Jv_java_lang_Thread_start((java_lang_Thread *) jthread, 0);
1966 /* JVM_StopThread */
1968 void JVM_StopThread(JNIEnv* env, jobject jthread, jobject throwable)
1970 log_println("JVM_StopThread: IMPLEMENT ME!");
1974 /* JVM_IsThreadAlive */
1976 jboolean JVM_IsThreadAlive(JNIEnv* env, jobject jthread)
1979 log_println("JVM_IsThreadAlive: jthread=%p", jthread);
1981 return _Jv_java_lang_Thread_isAlive((java_lang_Thread *) jthread);
1985 /* JVM_SuspendThread */
1987 void JVM_SuspendThread(JNIEnv* env, jobject jthread)
1989 log_println("JVM_SuspendThread: IMPLEMENT ME!");
1993 /* JVM_ResumeThread */
1995 void JVM_ResumeThread(JNIEnv* env, jobject jthread)
1997 log_println("JVM_ResumeThread: IMPLEMENT ME!");
2001 /* JVM_SetThreadPriority */
2003 void JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio)
2006 log_println("JVM_SetThreadPriority: jthread=%p, prio=%d", jthread, prio);
2008 _Jv_java_lang_Thread_setPriority((java_lang_Thread *) jthread, prio);
2014 void JVM_Yield(JNIEnv *env, jclass threadClass)
2016 log_println("JVM_Yield: IMPLEMENT ME!");
2022 void JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis)
2025 log_println("JVM_Sleep: threadClass=%p, millis=%ld", threadClass, millis);
2027 _Jv_java_lang_Thread_sleep(millis);
2031 /* JVM_CurrentThread */
2033 jobject JVM_CurrentThread(JNIEnv* env, jclass threadClass)
2036 log_println("JVM_CurrentThread: threadClass=%p", threadClass);
2038 return (jobject) _Jv_java_lang_Thread_currentThread();
2042 /* JVM_CountStackFrames */
2044 jint JVM_CountStackFrames(JNIEnv* env, jobject jthread)
2046 log_println("JVM_CountStackFrames: IMPLEMENT ME!");
2052 void JVM_Interrupt(JNIEnv* env, jobject jthread)
2054 log_println("JVM_Interrupt: IMPLEMENT ME!");
2058 /* JVM_IsInterrupted */
2060 jboolean JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted)
2063 log_println("JVM_IsInterrupted: jthread=%p, clear_interrupted=%d", jthread, clear_interrupted);
2065 /* XXX do something with clear_interrupted */
2066 return _Jv_java_lang_Thread_isInterrupted((java_lang_Thread *) jthread);
2072 jboolean JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj)
2074 log_println("JVM_HoldsLock: IMPLEMENT ME!");
2078 /* JVM_DumpAllStacks */
2080 void JVM_DumpAllStacks(JNIEnv* env, jclass unused)
2082 log_println("JVM_DumpAllStacks: IMPLEMENT ME!");
2086 /* JVM_CurrentLoadedClass */
2088 jclass JVM_CurrentLoadedClass(JNIEnv *env)
2090 log_println("JVM_CurrentLoadedClass: IMPLEMENT ME!");
2094 /* JVM_CurrentClassLoader */
2096 jobject JVM_CurrentClassLoader(JNIEnv *env)
2098 log_println("JVM_CurrentClassLoader: IMPLEMENT ME!");
2102 /* JVM_GetClassContext */
2104 jobjectArray JVM_GetClassContext(JNIEnv *env)
2107 log_println("JVM_GetClassContext");
2109 return (jobjectArray) stacktrace_getClassContext();
2113 /* JVM_ClassDepth */
2115 jint JVM_ClassDepth(JNIEnv *env, jstring name)
2117 log_println("JVM_ClassDepth: IMPLEMENT ME!");
2121 /* JVM_ClassLoaderDepth */
2123 jint JVM_ClassLoaderDepth(JNIEnv *env)
2125 log_println("JVM_ClassLoaderDepth: IMPLEMENT ME!");
2129 /* JVM_GetSystemPackage */
2131 jstring JVM_GetSystemPackage(JNIEnv *env, jstring name)
2133 log_println("JVM_GetSystemPackage: IMPLEMENT ME!");
2137 /* JVM_GetSystemPackages */
2139 jobjectArray JVM_GetSystemPackages(JNIEnv *env)
2141 log_println("JVM_GetSystemPackages: IMPLEMENT ME!");
2145 /* JVM_AllocateNewObject */
2147 jobject JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass)
2149 log_println("JVM_AllocateNewObject: IMPLEMENT ME!");
2153 /* JVM_AllocateNewArray */
2155 jobject JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length)
2157 log_println("JVM_AllocateNewArray: IMPLEMENT ME!");
2161 /* JVM_LatestUserDefinedLoader */
2163 jobject JVM_LatestUserDefinedLoader(JNIEnv *env)
2165 log_println("JVM_LatestUserDefinedLoader: IMPLEMENT ME!");
2169 /* JVM_LoadClass0 */
2171 jclass JVM_LoadClass0(JNIEnv *env, jobject receiver, jclass currClass, jstring currClassName)
2173 log_println("JVM_LoadClass0: IMPLEMENT ME!");
2177 /* JVM_GetArrayLength */
2179 jint JVM_GetArrayLength(JNIEnv *env, jobject arr)
2183 TRACEJVMCALLS("JVM_GetArrayLength(arr=%p)", arr);
2185 a = (java_array_t *) arr;
2188 exceptions_throw_nullpointerexception();
2192 if (!class_is_array(a->objheader.vftbl->class)) {
2193 /* exceptions_throw_illegalargumentexception("Argument is not an array"); */
2194 exceptions_throw_illegalargumentexception();
2202 /* JVM_GetArrayElement */
2204 jobject JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index)
2209 TRACEJVMCALLS("JVM_GetArrayElement(env=%p, arr=%p, index=%d)", env, arr, index);
2211 a = (java_array_t *) arr;
2214 exceptions_throw_nullpointerexception();
2218 if (!class_is_array(a->objheader.vftbl->class)) {
2219 exceptions_throw_illegalargumentexception();
2223 if (index < 0 || index > a->size) {
2224 exceptions_new_arrayindexoutofboundsexception(index);
2228 elementtype = a->objheader.vftbl->arraydesc->elementtype;
2230 switch (elementtype) {
2232 return (jobject)primitive_box_int(((java_handle_intarray_t*)a)->data[index]);
2233 case ARRAYTYPE_LONG:
2234 return (jobject)primitive_box_long(((java_handle_longarray_t*)a)->data[index]);
2235 case ARRAYTYPE_FLOAT:
2236 return (jobject)primitive_box_float(((java_handle_floatarray_t*)a)->data[index]);
2237 case ARRAYTYPE_DOUBLE:
2238 return (jobject)primitive_box_double(((java_handle_doublearray_t*)a)->data[index]);
2239 case ARRAYTYPE_BYTE:
2240 return (jobject)primitive_box_byte(((java_handle_bytearray_t*)a)->data[index]);
2241 case ARRAYTYPE_CHAR:
2242 return (jobject)primitive_box_char(((java_handle_chararray_t*)a)->data[index]);
2243 case ARRAYTYPE_SHORT:
2244 return (jobject)primitive_box_short(((java_handle_shortarray_t*)a)->data[index]);
2245 case ARRAYTYPE_BOOLEAN:
2246 return (jobject)primitive_box_boolean(((java_handle_booleanarray_t*)a)->data[index]);
2247 case ARRAYTYPE_OBJECT:
2248 return (jobject)((java_handle_objectarray_t*)a)->data[index];
2250 /* invalid element type */
2251 exceptions_throw_internalerror("invalid element type code in array descriptor: %d", elementtype);
2252 return (jobject)NULL;
2257 /* JVM_GetPrimitiveArrayElement */
2259 jvalue JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode)
2261 log_println("JVM_GetPrimitiveArrayElement: IMPLEMENT ME!");
2265 /* JVM_SetArrayElement */
2267 void JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val)
2269 log_println("JVM_SetArrayElement: IMPLEMENT ME!");
2273 /* JVM_SetPrimitiveArrayElement */
2275 void JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode)
2277 log_println("JVM_SetPrimitiveArrayElement: IMPLEMENT ME!");
2283 jobject JVM_NewArray(JNIEnv *env, jclass eltClass, jint length)
2288 java_handle_objectarray_t *oa;
2290 TRACEJVMCALLS("JVM_NewArray(env=%p, eltClass=%p, length=%d)", env, eltClass, length);
2292 c = (classinfo *) eltClass;
2294 /* create primitive or object array */
2296 if (class_is_primitive(c)) {
2297 pc = primitive_arrayclass_get_by_name(c->name);
2298 a = builtin_newarray(length, pc);
2303 oa = builtin_anewarray(length, c);
2305 return (jobject) oa;
2310 /* JVM_NewMultiArray */
2312 jobject JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim)
2314 log_println("JVM_NewMultiArray: IMPLEMENT ME!");
2318 /* JVM_InitializeSocketLibrary */
2320 jint JVM_InitializeSocketLibrary()
2322 log_println("JVM_InitializeSocketLibrary: IMPLEMENT ME!");
2328 jint JVM_Socket(jint domain, jint type, jint protocol)
2331 log_println("JVM_Socket: domain=%d, type=%d, protocol=%d", domain, type, protocol);
2333 return socket(domain, type, protocol);
2337 /* JVM_SocketClose */
2339 jint JVM_SocketClose(jint fd)
2342 log_println("JVM_SocketClose: fd=%d", fd);
2348 /* JVM_SocketShutdown */
2350 jint JVM_SocketShutdown(jint fd, jint howto)
2353 log_println("JVM_SocketShutdown: fd=%d, howto=%d", fd, howto);
2355 return shutdown(fd, howto);
2361 jint JVM_Recv(jint fd, char *buf, jint nBytes, jint flags)
2363 log_println("JVM_Recv: IMPLEMENT ME!");
2369 jint JVM_Send(jint fd, char *buf, jint nBytes, jint flags)
2371 log_println("JVM_Send: IMPLEMENT ME!");
2377 jint JVM_Timeout(int fd, long timeout)
2379 log_println("JVM_Timeout: IMPLEMENT ME!");
2385 jint JVM_Listen(jint fd, jint count)
2388 log_println("JVM_Listen: fd=%d, count=%d", fd, count);
2390 return listen(fd, count);
2396 jint JVM_Connect(jint fd, struct sockaddr *him, jint len)
2399 log_println("JVM_Connect: fd=%d, him=%p, len=%d", fd, him, len);
2401 return connect(fd, him, len);
2407 jint JVM_Bind(jint fd, struct sockaddr *him, jint len)
2409 log_println("JVM_Bind: IMPLEMENT ME!");
2415 jint JVM_Accept(jint fd, struct sockaddr *him, jint *len)
2418 log_println("JVM_Accept: fd=%d, him=%p, len=%p", fd, him, len);
2420 return accept(fd, him, (socklen_t *) len);
2426 jint JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen)
2428 log_println("JVM_RecvFrom: IMPLEMENT ME!");
2432 /* JVM_GetSockName */
2434 jint JVM_GetSockName(jint fd, struct sockaddr *him, int *len)
2437 log_println("JVM_GetSockName: fd=%d, him=%p, len=%p", fd, him, len);
2439 return getsockname(fd, him, (socklen_t *) len);
2445 jint JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen)
2447 log_println("JVM_SendTo: IMPLEMENT ME!");
2451 /* JVM_SocketAvailable */
2453 jint JVM_SocketAvailable(jint fd, jint *pbytes)
2455 log_println("JVM_SocketAvailable: IMPLEMENT ME!");
2459 /* JVM_GetSockOpt */
2461 jint JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen)
2463 log_println("JVM_GetSockOpt: IMPLEMENT ME!");
2467 /* JVM_SetSockOpt */
2469 jint JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen)
2472 log_println("JVM_SetSockOpt: fd=%d, level=%d, optname=%d, optval=%s, optlen=%d", fd, level, optname, optval, optlen);
2474 return setsockopt(fd, level, optname, optval, optlen);
2478 /* JVM_GetHostName */
2480 int JVM_GetHostName(char* name, int namelen)
2483 log_println("JVM_GetHostName: name=%s, namelen=%d", name, namelen);
2485 return gethostname(name, namelen);
2489 /* JVM_GetHostByAddr */
2491 struct hostent* JVM_GetHostByAddr(const char* name, int len, int type)
2493 log_println("JVM_GetHostByAddr: IMPLEMENT ME!");
2497 /* JVM_GetHostByName */
2499 struct hostent* JVM_GetHostByName(char* name)
2501 log_println("JVM_GetHostByName: IMPLEMENT ME!");
2505 /* JVM_GetProtoByName */
2507 struct protoent* JVM_GetProtoByName(char* name)
2509 log_println("JVM_GetProtoByName: IMPLEMENT ME!");
2513 /* JVM_LoadLibrary */
2515 void* JVM_LoadLibrary(const char* name)
2518 log_println("JVM_LoadLibrary: name=%s", name);
2520 return native_library_open(utf_new_char(name));
2524 /* JVM_UnloadLibrary */
2526 void JVM_UnloadLibrary(void* handle)
2528 log_println("JVM_UnloadLibrary: IMPLEMENT ME!");
2532 /* JVM_FindLibraryEntry */
2534 void* JVM_FindLibraryEntry(void* handle, const char* name)
2539 log_println("JVM_FindLibraryEntry: handle=%p, name=%s", handle, name);
2542 symbol = lt_dlsym(handle, name);
2550 jboolean JVM_IsNaN(jdouble a)
2552 log_println("JVM_IsNaN: IMPLEMENT ME!");
2556 /* JVM_IsSupportedJNIVersion */
2558 jboolean JVM_IsSupportedJNIVersion(jint version)
2561 log_println("JVM_IsSupportedJNIVersion: version=%d", version);
2564 case JNI_VERSION_1_1:
2565 case JNI_VERSION_1_2:
2566 case JNI_VERSION_1_4:
2574 /* JVM_InternString */
2576 jstring JVM_InternString(JNIEnv *env, jstring str)
2579 log_println("JVM_InternString: str=%p", str);
2581 return (jstring) _Jv_java_lang_String_intern((java_lang_String *) str);
2585 /* JVM_RawMonitorCreate */
2587 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void)
2592 log_println("JVM_RawMonitorCreate");
2595 o = NEW(java_object_t);
2597 lock_init_object_lock(o);
2603 /* JVM_RawMonitorDestroy */
2605 JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void *mon)
2608 log_println("JVM_RawMonitorDestroy: mon=%p", mon);
2610 FREE(mon, java_object_t);
2614 /* JVM_RawMonitorEnter */
2616 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void *mon)
2619 log_println("JVM_RawMonitorEnter: mon=%p", mon);
2621 (void) lock_monitor_enter((java_object_t *) mon);
2627 /* JVM_RawMonitorExit */
2629 JNIEXPORT void JNICALL JVM_RawMonitorExit(void *mon)
2632 log_println("JVM_RawMonitorExit: mon=%p", mon);
2634 (void) lock_monitor_exit((java_object_t *) mon);
2638 /* JVM_SetPrimitiveFieldValues */
2640 void JVM_SetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
2642 log_println("JVM_SetPrimitiveFieldValues: IMPLEMENT ME!");
2646 /* JVM_GetPrimitiveFieldValues */
2648 void JVM_GetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
2650 log_println("JVM_GetPrimitiveFieldValues: IMPLEMENT ME!");
2654 /* JVM_AccessVMBooleanFlag */
2656 jboolean JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get)
2658 log_println("JVM_AccessVMBooleanFlag: IMPLEMENT ME!");
2662 /* JVM_AccessVMIntFlag */
2664 jboolean JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get)
2666 log_println("JVM_AccessVMIntFlag: IMPLEMENT ME!");
2670 /* JVM_VMBreakPoint */
2672 void JVM_VMBreakPoint(JNIEnv *env, jobject obj)
2674 log_println("JVM_VMBreakPoint: IMPLEMENT ME!");
2678 /* JVM_GetClassFields */
2680 jobjectArray JVM_GetClassFields(JNIEnv *env, jclass cls, jint which)
2682 log_println("JVM_GetClassFields: IMPLEMENT ME!");
2686 /* JVM_GetClassMethods */
2688 jobjectArray JVM_GetClassMethods(JNIEnv *env, jclass cls, jint which)
2690 log_println("JVM_GetClassMethods: IMPLEMENT ME!");
2694 /* JVM_GetClassConstructors */
2696 jobjectArray JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which)
2698 log_println("JVM_GetClassConstructors: IMPLEMENT ME!");
2702 /* JVM_GetClassField */
2704 jobject JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which)
2706 log_println("JVM_GetClassField: IMPLEMENT ME!");
2710 /* JVM_GetClassMethod */
2712 jobject JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types, jint which)
2714 log_println("JVM_GetClassMethod: IMPLEMENT ME!");
2718 /* JVM_GetClassConstructor */
2720 jobject JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types, jint which)
2722 log_println("JVM_GetClassConstructor: IMPLEMENT ME!");
2726 /* JVM_NewInstance */
2728 jobject JVM_NewInstance(JNIEnv *env, jclass cls)
2730 log_println("JVM_NewInstance: IMPLEMENT ME!");
2736 jobject JVM_GetField(JNIEnv *env, jobject field, jobject obj)
2738 log_println("JVM_GetField: IMPLEMENT ME!");
2742 /* JVM_GetPrimitiveField */
2744 jvalue JVM_GetPrimitiveField(JNIEnv *env, jobject field, jobject obj, unsigned char wCode)
2746 log_println("JVM_GetPrimitiveField: IMPLEMENT ME!");
2752 void JVM_SetField(JNIEnv *env, jobject field, jobject obj, jobject val)
2754 log_println("JVM_SetField: IMPLEMENT ME!");
2758 /* JVM_SetPrimitiveField */
2760 void JVM_SetPrimitiveField(JNIEnv *env, jobject field, jobject obj, jvalue v, unsigned char vCode)
2762 log_println("JVM_SetPrimitiveField: IMPLEMENT ME!");
2766 /* JVM_InvokeMethod */
2768 jobject JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)
2771 log_println("JVM_InvokeMethod: method=%p, obj=%p, args0=%p", method, obj, args0);
2773 return (jobject) _Jv_java_lang_reflect_Method_invoke((java_lang_reflect_Method *) method, (java_lang_Object *) obj, (java_handle_objectarray_t *) args0);
2777 /* JVM_NewInstanceFromConstructor */
2779 jobject JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0)
2782 log_println("JVM_NewInstanceFromConstructor: c=%p, args0=%p", c, args0);
2784 return (jobject) _Jv_java_lang_reflect_Constructor_newInstance(env, (java_lang_reflect_Constructor *) c, (java_handle_objectarray_t *) args0);
2788 /* JVM_SupportsCX8 */
2790 jboolean JVM_SupportsCX8()
2793 log_println("JVM_SupportsCX8");
2795 return _Jv_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(NULL, NULL);
2801 jboolean JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal)
2803 log_println("JVM_CX8Field: IMPLEMENT ME!");
2807 /* JVM_GetAllThreads */
2809 jobjectArray JVM_GetAllThreads(JNIEnv *env, jclass dummy)
2811 log_println("JVM_GetAllThreads: IMPLEMENT ME!");
2815 /* JVM_DumpThreads */
2817 jobjectArray JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads)
2819 log_println("JVM_DumpThreads: IMPLEMENT ME!");
2823 /* JVM_GetManagement */
2825 void* JVM_GetManagement(jint version)
2827 log_println("JVM_GetManagement: IMPLEMENT ME!");
2831 /* JVM_InitAgentProperties */
2833 jobject JVM_InitAgentProperties(JNIEnv *env, jobject properties)
2835 log_println("JVM_InitAgentProperties: IMPLEMENT ME!");
2839 /* JVM_GetEnclosingMethodInfo */
2841 jobjectArray JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass)
2843 log_println("JVM_GetEnclosingMethodInfo: IMPLEMENT ME!");
2847 /* JVM_GetThreadStateValues */
2849 jintArray JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState)
2851 log_println("JVM_GetThreadStateValues: IMPLEMENT ME!");
2855 /* JVM_GetThreadStateValues */
2857 jobjectArray JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values)
2859 log_println("JVM_GetThreadStateValues: IMPLEMENT ME!");
2863 /* JVM_GetVersionInfo */
2865 void JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size)
2867 log_println("JVM_GetVersionInfo: IMPLEMENT ME!");
2871 /* OS: JVM_RegisterSignal */
2873 void* JVM_RegisterSignal(jint sig, void* handler)
2875 log_println("JVM_RegisterSignal: sig=%d, handler=%p, IMPLEMENT ME!", sig, handler);
2880 /* OS: JVM_RaiseSignal */
2882 jboolean JVM_RaiseSignal(jint sig)
2884 log_println("JVM_RaiseSignal: sig=%s", sig);
2889 /* OS: JVM_FindSignal */
2891 jint JVM_FindSignal(const char *name)
2893 log_println("JVM_FindSignal: name=%s", name);
2899 * These are local overrides for various environment variables in Emacs.
2900 * Please do not remove this and leave it at the end of the file, where
2901 * Emacs will automagically detect them.
2902 * ---------------------------------------------------------------------
2905 * indent-tabs-mode: t