[vmkit-commits] [PATCH] Implement a number of Java.sun.misc.Unsafe.* methods.
Nicolas Geoffray
nicolas.geoffray at gmail.com
Fri Nov 4 14:06:25 PDT 2011
Thanks Will for the new change. I have a few comments that I'd like you to
take into account before moving forward.
General comment: Please also update all places where we check for
isVMClassLoader (Jnjvm.cpp and JavaAOTCompiler.cpp) to also check for
isVMStaticInstance.
On Thu, Nov 3, 2011 at 3:19 PM, Will Dietz <wdietz2 at illinois.edu> wrote:
> Inlined below.
>
> Added a special class "VMStaticInstance" per our previous discussions.
>
> ~Will
>
> >From f2d553af8173b3615d06b059d5f70a35d5c02fa6 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Fri, 14 Oct 2011 06:07:15 -0500
> Subject: [PATCH 02/17] Implement a number of Java.sun.misc.Unsafe.*
> methods.
>
> Of particular interest is the addition of VMStaticInstance, used to
> enable us to return a reference to a static instance, even though a
> static instance isn't a heap object (and prevents the underlying
> static instance from being GC'd while this reference is live).
>
> This is required for us to support staticFieldBase/staticFieldOffset.
> ---
> lib/J3/ClassLib/Classpath.inc | 195
> +++++++++++++++++++++++++++++++++++-
> lib/J3/ClassLib/VMStaticInstance.h | 81 +++++++++++++++
> lib/J3/VMCore/Makefile | 2 +-
> lib/J3/VMCore/VirtualTables.cpp | 11 ++-
> 4 files changed, 285 insertions(+), 4 deletions(-)
> create mode 100644 lib/J3/ClassLib/VMStaticInstance.h
>
> diff --git a/lib/J3/ClassLib/Classpath.inc b/lib/J3/ClassLib/Classpath.inc
> index ccb9607..27fcb45 100644
> --- a/lib/J3/ClassLib/Classpath.inc
> +++ b/lib/J3/ClassLib/Classpath.inc
> @@ -15,12 +15,23 @@
> #include "JavaThread.h"
> #include "JavaUpcalls.h"
> #include "Jnjvm.h"
> +#include "Reader.h"
> +#include "VMStaticInstance.h"
>
>
> using namespace j3;
>
> extern "C" {
>
> +// Convert a 'base' JavaObject to its pointer representation.
> +// Handles our special VMStaticInstance wrapper.
> +static inline uint8 *baseToPtr(JavaObject *base) {
> + if (VMStaticInstance::isVMStaticInstance(base))
> + return (uint8*)((VMStaticInstance*)base)->getStaticInstance();
> + else
> + return (uint8*)base;
> +}
> +
> // Define hasClassInitializer because of a buggy implementation in
> Classpath.
> JNIEXPORT bool JNICALL
> Java_java_io_VMObjectStreamClass_hasClassInitializer(
> #ifdef NATIVE_JNI
> @@ -359,6 +370,186 @@ JavaObject* unsafe, JavaObject* obj, jlong
> offset, JavaObject* value) {
> mvm::Collector::objectReferenceWriteBarrier((gc*)obj, (gc**)ptr,
> (gc*)value);
> }
>
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_allocateMemory(
> +JavaObject* unsafe, jlong size) {
> + // TODO: Invalid size/OOM/etc handling!
> + jlong res = 0;
> + BEGIN_NATIVE_EXCEPTION(0)
> + res = (jlong)malloc(size);
> + END_NATIVE_EXCEPTION
> + return res;
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_freeMemory(
> +JavaObject* unsafe, jlong ptr) {
> + // TODO: Exception handling...
> + BEGIN_NATIVE_EXCEPTION(0)
> + free((void*)ptr);
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putLong__JJ(
> +JavaObject* unsafe, jlong ptr, jlong value) {
> + BEGIN_NATIVE_EXCEPTION(0)
> + *(jlong*)ptr = value;
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT jbyte JNICALL Java_sun_misc_Unsafe_getByte__J(
> +JavaObject* unsafe, jlong ptr) {
> + jbyte res = 0;
> + BEGIN_NATIVE_EXCEPTION(0)
> + res = *(jbyte*)ptr;
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_ensureClassInitialized(
> +JavaObject* unsafe, JavaObject* clazz) {
> + llvm_gcroot(unsafe, 0);
> + llvm_gcroot(clazz, 0);
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> +
> + CommonClass * cl = JavaObject::getClass(clazz);
> + assert(cl && cl->isClass());
>
You should add a cl->resolveClass(), because a java.lang.Class can be
created before the class is actually resolved.
+ cl->asClass()->initialiseClass(vm);
> +
> + END_NATIVE_EXCEPTION;
> +}
> +
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_staticFieldOffset(
> +JavaObject* unsafe, JavaObjectField* _field) {
> + llvm_gcroot(unsafe, 0);
> + llvm_gcroot(_field, 0);
> +
> + jlong res = 0;
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaField * field = JavaObjectField::getInternalField(_field);
> + assert(field);
> +
> + res = field->ptrOffset;
> +
> + END_NATIVE_EXCEPTION;
> +
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_staticFieldBase(
> +JavaObject* unsafe, JavaObjectField* _field) {
> + llvm_gcroot(unsafe, 0);
> + llvm_gcroot(_field, 0);
> + JavaObject* res = 0;
>
Add a llvm_gcroot(res, 0);
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaField * field = JavaObjectField::getInternalField(_field);
> + assert(field);
> + field->classDef->initialiseClass(JavaThread::get()->getJVM());
> +
> + void * staticInstance = field->classDef->getStaticInstance();
> + JnjvmClassLoader * JCL = field->classDef->classLoader;
> +
> + res = VMStaticInstance::allocate(JCL, staticInstance);
> +
> + END_NATIVE_EXCEPTION;
> +
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObjectVolatile(
> +JavaObject* unsafe, JavaObject* base, jlong offset) {
> + JavaObject * res = 0;
> + llvm_gcroot(unsafe, 0);
> + llvm_gcroot(base, 0);
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> + JavaObject** ptr = (JavaObject**) (baseToPtr(base) + offset);
> + res = *ptr;
> + END_NATIVE_EXCEPTION;
> +
> + return res;
> +}
> +
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayBaseOffset(
> +JavaObject* unsafe, JavaObject* clazz) {
> + // TODO: Implement me
>
Change to UNIMPLEMENTED() ?
> + return 0;
> +}
> +
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* clazz) {
> + // TODO: Implement me
>
Change to UNIMPLEMENTED()?
> + return 0;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL
>
> Java_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BIILjava_lang_ClassLoader_2Ljava_security_ProtectionDomain_2(
> +JavaObject* unsafe, JavaString *name, ArrayObject * bytesArr, jint
> off, jint len, JavaObject * loader, JavaObject * pd) {
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> + llvm_gcroot(unsafe, 0);
> + llvm_gcroot(name, 0);
> + llvm_gcroot(bytesArr, 0);
> + llvm_gcroot(loader, 0);
> + llvm_gcroot(pd, 0);
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + JnjvmClassLoader* JCL = NULL;
> + JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
> +
> + jint last = off + len;
> + if (last < bytesArr->size) {
> + assert(0 && "What exception to throw here?");
> + }
> + ClassBytes * bytes = new (JCL->allocator, len) ClassBytes(len);
> + memcpy(bytes->elements, JavaArray::getElements(bytesArr)+off, len);
> + const UTF8* utfName = JavaString::javaToInternal(name, JCL->hashUTF8);
> + UserClass *cl = JCL->constructClass(utfName, bytes);
> +
> + if (cl) res = (JavaObject*)cl->getClassDelegatee(vm);
> +
> + END_NATIVE_EXCEPTION;
> +
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_sun_misc_Unsafe_allocateInstance__Ljava_lang_Class_2(
> +JavaObject* unsafe, JavaObjectClass * clazz) {
> + JavaObject* res = 0;
> + llvm_gcroot(unsafe, 0);
> + llvm_gcroot(clazz, 0);
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaThread* th = JavaThread::get();
> + Jnjvm* vm = th->getJVM();
> +
> + UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, clazz,
> true);
> + if (cl->isClass())
> + res = cl->asClass()->doNew(vm);
> +
> + END_NATIVE_EXCEPTION;
> +
> + return res;
> +}
> +
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_throwException(
> +JavaObject* unsafe, JavaObject * obj) {
> + llvm_gcroot(unsafe, 0);
> + llvm_gcroot(obj, 0);
> +
> + JavaThread::get()->pendingException = obj;
>
This should be JavaThread::get()->throwException(obj) (with my latest
changes)
> +}
> +
> JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
> // Nothing
> }
> @@ -369,7 +560,7 @@ JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get
> ## Type ## __Ljava_lang_Object_
> JavaObject* unsafe, JavaObject* base, jlong offset) { \
> jtype res = 0; \
> BEGIN_NATIVE_EXCEPTION(0) \
> - jtype* ptr = (jtype*) (((uint8 *) base) + offset); \
> + jtype* ptr = (jtype*) (baseToPtr(base) + offset); \
> res = *ptr; \
> END_NATIVE_EXCEPTION \
> \
> @@ -379,7 +570,7 @@ JavaObject* unsafe, JavaObject* base, jlong offset) { \
> JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##
> __Ljava_lang_Object_2J ## shorttype( \
> JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
> BEGIN_NATIVE_EXCEPTION(0) \
> - jtype* ptr = (jtype*) (((uint8 *) base) + offset); \
> + jtype* ptr = (jtype*) (baseToPtr(base) + offset); \
> *ptr = val; \
> END_NATIVE_EXCEPTION \
> }
> diff --git a/lib/J3/ClassLib/VMStaticInstance.h
> b/lib/J3/ClassLib/VMStaticInstance.h
> new file mode 100644
> index 0000000..9f62062
> --- /dev/null
> +++ b/lib/J3/ClassLib/VMStaticInstance.h
> @@ -0,0 +1,81 @@
> +//===-------- VMStaticInstance.h - Java wrapper for a static
> instance------===//
> +//
> +// The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef JNJVM_VMSTATICINSTANCE_H
> +#define JNJVM_VMSTATICINSTANCE_H
> +
> +#include "JavaObject.h"
> +#include "JnjvmClassLoader.h"
> +
> +namespace j3 {
> +
> +/// VMStaticInstance - Wraps a staticInstance, tracing to the creating
> +/// ClassLoader to ensure the staticInstance and it's Class don't get
> +/// improperly GC'd.
> +/// Largely inspired by VMClassLoader.
> +///
> +class VMStaticInstance : public JavaObject {
> +private:
> + /// JCL - The classloader that created this static instance's class
> + ///
> + JnjvmClassLoader* JCL;
> +
> + /// staticInstance - The static instance wrapped by this object
> + ///
> + void * staticInstance;
>
Could you just have one field instead, that contains the Class?
> +
> +public:
> +
> + static VMStaticInstance* allocate(JnjvmClassLoader * JCL, void *
> staticInstance) {
> + VMStaticInstance* res = 0;
> + llvm_gcroot(res, 0);
> + res = (VMStaticInstance*)gc::operator new(sizeof(VMStaticInstance),
> &VT);
> + res->staticInstance = staticInstance;
> + res->JCL = JCL;
> + return res;
> + }
> +
> + /// VT - The VirtualTable for this GC-class.
> + ///
> + static VirtualTable VT;
> +
> + /// Is the object a VMStaticInstance object?
> + ///
> + static bool isVMStaticInstance(JavaObject* obj) {
> + llvm_gcroot(obj, 0);
> + return obj->getVirtualTable() == &VT;
> + }
> +
> + /// ~VMStaticInstance - Nothing. Placeholder method
> + /// to give the VirtualTable.
> + ///
> + static void staticDestructor(VMStaticInstance* obj) {
> + llvm_gcroot(obj, 0);
> + // Nothing to do here
> + }
> +
> + /// staticTracer - Trace the classloader that created
> + /// the underlying staticInstance
> + ///
> + static void staticTracer(VMStaticInstance* obj, word_t closure) {
> + llvm_gcroot(obj, 0);
> + if (obj->JCL != NULL) obj->JCL->tracer(closure);
> + }
> +
> + /// getStaticInstance - Get the static instance contained in this object
> + ///
> + void * getStaticInstance() {
> + return staticInstance;
> + }
> +
> +};
> +
> +}
> +
> +#endif // JNJVM_VMSTATICINSTANCE_H
> diff --git a/lib/J3/VMCore/Makefile b/lib/J3/VMCore/Makefile
> index fc07061..987919a 100644
> --- a/lib/J3/VMCore/Makefile
> +++ b/lib/J3/VMCore/Makefile
> @@ -14,4 +14,4 @@ MODULE_WITH_GC = J3
>
> include $(LEVEL)/Makefile.common
>
> -CXX.Flags += -I$(PROJ_OBJ_DIR)/../ClassLib
> -I$(PROJ_OBJ_DIR)/../LLVMRuntime
> -I$(PROJ_SRC_DIR)/../ClassLib/$(CLASSPATH_DIR)
> -I$(PROJ_SRC_DIR)/../../../include/j3
> +CXX.Flags += -I$(PROJ_OBJ_DIR)/../ClassLib
> -I$(PROJ_OBJ_DIR)/../LLVMRuntime
> -I$(PROJ_SRC_DIR)/../ClassLib/$(CLASSPATH_DIR)
> -I$(PROJ_SRC_DIR)/../../../include/j3 -I$(PROJ_SRC_DIR)/../ClassLib
> diff --git a/lib/J3/VMCore/VirtualTables.cpp
> b/lib/J3/VMCore/VirtualTables.cpp
> index 68774b7..6b3b999 100644
> --- a/lib/J3/VMCore/VirtualTables.cpp
> +++ b/lib/J3/VMCore/VirtualTables.cpp
> @@ -32,6 +32,7 @@
> #include "JnjvmClassLoader.h"
> #include "LockedMap.h"
> #include "ReferenceQueue.h"
> +#include "VMStaticInstance.h"
> #include "Zip.h"
>
> using namespace j3;
> @@ -44,7 +45,7 @@ using namespace j3;
> // Having many GC classes gives more work to the GC for the scanning phase
> // and for the relocation phase (for copying collectors).
> //
> -// In J3, there is only one internal gc object, the class loader.
> +// In J3, there is only one primary internal gc object, the class loader.
> // We decided that this was the best solution because
> // otherwise it would involve hacks on the java.lang.Classloader class.
> // Therefore, we create a new GC class with a finalize method that will
> @@ -52,12 +53,20 @@ using namespace j3;
> // not reachable anymore. This also relies on the java.lang.Classloader
> class
> // referencing an object of type VMClassLoader (this is the case in GNU
> // Classpath with the vmdata field).
> +// In addition, to handle support for sun.misc.Unsafe, we have a similar
> +// second clsas VMStaticInstance that wraps static instances for use
> +// in staticFieldBase and traces the owning ClassLoader to make sure
> +// the underlying instance and class don't get GC'd improperly.
>
> //===----------------------------------------------------------------------===//
>
> VirtualTable VMClassLoader::VT((word_t)VMClassLoader::staticDestructor,
> (word_t)VMClassLoader::staticDestructor,
> (word_t)VMClassLoader::staticTracer);
>
> +VirtualTable
> VMStaticInstance::VT((word_t)VMStaticInstance::staticDestructor,
> +
> (word_t)VMStaticInstance::staticDestructor,
> + (word_t)VMStaticInstance::staticTracer);
> +
>
> //===----------------------------------------------------------------------===//
> // Trace methods for Java objects. There are four types of objects:
> // (1) java.lang.Object and primitive arrays: no need to trace anything.
> --
> 1.7.5.1
> _______________________________________________
> vmkit-commits mailing list
> vmkit-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111104/a8cd2cb8/attachment.html>
More information about the vmkit-commits
mailing list