1 /* src/native/vm/openjdk/jvm.cpp - HotSpot VM interface functions
3 Copyright (C) 2007, 2008
4 CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
6 This file is part of CACAO.
8 This program is free software; you can redistribute it and/or
9 modify it under the terms of the GNU General Public License as
10 published by the Free Software Foundation; either version 2, or (at
11 your option) any later version.
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
35 #if defined(HAVE_SYS_IOCTL_H)
36 #define BSD_COMP /* Get FIONREAD on Solaris2 */
37 #include <sys/ioctl.h>
40 #include <sys/socket.h>
42 #include <sys/types.h>
44 // Include our JNI header before the JVM headers, because the JVM
45 // headers include jni.h and we want to override the typedefs in
47 #include "native/jni.hpp"
49 // We include jvm_md.h before jvm.h as the latter includes the former.
50 #include INCLUDE_JVM_MD_H
51 #include INCLUDE_JVM_H
53 #include "mm/memory.h"
55 #include "native/llni.h"
56 #include "native/native.hpp"
58 #include "native/vm/reflection.hpp"
60 #include "native/vm/openjdk/hpi.hpp"
61 #include "native/vm/openjdk/management.hpp"
63 #include "threads/lock.hpp"
64 #include "threads/thread.hpp"
66 #include "toolbox/logging.h"
67 #include "toolbox/list.hpp"
69 #include "vm/array.hpp"
71 #if defined(ENABLE_ASSERTION)
72 #include "vm/assertion.hpp"
75 #include "vm/jit/builtin.hpp"
76 #include "vm/classcache.h"
77 #include "vm/exceptions.hpp"
78 #include "vm/global.h"
79 #include "vm/globals.hpp"
80 #include "vm/initialize.hpp"
81 #include "vm/javaobjects.hpp"
82 #include "vm/options.h"
84 #include "vm/package.hpp"
85 #include "vm/primitive.hpp"
86 #include "vm/properties.hpp"
87 #include "vm/resolve.hpp"
88 #include "vm/signallocal.h"
89 #include "vm/string.hpp"
92 #include "vm/jit/stacktrace.hpp"
95 /* debugging macros ***********************************************************/
99 # define TRACEJVMCALLS(x) \
101 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
106 # define TRACEJVMCALLSENTER(x) \
108 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
114 # define TRACEJVMCALLSEXIT(x) \
116 if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
122 # define TRACEJVMCALLSVERBOSE(x) \
124 if (opt_TraceJVMCallsVerbose) { \
129 # define PRINTJVMWARNINGS(x)
131 /* if (opt_PrintJVMWarnings) { \ */
132 /* log_println x; \ */
138 # define TRACEJVMCALLS(x)
139 # define TRACEJVMCALLSENTER(x)
140 # define TRACEJVMCALLSEXIT(x)
141 # define TRACEJVMCALLSVERBOSE(x)
142 # define PRINTJVMWARNINGS(x)
147 // Interface functions are exported as C functions.
150 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
152 if ((intptr_t) count <= 0)
155 return vsnprintf(str, count, fmt, args);
159 int jio_snprintf(char *str, size_t count, const char *fmt, ...)
165 len = jio_vsnprintf(str, count, fmt, ap);
172 int jio_fprintf(FILE* f, const char *fmt, ...)
174 log_println("jio_fprintf: IMPLEMENT ME!");
180 int jio_vfprintf(FILE* f, const char *fmt, va_list args)
182 log_println("jio_vfprintf: IMPLEMENT ME!");
188 int jio_printf(const char *fmt, ...)
190 log_println("jio_printf: IMPLEMENT ME!");
196 /* JVM_GetInterfaceVersion */
198 jint JVM_GetInterfaceVersion()
200 /* This is defined in hotspot/src/share/vm/prims/jvm.h */
202 #define JVM_INTERFACE_VERSION 4
204 return JVM_INTERFACE_VERSION;
208 /* JVM_CurrentTimeMillis */
210 jlong JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)
212 TRACEJVMCALLS(("JVM_CurrentTimeMillis(env=%p, ignored=%p)", env, ignored));
214 return (jlong) builtin_currenttimemillis();
220 jlong JVM_NanoTime(JNIEnv *env, jclass ignored)
222 TRACEJVMCALLS(("JVM_NanoTime(env=%p, ignored=%p)", env, ignored));
224 return (jlong) builtin_nanotime();
230 void JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos, jobject dst, jint dst_pos, jint length)
235 s = (java_handle_t *) src;
236 d = (java_handle_t *) dst;
238 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));
240 builtin_arraycopy(s, src_pos, d, dst_pos, length);
244 /* JVM_InitProperties */
246 jobject JVM_InitProperties(JNIEnv *env, jobject properties)
251 TRACEJVMCALLS(("JVM_InitProperties(env=%p, properties=%p)", env, properties));
253 h = (java_handle_t *) properties;
255 /* Convert the -XX:MaxDirectMemorySize= command line flag to the
256 sun.nio.MaxDirectMemorySize property. Do this after setting
257 user properties to prevent people from setting the value with a
258 -D option, as requested. */
260 jio_snprintf(buf, sizeof(buf), PRINTF_FORMAT_INT64_T, opt_MaxDirectMemorySize);
261 VM::get_current()->get_properties().put("sun.nio.MaxDirectMemorySize", buf);
263 // Fill the java.util.Properties object.
264 VM::get_current()->get_properties().fill(h);
272 void JVM_Exit(jint code)
274 log_println("JVM_Exit: IMPLEMENT ME!");
280 void JVM_Halt(jint code)
282 TRACEJVMCALLS(("JVM_Halt(code=%d)", code));
289 /* JVM_OnExit(void (*func)) */
291 void JVM_OnExit(void (*func)(void))
293 log_println("JVM_OnExit(void (*func): IMPLEMENT ME!");
301 TRACEJVMCALLS(("JVM_GC()"));
307 /* JVM_MaxObjectInspectionAge */
309 jlong JVM_MaxObjectInspectionAge(void)
311 log_println("JVM_MaxObjectInspectionAge: IMPLEMENT ME!");
317 /* JVM_TraceInstructions */
319 void JVM_TraceInstructions(jboolean on)
321 log_println("JVM_TraceInstructions: IMPLEMENT ME!");
325 /* JVM_TraceMethodCalls */
327 void JVM_TraceMethodCalls(jboolean on)
329 log_println("JVM_TraceMethodCalls: IMPLEMENT ME!");
333 /* JVM_TotalMemory */
335 jlong JVM_TotalMemory(void)
337 TRACEJVMCALLS(("JVM_TotalMemory()"));
339 return gc_get_heap_size();
345 jlong JVM_FreeMemory(void)
347 TRACEJVMCALLS(("JVM_FreeMemory()"));
349 return gc_get_free_bytes();
355 jlong JVM_MaxMemory(void)
357 TRACEJVMCALLS(("JVM_MaxMemory()"));
359 return gc_get_max_heap_size();
363 /* JVM_ActiveProcessorCount */
365 jint JVM_ActiveProcessorCount(void)
367 TRACEJVMCALLS(("JVM_ActiveProcessorCount()"));
369 return os::processors_online();
373 /* JVM_FillInStackTrace */
375 void JVM_FillInStackTrace(JNIEnv *env, jobject receiver)
377 TRACEJVMCALLS(("JVM_FillInStackTrace(env=%p, receiver=%p)", env, receiver));
379 java_handle_bytearray_t* ba = stacktrace_get_current();
384 java_lang_Throwable jlt(receiver, ba);
388 /* JVM_PrintStackTrace */
390 void JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable)
392 log_println("JVM_PrintStackTrace: IMPLEMENT ME!");
396 /* JVM_GetStackTraceDepth */
398 jint JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable)
400 TRACEJVMCALLS(("JVM_GetStackTraceDepth(env=%p, throwable=%p)", env, throwable));
402 java_lang_Throwable jlt(throwable);
405 exceptions_throw_nullpointerexception();
409 java_handle_bytearray_t* ba = jlt.get_backtrace();
414 // We need a critical section here as the stacktrace structure is
415 // mapped onto a Java byte-array.
419 stacktrace_t* st = (stacktrace_t *) LLNI_array_data(ba);
421 int32_t depth = st->length;
429 /* JVM_GetStackTraceElement */
431 jobject JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index)
433 TRACEJVMCALLS(("JVM_GetStackTraceElement(env=%p, throwable=%p, index=%d)", env, throwable, index));
435 java_lang_Throwable jlt(throwable);
436 java_handle_bytearray_t* ba = jlt.get_backtrace();
438 // We need a critical section here as the stacktrace structure is
439 // mapped onto a Java byte-array.
442 stacktrace_t* st = (stacktrace_t *) LLNI_array_data(ba);
444 if ((index < 0) || (index >= st->length)) {
445 /* XXX This should be an IndexOutOfBoundsException (check this
447 exceptions_throw_arrayindexoutofboundsexception();
451 // Get the stacktrace entry.
452 stacktrace_entry_t* ste = &(st->entries[index]);
454 // Get the codeinfo, methodinfo and classinfo.
455 codeinfo* code = ste->code;
456 methodinfo* m = code->m;
457 classinfo* c = m->clazz;
460 java_handle_t* filename;
462 if (!(m->flags & ACC_NATIVE)) {
463 if (c->sourcefile != NULL)
464 filename = javastring_new(c->sourcefile);
474 if (m->flags & ACC_NATIVE) {
478 // FIXME linenumbertable->find could change the methodinfo
479 // pointer when hitting an inlined method.
480 linenumber = code->linenumbertable->find(&m, ste->pc);
481 linenumber = (linenumber == 0) ? -1 : linenumber;
486 // Get declaring class name.
487 java_handle_t* declaringclass = class_get_classname(c);
489 // Allocate a new StackTraceElement object.
490 java_lang_StackTraceElement jlste(declaringclass, javastring_new(m->name), filename, linenumber);
495 return (jobject) jlste.get_handle();
501 jint JVM_IHashCode(JNIEnv* env, jobject handle)
503 TRACEJVMCALLS(("JVM_IHashCode(env=%p, jobject=%p)", env, handle));
505 java_lang_Object o(handle);
507 return o.get_hashcode();
511 /* JVM_MonitorWait */
513 void JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms)
515 #if defined(ENABLE_THREADS)
519 TRACEJVMCALLS(("JVM_MonitorWait(env=%p, handle=%p, ms=%ld)", env, handle, ms));
521 /* exceptions_throw_illegalargumentexception("argument out of range"); */
522 exceptions_throw_illegalargumentexception();
526 #if defined(ENABLE_THREADS)
527 o = (java_handle_t *) handle;
529 lock_wait_for_object(o, ms, 0);
534 /* JVM_MonitorNotify */
536 void JVM_MonitorNotify(JNIEnv* env, jobject handle)
538 #if defined(ENABLE_THREADS)
542 TRACEJVMCALLS(("JVM_MonitorNotify(env=%p, handle=%p)", env, handle));
544 #if defined(ENABLE_THREADS)
545 o = (java_handle_t *) handle;
547 lock_notify_object(o);
552 /* JVM_MonitorNotifyAll */
554 void JVM_MonitorNotifyAll(JNIEnv* env, jobject handle)
556 #if defined(ENABLE_THREADS)
560 TRACEJVMCALLS(("JVM_MonitorNotifyAll(env=%p, handle=%p)", env, handle));
562 #if defined(ENABLE_THREADS)
563 o = (java_handle_t *) handle;
565 lock_notify_all_object(o);
572 jobject JVM_Clone(JNIEnv* env, jobject handle)
574 TRACEJVMCALLS(("JVM_Clone(env=%p, handle=%p)", env, handle));
576 return (jobject) builtin_clone(env, (java_handle_t *) handle);
580 /* JVM_InitializeCompiler */
582 void JVM_InitializeCompiler (JNIEnv *env, jclass compCls)
584 log_println("JVM_InitializeCompiler : IMPLEMENT ME!");
588 /* JVM_IsSilentCompiler */
590 jboolean JVM_IsSilentCompiler(JNIEnv *env, jclass compCls)
592 log_println("JVM_IsSilentCompiler: IMPLEMENT ME!");
598 /* JVM_CompileClass */
600 jboolean JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls)
602 log_println("JVM_CompileClass: IMPLEMENT ME!");
608 /* JVM_CompileClasses */
610 jboolean JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname)
612 log_println("JVM_CompileClasses: IMPLEMENT ME!");
618 /* JVM_CompilerCommand */
620 jobject JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg)
622 log_println("JVM_CompilerCommand: IMPLEMENT ME!");
628 /* JVM_EnableCompiler */
630 void JVM_EnableCompiler(JNIEnv *env, jclass compCls)
632 TRACEJVMCALLS(("JVM_EnableCompiler(env=%p, compCls=%p)", env, compCls));
633 PRINTJVMWARNINGS(("JVM_EnableCompiler not supported"));
637 /* JVM_DisableCompiler */
639 void JVM_DisableCompiler(JNIEnv *env, jclass compCls)
641 TRACEJVMCALLS(("JVM_DisableCompiler(env=%p, compCls=%p)", env, compCls));
642 PRINTJVMWARNINGS(("JVM_DisableCompiler not supported"));
646 /* JVM_GetLastErrorString */
648 jint JVM_GetLastErrorString(char* buf, int len)
650 TRACEJVMCALLS(("JVM_GetLastErrorString(buf=%p, len=%d", buf, len));
652 HPI& hpi = VM::get_current()->get_hpi();
653 return hpi.get_system().GetLastErrorString(buf, len);
659 char *JVM_NativePath(char* path)
661 TRACEJVMCALLS(("JVM_NativePath(path=%s)", path));
663 HPI& hpi = VM::get_current()->get_hpi();
664 return hpi.get_file().NativePath(path);
668 /* JVM_GetCallerClass */
670 jclass JVM_GetCallerClass(JNIEnv* env, int depth)
674 TRACEJVMCALLS(("JVM_GetCallerClass(env=%p, depth=%d)", env, depth));
676 c = stacktrace_get_caller_class(depth);
682 /* JVM_FindPrimitiveClass */
684 jclass JVM_FindPrimitiveClass(JNIEnv* env, const char* s)
689 TRACEJVMCALLS(("JVM_FindPrimitiveClass(env=%p, s=%s)", env, s));
692 c = Primitive::get_class_by_name(u);
694 return (jclass) LLNI_classinfo_wrap(c);
698 /* JVM_ResolveClass */
700 void JVM_ResolveClass(JNIEnv* env, jclass cls)
702 TRACEJVMCALLS(("JVM_ResolveClass(env=%p, cls=%p)", env, cls));
703 PRINTJVMWARNINGS(("JVM_ResolveClass not implemented"));
707 /* JVM_FindClassFromClassLoader */
709 jclass JVM_FindClassFromClassLoader(JNIEnv* env, const char* name, jboolean init, jobject loader, jboolean throwError)
715 TRACEJVMCALLS(("JVM_FindClassFromClassLoader(name=%s, init=%d, loader=%p, throwError=%d)", name, init, loader, throwError));
717 /* As of now, OpenJDK does not call this function with throwError
720 assert(throwError == false);
722 u = utf_new_char(name);
723 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
725 c = load_class_from_classloader(u, cl);
731 if (!(c->state & CLASS_INITIALIZED))
732 if (!initialize_class(c))
735 return (jclass) LLNI_classinfo_wrap(c);
739 /* JVM_FindClassFromClass */
741 jclass JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init, jclass from)
743 log_println("JVM_FindClassFromClass: IMPLEMENT ME!");
749 /* JVM_DefineClass */
751 jclass JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)
753 log_println("JVM_DefineClass: IMPLEMENT ME!");
759 /* JVM_DefineClassWithSource */
761 jclass JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)
767 TRACEJVMCALLS(("JVM_DefineClassWithSource(env=%p, name=%s, loader=%p, buf=%p, len=%d, pd=%p, source=%s)", env, name, loader, buf, len, pd, source));
770 u = utf_new_char(name);
774 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
776 /* XXX do something with source */
778 c = class_define(u, cl, len, (uint8_t *) buf, (java_handle_t *) pd);
780 return (jclass) LLNI_classinfo_wrap(c);
784 /* JVM_FindLoadedClass */
786 jclass JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name)
792 TRACEJVMCALLS(("JVM_FindLoadedClass(env=%p, loader=%p, name=%p)", env, loader, name));
794 cl = loader_hashtable_classloader_add((java_handle_t *) loader);
796 u = javastring_toutf((java_handle_t *) name, true);
797 c = classcache_lookup(cl, u);
799 return (jclass) LLNI_classinfo_wrap(c);
803 /* JVM_GetClassName */
805 jstring JVM_GetClassName(JNIEnv *env, jclass cls)
809 TRACEJVMCALLS(("JVM_GetClassName(env=%p, cls=%p)", env, cls));
811 c = LLNI_classinfo_unwrap(cls);
813 return (jstring) class_get_classname(c);
817 /* JVM_GetClassInterfaces */
819 jobjectArray JVM_GetClassInterfaces(JNIEnv *env, jclass cls)
822 java_handle_objectarray_t *oa;
824 TRACEJVMCALLS(("JVM_GetClassInterfaces(env=%p, cls=%p)", env, cls));
826 c = LLNI_classinfo_unwrap(cls);
828 oa = class_get_interfaces(c);
830 return (jobjectArray) oa;
834 /* JVM_GetClassLoader */
836 jobject JVM_GetClassLoader(JNIEnv *env, jclass cls)
841 TRACEJVMCALLSENTER(("JVM_GetClassLoader(env=%p, cls=%p)", env, cls));
843 c = LLNI_classinfo_unwrap(cls);
844 cl = class_get_classloader(c);
846 TRACEJVMCALLSEXIT(("->%p", cl));
852 /* JVM_IsInterface */
854 jboolean JVM_IsInterface(JNIEnv *env, jclass cls)
858 TRACEJVMCALLS(("JVM_IsInterface(env=%p, cls=%p)", env, cls));
860 c = LLNI_classinfo_unwrap(cls);
862 return class_is_interface(c);
866 /* JVM_GetClassSigners */
868 jobjectArray JVM_GetClassSigners(JNIEnv *env, jclass cls)
870 log_println("JVM_GetClassSigners: IMPLEMENT ME!");
876 /* JVM_SetClassSigners */
878 void JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers)
881 java_handle_objectarray_t *hoa;
883 TRACEJVMCALLS(("JVM_SetClassSigners(env=%p, cls=%p, signers=%p)", env, cls, signers));
885 c = LLNI_classinfo_unwrap(cls);
887 hoa = (java_handle_objectarray_t *) signers;
889 /* This call is ignored for primitive types and arrays. Signers
890 are only set once, ClassLoader.java, and thus shouldn't be
891 called with an array. Only the bootstrap loader creates
894 if (class_is_primitive(c) || class_is_array(c))
897 LLNI_classinfo_field_set(c, signers, hoa);
901 /* JVM_GetProtectionDomain */
903 jobject JVM_GetProtectionDomain(JNIEnv *env, jclass cls)
907 TRACEJVMCALLS(("JVM_GetProtectionDomain(env=%p, cls=%p)", env, cls));
909 c = LLNI_classinfo_unwrap(cls);
912 exceptions_throw_nullpointerexception();
916 /* Primitive types do not have a protection domain. */
918 if (class_is_primitive(c))
921 return (jobject) c->protectiondomain;
925 /* JVM_SetProtectionDomain */
927 void JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain)
929 log_println("JVM_SetProtectionDomain: IMPLEMENT ME!");
933 /* JVM_DoPrivileged */
935 jobject JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, jobject context, jboolean wrapException)
940 java_handle_t *result;
943 TRACEJVMCALLS(("JVM_DoPrivileged(env=%p, cls=%p, action=%p, context=%p, wrapException=%d)", env, cls, action, context, wrapException));
945 h = (java_handle_t *) action;
946 LLNI_class_get(h, c);
948 if (action == NULL) {
949 exceptions_throw_nullpointerexception();
953 /* lookup run() method (throw no exceptions) */
955 m = class_resolveclassmethod(c, utf_run, utf_void__java_lang_Object, c,
958 if ((m == NULL) || !(m->flags & ACC_PUBLIC) || (m->flags & ACC_STATIC)) {
959 exceptions_throw_internalerror("No run method");
963 /* XXX It seems something with a privileged stack needs to be done
966 result = vm_call_method(m, h);
968 e = exceptions_get_exception();
971 if ( builtin_instanceof(e, class_java_lang_Exception) &&
972 !builtin_instanceof(e, class_java_lang_RuntimeException)) {
973 exceptions_clear_exception();
974 exceptions_throw_privilegedactionexception(e);
980 return (jobject) result;
984 /* JVM_GetInheritedAccessControlContext */
986 jobject JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls)
988 log_println("JVM_GetInheritedAccessControlContext: IMPLEMENT ME!");
994 /* JVM_GetStackAccessControlContext */
996 jobject JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls)
998 TRACEJVMCALLS(("JVM_GetStackAccessControlContext(env=%p, cls=%p): IMPLEMENT ME!", env, cls));
1000 /* XXX All stuff I tested so far works without that function. At
1001 some point we have to implement it, but I disable the output
1002 for now to make IcedTea happy. */
1008 /* JVM_IsArrayClass */
1010 jboolean JVM_IsArrayClass(JNIEnv *env, jclass cls)
1014 TRACEJVMCALLS(("JVM_IsArrayClass(env=%p, cls=%p)", env, cls));
1016 c = LLNI_classinfo_unwrap(cls);
1018 return class_is_array(c);
1022 /* JVM_IsPrimitiveClass */
1024 jboolean JVM_IsPrimitiveClass(JNIEnv *env, jclass cls)
1028 TRACEJVMCALLS(("JVM_IsPrimitiveClass(env=%p, cls=%p)", env, cls));
1030 c = LLNI_classinfo_unwrap(cls);
1032 return class_is_primitive(c);
1036 /* JVM_GetComponentType */
1038 jclass JVM_GetComponentType(JNIEnv *env, jclass cls)
1040 classinfo *component;
1043 TRACEJVMCALLS(("JVM_GetComponentType(env=%p, cls=%p)", env, cls));
1045 c = LLNI_classinfo_unwrap(cls);
1047 component = class_get_componenttype(c);
1049 return (jclass) LLNI_classinfo_wrap(component);
1053 /* JVM_GetClassModifiers */
1055 jint JVM_GetClassModifiers(JNIEnv *env, jclass cls)
1060 TRACEJVMCALLS(("JVM_GetClassModifiers(env=%p, cls=%p)", env, cls));
1062 c = LLNI_classinfo_unwrap(cls);
1064 flags = class_get_modifiers(c, false);
1070 /* JVM_GetDeclaredClasses */
1072 jobjectArray JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)
1075 java_handle_objectarray_t *oa;
1077 TRACEJVMCALLS(("JVM_GetDeclaredClasses(env=%p, ofClass=%p)", env, ofClass));
1079 c = LLNI_classinfo_unwrap(ofClass);
1081 oa = class_get_declaredclasses(c, false);
1083 return (jobjectArray) oa;
1087 /* JVM_GetDeclaringClass */
1089 jclass JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass)
1094 TRACEJVMCALLS(("JVM_GetDeclaringClass(env=%p, ofClass=%p)", env, ofClass));
1096 c = LLNI_classinfo_unwrap(ofClass);
1098 dc = class_get_declaringclass(c);
1100 return (jclass) LLNI_classinfo_wrap(dc);
1104 /* JVM_GetClassSignature */
1106 jstring JVM_GetClassSignature(JNIEnv *env, jclass cls)
1112 TRACEJVMCALLS(("JVM_GetClassSignature(env=%p, cls=%p)", env, cls));
1114 c = LLNI_classinfo_unwrap(cls);
1116 /* Get the signature of the class. */
1118 u = class_get_signature(c);
1123 /* Convert UTF-string to a Java-string. */
1125 s = javastring_new(u);
1131 /* JVM_GetClassAnnotations */
1133 jbyteArray JVM_GetClassAnnotations(JNIEnv *env, jclass cls)
1135 TRACEJVMCALLS(("JVM_GetClassAnnotations(env=%p, cls=%p)", env, cls));
1138 exceptions_throw_nullpointerexception();
1142 classinfo* c = LLNI_classinfo_unwrap(cls);
1144 /* get annotations: */
1145 java_handle_bytearray_t* annotations = class_get_annotations(c);
1147 return (jbyteArray) annotations;
1151 /* JVM_GetFieldAnnotations */
1153 jbyteArray JVM_GetFieldAnnotations(JNIEnv *env, jobject field)
1155 TRACEJVMCALLS(("JVM_GetFieldAnnotations(env=%p, field=%p)", env, field));
1157 java_lang_reflect_Field jlrf(field);
1159 if (jlrf.is_null()) {
1160 exceptions_throw_nullpointerexception();
1164 return (jbyteArray) jlrf.get_annotations();
1168 /* JVM_GetMethodAnnotations */
1170 jbyteArray JVM_GetMethodAnnotations(JNIEnv *env, jobject method)
1172 TRACEJVMCALLS(("JVM_GetMethodAnnotations(env=%p, method=%p)", env, method));
1174 java_lang_reflect_Method jlrm(method);
1176 if (jlrm.is_null()) {
1177 exceptions_throw_nullpointerexception();
1181 return (jbyteArray) jlrm.get_annotations();
1185 /* JVM_GetMethodDefaultAnnotationValue */
1187 jbyteArray JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method)
1189 TRACEJVMCALLS(("JVM_GetMethodDefaultAnnotationValue(env=%p, method=%p)", env, method));
1191 java_lang_reflect_Method jlrm(method);
1193 if (jlrm.is_null()) {
1194 exceptions_throw_nullpointerexception();
1198 return (jbyteArray) jlrm.get_annotationDefault();
1202 /* JVM_GetMethodParameterAnnotations */
1204 jbyteArray JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method)
1206 TRACEJVMCALLS(("JVM_GetMethodParameterAnnotations(env=%p, method=%p)", env, method));
1208 java_lang_reflect_Method jlrm(method);
1210 if (jlrm.is_null()) {
1211 exceptions_throw_nullpointerexception();
1215 return (jbyteArray) jlrm.get_parameterAnnotations();
1219 /* JVM_GetClassDeclaredFields */
1221 jobjectArray JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1224 java_handle_objectarray_t *oa;
1226 TRACEJVMCALLS(("JVM_GetClassDeclaredFields(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1228 c = LLNI_classinfo_unwrap(ofClass);
1230 oa = class_get_declaredfields(c, publicOnly);
1232 return (jobjectArray) oa;
1236 /* JVM_GetClassDeclaredMethods */
1238 jobjectArray JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1240 TRACEJVMCALLS(("JVM_GetClassDeclaredMethods(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1242 classinfo* c = LLNI_classinfo_unwrap(ofClass);
1244 java_handle_objectarray_t* oa = class_get_declaredmethods(c, publicOnly);
1246 return (jobjectArray) oa;
1250 /* JVM_GetClassDeclaredConstructors */
1252 jobjectArray JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly)
1255 java_handle_objectarray_t *oa;
1257 TRACEJVMCALLS(("JVM_GetClassDeclaredConstructors(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly));
1259 c = LLNI_classinfo_unwrap(ofClass);
1261 oa = class_get_declaredconstructors(c, publicOnly);
1263 return (jobjectArray) oa;
1267 /* JVM_GetClassAccessFlags */
1269 jint JVM_GetClassAccessFlags(JNIEnv *env, jclass cls)
1273 TRACEJVMCALLS(("JVM_GetClassAccessFlags(env=%p, cls=%p)", env, cls));
1275 c = LLNI_classinfo_unwrap(cls);
1277 /* Primitive type classes have the correct access flags. */
1279 return c->flags & ACC_CLASS_REFLECT_MASK;
1283 /* JVM_GetClassConstantPool */
1285 jobject JVM_GetClassConstantPool(JNIEnv *env, jclass cls)
1287 #if defined(ENABLE_ANNOTATIONS)
1288 TRACEJVMCALLS(("JVM_GetClassConstantPool(env=%p, cls=%p)", env, cls));
1290 java_handle_t* h = native_new_and_init(class_sun_reflect_ConstantPool);
1291 sun_reflect_ConstantPool cp(h, cls);
1297 return (jobject) cp.get_handle();
1299 log_println("JVM_GetClassConstantPool(env=%p, cls=%p): not implemented in this configuration!", env, cls);
1305 /* JVM_ConstantPoolGetSize */
1307 jint JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool)
1309 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1311 TRACEJVMCALLS(("JVM_ConstantPoolGetSize(env=%p, unused=%p, jcpool=%p)", env, unused, jcpool));
1313 c = LLNI_classinfo_unwrap(jcpool);
1319 /* JVM_ConstantPoolGetClassAt */
1321 jclass JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1323 constant_classref *ref; /* classref to the class at constant pool index 'index' */
1324 classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
1325 classinfo *result; /* classinfo of the class at constant pool index 'index' */
1327 TRACEJVMCALLS(("JVM_ConstantPoolGetClassAt(env=%p, jcpool=%p, index=%d)", env, jcpool, index));
1329 c = LLNI_classinfo_unwrap(jcpool);
1331 ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1334 exceptions_throw_illegalargumentexception();
1338 result = resolve_classref_eager(ref);
1340 return (jclass) LLNI_classinfo_wrap(result);
1344 /* JVM_ConstantPoolGetClassAtIfLoaded */
1346 jclass JVM_ConstantPoolGetClassAtIfLoaded(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_ConstantPoolGetClassAtIfLoaded(env=%p, unused=%p, jcpool=%p, index=%d)", env, unused, jcpool, index));
1354 c = LLNI_classinfo_unwrap(jcpool);
1356 ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
1359 exceptions_throw_illegalargumentexception();
1363 if (!resolve_classref(NULL, ref, resolveLazy, true, true, &result)) {
1367 if ((result == NULL) || !(result->state & CLASS_LOADED)) {
1371 return (jclass) LLNI_classinfo_wrap(result);
1375 /* JVM_ConstantPoolGetMethodAt */
1377 jobject JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1379 constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
1380 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1382 TRACEJVMCALLS(("JVM_ConstantPoolGetMethodAt: jcpool=%p, index=%d", jcpool, index));
1384 cls = LLNI_classinfo_unwrap(jcpool);
1385 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1388 exceptions_throw_illegalargumentexception();
1392 // Create a new java.lang.reflect.Method Java object.
1393 /* XXX: is that right? or do I have to use resolve_method_*? */
1394 java_lang_reflect_Method jlrm(ref->p.method);
1396 return (jobject) jlrm.get_handle();
1400 /* JVM_ConstantPoolGetMethodAtIfLoaded */
1402 jobject JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1404 constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
1405 classinfo *c = NULL; /* resolved declaring class of the method */
1406 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1408 TRACEJVMCALLS(("JVM_ConstantPoolGetMethodAtIfLoaded: jcpool=%p, index=%d", jcpool, index));
1410 cls = LLNI_classinfo_unwrap(jcpool);
1411 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
1414 exceptions_throw_illegalargumentexception();
1418 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1422 if (c == NULL || !(c->state & CLASS_LOADED)) {
1426 // Create a new java.lang.reflect.Method Java object.
1427 java_lang_reflect_Method jlrm(ref->p.method);
1429 return (jobject) jlrm.get_handle();
1433 /* JVM_ConstantPoolGetFieldAt */
1435 jobject JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1437 constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
1438 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1440 TRACEJVMCALLS(("JVM_ConstantPoolGetFieldAt: jcpool=%p, index=%d", jcpool, index));
1442 cls = LLNI_classinfo_unwrap(jcpool);
1443 ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
1446 exceptions_throw_illegalargumentexception();
1450 // Create a new java.lang.reflect.Field Java object.
1451 java_lang_reflect_Field jlrf(ref->p.field);
1453 return (jobject) jlrf.get_handle();
1457 /* JVM_ConstantPoolGetFieldAtIfLoaded */
1459 jobject JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1461 constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
1462 classinfo *c; /* resolved declaring class for the field */
1463 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1465 TRACEJVMCALLS(("JVM_ConstantPoolGetFieldAtIfLoaded: 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 if (!resolve_classref(NULL, ref->p.classref, resolveLazy, true, true, &c)) {
1479 if (c == NULL || !(c->state & CLASS_LOADED)) {
1483 // Create a new java.lang.reflect.Field Java object.
1484 java_lang_reflect_Field jlrf(ref->p.field);
1486 return (jobject) jlrf.get_handle();
1490 /* JVM_ConstantPoolGetMemberRefInfoAt */
1492 jobjectArray JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1494 log_println("JVM_ConstantPoolGetMemberRefInfoAt: jcpool=%p, index=%d, IMPLEMENT ME!", jcpool, index);
1496 /* TODO: implement. (this is yet unused be OpenJDK but, so very low priority) */
1502 /* JVM_ConstantPoolGetIntAt */
1504 jint JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1506 constant_integer *ref; /* reference to the int value in constant pool at index 'index' */
1507 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1509 TRACEJVMCALLS(("JVM_ConstantPoolGetIntAt: jcpool=%p, index=%d", jcpool, index));
1511 cls = LLNI_classinfo_unwrap(jcpool);
1512 ref = (constant_integer*)class_getconstant(cls, index, CONSTANT_Integer);
1515 exceptions_throw_illegalargumentexception();
1523 /* JVM_ConstantPoolGetLongAt */
1525 jlong JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1527 constant_long *ref; /* reference to the long value in constant pool at index 'index' */
1528 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1530 TRACEJVMCALLS(("JVM_ConstantPoolGetLongAt: jcpool=%p, index=%d", jcpool, index));
1532 cls = LLNI_classinfo_unwrap(jcpool);
1533 ref = (constant_long*)class_getconstant(cls, index, CONSTANT_Long);
1536 exceptions_throw_illegalargumentexception();
1544 /* JVM_ConstantPoolGetFloatAt */
1546 jfloat JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1548 constant_float *ref; /* reference to the float value in constant pool at index 'index' */
1549 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1551 TRACEJVMCALLS(("JVM_ConstantPoolGetFloatAt: jcpool=%p, index=%d", jcpool, index));
1553 cls = LLNI_classinfo_unwrap(jcpool);
1554 ref = (constant_float*)class_getconstant(cls, index, CONSTANT_Float);
1557 exceptions_throw_illegalargumentexception();
1565 /* JVM_ConstantPoolGetDoubleAt */
1567 jdouble JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1569 constant_double *ref; /* reference to the double value in constant pool at index 'index' */
1570 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1572 TRACEJVMCALLS(("JVM_ConstantPoolGetDoubleAt: jcpool=%p, index=%d", jcpool, index));
1574 cls = LLNI_classinfo_unwrap(jcpool);
1575 ref = (constant_double*)class_getconstant(cls, index, CONSTANT_Double);
1578 exceptions_throw_illegalargumentexception();
1586 /* JVM_ConstantPoolGetStringAt */
1588 jstring JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1590 utf *ref; /* utf object for the string in constant pool at index 'index' */
1591 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1593 TRACEJVMCALLS(("JVM_ConstantPoolGetStringAt: jcpool=%p, index=%d", jcpool, index));
1595 cls = LLNI_classinfo_unwrap(jcpool);
1596 ref = (utf*)class_getconstant(cls, index, CONSTANT_String);
1599 exceptions_throw_illegalargumentexception();
1603 /* XXX: I hope literalstring_new is the right Function. */
1604 return (jstring)literalstring_new(ref);
1608 /* JVM_ConstantPoolGetUTF8At */
1610 jstring JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, jint index)
1612 utf *ref; /* utf object for the utf8 data in constant pool at index 'index' */
1613 classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
1615 TRACEJVMCALLS(("JVM_ConstantPoolGetUTF8At: jcpool=%p, index=%d", jcpool, index));
1617 cls = LLNI_classinfo_unwrap(jcpool);
1618 ref = (utf*)class_getconstant(cls, index, CONSTANT_Utf8);
1621 exceptions_throw_illegalargumentexception();
1625 /* XXX: I hope literalstring_new is the right Function. */
1626 return (jstring)literalstring_new(ref);
1630 /* JVM_DesiredAssertionStatus */
1632 jboolean JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls)
1634 #if defined(ENABLE_ASSERTION)
1639 TRACEJVMCALLS(("JVM_DesiredAssertionStatus(env=%p, unused=%p, cls=%p)", env, unused, cls));
1641 c = LLNI_classinfo_unwrap(cls);
1643 if (c->classloader == NULL) {
1644 status = (jboolean)assertion_system_enabled;
1647 status = (jboolean)assertion_user_enabled;
1650 if (list_assertion_names != NULL) {
1651 for (List<assertion_name_t*>::iterator it = list_assertion_names->begin();
1652 it != list_assertion_names->end(); it++) {
1653 assertion_name_t* item = *it;
1655 name = utf_new_char(item->name);
1656 if (name == c->packagename) {
1657 status = (jboolean)item->enabled;
1659 else if (name == c->name) {
1660 status = (jboolean)item->enabled;
1667 return (jboolean)false;
1672 /* JVM_AssertionStatusDirectives */
1674 jobject JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)
1676 java_handle_objectarray_t *classes;
1677 java_handle_objectarray_t *packages;
1678 java_booleanarray_t *classEnabled;
1679 java_booleanarray_t *packageEnabled;
1680 #if defined(ENABLE_ASSERTION)
1685 TRACEJVMCALLS(("JVM_AssertionStatusDirectives(env=%p, unused=%p)", env, unused));
1687 #if defined(ENABLE_ASSERTION)
1688 classes = builtin_anewarray(assertion_class_count, class_java_lang_Object);
1690 classes = builtin_anewarray(0, class_java_lang_Object);
1692 if (classes == NULL)
1695 #if defined(ENABLE_ASSERTION)
1696 packages = builtin_anewarray(assertion_package_count, class_java_lang_Object);
1698 packages = builtin_anewarray(0, class_java_lang_Object);
1700 if (packages == NULL)
1703 #if defined(ENABLE_ASSERTION)
1704 classEnabled = builtin_newarray_boolean(assertion_class_count);
1706 classEnabled = builtin_newarray_boolean(0);
1708 if (classEnabled == NULL)
1711 #if defined(ENABLE_ASSERTION)
1712 packageEnabled = builtin_newarray_boolean(assertion_package_count);
1714 packageEnabled = builtin_newarray_boolean(0);
1716 if (packageEnabled == NULL)
1719 #if defined(ENABLE_ASSERTION)
1720 /* initialize arrays */
1722 if (list_assertion_names != NULL) {
1726 for (List<assertion_name_t*>::iterator it = list_assertion_names->begin(); it != list_assertion_names->end(); it++) {
1727 assertion_name_t* item = *it;
1729 js = javastring_new_from_ascii(item->name);
1734 if (item->package == false) {
1735 classes->data[i] = js;
1736 classEnabled->data[i] = (jboolean) item->enabled;
1740 packages->data[j] = js;
1741 packageEnabled->data[j] = (jboolean) item->enabled;
1748 /* set instance fields */
1750 java_lang_AssertionStatusDirectives jlasd(classes, classEnabled, packages, packageEnabled);
1752 return (jobject) jlasd.get_handle();
1756 /* JVM_GetClassNameUTF */
1758 const char *JVM_GetClassNameUTF(JNIEnv *env, jclass cls)
1760 log_println("JVM_GetClassNameUTF: IMPLEMENT ME!");
1766 /* JVM_GetClassCPTypes */
1768 void JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types)
1770 log_println("JVM_GetClassCPTypes: IMPLEMENT ME!");
1774 /* JVM_GetClassCPEntriesCount */
1776 jint JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)
1778 log_println("JVM_GetClassCPEntriesCount: IMPLEMENT ME!");
1784 /* JVM_GetClassFieldsCount */
1786 jint JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)
1788 log_println("JVM_GetClassFieldsCount: IMPLEMENT ME!");
1794 /* JVM_GetClassMethodsCount */
1796 jint JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)
1798 log_println("JVM_GetClassMethodsCount: IMPLEMENT ME!");
1804 /* JVM_GetMethodIxExceptionIndexes */
1806 void JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions)
1808 log_println("JVM_GetMethodIxExceptionIndexes: IMPLEMENT ME!");
1812 /* JVM_GetMethodIxExceptionsCount */
1814 jint JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)
1816 log_println("JVM_GetMethodIxExceptionsCount: IMPLEMENT ME!");
1822 /* JVM_GetMethodIxByteCode */
1824 void JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code)
1826 log_println("JVM_GetMethodIxByteCode: IMPLEMENT ME!");
1830 /* JVM_GetMethodIxByteCodeLength */
1832 jint JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)
1834 log_println("JVM_GetMethodIxByteCodeLength: IMPLEMENT ME!");
1840 /* JVM_GetMethodIxExceptionTableEntry */
1842 void JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry)
1844 log_println("JVM_GetMethodIxExceptionTableEntry: IMPLEMENT ME!");
1848 /* JVM_GetMethodIxExceptionTableLength */
1850 jint JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)
1852 log_println("JVM_GetMethodIxExceptionTableLength: IMPLEMENT ME!");
1858 /* JVM_GetMethodIxModifiers */
1860 jint JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)
1862 log_println("JVM_GetMethodIxModifiers: IMPLEMENT ME!");
1868 /* JVM_GetFieldIxModifiers */
1870 jint JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)
1872 log_println("JVM_GetFieldIxModifiers: IMPLEMENT ME!");
1878 /* JVM_GetMethodIxLocalsCount */
1880 jint JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)
1882 log_println("JVM_GetMethodIxLocalsCount: IMPLEMENT ME!");
1888 /* JVM_GetMethodIxArgsSize */
1890 jint JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)
1892 log_println("JVM_GetMethodIxArgsSize: IMPLEMENT ME!");
1898 /* JVM_GetMethodIxMaxStack */
1900 jint JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)
1902 log_println("JVM_GetMethodIxMaxStack: IMPLEMENT ME!");
1908 /* JVM_IsConstructorIx */
1910 jboolean JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)
1912 log_println("JVM_IsConstructorIx: IMPLEMENT ME!");
1918 /* JVM_GetMethodIxNameUTF */
1920 const char *JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)
1922 log_println("JVM_GetMethodIxNameUTF: IMPLEMENT ME!");
1928 /* JVM_GetMethodIxSignatureUTF */
1930 const char *JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)
1932 log_println("JVM_GetMethodIxSignatureUTF: IMPLEMENT ME!");
1938 /* JVM_GetCPFieldNameUTF */
1940 const char *JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1942 log_println("JVM_GetCPFieldNameUTF: IMPLEMENT ME!");
1948 /* JVM_GetCPMethodNameUTF */
1950 const char *JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1952 log_println("JVM_GetCPMethodNameUTF: IMPLEMENT ME!");
1958 /* JVM_GetCPMethodSignatureUTF */
1960 const char *JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
1962 log_println("JVM_GetCPMethodSignatureUTF: IMPLEMENT ME!");
1968 /* JVM_GetCPFieldSignatureUTF */
1970 const char *JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
1972 log_println("JVM_GetCPFieldSignatureUTF: IMPLEMENT ME!");
1978 /* JVM_GetCPClassNameUTF */
1980 const char *JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1982 log_println("JVM_GetCPClassNameUTF: IMPLEMENT ME!");
1988 /* JVM_GetCPFieldClassNameUTF */
1990 const char *JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
1992 log_println("JVM_GetCPFieldClassNameUTF: IMPLEMENT ME!");
1998 /* JVM_GetCPMethodClassNameUTF */
2000 const char *JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
2002 log_println("JVM_GetCPMethodClassNameUTF: IMPLEMENT ME!");
2008 /* JVM_GetCPFieldModifiers */
2010 jint JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
2012 log_println("JVM_GetCPFieldModifiers: IMPLEMENT ME!");
2018 /* JVM_GetCPMethodModifiers */
2020 jint JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
2022 log_println("JVM_GetCPMethodModifiers: IMPLEMENT ME!");
2028 /* JVM_ReleaseUTF */
2030 void JVM_ReleaseUTF(const char *utf)
2032 log_println("JVM_ReleaseUTF: IMPLEMENT ME!");
2036 /* JVM_IsSameClassPackage */
2038 jboolean JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2)
2040 log_println("JVM_IsSameClassPackage: IMPLEMENT ME!");
2048 /* Taken from: hotspot/src/share/vm/prims/jvm.h */
2051 * JVM I/O error codes
2053 #define JVM_EEXIST -100
2055 jint JVM_Open(const char* fname, jint flags, jint mode)
2059 TRACEJVMCALLS(("JVM_Open(fname=%s, flags=%d, mode=%d)", fname, flags, mode));
2061 HPI& hpi = VM::get_current()->get_hpi();
2062 result = hpi.get_file().Open(fname, flags, mode);
2080 jint JVM_Close(jint fd)
2082 TRACEJVMCALLS(("JVM_Close(fd=%d)", fd));
2084 HPI& hpi = VM::get_current()->get_hpi();
2085 return hpi.get_file().Close(fd);
2091 jint JVM_Read(jint fd, char* buf, jint nbytes)
2093 TRACEJVMCALLS(("JVM_Read(fd=%d, buf=%p, nbytes=%d)", fd, buf, nbytes));
2095 HPI& hpi = VM::get_current()->get_hpi();
2096 return (jint) hpi.get_file().Read(fd, buf, nbytes);
2102 jint JVM_Write(jint fd, char* buf, jint nbytes)
2104 TRACEJVMCALLS(("JVM_Write(fd=%d, buf=%s, nbytes=%d)", fd, buf, nbytes));
2106 HPI& hpi = VM::get_current()->get_hpi();
2107 return (jint) hpi.get_file().Write(fd, buf, nbytes);
2113 jint JVM_Available(jint fd, jlong* pbytes)
2115 TRACEJVMCALLS(("JVM_Available(fd=%d, pbytes=%p)", fd, pbytes));
2117 HPI& hpi = VM::get_current()->get_hpi();
2118 return hpi.get_file().Available(fd, pbytes);
2124 jlong JVM_Lseek(jint fd, jlong offset, jint whence)
2126 TRACEJVMCALLS(("JVM_Lseek(fd=%d, offset=%ld, whence=%d)", fd, offset, whence));
2128 HPI& hpi = VM::get_current()->get_hpi();
2129 return hpi.get_file().Seek(fd, (off_t) offset, whence);
2135 jint JVM_SetLength(jint fd, jlong length)
2137 TRACEJVMCALLS(("JVM_SetLength(fd=%d, length=%ld)", length));
2139 HPI& hpi = VM::get_current()->get_hpi();
2140 return hpi.get_file().SetLength(fd, length);
2146 jint JVM_Sync(jint fd)
2148 TRACEJVMCALLS(("JVM_Sync(fd=%d)", fd));
2150 HPI& hpi = VM::get_current()->get_hpi();
2151 return hpi.get_file().Sync(fd);
2155 /* JVM_StartThread */
2157 void JVM_StartThread(JNIEnv* env, jobject jthread)
2159 TRACEJVMCALLS(("JVM_StartThread(env=%p, jthread=%p)", env, jthread));
2161 threads_thread_start((java_handle_t *) jthread);
2165 /* JVM_StopThread */
2167 void JVM_StopThread(JNIEnv* env, jobject jthread, jobject throwable)
2169 log_println("JVM_StopThread: Deprecated. Not implemented.");
2173 /* JVM_IsThreadAlive */
2175 jboolean JVM_IsThreadAlive(JNIEnv* env, jobject jthread)
2181 TRACEJVMCALLS(("JVM_IsThreadAlive(env=%p, jthread=%p)", env, jthread));
2183 h = (java_handle_t *) jthread;
2184 t = thread_get_thread(h);
2186 /* The threadobject is null when a thread is created in Java. The
2187 priority is set later during startup. */
2192 result = threads_thread_is_alive(t);
2198 /* JVM_SuspendThread */
2200 void JVM_SuspendThread(JNIEnv* env, jobject jthread)
2202 log_println("JVM_SuspendThread: Deprecated. Not implemented.");
2206 /* JVM_ResumeThread */
2208 void JVM_ResumeThread(JNIEnv* env, jobject jthread)
2210 log_println("JVM_ResumeThread: Deprecated. Not implemented.");
2214 /* JVM_SetThreadPriority */
2216 void JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio)
2221 TRACEJVMCALLS(("JVM_SetThreadPriority(env=%p, jthread=%p, prio=%d)", env, jthread, prio));
2223 h = (java_handle_t *) jthread;
2224 t = thread_get_thread(h);
2226 /* The threadobject is null when a thread is created in Java. The
2227 priority is set later during startup. */
2232 threads_set_thread_priority(t->tid, prio);
2238 void JVM_Yield(JNIEnv *env, jclass threadClass)
2240 TRACEJVMCALLS(("JVM_Yield(env=%p, threadClass=%p)", env, threadClass));
2248 void JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis)
2250 TRACEJVMCALLS(("JVM_Sleep(env=%p, threadClass=%p, millis=%ld)", env, threadClass, millis));
2252 threads_sleep(millis, 0);
2256 /* JVM_CurrentThread */
2258 jobject JVM_CurrentThread(JNIEnv* env, jclass threadClass)
2262 TRACEJVMCALLSVERBOSE(("JVM_CurrentThread(env=%p, threadClass=%p)", env, threadClass));
2264 o = thread_get_current_object();
2270 /* JVM_CountStackFrames */
2272 jint JVM_CountStackFrames(JNIEnv* env, jobject jthread)
2274 log_println("JVM_CountStackFrames: Deprecated. Not implemented.");
2282 void JVM_Interrupt(JNIEnv* env, jobject jthread)
2287 TRACEJVMCALLS(("JVM_Interrupt(env=%p, jthread=%p)", env, jthread));
2289 h = (java_handle_t *) jthread;
2290 t = thread_get_thread(h);
2295 threads_thread_interrupt(t);
2299 /* JVM_IsInterrupted */
2301 jboolean JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted)
2305 jboolean interrupted;
2307 TRACEJVMCALLS(("JVM_IsInterrupted(env=%p, jthread=%p, clear_interrupted=%d)", env, jthread, clear_interrupted));
2309 h = (java_handle_t *) jthread;
2310 t = thread_get_thread(h);
2312 interrupted = thread_is_interrupted(t);
2314 if (interrupted && clear_interrupted)
2315 thread_set_interrupted(t, false);
2323 jboolean JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj)
2328 TRACEJVMCALLS(("JVM_HoldsLock(env=%p, threadClass=%p, obj=%p)", env, threadClass, obj));
2330 h = (java_handle_t *) obj;
2333 exceptions_throw_nullpointerexception();
2337 result = lock_is_held_by_current_thread(h);
2343 /* JVM_DumpAllStacks */
2345 void JVM_DumpAllStacks(JNIEnv* env, jclass unused)
2347 log_println("JVM_DumpAllStacks: IMPLEMENT ME!");
2351 /* JVM_CurrentLoadedClass */
2353 jclass JVM_CurrentLoadedClass(JNIEnv *env)
2355 log_println("JVM_CurrentLoadedClass: IMPLEMENT ME!");
2361 /* JVM_CurrentClassLoader */
2363 jobject JVM_CurrentClassLoader(JNIEnv *env)
2365 /* XXX if a method in a class in a trusted loader is in a
2366 doPrivileged, return NULL */
2368 log_println("JVM_CurrentClassLoader: IMPLEMENT ME!");
2374 /* JVM_GetClassContext */
2376 jobjectArray JVM_GetClassContext(JNIEnv *env)
2378 TRACEJVMCALLS(("JVM_GetClassContext(env=%p)", env));
2380 return (jobjectArray) stacktrace_getClassContext();
2384 /* JVM_ClassDepth */
2386 jint JVM_ClassDepth(JNIEnv *env, jstring name)
2388 log_println("JVM_ClassDepth: IMPLEMENT ME!");
2394 /* JVM_ClassLoaderDepth */
2396 jint JVM_ClassLoaderDepth(JNIEnv *env)
2398 log_println("JVM_ClassLoaderDepth: IMPLEMENT ME!");
2404 /* JVM_GetSystemPackage */
2406 jstring JVM_GetSystemPackage(JNIEnv *env, jstring name)
2412 TRACEJVMCALLS(("JVM_GetSystemPackage(env=%p, name=%p)", env, name));
2414 /* s = Package::find(name); */
2415 u = javastring_toutf((java_handle_t *) name, false);
2417 result = Package::find(u);
2420 s = javastring_new(result);
2428 /* JVM_GetSystemPackages */
2430 jobjectArray JVM_GetSystemPackages(JNIEnv *env)
2432 log_println("JVM_GetSystemPackages: IMPLEMENT ME!");
2438 /* JVM_AllocateNewObject */
2440 jobject JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass)
2442 log_println("JVM_AllocateNewObject: IMPLEMENT ME!");
2448 /* JVM_AllocateNewArray */
2450 jobject JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length)
2452 log_println("JVM_AllocateNewArray: IMPLEMENT ME!");
2458 /* JVM_LatestUserDefinedLoader */
2460 jobject JVM_LatestUserDefinedLoader(JNIEnv *env)
2464 TRACEJVMCALLS(("JVM_LatestUserDefinedLoader(env=%p)", env));
2466 cl = stacktrace_first_nonnull_classloader();
2468 return (jobject) cl;
2472 /* JVM_LoadClass0 */
2474 jclass JVM_LoadClass0(JNIEnv *env, jobject receiver, jclass currClass, jstring currClassName)
2476 log_println("JVM_LoadClass0: IMPLEMENT ME!");
2482 /* JVM_GetArrayLength */
2484 jint JVM_GetArrayLength(JNIEnv *env, jobject arr)
2488 TRACEJVMCALLS(("JVM_GetArrayLength(arr=%p)", arr));
2490 a = (java_handle_t *) arr;
2492 return array_length_get(a);
2496 /* JVM_GetArrayElement */
2498 jobject JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index)
2503 TRACEJVMCALLS(("JVM_GetArrayElement(env=%p, arr=%p, index=%d)", env, arr, index));
2505 a = (java_handle_t *) arr;
2507 /* if (!class_is_array(a->objheader.vftbl->class)) { */
2508 /* exceptions_throw_illegalargumentexception(); */
2512 o = array_element_get(a, index);
2518 /* JVM_GetPrimitiveArrayElement */
2520 jvalue JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode)
2524 log_println("JVM_GetPrimitiveArrayElement: IMPLEMENT ME!");
2532 /* JVM_SetArrayElement */
2534 void JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val)
2537 java_handle_t *value;
2539 TRACEJVMCALLS(("JVM_SetArrayElement(env=%p, arr=%p, index=%d, val=%p)", env, arr, index, val));
2541 a = (java_handle_t *) arr;
2542 value = (java_handle_t *) val;
2544 array_element_set(a, index, value);
2548 /* JVM_SetPrimitiveArrayElement */
2550 void JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode)
2552 log_println("JVM_SetPrimitiveArrayElement: IMPLEMENT ME!");
2558 jobject JVM_NewArray(JNIEnv *env, jclass eltClass, jint length)
2563 java_handle_objectarray_t *oa;
2565 TRACEJVMCALLS(("JVM_NewArray(env=%p, eltClass=%p, length=%d)", env, eltClass, length));
2567 if (eltClass == NULL) {
2568 exceptions_throw_nullpointerexception();
2572 /* NegativeArraySizeException is checked in builtin_newarray. */
2574 c = LLNI_classinfo_unwrap(eltClass);
2576 /* Create primitive or object array. */
2578 if (class_is_primitive(c)) {
2579 pc = Primitive::get_arrayclass_by_name(c->name);
2581 /* void arrays are not allowed. */
2584 exceptions_throw_illegalargumentexception();
2588 a = builtin_newarray(length, pc);
2593 oa = builtin_anewarray(length, c);
2595 return (jobject) oa;
2600 /* JVM_NewMultiArray */
2602 jobject JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim)
2605 java_handle_intarray_t *ia;
2611 java_handle_objectarray_t *a;
2613 TRACEJVMCALLS(("JVM_NewMultiArray(env=%p, eltClass=%p, dim=%p)", env, eltClass, dim));
2615 if (eltClass == NULL) {
2616 exceptions_throw_nullpointerexception();
2620 /* NegativeArraySizeException is checked in builtin_newarray. */
2622 c = LLNI_classinfo_unwrap(eltClass);
2624 ia = (java_handle_intarray_t *) dim;
2626 length = array_length_get((java_handle_t *) ia);
2628 /* We check here for exceptions thrown in array_length_get,
2629 otherwise these exceptions get overwritten by the following
2630 IllegalArgumentException. */
2635 if ((length <= 0) || (length > /* MAX_DIM */ 255)) {
2636 exceptions_throw_illegalargumentexception();
2640 /* XXX This is just a quick hack to get it working. */
2642 dims = MNEW(long, length);
2644 for (i = 0; i < length; i++) {
2645 value = LLNI_array_direct(ia, i);
2646 dims[i] = (long) value;
2649 /* Create an array-class if necessary. */
2651 if (class_is_primitive(c))
2652 ac = Primitive::get_arrayclass_by_name(c->name);
2654 ac = class_array_of(c, true);
2659 a = builtin_multianewarray(length, (java_handle_t *) ac, dims);
2665 /* JVM_InitializeSocketLibrary */
2667 jint JVM_InitializeSocketLibrary()
2669 TRACEJVMCALLS(("JVM_InitializeSocketLibrary()"));
2671 HPI& hpi = VM::get_current()->get_hpi();
2672 return hpi.initialize_socket_library();
2678 jint JVM_Socket(jint domain, jint type, jint protocol)
2680 TRACEJVMCALLS(("JVM_Socket(domain=%d, type=%d, protocol=%d)", domain, type, protocol));
2682 return os::socket(domain, type, protocol);
2686 /* JVM_SocketClose */
2688 jint JVM_SocketClose(jint fd)
2690 TRACEJVMCALLS(("JVM_SocketClose(fd=%d)", fd));
2692 return os::close(fd);
2696 /* JVM_SocketShutdown */
2698 jint JVM_SocketShutdown(jint fd, jint howto)
2700 TRACEJVMCALLS(("JVM_SocketShutdown(fd=%d, howto=%d)", fd, howto));
2702 return os::shutdown(fd, howto);
2708 jint JVM_Recv(jint fd, char *buf, jint nBytes, jint flags)
2710 log_println("JVM_Recv: IMPLEMENT ME!");
2718 jint JVM_Send(jint fd, char *buf, jint nBytes, jint flags)
2720 log_println("JVM_Send: IMPLEMENT ME!");
2728 jint JVM_Timeout(int fd, long timeout)
2730 log_println("JVM_Timeout: IMPLEMENT ME!");
2738 jint JVM_Listen(jint fd, jint count)
2740 TRACEJVMCALLS(("JVM_Listen(fd=%d, count=%d)", fd, count));
2742 return os::listen(fd, count);
2748 jint JVM_Connect(jint fd, struct sockaddr *him, jint len)
2750 TRACEJVMCALLS(("JVM_Connect(fd=%d, him=%p, len=%d)", fd, him, len));
2752 return os::connect(fd, him, len);
2758 jint JVM_Bind(jint fd, struct sockaddr *him, jint len)
2760 log_println("JVM_Bind: IMPLEMENT ME!");
2768 jint JVM_Accept(jint fd, struct sockaddr *him, jint *len)
2770 TRACEJVMCALLS(("JVM_Accept(fd=%d, him=%p, len=%p)", fd, him, len));
2772 return os::accept(fd, him, (socklen_t *) len);
2778 jint JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen)
2780 log_println("JVM_RecvFrom: IMPLEMENT ME!");
2786 /* JVM_GetSockName */
2788 jint JVM_GetSockName(jint fd, struct sockaddr *him, int *len)
2790 TRACEJVMCALLS(("JVM_GetSockName(fd=%d, him=%p, len=%p)", fd, him, len));
2792 return os::getsockname(fd, him, (socklen_t *) len);
2798 jint JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen)
2800 log_println("JVM_SendTo: IMPLEMENT ME!");
2806 /* JVM_SocketAvailable */
2808 jint JVM_SocketAvailable(jint fd, jint *pbytes)
2810 #if defined(FIONREAD)
2814 TRACEJVMCALLS(("JVM_SocketAvailable(fd=%d, pbytes=%p)", fd, pbytes));
2818 result = ioctl(fd, FIONREAD, &bytes);
2827 # error FIONREAD not defined
2832 /* JVM_GetSockOpt */
2834 jint JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen)
2836 TRACEJVMCALLS(("JVM_GetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%p)", fd, level, optname, optval, optlen));
2838 return os::getsockopt(fd, level, optname, optval, (socklen_t *) optlen);
2842 /* JVM_SetSockOpt */
2844 jint JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen)
2846 TRACEJVMCALLS(("JVM_SetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%d)", fd, level, optname, optval, optlen));
2848 return os::setsockopt(fd, level, optname, optval, optlen);
2852 /* JVM_GetHostName */
2854 int JVM_GetHostName(char *name, int namelen)
2858 TRACEJVMCALLSENTER(("JVM_GetHostName(name=%s, namelen=%d)", name, namelen));
2860 result = os::gethostname(name, namelen);
2862 TRACEJVMCALLSEXIT(("->%d (name=%s)", result, name));
2868 /* JVM_GetHostByAddr */
2870 struct hostent *JVM_GetHostByAddr(const char* name, int len, int type)
2872 log_println("JVM_GetHostByAddr: IMPLEMENT ME!");
2878 /* JVM_GetHostByName */
2880 struct hostent *JVM_GetHostByName(char* name)
2882 log_println("JVM_GetHostByName: IMPLEMENT ME!");
2888 /* JVM_GetProtoByName */
2890 struct protoent *JVM_GetProtoByName(char* name)
2892 log_println("JVM_GetProtoByName: IMPLEMENT ME!");
2898 /* JVM_LoadLibrary */
2900 void* JVM_LoadLibrary(const char* name)
2902 TRACEJVMCALLSENTER(("JVM_LoadLibrary(name=%s)", name));
2904 utf* u = utf_new_char(name);
2906 NativeLibrary nl(u);
2907 void* handle = nl.open();
2909 TRACEJVMCALLSEXIT(("->%p", handle));
2915 /* JVM_UnloadLibrary */
2917 void JVM_UnloadLibrary(void* handle)
2919 TRACEJVMCALLS(("JVM_UnloadLibrary(handle=%p)", handle));
2921 NativeLibrary nl(handle);
2926 /* JVM_FindLibraryEntry */
2928 void *JVM_FindLibraryEntry(void* handle, const char* name)
2932 TRACEJVMCALLSENTER(("JVM_FindLibraryEntry(handle=%p, name=%s)", handle, name));
2934 HPI& hpi = VM::get_current()->get_hpi();
2935 symbol = hpi.get_library().FindLibraryEntry(handle, name);
2937 TRACEJVMCALLSEXIT(("->%p", symbol));
2945 jboolean JVM_IsNaN(jdouble a)
2947 log_println("JVM_IsNaN: IMPLEMENT ME!");
2953 /* JVM_IsSupportedJNIVersion */
2955 jboolean JVM_IsSupportedJNIVersion(jint version)
2957 TRACEJVMCALLS(("JVM_IsSupportedJNIVersion(version=%d)", version));
2959 return jni_version_check(version);
2963 /* JVM_InternString */
2965 jstring JVM_InternString(JNIEnv *env, jstring str)
2967 TRACEJVMCALLS(("JVM_InternString(env=%p, str=%p)", env, str));
2969 return (jstring) javastring_intern((java_handle_t *) str);
2973 /* JVM_RawMonitorCreate */
2975 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void)
2977 TRACEJVMCALLS(("JVM_RawMonitorCreate()"));
2979 Mutex* m = new Mutex();
2985 /* JVM_RawMonitorDestroy */
2987 JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void* mon)
2989 TRACEJVMCALLS(("JVM_RawMonitorDestroy(mon=%p)", mon));
2991 delete ((Mutex*) mon);
2995 /* JVM_RawMonitorEnter */
2997 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void* mon)
2999 TRACEJVMCALLS(("JVM_RawMonitorEnter(mon=%p)", mon));
3001 ((Mutex*) mon)->lock();
3007 /* JVM_RawMonitorExit */
3009 JNIEXPORT void JNICALL JVM_RawMonitorExit(void* mon)
3011 TRACEJVMCALLS(("JVM_RawMonitorExit(mon=%p)", mon));
3013 ((Mutex*) mon)->unlock();
3017 /* JVM_SetPrimitiveFieldValues */
3019 void JVM_SetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
3021 log_println("JVM_SetPrimitiveFieldValues: IMPLEMENT ME!");
3025 /* JVM_GetPrimitiveFieldValues */
3027 void JVM_GetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj, jlongArray fieldIDs, jcharArray typecodes, jbyteArray data)
3029 log_println("JVM_GetPrimitiveFieldValues: IMPLEMENT ME!");
3033 /* JVM_AccessVMBooleanFlag */
3035 jboolean JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get)
3037 log_println("JVM_AccessVMBooleanFlag: IMPLEMENT ME!");
3043 /* JVM_AccessVMIntFlag */
3045 jboolean JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get)
3047 log_println("JVM_AccessVMIntFlag: IMPLEMENT ME!");
3053 /* JVM_VMBreakPoint */
3055 void JVM_VMBreakPoint(JNIEnv *env, jobject obj)
3057 log_println("JVM_VMBreakPoint: IMPLEMENT ME!");
3061 /* JVM_GetClassFields */
3063 jobjectArray JVM_GetClassFields(JNIEnv *env, jclass cls, jint which)
3065 log_println("JVM_GetClassFields: IMPLEMENT ME!");
3071 /* JVM_GetClassMethods */
3073 jobjectArray JVM_GetClassMethods(JNIEnv *env, jclass cls, jint which)
3075 log_println("JVM_GetClassMethods: IMPLEMENT ME!");
3081 /* JVM_GetClassConstructors */
3083 jobjectArray JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which)
3085 log_println("JVM_GetClassConstructors: IMPLEMENT ME!");
3091 /* JVM_GetClassField */
3093 jobject JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which)
3095 log_println("JVM_GetClassField: IMPLEMENT ME!");
3101 /* JVM_GetClassMethod */
3103 jobject JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types, jint which)
3105 log_println("JVM_GetClassMethod: IMPLEMENT ME!");
3111 /* JVM_GetClassConstructor */
3113 jobject JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types, jint which)
3115 log_println("JVM_GetClassConstructor: IMPLEMENT ME!");
3121 /* JVM_NewInstance */
3123 jobject JVM_NewInstance(JNIEnv *env, jclass cls)
3125 log_println("JVM_NewInstance: IMPLEMENT ME!");
3133 jobject JVM_GetField(JNIEnv *env, jobject field, jobject obj)
3135 log_println("JVM_GetField: IMPLEMENT ME!");
3141 /* JVM_GetPrimitiveField */
3143 jvalue JVM_GetPrimitiveField(JNIEnv *env, jobject field, jobject obj, unsigned char wCode)
3147 log_println("JVM_GetPrimitiveField: IMPLEMENT ME!");
3157 void JVM_SetField(JNIEnv *env, jobject field, jobject obj, jobject val)
3159 log_println("JVM_SetField: IMPLEMENT ME!");
3163 /* JVM_SetPrimitiveField */
3165 void JVM_SetPrimitiveField(JNIEnv *env, jobject field, jobject obj, jvalue v, unsigned char vCode)
3167 log_println("JVM_SetPrimitiveField: IMPLEMENT ME!");
3171 /* JVM_InvokeMethod */
3173 jobject JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)
3175 TRACEJVMCALLS(("JVM_InvokeMethod(env=%p, method=%p, obj=%p, args0=%p)", env, method, obj, args0));
3177 java_lang_reflect_Method jlrm(method);
3179 java_handle_t* result = jlrm.invoke((java_handle_t*) obj, (java_handle_objectarray_t*) args0);
3181 return (jobject) result;
3185 /* JVM_NewInstanceFromConstructor */
3187 jobject JVM_NewInstanceFromConstructor(JNIEnv *env, jobject con, jobjectArray args0)
3189 TRACEJVMCALLS(("JVM_NewInstanceFromConstructor(env=%p, c=%p, args0=%p)", env, con, args0));
3191 java_lang_reflect_Constructor jlrc(con);
3192 java_handle_t* o = jlrc.new_instance((java_handle_objectarray_t*) args0);
3198 /* JVM_SupportsCX8 */
3200 jboolean JVM_SupportsCX8()
3202 TRACEJVMCALLS(("JVM_SupportsCX8()"));
3212 jboolean JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal)
3214 log_println("JVM_CX8Field: IMPLEMENT ME!");
3220 /* JVM_GetAllThreads */
3222 jobjectArray JVM_GetAllThreads(JNIEnv *env, jclass dummy)
3224 log_println("JVM_GetAllThreads: IMPLEMENT ME!");
3230 /* JVM_DumpThreads */
3232 jobjectArray JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads)
3234 log_println("JVM_DumpThreads: IMPLEMENT ME!");
3240 /* JVM_GetManagement */
3242 void *JVM_GetManagement(jint version)
3244 TRACEJVMCALLS(("JVM_GetManagement(version=%d)", version));
3246 return Management::get_jmm_interface(version);
3250 /* JVM_InitAgentProperties */
3252 jobject JVM_InitAgentProperties(JNIEnv *env, jobject properties)
3254 log_println("JVM_InitAgentProperties: IMPLEMENT ME!");
3260 /* JVM_GetEnclosingMethodInfo */
3262 jobjectArray JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass)
3266 java_handle_objectarray_t *oa;
3268 TRACEJVMCALLS(("JVM_GetEnclosingMethodInfo(env=%p, ofClass=%p)", env, ofClass));
3270 c = LLNI_classinfo_unwrap(ofClass);
3272 if ((c == NULL) || class_is_primitive(c))
3275 m = class_get_enclosingmethod_raw(c);
3280 oa = builtin_anewarray(3, class_java_lang_Object);
3285 array_objectarray_element_set(oa, 0, (java_handle_t *) LLNI_classinfo_wrap(m->clazz));
3286 array_objectarray_element_set(oa, 1, javastring_new(m->name));
3287 array_objectarray_element_set(oa, 2, javastring_new(m->descriptor));
3289 return (jobjectArray) oa;
3293 /* JVM_GetThreadStateValues */
3295 jintArray JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState)
3297 java_handle_intarray_t *ia;
3299 TRACEJVMCALLS(("JVM_GetThreadStateValues(env=%p, javaThreadState=%d)",
3300 env, javaThreadState));
3302 /* If new thread states are added in future JDK and VM versions,
3303 this should check if the JDK version is compatible with thread
3304 states supported by the VM. Return NULL if not compatible.
3306 This function must map the VM java_lang_Thread::ThreadStatus
3307 to the Java thread state that the JDK supports. */
3309 switch (javaThreadState) {
3310 case THREAD_STATE_NEW:
3311 ia = builtin_newarray_int(1);
3316 array_intarray_element_set(ia, 0, THREAD_STATE_NEW);
3319 case THREAD_STATE_RUNNABLE:
3320 ia = builtin_newarray_int(1);
3325 array_intarray_element_set(ia, 0, THREAD_STATE_RUNNABLE);
3328 case THREAD_STATE_BLOCKED:
3329 ia = builtin_newarray_int(1);
3334 array_intarray_element_set(ia, 0, THREAD_STATE_BLOCKED);
3337 case THREAD_STATE_WAITING:
3338 ia = builtin_newarray_int(2);
3343 array_intarray_element_set(ia, 0, THREAD_STATE_WAITING);
3344 /* XXX Implement parked stuff. */
3345 /* array_intarray_element_set(ia, 1, PARKED); */
3348 case THREAD_STATE_TIMED_WAITING:
3349 ia = builtin_newarray_int(3);
3354 /* XXX Not sure about that one. */
3355 /* array_intarray_element_set(ia, 0, SLEEPING); */
3356 array_intarray_element_set(ia, 0, THREAD_STATE_TIMED_WAITING);
3357 /* XXX Implement parked stuff. */
3358 /* array_intarray_element_set(ia, 2, PARKED); */
3361 case THREAD_STATE_TERMINATED:
3362 ia = builtin_newarray_int(1);
3367 array_intarray_element_set(ia, 0, THREAD_STATE_TERMINATED);
3371 /* Unknown state - probably incompatible JDK version */
3375 return (jintArray) ia;
3379 /* JVM_GetThreadStateNames */
3381 jobjectArray JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values)
3383 java_handle_intarray_t *ia;
3384 java_handle_objectarray_t *oa;
3387 TRACEJVMCALLS(("JVM_GetThreadStateNames(env=%p, javaThreadState=%d, values=%p)",
3388 env, javaThreadState, values));
3390 ia = (java_handle_intarray_t *) values;
3392 /* If new thread states are added in future JDK and VM versions,
3393 this should check if the JDK version is compatible with thread
3394 states supported by the VM. Return NULL if not compatible.
3396 This function must map the VM java_lang_Thread::ThreadStatus
3397 to the Java thread state that the JDK supports. */
3399 if (values == NULL) {
3400 exceptions_throw_nullpointerexception();
3404 switch (javaThreadState) {
3405 case THREAD_STATE_NEW:
3406 assert(ia->header.size == 1 && ia->data[0] == THREAD_STATE_NEW);
3408 oa = builtin_anewarray(1, class_java_lang_String);
3413 s = javastring_new(utf_new_char("NEW"));
3418 array_objectarray_element_set(oa, 0, s);
3421 case THREAD_STATE_RUNNABLE:
3422 oa = builtin_anewarray(1, class_java_lang_String);
3427 s = javastring_new(utf_new_char("RUNNABLE"));
3432 array_objectarray_element_set(oa, 0, s);
3435 case THREAD_STATE_BLOCKED:
3436 oa = builtin_anewarray(1, class_java_lang_String);
3441 s = javastring_new(utf_new_char("BLOCKED"));
3446 array_objectarray_element_set(oa, 0, s);
3449 case THREAD_STATE_WAITING:
3450 oa = builtin_anewarray(2, class_java_lang_String);
3455 s = javastring_new(utf_new_char("WAITING.OBJECT_WAIT"));
3456 /* s = javastring_new(utf_new_char("WAITING.PARKED")); */
3461 array_objectarray_element_set(oa, 0, s);
3462 /* array_objectarray_element_set(oa, 1, s); */
3465 case THREAD_STATE_TIMED_WAITING:
3466 oa = builtin_anewarray(3, class_java_lang_String);
3471 /* s = javastring_new(utf_new_char("TIMED_WAITING.SLEEPING")); */
3472 s = javastring_new(utf_new_char("TIMED_WAITING.OBJECT_WAIT"));
3473 /* s = javastring_new(utf_new_char("TIMED_WAITING.PARKED")); */
3478 /* array_objectarray_element_set(oa, 0, s); */
3479 array_objectarray_element_set(oa, 0, s);
3480 /* array_objectarray_element_set(oa, 2, s); */
3483 case THREAD_STATE_TERMINATED:
3484 oa = builtin_anewarray(1, class_java_lang_String);
3489 s = javastring_new(utf_new_char("TERMINATED"));
3494 array_objectarray_element_set(oa, 0, s);
3498 /* Unknown state - probably incompatible JDK version */
3502 return (jobjectArray) oa;
3506 /* JVM_GetVersionInfo */
3508 void JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size)
3510 log_println("JVM_GetVersionInfo: IMPLEMENT ME!");
3514 /* OS: JVM_RegisterSignal */
3516 void *JVM_RegisterSignal(jint sig, void *handler)
3518 functionptr newHandler;
3520 TRACEJVMCALLS(("JVM_RegisterSignal(sig=%d, handler=%p)", sig, handler));
3522 if (handler == (void *) 2)
3523 newHandler = (functionptr) signal_thread_handler;
3525 newHandler = (functionptr) (uintptr_t) handler;
3532 /* These signals are already used by the VM. */
3536 /* This signal is used by the VM to dump thread stacks unless
3537 ReduceSignalUsage is set, in which case the user is allowed
3538 to set his own _native_ handler for this signal; thus, in
3539 either case, we do not allow JVM_RegisterSignal to change
3549 signal_register_signal(sig, newHandler, SA_RESTART | SA_SIGINFO);
3551 /* XXX Should return old handler. */
3557 /* OS: JVM_RaiseSignal */
3559 jboolean JVM_RaiseSignal(jint sig)
3561 log_println("JVM_RaiseSignal: IMPLEMENT ME! sig=%s", sig);
3567 /* OS: JVM_FindSignal */
3569 jint JVM_FindSignal(const char *name)
3571 TRACEJVMCALLS(("JVM_FindSignal(name=%s)", name));
3573 #if defined(__LINUX__)
3574 if (strcmp(name, "HUP") == 0)
3577 if (strcmp(name, "INT") == 0)
3580 if (strcmp(name, "TERM") == 0)
3582 #elif defined(__SOLARIS__)
3585 if (os::str2sig(name, &signum) == -1)
3590 # error Not implemented for this OS.
3600 * These are local overrides for various environment variables in Emacs.
3601 * Please do not remove this and leave it at the end of the file, where
3602 * Emacs will automagically detect them.
3603 * ---------------------------------------------------------------------
3606 * indent-tabs-mode: t
3610 * vim:noexpandtab:sw=4:ts=4: