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.hpp"
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.hpp"
64 #if defined(ENABLE_ASSERTION)
65 #include "vm/assertion.hpp"
68 #include "vm/jit/builtin.hpp"
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.hpp"
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 VM::get_current()->get_properties().put("sun.nio.MaxDirectMemorySize", buf);
290 // Fill the java.util.Properties object.
291 VM::get_current()->get_properties().fill(h);
299 void JVM_Exit(jint code)
301 log_println("JVM_Exit: IMPLEMENT ME!");
307 void JVM_Halt(jint code)
309 TRACEJVMCALLS(("JVM_Halt(code=%d)", code));
316 /* JVM_OnExit(void (*func)) */
318 void JVM_OnExit(void (*func)(void))
320 log_println("JVM_OnExit(void (*func): IMPLEMENT ME!");
328 TRACEJVMCALLS(("JVM_GC()"));
334 /* JVM_MaxObjectInspectionAge */
336 jlong JVM_MaxObjectInspectionAge(void)
338 log_println("JVM_MaxObjectInspectionAge: IMPLEMENT ME!");
344 /* JVM_TraceInstructions */
346 void JVM_TraceInstructions(jboolean on)
348 log_println("JVM_TraceInstructions: IMPLEMENT ME!");
352 /* JVM_TraceMethodCalls */
354 void JVM_TraceMethodCalls(jboolean on)
356 log_println("JVM_TraceMethodCalls: IMPLEMENT ME!");
360 /* JVM_TotalMemory */
362 jlong JVM_TotalMemory(void)
364 TRACEJVMCALLS(("JVM_TotalMemory()"));
366 return gc_get_heap_size();
372 jlong JVM_FreeMemory(void)
374 TRACEJVMCALLS(("JVM_FreeMemory()"));
376 return gc_get_free_bytes();
382 jlong JVM_MaxMemory(void)
384 TRACEJVMCALLS(("JVM_MaxMemory()"));
386 return gc_get_max_heap_size();
390 /* JVM_ActiveProcessorCount */
392 jint JVM_ActiveProcessorCount(void)
394 TRACEJVMCALLS(("JVM_ActiveProcessorCount()"));
396 return os::processors_online();
400 /* JVM_FillInStackTrace */
402 void JVM_FillInStackTrace(JNIEnv *env, jobject receiver)
404 TRACEJVMCALLS(("JVM_FillInStackTrace(env=%p, receiver=%p)", env, receiver));
406 java_handle_bytearray_t* ba = stacktrace_get_current();
411 java_lang_Throwable jlt(receiver, ba);
415 /* JVM_PrintStackTrace */
417 void JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable)
419 log_println("JVM_PrintStackTrace: IMPLEMENT ME!");
423 /* JVM_GetStackTraceDepth */
425 jint JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable)
427 TRACEJVMCALLS(("JVM_GetStackTraceDepth(env=%p, throwable=%p)", env, throwable));
429 java_lang_Throwable jlt(throwable);
432 exceptions_throw_nullpointerexception();
436 java_handle_bytearray_t* ba = jlt.get_backtrace();
441 // We need a critical section here as the stacktrace structure is
442 // mapped onto a Java byte-array.
446 stacktrace_t* st = (stacktrace_t *) LLNI_array_data(ba);
448 int32_t depth = st->length;
456 /* JVM_GetStackTraceElement */
458 jobject JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index)
460 TRACEJVMCALLS(("JVM_GetStackTraceElement(env=%p, throwable=%p, index=%d)", env, throwable, index));
462 java_lang_Throwable jlt(throwable);
463 java_handle_bytearray_t* ba = jlt.get_backtrace();
465 // We need a critical section here as the stacktrace structure is
466 // mapped onto a Java byte-array.
469 stacktrace_t* st = (stacktrace_t *) LLNI_array_data(ba);
471 if ((index < 0) || (index >= st->length)) {
472 /* XXX This should be an IndexOutOfBoundsException (check this
474 exceptions_throw_arrayindexoutofboundsexception();
478 // Get the stacktrace entry.
479 stacktrace_entry_t* ste = &(st->entries[index]);
481 // Get the codeinfo, methodinfo and classinfo.
482 codeinfo* code = ste->code;
483 methodinfo* m = code->m;
484 classinfo* c = m->clazz;
487 java_handle_t* filename;
489 if (!(m->flags & ACC_NATIVE)) {
490 if (c->sourcefile != NULL)
491 filename = javastring_new(c->sourcefile);
501 if (m->flags & ACC_NATIVE) {
505 // FIXME linenumbertable->find could change the methodinfo
506 // pointer when hitting an inlined method.
507 linenumber = code->linenumbertable->find(&m, ste->pc);
508 linenumber = (linenumber == 0) ? -1 : linenumber;
513 // Get declaring class name.
514 java_handle_t* declaringclass = class_get_classname(c);
516 // Allocate a new StackTraceElement object.
517 java_lang_StackTraceElement jlste(declaringclass, javastring_new(m->name), filename, linenumber);
522 return (jobject) jlste.get_handle();
528 jint JVM_IHashCode(JNIEnv* env, jobject handle)
530 TRACEJVMCALLS(("JVM_IHashCode(env=%p, jobject=%p)", env, handle));
532 java_lang_Object o(handle);
534 return o.get_hashcode();
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)
1664 TRACEJVMCALLS(("JVM_DesiredAssertionStatus(env=%p, unused=%p, cls=%p)", env, unused, cls));
1666 c = LLNI_classinfo_unwrap(cls);
1668 if (c->classloader == NULL) {
1669 status = (jboolean)assertion_system_enabled;
1672 status = (jboolean)assertion_user_enabled;
1675 if (list_assertion_names != NULL) {
1676 for (List<assertion_name_t*>::iterator it = list_assertion_names->begin();
1677 it != list_assertion_names->end(); it++) {
1678 assertion_name_t* item = *it;
1680 name = utf_new_char(item->name);
1681 if (name == c->packagename) {
1682 status = (jboolean)item->enabled;
1684 else if (name == c->name) {
1685 status = (jboolean)item->enabled;
1692 return (jboolean)false;
1697 /* JVM_AssertionStatusDirectives */
1699 jobject JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)
1701 java_handle_objectarray_t *classes;
1702 java_handle_objectarray_t *packages;
1703 java_booleanarray_t *classEnabled;
1704 java_booleanarray_t *packageEnabled;
1705 #if defined(ENABLE_ASSERTION)
1710 TRACEJVMCALLS(("JVM_AssertionStatusDirectives(env=%p, unused=%p)", env, unused));
1712 #if defined(ENABLE_ASSERTION)
1713 classes = builtin_anewarray(assertion_class_count, class_java_lang_Object);
1715 classes = builtin_anewarray(0, class_java_lang_Object);
1717 if (classes == NULL)
1720 #if defined(ENABLE_ASSERTION)
1721 packages = builtin_anewarray(assertion_package_count, class_java_lang_Object);
1723 packages = builtin_anewarray(0, class_java_lang_Object);
1725 if (packages == NULL)
1728 #if defined(ENABLE_ASSERTION)
1729 classEnabled = builtin_newarray_boolean(assertion_class_count);
1731 classEnabled = builtin_newarray_boolean(0);
1733 if (classEnabled == NULL)
1736 #if defined(ENABLE_ASSERTION)
1737 packageEnabled = builtin_newarray_boolean(assertion_package_count);
1739 packageEnabled = builtin_newarray_boolean(0);
1741 if (packageEnabled == NULL)
1744 #if defined(ENABLE_ASSERTION)
1745 /* initialize arrays */
1747 if (list_assertion_names != NULL) {
1751 for (List<assertion_name_t*>::iterator it = list_assertion_names->begin(); it != list_assertion_names->end(); it++) {
1752 assertion_name_t* item = *it;
1754 js = javastring_new_from_ascii(item->name);
1759 if (item->package == false) {
1760 classes->data[i] = js;
1761 classEnabled->data[i] = (jboolean) item->enabled;
1765 packages->data[j] = js;
1766 packageEnabled->data[j] = (jboolean) item->enabled;
1773 /* set instance fields */
1775 java_lang_AssertionStatusDirectives jlasd(classes, classEnabled, packages, packageEnabled);
1777 return (jobject) jlasd.get_handle();
1781 /* JVM_GetClassNameUTF */
1783 const char *JVM_GetClassNameUTF(JNIEnv *env, jclass cls)
1785 log_println("JVM_GetClassNameUTF: IMPLEMENT ME!");
1791 /* JVM_GetClassCPTypes */
1793 void JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types)
1795 log_println("JVM_GetClassCPTypes: IMPLEMENT ME!");
1799 /* JVM_GetClassCPEntriesCount */
1801 jint JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)
1803 log_println("JVM_GetClassCPEntriesCount: IMPLEMENT ME!");
1809 /* JVM_GetClassFieldsCount */
1811 jint JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)
1813 log_println("JVM_GetClassFieldsCount: IMPLEMENT ME!");
1819 /* JVM_GetClassMethodsCount */
1821 jint JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)
1823 log_println("JVM_GetClassMethodsCount: IMPLEMENT ME!");
1829 /* JVM_GetMethodIxExceptionIndexes */
1831 void JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions)
1833 log_println("JVM_GetMethodIxExceptionIndexes: IMPLEMENT ME!");
1837 /* JVM_GetMethodIxExceptionsCount */
1839 jint JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)
1841 log_println("JVM_GetMethodIxExceptionsCount: IMPLEMENT ME!");
1847 /* JVM_GetMethodIxByteCode */
1849 void JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code)
1851 log_println("JVM_GetMethodIxByteCode: IMPLEMENT ME!");
1855 /* JVM_GetMethodIxByteCodeLength */
1857 jint JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)
1859 log_println("JVM_GetMethodIxByteCodeLength: IMPLEMENT ME!");
1865 /* JVM_GetMethodIxExceptionTableEntry */
1867 void JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry)
1869 log_println("JVM_GetMethodIxExceptionTableEntry: IMPLEMENT ME!");
1873 /* JVM_GetMethodIxExceptionTableLength */
1875 jint JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)
1877 log_println("JVM_GetMethodIxExceptionTableLength: IMPLEMENT ME!");
1883 /* JVM_GetMethodIxModifiers */
1885 jint JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)
1887 log_println("JVM_GetMethodIxModifiers: IMPLEMENT ME!");
1893 /* JVM_GetFieldIxModifiers */
1895 jint JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)
1897 log_println("JVM_GetFieldIxModifiers: IMPLEMENT ME!");
1903 /* JVM_GetMethodIxLocalsCount */
1905 jint JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)
1907 log_println("JVM_GetMethodIxLocalsCount: IMPLEMENT ME!");
1913 /* JVM_GetMethodIxArgsSize */
1915 jint JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)
1917 log_println("JVM_GetMethodIxArgsSize: IMPLEMENT ME!");
1923 /* JVM_GetMethodIxMaxStack */
1925 jint JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)
1927 log_println("JVM_GetMethodIxMaxStack: IMPLEMENT ME!");
1933 /* JVM_IsConstructorIx */
1935 jboolean JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)
1937 log_println("JVM_IsConstructorIx: IMPLEMENT ME!");
1943 /* JVM_GetMethodIxNameUTF */
1945 const char *JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)
1947 log_println("JVM_GetMethodIxNameUTF: IMPLEMENT ME!");
1953 /* JVM_GetMethodIxSignatureUTF */
1955 const char *JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)
1957 log_println("JVM_GetMethodIxSignatureUTF: IMPLEMENT ME!");
1963 /* JVM_GetCPFieldNameUTF */
1965 const char *JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1967 log_println("JVM_GetCPFieldNameUTF: IMPLEMENT ME!");
1973 /* JVM_GetCPMethodNameUTF */
1975 const char *JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1977 log_println("JVM_GetCPMethodNameUTF: IMPLEMENT ME!");
1983 /* JVM_GetCPMethodSignatureUTF */
1985 const char *JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
1987 log_println("JVM_GetCPMethodSignatureUTF: IMPLEMENT ME!");
1993 /* JVM_GetCPFieldSignatureUTF */
1995 const char *JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
1997 log_println("JVM_GetCPFieldSignatureUTF: IMPLEMENT ME!");
2003 /* JVM_GetCPClassNameUTF */
2005 const char *JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2007 log_println("JVM_GetCPClassNameUTF: IMPLEMENT ME!");
2013 /* JVM_GetCPFieldClassNameUTF */
2015 const char *JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2017 log_println("JVM_GetCPFieldClassNameUTF: IMPLEMENT ME!");
2023 /* JVM_GetCPMethodClassNameUTF */
2025 const char *JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2027 log_println("JVM_GetCPMethodClassNameUTF: IMPLEMENT ME!");
2033 /* JVM_GetCPFieldModifiers */
2035 jint JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
2037 log_println("JVM_GetCPFieldModifiers: IMPLEMENT ME!");
2043 /* JVM_GetCPMethodModifiers */
2045 jint JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
2047 log_println("JVM_GetCPMethodModifiers: IMPLEMENT ME!");
2053 /* JVM_ReleaseUTF */
2055 void JVM_ReleaseUTF(const char *utf)
2057 log_println("JVM_ReleaseUTF: IMPLEMENT ME!");
2061 /* JVM_IsSameClassPackage */
2063 jboolean JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2)
2065 log_println("JVM_IsSameClassPackage: IMPLEMENT ME!");
2073 /* Taken from: hotspot/src/share/vm/prims/jvm.h */
2076 * JVM I/O error codes
2078 #define JVM_EEXIST -100
2080 jint JVM_Open(const char *fname, jint flags, jint mode)
2084 TRACEJVMCALLS(("JVM_Open(fname=%s, flags=%d, mode=%d)", fname, flags, mode));
2086 result = hpi_file->Open(fname, flags, mode);
2104 jint JVM_Close(jint fd)
2106 TRACEJVMCALLS(("JVM_Close(fd=%d)", fd));
2108 return hpi_file->Close(fd);
2114 jint JVM_Read(jint fd, char *buf, jint nbytes)
2116 TRACEJVMCALLS(("JVM_Read(fd=%d, buf=%p, nbytes=%d)", fd, buf, nbytes));
2118 return (jint) hpi_file->Read(fd, buf, nbytes);
2124 jint JVM_Write(jint fd, char *buf, jint nbytes)
2126 TRACEJVMCALLS(("JVM_Write(fd=%d, buf=%s, nbytes=%d)", fd, buf, nbytes));
2128 return (jint) hpi_file->Write(fd, buf, nbytes);
2134 jint JVM_Available(jint fd, jlong *pbytes)
2136 TRACEJVMCALLS(("JVM_Available(fd=%d, pbytes=%p)", fd, pbytes));
2138 return hpi_file->Available(fd, pbytes);
2144 jlong JVM_Lseek(jint fd, jlong offset, jint whence)
2146 TRACEJVMCALLS(("JVM_Lseek(fd=%d, offset=%ld, whence=%d)", fd, offset, whence));
2148 return hpi_file->Seek(fd, (off_t) offset, whence);
2154 jint JVM_SetLength(jint fd, jlong length)
2156 TRACEJVMCALLS(("JVM_SetLength(fd=%d, length=%ld)", length));
2158 return hpi_file->SetLength(fd, length);
2164 jint JVM_Sync(jint fd)
2166 TRACEJVMCALLS(("JVM_Sync(fd=%d)", fd));
2168 return hpi_file->Sync(fd);
2172 /* JVM_StartThread */
2174 void JVM_StartThread(JNIEnv* env, jobject jthread)
2176 TRACEJVMCALLS(("JVM_StartThread(env=%p, jthread=%p)", env, jthread));
2178 threads_thread_start((java_handle_t *) jthread);
2182 /* JVM_StopThread */
2184 void JVM_StopThread(JNIEnv* env, jobject jthread, jobject throwable)
2186 log_println("JVM_StopThread: Deprecated. Not implemented.");
2190 /* JVM_IsThreadAlive */
2192 jboolean JVM_IsThreadAlive(JNIEnv* env, jobject jthread)
2198 TRACEJVMCALLS(("JVM_IsThreadAlive(env=%p, jthread=%p)", env, jthread));
2200 h = (java_handle_t *) jthread;
2201 t = thread_get_thread(h);
2203 /* The threadobject is null when a thread is created in Java. The
2204 priority is set later during startup. */
2209 result = threads_thread_is_alive(t);
2215 /* JVM_SuspendThread */
2217 void JVM_SuspendThread(JNIEnv* env, jobject jthread)
2219 log_println("JVM_SuspendThread: Deprecated. Not implemented.");
2223 /* JVM_ResumeThread */
2225 void JVM_ResumeThread(JNIEnv* env, jobject jthread)
2227 log_println("JVM_ResumeThread: Deprecated. Not implemented.");
2231 /* JVM_SetThreadPriority */
2233 void JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio)
2238 TRACEJVMCALLS(("JVM_SetThreadPriority(env=%p, jthread=%p, prio=%d)", env, jthread, prio));
2240 h = (java_handle_t *) jthread;
2241 t = thread_get_thread(h);
2243 /* The threadobject is null when a thread is created in Java. The
2244 priority is set later during startup. */
2249 threads_set_thread_priority(t->tid, prio);
2255 void JVM_Yield(JNIEnv *env, jclass threadClass)
2257 TRACEJVMCALLS(("JVM_Yield(env=%p, threadClass=%p)", env, threadClass));
2265 void JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis)
2267 TRACEJVMCALLS(("JVM_Sleep(env=%p, threadClass=%p, millis=%ld)", env, threadClass, millis));
2269 threads_sleep(millis, 0);
2273 /* JVM_CurrentThread */
2275 jobject JVM_CurrentThread(JNIEnv* env, jclass threadClass)
2279 TRACEJVMCALLSVERBOSE(("JVM_CurrentThread(env=%p, threadClass=%p)", env, threadClass));
2281 o = thread_get_current_object();
2287 /* JVM_CountStackFrames */
2289 jint JVM_CountStackFrames(JNIEnv* env, jobject jthread)
2291 log_println("JVM_CountStackFrames: Deprecated. Not implemented.");
2299 void JVM_Interrupt(JNIEnv* env, jobject jthread)
2304 TRACEJVMCALLS(("JVM_Interrupt(env=%p, jthread=%p)", env, jthread));
2306 h = (java_handle_t *) jthread;
2307 t = thread_get_thread(h);
2312 threads_thread_interrupt(t);
2316 /* JVM_IsInterrupted */
2318 jboolean JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted)
2322 jboolean interrupted;
2324 TRACEJVMCALLS(("JVM_IsInterrupted(env=%p, jthread=%p, clear_interrupted=%d)", env, jthread, clear_interrupted));
2326 h = (java_handle_t *) jthread;
2327 t = thread_get_thread(h);
2329 interrupted = thread_is_interrupted(t);
2331 if (interrupted && clear_interrupted)
2332 thread_set_interrupted(t, false);
2340 jboolean JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj)
2345 TRACEJVMCALLS(("JVM_HoldsLock(env=%p, threadClass=%p, obj=%p)", env, threadClass, obj));
2347 h = (java_handle_t *) obj;
2350 exceptions_throw_nullpointerexception();
2354 result = lock_is_held_by_current_thread(h);
2360 /* JVM_DumpAllStacks */
2362 void JVM_DumpAllStacks(JNIEnv* env, jclass unused)
2364 log_println("JVM_DumpAllStacks: IMPLEMENT ME!");
2368 /* JVM_CurrentLoadedClass */
2370 jclass JVM_CurrentLoadedClass(JNIEnv *env)
2372 log_println("JVM_CurrentLoadedClass: IMPLEMENT ME!");
2378 /* JVM_CurrentClassLoader */
2380 jobject JVM_CurrentClassLoader(JNIEnv *env)
2382 /* XXX if a method in a class in a trusted loader is in a
2383 doPrivileged, return NULL */
2385 log_println("JVM_CurrentClassLoader: IMPLEMENT ME!");
2391 /* JVM_GetClassContext */
2393 jobjectArray JVM_GetClassContext(JNIEnv *env)
2395 TRACEJVMCALLS(("JVM_GetClassContext(env=%p)", env));
2397 return (jobjectArray) stacktrace_getClassContext();
2401 /* JVM_ClassDepth */
2403 jint JVM_ClassDepth(JNIEnv *env, jstring name)
2405 log_println("JVM_ClassDepth: IMPLEMENT ME!");
2411 /* JVM_ClassLoaderDepth */
2413 jint JVM_ClassLoaderDepth(JNIEnv *env)
2415 log_println("JVM_ClassLoaderDepth: IMPLEMENT ME!");
2421 /* JVM_GetSystemPackage */
2423 jstring JVM_GetSystemPackage(JNIEnv *env, jstring name)
2429 TRACEJVMCALLS(("JVM_GetSystemPackage(env=%p, name=%p)", env, name));
2431 /* s = Package::find(name); */
2432 u = javastring_toutf((java_handle_t *) name, false);
2434 result = Package::find(u);
2437 s = javastring_new(result);
2445 /* JVM_GetSystemPackages */
2447 jobjectArray JVM_GetSystemPackages(JNIEnv *env)
2449 log_println("JVM_GetSystemPackages: IMPLEMENT ME!");
2455 /* JVM_AllocateNewObject */
2457 jobject JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass)
2459 log_println("JVM_AllocateNewObject: IMPLEMENT ME!");
2465 /* JVM_AllocateNewArray */
2467 jobject JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length)
2469 log_println("JVM_AllocateNewArray: IMPLEMENT ME!");
2475 /* JVM_LatestUserDefinedLoader */
2477 jobject JVM_LatestUserDefinedLoader(JNIEnv *env)
2481 TRACEJVMCALLS(("JVM_LatestUserDefinedLoader(env=%p)", env));
2483 cl = stacktrace_first_nonnull_classloader();
2485 return (jobject) cl;
2489 /* JVM_LoadClass0 */
2491 jclass JVM_LoadClass0(JNIEnv *env, jobject receiver, jclass currClass, jstring currClassName)
2493 log_println("JVM_LoadClass0: IMPLEMENT ME!");
2499 /* JVM_GetArrayLength */
2501 jint JVM_GetArrayLength(JNIEnv *env, jobject arr)
2505 TRACEJVMCALLS(("JVM_GetArrayLength(arr=%p)", arr));
2507 a = (java_handle_t *) arr;
2509 return array_length_get(a);
2513 /* JVM_GetArrayElement */
2515 jobject JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index)
2520 TRACEJVMCALLS(("JVM_GetArrayElement(env=%p, arr=%p, index=%d)", env, arr, index));
2522 a = (java_handle_t *) arr;
2524 /* if (!class_is_array(a->objheader.vftbl->class)) { */
2525 /* exceptions_throw_illegalargumentexception(); */
2529 o = array_element_get(a, index);
2535 /* JVM_GetPrimitiveArrayElement */
2537 jvalue JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode)
2541 log_println("JVM_GetPrimitiveArrayElement: IMPLEMENT ME!");
2549 /* JVM_SetArrayElement */
2551 void JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val)
2554 java_handle_t *value;
2556 TRACEJVMCALLS(("JVM_SetArrayElement(env=%p, arr=%p, index=%d, val=%p)", env, arr, index, val));
2558 a = (java_handle_t *) arr;
2559 value = (java_handle_t *) val;
2561 array_element_set(a, index, value);
2565 /* JVM_SetPrimitiveArrayElement */
2567 void JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode)
2569 log_println("JVM_SetPrimitiveArrayElement: IMPLEMENT ME!");
2575 jobject JVM_NewArray(JNIEnv *env, jclass eltClass, jint length)
2580 java_handle_objectarray_t *oa;
2582 TRACEJVMCALLS(("JVM_NewArray(env=%p, eltClass=%p, length=%d)", env, eltClass, length));
2584 if (eltClass == NULL) {
2585 exceptions_throw_nullpointerexception();
2589 /* NegativeArraySizeException is checked in builtin_newarray. */
2591 c = LLNI_classinfo_unwrap(eltClass);
2593 /* Create primitive or object array. */
2595 if (class_is_primitive(c)) {
2596 pc = Primitive::get_arrayclass_by_name(c->name);
2598 /* void arrays are not allowed. */
2601 exceptions_throw_illegalargumentexception();
2605 a = builtin_newarray(length, pc);
2610 oa = builtin_anewarray(length, c);
2612 return (jobject) oa;
2617 /* JVM_NewMultiArray */
2619 jobject JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim)
2622 java_handle_intarray_t *ia;
2628 java_handle_objectarray_t *a;
2630 TRACEJVMCALLS(("JVM_NewMultiArray(env=%p, eltClass=%p, dim=%p)", env, eltClass, dim));
2632 if (eltClass == NULL) {
2633 exceptions_throw_nullpointerexception();
2637 /* NegativeArraySizeException is checked in builtin_newarray. */
2639 c = LLNI_classinfo_unwrap(eltClass);
2641 ia = (java_handle_intarray_t *) dim;
2643 length = array_length_get((java_handle_t *) ia);
2645 /* We check here for exceptions thrown in array_length_get,
2646 otherwise these exceptions get overwritten by the following
2647 IllegalArgumentException. */
2652 if ((length <= 0) || (length > /* MAX_DIM */ 255)) {
2653 exceptions_throw_illegalargumentexception();
2657 /* XXX This is just a quick hack to get it working. */
2659 dims = MNEW(long, length);
2661 for (i = 0; i < length; i++) {
2662 value = LLNI_array_direct(ia, i);
2663 dims[i] = (long) value;
2666 /* Create an array-class if necessary. */
2668 if (class_is_primitive(c))
2669 ac = Primitive::get_arrayclass_by_name(c->name);
2671 ac = class_array_of(c, true);
2676 a = builtin_multianewarray(length, (java_handle_t *) ac, dims);
2682 /* JVM_InitializeSocketLibrary */
2684 jint JVM_InitializeSocketLibrary()
2686 TRACEJVMCALLS(("JVM_InitializeSocketLibrary()"));
2688 return hpi_initialize_socket_library();
2694 jint JVM_Socket(jint domain, jint type, jint protocol)
2696 TRACEJVMCALLS(("JVM_Socket(domain=%d, type=%d, protocol=%d)", domain, type, protocol));
2698 return os::socket(domain, type, protocol);
2702 /* JVM_SocketClose */
2704 jint JVM_SocketClose(jint fd)
2706 TRACEJVMCALLS(("JVM_SocketClose(fd=%d)", fd));
2708 return os::close(fd);
2712 /* JVM_SocketShutdown */
2714 jint JVM_SocketShutdown(jint fd, jint howto)
2716 TRACEJVMCALLS(("JVM_SocketShutdown(fd=%d, howto=%d)", fd, howto));
2718 return os::shutdown(fd, howto);
2724 jint JVM_Recv(jint fd, char *buf, jint nBytes, jint flags)
2726 log_println("JVM_Recv: IMPLEMENT ME!");
2734 jint JVM_Send(jint fd, char *buf, jint nBytes, jint flags)
2736 log_println("JVM_Send: IMPLEMENT ME!");
2744 jint JVM_Timeout(int fd, long timeout)
2746 log_println("JVM_Timeout: IMPLEMENT ME!");
2754 jint JVM_Listen(jint fd, jint count)
2756 TRACEJVMCALLS(("JVM_Listen(fd=%d, count=%d)", fd, count));
2758 return os::listen(fd, count);
2764 jint JVM_Connect(jint fd, struct sockaddr *him, jint len)
2766 TRACEJVMCALLS(("JVM_Connect(fd=%d, him=%p, len=%d)", fd, him, len));
2768 return os::connect(fd, him, len);
2774 jint JVM_Bind(jint fd, struct sockaddr *him, jint len)
2776 log_println("JVM_Bind: IMPLEMENT ME!");
2784 jint JVM_Accept(jint fd, struct sockaddr *him, jint *len)
2786 TRACEJVMCALLS(("JVM_Accept(fd=%d, him=%p, len=%p)", fd, him, len));
2788 return os::accept(fd, him, (socklen_t *) len);
2794 jint JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen)
2796 log_println("JVM_RecvFrom: IMPLEMENT ME!");
2802 /* JVM_GetSockName */
2804 jint JVM_GetSockName(jint fd, struct sockaddr *him, int *len)
2806 TRACEJVMCALLS(("JVM_GetSockName(fd=%d, him=%p, len=%p)", fd, him, len));
2808 return os::getsockname(fd, him, (socklen_t *) len);
2814 jint JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen)
2816 log_println("JVM_SendTo: IMPLEMENT ME!");
2822 /* JVM_SocketAvailable */
2824 jint JVM_SocketAvailable(jint fd, jint *pbytes)
2826 #if defined(FIONREAD)
2830 TRACEJVMCALLS(("JVM_SocketAvailable(fd=%d, pbytes=%p)", fd, pbytes));
2834 result = ioctl(fd, FIONREAD, &bytes);
2843 # error FIONREAD not defined
2848 /* JVM_GetSockOpt */
2850 jint JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen)
2852 TRACEJVMCALLS(("JVM_GetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%p)", fd, level, optname, optval, optlen));
2854 return os::getsockopt(fd, level, optname, optval, (socklen_t *) optlen);
2858 /* JVM_SetSockOpt */
2860 jint JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen)
2862 TRACEJVMCALLS(("JVM_SetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%d)", fd, level, optname, optval, optlen));
2864 return os::setsockopt(fd, level, optname, optval, optlen);
2868 /* JVM_GetHostName */
2870 int JVM_GetHostName(char *name, int namelen)
2874 TRACEJVMCALLSENTER(("JVM_GetHostName(name=%s, namelen=%d)", name, namelen));
2876 result = os::gethostname(name, namelen);
2878 TRACEJVMCALLSEXIT(("->%d (name=%s)", result, name));
2884 /* JVM_GetHostByAddr */
2886 struct hostent *JVM_GetHostByAddr(const char* name, int len, int type)
2888 log_println("JVM_GetHostByAddr: IMPLEMENT ME!");
2894 /* JVM_GetHostByName */
2896 struct hostent *JVM_GetHostByName(char* name)
2898 log_println("JVM_GetHostByName: IMPLEMENT ME!");
2904 /* JVM_GetProtoByName */
2906 struct protoent *JVM_GetProtoByName(char* name)
2908 log_println("JVM_GetProtoByName: IMPLEMENT ME!");
2914 /* JVM_LoadLibrary */
2916 void *JVM_LoadLibrary(const char *name)
2921 TRACEJVMCALLSENTER(("JVM_LoadLibrary(name=%s)", name));
2923 u = utf_new_char(name);
2925 handle = native_library_open(u);
2927 TRACEJVMCALLSEXIT(("->%p", handle));
2933 /* JVM_UnloadLibrary */
2935 void JVM_UnloadLibrary(void* handle)
2937 TRACEJVMCALLS(("JVM_UnloadLibrary(handle=%p)", handle));
2939 native_library_close(handle);
2943 /* JVM_FindLibraryEntry */
2945 void *JVM_FindLibraryEntry(void *handle, const char *name)
2949 TRACEJVMCALLSENTER(("JVM_FindLibraryEntry(handle=%p, name=%s)", handle, name));
2951 symbol = hpi_library->FindLibraryEntry(handle, name);
2953 TRACEJVMCALLSEXIT(("->%p", symbol));
2961 jboolean JVM_IsNaN(jdouble a)
2963 log_println("JVM_IsNaN: IMPLEMENT ME!");
2969 /* JVM_IsSupportedJNIVersion */
2971 jboolean JVM_IsSupportedJNIVersion(jint version)
2973 TRACEJVMCALLS(("JVM_IsSupportedJNIVersion(version=%d)", version));
2975 return jni_version_check(version);
2979 /* JVM_InternString */
2981 jstring JVM_InternString(JNIEnv *env, jstring str)
2983 TRACEJVMCALLS(("JVM_InternString(env=%p, str=%p)", env, str));
2985 return (jstring) javastring_intern((java_handle_t *) str);
2989 /* JVM_RawMonitorCreate */
2991 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void)
2995 TRACEJVMCALLS(("JVM_RawMonitorCreate()"));
2997 o = NEW(java_object_t);
2999 lock_init_object_lock(o);
3005 /* JVM_RawMonitorDestroy */
3007 JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void *mon)
3009 TRACEJVMCALLS(("JVM_RawMonitorDestroy(mon=%p)", mon));
3011 FREE(mon, java_object_t);
3015 /* JVM_RawMonitorEnter */
3017 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void *mon)
3019 TRACEJVMCALLS(("JVM_RawMonitorEnter(mon=%p)", mon));
3021 (void) lock_monitor_enter((java_object_t *) mon);
3027 /* JVM_RawMonitorExit */
3029 JNIEXPORT void JNICALL JVM_RawMonitorExit(void *mon)
3031 TRACEJVMCALLS(("JVM_RawMonitorExit(mon=%p)", mon));
3033 (void) lock_monitor_exit((java_object_t *) mon);
3037 /* JVM_SetPrimitiveFieldValues */
3039 void JVM_SetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
3041 log_println("JVM_SetPrimitiveFieldValues: IMPLEMENT ME!");
3045 /* JVM_GetPrimitiveFieldValues */
3047 void JVM_GetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
3049 log_println("JVM_GetPrimitiveFieldValues: IMPLEMENT ME!");
3053 /* JVM_AccessVMBooleanFlag */
3055 jboolean JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get)
3057 log_println("JVM_AccessVMBooleanFlag: IMPLEMENT ME!");
3063 /* JVM_AccessVMIntFlag */
3065 jboolean JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get)
3067 log_println("JVM_AccessVMIntFlag: IMPLEMENT ME!");
3073 /* JVM_VMBreakPoint */
3075 void JVM_VMBreakPoint(JNIEnv *env, jobject obj)
3077 log_println("JVM_VMBreakPoint: IMPLEMENT ME!");
3081 /* JVM_GetClassFields */
3083 jobjectArray JVM_GetClassFields(JNIEnv *env, jclass cls, jint which)
3085 log_println("JVM_GetClassFields: IMPLEMENT ME!");
3091 /* JVM_GetClassMethods */
3093 jobjectArray JVM_GetClassMethods(JNIEnv *env, jclass cls, jint which)
3095 log_println("JVM_GetClassMethods: IMPLEMENT ME!");
3101 /* JVM_GetClassConstructors */
3103 jobjectArray JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which)
3105 log_println("JVM_GetClassConstructors: IMPLEMENT ME!");
3111 /* JVM_GetClassField */
3113 jobject JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which)
3115 log_println("JVM_GetClassField: IMPLEMENT ME!");
3121 /* JVM_GetClassMethod */
3123 jobject JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types, jint which)
3125 log_println("JVM_GetClassMethod: IMPLEMENT ME!");
3131 /* JVM_GetClassConstructor */
3133 jobject JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types, jint which)
3135 log_println("JVM_GetClassConstructor: IMPLEMENT ME!");
3141 /* JVM_NewInstance */
3143 jobject JVM_NewInstance(JNIEnv *env, jclass cls)
3145 log_println("JVM_NewInstance: IMPLEMENT ME!");
3153 jobject JVM_GetField(JNIEnv *env, jobject field, jobject obj)
3155 log_println("JVM_GetField: IMPLEMENT ME!");
3161 /* JVM_GetPrimitiveField */
3163 jvalue JVM_GetPrimitiveField(JNIEnv *env, jobject field, jobject obj, unsigned char wCode)
3167 log_println("JVM_GetPrimitiveField: IMPLEMENT ME!");
3177 void JVM_SetField(JNIEnv *env, jobject field, jobject obj, jobject val)
3179 log_println("JVM_SetField: IMPLEMENT ME!");
3183 /* JVM_SetPrimitiveField */
3185 void JVM_SetPrimitiveField(JNIEnv *env, jobject field, jobject obj, jvalue v, unsigned char vCode)
3187 log_println("JVM_SetPrimitiveField: IMPLEMENT ME!");
3191 /* JVM_InvokeMethod */
3193 jobject JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)
3195 TRACEJVMCALLS(("JVM_InvokeMethod(env=%p, method=%p, obj=%p, args0=%p)", env, method, obj, args0));
3197 java_lang_reflect_Method jlrm(method);
3199 java_handle_t* result = jlrm.invoke((java_handle_t*) obj, (java_handle_objectarray_t*) args0);
3201 return (jobject) result;
3205 /* JVM_NewInstanceFromConstructor */
3207 jobject JVM_NewInstanceFromConstructor(JNIEnv *env, jobject con, jobjectArray args0)
3209 TRACEJVMCALLS(("JVM_NewInstanceFromConstructor(env=%p, c=%p, args0=%p)", env, con, args0));
3211 java_lang_reflect_Constructor jlrc(con);
3212 java_handle_t* o = jlrc.new_instance((java_handle_objectarray_t*) args0);
3218 /* JVM_SupportsCX8 */
3220 jboolean JVM_SupportsCX8()
3222 TRACEJVMCALLS(("JVM_SupportsCX8()"));
3232 jboolean JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal)
3234 log_println("JVM_CX8Field: IMPLEMENT ME!");
3240 /* JVM_GetAllThreads */
3242 jobjectArray JVM_GetAllThreads(JNIEnv *env, jclass dummy)
3244 log_println("JVM_GetAllThreads: IMPLEMENT ME!");
3250 /* JVM_DumpThreads */
3252 jobjectArray JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads)
3254 log_println("JVM_DumpThreads: IMPLEMENT ME!");
3260 /* JVM_GetManagement */
3262 void *JVM_GetManagement(jint version)
3264 TRACEJVMCALLS(("JVM_GetManagement(version=%d)", version));
3266 /* TODO We current don't support the management interface. */
3272 /* JVM_InitAgentProperties */
3274 jobject JVM_InitAgentProperties(JNIEnv *env, jobject properties)
3276 log_println("JVM_InitAgentProperties: IMPLEMENT ME!");
3282 /* JVM_GetEnclosingMethodInfo */
3284 jobjectArray JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass)
3288 java_handle_objectarray_t *oa;
3290 TRACEJVMCALLS(("JVM_GetEnclosingMethodInfo(env=%p, ofClass=%p)", env, ofClass));
3292 c = LLNI_classinfo_unwrap(ofClass);
3294 if ((c == NULL) || class_is_primitive(c))
3297 m = class_get_enclosingmethod_raw(c);
3302 oa = builtin_anewarray(3, class_java_lang_Object);
3307 array_objectarray_element_set(oa, 0, (java_handle_t *) LLNI_classinfo_wrap(m->clazz));
3308 array_objectarray_element_set(oa, 1, javastring_new(m->name));
3309 array_objectarray_element_set(oa, 2, javastring_new(m->descriptor));
3311 return (jobjectArray) oa;
3315 /* JVM_GetThreadStateValues */
3317 jintArray JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState)
3319 java_handle_intarray_t *ia;
3321 TRACEJVMCALLS(("JVM_GetThreadStateValues(env=%p, javaThreadState=%d)",
3322 env, javaThreadState));
3324 /* If new thread states are added in future JDK and VM versions,
3325 this should check if the JDK version is compatible with thread
3326 states supported by the VM. Return NULL if not compatible.
3328 This function must map the VM java_lang_Thread::ThreadStatus
3329 to the Java thread state that the JDK supports. */
3331 switch (javaThreadState) {
3332 case THREAD_STATE_NEW:
3333 ia = builtin_newarray_int(1);
3338 array_intarray_element_set(ia, 0, THREAD_STATE_NEW);
3341 case THREAD_STATE_RUNNABLE:
3342 ia = builtin_newarray_int(1);
3347 array_intarray_element_set(ia, 0, THREAD_STATE_RUNNABLE);
3350 case THREAD_STATE_BLOCKED:
3351 ia = builtin_newarray_int(1);
3356 array_intarray_element_set(ia, 0, THREAD_STATE_BLOCKED);
3359 case THREAD_STATE_WAITING:
3360 ia = builtin_newarray_int(2);
3365 array_intarray_element_set(ia, 0, THREAD_STATE_WAITING);
3366 /* XXX Implement parked stuff. */
3367 /* array_intarray_element_set(ia, 1, PARKED); */
3370 case THREAD_STATE_TIMED_WAITING:
3371 ia = builtin_newarray_int(3);
3376 /* XXX Not sure about that one. */
3377 /* array_intarray_element_set(ia, 0, SLEEPING); */
3378 array_intarray_element_set(ia, 0, THREAD_STATE_TIMED_WAITING);
3379 /* XXX Implement parked stuff. */
3380 /* array_intarray_element_set(ia, 2, PARKED); */
3383 case THREAD_STATE_TERMINATED:
3384 ia = builtin_newarray_int(1);
3389 array_intarray_element_set(ia, 0, THREAD_STATE_TERMINATED);
3393 /* Unknown state - probably incompatible JDK version */
3397 return (jintArray) ia;
3401 /* JVM_GetThreadStateNames */
3403 jobjectArray JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values)
3405 java_handle_intarray_t *ia;
3406 java_handle_objectarray_t *oa;
3409 TRACEJVMCALLS(("JVM_GetThreadStateNames(env=%p, javaThreadState=%d, values=%p)",
3410 env, javaThreadState, values));
3412 ia = (java_handle_intarray_t *) values;
3414 /* If new thread states are added in future JDK and VM versions,
3415 this should check if the JDK version is compatible with thread
3416 states supported by the VM. Return NULL if not compatible.
3418 This function must map the VM java_lang_Thread::ThreadStatus
3419 to the Java thread state that the JDK supports. */
3421 if (values == NULL) {
3422 exceptions_throw_nullpointerexception();
3426 switch (javaThreadState) {
3427 case THREAD_STATE_NEW:
3428 assert(ia->header.size == 1 && ia->data[0] == THREAD_STATE_NEW);
3430 oa = builtin_anewarray(1, class_java_lang_String);
3435 s = javastring_new(utf_new_char("NEW"));
3440 array_objectarray_element_set(oa, 0, s);
3443 case THREAD_STATE_RUNNABLE:
3444 oa = builtin_anewarray(1, class_java_lang_String);
3449 s = javastring_new(utf_new_char("RUNNABLE"));
3454 array_objectarray_element_set(oa, 0, s);
3457 case THREAD_STATE_BLOCKED:
3458 oa = builtin_anewarray(1, class_java_lang_String);
3463 s = javastring_new(utf_new_char("BLOCKED"));
3468 array_objectarray_element_set(oa, 0, s);
3471 case THREAD_STATE_WAITING:
3472 oa = builtin_anewarray(2, class_java_lang_String);
3477 s = javastring_new(utf_new_char("WAITING.OBJECT_WAIT"));
3478 /* s = javastring_new(utf_new_char("WAITING.PARKED")); */
3483 array_objectarray_element_set(oa, 0, s);
3484 /* array_objectarray_element_set(oa, 1, s); */
3487 case THREAD_STATE_TIMED_WAITING:
3488 oa = builtin_anewarray(3, class_java_lang_String);
3493 /* s = javastring_new(utf_new_char("TIMED_WAITING.SLEEPING")); */
3494 s = javastring_new(utf_new_char("TIMED_WAITING.OBJECT_WAIT"));
3495 /* s = javastring_new(utf_new_char("TIMED_WAITING.PARKED")); */
3500 /* array_objectarray_element_set(oa, 0, s); */
3501 array_objectarray_element_set(oa, 0, s);
3502 /* array_objectarray_element_set(oa, 2, s); */
3505 case THREAD_STATE_TERMINATED:
3506 oa = builtin_anewarray(1, class_java_lang_String);
3511 s = javastring_new(utf_new_char("TERMINATED"));
3516 array_objectarray_element_set(oa, 0, s);
3520 /* Unknown state - probably incompatible JDK version */
3524 return (jobjectArray) oa;
3528 /* JVM_GetVersionInfo */
3530 void JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size)
3532 log_println("JVM_GetVersionInfo: IMPLEMENT ME!");
3536 /* OS: JVM_RegisterSignal */
3538 void *JVM_RegisterSignal(jint sig, void *handler)
3540 functionptr newHandler;
3542 TRACEJVMCALLS(("JVM_RegisterSignal(sig=%d, handler=%p)", sig, handler));
3544 if (handler == (void *) 2)
3545 newHandler = (functionptr) signal_thread_handler;
3547 newHandler = (functionptr) (uintptr_t) handler;
3554 /* These signals are already used by the VM. */
3558 /* This signal is used by the VM to dump thread stacks unless
3559 ReduceSignalUsage is set, in which case the user is allowed
3560 to set his own _native_ handler for this signal; thus, in
3561 either case, we do not allow JVM_RegisterSignal to change
3571 signal_register_signal(sig, newHandler, SA_RESTART | SA_SIGINFO);
3573 /* XXX Should return old handler. */
3579 /* OS: JVM_RaiseSignal */
3581 jboolean JVM_RaiseSignal(jint sig)
3583 log_println("JVM_RaiseSignal: IMPLEMENT ME! sig=%s", sig);
3589 /* OS: JVM_FindSignal */
3591 jint JVM_FindSignal(const char *name)
3593 TRACEJVMCALLS(("JVM_FindSignal(name=%s)", name));
3595 #if defined(__LINUX__)
3596 if (strcmp(name, "HUP") == 0)
3599 if (strcmp(name, "INT") == 0)
3602 if (strcmp(name, "TERM") == 0)
3604 #elif defined(__SOLARIS__)
3607 if (os::str2sig(name, &signum) == -1)
3612 # error Not implemented for this OS.
3622 * These are local overrides for various environment variables in Emacs.
3623 * Please do not remove this and leave it at the end of the file, where
3624 * Emacs will automagically detect them.
3625 * ---------------------------------------------------------------------
3628 * indent-tabs-mode: t