/* src/native/vm/sun/jvm.c - HotSpot JVM interface functions
- Copyright (C) 2007 R. Grafl, A. Krall, C. Kruegel,
+ Copyright (C) 2007, 2008 R. Grafl, A. Krall, C. Kruegel,
C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
J. Wenninger, Institut f. Computersprachen - TU Wien
*/
-#define PRINTJVM 0
-
#include "config.h"
#include <assert.h>
#include <errno.h>
-#include <fcntl.h>
#include <ltdl.h>
+#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/stat.h>
+#include <sys/types.h>
#include "vm/types.h"
#include "native/include/java_lang_StackTraceElement.h"
#include "native/include/java_lang_Throwable.h"
#include "native/include/java_security_ProtectionDomain.h"
-#include "native/include/java_lang_Integer.h"
-#include "native/include/java_lang_Long.h"
-#include "native/include/java_lang_Short.h"
-#include "native/include/java_lang_Byte.h"
-#include "native/include/java_lang_Character.h"
-#include "native/include/java_lang_Boolean.h"
-#include "native/include/java_lang_Float.h"
-#include "native/include/java_lang_Double.h"
#if defined(ENABLE_ANNOTATIONS)
#include "native/include/sun_reflect_ConstantPool.h"
#include "native/vm/java_lang_Class.h"
#include "native/vm/java_lang_ClassLoader.h"
-#include "native/vm/java_lang_Object.h"
#include "native/vm/java_lang_Runtime.h"
#include "native/vm/java_lang_Thread.h"
#include "native/vm/java_lang_reflect_Constructor.h"
#include "native/vm/java_lang_reflect_Method.h"
-#include "native/vm/java_util_concurrent_atomic_AtomicLong.h"
#include "native/vm/reflect.h"
#include "threads/lock-common.h"
#include "threads/threads-common.h"
#include "toolbox/logging.h"
+#include "toolbox/list.h"
#include "vm/array.h"
+
+#if defined(ENABLE_ASSERTION)
+#include "vm/assertion.h"
+#endif
+
#include "vm/builtin.h"
#include "vm/exceptions.h"
#include "vm/global.h"
#include "vm/initialize.h"
+#include "vm/package.h"
#include "vm/primitive.h"
#include "vm/properties.h"
#include "vm/resolve.h"
#include "vmcore/classcache.h"
#include "vmcore/options.h"
+#include "vmcore/system.h"
/* debugging macros ***********************************************************/
#if !defined(NDEBUG)
-# define TRACEJVMCALLS(...) \
- do { \
- if (opt_TraceJVMCalls) { \
- log_println(__VA_ARGS__); \
- } \
+# define TRACEJVMCALLS(...) \
+ do { \
+ if (opt_TraceJVMCalls || opt_TraceJVMCallsVerbose) { \
+ log_println(__VA_ARGS__); \
+ } \
+ } while (0)
+
+# define TRACEJVMCALLSVERBOSE(x) \
+ do { \
+ if (opt_TraceJVMCallsVerbose) { \
+ log_println x; \
+ } \
} while (0)
# define PRINTJVMWARNINGS(...)
#else
# define TRACEJVMCALLS(...)
+# define TRACEJVMCALLSVERBOSE(x)
# define PRINTJVMWARNINGS(...)
#endif
int jio_fprintf(FILE* f, const char *fmt, ...)
{
log_println("jio_fprintf: IMPLEMENT ME!");
+
+ return 0;
}
int jio_vfprintf(FILE* f, const char *fmt, va_list args)
{
log_println("jio_vfprintf: IMPLEMENT ME!");
+
+ return 0;
}
int jio_printf(const char *fmt, ...)
{
log_println("jio_printf: IMPLEMENT ME!");
+
+ return 0;
}
jlong JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)
{
-#if PRINTJVM
- log_println("JVM_CurrentTimeMillis");
-#endif
+ TRACEJVMCALLS("JVM_CurrentTimeMillis(env=%p, ignored=%p)", env, ignored);
+
return (jlong) builtin_currenttimemillis();
}
jlong JVM_NanoTime(JNIEnv *env, jclass ignored)
{
-#if PRINTJVM
- log_println("JVM_NanoTime");
-#endif
+ TRACEJVMCALLS("JVM_NanoTime(env=%p, ignored=%p)", env, ignored);
+
return (jlong) builtin_nanotime();
}
s = (java_handle_t *) src;
d = (java_handle_t *) dst;
-#if PRINTJVM
- log_println("JVM_ArrayCopy: src=%p, src_pos=%d, dst=%p, dst_pos=%d, length=%d", src, src_pos, dst, dst_pos, length);
-#endif
+ 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));
- (void) builtin_arraycopy(s, src_pos, d, dst_pos, length);
+ builtin_arraycopy(s, src_pos, d, dst_pos, length);
}
jobject JVM_InitProperties(JNIEnv *env, jobject properties)
{
-#if PRINTJVM
- log_println("JVM_InitProperties: properties=%d", properties);
-#endif
- properties_system_add_all((java_handle_t *) properties);
+ java_handle_t *h;
+
+ TRACEJVMCALLS("JVM_InitProperties(env=%p, properties=%p)", env, properties);
+
+ h = (java_handle_t *) properties;
+
+ properties_system_add_all(h);
+
+ return properties;
}
void JVM_Halt(jint code)
{
-#if PRINTJVM
- log_println("JVM_Halt: code=%d", code);
-#endif
+ TRACEJVMCALLS("JVM_Halt(code=%d)", code);
+
/* vm_exit(code); */
vm_shutdown(code);
}
jlong JVM_MaxObjectInspectionAge(void)
{
log_println("JVM_MaxObjectInspectionAge: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_ActiveProcessorCount(void)
{
- log_println("JVM_ActiveProcessorCount: IMPLEMENT ME!");
+ TRACEJVMCALLS("JVM_ActiveProcessorCount()");
+
+ return system_processors_online();
}
void JVM_FillInStackTrace(JNIEnv *env, jobject receiver)
{
- java_lang_Throwable *o;
- stacktracecontainer *stc;
+ java_lang_Throwable *o;
+ java_handle_bytearray_t *ba;
-#if PRINTJVM
- log_println("JVM_FillInStackTrace: receiver=%p", receiver);
-#endif
+ TRACEJVMCALLS("JVM_FillInStackTrace(env=%p, receiver=%p)", env, receiver);
o = (java_lang_Throwable *) receiver;
- stc = stacktrace_fillInStackTrace();
+ ba = stacktrace_get();
- if (stc == NULL)
+ if (ba == NULL)
return;
- o->backtrace = (java_lang_Object *) stc;
+ LLNI_field_set_ref(o, backtrace, (java_lang_Object *) ba);
}
jint JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable)
{
- java_lang_Throwable *o;
- stacktracecontainer *stc;
- stacktracebuffer *stb;
+ java_lang_Throwable *t;
+ java_handle_bytearray_t *ba;
+ stacktrace_t *st;
+ int32_t depth;
-#if PRINTJVM
- log_println("JVM_GetStackTraceDepth: throwable=%p", throwable);
-#endif
+ TRACEJVMCALLS("JVM_GetStackTraceDepth(env=%p, throwable=%p)", env, throwable);
+
+ if (throwable == NULL) {
+ exceptions_throw_nullpointerexception();
+ return 0;
+ }
+
+ t = (java_lang_Throwable *) throwable;
+
+ LLNI_field_get_ref(t, backtrace, ba);
+
+ if (ba == NULL)
+ return 0;
+
+ /* We need a critical section here as the stacktrace structure is
+ mapped onto a Java byte-array. */
+
+ LLNI_CRITICAL_START;
+
+ st = (stacktrace_t *) LLNI_array_data(ba);
+
+ depth = st->length;
- o = (java_lang_Throwable *) throwable;
- stc = (stacktracecontainer *) o->backtrace;
- stb = &(stc->stb);
+ LLNI_CRITICAL_END;
- return stb->used;
+ return depth;
}
jobject JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index)
{
- java_lang_Throwable *t;
- stacktracecontainer *stc;
- stacktracebuffer *stb;
- stacktrace_entry *ste;
+ java_lang_Throwable *t;
+ java_handle_bytearray_t *ba;
+ stacktrace_t *st;
+ stacktrace_entry_t *ste;
+ codeinfo *code;
+ methodinfo *m;
+ classinfo *c;
java_lang_StackTraceElement *o;
java_lang_String *declaringclass;
java_lang_String *filename;
- s4 linenumber;
+ int32_t linenumber;
-#if PRINTJVM
- log_println("JVM_GetStackTraceElement: throwable=%p, index=%d", throwable, index);
-#endif
+ TRACEJVMCALLS("JVM_GetStackTraceElement(env=%p, throwable=%p, index=%d)", env, throwable, index);
+
+ t = (java_lang_Throwable *) throwable;
+
+ LLNI_field_get_ref(t, backtrace, ba);
+
+ /* FIXME critical section */
- t = (java_lang_Throwable *) throwable;
- stc = (stacktracecontainer *) t->backtrace;
- stb = &(stc->stb);
+ st = (stacktrace_t *) LLNI_array_data(ba);
- if ((index < 0) || (index >= stb->used)) {
+ if ((index < 0) || (index >= st->length)) {
/* XXX This should be an IndexOutOfBoundsException (check this
again). */
return NULL;
}
- ste = &(stb->entries[index]);
+ /* Get the stacktrace entry. */
+
+ ste = &(st->entries[index]);
+
+ /* Get the codeinfo, methodinfo and classinfo. */
+
+ code = ste->code;
+ m = code->m;
+ c = m->class;
/* allocate a new StackTraceElement */
/* get filename */
- if (!(ste->method->flags & ACC_NATIVE)) {
- if (ste->method->class->sourcefile)
- filename = (java_lang_String *) javastring_new(ste->method->class->sourcefile);
+ if (!(m->flags & ACC_NATIVE)) {
+ if (c->sourcefile != NULL)
+ filename = (java_lang_String *) javastring_new(c->sourcefile);
else
filename = NULL;
}
/* get line number */
- if (ste->method->flags & ACC_NATIVE)
+ if (m->flags & ACC_NATIVE) {
linenumber = -2;
- else
- linenumber = (ste->linenumber == 0) ? -1 : ste->linenumber;
+ }
+ else {
+ /* FIXME The linenumbertable_linenumber_for_pc could change
+ the methodinfo pointer when hitting an inlined method. */
+
+ linenumber = linenumbertable_linenumber_for_pc(&m, code, ste->pc);
+ linenumber = (linenumber == 0) ? -1 : linenumber;
+ }
/* get declaring class name */
- declaringclass =
- _Jv_java_lang_Class_getName(LLNI_classinfo_wrap(ste->method->class));
+ declaringclass = _Jv_java_lang_Class_getName(LLNI_classinfo_wrap(c));
/* fill the java.lang.StackTraceElement element */
+ /* FIXME critical section */
+
o->declaringClass = declaringclass;
- o->methodName = (java_lang_String *) javastring_new(ste->method->name);
+ o->methodName = (java_lang_String *) javastring_new(m->name);
o->fileName = filename;
o->lineNumber = linenumber;
jint JVM_IHashCode(JNIEnv* env, jobject handle)
{
-#if PRINTJVM
- log_println("JVM_IHashCode: jobject=%p", handle);
-#endif
+ TRACEJVMCALLS("JVM_IHashCode(env=%p, jobject=%p)", env, handle);
+
return (jint) ((ptrint) handle);
}
void JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms)
{
-#if PRINTJVM
- log_println("JVM_MonitorWait: handle=%p, ms=%ld", handle, ms);
+#if defined(ENABLE_THREADS)
+ java_handle_t *o;
+#endif
+
+ TRACEJVMCALLS("JVM_MonitorWait(env=%p, handle=%p, ms=%ld)", env, handle, ms);
+ if (ms < 0) {
+/* exceptions_throw_illegalargumentexception("argument out of range"); */
+ exceptions_throw_illegalargumentexception();
+ return;
+ }
+
+#if defined(ENABLE_THREADS)
+ o = (java_handle_t *) handle;
+
+ lock_wait_for_object(o, ms, 0);
#endif
- _Jv_java_lang_Object_wait((java_lang_Object *) handle, ms, 0);
}
void JVM_MonitorNotify(JNIEnv* env, jobject handle)
{
-#if PRINTJVM
- log_println("JVM_MonitorNotify: IMPLEMENT ME!");
+#if defined(ENABLE_THREADS)
+ java_handle_t *o;
+#endif
+
+ TRACEJVMCALLS("JVM_MonitorNotify(env=%p, handle=%p)", env, handle);
+
+#if defined(ENABLE_THREADS)
+ o = (java_handle_t *) handle;
+
+ lock_notify_object(o);
#endif
- _Jv_java_lang_Object_notify((java_lang_Object *) handle);
}
void JVM_MonitorNotifyAll(JNIEnv* env, jobject handle)
{
-#if PRINTJVM
- log_println("JVM_MonitorNotifyAll: handle=%p", handle);
+#if defined(ENABLE_THREADS)
+ java_handle_t *o;
+#endif
+
+ TRACEJVMCALLS("JVM_MonitorNotifyAll(env=%p, handle=%p)", env, handle);
+
+#if defined(ENABLE_THREADS)
+ o = (java_handle_t *) handle;
+
+ lock_notify_all_object(o);
#endif
- _Jv_java_lang_Object_notifyAll((java_lang_Object *) handle);
}
jobject JVM_Clone(JNIEnv* env, jobject handle)
{
-#if PRINTJVM
- log_println("JVM_Clone: handle=%p", handle);
-#endif
+ TRACEJVMCALLS("JVM_Clone(env=%p, handle=%p)", env, handle);
+
return (jobject) builtin_clone(env, (java_handle_t *) handle);
}
jboolean JVM_IsSilentCompiler(JNIEnv *env, jclass compCls)
{
log_println("JVM_IsSilentCompiler: IMPLEMENT ME!");
+
+ return 0;
}
jboolean JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls)
{
log_println("JVM_CompileClass: IMPLEMENT ME!");
+
+ return 0;
}
jboolean JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname)
{
log_println("JVM_CompileClasses: IMPLEMENT ME!");
+
+ return 0;
}
jobject JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg)
{
log_println("JVM_CompilerCommand: IMPLEMENT ME!");
+
+ return 0;
}
utf *u;
classloader *cl;
- TRACEJVMCALLS("JVM_FindClassFromClassLoader: name=%s, init=%d, loader=%p, throwError=%d", name, init, loader, throwError);
+ TRACEJVMCALLS("JVM_FindClassFromClassLoader(name=%s, init=%d, loader=%p, throwError=%d)", name, init, loader, throwError);
u = utf_new_char(name);
- cl = (classloader *) loader;
+ cl = loader_hashtable_classloader_add((java_handle_t *) loader);
c = load_class_from_classloader(u, cl);
jclass JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init, jclass from)
{
log_println("JVM_FindClassFromClass: IMPLEMENT ME!");
+
+ return NULL;
}
jclass JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)
{
log_println("JVM_DefineClass: IMPLEMENT ME!");
+
+ return NULL;
}
TRACEJVMCALLS("JVM_DefineClassWithSource(env=%p, name=%s, loader=%p, buf=%p, len=%d, pd=%p, source=%s)", env, name, loader, buf, len, pd, source);
- u = utf_new_char(name);
- cl = (classloader *) loader;
+ if (name != NULL)
+ u = utf_new_char(name);
+ else
+ u = NULL;
+
+ cl = loader_hashtable_classloader_add((java_handle_t *) loader);
/* XXX do something with source */
TRACEJVMCALLS("JVM_FindLoadedClass(env=%p, loader=%p, name=%p)", env, loader, name);
- cl = (classloader *) loader;
+ cl = loader_hashtable_classloader_add((java_handle_t *) loader);
u = javastring_toutf((java_handle_t *) name, true);
c = classcache_lookup(cl, u);
jstring JVM_GetClassName(JNIEnv *env, jclass cls)
{
-#if PRINTJVM
- log_println("JVM_GetClassName: cls=%p", cls);
-#endif
+ TRACEJVMCALLS("JVM_GetClassName(env=%p, cls=%p)", env, cls);
+
return (jstring) _Jv_java_lang_Class_getName((java_lang_Class *) cls);
}
jobject JVM_GetClassLoader(JNIEnv *env, jclass cls)
{
+ classinfo *c;
+ classloader *cl;
+
TRACEJVMCALLS("JVM_GetClassLoader(env=%p, cls=%p)", env, cls);
- return (jobject) _Jv_java_lang_Class_getClassLoader((java_lang_Class *) cls);
+ c = LLNI_classinfo_unwrap(cls);
+ cl = class_get_classloader(c);
+
+ return (jobject) cl;
}
{
classinfo *c;
-#if PRINTJVM
- log_println("JVM_IsInterface: cls=%p", cls);
-#endif
+ TRACEJVMCALLS("JVM_IsInterface(env=%p, cls=%p)", env, cls);
c = LLNI_classinfo_unwrap(cls);
jobjectArray JVM_GetClassSigners(JNIEnv *env, jclass cls)
{
log_println("JVM_GetClassSigners: IMPLEMENT ME!");
+
+ return NULL;
}
void JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers)
{
- log_println("JVM_SetClassSigners: IMPLEMENT ME!");
+ classinfo *c;
+ java_handle_objectarray_t *hoa;
+
+ TRACEJVMCALLS("JVM_SetClassSigners(env=%p, cls=%p, signers=%p)", env, cls, signers);
+
+ c = LLNI_classinfo_unwrap(cls);
+
+ hoa = (java_handle_objectarray_t *) signers;
+
+ /* This call is ignored for primitive types and arrays. Signers
+ are only set once, ClassLoader.java, and thus shouldn't be
+ called with an array. Only the bootstrap loader creates
+ arrays. */
+
+ if (class_is_primitive(c) || class_is_array(c))
+ return;
+
+ LLNI_classinfo_field_set(c, signers, hoa);
}
java_handle_t *result;
java_handle_t *e;
-#if PRINTJVM
- log_println("JVM_DoPrivileged: action=%p, context=%p, wrapException=%d", action, context, wrapException);
-#endif
+ TRACEJVMCALLS("JVM_DoPrivileged(env=%p, cls=%p, action=%p, context=%p, wrapException=%d)", env, cls, action, context, wrapException);
o = (java_handle_t *) action;
c = o->vftbl->class;
jobject JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls)
{
log_println("JVM_GetInheritedAccessControlContext: IMPLEMENT ME!");
+
+ return NULL;
}
jobject JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls)
{
- log_println("JVM_GetStackAccessControlContext: IMPLEMENT ME!");
+ TRACEJVMCALLS("JVM_GetStackAccessControlContext(env=%p, cls=%p): IMPLEMENT ME!", env, cls);
+
+ /* XXX All stuff I tested so far works without that function. At
+ some point we have to implement it, but I disable the output
+ for now to make IcedTea happy. */
+
+ return NULL;
}
jboolean JVM_IsArrayClass(JNIEnv *env, jclass cls)
{
-#if PRINTJVM
- log_println("JVM_IsArrayClass: cls=%p", cls);
-#endif
- return class_is_array(LLNI_classinfo_unwrap(cls));
+ classinfo *c;
+
+ TRACEJVMCALLS("JVM_IsArrayClass(env=%p, cls=%p)", env, cls);
+
+ c = LLNI_classinfo_unwrap(cls);
+
+ return class_is_array(c);
}
{
classinfo *c;
- c = LLNI_classinfo_unwrap(cls);
+ TRACEJVMCALLS("JVM_IsPrimitiveClass(env=%p, cls=%p)", env, cls);
-#if PRINTJVM
- log_println("JVM_IsPrimitiveClass(cls=%p)", cls);
-#endif
+ c = LLNI_classinfo_unwrap(cls);
return class_is_primitive(c);
}
jint JVM_GetClassModifiers(JNIEnv *env, jclass cls)
{
classinfo *c;
+ int32_t flags;
-#if PRINTJVM
- log_println("JVM_GetClassModifiers: cls=%p", cls);
-#endif
+ TRACEJVMCALLS("JVM_GetClassModifiers(env=%p, cls=%p)", env, cls);
c = LLNI_classinfo_unwrap(cls);
- /* XXX is this correct? */
+ flags = class_get_modifiers(c, false);
- return c->flags & ACC_CLASS_REFLECT_MASK;
+ return flags;
}
{
classinfo *c;
utf *u;
- java_object_t *s;
+ java_handle_t *s;
TRACEJVMCALLS("JVM_GetClassSignature(env=%p, cls=%p)", env, cls);
- c = (classinfo *) cls;
+ c = LLNI_classinfo_unwrap(cls);
/* Get the signature of the class. */
jbyteArray JVM_GetClassAnnotations(JNIEnv *env, jclass cls)
{
- classinfo *c = NULL;
- java_handle_bytearray_t *annotations = NULL;
+ classinfo *c = NULL; /* classinfo for 'cls' */
+ java_handle_bytearray_t *annotations = NULL; /* unparsed annotations */
TRACEJVMCALLS("JVM_GetClassAnnotations: cls=%p", cls);
jbyteArray JVM_GetFieldAnnotations(JNIEnv *env, jobject field)
{
- java_lang_reflect_Field *rf = (java_lang_reflect_Field*)field;
- java_handle_bytearray_t *ba = NULL;
+ java_lang_reflect_Field *rf = NULL; /* java.lang.reflect.Field for 'field' */
+ java_handle_bytearray_t *ba = NULL; /* unparsed annotations */
TRACEJVMCALLS("JVM_GetFieldAnnotations: field=%p", field);
return NULL;
}
+ rf = (java_lang_reflect_Field*)field;
+
LLNI_field_get_ref(rf, annotations, ba);
return (jbyteArray)ba;
jbyteArray JVM_GetMethodAnnotations(JNIEnv *env, jobject method)
{
- java_lang_reflect_Method *rm = (java_lang_reflect_Method*)method;
- java_handle_bytearray_t *ba = NULL;
+ java_lang_reflect_Method *rm = NULL; /* java.lang.reflect.Method for 'method' */
+ java_handle_bytearray_t *ba = NULL; /* unparsed annotations */
TRACEJVMCALLS("JVM_GetMethodAnnotations: method=%p", method);
return NULL;
}
+ rm = (java_lang_reflect_Method*)method;
+
LLNI_field_get_ref(rm, annotations, ba);
return (jbyteArray)ba;
jbyteArray JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method)
{
- java_lang_reflect_Method *rm = (java_lang_reflect_Method*)method;
- java_handle_bytearray_t *ba = NULL;
+ java_lang_reflect_Method *rm = NULL; /* java.lang.reflect.Method for 'method' */
+ java_handle_bytearray_t *ba = NULL; /* unparsed annotation default value */
TRACEJVMCALLS("JVM_GetMethodDefaultAnnotationValue: method=%p", method);
return NULL;
}
+ rm = (java_lang_reflect_Method*)method;
+
LLNI_field_get_ref(rm, annotationDefault, ba);
return (jbyteArray)ba;
jbyteArray JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method)
{
- java_lang_reflect_Method *rm = (java_lang_reflect_Method*)method;
- java_handle_bytearray_t *ba = NULL;
+ java_lang_reflect_Method *rm = NULL; /* java.lang.reflect.Method for 'method' */
+ java_handle_bytearray_t *ba = NULL; /* unparsed parameter annotations */
TRACEJVMCALLS("JVM_GetMethodParameterAnnotations: method=%p", method);
return NULL;
}
+ rm = (java_lang_reflect_Method*)method;
+
LLNI_field_get_ref(rm, parameterAnnotations, ba);
return (jbyteArray)ba;
jobjectArray JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)
{
-#if PRINTJVM
- log_println("JVM_GetClassDeclaredFields: ofClass=%p, publicOnly=%d", ofClass, publicOnly);
-#endif
+ TRACEJVMCALLS("JVM_GetClassDeclaredFields(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly);
+
return (jobjectArray) _Jv_java_lang_Class_getDeclaredFields((java_lang_Class *) ofClass, publicOnly);
}
jobjectArray JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly)
{
-#if PRINTJVM
- log_println("JVM_GetClassDeclaredMethods: ofClass=%p, publicOnly=%d", ofClass, publicOnly);
-#endif
+ TRACEJVMCALLS("JVM_GetClassDeclaredMethods(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly);
+
return (jobjectArray) _Jv_java_lang_Class_getDeclaredMethods((java_lang_Class *) ofClass, publicOnly);
}
jobjectArray JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly)
{
-#if PRINTJVM
- log_println("JVM_GetClassDeclaredConstructors: ofClass=%p, publicOnly=%d", ofClass, publicOnly);
-#endif
+ TRACEJVMCALLS("JVM_GetClassDeclaredConstructors(env=%p, ofClass=%p, publicOnly=%d)", env, ofClass, publicOnly);
+
return (jobjectArray) _Jv_java_lang_Class_getDeclaredConstructors((java_lang_Class *) ofClass, publicOnly);
}
{
classinfo *c;
-#if PRINTJVM
- log_println("JVM_GetClassAccessFlags: cls=%p", cls);
-#endif
+ TRACEJVMCALLS("JVM_GetClassAccessFlags(env=%p, cls=%p)", env, cls);
c = LLNI_classinfo_unwrap(cls);
+ /* Primitive type classes have the correct access flags. */
+
return c->flags & ACC_CLASS_REFLECT_MASK;
}
{
#if defined(ENABLE_ANNOTATIONS)
sun_reflect_ConstantPool *constantPool = NULL;
+ /* constant pool object for the class refered by 'cls' */
java_lang_Object *constantPoolOop = (java_lang_Object*)cls;
-
+ /* constantPoolOop field of the constant pool object */
+
TRACEJVMCALLS("JVM_GetClassConstantPool(env=%p, cls=%p)", env, cls);
constantPool =
jint JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool)
{
- classinfo *c;
+ classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
TRACEJVMCALLS("JVM_ConstantPoolGetSize(env=%p, unused=%p, jcpool=%p)", env, unused, jcpool);
jclass JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- constant_classref *ref;
- classinfo *c;
- classinfo *result;
+ constant_classref *ref; /* classref to the class at constant pool index 'index' */
+ classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
+ classinfo *result; /* classinfo of the class at constant pool index 'index' */
TRACEJVMCALLS("JVM_ConstantPoolGetClassAt(env=%p, jcpool=%p, index=%d)", env, jcpool, index);
ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
- if (ref == NULL)
+ if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return NULL;
+ }
result = resolve_classref_eager(ref);
jclass JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- constant_classref *ref;
- classinfo *c;
- classinfo *result;
+ constant_classref *ref; /* classref to the class at constant pool index 'index' */
+ classinfo *c; /* classinfo of the class for which 'this' is the constant pool */
+ classinfo *result; /* classinfo of the class at constant pool index 'index' */
TRACEJVMCALLS("JVM_ConstantPoolGetClassAtIfLoaded(env=%p, unused=%p, jcpool=%p, index=%d)", env, unused, jcpool, index);
ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
- if (ref == NULL)
+ if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return NULL;
+ }
- if (!resolve_classref(NULL, ref, resolveLazy, true, true, &result))
+ if (!resolve_classref(NULL, ref, resolveLazy, true, true, &result)) {
return NULL;
+ }
if ((result == NULL) || !(result->state & CLASS_LOADED)) {
return NULL;
jobject JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- constant_FMIref *ref;
- classinfo *cls = LLNI_classinfo_unwrap(jcpool);
+ constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
+ classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
TRACEJVMCALLS("JVM_ConstantPoolGetMethodAt: jcpool=%p, index=%d", jcpool, index);
-
+
+ cls = LLNI_classinfo_unwrap(jcpool);
ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return NULL;
}
jobject JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- constant_FMIref *ref;
- classinfo *c = NULL;
- classinfo *cls = LLNI_classinfo_unwrap(jcpool);
+ constant_FMIref *ref; /* reference to the method in constant pool at index 'index' */
+ classinfo *c = NULL; /* resolved declaring class of the method */
+ classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
TRACEJVMCALLS("JVM_ConstantPoolGetMethodAtIfLoaded: jcpool=%p, index=%d", jcpool, index);
+ cls = LLNI_classinfo_unwrap(jcpool);
ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Methodref);
if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return NULL;
}
jobject JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- constant_FMIref *ref;
- classinfo *cls = LLNI_classinfo_unwrap(jcpool);
+ constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
+ classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
TRACEJVMCALLS("JVM_ConstantPoolGetFieldAt: jcpool=%p, index=%d", jcpool, index);
+ cls = LLNI_classinfo_unwrap(jcpool);
ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return NULL;
}
jobject JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- constant_FMIref *ref;
- classinfo *c;
- classinfo *cls = LLNI_classinfo_unwrap(jcpool);
+ constant_FMIref *ref; /* reference to the field in constant pool at index 'index' */
+ classinfo *c; /* resolved declaring class for the field */
+ classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
TRACEJVMCALLS("JVM_ConstantPoolGetFieldAtIfLoaded: jcpool=%p, index=%d", jcpool, index);
+ cls = LLNI_classinfo_unwrap(jcpool);
ref = (constant_FMIref*)class_getconstant(cls, index, CONSTANT_Fieldref);
if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return NULL;
}
jobjectArray JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
log_println("JVM_ConstantPoolGetMemberRefInfoAt: jcpool=%p, index=%d, IMPLEMENT ME!", jcpool, index);
+
+ /* TODO: implement. (this is yet unused be OpenJDK but, so very low priority) */
+
return NULL;
}
jint JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- constant_integer *ref;
- classinfo *cls = LLNI_classinfo_unwrap(jcpool);
+ constant_integer *ref; /* reference to the int value in constant pool at index 'index' */
+ classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
TRACEJVMCALLS("JVM_ConstantPoolGetIntAt: jcpool=%p, index=%d", jcpool, index);
+ cls = LLNI_classinfo_unwrap(jcpool);
ref = (constant_integer*)class_getconstant(cls, index, CONSTANT_Integer);
if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return 0;
}
jlong JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- constant_long *ref;
- classinfo *cls = LLNI_classinfo_unwrap(jcpool);
+ constant_long *ref; /* reference to the long value in constant pool at index 'index' */
+ classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
TRACEJVMCALLS("JVM_ConstantPoolGetLongAt: jcpool=%p, index=%d", jcpool, index);
+ cls = LLNI_classinfo_unwrap(jcpool);
ref = (constant_long*)class_getconstant(cls, index, CONSTANT_Long);
if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return 0;
}
jfloat JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- constant_float *ref;
- classinfo *cls = LLNI_classinfo_unwrap(jcpool);
+ constant_float *ref; /* reference to the float value in constant pool at index 'index' */
+ classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
TRACEJVMCALLS("JVM_ConstantPoolGetFloatAt: jcpool=%p, index=%d", jcpool, index);
+ cls = LLNI_classinfo_unwrap(jcpool);
ref = (constant_float*)class_getconstant(cls, index, CONSTANT_Float);
if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return 0;
}
jdouble JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- constant_double *ref;
- classinfo *cls = LLNI_classinfo_unwrap(jcpool);
+ constant_double *ref; /* reference to the double value in constant pool at index 'index' */
+ classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
TRACEJVMCALLS("JVM_ConstantPoolGetDoubleAt: jcpool=%p, index=%d", jcpool, index);
+ cls = LLNI_classinfo_unwrap(jcpool);
ref = (constant_double*)class_getconstant(cls, index, CONSTANT_Double);
if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return 0;
}
jstring JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- utf *ref;
- classinfo *cls = LLNI_classinfo_unwrap(jcpool);
+ utf *ref; /* utf object for the string in constant pool at index 'index' */
+ classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
TRACEJVMCALLS("JVM_ConstantPoolGetStringAt: jcpool=%p, index=%d", jcpool, index);
+ cls = LLNI_classinfo_unwrap(jcpool);
ref = (utf*)class_getconstant(cls, index, CONSTANT_String);
if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return NULL;
}
jstring JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- utf *ref;
- classinfo *cls = LLNI_classinfo_unwrap(jcpool);
+ utf *ref; /* utf object for the utf8 data in constant pool at index 'index' */
+ classinfo *cls; /* classinfo of the class for which 'this' is the constant pool */
TRACEJVMCALLS("JVM_ConstantPoolGetUTF8At: jcpool=%p, index=%d", jcpool, index);
+ cls = LLNI_classinfo_unwrap(jcpool);
ref = (utf*)class_getconstant(cls, index, CONSTANT_Utf8);
if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return NULL;
}
jboolean JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls)
{
+#if defined(ENABLE_ASSERTION)
+ assertion_name_t *item;
+ classinfo *c;
+ jboolean status;
+ utf *name;
+
TRACEJVMCALLS("JVM_DesiredAssertionStatus(env=%p, unused=%p, cls=%p)", env, unused, cls);
- /* TODO: Implement this one, but false should be OK. */
+ c = LLNI_classinfo_unwrap(cls);
- return false;
+ if (c->classloader == NULL) {
+ status = (jboolean)assertion_system_enabled;
+ }
+ else {
+ status = (jboolean)assertion_user_enabled;
+ }
+
+ if (list_assertion_names != NULL) {
+ item = (assertion_name_t *)list_first(list_assertion_names);
+ while (item != NULL) {
+ name = utf_new_char(item->name);
+ if (name == c->packagename) {
+ status = (jboolean)item->enabled;
+ }
+ else if (name == c->name) {
+ status = (jboolean)item->enabled;
+ }
+
+ item = (assertion_name_t *)list_next(list_assertion_names, item);
+ }
+ }
+
+ return status;
+#else
+ return (jboolean)false;
+#endif
}
jobject JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)
{
- classinfo *c;
- java_lang_AssertionStatusDirectives *o;
- java_handle_objectarray_t *classes;
- java_handle_objectarray_t *packages;
-
-#if PRINTJVM || 1
- log_println("JVM_AssertionStatusDirectives");
+ classinfo *c;
+ java_lang_AssertionStatusDirectives *o;
+ java_handle_objectarray_t *classes;
+ java_handle_objectarray_t *packages;
+ java_booleanarray_t *classEnabled;
+ java_booleanarray_t *packageEnabled;
+#if defined(ENABLE_ASSERTION)
+ assertion_name_t *item;
+ java_handle_t *js;
+ s4 i, j;
#endif
- /* XXX this is not completely implemented */
+
+ TRACEJVMCALLS("JVM_AssertionStatusDirectives(env=%p, unused=%p)", env, unused);
c = load_class_bootstrap(utf_new_char("java/lang/AssertionStatusDirectives"));
if (o == NULL)
return NULL;
+#if defined(ENABLE_ASSERTION)
+ classes = builtin_anewarray(assertion_class_count, class_java_lang_Object);
+#else
classes = builtin_anewarray(0, class_java_lang_Object);
-
+#endif
if (classes == NULL)
return NULL;
+#if defined(ENABLE_ASSERTION)
+ packages = builtin_anewarray(assertion_package_count, class_java_lang_Object);
+#else
packages = builtin_anewarray(0, class_java_lang_Object);
-
+#endif
if (packages == NULL)
return NULL;
+
+#if defined(ENABLE_ASSERTION)
+ classEnabled = builtin_newarray_boolean(assertion_class_count);
+#else
+ classEnabled = builtin_newarray_boolean(0);
+#endif
+ if (classEnabled == NULL)
+ return NULL;
+
+#if defined(ENABLE_ASSERTION)
+ packageEnabled = builtin_newarray_boolean(assertion_package_count);
+#else
+ packageEnabled = builtin_newarray_boolean(0);
+#endif
+ if (packageEnabled == NULL)
+ return NULL;
+
+#if defined(ENABLE_ASSERTION)
+ /* initialize arrays */
+
+ if (list_assertion_names != NULL) {
+ i = 0;
+ j = 0;
+
+ item = (assertion_name_t *)list_first(list_assertion_names);
+ while (item != NULL) {
+ js = javastring_new_from_ascii(item->name);
+ if (js == NULL) {
+ return NULL;
+ }
+
+ if (item->package == false) {
+ classes->data[i] = js;
+ classEnabled->data[i] = (jboolean) item->enabled;
+ i += 1;
+ }
+ else {
+ packages->data[j] = js;
+ packageEnabled->data[j] = (jboolean) item->enabled;
+ j += 1;
+ }
+
+ item = (assertion_name_t *)list_next(list_assertion_names, item);
+ }
+ }
+#endif
/* set instance fields */
o->classes = classes;
o->packages = packages;
+ o->classEnabled = classEnabled;
+ o->packageEnabled = packageEnabled;
return (jobject) o;
}
/* JVM_GetClassNameUTF */
-const char* JVM_GetClassNameUTF(JNIEnv *env, jclass cls)
+const char *JVM_GetClassNameUTF(JNIEnv *env, jclass cls)
{
log_println("JVM_GetClassNameUTF: IMPLEMENT ME!");
+
+ return NULL;
}
jint JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)
{
log_println("JVM_GetClassCPEntriesCount: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)
{
log_println("JVM_GetClassFieldsCount: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)
{
log_println("JVM_GetClassMethodsCount: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)
{
log_println("JVM_GetMethodIxExceptionsCount: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)
{
log_println("JVM_GetMethodIxByteCodeLength: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)
{
log_println("JVM_GetMethodIxExceptionTableLength: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)
{
log_println("JVM_GetMethodIxModifiers: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)
{
log_println("JVM_GetFieldIxModifiers: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)
{
log_println("JVM_GetMethodIxLocalsCount: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)
{
log_println("JVM_GetMethodIxArgsSize: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)
{
log_println("JVM_GetMethodIxMaxStack: IMPLEMENT ME!");
+
+ return 0;
}
jboolean JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)
{
log_println("JVM_IsConstructorIx: IMPLEMENT ME!");
+
+ return 0;
}
/* JVM_GetMethodIxNameUTF */
-const char* JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)
+const char *JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)
{
log_println("JVM_GetMethodIxNameUTF: IMPLEMENT ME!");
+
+ return NULL;
}
/* JVM_GetMethodIxSignatureUTF */
-const char* JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)
+const char *JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)
{
log_println("JVM_GetMethodIxSignatureUTF: IMPLEMENT ME!");
+
+ return NULL;
}
/* JVM_GetCPFieldNameUTF */
-const char* JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)
+const char *JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)
{
log_println("JVM_GetCPFieldNameUTF: IMPLEMENT ME!");
+
+ return NULL;
}
/* JVM_GetCPMethodNameUTF */
-const char* JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)
+const char *JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)
{
log_println("JVM_GetCPMethodNameUTF: IMPLEMENT ME!");
+
+ return NULL;
}
/* JVM_GetCPMethodSignatureUTF */
-const char* JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
+const char *JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
{
log_println("JVM_GetCPMethodSignatureUTF: IMPLEMENT ME!");
+
+ return NULL;
}
/* JVM_GetCPFieldSignatureUTF */
-const char* JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
+const char *JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)
{
log_println("JVM_GetCPFieldSignatureUTF: IMPLEMENT ME!");
+
+ return NULL;
}
/* JVM_GetCPClassNameUTF */
-const char* JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
+const char *JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
{
log_println("JVM_GetCPClassNameUTF: IMPLEMENT ME!");
+
+ return NULL;
}
/* JVM_GetCPFieldClassNameUTF */
-const char* JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
+const char *JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
{
log_println("JVM_GetCPFieldClassNameUTF: IMPLEMENT ME!");
+
+ return NULL;
}
/* JVM_GetCPMethodClassNameUTF */
-const char* JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
+const char *JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)
{
log_println("JVM_GetCPMethodClassNameUTF: IMPLEMENT ME!");
+
+ return NULL;
}
jint JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
{
log_println("JVM_GetCPFieldModifiers: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)
{
log_println("JVM_GetCPMethodModifiers: IMPLEMENT ME!");
+
+ return 0;
}
jboolean JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2)
{
log_println("JVM_IsSameClassPackage: IMPLEMENT ME!");
+
+ return 0;
}
/* JVM_Open */
+/* Taken from: hotspot/src/share/vm/prims/jvm.h */
+
+/*
+ * JVM I/O error codes
+ */
+#define JVM_EEXIST -100
+
jint JVM_Open(const char *fname, jint flags, jint mode)
{
int result;
-#if PRINTJVM
- log_println("JVM_Open: fname=%s, flags=%d, mode=%d", fname, flags, mode);
-#endif
+ TRACEJVMCALLS("JVM_Open(fname=%s, flags=%d, mode=%d)", fname, flags, mode);
- result = open(fname, flags, mode);
+ result = system_open(fname, flags, mode);
if (result >= 0) {
return result;
}
else {
- switch(errno) {
+ switch (errno) {
case EEXIST:
- /* XXX don't know what to do here */
-/* return JVM_EEXIST; */
- return -1;
+ return JVM_EEXIST;
default:
return -1;
}
jint JVM_Close(jint fd)
{
-#if PRINTJVM
- log_println("JVM_Close: fd=%d", fd);
-#endif
- return close(fd);
+ TRACEJVMCALLS("JVM_Close(fd=%d)", fd);
+
+ return system_close(fd);
}
jint JVM_Read(jint fd, char *buf, jint nbytes)
{
-#if PRINTJVM
- log_println("JVM_Read: fd=%d, buf=%p, nbytes=%d", fd, buf, nbytes);
-#endif
- return read(fd, buf, nbytes);
+ TRACEJVMCALLS("JVM_Read(fd=%d, buf=%p, nbytes=%d)", fd, buf, nbytes);
+
+ return system_read(fd, buf, nbytes);
}
jint JVM_Write(jint fd, char *buf, jint nbytes)
{
-#if PRINTJVM
- log_println("JVM_Write: fd=%d, buf=%s, nbytes=%d", fd, buf, nbytes);
-#endif
- return write(fd, buf, nbytes);
+ TRACEJVMCALLS("JVM_Write(fd=%d, buf=%s, nbytes=%d)", fd, buf, nbytes);
+
+ return system_write(fd, buf, nbytes);
}
{
#if defined(FIONREAD)
int bytes;
+ int result;
TRACEJVMCALLS("JVM_Available(fd=%d, pbytes=%p)", fd, pbytes);
*pbytes = 0;
- if (ioctl(fd, FIONREAD, &bytes) < 0)
+ result = ioctl(fd, FIONREAD, &bytes);
+
+ if (result < 0)
return 0;
*pbytes = bytes;
jlong JVM_Lseek(jint fd, jlong offset, jint whence)
{
-#if PRINTJVM
- log_println("JVM_Lseek: fd=%d, offset=%ld, whence=%d", fd, offset, whence);
-#endif
- return (jlong) lseek(fd, (off_t) offset, whence);
+ TRACEJVMCALLS("JVM_Lseek(fd=%d, offset=%ld, whence=%d)", fd, offset, whence);
+
+ return (jlong) system_lseek(fd, (off_t) offset, whence);
}
jint JVM_SetLength(jint fd, jlong length)
{
- log_println("JVM_SetLength: IMPLEMENT ME!");
+ TRACEJVMCALLS("JVM_SetLength(fd=%d, length=%ld)", length);
+
+ return system_ftruncate(fd, length);
}
jint JVM_Sync(jint fd)
{
- log_println("JVM_Sync: IMPLEMENT ME!");
+ TRACEJVMCALLS("JVM_Sync(fd=%d)", fd);
+
+ return system_fsync(fd);
}
void JVM_StartThread(JNIEnv* env, jobject jthread)
{
-#if PRINTJVM
- log_println("JVM_StartThread: jthread=%p", jthread);
-#endif
+ TRACEJVMCALLS("JVM_StartThread(env=%p, jthread=%p)", env, jthread);
+
_Jv_java_lang_Thread_start((java_lang_Thread *) jthread, 0);
}
jboolean JVM_IsThreadAlive(JNIEnv* env, jobject jthread)
{
-#if PRINTJVM
- log_println("JVM_IsThreadAlive: jthread=%p", jthread);
-#endif
- return _Jv_java_lang_Thread_isAlive((java_lang_Thread *) jthread);
+ threadobject *t;
+ bool equal;
+ bool result;
+
+ TRACEJVMCALLS("JVM_IsThreadAlive(env=%p, jthread=%p)", env, jthread);
+
+ /* XXX this is just a quick hack */
+
+ for (t = threads_list_first(); t != NULL; t = threads_list_next(t)) {
+ LLNI_equals(t->object, jthread, equal);
+
+ if (equal == true)
+ break;
+ }
+
+ /* The threadobject is null when a thread is created in Java. The
+ priority is set later during startup. */
+
+ if (t == NULL)
+ return 0;
+
+ result = threads_thread_is_alive(t);
+
+ return result;
}
void JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio)
{
-#if PRINTJVM
- log_println("JVM_SetThreadPriority: jthread=%p, prio=%d", jthread, prio);
-#endif
+ TRACEJVMCALLS("JVM_SetThreadPriority(env=%p, jthread=%p, prio=%d)", env, jthread, prio);
+
_Jv_java_lang_Thread_setPriority((java_lang_Thread *) jthread, prio);
}
void JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis)
{
-#if PRINTJVM
- log_println("JVM_Sleep: threadClass=%p, millis=%ld", threadClass, millis);
-#endif
+ TRACEJVMCALLS("JVM_Sleep(env=%p, threadClass=%p, millis=%ld)", env, threadClass, millis);
+
_Jv_java_lang_Thread_sleep(millis);
}
jobject JVM_CurrentThread(JNIEnv* env, jclass threadClass)
{
-#if PRINTJVM
- log_println("JVM_CurrentThread: threadClass=%p", threadClass);
-#endif
+ TRACEJVMCALLSVERBOSE(("JVM_CurrentThread(env=%p, threadClass=%p)", env, threadClass));
+
return (jobject) _Jv_java_lang_Thread_currentThread();
}
jint JVM_CountStackFrames(JNIEnv* env, jobject jthread)
{
log_println("JVM_CountStackFrames: IMPLEMENT ME!");
+
+ return 0;
}
jboolean JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted)
{
-#if PRINTJVM
- log_println("JVM_IsInterrupted: jthread=%p, clear_interrupted=%d", jthread, clear_interrupted);
-#endif
+ TRACEJVMCALLS("JVM_IsInterrupted(env=%p, jthread=%p, clear_interrupted=%d)", env, jthread, clear_interrupted);
+
/* XXX do something with clear_interrupted */
+
return _Jv_java_lang_Thread_isInterrupted((java_lang_Thread *) jthread);
}
jboolean JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj)
{
- log_println("JVM_HoldsLock: IMPLEMENT ME!");
+ java_handle_t *h;
+ bool result;
+
+ TRACEJVMCALLS("JVM_HoldsLock(env=%p, threadClass=%p, obj=%p)", env, threadClass, obj);
+
+ h = (java_handle_t *) obj;
+
+ if (h == NULL) {
+ exceptions_throw_nullpointerexception();
+ return JNI_FALSE;
+ }
+
+ result = lock_is_held_by_current_thread(h);
+
+ return result;
}
jclass JVM_CurrentLoadedClass(JNIEnv *env)
{
log_println("JVM_CurrentLoadedClass: IMPLEMENT ME!");
+
+ return NULL;
}
doPrivileged, return NULL */
log_println("JVM_CurrentClassLoader: IMPLEMENT ME!");
+
+ return NULL;
}
jobjectArray JVM_GetClassContext(JNIEnv *env)
{
-#if PRINTJVM
- log_println("JVM_GetClassContext");
-#endif
+ TRACEJVMCALLS("JVM_GetClassContext(env=%p)", env);
+
return (jobjectArray) stacktrace_getClassContext();
}
jint JVM_ClassDepth(JNIEnv *env, jstring name)
{
log_println("JVM_ClassDepth: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_ClassLoaderDepth(JNIEnv *env)
{
log_println("JVM_ClassLoaderDepth: IMPLEMENT ME!");
+
+ return 0;
}
jstring JVM_GetSystemPackage(JNIEnv *env, jstring name)
{
- log_println("JVM_GetSystemPackage(env=%p, name=%p)");
- javastring_print((java_handle_t *) name);
- printf("\n");
+ java_handle_t *s;
+ utf *u;
+ utf *result;
- return NULL;
+ TRACEJVMCALLS("JVM_GetSystemPackage(env=%p, name=%p)", env, name);
+
+/* s = package_find(name); */
+ u = javastring_toutf((java_handle_t *) name, false);
+
+ result = package_find(u);
+
+ if (result != NULL)
+ s = javastring_new(result);
+ else
+ s = NULL;
+
+ return (jstring) s;
}
jobjectArray JVM_GetSystemPackages(JNIEnv *env)
{
log_println("JVM_GetSystemPackages: IMPLEMENT ME!");
+
+ return NULL;
}
jobject JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass)
{
log_println("JVM_AllocateNewObject: IMPLEMENT ME!");
+
+ return NULL;
}
jobject JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length)
{
log_println("JVM_AllocateNewArray: IMPLEMENT ME!");
+
+ return NULL;
}
jobject JVM_LatestUserDefinedLoader(JNIEnv *env)
{
- log_println("JVM_LatestUserDefinedLoader: IMPLEMENT ME!");
+ classloader *cl;
+
+ TRACEJVMCALLS("JVM_LatestUserDefinedLoader(env=%p)", env);
+
+ cl = stacktrace_first_nonnull_classloader();
+
+ return (jobject) cl;
}
jclass JVM_LoadClass0(JNIEnv *env, jobject receiver, jclass currClass, jstring currClassName)
{
log_println("JVM_LoadClass0: IMPLEMENT ME!");
+
+ return NULL;
}
jvalue JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode)
{
+ jvalue jv;
+
log_println("JVM_GetPrimitiveArrayElement: IMPLEMENT ME!");
+
+ jv.l = NULL;
+
+ return jv;
}
ia = (java_handle_intarray_t *) dim;
- length = array_length_get(ia);
+ length = array_length_get((java_handle_t *) ia);
dims = MNEW(long, length);
if (ac == NULL)
return NULL;
- a = builtin_multianewarray(length, ac, dims);
+ a = builtin_multianewarray(length, (java_handle_t *) ac, dims);
return (jobject) a;
}
jint JVM_InitializeSocketLibrary()
{
log_println("JVM_InitializeSocketLibrary: IMPLEMENT ME!");
+
+ return 0;
}
{
TRACEJVMCALLS("JVM_Socket(domain=%d, type=%d, protocol=%d)", domain, type, protocol);
- return socket(domain, type, protocol);
+ return system_socket(domain, type, protocol);
}
{
TRACEJVMCALLS("JVM_SocketClose(fd=%d)", fd);
- return close(fd);
+ return system_close(fd);
}
{
TRACEJVMCALLS("JVM_SocketShutdown(fd=%d, howto=%d)", fd, howto);
- return shutdown(fd, howto);
+ return system_shutdown(fd, howto);
}
jint JVM_Recv(jint fd, char *buf, jint nBytes, jint flags)
{
log_println("JVM_Recv: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_Send(jint fd, char *buf, jint nBytes, jint flags)
{
log_println("JVM_Send: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_Timeout(int fd, long timeout)
{
log_println("JVM_Timeout: IMPLEMENT ME!");
+
+ return 0;
}
{
TRACEJVMCALLS("JVM_Listen(fd=%d, count=%d)", fd, count);
- return listen(fd, count);
+ return system_listen(fd, count);
}
{
TRACEJVMCALLS("JVM_Connect(fd=%d, him=%p, len=%d)", fd, him, len);
- return connect(fd, him, len);
+ return system_connect(fd, him, len);
}
jint JVM_Bind(jint fd, struct sockaddr *him, jint len)
{
log_println("JVM_Bind: IMPLEMENT ME!");
+
+ return 0;
}
{
TRACEJVMCALLS("JVM_Accept(fd=%d, him=%p, len=%p)", fd, him, len);
- return accept(fd, him, (socklen_t *) len);
+ return system_accept(fd, him, (socklen_t *) len);
}
jint JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen)
{
log_println("JVM_RecvFrom: IMPLEMENT ME!");
+
+ return 0;
}
{
TRACEJVMCALLS("JVM_GetSockName(fd=%d, him=%p, len=%p)", fd, him, len);
- return getsockname(fd, him, (socklen_t *) len);
+ return system_getsockname(fd, him, (socklen_t *) len);
}
jint JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen)
{
log_println("JVM_SendTo: IMPLEMENT ME!");
+
+ return 0;
}
jint JVM_SocketAvailable(jint fd, jint *pbytes)
{
- log_println("JVM_SocketAvailable: IMPLEMENT ME!");
+#if defined(FIONREAD)
+ int bytes;
+ int result;
+
+ TRACEJVMCALLS("JVM_SocketAvailable(fd=%d, pbytes=%p)", fd, pbytes);
+
+ *pbytes = 0;
+
+ result = ioctl(fd, FIONREAD, &bytes);
+
+ if (result < 0)
+ return 0;
+
+ *pbytes = bytes;
+
+ return 1;
+#else
+# error FIONREAD not defined
+#endif
}
jint JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen)
{
- log_println("JVM_GetSockOpt: IMPLEMENT ME!");
+ TRACEJVMCALLS("JVM_GetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%p)", fd, level, optname, optval, optlen);
+
+ return system_getsockopt(fd, level, optname, optval, (socklen_t *) optlen);
}
{
TRACEJVMCALLS("JVM_SetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%d)", fd, level, optname, optval, optlen);
- return setsockopt(fd, level, optname, optval, optlen);
+ return system_setsockopt(fd, level, optname, optval, optlen);
}
/* JVM_GetHostName */
-int JVM_GetHostName(char* name, int namelen)
+int JVM_GetHostName(char *name, int namelen)
{
TRACEJVMCALLS("JVM_GetHostName(name=%s, namelen=%d)", name, namelen);
- return gethostname(name, namelen);
+ return system_gethostname(name, namelen);
}
/* JVM_GetHostByAddr */
-struct hostent* JVM_GetHostByAddr(const char* name, int len, int type)
+struct hostent *JVM_GetHostByAddr(const char* name, int len, int type)
{
log_println("JVM_GetHostByAddr: IMPLEMENT ME!");
+
+ return NULL;
}
/* JVM_GetHostByName */
-struct hostent* JVM_GetHostByName(char* name)
+struct hostent *JVM_GetHostByName(char* name)
{
log_println("JVM_GetHostByName: IMPLEMENT ME!");
+
+ return NULL;
}
/* JVM_GetProtoByName */
-struct protoent* JVM_GetProtoByName(char* name)
+struct protoent *JVM_GetProtoByName(char* name)
{
log_println("JVM_GetProtoByName: IMPLEMENT ME!");
+
+ return NULL;
}
void JVM_UnloadLibrary(void* handle)
{
- log_println("JVM_UnloadLibrary: IMPLEMENT ME!");
+ TRACEJVMCALLS("JVM_UnloadLibrary(handle=%p)", handle);
+
+ native_library_close(handle);
}
jboolean JVM_IsNaN(jdouble a)
{
log_println("JVM_IsNaN: IMPLEMENT ME!");
+
+ return 0;
}
{
TRACEJVMCALLS("JVM_IsSupportedJNIVersion(version=%d)", version);
- switch (version) {
- case JNI_VERSION_1_1:
- case JNI_VERSION_1_2:
- case JNI_VERSION_1_4:
- case JNI_VERSION_1_6:
- return true;
- default:
- return false;
- }
+ return jni_version_check(version);
}
{
java_object_t *o;
-#if PRINTJVM
- log_println("JVM_RawMonitorCreate");
-#endif
+ TRACEJVMCALLS("JVM_RawMonitorCreate()");
o = NEW(java_object_t);
JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void *mon)
{
-#if PRINTJVM
- log_println("JVM_RawMonitorDestroy: mon=%p", mon);
-#endif
+ TRACEJVMCALLS("JVM_RawMonitorDestroy(mon=%p)", mon);
+
FREE(mon, java_object_t);
}
JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void *mon)
{
-#if PRINTJVM
- log_println("JVM_RawMonitorEnter: mon=%p", mon);
-#endif
+ TRACEJVMCALLS("JVM_RawMonitorEnter(mon=%p)", mon);
+
(void) lock_monitor_enter((java_object_t *) mon);
return 0;
JNIEXPORT void JNICALL JVM_RawMonitorExit(void *mon)
{
-#if PRINTJVM
- log_println("JVM_RawMonitorExit: mon=%p", mon);
-#endif
+ TRACEJVMCALLS("JVM_RawMonitorExit(mon=%p)", mon);
+
(void) lock_monitor_exit((java_object_t *) mon);
}
jboolean JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get)
{
log_println("JVM_AccessVMBooleanFlag: IMPLEMENT ME!");
+
+ return 0;
}
jboolean JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get)
{
log_println("JVM_AccessVMIntFlag: IMPLEMENT ME!");
+
+ return 0;
}
jobjectArray JVM_GetClassFields(JNIEnv *env, jclass cls, jint which)
{
log_println("JVM_GetClassFields: IMPLEMENT ME!");
+
+ return NULL;
}
jobjectArray JVM_GetClassMethods(JNIEnv *env, jclass cls, jint which)
{
log_println("JVM_GetClassMethods: IMPLEMENT ME!");
+
+ return NULL;
}
jobjectArray JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which)
{
log_println("JVM_GetClassConstructors: IMPLEMENT ME!");
+
+ return NULL;
}
jobject JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which)
{
log_println("JVM_GetClassField: IMPLEMENT ME!");
+
+ return NULL;
}
jobject JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types, jint which)
{
log_println("JVM_GetClassMethod: IMPLEMENT ME!");
+
+ return NULL;
}
jobject JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types, jint which)
{
log_println("JVM_GetClassConstructor: IMPLEMENT ME!");
+
+ return NULL;
}
jobject JVM_NewInstance(JNIEnv *env, jclass cls)
{
log_println("JVM_NewInstance: IMPLEMENT ME!");
+
+ return NULL;
}
jobject JVM_GetField(JNIEnv *env, jobject field, jobject obj)
{
log_println("JVM_GetField: IMPLEMENT ME!");
+
+ return NULL;
}
jvalue JVM_GetPrimitiveField(JNIEnv *env, jobject field, jobject obj, unsigned char wCode)
{
+ jvalue jv;
+
log_println("JVM_GetPrimitiveField: IMPLEMENT ME!");
+
+ jv.l = NULL;
+
+ return jv;
}
jobject JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)
{
-#if PRINTJVM
- log_println("JVM_InvokeMethod: method=%p, obj=%p, args0=%p", method, obj, args0);
-#endif
+ TRACEJVMCALLS("JVM_InvokeMethod(env=%p, method=%p, obj=%p, args0=%p)", env, method, obj, args0);
+
return (jobject) _Jv_java_lang_reflect_Method_invoke((java_lang_reflect_Method *) method, (java_lang_Object *) obj, (java_handle_objectarray_t *) args0);
}
jobject JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0)
{
-#if PRINTJVM
- log_println("JVM_NewInstanceFromConstructor: c=%p, args0=%p", c, args0);
-#endif
+ TRACEJVMCALLS("JVM_NewInstanceFromConstructor(env=%p, c=%p, args0=%p)", env, c, args0);
+
return (jobject) _Jv_java_lang_reflect_Constructor_newInstance(env, (java_lang_reflect_Constructor *) c, (java_handle_objectarray_t *) args0);
}
jboolean JVM_SupportsCX8()
{
-#if PRINTJVM
- log_println("JVM_SupportsCX8");
-#endif
- return _Jv_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(NULL, NULL);
+ TRACEJVMCALLS("JVM_SupportsCX8()");
+
+ /* IMPLEMENT ME */
+
+ return 0;
}
jboolean JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal)
{
log_println("JVM_CX8Field: IMPLEMENT ME!");
+
+ return 0;
}
jobjectArray JVM_GetAllThreads(JNIEnv *env, jclass dummy)
{
log_println("JVM_GetAllThreads: IMPLEMENT ME!");
+
+ return NULL;
}
jobjectArray JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads)
{
log_println("JVM_DumpThreads: IMPLEMENT ME!");
+
+ return NULL;
}
/* JVM_GetManagement */
-void* JVM_GetManagement(jint version)
+void *JVM_GetManagement(jint version)
{
- log_println("JVM_GetManagement: IMPLEMENT ME!");
+ TRACEJVMCALLS("JVM_GetManagement(version=%d)", version);
+
+ /* TODO We current don't support the management interface. */
+
+ return NULL;
}
jobject JVM_InitAgentProperties(JNIEnv *env, jobject properties)
{
log_println("JVM_InitAgentProperties: IMPLEMENT ME!");
+
+ return NULL;
}
jobjectArray JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass)
{
- log_println("JVM_GetEnclosingMethodInfo: IMPLEMENT ME!");
+ classinfo *c;
+ methodinfo *m;
+ java_handle_objectarray_t *oa;
+
+ TRACEJVMCALLS("JVM_GetEnclosingMethodInfo(env=%p, ofClass=%p)", env, ofClass);
+
+ c = LLNI_classinfo_unwrap(ofClass);
+
+ if ((c == NULL) || class_is_primitive(c))
+ return NULL;
+
+ m = class_get_enclosingmethod(c);
+
+ if (m == NULL)
+ return NULL;
+
+ oa = builtin_anewarray(3, class_java_lang_Object);
+
+ if (oa == NULL)
+ return NULL;
+
+ array_objectarray_element_set(oa, 0, (java_handle_t *) LLNI_classinfo_wrap(m->class));
+ array_objectarray_element_set(oa, 1, javastring_new(m->name));
+ array_objectarray_element_set(oa, 2, javastring_new(m->descriptor));
+
+ return (jobjectArray) oa;
}
jboolean JVM_RaiseSignal(jint sig)
{
log_println("JVM_RaiseSignal: IMPLEMENT ME! sig=%s", sig);
+
return false;
}
projects / cacao.git / blobdiff