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>
46 #include "mm/memory.h"
48 #include "native/jni.h"
49 #include "native/llni.h"
50 #include "native/native.h"
52 #include "native/vm/reflection.hpp"
54 #include "native/vm/openjdk/hpi.h"
56 #include "threads/lock-common.h"
57 #include "threads/thread.hpp"
59 #include "toolbox/logging.h"
60 #include "toolbox/list.h"
64 #if defined(ENABLE_ASSERTION)
65 #include "vm/assertion.h"
68 #include "vm/builtin.h"
69 #include "vm/classcache.h"
70 #include "vm/exceptions.hpp"
71 #include "vm/global.h"
72 #include "vm/globals.hpp"
73 #include "vm/initialize.h"
74 #include "vm/javaobjects.hpp"
75 #include "vm/options.h"
77 #include "vm/package.hpp"
78 #include "vm/primitive.hpp"
79 #include "vm/properties.h"
80 #include "vm/resolve.h"
81 #include "vm/signallocal.h"
82 #include "vm/string.hpp"
85 #include "vm/jit/stacktrace.hpp"
88 /* debugging macros ***********************************************************/
92 # define TRACEJVMCALLS(x) \
94 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
99 # define TRACEJVMCALLSENTER(x) \
101 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
107 # define TRACEJVMCALLSEXIT(x) \
109 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
115 # define TRACEJVMCALLSVERBOSE(x) \
117 if (opt_TraceJVMCallsVerbose) { \
122 # define PRINTJVMWARNINGS(x)
124 /* if (opt_PrintJVMWarnings) { \ */
125 /* log_println x; \ */
131 # define TRACEJVMCALLS(x)
132 # define TRACEJVMCALLSENTER(x)
133 # define TRACEJVMCALLSEXIT(x)
134 # define TRACEJVMCALLSVERBOSE(x)
135 # define PRINTJVMWARNINGS(x)
141 /* Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx */
142 unsigned int jvm_version; /* Consists of major, minor, micro (n.n.n) */
143 /* and build number (xx) */
144 unsigned int update_version : 8; /* Update release version (uu) */
145 unsigned int special_update_version : 8; /* Special update release version (c) */
146 unsigned int reserved1 : 16;
147 unsigned int reserved2;
149 /* The following bits represents JVM supports that JDK has dependency on.
150 * JDK can use these bits to determine which JVM version
151 * and support it has to maintain runtime compatibility.
153 * When a new bit is added in a minor or update release, make sure
154 * the new bit is also added in the main/baseline.
156 unsigned int is_attachable : 1;
164 * A structure used to a capture exception table entry in a Java method.
171 } JVM_ExceptionTableEntryType;
174 // Interface functions are exported as C functions.
177 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
179 if ((intptr_t) count <= 0)
182 return vsnprintf(str, count, fmt, args);
186 int jio_snprintf(char *str, size_t count, const char *fmt, ...)
192 len = jio_vsnprintf(str, count, fmt, ap);
199 int jio_fprintf(FILE* f, const char *fmt, ...)
201 log_println("jio_fprintf: IMPLEMENT ME!");
207 int jio_vfprintf(FILE* f, const char *fmt, va_list args)
209 log_println("jio_vfprintf: IMPLEMENT ME!");
215 int jio_printf(const char *fmt, ...)
217 log_println("jio_printf: IMPLEMENT ME!");
223 /* JVM_GetInterfaceVersion */
225 jint JVM_GetInterfaceVersion()
227 /* This is defined in hotspot/src/share/vm/prims/jvm.h */
229 #define JVM_INTERFACE_VERSION 4
231 return JVM_INTERFACE_VERSION;
235 /* JVM_CurrentTimeMillis */
237 jlong JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)
239 TRACEJVMCALLS(("JVM_CurrentTimeMillis(env=%p, ignored=%p)", env, ignored));
241 return (jlong) builtin_currenttimemillis();
247 jlong JVM_NanoTime(JNIEnv *env, jclass ignored)
249 TRACEJVMCALLS(("JVM_NanoTime(env=%p, ignored=%p)", env, ignored));
251 return (jlong) builtin_nanotime();
257 void JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos, jobject dst, jint dst_pos, jint length)
262 s = (java_handle_t *) src;
263 d = (java_handle_t *) dst;
265 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));
267 builtin_arraycopy(s, src_pos, d, dst_pos, length);
271 /* JVM_InitProperties */
273 jobject JVM_InitProperties(JNIEnv *env, jobject properties)
278 TRACEJVMCALLS(("JVM_InitProperties(env=%p, properties=%p)", env, properties));
280 h = (java_handle_t *) properties;
282 /* Convert the -XX:MaxDirectMemorySize= command line flag to the
283 sun.nio.MaxDirectMemorySize property. Do this after setting
284 user properties to prevent people from setting the value with a
285 -D option, as requested. */
287 jio_snprintf(buf, sizeof(buf), PRINTF_FORMAT_INT64_T, opt_MaxDirectMemorySize);
288 properties_add("sun.nio.MaxDirectMemorySize", buf);
290 /* Add all properties. */
292 properties_system_add_all(h);
300 void JVM_Exit(jint code)
302 log_println("JVM_Exit: IMPLEMENT ME!");
308 void JVM_Halt(jint code)
310 TRACEJVMCALLS(("JVM_Halt(code=%d)", code));
317 /* JVM_OnExit(void (*func)) */
319 void JVM_OnExit(void (*func)(void))
321 log_println("JVM_OnExit(void (*func): IMPLEMENT ME!");
329 TRACEJVMCALLS(("JVM_GC()"));
335 /* JVM_MaxObjectInspectionAge */
337 jlong JVM_MaxObjectInspectionAge(void)
339 log_println("JVM_MaxObjectInspectionAge: IMPLEMENT ME!");
345 /* JVM_TraceInstructions */
347 void JVM_TraceInstructions(jboolean on)
349 log_println("JVM_TraceInstructions: IMPLEMENT ME!");
353 /* JVM_TraceMethodCalls */
355 void JVM_TraceMethodCalls(jboolean on)
357 log_println("JVM_TraceMethodCalls: IMPLEMENT ME!");
361 /* JVM_TotalMemory */
363 jlong JVM_TotalMemory(void)
365 TRACEJVMCALLS(("JVM_TotalMemory()"));
367 return gc_get_heap_size();
373 jlong JVM_FreeMemory(void)
375 TRACEJVMCALLS(("JVM_FreeMemory()"));
377 return gc_get_free_bytes();
383 jlong JVM_MaxMemory(void)
385 TRACEJVMCALLS(("JVM_MaxMemory()"));
387 return gc_get_max_heap_size();
391 /* JVM_ActiveProcessorCount */
393 jint JVM_ActiveProcessorCount(void)
395 TRACEJVMCALLS(("JVM_ActiveProcessorCount()"));
397 return os::processors_online();
401 /* JVM_FillInStackTrace */
403 void JVM_FillInStackTrace(JNIEnv *env, jobject receiver)
405 TRACEJVMCALLS(("JVM_FillInStackTrace(env=%p, receiver=%p)", env, receiver));
407 java_handle_bytearray_t* ba = stacktrace_get_current();
412 java_lang_Throwable jlt(receiver, ba);
416 /* JVM_PrintStackTrace */
418 void JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable)
420 log_println("JVM_PrintStackTrace: IMPLEMENT ME!");
424 /* JVM_GetStackTraceDepth */
426 jint JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable)
428 TRACEJVMCALLS(("JVM_GetStackTraceDepth(env=%p, throwable=%p)", env, throwable));
430 java_lang_Throwable jlt(throwable);
433 exceptions_throw_nullpointerexception();
437 java_handle_bytearray_t* ba = jlt.get_backtrace();
442 // We need a critical section here as the stacktrace structure is
443 // mapped onto a Java byte-array.
447 stacktrace_t* st = (stacktrace_t *) LLNI_array_data(ba);
449 int32_t depth = st->length;
457 /* JVM_GetStackTraceElement */
459 jobject JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index)
461 TRACEJVMCALLS(("JVM_GetStackTraceElement(env=%p, throwable=%p, index=%d)", env, throwable, index));
463 java_lang_Throwable jlt(throwable);
464 java_handle_bytearray_t* ba = jlt.get_backtrace();
466 // We need a critical section here as the stacktrace structure is
467 // mapped onto a Java byte-array.
470 stacktrace_t* st = (stacktrace_t *) LLNI_array_data(ba);
472 if ((index < 0) || (index >= st->length)) {
473 /* XXX This should be an IndexOutOfBoundsException (check this
475 exceptions_throw_arrayindexoutofboundsexception();
479 // Get the stacktrace entry.
480 stacktrace_entry_t* ste = &(st->entries[index]);
482 // Get the codeinfo, methodinfo and classinfo.
483 codeinfo* code = ste->code;
484 methodinfo* m = code->m;
485 classinfo* c = m->clazz;
488 java_handle_t* filename;
490 if (!(m->flags & ACC_NATIVE)) {
491 if (c->sourcefile != NULL)
492 filename = javastring_new(c->sourcefile);
502 if (m->flags & ACC_NATIVE) {
506 /* FIXME The linenumbertable_linenumber_for_pc could change
507 the methodinfo pointer when hitting an inlined method. */
509 linenumber = linenumbertable_linenumber_for_pc(&m, code, ste->pc);
510 linenumber = (linenumber == 0) ? -1 : linenumber;
515 // Get declaring class name.
516 java_handle_t* declaringclass = class_get_classname(c);
518 // Allocate a new StackTraceElement object.
519 java_lang_StackTraceElement jlste(declaringclass, javastring_new(m->name), filename, linenumber);
524 return (jobject) jlste.get_handle();
530 jint JVM_IHashCode(JNIEnv* env, jobject handle)
532 TRACEJVMCALLS(("JVM_IHashCode(env=%p, jobject=%p)", env, handle));
534 return (jint) ((ptrint) handle);
538 /* JVM_MonitorWait */
540 void JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms)
542 #if defined(ENABLE_THREADS)
546 TRACEJVMCALLS(("JVM_MonitorWait(env=%p, handle=%p, ms=%ld)", env, handle, ms));
548 /* exceptions_throw_illegalargumentexception("argument out of range"); */
549 exceptions_throw_illegalargumentexception();
553 #if defined(ENABLE_THREADS)
554 o = (java_handle_t *) handle;
556 lock_wait_for_object(o, ms, 0);
561 /* JVM_MonitorNotify */
563 void JVM_MonitorNotify(JNIEnv* env, jobject handle)
565 #if defined(ENABLE_THREADS)
569 TRACEJVMCALLS(("JVM_MonitorNotify(env=%p, handle=%p)", env, handle));
571 #if defined(ENABLE_THREADS)
572 o = (java_handle_t *) handle;
574 lock_notify_object(o);
579 /* JVM_MonitorNotifyAll */
581 void JVM_MonitorNotifyAll(JNIEnv* env, jobject handle)
583 #if defined(ENABLE_THREADS)
587 TRACEJVMCALLS(("JVM_MonitorNotifyAll(env=%p, handle=%p)", env, handle));
589 #if defined(ENABLE_THREADS)
590 o = (java_handle_t *) handle;
592 lock_notify_all_object(o);
599 jobject JVM_Clone(JNIEnv* env, jobject handle)
601 TRACEJVMCALLS(("JVM_Clone(env=%p, handle=%p)", env, handle));
603 return (jobject) builtin_clone(env, (java_handle_t *) handle);
607 /* JVM_InitializeCompiler */
609 void JVM_InitializeCompiler (JNIEnv *env, jclass compCls)
611 log_println("JVM_InitializeCompiler : IMPLEMENT ME!");
615 /* JVM_IsSilentCompiler */
617 jboolean JVM_IsSilentCompiler(JNIEnv *env, jclass compCls)
619 log_println("JVM_IsSilentCompiler: IMPLEMENT ME!");
625 /* JVM_CompileClass */
627 jboolean JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls)
629 log_println("JVM_CompileClass: IMPLEMENT ME!");
635 /* JVM_CompileClasses */
637 jboolean JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname)
639 log_println("JVM_CompileClasses: IMPLEMENT ME!");
645 /* JVM_CompilerCommand */
647 jobject JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg)
649 log_println("JVM_CompilerCommand: IMPLEMENT ME!");
655 /* JVM_EnableCompiler */
657 void JVM_EnableCompiler(JNIEnv *env, jclass compCls)
659 TRACEJVMCALLS(("JVM_EnableCompiler(env=%p, compCls=%p)", env, compCls));
660 PRINTJVMWARNINGS(("JVM_EnableCompiler not supported"));
664 /* JVM_DisableCompiler */
666 void JVM_DisableCompiler(JNIEnv *env, jclass compCls)
668 TRACEJVMCALLS(("JVM_DisableCompiler(env=%p, compCls=%p)", env, compCls));
669 PRINTJVMWARNINGS(("JVM_DisableCompiler not supported"));
673 /* JVM_GetLastErrorString */
675 jint JVM_GetLastErrorString(char *buf, int len)
677 TRACEJVMCALLS(("JVM_GetLastErrorString(buf=%p, len=%d", buf, len));
679 return hpi_system->GetLastErrorString(buf, len);
685 char *JVM_NativePath(char *path)
687 TRACEJVMCALLS(("JVM_NativePath(path=%s)", path));
689 return hpi_file->NativePath(path);
693 /* JVM_GetCallerClass */
695 jclass JVM_GetCallerClass(JNIEnv* env, int depth)
699 TRACEJVMCALLS(("JVM_GetCallerClass(env=%p, depth=%d)", env, depth));
701 c = stacktrace_get_caller_class(depth);
707 /* JVM_FindPrimitiveClass */
709 jclass JVM_FindPrimitiveClass(JNIEnv* env, const char* s)
714 TRACEJVMCALLS(("JVM_FindPrimitiveClass(env=%p, s=%s)", env, s));
717 c = Primitive::get_class_by_name(u);
719 return (jclass) LLNI_classinfo_wrap(c);
723 /* JVM_ResolveClass */
725 void JVM_ResolveClass(JNIEnv* env, jclass cls)
727 TRACEJVMCALLS(("JVM_ResolveClass(env=%p, cls=%p)", env, cls));
728 PRINTJVMWARNINGS(("JVM_ResolveClass not implemented"));
732 /* JVM_FindClassFromClassLoader */
734 jclass JVM_FindClassFromClassLoader(JNIEnv* env, const char* name, jboolean init, jobject loader, jboolean throwError)
740 TRACEJVMCALLS(("JVM_FindClassFromClassLoader(name=%s, init=%d, loader=%p, throwError=%d)", name, init, loader, throwError));
742 /* As of now, OpenJDK does not call this function with throwError
745 assert(throwError == false);
747 u = utf_new_char(name);
748 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
750 c = load_class_from_classloader(u, cl);
756 if (!(c->state & CLASS_INITIALIZED))
757 if (!initialize_class(c))
760 return (jclass) LLNI_classinfo_wrap(c);
764 /* JVM_FindClassFromClass */
766 jclass JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init, jclass from)
768 log_println("JVM_FindClassFromClass: IMPLEMENT ME!");
774 /* JVM_DefineClass */
776 jclass JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)
778 log_println("JVM_DefineClass: IMPLEMENT ME!");
784 /* JVM_DefineClassWithSource */
786 jclass JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)
792 TRACEJVMCALLS(("JVM_DefineClassWithSource(env=%p, name=%s, loader=%p, buf=%p, len=%d, pd=%p, source=%s)", env, name, loader, buf, len, pd, source));
795 u = utf_new_char(name);
799 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
801 /* XXX do something with source */
803 c = class_define(u, cl, len, (uint8_t *) buf, (java_handle_t *) pd);
805 return (jclass) LLNI_classinfo_wrap(c);
809 /* JVM_FindLoadedClass */
811 jclass JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name)
817 TRACEJVMCALLS(("JVM_FindLoadedClass(env=%p, loader=%p, name=%p)", env, loader, name));
819 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
821 u = javastring_toutf((java_handle_t *) name, true);
822 c = classcache_lookup(cl, u);
824 return (jclass) LLNI_classinfo_wrap(c);
828 /* JVM_GetClassName */
830 jstring JVM_GetClassName(JNIEnv *env, jclass cls)
834 TRACEJVMCALLS(("JVM_GetClassName(env=%p, cls=%p)", env, cls));
836 c = LLNI_classinfo_unwrap(cls);
838 return (jstring) class_get_classname(c);
842 /* JVM_GetClassInterfaces */
844 jobjectArray JVM_GetClassInterfaces(JNIEnv *env, jclass cls)
847 java_handle_objectarray_t *oa;
849 TRACEJVMCALLS(("JVM_GetClassInterfaces(env=%p, cls=%p)", env, cls));
851 c = LLNI_classinfo_unwrap(cls);
853 oa = class_get_interfaces(c);
855 return (jobjectArray) oa;
859 /* JVM_GetClassLoader */
861 jobject JVM_GetClassLoader(JNIEnv *env, jclass cls)
866 TRACEJVMCALLSENTER(("JVM_GetClassLoader(env=%p, cls=%p)", env, cls));
868 c = LLNI_classinfo_unwrap(cls);
869 cl = class_get_classloader(c);
871 TRACEJVMCALLSEXIT(("->%p", cl));
877 /* JVM_IsInterface */
879 jboolean JVM_IsInterface(JNIEnv *env, jclass cls)
883 TRACEJVMCALLS(("JVM_IsInterface(env=%p, cls=%p)", env, cls));
885 c = LLNI_classinfo_unwrap(cls);
887 return class_is_interface(c);
891 /* JVM_GetClassSigners */
893 jobjectArray JVM_GetClassSigners(JNIEnv *env, jclass cls)
895 log_println("JVM_GetClassSigners: IMPLEMENT ME!");
901 /* JVM_SetClassSigners */
903 void JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers)
906 java_handle_objectarray_t *hoa;
908 TRACEJVMCALLS(("JVM_SetClassSigners(env=%p, cls=%p, signers=%p)", env, cls, signers));
910 c = LLNI_classinfo_unwrap(cls);
912 hoa = (java_handle_objectarray_t *) signers;
914 /* This call is ignored for primitive types and arrays. Signers
915 are only set once, ClassLoader.java, and thus shouldn't be
916 called with an array. Only the bootstrap loader creates
919 if (class_is_primitive(c) || class_is_array(c))
922 LLNI_classinfo_field_set(c, signers, hoa);
926 /* JVM_GetProtectionDomain */
928 jobject JVM_GetProtectionDomain(JNIEnv *env, jclass cls)
932 TRACEJVMCALLS(("JVM_GetProtectionDomain(env=%p, cls=%p)", env, cls));
934 c = LLNI_classinfo_unwrap(cls);
937 exceptions_throw_nullpointerexception();
941 /* Primitive types do not have a protection domain. */
943 if (class_is_primitive(c))
946 return (jobject) c->protectiondomain;
950 /* JVM_SetProtectionDomain */
952 void JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain)
954 log_println("JVM_SetProtectionDomain: IMPLEMENT ME!");
958 /* JVM_DoPrivileged */
960 jobject JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, jobject context, jboolean wrapException)
965 java_handle_t *result;
968 TRACEJVMCALLS(("JVM_DoPrivileged(env=%p, cls=%p, action=%p, context=%p, wrapException=%d)", env, cls, action, context, wrapException));
970 h = (java_handle_t *) action;
971 LLNI_class_get(h, c);
973 if (action == NULL) {
974 exceptions_throw_nullpointerexception();
978 /* lookup run() method (throw no exceptions) */
980 m = class_resolveclassmethod(c, utf_run, utf_void__java_lang_Object, c,
983 if ((m == NULL) || !(m->flags & ACC_PUBLIC) || (m->flags & ACC_STATIC)) {
984 exceptions_throw_internalerror("No run method");
988 /* XXX It seems something with a privileged stack needs to be done
991 result = vm_call_method(m, h);
993 e = exceptions_get_exception();
996 if ( builtin_instanceof(e, class_java_lang_Exception) &&
997 !builtin_instanceof(e, class_java_lang_RuntimeException)) {
998 exceptions_clear_exception();
999 exceptions_throw_privilegedactionexception(e);
1005 return (jobject) result;
1009 /* JVM_GetInheritedAccessControlContext */
1011 jobject JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls)
1013 log_println("JVM_GetInheritedAccessControlContext: IMPLEMENT ME!");
1019 /* JVM_GetStackAccessControlContext */
1021 jobject JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls)
1023 TRACEJVMCALLS(("JVM_GetStackAccessControlContext(env=%p, cls=%p): IMPLEMENT ME!", env, cls));
1025 /* XXX All stuff I tested so far works without that function. At
1026 some point we have to implement it, but I disable the output
1027 for now to make IcedTea happy. */
1033 /* JVM_IsArrayClass */
1035 jboolean JVM_IsArrayClass(JNIEnv *env, jclass cls)
1039 TRACEJVMCALLS(("JVM_IsArrayClass(env=%p, cls=%p)", env, cls));
1041 c = LLNI_classinfo_unwrap(cls);
1043 return class_is_array(c);
1047 /* JVM_IsPrimitiveClass */
1049 jboolean JVM_IsPrimitiveClass(JNIEnv *env, jclass cls)
1053 TRACEJVMCALLS(("JVM_IsPrimitiveClass(env=%p, cls=%p)", env, cls));
1055 c = LLNI_classinfo_unwrap(cls);
1057 return class_is_primitive(c);
1061 /* JVM_GetComponentType */
1063 jclass JVM_GetComponentType(JNIEnv *env, jclass cls)
1065 classinfo *component;
1068 TRACEJVMCALLS(("JVM_GetComponentType(env=%p, cls=%p)", env, cls));
1070 c = LLNI_classinfo_unwrap(cls);
1072 component = class_get_componenttype(c);
1074 return (jclass) LLNI_classinfo_wrap(component);
1078 /* JVM_GetClassModifiers */
1080 jint JVM_GetClassModifiers(JNIEnv *env, jclass cls)
1085 TRACEJVMCALLS(("JVM_GetClassModifiers(env=%p, cls=%p)", env, cls));
1087 c = LLNI_classinfo_unwrap(cls);
1089 flags = class_get_modifiers(c, false);
1095 /* JVM_GetDeclaredClasses */
1097 jobjectArray JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)
1100 java_handle_objectarray_t *oa;
1102 TRACEJVMCALLS(("JVM_GetDeclaredClasses(env=%p, ofClass=%p)", env, ofClass));
1104 c = LLNI_classinfo_unwrap(ofClass);
1106 oa = class_get_declaredclasses(c, false);
1108 return (jobjectArray) oa;
1112 /* JVM_GetDeclaringClass */
1114 jclass JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass)
1119 TRACEJVMCALLS(("JVM_GetDeclaringClass(env=%p, ofClass=%p)", env, ofClass));
1121 c = LLNI_classinfo_unwrap(ofClass);
1123 dc = class_get_declaringclass(c);
1125 return (jclass) LLNI_classinfo_wrap(dc);
1129 /* JVM_GetClassSignature */
1131 jstring JVM_GetClassSignature(JNIEnv *env, jclass cls)
1137 TRACEJVMCALLS(("JVM_GetClassSignature(env=%p, cls=%p)", env, cls));
1139 c = LLNI_classinfo_unwrap(cls);
1141 /* Get the signature of the class. */
1143 u = class_get_signature(c);
1148 /* Convert UTF-string to a Java-string. */
1150 s = javastring_new(u);
1156 /* JVM_GetClassAnnotations */
1158 jbyteArray JVM_GetClassAnnotations(JNIEnv *env, jclass cls)
1160 TRACEJVMCALLS(("JVM_GetClassAnnotations(env=%p, cls=%p)", env, cls));
1163 exceptions_throw_nullpointerexception();
1167 classinfo* c = LLNI_classinfo_unwrap(cls);
1169 /* get annotations: */
1170 java_handle_bytearray_t* annotations = class_get_annotations(c);
1172 return (jbyteArray) annotations;
1176 /* JVM_GetFieldAnnotations */
1178 jbyteArray JVM_GetFieldAnnotations(JNIEnv *env, jobject field)
1180 TRACEJVMCALLS(("JVM_GetFieldAnnotations(env=%p, field=%p)", env, field));
1182 java_lang_reflect_Field jlrf(field);
1184 if (jlrf.is_null()) {
1185 exceptions_throw_nullpointerexception();
1189 return (jbyteArray) jlrf.get_annotations();
1193 /* JVM_GetMethodAnnotations */
1195 jbyteArray JVM_GetMethodAnnotations(JNIEnv *env, jobject method)
1197 TRACEJVMCALLS(("JVM_GetMethodAnnotations(env=%p, method=%p)", env, method));
1199 java_lang_reflect_Method jlrm(method);
1201 if (jlrm.is_null()) {
1202 exceptions_throw_nullpointerexception();
1206 return (jbyteArray) jlrm.get_annotations();
1210 /* JVM_GetMethodDefaultAnnotationValue */
1212 jbyteArray JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method)
1214 TRACEJVMCALLS(("JVM_GetMethodDefaultAnnotationValue(env=%p, method=%p)", env, method));
1216 java_lang_reflect_Method jlrm(method);
1218 if (jlrm.is_null()) {
1219 exceptions_throw_nullpointerexception();
1223 return (jbyteArray) jlrm.get_annotationDefault();
1227 /* JVM_GetMethodParameterAnnotations */
1229 jbyteArray JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method)
1231 TRACEJVMCALLS(("JVM_GetMethodParameterAnnotations(env=%p, method=%p)", env, method));
1233 java_lang_reflect_Method jlrm(method);
1235 if (jlrm.is_null()) {
1236 exceptions_throw_nullpointerexception();
1240 return (jbyteArray) jlrm.get_parameterAnnotations();
1244 /* JVM_GetClassDeclaredFields */
1246 jobjectArray JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1249 java_handle_objectarray_t *oa;
1251 TRACEJVMCALLS(("JVM_GetClassDeclaredFields(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1253 c = LLNI_classinfo_unwrap(ofClass);
1255 oa = class_get_declaredfields(c, publicOnly);
1257 return (jobjectArray) oa;
1261 /* JVM_GetClassDeclaredMethods */
1263 jobjectArray JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1265 TRACEJVMCALLS(("JVM_GetClassDeclaredMethods(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1267 classinfo* c = LLNI_classinfo_unwrap(ofClass);
1269 java_handle_objectarray_t* oa = class_get_declaredmethods(c, publicOnly);
1271 return (jobjectArray) oa;
1275 /* JVM_GetClassDeclaredConstructors */
1277 jobjectArray JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1280 java_handle_objectarray_t *oa;
1282 TRACEJVMCALLS(("JVM_GetClassDeclaredConstructors(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1284 c = LLNI_classinfo_unwrap(ofClass);
1286 oa = class_get_declaredconstructors(c, publicOnly);
1288 return (jobjectArray) oa;
1292 /* JVM_GetClassAccessFlags */
1294 jint JVM_GetClassAccessFlags(JNIEnv *env, jclass cls)
1298 TRACEJVMCALLS(("JVM_GetClassAccessFlags(env=%p, cls=%p)", env, cls));
1300 c = LLNI_classinfo_unwrap(cls);
1302 /* Primitive type classes have the correct access flags. */
1304 return c->flags & ACC_CLASS_REFLECT_MASK;
1308 /* JVM_GetClassConstantPool */
1310 jobject JVM_GetClassConstantPool(JNIEnv *env, jclass cls)
1312 #if defined(ENABLE_ANNOTATIONS)
1313 TRACEJVMCALLS(("JVM_GetClassConstantPool(env=%p, cls=%p)", env, cls));
1315 java_handle_t* h = native_new_and_init(class_sun_reflect_ConstantPool);
1316 sun_reflect_ConstantPool cp(h, cls);
1322 return (jobject) cp.get_handle();
1324 log_println("JVM_GetClassConstantPool(env=%p, cls=%p): not implemented in this configuration!", env, cls);
1330 /* JVM_ConstantPoolGetSize */
1332 jint JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool)
1334 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1336 TRACEJVMCALLS(("JVM_ConstantPoolGetSize(env=%p, unused=%p, jcpool=%p)", env, unused, jcpool));
1338 c = LLNI_classinfo_unwrap(jcpool);
1344 /* JVM_ConstantPoolGetClassAt */
1346 jclass JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1348 constant_classref *ref; /* classref to the class at constant pool index 'index' */
1349 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1350 classinfo *result; /* classinfo of the class at constant pool index 'index' */
1352 TRACEJVMCALLS(("JVM_ConstantPoolGetClassAt(env=%p, jcpool=%p, index=%d)", env, jcpool, index));
1354 c = LLNI_classinfo_unwrap(jcpool);
1356 ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1359 exceptions_throw_illegalargumentexception();
1363 result = resolve_classref_eager(ref);
1365 return (jclass) LLNI_classinfo_wrap(result);
1369 /* JVM_ConstantPoolGetClassAtIfLoaded */
1371 jclass JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1373 constant_classref *ref; /* classref to the class at constant pool index 'index' */
1374 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1375 classinfo *result; /* classinfo of the class at constant pool index 'index' */
1377 TRACEJVMCALLS(("JVM_ConstantPoolGetClassAtIfLoaded(env=%p, unused=%p, jcpool=%p, index=%d)", env, unused, jcpool, index));
1379 c = LLNI_classinfo_unwrap(jcpool);
1381 ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1384 exceptions_throw_illegalargumentexception();
1388 if (!resolve_classref(NULL, ref, resolveLazy, true, true, &result)) {
1392 if ((result == NULL) || !(result->state & CLASS_LOADED)) {
1396 return (jclass) LLNI_classinfo_wrap(result);
1400 /* JVM_ConstantPoolGetMethodAt */
1402 jobject JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1404 constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
1405 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1407 TRACEJVMCALLS(("JVM_ConstantPoolGetMethodAt: jcpool=%p, index=%d", jcpool, index));
1409 cls = LLNI_classinfo_unwrap(jcpool);
1410 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1413 exceptions_throw_illegalargumentexception();
1417 // Create a new java.lang.reflect.Method Java object.
1418 /* XXX: is that right? or do I have to use resolve_method_*? */
1419 java_lang_reflect_Method jlrm(ref->p.method);
1421 return (jobject) jlrm.get_handle();
1425 /* JVM_ConstantPoolGetMethodAtIfLoaded */
1427 jobject JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1429 constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
1430 classinfo *c = NULL; /* resolved declaring class of the method */
1431 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1433 TRACEJVMCALLS(("JVM_ConstantPoolGetMethodAtIfLoaded: jcpool=%p, index=%d", jcpool, index));
1435 cls = LLNI_classinfo_unwrap(jcpool);
1436 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1439 exceptions_throw_illegalargumentexception();
1443 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1447 if (c == NULL || !(c->state & CLASS_LOADED)) {
1451 // Create a new java.lang.reflect.Method Java object.
1452 java_lang_reflect_Method jlrm(ref->p.method);
1454 return (jobject) jlrm.get_handle();
1458 /* JVM_ConstantPoolGetFieldAt */
1460 jobject JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1462 constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
1463 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1465 TRACEJVMCALLS(("JVM_ConstantPoolGetFieldAt: jcpool=%p, index=%d", jcpool, index));
1467 cls = LLNI_classinfo_unwrap(jcpool);
1468 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1471 exceptions_throw_illegalargumentexception();
1475 // Create a new java.lang.reflect.Field Java object.
1476 java_lang_reflect_Field jlrf(ref->p.field);
1478 return (jobject) jlrf.get_handle();
1482 /* JVM_ConstantPoolGetFieldAtIfLoaded */
1484 jobject JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1486 constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
1487 classinfo *c; /* resolved declaring class for the field */
1488 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1490 TRACEJVMCALLS(("JVM_ConstantPoolGetFieldAtIfLoaded: jcpool=%p, index=%d", jcpool, index));
1492 cls = LLNI_classinfo_unwrap(jcpool);
1493 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1496 exceptions_throw_illegalargumentexception();
1500 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1504 if (c == NULL || !(c->state & CLASS_LOADED)) {
1508 // Create a new java.lang.reflect.Field Java object.
1509 java_lang_reflect_Field jlrf(ref->p.field);
1511 return (jobject) jlrf.get_handle();
1515 /* JVM_ConstantPoolGetMemberRefInfoAt */
1517 jobjectArray JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1519 log_println("JVM_ConstantPoolGetMemberRefInfoAt: jcpool=%p, index=%d, IMPLEMENT ME!", jcpool, index);
1521 /* TODO: implement. (this is yet unused be OpenJDK but, so very low priority) */
1527 /* JVM_ConstantPoolGetIntAt */
1529 jint JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1531 constant_integer *ref; /* reference to the int value in constant pool at index 'index' */
1532 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1534 TRACEJVMCALLS(("JVM_ConstantPoolGetIntAt: jcpool=%p, index=%d", jcpool, index));
1536 cls = LLNI_classinfo_unwrap(jcpool);
1537 ref = (constant_integer*)class_getconstant(cls, index, CONSTANT_Integer);
1540 exceptions_throw_illegalargumentexception();
1548 /* JVM_ConstantPoolGetLongAt */
1550 jlong JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1552 constant_long *ref; /* reference to the long value in constant pool at index 'index' */
1553 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1555 TRACEJVMCALLS(("JVM_ConstantPoolGetLongAt: jcpool=%p, index=%d", jcpool, index));
1557 cls = LLNI_classinfo_unwrap(jcpool);
1558 ref = (constant_long*)class_getconstant(cls, index, CONSTANT_Long);
1561 exceptions_throw_illegalargumentexception();
1569 /* JVM_ConstantPoolGetFloatAt */
1571 jfloat JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1573 constant_float *ref; /* reference to the float value in constant pool at index 'index' */
1574 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1576 TRACEJVMCALLS(("JVM_ConstantPoolGetFloatAt: jcpool=%p, index=%d", jcpool, index));
1578 cls = LLNI_classinfo_unwrap(jcpool);
1579 ref = (constant_float*)class_getconstant(cls, index, CONSTANT_Float);
1582 exceptions_throw_illegalargumentexception();
1590 /* JVM_ConstantPoolGetDoubleAt */
1592 jdouble JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1594 constant_double *ref; /* reference to the double value in constant pool at index 'index' */
1595 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1597 TRACEJVMCALLS(("JVM_ConstantPoolGetDoubleAt: jcpool=%p, index=%d", jcpool, index));
1599 cls = LLNI_classinfo_unwrap(jcpool);
1600 ref = (constant_double*)class_getconstant(cls, index, CONSTANT_Double);
1603 exceptions_throw_illegalargumentexception();
1611 /* JVM_ConstantPoolGetStringAt */
1613 jstring JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1615 utf *ref; /* utf object for the string in constant pool at index 'index' */
1616 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1618 TRACEJVMCALLS(("JVM_ConstantPoolGetStringAt: jcpool=%p, index=%d", jcpool, index));
1620 cls = LLNI_classinfo_unwrap(jcpool);
1621 ref = (utf*)class_getconstant(cls, index, CONSTANT_String);
1624 exceptions_throw_illegalargumentexception();
1628 /* XXX: I hope literalstring_new is the right Function. */
1629 return (jstring)literalstring_new(ref);
1633 /* JVM_ConstantPoolGetUTF8At */
1635 jstring JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1637 utf *ref; /* utf object for the utf8 data in constant pool at index 'index' */
1638 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1640 TRACEJVMCALLS(("JVM_ConstantPoolGetUTF8At: jcpool=%p, index=%d", jcpool, index));
1642 cls = LLNI_classinfo_unwrap(jcpool);
1643 ref = (utf*)class_getconstant(cls, index, CONSTANT_Utf8);
1646 exceptions_throw_illegalargumentexception();
1650 /* XXX: I hope literalstring_new is the right Function. */
1651 return (jstring)literalstring_new(ref);
1655 /* JVM_DesiredAssertionStatus */
1657 jboolean JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls)
1659 #if defined(ENABLE_ASSERTION)
1660 assertion_name_t *item;
1665 TRACEJVMCALLS(("JVM_DesiredAssertionStatus(env=%p, unused=%p, cls=%p)", env, unused, cls));
1667 c = LLNI_classinfo_unwrap(cls);
1669 if (c->classloader == NULL) {
1670 status = (jboolean)assertion_system_enabled;
1673 status = (jboolean)assertion_user_enabled;
1676 if (list_assertion_names != NULL) {
1677 item = (assertion_name_t *)list_first(list_assertion_names);
1678 while (item != NULL) {
1679 name = utf_new_char(item->name);
1680 if (name == c->packagename) {
1681 status = (jboolean)item->enabled;
1683 else if (name == c->name) {
1684 status = (jboolean)item->enabled;
1687 item = (assertion_name_t *)list_next(list_assertion_names, item);
1693 return (jboolean)false;
1698 /* JVM_AssertionStatusDirectives */
1700 jobject JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)
1702 java_handle_objectarray_t *classes;
1703 java_handle_objectarray_t *packages;
1704 java_booleanarray_t *classEnabled;
1705 java_booleanarray_t *packageEnabled;
1706 #if defined(ENABLE_ASSERTION)
1707 assertion_name_t *item;
1712 TRACEJVMCALLS(("JVM_AssertionStatusDirectives(env=%p, unused=%p)", env, unused));
1714 #if defined(ENABLE_ASSERTION)
1715 classes = builtin_anewarray(assertion_class_count, class_java_lang_Object);
1717 classes = builtin_anewarray(0, class_java_lang_Object);
1719 if (classes == NULL)
1722 #if defined(ENABLE_ASSERTION)
1723 packages = builtin_anewarray(assertion_package_count, class_java_lang_Object);
1725 packages = builtin_anewarray(0, class_java_lang_Object);
1727 if (packages == NULL)
1730 #if defined(ENABLE_ASSERTION)
1731 classEnabled = builtin_newarray_boolean(assertion_class_count);
1733 classEnabled = builtin_newarray_boolean(0);
1735 if (classEnabled == NULL)
1738 #if defined(ENABLE_ASSERTION)
1739 packageEnabled = builtin_newarray_boolean(assertion_package_count);
1741 packageEnabled = builtin_newarray_boolean(0);
1743 if (packageEnabled == NULL)
1746 #if defined(ENABLE_ASSERTION)
1747 /* initialize arrays */
1749 if (list_assertion_names != NULL) {
1753 item = (assertion_name_t *)list_first(list_assertion_names);
1754 while (item != NULL) {
1755 js = javastring_new_from_ascii(item->name);
1760 if (item->package == false) {
1761 classes->data[i] = js;
1762 classEnabled->data[i] = (jboolean) item->enabled;
1766 packages->data[j] = js;
1767 packageEnabled->data[j] = (jboolean) item->enabled;
1771 item = (assertion_name_t *)list_next(list_assertion_names, item);
1776 /* set instance fields */
1778 java_lang_AssertionStatusDirectives jlasd(classes, classEnabled, packages, packageEnabled);
1780 return (jobject) jlasd.get_handle();
1784 /* JVM_GetClassNameUTF */
1786 const char *JVM_GetClassNameUTF(JNIEnv *env, jclass cls)
1788 log_println("JVM_GetClassNameUTF: IMPLEMENT ME!");
1794 /* JVM_GetClassCPTypes */
1796 void JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types)
1798 log_println("JVM_GetClassCPTypes: IMPLEMENT ME!");
1802 /* JVM_GetClassCPEntriesCount */
1804 jint JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)
1806 log_println("JVM_GetClassCPEntriesCount: IMPLEMENT ME!");
1812 /* JVM_GetClassFieldsCount */
1814 jint JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)
1816 log_println("JVM_GetClassFieldsCount: IMPLEMENT ME!");
1822 /* JVM_GetClassMethodsCount */
1824 jint JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)
1826 log_println("JVM_GetClassMethodsCount: IMPLEMENT ME!");
1832 /* JVM_GetMethodIxExceptionIndexes */
1834 void JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions)
1836 log_println("JVM_GetMethodIxExceptionIndexes: IMPLEMENT ME!");
1840 /* JVM_GetMethodIxExceptionsCount */
1842 jint JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)
1844 log_println("JVM_GetMethodIxExceptionsCount: IMPLEMENT ME!");
1850 /* JVM_GetMethodIxByteCode */
1852 void JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code)
1854 log_println("JVM_GetMethodIxByteCode: IMPLEMENT ME!");
1858 /* JVM_GetMethodIxByteCodeLength */
1860 jint JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)
1862 log_println("JVM_GetMethodIxByteCodeLength: IMPLEMENT ME!");
1868 /* JVM_GetMethodIxExceptionTableEntry */
1870 void JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry)
1872 log_println("JVM_GetMethodIxExceptionTableEntry: IMPLEMENT ME!");
1876 /* JVM_GetMethodIxExceptionTableLength */
1878 jint JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)
1880 log_println("JVM_GetMethodIxExceptionTableLength: IMPLEMENT ME!");
1886 /* JVM_GetMethodIxModifiers */
1888 jint JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)
1890 log_println("JVM_GetMethodIxModifiers: IMPLEMENT ME!");
1896 /* JVM_GetFieldIxModifiers */
1898 jint JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)
1900 log_println("JVM_GetFieldIxModifiers: IMPLEMENT ME!");
1906 /* JVM_GetMethodIxLocalsCount */
1908 jint JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)
1910 log_println("JVM_GetMethodIxLocalsCount: IMPLEMENT ME!");
1916 /* JVM_GetMethodIxArgsSize */
1918 jint JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)
1920 log_println("JVM_GetMethodIxArgsSize: IMPLEMENT ME!");
1926 /* JVM_GetMethodIxMaxStack */
1928 jint JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)
1930 log_println("JVM_GetMethodIxMaxStack: IMPLEMENT ME!");
1936 /* JVM_IsConstructorIx */
1938 jboolean JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)
1940 log_println("JVM_IsConstructorIx: IMPLEMENT ME!");
1946 /* JVM_GetMethodIxNameUTF */
1948 const char *JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)
1950 log_println("JVM_GetMethodIxNameUTF: IMPLEMENT ME!");
1956 /* JVM_GetMethodIxSignatureUTF */
1958 const char *JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)
1960 log_println("JVM_GetMethodIxSignatureUTF: IMPLEMENT ME!");
1966 /* JVM_GetCPFieldNameUTF */
1968 const char *JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1970 log_println("JVM_GetCPFieldNameUTF: IMPLEMENT ME!");
1976 /* JVM_GetCPMethodNameUTF */
1978 const char *JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1980 log_println("JVM_GetCPMethodNameUTF: IMPLEMENT ME!");
1986 /* JVM_GetCPMethodSignatureUTF */
1988 const char *JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
1990 log_println("JVM_GetCPMethodSignatureUTF: IMPLEMENT ME!");
1996 /* JVM_GetCPFieldSignatureUTF */
1998 const char *JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
2000 log_println("JVM_GetCPFieldSignatureUTF: IMPLEMENT ME!");
2006 /* JVM_GetCPClassNameUTF */
2008 const char *JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2010 log_println("JVM_GetCPClassNameUTF: IMPLEMENT ME!");
2016 /* JVM_GetCPFieldClassNameUTF */
2018 const char *JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2020 log_println("JVM_GetCPFieldClassNameUTF: IMPLEMENT ME!");
2026 /* JVM_GetCPMethodClassNameUTF */
2028 const char *JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2030 log_println("JVM_GetCPMethodClassNameUTF: IMPLEMENT ME!");
2036 /* JVM_GetCPFieldModifiers */
2038 jint JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
2040 log_println("JVM_GetCPFieldModifiers: IMPLEMENT ME!");
2046 /* JVM_GetCPMethodModifiers */
2048 jint JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
2050 log_println("JVM_GetCPMethodModifiers: IMPLEMENT ME!");
2056 /* JVM_ReleaseUTF */
2058 void JVM_ReleaseUTF(const char *utf)
2060 log_println("JVM_ReleaseUTF: IMPLEMENT ME!");
2064 /* JVM_IsSameClassPackage */
2066 jboolean JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2)
2068 log_println("JVM_IsSameClassPackage: IMPLEMENT ME!");
2076 /* Taken from: hotspot/src/share/vm/prims/jvm.h */
2079 * JVM I/O error codes
2081 #define JVM_EEXIST -100
2083 jint JVM_Open(const char *fname, jint flags, jint mode)
2087 TRACEJVMCALLS(("JVM_Open(fname=%s, flags=%d, mode=%d)", fname, flags, mode));
2089 result = hpi_file->Open(fname, flags, mode);
2107 jint JVM_Close(jint fd)
2109 TRACEJVMCALLS(("JVM_Close(fd=%d)", fd));
2111 return hpi_file->Close(fd);
2117 jint JVM_Read(jint fd, char *buf, jint nbytes)
2119 TRACEJVMCALLS(("JVM_Read(fd=%d, buf=%p, nbytes=%d)", fd, buf, nbytes));
2121 return (jint) hpi_file->Read(fd, buf, nbytes);
2127 jint JVM_Write(jint fd, char *buf, jint nbytes)
2129 TRACEJVMCALLS(("JVM_Write(fd=%d, buf=%s, nbytes=%d)", fd, buf, nbytes));
2131 return (jint) hpi_file->Write(fd, buf, nbytes);
2137 jint JVM_Available(jint fd, jlong *pbytes)
2139 TRACEJVMCALLS(("JVM_Available(fd=%d, pbytes=%p)", fd, pbytes));
2141 return hpi_file->Available(fd, pbytes);
2147 jlong JVM_Lseek(jint fd, jlong offset, jint whence)
2149 TRACEJVMCALLS(("JVM_Lseek(fd=%d, offset=%ld, whence=%d)", fd, offset, whence));
2151 return hpi_file->Seek(fd, (off_t) offset, whence);
2157 jint JVM_SetLength(jint fd, jlong length)
2159 TRACEJVMCALLS(("JVM_SetLength(fd=%d, length=%ld)", length));
2161 return hpi_file->SetLength(fd, length);
2167 jint JVM_Sync(jint fd)
2169 TRACEJVMCALLS(("JVM_Sync(fd=%d)", fd));
2171 return hpi_file->Sync(fd);
2175 /* JVM_StartThread */
2177 void JVM_StartThread(JNIEnv* env, jobject jthread)
2179 TRACEJVMCALLS(("JVM_StartThread(env=%p, jthread=%p)", env, jthread));
2181 threads_thread_start((java_handle_t *) jthread);
2185 /* JVM_StopThread */
2187 void JVM_StopThread(JNIEnv* env, jobject jthread, jobject throwable)
2189 log_println("JVM_StopThread: Deprecated. Not implemented.");
2193 /* JVM_IsThreadAlive */
2195 jboolean JVM_IsThreadAlive(JNIEnv* env, jobject jthread)
2201 TRACEJVMCALLS(("JVM_IsThreadAlive(env=%p, jthread=%p)", env, jthread));
2203 h = (java_handle_t *) jthread;
2204 t = thread_get_thread(h);
2206 /* The threadobject is null when a thread is created in Java. The
2207 priority is set later during startup. */
2212 result = threads_thread_is_alive(t);
2218 /* JVM_SuspendThread */
2220 void JVM_SuspendThread(JNIEnv* env, jobject jthread)
2222 log_println("JVM_SuspendThread: Deprecated. Not implemented.");
2226 /* JVM_ResumeThread */
2228 void JVM_ResumeThread(JNIEnv* env, jobject jthread)
2230 log_println("JVM_ResumeThread: Deprecated. Not implemented.");
2234 /* JVM_SetThreadPriority */
2236 void JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio)
2241 TRACEJVMCALLS(("JVM_SetThreadPriority(env=%p, jthread=%p, prio=%d)", env, jthread, prio));
2243 h = (java_handle_t *) jthread;
2244 t = thread_get_thread(h);
2246 /* The threadobject is null when a thread is created in Java. The
2247 priority is set later during startup. */
2252 threads_set_thread_priority(t->tid, prio);
2258 void JVM_Yield(JNIEnv *env, jclass threadClass)
2260 TRACEJVMCALLS(("JVM_Yield(env=%p, threadClass=%p)", env, threadClass));
2268 void JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis)
2270 TRACEJVMCALLS(("JVM_Sleep(env=%p, threadClass=%p, millis=%ld)", env, threadClass, millis));
2272 threads_sleep(millis, 0);
2276 /* JVM_CurrentThread */
2278 jobject JVM_CurrentThread(JNIEnv* env, jclass threadClass)
2282 TRACEJVMCALLSVERBOSE(("JVM_CurrentThread(env=%p, threadClass=%p)", env, threadClass));
2284 o = thread_get_current_object();
2290 /* JVM_CountStackFrames */
2292 jint JVM_CountStackFrames(JNIEnv* env, jobject jthread)
2294 log_println("JVM_CountStackFrames: Deprecated. Not implemented.");
2302 void JVM_Interrupt(JNIEnv* env, jobject jthread)
2307 TRACEJVMCALLS(("JVM_Interrupt(env=%p, jthread=%p)", env, jthread));
2309 h = (java_handle_t *) jthread;
2310 t = thread_get_thread(h);
2315 threads_thread_interrupt(t);
2319 /* JVM_IsInterrupted */
2321 jboolean JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted)
2325 jboolean interrupted;
2327 TRACEJVMCALLS(("JVM_IsInterrupted(env=%p, jthread=%p, clear_interrupted=%d)", env, jthread, clear_interrupted));
2329 h = (java_handle_t *) jthread;
2330 t = thread_get_thread(h);
2332 interrupted = thread_is_interrupted(t);
2334 if (interrupted && clear_interrupted)
2335 thread_set_interrupted(t, false);
2343 jboolean JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj)
2348 TRACEJVMCALLS(("JVM_HoldsLock(env=%p, threadClass=%p, obj=%p)", env, threadClass, obj));
2350 h = (java_handle_t *) obj;
2353 exceptions_throw_nullpointerexception();
2357 result = lock_is_held_by_current_thread(h);
2363 /* JVM_DumpAllStacks */
2365 void JVM_DumpAllStacks(JNIEnv* env, jclass unused)
2367 log_println("JVM_DumpAllStacks: IMPLEMENT ME!");
2371 /* JVM_CurrentLoadedClass */
2373 jclass JVM_CurrentLoadedClass(JNIEnv *env)
2375 log_println("JVM_CurrentLoadedClass: IMPLEMENT ME!");
2381 /* JVM_CurrentClassLoader */
2383 jobject JVM_CurrentClassLoader(JNIEnv *env)
2385 /* XXX if a method in a class in a trusted loader is in a
2386 doPrivileged, return NULL */
2388 log_println("JVM_CurrentClassLoader: IMPLEMENT ME!");
2394 /* JVM_GetClassContext */
2396 jobjectArray JVM_GetClassContext(JNIEnv *env)
2398 TRACEJVMCALLS(("JVM_GetClassContext(env=%p)", env));
2400 return (jobjectArray) stacktrace_getClassContext();
2404 /* JVM_ClassDepth */
2406 jint JVM_ClassDepth(JNIEnv *env, jstring name)
2408 log_println("JVM_ClassDepth: IMPLEMENT ME!");
2414 /* JVM_ClassLoaderDepth */
2416 jint JVM_ClassLoaderDepth(JNIEnv *env)
2418 log_println("JVM_ClassLoaderDepth: IMPLEMENT ME!");
2424 /* JVM_GetSystemPackage */
2426 jstring JVM_GetSystemPackage(JNIEnv *env, jstring name)
2432 TRACEJVMCALLS(("JVM_GetSystemPackage(env=%p, name=%p)", env, name));
2434 /* s = Package::find(name); */
2435 u = javastring_toutf((java_handle_t *) name, false);
2437 result = Package::find(u);
2440 s = javastring_new(result);
2448 /* JVM_GetSystemPackages */
2450 jobjectArray JVM_GetSystemPackages(JNIEnv *env)
2452 log_println("JVM_GetSystemPackages: IMPLEMENT ME!");
2458 /* JVM_AllocateNewObject */
2460 jobject JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass)
2462 log_println("JVM_AllocateNewObject: IMPLEMENT ME!");
2468 /* JVM_AllocateNewArray */
2470 jobject JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length)
2472 log_println("JVM_AllocateNewArray: IMPLEMENT ME!");
2478 /* JVM_LatestUserDefinedLoader */
2480 jobject JVM_LatestUserDefinedLoader(JNIEnv *env)
2484 TRACEJVMCALLS(("JVM_LatestUserDefinedLoader(env=%p)", env));
2486 cl = stacktrace_first_nonnull_classloader();
2488 return (jobject) cl;
2492 /* JVM_LoadClass0 */
2494 jclass JVM_LoadClass0(JNIEnv *env, jobject receiver, jclass currClass, jstring currClassName)
2496 log_println("JVM_LoadClass0: IMPLEMENT ME!");
2502 /* JVM_GetArrayLength */
2504 jint JVM_GetArrayLength(JNIEnv *env, jobject arr)
2508 TRACEJVMCALLS(("JVM_GetArrayLength(arr=%p)", arr));
2510 a = (java_handle_t *) arr;
2512 return array_length_get(a);
2516 /* JVM_GetArrayElement */
2518 jobject JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index)
2523 TRACEJVMCALLS(("JVM_GetArrayElement(env=%p, arr=%p, index=%d)", env, arr, index));
2525 a = (java_handle_t *) arr;
2527 /* if (!class_is_array(a->objheader.vftbl->class)) { */
2528 /* exceptions_throw_illegalargumentexception(); */
2532 o = array_element_get(a, index);
2538 /* JVM_GetPrimitiveArrayElement */
2540 jvalue JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode)
2544 log_println("JVM_GetPrimitiveArrayElement: IMPLEMENT ME!");
2552 /* JVM_SetArrayElement */
2554 void JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val)
2557 java_handle_t *value;
2559 TRACEJVMCALLS(("JVM_SetArrayElement(env=%p, arr=%p, index=%d, val=%p)", env, arr, index, val));
2561 a = (java_handle_t *) arr;
2562 value = (java_handle_t *) val;
2564 array_element_set(a, index, value);
2568 /* JVM_SetPrimitiveArrayElement */
2570 void JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode)
2572 log_println("JVM_SetPrimitiveArrayElement: IMPLEMENT ME!");
2578 jobject JVM_NewArray(JNIEnv *env, jclass eltClass, jint length)
2583 java_handle_objectarray_t *oa;
2585 TRACEJVMCALLS(("JVM_NewArray(env=%p, eltClass=%p, length=%d)", env, eltClass, length));
2587 if (eltClass == NULL) {
2588 exceptions_throw_nullpointerexception();
2592 /* NegativeArraySizeException is checked in builtin_newarray. */
2594 c = LLNI_classinfo_unwrap(eltClass);
2596 /* Create primitive or object array. */
2598 if (class_is_primitive(c)) {
2599 pc = Primitive::get_arrayclass_by_name(c->name);
2601 /* void arrays are not allowed. */
2604 exceptions_throw_illegalargumentexception();
2608 a = builtin_newarray(length, pc);
2613 oa = builtin_anewarray(length, c);
2615 return (jobject) oa;
2620 /* JVM_NewMultiArray */
2622 jobject JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim)
2625 java_handle_intarray_t *ia;
2631 java_handle_objectarray_t *a;
2633 TRACEJVMCALLS(("JVM_NewMultiArray(env=%p, eltClass=%p, dim=%p)", env, eltClass, dim));
2635 if (eltClass == NULL) {
2636 exceptions_throw_nullpointerexception();
2640 /* NegativeArraySizeException is checked in builtin_newarray. */
2642 c = LLNI_classinfo_unwrap(eltClass);
2644 ia = (java_handle_intarray_t *) dim;
2646 length = array_length_get((java_handle_t *) ia);
2648 /* We check here for exceptions thrown in array_length_get,
2649 otherwise these exceptions get overwritten by the following
2650 IllegalArgumentException. */
2655 if ((length <= 0) || (length > /* MAX_DIM */ 255)) {
2656 exceptions_throw_illegalargumentexception();
2660 /* XXX This is just a quick hack to get it working. */
2662 dims = MNEW(long, length);
2664 for (i = 0; i < length; i++) {
2665 value = LLNI_array_direct(ia, i);
2666 dims[i] = (long) value;
2669 /* Create an array-class if necessary. */
2671 if (class_is_primitive(c))
2672 ac = Primitive::get_arrayclass_by_name(c->name);
2674 ac = class_array_of(c, true);
2679 a = builtin_multianewarray(length, (java_handle_t *) ac, dims);
2685 /* JVM_InitializeSocketLibrary */
2687 jint JVM_InitializeSocketLibrary()
2689 TRACEJVMCALLS(("JVM_InitializeSocketLibrary()"));
2691 return hpi_initialize_socket_library();
2697 jint JVM_Socket(jint domain, jint type, jint protocol)
2699 TRACEJVMCALLS(("JVM_Socket(domain=%d, type=%d, protocol=%d)", domain, type, protocol));
2701 return os::socket(domain, type, protocol);
2705 /* JVM_SocketClose */
2707 jint JVM_SocketClose(jint fd)
2709 TRACEJVMCALLS(("JVM_SocketClose(fd=%d)", fd));
2711 return os::close(fd);
2715 /* JVM_SocketShutdown */
2717 jint JVM_SocketShutdown(jint fd, jint howto)
2719 TRACEJVMCALLS(("JVM_SocketShutdown(fd=%d, howto=%d)", fd, howto));
2721 return os::shutdown(fd, howto);
2727 jint JVM_Recv(jint fd, char *buf, jint nBytes, jint flags)
2729 log_println("JVM_Recv: IMPLEMENT ME!");
2737 jint JVM_Send(jint fd, char *buf, jint nBytes, jint flags)
2739 log_println("JVM_Send: IMPLEMENT ME!");
2747 jint JVM_Timeout(int fd, long timeout)
2749 log_println("JVM_Timeout: IMPLEMENT ME!");
2757 jint JVM_Listen(jint fd, jint count)
2759 TRACEJVMCALLS(("JVM_Listen(fd=%d, count=%d)", fd, count));
2761 return os::listen(fd, count);
2767 jint JVM_Connect(jint fd, struct sockaddr *him, jint len)
2769 TRACEJVMCALLS(("JVM_Connect(fd=%d, him=%p, len=%d)", fd, him, len));
2771 return os::connect(fd, him, len);
2777 jint JVM_Bind(jint fd, struct sockaddr *him, jint len)
2779 log_println("JVM_Bind: IMPLEMENT ME!");
2787 jint JVM_Accept(jint fd, struct sockaddr *him, jint *len)
2789 TRACEJVMCALLS(("JVM_Accept(fd=%d, him=%p, len=%p)", fd, him, len));
2791 return os::accept(fd, him, (socklen_t *) len);
2797 jint JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen)
2799 log_println("JVM_RecvFrom: IMPLEMENT ME!");
2805 /* JVM_GetSockName */
2807 jint JVM_GetSockName(jint fd, struct sockaddr *him, int *len)
2809 TRACEJVMCALLS(("JVM_GetSockName(fd=%d, him=%p, len=%p)", fd, him, len));
2811 return os::getsockname(fd, him, (socklen_t *) len);
2817 jint JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen)
2819 log_println("JVM_SendTo: IMPLEMENT ME!");
2825 /* JVM_SocketAvailable */
2827 jint JVM_SocketAvailable(jint fd, jint *pbytes)
2829 #if defined(FIONREAD)
2833 TRACEJVMCALLS(("JVM_SocketAvailable(fd=%d, pbytes=%p)", fd, pbytes));
2837 result = ioctl(fd, FIONREAD, &bytes);
2846 # error FIONREAD not defined
2851 /* JVM_GetSockOpt */
2853 jint JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen)
2855 TRACEJVMCALLS(("JVM_GetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%p)", fd, level, optname, optval, optlen));
2857 return os::getsockopt(fd, level, optname, optval, (socklen_t *) optlen);
2861 /* JVM_SetSockOpt */
2863 jint JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen)
2865 TRACEJVMCALLS(("JVM_SetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%d)", fd, level, optname, optval, optlen));
2867 return os::setsockopt(fd, level, optname, optval, optlen);
2871 /* JVM_GetHostName */
2873 int JVM_GetHostName(char *name, int namelen)
2877 TRACEJVMCALLSENTER(("JVM_GetHostName(name=%s, namelen=%d)", name, namelen));
2879 result = os::gethostname(name, namelen);
2881 TRACEJVMCALLSEXIT(("->%d (name=%s)", result, name));
2887 /* JVM_GetHostByAddr */
2889 struct hostent *JVM_GetHostByAddr(const char* name, int len, int type)
2891 log_println("JVM_GetHostByAddr: IMPLEMENT ME!");
2897 /* JVM_GetHostByName */
2899 struct hostent *JVM_GetHostByName(char* name)
2901 log_println("JVM_GetHostByName: IMPLEMENT ME!");
2907 /* JVM_GetProtoByName */
2909 struct protoent *JVM_GetProtoByName(char* name)
2911 log_println("JVM_GetProtoByName: IMPLEMENT ME!");
2917 /* JVM_LoadLibrary */
2919 void *JVM_LoadLibrary(const char *name)
2924 TRACEJVMCALLSENTER(("JVM_LoadLibrary(name=%s)", name));
2926 u = utf_new_char(name);
2928 handle = native_library_open(u);
2930 TRACEJVMCALLSEXIT(("->%p", handle));
2936 /* JVM_UnloadLibrary */
2938 void JVM_UnloadLibrary(void* handle)
2940 TRACEJVMCALLS(("JVM_UnloadLibrary(handle=%p)", handle));
2942 native_library_close(handle);
2946 /* JVM_FindLibraryEntry */
2948 void *JVM_FindLibraryEntry(void *handle, const char *name)
2952 TRACEJVMCALLSENTER(("JVM_FindLibraryEntry(handle=%p, name=%s)", handle, name));
2954 symbol = hpi_library->FindLibraryEntry(handle, name);
2956 TRACEJVMCALLSEXIT(("->%p", symbol));
2964 jboolean JVM_IsNaN(jdouble a)
2966 log_println("JVM_IsNaN: IMPLEMENT ME!");
2972 /* JVM_IsSupportedJNIVersion */
2974 jboolean JVM_IsSupportedJNIVersion(jint version)
2976 TRACEJVMCALLS(("JVM_IsSupportedJNIVersion(version=%d)", version));
2978 return jni_version_check(version);
2982 /* JVM_InternString */
2984 jstring JVM_InternString(JNIEnv *env, jstring str)
2986 TRACEJVMCALLS(("JVM_InternString(env=%p, str=%p)", env, str));
2988 return (jstring) javastring_intern((java_handle_t *) str);
2992 /* JVM_RawMonitorCreate */
2994 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void)
2998 TRACEJVMCALLS(("JVM_RawMonitorCreate()"));
3000 o = NEW(java_object_t);
3002 lock_init_object_lock(o);
3008 /* JVM_RawMonitorDestroy */
3010 JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void *mon)
3012 TRACEJVMCALLS(("JVM_RawMonitorDestroy(mon=%p)", mon));
3014 FREE(mon, java_object_t);
3018 /* JVM_RawMonitorEnter */
3020 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void *mon)
3022 TRACEJVMCALLS(("JVM_RawMonitorEnter(mon=%p)", mon));
3024 (void) lock_monitor_enter((java_object_t *) mon);
3030 /* JVM_RawMonitorExit */
3032 JNIEXPORT void JNICALL JVM_RawMonitorExit(void *mon)
3034 TRACEJVMCALLS(("JVM_RawMonitorExit(mon=%p)", mon));
3036 (void) lock_monitor_exit((java_object_t *) mon);
3040 /* JVM_SetPrimitiveFieldValues */
3042 void JVM_SetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
3044 log_println("JVM_SetPrimitiveFieldValues: IMPLEMENT ME!");
3048 /* JVM_GetPrimitiveFieldValues */
3050 void JVM_GetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
3052 log_println("JVM_GetPrimitiveFieldValues: IMPLEMENT ME!");
3056 /* JVM_AccessVMBooleanFlag */
3058 jboolean JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get)
3060 log_println("JVM_AccessVMBooleanFlag: IMPLEMENT ME!");
3066 /* JVM_AccessVMIntFlag */
3068 jboolean JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get)
3070 log_println("JVM_AccessVMIntFlag: IMPLEMENT ME!");
3076 /* JVM_VMBreakPoint */
3078 void JVM_VMBreakPoint(JNIEnv *env, jobject obj)
3080 log_println("JVM_VMBreakPoint: IMPLEMENT ME!");
3084 /* JVM_GetClassFields */
3086 jobjectArray JVM_GetClassFields(JNIEnv *env, jclass cls, jint which)
3088 log_println("JVM_GetClassFields: IMPLEMENT ME!");
3094 /* JVM_GetClassMethods */
3096 jobjectArray JVM_GetClassMethods(JNIEnv *env, jclass cls, jint which)
3098 log_println("JVM_GetClassMethods: IMPLEMENT ME!");
3104 /* JVM_GetClassConstructors */
3106 jobjectArray JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which)
3108 log_println("JVM_GetClassConstructors: IMPLEMENT ME!");
3114 /* JVM_GetClassField */
3116 jobject JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which)
3118 log_println("JVM_GetClassField: IMPLEMENT ME!");
3124 /* JVM_GetClassMethod */
3126 jobject JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types, jint which)
3128 log_println("JVM_GetClassMethod: IMPLEMENT ME!");
3134 /* JVM_GetClassConstructor */
3136 jobject JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types, jint which)
3138 log_println("JVM_GetClassConstructor: IMPLEMENT ME!");
3144 /* JVM_NewInstance */
3146 jobject JVM_NewInstance(JNIEnv *env, jclass cls)
3148 log_println("JVM_NewInstance: IMPLEMENT ME!");
3156 jobject JVM_GetField(JNIEnv *env, jobject field, jobject obj)
3158 log_println("JVM_GetField: IMPLEMENT ME!");
3164 /* JVM_GetPrimitiveField */
3166 jvalue JVM_GetPrimitiveField(JNIEnv *env, jobject field, jobject obj, unsigned char wCode)
3170 log_println("JVM_GetPrimitiveField: IMPLEMENT ME!");
3180 void JVM_SetField(JNIEnv *env, jobject field, jobject obj, jobject val)
3182 log_println("JVM_SetField: IMPLEMENT ME!");
3186 /* JVM_SetPrimitiveField */
3188 void JVM_SetPrimitiveField(JNIEnv *env, jobject field, jobject obj, jvalue v, unsigned char vCode)
3190 log_println("JVM_SetPrimitiveField: IMPLEMENT ME!");
3194 /* JVM_InvokeMethod */
3196 jobject JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)
3198 TRACEJVMCALLS(("JVM_InvokeMethod(env=%p, method=%p, obj=%p, args0=%p)", env, method, obj, args0));
3200 java_lang_reflect_Method jlrm(method);
3202 java_handle_t* result = jlrm.invoke((java_handle_t*) obj, (java_handle_objectarray_t*) args0);
3204 return (jobject) result;
3208 /* JVM_NewInstanceFromConstructor */
3210 jobject JVM_NewInstanceFromConstructor(JNIEnv *env, jobject con, jobjectArray args0)
3212 TRACEJVMCALLS(("JVM_NewInstanceFromConstructor(env=%p, c=%p, args0=%p)", env, con, args0));
3214 java_lang_reflect_Constructor jlrc(con);
3215 java_handle_t* o = jlrc.new_instance((java_handle_objectarray_t*) args0);
3221 /* JVM_SupportsCX8 */
3223 jboolean JVM_SupportsCX8()
3225 TRACEJVMCALLS(("JVM_SupportsCX8()"));
3235 jboolean JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal)
3237 log_println("JVM_CX8Field: IMPLEMENT ME!");
3243 /* JVM_GetAllThreads */
3245 jobjectArray JVM_GetAllThreads(JNIEnv *env, jclass dummy)
3247 log_println("JVM_GetAllThreads: IMPLEMENT ME!");
3253 /* JVM_DumpThreads */
3255 jobjectArray JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads)
3257 log_println("JVM_DumpThreads: IMPLEMENT ME!");
3263 /* JVM_GetManagement */
3265 void *JVM_GetManagement(jint version)
3267 TRACEJVMCALLS(("JVM_GetManagement(version=%d)", version));
3269 /* TODO We current don't support the management interface. */
3275 /* JVM_InitAgentProperties */
3277 jobject JVM_InitAgentProperties(JNIEnv *env, jobject properties)
3279 log_println("JVM_InitAgentProperties: IMPLEMENT ME!");
3285 /* JVM_GetEnclosingMethodInfo */
3287 jobjectArray JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass)
3291 java_handle_objectarray_t *oa;
3293 TRACEJVMCALLS(("JVM_GetEnclosingMethodInfo(env=%p, ofClass=%p)", env, ofClass));
3295 c = LLNI_classinfo_unwrap(ofClass);
3297 if ((c == NULL) || class_is_primitive(c))
3300 m = class_get_enclosingmethod_raw(c);
3305 oa = builtin_anewarray(3, class_java_lang_Object);
3310 array_objectarray_element_set(oa, 0, (java_handle_t *) LLNI_classinfo_wrap(m->clazz));
3311 array_objectarray_element_set(oa, 1, javastring_new(m->name));
3312 array_objectarray_element_set(oa, 2, javastring_new(m->descriptor));
3314 return (jobjectArray) oa;
3318 /* JVM_GetThreadStateValues */
3320 jintArray JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState)
3322 java_handle_intarray_t *ia;
3324 TRACEJVMCALLS(("JVM_GetThreadStateValues(env=%p, javaThreadState=%d)",
3325 env, javaThreadState));
3327 /* If new thread states are added in future JDK and VM versions,
3328 this should check if the JDK version is compatible with thread
3329 states supported by the VM. Return NULL if not compatible.
3331 This function must map the VM java_lang_Thread::ThreadStatus
3332 to the Java thread state that the JDK supports. */
3334 switch (javaThreadState) {
3335 case THREAD_STATE_NEW:
3336 ia = builtin_newarray_int(1);
3341 array_intarray_element_set(ia, 0, THREAD_STATE_NEW);
3344 case THREAD_STATE_RUNNABLE:
3345 ia = builtin_newarray_int(1);
3350 array_intarray_element_set(ia, 0, THREAD_STATE_RUNNABLE);
3353 case THREAD_STATE_BLOCKED:
3354 ia = builtin_newarray_int(1);
3359 array_intarray_element_set(ia, 0, THREAD_STATE_BLOCKED);
3362 case THREAD_STATE_WAITING:
3363 ia = builtin_newarray_int(2);
3368 array_intarray_element_set(ia, 0, THREAD_STATE_WAITING);
3369 /* XXX Implement parked stuff. */
3370 /* array_intarray_element_set(ia, 1, PARKED); */
3373 case THREAD_STATE_TIMED_WAITING:
3374 ia = builtin_newarray_int(3);
3379 /* XXX Not sure about that one. */
3380 /* array_intarray_element_set(ia, 0, SLEEPING); */
3381 array_intarray_element_set(ia, 0, THREAD_STATE_TIMED_WAITING);
3382 /* XXX Implement parked stuff. */
3383 /* array_intarray_element_set(ia, 2, PARKED); */
3386 case THREAD_STATE_TERMINATED:
3387 ia = builtin_newarray_int(1);
3392 array_intarray_element_set(ia, 0, THREAD_STATE_TERMINATED);
3396 /* Unknown state - probably incompatible JDK version */
3400 return (jintArray) ia;
3404 /* JVM_GetThreadStateNames */
3406 jobjectArray JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values)
3408 java_handle_intarray_t *ia;
3409 java_handle_objectarray_t *oa;
3412 TRACEJVMCALLS(("JVM_GetThreadStateNames(env=%p, javaThreadState=%d, values=%p)",
3413 env, javaThreadState, values));
3415 ia = (java_handle_intarray_t *) values;
3417 /* If new thread states are added in future JDK and VM versions,
3418 this should check if the JDK version is compatible with thread
3419 states supported by the VM. Return NULL if not compatible.
3421 This function must map the VM java_lang_Thread::ThreadStatus
3422 to the Java thread state that the JDK supports. */
3424 if (values == NULL) {
3425 exceptions_throw_nullpointerexception();
3429 switch (javaThreadState) {
3430 case THREAD_STATE_NEW:
3431 assert(ia->header.size == 1 && ia->data[0] == THREAD_STATE_NEW);
3433 oa = builtin_anewarray(1, class_java_lang_String);
3438 s = javastring_new(utf_new_char("NEW"));
3443 array_objectarray_element_set(oa, 0, s);
3446 case THREAD_STATE_RUNNABLE:
3447 oa = builtin_anewarray(1, class_java_lang_String);
3452 s = javastring_new(utf_new_char("RUNNABLE"));
3457 array_objectarray_element_set(oa, 0, s);
3460 case THREAD_STATE_BLOCKED:
3461 oa = builtin_anewarray(1, class_java_lang_String);
3466 s = javastring_new(utf_new_char("BLOCKED"));
3471 array_objectarray_element_set(oa, 0, s);
3474 case THREAD_STATE_WAITING:
3475 oa = builtin_anewarray(2, class_java_lang_String);
3480 s = javastring_new(utf_new_char("WAITING.OBJECT_WAIT"));
3481 /* s = javastring_new(utf_new_char("WAITING.PARKED")); */
3486 array_objectarray_element_set(oa, 0, s);
3487 /* array_objectarray_element_set(oa, 1, s); */
3490 case THREAD_STATE_TIMED_WAITING:
3491 oa = builtin_anewarray(3, class_java_lang_String);
3496 /* s = javastring_new(utf_new_char("TIMED_WAITING.SLEEPING")); */
3497 s = javastring_new(utf_new_char("TIMED_WAITING.OBJECT_WAIT"));
3498 /* s = javastring_new(utf_new_char("TIMED_WAITING.PARKED")); */
3503 /* array_objectarray_element_set(oa, 0, s); */
3504 array_objectarray_element_set(oa, 0, s);
3505 /* array_objectarray_element_set(oa, 2, s); */
3508 case THREAD_STATE_TERMINATED:
3509 oa = builtin_anewarray(1, class_java_lang_String);
3514 s = javastring_new(utf_new_char("TERMINATED"));
3519 array_objectarray_element_set(oa, 0, s);
3523 /* Unknown state - probably incompatible JDK version */
3527 return (jobjectArray) oa;
3531 /* JVM_GetVersionInfo */
3533 void JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size)
3535 log_println("JVM_GetVersionInfo: IMPLEMENT ME!");
3539 /* OS: JVM_RegisterSignal */
3541 void *JVM_RegisterSignal(jint sig, void *handler)
3543 functionptr newHandler;
3545 TRACEJVMCALLS(("JVM_RegisterSignal(sig=%d, handler=%p)", sig, handler));
3547 if (handler == (void *) 2)
3548 newHandler = (functionptr) signal_thread_handler;
3550 newHandler = (functionptr) (uintptr_t) handler;
3557 /* These signals are already used by the VM. */
3561 /* This signal is used by the VM to dump thread stacks unless
3562 ReduceSignalUsage is set, in which case the user is allowed
3563 to set his own _native_ handler for this signal; thus, in
3564 either case, we do not allow JVM_RegisterSignal to change
3574 signal_register_signal(sig, newHandler, SA_RESTART | SA_SIGINFO);
3576 /* XXX Should return old handler. */
3582 /* OS: JVM_RaiseSignal */
3584 jboolean JVM_RaiseSignal(jint sig)
3586 log_println("JVM_RaiseSignal: IMPLEMENT ME! sig=%s", sig);
3592 /* OS: JVM_FindSignal */
3594 jint JVM_FindSignal(const char *name)
3596 TRACEJVMCALLS(("JVM_FindSignal(name=%s)", name));
3598 #if defined(__LINUX__)
3599 if (strcmp(name, "HUP") == 0)
3602 if (strcmp(name, "INT") == 0)
3605 if (strcmp(name, "TERM") == 0)
3607 #elif defined(__SOLARIS__)
3610 if (os::str2sig(name, &signum) == -1)
3615 # error Not implemented for this OS.
3625 * These are local overrides for various environment variables in Emacs.
3626 * Please do not remove this and leave it at the end of the file, where
3627 * Emacs will automagically detect them.
3628 * ---------------------------------------------------------------------
3631 * indent-tabs-mode: t