1 /* src/native/vm/openjdk/jvm.cpp - HotSpot VM interface functions
3 Copyright (C) 2007, 2008
4 CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
6 This file is part of CACAO.
8 This program is free software; you can redistribute it and/or
9 modify it under the terms of the GNU General Public License as
10 published by the Free Software Foundation; either version 2, or (at
11 your option) any later version.
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
35 #if defined(HAVE_SYS_IOCTL_H)
36 #define BSD_COMP /* Get FIONREAD on Solaris2 */
37 #include <sys/ioctl.h>
40 #include <sys/socket.h>
42 #include <sys/types.h>
44 // Include our JNI header before the JVM headers, because the JVM
45 // headers include jni.h and we want to override the typedefs in
47 #include "native/jni.hpp"
49 // We include jvm_md.h before jvm.h as the latter includes the former.
50 #include INCLUDE_JVM_MD_H
51 #include INCLUDE_JVM_H
53 #include "fdlibm/fdlibm.h"
55 #include "mm/memory.hpp"
57 #include "native/llni.h"
58 #include "native/native.hpp"
60 #include "native/vm/reflection.hpp"
62 #include "native/vm/openjdk/hpi.hpp"
63 #include "native/vm/openjdk/management.hpp"
65 #include "threads/lock.hpp"
66 #include "threads/thread.hpp"
67 #include "threads/threadlist.hpp"
69 #include "toolbox/logging.hpp"
70 #include "toolbox/list.hpp"
72 #include "vm/array.hpp"
74 #if defined(ENABLE_ASSERTION)
75 #include "vm/assertion.hpp"
78 #include "vm/jit/builtin.hpp"
79 #include "vm/classcache.hpp"
80 #include "vm/exceptions.hpp"
81 #include "vm/global.h"
82 #include "vm/globals.hpp"
83 #include "vm/initialize.hpp"
84 #include "vm/javaobjects.hpp"
85 #include "vm/options.h"
87 #include "vm/package.hpp"
88 #include "vm/primitive.hpp"
89 #include "vm/properties.hpp"
90 #include "vm/resolve.hpp"
91 #include "vm/signallocal.hpp"
92 #include "vm/string.hpp"
95 #include "vm/jit/stacktrace.hpp"
98 /* debugging macros ***********************************************************/
102 # define TRACEJVMCALLS(x) \
104 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
109 # define TRACEJVMCALLSENTER(x) \
111 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
117 # define TRACEJVMCALLSEXIT(x) \
119 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
125 # define TRACEJVMCALLSVERBOSE(x) \
127 if (opt_TraceJVMCallsVerbose) { \
132 # define PRINTJVMWARNINGS(x)
134 /* if (opt_PrintJVMWarnings) { \ */
135 /* log_println x; \ */
141 # define TRACEJVMCALLS(x)
142 # define TRACEJVMCALLSENTER(x)
143 # define TRACEJVMCALLSEXIT(x)
144 # define TRACEJVMCALLSVERBOSE(x)
145 # define PRINTJVMWARNINGS(x)
150 // Interface functions are exported as C functions.
153 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
155 if ((intptr_t) count <= 0)
158 return vsnprintf(str, count, fmt, args);
162 int jio_snprintf(char *str, size_t count, const char *fmt, ...)
168 len = jio_vsnprintf(str, count, fmt, ap);
175 int jio_fprintf(FILE* f, const char *fmt, ...)
177 log_println("jio_fprintf: IMPLEMENT ME!");
183 int jio_vfprintf(FILE* f, const char *fmt, va_list args)
185 log_println("jio_vfprintf: IMPLEMENT ME!");
191 int jio_printf(const char *fmt, ...)
193 log_println("jio_printf: IMPLEMENT ME!");
199 /* JVM_GetInterfaceVersion */
201 jint JVM_GetInterfaceVersion()
203 /* This is defined in hotspot/src/share/vm/prims/jvm.h */
205 #define JVM_INTERFACE_VERSION 4
207 return JVM_INTERFACE_VERSION;
211 /* JVM_CurrentTimeMillis */
213 jlong JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)
215 TRACEJVMCALLS(("JVM_CurrentTimeMillis(env=%p, ignored=%p)", env, ignored));
217 return (jlong) builtin_currenttimemillis();
223 jlong JVM_NanoTime(JNIEnv *env, jclass ignored)
225 TRACEJVMCALLS(("JVM_NanoTime(env=%p, ignored=%p)", env, ignored));
227 return (jlong) builtin_nanotime();
233 void JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos, jobject dst, jint dst_pos, jint length)
238 s = (java_handle_t *) src;
239 d = (java_handle_t *) dst;
241 TRACEJVMCALLSVERBOSE(("JVM_ArrayCopy(env=%p, ignored=%p, src=%p, src_pos=%d, dst=%p, dst_pos=%d, length=%d)", env, ignored, src, src_pos, dst, dst_pos, length));
243 builtin_arraycopy(s, src_pos, d, dst_pos, length);
247 /* JVM_InitProperties */
249 jobject JVM_InitProperties(JNIEnv *env, jobject properties)
254 TRACEJVMCALLS(("JVM_InitProperties(env=%p, properties=%p)", env, properties));
256 h = (java_handle_t *) properties;
258 /* Convert the -XX:MaxDirectMemorySize= command line flag to the
259 sun.nio.MaxDirectMemorySize property. Do this after setting
260 user properties to prevent people from setting the value with a
261 -D option, as requested. */
263 jio_snprintf(buf, sizeof(buf), PRINTF_FORMAT_INT64_T, opt_MaxDirectMemorySize);
264 VM::get_current()->get_properties().put("sun.nio.MaxDirectMemorySize", buf);
266 // Fill the java.util.Properties object.
267 VM::get_current()->get_properties().fill(h);
275 void JVM_Exit(jint code)
277 log_println("JVM_Exit: IMPLEMENT ME!");
283 void JVM_Halt(jint code)
285 TRACEJVMCALLS(("JVM_Halt(code=%d)", code));
292 /* JVM_OnExit(void (*func)) */
294 void JVM_OnExit(void (*func)(void))
296 log_println("JVM_OnExit(void (*func): IMPLEMENT ME!");
304 TRACEJVMCALLS(("JVM_GC()"));
310 /* JVM_MaxObjectInspectionAge */
312 jlong JVM_MaxObjectInspectionAge(void)
314 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 TRACEJVMCALLS(("JVM_ActiveProcessorCount()"));
372 return os::processors_online();
376 /* JVM_FillInStackTrace */
378 void JVM_FillInStackTrace(JNIEnv *env, jobject receiver)
380 TRACEJVMCALLS(("JVM_FillInStackTrace(env=%p, receiver=%p)", env, receiver));
382 java_handle_bytearray_t* ba = stacktrace_get_current();
387 java_lang_Throwable jlt(receiver, ba);
391 /* JVM_PrintStackTrace */
393 void JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable)
395 log_println("JVM_PrintStackTrace: IMPLEMENT ME!");
399 /* JVM_GetStackTraceDepth */
401 jint JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable)
403 TRACEJVMCALLS(("JVM_GetStackTraceDepth(env=%p, throwable=%p)", env, throwable));
405 java_lang_Throwable jlt(throwable);
408 exceptions_throw_nullpointerexception();
412 ByteArray ba(jlt.get_backtrace());
417 // We need a critical section here as the stacktrace structure is
418 // mapped onto a Java byte-array.
422 stacktrace_t* st = (stacktrace_t *) ba.get_raw_data_ptr();
424 int32_t depth = st->length;
432 /* JVM_GetStackTraceElement */
434 jobject JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index)
436 TRACEJVMCALLS(("JVM_GetStackTraceElement(env=%p, throwable=%p, index=%d)", env, throwable, index));
438 java_lang_Throwable jlt(throwable);
439 ByteArray ba(jlt.get_backtrace());
441 // XXX We need a critical section here as the stacktrace structure is
442 // mapped onto a Java byte-array.
443 stacktrace_t* st = (stacktrace_t *) ba.get_raw_data_ptr();
445 return stacktrace_get_StackTraceElement(st, index);
451 jint JVM_IHashCode(JNIEnv* env, jobject handle)
453 TRACEJVMCALLS(("JVM_IHashCode(env=%p, jobject=%p)", env, handle));
455 java_lang_Object o(handle);
457 return o.get_hashcode();
461 /* JVM_MonitorWait */
463 void JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms)
465 #if defined(ENABLE_THREADS)
469 TRACEJVMCALLS(("JVM_MonitorWait(env=%p, handle=%p, ms=%ld)", env, handle, ms));
471 /* exceptions_throw_illegalargumentexception("argument out of range"); */
472 exceptions_throw_illegalargumentexception();
476 #if defined(ENABLE_THREADS)
477 o = (java_handle_t *) handle;
479 lock_wait_for_object(o, ms, 0);
484 /* JVM_MonitorNotify */
486 void JVM_MonitorNotify(JNIEnv* env, jobject handle)
488 #if defined(ENABLE_THREADS)
492 TRACEJVMCALLS(("JVM_MonitorNotify(env=%p, handle=%p)", env, handle));
494 #if defined(ENABLE_THREADS)
495 o = (java_handle_t *) handle;
497 lock_notify_object(o);
502 /* JVM_MonitorNotifyAll */
504 void JVM_MonitorNotifyAll(JNIEnv* env, jobject handle)
506 #if defined(ENABLE_THREADS)
510 TRACEJVMCALLS(("JVM_MonitorNotifyAll(env=%p, handle=%p)", env, handle));
512 #if defined(ENABLE_THREADS)
513 o = (java_handle_t *) handle;
515 lock_notify_all_object(o);
522 jobject JVM_Clone(JNIEnv* env, jobject handle)
524 TRACEJVMCALLS(("JVM_Clone(env=%p, handle=%p)", env, handle));
526 return (jobject) builtin_clone(env, (java_handle_t *) handle);
530 /* JVM_InitializeCompiler */
532 void JVM_InitializeCompiler (JNIEnv *env, jclass compCls)
534 log_println("JVM_InitializeCompiler : IMPLEMENT ME!");
538 /* JVM_IsSilentCompiler */
540 jboolean JVM_IsSilentCompiler(JNIEnv *env, jclass compCls)
542 log_println("JVM_IsSilentCompiler: IMPLEMENT ME!");
548 /* JVM_CompileClass */
550 jboolean JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls)
552 log_println("JVM_CompileClass: IMPLEMENT ME!");
558 /* JVM_CompileClasses */
560 jboolean JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname)
562 log_println("JVM_CompileClasses: IMPLEMENT ME!");
568 /* JVM_CompilerCommand */
570 jobject JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg)
572 log_println("JVM_CompilerCommand: IMPLEMENT ME!");
578 /* JVM_EnableCompiler */
580 void JVM_EnableCompiler(JNIEnv *env, jclass compCls)
582 TRACEJVMCALLS(("JVM_EnableCompiler(env=%p, compCls=%p)", env, compCls));
583 PRINTJVMWARNINGS(("JVM_EnableCompiler not supported"));
587 /* JVM_DisableCompiler */
589 void JVM_DisableCompiler(JNIEnv *env, jclass compCls)
591 TRACEJVMCALLS(("JVM_DisableCompiler(env=%p, compCls=%p)", env, compCls));
592 PRINTJVMWARNINGS(("JVM_DisableCompiler not supported"));
596 /* JVM_GetLastErrorString */
598 jint JVM_GetLastErrorString(char* buf, int len)
600 TRACEJVMCALLS(("JVM_GetLastErrorString(buf=%p, len=%d", buf, len));
602 HPI& hpi = VM::get_current()->get_hpi();
603 return hpi.get_system().GetLastErrorString(buf, len);
609 char *JVM_NativePath(char* path)
611 TRACEJVMCALLS(("JVM_NativePath(path=%s)", path));
613 HPI& hpi = VM::get_current()->get_hpi();
614 return hpi.get_file().NativePath(path);
618 /* JVM_GetCallerClass */
620 jclass JVM_GetCallerClass(JNIEnv* env, int depth)
624 TRACEJVMCALLS(("JVM_GetCallerClass(env=%p, depth=%d)", env, depth));
626 c = stacktrace_get_caller_class(depth);
632 /* JVM_FindPrimitiveClass */
634 jclass JVM_FindPrimitiveClass(JNIEnv* env, const char* s)
639 TRACEJVMCALLS(("JVM_FindPrimitiveClass(env=%p, s=%s)", env, s));
642 c = Primitive::get_class_by_name(u);
644 return (jclass) LLNI_classinfo_wrap(c);
648 /* JVM_ResolveClass */
650 void JVM_ResolveClass(JNIEnv* env, jclass cls)
652 TRACEJVMCALLS(("JVM_ResolveClass(env=%p, cls=%p)", env, cls));
653 PRINTJVMWARNINGS(("JVM_ResolveClass not implemented"));
657 /* JVM_FindClassFromClassLoader */
659 jclass JVM_FindClassFromClassLoader(JNIEnv* env, const char* name, jboolean init, jobject loader, jboolean throwError)
665 TRACEJVMCALLS(("JVM_FindClassFromClassLoader(name=%s, init=%d, loader=%p, throwError=%d)", name, init, loader, throwError));
667 /* As of now, OpenJDK does not call this function with throwError
670 assert(throwError == false);
672 u = utf_new_char(name);
673 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
675 c = load_class_from_classloader(u, cl);
681 if (!(c->state & CLASS_INITIALIZED))
682 if (!initialize_class(c))
685 return (jclass) LLNI_classinfo_wrap(c);
689 /* JVM_FindClassFromClass */
691 jclass JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init, jclass from)
693 log_println("JVM_FindClassFromClass: IMPLEMENT ME!");
699 /* JVM_DefineClass */
701 jclass JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)
703 log_println("JVM_DefineClass: IMPLEMENT ME!");
709 /* JVM_DefineClassWithSource */
711 jclass JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)
717 TRACEJVMCALLS(("JVM_DefineClassWithSource(env=%p, name=%s, loader=%p, buf=%p, len=%d, pd=%p, source=%s)", env, name, loader, buf, len, pd, source));
720 u = utf_new_char(name);
724 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
726 /* XXX do something with source */
728 c = class_define(u, cl, len, (uint8_t *) buf, (java_handle_t *) pd);
730 return (jclass) LLNI_classinfo_wrap(c);
734 /* JVM_FindLoadedClass */
736 jclass JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name)
742 TRACEJVMCALLS(("JVM_FindLoadedClass(env=%p, loader=%p, name=%p)", env, loader, name));
744 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
746 u = javastring_toutf((java_handle_t *) name, true);
747 c = classcache_lookup(cl, u);
749 return (jclass) LLNI_classinfo_wrap(c);
753 /* JVM_GetClassName */
755 jstring JVM_GetClassName(JNIEnv *env, jclass cls)
759 TRACEJVMCALLS(("JVM_GetClassName(env=%p, cls=%p)", env, cls));
761 c = LLNI_classinfo_unwrap(cls);
763 return (jstring) class_get_classname(c);
767 /* JVM_GetClassInterfaces */
769 jobjectArray JVM_GetClassInterfaces(JNIEnv *env, jclass cls)
772 java_handle_objectarray_t *oa;
774 TRACEJVMCALLS(("JVM_GetClassInterfaces(env=%p, cls=%p)", env, cls));
776 c = LLNI_classinfo_unwrap(cls);
778 oa = class_get_interfaces(c);
784 /* JVM_GetClassLoader */
786 jobject JVM_GetClassLoader(JNIEnv *env, jclass cls)
791 TRACEJVMCALLSENTER(("JVM_GetClassLoader(env=%p, cls=%p)", env, cls));
793 c = LLNI_classinfo_unwrap(cls);
794 cl = class_get_classloader(c);
796 TRACEJVMCALLSEXIT(("->%p", cl));
802 /* JVM_IsInterface */
804 jboolean JVM_IsInterface(JNIEnv *env, jclass cls)
808 TRACEJVMCALLS(("JVM_IsInterface(env=%p, cls=%p)", env, cls));
810 c = LLNI_classinfo_unwrap(cls);
812 return class_is_interface(c);
816 /* JVM_GetClassSigners */
818 jobjectArray JVM_GetClassSigners(JNIEnv *env, jclass cls)
820 log_println("JVM_GetClassSigners: IMPLEMENT ME!");
826 /* JVM_SetClassSigners */
828 void JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers)
830 TRACEJVMCALLS(("JVM_SetClassSigners(env=%p, cls=%p, signers=%p)", env, cls, signers));
832 classinfo* c = LLNI_classinfo_unwrap(cls);
834 ObjectArray oa(signers);
836 /* This call is ignored for primitive types and arrays. Signers
837 are only set once, ClassLoader.java, and thus shouldn't be
838 called with an array. Only the bootstrap loader creates
841 if (class_is_primitive(c) || class_is_array(c))
845 LLNI_classinfo_field_set(c, signers, (java_objectarray_t*) oa.get_handle());
849 /* JVM_GetProtectionDomain */
851 jobject JVM_GetProtectionDomain(JNIEnv *env, jclass cls)
855 TRACEJVMCALLS(("JVM_GetProtectionDomain(env=%p, cls=%p)", env, cls));
857 c = LLNI_classinfo_unwrap(cls);
860 exceptions_throw_nullpointerexception();
864 /* Primitive types do not have a protection domain. */
866 if (class_is_primitive(c))
869 return (jobject) c->protectiondomain;
873 /* JVM_SetProtectionDomain */
875 void JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain)
877 log_println("JVM_SetProtectionDomain: IMPLEMENT ME!");
881 /* JVM_DoPrivileged */
883 jobject JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, jobject context, jboolean wrapException)
888 java_handle_t *result;
891 TRACEJVMCALLS(("JVM_DoPrivileged(env=%p, cls=%p, action=%p, context=%p, wrapException=%d)", env, cls, action, context, wrapException));
893 h = (java_handle_t *) action;
894 LLNI_class_get(h, c);
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, h);
916 e = exceptions_get_exception();
919 if ( builtin_instanceof(e, class_java_lang_Exception) &&
920 !builtin_instanceof(e, class_java_lang_RuntimeException)) {
921 exceptions_clear_exception();
922 exceptions_throw_privilegedactionexception(e);
928 return (jobject) result;
932 /* JVM_GetInheritedAccessControlContext */
934 jobject JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls)
936 log_println("JVM_GetInheritedAccessControlContext: IMPLEMENT ME!");
942 /* JVM_GetStackAccessControlContext */
944 jobject JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls)
946 TRACEJVMCALLS(("JVM_GetStackAccessControlContext(env=%p, cls=%p): IMPLEMENT ME!", env, cls));
948 /* XXX All stuff I tested so far works without that function. At
949 some point we have to implement it, but I disable the output
950 for now to make IcedTea happy. */
956 /* JVM_IsArrayClass */
958 jboolean JVM_IsArrayClass(JNIEnv *env, jclass cls)
962 TRACEJVMCALLS(("JVM_IsArrayClass(env=%p, cls=%p)", env, cls));
964 c = LLNI_classinfo_unwrap(cls);
966 return class_is_array(c);
970 /* JVM_IsPrimitiveClass */
972 jboolean JVM_IsPrimitiveClass(JNIEnv *env, jclass cls)
976 TRACEJVMCALLS(("JVM_IsPrimitiveClass(env=%p, cls=%p)", env, cls));
978 c = LLNI_classinfo_unwrap(cls);
980 return class_is_primitive(c);
984 /* JVM_GetComponentType */
986 jclass JVM_GetComponentType(JNIEnv *env, jclass cls)
988 classinfo *component;
991 TRACEJVMCALLS(("JVM_GetComponentType(env=%p, cls=%p)", env, cls));
993 c = LLNI_classinfo_unwrap(cls);
995 component = class_get_componenttype(c);
997 return (jclass) LLNI_classinfo_wrap(component);
1001 /* JVM_GetClassModifiers */
1003 jint JVM_GetClassModifiers(JNIEnv *env, jclass cls)
1008 TRACEJVMCALLS(("JVM_GetClassModifiers(env=%p, cls=%p)", env, cls));
1010 c = LLNI_classinfo_unwrap(cls);
1012 flags = class_get_modifiers(c, false);
1018 /* JVM_GetDeclaredClasses */
1020 jobjectArray JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)
1023 java_handle_objectarray_t *oa;
1025 TRACEJVMCALLS(("JVM_GetDeclaredClasses(env=%p, ofClass=%p)", env, ofClass));
1027 c = LLNI_classinfo_unwrap(ofClass);
1029 oa = class_get_declaredclasses(c, false);
1035 /* JVM_GetDeclaringClass */
1037 jclass JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass)
1042 TRACEJVMCALLS(("JVM_GetDeclaringClass(env=%p, ofClass=%p)", env, ofClass));
1044 c = LLNI_classinfo_unwrap(ofClass);
1046 dc = class_get_declaringclass(c);
1048 return (jclass) LLNI_classinfo_wrap(dc);
1052 /* JVM_GetClassSignature */
1054 jstring JVM_GetClassSignature(JNIEnv *env, jclass cls)
1060 TRACEJVMCALLS(("JVM_GetClassSignature(env=%p, cls=%p)", env, cls));
1062 c = LLNI_classinfo_unwrap(cls);
1064 /* Get the signature of the class. */
1066 u = class_get_signature(c);
1071 /* Convert UTF-string to a Java-string. */
1073 s = javastring_new(u);
1079 /* JVM_GetClassAnnotations */
1081 jbyteArray JVM_GetClassAnnotations(JNIEnv *env, jclass cls)
1083 TRACEJVMCALLS(("JVM_GetClassAnnotations(env=%p, cls=%p)", env, cls));
1086 exceptions_throw_nullpointerexception();
1090 classinfo* c = LLNI_classinfo_unwrap(cls);
1092 /* get annotations: */
1093 java_handle_bytearray_t* annotations = class_get_annotations(c);
1095 return (jbyteArray) annotations;
1099 /* JVM_GetFieldAnnotations */
1101 jbyteArray JVM_GetFieldAnnotations(JNIEnv *env, jobject field)
1103 TRACEJVMCALLS(("JVM_GetFieldAnnotations(env=%p, field=%p)", env, field));
1105 java_lang_reflect_Field jlrf(field);
1107 if (jlrf.is_null()) {
1108 exceptions_throw_nullpointerexception();
1112 return (jbyteArray) jlrf.get_annotations();
1116 /* JVM_GetMethodAnnotations */
1118 jbyteArray JVM_GetMethodAnnotations(JNIEnv *env, jobject method)
1120 TRACEJVMCALLS(("JVM_GetMethodAnnotations(env=%p, method=%p)", env, method));
1122 java_lang_reflect_Method jlrm(method);
1124 if (jlrm.is_null()) {
1125 exceptions_throw_nullpointerexception();
1129 return (jbyteArray) jlrm.get_annotations();
1133 /* JVM_GetMethodDefaultAnnotationValue */
1135 jbyteArray JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method)
1137 TRACEJVMCALLS(("JVM_GetMethodDefaultAnnotationValue(env=%p, method=%p)", env, method));
1139 java_lang_reflect_Method jlrm(method);
1141 if (jlrm.is_null()) {
1142 exceptions_throw_nullpointerexception();
1146 return (jbyteArray) jlrm.get_annotationDefault();
1150 /* JVM_GetMethodParameterAnnotations */
1152 jbyteArray JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method)
1154 TRACEJVMCALLS(("JVM_GetMethodParameterAnnotations(env=%p, method=%p)", env, method));
1156 java_lang_reflect_Method jlrm(method);
1158 if (jlrm.is_null()) {
1159 exceptions_throw_nullpointerexception();
1163 return (jbyteArray) jlrm.get_parameterAnnotations();
1167 /* JVM_GetClassDeclaredFields */
1169 jobjectArray JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1172 java_handle_objectarray_t *oa;
1174 TRACEJVMCALLS(("JVM_GetClassDeclaredFields(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1176 c = LLNI_classinfo_unwrap(ofClass);
1178 oa = class_get_declaredfields(c, publicOnly);
1184 /* JVM_GetClassDeclaredMethods */
1186 jobjectArray JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1188 TRACEJVMCALLS(("JVM_GetClassDeclaredMethods(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1190 classinfo* c = LLNI_classinfo_unwrap(ofClass);
1192 java_handle_objectarray_t* oa = class_get_declaredmethods(c, publicOnly);
1198 /* JVM_GetClassDeclaredConstructors */
1200 jobjectArray JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1203 java_handle_objectarray_t *oa;
1205 TRACEJVMCALLS(("JVM_GetClassDeclaredConstructors(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1207 c = LLNI_classinfo_unwrap(ofClass);
1209 oa = class_get_declaredconstructors(c, publicOnly);
1215 /* JVM_GetClassAccessFlags */
1217 jint JVM_GetClassAccessFlags(JNIEnv *env, jclass cls)
1221 TRACEJVMCALLS(("JVM_GetClassAccessFlags(env=%p, cls=%p)", env, cls));
1223 c = LLNI_classinfo_unwrap(cls);
1225 /* Primitive type classes have the correct access flags. */
1227 return c->flags & ACC_CLASS_REFLECT_MASK;
1231 /* JVM_GetClassConstantPool */
1233 jobject JVM_GetClassConstantPool(JNIEnv *env, jclass cls)
1235 #if defined(ENABLE_ANNOTATIONS)
1236 TRACEJVMCALLS(("JVM_GetClassConstantPool(env=%p, cls=%p)", env, cls));
1238 java_handle_t* h = native_new_and_init(class_sun_reflect_ConstantPool);
1239 sun_reflect_ConstantPool cp(h, cls);
1245 return (jobject) cp.get_handle();
1247 log_println("JVM_GetClassConstantPool(env=%p, cls=%p): not implemented in this configuration!", env, cls);
1253 /* JVM_ConstantPoolGetSize */
1255 jint JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool)
1257 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1259 TRACEJVMCALLS(("JVM_ConstantPoolGetSize(env=%p, unused=%p, jcpool=%p)", env, unused, jcpool));
1261 c = LLNI_classinfo_unwrap(jcpool);
1267 /* JVM_ConstantPoolGetClassAt */
1269 jclass JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1271 constant_classref *ref; /* classref to the class at constant pool index 'index' */
1272 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1273 classinfo *result; /* classinfo of the class at constant pool index 'index' */
1275 TRACEJVMCALLS(("JVM_ConstantPoolGetClassAt(env=%p, jcpool=%p, index=%d)", env, jcpool, index));
1277 c = LLNI_classinfo_unwrap(jcpool);
1279 ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1282 exceptions_throw_illegalargumentexception();
1286 result = resolve_classref_eager(ref);
1288 return (jclass) LLNI_classinfo_wrap(result);
1292 /* JVM_ConstantPoolGetClassAtIfLoaded */
1294 jclass JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1296 constant_classref *ref; /* classref to the class at constant pool index 'index' */
1297 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1298 classinfo *result; /* classinfo of the class at constant pool index 'index' */
1300 TRACEJVMCALLS(("JVM_ConstantPoolGetClassAtIfLoaded(env=%p, unused=%p, jcpool=%p, index=%d)", env, unused, jcpool, index));
1302 c = LLNI_classinfo_unwrap(jcpool);
1304 ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1307 exceptions_throw_illegalargumentexception();
1311 if (!resolve_classref(NULL, ref, resolveLazy, true, true, &result)) {
1315 if ((result == NULL) || !(result->state & CLASS_LOADED)) {
1319 return (jclass) LLNI_classinfo_wrap(result);
1323 /* JVM_ConstantPoolGetMethodAt */
1325 jobject JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1327 constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
1328 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1330 TRACEJVMCALLS(("JVM_ConstantPoolGetMethodAt: jcpool=%p, index=%d", jcpool, index));
1332 cls = LLNI_classinfo_unwrap(jcpool);
1333 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1336 exceptions_throw_illegalargumentexception();
1340 // Create a new java.lang.reflect.Method Java object.
1341 /* XXX: is that right? or do I have to use resolve_method_*? */
1342 java_lang_reflect_Method jlrm(ref->p.method);
1344 return (jobject) jlrm.get_handle();
1348 /* JVM_ConstantPoolGetMethodAtIfLoaded */
1350 jobject JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1352 constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
1353 classinfo *c = NULL; /* resolved declaring class of the method */
1354 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1356 TRACEJVMCALLS(("JVM_ConstantPoolGetMethodAtIfLoaded: jcpool=%p, index=%d", jcpool, index));
1358 cls = LLNI_classinfo_unwrap(jcpool);
1359 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1362 exceptions_throw_illegalargumentexception();
1366 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1370 if (c == NULL || !(c->state & CLASS_LOADED)) {
1374 // Create a new java.lang.reflect.Method Java object.
1375 java_lang_reflect_Method jlrm(ref->p.method);
1377 return (jobject) jlrm.get_handle();
1381 /* JVM_ConstantPoolGetFieldAt */
1383 jobject JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1385 constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
1386 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1388 TRACEJVMCALLS(("JVM_ConstantPoolGetFieldAt: jcpool=%p, index=%d", jcpool, index));
1390 cls = LLNI_classinfo_unwrap(jcpool);
1391 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1394 exceptions_throw_illegalargumentexception();
1398 // Create a new java.lang.reflect.Field Java object.
1399 java_lang_reflect_Field jlrf(ref->p.field);
1401 return (jobject) jlrf.get_handle();
1405 /* JVM_ConstantPoolGetFieldAtIfLoaded */
1407 jobject JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1409 constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
1410 classinfo *c; /* resolved declaring class for the field */
1411 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1413 TRACEJVMCALLS(("JVM_ConstantPoolGetFieldAtIfLoaded: jcpool=%p, index=%d", jcpool, index));
1415 cls = LLNI_classinfo_unwrap(jcpool);
1416 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1419 exceptions_throw_illegalargumentexception();
1423 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1427 if (c == NULL || !(c->state & CLASS_LOADED)) {
1431 // Create a new java.lang.reflect.Field Java object.
1432 java_lang_reflect_Field jlrf(ref->p.field);
1434 return (jobject) jlrf.get_handle();
1438 /* JVM_ConstantPoolGetMemberRefInfoAt */
1440 jobjectArray JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1442 log_println("JVM_ConstantPoolGetMemberRefInfoAt: jcpool=%p, index=%d, IMPLEMENT ME!", jcpool, index);
1444 /* TODO: implement. (this is yet unused be OpenJDK but, so very low priority) */
1450 /* JVM_ConstantPoolGetIntAt */
1452 jint JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1454 constant_integer *ref; /* reference to the int value in constant pool at index 'index' */
1455 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1457 TRACEJVMCALLS(("JVM_ConstantPoolGetIntAt: jcpool=%p, index=%d", jcpool, index));
1459 cls = LLNI_classinfo_unwrap(jcpool);
1460 ref = (constant_integer*)class_getconstant(cls, index, CONSTANT_Integer);
1463 exceptions_throw_illegalargumentexception();
1471 /* JVM_ConstantPoolGetLongAt */
1473 jlong JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1475 constant_long *ref; /* reference to the long value in constant pool at index 'index' */
1476 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1478 TRACEJVMCALLS(("JVM_ConstantPoolGetLongAt: jcpool=%p, index=%d", jcpool, index));
1480 cls = LLNI_classinfo_unwrap(jcpool);
1481 ref = (constant_long*)class_getconstant(cls, index, CONSTANT_Long);
1484 exceptions_throw_illegalargumentexception();
1492 /* JVM_ConstantPoolGetFloatAt */
1494 jfloat JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1496 constant_float *ref; /* reference to the float value in constant pool at index 'index' */
1497 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1499 TRACEJVMCALLS(("JVM_ConstantPoolGetFloatAt: jcpool=%p, index=%d", jcpool, index));
1501 cls = LLNI_classinfo_unwrap(jcpool);
1502 ref = (constant_float*)class_getconstant(cls, index, CONSTANT_Float);
1505 exceptions_throw_illegalargumentexception();
1513 /* JVM_ConstantPoolGetDoubleAt */
1515 jdouble JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1517 constant_double *ref; /* reference to the double value in constant pool at index 'index' */
1518 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1520 TRACEJVMCALLS(("JVM_ConstantPoolGetDoubleAt: jcpool=%p, index=%d", jcpool, index));
1522 cls = LLNI_classinfo_unwrap(jcpool);
1523 ref = (constant_double*)class_getconstant(cls, index, CONSTANT_Double);
1526 exceptions_throw_illegalargumentexception();
1534 /* JVM_ConstantPoolGetStringAt */
1536 jstring JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1538 utf *ref; /* utf object for the string in constant pool at index 'index' */
1539 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1541 TRACEJVMCALLS(("JVM_ConstantPoolGetStringAt: jcpool=%p, index=%d", jcpool, index));
1543 cls = LLNI_classinfo_unwrap(jcpool);
1544 ref = (utf*)class_getconstant(cls, index, CONSTANT_String);
1547 exceptions_throw_illegalargumentexception();
1551 /* XXX: I hope literalstring_new is the right Function. */
1552 return (jstring)literalstring_new(ref);
1556 /* JVM_ConstantPoolGetUTF8At */
1558 jstring JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1560 utf *ref; /* utf object for the utf8 data in constant pool at index 'index' */
1561 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1563 TRACEJVMCALLS(("JVM_ConstantPoolGetUTF8At: jcpool=%p, index=%d", jcpool, index));
1565 cls = LLNI_classinfo_unwrap(jcpool);
1566 ref = (utf*)class_getconstant(cls, index, CONSTANT_Utf8);
1569 exceptions_throw_illegalargumentexception();
1573 /* XXX: I hope literalstring_new is the right Function. */
1574 return (jstring)literalstring_new(ref);
1578 /* JVM_DesiredAssertionStatus */
1580 jboolean JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls)
1582 #if defined(ENABLE_ASSERTION)
1587 TRACEJVMCALLS(("JVM_DesiredAssertionStatus(env=%p, unused=%p, cls=%p)", env, unused, cls));
1589 c = LLNI_classinfo_unwrap(cls);
1591 if (c->classloader == NULL) {
1592 status = (jboolean)assertion_system_enabled;
1595 status = (jboolean)assertion_user_enabled;
1598 if (list_assertion_names != NULL) {
1599 for (List<assertion_name_t*>::iterator it = list_assertion_names->begin();
1600 it != list_assertion_names->end(); it++) {
1601 assertion_name_t* item = *it;
1603 name = utf_new_char(item->name);
1604 if (name == c->packagename) {
1605 status = (jboolean)item->enabled;
1607 else if (name == c->name) {
1608 status = (jboolean)item->enabled;
1615 return (jboolean)false;
1620 /* JVM_AssertionStatusDirectives */
1622 jobject JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)
1624 #if defined(ENABLE_ASSERTION)
1629 TRACEJVMCALLS(("JVM_AssertionStatusDirectives(env=%p, unused=%p)", env, unused));
1631 #if defined(ENABLE_ASSERTION)
1632 ObjectArray classes(assertion_class_count, class_java_lang_Object);
1634 ObjectArray classes(0, class_java_lang_Object);
1636 if (classes.is_null())
1639 #if defined(ENABLE_ASSERTION)
1640 ObjectArray packages(assertion_package_count, class_java_lang_Object);
1642 ObjectArray packages(0, class_java_lang_Object);
1644 if (packages.is_null())
1647 #if defined(ENABLE_ASSERTION)
1648 BooleanArray classEnabled(assertion_class_count);
1650 BooleanArray classEnabled(0);
1652 if (classEnabled.is_null())
1655 #if defined(ENABLE_ASSERTION)
1656 BooleanArray packageEnabled(assertion_package_count);
1658 BooleanArray packageEnabled(0);
1660 if (packageEnabled.is_null())
1663 #if defined(ENABLE_ASSERTION)
1664 /* initialize arrays */
1666 if (list_assertion_names != NULL) {
1670 for (List<assertion_name_t*>::iterator it = list_assertion_names->begin(); it != list_assertion_names->end(); it++) {
1671 assertion_name_t* item = *it;
1673 js = javastring_new_from_ascii(item->name);
1678 if (item->package == false) {
1679 classes.set_element(i, js);
1680 classEnabled.set_element(i, (jboolean) item->enabled);
1684 packages.set_element(j, js);
1685 packageEnabled.set_element(j, (jboolean) item->enabled);
1692 /* set instance fields */
1694 java_lang_AssertionStatusDirectives jlasd(
1695 classes.get_handle(),
1696 classEnabled.get_handle(),
1697 packages.get_handle(),
1698 packageEnabled.get_handle());
1700 return (jobject) jlasd.get_handle();
1704 /* JVM_GetClassNameUTF */
1706 const char *JVM_GetClassNameUTF(JNIEnv *env, jclass cls)
1708 log_println("JVM_GetClassNameUTF: IMPLEMENT ME!");
1714 /* JVM_GetClassCPTypes */
1716 void JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types)
1718 log_println("JVM_GetClassCPTypes: IMPLEMENT ME!");
1722 /* JVM_GetClassCPEntriesCount */
1724 jint JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)
1726 log_println("JVM_GetClassCPEntriesCount: IMPLEMENT ME!");
1732 /* JVM_GetClassFieldsCount */
1734 jint JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)
1736 log_println("JVM_GetClassFieldsCount: IMPLEMENT ME!");
1742 /* JVM_GetClassMethodsCount */
1744 jint JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)
1746 log_println("JVM_GetClassMethodsCount: IMPLEMENT ME!");
1752 /* JVM_GetMethodIxExceptionIndexes */
1754 void JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions)
1756 log_println("JVM_GetMethodIxExceptionIndexes: IMPLEMENT ME!");
1760 /* JVM_GetMethodIxExceptionsCount */
1762 jint JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)
1764 log_println("JVM_GetMethodIxExceptionsCount: IMPLEMENT ME!");
1770 /* JVM_GetMethodIxByteCode */
1772 void JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code)
1774 log_println("JVM_GetMethodIxByteCode: IMPLEMENT ME!");
1778 /* JVM_GetMethodIxByteCodeLength */
1780 jint JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)
1782 log_println("JVM_GetMethodIxByteCodeLength: IMPLEMENT ME!");
1788 /* JVM_GetMethodIxExceptionTableEntry */
1790 void JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry)
1792 log_println("JVM_GetMethodIxExceptionTableEntry: IMPLEMENT ME!");
1796 /* JVM_GetMethodIxExceptionTableLength */
1798 jint JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)
1800 log_println("JVM_GetMethodIxExceptionTableLength: IMPLEMENT ME!");
1806 /* JVM_GetMethodIxModifiers */
1808 jint JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)
1810 log_println("JVM_GetMethodIxModifiers: IMPLEMENT ME!");
1816 /* JVM_GetFieldIxModifiers */
1818 jint JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)
1820 log_println("JVM_GetFieldIxModifiers: IMPLEMENT ME!");
1826 /* JVM_GetMethodIxLocalsCount */
1828 jint JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)
1830 log_println("JVM_GetMethodIxLocalsCount: IMPLEMENT ME!");
1836 /* JVM_GetMethodIxArgsSize */
1838 jint JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)
1840 log_println("JVM_GetMethodIxArgsSize: IMPLEMENT ME!");
1846 /* JVM_GetMethodIxMaxStack */
1848 jint JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)
1850 log_println("JVM_GetMethodIxMaxStack: IMPLEMENT ME!");
1856 /* JVM_IsConstructorIx */
1858 jboolean JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)
1860 log_println("JVM_IsConstructorIx: IMPLEMENT ME!");
1866 /* JVM_GetMethodIxNameUTF */
1868 const char *JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)
1870 log_println("JVM_GetMethodIxNameUTF: IMPLEMENT ME!");
1876 /* JVM_GetMethodIxSignatureUTF */
1878 const char *JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)
1880 log_println("JVM_GetMethodIxSignatureUTF: IMPLEMENT ME!");
1886 /* JVM_GetCPFieldNameUTF */
1888 const char *JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1890 log_println("JVM_GetCPFieldNameUTF: IMPLEMENT ME!");
1896 /* JVM_GetCPMethodNameUTF */
1898 const char *JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1900 log_println("JVM_GetCPMethodNameUTF: IMPLEMENT ME!");
1906 /* JVM_GetCPMethodSignatureUTF */
1908 const char *JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
1910 log_println("JVM_GetCPMethodSignatureUTF: IMPLEMENT ME!");
1916 /* JVM_GetCPFieldSignatureUTF */
1918 const char *JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
1920 log_println("JVM_GetCPFieldSignatureUTF: IMPLEMENT ME!");
1926 /* JVM_GetCPClassNameUTF */
1928 const char *JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1930 log_println("JVM_GetCPClassNameUTF: IMPLEMENT ME!");
1936 /* JVM_GetCPFieldClassNameUTF */
1938 const char *JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1940 log_println("JVM_GetCPFieldClassNameUTF: IMPLEMENT ME!");
1946 /* JVM_GetCPMethodClassNameUTF */
1948 const char *JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1950 log_println("JVM_GetCPMethodClassNameUTF: IMPLEMENT ME!");
1956 /* JVM_GetCPFieldModifiers */
1958 jint JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
1960 log_println("JVM_GetCPFieldModifiers: IMPLEMENT ME!");
1966 /* JVM_GetCPMethodModifiers */
1968 jint JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
1970 log_println("JVM_GetCPMethodModifiers: IMPLEMENT ME!");
1976 /* JVM_ReleaseUTF */
1978 void JVM_ReleaseUTF(const char *utf)
1980 log_println("JVM_ReleaseUTF: IMPLEMENT ME!");
1984 /* JVM_IsSameClassPackage */
1986 jboolean JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2)
1988 log_println("JVM_IsSameClassPackage: IMPLEMENT ME!");
1996 /* Taken from: hotspot/src/share/vm/prims/jvm.h */
1999 * JVM I/O error codes
2001 #define JVM_EEXIST -100
2003 jint JVM_Open(const char* fname, jint flags, jint mode)
2007 TRACEJVMCALLS(("JVM_Open(fname=%s, flags=%d, mode=%d)", fname, flags, mode));
2009 HPI& hpi = VM::get_current()->get_hpi();
2010 result = hpi.get_file().Open(fname, flags, mode);
2028 jint JVM_Close(jint fd)
2030 TRACEJVMCALLS(("JVM_Close(fd=%d)", fd));
2032 HPI& hpi = VM::get_current()->get_hpi();
2033 return hpi.get_file().Close(fd);
2039 jint JVM_Read(jint fd, char* buf, jint nbytes)
2041 TRACEJVMCALLS(("JVM_Read(fd=%d, buf=%p, nbytes=%d)", fd, buf, nbytes));
2043 HPI& hpi = VM::get_current()->get_hpi();
2044 return (jint) hpi.get_file().Read(fd, buf, nbytes);
2050 jint JVM_Write(jint fd, char* buf, jint nbytes)
2052 TRACEJVMCALLS(("JVM_Write(fd=%d, buf=%s, nbytes=%d)", fd, buf, nbytes));
2054 HPI& hpi = VM::get_current()->get_hpi();
2055 return (jint) hpi.get_file().Write(fd, buf, nbytes);
2061 jint JVM_Available(jint fd, jlong* pbytes)
2063 TRACEJVMCALLS(("JVM_Available(fd=%d, pbytes=%p)", fd, pbytes));
2065 HPI& hpi = VM::get_current()->get_hpi();
2066 return hpi.get_file().Available(fd, pbytes);
2072 jlong JVM_Lseek(jint fd, jlong offset, jint whence)
2074 TRACEJVMCALLS(("JVM_Lseek(fd=%d, offset=%ld, whence=%d)", fd, offset, whence));
2076 HPI& hpi = VM::get_current()->get_hpi();
2077 return hpi.get_file().Seek(fd, (off_t) offset, whence);
2083 jint JVM_SetLength(jint fd, jlong length)
2085 TRACEJVMCALLS(("JVM_SetLength(fd=%d, length=%ld)", length));
2087 HPI& hpi = VM::get_current()->get_hpi();
2088 return hpi.get_file().SetLength(fd, length);
2094 jint JVM_Sync(jint fd)
2096 TRACEJVMCALLS(("JVM_Sync(fd=%d)", fd));
2098 HPI& hpi = VM::get_current()->get_hpi();
2099 return hpi.get_file().Sync(fd);
2103 /* JVM_StartThread */
2105 void JVM_StartThread(JNIEnv* env, jobject jthread)
2107 TRACEJVMCALLS(("JVM_StartThread(env=%p, jthread=%p)", env, jthread));
2109 threads_thread_start((java_handle_t *) jthread);
2113 /* JVM_StopThread */
2115 void JVM_StopThread(JNIEnv* env, jobject jthread, jobject throwable)
2117 log_println("JVM_StopThread: Deprecated. Not implemented.");
2121 /* JVM_IsThreadAlive */
2123 jboolean JVM_IsThreadAlive(JNIEnv* env, jobject jthread)
2129 TRACEJVMCALLS(("JVM_IsThreadAlive(env=%p, jthread=%p)", env, jthread));
2131 h = (java_handle_t *) jthread;
2132 t = thread_get_thread(h);
2134 /* The threadobject is null when a thread is created in Java. */
2139 result = threads_thread_is_alive(t);
2145 /* JVM_SuspendThread */
2147 void JVM_SuspendThread(JNIEnv* env, jobject jthread)
2149 log_println("JVM_SuspendThread: Deprecated. Not implemented.");
2153 /* JVM_ResumeThread */
2155 void JVM_ResumeThread(JNIEnv* env, jobject jthread)
2157 log_println("JVM_ResumeThread: Deprecated. Not implemented.");
2161 /* JVM_SetThreadPriority */
2163 void JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio)
2168 TRACEJVMCALLS(("JVM_SetThreadPriority(env=%p, jthread=%p, prio=%d)", env, jthread, prio));
2170 h = (java_handle_t *) jthread;
2171 t = thread_get_thread(h);
2173 /* The threadobject is null when a thread is created in Java. The
2174 priority is set later during startup. */
2179 threads_set_thread_priority(t->tid, prio);
2185 void JVM_Yield(JNIEnv *env, jclass threadClass)
2187 TRACEJVMCALLS(("JVM_Yield(env=%p, threadClass=%p)", env, threadClass));
2195 void JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis)
2197 TRACEJVMCALLS(("JVM_Sleep(env=%p, threadClass=%p, millis=%ld)", env, threadClass, millis));
2199 threads_sleep(millis, 0);
2203 /* JVM_CurrentThread */
2205 jobject JVM_CurrentThread(JNIEnv* env, jclass threadClass)
2209 TRACEJVMCALLSVERBOSE(("JVM_CurrentThread(env=%p, threadClass=%p)", env, threadClass));
2211 o = thread_get_current_object();
2217 /* JVM_CountStackFrames */
2219 jint JVM_CountStackFrames(JNIEnv* env, jobject jthread)
2221 log_println("JVM_CountStackFrames: Deprecated. Not implemented.");
2229 void JVM_Interrupt(JNIEnv* env, jobject jthread)
2234 TRACEJVMCALLS(("JVM_Interrupt(env=%p, jthread=%p)", env, jthread));
2236 h = (java_handle_t *) jthread;
2237 t = thread_get_thread(h);
2239 /* The threadobject is null when a thread is created in Java. */
2244 threads_thread_interrupt(t);
2248 /* JVM_IsInterrupted */
2250 jboolean JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted)
2254 jboolean interrupted;
2256 TRACEJVMCALLS(("JVM_IsInterrupted(env=%p, jthread=%p, clear_interrupted=%d)", env, jthread, clear_interrupted));
2258 h = (java_handle_t *) jthread;
2259 t = thread_get_thread(h);
2261 /* The threadobject is null when a thread is created in Java. */
2266 interrupted = thread_is_interrupted(t);
2268 if (interrupted && clear_interrupted)
2269 thread_set_interrupted(t, false);
2277 jboolean JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj)
2282 TRACEJVMCALLS(("JVM_HoldsLock(env=%p, threadClass=%p, obj=%p)", env, threadClass, obj));
2284 h = (java_handle_t *) obj;
2287 exceptions_throw_nullpointerexception();
2291 result = lock_is_held_by_current_thread(h);
2297 /* JVM_DumpAllStacks */
2299 void JVM_DumpAllStacks(JNIEnv* env, jclass unused)
2301 log_println("JVM_DumpAllStacks: IMPLEMENT ME!");
2305 /* JVM_CurrentLoadedClass */
2307 jclass JVM_CurrentLoadedClass(JNIEnv *env)
2309 log_println("JVM_CurrentLoadedClass: IMPLEMENT ME!");
2315 /* JVM_CurrentClassLoader */
2317 jobject JVM_CurrentClassLoader(JNIEnv *env)
2319 /* XXX if a method in a class in a trusted loader is in a
2320 doPrivileged, return NULL */
2322 log_println("JVM_CurrentClassLoader: IMPLEMENT ME!");
2328 /* JVM_GetClassContext */
2330 jobjectArray JVM_GetClassContext(JNIEnv *env)
2332 TRACEJVMCALLS(("JVM_GetClassContext(env=%p)", env));
2334 return stacktrace_getClassContext();
2338 /* JVM_ClassDepth */
2340 jint JVM_ClassDepth(JNIEnv *env, jstring name)
2342 log_println("JVM_ClassDepth: IMPLEMENT ME!");
2348 /* JVM_ClassLoaderDepth */
2350 jint JVM_ClassLoaderDepth(JNIEnv *env)
2352 log_println("JVM_ClassLoaderDepth: IMPLEMENT ME!");
2358 /* JVM_GetSystemPackage */
2360 jstring JVM_GetSystemPackage(JNIEnv *env, jstring name)
2366 TRACEJVMCALLS(("JVM_GetSystemPackage(env=%p, name=%p)", env, name));
2368 /* s = Package::find(name); */
2369 u = javastring_toutf((java_handle_t *) name, false);
2371 result = Package::find(u);
2374 s = javastring_new(result);
2382 /* JVM_GetSystemPackages */
2384 jobjectArray JVM_GetSystemPackages(JNIEnv *env)
2386 log_println("JVM_GetSystemPackages: IMPLEMENT ME!");
2392 /* JVM_AllocateNewObject */
2394 jobject JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass)
2396 log_println("JVM_AllocateNewObject: IMPLEMENT ME!");
2402 /* JVM_AllocateNewArray */
2404 jobject JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length)
2406 log_println("JVM_AllocateNewArray: IMPLEMENT ME!");
2412 /* JVM_LatestUserDefinedLoader */
2414 jobject JVM_LatestUserDefinedLoader(JNIEnv *env)
2418 TRACEJVMCALLS(("JVM_LatestUserDefinedLoader(env=%p)", env));
2420 cl = stacktrace_first_nonnull_classloader();
2422 return (jobject) cl;
2426 /* JVM_LoadClass0 */
2428 jclass JVM_LoadClass0(JNIEnv *env, jobject receiver, jclass currClass, jstring currClassName)
2430 log_println("JVM_LoadClass0: IMPLEMENT ME!");
2436 /* JVM_GetArrayLength */
2438 jint JVM_GetArrayLength(JNIEnv *env, jobject arr)
2440 TRACEJVMCALLS(("JVM_GetArrayLength(arr=%p)", arr));
2443 exceptions_throw_nullpointerexception();
2449 // Check for exception in constructor.
2454 return a.get_length();
2458 /* JVM_GetArrayElement */
2460 jobject JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index)
2462 TRACEJVMCALLS(("JVM_GetArrayElement(env=%p, arr=%p, index=%d)", env, arr, index));
2466 /* if (!class_is_array(a->objheader.vftbl->class)) { */
2467 /* exceptions_throw_illegalargumentexception(); */
2471 return a.get_boxed_element(index);
2475 /* JVM_GetPrimitiveArrayElement */
2477 jvalue JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode)
2481 log_println("JVM_GetPrimitiveArrayElement: IMPLEMENT ME!");
2489 /* JVM_SetArrayElement */
2491 void JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val)
2493 TRACEJVMCALLS(("JVM_SetArrayElement(env=%p, arr=%p, index=%d, val=%p)", env, arr, index, val));
2497 a.set_boxed_element(index, val);
2501 /* JVM_SetPrimitiveArrayElement */
2503 void JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode)
2505 log_println("JVM_SetPrimitiveArrayElement: IMPLEMENT ME!");
2511 jobject JVM_NewArray(JNIEnv *env, jclass eltClass, jint length)
2513 TRACEJVMCALLS(("JVM_NewArray(env=%p, eltClass=%p, length=%d)", env, eltClass, length));
2515 if (eltClass == NULL) {
2516 exceptions_throw_nullpointerexception();
2520 /* NegativeArraySizeException is checked by array constructor. */
2522 classinfo* c = LLNI_classinfo_unwrap(eltClass);
2524 /* Create primitive or object array. */
2526 if (class_is_primitive(c)) {
2527 classinfo* pc = Primitive::get_arrayclass_by_name(c->name);
2529 /* void arrays are not allowed. */
2532 exceptions_throw_illegalargumentexception();
2536 Array a(length, pc);
2538 return (jobject) a.get_handle();
2541 ObjectArray oa(length, c);
2543 return (jobject) oa.get_handle();
2548 /* JVM_NewMultiArray */
2550 jobject JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim)
2558 java_handle_objectarray_t *a;
2560 TRACEJVMCALLS(("JVM_NewMultiArray(env=%p, eltClass=%p, dim=%p)", env, eltClass, dim));
2562 if (eltClass == NULL) {
2563 exceptions_throw_nullpointerexception();
2567 /* NegativeArraySizeException is checked in builtin_newarray. */
2569 c = LLNI_classinfo_unwrap(eltClass);
2573 /* We check here for exceptions thrown in array_length_get,
2574 otherwise these exceptions get overwritten by the following
2575 IllegalArgumentException. */
2580 length = ia.get_length();
2582 if ((length <= 0) || (length > /* MAX_DIM */ 255)) {
2583 exceptions_throw_illegalargumentexception();
2587 /* XXX This is just a quick hack to get it working. */
2589 dims = MNEW(long, length);
2591 for (i = 0; i < length; i++) {
2592 value = ia.get_element(i);
2593 dims[i] = (long) value;
2596 /* Create an array-class if necessary. */
2598 if (class_is_primitive(c)) {
2599 ac = Primitive::get_arrayclass_by_name(c->name);
2601 // Arrays of void are not allowed.
2603 exceptions_throw_illegalargumentexception();
2608 ac = class_multiarray_of((length - 1), ac, true);
2611 ac = class_multiarray_of(length, c, true);
2616 /* Allocate a new array on the heap. */
2618 a = builtin_multianewarray(length, (java_handle_t *) ac, dims);
2624 /* JVM_InitializeSocketLibrary */
2626 jint JVM_InitializeSocketLibrary()
2628 TRACEJVMCALLS(("JVM_InitializeSocketLibrary()"));
2630 HPI& hpi = VM::get_current()->get_hpi();
2631 return hpi.initialize_socket_library();
2637 jint JVM_Socket(jint domain, jint type, jint protocol)
2639 TRACEJVMCALLS(("JVM_Socket(domain=%d, type=%d, protocol=%d)", domain, type, protocol));
2641 return os::socket(domain, type, protocol);
2645 /* JVM_SocketClose */
2647 jint JVM_SocketClose(jint fd)
2649 TRACEJVMCALLS(("JVM_SocketClose(fd=%d)", fd));
2651 return os::close(fd);
2655 /* JVM_SocketShutdown */
2657 jint JVM_SocketShutdown(jint fd, jint howto)
2659 TRACEJVMCALLS(("JVM_SocketShutdown(fd=%d, howto=%d)", fd, howto));
2661 return os::shutdown(fd, howto);
2667 jint JVM_Recv(jint fd, char *buf, jint nBytes, jint flags)
2669 log_println("JVM_Recv: IMPLEMENT ME!");
2677 jint JVM_Send(jint fd, char *buf, jint nBytes, jint flags)
2679 TRACEJVMCALLSENTER(("JVM_Send(fd=%d, buf=%p, nBytes=%d, flags=%d", fd, buf, nBytes, flags));
2681 int result = os::send(fd, buf, nBytes, flags);
2683 TRACEJVMCALLSEXIT(("->%d", result));
2691 jint JVM_Timeout(int fd, long timeout)
2693 log_println("JVM_Timeout: IMPLEMENT ME!");
2701 jint JVM_Listen(jint fd, jint count)
2703 TRACEJVMCALLS(("JVM_Listen(fd=%d, count=%d)", fd, count));
2705 return os::listen(fd, count);
2711 jint JVM_Connect(jint fd, struct sockaddr *him, jint len)
2713 TRACEJVMCALLS(("JVM_Connect(fd=%d, him=%p, len=%d)", fd, him, len));
2715 return os::connect(fd, him, len);
2721 jint JVM_Bind(jint fd, struct sockaddr *him, jint len)
2723 log_println("JVM_Bind: IMPLEMENT ME!");
2731 jint JVM_Accept(jint fd, struct sockaddr *him, jint *len)
2733 TRACEJVMCALLS(("JVM_Accept(fd=%d, him=%p, len=%p)", fd, him, len));
2735 return os::accept(fd, him, (socklen_t *) len);
2741 jint JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen)
2743 log_println("JVM_RecvFrom: IMPLEMENT ME!");
2749 /* JVM_GetSockName */
2751 jint JVM_GetSockName(jint fd, struct sockaddr *him, int *len)
2753 TRACEJVMCALLS(("JVM_GetSockName(fd=%d, him=%p, len=%p)", fd, him, len));
2755 return os::getsockname(fd, him, (socklen_t *) len);
2761 jint JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen)
2763 log_println("JVM_SendTo: IMPLEMENT ME!");
2769 /* JVM_SocketAvailable */
2771 jint JVM_SocketAvailable(jint fd, jint *pbytes)
2773 #if defined(FIONREAD)
2777 TRACEJVMCALLS(("JVM_SocketAvailable(fd=%d, pbytes=%p)", fd, pbytes));
2781 result = ioctl(fd, FIONREAD, &bytes);
2790 # error FIONREAD not defined
2795 /* JVM_GetSockOpt */
2797 jint JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen)
2799 TRACEJVMCALLS(("JVM_GetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%p)", fd, level, optname, optval, optlen));
2801 return os::getsockopt(fd, level, optname, optval, (socklen_t *) optlen);
2805 /* JVM_SetSockOpt */
2807 jint JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen)
2809 TRACEJVMCALLS(("JVM_SetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%d)", fd, level, optname, optval, optlen));
2811 return os::setsockopt(fd, level, optname, optval, optlen);
2815 /* JVM_GetHostName */
2817 int JVM_GetHostName(char *name, int namelen)
2821 TRACEJVMCALLSENTER(("JVM_GetHostName(name=%s, namelen=%d)", name, namelen));
2823 result = os::gethostname(name, namelen);
2825 TRACEJVMCALLSEXIT(("->%d (name=%s)", result, name));
2831 /* JVM_GetHostByAddr */
2833 struct hostent *JVM_GetHostByAddr(const char* name, int len, int type)
2835 log_println("JVM_GetHostByAddr: IMPLEMENT ME!");
2841 /* JVM_GetHostByName */
2843 struct hostent *JVM_GetHostByName(char* name)
2845 log_println("JVM_GetHostByName: IMPLEMENT ME!");
2851 /* JVM_GetProtoByName */
2853 struct protoent *JVM_GetProtoByName(char* name)
2855 log_println("JVM_GetProtoByName: IMPLEMENT ME!");
2861 /* JVM_LoadLibrary */
2863 void* JVM_LoadLibrary(const char* name)
2865 TRACEJVMCALLSENTER(("JVM_LoadLibrary(name=%s)", name));
2867 utf* u = utf_new_char(name);
2869 NativeLibrary nl(u);
2870 void* handle = nl.open();
2872 TRACEJVMCALLSEXIT(("->%p", handle));
2878 /* JVM_UnloadLibrary */
2880 void JVM_UnloadLibrary(void* handle)
2882 TRACEJVMCALLS(("JVM_UnloadLibrary(handle=%p)", handle));
2884 NativeLibrary nl(handle);
2889 /* JVM_FindLibraryEntry */
2891 void *JVM_FindLibraryEntry(void* handle, const char* name)
2895 TRACEJVMCALLSENTER(("JVM_FindLibraryEntry(handle=%p, name=%s)", handle, name));
2897 HPI& hpi = VM::get_current()->get_hpi();
2898 symbol = hpi.get_library().FindLibraryEntry(handle, name);
2900 TRACEJVMCALLSEXIT(("->%p", symbol));
2908 jboolean JVM_IsNaN(jdouble d)
2912 TRACEJVMCALLSENTER(("JVM_IsNaN(d=%f)", d));
2916 TRACEJVMCALLSEXIT(("->%d", result));
2922 /* JVM_IsSupportedJNIVersion */
2924 jboolean JVM_IsSupportedJNIVersion(jint version)
2926 TRACEJVMCALLS(("JVM_IsSupportedJNIVersion(version=%d)", version));
2928 return jni_version_check(version);
2932 /* JVM_InternString */
2934 jstring JVM_InternString(JNIEnv *env, jstring str)
2936 TRACEJVMCALLS(("JVM_InternString(env=%p, str=%p)", env, str));
2938 return (jstring) javastring_intern((java_handle_t *) str);
2942 /* JVM_RawMonitorCreate */
2944 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void)
2946 TRACEJVMCALLS(("JVM_RawMonitorCreate()"));
2948 Mutex* m = new Mutex();
2954 /* JVM_RawMonitorDestroy */
2956 JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void* mon)
2958 TRACEJVMCALLS(("JVM_RawMonitorDestroy(mon=%p)", mon));
2960 delete ((Mutex*) mon);
2964 /* JVM_RawMonitorEnter */
2966 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void* mon)
2968 TRACEJVMCALLS(("JVM_RawMonitorEnter(mon=%p)", mon));
2970 ((Mutex*) mon)->lock();
2976 /* JVM_RawMonitorExit */
2978 JNIEXPORT void JNICALL JVM_RawMonitorExit(void* mon)
2980 TRACEJVMCALLS(("JVM_RawMonitorExit(mon=%p)", mon));
2982 ((Mutex*) mon)->unlock();
2986 /* JVM_SetPrimitiveFieldValues */
2988 void JVM_SetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
2990 log_println("JVM_SetPrimitiveFieldValues: IMPLEMENT ME!");
2994 /* JVM_GetPrimitiveFieldValues */
2996 void JVM_GetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
2998 log_println("JVM_GetPrimitiveFieldValues: IMPLEMENT ME!");
3002 /* JVM_AccessVMBooleanFlag */
3004 jboolean JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get)
3006 log_println("JVM_AccessVMBooleanFlag: IMPLEMENT ME!");
3012 /* JVM_AccessVMIntFlag */
3014 jboolean JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get)
3016 log_println("JVM_AccessVMIntFlag: IMPLEMENT ME!");
3022 /* JVM_VMBreakPoint */
3024 void JVM_VMBreakPoint(JNIEnv *env, jobject obj)
3026 log_println("JVM_VMBreakPoint: IMPLEMENT ME!");
3030 /* JVM_GetClassFields */
3032 jobjectArray JVM_GetClassFields(JNIEnv *env, jclass cls, jint which)
3034 log_println("JVM_GetClassFields: IMPLEMENT ME!");
3040 /* JVM_GetClassMethods */
3042 jobjectArray JVM_GetClassMethods(JNIEnv *env, jclass cls, jint which)
3044 log_println("JVM_GetClassMethods: IMPLEMENT ME!");
3050 /* JVM_GetClassConstructors */
3052 jobjectArray JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which)
3054 log_println("JVM_GetClassConstructors: IMPLEMENT ME!");
3060 /* JVM_GetClassField */
3062 jobject JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which)
3064 log_println("JVM_GetClassField: IMPLEMENT ME!");
3070 /* JVM_GetClassMethod */
3072 jobject JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types, jint which)
3074 log_println("JVM_GetClassMethod: IMPLEMENT ME!");
3080 /* JVM_GetClassConstructor */
3082 jobject JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types, jint which)
3084 log_println("JVM_GetClassConstructor: IMPLEMENT ME!");
3090 /* JVM_NewInstance */
3092 jobject JVM_NewInstance(JNIEnv *env, jclass cls)
3094 log_println("JVM_NewInstance: IMPLEMENT ME!");
3102 jobject JVM_GetField(JNIEnv *env, jobject field, jobject obj)
3104 log_println("JVM_GetField: IMPLEMENT ME!");
3110 /* JVM_GetPrimitiveField */
3112 jvalue JVM_GetPrimitiveField(JNIEnv *env, jobject field, jobject obj, unsigned char wCode)
3116 log_println("JVM_GetPrimitiveField: IMPLEMENT ME!");
3126 void JVM_SetField(JNIEnv *env, jobject field, jobject obj, jobject val)
3128 log_println("JVM_SetField: IMPLEMENT ME!");
3132 /* JVM_SetPrimitiveField */
3134 void JVM_SetPrimitiveField(JNIEnv *env, jobject field, jobject obj, jvalue v, unsigned char vCode)
3136 log_println("JVM_SetPrimitiveField: IMPLEMENT ME!");
3140 /* JVM_InvokeMethod */
3142 jobject JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)
3144 TRACEJVMCALLS(("JVM_InvokeMethod(env=%p, method=%p, obj=%p, args0=%p)", env, method, obj, args0));
3146 java_lang_reflect_Method jlrm(method);
3148 java_handle_t* result = jlrm.invoke((java_handle_t*) obj, (java_handle_objectarray_t*) args0);
3150 return (jobject) result;
3154 /* JVM_NewInstanceFromConstructor */
3156 jobject JVM_NewInstanceFromConstructor(JNIEnv *env, jobject con, jobjectArray args0)
3158 TRACEJVMCALLS(("JVM_NewInstanceFromConstructor(env=%p, c=%p, args0=%p)", env, con, args0));
3160 java_lang_reflect_Constructor jlrc(con);
3161 java_handle_t* o = jlrc.new_instance((java_handle_objectarray_t*) args0);
3167 /* JVM_SupportsCX8 */
3169 jboolean JVM_SupportsCX8()
3171 TRACEJVMCALLS(("JVM_SupportsCX8()"));
3181 jboolean JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal)
3183 log_println("JVM_CX8Field: IMPLEMENT ME!");
3189 /* JVM_GetAllThreads */
3191 jobjectArray JVM_GetAllThreads(JNIEnv *env, jclass dummy)
3193 // Get a list of all active threads.
3194 list<threadobject*> active_threads;
3195 ThreadList::get_active_threads(active_threads);
3197 // Allocate array to hold the java.lang.Thread objects.
3198 int32_t length = active_threads.size();
3199 ObjectArray oa(length, class_java_lang_Thread);
3204 // Iterate over all threads (which were active just a second ago).
3206 for (List<threadobject*>::iterator it = active_threads.begin(); it != active_threads.end(); it++) {
3207 threadobject* t = *it;
3209 java_handle_t* h = thread_get_object(t);
3212 oa.set_element(index, h);
3217 return oa.get_handle();
3221 /* JVM_DumpThreads */
3223 jobjectArray JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads)
3227 TRACEJVMCALLS(("JVM_DumpThreads((env=%p, threadClass=%p, threads=%p)", env, threadClass, threads));
3229 if (threads == NULL) {
3230 exceptions_throw_nullpointerexception();
3234 ObjectArray oa(threads);
3236 // Get length of the threads array.
3237 int32_t length = oa.get_length();
3240 exceptions_throw_illegalargumentexception();
3244 // Allocate array to hold stacktraces.
3245 classinfo* arrayclass = class_array_of(class_java_lang_StackTraceElement, true);
3246 ObjectArray oaresult(length, arrayclass);
3248 if (oaresult.is_null()) {
3252 // Iterate over all passed thread objects.
3253 for (i = 0; i < length; i++) {
3254 java_handle_t* thread = oa.get_element(i);
3256 // Get thread for the given thread object.
3257 threadobject* t = thread_get_thread(thread);
3259 // The threadobject is null when a thread is created in Java.
3263 // Get stacktrace for given thread.
3264 stacktrace_t* st = stacktrace_get_of_thread(t);
3266 // Convert stacktrace into array of StackTraceElements.
3267 java_handle_objectarray_t* oaste = stacktrace_get_StackTraceElements(st);
3272 oaresult.set_element(i, oaste);
3275 return oaresult.get_handle();
3279 /* JVM_GetManagement */
3281 void *JVM_GetManagement(jint version)
3283 TRACEJVMCALLS(("JVM_GetManagement(version=%d)", version));
3285 return Management::get_jmm_interface(version);
3289 /* JVM_InitAgentProperties */
3291 jobject JVM_InitAgentProperties(JNIEnv *env, jobject properties)
3293 log_println("JVM_InitAgentProperties: IMPLEMENT ME!");
3299 /* JVM_GetEnclosingMethodInfo */
3301 jobjectArray JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass)
3303 TRACEJVMCALLS(("JVM_GetEnclosingMethodInfo(env=%p, ofClass=%p)", env, ofClass));
3305 classinfo* c = LLNI_classinfo_unwrap(ofClass);
3307 if ((c == NULL) || class_is_primitive(c))
3310 methodinfo* m = class_get_enclosingmethod_raw(c);
3315 ObjectArray oa(3, class_java_lang_Object);
3320 oa.set_element(0, (java_handle_t *) LLNI_classinfo_wrap(m->clazz));
3321 oa.set_element(1, javastring_new(m->name));
3322 oa.set_element(2, javastring_new(m->descriptor));
3324 return oa.get_handle();
3328 /* JVM_GetThreadStateValues */
3330 jintArray JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState)
3332 TRACEJVMCALLS(("JVM_GetThreadStateValues(env=%p, javaThreadState=%d)",
3333 env, javaThreadState));
3335 /* If new thread states are added in future JDK and VM versions,
3336 this should check if the JDK version is compatible with thread
3337 states supported by the VM. Return NULL if not compatible.
3339 This function must map the VM java_lang_Thread::ThreadStatus
3340 to the Java thread state that the JDK supports. */
3342 switch (javaThreadState) {
3343 case THREAD_STATE_NEW:
3350 ia.set_element(0, THREAD_STATE_NEW);
3351 return ia.get_handle();
3354 case THREAD_STATE_RUNNABLE:
3361 ia.set_element(0, THREAD_STATE_RUNNABLE);
3362 return ia.get_handle();
3365 case THREAD_STATE_BLOCKED:
3372 ia.set_element(0, THREAD_STATE_BLOCKED);
3373 return ia.get_handle();
3376 case THREAD_STATE_WAITING:
3383 ia.set_element(0, THREAD_STATE_WAITING);
3384 ia.set_element(1, THREAD_STATE_PARKED);
3385 return ia.get_handle();
3388 case THREAD_STATE_TIMED_WAITING:
3395 /* XXX Not sure about that one. */
3396 /* ia.set_element(0, SLEEPING); */
3397 ia.set_element(0, THREAD_STATE_TIMED_WAITING);
3398 ia.set_element(1, THREAD_STATE_TIMED_PARKED);
3399 return ia.get_handle();
3402 case THREAD_STATE_TERMINATED:
3409 ia.set_element(0, THREAD_STATE_TERMINATED);
3410 return ia.get_handle();
3414 /* Unknown state - probably incompatible JDK version */
3420 /* JVM_GetThreadStateNames */
3422 jobjectArray JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values)
3426 TRACEJVMCALLS(("JVM_GetThreadStateNames(env=%p, javaThreadState=%d, values=%p)",
3427 env, javaThreadState, values));
3429 IntArray ia(values);
3431 /* If new thread states are added in future JDK and VM versions,
3432 this should check if the JDK version is compatible with thread
3433 states supported by the VM. Return NULL if not compatible.
3435 This function must map the VM java_lang_Thread::ThreadStatus
3436 to the Java thread state that the JDK supports. */
3438 if (values == NULL) {
3439 exceptions_throw_nullpointerexception();
3443 switch (javaThreadState) {
3444 case THREAD_STATE_NEW:
3446 assert(ia.get_length() == 1 && ia.get_element(0) == THREAD_STATE_NEW);
3448 ObjectArray oa(1, class_java_lang_String);
3453 s = javastring_new(utf_new_char("NEW"));
3458 oa.set_element(0, s);
3459 return oa.get_handle();
3462 case THREAD_STATE_RUNNABLE:
3464 ObjectArray oa(1, class_java_lang_String);
3469 s = javastring_new(utf_new_char("RUNNABLE"));
3474 oa.set_element(0, s);
3475 return oa.get_handle();
3478 case THREAD_STATE_BLOCKED:
3480 ObjectArray oa(1, class_java_lang_String);
3485 s = javastring_new(utf_new_char("BLOCKED"));
3490 oa.set_element(0, s);
3491 return oa.get_handle();
3494 case THREAD_STATE_WAITING:
3496 ObjectArray oa(2, class_java_lang_String);
3501 s = javastring_new(utf_new_char("WAITING.OBJECT_WAIT"));
3506 oa.set_element(0, s);
3508 s = javastring_new(utf_new_char("WAITING.PARKED"));
3513 oa.set_element(1, s);
3514 return oa.get_handle();
3517 case THREAD_STATE_TIMED_WAITING:
3519 ObjectArray oa(2, class_java_lang_String);
3524 /* s = javastring_new(utf_new_char("TIMED_WAITING.SLEEPING")); */
3525 s = javastring_new(utf_new_char("TIMED_WAITING.OBJECT_WAIT"));
3530 oa.set_element(0, s);
3532 s = javastring_new(utf_new_char("TIMED_WAITING.PARKED"));
3537 oa.set_element(1, s);
3538 return oa.get_handle();
3541 case THREAD_STATE_TERMINATED:
3543 ObjectArray oa(1, class_java_lang_String);
3548 s = javastring_new(utf_new_char("TERMINATED"));
3553 oa.set_element(0, s);
3554 return oa.get_handle();
3558 /* Unknown state - probably incompatible JDK version */
3564 /* JVM_GetVersionInfo */
3566 void JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size)
3568 log_println("JVM_GetVersionInfo: IMPLEMENT ME!");
3572 /* OS: JVM_RegisterSignal */
3574 void *JVM_RegisterSignal(jint sig, void *handler)
3576 functionptr newHandler;
3578 TRACEJVMCALLS(("JVM_RegisterSignal(sig=%d, handler=%p)", sig, handler));
3580 if (handler == (void *) 2)
3581 newHandler = (functionptr) signal_thread_handler;
3583 newHandler = (functionptr) (uintptr_t) handler;
3590 /* These signals are already used by the VM. */
3594 /* This signal is used by the VM to dump thread stacks unless
3595 ReduceSignalUsage is set, in which case the user is allowed
3596 to set his own _native_ handler for this signal; thus, in
3597 either case, we do not allow JVM_RegisterSignal to change
3607 signal_register_signal(sig, newHandler, SA_RESTART | SA_SIGINFO);
3609 /* XXX Should return old handler. */
3615 /* OS: JVM_RaiseSignal */
3617 jboolean JVM_RaiseSignal(jint sig)
3619 log_println("JVM_RaiseSignal: IMPLEMENT ME! sig=%s", sig);
3625 /* OS: JVM_FindSignal */
3627 jint JVM_FindSignal(const char *name)
3629 TRACEJVMCALLS(("JVM_FindSignal(name=%s)", name));
3631 #if defined(__LINUX__)
3632 if (strcmp(name, "HUP") == 0)
3635 if (strcmp(name, "INT") == 0)
3638 if (strcmp(name, "TERM") == 0)
3640 #elif defined(__SOLARIS__)
3643 if (os::str2sig(name, &signum) == -1)
3648 # error Not implemented for this OS.
3658 * These are local overrides for various environment variables in Emacs.
3659 * Please do not remove this and leave it at the end of the file, where
3660 * Emacs will automagically detect them.
3661 * ---------------------------------------------------------------------
3664 * indent-tabs-mode: t
3668 * vim:noexpandtab:sw=4:ts=4: