Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: jvm.c 8357 2007-08-19 22:59:43Z twisti $
-
*/
#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/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 "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 "vm/signallocal.h"
#include "vm/stringlocal.h"
#include "vm/vm.h"
#include "vmcore/classcache.h"
#include "vmcore/options.h"
+#include "vmcore/system.h"
-/* debugging macro ************************************************************/
+/* debugging macros ***********************************************************/
#if !defined(NDEBUG)
-# define TRACEJVMCALLS(...) \
- do { \
- if (opt_TraceJVMCalls) { \
- log_println(__VA_ARGS__); \
- } \
+
+# define TRACEJVMCALLS(...) \
+ do { \
+ if (opt_TraceJVMCalls) { \
+ log_println(__VA_ARGS__); \
+ } \
} while (0)
+
+# define PRINTJVMWARNINGS(...)
+/* do { \ */
+/* if (opt_PrintJVMWarnings) { \ */
+/* log_println(__VA_ARGS__); \ */
+/* } \ */
+/* } while (0) */
+
#else
+
# define TRACEJVMCALLS(...)
+# define PRINTJVMWARNINGS(...)
+
#endif
log_println("JVM_ArrayCopy: src=%p, src_pos=%d, dst=%p, dst_pos=%d, length=%d", src, src_pos, dst, dst_pos, length);
#endif
- (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;
}
jlong JVM_MaxMemory(void)
{
- log_println("JVM_MaxMemory: IMPLEMENT ME!");
+ TRACEJVMCALLS("JVM_MaxMemory()");
+
+ return gc_get_max_heap_size();
}
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);
o = (java_lang_Throwable *) receiver;
- stc = stacktrace_fillInStackTrace();
+ ba = stacktrace_fillInStackTrace();
- if (stc == NULL)
+ if (ba == NULL)
return;
- o->backtrace = (java_lang_Object *) stc;
+ o->backtrace = (java_lang_Object *) ba;
}
jint JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable)
{
- java_lang_Throwable *o;
- stacktracecontainer *stc;
- stacktracebuffer *stb;
+ java_lang_Throwable *o;
+ java_handle_bytearray_t *ba;
+ stacktracebuffer *stb;
-#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;
+ }
o = (java_lang_Throwable *) throwable;
- stc = (stacktracecontainer *) o->backtrace;
- stb = &(stc->stb);
+ ba = (java_handle_bytearray_t *) o->backtrace;
+
+ if (ba == NULL)
+ return 0;
+
+ stb = (stacktracebuffer *) LLNI_array_data(ba);
return stb->used;
}
jobject JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index)
{
java_lang_Throwable *t;
- stacktracecontainer *stc;
- stacktracebuffer *stb;
- stacktrace_entry *ste;
+ java_handle_bytearray_t *ba;
+ stacktracebuffer *stb;
+ stacktrace_entry *ste;
java_lang_StackTraceElement *o;
java_lang_String *declaringclass;
java_lang_String *filename;
#endif
t = (java_lang_Throwable *) throwable;
- stc = (stacktracecontainer *) t->backtrace;
- stb = &(stc->stb);
+ ba = (java_handle_bytearray_t *) t->backtrace;
+ stb = (stacktracebuffer *) LLNI_array_data(ba);
if ((index < 0) || (index >= stb->used)) {
/* XXX This should be an IndexOutOfBoundsException (check this
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);
}
void JVM_EnableCompiler(JNIEnv *env, jclass compCls)
{
- log_println("JVM_EnableCompiler: IMPLEMENT ME!");
+ TRACEJVMCALLS("JVM_EnableCompiler(env=%p, compCls=%p)", env, compCls);
+ PRINTJVMWARNINGS("JVM_EnableCompiler not supported");
}
void JVM_DisableCompiler(JNIEnv *env, jclass compCls)
{
- log_println("JVM_DisableCompiler: IMPLEMENT ME!");
+ TRACEJVMCALLS("JVM_DisableCompiler(env=%p, compCls=%p)", env, compCls);
+ PRINTJVMWARNINGS("JVM_DisableCompiler not supported");
}
/* JVM_NativePath */
-char* JVM_NativePath(char* path)
+char *JVM_NativePath(char *path)
{
-#if PRINTJVM
- log_println("JVM_NativePath: path=%s", path);
-#endif
+ TRACEJVMCALLS("JVM_NativePath(path=%s)", path);
+
/* XXX is this correct? */
return path;
{
java_handle_objectarray_t *oa;
-#if PRINTJVM
- log_println("JVM_GetCallerClass: depth=%d", depth);
-#endif
+ TRACEJVMCALLS("JVM_GetCallerClass(env=%p, depth=%d)", env, depth);
oa = stacktrace_getClassContext();
u = utf_new_char(s);
c = primitive_class_get_by_name(u);
- return LLNI_classinfo_wrap(c);
+ return (jclass) LLNI_classinfo_wrap(c);
}
void JVM_ResolveClass(JNIEnv* env, jclass cls)
{
- log_println("JVM_ResolveClass: IMPLEMENT ME!");
+ TRACEJVMCALLS("JVM_ResolveClass(env=%p, cls=%p)", env, cls);
+ PRINTJVMWARNINGS("JVM_ResolveClass not implemented");
}
jclass JVM_FindClassFromClassLoader(JNIEnv* env, const char* name, jboolean init, jobject loader, jboolean throwError)
{
- classinfo *c;
+ classinfo *c;
+ utf *u;
+ classloader *cl;
-#if PRINTJVM
- log_println("JVM_FindClassFromClassLoader: name=%s, init=%d, loader=%p, throwError=%d", name, init, loader, throwError);
-#endif
+ TRACEJVMCALLS("JVM_FindClassFromClassLoader: name=%s, init=%d, loader=%p, throwError=%d", name, init, loader, throwError);
- c = load_class_from_classloader(utf_new_char(name), (classloader *) loader);
+ u = utf_new_char(name);
+ cl = loader_hashtable_classloader_add((java_handle_t *) loader);
+
+ c = load_class_from_classloader(u, cl);
if (c == NULL)
return NULL;
if (!initialize_class(c))
return NULL;
- return LLNI_classinfo_wrap(c);
+ return (jclass) LLNI_classinfo_wrap(c);
}
jclass JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)
{
-#if PRINTJVM
- log_println("JVM_DefineClassWithSource: name=%s, loader=%p, buf=%p, len=%d, pd=%p, source=%s", name, loader, buf, len, pd, source);
-#endif
- /* XXX do something with pd and source */
+ classinfo *c;
+ utf *u;
+ classloader *cl;
+
+ TRACEJVMCALLS("JVM_DefineClassWithSource(env=%p, name=%s, loader=%p, buf=%p, len=%d, pd=%p, source=%s)", env, name, loader, buf, len, pd, source);
+
+ 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 */
- return LLNI_classinfo_wrap( class_define(utf_new_char(name), (classloader *) loader, len, (u1 *) buf) );
+ c = class_define(u, cl, len, (const uint8_t *) buf, (java_handle_t *) pd);
+ return (jclass) LLNI_classinfo_wrap(c);
}
utf *u;
classinfo *c;
- cl = (classloader *) loader;
+ TRACEJVMCALLS("JVM_FindLoadedClass(env=%p, loader=%p, name=%p)", env, loader, name);
-#if PRINTJVM
- log_println("JVM_FindLoadedClass(loader=%p, name=%p)", loader, name);
-#endif
+ cl = loader_hashtable_classloader_add((java_handle_t *) loader);
u = javastring_toutf((java_handle_t *) name, true);
c = classcache_lookup(cl, u);
- return LLNI_classinfo_wrap(c);
+ return (jclass) LLNI_classinfo_wrap(c);
}
jobject JVM_GetClassLoader(JNIEnv *env, jclass cls)
{
-#if PRINTJVM
- log_println("JVM_GetClassLoader: cls=%p", cls);
-#endif
- return (jobject) _Jv_java_lang_Class_getClassLoader((java_lang_Class *) cls);
+ classinfo *c;
+ classloader *cl;
+
+ TRACEJVMCALLS("JVM_GetClassLoader(env=%p, cls=%p)", env, cls);
+
+ c = LLNI_classinfo_unwrap(cls);
+ cl = class_get_classloader(c);
+
+ return (jobject) cl;
}
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);
}
{
classinfo *c;
-#if PRINTJVM || 1
- log_println("JVM_GetProtectionDomain: cls=%p");
-#endif
+ TRACEJVMCALLS("JVM_GetProtectionDomain(env=%p, cls=%p)", env, cls);
c = LLNI_classinfo_unwrap(cls);
if (class_is_primitive(c))
return NULL;
- return NULL;
+ return (jobject) c->protectiondomain;
}
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;
}
component = class_get_componenttype(c);
- return LLNI_classinfo_wrap(component);
+ return (jclass) LLNI_classinfo_wrap(component);
}
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;
}
jclass JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass)
{
- classinfo *c = LLNI_classinfo_unwrap(ofClass);
+ classinfo *c;
+ classinfo *dc;
- TRACEJVMCALLS("JVM_GetDeclaringClass: ofClass=%p", ofClass);
+ TRACEJVMCALLS("JVM_GetDeclaringClass(env=%p, ofClass=%p)", env, ofClass);
- if(c == NULL) {
- exceptions_throw_nullpointerexception();
- return NULL;
- }
+ c = LLNI_classinfo_unwrap(ofClass);
+
+ dc = class_get_declaringclass(c);
- return LLNI_classinfo_wrap(class_get_declaringclass(c));
+ return (jclass) LLNI_classinfo_wrap(dc);
}
jstring JVM_GetClassSignature(JNIEnv *env, jclass cls)
{
- log_println("JVM_GetClassSignature: IMPLEMENT ME!");
+ classinfo *c;
+ utf *u;
+ java_handle_t *s;
+
+ TRACEJVMCALLS("JVM_GetClassSignature(env=%p, cls=%p)", env, cls);
+
+ c = LLNI_classinfo_unwrap(cls);
+
+ /* Get the signature of the class. */
+
+ u = class_get_signature(c);
+
+ if (u == NULL)
+ return NULL;
+
+ /* Convert UTF-string to a Java-string. */
+
+ s = javastring_new(u);
+
+ return (jstring) s;
}
jbyteArray JVM_GetClassAnnotations(JNIEnv *env, jclass cls)
{
-#if defined(ENABLE_ANNOTATIONS)
- classinfo *c = LLNI_classinfo_unwrap(cls);
- 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);
exceptions_throw_nullpointerexception();
return NULL;
}
+
+ c = LLNI_classinfo_unwrap(cls);
- /* Return null for arrays and primitives: */
- if(class_is_primitive(c) || class_is_array(c))
- {
- return NULL;
- }
-
- if(c->annotations != NULL)
- {
- uint32_t size = c->annotations->size;
- annotations = builtin_newarray_byte(size);
-
- if(annotations != NULL)
- {
- MCOPY(annotations->data, c->annotations->data, uint8_t, size);
- }
- }
+ /* get annotations: */
+ annotations = class_get_annotations(c);
return (jbyteArray)annotations;
-#else
- log_println("JVM_GetClassAnnotations: cls=%p, not implemented in this configuration!", cls);
- return NULL;
-#endif
}
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;
{
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;
-
- TRACEJVMCALLS("JVM_GetClassConstantPool: cls=%p", cls);
+ /* constantPoolOop field of the constant pool object */
- assert(cls != NULL);
+ TRACEJVMCALLS("JVM_GetClassConstantPool(env=%p, cls=%p)", env, cls);
constantPool =
(sun_reflect_ConstantPool*)native_new_and_init(
return (jobject)constantPool;
#else
- log_println("JVM_GetClassConstantPool: cls=%p, not implemented in this configuration!", cls);
+ log_println("JVM_GetClassConstantPool(env=%p, cls=%p): not implemented in this configuration!", env, cls);
return NULL;
#endif
}
jint JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool)
{
- classinfo *cls = LLNI_classinfo_unwrap(jcpool);
- TRACEJVMCALLS("JVM_ConstantPoolGetSize: jcpool=%p", jcpool);
- return cls->cpcount;
+ 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);
+
+ c = LLNI_classinfo_unwrap(jcpool);
+
+ return c->cpcount;
}
jclass JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- constant_classref *ref;
- classinfo *cls = LLNI_classinfo_unwrap(jcpool);
-
- TRACEJVMCALLS("JVM_ConstantPoolGetClassAt: jcpool=%p, index=%d", jcpool, index);
+ 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(cls, index, CONSTANT_Class);
+ c = LLNI_classinfo_unwrap(jcpool);
+
+ ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return NULL;
}
- return LLNI_classinfo_wrap(resolve_classref_eager(ref));
+ result = resolve_classref_eager(ref);
+
+ return (jclass) LLNI_classinfo_wrap(result);
}
jclass JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)
{
- constant_classref *ref;
- classinfo *c = NULL;
- classinfo *cls = LLNI_classinfo_unwrap(jcpool);
+ 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: jcpool=%p, index=%d", jcpool, index);
+ TRACEJVMCALLS("JVM_ConstantPoolGetClassAtIfLoaded(env=%p, unused=%p, jcpool=%p, index=%d)", env, unused, jcpool, index);
- ref = (constant_classref*)class_getconstant(cls, index, CONSTANT_Class);
+ c = LLNI_classinfo_unwrap(jcpool);
+
+ ref = (constant_classref *) class_getconstant(c, index, CONSTANT_Class);
if (ref == NULL) {
+ exceptions_throw_illegalargumentexception();
return NULL;
}
- if (!resolve_classref(NULL, ref, resolveLazy, true, true, &c)) {
+ if (!resolve_classref(NULL, ref, resolveLazy, true, true, &result)) {
return NULL;
}
- if (c == NULL || !(c->state & CLASS_LOADED)) {
+ if ((result == NULL) || !(result->state & CLASS_LOADED)) {
return NULL;
}
- return LLNI_classinfo_wrap(c);
+ return (jclass) LLNI_classinfo_wrap(result);
}
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)
{
- log_println("JVM_DesiredAssertionStatus: cls=%p, IMPLEMENT ME!", cls);
+ TRACEJVMCALLS("JVM_DesiredAssertionStatus(env=%p, unused=%p, cls=%p)", env, unused, cls);
+
+ /* TODO: Implement this one, but false should be OK. */
return false;
}
java_handle_objectarray_t *classes;
java_handle_objectarray_t *packages;
-#if PRINTJVM || 1
- log_println("JVM_AssertionStatusDirectives");
-#endif
+ TRACEJVMCALLS("JVM_AssertionStatusDirectives(env=%p, unused=%p): COMPLETE ME!", env, unused);
+
/* XXX this is not completely implemented */
c = load_class_bootstrap(utf_new_char("java/lang/AssertionStatusDirectives"));
jint JVM_Available(jint fd, jlong *pbytes)
{
- TRACEJVMCALLS("JVM_Available(fd=%d, pbytes=%p)", fd, pbytes);
-
#if defined(FIONREAD)
int bytes;
+ TRACEJVMCALLS("JVM_Available(fd=%d, pbytes=%p)", fd, pbytes);
+
+ *pbytes = 0;
+
if (ioctl(fd, FIONREAD, &bytes) < 0)
return 0;
*pbytes = bytes;
return 1;
-#elif defined(HAVE_FSTAT)
- struct stat statBuffer;
- off_t n;
- int result;
-
- *pbytes = 0;
-
- if ((fstat(fd, &statBuffer) == 0) && S_ISREG (statBuffer.st_mode)) {
- n = lseek (fd, 0, SEEK_CUR);
-
- if (n != -1) {
- *pbytes = statBuffer.st_size - n;
- result = 1;
- }
- else {
- result = 0;
- }
- }
- else {
- result = 0;
- }
-
- return result;
-#elif defined(HAVE_SELECT)
- fd_set filedescriptset;
- struct timeval tv;
- int result;
-
- *pbytes = 0;
-
- FD_ZERO(&filedescriptset);
- FD_SET(fd, &filedescriptset);
- memset(&tv, 0, sizeof(tv));
-
- switch (select(fd+1, &filedescriptset, NULL, NULL, &tv))
- {
- case -1:
- result = errno;
- break;
- case 0:
- *pbytes = 0;
- result = CPNATIVE_OK;
- break;
- default:
- *pbytes = 1;
- result = CPNATIVE_OK;
- break;
- }
- return result;
#else
- *pbytes = 0;
- return 0;
+# error FIONREAD not defined
#endif
}
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
+ TRACEJVMCALLS("JVM_Lseek(fd=%d, offset=%ld, whence=%d)", fd, offset, whence);
+
return (jlong) 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 ftruncate(fd, length);
}
jint JVM_Sync(jint fd)
{
- log_println("JVM_Sync: IMPLEMENT ME!");
+ TRACEJVMCALLS("JVM_Sync(fd=%d)", fd);
+
+ return fsync(fd);
}
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_Yield(JNIEnv *env, jclass threadClass)
{
- log_println("JVM_Yield: IMPLEMENT ME!");
+ TRACEJVMCALLS("JVM_Yield(env=%p, threadClass=%p)", env, threadClass);
+
+ threads_yield();
}
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;
}
jobject JVM_CurrentClassLoader(JNIEnv *env)
{
+ /* XXX if a method in a class in a trusted loader is in a
+ doPrivileged, return NULL */
+
log_println("JVM_CurrentClassLoader: IMPLEMENT ME!");
}
jstring JVM_GetSystemPackage(JNIEnv *env, jstring name)
{
- log_println("JVM_GetSystemPackage(env=%p, name=%p)");
- javastring_print(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(name, false);
+ result = package_find(u);
+ if (result != NULL)
+ s = javastring_new(result);
+ else
+ s = NULL;
+
+ return (jstring) s;
}
jint JVM_GetArrayLength(JNIEnv *env, jobject arr)
{
- java_array_t *a;
+ java_handle_t *a;
TRACEJVMCALLS("JVM_GetArrayLength(arr=%p)", arr);
- a = (java_array_t *) arr;
-
- if (a == NULL) {
- exceptions_throw_nullpointerexception();
- return 0;
- }
-
- if (!class_is_array(a->objheader.vftbl->class)) {
-/* exceptions_throw_illegalargumentexception("Argument is not an array"); */
- exceptions_throw_illegalargumentexception();
- return 0;
- }
+ a = (java_handle_t *) arr;
- return a->size;
+ return array_length_get(a);
}
jobject JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index)
{
- vftbl_t *v;
java_handle_t *a;
- int elementtype;
- int32_t size;
+ java_handle_t *o;
TRACEJVMCALLS("JVM_GetArrayElement(env=%p, arr=%p, index=%d)", env, arr, index);
a = (java_handle_t *) arr;
- if (a == NULL) {
- exceptions_throw_nullpointerexception();
- return NULL;
- }
+/* if (!class_is_array(a->objheader.vftbl->class)) { */
+/* exceptions_throw_illegalargumentexception(); */
+/* return NULL; */
+/* } */
- v = LLNI_vftbl_direct(a);
+ o = array_element_get(a, index);
- if (!class_is_array(v->class)) {
- exceptions_throw_illegalargumentexception();
- return NULL;
- }
-
- size = LLNI_array_size(a);
-
- if (index < 0 || index >= size) {
- exceptions_throw_arrayindexoutofboundsexception();
- return NULL;
- }
-
- elementtype = v->arraydesc->elementtype;
-
- switch (elementtype) {
- case ARRAYTYPE_INT:
- return (jobject)primitive_box_int(array_intarray_element_get(a, index));
- case ARRAYTYPE_LONG:
- return (jobject)primitive_box_long(array_longarray_element_get(a, index));
- case ARRAYTYPE_FLOAT:
- return (jobject)primitive_box_float(array_floatarray_element_get(a, index));
- case ARRAYTYPE_DOUBLE:
- return (jobject)primitive_box_double(array_doublearray_element_get(a, index));
- case ARRAYTYPE_BYTE:
- return (jobject)primitive_box_byte(array_bytearray_element_get(a, index));
- case ARRAYTYPE_CHAR:
- return (jobject)primitive_box_char(array_chararray_element_get(a, index));
- case ARRAYTYPE_SHORT:
- return (jobject)primitive_box_short(array_shortarray_element_get(a, index));
- case ARRAYTYPE_BOOLEAN:
- return (jobject)primitive_box_boolean(array_booleanarray_element_get(a, index));
- case ARRAYTYPE_OBJECT:
- return (jobject)array_objectarray_element_get(a, index);
- default:
- /* invalid element type */
- vm_abort("array_element_primitive_get: invalid array element type %d",
- elementtype);
- return NULL;
- }
+ return (jobject) o;
}
void JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val)
{
- log_println("JVM_SetArrayElement: IMPLEMENT ME!");
+ java_handle_t *a;
+ java_handle_t *value;
+
+ TRACEJVMCALLS("JVM_SetArrayElement(env=%p, arr=%p, index=%d, val=%p)", env, arr, index, val);
+
+ a = (java_handle_t *) arr;
+ value = (java_handle_t *) val;
+
+ array_element_set(a, index, value);
}
TRACEJVMCALLS("JVM_NewArray(env=%p, eltClass=%p, length=%d)", env, eltClass, length);
+ if (eltClass == NULL) {
+ exceptions_throw_nullpointerexception();
+ return NULL;
+ }
+
+ /* NegativeArraySizeException is checked in builtin_newarray. */
+
c = LLNI_classinfo_unwrap(eltClass);
/* create primitive or object array */
jobject JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim)
{
- log_println("JVM_NewMultiArray: IMPLEMENT ME!");
+ classinfo *c;
+ java_handle_intarray_t *ia;
+ int32_t length;
+ long *dims;
+ int32_t value;
+ int32_t i;
+ classinfo *ac;
+ java_handle_objectarray_t *a;
+
+ TRACEJVMCALLS("JVM_NewMultiArray(env=%p, eltClass=%p, dim=%p)", env, eltClass, dim);
+
+ if (eltClass == NULL) {
+ exceptions_throw_nullpointerexception();
+ return NULL;
+ }
+
+ /* NegativeArraySizeException is checked in builtin_newarray. */
+
+ c = LLNI_classinfo_unwrap(eltClass);
+
+ /* XXX This is just a quick hack to get it working. */
+
+ ia = (java_handle_intarray_t *) dim;
+
+ length = array_length_get(ia);
+
+ dims = MNEW(long, length);
+
+ for (i = 0; i < length; i++) {
+ value = LLNI_array_direct(ia, i);
+ dims[i] = (long) value;
+ }
+
+ /* Create an array-class if necessary. */
+
+ if (class_is_primitive(c))
+ ac = primitive_arrayclass_get_by_name(c->name);
+ else
+ ac = class_array_of(c, true);
+
+ if (ac == NULL)
+ return NULL;
+
+ a = builtin_multianewarray(length, ac, dims);
+
+ return (jobject) a;
}
jint JVM_Socket(jint domain, jint type, jint protocol)
{
-#if PRINTJVM || 1
- log_println("JVM_Socket: domain=%d, type=%d, protocol=%d", domain, type, protocol);
-#endif
+ TRACEJVMCALLS("JVM_Socket(domain=%d, type=%d, protocol=%d)", domain, type, protocol);
+
return socket(domain, type, protocol);
}
jint JVM_SocketClose(jint fd)
{
-#if PRINTJVM || 1
- log_println("JVM_SocketClose: fd=%d", fd);
-#endif
+ TRACEJVMCALLS("JVM_SocketClose(fd=%d)", fd);
+
return close(fd);
}
jint JVM_SocketShutdown(jint fd, jint howto)
{
-#if PRINTJVM || 1
- log_println("JVM_SocketShutdown: fd=%d, howto=%d", fd, howto);
-#endif
+ TRACEJVMCALLS("JVM_SocketShutdown(fd=%d, howto=%d)", fd, howto);
+
return shutdown(fd, howto);
}
jint JVM_Listen(jint fd, jint count)
{
-#if PRINTJVM || 1
- log_println("JVM_Listen: fd=%d, count=%d", fd, count);
-#endif
+ TRACEJVMCALLS("JVM_Listen(fd=%d, count=%d)", fd, count);
+
return listen(fd, count);
}
jint JVM_Connect(jint fd, struct sockaddr *him, jint len)
{
-#if PRINTJVM || 1
- log_println("JVM_Connect: fd=%d, him=%p, len=%d", fd, him, len);
-#endif
+ TRACEJVMCALLS("JVM_Connect(fd=%d, him=%p, len=%d)", fd, him, len);
+
return connect(fd, him, len);
}
jint JVM_Accept(jint fd, struct sockaddr *him, jint *len)
{
-#if PRINTJVM || 1
- log_println("JVM_Accept: fd=%d, him=%p, len=%p", fd, him, len);
-#endif
+ TRACEJVMCALLS("JVM_Accept(fd=%d, him=%p, len=%p)", fd, him, len);
+
return accept(fd, him, (socklen_t *) len);
}
jint JVM_GetSockName(jint fd, struct sockaddr *him, int *len)
{
-#if PRINTJVM || 1
- log_println("JVM_GetSockName: fd=%d, him=%p, len=%p", fd, him, len);
-#endif
+ TRACEJVMCALLS("JVM_GetSockName(fd=%d, him=%p, len=%p)", fd, him, len);
+
return getsockname(fd, him, (socklen_t *) len);
}
jint JVM_SocketAvailable(jint fd, jint *pbytes)
{
- log_println("JVM_SocketAvailable: IMPLEMENT ME!");
+#if defined(FIONREAD)
+ int bytes;
+
+ TRACEJVMCALLS("JVM_SocketAvailable(fd=%d, pbytes=%p)", fd, pbytes);
+
+ *pbytes = 0;
+
+ if (ioctl(fd, FIONREAD, &bytes) < 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!");
+#if defined(HAVE_GETSOCKOPT)
+ TRACEJVMCALLS("JVM_GetSockOpt(fd=%d, level=%d, optname=%d, optval=%s, optlen=%p)", fd, level, optname, optval, optlen);
+
+ return getsockopt(fd, level, optname, optval, (socklen_t *) optlen);
+#else
+# error getsockopt not available
+#endif
}
jint JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen)
{
-#if PRINTJVM || 1
- log_println("JVM_SetSockOpt: fd=%d, level=%d, optname=%d, optval=%s, optlen=%d", fd, level, optname, optval, optlen);
-#endif
+#if defined(HAVE_SETSOCKOPT)
+ 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);
+#else
+# error setsockopt not available
+#endif
}
int JVM_GetHostName(char* name, int namelen)
{
-#if PRINTJVM || 1
- log_println("JVM_GetHostName: name=%s, namelen=%d", name, namelen);
-#endif
+ TRACEJVMCALLS("JVM_GetHostName(name=%s, namelen=%d)", name, namelen);
+
return gethostname(name, namelen);
}
/* JVM_LoadLibrary */
-void* JVM_LoadLibrary(const char* name)
+void *JVM_LoadLibrary(const char *name)
{
-#if PRINTJVM
- log_println("JVM_LoadLibrary: name=%s", name);
-#endif
- return native_library_open(utf_new_char(name));
+ utf *u;
+
+ TRACEJVMCALLS("JVM_LoadLibrary(name=%s)", name);
+
+ u = utf_new_char(name);
+
+ return native_library_open(u);
}
/* JVM_FindLibraryEntry */
-void* JVM_FindLibraryEntry(void* handle, const char* name)
+void *JVM_FindLibraryEntry(void *handle, const char *name)
{
lt_ptr symbol;
-#if PRINTJVM
- log_println("JVM_FindLibraryEntry: handle=%p, name=%s", handle, name);
-#endif
+ TRACEJVMCALLS("JVM_FindLibraryEntry(handle=%p, name=%s)", handle, name);
symbol = lt_dlsym(handle, name);
jboolean JVM_IsSupportedJNIVersion(jint version)
{
-#if PRINTJVM
- log_println("JVM_IsSupportedJNIVersion: version=%d", version);
-#endif
- switch (version) {
- case JNI_VERSION_1_1:
- case JNI_VERSION_1_2:
- case JNI_VERSION_1_4:
- return true;
- default:
- return false;
- }
+ TRACEJVMCALLS("JVM_IsSupportedJNIVersion(version=%d)", version);
+
+ return jni_version_check(version);
}
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;
}
jintArray JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState)
{
- log_println("JVM_GetThreadStateValues: IMPLEMENT ME!");
+ java_handle_intarray_t *ia;
+
+ TRACEJVMCALLS("JVM_GetThreadStateValues(env=%p, javaThreadState=%d)",
+ env, javaThreadState);
+
+ /* If new thread states are added in future JDK and VM versions,
+ this should check if the JDK version is compatible with thread
+ states supported by the VM. Return NULL if not compatible.
+
+ This function must map the VM java_lang_Thread::ThreadStatus
+ to the Java thread state that the JDK supports. */
+
+ switch (javaThreadState) {
+ case THREAD_STATE_NEW:
+ ia = builtin_newarray_int(1);
+
+ if (ia == NULL)
+ return NULL;
+
+ array_intarray_element_set(ia, 0, THREAD_STATE_NEW);
+ break;
+
+ case THREAD_STATE_RUNNABLE:
+ ia = builtin_newarray_int(1);
+
+ if (ia == NULL)
+ return NULL;
+
+ array_intarray_element_set(ia, 0, THREAD_STATE_RUNNABLE);
+ break;
+
+ case THREAD_STATE_BLOCKED:
+ ia = builtin_newarray_int(1);
+
+ if (ia == NULL)
+ return NULL;
+
+ array_intarray_element_set(ia, 0, THREAD_STATE_BLOCKED);
+ break;
+
+ case THREAD_STATE_WAITING:
+ ia = builtin_newarray_int(2);
+
+ if (ia == NULL)
+ return NULL;
+
+ array_intarray_element_set(ia, 0, THREAD_STATE_WAITING);
+ /* XXX Implement parked stuff. */
+/* array_intarray_element_set(ia, 1, PARKED); */
+ break;
+
+ case THREAD_STATE_TIMED_WAITING:
+ ia = builtin_newarray_int(3);
+
+ if (ia == NULL)
+ return NULL;
+
+ /* XXX Not sure about that one. */
+/* array_intarray_element_set(ia, 0, SLEEPING); */
+ array_intarray_element_set(ia, 0, THREAD_STATE_TIMED_WAITING);
+ /* XXX Implement parked stuff. */
+/* array_intarray_element_set(ia, 2, PARKED); */
+ break;
+
+ case THREAD_STATE_TERMINATED:
+ ia = builtin_newarray_int(1);
+
+ if (ia == NULL)
+ return NULL;
+
+ array_intarray_element_set(ia, 0, THREAD_STATE_TERMINATED);
+ break;
+
+ default:
+ /* Unknown state - probably incompatible JDK version */
+ return NULL;
+ }
+
+ return (jintArray) ia;
}
-/* JVM_GetThreadStateValues */
+/* JVM_GetThreadStateNames */
jobjectArray JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values)
{
- log_println("JVM_GetThreadStateValues: IMPLEMENT ME!");
+ java_handle_intarray_t *ia;
+ java_handle_objectarray_t *oa;
+ java_object_t *s;
+
+ TRACEJVMCALLS("JVM_GetThreadStateNames(env=%p, javaThreadState=%d, values=%p)",
+ env, javaThreadState, values);
+
+ ia = (java_handle_intarray_t *) values;
+
+ /* If new thread states are added in future JDK and VM versions,
+ this should check if the JDK version is compatible with thread
+ states supported by the VM. Return NULL if not compatible.
+
+ This function must map the VM java_lang_Thread::ThreadStatus
+ to the Java thread state that the JDK supports. */
+
+ if (values == NULL) {
+ exceptions_throw_nullpointerexception();
+ return NULL;
+ }
+
+ switch (javaThreadState) {
+ case THREAD_STATE_NEW:
+ assert(ia->header.size == 1 && ia->data[0] == THREAD_STATE_NEW);
+
+ oa = builtin_anewarray(1, class_java_lang_String);
+
+ if (oa == NULL)
+ return NULL;
+
+ s = javastring_new(utf_new_char("NEW"));
+
+ if (s == NULL)
+ return NULL;
+
+ array_objectarray_element_set(oa, 0, s);
+ break;
+
+ case THREAD_STATE_RUNNABLE:
+ oa = builtin_anewarray(1, class_java_lang_String);
+
+ if (oa == NULL)
+ return NULL;
+
+ s = javastring_new(utf_new_char("RUNNABLE"));
+
+ if (s == NULL)
+ return NULL;
+
+ array_objectarray_element_set(oa, 0, s);
+ break;
+
+ case THREAD_STATE_BLOCKED:
+ oa = builtin_anewarray(1, class_java_lang_String);
+
+ if (oa == NULL)
+ return NULL;
+
+ s = javastring_new(utf_new_char("BLOCKED"));
+
+ if (s == NULL)
+ return NULL;
+
+ array_objectarray_element_set(oa, 0, s);
+ break;
+
+ case THREAD_STATE_WAITING:
+ oa = builtin_anewarray(2, class_java_lang_String);
+
+ if (oa == NULL)
+ return NULL;
+
+ s = javastring_new(utf_new_char("WAITING.OBJECT_WAIT"));
+/* s = javastring_new(utf_new_char("WAITING.PARKED")); */
+
+ if (s == NULL)
+ return NULL;
+
+ array_objectarray_element_set(oa, 0, s);
+/* array_objectarray_element_set(oa, 1, s); */
+ break;
+
+ case THREAD_STATE_TIMED_WAITING:
+ oa = builtin_anewarray(3, class_java_lang_String);
+
+ if (oa == NULL)
+ return NULL;
+
+/* s = javastring_new(utf_new_char("TIMED_WAITING.SLEEPING")); */
+ s = javastring_new(utf_new_char("TIMED_WAITING.OBJECT_WAIT"));
+/* s = javastring_new(utf_new_char("TIMED_WAITING.PARKED")); */
+
+ if (s == NULL)
+ return NULL;
+
+/* array_objectarray_element_set(oa, 0, s); */
+ array_objectarray_element_set(oa, 0, s);
+/* array_objectarray_element_set(oa, 2, s); */
+ break;
+
+ case THREAD_STATE_TERMINATED:
+ oa = builtin_anewarray(1, class_java_lang_String);
+
+ if (oa == NULL)
+ return NULL;
+
+ s = javastring_new(utf_new_char("TERMINATED"));
+
+ if (s == NULL)
+ return NULL;
+
+ array_objectarray_element_set(oa, 0, s);
+ break;
+
+ default:
+ /* Unknown state - probably incompatible JDK version */
+ return NULL;
+ }
+
+ return (jobjectArray) oa;
}
/* OS: JVM_RegisterSignal */
-void* JVM_RegisterSignal(jint sig, void* handler)
+void *JVM_RegisterSignal(jint sig, void *handler)
{
- log_println("JVM_RegisterSignal: sig=%d, handler=%p, IMPLEMENT ME!", sig, handler);
- return NULL;
+ functionptr newHandler;
+
+ TRACEJVMCALLS("JVM_RegisterSignal(sig=%d, handler=%p)", sig, handler);
+
+ if (handler == (void *) 2)
+ newHandler = (functionptr) signal_thread_handler;
+ else
+ newHandler = (functionptr) (uintptr_t) handler;
+
+ switch (sig) {
+ case SIGILL:
+ case SIGFPE:
+ case SIGUSR1:
+ case SIGSEGV:
+ /* These signals are already used by the VM. */
+ return (void *) -1;
+
+ case SIGQUIT:
+ /* This signal is used by the VM to dump thread stacks unless
+ ReduceSignalUsage is set, in which case the user is allowed
+ to set his own _native_ handler for this signal; thus, in
+ either case, we do not allow JVM_RegisterSignal to change
+ the handler. */
+ return (void *) -1;
+
+ case SIGHUP:
+ case SIGINT:
+ case SIGTERM:
+ break;
+ }
+
+ signal_register_signal(sig, newHandler, 0);
+
+ /* XXX Should return old handler. */
+
+ return (void *) 2;
}
jboolean JVM_RaiseSignal(jint sig)
{
- log_println("JVM_RaiseSignal: sig=%s", sig);
+ log_println("JVM_RaiseSignal: IMPLEMENT ME! sig=%s", sig);
return false;
}
jint JVM_FindSignal(const char *name)
{
- log_println("JVM_FindSignal: name=%s", name);
- return 0;
+ TRACEJVMCALLS("JVM_FindSignal(name=%s)", name);
+
+#if defined(__LINUX__)
+ if (strcmp(name, "HUP") == 0)
+ return SIGHUP;
+
+ if (strcmp(name, "INT") == 0)
+ return SIGINT;
+
+ if (strcmp(name, "TERM") == 0)
+ return SIGTERM;
+#else
+# error not implemented for this OS
+#endif
+
+ return -1;
}
projects / cacao.git / blobdiff