From nicolas.geoffray at gmail.com  Tue Nov  1 09:37:26 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 1 Nov 2011 17:37:26 +0100
Subject: [vmkit-commits] [PATCH] Add support for stack traces in OpenJDK
In-Reply-To: <CAKGWAO8VmbDYrN2iGu+h2_fV=GyDh2tiBi+j8=GUCfiyxDAxQg@mail.gmail.com>
References: <CAKGWAO-L_C0OH6wFJW8TP++ca5avBfN7NnAcOe3q3-rzg2Rsog@mail.gmail.com>
	<dd3b2fd5d5c84f3c96ad4490449e22b6@CITESHT4.ad.uillinois.edu>
	<CAKGWAO8VmbDYrN2iGu+h2_fV=GyDh2tiBi+j8=GUCfiyxDAxQg@mail.gmail.com>
Message-ID: <CAPYwfiqucNB9rW4-_cF3EtCYAEd+4C=g8+bD9Qzh9bYzENY1fA@mail.gmail.com>

On Tue, Nov 1, 2011 at 5:41 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> On Thu, Oct 27, 2011 at 4:19 PM, Nicolas Geoffray
> <nicolas.geoffray at gmail.com> wrote:
> >> +int JavaObjectThrowable::getStackTraceBase(JavaObjectThrowable * self)
> {
> >> +  if (!self->backtrace) return 0;
> >> +
> >> +  Jnjvm* vm = JavaThread::get()->getJVM();
> >> +
> >> +  JavaObject * stack = self->backtrace;
> >> +  llvm_gcroot(self, 0);
> >> +  llvm_gcroot(stack, 0);
> >
> > This is not written anywhere, but I usually follow the rule to declare GC
> > variables and llvm_gcroot as the first things in a method. This makes it
> > easier to review the code and find potential GC bugs.
> >
>
> Yep, sure thing. Fixed (in both spots mentioned)
>
> >> +  uint32 length = th->getFrameContextLength();
> >> +
> >> +  if (sizeof(void*) == 4)
> >
> > I know this probably comes from my code, but please use the macros
> ARCH_32
> > and ARCH_64 for these kinds of checks.
> >
>
> Fixed.
>
> >
> > Ah that's not true anymore :) Please remove the cl->getBytes() check.
>
> Sure thing.
>
> >> +
> >> +  sint32 cur = 0;
> >> +  for (sint32 i = base; i < JavaArray::getSize(stack); ++i) {
> >> +    intptr_t sp = ArrayPtr::getElement((ArrayPtr*)stack, i);
> >
> > sp -> ip
> >
>
> Fixed :).
>
> >>
> >> +    mvm::FrameInfo* FI = vm->IPToFrameInfo(sp);
> >> +    if (FI->Metadata != NULL) {
> >> +      if (cur == index) {
> >> +        result = consStackElement(FI, sp);
> >> +        break;
> >> +      }
> >> +      cur++;
> >> +    }
> >> +  }
> >
> > Maybe check that result is not null?
> >
>
> I'm not sure what you mean, sorry.  Would you mind elaborating?
>

It looks like the method *must* return a stack element, so we must make
sure result is not null. So I meant, maybe you should add an assert that
result is not null?


>
> Updated version inlined below, FWIW.
>
> ~Will
>
> From e04dad6e4322ba91e854c2ce7f7292f2476c89c3 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Fri, 28 Oct 2011 09:21:42 -0500
> Subject: [PATCH 1/8] Add OpenJDK support for stack traces
>
> ---
>  lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp |   55 +++++++++++-
>  lib/J3/ClassLib/OpenJDK/ClasspathReflect.h   |   19 ++--
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc          |  133
> +++++++++++++++++++++++++-
>  3 files changed, 194 insertions(+), 13 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
> b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
> index 74117ce..4842bb9 100644
> --- a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
> +++ b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
> @@ -11,6 +11,9 @@
>  #include "JavaClass.h"
>  #include "JavaObject.h"
>  #include "JavaThread.h"
> +#include "Jnjvm.h"
> +#include "JavaUpcalls.h"
> +#include "JavaArray.h"
>
>  namespace j3 {
>
> @@ -20,11 +23,61 @@ JavaMethod*
> JavaObjectConstructor::getInternalMethod(JavaObjectConstructor* self
>   return &(cls->asClass()->virtualMethods[self->slot]);
>  }
>
> -
>  JavaMethod* JavaObjectMethod::getInternalMethod(JavaObjectMethod* self) {
>   llvm_gcroot(self, 0);
>    UserCommonClass* cls = JavaObjectClass::getClass(self->clazz);
>    return &(cls->asClass()->virtualMethods[self->slot]);
>  }
>
> +
> +int JavaObjectThrowable::getStackTraceBase(JavaObjectThrowable * self) {
> +  JavaObject * stack = NULL;
> +  llvm_gcroot(self, 0);
> +  llvm_gcroot(stack, 0);
> +
> +  if (!self->backtrace) return 0;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +
> +  stack = self->backtrace;
> +  sint32 index = 2;;
> +  while (index != JavaArray::getSize(stack)) {
> +    mvm::FrameInfo* FI =
> vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
> +    if (FI->Metadata == NULL) ++index;
> +    else {
> +      JavaMethod* meth = (JavaMethod*)FI->Metadata;
> +      assert(meth && "Wrong stack trace");
> +      if (meth->classDef->isAssignableFrom(vm->upcalls->newThrowable)) {
> +        ++index;
> +      } else return index;
> +    }
> +  }
> +
> +  assert(0 && "Invalid stack trace!");
> +  return 0;
> +}
> +
> +int JavaObjectThrowable::getStackTraceDepth(JavaObjectThrowable * self) {
> +  JavaObject * stack = NULL;
> +  llvm_gcroot(self, 0);
> +  llvm_gcroot(stack, 0);
> +
> +  if (!self->backtrace) return 0;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +
> +  stack = self->backtrace;
> +  sint32 index = getStackTraceBase(self);
> +
> +  sint32 size = 0;
> +  sint32 cur = index;
> +  while (cur < JavaArray::getSize(stack)) {
> +    mvm::FrameInfo* FI =
> vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
> +    ++cur;
> +    if (FI->Metadata != NULL) ++size;
> +  }
> +
> +  return size;
> +}
> +
>  }
> diff --git a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
> b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
> index 7deecbe..0055a73 100644
> --- a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
> +++ b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
> @@ -17,6 +17,7 @@
>  #include "JavaThread.h"
>  #include "JavaString.h"
>
> +extern "C" j3::JavaObject* internalFillInStackTrace(j3::JavaObject*);
>  namespace j3 {
>
>  class JavaObjectClass : public JavaObject {
> @@ -262,18 +263,18 @@ public:
>      llvm_gcroot(self, 0);
>     llvm_gcroot(stackTrace, 0);
>
> -    // TODO: Implement this right
> -    assert(0 && "fillInStackTrace not implemented yet!");
> -
> -    // stackTrace = internalFillInStackTrace(self);
> -    // mvm::Collector::objectReferenceWriteBarrier(
> -    //     (gc*)self, (gc**)&(self->vmState), (gc*)stackTrace);
> +    stackTrace = internalFillInStackTrace(self);
> +    mvm::Collector::objectReferenceWriteBarrier(
> +        (gc*)self, (gc**)&(self->backtrace), (gc*)stackTrace);
>
> -    // mvm::Collector::objectReferenceWriteBarrier(
> -    //     (gc*)self, (gc**)&(self->cause), (gc*)self);
> +    mvm::Collector::objectReferenceWriteBarrier(
> +        (gc*)self, (gc**)&(self->cause), (gc*)self);
>
> -    // self->stackTrace = NULL;
> +    self->stackTrace = NULL;
>   }
> +
> +  static int getStackTraceDepth(JavaObjectThrowable * self);
> +  static int getStackTraceBase(JavaObjectThrowable * self);
>  };
>
>  class JavaObjectReference : public JavaObject {
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 31bd044..d9c1a78 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -22,6 +22,76 @@
>  #define NYI() \
>   do{ assert(0 && "Not yet implemented!"); abort(); } while(0)
>
> +JavaObject* internalFillInStackTrace(JavaObject* throwable) {
> +
> +  ArrayPtr* result = 0;
> +  llvm_gcroot(throwable, 0);
> +  llvm_gcroot(result, 0);
> +
> +  JavaThread* th = JavaThread::get();
> +  Jnjvm* vm = th->getJVM();
> +  assert(th);
> +  assert(vm);
> +
> +  uint32 length = th->getFrameContextLength();
> +
> +#ifdef ARCH_64
> +    ClassArray* cl = vm->upcalls->ArrayOfInt;
> +    result = (ArrayPtr*) cl->doNew(length, vm);
> +#else
> +    ClassArray* cl = vm->upcalls->ArrayOfLong;
> +    result = (ArrayPtr*) cl->doNew(length, vm);
> +#endif
> +
> +  // Don't call th->getFrameContext because it is not GC-safe.
> +  mvm::StackWalker Walker(th);
> +  uint32_t i = 0;
> +
> +  while (intptr_t ip = *Walker) {
> +    ArrayPtr::setElement(result, ip, i);
> +    ++i;
> +    ++Walker;
> +  }
> +
> +  return result;
> +}
> +
> +JavaObject* consStackElement(mvm::FrameInfo* FI, intptr_t ip) {
> +
> +  JavaString* methodName = 0;
> +  JavaString* className = 0;
> +  JavaString* sourceName = 0;
> +  JavaObject* res = 0;
> +  llvm_gcroot(methodName, 0);
> +  llvm_gcroot(className, 0);
> +  llvm_gcroot(sourceName, 0);
> +  llvm_gcroot(res, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JavaMethod* meth = (JavaMethod*)FI->Metadata;
> +  methodName = vm->internalUTF8ToStr(meth->name);
> +  Class* cl = meth->classDef;
> +  className = JavaString::internalToJava(cl->name, vm);
> +
> +  Attribut* sourceAtt = cl->lookupAttribut(Attribut::sourceFileAttribut);
> +
> +  if (sourceAtt) {
> +    Reader reader(sourceAtt, cl->bytes);
> +    uint16 index = reader.readU2();
> +    sourceName =
> vm->internalUTF8ToStr(cl->getConstantPool()->UTF8At(index));
> +  }
> +
> +  uint16 lineNumber = meth->lookupLineNumber(FI);
> +
> +  UserClass* newS = vm->upcalls->newStackTraceElement;
> +  res = newS->doNew(vm);
> +  vm->upcalls->initStackTraceElement->invokeIntSpecial(vm, newS, res,
> +                                                       &className,
> +                                                       &methodName,
> +                                                       &sourceName,
> +                                                       lineNumber);
> +  return res;
> +}
>
>  JNIEXPORT jint JNICALL
>  JVM_GetInterfaceVersion(void) {
> @@ -266,7 +336,17 @@ JVM_IsNaN(jdouble d) {
>   */
>  JNIEXPORT void JNICALL
>  JVM_FillInStackTrace(JNIEnv *env, jobject throwable) {
> -  NYI();
> +  JavaObjectThrowable * T = 0;
> +  llvm_gcroot(T, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  T = *(JavaObjectThrowable**)throwable;
> +  JavaObjectThrowable::fillInStackTrace(T);
> +
> +  RETURN_VOID_FROM_JNI;
> +
> +  END_JNI_EXCEPTION
>  }
>
>  JNIEXPORT void JNICALL
> @@ -276,12 +356,59 @@ JVM_PrintStackTrace(JNIEnv *env, jobject
> throwable, jobject printable) {
>
>  JNIEXPORT jint JNICALL
>  JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable) {
> -  NYI();
> +  JavaObjectThrowable * T = 0;
> +  llvm_gcroot(T, 0);
> +
> +  jint res = -1;
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  T = *(JavaObjectThrowable**)throwable;
> +  res = JavaObjectThrowable::getStackTraceDepth(T);
> +
> +  RETURN_FROM_JNI(res);
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jobject JNICALL
>  JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index) {
> -  NYI();
> +  JavaObjectThrowable * T = 0;
> +  JavaObject * result = 0;
> +  JavaObject * stack = 0;
> +  llvm_gcroot(T, 0);
> +  llvm_gcroot(result, 0);
> +  llvm_gcroot(stack, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  T = *(JavaObjectThrowable**)throwable;
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  stack = vm->upcalls->backtrace->getInstanceObjectField(T);
> +  verifyNull(stack);
> +
> +  sint32 base = JavaObjectThrowable::getStackTraceBase(T);
> +
> +  sint32 cur = 0;
> +  for (sint32 i = base; i < JavaArray::getSize(stack); ++i) {
> +    intptr_t ip = ArrayPtr::getElement((ArrayPtr*)stack, i);
> +    mvm::FrameInfo* FI = vm->IPToFrameInfo(ip);
> +    if (FI->Metadata != NULL) {
> +      if (cur == index) {
> +        result = consStackElement(FI, ip);
> +        break;
> +      }
> +      cur++;
> +    }
> +  }
> +
> +  RETURN_FROM_JNI((jobject)th->pushJNIRef(result));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /*
> --
> 1.7.5.1
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111101/86dc009f/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  1 09:39:28 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 1 Nov 2011 17:39:28 +0100
Subject: [vmkit-commits] [PATCH] Implement JVM_SetThreadPriority
In-Reply-To: <CAKGWAO9sVjjf62hbOhx4=EbBMn=N5NFX9DCz0KeeoYEAUSJjUg@mail.gmail.com>
References: <CAKGWAO9sVjjf62hbOhx4=EbBMn=N5NFX9DCz0KeeoYEAUSJjUg@mail.gmail.com>
Message-ID: <CAPYwfir8XjPe41w1=qzUz2izGkR5W68G4SnXX4wG4xRRpJ5quA@mail.gmail.com>

Looks good with one comment.

On Tue, Nov 1, 2011 at 5:41 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> ~Will
>
> >From ca5573058b469fe5868e7f807b1567252db848e2 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Mon, 31 Oct 2011 16:12:34 -0500
> Subject: [PATCH 2/8] Implement JVM_SetThreadPriority
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   14 +++++++++++++-
>  1 files changed, 13 insertions(+), 1 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index d9c1a78..0360894 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -479,7 +479,19 @@ JVM_ResumeThread(JNIEnv *env, jobject thread) {
>
>  JNIEXPORT void JNICALL
>  JVM_SetThreadPriority(JNIEnv *env, jobject thread, jint prio) {
> -  NYI();
> +  JavaObject * T;
> +  llvm_gcroot(thread, 0);
>

thread is not a GC object, it's a pointer to it. So you should never
llvm_gcroot it.


> +  llvm_gcroot(T, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  Jnjvm * vm = th->getJVM();
> +  T = *(JavaObject**)thread;
> +
> +  vm->upcalls->priority->setInstanceInt32Field(T, prio);
> +
> +  RETURN_VOID_FROM_JNI
> +  END_JNI_EXCEPTION
>  }
>
>  JNIEXPORT void JNICALL
> --
> 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/20111101/1f2419b8/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  1 09:43:26 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 1 Nov 2011 17:43:26 +0100
Subject: [vmkit-commits] [PATCH] Implement JVM_GetClassLoader
In-Reply-To: <CAKGWAO-U3jMn4KTF6Z3YLh6cO0OeDytcMhwTQfZW3tzN0mKwqg@mail.gmail.com>
References: <CAKGWAO-U3jMn4KTF6Z3YLh6cO0OeDytcMhwTQfZW3tzN0mKwqg@mail.gmail.com>
Message-ID: <CAPYwfiqzLzh6vbM=0D3CpnbmFewh7WOSHqN-Oht6bBmqHuunuw@mail.gmail.com>

Looks good!

On Tue, Nov 1, 2011 at 5:42 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> ~Will
>
> >From a8d486f49ea7a366a8d50b2db74a14fac66cbc25 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Mon, 31 Oct 2011 16:27:07 -0500
> Subject: [PATCH 3/8] Implement JVM_GetClassLoader
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   15 ++++++++++++++-
>  1 files changed, 14 insertions(+), 1 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 0360894..e0000f2 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -821,7 +821,20 @@ JVM_GetClassInterfaces(JNIEnv *env, jclass cls) {
>
>  JNIEXPORT jobject JNICALL
>  JVM_GetClassLoader(JNIEnv *env, jclass cls) {
> -  NYI();
> +  JavaObject * Cl = *(JavaObject**)cls;
> +  JavaObject * res = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(res, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +  res = cl->classLoader->getJavaClassLoader();
> +  RETURN_FROM_JNI((jobject)th->pushJNIRef(res));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jboolean JNICALL
> --
> 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/20111101/68600418/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  1 12:09:09 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 1 Nov 2011 20:09:09 +0100
Subject: [vmkit-commits] [PATCH] Don't abort in EnsureLocalCapacity,
 assume we have capacity
In-Reply-To: <CAKGWAO-rvVqXYNjFUDmVv1Voo1h-buQ5QdGVDnEqr8evT4fyjQ@mail.gmail.com>
References: <CAKGWAO-rvVqXYNjFUDmVv1Voo1h-buQ5QdGVDnEqr8evT4fyjQ@mail.gmail.com>
Message-ID: <CAPYwfirs0am9C59t0Au9E4douvk0T=Y1DLKzOdq28+9mwbBEqg@mail.gmail.com>

Looks good!

Alternatively, we could allocate space up front in the method, but I don't
think that's worth the trouble.

Nicolas

On Tue, Nov 1, 2011 at 5:53 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> The idea here is simply that we'll more or less always have capacity,
> and since we dynamically allocate new blocks of references (100 at a
> time) there's no meaningful way to check if we're at capacity.
>
> Thoughts welcome of course :).
>
> ~Will
>
> >From b40f02d173d5aeff6b5e68522ac5d8342f58c2c0 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Mon, 31 Oct 2011 16:36:17 -0500
> Subject: [PATCH 5/8] Don't abort in JNI EnsureLocalCapacity, assume we have
>  capacity.
>
> ---
>  lib/J3/VMCore/Jni.cpp |    3 +--
>  1 files changed, 1 insertions(+), 2 deletions(-)
>
> diff --git a/lib/J3/VMCore/Jni.cpp b/lib/J3/VMCore/Jni.cpp
> index 8f5a19f..6fceac6 100644
> --- a/lib/J3/VMCore/Jni.cpp
> +++ b/lib/J3/VMCore/Jni.cpp
> @@ -297,8 +297,7 @@ jobject NewLocalRef(JNIEnv *env, jobject ref) {
>
>
>  jint EnsureLocalCapacity(JNIEnv* env, jint capacity) {
> -  NYI();
> -  abort();
> +  // Assume we have capacity
>   return 0;
>  }
>
> --
> 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/20111101/6444c50a/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  1 12:25:43 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 1 Nov 2011 20:25:43 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_InternString, JVM_StartThread,
	JVM_IsThreadAlive
In-Reply-To: <CAKGWAO-Athf6=VdFNvq+LEygTF+iMJXXfJv5uxRKL+Rto_p8eQ@mail.gmail.com>
References: <CAKGWAO-Athf6=VdFNvq+LEygTF+iMJXXfJv5uxRKL+Rto_p8eQ@mail.gmail.com>
Message-ID: <CAPYwfiq7S2N0rNpB7NXpm0t8+UROkDzXuraYOWoOEU-R3mxz9Q@mail.gmail.com>

Looks good! Please commit.

On Tue, Nov 1, 2011 at 5:54 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> ~Will
>
> >From 0ed273dac8e45e630b292d52b6463b965d43f265 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Mon, 31 Oct 2011 22:16:10 -0500
> Subject: [PATCH 6/8] Impl JVM_InternString, JVM_StartThread,
>  JVM_IsThreadAlive
>
> ---
>  lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp |   21 -------
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc     |   95
> ++++++++++++++++++++++++++++++-
>  2 files changed, 92 insertions(+), 24 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> index d9fa7d7..43ff227 100644
> --- a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> +++ b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> @@ -367,27 +367,6 @@ extern "C" void
> Java_java_lang_ref_PhantomReference__0003Cinit_0003E__Ljava_lang
>   END_NATIVE_EXCEPTION
>  }
>
> -extern "C" JavaString*
> Java_java_lang_VMString_intern__Ljava_lang_String_2(
> -    JavaString* obj) {
> -  const ArrayUInt16* array = 0;
> -  JavaString* res = 0;
> -  llvm_gcroot(obj, 0);
> -  llvm_gcroot(array, 0);
> -  llvm_gcroot(res, 0);
> -  // If the string is already interned, just return.
> -  if (obj->getVirtualTable() == JavaString::internStringVT) return obj;
> -
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  array = JavaString::strToArray(obj, vm);
> -  res = vm->constructString(array);
> -
> -  END_NATIVE_EXCEPTION
> -
> -  return res;
> -}
> -
>  extern "C" JavaObject*
> Java_sun_reflect_Reflection_getCallerClass__I(uint32 index) {
>
>   JavaObject* res = 0;
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index e0000f2..e19bf96 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -165,7 +165,28 @@ JVM_Clone(JNIEnv *env, jobject obj) {
>  */
>  JNIEXPORT jstring JNICALL
>  JVM_InternString(JNIEnv *env, jstring _str) {
> -  NYI();
> +  JavaString * str = *(JavaString**)_str;
> +  const ArrayUInt16* array = 0;
> +  JavaString * res = 0;
> +  llvm_gcroot(str, 0);
> +  llvm_gcroot(array, 0);
> +  llvm_gcroot(res, 0);
> +
> +  // If already intern'd, just return.
> +  if(str->getVirtualTable() == JavaString::internStringVT)
> +    return _str;
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  array = JavaString::strToArray(str, vm);
> +  res = vm->constructString(array);
> +
> +  RETURN_FROM_JNI((jstring)th->pushJNIRef(res))
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /*
> @@ -449,12 +470,67 @@ JVM_DisableCompiler(JNIEnv *env, jclass compCls) {
>   NYI();
>  }
>
> +void start(JavaThread* thread) {
> +
> +  JavaObject* javaThread = NULL;
> +  llvm_gcroot(javaThread, 0);
> +
> +  Jnjvm* vm = thread->getJVM();
> +
> +  // Wait some time to let the creator initialise this field
> +  while (thread->javaThread == NULL) {
> +    mvm::Thread::yield();
> +  }
> +
> +  javaThread = thread->javaThread;
> +  assert(javaThread && "Didn't fix the javaThread of a j3 thread");
> +
> +  // Ok, now that the thread is created we can set the the value of eetop
> +  // which points from the javaobject to our internal JavaThread
> +  vm->upcalls->eetop->setInstanceLongField(javaThread, (long)thread);
> +
> +  // If the thread is not a daemon, it is added to the list of threads to
> +  // wait until exit.
> +  bool isDaemon = vm->upcalls->daemon->getInstanceInt8Field(javaThread);
> +
> +  if (!isDaemon) {
> +    vm->threadSystem.enter();
> +  }
> +
> +  assert(javaThread->getVirtualTable());
> +  // Run the VMThread::run function
> +  vm->upcalls->runThread->invokeIntSpecial(vm,
> vm->upcalls->newThread, javaThread);
> +
> +  // Remove the thread from the list.
> +  if (!isDaemon) {
> +    vm->threadSystem.leave();
> +  }
> +}
>  /*
>  * java.lang.Thread
>  */
>  JNIEXPORT void JNICALL
>  JVM_StartThread(JNIEnv *env, jobject _thread) {
> -  NYI();
> +  JavaObject * thread = 0;
> +  JavaThread * javaThread = 0;
> +  llvm_gcroot(thread, 0);
> +  llvm_gcroot(javaThread, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  thread = *(JavaObject**)_thread;
> +  assert(thread);
> +  assert(thread->getVirtualTable());
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +
> +  JavaThread * newTh = new JavaThread(vm);
> +  if (!newTh) vm->outOfMemoryError();
> +  newTh->start((void (*)(mvm::Thread*))start);
> +
> +  newTh->initialise(thread, 0);
> +
> +  RETURN_VOID_FROM_JNI
> +
> +  END_JNI_EXCEPTION
>  }
>
>  JNIEXPORT void JNICALL
> @@ -464,7 +540,20 @@ JVM_StopThread(JNIEnv *env, jobject thread,
> jobject exception) {
>
>  JNIEXPORT jboolean JNICALL
>  JVM_IsThreadAlive(JNIEnv *env, jobject _thread) {
> -  NYI();
> +  BEGIN_JNI_EXCEPTION
> +  JavaObject * thread = *(JavaObject**)_thread;
> +  llvm_gcroot(thread, 0);
> +  assert(thread);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  jint status = vm->upcalls->threadStatus->getInstanceInt32Field(thread);
> +
> +  // TODO: We don't actually maintain 'status'...
> +  RETURN_FROM_JNI(status != 0);
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT void JNICALL
> --
> 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/20111101/5833b936/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  1 12:27:17 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 1 Nov 2011 20:27:17 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_DoPrivileged,
	no actual protection.
In-Reply-To: <CAKGWAO8g=KsrLQ3YH4n2cejLnOp0bRvXM63zR-XFOQxSbRVmSw@mail.gmail.com>
References: <CAKGWAO8g=KsrLQ3YH4n2cejLnOp0bRvXM63zR-XFOQxSbRVmSw@mail.gmail.com>
Message-ID: <CAPYwfirzdgeOJgu26OEwp4gVdDxD_F2Ek571Mxpbkv7pmD5f2Q@mail.gmail.com>

Looks good. We're not security freaks (yet) :)

On Tue, Nov 1, 2011 at 5:58 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> For now, dodge the implementation of anything actually secure, and put
> a working implementation in the code since it's used a fair amount
> while bootstrapping OpenJDK.
>
> ~Will
>
> >From 8cc1f086eb2ae50a0257fff04c5b704fb648ce0a Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Mon, 31 Oct 2011 16:37:26 -0500
> Subject: [PATCH 8/8] Impl JVM_DoPrivileged, no actual protection.
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   34
> +++++++++++++++++++++++++++++++---
>  1 files changed, 31 insertions(+), 3 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index fc4663c..cc8c3a4 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -1141,18 +1141,46 @@ JNIEXPORT jstring JNICALL JVM_ConstantPoolGetUTF8At
>  JNIEXPORT jobject JNICALL
>  JVM_DoPrivileged(JNIEnv *env, jclass cls,
>                  jobject action, jobject context, jboolean wrapException) {
> -  NYI();
> +  JavaObject * obj = 0;
> +  JavaObject * res = 0;
> +  llvm_gcroot(obj, 0);
> +  llvm_gcroot(res, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  verifyNull(action);
> +
> +  obj = *(JavaObject**)action;
> +
> +  Jnjvm* vm = th->getJVM();
> +
> +  // For now, we don't do anything special,
> +  // just call the requested 'run()' method...
> +  UserClass * cl = JavaObject::getClass(obj)->asClass();
> +  const UTF8 * runName = cl->classLoader->hashUTF8->lookupAsciiz("run");
> +  const UTF8 * runType =
> cl->classLoader->hashUTF8->lookupAsciiz("()Ljava/lang/Object;");
> +  assert(cl); assert(runName); assert(runType);
> +
> +  JavaMethod * meth = cl->lookupMethodDontThrow(runName, runType,
> false, true, 0);
> +  assert(meth);
> +
> +  res = meth->invokeJavaObjectVirtual(vm, cl, obj, obj);
> +
> +  RETURN_FROM_JNI((jobject)th->pushJNIRef(res));
> +
> +  END_JNI_EXCEPTION
>  }
>
>  JNIEXPORT jobject JNICALL
>  JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls) {
> -  NYI();
> +  // No AccessControlContext supported yet
> +  return NULL;
>  }
>
>
>  JNIEXPORT jobject JNICALL
>  JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls) {
> -  NYI();
> +  // No AccessControlContext supported yet
> +  return NULL;
>  }
>
>  /*
> --
> 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/20111101/4d485ceb/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  1 12:30:37 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 1 Nov 2011 20:30:37 +0100
Subject: [vmkit-commits] [PATCH] Move ArrayCopy to new 'Shared.inc',
 use in both CP and OJ.
In-Reply-To: <CAKGWAO-FyL+ACwGFatg+cKwdc4Z6YAUnjVWNmTMRbg10uANQoA@mail.gmail.com>
References: <CAKGWAO-FyL+ACwGFatg+cKwdc4Z6YAUnjVWNmTMRbg10uANQoA@mail.gmail.com>
Message-ID: <CAPYwfioDffAjLZ+-8SuiDBKfeCRnz6fkaqRwtuYWv=_=d_zz2g@mail.gmail.com>

Could you name the file ArrayCopy.inc instead? I'm fine with having it in
lib/J3ClassLib, like you have done for SetProperties.inc. So I think you
should continue doing with with shared files whose names describe what's in
it.

Otherwise, the change looks good.

On Tue, Nov 1, 2011 at 6:01 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Almost entirely a minor refactoring patch, FWIW.
>
> I'm not particular about where to put the common code (thoughts
> welcome), but "Shared.inc" seemed as good as any for the place to put
> shared ClassLib code that isn't already in its own neat file.
>
> Thanks!
>
> ~Will
>
> >From eb5a72d6de2bfd98e44e4bb0729954b29b4411a6 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Thu, 27 Oct 2011 17:30:41 -0500
> Subject: [PATCH 7/8] Move ArrayCopy to new 'Shared.inc', use in both CP and
>  OJ.
>
> ---
>  lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc |   72
> +-----------------
>  lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp       |    1 +
>  lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp            |    1 +
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc                |   17 ++++-
>  lib/J3/ClassLib/Shared.inc                         |   82
> ++++++++++++++++++++
>  5 files changed, 101 insertions(+), 72 deletions(-)
>  create mode 100644 lib/J3/ClassLib/Shared.inc
>
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc
> index 187bfa5..05469ed 100644
> --- a/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc
> @@ -30,77 +30,7 @@ jint sstart,
>  JavaObject* dst,
>  jint dstart,
>  jint len) {
> -
> -  JavaObject* cur = 0;
> -  llvm_gcroot(src, 0);
> -  llvm_gcroot(dst, 0);
> -  llvm_gcroot(cur, 0);
> -  assert(src->getVirtualTable());
> -  assert(dst->getVirtualTable());
> -
> -  JavaThread* th = JavaThread::get();
> -  Jnjvm *vm = th->getJVM();
> -
> -  if (src == NULL || dst == NULL) {
> -    th->throwException(vm->CreateNullPointerException());
> -    UNREACHABLE();
> -  }
> -
> -  if (!(JavaObject::getClass(src)->isArray() &&
> -        JavaObject::getClass(dst)->isArray())) {
> -    th->throwException(vm->CreateArrayStoreException(
> -      (JavaVirtualTable*)dst->getVirtualTable()));
> -    UNREACHABLE();
> -  }
> -
> -  UserClassArray* ts = (UserClassArray*)JavaObject::getClass(src);
> -  UserClassArray* td = (UserClassArray*)JavaObject::getClass(dst);
> -  UserCommonClass* dstType = td->baseClass();
> -  UserCommonClass* srcType = ts->baseClass();
> -
> -  sint32 srcSize = JavaArray::getSize(src);
> -  sint32 dstSize = JavaArray::getSize(dst);
> -
> -  if (len > srcSize) {
> -    th->throwException(vm->CreateIndexOutOfBoundsException(len));
> -  } else if (len > dstSize) {
> -    th->throwException(vm->CreateIndexOutOfBoundsException(len));
> -  } else if (len + sstart > srcSize) {
> -    th->throwException(vm->CreateIndexOutOfBoundsException(len + sstart));
> -  } else if (len + dstart > dstSize) {
> -    th->throwException(vm->CreateIndexOutOfBoundsException(len + dstart));
> -  } else if (dstart < 0) {
> -    th->throwException(vm->CreateIndexOutOfBoundsException(dstart));
> -  } else if (sstart < 0) {
> -    th->throwException(vm->CreateIndexOutOfBoundsException(sstart));
> -  } else if (len < 0) {
> -    th->throwException(vm->CreateIndexOutOfBoundsException(len));
> -  } else if ((dstType->isPrimitive() || srcType->isPrimitive()) &&
> -             srcType != dstType) {
> -    th->throwException(vm->CreateArrayStoreException(
> -      (JavaVirtualTable*)dst->getVirtualTable()));
> -  }
> -
> -  if (!(dstType->isPrimitive())) {
> -    for (int i = 0; i < len; i++) {
> -      cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);
> -      if (cur) {
> -        if (!(JavaObject::getClass(cur)->isAssignableFrom(dstType))) {
> -          th->throwException(vm->CreateArrayStoreException(
> -              (JavaVirtualTable*)dst->getVirtualTable()));
> -          break;
> -        } else {
> -          ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);
> -        }
> -      }
> -    }
> -  } else {
> -    uint32 logSize = dstType->asPrimitiveClass()->logSize;
> -    void* ptrDst = (void*)((int64_t)JavaArray::getElements(dst) +
> (dstart << logSize));
> -    void* ptrSrc = (void*)((int64_t)JavaArray::getElements(src) +
> (sstart << logSize));
> -    memmove(ptrDst, ptrSrc, len << logSize);
> -  }
> -
> +  Shared_ArrayCopy(src, sstart, dst, dstart, len);
>  }
>
>  JNIEXPORT jint JNICALL Java_java_lang_VMSystem_identityHashCode(
> diff --git a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> index bc797d1..bb47192 100644
> --- a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> +++ b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> @@ -1075,6 +1075,7 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {
>  #include "Classpath.inc"
>  #include "ClasspathField.inc"
>  #include "ClasspathMethod.inc"
> +#include "Shared.inc"
>  #include "ClasspathVMClass.inc"
>  #include "ClasspathVMClassLoader.inc"
>  #include "ClasspathVMObject.inc"
> diff --git a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> index 43ff227..a9d8c73 100644
> --- a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> +++ b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> @@ -901,4 +901,5 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {
>  #include "Classpath.inc"
>  #include "ClasspathField.inc"
>  #include "ClasspathMethod.inc"
> +#include "Shared.inc"
>  #include "OpenJDK.inc"
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index e19bf96..fc4663c 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -215,7 +215,22 @@ JVM_NanoTime(JNIEnv *env, jclass ignored) {
>  JNIEXPORT void JNICALL
>  JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject jsrc, jint sstart,
>               jobject jdst, jint dstart, jint len) {
> -  NYI();
> +  JavaObject *src = 0;
> +  JavaObject *dst = 0;
> +  JavaObject* cur = 0;
> +  llvm_gcroot(src, 0);
> +  llvm_gcroot(dst, 0);
> +  llvm_gcroot(cur, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  src = *(JavaObject**)jsrc;
> +  dst = *(JavaObject**)jdst;
> +
> +  Shared_ArrayCopy(src, sstart, dst, dstart, len);
> +
> +  RETURN_VOID_FROM_JNI
> +  END_JNI_EXCEPTION
>  }
>
>  JNIEXPORT jobject JNICALL
> diff --git a/lib/J3/ClassLib/Shared.inc b/lib/J3/ClassLib/Shared.inc
> new file mode 100644
> index 0000000..f4d987e
> --- /dev/null
> +++ b/lib/J3/ClassLib/Shared.inc
> @@ -0,0 +1,82 @@
> +//===-- Shared.inc - Code common from ClassLib implementations
> ------------===//
> +//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +
> +void Shared_ArrayCopy(JavaObject* src, jint sstart, JavaObject* dst,
> jint dstart, jint len)
> +{
> +  JavaObject* cur = 0;
> +  llvm_gcroot(src, 0);
> +  llvm_gcroot(dst, 0);
> +  llvm_gcroot(cur, 0);
> +  assert(src->getVirtualTable());
> +  assert(dst->getVirtualTable());
> +
> +  JavaThread* th = JavaThread::get();
> +  Jnjvm *vm = th->getJVM();
> +
> +  if (src == NULL || dst == NULL) {
> +    th->throwException(vm->CreateNullPointerException());
> +    UNREACHABLE();
> +  }
> +
> +  if (!(JavaObject::getClass(src)->isArray() &&
> +        JavaObject::getClass(dst)->isArray())) {
> +    th->throwException(vm->CreateArrayStoreException(
> +      (JavaVirtualTable*)dst->getVirtualTable()));
> +    UNREACHABLE();
> +  }
> +
> +  UserClassArray* ts = (UserClassArray*)JavaObject::getClass(src);
> +  UserClassArray* td = (UserClassArray*)JavaObject::getClass(dst);
> +  UserCommonClass* dstType = td->baseClass();
> +  UserCommonClass* srcType = ts->baseClass();
> +
> +  sint32 srcSize = JavaArray::getSize(src);
> +  sint32 dstSize = JavaArray::getSize(dst);
> +
> +  if (len > srcSize) {
> +    th->throwException(vm->CreateIndexOutOfBoundsException(len));
> +  } else if (len > dstSize) {
> +    th->throwException(vm->CreateIndexOutOfBoundsException(len));
> +  } else if (len + sstart > srcSize) {
> +    th->throwException(vm->CreateIndexOutOfBoundsException(len + sstart));
> +  } else if (len + dstart > dstSize) {
> +    th->throwException(vm->CreateIndexOutOfBoundsException(len + dstart));
> +  } else if (dstart < 0) {
> +    th->throwException(vm->CreateIndexOutOfBoundsException(dstart));
> +  } else if (sstart < 0) {
> +    th->throwException(vm->CreateIndexOutOfBoundsException(sstart));
> +  } else if (len < 0) {
> +    th->throwException(vm->CreateIndexOutOfBoundsException(len));
> +  } else if ((dstType->isPrimitive() || srcType->isPrimitive()) &&
> +             srcType != dstType) {
> +    th->throwException(vm->CreateArrayStoreException(
> +      (JavaVirtualTable*)dst->getVirtualTable()));
> +  }
> +
> +  if (!(dstType->isPrimitive())) {
> +    for (int i = 0; i < len; i++) {
> +      cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);
> +      if (cur) {
> +        if (!(JavaObject::getClass(cur)->isAssignableFrom(dstType))) {
> +          th->throwException(vm->CreateArrayStoreException(
> +              (JavaVirtualTable*)dst->getVirtualTable()));
> +          break;
> +        } else {
> +          ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);
> +        }
> +      }
> +    }
> +  } else {
> +    uint32 logSize = dstType->asPrimitiveClass()->logSize;
> +    void* ptrDst = (void*)((int64_t)JavaArray::getElements(dst) +
> (dstart << logSize));
> +    void* ptrSrc = (void*)((int64_t)JavaArray::getElements(src) +
> (sstart << logSize));
> +    memmove(ptrDst, ptrSrc, len << logSize);
> +  }
> +}
> --
> 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/20111101/6df510df/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  1 12:45:49 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 1 Nov 2011 20:45:49 +0100
Subject: [vmkit-commits] [PATCH] OpenJDK threading: initialize fields
In-Reply-To: <CAKGWAO9HaTGuzUkun7_GQa40M8mBpuo68b-NHG8ot738=f_HXQ@mail.gmail.com>
References: <CAKGWAO9HaTGuzUkun7_GQa40M8mBpuo68b-NHG8ot738=f_HXQ@mail.gmail.com>
Message-ID: <CAPYwfiq56pF91Ys_5aMs+B0at2PzHM0nu894NFY-2_qZ+4EENw@mail.gmail.com>

Hi Will,

I think the approach is fine here. I also had to make something that looks
unclean for GNU Classpath. But the creation of the main thread is something
special, that requires special handling. So patch looks good, feel free to
commit!

Nicolas

On Tue, Nov 1, 2011 at 6:11 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> The main thing is the small change to explicitly set the eetop field
> to the JavaThread.
>
> The reason we set the fields *before* calling the constructor is due
> to a bit of strangeness that probably needs some discussion.
>
> In the thread constructor, it defaults to setting the
> thread-being-constructed's priority and daemon status from what the
> parent thread has for those values.  The parent thread is determined
> by a call to JVM_CurrentThread.
>
> This is all well and good except when we're using CreateJavaThread to
> create the Thread for the currently-running main thread, since this
> means the constructor will try to use the values of the thread it's
> mid-creating to initialize itself with.  And of course it does sanity
> checks on those values and things don't work out well (turns out '0'
> is an invalid priority).
>
> I thought about making this specific to the main thread construction,
> but it doesn't seem worth it since in all other cases these values
> will be overridden happily immediately anyway.
>
> I understand this is a tad hacky, but the alternatives I thought of
> seemed worse (some kinda of placeholder parent-of-main thread whose
> sole purpose in existing is to fix this field initialization issue).
>
> As always thoughts very much welcome, and thank you for your time :).
>
> ~Will
>
> >From 2dc1fa5b0da33852cfca80b67e50967d0262709a Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Thu, 27 Oct 2011 19:29:48 -0500
> Subject: [PATCH 4/8] OpenJDK threading: intialize fields, set eeetop field.
>
> ---
>  lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp |    8 ++++++--
>  1 files changed, 6 insertions(+), 2 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> index 476b6e3..d9fa7d7 100644
> --- a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> +++ b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> @@ -235,12 +235,16 @@ void Classpath::CreateJavaThread(Jnjvm* vm,
> JavaThread* myth,
>
>   name = vm->asciizToStr(thName);
>
> +  // Initialize the values
> +  priority->setInstanceInt32Field(th, (uint32)5);
> +  daemon->setInstanceInt8Field(th, (uint32)false);
> +
>   // call Thread(ThreadGroup,String) constructor
>   initThread->invokeIntSpecial(vm, newThread, th, &Group, &name);
>
>   // Store reference to the JavaThread for this thread in the 'eetop' field
> -  // TODO: Don't do this until we have the tracing handled.
> -  // eetop->setInstanceLongField(th, (long)myth);
> +  // GC-safe since 'eetop' is of type 'long'
> +  eetop->setInstanceLongField(th, (long)myth);
>  }
>
>  void Classpath::InitializeThreading(Jnjvm* vm) {
> --
> 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/20111101/25673f7a/attachment.html>

From wdietz2 at illinois.edu  Tue Nov  1 13:06:06 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 01 Nov 2011 20:06:06 -0000
Subject: [vmkit-commits] [vmkit] r143479 - in
 /vmkit/trunk/lib/J3/ClassLib/OpenJDK: ClasspathReflect.cpp
 ClasspathReflect.h OpenJDK.inc
Message-ID: <20111101200607.044492A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  1 15:06:06 2011
New Revision: 143479

URL: http://llvm.org/viewvc/llvm-project?rev=143479&view=rev
Log:
Add OpenJDK support for stack traces

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp?rev=143479&r1=143478&r2=143479&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp Tue Nov  1 15:06:06 2011
@@ -11,6 +11,9 @@
 #include "JavaClass.h"
 #include "JavaObject.h"
 #include "JavaThread.h"
+#include "Jnjvm.h"
+#include "JavaUpcalls.h"
+#include "JavaArray.h"
 
 namespace j3 {
 
@@ -20,11 +23,61 @@
   return &(cls->asClass()->virtualMethods[self->slot]);
 }
 
-
 JavaMethod* JavaObjectMethod::getInternalMethod(JavaObjectMethod* self) {
   llvm_gcroot(self, 0);
   UserCommonClass* cls = JavaObjectClass::getClass(self->clazz);
   return &(cls->asClass()->virtualMethods[self->slot]);
 }
 
+
+int JavaObjectThrowable::getStackTraceBase(JavaObjectThrowable * self) {
+  JavaObject * stack = NULL;
+  llvm_gcroot(self, 0);
+  llvm_gcroot(stack, 0);
+
+  if (!self->backtrace) return 0;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+
+  stack = self->backtrace;
+  sint32 index = 2;;
+  while (index != JavaArray::getSize(stack)) {
+    mvm::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
+    if (FI->Metadata == NULL) ++index;
+    else {
+      JavaMethod* meth = (JavaMethod*)FI->Metadata;
+      assert(meth && "Wrong stack trace");
+      if (meth->classDef->isAssignableFrom(vm->upcalls->newThrowable)) {
+        ++index;
+      } else return index;
+    }
+  }
+
+  assert(0 && "Invalid stack trace!");
+  return 0;
+}
+
+int JavaObjectThrowable::getStackTraceDepth(JavaObjectThrowable * self) {
+  JavaObject * stack = NULL;
+  llvm_gcroot(self, 0);
+  llvm_gcroot(stack, 0);
+
+  if (!self->backtrace) return 0;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+
+  stack = self->backtrace;
+  sint32 index = getStackTraceBase(self);
+
+  sint32 size = 0;
+  sint32 cur = index;
+  while (cur < JavaArray::getSize(stack)) {
+    mvm::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
+    ++cur;
+    if (FI->Metadata != NULL) ++size;
+  }
+
+  return size;
+}
+
 }

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h?rev=143479&r1=143478&r2=143479&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h Tue Nov  1 15:06:06 2011
@@ -17,6 +17,7 @@
 #include "JavaThread.h"
 #include "JavaString.h"
 
+extern "C" j3::JavaObject* internalFillInStackTrace(j3::JavaObject*);
 namespace j3 {
 
 class JavaObjectClass : public JavaObject {
@@ -262,18 +263,18 @@
     llvm_gcroot(self, 0);
     llvm_gcroot(stackTrace, 0);
 
-    // TODO: Implement this right
-    assert(0 && "fillInStackTrace not implemented yet!");
-
-    // stackTrace = internalFillInStackTrace(self);
-    // mvm::Collector::objectReferenceWriteBarrier(
-    //     (gc*)self, (gc**)&(self->vmState), (gc*)stackTrace);
+    stackTrace = internalFillInStackTrace(self);
+    mvm::Collector::objectReferenceWriteBarrier(
+        (gc*)self, (gc**)&(self->backtrace), (gc*)stackTrace);
 
-    // mvm::Collector::objectReferenceWriteBarrier(
-    //     (gc*)self, (gc**)&(self->cause), (gc*)self);
+    mvm::Collector::objectReferenceWriteBarrier(
+        (gc*)self, (gc**)&(self->cause), (gc*)self);
 
-    // self->stackTrace = NULL;
+    self->stackTrace = NULL;
   }
+
+  static int getStackTraceDepth(JavaObjectThrowable * self);
+  static int getStackTraceBase(JavaObjectThrowable * self);
 };
 
 class JavaObjectReference : public JavaObject {

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143479&r1=143478&r2=143479&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov  1 15:06:06 2011
@@ -22,6 +22,76 @@
 #define NYI() \
   do{ assert(0 && "Not yet implemented!"); abort(); } while(0)
 
+JavaObject* internalFillInStackTrace(JavaObject* throwable) {
+
+  ArrayPtr* result = 0;
+  llvm_gcroot(throwable, 0);
+  llvm_gcroot(result, 0);
+
+  JavaThread* th = JavaThread::get();
+  Jnjvm* vm = th->getJVM();
+  assert(th);
+  assert(vm);
+
+  uint32 length = th->getFrameContextLength();
+
+#ifdef ARCH_64
+    ClassArray* cl = vm->upcalls->ArrayOfInt;
+    result = (ArrayPtr*) cl->doNew(length, vm);
+#else
+    ClassArray* cl = vm->upcalls->ArrayOfLong;
+    result = (ArrayPtr*) cl->doNew(length, vm);
+#endif
+
+  // Don't call th->getFrameContext because it is not GC-safe.
+  mvm::StackWalker Walker(th);
+  uint32_t i = 0;
+
+  while (intptr_t ip = *Walker) {
+    ArrayPtr::setElement(result, ip, i);
+    ++i;
+    ++Walker;
+  }
+
+  return result;
+}
+
+JavaObject* consStackElement(mvm::FrameInfo* FI, intptr_t ip) {
+
+  JavaString* methodName = 0;
+  JavaString* className = 0;
+  JavaString* sourceName = 0;
+  JavaObject* res = 0;
+  llvm_gcroot(methodName, 0);
+  llvm_gcroot(className, 0);
+  llvm_gcroot(sourceName, 0);
+  llvm_gcroot(res, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JavaMethod* meth = (JavaMethod*)FI->Metadata;
+  methodName = vm->internalUTF8ToStr(meth->name);
+  Class* cl = meth->classDef;
+  className = JavaString::internalToJava(cl->name, vm);
+
+  Attribut* sourceAtt = cl->lookupAttribut(Attribut::sourceFileAttribut);
+
+  if (sourceAtt) {
+    Reader reader(sourceAtt, cl->bytes);
+    uint16 index = reader.readU2();
+    sourceName = vm->internalUTF8ToStr(cl->getConstantPool()->UTF8At(index));
+  }
+
+  uint16 lineNumber = meth->lookupLineNumber(FI);
+
+  UserClass* newS = vm->upcalls->newStackTraceElement;
+  res = newS->doNew(vm);
+  vm->upcalls->initStackTraceElement->invokeIntSpecial(vm, newS, res,
+                                                       &className,
+                                                       &methodName,
+                                                       &sourceName,
+                                                       lineNumber);
+  return res;
+}
 
 JNIEXPORT jint JNICALL
 JVM_GetInterfaceVersion(void) {
@@ -266,7 +336,17 @@
  */
 JNIEXPORT void JNICALL
 JVM_FillInStackTrace(JNIEnv *env, jobject throwable) {
-  NYI();
+  JavaObjectThrowable * T = 0;
+  llvm_gcroot(T, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  T = *(JavaObjectThrowable**)throwable;
+  JavaObjectThrowable::fillInStackTrace(T);
+
+  RETURN_VOID_FROM_JNI;
+
+  END_JNI_EXCEPTION
 }
 
 JNIEXPORT void JNICALL
@@ -276,12 +356,60 @@
 
 JNIEXPORT jint JNICALL
 JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable) {
-  NYI();
+  JavaObjectThrowable * T = 0;
+  llvm_gcroot(T, 0);
+
+  jint res = -1;
+
+  BEGIN_JNI_EXCEPTION
+
+  T = *(JavaObjectThrowable**)throwable;
+  res = JavaObjectThrowable::getStackTraceDepth(T);
+
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jobject JNICALL
 JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index) {
-  NYI();
+  JavaObjectThrowable * T = 0;
+  JavaObject * result = 0;
+  JavaObject * stack = 0;
+  llvm_gcroot(T, 0);
+  llvm_gcroot(result, 0);
+  llvm_gcroot(stack, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  T = *(JavaObjectThrowable**)throwable;
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  stack = vm->upcalls->backtrace->getInstanceObjectField(T);
+  verifyNull(stack);
+
+  sint32 base = JavaObjectThrowable::getStackTraceBase(T);
+
+  sint32 cur = 0;
+  for (sint32 i = base; i < JavaArray::getSize(stack); ++i) {
+    intptr_t ip = ArrayPtr::getElement((ArrayPtr*)stack, i);
+    mvm::FrameInfo* FI = vm->IPToFrameInfo(ip);
+    if (FI->Metadata != NULL) {
+      if (cur == index) {
+        result = consStackElement(FI, ip);
+        break;
+      }
+      cur++;
+    }
+  }
+
+  assert(result && "No stack element found");
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(result));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /*




From wdietz2 at illinois.edu  Tue Nov  1 13:06:08 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 01 Nov 2011 20:06:08 -0000
Subject: [vmkit-commits] [vmkit] r143480 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111101200608.CF6312A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  1 15:06:08 2011
New Revision: 143480

URL: http://llvm.org/viewvc/llvm-project?rev=143480&view=rev
Log:
Implement JVM_SetThreadPriority

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143480&r1=143479&r2=143480&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov  1 15:06:08 2011
@@ -480,7 +480,18 @@
 
 JNIEXPORT void JNICALL
 JVM_SetThreadPriority(JNIEnv *env, jobject thread, jint prio) {
-  NYI();
+  JavaObject * T;
+  llvm_gcroot(T, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm * vm = th->getJVM();
+  T = *(JavaObject**)thread;
+
+  vm->upcalls->priority->setInstanceInt32Field(T, prio);
+
+  RETURN_VOID_FROM_JNI
+  END_JNI_EXCEPTION
 }
 
 JNIEXPORT void JNICALL




From wdietz2 at illinois.edu  Tue Nov  1 13:06:10 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 01 Nov 2011 20:06:10 -0000
Subject: [vmkit-commits] [vmkit] r143481 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111101200610.962EB2A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  1 15:06:10 2011
New Revision: 143481

URL: http://llvm.org/viewvc/llvm-project?rev=143481&view=rev
Log:
Implement JVM_GetClassLoader

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143481&r1=143480&r2=143481&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov  1 15:06:10 2011
@@ -821,7 +821,20 @@
 
 JNIEXPORT jobject JNICALL
 JVM_GetClassLoader(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObject * Cl = *(JavaObject**)cls;
+  JavaObject * res = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(res, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  res = cl->classLoader->getJavaClassLoader();
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(res));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jboolean JNICALL




From wdietz2 at illinois.edu  Tue Nov  1 13:06:12 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 01 Nov 2011 20:06:12 -0000
Subject: [vmkit-commits] [vmkit] r143482 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
Message-ID: <20111101200612.5E82A2A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  1 15:06:12 2011
New Revision: 143482

URL: http://llvm.org/viewvc/llvm-project?rev=143482&view=rev
Log:
OpenJDK threading: intialize fields, set eeetop field.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp?rev=143482&r1=143481&r2=143482&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp Tue Nov  1 15:06:12 2011
@@ -235,12 +235,16 @@
 
   name = vm->asciizToStr(thName);
 
+  // Initialize the values
+  priority->setInstanceInt32Field(th, (uint32)5);
+  daemon->setInstanceInt8Field(th, (uint32)false);
+
   // call Thread(ThreadGroup,String) constructor
   initThread->invokeIntSpecial(vm, newThread, th, &Group, &name);
 
   // Store reference to the JavaThread for this thread in the 'eetop' field
-  // TODO: Don't do this until we have the tracing handled.
-  // eetop->setInstanceLongField(th, (long)myth);
+  // GC-safe since 'eetop' is of type 'long'
+  eetop->setInstanceLongField(th, (long)myth);
 }
 
 void Classpath::InitializeThreading(Jnjvm* vm) {




From wdietz2 at illinois.edu  Tue Nov  1 13:06:13 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 01 Nov 2011 20:06:13 -0000
Subject: [vmkit-commits] [vmkit] r143483 - /vmkit/trunk/lib/J3/VMCore/Jni.cpp
Message-ID: <20111101200613.F2E792A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  1 15:06:13 2011
New Revision: 143483

URL: http://llvm.org/viewvc/llvm-project?rev=143483&view=rev
Log:
Don't abort in JNI EnsureLocalCapacity, assume we have capacity.

Modified:
    vmkit/trunk/lib/J3/VMCore/Jni.cpp

Modified: vmkit/trunk/lib/J3/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jni.cpp?rev=143483&r1=143482&r2=143483&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Jni.cpp Tue Nov  1 15:06:13 2011
@@ -297,8 +297,7 @@
 
 
 jint EnsureLocalCapacity(JNIEnv* env, jint capacity) {
-  NYI();
-  abort();
+  // Assume we have capacity
   return 0;
 }
 




From wdietz2 at illinois.edu  Tue Nov  1 13:06:15 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 01 Nov 2011 20:06:15 -0000
Subject: [vmkit-commits] [vmkit] r143484 - in
 /vmkit/trunk/lib/J3/ClassLib/OpenJDK: JavaUpcalls.cpp OpenJDK.inc
Message-ID: <20111101200615.E06BB2A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  1 15:06:15 2011
New Revision: 143484

URL: http://llvm.org/viewvc/llvm-project?rev=143484&view=rev
Log:
Impl JVM_InternString, JVM_StartThread, JVM_IsThreadAlive

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp?rev=143484&r1=143483&r2=143484&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp Tue Nov  1 15:06:15 2011
@@ -367,27 +367,6 @@
   END_NATIVE_EXCEPTION
 }
 
-extern "C" JavaString* Java_java_lang_VMString_intern__Ljava_lang_String_2(
-    JavaString* obj) {
-  const ArrayUInt16* array = 0;
-  JavaString* res = 0;
-  llvm_gcroot(obj, 0);
-  llvm_gcroot(array, 0);
-  llvm_gcroot(res, 0);
-  // If the string is already interned, just return.
-  if (obj->getVirtualTable() == JavaString::internStringVT) return obj;
-
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  array = JavaString::strToArray(obj, vm);
-  res = vm->constructString(array);
-
-  END_NATIVE_EXCEPTION
-
-  return res;
-}
-
 extern "C" JavaObject* Java_sun_reflect_Reflection_getCallerClass__I(uint32 index) {
 
   JavaObject* res = 0;

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143484&r1=143483&r2=143484&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov  1 15:06:15 2011
@@ -165,7 +165,28 @@
  */
 JNIEXPORT jstring JNICALL
 JVM_InternString(JNIEnv *env, jstring _str) {
-  NYI();
+  JavaString * str = *(JavaString**)_str;
+  const ArrayUInt16* array = 0;
+  JavaString * res = 0;
+  llvm_gcroot(str, 0);
+  llvm_gcroot(array, 0);
+  llvm_gcroot(res, 0);
+
+  // If already intern'd, just return.
+  if(str->getVirtualTable() == JavaString::internStringVT)
+    return _str;
+
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  array = JavaString::strToArray(str, vm);
+  res = vm->constructString(array);
+
+  RETURN_FROM_JNI((jstring)th->pushJNIRef(res))
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /*
@@ -450,12 +471,67 @@
   NYI();
 }
 
+void start(JavaThread* thread) {
+
+  JavaObject* javaThread = NULL;
+  llvm_gcroot(javaThread, 0);
+
+  Jnjvm* vm = thread->getJVM();
+
+  // Wait some time to let the creator initialise this field
+  while (thread->javaThread == NULL) {
+    mvm::Thread::yield();
+  }
+
+  javaThread = thread->javaThread;
+  assert(javaThread && "Didn't fix the javaThread of a j3 thread");
+
+  // Ok, now that the thread is created we can set the the value of eetop
+  // which points from the javaobject to our internal JavaThread
+  vm->upcalls->eetop->setInstanceLongField(javaThread, (long)thread);
+
+  // If the thread is not a daemon, it is added to the list of threads to
+  // wait until exit.
+  bool isDaemon = vm->upcalls->daemon->getInstanceInt8Field(javaThread);
+
+  if (!isDaemon) {
+    vm->threadSystem.enter();
+  }
+
+  assert(javaThread->getVirtualTable());
+  // Run the VMThread::run function
+  vm->upcalls->runThread->invokeIntSpecial(vm, vm->upcalls->newThread, javaThread);
+
+  // Remove the thread from the list.
+  if (!isDaemon) {
+    vm->threadSystem.leave();
+  }
+}
 /*
  * java.lang.Thread
  */
 JNIEXPORT void JNICALL
 JVM_StartThread(JNIEnv *env, jobject _thread) {
-  NYI();
+  JavaObject * thread = 0;
+  JavaThread * javaThread = 0;
+  llvm_gcroot(thread, 0);
+  llvm_gcroot(javaThread, 0);
+  BEGIN_JNI_EXCEPTION
+
+  thread = *(JavaObject**)_thread;
+  assert(thread);
+  assert(thread->getVirtualTable());
+  Jnjvm* vm = JavaThread::get()->getJVM();
+
+  JavaThread * newTh = new JavaThread(vm);
+  if (!newTh) vm->outOfMemoryError();
+  newTh->start((void (*)(mvm::Thread*))start);
+
+  newTh->initialise(thread, 0);
+
+  RETURN_VOID_FROM_JNI
+
+  END_JNI_EXCEPTION
 }
 
 JNIEXPORT void JNICALL
@@ -465,7 +541,20 @@
 
 JNIEXPORT jboolean JNICALL
 JVM_IsThreadAlive(JNIEnv *env, jobject _thread) {
-  NYI();
+  BEGIN_JNI_EXCEPTION
+  JavaObject * thread = *(JavaObject**)_thread;
+  llvm_gcroot(thread, 0);
+  assert(thread);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  jint status = vm->upcalls->threadStatus->getInstanceInt32Field(thread);
+
+  // TODO: We don't actually maintain 'status'...
+  RETURN_FROM_JNI(status != 0);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT void JNICALL




From wdietz2 at illinois.edu  Tue Nov  1 13:06:20 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 01 Nov 2011 20:06:20 -0000
Subject: [vmkit-commits] [vmkit] r143486 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111101200620.2EE412A6C12D@llvm.org>

Author: wdietz2
Date: Tue Nov  1 15:06:19 2011
New Revision: 143486

URL: http://llvm.org/viewvc/llvm-project?rev=143486&view=rev
Log:
Impl JVM_DoPrivileged, no actual protection.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143486&r1=143485&r2=143486&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov  1 15:06:19 2011
@@ -1143,18 +1143,46 @@
 JNIEXPORT jobject JNICALL
 JVM_DoPrivileged(JNIEnv *env, jclass cls,
                  jobject action, jobject context, jboolean wrapException) {
-  NYI();
+  JavaObject * obj = 0;
+  JavaObject * res = 0;
+  llvm_gcroot(obj, 0);
+  llvm_gcroot(res, 0);
+  BEGIN_JNI_EXCEPTION
+
+  verifyNull(action);
+
+  obj = *(JavaObject**)action;
+
+  Jnjvm* vm = th->getJVM();
+
+  // For now, we don't do anything special,
+  // just call the requested 'run()' method...
+  UserClass * cl = JavaObject::getClass(obj)->asClass();
+  const UTF8 * runName = cl->classLoader->hashUTF8->lookupAsciiz("run");
+  const UTF8 * runType = cl->classLoader->hashUTF8->lookupAsciiz("()Ljava/lang/Object;");
+  assert(cl); assert(runName); assert(runType);
+
+  JavaMethod * meth = cl->lookupMethodDontThrow(runName, runType, false, true, 0);
+  assert(meth);
+
+  res = meth->invokeJavaObjectVirtual(vm, cl, obj, obj);
+
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(res));
+
+  END_JNI_EXCEPTION
 }
 
 JNIEXPORT jobject JNICALL
 JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls) {
-  NYI();
+  // No AccessControlContext supported yet
+  return NULL;
 }
 
 
 JNIEXPORT jobject JNICALL
 JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls) {
-  NYI();
+  // No AccessControlContext supported yet
+  return NULL;
 }
 
 /*




From wdietz2 at illinois.edu  Tue Nov  1 13:06:18 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 01 Nov 2011 20:06:18 -0000
Subject: [vmkit-commits] [vmkit] r143485 - in /vmkit/trunk/lib/J3/ClassLib:
 ArrayCopy.inc GNUClasspath/ClasspathVMSystem.inc OpenJDK/OpenJDK.inc
Message-ID: <20111101200618.5C13C2A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  1 15:06:17 2011
New Revision: 143485

URL: http://llvm.org/viewvc/llvm-project?rev=143485&view=rev
Log:
Move ArrayCopy to new 'ArrayCopy.inc', use in both CP and OJ.

Added:
    vmkit/trunk/lib/J3/ClassLib/ArrayCopy.inc
      - copied, changed from r143484, vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc
Modified:
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Copied: vmkit/trunk/lib/J3/ClassLib/ArrayCopy.inc (from r143484, vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/ArrayCopy.inc?p2=vmkit/trunk/lib/J3/ClassLib/ArrayCopy.inc&p1=vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc&r1=143484&r2=143485&rev=143485&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/ArrayCopy.inc Tue Nov  1 15:06:17 2011
@@ -1,4 +1,4 @@
-//===-- ClasspathVMSystem.cpp - GNU classpath java/lang/VMSystem ----------===//
+//===-- ArrayCopy.inc - ArrayCopy implementation --------------------------===//
 //
 //                            The VMKit project
 //
@@ -7,30 +7,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "types.h"
-
-#include "Classpath.h"
-#include "JavaArray.h"
-#include "JavaClass.h"
-#include "JavaObject.h"
-#include "JavaThread.h"
-#include "Jnjvm.h"
-
-using namespace j3;
-
-extern "C" {
-
-JNIEXPORT void JNICALL Java_java_lang_VMSystem_arraycopy(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass _cl,
-#endif
-JavaObject* src,
-jint sstart,
-JavaObject* dst,
-jint dstart,
-jint len) {
 
+void ArrayCopy(JavaObject* src, jint sstart, JavaObject* dst, jint dstart, jint len)
+{
   JavaObject* cur = 0;
   llvm_gcroot(src, 0);
   llvm_gcroot(dst, 0);
@@ -45,14 +24,14 @@
     th->throwException(vm->CreateNullPointerException());
     UNREACHABLE();
   }
-  
+
   if (!(JavaObject::getClass(src)->isArray() &&
         JavaObject::getClass(dst)->isArray())) {
     th->throwException(vm->CreateArrayStoreException(
       (JavaVirtualTable*)dst->getVirtualTable()));
     UNREACHABLE();
   }
-  
+
   UserClassArray* ts = (UserClassArray*)JavaObject::getClass(src);
   UserClassArray* td = (UserClassArray*)JavaObject::getClass(dst);
   UserCommonClass* dstType = td->baseClass();
@@ -80,7 +59,7 @@
     th->throwException(vm->CreateArrayStoreException(
       (JavaVirtualTable*)dst->getVirtualTable()));
   }
-  
+
   if (!(dstType->isPrimitive())) {
     for (int i = 0; i < len; i++) {
       cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);
@@ -94,25 +73,10 @@
         }
       }
     }
-  } else { 
+  } else {
     uint32 logSize = dstType->asPrimitiveClass()->logSize;
     void* ptrDst = (void*)((int64_t)JavaArray::getElements(dst) + (dstart << logSize));
     void* ptrSrc = (void*)((int64_t)JavaArray::getElements(src) + (sstart << logSize));
     memmove(ptrDst, ptrSrc, len << logSize);
   }
-
-}
-
-JNIEXPORT jint JNICALL Java_java_lang_VMSystem_identityHashCode(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObject* obj) {
-
-  llvm_gcroot(obj, 0);
-  if (obj == NULL) return 0;
-  return JavaObject::hashCode(obj);
-}
-
 }

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc?rev=143485&r1=143484&r2=143485&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc Tue Nov  1 15:06:17 2011
@@ -9,6 +9,7 @@
 
 #include "types.h"
 
+#include "ArrayCopy.h"
 #include "Classpath.h"
 #include "JavaArray.h"
 #include "JavaClass.h"
@@ -30,77 +31,7 @@
 JavaObject* dst,
 jint dstart,
 jint len) {
-
-  JavaObject* cur = 0;
-  llvm_gcroot(src, 0);
-  llvm_gcroot(dst, 0);
-  llvm_gcroot(cur, 0);
-  assert(src->getVirtualTable());
-  assert(dst->getVirtualTable());
-
-  JavaThread* th = JavaThread::get();
-  Jnjvm *vm = th->getJVM();
-
-  if (src == NULL || dst == NULL) {
-    th->throwException(vm->CreateNullPointerException());
-    UNREACHABLE();
-  }
-  
-  if (!(JavaObject::getClass(src)->isArray() &&
-        JavaObject::getClass(dst)->isArray())) {
-    th->throwException(vm->CreateArrayStoreException(
-      (JavaVirtualTable*)dst->getVirtualTable()));
-    UNREACHABLE();
-  }
-  
-  UserClassArray* ts = (UserClassArray*)JavaObject::getClass(src);
-  UserClassArray* td = (UserClassArray*)JavaObject::getClass(dst);
-  UserCommonClass* dstType = td->baseClass();
-  UserCommonClass* srcType = ts->baseClass();
-
-  sint32 srcSize = JavaArray::getSize(src);
-  sint32 dstSize = JavaArray::getSize(dst);
-
-  if (len > srcSize) {
-    th->throwException(vm->CreateIndexOutOfBoundsException(len));
-  } else if (len > dstSize) {
-    th->throwException(vm->CreateIndexOutOfBoundsException(len));
-  } else if (len + sstart > srcSize) {
-    th->throwException(vm->CreateIndexOutOfBoundsException(len + sstart));
-  } else if (len + dstart > dstSize) {
-    th->throwException(vm->CreateIndexOutOfBoundsException(len + dstart));
-  } else if (dstart < 0) {
-    th->throwException(vm->CreateIndexOutOfBoundsException(dstart));
-  } else if (sstart < 0) {
-    th->throwException(vm->CreateIndexOutOfBoundsException(sstart));
-  } else if (len < 0) {
-    th->throwException(vm->CreateIndexOutOfBoundsException(len));
-  } else if ((dstType->isPrimitive() || srcType->isPrimitive()) &&
-             srcType != dstType) {
-    th->throwException(vm->CreateArrayStoreException(
-      (JavaVirtualTable*)dst->getVirtualTable()));
-  }
-  
-  if (!(dstType->isPrimitive())) {
-    for (int i = 0; i < len; i++) {
-      cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);
-      if (cur) {
-        if (!(JavaObject::getClass(cur)->isAssignableFrom(dstType))) {
-          th->throwException(vm->CreateArrayStoreException(
-              (JavaVirtualTable*)dst->getVirtualTable()));
-          break;
-        } else {
-          ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);
-        }
-      }
-    }
-  } else { 
-    uint32 logSize = dstType->asPrimitiveClass()->logSize;
-    void* ptrDst = (void*)((int64_t)JavaArray::getElements(dst) + (dstart << logSize));
-    void* ptrSrc = (void*)((int64_t)JavaArray::getElements(src) + (sstart << logSize));
-    memmove(ptrDst, ptrSrc, len << logSize);
-  }
-
+  ArrayCopy(src, sstart, dst, dstart, len);
 }
 
 JNIEXPORT jint JNICALL Java_java_lang_VMSystem_identityHashCode(

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143485&r1=143484&r2=143485&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov  1 15:06:17 2011
@@ -7,17 +7,19 @@
 //===----------------------------------------------------------------------===//
 
 #include "jvm.h"
-#include "Reader.h"
+
+#include "ArrayCopy.inc"
 #include "JavaConstantPool.h"
+#include "Reader.h"
 #include "SetProperties.inc"
 
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
+#include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
-#include <errno.h>
 #include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
 
 #define NYI() \
   do{ assert(0 && "Not yet implemented!"); abort(); } while(0)
@@ -215,7 +217,22 @@
 JNIEXPORT void JNICALL
 JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject jsrc, jint sstart,
               jobject jdst, jint dstart, jint len) {
-  NYI();
+  JavaObject *src = 0;
+  JavaObject *dst = 0;
+  JavaObject* cur = 0;
+  llvm_gcroot(src, 0);
+  llvm_gcroot(dst, 0);
+  llvm_gcroot(cur, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  src = *(JavaObject**)jsrc;
+  dst = *(JavaObject**)jdst;
+
+  ArrayCopy(src, sstart, dst, dstart, len);
+
+  RETURN_VOID_FROM_JNI
+  END_JNI_EXCEPTION
 }
 
 JNIEXPORT jobject JNICALL




From wdietz2 at illinois.edu  Tue Nov  1 13:56:44 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 01 Nov 2011 20:56:44 -0000
Subject: [vmkit-commits] [vmkit] r143493 -
 /vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc
Message-ID: <20111101205644.60D5E2A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  1 15:56:44 2011
New Revision: 143493

URL: http://llvm.org/viewvc/llvm-project?rev=143493&view=rev
Log:
Fix broken include in ClasspathVMSystem.inc introduced in r143485

Modified:
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc?rev=143493&r1=143492&r2=143493&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc Tue Nov  1 15:56:44 2011
@@ -9,7 +9,7 @@
 
 #include "types.h"
 
-#include "ArrayCopy.h"
+#include "ArrayCopy.inc"
 #include "Classpath.h"
 #include "JavaArray.h"
 #include "JavaClass.h"




From wdietz2 at illinois.edu  Wed Nov  2 18:26:48 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 03 Nov 2011 01:26:48 -0000
Subject: [vmkit-commits] [vmkit] r143602 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111103012649.04AAB2A6C12C@llvm.org>

Author: wdietz2
Date: Wed Nov  2 20:26:48 2011
New Revision: 143602

URL: http://llvm.org/viewvc/llvm-project?rev=143602&view=rev
Log:
Fix incorrect ARCH_64 detection in OpenJDK's stack trace creation.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143602&r1=143601&r2=143602&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Wed Nov  2 20:26:48 2011
@@ -37,7 +37,7 @@
 
   uint32 length = th->getFrameContextLength();
 
-#ifdef ARCH_64
+#ifndef ARCH_64
     ClassArray* cl = vm->upcalls->ArrayOfInt;
     result = (ArrayPtr*) cl->doNew(length, vm);
 #else




From wdietz2 at illinois.edu  Thu Nov  3 07:17:44 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:17:44 -0500
Subject: [vmkit-commits] [PATCH] Impl JVM_GetClassDeclared{Fields, Methods,
	Constructors}
Message-ID: <CAKGWAO_-dfyndN+9MKtvsAtCJ6_HdBzFjuKobY27B8JiO6OT_Q@mail.gmail.com>

Inlined below.

Mostly copied from equivalent Classpath implementations, only the
OpenJDK constructors are different.

~Will

>From 0821f3663e504c431f96a52070e9983afd87d4a7 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Mon, 31 Oct 2011 16:54:28 -0500
Subject: [PATCH 01/17] Impl JVM_GetClassDeclared{Fields,Methods,Constructors}

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |  228 ++++++++++++++++++++++++++++++++++-
 1 files changed, 225 insertions(+), 3 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index f4110b7..b724e73 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -1016,17 +1016,237 @@ JVM_GetClassAnnotations(JNIEnv *env, jclass cls) {

 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
-  NYI();
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  JavaString* str = 0;
+  JavaObject * Cl = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+  llvm_gcroot(str, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)ofClass;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  Classpath* upcalls = vm->upcalls;
+
+  if (cl->isArray() || cl->isPrimitive()) {
+    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();
+    JnjvmClassLoader* classLoader = cl->classLoader;
+    uint32 size = 0;
+
+    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+         ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+          (!publicOnly || pub)) {
+        ++size;
+      }
+    }
+
+
+    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+         ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+          (!publicOnly || pub)) {
+        // TODO: check parameter types
+        UserClass* Meth = vm->upcalls->newMethod;
+        tmp = Meth->doNew(vm);
+        str = vm->internalUTF8ToStr(meth->name);
+        JavaObject * pArr = meth->getParameterTypes(classLoader);
+        JavaObject * eArr = meth->getExceptionTypes(classLoader);
+        JavaObject * retTy = meth->getReturnType(classLoader);
+        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp,
+          &Cl,          /* declaring class */
+          &str,         /* name */
+          &pArr,        /* parameter types */
+          &retTy,       /* return type */
+          &eArr,        /* exceptions */
+          meth->access, /* modifiers */
+          i,            /* slot */
+          NULL,         /* signature */
+          NULL,         /* annotations */
+          NULL,         /* parameter annotations */
+          NULL,         /* default annotations */
+          i);
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
-  NYI();
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  JavaString* name = 0;
+  JavaObject*const*  type = 0;
+  JavaString* sign = 0;
+  JavaObject* annArray = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+  llvm_gcroot(name, 0);
+  llvm_gcroot(type, 0);
+  llvm_gcroot(sign, 0);
+  llvm_gcroot(annArray, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  JavaObject * Cl = *(JavaObject**)ofClass;
+  llvm_gcroot(Cl, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  if (!cl->isClass()) {
+    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();
+    uint32 size = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+         ++i) {
+      JavaField* field = &realCl->virtualFields[i];
+      if (!publicOnly || isPublic(field->access)) {
+        ++size;
+      }
+    }
+
+
+    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+         ++i) {
+      JavaField* field = &realCl->virtualFields[i];
+      if (!publicOnly || isPublic(field->access)) {
+        // TODO: check parameter types
+        UserClass* Field = vm->upcalls->newField;
+        tmp = Field->doNew(vm);
+        name = vm->internalUTF8ToStr(field->name);
+
+        //type->Class
+        UserCommonClass * fieldCl =
field->getSignature()->assocClass(cl->classLoader);
+        assert(fieldCl);
+        type = fieldCl->getClassDelegateePtr(vm);
+
+        // TODO:Implement these!
+        sign = NULL;
+        annArray = NULL;
+
+        //Convert to string
+
+        /* java.reflect.Field(
+         *   Class declaringClass,
+         *   String name,
+         *   Class type,
+         *   int modifiers,
+         *   int slot,
+         *   String signature,
+         *   byte[] annotations)
+         */
+        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp,
+          &Cl,
+          &name,
+          type,
+          field->access,
+          i,
+          sign,
+          annArray);
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass,
jboolean publicOnly) {
-  NYI();
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  JavaObject* Cl = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)ofClass;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
+    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();;
+    JnjvmClassLoader* classLoader = cl->classLoader;
+    uint32 size = 0;
+
+    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+          (!publicOnly || pub)) {
+        ++size;
+      }
+    }
+
+    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+          (!publicOnly || pub)) {
+        UserClass* Cons = vm->upcalls->newConstructor;
+        JavaObject * pArr = meth->getParameterTypes(classLoader);
+        JavaObject * eArr = meth->getExceptionTypes(classLoader);
+        tmp = Cons->doNew(vm);
+        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp,
+          &Cl,          /* declaringClass */
+          &pArr,        /* parameterTypes */
+          &eArr,        /* checkedExceptions */
+          meth->access, /* modifiers */
+          i,            /* slot */
+          NULL,         /* String signature */
+          NULL,         /* annotations */
+          NULL          /* parameterAnnotations */
+        );
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /* Differs from JVM_GetClassModifiers in treatment of inner classes.
@@ -1170,6 +1390,8 @@ JVM_DoPrivileged(JNIEnv *env, jclass cls,
   RETURN_FROM_JNI((jobject)th->pushJNIRef(res));

   END_JNI_EXCEPTION
+
+  return NULL;
 }

 JNIEXPORT jobject JNICALL
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:19:09 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:19:09 -0500
Subject: [vmkit-commits] [PATCH] Implement a number of
	Java.sun.misc.Unsafe.* methods.
Message-ID: <CAKGWAO9sjQOL2vt9-ekS1vR=PdH=_xPZHpw=NejtpfreJDHQxA@mail.gmail.com>

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());
+  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;
+  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
+  return 0;
+}
+
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* clazz) {
+  // TODO: Implement me
+  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;
+}
+
 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;
+
+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


From wdietz2 at illinois.edu  Thu Nov  3 07:24:32 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:24:32 -0500
Subject: [vmkit-commits] [PATCH] Impl JVM_Clone
Message-ID: <CAKGWAO_O3ppjyMAB=U5W=9kQvRz8m5XYD44S=qgDgGura9GRhA@mail.gmail.com>

Inlined below.

The cloneNotSupportedException will be uncommented and fixed later,
when I'm making a pass to fix behavior like that with mauve and the
like.

~Will

>From a417116231df8de0a080687e7c6116b4cd3ee457 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 20:36:17 -0500
Subject: [PATCH 03/17] Impl JVM_Clone

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   73 ++++++++++++++++++++++++++++++++++-
 1 files changed, 72 insertions(+), 1 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index b724e73..30a670f 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -159,7 +159,78 @@ JVM_MonitorNotifyAll(JNIEnv *env, jobject obj) {

 JNIEXPORT jobject JNICALL
 JVM_Clone(JNIEnv *env, jobject obj) {
-  NYI();
+  JavaObject* res = NULL;
+  JavaObject* tmp = NULL;
+  JavaObject* src = NULL;
+  llvm_gcroot(res, 0);
+  llvm_gcroot(tmp, 0);
+  llvm_gcroot(src, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  src = *(JavaObject**)obj;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = JavaObject::getClass(src);
+
+  // If this doesn't inherit the Cloneable interface, it's invalid
+  // to try to clone it.
+  if (!JavaObject::instanceOf(src, vm->upcalls->cloneableClass))
+    NYI(); //vm->cloneNotSupportedException();
+
+  if (cl->isArray()) {
+    UserClassArray* array = cl->asArrayClass();
+    int length = JavaArray::getSize(src);
+    res = array->doNew(length, vm);
+    UserCommonClass* base = array->baseClass();
+    if (base->isPrimitive()) {
+      int size = length << base->asPrimitiveClass()->logSize;
+      memcpy((void*)((uintptr_t)res + sizeof(JavaObject) + sizeof(size_t)),
+             (void*)((uintptr_t)src + sizeof(JavaObject) + sizeof(size_t)),
+             size);
+    } else {
+      for (int i = 0; i < length; i++) {
+        tmp = ArrayObject::getElement((ArrayObject*)src, i);
+        ArrayObject::setElement((ArrayObject*)res, tmp, i);
+      }
+    }
+  } else {
+    assert(cl->isClass() && "Not a class!");
+    res = cl->asClass()->doNew(vm);
+    while (cl != NULL) {
+      for (uint32 i = 0; i < cl->asClass()->nbVirtualFields; ++i) {
+        JavaField& field = cl->asClass()->virtualFields[i];
+        if (field.isReference()) {
+          tmp = field.getInstanceObjectField(src);
+          JavaObject** ptr = field.getInstanceObjectFieldPtr(res);
+          mvm::Collector::objectReferenceWriteBarrier((gc*)res,
(gc**)ptr, (gc*)tmp);
+        } else if (field.isLong()) {
+          field.setInstanceLongField(res, field.getInstanceLongField(src));
+        } else if (field.isDouble()) {
+          field.setInstanceDoubleField(res, field.getInstanceDoubleField(src));
+        } else if (field.isInt()) {
+          field.setInstanceInt32Field(res, field.getInstanceInt32Field(src));
+        } else if (field.isFloat()) {
+          field.setInstanceFloatField(res, field.getInstanceFloatField(src));
+        } else if (field.isShort() || field.isChar()) {
+          field.setInstanceInt16Field(res, field.getInstanceInt16Field(src));
+        } else if (field.isByte() || field.isBoolean()) {
+          field.setInstanceInt8Field(res, field.getInstanceInt8Field(src));
+        } else {
+          UNREACHABLE();
+        }
+      }
+      cl = cl->super;
+    }
+  }
+
+  res = (JavaObject*)th->pushJNIRef(res);
+
+  RETURN_FROM_JNI((jobject)res);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /*
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:25:15 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:25:15 -0500
Subject: [vmkit-commits] [PATCH] Impl JVM_GetClassContext
Message-ID: <CAKGWAO9UHLbRGpNLPLM6-32sEspvYs4hyuRpA=tLn7mE9pDznw@mail.gmail.com>

Inlined below.

~Will

>From 27a8b66190db992968e8674d3832bb6176cd9b35 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 20:36:57 -0500
Subject: [PATCH 04/17] Impl JVM_GetClassContext

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   32 +++++++++++++++++++++++++++++++-
 1 files changed, 31 insertions(+), 1 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 30a670f..9305e66 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -742,7 +742,37 @@ JVM_CurrentClassLoader(JNIEnv *env) {

 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassContext(JNIEnv *env) {
-  NYI();
+  ArrayObject* result = NULL;
+  JavaObject* delegatee = NULL;
+  llvm_gcroot(result, 0);
+  llvm_gcroot(delegatee, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  JavaThread* th = JavaThread::get();
+  Jnjvm* vm = th->getJVM();
+  uint32 length = th->getFrameContextLength();
+
+  mvm::ThreadAllocator allocator;
+  uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *
sizeof(uintptr_t));
+
+  uint32 finalSize = th->getJavaFrameContext((void**)buffer);
+
+  result = (ArrayObject*)
+    vm->upcalls->stackTraceArray->doNew(finalSize, vm);
+
+  for (uint32 i = 0; i != finalSize; ++i) {
+    JavaMethod* meth = ((JavaMethod**)buffer)[i];
+    assert(meth && "Wrong stack trace");
+    delegatee = meth->classDef->getClassDelegatee(vm);;
+    ArrayObject::setElement(result, delegatee, i);
+  }
+
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(result));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT jint JNICALL
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:26:25 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:26:25 -0500
Subject: [vmkit-commits] [PATCH] Impl JVM_{FindClassFromClassLoader,
	FindClassFromBootLoader, FindLoadedClass}
Message-ID: <CAKGWAO8Dfu-fZQ++cf+paNBzE_Ox2980UHSccCsRbmgsE5P_Dw@mail.gmail.com>

Inlined below.

Thanks! :)

~Will

>From 84f0b389681480cafbb4cd096f160504e223f543 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 20:41:10 -0500
Subject: [PATCH 05/17] Impl
 JVM_{FindClassFromClassLoader,FindClassFromBootLoader,FindLoadedClass}

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   66 +++++++++++++++++++++++++++++++++--
 1 files changed, 63 insertions(+), 3 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 9305e66..60db37a 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -962,12 +962,52 @@ JVM_ResolveClass(JNIEnv *env, jclass cls) {
 JNIEXPORT jclass JNICALL
 JVM_FindClassFromClassLoader(JNIEnv *env, const char *name, jboolean init,
                              jobject _loader, jboolean throwError) {
-  NYI();
+  BEGIN_JNI_EXCEPTION
+
+  JavaObject * loader = _loader ? *(JavaObject**)_loader : 0;
+  llvm_gcroot(loader, 0);
+
+  jclass res;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader* JCL = NULL;
+  JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
+
+  CommonClass * Cl = JCL->loadClassFromAsciiz(name, true, throwError);
+  if (Cl) {
+    if (init && Cl->asClass())
+      Cl->asClass()->initialiseClass(vm);
+    res = (jclass)Cl->getClassDelegateePtr(vm);
+  }
+  else {
+    vm->classNotFoundException(vm->asciizToStr(name));
+  }
+
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT jclass JNICALL
 JVM_FindClassFromBootLoader(JNIEnv *env, const char *name) {
-  NYI();
+  BEGIN_JNI_EXCEPTION
+
+  jclass res = 0;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader* JCL = vm->bootstrapLoader;
+
+  CommonClass * Cl = JCL->loadClassFromAsciiz(name, true, false);
+  if (Cl) {
+    res = (jclass)Cl->getClassDelegateePtr(vm);
+  }
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /*
@@ -982,7 +1022,27 @@ JVM_FindClassFromClass(JNIEnv *env, const char
*name, jboolean init,
 /* Find a loaded class cached by the VM */
 JNIEXPORT jclass JNICALL
 JVM_FindLoadedClass(JNIEnv *env, jobject _loader, jstring name) {
-  NYI();
+  JavaObject * loader = 0;
+  llvm_gcroot(loader, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader* JCL = NULL;
+
+  JavaString * str = *(JavaString**)name;
+
+  loader = *(JavaObject**)_loader;
+
+  CommonClass * Cl = 0;
+
+  JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
+  if (JCL)
+   Cl = JCL->lookupClassFromJavaString(str);
+  jclass res = Cl ? (jclass)Cl->getClassDelegateePtr(vm) : 0;
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+
 }

 /* Define a class */
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:27:11 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:27:11 -0500
Subject: [vmkit-commits] [PATCH] Impl more JVM_* methods--Is{Interface, Array,
	Primitive}, GetPD, GetCompType
Message-ID: <CAKGWAO9VDA2vSHJ-mBVHOaZ9xW3iRcSk1r=4Vp-P-FPHa+AedQ@mail.gmail.com>

Inlined below.

~Will

>From bf6022bd59d8c1c4cb5b3451de6be01450e05d47 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 21:05:45 -0500
Subject: [PATCH 06/17] Impl more JVM_*
 methods--Is{Interface,Array,Primitive},GetPD,GetCompType

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   87 +++++++++++++++++++++++++++++++++--
 1 files changed, 82 insertions(+), 5 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 60db37a..3d157ed 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -1106,7 +1106,24 @@ JVM_GetClassLoader(JNIEnv *env, jclass cls) {

 JNIEXPORT jboolean JNICALL
 JVM_IsInterface(JNIEnv *env, jclass cls) {
-  NYI();
+  jboolean res = JNI_FALSE;
+
+  JavaObject * Cl = 0;
+  llvm_gcroot(Cl, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  res = cl->isInterface();
+
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+
+  return JNI_FALSE;
 }

 JNIEXPORT jobjectArray JNICALL
@@ -1121,7 +1138,20 @@ JVM_SetClassSigners(JNIEnv *env, jclass cls,
jobjectArray signers) {

 JNIEXPORT jobject JNICALL
 JVM_GetProtectionDomain(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObjectClass * JOC = 0;
+  JavaObject * pd = 0;
+  llvm_gcroot(JOC, 0);
+  llvm_gcroot(pd, 0);
+  BEGIN_JNI_EXCEPTION
+
+  JOC = *(JavaObjectClass**)cls;
+  pd = JavaObjectClass::getProtectionDomain(JOC);
+
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(pd));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT void JNICALL
@@ -1131,17 +1161,64 @@ JVM_SetProtectionDomain(JNIEnv *env, jclass
cls, jobject protection_domain) {

 JNIEXPORT jboolean JNICALL
 JVM_IsArrayClass(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObject * Cl = 0;
+  llvm_gcroot(Cl, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  RETURN_FROM_JNI(cl->isArray());
+
+  END_JNI_EXCEPTION
+
+  return JNI_FALSE;
 }

 JNIEXPORT jboolean JNICALL
 JVM_IsPrimitiveClass(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObject * Cl = 0;
+  llvm_gcroot(Cl, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  RETURN_FROM_JNI(cl->isPrimitive());
+
+  END_JNI_EXCEPTION
+
+  return JNI_FALSE;
 }

 JNIEXPORT jclass JNICALL
 JVM_GetComponentType(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObject * Cl = 0;
+  JavaObject* res = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(res, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  if (cl->isArray()) {
+    UserCommonClass* bc = cl->asArrayClass()->baseClass();
+    res = (JavaObject*)bc->getClassDelegateePtr(vm);
+  } else {
+    res = 0;
+  }
+
+  RETURN_FROM_JNI((jclass)res);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT jint JNICALL
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:27:52 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:27:52 -0500
Subject: [vmkit-commits] [PATCH] Impl JVM_GetClass{Modifiers,
	GetClassAccessFlags}
Message-ID: <CAKGWAO9Bu0+vvV1=b1Q92jBsqfG7iT-VH0spR8VHj2s_DaOh3Q@mail.gmail.com>

Inlined below.

Thanks!

~Will

>From 162150b6387d3f750eca94a85dbcd9345cb3ccdc Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 22:14:42 -0500
Subject: [PATCH 07/17] Impl JVM_GetClass{Modifiers,GetClassAccessFlags}

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   40 +++++++++++++++++++++++++++++++++-
 1 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 3d157ed..8e4e737 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -1223,7 +1223,27 @@ JVM_GetComponentType(JNIEnv *env, jclass cls) {

 JNIEXPORT jint JNICALL
 JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObject * Cl = 0;
+  llvm_gcroot(Cl, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
false)->asClass();;
+
+  jint res = cl->getAccess();
+
+  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
+    // javac may put that flag to inner classes of enum classes.
+    res &= ~ACC_ENUM;
+  }
+
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT jobjectArray JNICALL
@@ -1495,7 +1515,23 @@ JVM_GetClassDeclaredConstructors(JNIEnv *env,
jclass ofClass, jboolean publicOnl
    valid. */
 JNIEXPORT jint JNICALL
 JVM_GetClassAccessFlags(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObject * Cl = 0;
+  llvm_gcroot(Cl, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  assert(cl->isClass());
+
+  // TODO: Verify this is doing what this function is supposed to do
+  // (In particular regarding the comment block above)
+  RETURN_FROM_JNI(cl->asClass()->access);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /* The following two reflection routines are still needed due to
startup time issues */
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:28:32 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:28:32 -0500
Subject: [vmkit-commits] [PATCH] Impl JVM_GetClassName
Message-ID: <CAKGWAO82cBiZvka7dCx_QrWU5da_8RT_DY+ifWXrpg4sa6c+bQ@mail.gmail.com>

Inlined below.

Thanks!

~Will

>From 7aa56e329b296d2c11f5b0e7e3025e12caacae5e Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 22:21:02 -0500
Subject: [PATCH 08/17] Impl JVM_GetClassName

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   20 +++++++++++++++++++-
 1 files changed, 19 insertions(+), 1 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 8e4e737..9c5fb93 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -1078,7 +1078,25 @@ JVM_DefineClassWithSourceCond(JNIEnv *env,
const char *name, jobject loader,

 JNIEXPORT jstring JNICALL
 JVM_GetClassName(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObject * result = 0;
+  JavaObject * Cl = 0;
+  llvm_gcroot(result, 0);
+  llvm_gcroot(Cl, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  const UTF8* iname = cl->getName();
+  result = JavaString::internalToJava(iname, vm);
+
+  RETURN_FROM_JNI((jstring)th->pushJNIRef(result));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT jobjectArray JNICALL
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:29:26 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:29:26 -0500
Subject: [vmkit-commits] [PATCH] Impl JVM_NewInstanceFromConstructor
Message-ID: <CAKGWAO_Y4L6oBkUbJC02aJpb9Kd3jGhBpraSJ-nY0rLzcGGr0Q@mail.gmail.com>

Inlined below.

~Will

>From 6a870bd12c931552d7979ef216f3d0ff73bd306d Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 22:24:03 -0500
Subject: [PATCH 09/17] Impl JVM_NewInstanceFromConstructor

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   72 ++++++++++++++++++++++++++++++++++-
 1 files changed, 71 insertions(+), 1 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 9c5fb93..31ea42d 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -1566,7 +1566,77 @@ JVM_InvokeMethod(JNIEnv *env, jobject method,
jobject _obj, jobjectArray args0)
  */
 JNIEXPORT jobject JNICALL
 JVM_NewInstanceFromConstructor(JNIEnv *env, jobject _c, jobjectArray args0) {
-  NYI();
+  ArrayObject * args = 0;
+  JavaObjectConstructor * c = 0;
+  JavaObject * res = 0;
+  JavaObject* excp = 0;
+  llvm_gcroot(args, 0);
+  llvm_gcroot(c, 0);
+  llvm_gcroot(res, 0);
+  llvm_gcroot(excp, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  c = *(JavaObjectConstructor**)_c;
+  if (args0) args = *(ArrayObject**)args0;
+
+  UserClass* cl = JavaObjectConstructor::getClass(c);
+  JavaMethod * meth = JavaObjectConstructor::getInternalMethod(c);
+  assert(cl && meth);
+
+
+  sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;
+  Signdef* sign = meth->getSignature();
+  sint32 size = sign->nbArguments;
+
+  if (isAbstract(cl->access)) vm->instantiationException(cl);
+
+  mvm::ThreadAllocator allocator;
+  // Allocate a buffer to store the arguments.
+  jvalue* buf = size ?
+      (jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;
+
+  if (nbArgs == size) {
+    cl->initialiseClass(vm);
+    res = cl->doNew(vm);
+
+    JavaObject** ptr = (JavaObject**)ArrayObject::getElements(args);
+    Typedef* const* arguments = sign->getArgumentsType();
+    // Store the arguments, unboxing primitives if necessary.
+    for (sint32 i = 0; i < size; ++i) {
+      JavaObject::decapsulePrimitive(ptr[i], vm, &buf[i], arguments[i]);
+      if (!arguments[i]->isPrimitive()) {
+        buf[i].l = reinterpret_cast<jobject>(&ptr[i]);
+      }
+    }
+
+    JavaThread* th = JavaThread::get();
+    TRY {
+      meth->invokeIntSpecialBuf(vm, cl, res, buf);
+    } CATCH {
+      excp = th->getJavaException();
+    } END_CATCH;
+    if (excp) {
+      if (JavaObject::getClass(excp)->isAssignableFrom(vm->upcalls->newException))
{
+        th->clearException();
+        // If it's an exception, we encapsule it in an
+        // invocationTargetException
+        vm->invocationTargetException(excp);
+      } else {
+        // If it's an error, throw it again.
+        th->throwPendingException();
+      }
+      res = NULL;
+    }
+  } else {
+    vm->illegalArgumentException("wrong number of arguments");
+  }
+
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(res));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /*
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:30:58 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:30:58 -0500
Subject: [vmkit-commits] [PATCH] Impl JVM_IsSupportedJNIVersion,
 claim we support all known JNI versions.
Message-ID: <CAKGWAO-n99-tZ_RSbs8m4pOC3yFMrizm7oeGHpARTAEkNqQ+RQ@mail.gmail.com>

Inlined below.

Possibly better than a simple "return true" in that we don't claim to
support JNI versions that are invalid or don't exist yet :).

~Will

>From 5064cafd6be7fd9987323d8b0604e25784488e70 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 22:31:14 -0500
Subject: [PATCH 10/17] Impl JVM_IsSupportedJNIVersion, claim we support all
 known JNI versions.

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |    5 ++++-
 1 files changed, 4 insertions(+), 1 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 31ea42d..fd7f450 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -429,7 +429,10 @@ JVM_FindLibraryEntry(void *handle, const char *name) {

 JNIEXPORT jboolean JNICALL
 JVM_IsSupportedJNIVersion(jint version) {
-  NYI();
+  return version == JNI_VERSION_1_1 ||
+         version == JNI_VERSION_1_2 ||
+         version == JNI_VERSION_1_4 |
+         version == JNI_VERSION_1_6;
 }

 /*
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:32:06 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:32:06 -0500
Subject: [vmkit-commits] [PATCH] Impl JVM_NativePath
Message-ID: <CAKGWAO-J02XFmREEEuEGB-U+GeexBROssErSJdrz1bPaVHdn-Q@mail.gmail.com>

Inlined below.

Mostly to get things going along, since it's clearly not a real implementation.

Seems to work just fine though.

~Will

>From af0de8acd69fccb6becfcc25be8530ee872de9bb Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 22:31:50 -0500
Subject: [PATCH 11/17] Fake impl JVM_NativePath.  Can implement properly
 later if needed.

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |    3 ++-
 1 files changed, 2 insertions(+), 1 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index fd7f450..bb11f0d 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -2178,7 +2178,8 @@ JVM_GetLastErrorString(char *buf, int len) {
  */
 JNIEXPORT char * JNICALL
 JVM_NativePath(char * path) {
-  NYI();
+  // TODO: Implement me?
+  return path;
 }

 /*
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:32:59 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:32:59 -0500
Subject: [vmkit-commits] [PATCH] Add (minimal) signal support regarding
	JVM_FindSignal, JVM_RegisterSignal
Message-ID: <CAKGWAO_xJ3hh1pzV-4NqvfxK+SywDRmo3yX+jdO=VdrM23zTjQ@mail.gmail.com>

Inlined below.

Thanks!

~Will

>From b61e5572ad53bf8c518c0ba458942d0696ad20e8 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 22:41:45 -0500
Subject: [PATCH 12/17] Add (minimal) signal support regarding JVM_FindSignal,
 JVM_RegisterSignal

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   28 ++++++++++++++++++++++++++--
 1 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index bb11f0d..48ffce9 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -1781,7 +1781,8 @@ JVM_GetStackAccessControlContext(JNIEnv *env,
jclass cls) {

 JNIEXPORT void * JNICALL
 JVM_RegisterSignal(jint sig, void *handler) {
-  NYI();
+  // Don't let signals be registered, yet.
+  return (void*)-1;
 }

 JNIEXPORT jboolean JNICALL
@@ -1791,7 +1792,30 @@ JVM_RaiseSignal(jint sig) {

 JNIEXPORT jint JNICALL
 JVM_FindSignal(const char *name) {
-  NYI();
+  // Map Signal name to integer...
+  static struct {
+    const char * name;
+    int num;
+  } SignalMap[] =
+  {
+    { "TERM", SIGTERM },
+    { "HUP", SIGHUP },
+    { "INT", SIGINT }
+  };
+  static uint32 signal_count = sizeof(SignalMap)/sizeof(SignalMap[0]);
+
+  BEGIN_JNI_EXCEPTION
+
+  for(uint32 i = 0; i < signal_count; ++i) {
+    if (!strcmp(name, SignalMap[i].name))
+      RETURN_FROM_JNI(SignalMap[i].num);
+  }
+
+  fprintf(stderr, "Unknown Signal \"%s\", missing entry in table?\n", name);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /*
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:36:11 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:36:11 -0500
Subject: [vmkit-commits] [PATCH] In OpenJDK,
	use the 'classes' field of ClassLoader to track VMClassLoader.
Message-ID: <CAKGWAO_TZ4X_Yqx+EVtefSSz1_9Jm-UC18YQc3DnxG-MGpH4pA@mail.gmail.com>

Inlined below.

Traces the internal classloader by stashing a VMClassLoader into the
'classes' field.

FWIW the *only* time anyone 'writes' to the classes field is
initializing it to empty in the constructor.

~Will

>From 1b728ad7ab762680abe320eaf9f66e1e5c981560 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 22:48:26 -0500
Subject: [PATCH 13/17] In OpenJDK, use the 'classes' field of ClassLoader to
 track VMClassLoader.

Also, don't just check the 'vmdata' field for non-null, since in OJ it will be
initialized to an empty vector.  Instead, consider the field uninitialized if
it's either null or of the wrong type.
---
 lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp |    7 +++----
 lib/J3/VMCore/JnjvmClassLoader.cpp      |    7 +++++--
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
index 43ff227..22db276 100644
--- a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
+++ b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
@@ -552,10 +552,9 @@ void
Classpath::initialiseClasspath(JnjvmClassLoader* loader) {
     UPCALL_FIELD(loader, "java/nio/Buffer", "address",
"Lgnu/classpath/Pointer;",
                  ACC_VIRTUAL);

-  // TODO: Resolve how to tie a ClassLoader to its internal representation
-  //vmdataClassLoader =
-  //  UPCALL_FIELD(loader, "java/lang/ClassLoader", "vmdata",
"Ljava/lang/Object;",
-  //               ACC_VIRTUAL);
+  vmdataClassLoader =
+    UPCALL_FIELD(loader, "java/lang/ClassLoader", "classes",
"Ljava/util/Vector;",
+                 ACC_VIRTUAL);

   newStackTraceElement =
     UPCALL_CLASS(loader, "java/lang/StackTraceElement");
diff --git a/lib/J3/VMCore/JnjvmClassLoader.cpp
b/lib/J3/VMCore/JnjvmClassLoader.cpp
index 5444941..fd1eabb 100644
--- a/lib/J3/VMCore/JnjvmClassLoader.cpp
+++ b/lib/J3/VMCore/JnjvmClassLoader.cpp
@@ -808,11 +808,14 @@
JnjvmClassLoader::getJnjvmLoaderFromJavaObject(JavaObject* loader,
Jnjvm* vm) {
   vmdata =
     (VMClassLoader*)(upcalls->vmdataClassLoader->getInstanceObjectField(loader));

-  if (vmdata == NULL) {
+  // If the vmdata field isn't set yet, or it's set to something other than
+  // a VMClassLoader (which happens in the OpenJDK port), then initialize
+  // the field now.
+  if (vmdata == NULL || !VMClassLoader::isVMClassLoader(vmdata)) {
     JavaObject::acquire(loader);
     vmdata =
       (VMClassLoader*)(upcalls->vmdataClassLoader->getInstanceObjectField(loader));
-    if (!vmdata) {
+    if (!vmdata || !VMClassLoader::isVMClassLoader(vmdata)) {
       vmdata = VMClassLoader::allocate();
       mvm::BumpPtrAllocator* A = new mvm::BumpPtrAllocator();
       JCL = new(*A, "Class loader") JnjvmClassLoader(*A, *vm->bootstrapLoader,
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:37:40 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:37:40 -0500
Subject: [vmkit-commits] [PATCH] Refactor AOT into ClassLib-specific
 components, add support for OpenJDK
Message-ID: <CAKGWAO9O1gMuvhksmqg6mqJHWMX4YYPPxPnFVmNBkkd-0P3FTQ@mail.gmail.com>

Inlined below.

Thanks!

~Will

>From b036d7358b9e57da79e71f04e1869bb9e2015718 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 22:54:23 -0500
Subject: [PATCH 14/17] Refactor AOT into ClassLib-specific components, add
 support for OpenJDK

* Fix the JavaClass field layout for OpenJDK
* Restore the Class mapping (stored in an 'extra' field).  Ignore PD for now,
    since in the Classpath port we emit a null constant for it anyway.
---
 lib/J3/Compiler/JavaAOTCompiler.cpp          |   36 +++------------
 lib/J3/Compiler/JavaAOTCompilerClasspath.inc |   39 ++++++++++++++++
 lib/J3/Compiler/JavaAOTCompilerOpenJDK.inc   |   63 ++++++++++++++++++++++++++
 lib/J3/VMCore/Precompiled.cpp                |    4 ++
 4 files changed, 112 insertions(+), 30 deletions(-)
 create mode 100644 lib/J3/Compiler/JavaAOTCompilerClasspath.inc
 create mode 100644 lib/J3/Compiler/JavaAOTCompilerOpenJDK.inc

diff --git a/lib/J3/Compiler/JavaAOTCompiler.cpp
b/lib/J3/Compiler/JavaAOTCompiler.cpp
index d16d57c..11488df 100644
--- a/lib/J3/Compiler/JavaAOTCompiler.cpp
+++ b/lib/J3/Compiler/JavaAOTCompiler.cpp
@@ -687,36 +687,6 @@ Constant*
JavaAOTCompiler::CreateConstantForBaseObject(CommonClass* cl) {
   return ConstantStruct::get(STy, Elmts);
 }

-Constant* JavaAOTCompiler::CreateConstantFromJavaClass(CommonClass* cl) {
-  assert(!useCooperativeGC());
-  Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
-  LLVMClassInfo* LCI = getClassInfo(javaClass);
-  StructType* STy =
-    dyn_cast<StructType>(LCI->getVirtualType()->getContainedType(0));
-
-  std::vector<Constant*> Elmts;
-
-  // JavaObject
-  Elmts.push_back(CreateConstantForBaseObject(javaClass));
-
-  // signers
-  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
-
-  // pd
-  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
-
-  // vmdata
-  Constant* Cl = getNativeClass(cl);
-  Cl = ConstantExpr::getCast(Instruction::BitCast, Cl,
-                             JavaIntrinsics.JavaObjectType);
-  Elmts.push_back(Cl);
-
-  // constructor
-  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
-
-  return ConstantStruct::get(STy, Elmts);
-}
-
 Constant* JavaAOTCompiler::CreateConstantFromJavaObject(JavaObject* obj) {
   assert(!useCooperativeGC());
   CommonClass* cl = JavaObject::getClass(obj);
@@ -2557,3 +2527,9 @@ CommonClass*
JavaAOTCompiler::getUniqueBaseClass(CommonClass* cl) {
   }
   return currentClass;
 }
+
+#ifdef USE_OPENJDK
+#include "JavaAOTCompilerOpenJDK.inc"
+#else
+#include "JavaAOTCompilerClasspath.inc"
+#endif
diff --git a/lib/J3/Compiler/JavaAOTCompilerClasspath.inc
b/lib/J3/Compiler/JavaAOTCompilerClasspath.inc
new file mode 100644
index 0000000..41199ec
--- /dev/null
+++ b/lib/J3/Compiler/JavaAOTCompilerClasspath.inc
@@ -0,0 +1,39 @@
+//===----- JavaAOTCompilerClasspath.inc - GNUClasspath AOT support
--------===//
+//
+//                            The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+Constant* JavaAOTCompiler::CreateConstantFromJavaClass(CommonClass* cl) {
+  assert(!useCooperativeGC());
+  Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
+  LLVMClassInfo* LCI = getClassInfo(javaClass);
+  StructType* STy =
+    dyn_cast<StructType>(LCI->getVirtualType()->getContainedType(0));
+
+  std::vector<Constant*> Elmts;
+
+  // JavaObject
+  Elmts.push_back(CreateConstantForBaseObject(javaClass));
+
+  // signers
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+
+  // pd
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+
+  // vmdata
+  Constant* Cl = getNativeClass(cl);
+  Cl = ConstantExpr::getCast(Instruction::BitCast, Cl,
+                             JavaIntrinsics.JavaObjectType);
+  Elmts.push_back(Cl);
+
+  // constructor
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+
+  return ConstantStruct::get(STy, Elmts);
+}
+
diff --git a/lib/J3/Compiler/JavaAOTCompilerOpenJDK.inc
b/lib/J3/Compiler/JavaAOTCompilerOpenJDK.inc
new file mode 100644
index 0000000..367c56f
--- /dev/null
+++ b/lib/J3/Compiler/JavaAOTCompilerOpenJDK.inc
@@ -0,0 +1,63 @@
+//===----- JavaAOTCompilerOpenJDK.inc - OpenJDK AOT support
---------------===//
+//
+//                            The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+Constant* JavaAOTCompiler::CreateConstantFromJavaClass(CommonClass* cl) {
+  assert(!useCooperativeGC());
+  Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
+  LLVMClassInfo* LCI = getClassInfo(javaClass);
+  StructType* STy =
+    dyn_cast<StructType>(LCI->getVirtualType()->getContainedType(0));
+
+  std::vector<Constant*> Elmts;
+
+  // JavaObject
+  Elmts.push_back(CreateConstantForBaseObject(javaClass));
+
+  // Constructor
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // newInstanceCallerCache
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // Name
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // declaredFields
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // publicFields
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // declaredMethods
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // publicMethods
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // declaredConstructors
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // publicConstructors
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // declaredPublicFields
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // declaredPublicMethods
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // classRedefinedCount
+  Elmts.push_back(ConstantInt::get(Type::getInt32Ty(getLLVMContext()), 0));
+  // lastRedefinedCount
+  Elmts.push_back(ConstantInt::get(Type::getInt32Ty(getLLVMContext()), 0));
+  // genericInfo
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // enumConstants
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // enumConstantDictionary
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // annotations
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // declaredAnnotations
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+  // annotationType
+  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
+
+  return ConstantStruct::get(STy, Elmts);
+}
+
diff --git a/lib/J3/VMCore/Precompiled.cpp b/lib/J3/VMCore/Precompiled.cpp
index e469eaf..8fdd213 100644
--- a/lib/J3/VMCore/Precompiled.cpp
+++ b/lib/J3/VMCore/Precompiled.cpp
@@ -11,6 +11,7 @@
 #include <dlfcn.h>
 #include "mvm/MethodInfo.h"

+#include "ClasspathReflect.h"
 #include "JavaClass.h"
 #include "JavaUpcalls.h"
 #include "JnjvmClassLoader.h"
@@ -81,6 +82,9 @@ Class* JnjvmClassLoader::loadClassFromSelf(Jnjvm*
vm, const char* name) {
 extern "C" void vmjcAddPreCompiledClass(JnjvmClassLoader* JCL,
                                         CommonClass* cl) {
   cl->classLoader = JCL;
+  // Ensure the Class mapping field is set properly.
+  // (Needed for OpenJDK, since this mapping isn't part of the Class type)
+  JavaObjectClass::setClass((JavaObjectClass*)cl->getDelegatee(),cl);
 }


-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:38:51 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:38:51 -0500
Subject: [vmkit-commits] [PATCH] Impl JVM_Interrupt, JVM_IsInterrupted
Message-ID: <CAKGWAO-bgC06FJPcMOvDoroewZMyAmD-zGPYKUDXA9WeU=e9Yg@mail.gmail.com>

Inlined below.

Very similar to classpath code, only the field type is different, so
should be using the "Long" instance accessors, not Object.

~Will

>From effd45eb93189cbcd18480e691e4027fcaac4868 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Thu, 3 Nov 2011 08:57:13 -0500
Subject: [PATCH 16/17] Impl JVM_Interrupt, JVM_IsInterrupted

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   70 +++++++++++++++++++++++++++++++++--
 1 files changed, 66 insertions(+), 4 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 48ffce9..954234d 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -700,13 +700,75 @@ JVM_CountStackFrames(JNIEnv *env, jobject thread) {
 }

 JNIEXPORT void JNICALL
-JVM_Interrupt(JNIEnv *env, jobject thread) {
-  NYI();
+JVM_Interrupt(JNIEnv *env, jobject _thread) {
+  JavaObject * thread = 0;
+  llvm_gcroot(thread, 0);
+  BEGIN_JNI_EXCEPTION
+
+  thread = *(JavaObject**)_thread;
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JavaField * field = vm->upcalls->eetop;
+
+  // It's possible that the thread to be interrupted has not finished
+  // its initialization. Wait until the initialization is done.
+  while (field->getInstanceLongField(thread) == 0)
+    mvm::Thread::yield();
+
+  JavaThread* th = (JavaThread*)field->getInstanceLongField(thread);
+  th->lockingThread.interruptFlag = 1;
+  mvm::FatLock* lock = th->lockingThread.waitsOn;
+
+  // If the thread is blocked on a wait. We also verify nextWaiting in case
+  // the thread has been notified.
+  if (lock && th->lockingThread.nextWaiting) {
+    th->lockingThread.state = mvm::LockingThread::StateInterrupted;
+
+    // Make sure the thread is waiting.
+    uint32 locked = 0;
+    while (true) {
+      locked = (lock->tryAcquire() == 0);
+      if (locked || (lock->getOwner() != th && lock->getOwner() != 0))
+        break;
+      else mvm::Thread::yield();
+    }
+
+    // Interrupt the thread.
+    th->lockingThread.varcond.signal();
+
+    // Release the lock if we acquired it.
+    if (locked) lock->release(lock->getAssociatedObject(), vm->lockSystem);
+  }
+
+  // Here we could also raise a signal for interrupting I/O
+
+  RETURN_VOID_FROM_JNI
+  END_JNI_EXCEPTION
 }

 JNIEXPORT jboolean JNICALL
-JVM_IsInterrupted(JNIEnv *env, jobject thread, jboolean clearInterrupted) {
-  NYI();
+JVM_IsInterrupted(JNIEnv *env, jobject _thread, jboolean clearInterrupted) {
+  JavaObject * thread = 0;
+  llvm_gcroot(thread, 0);
+
+  bool interrupt = false;
+
+  BEGIN_JNI_EXCEPTION
+
+  thread = *(JavaObject**)_thread;
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JavaField * field = vm->upcalls->eetop;
+
+  JavaThread* jth = (JavaThread*)field->getInstanceLongField(thread);
+  interrupt = (jboolean)jth->lockingThread.interruptFlag;
+
+  if (clearInterrupted)
+    jth->lockingThread.interruptFlag = 0;
+
+  RETURN_FROM_JNI(interrupt);
+
+  END_JNI_EXCEPTION
+
+  return false;
 }

 JNIEXPORT jboolean JNICALL
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:39:27 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:39:27 -0500
Subject: [vmkit-commits] [PATCH] Impl JVM_DefineClass and variants. No
 support for source or verification yet.
Message-ID: <CAKGWAO9iqUieYin4WX2=FO-ygLv6k0=Ze0Xq1n2ENpSaD0HgXQ@mail.gmail.com>

Inlined below.

~Will

>From 1d583aa7435e95f243c2e27008c31f52d322938b Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Thu, 3 Nov 2011 09:10:11 -0500
Subject: [PATCH 17/17] Impl JVM_DefineClass and variants.  No support for
 source or verification yet.

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   31 ++++++++++++++++++++++++++++---
 1 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 954234d..c08908b 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -1114,7 +1114,30 @@ JVM_FindLoadedClass(JNIEnv *env, jobject
_loader, jstring name) {
 JNIEXPORT jclass JNICALL
 JVM_DefineClass(JNIEnv *env, const char *name, jobject _loader, const
jbyte *buf,
                 jsize len, jobject pd) {
-  NYI();
+  JavaObject * loader = 0;
+  llvm_gcroot(loader, 0);
+  BEGIN_JNI_EXCEPTION
+
+  loader = _loader ? *(JavaObject**)_loader : 0;
+
+  jclass res;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader* JCL = NULL;
+  JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
+
+  ClassBytes * bytes = new (JCL->allocator, len) ClassBytes(len);
+  memcpy(bytes->elements,buf,len);
+  const UTF8* utfName = JCL->asciizConstructUTF8(name);
+  UserClass *cl = JCL->constructClass(utfName, bytes);
+
+  if (cl) res = (jclass)cl->getClassDelegateePtr(vm);
+
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /* Define a class with a source (added in JDK1.5) */
@@ -1122,7 +1145,8 @@ JNIEXPORT jclass JNICALL
 JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader,
                           const jbyte *buf, jsize len, jobject pd,
                           const char *source) {
-  NYI();
+  // Discard source for now
+  return JVM_DefineClass(env, name, loader, buf, len, pd);
 }

 /* Define a class with a source with conditional verification (added HSX 14)
@@ -1134,7 +1158,8 @@ JNIEXPORT jclass JNICALL
 JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name, jobject loader,
                               const jbyte *buf, jsize len, jobject pd,
                               const char *source, jboolean verify) {
-  NYI();
+  // Discard source and verification
+  return JVM_DefineClass(env, name, loader, buf, len, pd);
 }

 /*
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:48:04 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:48:04 -0500
Subject: [vmkit-commits] [PATCH] Remove System.err.println from mmtk stuff
	to fix dep on bootstrap
Message-ID: <CAKGWAO9vi2z4GBRiSecCzoG_S-L2AkjkDLxAu1jvOL0TREUtxQ@mail.gmail.com>

Inlined below.

This change seems benign, but I'm not sure if it's masking some other
bug I should be concerned about.

Patch primarily a discussion point, although could be committed too
(since it's rather minor).

FWIW, with this patch (and the previous ones), we can build a
OpenJDK-based VMKit that can run many simple codes, and on larger
codes seems to only fail when encountering some of the many NYI()'d
(or intentionally unimplemented) pieces.  Which is kinda neat! :)

In the future I hope to focus on getting it to run various codes
better (dacapo being my big goal, but not the full story), and try to
generally improve misc behavior compatibility/compliance-wise :).

Thanks!

~Will

>From 0462e91eb86e28c00707c40d624853eb51679904 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 23:02:45 -0500
Subject: [PATCH 15/17] Remove System.err.println from mmtk stuff to fix dep
 on bootstrap

Not entirely sure, but with these present we get linker errors with
libFinalMMtk.a on misc pieces that are pulled in from System.err,
  namely things like sun.nio.cs.StreamEncoder.

On one hand this seems like an undiagnosed failure of the precompilation,
   however we're not trying to build System.err things while
   compiling mmtk, and this change is relatively minor.
---
 mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java
b/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java
index 8dc8f82..9f90b8e 100644
--- a/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java
+++ b/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java
@@ -53,7 +53,7 @@ public final class BuildTimeConfig extends
org.mmtk.vm.BuildTimeConfig {
     if (default_property_file == null) {
       propFileName = System.getProperty(property_file_property);
       if (propFileName == null) {
-        System.err.println(property_file_property+" must specify a
properties file");
+        //System.err.println(property_file_property+" must specify a
properties file");
         VM.sysExit(1);
       }
     } else {
@@ -67,7 +67,7 @@ public final class BuildTimeConfig extends
org.mmtk.vm.BuildTimeConfig {
       propFileStream.close();
     } catch (FileNotFoundException e) {
       if (!propFileName.equals(default_property_file)) {
-        System.err.println(propFileName+" not found.");
+        //System.err.println(propFileName+" not found.");
         VM.sysExit(1);
       }
     } catch (IOException e) {
-- 
1.7.5.1


From wdietz2 at illinois.edu  Thu Nov  3 07:57:20 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 3 Nov 2011 09:57:20 -0500
Subject: [vmkit-commits] [PATCH/DISCUSS] registerNatives Lock, avoid deadlock
Message-ID: <CAKGWAO8AT0G1OAsHBz17j1Pm4-7JbuSPPL0SyA+DmKUtd2Q4Lg@mail.gmail.com>

Hi,

I'm noticing deadlocks occurring in the OpenJDK port involving the
registerNatives stuff.

Looking at the lock acquisition/release things look clean (the only
way to exit without releasing a lock is through an assertion
failure)--but I don't know what kinds of larger lock-related
dependencies/assumptions/orderings there might be.  Apparently the
existing code does do something wrong, however.

Inlined below is a patch that simply gives registerNatives its own
lock, which seems to resolve these issues in all cases (the deadlock
occurs reliably in the codes that trigger this).  However I don't like
"I don't know what was wrong before" bits, and thought I'd bounce this
off you before deep-diving the locking to see what's wrong.

FWIW the other locks held during deadlock are the protectIR() locks.

Thanks for your time! :)

~Will

>From d28307a26fdecdddb96273a813451e56216857ab Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 2 Nov 2011 17:19:31 -0500
Subject: [PATCH] Add new 'nativesLock' to protect the registerNatives map.

This fixes various deadlock scenarios when using the other lock.
Not sure what caused them, but this works for now and is conceptually
a different lock anyway.

Avoiding debugging the other version for now :).
---
 lib/J3/VMCore/JnjvmClassLoader.cpp |    8 ++++----
 lib/J3/VMCore/JnjvmClassLoader.h   |    4 ++++
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/lib/J3/VMCore/JnjvmClassLoader.cpp
b/lib/J3/VMCore/JnjvmClassLoader.cpp
index 97b598e..59659c5 100644
--- a/lib/J3/VMCore/JnjvmClassLoader.cpp
+++ b/lib/J3/VMCore/JnjvmClassLoader.cpp
@@ -1046,17 +1046,17 @@ JavaString**
StringList::addString(JnjvmClassLoader* JCL, JavaString* obj) {
 }

 void JnjvmClassLoader::registerNative(JavaMethod * meth, word_t fnPtr) {
-  lock.lock();
+  nativesLock.lock();
   // Don't support multiple levels of registerNatives
   assert(registeredNatives.find(meth) == registeredNatives.end());

   registeredNatives[meth] = fnPtr;
-  lock.unlock();
+  nativesLock.unlock();
 }

 word_t JnjvmClassLoader::getRegisteredNative(const JavaMethod * meth) {
-  lock.lock();
+  nativesLock.lock();
   word_t res = registeredNatives[meth];
-  lock.unlock();
+  nativesLock.unlock();
   return res;
 }
diff --git a/lib/J3/VMCore/JnjvmClassLoader.h b/lib/J3/VMCore/JnjvmClassLoader.h
index f5891b0..3c1824b 100644
--- a/lib/J3/VMCore/JnjvmClassLoader.h
+++ b/lib/J3/VMCore/JnjvmClassLoader.h
@@ -113,6 +113,10 @@ protected:
   ///
   std::map<const JavaMethod*,word_t> registeredNatives;

+  /// nativesLock - Locks the registeredNatives map above
+  ///
+  mvm::LockRecursive nativesLock;
+
 public:

   /// allocator - Reference to the memory allocator, which will allocate UTF8s,
-- 
1.7.5.1


From nicolas.geoffray at gmail.com  Thu Nov  3 14:36:06 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Thu, 3 Nov 2011 22:36:06 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_GetClassDeclared{Fields,
 Methods, Constructors}
In-Reply-To: <CAKGWAO_-dfyndN+9MKtvsAtCJ6_HdBzFjuKobY27B8JiO6OT_Q@mail.gmail.com>
References: <CAKGWAO_-dfyndN+9MKtvsAtCJ6_HdBzFjuKobY27B8JiO6OT_Q@mail.gmail.com>
Message-ID: <CAPYwfip+U9cCzepe7gFoSD=DS5XmNFRMeL8+N9LXGR3oaDVsPA@mail.gmail.com>

Looks good!

On Thu, Nov 3, 2011 at 3:17 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Mostly copied from equivalent Classpath implementations, only the
> OpenJDK constructors are different.
>
> ~Will
>
> >From 0821f3663e504c431f96a52070e9983afd87d4a7 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Mon, 31 Oct 2011 16:54:28 -0500
> Subject: [PATCH 01/17] Impl
> JVM_GetClassDeclared{Fields,Methods,Constructors}
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |  228
> ++++++++++++++++++++++++++++++++++-
>  1 files changed, 225 insertions(+), 3 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index f4110b7..b724e73 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -1016,17 +1016,237 @@ JVM_GetClassAnnotations(JNIEnv *env, jclass cls) {
>
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean
> publicOnly) {
> -  NYI();
> +  ArrayObject* ret = 0;
> +  JavaObject* tmp = 0;
> +  JavaString* str = 0;
> +  JavaObject * Cl = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(tmp, 0);
> +  llvm_gcroot(str, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  Cl = *(JavaObject**)ofClass;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +  Classpath* upcalls = vm->upcalls;
> +
> +  if (cl->isArray() || cl->isPrimitive()) {
> +    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
> +  } else {
> +    UserClass* realCl = cl->asClass();
> +    JnjvmClassLoader* classLoader = cl->classLoader;
> +    uint32 size = 0;
> +
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> +         ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> +          (!publicOnly || pub)) {
> +        ++size;
> +      }
> +    }
> +
> +
> +    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
> +
> +    sint32 index = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> +         ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> +          (!publicOnly || pub)) {
> +        // TODO: check parameter types
> +        UserClass* Meth = vm->upcalls->newMethod;
> +        tmp = Meth->doNew(vm);
> +        str = vm->internalUTF8ToStr(meth->name);
> +        JavaObject * pArr = meth->getParameterTypes(classLoader);
> +        JavaObject * eArr = meth->getExceptionTypes(classLoader);
> +        JavaObject * retTy = meth->getReturnType(classLoader);
> +        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp,
> +          &Cl,          /* declaring class */
> +          &str,         /* name */
> +          &pArr,        /* parameter types */
> +          &retTy,       /* return type */
> +          &eArr,        /* exceptions */
> +          meth->access, /* modifiers */
> +          i,            /* slot */
> +          NULL,         /* signature */
> +          NULL,         /* annotations */
> +          NULL,         /* parameter annotations */
> +          NULL,         /* default annotations */
> +          i);
> +        ArrayObject::setElement(ret, tmp, index);
> +        index++;
> +      }
> +    }
> +  }
> +
> +  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean
> publicOnly) {
> -  NYI();
> +  ArrayObject* ret = 0;
> +  JavaObject* tmp = 0;
> +  JavaString* name = 0;
> +  JavaObject*const*  type = 0;
> +  JavaString* sign = 0;
> +  JavaObject* annArray = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(tmp, 0);
> +  llvm_gcroot(name, 0);
> +  llvm_gcroot(type, 0);
> +  llvm_gcroot(sign, 0);
> +  llvm_gcroot(annArray, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  JavaObject * Cl = *(JavaObject**)ofClass;
> +  llvm_gcroot(Cl, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> +  if (!cl->isClass()) {
> +    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
> +  } else {
> +    UserClass* realCl = cl->asClass();
> +    uint32 size = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> +         ++i) {
> +      JavaField* field = &realCl->virtualFields[i];
> +      if (!publicOnly || isPublic(field->access)) {
> +        ++size;
> +      }
> +    }
> +
> +
> +    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
> +
> +    sint32 index = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> +         ++i) {
> +      JavaField* field = &realCl->virtualFields[i];
> +      if (!publicOnly || isPublic(field->access)) {
> +        // TODO: check parameter types
> +        UserClass* Field = vm->upcalls->newField;
> +        tmp = Field->doNew(vm);
> +        name = vm->internalUTF8ToStr(field->name);
> +
> +        //type->Class
> +        UserCommonClass * fieldCl =
> field->getSignature()->assocClass(cl->classLoader);
> +        assert(fieldCl);
> +        type = fieldCl->getClassDelegateePtr(vm);
> +
> +        // TODO:Implement these!
> +        sign = NULL;
> +        annArray = NULL;
> +
> +        //Convert to string
> +
> +        /* java.reflect.Field(
> +         *   Class declaringClass,
> +         *   String name,
> +         *   Class type,
> +         *   int modifiers,
> +         *   int slot,
> +         *   String signature,
> +         *   byte[] annotations)
> +         */
> +        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp,
> +          &Cl,
> +          &name,
> +          type,
> +          field->access,
> +          i,
> +          sign,
> +          annArray);
> +        ArrayObject::setElement(ret, tmp, index);
> +        index++;
> +      }
> +    }
> +  }
> +  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass,
> jboolean publicOnly) {
> -  NYI();
> +  ArrayObject* ret = 0;
> +  JavaObject* tmp = 0;
> +  JavaObject* Cl = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(tmp, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  Cl = *(JavaObject**)ofClass;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> +  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
> +    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
> +  } else {
> +    UserClass* realCl = cl->asClass();;
> +    JnjvmClassLoader* classLoader = cl->classLoader;
> +    uint32 size = 0;
> +
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> +          (!publicOnly || pub)) {
> +        ++size;
> +      }
> +    }
> +
> +    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size,
> vm);
> +
> +    sint32 index = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> +          (!publicOnly || pub)) {
> +        UserClass* Cons = vm->upcalls->newConstructor;
> +        JavaObject * pArr = meth->getParameterTypes(classLoader);
> +        JavaObject * eArr = meth->getExceptionTypes(classLoader);
> +        tmp = Cons->doNew(vm);
> +        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp,
> +          &Cl,          /* declaringClass */
> +          &pArr,        /* parameterTypes */
> +          &eArr,        /* checkedExceptions */
> +          meth->access, /* modifiers */
> +          i,            /* slot */
> +          NULL,         /* String signature */
> +          NULL,         /* annotations */
> +          NULL          /* parameterAnnotations */
> +        );
> +        ArrayObject::setElement(ret, tmp, index);
> +        index++;
> +      }
> +    }
> +  }
> +
> +  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /* Differs from JVM_GetClassModifiers in treatment of inner classes.
> @@ -1170,6 +1390,8 @@ JVM_DoPrivileged(JNIEnv *env, jclass cls,
>   RETURN_FROM_JNI((jobject)th->pushJNIRef(res));
>
>   END_JNI_EXCEPTION
> +
> +  return NULL;
>  }
>
>  JNIEXPORT jobject JNICALL
> --
> 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/20111103/493ace39/attachment.html>

From wdietz2 at illinois.edu  Thu Nov  3 18:08:00 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Fri, 04 Nov 2011 01:08:00 -0000
Subject: [vmkit-commits] [vmkit] r143672 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111104010800.4A6822A6C12C@llvm.org>

Author: wdietz2
Date: Thu Nov  3 20:08:00 2011
New Revision: 143672

URL: http://llvm.org/viewvc/llvm-project?rev=143672&view=rev
Log:
Impl JVM_GetClassDeclared{Fields,Methods,Constructors}

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143672&r1=143671&r2=143672&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Thu Nov  3 20:08:00 2011
@@ -1016,17 +1016,237 @@
 
 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
-  NYI();
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  JavaString* str = 0;
+  JavaObject * Cl = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+  llvm_gcroot(str, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)ofClass;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  Classpath* upcalls = vm->upcalls;
+
+  if (cl->isArray() || cl->isPrimitive()) {
+    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();
+    JnjvmClassLoader* classLoader = cl->classLoader;
+    uint32 size = 0;
+
+    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+         ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+          (!publicOnly || pub)) {
+        ++size;
+      }
+    }
+
+
+    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+         ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+          (!publicOnly || pub)) {
+        // TODO: check parameter types
+        UserClass* Meth = vm->upcalls->newMethod;
+        tmp = Meth->doNew(vm);
+        str = vm->internalUTF8ToStr(meth->name);
+        JavaObject * pArr = meth->getParameterTypes(classLoader);
+        JavaObject * eArr = meth->getExceptionTypes(classLoader);
+        JavaObject * retTy = meth->getReturnType(classLoader);
+        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp,
+          &Cl,          /* declaring class */
+          &str,         /* name */
+          &pArr,        /* parameter types */
+          &retTy,       /* return type */
+          &eArr,        /* exceptions */
+          meth->access, /* modifiers */
+          i,            /* slot */
+          NULL,         /* signature */
+          NULL,         /* annotations */
+          NULL,         /* parameter annotations */
+          NULL,         /* default annotations */
+          i);
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
-  NYI();
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  JavaString* name = 0;
+  JavaObject*const*  type = 0;
+  JavaString* sign = 0;
+  JavaObject* annArray = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+  llvm_gcroot(name, 0);
+  llvm_gcroot(type, 0);
+  llvm_gcroot(sign, 0);
+  llvm_gcroot(annArray, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  JavaObject * Cl = *(JavaObject**)ofClass;
+  llvm_gcroot(Cl, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  if (!cl->isClass()) {
+    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();
+    uint32 size = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+         ++i) {
+      JavaField* field = &realCl->virtualFields[i];
+      if (!publicOnly || isPublic(field->access)) {
+        ++size;
+      }
+    }
+
+
+    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+         ++i) {
+      JavaField* field = &realCl->virtualFields[i];
+      if (!publicOnly || isPublic(field->access)) {
+        // TODO: check parameter types
+        UserClass* Field = vm->upcalls->newField;
+        tmp = Field->doNew(vm);
+        name = vm->internalUTF8ToStr(field->name);
+
+        //type->Class
+        UserCommonClass * fieldCl = field->getSignature()->assocClass(cl->classLoader);
+        assert(fieldCl);
+        type = fieldCl->getClassDelegateePtr(vm);
+
+        // TODO:Implement these!
+        sign = NULL;
+        annArray = NULL;
+
+        //Convert to string
+
+        /* java.reflect.Field(
+         *   Class declaringClass,
+         *   String name,
+         *   Class type,
+         *   int modifiers,
+         *   int slot,
+         *   String signature,
+         *   byte[] annotations)
+         */
+        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp,
+          &Cl,
+          &name,
+          type,
+          field->access,
+          i,
+          sign,
+          annArray);
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
-  NYI();
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  JavaObject* Cl = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)ofClass;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
+    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();;
+    JnjvmClassLoader* classLoader = cl->classLoader;
+    uint32 size = 0;
+
+    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+          (!publicOnly || pub)) {
+        ++size;
+      }
+    }
+
+    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+          (!publicOnly || pub)) {
+        UserClass* Cons = vm->upcalls->newConstructor;
+        JavaObject * pArr = meth->getParameterTypes(classLoader);
+        JavaObject * eArr = meth->getExceptionTypes(classLoader);
+        tmp = Cons->doNew(vm);
+        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp,
+          &Cl,          /* declaringClass */
+          &pArr,        /* parameterTypes */
+          &eArr,        /* checkedExceptions */
+          meth->access, /* modifiers */
+          i,            /* slot */
+          NULL,         /* String signature */
+          NULL,         /* annotations */
+          NULL          /* parameterAnnotations */
+        );
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /* Differs from JVM_GetClassModifiers in treatment of inner classes.
@@ -1170,6 +1390,8 @@
   RETURN_FROM_JNI((jobject)th->pushJNIRef(res));
 
   END_JNI_EXCEPTION
+
+  return NULL;
 }
 
 JNIEXPORT jobject JNICALL




From nicolas.geoffray at gmail.com  Fri Nov  4 14:06:25 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:06:25 +0100
Subject: [vmkit-commits] [PATCH] Implement a number of
 Java.sun.misc.Unsafe.* methods.
In-Reply-To: <CAKGWAO9sjQOL2vt9-ekS1vR=PdH=_xPZHpw=NejtpfreJDHQxA@mail.gmail.com>
References: <CAKGWAO9sjQOL2vt9-ekS1vR=PdH=_xPZHpw=NejtpfreJDHQxA@mail.gmail.com>
Message-ID: <CAPYwfiqqzf75hqdND0UULwf-6w-pYShPnmQQvCfvckDZ-En8Zg@mail.gmail.com>

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>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:10:53 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:10:53 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_GetClassContext
In-Reply-To: <CAKGWAO9UHLbRGpNLPLM6-32sEspvYs4hyuRpA=tLn7mE9pDznw@mail.gmail.com>
References: <CAKGWAO9UHLbRGpNLPLM6-32sEspvYs4hyuRpA=tLn7mE9pDznw@mail.gmail.com>
Message-ID: <CAPYwfio5DKfNaBthTggTBwLJfRi0epOxHb0LEARB2EXZpSQ5FA@mail.gmail.com>

On Thu, Nov 3, 2011 at 3:25 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> ~Will
>
> >From 27a8b66190db992968e8674d3832bb6176cd9b35 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 20:36:57 -0500
> Subject: [PATCH 04/17] Impl JVM_GetClassContext
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   32
> +++++++++++++++++++++++++++++++-
>  1 files changed, 31 insertions(+), 1 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 30a670f..9305e66 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -742,7 +742,37 @@ JVM_CurrentClassLoader(JNIEnv *env) {
>
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassContext(JNIEnv *env) {
> -  NYI();
> +  ArrayObject* result = NULL;
> +  JavaObject* delegatee = NULL;
> +  llvm_gcroot(result, 0);
> +  llvm_gcroot(delegatee, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  JavaThread* th = JavaThread::get();
> +  Jnjvm* vm = th->getJVM();
> +  uint32 length = th->getFrameContextLength();
> +
> +  mvm::ThreadAllocator allocator;
> +  uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *
> sizeof(uintptr_t));
> +
> +  uint32 finalSize = th->getJavaFrameContext((void**)buffer);
> +
> +  result = (ArrayObject*)
> +    vm->upcalls->stackTraceArray->doNew(finalSize, vm);
>

This should not be a stackTraceArray but a classArrayClass, right? You're
storing java.lang.Class in the lines above.


> +
> +  for (uint32 i = 0; i != finalSize; ++i) {
> +    JavaMethod* meth = ((JavaMethod**)buffer)[i];
> +    assert(meth && "Wrong stack trace");
> +    delegatee = meth->classDef->getClassDelegatee(vm);;
> +    ArrayObject::setElement(result, delegatee, i);
> +  }
> +
> +  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(result));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jint JNICALL
> --
> 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/44254499/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:13:55 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:13:55 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_{FindClassFromClassLoader,
 FindClassFromBootLoader, FindLoadedClass}
In-Reply-To: <CAKGWAO8Dfu-fZQ++cf+paNBzE_Ox2980UHSccCsRbmgsE5P_Dw@mail.gmail.com>
References: <CAKGWAO8Dfu-fZQ++cf+paNBzE_Ox2980UHSccCsRbmgsE5P_Dw@mail.gmail.com>
Message-ID: <CAPYwfios83fB9MaDzd_6pqahngF-vonfZrKhYaTCUjxiNUiqhQ@mail.gmail.com>

Looks good! With one comment.

On Thu, Nov 3, 2011 at 3:26 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Thanks! :)
>
> ~Will
>
> >From 84f0b389681480cafbb4cd096f160504e223f543 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 20:41:10 -0500
> Subject: [PATCH 05/17] Impl
>  JVM_{FindClassFromClassLoader,FindClassFromBootLoader,FindLoadedClass}
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   66
> +++++++++++++++++++++++++++++++++--
>  1 files changed, 63 insertions(+), 3 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 9305e66..60db37a 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -962,12 +962,52 @@ JVM_ResolveClass(JNIEnv *env, jclass cls) {
>  JNIEXPORT jclass JNICALL
>  JVM_FindClassFromClassLoader(JNIEnv *env, const char *name, jboolean init,
>                              jobject _loader, jboolean throwError) {
> -  NYI();
> +  BEGIN_JNI_EXCEPTION
> +
> +  JavaObject * loader = _loader ? *(JavaObject**)_loader : 0;
> +  llvm_gcroot(loader, 0);
> +
> +  jclass res;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JnjvmClassLoader* JCL = NULL;
> +  JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
>

Merge the two lines above.


> +
> +  CommonClass * Cl = JCL->loadClassFromAsciiz(name, true, throwError);
> +  if (Cl) {
> +    if (init && Cl->asClass())
> +      Cl->asClass()->initialiseClass(vm);
> +    res = (jclass)Cl->getClassDelegateePtr(vm);
> +  }
> +  else {
> +    vm->classNotFoundException(vm->asciizToStr(name));
> +  }
> +
> +  RETURN_FROM_JNI(res);
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jclass JNICALL
>  JVM_FindClassFromBootLoader(JNIEnv *env, const char *name) {
> -  NYI();
> +  BEGIN_JNI_EXCEPTION
> +
> +  jclass res = 0;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JnjvmClassLoader* JCL = vm->bootstrapLoader;
> +
> +  CommonClass * Cl = JCL->loadClassFromAsciiz(name, true, false);
> +  if (Cl) {
> +    res = (jclass)Cl->getClassDelegateePtr(vm);
> +  }
> +  RETURN_FROM_JNI(res);
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /*
> @@ -982,7 +1022,27 @@ JVM_FindClassFromClass(JNIEnv *env, const char
> *name, jboolean init,
>  /* Find a loaded class cached by the VM */
>  JNIEXPORT jclass JNICALL
>  JVM_FindLoadedClass(JNIEnv *env, jobject _loader, jstring name) {
> -  NYI();
> +  JavaObject * loader = 0;
> +  llvm_gcroot(loader, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JnjvmClassLoader* JCL = NULL;
> +
> +  JavaString * str = *(JavaString**)name;
> +
> +  loader = *(JavaObject**)_loader;
> +
> +  CommonClass * Cl = 0;
> +
> +  JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
> +  if (JCL)
> +   Cl = JCL->lookupClassFromJavaString(str);
> +  jclass res = Cl ? (jclass)Cl->getClassDelegateePtr(vm) : 0;
> +  RETURN_FROM_JNI(res);
> +
> +  END_JNI_EXCEPTION
> +
>  }
>
>  /* Define a class */
> --
> 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/4d40f8a8/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:15:29 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:15:29 +0100
Subject: [vmkit-commits] [PATCH] Impl more JVM_* methods--Is{Interface,
 Array, Primitive}, GetPD, GetCompType
In-Reply-To: <CAKGWAO9VDA2vSHJ-mBVHOaZ9xW3iRcSk1r=4Vp-P-FPHa+AedQ@mail.gmail.com>
References: <CAKGWAO9VDA2vSHJ-mBVHOaZ9xW3iRcSk1r=4Vp-P-FPHa+AedQ@mail.gmail.com>
Message-ID: <CAPYwfio7pa+NtmoeHNF_8h7k=nX7cMD6VQ3dFbcFOW6pJcRLww@mail.gmail.com>

Looks good!

On Thu, Nov 3, 2011 at 3:27 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> ~Will
>
> >From bf6022bd59d8c1c4cb5b3451de6be01450e05d47 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 21:05:45 -0500
> Subject: [PATCH 06/17] Impl more JVM_*
>  methods--Is{Interface,Array,Primitive},GetPD,GetCompType
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   87
> +++++++++++++++++++++++++++++++++--
>  1 files changed, 82 insertions(+), 5 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 60db37a..3d157ed 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -1106,7 +1106,24 @@ JVM_GetClassLoader(JNIEnv *env, jclass cls) {
>
>  JNIEXPORT jboolean JNICALL
>  JVM_IsInterface(JNIEnv *env, jclass cls) {
> -  NYI();
> +  jboolean res = JNI_FALSE;
> +
> +  JavaObject * Cl = 0;
> +  llvm_gcroot(Cl, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  Cl = *(JavaObject**)cls;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> +  res = cl->isInterface();
> +
> +  RETURN_FROM_JNI(res);
> +
> +  END_JNI_EXCEPTION
> +
> +  return JNI_FALSE;
>  }
>
>  JNIEXPORT jobjectArray JNICALL
> @@ -1121,7 +1138,20 @@ JVM_SetClassSigners(JNIEnv *env, jclass cls,
> jobjectArray signers) {
>
>  JNIEXPORT jobject JNICALL
>  JVM_GetProtectionDomain(JNIEnv *env, jclass cls) {
> -  NYI();
> +  JavaObjectClass * JOC = 0;
> +  JavaObject * pd = 0;
> +  llvm_gcroot(JOC, 0);
> +  llvm_gcroot(pd, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  JOC = *(JavaObjectClass**)cls;
> +  pd = JavaObjectClass::getProtectionDomain(JOC);
> +
> +  RETURN_FROM_JNI((jobject)th->pushJNIRef(pd));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT void JNICALL
> @@ -1131,17 +1161,64 @@ JVM_SetProtectionDomain(JNIEnv *env, jclass
> cls, jobject protection_domain) {
>
>  JNIEXPORT jboolean JNICALL
>  JVM_IsArrayClass(JNIEnv *env, jclass cls) {
> -  NYI();
> +  JavaObject * Cl = 0;
> +  llvm_gcroot(Cl, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  Cl = *(JavaObject**)cls;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> +  RETURN_FROM_JNI(cl->isArray());
> +
> +  END_JNI_EXCEPTION
> +
> +  return JNI_FALSE;
>  }
>
>  JNIEXPORT jboolean JNICALL
>  JVM_IsPrimitiveClass(JNIEnv *env, jclass cls) {
> -  NYI();
> +  JavaObject * Cl = 0;
> +  llvm_gcroot(Cl, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  Cl = *(JavaObject**)cls;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> +  RETURN_FROM_JNI(cl->isPrimitive());
> +
> +  END_JNI_EXCEPTION
> +
> +  return JNI_FALSE;
>  }
>
>  JNIEXPORT jclass JNICALL
>  JVM_GetComponentType(JNIEnv *env, jclass cls) {
> -  NYI();
> +  JavaObject * Cl = 0;
> +  JavaObject* res = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(res, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  Cl = *(JavaObject**)cls;
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> +  if (cl->isArray()) {
> +    UserCommonClass* bc = cl->asArrayClass()->baseClass();
> +    res = (JavaObject*)bc->getClassDelegateePtr(vm);
> +  } else {
> +    res = 0;
> +  }
> +
> +  RETURN_FROM_JNI((jclass)res);
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jint JNICALL
> --
> 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/956bb6e4/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:17:09 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:17:09 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_GetClass{Modifiers,
	GetClassAccessFlags}
In-Reply-To: <CAKGWAO9Bu0+vvV1=b1Q92jBsqfG7iT-VH0spR8VHj2s_DaOh3Q@mail.gmail.com>
References: <CAKGWAO9Bu0+vvV1=b1Q92jBsqfG7iT-VH0spR8VHj2s_DaOh3Q@mail.gmail.com>
Message-ID: <CAPYwfioS+vapME+LM-y-OuNXp9h2o_x-XG3yuE=BT_=QRPnXxg@mail.gmail.com>

Looks good!

On Thu, Nov 3, 2011 at 3:27 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Thanks!
>
> ~Will
>
> >From 162150b6387d3f750eca94a85dbcd9345cb3ccdc Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 22:14:42 -0500
> Subject: [PATCH 07/17] Impl JVM_GetClass{Modifiers,GetClassAccessFlags}
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   40
> +++++++++++++++++++++++++++++++++-
>  1 files changed, 38 insertions(+), 2 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 3d157ed..8e4e737 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -1223,7 +1223,27 @@ JVM_GetComponentType(JNIEnv *env, jclass cls) {
>
>  JNIEXPORT jint JNICALL
>  JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
> -  NYI();
> +  JavaObject * Cl = 0;
> +  llvm_gcroot(Cl, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  Cl = *(JavaObject**)cls;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();;
> +
> +  jint res = cl->getAccess();
> +
> +  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
> +    // javac may put that flag to inner classes of enum classes.
> +    res &= ~ACC_ENUM;
> +  }
> +
> +  RETURN_FROM_JNI(res);
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jobjectArray JNICALL
> @@ -1495,7 +1515,23 @@ JVM_GetClassDeclaredConstructors(JNIEnv *env,
> jclass ofClass, jboolean publicOnl
>    valid. */
>  JNIEXPORT jint JNICALL
>  JVM_GetClassAccessFlags(JNIEnv *env, jclass cls) {
> -  NYI();
> +  JavaObject * Cl = 0;
> +  llvm_gcroot(Cl, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  Cl = *(JavaObject**)cls;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +  assert(cl->isClass());
> +
> +  // TODO: Verify this is doing what this function is supposed to do
> +  // (In particular regarding the comment block above)
> +  RETURN_FROM_JNI(cl->asClass()->access);
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /* The following two reflection routines are still needed due to
> startup time issues */
> --
> 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/343d3140/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:17:36 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:17:36 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_GetClassName
In-Reply-To: <CAKGWAO82cBiZvka7dCx_QrWU5da_8RT_DY+ifWXrpg4sa6c+bQ@mail.gmail.com>
References: <CAKGWAO82cBiZvka7dCx_QrWU5da_8RT_DY+ifWXrpg4sa6c+bQ@mail.gmail.com>
Message-ID: <CAPYwfipaWjbET5acX2-9brKBbxU4+abKE5uauYNJ5NpUSnEfYQ@mail.gmail.com>

Looks good!

On Thu, Nov 3, 2011 at 3:28 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Thanks!
>
> ~Will
>
> >From 7aa56e329b296d2c11f5b0e7e3025e12caacae5e Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 22:21:02 -0500
> Subject: [PATCH 08/17] Impl JVM_GetClassName
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   20 +++++++++++++++++++-
>  1 files changed, 19 insertions(+), 1 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 8e4e737..9c5fb93 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -1078,7 +1078,25 @@ JVM_DefineClassWithSourceCond(JNIEnv *env,
> const char *name, jobject loader,
>
>  JNIEXPORT jstring JNICALL
>  JVM_GetClassName(JNIEnv *env, jclass cls) {
> -  NYI();
> +  JavaObject * result = 0;
> +  JavaObject * Cl = 0;
> +  llvm_gcroot(result, 0);
> +  llvm_gcroot(Cl, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  Cl = *(JavaObject**)cls;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> +  const UTF8* iname = cl->getName();
> +  result = JavaString::internalToJava(iname, vm);
> +
> +  RETURN_FROM_JNI((jstring)th->pushJNIRef(result));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jobjectArray JNICALL
> --
> 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/700d03e3/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:23:41 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:23:41 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_NewInstanceFromConstructor
In-Reply-To: <CAKGWAO_Y4L6oBkUbJC02aJpb9Kd3jGhBpraSJ-nY0rLzcGGr0Q@mail.gmail.com>
References: <CAKGWAO_Y4L6oBkUbJC02aJpb9Kd3jGhBpraSJ-nY0rLzcGGr0Q@mail.gmail.com>
Message-ID: <CAPYwfirGwpuVDY0Hvsd==MA7AVTZtsYdx5ix89BzCvMjCf5KEg@mail.gmail.com>

Looks good! This is again very similar to what is in classpath. I know I
said that you should not worry about duplicating code, but after reviewing
a few of your changes, if you could somehow try to share when you can,
that'd be great :)

But feel free to ignore for now, if that's on your way of making the
progress you want.

Nicolas

On Thu, Nov 3, 2011 at 3:29 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> ~Will
>
> >From 6a870bd12c931552d7979ef216f3d0ff73bd306d Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 22:24:03 -0500
> Subject: [PATCH 09/17] Impl JVM_NewInstanceFromConstructor
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   72
> ++++++++++++++++++++++++++++++++++-
>  1 files changed, 71 insertions(+), 1 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 9c5fb93..31ea42d 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -1566,7 +1566,77 @@ JVM_InvokeMethod(JNIEnv *env, jobject method,
> jobject _obj, jobjectArray args0)
>  */
>  JNIEXPORT jobject JNICALL
>  JVM_NewInstanceFromConstructor(JNIEnv *env, jobject _c, jobjectArray
> args0) {
> -  NYI();
> +  ArrayObject * args = 0;
> +  JavaObjectConstructor * c = 0;
> +  JavaObject * res = 0;
> +  JavaObject* excp = 0;
> +  llvm_gcroot(args, 0);
> +  llvm_gcroot(c, 0);
> +  llvm_gcroot(res, 0);
> +  llvm_gcroot(excp, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  c = *(JavaObjectConstructor**)_c;
> +  if (args0) args = *(ArrayObject**)args0;
> +
> +  UserClass* cl = JavaObjectConstructor::getClass(c);
> +  JavaMethod * meth = JavaObjectConstructor::getInternalMethod(c);
> +  assert(cl && meth);
> +
> +
> +  sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;
> +  Signdef* sign = meth->getSignature();
> +  sint32 size = sign->nbArguments;
> +
> +  if (isAbstract(cl->access)) vm->instantiationException(cl);
> +
> +  mvm::ThreadAllocator allocator;
> +  // Allocate a buffer to store the arguments.
> +  jvalue* buf = size ?
> +      (jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;
> +
> +  if (nbArgs == size) {
> +    cl->initialiseClass(vm);
> +    res = cl->doNew(vm);
> +
> +    JavaObject** ptr = (JavaObject**)ArrayObject::getElements(args);
> +    Typedef* const* arguments = sign->getArgumentsType();
> +    // Store the arguments, unboxing primitives if necessary.
> +    for (sint32 i = 0; i < size; ++i) {
> +      JavaObject::decapsulePrimitive(ptr[i], vm, &buf[i], arguments[i]);
> +      if (!arguments[i]->isPrimitive()) {
> +        buf[i].l = reinterpret_cast<jobject>(&ptr[i]);
> +      }
> +    }
> +
> +    JavaThread* th = JavaThread::get();
> +    TRY {
> +      meth->invokeIntSpecialBuf(vm, cl, res, buf);
> +    } CATCH {
> +      excp = th->getJavaException();
> +    } END_CATCH;
> +    if (excp) {
> +      if
> (JavaObject::getClass(excp)->isAssignableFrom(vm->upcalls->newException))
> {
> +        th->clearException();
> +        // If it's an exception, we encapsule it in an
> +        // invocationTargetException
> +        vm->invocationTargetException(excp);
> +      } else {
> +        // If it's an error, throw it again.
> +        th->throwPendingException();
> +      }
> +      res = NULL;
> +    }
> +  } else {
> +    vm->illegalArgumentException("wrong number of arguments");
> +  }
> +
> +  RETURN_FROM_JNI((jobject)th->pushJNIRef(res));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /*
> --
> 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/3106a03c/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:24:51 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:24:51 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_IsSupportedJNIVersion,
 claim we support all known JNI versions.
In-Reply-To: <CAKGWAO-n99-tZ_RSbs8m4pOC3yFMrizm7oeGHpARTAEkNqQ+RQ@mail.gmail.com>
References: <CAKGWAO-n99-tZ_RSbs8m4pOC3yFMrizm7oeGHpARTAEkNqQ+RQ@mail.gmail.com>
Message-ID: <CAPYwfir2Tk6tTi-71tAy89Zsjh05_pdP-CYzR-bHWQ4iDANuTg@mail.gmail.com>

Looks good :)

On Thu, Nov 3, 2011 at 3:30 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Possibly better than a simple "return true" in that we don't claim to
> support JNI versions that are invalid or don't exist yet :).
>
> ~Will
>
> >From 5064cafd6be7fd9987323d8b0604e25784488e70 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 22:31:14 -0500
> Subject: [PATCH 10/17] Impl JVM_IsSupportedJNIVersion, claim we support all
>  known JNI versions.
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |    5 ++++-
>  1 files changed, 4 insertions(+), 1 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 31ea42d..fd7f450 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -429,7 +429,10 @@ JVM_FindLibraryEntry(void *handle, const char *name) {
>
>  JNIEXPORT jboolean JNICALL
>  JVM_IsSupportedJNIVersion(jint version) {
> -  NYI();
> +  return version == JNI_VERSION_1_1 ||
> +         version == JNI_VERSION_1_2 ||
> +         version == JNI_VERSION_1_4 |
> +         version == JNI_VERSION_1_6;
>  }
>
>  /*
> --
> 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/04879bf0/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:26:03 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:26:03 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_NativePath
In-Reply-To: <CAKGWAO-J02XFmREEEuEGB-U+GeexBROssErSJdrz1bPaVHdn-Q@mail.gmail.com>
References: <CAKGWAO-J02XFmREEEuEGB-U+GeexBROssErSJdrz1bPaVHdn-Q@mail.gmail.com>
Message-ID: <CAPYwfio2NOq5NWUiGoyqOmfpHTHaB1zZ5t6mT62KoJbMfcJ7Yw@mail.gmail.com>

Looks good.

On Thu, Nov 3, 2011 at 3:32 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Mostly to get things going along, since it's clearly not a real
> implementation.
>
> Seems to work just fine though.
>
> ~Will
>
> >From af0de8acd69fccb6becfcc25be8530ee872de9bb Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 22:31:50 -0500
> Subject: [PATCH 11/17] Fake impl JVM_NativePath.  Can implement properly
>  later if needed.
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |    3 ++-
>  1 files changed, 2 insertions(+), 1 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index fd7f450..bb11f0d 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -2178,7 +2178,8 @@ JVM_GetLastErrorString(char *buf, int len) {
>  */
>  JNIEXPORT char * JNICALL
>  JVM_NativePath(char * path) {
> -  NYI();
> +  // TODO: Implement me?
> +  return path;
>  }
>
>  /*
> --
> 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/b675d273/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:27:48 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:27:48 +0100
Subject: [vmkit-commits] [PATCH] Add (minimal) signal support regarding
 JVM_FindSignal, JVM_RegisterSignal
In-Reply-To: <CAKGWAO_xJ3hh1pzV-4NqvfxK+SywDRmo3yX+jdO=VdrM23zTjQ@mail.gmail.com>
References: <CAKGWAO_xJ3hh1pzV-4NqvfxK+SywDRmo3yX+jdO=VdrM23zTjQ@mail.gmail.com>
Message-ID: <CAPYwfiqecUEB7LawjGsCC2MC2S0wrvWTfcQdpJC7OXeyNEux_Q@mail.gmail.com>

Looks good!

On Thu, Nov 3, 2011 at 3:32 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Thanks!
>
> ~Will
>
> >From b61e5572ad53bf8c518c0ba458942d0696ad20e8 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 22:41:45 -0500
> Subject: [PATCH 12/17] Add (minimal) signal support regarding
> JVM_FindSignal,
>  JVM_RegisterSignal
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   28 ++++++++++++++++++++++++++--
>  1 files changed, 26 insertions(+), 2 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index bb11f0d..48ffce9 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -1781,7 +1781,8 @@ JVM_GetStackAccessControlContext(JNIEnv *env,
> jclass cls) {
>
>  JNIEXPORT void * JNICALL
>  JVM_RegisterSignal(jint sig, void *handler) {
> -  NYI();
> +  // Don't let signals be registered, yet.
> +  return (void*)-1;
>  }
>
>  JNIEXPORT jboolean JNICALL
> @@ -1791,7 +1792,30 @@ JVM_RaiseSignal(jint sig) {
>
>  JNIEXPORT jint JNICALL
>  JVM_FindSignal(const char *name) {
> -  NYI();
> +  // Map Signal name to integer...
> +  static struct {
> +    const char * name;
> +    int num;
> +  } SignalMap[] =
> +  {
> +    { "TERM", SIGTERM },
> +    { "HUP", SIGHUP },
> +    { "INT", SIGINT }
> +  };
> +  static uint32 signal_count = sizeof(SignalMap)/sizeof(SignalMap[0]);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  for(uint32 i = 0; i < signal_count; ++i) {
> +    if (!strcmp(name, SignalMap[i].name))
> +      RETURN_FROM_JNI(SignalMap[i].num);
> +  }
> +
> +  fprintf(stderr, "Unknown Signal \"%s\", missing entry in table?\n",
> name);
>

Add UNIMPLEMENTED?


> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /*
> --
> 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/d07e5a8a/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:08:38 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:08:38 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_Clone
In-Reply-To: <CAKGWAO_O3ppjyMAB=U5W=9kQvRz8m5XYD44S=qgDgGura9GRhA@mail.gmail.com>
References: <CAKGWAO_O3ppjyMAB=U5W=9kQvRz8m5XYD44S=qgDgGura9GRhA@mail.gmail.com>
Message-ID: <CAPYwfip_fhSkt9Rts=or9QobSrNsD4TDysiW3y8cytai+rNhgw@mail.gmail.com>

Hi Will,

It looks like a big chunk of this code could be shared between the 2 class
libraries. Could you just make a method in JavaObject? Thanks!

Nicolas

On Thu, Nov 3, 2011 at 3:24 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> The cloneNotSupportedException will be uncommented and fixed later,
> when I'm making a pass to fix behavior like that with mauve and the
> like.
>
> ~Will
>
> >From a417116231df8de0a080687e7c6116b4cd3ee457 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 20:36:17 -0500
> Subject: [PATCH 03/17] Impl JVM_Clone
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   73
> ++++++++++++++++++++++++++++++++++-
>  1 files changed, 72 insertions(+), 1 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index b724e73..30a670f 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -159,7 +159,78 @@ JVM_MonitorNotifyAll(JNIEnv *env, jobject obj) {
>
>  JNIEXPORT jobject JNICALL
>  JVM_Clone(JNIEnv *env, jobject obj) {
> -  NYI();
> +  JavaObject* res = NULL;
> +  JavaObject* tmp = NULL;
> +  JavaObject* src = NULL;
> +  llvm_gcroot(res, 0);
> +  llvm_gcroot(tmp, 0);
> +  llvm_gcroot(src, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  src = *(JavaObject**)obj;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = JavaObject::getClass(src);
> +
> +  // If this doesn't inherit the Cloneable interface, it's invalid
> +  // to try to clone it.
> +  if (!JavaObject::instanceOf(src, vm->upcalls->cloneableClass))
> +    NYI(); //vm->cloneNotSupportedException();
> +
> +  if (cl->isArray()) {
> +    UserClassArray* array = cl->asArrayClass();
> +    int length = JavaArray::getSize(src);
> +    res = array->doNew(length, vm);
> +    UserCommonClass* base = array->baseClass();
> +    if (base->isPrimitive()) {
> +      int size = length << base->asPrimitiveClass()->logSize;
> +      memcpy((void*)((uintptr_t)res + sizeof(JavaObject) +
> sizeof(size_t)),
> +             (void*)((uintptr_t)src + sizeof(JavaObject) +
> sizeof(size_t)),
> +             size);
> +    } else {
> +      for (int i = 0; i < length; i++) {
> +        tmp = ArrayObject::getElement((ArrayObject*)src, i);
> +        ArrayObject::setElement((ArrayObject*)res, tmp, i);
> +      }
> +    }
> +  } else {
> +    assert(cl->isClass() && "Not a class!");
> +    res = cl->asClass()->doNew(vm);
> +    while (cl != NULL) {
> +      for (uint32 i = 0; i < cl->asClass()->nbVirtualFields; ++i) {
> +        JavaField& field = cl->asClass()->virtualFields[i];
> +        if (field.isReference()) {
> +          tmp = field.getInstanceObjectField(src);
> +          JavaObject** ptr = field.getInstanceObjectFieldPtr(res);
> +          mvm::Collector::objectReferenceWriteBarrier((gc*)res,
> (gc**)ptr, (gc*)tmp);
> +        } else if (field.isLong()) {
> +          field.setInstanceLongField(res,
> field.getInstanceLongField(src));
> +        } else if (field.isDouble()) {
> +          field.setInstanceDoubleField(res,
> field.getInstanceDoubleField(src));
> +        } else if (field.isInt()) {
> +          field.setInstanceInt32Field(res,
> field.getInstanceInt32Field(src));
> +        } else if (field.isFloat()) {
> +          field.setInstanceFloatField(res,
> field.getInstanceFloatField(src));
> +        } else if (field.isShort() || field.isChar()) {
> +          field.setInstanceInt16Field(res,
> field.getInstanceInt16Field(src));
> +        } else if (field.isByte() || field.isBoolean()) {
> +          field.setInstanceInt8Field(res,
> field.getInstanceInt8Field(src));
> +        } else {
> +          UNREACHABLE();
> +        }
> +      }
> +      cl = cl->super;
> +    }
> +  }
> +
> +  res = (JavaObject*)th->pushJNIRef(res);
> +
> +  RETURN_FROM_JNI((jobject)res);
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /*
> --
> 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/0b682e88/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:43:54 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:43:54 +0100
Subject: [vmkit-commits] [PATCH] In OpenJDK,
 use the 'classes' field of ClassLoader to track VMClassLoader.
In-Reply-To: <CAKGWAO_TZ4X_Yqx+EVtefSSz1_9Jm-UC18YQc3DnxG-MGpH4pA@mail.gmail.com>
References: <CAKGWAO_TZ4X_Yqx+EVtefSSz1_9Jm-UC18YQc3DnxG-MGpH4pA@mail.gmail.com>
Message-ID: <CAPYwfipLHvp8nA2JRgSXMCkoG+1f8pxFiSk=nXRGmrOouk_2EA@mail.gmail.com>

Looks good!

On Thu, Nov 3, 2011 at 3:36 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Traces the internal classloader by stashing a VMClassLoader into the
> 'classes' field.
>
> FWIW the *only* time anyone 'writes' to the classes field is
> initializing it to empty in the constructor.
>
> ~Will
>
> >From 1b728ad7ab762680abe320eaf9f66e1e5c981560 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 22:48:26 -0500
> Subject: [PATCH 13/17] In OpenJDK, use the 'classes' field of ClassLoader
> to
>  track VMClassLoader.
>
> Also, don't just check the 'vmdata' field for non-null, since in OJ it
> will be
> initialized to an empty vector.  Instead, consider the field uninitialized
> if
> it's either null or of the wrong type.
> ---
>  lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp |    7 +++----
>  lib/J3/VMCore/JnjvmClassLoader.cpp      |    7 +++++--
>  2 files changed, 8 insertions(+), 6 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> index 43ff227..22db276 100644
> --- a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> +++ b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> @@ -552,10 +552,9 @@ void
> Classpath::initialiseClasspath(JnjvmClassLoader* loader) {
>     UPCALL_FIELD(loader, "java/nio/Buffer", "address",
> "Lgnu/classpath/Pointer;",
>                  ACC_VIRTUAL);
>
> -  // TODO: Resolve how to tie a ClassLoader to its internal representation
> -  //vmdataClassLoader =
> -  //  UPCALL_FIELD(loader, "java/lang/ClassLoader", "vmdata",
> "Ljava/lang/Object;",
> -  //               ACC_VIRTUAL);
> +  vmdataClassLoader =
> +    UPCALL_FIELD(loader, "java/lang/ClassLoader", "classes",
> "Ljava/util/Vector;",
> +                 ACC_VIRTUAL);
>
>   newStackTraceElement =
>     UPCALL_CLASS(loader, "java/lang/StackTraceElement");
> diff --git a/lib/J3/VMCore/JnjvmClassLoader.cpp
> b/lib/J3/VMCore/JnjvmClassLoader.cpp
> index 5444941..fd1eabb 100644
> --- a/lib/J3/VMCore/JnjvmClassLoader.cpp
> +++ b/lib/J3/VMCore/JnjvmClassLoader.cpp
> @@ -808,11 +808,14 @@
> JnjvmClassLoader::getJnjvmLoaderFromJavaObject(JavaObject* loader,
> Jnjvm* vm) {
>   vmdata =
>
> (VMClassLoader*)(upcalls->vmdataClassLoader->getInstanceObjectField(loader));
>
> -  if (vmdata == NULL) {
> +  // If the vmdata field isn't set yet, or it's set to something other
> than
> +  // a VMClassLoader (which happens in the OpenJDK port), then initialize
> +  // the field now.
> +  if (vmdata == NULL || !VMClassLoader::isVMClassLoader(vmdata)) {
>     JavaObject::acquire(loader);
>     vmdata =
>
> (VMClassLoader*)(upcalls->vmdataClassLoader->getInstanceObjectField(loader));
> -    if (!vmdata) {
> +    if (!vmdata || !VMClassLoader::isVMClassLoader(vmdata)) {
>       vmdata = VMClassLoader::allocate();
>       mvm::BumpPtrAllocator* A = new mvm::BumpPtrAllocator();
>       JCL = new(*A, "Class loader") JnjvmClassLoader(*A,
> *vm->bootstrapLoader,
> --
> 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/5f672281/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:47:15 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:47:15 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_Interrupt, JVM_IsInterrupted
In-Reply-To: <CAKGWAO-bgC06FJPcMOvDoroewZMyAmD-zGPYKUDXA9WeU=e9Yg@mail.gmail.com>
References: <CAKGWAO-bgC06FJPcMOvDoroewZMyAmD-zGPYKUDXA9WeU=e9Yg@mail.gmail.com>
Message-ID: <CAPYwfipe1g4NcfE_nzmGDN=ftGg8RkFwz6AdzfFEX8zg9+paZw@mail.gmail.com>

Looks good. Again, if you could try to share that code... :)

On Thu, Nov 3, 2011 at 3:38 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Very similar to classpath code, only the field type is different, so
> should be using the "Long" instance accessors, not Object.
>
> ~Will
>
> >From effd45eb93189cbcd18480e691e4027fcaac4868 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Thu, 3 Nov 2011 08:57:13 -0500
> Subject: [PATCH 16/17] Impl JVM_Interrupt, JVM_IsInterrupted
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   70
> +++++++++++++++++++++++++++++++++--
>  1 files changed, 66 insertions(+), 4 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 48ffce9..954234d 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -700,13 +700,75 @@ JVM_CountStackFrames(JNIEnv *env, jobject thread) {
>  }
>
>  JNIEXPORT void JNICALL
> -JVM_Interrupt(JNIEnv *env, jobject thread) {
> -  NYI();
> +JVM_Interrupt(JNIEnv *env, jobject _thread) {
> +  JavaObject * thread = 0;
> +  llvm_gcroot(thread, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  thread = *(JavaObject**)_thread;
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JavaField * field = vm->upcalls->eetop;
> +
> +  // It's possible that the thread to be interrupted has not finished
> +  // its initialization. Wait until the initialization is done.
> +  while (field->getInstanceLongField(thread) == 0)
> +    mvm::Thread::yield();
> +
> +  JavaThread* th = (JavaThread*)field->getInstanceLongField(thread);
> +  th->lockingThread.interruptFlag = 1;
> +  mvm::FatLock* lock = th->lockingThread.waitsOn;
> +
> +  // If the thread is blocked on a wait. We also verify nextWaiting in
> case
> +  // the thread has been notified.
> +  if (lock && th->lockingThread.nextWaiting) {
> +    th->lockingThread.state = mvm::LockingThread::StateInterrupted;
> +
> +    // Make sure the thread is waiting.
> +    uint32 locked = 0;
> +    while (true) {
> +      locked = (lock->tryAcquire() == 0);
> +      if (locked || (lock->getOwner() != th && lock->getOwner() != 0))
> +        break;
> +      else mvm::Thread::yield();
> +    }
> +
> +    // Interrupt the thread.
> +    th->lockingThread.varcond.signal();
> +
> +    // Release the lock if we acquired it.
> +    if (locked) lock->release(lock->getAssociatedObject(),
> vm->lockSystem);
> +  }
> +
> +  // Here we could also raise a signal for interrupting I/O
> +
> +  RETURN_VOID_FROM_JNI
> +  END_JNI_EXCEPTION
>  }
>
>  JNIEXPORT jboolean JNICALL
> -JVM_IsInterrupted(JNIEnv *env, jobject thread, jboolean clearInterrupted)
> {
> -  NYI();
> +JVM_IsInterrupted(JNIEnv *env, jobject _thread, jboolean
> clearInterrupted) {
> +  JavaObject * thread = 0;
> +  llvm_gcroot(thread, 0);
> +
> +  bool interrupt = false;
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  thread = *(JavaObject**)_thread;
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JavaField * field = vm->upcalls->eetop;
> +
> +  JavaThread* jth = (JavaThread*)field->getInstanceLongField(thread);
> +  interrupt = (jboolean)jth->lockingThread.interruptFlag;
> +
> +  if (clearInterrupted)
> +    jth->lockingThread.interruptFlag = 0;
> +
> +  RETURN_FROM_JNI(interrupt);
> +
> +  END_JNI_EXCEPTION
> +
> +  return false;
>  }
>
>  JNIEXPORT jboolean JNICALL
> --
> 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/c455d099/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:57:19 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:57:19 +0100
Subject: [vmkit-commits] [PATCH] Refactor AOT into ClassLib-specific
 components, add support for OpenJDK
In-Reply-To: <CAKGWAO9O1gMuvhksmqg6mqJHWMX4YYPPxPnFVmNBkkd-0P3FTQ@mail.gmail.com>
References: <CAKGWAO9O1gMuvhksmqg6mqJHWMX4YYPPxPnFVmNBkkd-0P3FTQ@mail.gmail.com>
Message-ID: <CAPYwfir+6vdWPM+-wvXc2kLgvuffs+6iJEf3apic8OuvJ2AQ1Q@mail.gmail.com>

Don't you need to fix java.lang.String also?

There is a problem if we don't add the extra fields in LLVM's struct: the
object will be emitted in the executable, and won't be big enough to
contain the two extra fields.

I think we should drop emitting java.lang.Class instances in AOT, because
it does not work with a precise GC. When compiling MMTk (which should be
the only user of AOT without a precise GC), we could be able to just emit
null there. Could you try and confirm?

If it turns out it does not work, we could also try to put a dummy
java.lang.Object or java.lang.Class, following the object layout but
without containing any data. In any case, your change in
vmjcAddPrecompiledClass should be removed.

On Thu, Nov 3, 2011 at 3:37 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Thanks!
>
> ~Will
>
> >From b036d7358b9e57da79e71f04e1869bb9e2015718 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 22:54:23 -0500
> Subject: [PATCH 14/17] Refactor AOT into ClassLib-specific components, add
>  support for OpenJDK
>
> * Fix the JavaClass field layout for OpenJDK
> * Restore the Class mapping (stored in an 'extra' field).  Ignore PD for
> now,
>    since in the Classpath port we emit a null constant for it anyway.
> ---
>  lib/J3/Compiler/JavaAOTCompiler.cpp          |   36 +++------------
>  lib/J3/Compiler/JavaAOTCompilerClasspath.inc |   39 ++++++++++++++++
>  lib/J3/Compiler/JavaAOTCompilerOpenJDK.inc   |   63
> ++++++++++++++++++++++++++
>  lib/J3/VMCore/Precompiled.cpp                |    4 ++
>  4 files changed, 112 insertions(+), 30 deletions(-)
>  create mode 100644 lib/J3/Compiler/JavaAOTCompilerClasspath.inc
>  create mode 100644 lib/J3/Compiler/JavaAOTCompilerOpenJDK.inc
>
> diff --git a/lib/J3/Compiler/JavaAOTCompiler.cpp
> b/lib/J3/Compiler/JavaAOTCompiler.cpp
> index d16d57c..11488df 100644
> --- a/lib/J3/Compiler/JavaAOTCompiler.cpp
> +++ b/lib/J3/Compiler/JavaAOTCompiler.cpp
> @@ -687,36 +687,6 @@ Constant*
> JavaAOTCompiler::CreateConstantForBaseObject(CommonClass* cl) {
>   return ConstantStruct::get(STy, Elmts);
>  }
>
> -Constant* JavaAOTCompiler::CreateConstantFromJavaClass(CommonClass* cl) {
> -  assert(!useCooperativeGC());
> -  Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
> -  LLVMClassInfo* LCI = getClassInfo(javaClass);
> -  StructType* STy =
> -    dyn_cast<StructType>(LCI->getVirtualType()->getContainedType(0));
> -
> -  std::vector<Constant*> Elmts;
> -
> -  // JavaObject
> -  Elmts.push_back(CreateConstantForBaseObject(javaClass));
> -
> -  // signers
> -  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> -
> -  // pd
> -  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> -
> -  // vmdata
> -  Constant* Cl = getNativeClass(cl);
> -  Cl = ConstantExpr::getCast(Instruction::BitCast, Cl,
> -                             JavaIntrinsics.JavaObjectType);
> -  Elmts.push_back(Cl);
> -
> -  // constructor
> -  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> -
> -  return ConstantStruct::get(STy, Elmts);
> -}
> -
>  Constant* JavaAOTCompiler::CreateConstantFromJavaObject(JavaObject* obj) {
>   assert(!useCooperativeGC());
>   CommonClass* cl = JavaObject::getClass(obj);
> @@ -2557,3 +2527,9 @@ CommonClass*
> JavaAOTCompiler::getUniqueBaseClass(CommonClass* cl) {
>   }
>   return currentClass;
>  }
> +
> +#ifdef USE_OPENJDK
> +#include "JavaAOTCompilerOpenJDK.inc"
> +#else
> +#include "JavaAOTCompilerClasspath.inc"
> +#endif
> diff --git a/lib/J3/Compiler/JavaAOTCompilerClasspath.inc
> b/lib/J3/Compiler/JavaAOTCompilerClasspath.inc
> new file mode 100644
> index 0000000..41199ec
> --- /dev/null
> +++ b/lib/J3/Compiler/JavaAOTCompilerClasspath.inc
> @@ -0,0 +1,39 @@
> +//===----- JavaAOTCompilerClasspath.inc - GNUClasspath AOT support
> --------===//
> +//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +Constant* JavaAOTCompiler::CreateConstantFromJavaClass(CommonClass* cl) {
> +  assert(!useCooperativeGC());
> +  Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
> +  LLVMClassInfo* LCI = getClassInfo(javaClass);
> +  StructType* STy =
> +    dyn_cast<StructType>(LCI->getVirtualType()->getContainedType(0));
> +
> +  std::vector<Constant*> Elmts;
> +
> +  // JavaObject
> +  Elmts.push_back(CreateConstantForBaseObject(javaClass));
> +
> +  // signers
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +
> +  // pd
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +
> +  // vmdata
> +  Constant* Cl = getNativeClass(cl);
> +  Cl = ConstantExpr::getCast(Instruction::BitCast, Cl,
> +                             JavaIntrinsics.JavaObjectType);
> +  Elmts.push_back(Cl);
> +
> +  // constructor
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +
> +  return ConstantStruct::get(STy, Elmts);
> +}
> +
> diff --git a/lib/J3/Compiler/JavaAOTCompilerOpenJDK.inc
> b/lib/J3/Compiler/JavaAOTCompilerOpenJDK.inc
> new file mode 100644
> index 0000000..367c56f
> --- /dev/null
> +++ b/lib/J3/Compiler/JavaAOTCompilerOpenJDK.inc
> @@ -0,0 +1,63 @@
> +//===----- JavaAOTCompilerOpenJDK.inc - OpenJDK AOT support
> ---------------===//
> +//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +Constant* JavaAOTCompiler::CreateConstantFromJavaClass(CommonClass* cl) {
> +  assert(!useCooperativeGC());
> +  Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
> +  LLVMClassInfo* LCI = getClassInfo(javaClass);
> +  StructType* STy =
> +    dyn_cast<StructType>(LCI->getVirtualType()->getContainedType(0));
> +
> +  std::vector<Constant*> Elmts;
> +
> +  // JavaObject
> +  Elmts.push_back(CreateConstantForBaseObject(javaClass));
> +
> +  // Constructor
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // newInstanceCallerCache
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // Name
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // declaredFields
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // publicFields
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // declaredMethods
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // publicMethods
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // declaredConstructors
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // publicConstructors
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // declaredPublicFields
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // declaredPublicMethods
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // classRedefinedCount
> +  Elmts.push_back(ConstantInt::get(Type::getInt32Ty(getLLVMContext()),
> 0));
> +  // lastRedefinedCount
> +  Elmts.push_back(ConstantInt::get(Type::getInt32Ty(getLLVMContext()),
> 0));
> +  // genericInfo
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // enumConstants
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // enumConstantDictionary
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // annotations
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // declaredAnnotations
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +  // annotationType
> +  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> +
> +  return ConstantStruct::get(STy, Elmts);
>

There will be a problem here that java.lang.Class objects will not be
allocated properly. They won't be able to contain the two extra fields,


> +}
> +
> diff --git a/lib/J3/VMCore/Precompiled.cpp b/lib/J3/VMCore/Precompiled.cpp
> index e469eaf..8fdd213 100644
> --- a/lib/J3/VMCore/Precompiled.cpp
> +++ b/lib/J3/VMCore/Precompiled.cpp
> @@ -11,6 +11,7 @@
>  #include <dlfcn.h>
>  #include "mvm/MethodInfo.h"
>
> +#include "ClasspathReflect.h"
>  #include "JavaClass.h"
>  #include "JavaUpcalls.h"
>  #include "JnjvmClassLoader.h"
> @@ -81,6 +82,9 @@ Class* JnjvmClassLoader::loadClassFromSelf(Jnjvm*
> vm, const char* name) {
>  extern "C" void vmjcAddPreCompiledClass(JnjvmClassLoader* JCL,
>                                         CommonClass* cl) {
>   cl->classLoader = JCL;
> +  // Ensure the Class mapping field is set properly.
> +  // (Needed for OpenJDK, since this mapping isn't part of the Class type)
> +  JavaObjectClass::setClass((JavaObjectClass*)cl->getDelegatee(),cl);
>

Did you actually run some code that failed because of this not being set?


>  }
>
>
> --
> 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/25679e94/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 14:57:54 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 22:57:54 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_DefineClass and variants. No
 support for source or verification yet.
In-Reply-To: <CAKGWAO9iqUieYin4WX2=FO-ygLv6k0=Ze0Xq1n2ENpSaD0HgXQ@mail.gmail.com>
References: <CAKGWAO9iqUieYin4WX2=FO-ygLv6k0=Ze0Xq1n2ENpSaD0HgXQ@mail.gmail.com>
Message-ID: <CAPYwfipM67h6cLbwMtSKMUK2KrK36ExgrvtkFEKxfDp0kqgjkQ@mail.gmail.com>

Looks good!

On Thu, Nov 3, 2011 at 3:39 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> ~Will
>
> >From 1d583aa7435e95f243c2e27008c31f52d322938b Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Thu, 3 Nov 2011 09:10:11 -0500
> Subject: [PATCH 17/17] Impl JVM_DefineClass and variants.  No support for
>  source or verification yet.
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   31 ++++++++++++++++++++++++++++---
>  1 files changed, 28 insertions(+), 3 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 954234d..c08908b 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -1114,7 +1114,30 @@ JVM_FindLoadedClass(JNIEnv *env, jobject
> _loader, jstring name) {
>  JNIEXPORT jclass JNICALL
>  JVM_DefineClass(JNIEnv *env, const char *name, jobject _loader, const
> jbyte *buf,
>                 jsize len, jobject pd) {
> -  NYI();
> +  JavaObject * loader = 0;
> +  llvm_gcroot(loader, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  loader = _loader ? *(JavaObject**)_loader : 0;
> +
> +  jclass res;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JnjvmClassLoader* JCL = NULL;
> +  JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
> +
> +  ClassBytes * bytes = new (JCL->allocator, len) ClassBytes(len);
> +  memcpy(bytes->elements,buf,len);
> +  const UTF8* utfName = JCL->asciizConstructUTF8(name);
> +  UserClass *cl = JCL->constructClass(utfName, bytes);
> +
> +  if (cl) res = (jclass)cl->getClassDelegateePtr(vm);
> +
> +  RETURN_FROM_JNI(res);
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /* Define a class with a source (added in JDK1.5) */
> @@ -1122,7 +1145,8 @@ JNIEXPORT jclass JNICALL
>  JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader,
>                           const jbyte *buf, jsize len, jobject pd,
>                           const char *source) {
> -  NYI();
> +  // Discard source for now
> +  return JVM_DefineClass(env, name, loader, buf, len, pd);
>  }
>
>  /* Define a class with a source with conditional verification (added HSX
> 14)
> @@ -1134,7 +1158,8 @@ JNIEXPORT jclass JNICALL
>  JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name, jobject
> loader,
>                               const jbyte *buf, jsize len, jobject pd,
>                               const char *source, jboolean verify) {
> -  NYI();
> +  // Discard source and verification
> +  return JVM_DefineClass(env, name, loader, buf, len, pd);
>  }
>
>  /*
> --
> 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/23f69ff9/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 15:06:30 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 23:06:30 +0100
Subject: [vmkit-commits] [PATCH] Remove System.err.println from mmtk
 stuff to fix dep on bootstrap
In-Reply-To: <CAKGWAO9vi2z4GBRiSecCzoG_S-L2AkjkDLxAu1jvOL0TREUtxQ@mail.gmail.com>
References: <CAKGWAO9vi2z4GBRiSecCzoG_S-L2AkjkDLxAu1jvOL0TREUtxQ@mail.gmail.com>
Message-ID: <CAPYwfip3xxs-ma0mk9dc=H0e8JOs59tj36qV3AsJeE98C0CuPg@mail.gmail.com>

Hi Will,

On Thu, Nov 3, 2011 at 3:48 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> This change seems benign, but I'm not sure if it's masking some other
> bug I should be concerned about.
>
> Patch primarily a discussion point, although could be committed too
> (since it's rather minor).
>
> FWIW, with this patch (and the previous ones), we can build a
> OpenJDK-based VMKit that can run many simple codes, and on larger
> codes seems to only fail when encountering some of the many NYI()'d
> (or intentionally unimplemented) pieces.  Which is kinda neat! :)
>

Definitely! That's a giant step! Any plans on sending the instructions on
which OpenJDK to use? How to configure, etc? :)


> In the future I hope to focus on getting it to run various codes
> better (dacapo being my big goal, but not the full story), and try to
> generally improve misc behavior compatibility/compliance-wise :).
>

Big encouragements for getting dacapo to run, especially all benchmarks of
the latest version (which do not run on GNU Classpath).

There is also SpecJVM2008 I think, that anyone can download. It'd be neat
to have that running too :)


>
> Thanks!
>
> ~Will
>
> >From 0462e91eb86e28c00707c40d624853eb51679904 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 23:02:45 -0500
> Subject: [PATCH 15/17] Remove System.err.println from mmtk stuff to fix dep
>  on bootstrap
>
> Not entirely sure, but with these present we get linker errors with
> libFinalMMtk.a on misc pieces that are pulled in from System.err,
>  namely things like sun.nio.cs.StreamEncoder.
>

This may just be a limitation of the AOT compiler, which pulls out more
than it actually needs. I'd be interested to see the error messages if you
still have them.

Patch is fine to commit because it just touches mmtk/src/org/j3 files. Note
that if it were to touch other mmtk/src/org files, it wouldn't be as fine
because it's code that is imported from mmtk. And this code we should try
to not deviate from it, to avoid merge conflicts.

Again, that's a great step forward! Nice work. I'm looking forward to see
all the dacapo benchmarks run on vmkit :)

Nicolas


> On one hand this seems like an undiagnosed failure of the precompilation,
>   however we're not trying to build System.err things while
>   compiling mmtk, and this change is relatively minor.
> ---
>  mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java |    4 ++--
>  1 files changed, 2 insertions(+), 2 deletions(-)
>
> diff --git a/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java
> b/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java
> index 8dc8f82..9f90b8e 100644
> --- a/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java
> +++ b/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java
> @@ -53,7 +53,7 @@ public final class BuildTimeConfig extends
> org.mmtk.vm.BuildTimeConfig {
>     if (default_property_file == null) {
>       propFileName = System.getProperty(property_file_property);
>       if (propFileName == null) {
> -        System.err.println(property_file_property+" must specify a
> properties file");
> +        //System.err.println(property_file_property+" must specify a
> properties file");
>         VM.sysExit(1);
>       }
>     } else {
> @@ -67,7 +67,7 @@ public final class BuildTimeConfig extends
> org.mmtk.vm.BuildTimeConfig {
>       propFileStream.close();
>     } catch (FileNotFoundException e) {
>       if (!propFileName.equals(default_property_file)) {
> -        System.err.println(propFileName+" not found.");
> +        //System.err.println(propFileName+" not found.");
>         VM.sysExit(1);
>       }
>     } catch (IOException e) {
> --
> 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/be7d5faf/attachment.html>

From nicolas.geoffray at gmail.com  Fri Nov  4 15:11:32 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 4 Nov 2011 23:11:32 +0100
Subject: [vmkit-commits] [PATCH/DISCUSS] registerNatives Lock,
	avoid deadlock
In-Reply-To: <CAKGWAO8AT0G1OAsHBz17j1Pm4-7JbuSPPL0SyA+DmKUtd2Q4Lg@mail.gmail.com>
References: <CAKGWAO8AT0G1OAsHBz17j1Pm4-7JbuSPPL0SyA+DmKUtd2Q4Lg@mail.gmail.com>
Message-ID: <CAPYwfio+K_v8zzLsc2ZjkNFsDUpS7spD+0JAvOzuJdLnWCaXWQ@mail.gmail.com>

Oh yes, because getRegisteredNative is called while compiling, and the
class loader lock may be used indirectly by application, we may have a
deadlock situation.

Besides fixing the problem, I think your patch is cleaner because it makes
the locking local. Apologies for suggesting you a bogus implementation. I'm
surprised you encountered the bug that early though! Are you running vmkit
w/openjdk on an application that creates mulitple threads?

Please apply!

Nicolas

On Thu, Nov 3, 2011 at 3:57 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Hi,
>
> I'm noticing deadlocks occurring in the OpenJDK port involving the
> registerNatives stuff.
>
> Looking at the lock acquisition/release things look clean (the only
> way to exit without releasing a lock is through an assertion
> failure)--but I don't know what kinds of larger lock-related
> dependencies/assumptions/orderings there might be.  Apparently the
> existing code does do something wrong, however.
>
> Inlined below is a patch that simply gives registerNatives its own
> lock, which seems to resolve these issues in all cases (the deadlock
> occurs reliably in the codes that trigger this).  However I don't like
> "I don't know what was wrong before" bits, and thought I'd bounce this
> off you before deep-diving the locking to see what's wrong.
>
> FWIW the other locks held during deadlock are the protectIR() locks.
>
> Thanks for your time! :)
>
> ~Will
>
> >From d28307a26fdecdddb96273a813451e56216857ab Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 2 Nov 2011 17:19:31 -0500
> Subject: [PATCH] Add new 'nativesLock' to protect the registerNatives map.
>
> This fixes various deadlock scenarios when using the other lock.
> Not sure what caused them, but this works for now and is conceptually
> a different lock anyway.
>
> Avoiding debugging the other version for now :).
> ---
>  lib/J3/VMCore/JnjvmClassLoader.cpp |    8 ++++----
>  lib/J3/VMCore/JnjvmClassLoader.h   |    4 ++++
>  2 files changed, 8 insertions(+), 4 deletions(-)
>
> diff --git a/lib/J3/VMCore/JnjvmClassLoader.cpp
> b/lib/J3/VMCore/JnjvmClassLoader.cpp
> index 97b598e..59659c5 100644
> --- a/lib/J3/VMCore/JnjvmClassLoader.cpp
> +++ b/lib/J3/VMCore/JnjvmClassLoader.cpp
> @@ -1046,17 +1046,17 @@ JavaString**
> StringList::addString(JnjvmClassLoader* JCL, JavaString* obj) {
>  }
>
>  void JnjvmClassLoader::registerNative(JavaMethod * meth, word_t fnPtr) {
> -  lock.lock();
> +  nativesLock.lock();
>   // Don't support multiple levels of registerNatives
>   assert(registeredNatives.find(meth) == registeredNatives.end());
>
>   registeredNatives[meth] = fnPtr;
> -  lock.unlock();
> +  nativesLock.unlock();
>  }
>
>  word_t JnjvmClassLoader::getRegisteredNative(const JavaMethod * meth) {
> -  lock.lock();
> +  nativesLock.lock();
>   word_t res = registeredNatives[meth];
> -  lock.unlock();
> +  nativesLock.unlock();
>   return res;
>  }
> diff --git a/lib/J3/VMCore/JnjvmClassLoader.h
> b/lib/J3/VMCore/JnjvmClassLoader.h
> index f5891b0..3c1824b 100644
> --- a/lib/J3/VMCore/JnjvmClassLoader.h
> +++ b/lib/J3/VMCore/JnjvmClassLoader.h
> @@ -113,6 +113,10 @@ protected:
>   ///
>   std::map<const JavaMethod*,word_t> registeredNatives;
>
> +  /// nativesLock - Locks the registeredNatives map above
> +  ///
> +  mvm::LockRecursive nativesLock;
> +
>  public:
>
>   /// allocator - Reference to the memory allocator, which will allocate
> UTF8s,
> --
> 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/c76fbc26/attachment.html>

From wdietz2 at illinois.edu  Sat Nov  5 14:03:15 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 5 Nov 2011 16:03:15 -0500
Subject: [vmkit-commits] [PATCH] Impl JVM_GetClassContext
In-Reply-To: <CAPYwfio5DKfNaBthTggTBwLJfRi0epOxHb0LEARB2EXZpSQ5FA@mail.gmail.com>
References: <CAKGWAO9UHLbRGpNLPLM6-32sEspvYs4hyuRpA=tLn7mE9pDznw@mail.gmail.com>
	<CAPYwfio5DKfNaBthTggTBwLJfRi0epOxHb0LEARB2EXZpSQ5FA@mail.gmail.com>
Message-ID: <CAKGWAO9gKaDnqfDPZu8rV2EQrV5MfiueprAwH6hJrp1TxThUYA@mail.gmail.com>

On Fri, Nov 4, 2011 at 4:10 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
>
>
> On Thu, Nov 3, 2011 at 3:25 PM, Will Dietz <wdietz2 at illinois.edu> wrote:
>>
>> Inlined below.
>>
>> ~Will
>>
>> >From 27a8b66190db992968e8674d3832bb6176cd9b35 Mon Sep 17 00:00:00 2001
>> From: Will Dietz <w at wdtz.org>
>> Date: Wed, 2 Nov 2011 20:36:57 -0500
>> Subject: [PATCH 04/17] Impl JVM_GetClassContext
>>
>> ---
>>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   32
>> +++++++++++++++++++++++++++++++-
>>  1 files changed, 31 insertions(+), 1 deletions(-)
>>
>> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
>> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
>> index 30a670f..9305e66 100644
>> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
>> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
>> @@ -742,7 +742,37 @@ JVM_CurrentClassLoader(JNIEnv *env) {
>>
>>  JNIEXPORT jobjectArray JNICALL
>>  JVM_GetClassContext(JNIEnv *env) {
>> -  NYI();
>> +  ArrayObject* result = NULL;
>> +  JavaObject* delegatee = NULL;
>> +  llvm_gcroot(result, 0);
>> +  llvm_gcroot(delegatee, 0);
>> +
>> +  BEGIN_JNI_EXCEPTION
>> +
>> +  JavaThread* th = JavaThread::get();
>> +  Jnjvm* vm = th->getJVM();
>> +  uint32 length = th->getFrameContextLength();
>> +
>> +  mvm::ThreadAllocator allocator;
>> +  uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *
>> sizeof(uintptr_t));
>> +
>> +  uint32 finalSize = th->getJavaFrameContext((void**)buffer);
>> +
>> +  result = (ArrayObject*)
>> +    vm->upcalls->stackTraceArray->doNew(finalSize, vm);
>
> This should not be a stackTraceArray but a classArrayClass, right? You're
> storing java.lang.Class in the lines above.
>

Oh, dear.  You're definitely right.  I'll fix this when updating to
better code-sharing :).

~Will



From wdietz2 at illinois.edu  Sat Nov  5 14:04:26 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 05 Nov 2011 21:04:26 -0000
Subject: [vmkit-commits] [vmkit] r143824 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111105210426.2A19E2A6C12C@llvm.org>

Author: wdietz2
Date: Sat Nov  5 16:04:25 2011
New Revision: 143824

URL: http://llvm.org/viewvc/llvm-project?rev=143824&view=rev
Log:
Impl JVM_{FindClassFromClassLoader,FindClassFromBootLoader,FindLoadedClass}

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143824&r1=143823&r2=143824&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Sat Nov  5 16:04:25 2011
@@ -861,12 +861,52 @@
 JNIEXPORT jclass JNICALL
 JVM_FindClassFromClassLoader(JNIEnv *env, const char *name, jboolean init,
                              jobject _loader, jboolean throwError) {
-  NYI();
+  BEGIN_JNI_EXCEPTION
+
+  JavaObject * loader = _loader ? *(JavaObject**)_loader : 0;
+  llvm_gcroot(loader, 0);
+
+  jclass res;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader* JCL =
+    JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
+
+  CommonClass * Cl = JCL->loadClassFromAsciiz(name, true, throwError);
+  if (Cl) {
+    if (init && Cl->asClass())
+      Cl->asClass()->initialiseClass(vm);
+    res = (jclass)Cl->getClassDelegateePtr(vm);
+  }
+  else {
+    vm->classNotFoundException(vm->asciizToStr(name));
+  }
+
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jclass JNICALL
 JVM_FindClassFromBootLoader(JNIEnv *env, const char *name) {
-  NYI();
+  BEGIN_JNI_EXCEPTION
+
+  jclass res = 0;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader* JCL = vm->bootstrapLoader;
+
+  CommonClass * Cl = JCL->loadClassFromAsciiz(name, true, false);
+  if (Cl) {
+    res = (jclass)Cl->getClassDelegateePtr(vm);
+  }
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /*
@@ -881,7 +921,27 @@
 /* Find a loaded class cached by the VM */
 JNIEXPORT jclass JNICALL
 JVM_FindLoadedClass(JNIEnv *env, jobject _loader, jstring name) {
-  NYI();
+  JavaObject * loader = 0;
+  llvm_gcroot(loader, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader* JCL = NULL;
+
+  JavaString * str = *(JavaString**)name;
+
+  loader = *(JavaObject**)_loader;
+
+  CommonClass * Cl = 0;
+
+  JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
+  if (JCL)
+   Cl = JCL->lookupClassFromJavaString(str);
+  jclass res = Cl ? (jclass)Cl->getClassDelegateePtr(vm) : 0;
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+
 }
 
 /* Define a class */




From wdietz2 at illinois.edu  Sat Nov  5 14:06:03 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 05 Nov 2011 21:06:03 -0000
Subject: [vmkit-commits] [vmkit] r143825 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111105210603.172032A6C12C@llvm.org>

Author: wdietz2
Date: Sat Nov  5 16:06:02 2011
New Revision: 143825

URL: http://llvm.org/viewvc/llvm-project?rev=143825&view=rev
Log:
Impl more JVM_* methods--Is{Interface,Array,Primitive},GetPD,GetCompType

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143825&r1=143824&r2=143825&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Sat Nov  5 16:06:02 2011
@@ -1005,7 +1005,24 @@
 
 JNIEXPORT jboolean JNICALL
 JVM_IsInterface(JNIEnv *env, jclass cls) {
-  NYI();
+  jboolean res = JNI_FALSE;
+
+  JavaObject * Cl = 0;
+  llvm_gcroot(Cl, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  res = cl->isInterface();
+
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+
+  return JNI_FALSE;
 }
 
 JNIEXPORT jobjectArray JNICALL
@@ -1020,7 +1037,20 @@
 
 JNIEXPORT jobject JNICALL
 JVM_GetProtectionDomain(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObjectClass * JOC = 0;
+  JavaObject * pd = 0;
+  llvm_gcroot(JOC, 0);
+  llvm_gcroot(pd, 0);
+  BEGIN_JNI_EXCEPTION
+
+  JOC = *(JavaObjectClass**)cls;
+  pd = JavaObjectClass::getProtectionDomain(JOC);
+
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(pd));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT void JNICALL
@@ -1030,17 +1060,64 @@
 
 JNIEXPORT jboolean JNICALL
 JVM_IsArrayClass(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObject * Cl = 0;
+  llvm_gcroot(Cl, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  RETURN_FROM_JNI(cl->isArray());
+
+  END_JNI_EXCEPTION
+
+  return JNI_FALSE;
 }
 
 JNIEXPORT jboolean JNICALL
 JVM_IsPrimitiveClass(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObject * Cl = 0;
+  llvm_gcroot(Cl, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  RETURN_FROM_JNI(cl->isPrimitive());
+
+  END_JNI_EXCEPTION
+
+  return JNI_FALSE;
 }
 
 JNIEXPORT jclass JNICALL
 JVM_GetComponentType(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObject * Cl = 0;
+  JavaObject* res = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(res, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  if (cl->isArray()) {
+    UserCommonClass* bc = cl->asArrayClass()->baseClass();
+    res = (JavaObject*)bc->getClassDelegateePtr(vm);
+  } else {
+    res = 0;
+  }
+
+  RETURN_FROM_JNI((jclass)res);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jint JNICALL




From wdietz2 at illinois.edu  Sat Nov  5 14:06:04 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 05 Nov 2011 21:06:04 -0000
Subject: [vmkit-commits] [vmkit] r143826 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111105210604.CBD562A6C12C@llvm.org>

Author: wdietz2
Date: Sat Nov  5 16:06:04 2011
New Revision: 143826

URL: http://llvm.org/viewvc/llvm-project?rev=143826&view=rev
Log:
Impl JVM_GetClass{Modifiers,GetClassAccessFlags}

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143826&r1=143825&r2=143826&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Sat Nov  5 16:06:04 2011
@@ -1122,7 +1122,27 @@
 
 JNIEXPORT jint JNICALL
 JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObject * Cl = 0;
+  llvm_gcroot(Cl, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();;
+
+  jint res = cl->getAccess();
+
+  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
+    // javac may put that flag to inner classes of enum classes.
+    res &= ~ACC_ENUM;
+  }
+
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jobjectArray JNICALL
@@ -1394,7 +1414,23 @@
    valid. */
 JNIEXPORT jint JNICALL
 JVM_GetClassAccessFlags(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObject * Cl = 0;
+  llvm_gcroot(Cl, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  assert(cl->isClass());
+
+  // TODO: Verify this is doing what this function is supposed to do
+  // (In particular regarding the comment block above)
+  RETURN_FROM_JNI(cl->asClass()->access);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /* The following two reflection routines are still needed due to startup time issues */




From wdietz2 at illinois.edu  Sat Nov  5 14:06:06 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 05 Nov 2011 21:06:06 -0000
Subject: [vmkit-commits] [vmkit] r143827 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111105210606.807A52A6C12C@llvm.org>

Author: wdietz2
Date: Sat Nov  5 16:06:06 2011
New Revision: 143827

URL: http://llvm.org/viewvc/llvm-project?rev=143827&view=rev
Log:
Impl JVM_GetClassName

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143827&r1=143826&r2=143827&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Sat Nov  5 16:06:06 2011
@@ -977,7 +977,25 @@
 
 JNIEXPORT jstring JNICALL
 JVM_GetClassName(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObject * result = 0;
+  JavaObject * Cl = 0;
+  llvm_gcroot(result, 0);
+  llvm_gcroot(Cl, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObject**)cls;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  const UTF8* iname = cl->getName();
+  result = JavaString::internalToJava(iname, vm);
+
+  RETURN_FROM_JNI((jstring)th->pushJNIRef(result));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jobjectArray JNICALL




From wdietz2 at illinois.edu  Sat Nov  5 14:06:49 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 05 Nov 2011 21:06:49 -0000
Subject: [vmkit-commits] [vmkit] r143828 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111105210649.E65DD2A6C12C@llvm.org>

Author: wdietz2
Date: Sat Nov  5 16:06:49 2011
New Revision: 143828

URL: http://llvm.org/viewvc/llvm-project?rev=143828&view=rev
Log:
Impl JVM_IsSupportedJNIVersion, claim we support all known JNI versions.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143828&r1=143827&r2=143828&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Sat Nov  5 16:06:49 2011
@@ -358,7 +358,10 @@
 
 JNIEXPORT jboolean JNICALL
 JVM_IsSupportedJNIVersion(jint version) {
-  NYI();
+  return version == JNI_VERSION_1_1 ||
+         version == JNI_VERSION_1_2 ||
+         version == JNI_VERSION_1_4 |
+         version == JNI_VERSION_1_6;
 }
 
 /*




From wdietz2 at illinois.edu  Sat Nov  5 14:07:34 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 05 Nov 2011 21:07:34 -0000
Subject: [vmkit-commits] [vmkit] r143829 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111105210734.4A41B2A6C12C@llvm.org>

Author: wdietz2
Date: Sat Nov  5 16:07:34 2011
New Revision: 143829

URL: http://llvm.org/viewvc/llvm-project?rev=143829&view=rev
Log:
Fake impl JVM_NativePath.  Can implement properly later if needed.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143829&r1=143828&r2=143829&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Sat Nov  5 16:07:34 2011
@@ -2007,7 +2007,8 @@
  */
 JNIEXPORT char * JNICALL
 JVM_NativePath(char * path) {
-  NYI();
+  // TODO: Implement me?
+  return path;
 }
 
 /*




From nicolas.geoffray at gmail.com  Sat Nov  5 14:11:51 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Sat, 5 Nov 2011 22:11:51 +0100
Subject: [vmkit-commits] [vmkit] r143824 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
In-Reply-To: <20111105210426.2A19E2A6C12C@llvm.org>
References: <20111105210426.2A19E2A6C12C@llvm.org>
Message-ID: <CAPYwfirwb7bGtxcpKYesBtxkrcWqRZnD4gkwHiHAocsHvmxuXg@mail.gmail.com>

On Sat, Nov 5, 2011 at 10:04 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Author: wdietz2
> Date: Sat Nov  5 16:04:25 2011
> New Revision: 143824
>
> URL: http://llvm.org/viewvc/llvm-project?rev=143824&view=rev
> Log:
> Impl JVM_{FindClassFromClassLoader,FindClassFromBootLoader,FindLoadedClass}
>
> Modified:
>    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
>
> Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> URL:
> http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143824&r1=143823&r2=143824&view=diff
>
> ==============================================================================
> --- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
> +++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Sat Nov  5 16:04:25
> 2011
> @@ -861,12 +861,52 @@
>  JNIEXPORT jclass JNICALL
>  JVM_FindClassFromClassLoader(JNIEnv *env, const char *name, jboolean init,
>                              jobject _loader, jboolean throwError) {
> -  NYI();
> +  BEGIN_JNI_EXCEPTION
> +
> +  JavaObject * loader = _loader ? *(JavaObject**)_loader : 0;
> +  llvm_gcroot(loader, 0);
> +
> +  jclass res;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JnjvmClassLoader* JCL =
> +    JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
> +
> +  CommonClass * Cl = JCL->loadClassFromAsciiz(name, true, throwError);
> +  if (Cl) {
> +    if (init && Cl->asClass())
> +      Cl->asClass()->initialiseClass(vm);
> +    res = (jclass)Cl->getClassDelegateePtr(vm);
> +  }
> +  else {
> +    vm->classNotFoundException(vm->asciizToStr(name));
> +  }
> +
> +  RETURN_FROM_JNI(res);
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jclass JNICALL
>  JVM_FindClassFromBootLoader(JNIEnv *env, const char *name) {
> -  NYI();
> +  BEGIN_JNI_EXCEPTION
> +
> +  jclass res = 0;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JnjvmClassLoader* JCL = vm->bootstrapLoader;
> +
> +  CommonClass * Cl = JCL->loadClassFromAsciiz(name, true, false);
> +  if (Cl) {
> +    res = (jclass)Cl->getClassDelegateePtr(vm);
> +  }
> +  RETURN_FROM_JNI(res);
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /*
> @@ -881,7 +921,27 @@
>  /* Find a loaded class cached by the VM */
>  JNIEXPORT jclass JNICALL
>  JVM_FindLoadedClass(JNIEnv *env, jobject _loader, jstring name) {
> -  NYI();
> +  JavaObject * loader = 0;
> +  llvm_gcroot(loader, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JnjvmClassLoader* JCL = NULL;
> +
> +  JavaString * str = *(JavaString**)name;
>

Sorry I forgot that one during the review, but str should be defined at the
beginning of the method, and a llvm_gcroot call with it should be added too.

+
> +  loader = *(JavaObject**)_loader;
> +
> +  CommonClass * Cl = 0;
> +
> +  JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
> +  if (JCL)
> +   Cl = JCL->lookupClassFromJavaString(str);
> +  jclass res = Cl ? (jclass)Cl->getClassDelegateePtr(vm) : 0;
> +  RETURN_FROM_JNI(res);
> +
> +  END_JNI_EXCEPTION
> +
>  }
>
>  /* Define a class */
>
>
> _______________________________________________
> 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/20111105/151a13b2/attachment.html>

From wdietz2 at illinois.edu  Sat Nov  5 14:09:51 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 05 Nov 2011 21:09:51 -0000
Subject: [vmkit-commits] [vmkit] r143830 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111105210951.108712A6C12C@llvm.org>

Author: wdietz2
Date: Sat Nov  5 16:09:50 2011
New Revision: 143830

URL: http://llvm.org/viewvc/llvm-project?rev=143830&view=rev
Log:
Add (minimal) signal support regarding JVM_FindSignal, JVM_RegisterSignal

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143830&r1=143829&r2=143830&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Sat Nov  5 16:09:50 2011
@@ -1610,7 +1610,8 @@
 
 JNIEXPORT void * JNICALL
 JVM_RegisterSignal(jint sig, void *handler) {
-  NYI();
+  // Don't let signals be registered, yet.
+  return (void*)-1;
 }
 
 JNIEXPORT jboolean JNICALL
@@ -1620,7 +1621,31 @@
 
 JNIEXPORT jint JNICALL
 JVM_FindSignal(const char *name) {
-  NYI();
+  // Map Signal name to integer...
+  static struct {
+    const char * name;
+    int num;
+  } SignalMap[] =
+  {
+    { "TERM", SIGTERM },
+    { "HUP", SIGHUP },
+    { "INT", SIGINT }
+  };
+  static uint32 signal_count = sizeof(SignalMap)/sizeof(SignalMap[0]);
+
+  BEGIN_JNI_EXCEPTION
+
+  for(uint32 i = 0; i < signal_count; ++i) {
+    if (!strcmp(name, SignalMap[i].name))
+      RETURN_FROM_JNI(SignalMap[i].num);
+  }
+
+  fprintf(stderr, "Unknown Signal \"%s\", missing entry in table?\n", name);
+  UNIMPLEMENTED();
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /*




From wdietz2 at illinois.edu  Sat Nov  5 14:10:19 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 05 Nov 2011 21:10:19 -0000
Subject: [vmkit-commits] [vmkit] r143831 - in /vmkit/trunk/lib/J3:
 ClassLib/OpenJDK/JavaUpcalls.cpp VMCore/JnjvmClassLoader.cpp
Message-ID: <20111105211019.199572A6C12C@llvm.org>

Author: wdietz2
Date: Sat Nov  5 16:10:18 2011
New Revision: 143831

URL: http://llvm.org/viewvc/llvm-project?rev=143831&view=rev
Log:
In OpenJDK, use the 'classes' field of ClassLoader to track VMClassLoader.

Also, don't just check the 'vmdata' field for non-null, since in OJ it will be
initialized to an empty vector.  Instead, consider the field uninitialized if
it's either null or of the wrong type.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
    vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp?rev=143831&r1=143830&r2=143831&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp Sat Nov  5 16:10:18 2011
@@ -552,10 +552,9 @@
     UPCALL_FIELD(loader, "java/nio/Buffer", "address", "Lgnu/classpath/Pointer;",
                  ACC_VIRTUAL);
 
-  // TODO: Resolve how to tie a ClassLoader to its internal representation
-  //vmdataClassLoader =
-  //  UPCALL_FIELD(loader, "java/lang/ClassLoader", "vmdata", "Ljava/lang/Object;",
-  //               ACC_VIRTUAL);
+  vmdataClassLoader =
+    UPCALL_FIELD(loader, "java/lang/ClassLoader", "classes", "Ljava/util/Vector;",
+                 ACC_VIRTUAL);
 
   newStackTraceElement =
     UPCALL_CLASS(loader, "java/lang/StackTraceElement");

Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp?rev=143831&r1=143830&r2=143831&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp Sat Nov  5 16:10:18 2011
@@ -808,11 +808,14 @@
   vmdata = 
     (VMClassLoader*)(upcalls->vmdataClassLoader->getInstanceObjectField(loader));
   
-  if (vmdata == NULL) {
+  // If the vmdata field isn't set yet, or it's set to something other than
+  // a VMClassLoader (which happens in the OpenJDK port), then initialize
+  // the field now.
+  if (vmdata == NULL || !VMClassLoader::isVMClassLoader(vmdata)) {
     JavaObject::acquire(loader);
     vmdata = 
       (VMClassLoader*)(upcalls->vmdataClassLoader->getInstanceObjectField(loader));
-    if (!vmdata) {
+    if (!vmdata || !VMClassLoader::isVMClassLoader(vmdata)) {
       vmdata = VMClassLoader::allocate();
       mvm::BumpPtrAllocator* A = new mvm::BumpPtrAllocator();
       JCL = new(*A, "Class loader") JnjvmClassLoader(*A, *vm->bootstrapLoader,




From wdietz2 at illinois.edu  Sat Nov  5 14:10:52 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 05 Nov 2011 21:10:52 -0000
Subject: [vmkit-commits] [vmkit] r143832 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111105211052.937782A6C12C@llvm.org>

Author: wdietz2
Date: Sat Nov  5 16:10:52 2011
New Revision: 143832

URL: http://llvm.org/viewvc/llvm-project?rev=143832&view=rev
Log:
Impl JVM_DefineClass and variants.  No support for source or verification yet.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143832&r1=143831&r2=143832&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Sat Nov  5 16:10:52 2011
@@ -951,7 +951,30 @@
 JNIEXPORT jclass JNICALL
 JVM_DefineClass(JNIEnv *env, const char *name, jobject _loader, const jbyte *buf,
                 jsize len, jobject pd) {
-  NYI();
+  JavaObject * loader = 0;
+  llvm_gcroot(loader, 0);
+  BEGIN_JNI_EXCEPTION
+
+  loader = _loader ? *(JavaObject**)_loader : 0;
+
+  jclass res;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader* JCL = NULL;
+  JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
+
+  ClassBytes * bytes = new (JCL->allocator, len) ClassBytes(len);
+  memcpy(bytes->elements,buf,len);
+  const UTF8* utfName = JCL->asciizConstructUTF8(name);
+  UserClass *cl = JCL->constructClass(utfName, bytes);
+
+  if (cl) res = (jclass)cl->getClassDelegateePtr(vm);
+
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /* Define a class with a source (added in JDK1.5) */
@@ -959,7 +982,8 @@
 JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader,
                           const jbyte *buf, jsize len, jobject pd,
                           const char *source) {
-  NYI();
+  // Discard source for now
+  return JVM_DefineClass(env, name, loader, buf, len, pd);
 }
 
 /* Define a class with a source with conditional verification (added HSX 14)
@@ -971,7 +995,8 @@
 JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name, jobject loader,
                               const jbyte *buf, jsize len, jobject pd,
                               const char *source, jboolean verify) {
-  NYI();
+  // Discard source and verification
+  return JVM_DefineClass(env, name, loader, buf, len, pd);
 }
 
 /*




From wdietz2 at illinois.edu  Sat Nov  5 14:14:30 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 05 Nov 2011 21:14:30 -0000
Subject: [vmkit-commits] [vmkit] r143833 -
	/vmkit/trunk/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java
Message-ID: <20111105211430.E6A012A6C12C@llvm.org>

Author: wdietz2
Date: Sat Nov  5 16:14:30 2011
New Revision: 143833

URL: http://llvm.org/viewvc/llvm-project?rev=143833&view=rev
Log:
Remove System.err.println from mmtk stuff to fix dep on bootstrap

Not entirely sure, but with these present we get linker errors with
libFinalMMtk.a on misc pieces that are pulled in from System.err,
  namely things like sun.nio.cs.StreamEncoder.

On one hand this seems like an undiagnosed failure of the precompilation,
   however we're not trying to build System.err things while
   compiling mmtk, and this change is relatively minor.

Modified:
    vmkit/trunk/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java

Modified: vmkit/trunk/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java?rev=143833&r1=143832&r2=143833&view=diff
==============================================================================
--- vmkit/trunk/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java (original)
+++ vmkit/trunk/mmtk/java/src/org/j3/mmtk/BuildTimeConfig.java Sat Nov  5 16:14:30 2011
@@ -53,7 +53,7 @@
     if (default_property_file == null) {
       propFileName = System.getProperty(property_file_property);
       if (propFileName == null) {
-        System.err.println(property_file_property+" must specify a properties file");
+        //System.err.println(property_file_property+" must specify a properties file");
         VM.sysExit(1);
       }   
     } else {
@@ -67,7 +67,7 @@
       propFileStream.close();
     } catch (FileNotFoundException e) {
       if (!propFileName.equals(default_property_file)) {
-        System.err.println(propFileName+" not found.");
+        //System.err.println(propFileName+" not found.");
         VM.sysExit(1);
       }   
     } catch (IOException e) {




From wdietz2 at illinois.edu  Sat Nov  5 14:21:26 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 05 Nov 2011 21:21:26 -0000
Subject: [vmkit-commits] [vmkit] r143835 - in /vmkit/trunk/lib/J3/VMCore:
 JnjvmClassLoader.cpp JnjvmClassLoader.h
Message-ID: <20111105212126.A69762A6C12C@llvm.org>

Author: wdietz2
Date: Sat Nov  5 16:21:26 2011
New Revision: 143835

URL: http://llvm.org/viewvc/llvm-project?rev=143835&view=rev
Log:
Add new 'nativesLock' to protect the registerNatives map.

Using the classloader lock, as we did before, causes deadlocks in certain
situations, and this is a cleaner approach anyway.

Modified:
    vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
    vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h

Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp?rev=143835&r1=143834&r2=143835&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp Sat Nov  5 16:21:26 2011
@@ -1044,17 +1044,17 @@
 }
 
 void JnjvmClassLoader::registerNative(JavaMethod * meth, word_t fnPtr) {
-  lock.lock();
+  nativesLock.lock();
   // Don't support multiple levels of registerNatives
   assert(registeredNatives.find(meth) == registeredNatives.end());
 
   registeredNatives[meth] = fnPtr;
-  lock.unlock();
+  nativesLock.unlock();
 }
 
 word_t JnjvmClassLoader::getRegisteredNative(const JavaMethod * meth) {
-  lock.lock();
+  nativesLock.lock();
   word_t res = registeredNatives[meth];
-  lock.unlock();
+  nativesLock.unlock();
   return res;
 }

Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h?rev=143835&r1=143834&r2=143835&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h Sat Nov  5 16:21:26 2011
@@ -113,6 +113,10 @@
   ///
   std::map<const JavaMethod*,word_t> registeredNatives;
 
+  /// nativesLock - Locks the registeredNatives map above
+  ///
+  mvm::LockRecursive nativesLock;
+
 public:
   
   /// allocator - Reference to the memory allocator, which will allocate UTF8s,




From wdietz2 at illinois.edu  Sat Nov  5 14:26:18 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 5 Nov 2011 16:26:18 -0500
Subject: [vmkit-commits] [PATCH/DISCUSS] registerNatives Lock,
	avoid deadlock
In-Reply-To: <CAPYwfio+K_v8zzLsc2ZjkNFsDUpS7spD+0JAvOzuJdLnWCaXWQ@mail.gmail.com>
References: <CAKGWAO8AT0G1OAsHBz17j1Pm4-7JbuSPPL0SyA+DmKUtd2Q4Lg@mail.gmail.com>
	<CAPYwfio+K_v8zzLsc2ZjkNFsDUpS7spD+0JAvOzuJdLnWCaXWQ@mail.gmail.com>
Message-ID: <CAKGWAO9cR7bODz0=JqtegwkACg0M4Xe-jACQ2H4vjyubcX22ZQ@mail.gmail.com>

On Fri, Nov 4, 2011 at 5:11 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> Oh yes, because getRegisteredNative is called while compiling, and the class
> loader lock may be used indirectly by application, we may have a deadlock
> situation.

Yep, that's exactly what was happening :).

> Besides fixing the problem, I think your patch is cleaner because it makes
> the locking local. Apologies for suggesting you a bogus implementation. I'm
> surprised you encountered the bug that early though! Are you running vmkit
> w/openjdk on an application that creates mulitple threads?

No worries re:suggestion, and yeah local lock sounds good :).

I *am* running vmkit (w/openjdk) on applications that spawn multiple
threads, but none run correctly yet (my only non-synthetic test cases
are dacapo and similar).  Thanks for the SPECJVM suggestion, didn't
realize it was free.  As for more tractable goals, let me know if you
have any suggestions for suitable test applications.

Note that beyond what's here on the mailing list, I have a few more
patches (phew, almost done!) in my local tree that haven't been
upstreamed yet.  Hopefully I'll be synced with trunk very soon and can
start looking at fixing remaining unimplemented things (and perhaps
misc bugs :)).

> Please apply!

Will do, thanks! :)

~Will


From wdietz2 at illinois.edu  Sat Nov  5 14:54:38 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 05 Nov 2011 21:54:38 -0000
Subject: [vmkit-commits] [vmkit] r143837 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111105215438.3C3872A6C12C@llvm.org>

Author: wdietz2
Date: Sat Nov  5 16:54:37 2011
New Revision: 143837

URL: http://llvm.org/viewvc/llvm-project?rev=143837&view=rev
Log:
Fix missed gcroot, fix missing return value in exception case.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143837&r1=143836&r2=143837&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Sat Nov  5 16:54:37 2011
@@ -925,15 +925,16 @@
 JNIEXPORT jclass JNICALL
 JVM_FindLoadedClass(JNIEnv *env, jobject _loader, jstring name) {
   JavaObject * loader = 0;
+  JavaString * str = 0;
   llvm_gcroot(loader, 0);
+  llvm_gcroot(str, 0);
   BEGIN_JNI_EXCEPTION
 
   Jnjvm* vm = JavaThread::get()->getJVM();
   JnjvmClassLoader* JCL = NULL;
 
-  JavaString * str = *(JavaString**)name;
-
   loader = *(JavaObject**)_loader;
+  str = *(JavaString**)name;
 
   CommonClass * Cl = 0;
 
@@ -945,6 +946,7 @@
 
   END_JNI_EXCEPTION
 
+  return 0;
 }
 
 /* Define a class */




From wdietz2 at illinois.edu  Sun Nov  6 00:32:08 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sun, 6 Nov 2011 01:32:08 -0600
Subject: [vmkit-commits] [PATCH] Refactor AOT into ClassLib-specific
 components, add support for OpenJDK
In-Reply-To: <CAPYwfir+6vdWPM+-wvXc2kLgvuffs+6iJEf3apic8OuvJ2AQ1Q@mail.gmail.com>
References: <CAKGWAO9O1gMuvhksmqg6mqJHWMX4YYPPxPnFVmNBkkd-0P3FTQ@mail.gmail.com>
	<CAPYwfir+6vdWPM+-wvXc2kLgvuffs+6iJEf3apic8OuvJ2AQ1Q@mail.gmail.com>
Message-ID: <CAKGWAO8KG322NXbf1e=kyfQf1zCOpFt=jyW8QEzfwRaT_fAPTw@mail.gmail.com>

On Fri, Nov 4, 2011 at 4:57 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> Don't you need to fix java.lang.String also?
>

Hmm, I'd imagine so-- good call.  Strange this didn't break anything
terribly :).

> There is a problem if we don't add the extra fields in LLVM's struct: the
> object will be emitted in the executable, and won't be big enough to contain
> the two extra fields.

Bah, okay.  That sort of thing was why my previous (otherwise hacky)
patch for adding extra fields was useful--LLVMInfo would do the right
thing.

However, I like your idea below of trying to ditch emitting Class in
AOT entirely, I'll give it a go.

> I think we should drop emitting java.lang.Class instances in AOT, because it
> does not work with a precise GC. When compiling MMTk (which should be the
> only user of AOT without a precise GC), we could be able to just emit null
> there. Could you try and confirm?

Will do.

> If it turns out it does not work, we could also try to put a dummy
> java.lang.Object or java.lang.Class, following the object layout but without
> containing any data. In any case, your change in vmjcAddPrecompiledClass
> should be removed.
>

Okay, will give this a go if the above doesn't pan out.

>>   cl->classLoader = JCL;
>> +  // Ensure the Class mapping field is set properly.
>> +  // (Needed for OpenJDK, since this mapping isn't part of the Class
>> type)
>> +  JavaObjectClass::setClass((JavaObjectClass*)cl->getDelegatee(),cl);
>
> Did you actually run some code that failed because of this not being set?
>
>>

Sorta.  I ran into failures in the precompiler (presumably due to MMTk
as you mention), so never made it to any actual code without fixing
the mapping one way or the other.

Anyway, I'll look into the ideas you mention above and report back :).

Thanks!

~Will



From nicolas.geoffray at gmail.com  Sun Nov  6 02:38:03 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Sun, 6 Nov 2011 11:38:03 +0100
Subject: [vmkit-commits] [PATCH] Refactor AOT into ClassLib-specific
 components, add support for OpenJDK
In-Reply-To: <CAKGWAO8KG322NXbf1e=kyfQf1zCOpFt=jyW8QEzfwRaT_fAPTw@mail.gmail.com>
References: <CAKGWAO9O1gMuvhksmqg6mqJHWMX4YYPPxPnFVmNBkkd-0P3FTQ@mail.gmail.com>
	<CAPYwfir+6vdWPM+-wvXc2kLgvuffs+6iJEf3apic8OuvJ2AQ1Q@mail.gmail.com>
	<CAKGWAO8KG322NXbf1e=kyfQf1zCOpFt=jyW8QEzfwRaT_fAPTw@mail.gmail.com>
Message-ID: <CAPYwfioYvGV+mxeOTB4etocsqLaatHm9JVseTrSKtrdpjh5FYw@mail.gmail.com>

On Sun, Nov 6, 2011 at 8:32 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> On Fri, Nov 4, 2011 at 4:57 PM, Nicolas Geoffray
> <nicolas.geoffray at gmail.com> wrote:
> > Don't you need to fix java.lang.String also?
> >
>
> Hmm, I'd imagine so-- good call.  Strange this didn't break anything
> terribly :).
>

I think they are used for debugging and logging in MMTk, so as long as you
weren't printing things, you may not use the generated strings at all.


> > There is a problem if we don't add the extra fields in LLVM's struct: the
> > object will be emitted in the executable, and won't be big enough to
> contain
> > the two extra fields.
>
> Bah, okay.  That sort of thing was why my previous (otherwise hacky)
> patch for adding extra fields was useful--LLVMInfo would do the right
> thing.
>

Indeed. Sorry about not liking this solution :)


>
> However, I like your idea below of trying to ditch emitting Class in
> AOT entirely, I'll give it a go.
>

Thanks!

Nicolas


>
> > I think we should drop emitting java.lang.Class instances in AOT,
> because it
> > does not work with a precise GC. When compiling MMTk (which should be the
> > only user of AOT without a precise GC), we could be able to just emit
> null
> > there. Could you try and confirm?
>
> Will do.
>
> > If it turns out it does not work, we could also try to put a dummy
> > java.lang.Object or java.lang.Class, following the object layout but
> without
> > containing any data. In any case, your change in vmjcAddPrecompiledClass
> > should be removed.
> >
>
> Okay, will give this a go if the above doesn't pan out.
>
> >>   cl->classLoader = JCL;
> >> +  // Ensure the Class mapping field is set properly.
> >> +  // (Needed for OpenJDK, since this mapping isn't part of the Class
> >> type)
> >> +  JavaObjectClass::setClass((JavaObjectClass*)cl->getDelegatee(),cl);
> >
> > Did you actually run some code that failed because of this not being set?
> >
> >>
>
> Sorta.  I ran into failures in the precompiler (presumably due to MMTk
> as you mention), so never made it to any actual code without fixing
> the mapping one way or the other.
>
> Anyway, I'll look into the ideas you mention above and report back :).
>
> Thanks!
>
> ~Will
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111106/1612ad87/attachment.html>

From nicolas.geoffray at gmail.com  Sun Nov  6 08:05:06 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Sun, 6 Nov 2011 17:05:06 +0100
Subject: [vmkit-commits] OpenJDK for vmkit 0.30 (llvm 3.0)
Message-ID: <CAPYwfirvhfpwyriWZPVnS=aW5NRESWNcmeRS5fnsxG5iBSx-CA@mail.gmail.com>

Hi Will,

In case you don't know, llvm will release version 3.0 in a few days. Since
llvm 2.3, I make a 'release' version of vmkit for each llvm release. It's
is more of a bundle that compiles with the released version of llvm.

I'd like to create the 'release'  branch soon, so that I can start testing
vmkit 0.30 against llvm 3.0 and create the bundle. Are there extra patches
you'd like to integrate for the release? Also, should we promote the
OpenJDK port for the release notes, or should we wait until we have
something functional that you and I have tested and used for large-size
applications (eg dacapo)? Hopefully we'll be at that state the next version
(0.31)?

Let me know!

Thanks,
Nicolas
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111106/40908431/attachment.html>

From wdietz2 at illinois.edu  Sun Nov  6 18:50:01 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sun, 6 Nov 2011 20:50:01 -0600
Subject: [vmkit-commits] [PATCH] Implement a number of
 Java.sun.misc.Unsafe.* methods.
In-Reply-To: <CAPYwfiqqzf75hqdND0UULwf-6w-pYShPnmQQvCfvckDZ-En8Zg@mail.gmail.com>
References: <CAKGWAO9sjQOL2vt9-ekS1vR=PdH=_xPZHpw=NejtpfreJDHQxA@mail.gmail.com>
	<CAPYwfiqqzf75hqdND0UULwf-6w-pYShPnmQQvCfvckDZ-En8Zg@mail.gmail.com>
Message-ID: <CAKGWAO8FBBqsnxpx1G4ydX5X79q-yWQA6=8T_Hdfm=JoqYfcFw@mail.gmail.com>

On Fri, Nov 4, 2011 at 4:06 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> Thanks Will for the new change. I have a few comments that I'd like you to
> take into account before moving forward.
[snip]

Thank you for your comments!  Updated patch inlined below :).

~Will

>From 64c05c78614b4036e40dc915926f590b82f60966 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 6/8] 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  |   82 +++++++++++++++
 lib/J3/Compiler/JavaAOTCompiler.cpp |    5 +-
 lib/J3/Compiler/Makefile            |    2 +-
 lib/J3/VMCore/Jnjvm.cpp             |    5 +
 lib/J3/VMCore/Makefile              |    2 +-
 lib/J3/VMCore/VirtualTables.cpp     |   11 ++-
 7 files changed, 296 insertions(+), 6 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..c81e26b 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());
+  cl->asClass()->resolveClass();
+  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) {
+  JavaObject* res = 0;
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(_field, 0);
+  llvm_gcroot(res, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  JavaField * field = JavaObjectField::getInternalField(_field);
+  assert(field);
+  field->classDef->initialiseClass(JavaThread::get()->getJVM());
+
+  res = VMStaticInstance::allocate(
+    (JavaObjectClass*)field->classDef->getDelegatee());
+
+  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) {
+  UNIMPLEMENTED();
+  return 0;
+}
+
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* clazz) {
+  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()->throwException(obj);
+}
+
 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..f2ca906
--- /dev/null
+++ b/lib/J3/ClassLib/VMStaticInstance.h
@@ -0,0 +1,82 @@
+//===-------- 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 "ClasspathReflect.h"
+#include "JavaObject.h"
+#include "MvmGC.h"
+
+namespace j3 {
+
+/// VMStaticInstance - Used as a placeholder for a staticInstance, tracing to
+/// the corresponding Class to ensure it doesn't get improperly GC'd.
+/// This placeholder is used solely in getStaticFieldBase and the various
+/// put/get methods in sun.misc.Unsafe, any other use is invalid.
+/// Largely inspired by VMClassLoader.
+///
+class VMStaticInstance : public JavaObject {
+private:
+
+  /// OwningClass - The Class this is represents a static instance of.
+  JavaObjectClass * OwningClass;
+
+public:
+
+  static VMStaticInstance* allocate(JavaObjectClass * Class) {
+    VMStaticInstance* res = 0;
+    llvm_gcroot(res, 0);
+    llvm_gcroot(Class, 0);
+    res = (VMStaticInstance*)gc::operator new(sizeof(VMStaticInstance), &VT);
+    res->OwningClass = Class;
+
+    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 through to our Class
+  ///
+  static void staticTracer(VMStaticInstance* obj, word_t closure) {
+    llvm_gcroot(obj, 0);
+    if (obj->OwningClass != NULL) obj->OwningClass->tracer(closure);
+  }
+
+  /// getStaticInstance - Get the static instance contained in this object
+  ///
+  void * getStaticInstance() {
+    assert(OwningClass);
+    UserCommonClass * Cl = JavaObjectClass::getClass(OwningClass);
+    assert(Cl && Cl->isClass());
+    return Cl->asClass()->getStaticInstance();
+  }
+
+};
+
+}
+
+#endif // JNJVM_VMSTATICINSTANCE_H
diff --git a/lib/J3/Compiler/JavaAOTCompiler.cpp
b/lib/J3/Compiler/JavaAOTCompiler.cpp
index d16d57c..1a4d2e4 100644
--- a/lib/J3/Compiler/JavaAOTCompiler.cpp
+++ b/lib/J3/Compiler/JavaAOTCompiler.cpp
@@ -32,6 +32,7 @@
 #include "JavaUpcalls.h"
 #include "Jnjvm.h"
 #include "Reader.h"
+#include "VMStaticInstance.h"
 #include "Zip.h"

 #include <cstdio>
@@ -2545,7 +2546,9 @@ CommonClass*
JavaAOTCompiler::getUniqueBaseClass(CommonClass* cl) {

   for (; I != E; ++I) {
     JavaObject* obj = (JavaObject*)(*I);
-    if (!VMClassLoader::isVMClassLoader(obj) &&
JavaObject::instanceOf(obj, cl)) {
+    if (!VMClassLoader::isVMClassLoader(obj) &&
+        !VMStaticInstance::isVMStaticInstance(obj) &&
+        JavaObject::instanceOf(obj, cl)) {
       if (currentClass != NULL) {
         if (JavaObject::getClass(obj) != currentClass) {
           return 0;
diff --git a/lib/J3/Compiler/Makefile b/lib/J3/Compiler/Makefile
index 58bb2e1..99c46db 100644
--- a/lib/J3/Compiler/Makefile
+++ b/lib/J3/Compiler/Makefile
@@ -14,4 +14,4 @@ MODULE_WITH_GC = J3Compiler

 include $(LEVEL)/Makefile.common

-CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime
-I$(PROJ_SRC_DIR)/../ClassLib/$(CLASSPATH_DIR)
-I$(PROJ_SRC_DIR)/../VMCore
+CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime
-I$(PROJ_SRC_DIR)/../ClassLib/$(CLASSPATH_DIR)
-I$(PROJ_SRC_DIR)/../ClassLib/ -I$(PROJ_SRC_DIR)/../VMCore
diff --git a/lib/J3/VMCore/Jnjvm.cpp b/lib/J3/VMCore/Jnjvm.cpp
index 4961694..5165b88 100644
--- a/lib/J3/VMCore/Jnjvm.cpp
+++ b/lib/J3/VMCore/Jnjvm.cpp
@@ -35,6 +35,7 @@
 #include "LockedMap.h"
 #include "Reader.h"
 #include "ReferenceQueue.h"
+#include "VMStaticInstance.h"
 #include "Zip.h"

 using namespace j3;
@@ -1394,6 +1395,8 @@ size_t Jnjvm::getObjectSize(gc* object) {
   JavaObject* src = (JavaObject*)object;
   if (VMClassLoader::isVMClassLoader(src)) {
     size = sizeof(VMClassLoader);
+  } else if (VMStaticInstance::isVMStaticInstance(src)) {
+    size = sizeof(VMStaticInstance);
   } else {
     CommonClass* cl = JavaObject::getClass(src);
     if (cl->isArray()) {
@@ -1416,6 +1419,8 @@ const char* Jnjvm::getObjectTypeName(gc* object) {
   JavaObject* src = (JavaObject*)object;
   if (VMClassLoader::isVMClassLoader(src)) {
     return "VMClassLoader";
+  } else if (VMStaticInstance::isVMStaticInstance(src)) {
+    return "VMStaticInstance";
   } else {
     CommonClass* cl = JavaObject::getClass(src);
     // This code is only used for debugging on a fatal error. It is fine to
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


From wdietz2 at illinois.edu  Sun Nov  6 18:51:26 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sun, 6 Nov 2011 20:51:26 -0600
Subject: [vmkit-commits] [PATCH] Impl JVM_NewInstanceFromConstructor
In-Reply-To: <CAPYwfirGwpuVDY0Hvsd==MA7AVTZtsYdx5ix89BzCvMjCf5KEg@mail.gmail.com>
References: <CAKGWAO_Y4L6oBkUbJC02aJpb9Kd3jGhBpraSJ-nY0rLzcGGr0Q@mail.gmail.com>
	<CAPYwfirGwpuVDY0Hvsd==MA7AVTZtsYdx5ix89BzCvMjCf5KEg@mail.gmail.com>
Message-ID: <CAKGWAO-LQ9Wrt+0WpSKMW988bxqJxkBRXAER27p+GwnWC+kcYw@mail.gmail.com>

On Fri, Nov 4, 2011 at 4:23 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> Looks good! This is again very similar to what is in classpath. I know I
> said that you should not worry about duplicating code, but after reviewing a
> few of your changes, if you could somehow try to share when you can, that'd
> be great :)
> But feel free to ignore for now, if that's on your way of making the
> progress you want.
> Nicolas

Good call.

Updated patch inlined below.  Much simpler :).

~Will

>From b2e31a674c06cb9dc2a19c42d97053e91590f5b0 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Sun, 6 Nov 2011 01:33:34 -0500
Subject: [PATCH 4/8] Impl JVM_NewInstanceFromConstructor, using existing
 Classpath code.

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   22 +++++++++++++++++++++-
 1 files changed, 21 insertions(+), 1 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 4f25fb0..15029ea 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -1464,7 +1464,27 @@ JVM_InvokeMethod(JNIEnv *env, jobject method,
jobject _obj, jobjectArray args0)
  */
 JNIEXPORT jobject JNICALL
 JVM_NewInstanceFromConstructor(JNIEnv *env, jobject _c, jobjectArray args0) {
-  NYI();
+  JavaObject * ret = 0;
+  JavaObjectConstructor * c = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(c, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+
+  c = *(JavaObjectConstructor**)_c;
+
+  ret = proceedConstructor(
+    c,
+    args0? *(ArrayObject**)args0 : 0,
+    JavaObjectConstructor::getClass(c)->getDelegatee(),
+    0 /* unused */ );
+
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(ret));
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /*
-- 
1.7.5.1


From wdietz2 at illinois.edu  Sun Nov  6 18:55:59 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sun, 6 Nov 2011 20:55:59 -0600
Subject: [vmkit-commits] [PATCH] Refactor AOT into ClassLib-specific
 components, add support for OpenJDK
In-Reply-To: <CAPYwfioYvGV+mxeOTB4etocsqLaatHm9JVseTrSKtrdpjh5FYw@mail.gmail.com>
References: <CAKGWAO9O1gMuvhksmqg6mqJHWMX4YYPPxPnFVmNBkkd-0P3FTQ@mail.gmail.com>
	<CAPYwfir+6vdWPM+-wvXc2kLgvuffs+6iJEf3apic8OuvJ2AQ1Q@mail.gmail.com>
	<CAKGWAO8KG322NXbf1e=kyfQf1zCOpFt=jyW8QEzfwRaT_fAPTw@mail.gmail.com>
	<CAPYwfioYvGV+mxeOTB4etocsqLaatHm9JVseTrSKtrdpjh5FYw@mail.gmail.com>
Message-ID: <CAKGWAO-AfG0GxAV8_eKh8PuF1=L9qncrptsAFAbvA2BXN2H5uw@mail.gmail.com>

On Sun, Nov 6, 2011 at 4:38 AM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> On Sun, Nov 6, 2011 at 8:32 AM, Will Dietz <wdietz2 at illinois.edu> wrote:
>>
>> On Fri, Nov 4, 2011 at 4:57 PM, Nicolas Geoffray
>> <nicolas.geoffray at gmail.com> wrote:
>> > Don't you need to fix java.lang.String also?
>> >
>>
>> Hmm, I'd imagine so-- good call.  Strange this didn't break anything
>> terribly :).
>
> I think they are used for debugging and logging in MMTk, so as long as you
> weren't printing things, you may not use the generated strings at all.
>>
>> > There is a problem if we don't add the extra fields in LLVM's struct:
>> > the
>> > object will be emitted in the executable, and won't be big enough to
>> > contain
>> > the two extra fields.
>>
>> Bah, okay.  That sort of thing was why my previous (otherwise hacky)
>> patch for adding extra fields was useful--LLVMInfo would do the right
>> thing.
>
> Indeed. Sorry about not liking this solution :)
>

No need to be sorry :).

>>
>> However, I like your idea below of trying to ditch emitting Class in
>> AOT entirely, I'll give it a go.
>
> Thanks!
> Nicolas
>

Gave it a go, and the corresponding patch is inlined below.

However, in order for it to work, it also needs the "Don't emit
methods for primitive classes' VT" patch, which I'm sending in a
separate thread.

~Will

>From e8eda306e44c270545fdb31b3ba954cfd016c511 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Sun, 6 Nov 2011 20:17:02 -0600
Subject: [PATCH 7/8] Emit NULL for j.l.Class in AOT.

---
 include/j3/JavaAOTCompiler.h        |    1 -
 lib/J3/Compiler/JavaAOTCompiler.cpp |   64 +----------------------------------
 2 files changed, 1 insertions(+), 64 deletions(-)

diff --git a/include/j3/JavaAOTCompiler.h b/include/j3/JavaAOTCompiler.h
index b278a41..483bffb 100644
--- a/include/j3/JavaAOTCompiler.h
+++ b/include/j3/JavaAOTCompiler.h
@@ -94,7 +94,6 @@ private:
   llvm::Constant* CreateConstantFromJavaMethod(JavaMethod& method);
   llvm::Constant* CreateConstantFromStaticInstance(Class* cl);
   llvm::Constant* CreateConstantFromJavaString(JavaString* str);
-  llvm::Constant* CreateConstantFromJavaClass(CommonClass* cl);
   llvm::Constant* CreateConstantForBaseObject(CommonClass* cl);
   llvm::Constant* CreateConstantFromJavaObject(JavaObject* obj);
   llvm::Constant* CreateConstantFromClassBytes(ClassBytes* bytes);
diff --git a/lib/J3/Compiler/JavaAOTCompiler.cpp
b/lib/J3/Compiler/JavaAOTCompiler.cpp
index 1a4d2e4..2ae8973 100644
--- a/lib/J3/Compiler/JavaAOTCompiler.cpp
+++ b/lib/J3/Compiler/JavaAOTCompiler.cpp
@@ -295,39 +295,7 @@ Constant* JavaAOTCompiler::getStringPtr(JavaString** str) {
 }

 Constant* JavaAOTCompiler::getJavaClass(CommonClass* cl) {
-  Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
-  LLVMClassInfo* LCI = getClassInfo(javaClass);
-  llvm::Type* Ty = LCI->getVirtualType();
-
-  if (useCooperativeGC()) {
-    return Constant::getNullValue(JavaIntrinsics.JavaObjectType);
-  } else {
-    java_class_iterator End = javaClasses.end();
-    java_class_iterator I = javaClasses.find(cl);
-    if (I == End) {
-      final_object_iterator End = finalObjects.end();
-      final_object_iterator I = finalObjects.find(cl->delegatee[0]);
-      if (I == End) {
-
-        Module& Mod = *getLLVMModule();
-
-        GlobalVariable* varGV =
-          new GlobalVariable(Mod, Ty->getContainedType(0), false,
-                             GlobalValue::InternalLinkage, 0, "");
-
-        Constant* res = ConstantExpr::getCast(Instruction::BitCast, varGV,
-                                              JavaIntrinsics.JavaObjectType);
-
-        javaClasses.insert(std::make_pair(cl, res));
-        varGV->setInitializer(CreateConstantFromJavaClass(cl));
-        return res;
-      } else {
-        return I->second;
-      }
-    } else {
-      return I->second;
-    }
-  }
+  return Constant::getNullValue(JavaIntrinsics.JavaObjectType);
 }

 Constant* JavaAOTCompiler::getJavaClassPtr(CommonClass* cl) {
@@ -688,36 +656,6 @@ Constant*
JavaAOTCompiler::CreateConstantForBaseObject(CommonClass* cl) {
   return ConstantStruct::get(STy, Elmts);
 }

-Constant* JavaAOTCompiler::CreateConstantFromJavaClass(CommonClass* cl) {
-  assert(!useCooperativeGC());
-  Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
-  LLVMClassInfo* LCI = getClassInfo(javaClass);
-  StructType* STy =
-    dyn_cast<StructType>(LCI->getVirtualType()->getContainedType(0));
-
-  std::vector<Constant*> Elmts;
-
-  // JavaObject
-  Elmts.push_back(CreateConstantForBaseObject(javaClass));
-
-  // signers
-  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
-
-  // pd
-  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
-
-  // vmdata
-  Constant* Cl = getNativeClass(cl);
-  Cl = ConstantExpr::getCast(Instruction::BitCast, Cl,
-                             JavaIntrinsics.JavaObjectType);
-  Elmts.push_back(Cl);
-
-  // constructor
-  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
-
-  return ConstantStruct::get(STy, Elmts);
-}
-
 Constant* JavaAOTCompiler::CreateConstantFromJavaObject(JavaObject* obj) {
   assert(!useCooperativeGC());
   CommonClass* cl = JavaObject::getClass(obj);
-- 
1.7.5.1



From wdietz2 at illinois.edu  Sun Nov  6 18:58:29 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sun, 6 Nov 2011 20:58:29 -0600
Subject: [vmkit-commits] [PATCH] Impl JVM_GetClassContext,
	refactor existing code into shared ClassContext.inc.
Message-ID: <CAKGWAO-i=qKJdyeAZPmfC6CYCNheukN4rma6ymxSeEnkq2rH=A@mail.gmail.com>

Inlined below.

~Will

>From 4c7de028f511bf52c3601ce57beb02ffcb939420 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Sat, 5 Nov 2011 20:47:15 -0500
Subject: [PATCH 2/8] Impl JVM_GetClassContext, refactor existing code into
 shared ClassContext.inc.

Also, fix ClassContext creation of wrong array type.
---
 lib/J3/ClassLib/ClassContext.inc                   |   36 ++++++++++++++++++++
 .../GNUClasspath/ClasspathVMStackWalker.inc        |   25 ++-----------
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc                |   12 ++++++-
 3 files changed, 51 insertions(+), 22 deletions(-)
 create mode 100644 lib/J3/ClassLib/ClassContext.inc

diff --git a/lib/J3/ClassLib/ClassContext.inc b/lib/J3/ClassLib/ClassContext.inc
new file mode 100644
index 0000000..71c17d7
--- /dev/null
+++ b/lib/J3/ClassLib/ClassContext.inc
@@ -0,0 +1,36 @@
+//===------------ ClassContext.inc -- Implement GetClassContext
-----------===//
+//
+//                            The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+ArrayObject* GetClassContext() {
+  ArrayObject* result = NULL;
+  JavaObject* delegatee = NULL;
+  llvm_gcroot(result, 0);
+  llvm_gcroot(delegatee, 0);
+
+  JavaThread* th = JavaThread::get();
+  Jnjvm* vm = th->getJVM();
+  uint32 length = th->getFrameContextLength();
+
+  mvm::ThreadAllocator allocator;
+  uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *
sizeof(uintptr_t));
+
+  uint32 finalSize = th->getJavaFrameContext((void**)buffer);
+
+  result = (ArrayObject*)
+    vm->upcalls->classArrayClass->doNew(finalSize, vm);
+
+  for (uint32 i = 0; i != finalSize; ++i) {
+    JavaMethod* meth = ((JavaMethod**)buffer)[i];
+    assert(meth && "Wrong stack trace");
+    delegatee = meth->classDef->getClassDelegatee(vm);;
+    ArrayObject::setElement(result, delegatee, i);
+  }
+
+  return result;
+}
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
index b0c94e5..c51a246 100644
--- a/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
@@ -19,6 +19,8 @@
 #include "JavaUpcalls.h"
 #include "Jnjvm.h"

+#include "ClassContext.inc"
+
 using namespace j3;

 extern "C" {
@@ -31,31 +33,12 @@ jclass clazz,
 ) {

   ArrayObject* result = NULL;
-  JavaObject* delegatee = NULL;
   llvm_gcroot(result, 0);
-  llvm_gcroot(delegatee, 0);

   BEGIN_NATIVE_EXCEPTION(0)

-  JavaThread* th = JavaThread::get();
-  Jnjvm* vm = th->getJVM();
-  uint32 length = th->getFrameContextLength();
-
-  mvm::ThreadAllocator allocator;
-  uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *
sizeof(uintptr_t));
-
-  uint32 finalSize = th->getJavaFrameContext((void**)buffer);
-
-  result = (ArrayObject*)
-    vm->upcalls->stackTraceArray->doNew(finalSize, vm);
-
-  for (uint32 i = 0; i != finalSize; ++i) {
-    JavaMethod* meth = ((JavaMethod**)buffer)[i];
-    assert(meth && "Wrong stack trace");
-    delegatee = meth->classDef->getClassDelegatee(vm);;
-    ArrayObject::setElement(result, delegatee, i);
-  }
-
+  result = GetClassContext();
+
   END_NATIVE_EXCEPTION

   return result;
diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 947b7d3..012b021 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -12,6 +12,7 @@
 #include "Reader.h"

 #include "ArrayCopy.inc"
+#include "ClassContext.inc"
 #include "SetProperties.inc"
 #include "Object.inc"

@@ -672,7 +673,16 @@ JVM_CurrentClassLoader(JNIEnv *env) {

 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassContext(JNIEnv *env) {
-  NYI();
+  ArrayObject * res = 0;
+  llvm_gcroot(res, 0);
+  BEGIN_JNI_EXCEPTION
+
+  res = GetClassContext();
+
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(res));
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT jint JNICALL
-- 
1.7.5.1


From wdietz2 at illinois.edu  Sun Nov  6 18:57:48 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sun, 6 Nov 2011 20:57:48 -0600
Subject: [vmkit-commits] [PATCH] Refactor JavaObject-related ClassLib code.
Message-ID: <CAKGWAO-F8iB94gcZfSzD1RkrwaCaURfWaO2TiSqihXm016qzRA@mail.gmail.com>

Inlined below.

~Will

>From b27df42e89b104ec6d98f0d35fee5ddf1c8c64aa Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Sat, 5 Nov 2011 20:24:31 -0500
Subject: [PATCH 1/8] Refactor JavaObject-related ClassLib code.

---
 lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc |   68 +------------------
 lib/J3/ClassLib/Object.inc                         |   31 +++++++++
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc                |   46 ++++++-------
 lib/J3/VMCore/JavaObject.cpp                       |   66 +++++++++++++++++++
 lib/J3/VMCore/JavaObject.h                         |    4 +
 5 files changed, 127 insertions(+), 88 deletions(-)
 create mode 100644 lib/J3/ClassLib/Object.inc

diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
index ab3f0c5..1c981d4 100644
--- a/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
@@ -10,11 +10,8 @@
 #include "types.h"

 #include "Classpath.h"
-#include "JavaArray.h"
-#include "JavaClass.h"
-#include "JavaObject.h"
-#include "JavaThread.h"
 #include "Jnjvm.h"
+#include "Object.inc"

 using namespace j3;

@@ -28,59 +25,12 @@ jclass clazz,
 JavaObject* src) {

   JavaObject* res = NULL;
-  JavaObject* tmp = NULL;
   llvm_gcroot(res, 0);
   llvm_gcroot(src, 0);

   BEGIN_NATIVE_EXCEPTION(0)

-  UserCommonClass* cl = JavaObject::getClass(src);
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  if (cl->isArray()) {
-    UserClassArray* array = cl->asArrayClass();
-    int length = JavaArray::getSize(src);
-    res = array->doNew(length, vm);
-    UserCommonClass* base = array->baseClass();
-    if (base->isPrimitive()) {
-      int size = length << base->asPrimitiveClass()->logSize;
-      memcpy((void*)((uintptr_t)res + sizeof(JavaObject) + sizeof(size_t)),
-             (void*)((uintptr_t)src + sizeof(JavaObject) + sizeof(size_t)),
-             size);
-    } else {
-      for (int i = 0; i < length; i++) {
-        tmp = ArrayObject::getElement((ArrayObject*)src, i);
-        ArrayObject::setElement((ArrayObject*)res, tmp, i);
-      }
-    }
-  } else {
-    assert(cl->isClass() && "Not a class!");
-    res = cl->asClass()->doNew(vm);
-    while (cl != NULL) {
-      for (uint32 i = 0; i < cl->asClass()->nbVirtualFields; ++i) {
-        JavaField& field = cl->asClass()->virtualFields[i];
-        if (field.isReference()) {
-          tmp = field.getInstanceObjectField(src);
-          JavaObject** ptr = field.getInstanceObjectFieldPtr(res);
-          mvm::Collector::objectReferenceWriteBarrier((gc*)res,
(gc**)ptr, (gc*)tmp);
-        } else if (field.isLong()) {
-          field.setInstanceLongField(res, field.getInstanceLongField(src));
-        } else if (field.isDouble()) {
-          field.setInstanceDoubleField(res, field.getInstanceDoubleField(src));
-        } else if (field.isInt()) {
-          field.setInstanceInt32Field(res, field.getInstanceInt32Field(src));
-        } else if (field.isFloat()) {
-          field.setInstanceFloatField(res, field.getInstanceFloatField(src));
-        } else if (field.isShort() || field.isChar()) {
-          field.setInstanceInt16Field(res, field.getInstanceInt16Field(src));
-        } else if (field.isByte() || field.isBoolean()) {
-          field.setInstanceInt8Field(res, field.getInstanceInt8Field(src));
-        } else {
-          UNREACHABLE();
-        }
-      }
-      cl = cl->super;
-    }
-  }
+  res = JavaObject::clone(src);

   END_NATIVE_EXCEPTION

@@ -130,23 +80,13 @@ JNIEXPORT void JNICALL Java_java_lang_VMObject_wait(
 JNIEnv *env,
 jclass clazz,
 #endif
-JavaObject* obj, jlong ms, jint ns) {
+JavaObject* obj, long long ms, int ns) {

   llvm_gcroot(obj, 0);

   BEGIN_NATIVE_EXCEPTION(0)

-  uint32 sec = (uint32) (ms / 1000);
-  uint32 usec = (ns / 1000) + 1000 * (ms % 1000);
-  if (ns && !usec) usec = 1;
-  if (sec || usec) {
-    struct timeval t;
-    t.tv_sec = sec;
-    t.tv_usec = usec;
-    JavaObject::timedWait(obj, t);
-  } else {
-    JavaObject::wait(obj);
-  }
+  Object_wait(obj, ms, ns);

   END_NATIVE_EXCEPTION
 }
diff --git a/lib/J3/ClassLib/Object.inc b/lib/J3/ClassLib/Object.inc
new file mode 100644
index 0000000..aa6f92b
--- /dev/null
+++ b/lib/J3/ClassLib/Object.inc
@@ -0,0 +1,31 @@
+//===---------- Object.inc - Shared j.l.Object code
-----------------------===//
+//                            The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "JavaObject.h"
+
+void Object_wait(JavaObject* obj, jlong ms, jint ns) {
+  llvm_gcroot(obj, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+
+  if (ms < 0 || ns < 0) {
+    vm->illegalArgumentException("Negative wait time specified");
+  }
+
+  uint32 sec = (uint32) (ms / 1000);
+  uint32 usec = (ns / 1000) + 1000 * (ms % 1000);
+  if (ns && !usec) usec = 1;
+  if (sec || usec) {
+    struct timeval t;
+    t.tv_sec = sec;
+    t.tv_usec = usec;
+    JavaObject::timedWait(obj, t);
+  } else {
+    JavaObject::wait(obj);
+  }
+}
diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 9d92f91..947b7d3 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -8,10 +8,12 @@

 #include "jvm.h"

-#include "ArrayCopy.inc"
 #include "JavaConstantPool.h"
 #include "Reader.h"
+
+#include "ArrayCopy.inc"
 #include "SetProperties.inc"
+#include "Object.inc"

 #include <errno.h>
 #include <fcntl.h>
@@ -115,51 +117,47 @@ JVM_IHashCode(JNIEnv *env, jobject _obj) {

 JNIEXPORT void JNICALL
 JVM_MonitorWait(JNIEnv *env, jobject obj, jlong ms) {
-  JavaObject * o = 0;
-  llvm_gcroot(o, 0);
-
   BEGIN_JNI_EXCEPTION
-  Jnjvm* vm = JavaThread::get()->getJVM();
-
-  o = *(JavaObject**)obj;

-  if (ms < 0) {
-    vm->illegalArgumentException("Negative wait time specified");
-  }
-  if (ms) {
-    struct timeval info;
-    uint64_t usec = ms * 1000LL;
-    info.tv_usec = usec % 1000000LL;
-    info.tv_sec = usec / 1000000LL;
-    JavaObject::timedWait(o, info);
-  } else {
-    JavaObject::wait(o);
-  }
+  Object_wait(*(JavaObject**)obj, ms, 0);
   RETURN_VOID_FROM_JNI
+
   END_JNI_EXCEPTION
 }

 JNIEXPORT void JNICALL
 JVM_MonitorNotify(JNIEnv *env, jobject obj) {
   BEGIN_JNI_EXCEPTION
-  JavaObject * o = *(JavaObject**)obj;
-  JavaObject::notify(o);
+
+  JavaObject::notify(*(JavaObject**)obj);
+
   RETURN_VOID_FROM_JNI
+
   END_JNI_EXCEPTION
 }

 JNIEXPORT void JNICALL
 JVM_MonitorNotifyAll(JNIEnv *env, jobject obj) {
   BEGIN_JNI_EXCEPTION
-  JavaObject * o = *(JavaObject**)obj;
-  JavaObject::notifyAll(o);
+
+  JavaObject::notifyAll(*(JavaObject**)obj);
   RETURN_VOID_FROM_JNI
+
   END_JNI_EXCEPTION
 }

 JNIEXPORT jobject JNICALL
 JVM_Clone(JNIEnv *env, jobject obj) {
-  NYI();
+  JavaObject * clone = 0;
+  llvm_gcroot(clone, 0);
+  BEGIN_JNI_EXCEPTION
+
+  clone = JavaObject::clone(*(JavaObject**)obj);
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(clone));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /*
diff --git a/lib/J3/VMCore/JavaObject.cpp b/lib/J3/VMCore/JavaObject.cpp
index 55305af..d5e989f 100644
--- a/lib/J3/VMCore/JavaObject.cpp
+++ b/lib/J3/VMCore/JavaObject.cpp
@@ -9,6 +9,7 @@

 #include "mvm/Threads/Locks.h"

+#include "JavaArray.h"
 #include "JavaClass.h"
 #include "JavaObject.h"
 #include "JavaThread.h"
@@ -118,6 +119,71 @@ void JavaObject::notifyAll(JavaObject* self) {
   thread->lockingThread.notifyAll(self, table);
 }

+JavaObject* JavaObject::clone(JavaObject* src) {
+  JavaObject* res = 0;
+  JavaObject* tmp = 0;
+
+  llvm_gcroot(src, 0);
+  llvm_gcroot(res, 0);
+  llvm_gcroot(tmp, 0);
+
+  UserCommonClass* cl = JavaObject::getClass(src);
+  Jnjvm* vm = JavaThread::get()->getJVM();
+
+  // If this doesn't inherit the Cloneable interface, throw exception
+  // TODO: Add support in both VM's for the upcalls fields used here
+  //if (!JavaObject::instanceOf(src, vm->upcalls->cloneableClass))
+  //  vm->cloneNotSupportedException();
+
+  if (cl->isArray()) {
+    UserClassArray* array = cl->asArrayClass();
+    int length = JavaArray::getSize(src);
+    res = array->doNew(length, vm);
+    UserCommonClass* base = array->baseClass();
+    if (base->isPrimitive()) {
+      int size = length << base->asPrimitiveClass()->logSize;
+      memcpy((void*)((uintptr_t)res + sizeof(JavaObject) + sizeof(size_t)),
+             (void*)((uintptr_t)src + sizeof(JavaObject) + sizeof(size_t)),
+             size);
+    } else {
+      for (int i = 0; i < length; i++) {
+        tmp = ArrayObject::getElement((ArrayObject*)src, i);
+        ArrayObject::setElement((ArrayObject*)res, tmp, i);
+      }
+    }
+  } else {
+    assert(cl->isClass() && "Not a class!");
+    res = cl->asClass()->doNew(vm);
+    while (cl != NULL) {
+      for (uint32 i = 0; i < cl->asClass()->nbVirtualFields; ++i) {
+        JavaField& field = cl->asClass()->virtualFields[i];
+        if (field.isReference()) {
+          tmp = field.getInstanceObjectField(src);
+          JavaObject** ptr = field.getInstanceObjectFieldPtr(res);
+          mvm::Collector::objectReferenceWriteBarrier((gc*)res,
(gc**)ptr, (gc*)tmp);
+        } else if (field.isLong()) {
+          field.setInstanceLongField(res, field.getInstanceLongField(src));
+        } else if (field.isDouble()) {
+          field.setInstanceDoubleField(res, field.getInstanceDoubleField(src));
+        } else if (field.isInt()) {
+          field.setInstanceInt32Field(res, field.getInstanceInt32Field(src));
+        } else if (field.isFloat()) {
+          field.setInstanceFloatField(res, field.getInstanceFloatField(src));
+        } else if (field.isShort() || field.isChar()) {
+          field.setInstanceInt16Field(res, field.getInstanceInt16Field(src));
+        } else if (field.isByte() || field.isBoolean()) {
+          field.setInstanceInt8Field(res, field.getInstanceInt8Field(src));
+        } else {
+          UNREACHABLE();
+        }
+      }
+      cl = cl->super;
+    }
+  }
+
+  return res;
+}
+
 void JavaObject::overflowThinLock(JavaObject* self) {
   llvm_gcroot(self, 0);
   mvm::ThinLock::overflowThinLock(self,
JavaThread::get()->getJVM()->lockSystem);
diff --git a/lib/J3/VMCore/JavaObject.h b/lib/J3/VMCore/JavaObject.h
index 83995e3..7c385af 100644
--- a/lib/J3/VMCore/JavaObject.h
+++ b/lib/J3/VMCore/JavaObject.h
@@ -266,6 +266,10 @@ public:
   /// the monitor.
   ///
   static void notifyAll(JavaObject* self);
+
+  /// clone - Java clone. Creates a copy of this object.
+  ///
+  static JavaObject* clone(JavaObject* other);

   /// overflowThinLock - Notify that the thin lock has overflowed.
   ///
-- 
1.7.5.1


From wdietz2 at illinois.edu  Sun Nov  6 19:00:35 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sun, 6 Nov 2011 21:00:35 -0600
Subject: [vmkit-commits] [PATCH] Refactor Class-related code into new
	Class.inc.
Message-ID: <CAKGWAO81ayMGHg9xuTNA9iaUT2h+46tGtFhqbGctaUY4KOyDnA@mail.gmail.com>

Inlined below. Also attached, since it's a bit larger.

Shares a lot more code, which is good.

However, the creation of Field/Method/Constructor objects is still
different for classpath vs openjdk, so add some callback functions to
define those.

~Will

>From 151c15f1982b9b4ced11a704303f7103104aac36 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Sat, 5 Nov 2011 23:53:56 -0500
Subject: [PATCH 3/8] Refactor Class-related code into new Class.inc.

---
 lib/J3/ClassLib/Class.inc                         |  251 ++++++++++++++
 lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc |  239 ++++----------
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc               |  367 +++++++++------------
 3 files changed, 474 insertions(+), 383 deletions(-)
 create mode 100644 lib/J3/ClassLib/Class.inc

diff --git a/lib/J3/ClassLib/Class.inc b/lib/J3/ClassLib/Class.inc
new file mode 100644
index 0000000..4e8e063
--- /dev/null
+++ b/lib/J3/ClassLib/Class.inc
@@ -0,0 +1,251 @@
+//===---- Class.inc - Shared j.l.Class code
-------------------------------===//
+//
+//                            The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Implementation-specific logic
+JavaObject* ClassLib_getConstructor(JavaMethod * cons, int i);
+JavaObject* ClassLib_getMethod(JavaMethod* meth, int i);
+JavaObject* ClassLib_getField(JavaField* field, int i);
+
+static inline ArrayObject* Class_getDeclaredConstructors(JavaObject*
Cl, jboolean publicOnly) {
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
+    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();;
+    JnjvmClassLoader* classLoader = cl->classLoader;
+    uint32 size = 0;
+
+    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+          (!publicOnly || pub)) {
+        ++size;
+      }
+    }
+
+    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+          (!publicOnly || pub)) {
+        tmp = ClassLib_getConstructor(meth, i);
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+
+  return ret;
+}
+
+static inline ArrayObject* Class_getDeclaredMethods(JavaObject* Cl,
jboolean publicOnly) {
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  JavaString* str = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+  llvm_gcroot(str, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  Classpath* upcalls = vm->upcalls;
+
+  if (cl->isArray() || cl->isPrimitive()) {
+    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();
+    JnjvmClassLoader* classLoader = cl->classLoader;
+    uint32 size = 0;
+
+    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+         ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+          !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
+          (!publicOnly || pub)) {
+        ++size;
+      }
+    }
+
+
+    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+         ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+          !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
+          (!publicOnly || pub)) {
+        tmp = ClassLib_getMethod(meth, i);
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+
+  return ret;
+}
+
+static inline JavaObject* Class_getDeclaringClass(JavaObject * Cl) {
+  JavaObject* res = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(res, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
+
+  if (cl) {
+    cl->resolveInnerOuterClasses();
+    UserClass* outer = cl->getOuterClass();
+    if (outer) {
+      res = outer->getClassDelegatee(vm);
+    }
+  }
+
+  return res;
+}
+
+static inline ArrayObject* Class_getDeclaredClasses(JavaObject* Cl,
bool publicOnly) {
+  ArrayObject* result = 0;
+  llvm_gcroot(result, 0);
+  llvm_gcroot(Cl, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
+  if (cl) {
+    cl->resolveInnerOuterClasses();
+    UserClassArray* array = vm->upcalls->constructorArrayClass;
+
+    uint16 sizeArray = 0;
+
+    if (publicOnly) {
+      for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
+        UserClass* klass = cl->innerClasses[i];
+        if (isPublic(klass->innerAccess)) ++sizeArray;
+      }
+    } else {
+      sizeArray = cl->nbInnerClasses;
+    }
+
+    result = (ArrayObject*)array->doNew(sizeArray, vm);
+    int index = 0;
+    for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
+      UserClass* klass = cl->innerClasses[i];
+      if (!publicOnly || isPublic(klass->innerAccess))
+        ArrayObject::setElement(result, klass->getClassDelegatee(vm), index++);
+    }
+    assert(index == sizeArray);
+  }
+
+  return result;
+}
+
+static inline ArrayObject* Class_getDeclaredFields(JavaObject* Cl,
jboolean publicOnly) {
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  JavaString* name = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+  llvm_gcroot(name, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  if (!cl->isClass()) {
+    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();
+    uint32 size = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+         ++i) {
+      JavaField* field = &realCl->virtualFields[i];
+      if (!publicOnly || isPublic(field->access)) {
+        ++size;
+      }
+    }
+
+    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+         ++i) {
+      JavaField* field = &realCl->virtualFields[i];
+      if (!publicOnly || isPublic(field->access)) {
+        tmp = ClassLib_getField(field, i);
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+
+  return ret;
+}
+
+static inline ArrayObject* Class_getInterfaces(JavaObject* Cl) {
+  ArrayObject* res = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(res, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  res = (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,
vm);
+
+  for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
+    UserClass* klass = cl->interfaces[i];
+    ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
+  }
+
+  return res;
+}
+
+static inline ArrayObject* Class_getDeclaredAnnotations(JavaObject* Cl) {
+  // TODO: Implement me (for now just returning empty array)
+  ArrayObject* res = 0;
+  llvm_gcroot(res, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
+  res = (ArrayObject*)array->doNew(0, vm);
+
+  return res;
+}
+
+static inline jint Class_getModifiers(JavaObject * Cl) {
+  llvm_gcroot(Cl, 0);
+  jint res;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  res = cl->getAccess();
+
+  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
+    // javac may put that flag to inner classes of enum classes.
+    res &= ~ACC_ENUM;
+  }
+
+  return res;
+}
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
index 0c4d21c..47fd6b6 100644
--- a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
@@ -21,6 +21,8 @@
 #include "JavaUpcalls.h"
 #include "Jnjvm.h"

+#include "Class.inc"
+
 using namespace j3;

 extern "C" {
@@ -86,48 +88,12 @@ JavaObject* Cl,
 jboolean publicOnly) {

   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
   llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
-  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
-    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();;
-    JnjvmClassLoader* classLoader = cl->classLoader;
-    uint32 size = 0;
-
-    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
-          (!publicOnly || pub)) {
-        ++size;
-      }
-    }
-
-    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
-          (!publicOnly || pub)) {
-        UserClass* Cons = vm->upcalls->newConstructor;
-        tmp = Cons->doNew(vm);
-        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp, &Cl, i);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = Class_getDeclaredConstructors(Cl, publicOnly);

   END_NATIVE_EXCEPTION

@@ -143,58 +109,12 @@ JavaObject* Cl,
 jboolean publicOnly) {

   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaString* str = 0;
   llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
-  llvm_gcroot(str, 0);

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-  Classpath* upcalls = vm->upcalls;
-
-  if (cl->isArray() || cl->isPrimitive()) {
-    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();
-    JnjvmClassLoader* classLoader = cl->classLoader;
-    uint32 size = 0;
-
-    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
-         ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
-          !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
-          (!publicOnly || pub)) {
-        ++size;
-      }
-    }
-
-
-    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
-         ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
-          !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
-          (!publicOnly || pub)) {
-        // TODO: check parameter types
-        UserClass* Meth = vm->upcalls->newMethod;
-        tmp = Meth->doNew(vm);
-        str = vm->internalUTF8ToStr(meth->name);
-        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, &Cl, &str, i);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = Class_getDeclaredMethods(Cl, publicOnly);

   END_NATIVE_EXCEPTION

@@ -214,14 +134,7 @@ jboolean ignore) {

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-  res = cl->getAccess();
-
-  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
-    // javac may put that flag to inner classes of enum classes.
-    res &= ~ACC_ENUM;
-  }
+  res = Class_getModifiers(Cl);

   END_NATIVE_EXCEPTION
   return res;
@@ -428,49 +341,12 @@ jclass clazz,
 JavaObject* Cl, jboolean publicOnly) {

   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaString* name = 0;
   llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
-  llvm_gcroot(name, 0);

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
-  if (!cl->isClass()) {
-    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();
-    uint32 size = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
-         ++i) {
-      JavaField* field = &realCl->virtualFields[i];
-      if (!publicOnly || isPublic(field->access)) {
-        ++size;
-      }
-    }
-
-
-    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
-         ++i) {
-      JavaField* field = &realCl->virtualFields[i];
-      if (!publicOnly || isPublic(field->access)) {
-        // TODO: check parameter types
-        UserClass* Field = vm->upcalls->newField;
-        tmp = Field->doNew(vm);
-        name = vm->internalUTF8ToStr(field->name);
-        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, &Cl,
&name, i);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = Class_getDeclaredFields(Cl, publicOnly);

   END_NATIVE_EXCEPTION

@@ -490,14 +366,7 @@ JavaObject* Cl) {

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-  res = (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,
vm);
-
-  for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
-    UserClass* klass = cl->interfaces[i];
-    ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
-  }
+  res = Class_getInterfaces(Cl);

   END_NATIVE_EXCEPTION

@@ -518,16 +387,7 @@ JavaObject* Cl) {

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
-
-  if (cl) {
-    cl->resolveInnerOuterClasses();
-    UserClass* outer = cl->getOuterClass();
-    if (outer) {
-      res = outer->getClassDelegatee(vm);
-    }
-  }
+  res = Class_getDeclaringClass(Cl);

   END_NATIVE_EXCEPTION

@@ -548,33 +408,7 @@ JavaObject* Cl, bool publicOnly) {

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
-  if (cl) {
-    cl->resolveInnerOuterClasses();
-    UserClassArray* array = vm->upcalls->constructorArrayClass;
-
-    uint16 sizeArray = 0;
-
-    if (publicOnly) {
-      for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
-        UserClass* klass = cl->innerClasses[i];
-        if (isPublic(klass->innerAccess)) ++sizeArray;
-      }
-    } else {
-      sizeArray = cl->nbInnerClasses;
-    }
-
-    result = (ArrayObject*)array->doNew(sizeArray, vm);
-    int index = 0;
-    for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
-      UserClass* klass = cl->innerClasses[i];
-      if (!publicOnly || isPublic(klass->innerAccess))
-        ArrayObject::setElement(result, klass->getClassDelegatee(vm),
index++);
-    }
-    assert(index == sizeArray);
-  }
-
+  result = Class_getDeclaredClasses(Cl, publicOnly);

   END_NATIVE_EXCEPTION

@@ -603,16 +437,14 @@ jclass clazz,
 #endif
 JavaObject* Cl) {
   // TODO implement me
-
+
   ArrayObject* res = 0;
   llvm_gcroot(res, 0);
   llvm_gcroot(Cl, 0);
-
+
   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
-  res = (ArrayObject*)array->doNew(0, vm);
+  res = Class_getDeclaredAnnotations(Cl);

   END_NATIVE_EXCEPTION

@@ -641,5 +473,52 @@ JavaObject* Cl) {
   return res;
 }

+JavaObject* ClassLib_getConstructor(JavaMethod * cons, int i) {
+  JavaObject* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* Cons = vm->upcalls->newConstructor;
+  ret = Cons->doNew(vm);
+  JavaObject* const* Cl = cons->classDef->getDelegateePtr();
+  vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
+    Cl, i);
+
+  return ret;
+}
+
+JavaObject* ClassLib_getMethod(JavaMethod* meth, int i) {
+  JavaObject* ret = 0;
+  JavaString* str = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(str, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* Meth = vm->upcalls->newMethod;
+  ret = Meth->doNew(vm);
+  str = vm->internalUTF8ToStr(meth->name);
+  JavaObject* const* Cl = meth->classDef->getDelegateePtr();
+  vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
+    Cl, &str, i);
+
+  return ret;
+}
+
+JavaObject* ClassLib_getField(JavaField* field, int i) {
+  JavaObject* ret = 0;
+  JavaString* name = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(name, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* Field = vm->upcalls->newField;
+  ret = Field->doNew(vm);
+  name = vm->internalUTF8ToStr(field->name);
+  JavaObject* const* Cl = field->classDef->getDelegateePtr();
+  vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
+    Cl, &name, i);
+
+  return ret;
+}

 }
diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 012b021..4f25fb0 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -12,6 +12,7 @@
 #include "Reader.h"

 #include "ArrayCopy.inc"
+#include "Class.inc"
 #include "ClassContext.inc"
 #include "SetProperties.inc"
 #include "Object.inc"
@@ -1038,7 +1039,18 @@ JVM_GetClassName(JNIEnv *env, jclass cls) {

 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassInterfaces(JNIEnv *env, jclass cls) {
-  NYI();
+  ArrayObject* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  ret = Class_getInterfaces(*(JavaObject**)cls);
+
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT jobject JNICALL
@@ -1184,17 +1196,7 @@ JVM_GetClassModifiers(JNIEnv *env, jclass cls) {

   Cl = *(JavaObject**)cls;

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
false)->asClass();;
-
-  jint res = cl->getAccess();
-
-  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
-    // javac may put that flag to inner classes of enum classes.
-    res &= ~ACC_ENUM;
-  }
-
-  RETURN_FROM_JNI(res);
+  RETURN_FROM_JNI(Class_getModifiers(Cl));

   END_JNI_EXCEPTION

@@ -1203,12 +1205,35 @@ JVM_GetClassModifiers(JNIEnv *env, jclass cls) {

 JNIEXPORT jobjectArray JNICALL
 JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass) {
-  NYI();
+  ArrayObject* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  // TODO: Verify boolean parameter here, assuming should default to true.
+  ret = Class_getDeclaredClasses(*(JavaObject**)ofClass, false);
+
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT jclass JNICALL
 JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass) {
-  NYI();
+  JavaObject* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  ret = Class_getDeclaringClass(*(JavaObject**)ofClass);
+
+  RETURN_FROM_JNI((jclass)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /* Generics support (JDK 1.5) */
@@ -1220,84 +1245,144 @@ JVM_GetClassSignature(JNIEnv *env, jclass cls) {
 /* Annotations support (JDK 1.5) */
 JNIEXPORT jbyteArray JNICALL
 JVM_GetClassAnnotations(JNIEnv *env, jclass cls) {
-  NYI();
+  ArrayObject* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  ret = Class_getDeclaredAnnotations(*(JavaObject**)cls);
+
+  RETURN_FROM_JNI((jbyteArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /*
  * New (JDK 1.4) reflection implementation
  */
+JavaObject* ClassLib_getConstructor(JavaMethod * cons, int i) {
+  JavaObject* ret = 0;
+  JavaObject* pArr = 0;
+  JavaObject* eArr = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(pArr, 0);
+  llvm_gcroot(eArr, 0);

-JNIEXPORT jobjectArray JNICALL
-JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
-  ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader * classLoader = cons->classDef->classLoader;
+
+  UserClass* Cons = vm->upcalls->newConstructor;
+  pArr = cons->getParameterTypes(classLoader);
+  eArr = cons->getExceptionTypes(classLoader);
+  ret = Cons->doNew(vm);
+  JavaObject* const* Cl = cons->classDef->getDelegateePtr();
+  vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
+    Cl,           /* declaringClass */
+    &pArr,        /* parameterTypes */
+    &eArr,        /* checkedExceptions */
+    cons->access, /* modifiers */
+    i,            /* slot */
+    NULL,         /* String signature */
+    NULL,         /* annotations */
+    NULL          /* parameterAnnotations */
+  );
+
+  return ret;
+}
+
+JavaObject* ClassLib_getMethod(JavaMethod* meth, int i) {
+  JavaObject* ret = 0;
   JavaString* str = 0;
-  JavaObject * Cl = 0;
-  llvm_gcroot(Cl, 0);
+  JavaObject* pArr = 0;
+  JavaObject* eArr = 0;
+  JavaObject* retTy = 0;
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
   llvm_gcroot(str, 0);
+  llvm_gcroot(pArr, 0);
+  llvm_gcroot(eArr, 0);
+  llvm_gcroot(retTy, 0);

-  BEGIN_JNI_EXCEPTION
-
-  Cl = *(JavaObject**)ofClass;
+  // TODO: check parameter types
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader * classLoader = meth->classDef->classLoader;
+
+  UserClass* Meth = vm->upcalls->newMethod;
+  ret = Meth->doNew(vm);
+  str = vm->internalUTF8ToStr(meth->name);
+  pArr = meth->getParameterTypes(classLoader);
+  eArr = meth->getExceptionTypes(classLoader);
+  retTy = meth->getReturnType(classLoader);
+  JavaObject* const* Cl = meth->classDef->getClassDelegateePtr(vm);
+  vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
+    Cl,           /* declaring class */
+    &str,         /* name */
+    &pArr,        /* parameter types */
+    &retTy,       /* return type */
+    &eArr,        /* exceptions */
+    meth->access, /* modifiers */
+    i,            /* slot */
+    NULL,         /* signature */
+    NULL,         /* annotations */
+    NULL,         /* parameter annotations */
+    NULL);        /* default annotations */
+
+  return ret;
+}
+
+JavaObject* ClassLib_getField(JavaField* field, int i) {
+  JavaObject* ret = 0;
+  JavaString* name = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(name, 0);

+  // TODO: check parameter types
   Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-  Classpath* upcalls = vm->upcalls;
+  UserClass* Field = vm->upcalls->newField;
+  ret = Field->doNew(vm);
+  name = vm->internalUTF8ToStr(field->name);
+
+  //type->Class
+  JnjvmClassLoader* loader = field->classDef->classLoader;
+  UserCommonClass * fieldCl = field->getSignature()->assocClass(loader);
+  assert(fieldCl);
+  JavaObject* const* type = fieldCl->getClassDelegateePtr(vm);
+  JavaObject* const* Cl = field->classDef->getClassDelegateePtr(vm);
+
+  // TODO:Implement these!
+  JavaObject** sign = NULL;
+  JavaObject** annArray = NULL;
+
+  /* java.reflect.Field(
+  *   Class declaringClass,
+  *   String name,
+  *   Class type,
+  *   int modifiers,
+  *   int slot,
+  *   String signature,
+  *   byte[] annotations)
+  */
+  vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
+    Cl,
+    &name,
+    type,
+    field->access,
+    i,
+    sign,
+    annArray);
+
+  return ret;
+}

-  if (cl->isArray() || cl->isPrimitive()) {
-    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();
-    JnjvmClassLoader* classLoader = cl->classLoader;
-    uint32 size = 0;
-
-    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
-         ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
-          (!publicOnly || pub)) {
-        ++size;
-      }
-    }
+JNIEXPORT jobjectArray JNICALL
+JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
+  ArrayObject* ret = 0;
+  llvm_gcroot(ret, 0);

+  BEGIN_JNI_EXCEPTION

-    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
-         ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
-          (!publicOnly || pub)) {
-        // TODO: check parameter types
-        UserClass* Meth = vm->upcalls->newMethod;
-        tmp = Meth->doNew(vm);
-        str = vm->internalUTF8ToStr(meth->name);
-        JavaObject * pArr = meth->getParameterTypes(classLoader);
-        JavaObject * eArr = meth->getExceptionTypes(classLoader);
-        JavaObject * retTy = meth->getReturnType(classLoader);
-        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp,
-          &Cl,          /* declaring class */
-          &str,         /* name */
-          &pArr,        /* parameter types */
-          &retTy,       /* return type */
-          &eArr,        /* exceptions */
-          meth->access, /* modifiers */
-          i,            /* slot */
-          NULL,         /* signature */
-          NULL,         /* annotations */
-          NULL,         /* parameter annotations */
-          NULL,         /* default annotations */
-          i);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = Class_getDeclaredMethods(*(JavaObject**)ofClass, publicOnly);

   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));

@@ -1309,85 +1394,12 @@ JVM_GetClassDeclaredMethods(JNIEnv *env,
jclass ofClass, jboolean publicOnly) {
 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaString* name = 0;
-  JavaObject*const*  type = 0;
-  JavaString* sign = 0;
-  JavaObject* annArray = 0;
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
-  llvm_gcroot(name, 0);
-  llvm_gcroot(type, 0);
-  llvm_gcroot(sign, 0);
-  llvm_gcroot(annArray, 0);

   BEGIN_JNI_EXCEPTION

-  JavaObject * Cl = *(JavaObject**)ofClass;
-  llvm_gcroot(Cl, 0);
+  ret = Class_getDeclaredFields(*(JavaObject**)ofClass, publicOnly);

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
-  if (!cl->isClass()) {
-    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();
-    uint32 size = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
-         ++i) {
-      JavaField* field = &realCl->virtualFields[i];
-      if (!publicOnly || isPublic(field->access)) {
-        ++size;
-      }
-    }
-
-
-    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
-         ++i) {
-      JavaField* field = &realCl->virtualFields[i];
-      if (!publicOnly || isPublic(field->access)) {
-        // TODO: check parameter types
-        UserClass* Field = vm->upcalls->newField;
-        tmp = Field->doNew(vm);
-        name = vm->internalUTF8ToStr(field->name);
-
-        //type->Class
-        UserCommonClass * fieldCl =
field->getSignature()->assocClass(cl->classLoader);
-        assert(fieldCl);
-        type = fieldCl->getClassDelegateePtr(vm);
-
-        // TODO:Implement these!
-        sign = NULL;
-        annArray = NULL;
-
-        //Convert to string
-
-        /* java.reflect.Field(
-         *   Class declaringClass,
-         *   String name,
-         *   Class type,
-         *   int modifiers,
-         *   int slot,
-         *   String signature,
-         *   byte[] annotations)
-         */
-        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp,
-          &Cl,
-          &name,
-          type,
-          field->access,
-          i,
-          sign,
-          annArray);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));

   END_JNI_EXCEPTION
@@ -1398,62 +1410,11 @@ JVM_GetClassDeclaredFields(JNIEnv *env, jclass
ofClass, jboolean publicOnly) {
 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass,
jboolean publicOnly) {
   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaObject* Cl = 0;
-  llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);

   BEGIN_JNI_EXCEPTION

-  Cl = *(JavaObject**)ofClass;
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
-  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
-    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();;
-    JnjvmClassLoader* classLoader = cl->classLoader;
-    uint32 size = 0;
-
-    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
-          (!publicOnly || pub)) {
-        ++size;
-      }
-    }
-
-    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
-          (!publicOnly || pub)) {
-        UserClass* Cons = vm->upcalls->newConstructor;
-        JavaObject * pArr = meth->getParameterTypes(classLoader);
-        JavaObject * eArr = meth->getExceptionTypes(classLoader);
-        tmp = Cons->doNew(vm);
-        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp,
-          &Cl,          /* declaringClass */
-          &pArr,        /* parameterTypes */
-          &eArr,        /* checkedExceptions */
-          meth->access, /* modifiers */
-          i,            /* slot */
-          NULL,         /* String signature */
-          NULL,         /* annotations */
-          NULL          /* parameterAnnotations */
-        );
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = Class_getDeclaredConstructors(*(JavaObject**)ofClass, publicOnly);

   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));

-- 
1.7.5.1
-------------- next part --------------
A non-text attachment was scrubbed...
Name: 0003-Refactor-Class-related-code-into-new-Class.inc.patch
Type: application/octet-stream
Size: 32106 bytes
Desc: not available
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111106/2b4a18c3/attachment.obj>

From wdietz2 at illinois.edu  Sun Nov  6 19:04:08 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sun, 6 Nov 2011 21:04:08 -0600
Subject: [vmkit-commits] [PATCH] Don't try to emit methods from primitive
	classes' VT, they're bogus.
Message-ID: <CAKGWAO-6a-wJ4HoK5oor1i8hKVS-xU9U0BwXKUVWRJnxPPsF3g@mail.gmail.com>

Inlined below.

I honestly don't know why this didn't cause problems before, since we
explicitly attempt to emit the VT for primitive classes (while
precompiling) in a few places.  However, this is needed for the "emit
null for j.l.Class" patch to work, which was a bit unexpected :).

Thanks!

~Will

>From 8a795a7a5f6c69ef97407ef9582d8b8a524ba456 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Sun, 6 Nov 2011 20:16:44 -0600
Subject: [PATCH 8/8] Don't try to emit methods from primitive classes' VT,
 they're bogus.

---
 lib/J3/Compiler/JavaAOTCompiler.cpp |    5 ++++-
 1 files changed, 4 insertions(+), 1 deletions(-)

diff --git a/lib/J3/Compiler/JavaAOTCompiler.cpp
b/lib/J3/Compiler/JavaAOTCompiler.cpp
index 2ae8973..c4dc364 100644
--- a/lib/J3/Compiler/JavaAOTCompiler.cpp
+++ b/lib/J3/Compiler/JavaAOTCompiler.cpp
@@ -1775,7 +1775,10 @@ Constant*
JavaAOTCompiler::CreateConstantFromVT(JavaVirtualTable* VT) {
   // methods
   for (uint32 i = JavaVirtualTable::getFirstJavaMethodIndex(); i < size; ++i) {
     JavaMethod* meth = ((JavaMethod**)RealVT)[i];
-    if (isAbstract(meth->access)) {
+    // Primitive classes don't have methods--abstract or otherwise.
+    // (But we do have placeholders for j.l.Object methods in their VTs,
+    // so just emit NULL's here)
+    if (isAbstract(meth->access) || classDef->isPrimitive()) {
       Elemts.push_back(Constant::getNullValue(PTy));
     } else {
       Function* F = getMethodOrStub(meth, maybeCustomize);
-- 
1.7.5.1


From wdietz2 at illinois.edu  Sun Nov  6 19:06:33 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 07 Nov 2011 03:06:33 -0000
Subject: [vmkit-commits] [vmkit] r143903 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111107030634.04A682A6C12C@llvm.org>

Author: wdietz2
Date: Sun Nov  6 21:06:33 2011
New Revision: 143903

URL: http://llvm.org/viewvc/llvm-project?rev=143903&view=rev
Log:
Impl JVM_Interrupt, JVM_IsInterrupted

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143903&r1=143902&r2=143903&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Sun Nov  6 21:06:33 2011
@@ -629,13 +629,75 @@
 }
 
 JNIEXPORT void JNICALL
-JVM_Interrupt(JNIEnv *env, jobject thread) {
-  NYI();
+JVM_Interrupt(JNIEnv *env, jobject _thread) {
+  JavaObject * thread = 0;
+  llvm_gcroot(thread, 0);
+  BEGIN_JNI_EXCEPTION
+
+  thread = *(JavaObject**)_thread;
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JavaField * field = vm->upcalls->eetop;
+
+  // It's possible that the thread to be interrupted has not finished
+  // its initialization. Wait until the initialization is done.
+  while (field->getInstanceLongField(thread) == 0)
+    mvm::Thread::yield();
+
+  JavaThread* th = (JavaThread*)field->getInstanceLongField(thread);
+  th->lockingThread.interruptFlag = 1;
+  mvm::FatLock* lock = th->lockingThread.waitsOn;
+
+  // If the thread is blocked on a wait. We also verify nextWaiting in case
+  // the thread has been notified.
+  if (lock && th->lockingThread.nextWaiting) {
+    th->lockingThread.state = mvm::LockingThread::StateInterrupted;
+
+    // Make sure the thread is waiting.
+    uint32 locked = 0;
+    while (true) {
+      locked = (lock->tryAcquire() == 0);
+      if (locked || (lock->getOwner() != th && lock->getOwner() != 0))
+        break;
+      else mvm::Thread::yield();
+    }
+
+    // Interrupt the thread.
+    th->lockingThread.varcond.signal();
+
+    // Release the lock if we acquired it.
+    if (locked) lock->release(lock->getAssociatedObject(), vm->lockSystem);
+  }
+
+  // Here we could also raise a signal for interrupting I/O
+
+  RETURN_VOID_FROM_JNI
+  END_JNI_EXCEPTION
 }
 
 JNIEXPORT jboolean JNICALL
-JVM_IsInterrupted(JNIEnv *env, jobject thread, jboolean clearInterrupted) {
-  NYI();
+JVM_IsInterrupted(JNIEnv *env, jobject _thread, jboolean clearInterrupted) {
+  JavaObject * thread = 0;
+  llvm_gcroot(thread, 0);
+
+  bool interrupt = false;
+
+  BEGIN_JNI_EXCEPTION
+
+  thread = *(JavaObject**)_thread;
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JavaField * field = vm->upcalls->eetop;
+
+  JavaThread* jth = (JavaThread*)field->getInstanceLongField(thread);
+  interrupt = (jboolean)jth->lockingThread.interruptFlag;
+
+  if (clearInterrupted)
+    jth->lockingThread.interruptFlag = 0;
+
+  RETURN_FROM_JNI(interrupt);
+
+  END_JNI_EXCEPTION
+
+  return false;
 }
 
 JNIEXPORT jboolean JNICALL




From gael.thomas at lip6.fr  Mon Nov  7 03:16:04 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Mon, 07 Nov 2011 11:16:04 -0000
Subject: [vmkit-commits] [vmkit] r143957 - in /vmkit/trunk: ./
 lib/J3/ClassLib/ lib/J3/ClassLib/GNUClasspath/ lib/J3/VMCore/JavaClass.cpp
 lib/J3/VMCore/JavaObject.cpp lib/Mvm/CommonThread/ObjectLocks.cpp
 lib/Mvm/CommonThread/ctlock.cpp lib/Mvm/Compiler/JIT.cpp lib/Mvm/MMTk/
 mmtk/inline/ mmtk/java/ mmtk/mmtk-alloc/ mmtk/mmtk-j3/Statistics.cpp tools/
Message-ID: <20111107111605.15D512A6C12C@llvm.org>

Author: gthomas
Date: Mon Nov  7 05:16:04 2011
New Revision: 143957

URL: http://llvm.org/viewvc/llvm-project?rev=143957&view=rev
Log:
avoid warnings, LLVM_HOSTTRIPLE is now LLVM_DEFAULT_TARGET_TRIPLE

Modified:
    vmkit/trunk/   (props changed)
    vmkit/trunk/lib/J3/ClassLib/   (props changed)
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/   (props changed)
    vmkit/trunk/lib/J3/VMCore/JavaClass.cpp
    vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
    vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
    vmkit/trunk/lib/Mvm/MMTk/   (props changed)
    vmkit/trunk/mmtk/inline/   (props changed)
    vmkit/trunk/mmtk/java/   (props changed)
    vmkit/trunk/mmtk/mmtk-alloc/   (props changed)
    vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp
    vmkit/trunk/tools/   (props changed)

Propchange: vmkit/trunk/
------------------------------------------------------------------------------
--- svn:ignore (original)
+++ svn:ignore Mon Nov  7 05:16:04 2011
@@ -1,5 +1,6 @@
 do-find
 Makefile.config
+Makefile.llvmbuild
 replace.sh
 config.log
 *.tmp

Propchange: vmkit/trunk/lib/J3/ClassLib/
------------------------------------------------------------------------------
--- svn:ignore (added)
+++ svn:ignore Mon Nov  7 05:16:04 2011
@@ -0,0 +1 @@
+Classpath.h

Propchange: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/
------------------------------------------------------------------------------
--- svn:ignore (added)
+++ svn:ignore Mon Nov  7 05:16:04 2011
@@ -0,0 +1 @@
+Release

Modified: vmkit/trunk/lib/J3/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaClass.cpp?rev=143957&r1=143956&r2=143957&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaClass.cpp Mon Nov  7 05:16:04 2011
@@ -877,7 +877,8 @@
   PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", mvm::PrintBuffer(this).cString());
 
   Reader reader(bytes);
-  uint32 magic = reader.readU4();
+  uint32 magic;
+  magic = reader.readU4();
   assert(magic == Jnjvm::Magic && "I've created a class but magic is no good!");
 
   /* uint16 minor = */ reader.readU2();

Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.cpp?rev=143957&r1=143956&r2=143957&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaObject.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaObject.cpp Mon Nov  7 05:16:04 2011
@@ -34,7 +34,8 @@
   assert(mvm::HashBits != 0);
 
   word_t header = self->header;
-  word_t GCBits = header & mvm::GCBitMask;
+  word_t GCBits;
+  GCBits = header & mvm::GCBitMask;
   word_t val = header & HashMask;
   if (val != 0) {
     return val ^ (word_t)getClass(self);

Modified: vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp?rev=143957&r1=143956&r2=143957&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp Mon Nov  7 05:16:04 2011
@@ -45,10 +45,12 @@
 void ThinLock::removeFatLock(FatLock* fatLock, LockSystem& table) {
   gc* object = fatLock->associatedObject;
   llvm_gcroot(object, 0);
-  word_t ID = fatLock->getID();
+  word_t ID;
   word_t oldValue = 0;
   word_t newValue = 0;
   word_t yieldedValue = 0;
+
+  ID = fatLock->getID();
   do {
     oldValue = object->header;
     newValue = oldValue & NonLockBitsMask;

Modified: vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp?rev=143957&r1=143956&r2=143957&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp Mon Nov  7 05:16:04 2011
@@ -130,7 +130,8 @@
 }
 
 Cond::Cond() {
-  int errorcode = pthread_cond_init((pthread_cond_t*)&internalCond, NULL);
+  int errorcode;
+  errorcode = pthread_cond_init((pthread_cond_t*)&internalCond, NULL);
   assert(errorcode == 0); 
 }
 
@@ -145,11 +146,11 @@
 void Cond::wait(Lock* l) {
   assert(l->selfOwner());
   int n = l->unsafeUnlock();
-
+  int res;
   Thread* th = Thread::get();
   th->enterUncooperativeCode();
-  int res = pthread_cond_wait((pthread_cond_t*)&internalCond,
-                              (pthread_mutex_t*)&(l->internalLock));
+  res = pthread_cond_wait((pthread_cond_t*)&internalCond,
+													(pthread_mutex_t*)&(l->internalLock));
   th->leaveUncooperativeCode();
 
   assert(!res && "Error on wait");

Modified: vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/JIT.cpp?rev=143957&r1=143956&r2=143957&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/JIT.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/JIT.cpp Mon Nov  7 05:16:04 2011
@@ -60,7 +60,11 @@
 }
 
 const char* MvmModule::getHostTriple() {
-  return LLVM_HOSTTRIPLE;
+#ifdef LLVM_HOSTTRIPLE
+  return LLVM_HOSTTRIPLE
+#else
+  return LLVM_DEFAULT_TARGET_TRIPLE;
+#endif
 }
 
 cl::opt<bool>
@@ -416,7 +420,8 @@
     FrameIterator iterator(*frames);
     while (iterator.hasNext()) {
       FrameInfo* frame = iterator.next();
-      FrameInfo* other = VM->IPToFrameInfo(frame->ReturnAddress);
+      FrameInfo* other;
+      other = VM->IPToFrameInfo(frame->ReturnAddress);
       assert(frame->ReturnAddress == other->ReturnAddress);
     }
   }

Propchange: vmkit/trunk/lib/Mvm/MMTk/
------------------------------------------------------------------------------
--- svn:ignore (original)
+++ svn:ignore Mon Nov  7 05:16:04 2011
@@ -1 +1,3 @@
 Release+Asserts
+Release
+

Propchange: vmkit/trunk/mmtk/inline/
------------------------------------------------------------------------------
--- svn:ignore (original)
+++ svn:ignore Mon Nov  7 05:16:04 2011
@@ -1,2 +1,3 @@
 Release+Asserts
+Release
 *.inc

Propchange: vmkit/trunk/mmtk/java/
------------------------------------------------------------------------------
--- svn:ignore (original)
+++ svn:ignore Mon Nov  7 05:16:04 2011
@@ -1,5 +1,6 @@
 build.xml
 Release+Asserts
+Release
 mmtk-vmkit.bc
 mmtk-vmkit-optimized.bc
 mmtk-vmkit.jar

Propchange: vmkit/trunk/mmtk/mmtk-alloc/
------------------------------------------------------------------------------
--- svn:ignore (original)
+++ svn:ignore Mon Nov  7 05:16:04 2011
@@ -1 +1,3 @@
 Release+Asserts
+Release
+

Modified: vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp?rev=143957&r1=143956&r2=143957&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp Mon Nov  7 05:16:04 2011
@@ -22,7 +22,8 @@
   int64_t result;
   struct timeval tp; 
 
-  int res = gettimeofday (&tp, NULL);
+  int res;
+	res = gettimeofday (&tp, NULL);
   assert(res != -1 && "failed gettimeofday.");
 
   result = (int64_t) tp.tv_sec;

Propchange: vmkit/trunk/tools/
------------------------------------------------------------------------------
--- svn:ignore (added)
+++ svn:ignore Mon Nov  7 05:16:04 2011
@@ -0,0 +1 @@
+llvm-config-2




From wdietz2 at illinois.edu  Mon Nov  7 11:12:20 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 07 Nov 2011 19:12:20 -0000
Subject: [vmkit-commits] [vmkit] r143995 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111107191220.23D662A6C12C@llvm.org>

Author: wdietz2
Date: Mon Nov  7 13:12:19 2011
New Revision: 143995

URL: http://llvm.org/viewvc/llvm-project?rev=143995&view=rev
Log:
Fix JVM_FindLibraryEntry to actually use handle parameter.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=143995&r1=143994&r2=143995&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Mon Nov  7 13:12:19 2011
@@ -348,9 +348,7 @@
 JVM_FindLibraryEntry(void *handle, const char *name) {
   BEGIN_JNI_EXCEPTION
   Jnjvm* vm = JavaThread::get()->getJVM();
-  bool j3 = false;
-  RETURN_FROM_JNI((void *)vm->bootstrapLoader->loadInLib(name, j3));
-
+  RETURN_FROM_JNI((void *)vm->bootstrapLoader->loadInLib(name, handle));
   END_JNI_EXCEPTION
 
   return 0;




From wdietz2 at illinois.edu  Mon Nov  7 11:34:24 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 7 Nov 2011 13:34:24 -0600
Subject: [vmkit-commits] [vmkit] r143957 - in /vmkit/trunk: ./
 lib/J3/ClassLib/ lib/J3/ClassLib/GNUClasspath/ lib/J3/VMCore/JavaClass.cpp
 lib/J3/VMCore/JavaObject.cpp lib/Mvm/CommonThread/ObjectLocks.cpp
 lib/Mvm/CommonThread/ctlock.cpp lib/Mvm/Compiler/JI
Message-ID: <CAKGWAO-+uzOhi3ZLLHFn9RBmVeJxtSOzhMKZvHVBP+4R224HPA@mail.gmail.com>

On Mon, Nov 7, 2011 at 5:16 AM, Gael Thomas <gael.thomas at lip6.fr> wrote:
> Author: gthomas
> Date: Mon Nov  7 05:16:04 2011
> New Revision: 143957
>
> URL: http://llvm.org/viewvc/llvm-project?rev=143957&view=rev
> Log:
> avoid warnings, LLVM_HOSTTRIPLE is now LLVM_DEFAULT_TARGET_TRIPLE
>
> Modified:
>    vmkit/trunk/   (props changed)
>    vmkit/trunk/lib/J3/ClassLib/   (props changed)
>    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/   (props changed)
>    vmkit/trunk/lib/J3/VMCore/JavaClass.cpp
>    vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
>    vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp
>    vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
>    vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
>    vmkit/trunk/lib/Mvm/MMTk/   (props changed)
>    vmkit/trunk/mmtk/inline/   (props changed)
>    vmkit/trunk/mmtk/java/   (props changed)
>    vmkit/trunk/mmtk/mmtk-alloc/   (props changed)
>    vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp
>    vmkit/trunk/tools/   (props changed)
>
> Propchange: vmkit/trunk/
> ------------------------------------------------------------------------------
> --- svn:ignore (original)
> +++ svn:ignore Mon Nov  7 05:16:04 2011
> @@ -1,5 +1,6 @@
>  do-find
>  Makefile.config
> +Makefile.llvmbuild
>  replace.sh
>  config.log
>  *.tmp
>
> Propchange: vmkit/trunk/lib/J3/ClassLib/
> ------------------------------------------------------------------------------
> --- svn:ignore (added)
> +++ svn:ignore Mon Nov  7 05:16:04 2011
> @@ -0,0 +1 @@
> +Classpath.h
>
> Propchange: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/
> ------------------------------------------------------------------------------
> --- svn:ignore (added)
> +++ svn:ignore Mon Nov  7 05:16:04 2011
> @@ -0,0 +1 @@
> +Release
>
> Modified: vmkit/trunk/lib/J3/VMCore/JavaClass.cpp
> URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaClass.cpp?rev=143957&r1=143956&r2=143957&view=diff
> ==============================================================================
> --- vmkit/trunk/lib/J3/VMCore/JavaClass.cpp (original)
> +++ vmkit/trunk/lib/J3/VMCore/JavaClass.cpp Mon Nov  7 05:16:04 2011
> @@ -877,7 +877,8 @@
>   PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", mvm::PrintBuffer(this).cString());
>
>   Reader reader(bytes);
> -  uint32 magic = reader.readU4();
> +  uint32 magic;
> +  magic = reader.readU4();
>   assert(magic == Jnjvm::Magic && "I've created a class but magic is no good!");
>
>   /* uint16 minor = */ reader.readU2();
>
> Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
> URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.cpp?rev=143957&r1=143956&r2=143957&view=diff
> ==============================================================================
> --- vmkit/trunk/lib/J3/VMCore/JavaObject.cpp (original)
> +++ vmkit/trunk/lib/J3/VMCore/JavaObject.cpp Mon Nov  7 05:16:04 2011
> @@ -34,7 +34,8 @@
>   assert(mvm::HashBits != 0);
>
>   word_t header = self->header;
> -  word_t GCBits = header & mvm::GCBitMask;
> +  word_t GCBits;
> +  GCBits = header & mvm::GCBitMask;
>   word_t val = header & HashMask;
>   if (val != 0) {
>     return val ^ (word_t)getClass(self);
>
> Modified: vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp
> URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp?rev=143957&r1=143956&r2=143957&view=diff
> ==============================================================================
> --- vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp (original)
> +++ vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp Mon Nov  7 05:16:04 2011
> @@ -45,10 +45,12 @@
>  void ThinLock::removeFatLock(FatLock* fatLock, LockSystem& table) {
>   gc* object = fatLock->associatedObject;
>   llvm_gcroot(object, 0);
> -  word_t ID = fatLock->getID();
> +  word_t ID;
>   word_t oldValue = 0;
>   word_t newValue = 0;
>   word_t yieldedValue = 0;
> +
> +  ID = fatLock->getID();
>   do {
>     oldValue = object->header;
>     newValue = oldValue & NonLockBitsMask;
>
> Modified: vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
> URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp?rev=143957&r1=143956&r2=143957&view=diff
> ==============================================================================
> --- vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp (original)
> +++ vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp Mon Nov  7 05:16:04 2011
> @@ -130,7 +130,8 @@
>  }
>
>  Cond::Cond() {
> -  int errorcode = pthread_cond_init((pthread_cond_t*)&internalCond, NULL);
> +  int errorcode;
> +  errorcode = pthread_cond_init((pthread_cond_t*)&internalCond, NULL);
>   assert(errorcode == 0);
>  }
>
> @@ -145,11 +146,11 @@
>  void Cond::wait(Lock* l) {
>   assert(l->selfOwner());
>   int n = l->unsafeUnlock();
> -
> +  int res;
>   Thread* th = Thread::get();
>   th->enterUncooperativeCode();
> -  int res = pthread_cond_wait((pthread_cond_t*)&internalCond,
> -                              (pthread_mutex_t*)&(l->internalLock));
> +  res = pthread_cond_wait((pthread_cond_t*)&internalCond,
> +                                                                                                       (pthread_mutex_t*)&(l->internalLock));
>   th->leaveUncooperativeCode();
>
>   assert(!res && "Error on wait");
>
> Modified: vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
> URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/JIT.cpp?rev=143957&r1=143956&r2=143957&view=diff
> ==============================================================================
> --- vmkit/trunk/lib/Mvm/Compiler/JIT.cpp (original)
> +++ vmkit/trunk/lib/Mvm/Compiler/JIT.cpp Mon Nov  7 05:16:04 2011
> @@ -60,7 +60,11 @@
>  }
>
>  const char* MvmModule::getHostTriple() {
> -  return LLVM_HOSTTRIPLE;
> +#ifdef LLVM_HOSTTRIPLE
> +  return LLVM_HOSTTRIPLE

But I needed that semicolon! :)

Just wondering, what compiler are you using that's causing the
warnings fixed in this commit?

> +#else
> +  return LLVM_DEFAULT_TARGET_TRIPLE;
> +#endif
>  }
>
>  cl::opt<bool>
> @@ -416,7 +420,8 @@
>     FrameIterator iterator(*frames);
>     while (iterator.hasNext()) {
>       FrameInfo* frame = iterator.next();
> -      FrameInfo* other = VM->IPToFrameInfo(frame->ReturnAddress);
> +      FrameInfo* other;
> +      other = VM->IPToFrameInfo(frame->ReturnAddress);
>       assert(frame->ReturnAddress == other->ReturnAddress);
>     }
>   }
>
> Propchange: vmkit/trunk/lib/Mvm/MMTk/
> ------------------------------------------------------------------------------
> --- svn:ignore (original)
> +++ svn:ignore Mon Nov  7 05:16:04 2011
> @@ -1 +1,3 @@
>  Release+Asserts
> +Release
> +
>
> Propchange: vmkit/trunk/mmtk/inline/
> ------------------------------------------------------------------------------
> --- svn:ignore (original)
> +++ svn:ignore Mon Nov  7 05:16:04 2011
> @@ -1,2 +1,3 @@
>  Release+Asserts
> +Release
>  *.inc
>
> Propchange: vmkit/trunk/mmtk/java/
> ------------------------------------------------------------------------------
> --- svn:ignore (original)
> +++ svn:ignore Mon Nov  7 05:16:04 2011
> @@ -1,5 +1,6 @@
>  build.xml
>  Release+Asserts
> +Release
>  mmtk-vmkit.bc
>  mmtk-vmkit-optimized.bc
>  mmtk-vmkit.jar
>
> Propchange: vmkit/trunk/mmtk/mmtk-alloc/
> ------------------------------------------------------------------------------
> --- svn:ignore (original)
> +++ svn:ignore Mon Nov  7 05:16:04 2011
> @@ -1 +1,3 @@
>  Release+Asserts
> +Release
> +
>
> Modified: vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp
> URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp?rev=143957&r1=143956&r2=143957&view=diff
> ==============================================================================
> --- vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp (original)
> +++ vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp Mon Nov  7 05:16:04 2011
> @@ -22,7 +22,8 @@
>   int64_t result;
>   struct timeval tp;
>
> -  int res = gettimeofday (&tp, NULL);
> +  int res;
> +       res = gettimeofday (&tp, NULL);
>   assert(res != -1 && "failed gettimeofday.");
>
>   result = (int64_t) tp.tv_sec;
>
> Propchange: vmkit/trunk/tools/
> ------------------------------------------------------------------------------
> --- svn:ignore (added)
> +++ svn:ignore Mon Nov  7 05:16:04 2011
> @@ -0,0 +1 @@
> +llvm-config-2
>
>
> _______________________________________________
> vmkit-commits mailing list
> vmkit-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>



From wdietz2 at illinois.edu  Mon Nov  7 12:14:20 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 7 Nov 2011 14:14:20 -0600
Subject: [vmkit-commits] [PATCH] Fix LSHL to mask the shift operand.
In-Reply-To: <CAKGWAO9ME+PwJ+o_HZaVGfirf-TdnO0msVtpdP2e0KZ2chsZWA@mail.gmail.com>
References: <CAKGWAO9ME+PwJ+o_HZaVGfirf-TdnO0msVtpdP2e0KZ2chsZWA@mail.gmail.com>
Message-ID: <CAKGWAO8=2g=8XqXdFGs78Q58oC8OLZiNPfiHTzwfdXw9w_EPMA@mail.gmail.com>

Inlined below.

The masking logic is already used in LUSHR, FWIW.

~Will

>From 029662fa7bd23532d8a5be59793efab715217356 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Sun, 6 Nov 2011 23:26:17 -0600
Subject: [PATCH] Fix LSHL to mask the shift operand.

Simple test case illustrating failure:

class Test {
   public static void main(String[] args) {
     long l = 1;
     System.out.println(l);
     System.out.println(l << 10);
     System.out.println(l << 32);
     System.out.println(l << 64);
     System.out.println(l << 128);
     System.out.println(l << -10);
   }
}

Should produce (java Hotspot 1.6.0_27)
1
1024
4294967296
1
1
18014398509481984

Before this patch j3 produces:
1
1024
4294967296
4294967296
4294967296
4294967296

This patch aligns j3 with java's behavior.
Additionally, this causes j3 to pass Mauve's Long tests.
---
 lib/J3/Compiler/JavaJITOpcodes.cpp |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

diff --git a/lib/J3/Compiler/JavaJITOpcodes.cpp
b/lib/J3/Compiler/JavaJITOpcodes.cpp
index 4c5e8cd..93b9c3c 100644
--- a/lib/J3/Compiler/JavaJITOpcodes.cpp
+++ b/lib/J3/Compiler/JavaJITOpcodes.cpp
@@ -1185,6 +1185,8 @@ void JavaJIT::compileOpcodes(Reader& reader,
uint32 codeLength) {

      case LSHL : {
        Value* val2 = new ZExtInst(pop(),
Type::getInt64Ty(*llvmContext), "", currentBlock);
+        Value* mask = ConstantInt::get(Type::getInt64Ty(*llvmContext), 0x3F);
+        val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock);
        pop(); // remove the 0 on the stack
        Value* val1 = pop();
        push(BinaryOperator::CreateShl(val1, val2, "", currentBlock),
--
1.7.5.1



From wdietz2 at illinois.edu  Mon Nov  7 12:16:14 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 7 Nov 2011 14:16:14 -0600
Subject: [vmkit-commits] [PATCH] Fix LSHR by masking the shift operand.
Message-ID: <CAKGWAO8-0ijaQ7OdO9RW9oKg2zKN_3kyzmNpCaSFun7QdtsdKw@mail.gmail.com>

Same thing as previous LSHL patch, only for LSHR.

~Will

>From fc51294c2ddb78189092fd87ed4950ecdb6f43c0 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Mon, 7 Nov 2011 13:56:25 -0600
Subject: [PATCH] Fix LSHR by masking the shift operand.

Sample test case:

class Test {
    public static void main(String[] args) {
      long l = 1;
      System.out.println(l);
      System.out.println(l >> 10);
      System.out.println(l >> 32);
      System.out.println(l >> 64);
      System.out.println(l >> 128);
      System.out.println(l >> -10);
    }
}

java produces (Hotspot 1.6.0_27):
1
0
0
1
1
0

j3 before this patch produces:
1
0
0
0
0
0
---
 lib/J3/Compiler/JavaJITOpcodes.cpp |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

diff --git a/lib/J3/Compiler/JavaJITOpcodes.cpp
b/lib/J3/Compiler/JavaJITOpcodes.cpp
index 93b9c3c..682e406 100644
--- a/lib/J3/Compiler/JavaJITOpcodes.cpp
+++ b/lib/J3/Compiler/JavaJITOpcodes.cpp
@@ -1207,6 +1207,8 @@ void JavaJIT::compileOpcodes(Reader& reader,
uint32 codeLength) {

       case LSHR : {
         Value* val2 = new ZExtInst(pop(),
Type::getInt64Ty(*llvmContext), "", currentBlock);
+        Value* mask = ConstantInt::get(Type::getInt64Ty(*llvmContext), 0x3F);
+        val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock);
         pop(); // remove the 0 on the stack
         Value* val1 = pop();
         push(BinaryOperator::CreateAShr(val1, val2, "", currentBlock),
-- 
1.7.5.1


From wdietz2 at illinois.edu  Mon Nov  7 12:25:17 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 7 Nov 2011 14:25:17 -0600
Subject: [vmkit-commits] [PATCH] Impl JVM_InvokeMethod,
	use existing proceedMethod from Classpath
Message-ID: <CAKGWAO_fbagmwMsx6uWBZgaUc2UJ9pFEX_msiAAovp7BAH_3Gg@mail.gmail.com>

>From 4dee86c7d7a61ef8b6e2cd911126ee5b72e517c4 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Sun, 6 Nov 2011 22:04:20 -0600
Subject: [PATCH 1/3] Impl JVM_InvokeMethod, use existing proceedMethod from
 Classpath

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   25 +++++++++++++++++++++++--
 1 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 92c646d..e625a9f 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -1515,8 +1515,29 @@ JVM_GetClassAccessFlags(JNIEnv *env, jclass cls) {
  * java.lang.reflect.Method
  */
 JNIEXPORT jobject JNICALL
-JVM_InvokeMethod(JNIEnv *env, jobject method, jobject _obj,
jobjectArray args0) {
-  NYI();
+JVM_InvokeMethod(JNIEnv *env, jobject _m, jobject _obj, jobjectArray args0) {
+  JavaObject * ret = 0;
+  JavaObjectMethod * m = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(m, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+
+  m = *(JavaObjectMethod**)_m;
+
+  ret = proceedMethod(
+    m,
+    _obj ? *(JavaObject**)_obj : 0,
+    args0? *(ArrayObject**)args0 : 0,
+    JavaObjectMethod::getClass(m)->getDelegatee(),
+    0 /* unused */ );
+
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(ret));
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /*
-- 
1.7.5.1


From wdietz2 at illinois.edu  Mon Nov  7 12:26:58 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 7 Nov 2011 14:26:58 -0600
Subject: [vmkit-commits] [PATCH] Don't abort on JVM_SetClassSigners,
	let it proceed.
Message-ID: <CAKGWAO_JXgAuJax6z_HUWeZeYuGErEk6-Qp1ng7HS=Yhx+VM3Q@mail.gmail.com>

Inlined below.

Seems benign, and helps get through code that insists on setting the signers.

~Will

>From c4ed3b1df165e863a1cc0f0e7d1ebde188f82de4 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Sun, 6 Nov 2011 23:31:03 -0600
Subject: [PATCH 2/3] Don't abort on JVM_SetClassSigners, let it proceed.

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |    4 +++-
 1 files changed, 3 insertions(+), 1 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index e625a9f..b86b56f 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -1160,7 +1160,9 @@ JVM_GetClassSigners(JNIEnv *env, jclass cls) {

 JNIEXPORT void JNICALL
 JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers) {
-  NYI();
+  // Let them 'set' signers, since we don't implement this yet and
+  // don't allow them to 'get' the value back (above).
+  //NYI();
 }

 JNIEXPORT jobject JNICALL
-- 
1.7.5.1


From wdietz2 at illinois.edu  Mon Nov  7 12:28:43 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 7 Nov 2011 14:28:43 -0600
Subject: [vmkit-commits] [PATCH] Impl JVM_NewArray
Message-ID: <CAKGWAO9HHoXH7mRK3VDXyhP+hqzaJFR33fYUoUk+dYBqWp4RcQ@mail.gmail.com>

Inlined below.

~Will

>From 32f5d8efb6c9908c9bb36cdee3facfc3c91a7bf4 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Sat, 5 Nov 2011 14:55:48 -0500
Subject: [PATCH 3/3] Impl JVM_NewArray.

---
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   49 ++++++++++++++++++++++++++++++++++-
 1 files changed, 48 insertions(+), 1 deletions(-)

diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index b86b56f..6342cfe 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -830,7 +830,54 @@ JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject
arr, jint index, jvalue v,

 JNIEXPORT jobject JNICALL
 JVM_NewArray(JNIEnv *env, jclass eltClass, jint length) {
-  NYI();
+  ArrayObject * res = 0;
+  llvm_gcroot(res, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm* vm = th->getJVM();
+  if (length < 0) vm->negativeArraySizeException(length);
+
+  JavaObject * eltClassObj = *(JavaObject**)eltClass;
+  UserCommonClass* base =
+    UserCommonClass::resolvedImplClass(vm, eltClassObj, true);
+  JnjvmClassLoader* loader = base->classLoader;
+  const UTF8* name = base->getName();
+  const UTF8* arrayName = loader->constructArrayName(1, name);
+  if (base->isPrimitive()) {
+    UserClassArray *array = 0;
+    if (base == vm->upcalls->OfBool) {
+      array = vm->upcalls->ArrayOfBool;
+    } else if (base == vm->upcalls->OfByte) {
+      array = vm->upcalls->ArrayOfByte;
+    } else if (base == vm->upcalls->OfShort) {
+      array = vm->upcalls->ArrayOfShort;
+    } else if (base == vm->upcalls->OfChar) {
+      array = vm->upcalls->ArrayOfChar;
+    } else if (base == vm->upcalls->OfInt) {
+      array = vm->upcalls->ArrayOfInt;
+    } else if (base == vm->upcalls->OfFloat) {
+      array = vm->upcalls->ArrayOfFloat;
+    } else if (base == vm->upcalls->OfLong) {
+      array = vm->upcalls->ArrayOfLong;
+    } else if (base == vm->upcalls->OfDouble) {
+      array = vm->upcalls->ArrayOfDouble;
+    } else {
+      vm->illegalArgumentException("Invalid array primitive type!");
+      abort();
+    }
+    res = (ArrayObject*)array->doNew(length, vm);
+  } else {
+    UserClassArray* array = loader->constructArray(arrayName, base);
+    res = (ArrayObject*)array->doNew(length, vm);
+  }
+
+  jobject ret = (jobject)th->pushJNIRef(res);
+  RETURN_FROM_JNI(ret);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT jobject JNICALL
-- 
1.7.5.1


From wdietz2 at illinois.edu  Mon Nov  7 13:02:39 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 7 Nov 2011 15:02:39 -0600
Subject: [vmkit-commits] [PATCH] Remove System.err.println from mmtk
 stuff to fix dep on bootstrap
In-Reply-To: <CAPYwfip3xxs-ma0mk9dc=H0e8JOs59tj36qV3AsJeE98C0CuPg@mail.gmail.com>
References: <CAKGWAO9vi2z4GBRiSecCzoG_S-L2AkjkDLxAu1jvOL0TREUtxQ@mail.gmail.com>
	<CAPYwfip3xxs-ma0mk9dc=H0e8JOs59tj36qV3AsJeE98C0CuPg@mail.gmail.com>
Message-ID: <CAKGWAO_1cLFBiwwE4xm3LhLRje4AgEvPd2mjYQerXfsE_ykreA@mail.gmail.com>

On Fri, Nov 4, 2011 at 5:06 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> Hi Will,
>
> On Thu, Nov 3, 2011 at 3:48 PM, Will Dietz <wdietz2 at illinois.edu> wrote:
>>
>> Inlined below.
>>
>> This change seems benign, but I'm not sure if it's masking some other
>> bug I should be concerned about.
>>
>> Patch primarily a discussion point, although could be committed too
>> (since it's rather minor).
>>
>> FWIW, with this patch (and the previous ones), we can build a
>> OpenJDK-based VMKit that can run many simple codes, and on larger
>> codes seems to only fail when encountering some of the many NYI()'d
>> (or intentionally unimplemented) pieces.  Which is kinda neat! :)
>
> Definitely! That's a giant step! Any plans on sending the instructions on
> which OpenJDK to use? How to configure, etc? :)

I'd love to get that ball rolling, although I'm a bit limited by what
versions I've tested against, and proprietary vs IcedTea.  That said,
I naively expect this to work more or less on any version of OpenJDK
"1.6", as well as with Sun's proprietary 1.6 builds (which is actually
what I test against mostly since it's what I have installed globally).

I'll draft some instructions and try them on a few machines I have
access to you and send them to the list :).

Haven't tried the OpenJDK stuff on a Mac at all, maybe I'll give that
a go too...

>>
>> In the future I hope to focus on getting it to run various codes
>> better (dacapo being my big goal, but not the full story), and try to
>> generally improve misc behavior compatibility/compliance-wise :).
>
> Big encouragements for getting dacapo to run, especially all benchmarks of
> the latest version (which do not run on GNU Classpath).
> There is also SpecJVM2008 I think, that anyone can download. It'd be neat to
> have that running too :)
>

Indeed.  Unfortunately looks like SpecJVM2008 needs awt, which was unexpected.

awt presently segfaults when it tries to call back into the JVM_
methods from native code-- the way it calls them is different than the
way they're called from java code, and results in failures.  Bummer,
will look into this more once other things work better (pure java
code, like dacapo, for example).

>>
>> Thanks!
>>
>> ~Will
>>
>> >From 0462e91eb86e28c00707c40d624853eb51679904 Mon Sep 17 00:00:00 2001
>> From: Will Dietz <w at wdtz.org>
>> Date: Wed, 2 Nov 2011 23:02:45 -0500
>> Subject: [PATCH 15/17] Remove System.err.println from mmtk stuff to fix
>> dep
>>  on bootstrap
>>
>> Not entirely sure, but with these present we get linker errors with
>> libFinalMMtk.a on misc pieces that are pulled in from System.err,
>>  namely things like sun.nio.cs.StreamEncoder.
>
> This may just be a limitation of the AOT compiler, which pulls out more than
> it actually needs. I'd be interested to see the error messages if you still
> have them.
>

I just tried this now, errors appended to end of this message.

> Patch is fine to commit because it just touches mmtk/src/org/j3 files. Note
> that if it were to touch other mmtk/src/org files, it wouldn't be as fine
> because it's code that is imported from mmtk. And this code we should try to
> not deviate from it, to avoid merge conflicts.

Okay, understood.  Committed, thanks!

> Again, that's a great step forward! Nice work. I'm looking forward to see
> all the dacapo benchmarks run on vmkit :)
> Nicolas

Heh, me too, although it's slow going :).

~Will

Errors emitted without this patch:
==============================================
BUILD SUCCESSFUL
Total time: 5 seconds
llvm[2]: Building Release+Asserts mmtk-vmkit.jar all
WARNING: Linking two modules of different data layouts!
make[2]: Leaving directory
`/home/will/llvm/tot/llvm-objects-32/projects/vmkit/mmtk/java'
make[2]: Entering directory
`/home/will/llvm/tot/llvm-objects-32/projects/vmkit/mmtk/inline'
llvm[2]: Compiling InlineMethods.cpp for Release+Asserts build (bytecode)
llvm[2]: Compiling InlineMethods.ll to InlineMethods.bc for
Release+Asserts build (bytecode)
llvm[2]: Compiling InlineMethods.bc to InlineMethods.s for Release+Asserts build
llvm[2]: Compiling InlineMethods.s for Release+Asserts build
llvm[2]: Building Release+Asserts Archive Library libInlineMMTk.a
make[2]: Leaving directory
`/home/will/llvm/tot/llvm-objects-32/projects/vmkit/mmtk/inline'
make[1]: Leaving directory
`/home/will/llvm/tot/llvm-objects-32/projects/vmkit/mmtk'
make[1]: Entering directory
`/home/will/llvm/tot/llvm-objects-32/projects/vmkit/tools/precompiler'
llvm[1]: Compiling Precompiler.cpp for Release+Asserts build
llvm[1]: Linking Release+Asserts executable precompiler (without symbols)
/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/libFinalMMTk.a(FinalMMTk.o):/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/FinalMMTk.bc:function
sun_nio_cs_StreamEncoder_VT: error: undefined reference to
'sun_nio_cs_StreamEncoder'
/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/libFinalMMTk.a(FinalMMTk.o):/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/FinalMMTk.bc:function
sun_nio_cs_ISO_18859_11_VT: error: undefined reference to
'sun_nio_cs_ISO_18859_11'
/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/libFinalMMTk.a(FinalMMTk.o):/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/FinalMMTk.bc:function
sun_nio_cs_HistoricallyNamedCharset_VT: error: undefined reference to
'sun_nio_cs_HistoricallyNamedCharset'
/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/libFinalMMTk.a(FinalMMTk.o):/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/FinalMMTk.bc:function
__unnamed_6816: error: undefined reference to
'sun_nio_cs_HistoricallyNamedCharset_VirtualMethods'
/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/libFinalMMTk.a(FinalMMTk.o):/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/FinalMMTk.bc:function
sun_nio_cs_ISO_18859_11_00024Encoder_VT: error: undefined reference to
'sun_nio_cs_ISO_18859_11_00024Encoder'
/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/libFinalMMTk.a(FinalMMTk.o):/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/FinalMMTk.bc:function
sun_nio_cs_ISO_18859_11_00024Decoder_VT: error: undefined reference to
'sun_nio_cs_ISO_18859_11_00024Decoder'
/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/libFinalMMTk.a(FinalMMTk.o):/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/lib/FinalMMTk.bc:function
sun_nio_cs_Surrogate_00024Parser_VT: error: undefined reference to
'sun_nio_cs_Surrogate_00024Parser'
collect2: ld returned 1 exit status
make[1]: *** [/home/will/llvm/tot/llvm-objects-32/projects/vmkit/Release+Asserts/bin/precompiler]
Error 1
make[1]: Leaving directory
`/home/will/llvm/tot/llvm-objects-32/projects/vmkit/tools/precompiler'
make: *** [all] Error 1



From nicolas.geoffray at gmail.com  Tue Nov  8 00:25:31 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 09:25:31 +0100
Subject: [vmkit-commits] OpenJDK for vmkit 0.30 (llvm 3.0)
In-Reply-To: <CAPYwfirvhfpwyriWZPVnS=aW5NRESWNcmeRS5fnsxG5iBSx-CA@mail.gmail.com>
References: <CAPYwfirvhfpwyriWZPVnS=aW5NRESWNcmeRS5fnsxG5iBSx-CA@mail.gmail.com>
Message-ID: <CAPYwfiqhOxjn0Dgz90Mk_EQHjqknmCVHMS-x6a5-rqJ62+CLkQ@mail.gmail.com>

Will, ping?

On Sun, Nov 6, 2011 at 5:05 PM, Nicolas Geoffray <nicolas.geoffray at gmail.com
> wrote:

> Hi Will,
>
> In case you don't know, llvm will release version 3.0 in a few days. Since
> llvm 2.3, I make a 'release' version of vmkit for each llvm release. It's
> is more of a bundle that compiles with the released version of llvm.
>
> I'd like to create the 'release'  branch soon, so that I can start testing
> vmkit 0.30 against llvm 3.0 and create the bundle. Are there extra patches
> you'd like to integrate for the release? Also, should we promote the
> OpenJDK port for the release notes, or should we wait until we have
> something functional that you and I have tested and used for large-size
> applications (eg dacapo)? Hopefully we'll be at that state the next version
> (0.31)?
>
> Let me know!
>
> Thanks,
> Nicolas
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111108/94e9437f/attachment.html>

From gael.thomas at lip6.fr  Tue Nov  8 05:59:52 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Tue, 08 Nov 2011 13:59:52 -0000
Subject: [vmkit-commits] [vmkit] r144082 - in /vmkit/trunk:
 Makefile.common.in Makefile.config.in lib/Mvm/JITGCPass/Makefile
 lib/Mvm/StaticGCPass/Makefile lib/Mvm/StaticGCPrinter/Makefile
 mmtk/magic/Makefile
Message-ID: <20111108135952.7AE0E2A6C12C@llvm.org>

Author: gthomas
Date: Tue Nov  8 07:59:52 2011
New Revision: 144082

URL: http://llvm.org/viewvc/llvm-project?rev=144082&view=rev
Log:
can use Makefile.common from a foreign project

Modified:
    vmkit/trunk/Makefile.common.in
    vmkit/trunk/Makefile.config.in
    vmkit/trunk/lib/Mvm/JITGCPass/Makefile
    vmkit/trunk/lib/Mvm/StaticGCPass/Makefile
    vmkit/trunk/lib/Mvm/StaticGCPrinter/Makefile
    vmkit/trunk/mmtk/magic/Makefile

Modified: vmkit/trunk/Makefile.common.in
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile.common.in?rev=144082&r1=144081&r2=144082&view=diff
==============================================================================
--- vmkit/trunk/Makefile.common.in (original)
+++ vmkit/trunk/Makefile.common.in Tue Nov  8 07:59:52 2011
@@ -1,6 +1,3 @@
-# Set the name of the project here
-PROJECT_NAME := @PACKAGE_NAME@
-PROJ_VERSION := @PACKAGE_VERSION@
  
 # Set this variable to the top of the LLVM source tree.
 LLVM_SRC_ROOT = @LLVM_SRC@
@@ -9,15 +6,6 @@
 # (this is *not* the same as OBJ_ROOT as defined in LLVM's Makefile.config).
 LLVM_OBJ_ROOT = @LLVM_OBJ@
 
-# Set the directory root of this project's source files
-PROJ_SRC_ROOT := $(subst //,/, at abs_top_srcdir@)
-
-# Set the root directory of this project's object files
-PROJ_OBJ_ROOT := $(subst //,/, at abs_top_objdir@)
-
-# Set the root directory of this project's install prefix
-PROJ_INSTALL_ROOT := @prefix@
-
 # Define BYTECODE_LIBRARY before including LLVM's Makefile.common to get
 # dependencies right.
 BYTECODE_LIBRARY = 1
@@ -29,7 +17,6 @@
   BUILT_SOURCES = FrametablesSymbols.inc FrametablesExterns.inc
 endif
   
-
 # Include LLVM's Master Makefile.
 include $(LLVM_OBJ_ROOT)/Makefile.common
 
@@ -47,4 +34,4 @@
 
 LIBS += -lz
 
-include $(PROJ_SRC_ROOT)/Makefile.rules
+include $(VMKIT_SRC_ROOT)/Makefile.rules

Modified: vmkit/trunk/Makefile.config.in
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile.config.in?rev=144082&r1=144081&r2=144082&view=diff
==============================================================================
--- vmkit/trunk/Makefile.config.in (original)
+++ vmkit/trunk/Makefile.config.in Tue Nov  8 07:59:52 2011
@@ -1,3 +1,17 @@
+# Set the name of the project here
+PROJECT_NAME := @PACKAGE_NAME@
+PROJ_VERSION := @PACKAGE_VERSION@
+
+# Set the directory root of this project's source files
+PROJ_SRC_ROOT := $(subst //,/, at abs_top_srcdir@)
+VMKIT_SRC_ROOT := $(PROJ_SRC_ROOT)
+
+# Set the root directory of this project's object files
+PROJ_OBJ_ROOT := $(subst //,/, at abs_top_objdir@)
+
+# Set the root directory of this project's install prefix
+PROJ_INSTALL_ROOT := @prefix@
+
 MMTK_PLAN = @MMTK_PLAN@
 MMTK_PLAN_HEADER = @MMTK_PLAN_HEADER@
 WITH_64 = @WITH_64@

Modified: vmkit/trunk/lib/Mvm/JITGCPass/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/JITGCPass/Makefile?rev=144082&r1=144081&r2=144082&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/JITGCPass/Makefile (original)
+++ vmkit/trunk/lib/Mvm/JITGCPass/Makefile Tue Nov  8 07:59:52 2011
@@ -8,6 +8,9 @@
 ##===----------------------------------------------------------------------===##
 
 LEVEL = ../../..
+
+include $(LEVEL)/Makefile.config
+
 LIBRARYNAME = JITGCPass
 LOADABLE_MODULE = 1
 USEDLIBS =

Modified: vmkit/trunk/lib/Mvm/StaticGCPass/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/StaticGCPass/Makefile?rev=144082&r1=144081&r2=144082&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/StaticGCPass/Makefile (original)
+++ vmkit/trunk/lib/Mvm/StaticGCPass/Makefile Tue Nov  8 07:59:52 2011
@@ -8,6 +8,9 @@
 ##===----------------------------------------------------------------------===##
 
 LEVEL = ../../..
+
+include $(LEVEL)/Makefile.config
+
 LIBRARYNAME = StaticGCPass
 LOADABLE_MODULE = 1
 

Modified: vmkit/trunk/lib/Mvm/StaticGCPrinter/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/StaticGCPrinter/Makefile?rev=144082&r1=144081&r2=144082&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/StaticGCPrinter/Makefile (original)
+++ vmkit/trunk/lib/Mvm/StaticGCPrinter/Makefile Tue Nov  8 07:59:52 2011
@@ -8,6 +8,9 @@
 ##===----------------------------------------------------------------------===##
 
 LEVEL = ../../..
+
+include $(LEVEL)/Makefile.config
+
 LIBRARYNAME = StaticGCPrinter
 LOADABLE_MODULE = 1
 

Modified: vmkit/trunk/mmtk/magic/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/magic/Makefile?rev=144082&r1=144081&r2=144082&view=diff
==============================================================================
--- vmkit/trunk/mmtk/magic/Makefile (original)
+++ vmkit/trunk/mmtk/magic/Makefile Tue Nov  8 07:59:52 2011
@@ -8,6 +8,9 @@
 ##===----------------------------------------------------------------------===##
 
 LEVEL = ../..
+
+include $(LEVEL)/Makefile.config
+
 LIBRARYNAME = MMTKMagic
 LOADABLE_MODULE = 1
 




From nicolas.geoffray at gmail.com  Tue Nov  8 07:57:28 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 16:57:28 +0100
Subject: [vmkit-commits] [PATCH] Implement a number of
 Java.sun.misc.Unsafe.* methods.
In-Reply-To: <CAKGWAO8FBBqsnxpx1G4ydX5X79q-yWQA6=8T_Hdfm=JoqYfcFw@mail.gmail.com>
References: <CAKGWAO9sjQOL2vt9-ekS1vR=PdH=_xPZHpw=NejtpfreJDHQxA@mail.gmail.com>
	<CAPYwfiqqzf75hqdND0UULwf-6w-pYShPnmQQvCfvckDZ-En8Zg@mail.gmail.com>
	<CAKGWAO8FBBqsnxpx1G4ydX5X79q-yWQA6=8T_Hdfm=JoqYfcFw@mail.gmail.com>
Message-ID: <CAPYwfioqm+6d8ZNA059-5_k2GXgpFh=VRVf+Popn8+LZ1aJRFA@mail.gmail.com>

Almost good to go :)

On Mon, Nov 7, 2011 at 3:50 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> On Fri, Nov 4, 2011 at 4:06 PM, Nicolas Geoffray
> <nicolas.geoffray at gmail.com> wrote:
> > Thanks Will for the new change. I have a few comments that I'd like you
> to
> > take into account before moving forward.
> [snip]
>
> Thank you for your comments!  Updated patch inlined below :).
>
> ~Will
>
> From 64c05c78614b4036e40dc915926f590b82f60966 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 6/8] 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  |   82 +++++++++++++++
>  lib/J3/Compiler/JavaAOTCompiler.cpp |    5 +-
>  lib/J3/Compiler/Makefile            |    2 +-
>  lib/J3/VMCore/Jnjvm.cpp             |    5 +
>  lib/J3/VMCore/Makefile              |    2 +-
>  lib/J3/VMCore/VirtualTables.cpp     |   11 ++-
>  7 files changed, 296 insertions(+), 6 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..c81e26b 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());
> +  cl->asClass()->resolveClass();
> +  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) {
> +  JavaObject* res = 0;
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(_field, 0);
> +  llvm_gcroot(res, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  JavaField * field = JavaObjectField::getInternalField(_field);
> +  assert(field);
> +  field->classDef->initialiseClass(JavaThread::get()->getJVM());
> +
> +  res = VMStaticInstance::allocate(
> +    (JavaObjectClass*)field->classDef->getDelegatee());
> +
> +  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) {
> +  UNIMPLEMENTED();
> +  return 0;
> +}
> +
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* clazz) {
> +  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()->throwException(obj);
> +}
> +
>  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..f2ca906
> --- /dev/null
> +++ b/lib/J3/ClassLib/VMStaticInstance.h
> @@ -0,0 +1,82 @@
> +//===-------- 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 "ClasspathReflect.h"
> +#include "JavaObject.h"
> +#include "MvmGC.h"
> +
> +namespace j3 {
> +
> +/// VMStaticInstance - Used as a placeholder for a staticInstance,
> tracing to
> +/// the corresponding Class to ensure it doesn't get improperly GC'd.
> +/// This placeholder is used solely in getStaticFieldBase and the various
> +/// put/get methods in sun.misc.Unsafe, any other use is invalid.
> +/// Largely inspired by VMClassLoader.
> +///
> +class VMStaticInstance : public JavaObject {
> +private:
> +
> +  /// OwningClass - The Class this is represents a static instance of.
> +  JavaObjectClass * OwningClass;
>

You should use the Class* instead of the JavaObjectClass. This makes it
less brittle for the GC.

+
> +public:
> +
> +  static VMStaticInstance* allocate(JavaObjectClass * Class) {
> +    VMStaticInstance* res = 0;
> +    llvm_gcroot(res, 0);
> +    llvm_gcroot(Class, 0);
> +    res = (VMStaticInstance*)gc::operator new(sizeof(VMStaticInstance),
> &VT);
> +    res->OwningClass = Class;
> +
> +    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 through to our Class
> +  ///
> +  static void staticTracer(VMStaticInstance* obj, word_t closure) {
> +    llvm_gcroot(obj, 0);
> +    if (obj->OwningClass != NULL) obj->OwningClass->tracer(closure);
>

That's a bug if it's null. Maybe assert that it's not. Also, by replacing
OwningClass to a Class*, you should do
obj->OwningClass->JCL->tracer(closure);

+  }
> +
> +  /// getStaticInstance - Get the static instance contained in this object
> +  ///
> +  void * getStaticInstance() {
>

Just change it to OwningClass->getStaticInstance();


> +    assert(OwningClass);
> +    UserCommonClass * Cl = JavaObjectClass::getClass(OwningClass);
> +    assert(Cl && Cl->isClass());
> +    return Cl->asClass()->getStaticInstance();
> +  }
> +
> +};
> +
> +}
> +
> +#endif // JNJVM_VMSTATICINSTANCE_H
> diff --git a/lib/J3/Compiler/JavaAOTCompiler.cpp
> b/lib/J3/Compiler/JavaAOTCompiler.cpp
> index d16d57c..1a4d2e4 100644
> --- a/lib/J3/Compiler/JavaAOTCompiler.cpp
> +++ b/lib/J3/Compiler/JavaAOTCompiler.cpp
> @@ -32,6 +32,7 @@
>  #include "JavaUpcalls.h"
>  #include "Jnjvm.h"
>  #include "Reader.h"
> +#include "VMStaticInstance.h"
>  #include "Zip.h"
>
>  #include <cstdio>
> @@ -2545,7 +2546,9 @@ CommonClass*
> JavaAOTCompiler::getUniqueBaseClass(CommonClass* cl) {
>
>   for (; I != E; ++I) {
>     JavaObject* obj = (JavaObject*)(*I);
> -    if (!VMClassLoader::isVMClassLoader(obj) &&
> JavaObject::instanceOf(obj, cl)) {
> +    if (!VMClassLoader::isVMClassLoader(obj) &&
> +        !VMStaticInstance::isVMStaticInstance(obj) &&
> +        JavaObject::instanceOf(obj, cl)) {
>       if (currentClass != NULL) {
>         if (JavaObject::getClass(obj) != currentClass) {
>           return 0;
> diff --git a/lib/J3/Compiler/Makefile b/lib/J3/Compiler/Makefile
> index 58bb2e1..99c46db 100644
> --- a/lib/J3/Compiler/Makefile
> +++ b/lib/J3/Compiler/Makefile
> @@ -14,4 +14,4 @@ MODULE_WITH_GC = J3Compiler
>
>  include $(LEVEL)/Makefile.common
>
> -CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime
> -I$(PROJ_SRC_DIR)/../ClassLib/$(CLASSPATH_DIR)
> -I$(PROJ_SRC_DIR)/../VMCore
> +CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime
> -I$(PROJ_SRC_DIR)/../ClassLib/$(CLASSPATH_DIR)
> -I$(PROJ_SRC_DIR)/../ClassLib/ -I$(PROJ_SRC_DIR)/../VMCore
> diff --git a/lib/J3/VMCore/Jnjvm.cpp b/lib/J3/VMCore/Jnjvm.cpp
> index 4961694..5165b88 100644
> --- a/lib/J3/VMCore/Jnjvm.cpp
> +++ b/lib/J3/VMCore/Jnjvm.cpp
> @@ -35,6 +35,7 @@
>  #include "LockedMap.h"
>  #include "Reader.h"
>  #include "ReferenceQueue.h"
> +#include "VMStaticInstance.h"
>  #include "Zip.h"
>
>  using namespace j3;
> @@ -1394,6 +1395,8 @@ size_t Jnjvm::getObjectSize(gc* object) {
>   JavaObject* src = (JavaObject*)object;
>   if (VMClassLoader::isVMClassLoader(src)) {
>     size = sizeof(VMClassLoader);
> +  } else if (VMStaticInstance::isVMStaticInstance(src)) {
> +    size = sizeof(VMStaticInstance);
>   } else {
>     CommonClass* cl = JavaObject::getClass(src);
>     if (cl->isArray()) {
> @@ -1416,6 +1419,8 @@ const char* Jnjvm::getObjectTypeName(gc* object) {
>   JavaObject* src = (JavaObject*)object;
>   if (VMClassLoader::isVMClassLoader(src)) {
>     return "VMClassLoader";
> +  } else if (VMStaticInstance::isVMStaticInstance(src)) {
> +    return "VMStaticInstance";
>   } else {
>     CommonClass* cl = JavaObject::getClass(src);
>     // This code is only used for debugging on a fatal error. It is fine to
> 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
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111108/0804f968/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 08:51:42 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 17:51:42 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_NewInstanceFromConstructor
In-Reply-To: <CAKGWAO-LQ9Wrt+0WpSKMW988bxqJxkBRXAER27p+GwnWC+kcYw@mail.gmail.com>
References: <CAKGWAO_Y4L6oBkUbJC02aJpb9Kd3jGhBpraSJ-nY0rLzcGGr0Q@mail.gmail.com>
	<CAPYwfirGwpuVDY0Hvsd==MA7AVTZtsYdx5ix89BzCvMjCf5KEg@mail.gmail.com>
	<CAKGWAO-LQ9Wrt+0WpSKMW988bxqJxkBRXAER27p+GwnWC+kcYw@mail.gmail.com>
Message-ID: <CAPYwfio74fXMvwmb6uqzki9S1qvcWSmRo=g9wioDzcR43qeSSg@mail.gmail.com>

Looks good, thanks!

On Mon, Nov 7, 2011 at 3:51 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> On Fri, Nov 4, 2011 at 4:23 PM, Nicolas Geoffray
> <nicolas.geoffray at gmail.com> wrote:
> > Looks good! This is again very similar to what is in classpath. I know I
> > said that you should not worry about duplicating code, but after
> reviewing a
> > few of your changes, if you could somehow try to share when you can,
> that'd
> > be great :)
> > But feel free to ignore for now, if that's on your way of making the
> > progress you want.
> > Nicolas
>
> Good call.
>
> Updated patch inlined below.  Much simpler :).
>
> ~Will
>
> From b2e31a674c06cb9dc2a19c42d97053e91590f5b0 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sun, 6 Nov 2011 01:33:34 -0500
> Subject: [PATCH 4/8] Impl JVM_NewInstanceFromConstructor, using existing
>  Classpath code.
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   22 +++++++++++++++++++++-
>  1 files changed, 21 insertions(+), 1 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 4f25fb0..15029ea 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -1464,7 +1464,27 @@ JVM_InvokeMethod(JNIEnv *env, jobject method,
> jobject _obj, jobjectArray args0)
>  */
>  JNIEXPORT jobject JNICALL
>  JVM_NewInstanceFromConstructor(JNIEnv *env, jobject _c, jobjectArray
> args0) {
> -  NYI();
> +  JavaObject * ret = 0;
> +  JavaObjectConstructor * c = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(c, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +
> +  c = *(JavaObjectConstructor**)_c;
> +
> +  ret = proceedConstructor(
> +    c,
> +    args0? *(ArrayObject**)args0 : 0,
> +    JavaObjectConstructor::getClass(c)->getDelegatee(),
> +    0 /* unused */ );
> +
> +  RETURN_FROM_JNI((jobject)th->pushJNIRef(ret));
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /*
> --
> 1.7.5.1
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111108/d2e4c493/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 09:00:14 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 18:00:14 +0100
Subject: [vmkit-commits] [PATCH] Refactor AOT into ClassLib-specific
 components, add support for OpenJDK
In-Reply-To: <CAKGWAO-AfG0GxAV8_eKh8PuF1=L9qncrptsAFAbvA2BXN2H5uw@mail.gmail.com>
References: <CAKGWAO9O1gMuvhksmqg6mqJHWMX4YYPPxPnFVmNBkkd-0P3FTQ@mail.gmail.com>
	<CAPYwfir+6vdWPM+-wvXc2kLgvuffs+6iJEf3apic8OuvJ2AQ1Q@mail.gmail.com>
	<CAKGWAO8KG322NXbf1e=kyfQf1zCOpFt=jyW8QEzfwRaT_fAPTw@mail.gmail.com>
	<CAPYwfioYvGV+mxeOTB4etocsqLaatHm9JVseTrSKtrdpjh5FYw@mail.gmail.com>
	<CAKGWAO-AfG0GxAV8_eKh8PuF1=L9qncrptsAFAbvA2BXN2H5uw@mail.gmail.com>
Message-ID: <CAPYwfipaj4bq9f8gzstasRH+ziio9TF0et+N6WvtzW_L9P_Bmw@mail.gmail.com>

On Mon, Nov 7, 2011 at 3:55 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> On Sun, Nov 6, 2011 at 4:38 AM, Nicolas Geoffray
> <nicolas.geoffray at gmail.com> wrote:
> > On Sun, Nov 6, 2011 at 8:32 AM, Will Dietz <wdietz2 at illinois.edu> wrote:
> >>
> >> On Fri, Nov 4, 2011 at 4:57 PM, Nicolas Geoffray
> >> <nicolas.geoffray at gmail.com> wrote:
> >> > Don't you need to fix java.lang.String also?
> >> >
> >>
> >> Hmm, I'd imagine so-- good call.  Strange this didn't break anything
> >> terribly :).
> >
> > I think they are used for debugging and logging in MMTk, so as long as
> you
> > weren't printing things, you may not use the generated strings at all.
> >>
> >> > There is a problem if we don't add the extra fields in LLVM's struct:
> >> > the
> >> > object will be emitted in the executable, and won't be big enough to
> >> > contain
> >> > the two extra fields.
> >>
> >> Bah, okay.  That sort of thing was why my previous (otherwise hacky)
> >> patch for adding extra fields was useful--LLVMInfo would do the right
> >> thing.
> >
> > Indeed. Sorry about not liking this solution :)
> >
>
> No need to be sorry :).
>
> >>
> >> However, I like your idea below of trying to ditch emitting Class in
> >> AOT entirely, I'll give it a go.
> >
> > Thanks!
> > Nicolas
> >
>
> Gave it a go, and the corresponding patch is inlined below.
>
> However, in order for it to work, it also needs the "Don't emit
> methods for primitive classes' VT" patch, which I'm sending in a
> separate thread.
>
> ~Will
>
> From e8eda306e44c270545fdb31b3ba954cfd016c511 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sun, 6 Nov 2011 20:17:02 -0600
> Subject: [PATCH 7/8] Emit NULL for j.l.Class in AOT.
>
> ---
>  include/j3/JavaAOTCompiler.h        |    1 -
>  lib/J3/Compiler/JavaAOTCompiler.cpp |   64
> +----------------------------------
>  2 files changed, 1 insertions(+), 64 deletions(-)
>
> diff --git a/include/j3/JavaAOTCompiler.h b/include/j3/JavaAOTCompiler.h
> index b278a41..483bffb 100644
> --- a/include/j3/JavaAOTCompiler.h
> +++ b/include/j3/JavaAOTCompiler.h
> @@ -94,7 +94,6 @@ private:
>   llvm::Constant* CreateConstantFromJavaMethod(JavaMethod& method);
>   llvm::Constant* CreateConstantFromStaticInstance(Class* cl);
>   llvm::Constant* CreateConstantFromJavaString(JavaString* str);
> -  llvm::Constant* CreateConstantFromJavaClass(CommonClass* cl);
>   llvm::Constant* CreateConstantForBaseObject(CommonClass* cl);
>   llvm::Constant* CreateConstantFromJavaObject(JavaObject* obj);
>   llvm::Constant* CreateConstantFromClassBytes(ClassBytes* bytes);
> diff --git a/lib/J3/Compiler/JavaAOTCompiler.cpp
> b/lib/J3/Compiler/JavaAOTCompiler.cpp
> index 1a4d2e4..2ae8973 100644
> --- a/lib/J3/Compiler/JavaAOTCompiler.cpp
> +++ b/lib/J3/Compiler/JavaAOTCompiler.cpp
> @@ -295,39 +295,7 @@ Constant* JavaAOTCompiler::getStringPtr(JavaString**
> str) {
>  }
>
>  Constant* JavaAOTCompiler::getJavaClass(CommonClass* cl) {
> -  Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
> -  LLVMClassInfo* LCI = getClassInfo(javaClass);
> -  llvm::Type* Ty = LCI->getVirtualType();
> -
> -  if (useCooperativeGC()) {
> -    return Constant::getNullValue(JavaIntrinsics.JavaObjectType);
> -  } else {
> -    java_class_iterator End = javaClasses.end();
> -    java_class_iterator I = javaClasses.find(cl);
> -    if (I == End) {
> -      final_object_iterator End = finalObjects.end();
> -      final_object_iterator I = finalObjects.find(cl->delegatee[0]);
> -      if (I == End) {
> -
> -        Module& Mod = *getLLVMModule();
> -
> -        GlobalVariable* varGV =
> -          new GlobalVariable(Mod, Ty->getContainedType(0), false,
> -                             GlobalValue::InternalLinkage, 0, "");
> -
> -        Constant* res = ConstantExpr::getCast(Instruction::BitCast, varGV,
> -
>  JavaIntrinsics.JavaObjectType);
> -
> -        javaClasses.insert(std::make_pair(cl, res));
> -        varGV->setInitializer(CreateConstantFromJavaClass(cl));
> -        return res;
> -      } else {
> -        return I->second;
> -      }
> -    } else {
> -      return I->second;
> -    }
> -  }
> +  return Constant::getNullValue(JavaIntrinsics.JavaObjectType);
>

Did you make sure this works with the current setup (mmtk + gnu classpath)?
If you did, then please apply!


>  }
>
>  Constant* JavaAOTCompiler::getJavaClassPtr(CommonClass* cl) {
> @@ -688,36 +656,6 @@ Constant*
> JavaAOTCompiler::CreateConstantForBaseObject(CommonClass* cl) {
>   return ConstantStruct::get(STy, Elmts);
>  }
>
> -Constant* JavaAOTCompiler::CreateConstantFromJavaClass(CommonClass* cl) {
> -  assert(!useCooperativeGC());
> -  Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
> -  LLVMClassInfo* LCI = getClassInfo(javaClass);
> -  StructType* STy =
> -    dyn_cast<StructType>(LCI->getVirtualType()->getContainedType(0));
> -
> -  std::vector<Constant*> Elmts;
> -
> -  // JavaObject
> -  Elmts.push_back(CreateConstantForBaseObject(javaClass));
> -
> -  // signers
> -  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> -
> -  // pd
> -  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> -
> -  // vmdata
> -  Constant* Cl = getNativeClass(cl);
> -  Cl = ConstantExpr::getCast(Instruction::BitCast, Cl,
> -                             JavaIntrinsics.JavaObjectType);
> -  Elmts.push_back(Cl);
> -
> -  // constructor
> -  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
> -
> -  return ConstantStruct::get(STy, Elmts);
> -}
> -
>  Constant* JavaAOTCompiler::CreateConstantFromJavaObject(JavaObject* obj) {
>   assert(!useCooperativeGC());
>   CommonClass* cl = JavaObject::getClass(obj);
> --
> 1.7.5.1
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111108/c9f255be/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 09:03:37 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 18:03:37 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_GetClassContext,
 refactor existing code into shared ClassContext.inc.
In-Reply-To: <CAKGWAO-i=qKJdyeAZPmfC6CYCNheukN4rma6ymxSeEnkq2rH=A@mail.gmail.com>
References: <CAKGWAO-i=qKJdyeAZPmfC6CYCNheukN4rma6ymxSeEnkq2rH=A@mail.gmail.com>
Message-ID: <CAPYwfioV2iNgc+zqSEd7wWqtx6Jvs=NEVaPg-rObtt+vthjzzg@mail.gmail.com>

On Mon, Nov 7, 2011 at 3:58 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> ~Will
>
> >From 4c7de028f511bf52c3601ce57beb02ffcb939420 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sat, 5 Nov 2011 20:47:15 -0500
> Subject: [PATCH 2/8] Impl JVM_GetClassContext, refactor existing code into
>  shared ClassContext.inc.
>
> Also, fix ClassContext creation of wrong array type.
> ---
>  lib/J3/ClassLib/ClassContext.inc                   |   36
> ++++++++++++++++++++
>  .../GNUClasspath/ClasspathVMStackWalker.inc        |   25 ++-----------
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc                |   12 ++++++-
>  3 files changed, 51 insertions(+), 22 deletions(-)
>  create mode 100644 lib/J3/ClassLib/ClassContext.inc
>
> diff --git a/lib/J3/ClassLib/ClassContext.inc
> b/lib/J3/ClassLib/ClassContext.inc
> new file mode 100644
> index 0000000..71c17d7
> --- /dev/null
> +++ b/lib/J3/ClassLib/ClassContext.inc
> @@ -0,0 +1,36 @@
> +//===------------ ClassContext.inc -- Implement GetClassContext
> -----------===//
> +//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +ArrayObject* GetClassContext() {
> +  ArrayObject* result = NULL;
> +  JavaObject* delegatee = NULL;
> +  llvm_gcroot(result, 0);
> +  llvm_gcroot(delegatee, 0);
> +
> +  JavaThread* th = JavaThread::get();
> +  Jnjvm* vm = th->getJVM();
> +  uint32 length = th->getFrameContextLength();
> +
> +  mvm::ThreadAllocator allocator;
> +  uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *
> sizeof(uintptr_t));
> +
> +  uint32 finalSize = th->getJavaFrameContext((void**)buffer);
> +
> +  result = (ArrayObject*)
> +    vm->upcalls->classArrayClass->doNew(finalSize, vm);
> +
> +  for (uint32 i = 0; i != finalSize; ++i) {
> +    JavaMethod* meth = ((JavaMethod**)buffer)[i];
> +    assert(meth && "Wrong stack trace");
> +    delegatee = meth->classDef->getClassDelegatee(vm);;
> +    ArrayObject::setElement(result, delegatee, i);
> +  }
> +
> +  return result;
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> index b0c94e5..c51a246 100644
> --- a/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> @@ -19,6 +19,8 @@
>  #include "JavaUpcalls.h"
>  #include "Jnjvm.h"
>
> +#include "ClassContext.inc"
> +
>  using namespace j3;
>
>  extern "C" {
> @@ -31,31 +33,12 @@ jclass clazz,
>  ) {
>
>   ArrayObject* result = NULL;
> -  JavaObject* delegatee = NULL;
>   llvm_gcroot(result, 0);
> -  llvm_gcroot(delegatee, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  JavaThread* th = JavaThread::get();
> -  Jnjvm* vm = th->getJVM();
> -  uint32 length = th->getFrameContextLength();
> -
> -  mvm::ThreadAllocator allocator;
> -  uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *
> sizeof(uintptr_t));
> -
> -  uint32 finalSize = th->getJavaFrameContext((void**)buffer);
> -
> -  result = (ArrayObject*)
> -    vm->upcalls->stackTraceArray->doNew(finalSize, vm);
>

Wow, just realized I'm the one to blame for that stackTrace array bug :)
Thanks Will for fixing it. Please apply!


> -
> -  for (uint32 i = 0; i != finalSize; ++i) {
> -    JavaMethod* meth = ((JavaMethod**)buffer)[i];
> -    assert(meth && "Wrong stack trace");
> -    delegatee = meth->classDef->getClassDelegatee(vm);;
> -    ArrayObject::setElement(result, delegatee, i);
> -  }
> -
> +  result = GetClassContext();
> +
>   END_NATIVE_EXCEPTION
>
>   return result;
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 947b7d3..012b021 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -12,6 +12,7 @@
>  #include "Reader.h"
>
>  #include "ArrayCopy.inc"
> +#include "ClassContext.inc"
>  #include "SetProperties.inc"
>  #include "Object.inc"
>
> @@ -672,7 +673,16 @@ JVM_CurrentClassLoader(JNIEnv *env) {
>
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassContext(JNIEnv *env) {
> -  NYI();
> +  ArrayObject * res = 0;
> +  llvm_gcroot(res, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  res = GetClassContext();
> +
> +  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(res));
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jint JNICALL
> --
> 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/20111108/078c54c6/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 09:02:36 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 18:02:36 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_GetClassContext,
 refactor existing code into shared ClassContext.inc.
In-Reply-To: <CAKGWAO-i=qKJdyeAZPmfC6CYCNheukN4rma6ymxSeEnkq2rH=A@mail.gmail.com>
References: <CAKGWAO-i=qKJdyeAZPmfC6CYCNheukN4rma6ymxSeEnkq2rH=A@mail.gmail.com>
Message-ID: <CAPYwfiq_c1A844+ZbY=1v7NKwu_d0_jF4_4-c80KQhKmSQqOZg@mail.gmail.com>

On Mon, Nov 7, 2011 at 3:58 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> ~Will
>
> >From 4c7de028f511bf52c3601ce57beb02ffcb939420 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sat, 5 Nov 2011 20:47:15 -0500
> Subject: [PATCH 2/8] Impl JVM_GetClassContext, refactor existing code into
>  shared ClassContext.inc.
>
> Also, fix ClassContext creation of wrong array type.
> ---
>  lib/J3/ClassLib/ClassContext.inc                   |   36
> ++++++++++++++++++++
>  .../GNUClasspath/ClasspathVMStackWalker.inc        |   25 ++-----------
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc                |   12 ++++++-
>  3 files changed, 51 insertions(+), 22 deletions(-)
>  create mode 100644 lib/J3/ClassLib/ClassContext.inc
>
> diff --git a/lib/J3/ClassLib/ClassContext.inc
> b/lib/J3/ClassLib/ClassContext.inc
> new file mode 100644
> index 0000000..71c17d7
> --- /dev/null
> +++ b/lib/J3/ClassLib/ClassContext.inc
> @@ -0,0 +1,36 @@
> +//===------------ ClassContext.inc -- Implement GetClassContext
> -----------===//
> +//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +ArrayObject* GetClassContext() {
> +  ArrayObject* result = NULL;
> +  JavaObject* delegatee = NULL;
> +  llvm_gcroot(result, 0);
> +  llvm_gcroot(delegatee, 0);
> +
> +  JavaThread* th = JavaThread::get();
> +  Jnjvm* vm = th->getJVM();
> +  uint32 length = th->getFrameContextLength();
> +
> +  mvm::ThreadAllocator allocator;
> +  uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *
> sizeof(uintptr_t));
> +
> +  uint32 finalSize = th->getJavaFrameContext((void**)buffer);
> +
> +  result = (ArrayObject*)
> +    vm->upcalls->classArrayClass->doNew(finalSize, vm);
> +
> +  for (uint32 i = 0; i != finalSize; ++i) {
> +    JavaMethod* meth = ((JavaMethod**)buffer)[i];
> +    assert(meth && "Wrong stack trace");
> +    delegatee = meth->classDef->getClassDelegatee(vm);;
> +    ArrayObject::setElement(result, delegatee, i);
> +  }
> +
> +  return result;
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> index b0c94e5..c51a246 100644
> --- a/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> @@ -19,6 +19,8 @@
>  #include "JavaUpcalls.h"
>  #include "Jnjvm.h"
>
> +#include "ClassContext.inc"
> +
>  using namespace j3;
>
>  extern "C" {
> @@ -31,31 +33,12 @@ jclass clazz,
>  ) {
>
>   ArrayObject* result = NULL;
> -  JavaObject* delegatee = NULL;
>   llvm_gcroot(result, 0);
> -  llvm_gcroot(delegatee, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  JavaThread* th = JavaThread::get();
> -  Jnjvm* vm = th->getJVM();
> -  uint32 length = th->getFrameContextLength();
> -
> -  mvm::ThreadAllocator allocator;
> -  uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *
> sizeof(uintptr_t));
> -
> -  uint32 finalSize = th->getJavaFrameContext((void**)buffer);
> -
> -  result = (ArrayObject*)
> -    vm->upcalls->stackTraceArray->doNew(finalSize, vm);
>

Wow, just realized I'm the one to blame for that stackTrace array bug :)
Thanks Will for fixing it. Please apply!


> -
> -  for (uint32 i = 0; i != finalSize; ++i) {
> -    JavaMethod* meth = ((JavaMethod**)buffer)[i];
> -    assert(meth && "Wrong stack trace");
> -    delegatee = meth->classDef->getClassDelegatee(vm);;
> -    ArrayObject::setElement(result, delegatee, i);
> -  }
> -
> +  result = GetClassContext();
> +
>   END_NATIVE_EXCEPTION
>
>   return result;
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 947b7d3..012b021 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -12,6 +12,7 @@
>  #include "Reader.h"
>
>  #include "ArrayCopy.inc"
> +#include "ClassContext.inc"
>  #include "SetProperties.inc"
>  #include "Object.inc"
>
> @@ -672,7 +673,16 @@ JVM_CurrentClassLoader(JNIEnv *env) {
>
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassContext(JNIEnv *env) {
> -  NYI();
> +  ArrayObject * res = 0;
> +  llvm_gcroot(res, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  res = GetClassContext();
> +
> +  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(res));
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jint JNICALL
> --
> 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/20111108/03075593/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 09:02:36 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 18:02:36 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_GetClassContext,
 refactor existing code into shared ClassContext.inc.
In-Reply-To: <CAKGWAO-i=qKJdyeAZPmfC6CYCNheukN4rma6ymxSeEnkq2rH=A@mail.gmail.com>
References: <CAKGWAO-i=qKJdyeAZPmfC6CYCNheukN4rma6ymxSeEnkq2rH=A@mail.gmail.com>
Message-ID: <CAPYwfiq_c1A844+ZbY=1v7NKwu_d0_jF4_4-c80KQhKmSQqOZg@mail.gmail.com>

On Mon, Nov 7, 2011 at 3:58 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> ~Will
>
> >From 4c7de028f511bf52c3601ce57beb02ffcb939420 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sat, 5 Nov 2011 20:47:15 -0500
> Subject: [PATCH 2/8] Impl JVM_GetClassContext, refactor existing code into
>  shared ClassContext.inc.
>
> Also, fix ClassContext creation of wrong array type.
> ---
>  lib/J3/ClassLib/ClassContext.inc                   |   36
> ++++++++++++++++++++
>  .../GNUClasspath/ClasspathVMStackWalker.inc        |   25 ++-----------
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc                |   12 ++++++-
>  3 files changed, 51 insertions(+), 22 deletions(-)
>  create mode 100644 lib/J3/ClassLib/ClassContext.inc
>
> diff --git a/lib/J3/ClassLib/ClassContext.inc
> b/lib/J3/ClassLib/ClassContext.inc
> new file mode 100644
> index 0000000..71c17d7
> --- /dev/null
> +++ b/lib/J3/ClassLib/ClassContext.inc
> @@ -0,0 +1,36 @@
> +//===------------ ClassContext.inc -- Implement GetClassContext
> -----------===//
> +//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +ArrayObject* GetClassContext() {
> +  ArrayObject* result = NULL;
> +  JavaObject* delegatee = NULL;
> +  llvm_gcroot(result, 0);
> +  llvm_gcroot(delegatee, 0);
> +
> +  JavaThread* th = JavaThread::get();
> +  Jnjvm* vm = th->getJVM();
> +  uint32 length = th->getFrameContextLength();
> +
> +  mvm::ThreadAllocator allocator;
> +  uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *
> sizeof(uintptr_t));
> +
> +  uint32 finalSize = th->getJavaFrameContext((void**)buffer);
> +
> +  result = (ArrayObject*)
> +    vm->upcalls->classArrayClass->doNew(finalSize, vm);
> +
> +  for (uint32 i = 0; i != finalSize; ++i) {
> +    JavaMethod* meth = ((JavaMethod**)buffer)[i];
> +    assert(meth && "Wrong stack trace");
> +    delegatee = meth->classDef->getClassDelegatee(vm);;
> +    ArrayObject::setElement(result, delegatee, i);
> +  }
> +
> +  return result;
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> index b0c94e5..c51a246 100644
> --- a/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> @@ -19,6 +19,8 @@
>  #include "JavaUpcalls.h"
>  #include "Jnjvm.h"
>
> +#include "ClassContext.inc"
> +
>  using namespace j3;
>
>  extern "C" {
> @@ -31,31 +33,12 @@ jclass clazz,
>  ) {
>
>   ArrayObject* result = NULL;
> -  JavaObject* delegatee = NULL;
>   llvm_gcroot(result, 0);
> -  llvm_gcroot(delegatee, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  JavaThread* th = JavaThread::get();
> -  Jnjvm* vm = th->getJVM();
> -  uint32 length = th->getFrameContextLength();
> -
> -  mvm::ThreadAllocator allocator;
> -  uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *
> sizeof(uintptr_t));
> -
> -  uint32 finalSize = th->getJavaFrameContext((void**)buffer);
> -
> -  result = (ArrayObject*)
> -    vm->upcalls->stackTraceArray->doNew(finalSize, vm);
>

Wow, just realized I'm the one to blame for that stackTrace array bug :)
Thanks Will for fixing it. Please apply!


> -
> -  for (uint32 i = 0; i != finalSize; ++i) {
> -    JavaMethod* meth = ((JavaMethod**)buffer)[i];
> -    assert(meth && "Wrong stack trace");
> -    delegatee = meth->classDef->getClassDelegatee(vm);;
> -    ArrayObject::setElement(result, delegatee, i);
> -  }
> -
> +  result = GetClassContext();
> +
>   END_NATIVE_EXCEPTION
>
>   return result;
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 947b7d3..012b021 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -12,6 +12,7 @@
>  #include "Reader.h"
>
>  #include "ArrayCopy.inc"
> +#include "ClassContext.inc"
>  #include "SetProperties.inc"
>  #include "Object.inc"
>
> @@ -672,7 +673,16 @@ JVM_CurrentClassLoader(JNIEnv *env) {
>
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassContext(JNIEnv *env) {
> -  NYI();
> +  ArrayObject * res = 0;
> +  llvm_gcroot(res, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  res = GetClassContext();
> +
> +  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(res));
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jint JNICALL
> --
> 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/20111108/03075593/attachment-0001.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 09:34:43 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 18:34:43 +0100
Subject: [vmkit-commits] [PATCH] Refactor JavaObject-related ClassLib
	code.
In-Reply-To: <CAKGWAO-F8iB94gcZfSzD1RkrwaCaURfWaO2TiSqihXm016qzRA@mail.gmail.com>
References: <CAKGWAO-F8iB94gcZfSzD1RkrwaCaURfWaO2TiSqihXm016qzRA@mail.gmail.com>
Message-ID: <CAPYwfirid25hC1gNyg_7VqT=eFbonFjhJ6Vn5FaF_k5PMAQZQg@mail.gmail.com>

Few comments. Please apply when you've addressed them.

On Mon, Nov 7, 2011 at 3:57 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> ~Will
>
> >From b27df42e89b104ec6d98f0d35fee5ddf1c8c64aa Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sat, 5 Nov 2011 20:24:31 -0500
> Subject: [PATCH 1/8] Refactor JavaObject-related ClassLib code.
>
> ---
>  lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc |   68
> +------------------
>  lib/J3/ClassLib/Object.inc                         |   31 +++++++++
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc                |   46 ++++++-------
>  lib/J3/VMCore/JavaObject.cpp                       |   66
> +++++++++++++++++++
>  lib/J3/VMCore/JavaObject.h                         |    4 +
>  5 files changed, 127 insertions(+), 88 deletions(-)
>  create mode 100644 lib/J3/ClassLib/Object.inc
>
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
> index ab3f0c5..1c981d4 100644
> --- a/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
> @@ -10,11 +10,8 @@
>  #include "types.h"
>
>  #include "Classpath.h"
> -#include "JavaArray.h"
> -#include "JavaClass.h"
> -#include "JavaObject.h"
> -#include "JavaThread.h"
>  #include "Jnjvm.h"
> +#include "Object.inc"
>
>  using namespace j3;
>
> @@ -28,59 +25,12 @@ jclass clazz,
>  JavaObject* src) {
>
>   JavaObject* res = NULL;
> -  JavaObject* tmp = NULL;
>   llvm_gcroot(res, 0);
>   llvm_gcroot(src, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  UserCommonClass* cl = JavaObject::getClass(src);
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  if (cl->isArray()) {
> -    UserClassArray* array = cl->asArrayClass();
> -    int length = JavaArray::getSize(src);
> -    res = array->doNew(length, vm);
> -    UserCommonClass* base = array->baseClass();
> -    if (base->isPrimitive()) {
> -      int size = length << base->asPrimitiveClass()->logSize;
> -      memcpy((void*)((uintptr_t)res + sizeof(JavaObject) +
> sizeof(size_t)),
> -             (void*)((uintptr_t)src + sizeof(JavaObject) +
> sizeof(size_t)),
> -             size);
> -    } else {
> -      for (int i = 0; i < length; i++) {
> -        tmp = ArrayObject::getElement((ArrayObject*)src, i);
> -        ArrayObject::setElement((ArrayObject*)res, tmp, i);
> -      }
> -    }
> -  } else {
> -    assert(cl->isClass() && "Not a class!");
> -    res = cl->asClass()->doNew(vm);
> -    while (cl != NULL) {
> -      for (uint32 i = 0; i < cl->asClass()->nbVirtualFields; ++i) {
> -        JavaField& field = cl->asClass()->virtualFields[i];
> -        if (field.isReference()) {
> -          tmp = field.getInstanceObjectField(src);
> -          JavaObject** ptr = field.getInstanceObjectFieldPtr(res);
> -          mvm::Collector::objectReferenceWriteBarrier((gc*)res,
> (gc**)ptr, (gc*)tmp);
> -        } else if (field.isLong()) {
> -          field.setInstanceLongField(res,
> field.getInstanceLongField(src));
> -        } else if (field.isDouble()) {
> -          field.setInstanceDoubleField(res,
> field.getInstanceDoubleField(src));
> -        } else if (field.isInt()) {
> -          field.setInstanceInt32Field(res,
> field.getInstanceInt32Field(src));
> -        } else if (field.isFloat()) {
> -          field.setInstanceFloatField(res,
> field.getInstanceFloatField(src));
> -        } else if (field.isShort() || field.isChar()) {
> -          field.setInstanceInt16Field(res,
> field.getInstanceInt16Field(src));
> -        } else if (field.isByte() || field.isBoolean()) {
> -          field.setInstanceInt8Field(res,
> field.getInstanceInt8Field(src));
> -        } else {
> -          UNREACHABLE();
> -        }
> -      }
> -      cl = cl->super;
> -    }
> -  }
> +  res = JavaObject::clone(src);
>
>   END_NATIVE_EXCEPTION
>
> @@ -130,23 +80,13 @@ JNIEXPORT void JNICALL Java_java_lang_VMObject_wait(
>  JNIEnv *env,
>  jclass clazz,
>  #endif
> -JavaObject* obj, jlong ms, jint ns) {
> +JavaObject* obj, long long ms, int ns) {
>

Please use int64_t instead of long long.


>
>   llvm_gcroot(obj, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  uint32 sec = (uint32) (ms / 1000);
> -  uint32 usec = (ns / 1000) + 1000 * (ms % 1000);
> -  if (ns && !usec) usec = 1;
> -  if (sec || usec) {
> -    struct timeval t;
> -    t.tv_sec = sec;
> -    t.tv_usec = usec;
> -    JavaObject::timedWait(obj, t);
> -  } else {
> -    JavaObject::wait(obj);
> -  }
> +  Object_wait(obj, ms, ns);
>
>   END_NATIVE_EXCEPTION
>  }
> diff --git a/lib/J3/ClassLib/Object.inc b/lib/J3/ClassLib/Object.inc
> new file mode 100644
> index 0000000..aa6f92b
> --- /dev/null
> +++ b/lib/J3/ClassLib/Object.inc
> @@ -0,0 +1,31 @@
> +//===---------- Object.inc - Shared j.l.Object code
> -----------------------===//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +#include "JavaObject.h"
> +
> +void Object_wait(JavaObject* obj, jlong ms, jint ns) {
>

Could that just go in JavaObject.h/JavaObject.cpp?


> +  llvm_gcroot(obj, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +
> +  if (ms < 0 || ns < 0) {
> +    vm->illegalArgumentException("Negative wait time specified");
> +  }
> +
> +  uint32 sec = (uint32) (ms / 1000);
> +  uint32 usec = (ns / 1000) + 1000 * (ms % 1000);
> +  if (ns && !usec) usec = 1;
> +  if (sec || usec) {
> +    struct timeval t;
> +    t.tv_sec = sec;
> +    t.tv_usec = usec;
> +    JavaObject::timedWait(obj, t);
> +  } else {
> +    JavaObject::wait(obj);
> +  }
> +}
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 9d92f91..947b7d3 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -8,10 +8,12 @@
>
>  #include "jvm.h"
>
> -#include "ArrayCopy.inc"
>  #include "JavaConstantPool.h"
>  #include "Reader.h"
> +
> +#include "ArrayCopy.inc"
>  #include "SetProperties.inc"
> +#include "Object.inc"
>
>  #include <errno.h>
>  #include <fcntl.h>
> @@ -115,51 +117,47 @@ JVM_IHashCode(JNIEnv *env, jobject _obj) {
>
>  JNIEXPORT void JNICALL
>  JVM_MonitorWait(JNIEnv *env, jobject obj, jlong ms) {
> -  JavaObject * o = 0;
> -  llvm_gcroot(o, 0);
> -
>   BEGIN_JNI_EXCEPTION
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -
> -  o = *(JavaObject**)obj;
>
> -  if (ms < 0) {
> -    vm->illegalArgumentException("Negative wait time specified");
> -  }
> -  if (ms) {
> -    struct timeval info;
> -    uint64_t usec = ms * 1000LL;
> -    info.tv_usec = usec % 1000000LL;
> -    info.tv_sec = usec / 1000000LL;
> -    JavaObject::timedWait(o, info);
> -  } else {
> -    JavaObject::wait(o);
> -  }
> +  Object_wait(*(JavaObject**)obj, ms, 0);
>   RETURN_VOID_FROM_JNI
> +
>   END_JNI_EXCEPTION
>  }
>
>  JNIEXPORT void JNICALL
>  JVM_MonitorNotify(JNIEnv *env, jobject obj) {
>   BEGIN_JNI_EXCEPTION
> -  JavaObject * o = *(JavaObject**)obj;
> -  JavaObject::notify(o);
> +
> +  JavaObject::notify(*(JavaObject**)obj);
> +
>   RETURN_VOID_FROM_JNI
> +
>   END_JNI_EXCEPTION
>  }
>
>  JNIEXPORT void JNICALL
>  JVM_MonitorNotifyAll(JNIEnv *env, jobject obj) {
>   BEGIN_JNI_EXCEPTION
> -  JavaObject * o = *(JavaObject**)obj;
> -  JavaObject::notifyAll(o);
> +
> +  JavaObject::notifyAll(*(JavaObject**)obj);
>   RETURN_VOID_FROM_JNI
> +
>   END_JNI_EXCEPTION
>  }
>
>  JNIEXPORT jobject JNICALL
>  JVM_Clone(JNIEnv *env, jobject obj) {
> -  NYI();
> +  JavaObject * clone = 0;
> +  llvm_gcroot(clone, 0);
> +  BEGIN_JNI_EXCEPTION
> +
> +  clone = JavaObject::clone(*(JavaObject**)obj);
> +  RETURN_FROM_JNI((jobject)th->pushJNIRef(clone));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /*
> diff --git a/lib/J3/VMCore/JavaObject.cpp b/lib/J3/VMCore/JavaObject.cpp
> index 55305af..d5e989f 100644
> --- a/lib/J3/VMCore/JavaObject.cpp
> +++ b/lib/J3/VMCore/JavaObject.cpp
> @@ -9,6 +9,7 @@
>
>  #include "mvm/Threads/Locks.h"
>
> +#include "JavaArray.h"
>  #include "JavaClass.h"
>  #include "JavaObject.h"
>  #include "JavaThread.h"
> @@ -118,6 +119,71 @@ void JavaObject::notifyAll(JavaObject* self) {
>   thread->lockingThread.notifyAll(self, table);
>  }
>
> +JavaObject* JavaObject::clone(JavaObject* src) {
> +  JavaObject* res = 0;
> +  JavaObject* tmp = 0;
> +
> +  llvm_gcroot(src, 0);
> +  llvm_gcroot(res, 0);
> +  llvm_gcroot(tmp, 0);
> +
> +  UserCommonClass* cl = JavaObject::getClass(src);
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +
> +  // If this doesn't inherit the Cloneable interface, throw exception
> +  // TODO: Add support in both VM's


VM's -> Class libraries


> for the upcalls fields used here
> +  //if (!JavaObject::instanceOf(src, vm->upcalls->cloneableClass))
> +  //  vm->cloneNotSupportedException();
> +
> +  if (cl->isArray()) {
> +    UserClassArray* array = cl->asArrayClass();
> +    int length = JavaArray::getSize(src);
> +    res = array->doNew(length, vm);
> +    UserCommonClass* base = array->baseClass();
> +    if (base->isPrimitive()) {
> +      int size = length << base->asPrimitiveClass()->logSize;
> +      memcpy((void*)((uintptr_t)res + sizeof(JavaObject) +
> sizeof(size_t)),
> +             (void*)((uintptr_t)src + sizeof(JavaObject) +
> sizeof(size_t)),
> +             size);
> +    } else {
> +      for (int i = 0; i < length; i++) {
> +        tmp = ArrayObject::getElement((ArrayObject*)src, i);
> +        ArrayObject::setElement((ArrayObject*)res, tmp, i);
> +      }
> +    }
> +  } else {
> +    assert(cl->isClass() && "Not a class!");
> +    res = cl->asClass()->doNew(vm);
> +    while (cl != NULL) {
> +      for (uint32 i = 0; i < cl->asClass()->nbVirtualFields; ++i) {
> +        JavaField& field = cl->asClass()->virtualFields[i];
> +        if (field.isReference()) {
> +          tmp = field.getInstanceObjectField(src);
> +          JavaObject** ptr = field.getInstanceObjectFieldPtr(res);
> +          mvm::Collector::objectReferenceWriteBarrier((gc*)res,
> (gc**)ptr, (gc*)tmp);
> +        } else if (field.isLong()) {
> +          field.setInstanceLongField(res,
> field.getInstanceLongField(src));
> +        } else if (field.isDouble()) {
> +          field.setInstanceDoubleField(res,
> field.getInstanceDoubleField(src));
> +        } else if (field.isInt()) {
> +          field.setInstanceInt32Field(res,
> field.getInstanceInt32Field(src));
> +        } else if (field.isFloat()) {
> +          field.setInstanceFloatField(res,
> field.getInstanceFloatField(src));
> +        } else if (field.isShort() || field.isChar()) {
> +          field.setInstanceInt16Field(res,
> field.getInstanceInt16Field(src));
> +        } else if (field.isByte() || field.isBoolean()) {
> +          field.setInstanceInt8Field(res,
> field.getInstanceInt8Field(src));
> +        } else {
> +          UNREACHABLE();
> +        }
> +      }
> +      cl = cl->super;
> +    }
> +  }
> +
> +  return res;
> +}
> +
>  void JavaObject::overflowThinLock(JavaObject* self) {
>   llvm_gcroot(self, 0);
>   mvm::ThinLock::overflowThinLock(self,
> JavaThread::get()->getJVM()->lockSystem);
> diff --git a/lib/J3/VMCore/JavaObject.h b/lib/J3/VMCore/JavaObject.h
> index 83995e3..7c385af 100644
> --- a/lib/J3/VMCore/JavaObject.h
> +++ b/lib/J3/VMCore/JavaObject.h
> @@ -266,6 +266,10 @@ public:
>   /// the monitor.
>   ///
>   static void notifyAll(JavaObject* self);
> +
> +  /// clone - Java clone. Creates a copy of this object.
> +  ///
> +  static JavaObject* clone(JavaObject* other);
>
>   /// overflowThinLock - Notify that the thin lock has overflowed.
>   ///
> --
> 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/20111108/f930dc85/attachment.html>

From wdietz2 at illinois.edu  Tue Nov  8 09:33:57 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 08 Nov 2011 17:33:57 -0000
Subject: [vmkit-commits] [vmkit] r144090 - in /vmkit/trunk/lib/J3/ClassLib:
 ClassContext.inc GNUClasspath/ClasspathVMStackWalker.inc
 OpenJDK/OpenJDK.inc
Message-ID: <20111108173357.15DC32A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  8 11:33:56 2011
New Revision: 144090

URL: http://llvm.org/viewvc/llvm-project?rev=144090&view=rev
Log:
Impl JVM_GetClassContext, refactor existing code into shared ClassContext.inc.

Also, fix ClassContext creation of wrong array type.

Added:
    vmkit/trunk/lib/J3/ClassLib/ClassContext.inc
Modified:
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Added: vmkit/trunk/lib/J3/ClassLib/ClassContext.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/ClassContext.inc?rev=144090&view=auto
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/ClassContext.inc (added)
+++ vmkit/trunk/lib/J3/ClassLib/ClassContext.inc Tue Nov  8 11:33:56 2011
@@ -0,0 +1,36 @@
+//===------------ ClassContext.inc -- Implement GetClassContext -----------===//
+//
+//                            The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+ArrayObject* GetClassContext() {
+  ArrayObject* result = NULL;
+  JavaObject* delegatee = NULL;
+  llvm_gcroot(result, 0);
+  llvm_gcroot(delegatee, 0);
+
+  JavaThread* th = JavaThread::get();
+  Jnjvm* vm = th->getJVM();
+  uint32 length = th->getFrameContextLength();
+
+  mvm::ThreadAllocator allocator;
+  uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length * sizeof(uintptr_t));
+
+  uint32 finalSize = th->getJavaFrameContext((void**)buffer);
+
+  result = (ArrayObject*)
+    vm->upcalls->classArrayClass->doNew(finalSize, vm);
+
+  for (uint32 i = 0; i != finalSize; ++i) {
+    JavaMethod* meth = ((JavaMethod**)buffer)[i];
+    assert(meth && "Wrong stack trace");
+    delegatee = meth->classDef->getClassDelegatee(vm);;
+    ArrayObject::setElement(result, delegatee, i);
+  }
+
+  return result;
+}

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc?rev=144090&r1=144089&r2=144090&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc Tue Nov  8 11:33:56 2011
@@ -19,6 +19,8 @@
 #include "JavaUpcalls.h"
 #include "Jnjvm.h"
 
+#include "ClassContext.inc"
+
 using namespace j3;
 
 extern "C" {
@@ -31,31 +33,12 @@
 ) {
 
   ArrayObject* result = NULL;
-  JavaObject* delegatee = NULL;
   llvm_gcroot(result, 0);
-  llvm_gcroot(delegatee, 0);
 
   BEGIN_NATIVE_EXCEPTION(0)
 
-  JavaThread* th = JavaThread::get();
-  Jnjvm* vm = th->getJVM();
-  uint32 length = th->getFrameContextLength();
-  
-  mvm::ThreadAllocator allocator;  
-  uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length * sizeof(uintptr_t));
-  
-  uint32 finalSize = th->getJavaFrameContext((void**)buffer);
-  
-  result = (ArrayObject*)
-    vm->upcalls->stackTraceArray->doNew(finalSize, vm);
-   
-  for (uint32 i = 0; i != finalSize; ++i) {
-    JavaMethod* meth = ((JavaMethod**)buffer)[i];
-    assert(meth && "Wrong stack trace");
-    delegatee = meth->classDef->getClassDelegatee(vm);;
-    ArrayObject::setElement(result, delegatee, i);
-  }
-  
+  result = GetClassContext();
+
   END_NATIVE_EXCEPTION
   
   return result;

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144090&r1=144089&r2=144090&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov  8 11:33:56 2011
@@ -8,9 +8,11 @@
 
 #include "jvm.h"
 
-#include "ArrayCopy.inc"
 #include "JavaConstantPool.h"
 #include "Reader.h"
+
+#include "ArrayCopy.inc"
+#include "ClassContext.inc"
 #include "SetProperties.inc"
 
 #include <errno.h>
@@ -734,7 +736,16 @@
 
 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassContext(JNIEnv *env) {
-  NYI();
+  ArrayObject * res = 0;
+  llvm_gcroot(res, 0);
+  BEGIN_JNI_EXCEPTION
+
+  res = GetClassContext();
+
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(res));
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jint JNICALL




From wdietz2 at illinois.edu  Tue Nov  8 09:33:58 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 08 Nov 2011 17:33:58 -0000
Subject: [vmkit-commits] [vmkit] r144091 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111108173358.C77812A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  8 11:33:58 2011
New Revision: 144091

URL: http://llvm.org/viewvc/llvm-project?rev=144091&view=rev
Log:
Impl JVM_NewInstanceFromConstructor, using existing Classpath code.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144091&r1=144090&r2=144091&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov  8 11:33:58 2011
@@ -1566,7 +1566,27 @@
  */
 JNIEXPORT jobject JNICALL
 JVM_NewInstanceFromConstructor(JNIEnv *env, jobject _c, jobjectArray args0) {
-  NYI();
+  JavaObject * ret = 0;
+  JavaObjectConstructor * c = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(c, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+
+  c = *(JavaObjectConstructor**)_c;
+
+  ret = proceedConstructor(
+    c,
+    args0? *(ArrayObject**)args0 : 0,
+    JavaObjectConstructor::getClass(c)->getDelegatee(),
+    0 /* unused */ );
+
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(ret));
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /*




From wdietz2 at illinois.edu  Tue Nov  8 09:34:00 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 08 Nov 2011 17:34:00 -0000
Subject: [vmkit-commits] [vmkit] r144092 -
	/vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
Message-ID: <20111108173400.656ED2A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  8 11:34:00 2011
New Revision: 144092

URL: http://llvm.org/viewvc/llvm-project?rev=144092&view=rev
Log:
Fix missing semicolon.

Modified:
    vmkit/trunk/lib/Mvm/Compiler/JIT.cpp

Modified: vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/JIT.cpp?rev=144092&r1=144091&r2=144092&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/JIT.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/JIT.cpp Tue Nov  8 11:34:00 2011
@@ -61,7 +61,7 @@
 
 const char* MvmModule::getHostTriple() {
 #ifdef LLVM_HOSTTRIPLE
-  return LLVM_HOSTTRIPLE
+  return LLVM_HOSTTRIPLE;
 #else
   return LLVM_DEFAULT_TARGET_TRIPLE;
 #endif




From wdietz2 at illinois.edu  Tue Nov  8 10:02:58 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 08 Nov 2011 18:02:58 -0000
Subject: [vmkit-commits] [vmkit] r144093 - in /vmkit/trunk/lib/J3:
 ClassLib/GNUClasspath/ClasspathVMObject.inc ClassLib/OpenJDK/OpenJDK.inc
 VMCore/JavaObject.cpp VMCore/JavaObject.h
Message-ID: <20111108180259.116D42A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  8 12:02:58 2011
New Revision: 144093

URL: http://llvm.org/viewvc/llvm-project?rev=144093&view=rev
Log:
Refactor JavaObject-related ClassLib code.

Modified:
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
    vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
    vmkit/trunk/lib/J3/VMCore/JavaObject.h

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc?rev=144093&r1=144092&r2=144093&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc Tue Nov  8 12:02:58 2011
@@ -10,10 +10,6 @@
 #include "types.h"
 
 #include "Classpath.h"
-#include "JavaArray.h"
-#include "JavaClass.h"
-#include "JavaObject.h"
-#include "JavaThread.h"
 #include "Jnjvm.h"
 
 using namespace j3;
@@ -28,59 +24,12 @@
 JavaObject* src) {
   
   JavaObject* res = NULL;
-  JavaObject* tmp = NULL;
   llvm_gcroot(res, 0);
   llvm_gcroot(src, 0);
 
   BEGIN_NATIVE_EXCEPTION(0)
 
-  UserCommonClass* cl = JavaObject::getClass(src);
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  if (cl->isArray()) {
-    UserClassArray* array = cl->asArrayClass();
-    int length = JavaArray::getSize(src);
-    res = array->doNew(length, vm);
-    UserCommonClass* base = array->baseClass();
-    if (base->isPrimitive()) {
-      int size = length << base->asPrimitiveClass()->logSize;
-      memcpy((void*)((uintptr_t)res + sizeof(JavaObject) + sizeof(size_t)),
-             (void*)((uintptr_t)src + sizeof(JavaObject) + sizeof(size_t)),
-             size);
-    } else {
-      for (int i = 0; i < length; i++) {
-        tmp = ArrayObject::getElement((ArrayObject*)src, i);
-        ArrayObject::setElement((ArrayObject*)res, tmp, i);
-      }
-    }
-  } else {
-    assert(cl->isClass() && "Not a class!");
-    res = cl->asClass()->doNew(vm);
-    while (cl != NULL) {
-      for (uint32 i = 0; i < cl->asClass()->nbVirtualFields; ++i) {
-        JavaField& field = cl->asClass()->virtualFields[i];
-        if (field.isReference()) {
-          tmp = field.getInstanceObjectField(src);
-          JavaObject** ptr = field.getInstanceObjectFieldPtr(res);
-          mvm::Collector::objectReferenceWriteBarrier((gc*)res, (gc**)ptr, (gc*)tmp);
-        } else if (field.isLong()) {
-          field.setInstanceLongField(res, field.getInstanceLongField(src));
-        } else if (field.isDouble()) {
-          field.setInstanceDoubleField(res, field.getInstanceDoubleField(src));
-        } else if (field.isInt()) {
-          field.setInstanceInt32Field(res, field.getInstanceInt32Field(src));
-        } else if (field.isFloat()) {
-          field.setInstanceFloatField(res, field.getInstanceFloatField(src));
-        } else if (field.isShort() || field.isChar()) {
-          field.setInstanceInt16Field(res, field.getInstanceInt16Field(src));
-        } else if (field.isByte() || field.isBoolean()) {
-          field.setInstanceInt8Field(res, field.getInstanceInt8Field(src));
-        } else {
-          UNREACHABLE();
-        }
-      }
-      cl = cl->super;
-    }
-  }
+  res = JavaObject::clone(src);
 
   END_NATIVE_EXCEPTION
 
@@ -136,17 +85,7 @@
 
   BEGIN_NATIVE_EXCEPTION(0)
 
-  uint32 sec = (uint32) (ms / 1000);
-  uint32 usec = (ns / 1000) + 1000 * (ms % 1000);
-  if (ns && !usec) usec = 1;
-  if (sec || usec) {
-    struct timeval t;
-    t.tv_sec = sec;
-    t.tv_usec = usec;
-    JavaObject::timedWait(obj, t);
-  } else {
-    JavaObject::wait(obj);
-  }
+  JavaObject::wait(obj, ms, ns);
 
   END_NATIVE_EXCEPTION
 }

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144093&r1=144092&r2=144093&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov  8 12:02:58 2011
@@ -117,51 +117,47 @@
 
 JNIEXPORT void JNICALL
 JVM_MonitorWait(JNIEnv *env, jobject obj, jlong ms) {
-  JavaObject * o = 0;
-  llvm_gcroot(o, 0);
-
   BEGIN_JNI_EXCEPTION
-  Jnjvm* vm = JavaThread::get()->getJVM();
-
-  o = *(JavaObject**)obj;
 
-  if (ms < 0) {
-    vm->illegalArgumentException("Negative wait time specified");
-  }
-  if (ms) {
-    struct timeval info;
-    uint64_t usec = ms * 1000LL;
-    info.tv_usec = usec % 1000000LL;
-    info.tv_sec = usec / 1000000LL;
-    JavaObject::timedWait(o, info);
-  } else {
-    JavaObject::wait(o);
-  }
+  JavaObject::wait(*(JavaObject**)obj, ms, 0);
   RETURN_VOID_FROM_JNI
+
   END_JNI_EXCEPTION
 }
 
 JNIEXPORT void JNICALL
 JVM_MonitorNotify(JNIEnv *env, jobject obj) {
   BEGIN_JNI_EXCEPTION
-  JavaObject * o = *(JavaObject**)obj;
-  JavaObject::notify(o);
+
+  JavaObject::notify(*(JavaObject**)obj);
+
   RETURN_VOID_FROM_JNI
+
   END_JNI_EXCEPTION
 }
 
 JNIEXPORT void JNICALL
 JVM_MonitorNotifyAll(JNIEnv *env, jobject obj) {
   BEGIN_JNI_EXCEPTION
-  JavaObject * o = *(JavaObject**)obj;
-  JavaObject::notifyAll(o);
+
+  JavaObject::notifyAll(*(JavaObject**)obj);
   RETURN_VOID_FROM_JNI
+
   END_JNI_EXCEPTION
 }
 
 JNIEXPORT jobject JNICALL
 JVM_Clone(JNIEnv *env, jobject obj) {
-  NYI();
+  JavaObject * clone = 0;
+  llvm_gcroot(clone, 0);
+  BEGIN_JNI_EXCEPTION
+
+  clone = JavaObject::clone(*(JavaObject**)obj);
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(clone));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /*

Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.cpp?rev=144093&r1=144092&r2=144093&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaObject.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaObject.cpp Tue Nov  8 12:02:58 2011
@@ -9,6 +9,7 @@
 
 #include "mvm/Threads/Locks.h"
 
+#include "JavaArray.h"
 #include "JavaClass.h"
 #include "JavaObject.h"
 #include "JavaThread.h"
@@ -95,6 +96,28 @@
   waitIntern(self, &info, true);
 }
 
+void JavaObject::wait(JavaObject* self, int64_t ms, int32_t ns) {
+  llvm_gcroot(self, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+
+  if (ms < 0 || ns < 0) {
+    vm->illegalArgumentException("Negative wait time specified");
+  }
+
+  uint32 sec = (uint32) (ms / 1000);
+  uint32 usec = (ns / 1000) + 1000 * (ms % 1000);
+  if (ns && !usec) usec = 1;
+  if (sec || usec) {
+    struct timeval t;
+    t.tv_sec = sec;
+    t.tv_usec = usec;
+    JavaObject::timedWait(self, t);
+  } else {
+    JavaObject::wait(self);
+  }
+}
+
 void JavaObject::notify(JavaObject* self) {
   llvm_gcroot(self, 0);
   JavaThread* thread = JavaThread::get();
@@ -119,6 +142,71 @@
   thread->lockingThread.notifyAll(self, table);
 }
 
+JavaObject* JavaObject::clone(JavaObject* src) {
+  JavaObject* res = 0;
+  JavaObject* tmp = 0;
+
+  llvm_gcroot(src, 0);
+  llvm_gcroot(res, 0);
+  llvm_gcroot(tmp, 0);
+
+  UserCommonClass* cl = JavaObject::getClass(src);
+  Jnjvm* vm = JavaThread::get()->getJVM();
+
+  // If this doesn't inherit the Cloneable interface, throw exception
+  // TODO: Add support in both class libraries for the upcalls fields used here
+  //if (!JavaObject::instanceOf(src, vm->upcalls->cloneableClass))
+  //  vm->cloneNotSupportedException();
+
+  if (cl->isArray()) {
+    UserClassArray* array = cl->asArrayClass();
+    int length = JavaArray::getSize(src);
+    res = array->doNew(length, vm);
+    UserCommonClass* base = array->baseClass();
+    if (base->isPrimitive()) {
+      int size = length << base->asPrimitiveClass()->logSize;
+      memcpy((void*)((uintptr_t)res + sizeof(JavaObject) + sizeof(size_t)),
+             (void*)((uintptr_t)src + sizeof(JavaObject) + sizeof(size_t)),
+             size);
+    } else {
+      for (int i = 0; i < length; i++) {
+        tmp = ArrayObject::getElement((ArrayObject*)src, i);
+        ArrayObject::setElement((ArrayObject*)res, tmp, i);
+      }
+    }
+  } else {
+    assert(cl->isClass() && "Not a class!");
+    res = cl->asClass()->doNew(vm);
+    while (cl != NULL) {
+      for (uint32 i = 0; i < cl->asClass()->nbVirtualFields; ++i) {
+        JavaField& field = cl->asClass()->virtualFields[i];
+        if (field.isReference()) {
+          tmp = field.getInstanceObjectField(src);
+          JavaObject** ptr = field.getInstanceObjectFieldPtr(res);
+          mvm::Collector::objectReferenceWriteBarrier((gc*)res, (gc**)ptr, (gc*)tmp);
+        } else if (field.isLong()) {
+          field.setInstanceLongField(res, field.getInstanceLongField(src));
+        } else if (field.isDouble()) {
+          field.setInstanceDoubleField(res, field.getInstanceDoubleField(src));
+        } else if (field.isInt()) {
+          field.setInstanceInt32Field(res, field.getInstanceInt32Field(src));
+        } else if (field.isFloat()) {
+          field.setInstanceFloatField(res, field.getInstanceFloatField(src));
+        } else if (field.isShort() || field.isChar()) {
+          field.setInstanceInt16Field(res, field.getInstanceInt16Field(src));
+        } else if (field.isByte() || field.isBoolean()) {
+          field.setInstanceInt8Field(res, field.getInstanceInt8Field(src));
+        } else {
+          UNREACHABLE();
+        }
+      }
+      cl = cl->super;
+    }
+  }
+
+  return res;
+}
+
 void JavaObject::overflowThinLock(JavaObject* self) {
   llvm_gcroot(self, 0);
   mvm::ThinLock::overflowThinLock(self, JavaThread::get()->getJVM()->lockSystem);

Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.h?rev=144093&r1=144092&r2=144093&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaObject.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaObject.h Tue Nov  8 12:02:58 2011
@@ -257,6 +257,10 @@
   ///
   static void timedWait(JavaObject* self, struct timeval &info);
   
+  /// wait - Wait for specified ms and ns.  Wrapper for either wait() or
+  /// timedWait, depending on duration specified.
+  static void wait(JavaObject* self, int64_t ms, int32_t ns);
+
   /// notify - Java notify. Notifies a thread from the availability of the
   /// monitor.
   ///
@@ -266,6 +270,10 @@
   /// the monitor.
   ///
   static void notifyAll(JavaObject* self);
+
+  /// clone - Java clone. Creates a copy of this object.
+  ///
+  static JavaObject* clone(JavaObject* other);
  
   /// overflowThinLock - Notify that the thin lock has overflowed.
   ///




From nicolas.geoffray at gmail.com  Tue Nov  8 12:36:24 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 21:36:24 +0100
Subject: [vmkit-commits] [PATCH] Refactor Class-related code into new
	Class.inc.
In-Reply-To: <CAKGWAO81ayMGHg9xuTNA9iaUT2h+46tGtFhqbGctaUY4KOyDnA@mail.gmail.com>
References: <CAKGWAO81ayMGHg9xuTNA9iaUT2h+46tGtFhqbGctaUY4KOyDnA@mail.gmail.com>
Message-ID: <CAPYwfirrWZTLL63T=2TJaF4yM_TBtBkDX3_X1RgaPQO5d+pLOA@mail.gmail.com>

Looks good, with one request.

On Mon, Nov 7, 2011 at 4:00 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below. Also attached, since it's a bit larger.
>
> Shares a lot more code, which is good.
>
> However, the creation of Field/Method/Constructor objects is still
> different for classpath vs openjdk, so add some callback functions to
> define those.
>
> ~Will
>
> >From 151c15f1982b9b4ced11a704303f7103104aac36 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sat, 5 Nov 2011 23:53:56 -0500
> Subject: [PATCH 3/8] Refactor Class-related code into new Class.inc.
>
> ---
>  lib/J3/ClassLib/Class.inc                         |  251 ++++++++++++++
>  lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc |  239 ++++----------
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc               |  367
> +++++++++------------
>  3 files changed, 474 insertions(+), 383 deletions(-)
>  create mode 100644 lib/J3/ClassLib/Class.inc
>
> diff --git a/lib/J3/ClassLib/Class.inc b/lib/J3/ClassLib/Class.inc
> new file mode 100644
> index 0000000..4e8e063
> --- /dev/null
> +++ b/lib/J3/ClassLib/Class.inc
> @@ -0,0 +1,251 @@
> +//===---- Class.inc - Shared j.l.Class code
> -------------------------------===//
> +//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +// Implementation-specific logic
> +JavaObject* ClassLib_getConstructor(JavaMethod * cons, int i);
> +JavaObject* ClassLib_getMethod(JavaMethod* meth, int i);
> +JavaObject* ClassLib_getField(JavaField* field, int i);
> +
> +static inline ArrayObject* Class_getDeclaredConstructors(JavaObject*
> Cl, jboolean publicOnly) {
>

Please put this method as a static method of JavaObjectClass (I know, you
have to add it to the file in gnu classpath, as well as openjdk).

The reason I'm asking is because I just realized that you're using static
inline. Note that if it was static only, the GC would not work with it
(limitation in clang). Because you're putting inline, I guess that's the
reason why it did not fail, but that's very brittle. Please do the same for
all the other methods above. Thanks!


> +  ArrayObject* ret = 0;
> +  JavaObject* tmp = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(tmp, 0);
> +
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> +  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
> +    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
> +  } else {
> +    UserClass* realCl = cl->asClass();;
> +    JnjvmClassLoader* classLoader = cl->classLoader;
> +    uint32 size = 0;
> +
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> +          (!publicOnly || pub)) {
> +        ++size;
> +      }
> +    }
> +
> +    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size,
> vm);
> +
> +    sint32 index = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> +          (!publicOnly || pub)) {
> +        tmp = ClassLib_getConstructor(meth, i);
> +        ArrayObject::setElement(ret, tmp, index);
> +        index++;
> +      }
> +    }
> +  }
> +
> +  return ret;
> +}
> +
> +static inline ArrayObject* Class_getDeclaredMethods(JavaObject* Cl,
> jboolean publicOnly) {
> +  ArrayObject* ret = 0;
> +  JavaObject* tmp = 0;
> +  JavaString* str = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(tmp, 0);
> +  llvm_gcroot(str, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +  Classpath* upcalls = vm->upcalls;
> +
> +  if (cl->isArray() || cl->isPrimitive()) {
> +    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
> +  } else {
> +    UserClass* realCl = cl->asClass();
> +    JnjvmClassLoader* classLoader = cl->classLoader;
> +    uint32 size = 0;
> +
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> +         ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> +          !(meth->name->equals(classLoader->bootstrapLoader->clinitName))
> &&
> +          (!publicOnly || pub)) {
> +        ++size;
> +      }
> +    }
> +
> +
> +    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
> +
> +    sint32 index = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> +         ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> +          !(meth->name->equals(classLoader->bootstrapLoader->clinitName))
> &&
> +          (!publicOnly || pub)) {
> +        tmp = ClassLib_getMethod(meth, i);
> +        ArrayObject::setElement(ret, tmp, index);
> +        index++;
> +      }
> +    }
> +  }
> +
> +  return ret;
> +}
> +
> +static inline JavaObject* Class_getDeclaringClass(JavaObject * Cl) {
> +  JavaObject* res = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(res, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> +
> +  if (cl) {
> +    cl->resolveInnerOuterClasses();
> +    UserClass* outer = cl->getOuterClass();
> +    if (outer) {
> +      res = outer->getClassDelegatee(vm);
> +    }
> +  }
> +
> +  return res;
> +}
> +
> +static inline ArrayObject* Class_getDeclaredClasses(JavaObject* Cl,
> bool publicOnly) {
> +  ArrayObject* result = 0;
> +  llvm_gcroot(result, 0);
> +  llvm_gcroot(Cl, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> +  if (cl) {
> +    cl->resolveInnerOuterClasses();
> +    UserClassArray* array = vm->upcalls->constructorArrayClass;
> +
> +    uint16 sizeArray = 0;
> +
> +    if (publicOnly) {
> +      for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
> +        UserClass* klass = cl->innerClasses[i];
> +        if (isPublic(klass->innerAccess)) ++sizeArray;
> +      }
> +    } else {
> +      sizeArray = cl->nbInnerClasses;
> +    }
> +
> +    result = (ArrayObject*)array->doNew(sizeArray, vm);
> +    int index = 0;
> +    for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
> +      UserClass* klass = cl->innerClasses[i];
> +      if (!publicOnly || isPublic(klass->innerAccess))
> +        ArrayObject::setElement(result, klass->getClassDelegatee(vm),
> index++);
> +    }
> +    assert(index == sizeArray);
> +  }
> +
> +  return result;
> +}
> +
> +static inline ArrayObject* Class_getDeclaredFields(JavaObject* Cl,
> jboolean publicOnly) {
> +  ArrayObject* ret = 0;
> +  JavaObject* tmp = 0;
> +  JavaString* name = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(tmp, 0);
> +  llvm_gcroot(name, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> +  if (!cl->isClass()) {
> +    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
> +  } else {
> +    UserClass* realCl = cl->asClass();
> +    uint32 size = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> +         ++i) {
> +      JavaField* field = &realCl->virtualFields[i];
> +      if (!publicOnly || isPublic(field->access)) {
> +        ++size;
> +      }
> +    }
> +
> +    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
> +
> +    sint32 index = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> +         ++i) {
> +      JavaField* field = &realCl->virtualFields[i];
> +      if (!publicOnly || isPublic(field->access)) {
> +        tmp = ClassLib_getField(field, i);
> +        ArrayObject::setElement(ret, tmp, index);
> +        index++;
> +      }
> +    }
> +  }
> +
> +  return ret;
> +}
> +
> +static inline ArrayObject* Class_getInterfaces(JavaObject* Cl) {
> +  ArrayObject* res = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(res, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +  res =
> (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,
> vm);
> +
> +  for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
> +    UserClass* klass = cl->interfaces[i];
> +    ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
> +  }
> +
> +  return res;
> +}
> +
> +static inline ArrayObject* Class_getDeclaredAnnotations(JavaObject* Cl) {
> +  // TODO: Implement me (for now just returning empty array)
> +  ArrayObject* res = 0;
> +  llvm_gcroot(res, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
> +  res = (ArrayObject*)array->doNew(0, vm);
> +
> +  return res;
> +}
> +
> +static inline jint Class_getModifiers(JavaObject * Cl) {
> +  llvm_gcroot(Cl, 0);
> +  jint res;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +  res = cl->getAccess();
> +
> +  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
> +    // javac may put that flag to inner classes of enum classes.
> +    res &= ~ACC_ENUM;
> +  }
> +
> +  return res;
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> index 0c4d21c..47fd6b6 100644
> --- a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> @@ -21,6 +21,8 @@
>  #include "JavaUpcalls.h"
>  #include "Jnjvm.h"
>
> +#include "Class.inc"
> +
>  using namespace j3;
>
>  extern "C" {
> @@ -86,48 +88,12 @@ JavaObject* Cl,
>  jboolean publicOnly) {
>
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
>   llvm_gcroot(Cl, 0);
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> -  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
> -    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();;
> -    JnjvmClassLoader* classLoader = cl->classLoader;
> -    uint32 size = 0;
> -
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> -          (!publicOnly || pub)) {
> -        ++size;
> -      }
> -    }
> -
> -    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size,
> vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> -          (!publicOnly || pub)) {
> -        UserClass* Cons = vm->upcalls->newConstructor;
> -        tmp = Cons->doNew(vm);
> -        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp,
> &Cl, i);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = Class_getDeclaredConstructors(Cl, publicOnly);
>
>   END_NATIVE_EXCEPTION
>
> @@ -143,58 +109,12 @@ JavaObject* Cl,
>  jboolean publicOnly) {
>
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> -  JavaString* str = 0;
>   llvm_gcroot(Cl, 0);
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
> -  llvm_gcroot(str, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -  Classpath* upcalls = vm->upcalls;
> -
> -  if (cl->isArray() || cl->isPrimitive()) {
> -    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();
> -    JnjvmClassLoader* classLoader = cl->classLoader;
> -    uint32 size = 0;
> -
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> -         ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> -          !(meth->name->equals(classLoader->bootstrapLoader->clinitName))
> &&
> -          (!publicOnly || pub)) {
> -        ++size;
> -      }
> -    }
> -
> -
> -    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> -         ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> -          !(meth->name->equals(classLoader->bootstrapLoader->clinitName))
> &&
> -          (!publicOnly || pub)) {
> -        // TODO: check parameter types
> -        UserClass* Meth = vm->upcalls->newMethod;
> -        tmp = Meth->doNew(vm);
> -        str = vm->internalUTF8ToStr(meth->name);
> -        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, &Cl, &str,
> i);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = Class_getDeclaredMethods(Cl, publicOnly);
>
>   END_NATIVE_EXCEPTION
>
> @@ -214,14 +134,7 @@ jboolean ignore) {
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -  res = cl->getAccess();
> -
> -  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
> -    // javac may put that flag to inner classes of enum classes.
> -    res &= ~ACC_ENUM;
> -  }
> +  res = Class_getModifiers(Cl);
>
>   END_NATIVE_EXCEPTION
>   return res;
> @@ -428,49 +341,12 @@ jclass clazz,
>  JavaObject* Cl, jboolean publicOnly) {
>
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> -  JavaString* name = 0;
>   llvm_gcroot(Cl, 0);
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
> -  llvm_gcroot(name, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> -  if (!cl->isClass()) {
> -    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();
> -    uint32 size = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> -         ++i) {
> -      JavaField* field = &realCl->virtualFields[i];
> -      if (!publicOnly || isPublic(field->access)) {
> -        ++size;
> -      }
> -    }
> -
> -
> -    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> -         ++i) {
> -      JavaField* field = &realCl->virtualFields[i];
> -      if (!publicOnly || isPublic(field->access)) {
> -        // TODO: check parameter types
> -        UserClass* Field = vm->upcalls->newField;
> -        tmp = Field->doNew(vm);
> -        name = vm->internalUTF8ToStr(field->name);
> -        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, &Cl,
> &name, i);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = Class_getDeclaredFields(Cl, publicOnly);
>
>   END_NATIVE_EXCEPTION
>
> @@ -490,14 +366,7 @@ JavaObject* Cl) {
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -  res =
> (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,
> vm);
> -
> -  for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
> -    UserClass* klass = cl->interfaces[i];
> -    ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
> -  }
> +  res = Class_getInterfaces(Cl);
>
>   END_NATIVE_EXCEPTION
>
> @@ -518,16 +387,7 @@ JavaObject* Cl) {
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> -
> -  if (cl) {
> -    cl->resolveInnerOuterClasses();
> -    UserClass* outer = cl->getOuterClass();
> -    if (outer) {
> -      res = outer->getClassDelegatee(vm);
> -    }
> -  }
> +  res = Class_getDeclaringClass(Cl);
>
>   END_NATIVE_EXCEPTION
>
> @@ -548,33 +408,7 @@ JavaObject* Cl, bool publicOnly) {
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> -  if (cl) {
> -    cl->resolveInnerOuterClasses();
> -    UserClassArray* array = vm->upcalls->constructorArrayClass;
> -
> -    uint16 sizeArray = 0;
> -
> -    if (publicOnly) {
> -      for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
> -        UserClass* klass = cl->innerClasses[i];
> -        if (isPublic(klass->innerAccess)) ++sizeArray;
> -      }
> -    } else {
> -      sizeArray = cl->nbInnerClasses;
> -    }
> -
> -    result = (ArrayObject*)array->doNew(sizeArray, vm);
> -    int index = 0;
> -    for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
> -      UserClass* klass = cl->innerClasses[i];
> -      if (!publicOnly || isPublic(klass->innerAccess))
> -        ArrayObject::setElement(result, klass->getClassDelegatee(vm),
> index++);
> -    }
> -    assert(index == sizeArray);
> -  }
> -
> +  result = Class_getDeclaredClasses(Cl, publicOnly);
>
>   END_NATIVE_EXCEPTION
>
> @@ -603,16 +437,14 @@ jclass clazz,
>  #endif
>  JavaObject* Cl) {
>   // TODO implement me
> -
> +
>   ArrayObject* res = 0;
>   llvm_gcroot(res, 0);
>   llvm_gcroot(Cl, 0);
> -
> +
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
> -  res = (ArrayObject*)array->doNew(0, vm);
> +  res = Class_getDeclaredAnnotations(Cl);
>
>   END_NATIVE_EXCEPTION
>
> @@ -641,5 +473,52 @@ JavaObject* Cl) {
>   return res;
>  }
>
> +JavaObject* ClassLib_getConstructor(JavaMethod * cons, int i) {
> +  JavaObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* Cons = vm->upcalls->newConstructor;
> +  ret = Cons->doNew(vm);
> +  JavaObject* const* Cl = cons->classDef->getDelegateePtr();
> +  vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
> +    Cl, i);
> +
> +  return ret;
> +}
> +
> +JavaObject* ClassLib_getMethod(JavaMethod* meth, int i) {
> +  JavaObject* ret = 0;
> +  JavaString* str = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(str, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* Meth = vm->upcalls->newMethod;
> +  ret = Meth->doNew(vm);
> +  str = vm->internalUTF8ToStr(meth->name);
> +  JavaObject* const* Cl = meth->classDef->getDelegateePtr();
> +  vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
> +    Cl, &str, i);
> +
> +  return ret;
> +}
> +
> +JavaObject* ClassLib_getField(JavaField* field, int i) {
> +  JavaObject* ret = 0;
> +  JavaString* name = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(name, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* Field = vm->upcalls->newField;
> +  ret = Field->doNew(vm);
> +  name = vm->internalUTF8ToStr(field->name);
> +  JavaObject* const* Cl = field->classDef->getDelegateePtr();
> +  vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
> +    Cl, &name, i);
> +
> +  return ret;
> +}
>
>  }
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 012b021..4f25fb0 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -12,6 +12,7 @@
>  #include "Reader.h"
>
>  #include "ArrayCopy.inc"
> +#include "Class.inc"
>  #include "ClassContext.inc"
>  #include "SetProperties.inc"
>  #include "Object.inc"
> @@ -1038,7 +1039,18 @@ JVM_GetClassName(JNIEnv *env, jclass cls) {
>
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassInterfaces(JNIEnv *env, jclass cls) {
> -  NYI();
> +  ArrayObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  ret = Class_getInterfaces(*(JavaObject**)cls);
> +
> +  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jobject JNICALL
> @@ -1184,17 +1196,7 @@ JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
>
>   Cl = *(JavaObject**)cls;
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();;
> -
> -  jint res = cl->getAccess();
> -
> -  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
> -    // javac may put that flag to inner classes of enum classes.
> -    res &= ~ACC_ENUM;
> -  }
> -
> -  RETURN_FROM_JNI(res);
> +  RETURN_FROM_JNI(Class_getModifiers(Cl));
>
>   END_JNI_EXCEPTION
>
> @@ -1203,12 +1205,35 @@ JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
>
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass) {
> -  NYI();
> +  ArrayObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  // TODO: Verify boolean parameter here, assuming should default to true.
> +  ret = Class_getDeclaredClasses(*(JavaObject**)ofClass, false);
> +
> +  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jclass JNICALL
>  JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass) {
> -  NYI();
> +  JavaObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  ret = Class_getDeclaringClass(*(JavaObject**)ofClass);
> +
> +  RETURN_FROM_JNI((jclass)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /* Generics support (JDK 1.5) */
> @@ -1220,84 +1245,144 @@ JVM_GetClassSignature(JNIEnv *env, jclass cls) {
>  /* Annotations support (JDK 1.5) */
>  JNIEXPORT jbyteArray JNICALL
>  JVM_GetClassAnnotations(JNIEnv *env, jclass cls) {
> -  NYI();
> +  ArrayObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  ret = Class_getDeclaredAnnotations(*(JavaObject**)cls);
> +
> +  RETURN_FROM_JNI((jbyteArray)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /*
>  * New (JDK 1.4) reflection implementation
>  */
> +JavaObject* ClassLib_getConstructor(JavaMethod * cons, int i) {
> +  JavaObject* ret = 0;
> +  JavaObject* pArr = 0;
> +  JavaObject* eArr = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(pArr, 0);
> +  llvm_gcroot(eArr, 0);
>
> -JNIEXPORT jobjectArray JNICALL
> -JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean
> publicOnly) {
> -  ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JnjvmClassLoader * classLoader = cons->classDef->classLoader;
> +
> +  UserClass* Cons = vm->upcalls->newConstructor;
> +  pArr = cons->getParameterTypes(classLoader);
> +  eArr = cons->getExceptionTypes(classLoader);
> +  ret = Cons->doNew(vm);
> +  JavaObject* const* Cl = cons->classDef->getDelegateePtr();
> +  vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
> +    Cl,           /* declaringClass */
> +    &pArr,        /* parameterTypes */
> +    &eArr,        /* checkedExceptions */
> +    cons->access, /* modifiers */
> +    i,            /* slot */
> +    NULL,         /* String signature */
> +    NULL,         /* annotations */
> +    NULL          /* parameterAnnotations */
> +  );
> +
> +  return ret;
> +}
> +
> +JavaObject* ClassLib_getMethod(JavaMethod* meth, int i) {
> +  JavaObject* ret = 0;
>   JavaString* str = 0;
> -  JavaObject * Cl = 0;
> -  llvm_gcroot(Cl, 0);
> +  JavaObject* pArr = 0;
> +  JavaObject* eArr = 0;
> +  JavaObject* retTy = 0;
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
>   llvm_gcroot(str, 0);
> +  llvm_gcroot(pArr, 0);
> +  llvm_gcroot(eArr, 0);
> +  llvm_gcroot(retTy, 0);
>
> -  BEGIN_JNI_EXCEPTION
> -
> -  Cl = *(JavaObject**)ofClass;
> +  // TODO: check parameter types
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JnjvmClassLoader * classLoader = meth->classDef->classLoader;
> +
> +  UserClass* Meth = vm->upcalls->newMethod;
> +  ret = Meth->doNew(vm);
> +  str = vm->internalUTF8ToStr(meth->name);
> +  pArr = meth->getParameterTypes(classLoader);
> +  eArr = meth->getExceptionTypes(classLoader);
> +  retTy = meth->getReturnType(classLoader);
> +  JavaObject* const* Cl = meth->classDef->getClassDelegateePtr(vm);
> +  vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
> +    Cl,           /* declaring class */
> +    &str,         /* name */
> +    &pArr,        /* parameter types */
> +    &retTy,       /* return type */
> +    &eArr,        /* exceptions */
> +    meth->access, /* modifiers */
> +    i,            /* slot */
> +    NULL,         /* signature */
> +    NULL,         /* annotations */
> +    NULL,         /* parameter annotations */
> +    NULL);        /* default annotations */
> +
> +  return ret;
> +}
> +
> +JavaObject* ClassLib_getField(JavaField* field, int i) {
> +  JavaObject* ret = 0;
> +  JavaString* name = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(name, 0);
>
> +  // TODO: check parameter types
>   Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -  Classpath* upcalls = vm->upcalls;
> +  UserClass* Field = vm->upcalls->newField;
> +  ret = Field->doNew(vm);
> +  name = vm->internalUTF8ToStr(field->name);
> +
> +  //type->Class
> +  JnjvmClassLoader* loader = field->classDef->classLoader;
> +  UserCommonClass * fieldCl = field->getSignature()->assocClass(loader);
> +  assert(fieldCl);
> +  JavaObject* const* type = fieldCl->getClassDelegateePtr(vm);
> +  JavaObject* const* Cl = field->classDef->getClassDelegateePtr(vm);
> +
> +  // TODO:Implement these!
> +  JavaObject** sign = NULL;
> +  JavaObject** annArray = NULL;
> +
> +  /* java.reflect.Field(
> +  *   Class declaringClass,
> +  *   String name,
> +  *   Class type,
> +  *   int modifiers,
> +  *   int slot,
> +  *   String signature,
> +  *   byte[] annotations)
> +  */
> +  vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
> +    Cl,
> +    &name,
> +    type,
> +    field->access,
> +    i,
> +    sign,
> +    annArray);
> +
> +  return ret;
> +}
>
> -  if (cl->isArray() || cl->isPrimitive()) {
> -    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();
> -    JnjvmClassLoader* classLoader = cl->classLoader;
> -    uint32 size = 0;
> -
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> -         ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> -          (!publicOnly || pub)) {
> -        ++size;
> -      }
> -    }
> +JNIEXPORT jobjectArray JNICALL
> +JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean
> publicOnly) {
> +  ArrayObject* ret = 0;
> +  llvm_gcroot(ret, 0);
>
> +  BEGIN_JNI_EXCEPTION
>
> -    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> -         ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> -          (!publicOnly || pub)) {
> -        // TODO: check parameter types
> -        UserClass* Meth = vm->upcalls->newMethod;
> -        tmp = Meth->doNew(vm);
> -        str = vm->internalUTF8ToStr(meth->name);
> -        JavaObject * pArr = meth->getParameterTypes(classLoader);
> -        JavaObject * eArr = meth->getExceptionTypes(classLoader);
> -        JavaObject * retTy = meth->getReturnType(classLoader);
> -        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp,
> -          &Cl,          /* declaring class */
> -          &str,         /* name */
> -          &pArr,        /* parameter types */
> -          &retTy,       /* return type */
> -          &eArr,        /* exceptions */
> -          meth->access, /* modifiers */
> -          i,            /* slot */
> -          NULL,         /* signature */
> -          NULL,         /* annotations */
> -          NULL,         /* parameter annotations */
> -          NULL,         /* default annotations */
> -          i);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = Class_getDeclaredMethods(*(JavaObject**)ofClass, publicOnly);
>
>   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
>
> @@ -1309,85 +1394,12 @@ JVM_GetClassDeclaredMethods(JNIEnv *env,
> jclass ofClass, jboolean publicOnly) {
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean
> publicOnly) {
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> -  JavaString* name = 0;
> -  JavaObject*const*  type = 0;
> -  JavaString* sign = 0;
> -  JavaObject* annArray = 0;
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
> -  llvm_gcroot(name, 0);
> -  llvm_gcroot(type, 0);
> -  llvm_gcroot(sign, 0);
> -  llvm_gcroot(annArray, 0);
>
>   BEGIN_JNI_EXCEPTION
>
> -  JavaObject * Cl = *(JavaObject**)ofClass;
> -  llvm_gcroot(Cl, 0);
> +  ret = Class_getDeclaredFields(*(JavaObject**)ofClass, publicOnly);
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> -  if (!cl->isClass()) {
> -    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();
> -    uint32 size = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> -         ++i) {
> -      JavaField* field = &realCl->virtualFields[i];
> -      if (!publicOnly || isPublic(field->access)) {
> -        ++size;
> -      }
> -    }
> -
> -
> -    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> -         ++i) {
> -      JavaField* field = &realCl->virtualFields[i];
> -      if (!publicOnly || isPublic(field->access)) {
> -        // TODO: check parameter types
> -        UserClass* Field = vm->upcalls->newField;
> -        tmp = Field->doNew(vm);
> -        name = vm->internalUTF8ToStr(field->name);
> -
> -        //type->Class
> -        UserCommonClass * fieldCl =
> field->getSignature()->assocClass(cl->classLoader);
> -        assert(fieldCl);
> -        type = fieldCl->getClassDelegateePtr(vm);
> -
> -        // TODO:Implement these!
> -        sign = NULL;
> -        annArray = NULL;
> -
> -        //Convert to string
> -
> -        /* java.reflect.Field(
> -         *   Class declaringClass,
> -         *   String name,
> -         *   Class type,
> -         *   int modifiers,
> -         *   int slot,
> -         *   String signature,
> -         *   byte[] annotations)
> -         */
> -        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp,
> -          &Cl,
> -          &name,
> -          type,
> -          field->access,
> -          i,
> -          sign,
> -          annArray);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
>   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
>
>   END_JNI_EXCEPTION
> @@ -1398,62 +1410,11 @@ JVM_GetClassDeclaredFields(JNIEnv *env, jclass
> ofClass, jboolean publicOnly) {
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass,
> jboolean publicOnly) {
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> -  JavaObject* Cl = 0;
> -  llvm_gcroot(Cl, 0);
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
>
>   BEGIN_JNI_EXCEPTION
>
> -  Cl = *(JavaObject**)ofClass;
> -
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> -  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
> -    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();;
> -    JnjvmClassLoader* classLoader = cl->classLoader;
> -    uint32 size = 0;
> -
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> -          (!publicOnly || pub)) {
> -        ++size;
> -      }
> -    }
> -
> -    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size,
> vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> -          (!publicOnly || pub)) {
> -        UserClass* Cons = vm->upcalls->newConstructor;
> -        JavaObject * pArr = meth->getParameterTypes(classLoader);
> -        JavaObject * eArr = meth->getExceptionTypes(classLoader);
> -        tmp = Cons->doNew(vm);
> -        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp,
> -          &Cl,          /* declaringClass */
> -          &pArr,        /* parameterTypes */
> -          &eArr,        /* checkedExceptions */
> -          meth->access, /* modifiers */
> -          i,            /* slot */
> -          NULL,         /* String signature */
> -          NULL,         /* annotations */
> -          NULL          /* parameterAnnotations */
> -        );
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = Class_getDeclaredConstructors(*(JavaObject**)ofClass, publicOnly);
>
>   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
>
> --
> 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/20111108/55c50624/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 12:36:55 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 21:36:55 +0100
Subject: [vmkit-commits] [PATCH] Refactor Class-related code into new
	Class.inc.
In-Reply-To: <CAKGWAO81ayMGHg9xuTNA9iaUT2h+46tGtFhqbGctaUY4KOyDnA@mail.gmail.com>
References: <CAKGWAO81ayMGHg9xuTNA9iaUT2h+46tGtFhqbGctaUY4KOyDnA@mail.gmail.com>
Message-ID: <CAPYwfiq19p6UQ-47WbX-CG7PVNOMuoJk5+ww9z0Zn_jRR1VeMQ@mail.gmail.com>

Looks good, with one request.

On Mon, Nov 7, 2011 at 4:00 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below. Also attached, since it's a bit larger.
>
> Shares a lot more code, which is good.
>
> However, the creation of Field/Method/Constructor objects is still
> different for classpath vs openjdk, so add some callback functions to
> define those.
>
> ~Will
>
> >From 151c15f1982b9b4ced11a704303f7103104aac36 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sat, 5 Nov 2011 23:53:56 -0500
> Subject: [PATCH 3/8] Refactor Class-related code into new Class.inc.
>
> ---
>  lib/J3/ClassLib/Class.inc                         |  251 ++++++++++++++
>  lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc |  239 ++++----------
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc               |  367
> +++++++++------------
>  3 files changed, 474 insertions(+), 383 deletions(-)
>  create mode 100644 lib/J3/ClassLib/Class.inc
>
> diff --git a/lib/J3/ClassLib/Class.inc b/lib/J3/ClassLib/Class.inc
> new file mode 100644
> index 0000000..4e8e063
> --- /dev/null
> +++ b/lib/J3/ClassLib/Class.inc
> @@ -0,0 +1,251 @@
> +//===---- Class.inc - Shared j.l.Class code
> -------------------------------===//
> +//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +// Implementation-specific logic
> +JavaObject* ClassLib_getConstructor(JavaMethod * cons, int i);
> +JavaObject* ClassLib_getMethod(JavaMethod* meth, int i);
> +JavaObject* ClassLib_getField(JavaField* field, int i);
> +
> +static inline ArrayObject* Class_getDeclaredConstructors(JavaObject*
> Cl, jboolean publicOnly) {
>

Please put this method as a static method of JavaObjectClass (I know, you
have to add it to the file in gnu classpath, as well as openjdk).

The reason I'm asking is because I just realized that you're using static
inline. Note that if it was static only, the GC would not work with it
(limitation in clang). Because you're putting inline, I guess that's the
reason why it did not fail, but that's very brittle. Please do the same for
all the other methods above. Thanks!


> +  ArrayObject* ret = 0;
> +  JavaObject* tmp = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(tmp, 0);
> +
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> +  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
> +    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
> +  } else {
> +    UserClass* realCl = cl->asClass();;
> +    JnjvmClassLoader* classLoader = cl->classLoader;
> +    uint32 size = 0;
> +
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> +          (!publicOnly || pub)) {
> +        ++size;
> +      }
> +    }
> +
> +    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size,
> vm);
> +
> +    sint32 index = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> +          (!publicOnly || pub)) {
> +        tmp = ClassLib_getConstructor(meth, i);
> +        ArrayObject::setElement(ret, tmp, index);
> +        index++;
> +      }
> +    }
> +  }
> +
> +  return ret;
> +}
> +
> +static inline ArrayObject* Class_getDeclaredMethods(JavaObject* Cl,
> jboolean publicOnly) {
> +  ArrayObject* ret = 0;
> +  JavaObject* tmp = 0;
> +  JavaString* str = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(tmp, 0);
> +  llvm_gcroot(str, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +  Classpath* upcalls = vm->upcalls;
> +
> +  if (cl->isArray() || cl->isPrimitive()) {
> +    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
> +  } else {
> +    UserClass* realCl = cl->asClass();
> +    JnjvmClassLoader* classLoader = cl->classLoader;
> +    uint32 size = 0;
> +
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> +         ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> +          !(meth->name->equals(classLoader->bootstrapLoader->clinitName))
> &&
> +          (!publicOnly || pub)) {
> +        ++size;
> +      }
> +    }
> +
> +
> +    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
> +
> +    sint32 index = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> +         ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> +          !(meth->name->equals(classLoader->bootstrapLoader->clinitName))
> &&
> +          (!publicOnly || pub)) {
> +        tmp = ClassLib_getMethod(meth, i);
> +        ArrayObject::setElement(ret, tmp, index);
> +        index++;
> +      }
> +    }
> +  }
> +
> +  return ret;
> +}
> +
> +static inline JavaObject* Class_getDeclaringClass(JavaObject * Cl) {
> +  JavaObject* res = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(res, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> +
> +  if (cl) {
> +    cl->resolveInnerOuterClasses();
> +    UserClass* outer = cl->getOuterClass();
> +    if (outer) {
> +      res = outer->getClassDelegatee(vm);
> +    }
> +  }
> +
> +  return res;
> +}
> +
> +static inline ArrayObject* Class_getDeclaredClasses(JavaObject* Cl,
> bool publicOnly) {
> +  ArrayObject* result = 0;
> +  llvm_gcroot(result, 0);
> +  llvm_gcroot(Cl, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> +  if (cl) {
> +    cl->resolveInnerOuterClasses();
> +    UserClassArray* array = vm->upcalls->constructorArrayClass;
> +
> +    uint16 sizeArray = 0;
> +
> +    if (publicOnly) {
> +      for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
> +        UserClass* klass = cl->innerClasses[i];
> +        if (isPublic(klass->innerAccess)) ++sizeArray;
> +      }
> +    } else {
> +      sizeArray = cl->nbInnerClasses;
> +    }
> +
> +    result = (ArrayObject*)array->doNew(sizeArray, vm);
> +    int index = 0;
> +    for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
> +      UserClass* klass = cl->innerClasses[i];
> +      if (!publicOnly || isPublic(klass->innerAccess))
> +        ArrayObject::setElement(result, klass->getClassDelegatee(vm),
> index++);
> +    }
> +    assert(index == sizeArray);
> +  }
> +
> +  return result;
> +}
> +
> +static inline ArrayObject* Class_getDeclaredFields(JavaObject* Cl,
> jboolean publicOnly) {
> +  ArrayObject* ret = 0;
> +  JavaObject* tmp = 0;
> +  JavaString* name = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(tmp, 0);
> +  llvm_gcroot(name, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> +  if (!cl->isClass()) {
> +    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
> +  } else {
> +    UserClass* realCl = cl->asClass();
> +    uint32 size = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> +         ++i) {
> +      JavaField* field = &realCl->virtualFields[i];
> +      if (!publicOnly || isPublic(field->access)) {
> +        ++size;
> +      }
> +    }
> +
> +    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
> +
> +    sint32 index = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> +         ++i) {
> +      JavaField* field = &realCl->virtualFields[i];
> +      if (!publicOnly || isPublic(field->access)) {
> +        tmp = ClassLib_getField(field, i);
> +        ArrayObject::setElement(ret, tmp, index);
> +        index++;
> +      }
> +    }
> +  }
> +
> +  return ret;
> +}
> +
> +static inline ArrayObject* Class_getInterfaces(JavaObject* Cl) {
> +  ArrayObject* res = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(res, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +  res =
> (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,
> vm);
> +
> +  for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
> +    UserClass* klass = cl->interfaces[i];
> +    ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
> +  }
> +
> +  return res;
> +}
> +
> +static inline ArrayObject* Class_getDeclaredAnnotations(JavaObject* Cl) {
> +  // TODO: Implement me (for now just returning empty array)
> +  ArrayObject* res = 0;
> +  llvm_gcroot(res, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
> +  res = (ArrayObject*)array->doNew(0, vm);
> +
> +  return res;
> +}
> +
> +static inline jint Class_getModifiers(JavaObject * Cl) {
> +  llvm_gcroot(Cl, 0);
> +  jint res;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +  res = cl->getAccess();
> +
> +  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
> +    // javac may put that flag to inner classes of enum classes.
> +    res &= ~ACC_ENUM;
> +  }
> +
> +  return res;
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> index 0c4d21c..47fd6b6 100644
> --- a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> @@ -21,6 +21,8 @@
>  #include "JavaUpcalls.h"
>  #include "Jnjvm.h"
>
> +#include "Class.inc"
> +
>  using namespace j3;
>
>  extern "C" {
> @@ -86,48 +88,12 @@ JavaObject* Cl,
>  jboolean publicOnly) {
>
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
>   llvm_gcroot(Cl, 0);
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> -  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
> -    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();;
> -    JnjvmClassLoader* classLoader = cl->classLoader;
> -    uint32 size = 0;
> -
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> -          (!publicOnly || pub)) {
> -        ++size;
> -      }
> -    }
> -
> -    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size,
> vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> -          (!publicOnly || pub)) {
> -        UserClass* Cons = vm->upcalls->newConstructor;
> -        tmp = Cons->doNew(vm);
> -        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp,
> &Cl, i);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = Class_getDeclaredConstructors(Cl, publicOnly);
>
>   END_NATIVE_EXCEPTION
>
> @@ -143,58 +109,12 @@ JavaObject* Cl,
>  jboolean publicOnly) {
>
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> -  JavaString* str = 0;
>   llvm_gcroot(Cl, 0);
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
> -  llvm_gcroot(str, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -  Classpath* upcalls = vm->upcalls;
> -
> -  if (cl->isArray() || cl->isPrimitive()) {
> -    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();
> -    JnjvmClassLoader* classLoader = cl->classLoader;
> -    uint32 size = 0;
> -
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> -         ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> -          !(meth->name->equals(classLoader->bootstrapLoader->clinitName))
> &&
> -          (!publicOnly || pub)) {
> -        ++size;
> -      }
> -    }
> -
> -
> -    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> -         ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> -          !(meth->name->equals(classLoader->bootstrapLoader->clinitName))
> &&
> -          (!publicOnly || pub)) {
> -        // TODO: check parameter types
> -        UserClass* Meth = vm->upcalls->newMethod;
> -        tmp = Meth->doNew(vm);
> -        str = vm->internalUTF8ToStr(meth->name);
> -        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, &Cl, &str,
> i);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = Class_getDeclaredMethods(Cl, publicOnly);
>
>   END_NATIVE_EXCEPTION
>
> @@ -214,14 +134,7 @@ jboolean ignore) {
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -  res = cl->getAccess();
> -
> -  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
> -    // javac may put that flag to inner classes of enum classes.
> -    res &= ~ACC_ENUM;
> -  }
> +  res = Class_getModifiers(Cl);
>
>   END_NATIVE_EXCEPTION
>   return res;
> @@ -428,49 +341,12 @@ jclass clazz,
>  JavaObject* Cl, jboolean publicOnly) {
>
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> -  JavaString* name = 0;
>   llvm_gcroot(Cl, 0);
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
> -  llvm_gcroot(name, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> -  if (!cl->isClass()) {
> -    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();
> -    uint32 size = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> -         ++i) {
> -      JavaField* field = &realCl->virtualFields[i];
> -      if (!publicOnly || isPublic(field->access)) {
> -        ++size;
> -      }
> -    }
> -
> -
> -    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> -         ++i) {
> -      JavaField* field = &realCl->virtualFields[i];
> -      if (!publicOnly || isPublic(field->access)) {
> -        // TODO: check parameter types
> -        UserClass* Field = vm->upcalls->newField;
> -        tmp = Field->doNew(vm);
> -        name = vm->internalUTF8ToStr(field->name);
> -        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, &Cl,
> &name, i);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = Class_getDeclaredFields(Cl, publicOnly);
>
>   END_NATIVE_EXCEPTION
>
> @@ -490,14 +366,7 @@ JavaObject* Cl) {
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -  res =
> (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,
> vm);
> -
> -  for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
> -    UserClass* klass = cl->interfaces[i];
> -    ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
> -  }
> +  res = Class_getInterfaces(Cl);
>
>   END_NATIVE_EXCEPTION
>
> @@ -518,16 +387,7 @@ JavaObject* Cl) {
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> -
> -  if (cl) {
> -    cl->resolveInnerOuterClasses();
> -    UserClass* outer = cl->getOuterClass();
> -    if (outer) {
> -      res = outer->getClassDelegatee(vm);
> -    }
> -  }
> +  res = Class_getDeclaringClass(Cl);
>
>   END_NATIVE_EXCEPTION
>
> @@ -548,33 +408,7 @@ JavaObject* Cl, bool publicOnly) {
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> -  if (cl) {
> -    cl->resolveInnerOuterClasses();
> -    UserClassArray* array = vm->upcalls->constructorArrayClass;
> -
> -    uint16 sizeArray = 0;
> -
> -    if (publicOnly) {
> -      for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
> -        UserClass* klass = cl->innerClasses[i];
> -        if (isPublic(klass->innerAccess)) ++sizeArray;
> -      }
> -    } else {
> -      sizeArray = cl->nbInnerClasses;
> -    }
> -
> -    result = (ArrayObject*)array->doNew(sizeArray, vm);
> -    int index = 0;
> -    for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
> -      UserClass* klass = cl->innerClasses[i];
> -      if (!publicOnly || isPublic(klass->innerAccess))
> -        ArrayObject::setElement(result, klass->getClassDelegatee(vm),
> index++);
> -    }
> -    assert(index == sizeArray);
> -  }
> -
> +  result = Class_getDeclaredClasses(Cl, publicOnly);
>
>   END_NATIVE_EXCEPTION
>
> @@ -603,16 +437,14 @@ jclass clazz,
>  #endif
>  JavaObject* Cl) {
>   // TODO implement me
> -
> +
>   ArrayObject* res = 0;
>   llvm_gcroot(res, 0);
>   llvm_gcroot(Cl, 0);
> -
> +
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
> -  res = (ArrayObject*)array->doNew(0, vm);
> +  res = Class_getDeclaredAnnotations(Cl);
>
>   END_NATIVE_EXCEPTION
>
> @@ -641,5 +473,52 @@ JavaObject* Cl) {
>   return res;
>  }
>
> +JavaObject* ClassLib_getConstructor(JavaMethod * cons, int i) {
> +  JavaObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* Cons = vm->upcalls->newConstructor;
> +  ret = Cons->doNew(vm);
> +  JavaObject* const* Cl = cons->classDef->getDelegateePtr();
> +  vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
> +    Cl, i);
> +
> +  return ret;
> +}
> +
> +JavaObject* ClassLib_getMethod(JavaMethod* meth, int i) {
> +  JavaObject* ret = 0;
> +  JavaString* str = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(str, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* Meth = vm->upcalls->newMethod;
> +  ret = Meth->doNew(vm);
> +  str = vm->internalUTF8ToStr(meth->name);
> +  JavaObject* const* Cl = meth->classDef->getDelegateePtr();
> +  vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
> +    Cl, &str, i);
> +
> +  return ret;
> +}
> +
> +JavaObject* ClassLib_getField(JavaField* field, int i) {
> +  JavaObject* ret = 0;
> +  JavaString* name = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(name, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* Field = vm->upcalls->newField;
> +  ret = Field->doNew(vm);
> +  name = vm->internalUTF8ToStr(field->name);
> +  JavaObject* const* Cl = field->classDef->getDelegateePtr();
> +  vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
> +    Cl, &name, i);
> +
> +  return ret;
> +}
>
>  }
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 012b021..4f25fb0 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -12,6 +12,7 @@
>  #include "Reader.h"
>
>  #include "ArrayCopy.inc"
> +#include "Class.inc"
>  #include "ClassContext.inc"
>  #include "SetProperties.inc"
>  #include "Object.inc"
> @@ -1038,7 +1039,18 @@ JVM_GetClassName(JNIEnv *env, jclass cls) {
>
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassInterfaces(JNIEnv *env, jclass cls) {
> -  NYI();
> +  ArrayObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  ret = Class_getInterfaces(*(JavaObject**)cls);
> +
> +  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jobject JNICALL
> @@ -1184,17 +1196,7 @@ JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
>
>   Cl = *(JavaObject**)cls;
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();;
> -
> -  jint res = cl->getAccess();
> -
> -  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
> -    // javac may put that flag to inner classes of enum classes.
> -    res &= ~ACC_ENUM;
> -  }
> -
> -  RETURN_FROM_JNI(res);
> +  RETURN_FROM_JNI(Class_getModifiers(Cl));
>
>   END_JNI_EXCEPTION
>
> @@ -1203,12 +1205,35 @@ JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
>
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass) {
> -  NYI();
> +  ArrayObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  // TODO: Verify boolean parameter here, assuming should default to true.
> +  ret = Class_getDeclaredClasses(*(JavaObject**)ofClass, false);
> +
> +  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jclass JNICALL
>  JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass) {
> -  NYI();
> +  JavaObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  ret = Class_getDeclaringClass(*(JavaObject**)ofClass);
> +
> +  RETURN_FROM_JNI((jclass)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /* Generics support (JDK 1.5) */
> @@ -1220,84 +1245,144 @@ JVM_GetClassSignature(JNIEnv *env, jclass cls) {
>  /* Annotations support (JDK 1.5) */
>  JNIEXPORT jbyteArray JNICALL
>  JVM_GetClassAnnotations(JNIEnv *env, jclass cls) {
> -  NYI();
> +  ArrayObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  ret = Class_getDeclaredAnnotations(*(JavaObject**)cls);
> +
> +  RETURN_FROM_JNI((jbyteArray)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /*
>  * New (JDK 1.4) reflection implementation
>  */
> +JavaObject* ClassLib_getConstructor(JavaMethod * cons, int i) {
> +  JavaObject* ret = 0;
> +  JavaObject* pArr = 0;
> +  JavaObject* eArr = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(pArr, 0);
> +  llvm_gcroot(eArr, 0);
>
> -JNIEXPORT jobjectArray JNICALL
> -JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean
> publicOnly) {
> -  ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JnjvmClassLoader * classLoader = cons->classDef->classLoader;
> +
> +  UserClass* Cons = vm->upcalls->newConstructor;
> +  pArr = cons->getParameterTypes(classLoader);
> +  eArr = cons->getExceptionTypes(classLoader);
> +  ret = Cons->doNew(vm);
> +  JavaObject* const* Cl = cons->classDef->getDelegateePtr();
> +  vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
> +    Cl,           /* declaringClass */
> +    &pArr,        /* parameterTypes */
> +    &eArr,        /* checkedExceptions */
> +    cons->access, /* modifiers */
> +    i,            /* slot */
> +    NULL,         /* String signature */
> +    NULL,         /* annotations */
> +    NULL          /* parameterAnnotations */
> +  );
> +
> +  return ret;
> +}
> +
> +JavaObject* ClassLib_getMethod(JavaMethod* meth, int i) {
> +  JavaObject* ret = 0;
>   JavaString* str = 0;
> -  JavaObject * Cl = 0;
> -  llvm_gcroot(Cl, 0);
> +  JavaObject* pArr = 0;
> +  JavaObject* eArr = 0;
> +  JavaObject* retTy = 0;
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
>   llvm_gcroot(str, 0);
> +  llvm_gcroot(pArr, 0);
> +  llvm_gcroot(eArr, 0);
> +  llvm_gcroot(retTy, 0);
>
> -  BEGIN_JNI_EXCEPTION
> -
> -  Cl = *(JavaObject**)ofClass;
> +  // TODO: check parameter types
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JnjvmClassLoader * classLoader = meth->classDef->classLoader;
> +
> +  UserClass* Meth = vm->upcalls->newMethod;
> +  ret = Meth->doNew(vm);
> +  str = vm->internalUTF8ToStr(meth->name);
> +  pArr = meth->getParameterTypes(classLoader);
> +  eArr = meth->getExceptionTypes(classLoader);
> +  retTy = meth->getReturnType(classLoader);
> +  JavaObject* const* Cl = meth->classDef->getClassDelegateePtr(vm);
> +  vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
> +    Cl,           /* declaring class */
> +    &str,         /* name */
> +    &pArr,        /* parameter types */
> +    &retTy,       /* return type */
> +    &eArr,        /* exceptions */
> +    meth->access, /* modifiers */
> +    i,            /* slot */
> +    NULL,         /* signature */
> +    NULL,         /* annotations */
> +    NULL,         /* parameter annotations */
> +    NULL);        /* default annotations */
> +
> +  return ret;
> +}
> +
> +JavaObject* ClassLib_getField(JavaField* field, int i) {
> +  JavaObject* ret = 0;
> +  JavaString* name = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(name, 0);
>
> +  // TODO: check parameter types
>   Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -  Classpath* upcalls = vm->upcalls;
> +  UserClass* Field = vm->upcalls->newField;
> +  ret = Field->doNew(vm);
> +  name = vm->internalUTF8ToStr(field->name);
> +
> +  //type->Class
> +  JnjvmClassLoader* loader = field->classDef->classLoader;
> +  UserCommonClass * fieldCl = field->getSignature()->assocClass(loader);
> +  assert(fieldCl);
> +  JavaObject* const* type = fieldCl->getClassDelegateePtr(vm);
> +  JavaObject* const* Cl = field->classDef->getClassDelegateePtr(vm);
> +
> +  // TODO:Implement these!
> +  JavaObject** sign = NULL;
> +  JavaObject** annArray = NULL;
> +
> +  /* java.reflect.Field(
> +  *   Class declaringClass,
> +  *   String name,
> +  *   Class type,
> +  *   int modifiers,
> +  *   int slot,
> +  *   String signature,
> +  *   byte[] annotations)
> +  */
> +  vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
> +    Cl,
> +    &name,
> +    type,
> +    field->access,
> +    i,
> +    sign,
> +    annArray);
> +
> +  return ret;
> +}
>
> -  if (cl->isArray() || cl->isPrimitive()) {
> -    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();
> -    JnjvmClassLoader* classLoader = cl->classLoader;
> -    uint32 size = 0;
> -
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> -         ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> -          (!publicOnly || pub)) {
> -        ++size;
> -      }
> -    }
> +JNIEXPORT jobjectArray JNICALL
> +JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean
> publicOnly) {
> +  ArrayObject* ret = 0;
> +  llvm_gcroot(ret, 0);
>
> +  BEGIN_JNI_EXCEPTION
>
> -    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> -         ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> -          (!publicOnly || pub)) {
> -        // TODO: check parameter types
> -        UserClass* Meth = vm->upcalls->newMethod;
> -        tmp = Meth->doNew(vm);
> -        str = vm->internalUTF8ToStr(meth->name);
> -        JavaObject * pArr = meth->getParameterTypes(classLoader);
> -        JavaObject * eArr = meth->getExceptionTypes(classLoader);
> -        JavaObject * retTy = meth->getReturnType(classLoader);
> -        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp,
> -          &Cl,          /* declaring class */
> -          &str,         /* name */
> -          &pArr,        /* parameter types */
> -          &retTy,       /* return type */
> -          &eArr,        /* exceptions */
> -          meth->access, /* modifiers */
> -          i,            /* slot */
> -          NULL,         /* signature */
> -          NULL,         /* annotations */
> -          NULL,         /* parameter annotations */
> -          NULL,         /* default annotations */
> -          i);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = Class_getDeclaredMethods(*(JavaObject**)ofClass, publicOnly);
>
>   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
>
> @@ -1309,85 +1394,12 @@ JVM_GetClassDeclaredMethods(JNIEnv *env,
> jclass ofClass, jboolean publicOnly) {
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean
> publicOnly) {
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> -  JavaString* name = 0;
> -  JavaObject*const*  type = 0;
> -  JavaString* sign = 0;
> -  JavaObject* annArray = 0;
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
> -  llvm_gcroot(name, 0);
> -  llvm_gcroot(type, 0);
> -  llvm_gcroot(sign, 0);
> -  llvm_gcroot(annArray, 0);
>
>   BEGIN_JNI_EXCEPTION
>
> -  JavaObject * Cl = *(JavaObject**)ofClass;
> -  llvm_gcroot(Cl, 0);
> +  ret = Class_getDeclaredFields(*(JavaObject**)ofClass, publicOnly);
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> -  if (!cl->isClass()) {
> -    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();
> -    uint32 size = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> -         ++i) {
> -      JavaField* field = &realCl->virtualFields[i];
> -      if (!publicOnly || isPublic(field->access)) {
> -        ++size;
> -      }
> -    }
> -
> -
> -    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> -         ++i) {
> -      JavaField* field = &realCl->virtualFields[i];
> -      if (!publicOnly || isPublic(field->access)) {
> -        // TODO: check parameter types
> -        UserClass* Field = vm->upcalls->newField;
> -        tmp = Field->doNew(vm);
> -        name = vm->internalUTF8ToStr(field->name);
> -
> -        //type->Class
> -        UserCommonClass * fieldCl =
> field->getSignature()->assocClass(cl->classLoader);
> -        assert(fieldCl);
> -        type = fieldCl->getClassDelegateePtr(vm);
> -
> -        // TODO:Implement these!
> -        sign = NULL;
> -        annArray = NULL;
> -
> -        //Convert to string
> -
> -        /* java.reflect.Field(
> -         *   Class declaringClass,
> -         *   String name,
> -         *   Class type,
> -         *   int modifiers,
> -         *   int slot,
> -         *   String signature,
> -         *   byte[] annotations)
> -         */
> -        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp,
> -          &Cl,
> -          &name,
> -          type,
> -          field->access,
> -          i,
> -          sign,
> -          annArray);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
>   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
>
>   END_JNI_EXCEPTION
> @@ -1398,62 +1410,11 @@ JVM_GetClassDeclaredFields(JNIEnv *env, jclass
> ofClass, jboolean publicOnly) {
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass,
> jboolean publicOnly) {
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> -  JavaObject* Cl = 0;
> -  llvm_gcroot(Cl, 0);
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
>
>   BEGIN_JNI_EXCEPTION
>
> -  Cl = *(JavaObject**)ofClass;
> -
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> -  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
> -    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();;
> -    JnjvmClassLoader* classLoader = cl->classLoader;
> -    uint32 size = 0;
> -
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> -          (!publicOnly || pub)) {
> -        ++size;
> -      }
> -    }
> -
> -    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size,
> vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> -          (!publicOnly || pub)) {
> -        UserClass* Cons = vm->upcalls->newConstructor;
> -        JavaObject * pArr = meth->getParameterTypes(classLoader);
> -        JavaObject * eArr = meth->getExceptionTypes(classLoader);
> -        tmp = Cons->doNew(vm);
> -        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp,
> -          &Cl,          /* declaringClass */
> -          &pArr,        /* parameterTypes */
> -          &eArr,        /* checkedExceptions */
> -          meth->access, /* modifiers */
> -          i,            /* slot */
> -          NULL,         /* String signature */
> -          NULL,         /* annotations */
> -          NULL          /* parameterAnnotations */
> -        );
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = Class_getDeclaredConstructors(*(JavaObject**)ofClass, publicOnly);
>
>   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
>
> --
> 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/20111108/0196b6dc/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 12:41:49 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 21:41:49 +0100
Subject: [vmkit-commits] [PATCH] Don't try to emit methods from
 primitive classes' VT, they're bogus.
In-Reply-To: <CAKGWAO-6a-wJ4HoK5oor1i8hKVS-xU9U0BwXKUVWRJnxPPsF3g@mail.gmail.com>
References: <CAKGWAO-6a-wJ4HoK5oor1i8hKVS-xU9U0BwXKUVWRJnxPPsF3g@mail.gmail.com>
Message-ID: <CAPYwfiq6uiuUrEJ6_kWGve==2eTcc4asOHW=CDw7mUUpp84DuQ@mail.gmail.com>

That's ok to apply. Indeed it does look strange, do you have an error
message?

In any case, the fact that primitive classes have a VT should disappear. I
haven't gone to doing that cleanup yet.

On Mon, Nov 7, 2011 at 4:04 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> I honestly don't know why this didn't cause problems before, since we
> explicitly attempt to emit the VT for primitive classes (while
> precompiling) in a few places.  However, this is needed for the "emit
> null for j.l.Class" patch to work, which was a bit unexpected :).
>
> Thanks!
>
> ~Will
>
> >From 8a795a7a5f6c69ef97407ef9582d8b8a524ba456 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sun, 6 Nov 2011 20:16:44 -0600
> Subject: [PATCH 8/8] Don't try to emit methods from primitive classes' VT,
>  they're bogus.
>
> ---
>  lib/J3/Compiler/JavaAOTCompiler.cpp |    5 ++++-
>  1 files changed, 4 insertions(+), 1 deletions(-)
>
> diff --git a/lib/J3/Compiler/JavaAOTCompiler.cpp
> b/lib/J3/Compiler/JavaAOTCompiler.cpp
> index 2ae8973..c4dc364 100644
> --- a/lib/J3/Compiler/JavaAOTCompiler.cpp
> +++ b/lib/J3/Compiler/JavaAOTCompiler.cpp
> @@ -1775,7 +1775,10 @@ Constant*
> JavaAOTCompiler::CreateConstantFromVT(JavaVirtualTable* VT) {
>   // methods
>   for (uint32 i = JavaVirtualTable::getFirstJavaMethodIndex(); i < size;
> ++i) {
>     JavaMethod* meth = ((JavaMethod**)RealVT)[i];
> -    if (isAbstract(meth->access)) {
> +    // Primitive classes don't have methods--abstract or otherwise.
> +    // (But we do have placeholders for j.l.Object methods in their VTs,
> +    // so just emit NULL's here)
> +    if (isAbstract(meth->access) || classDef->isPrimitive()) {
>       Elemts.push_back(Constant::getNullValue(PTy));
>     } else {
>       Function* F = getMethodOrStub(meth, maybeCustomize);
> --
> 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/20111108/67c84d6c/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 12:45:01 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 21:45:01 +0100
Subject: [vmkit-commits] [vmkit] r143957 - in /vmkit/trunk: ./
 lib/J3/ClassLib/ lib/J3/ClassLib/GNUClasspath/ lib/J3/VMCore/JavaClass.cpp
 lib/J3/VMCore/JavaObject.cpp lib/Mvm/CommonThread/ObjectLocks.cpp
 lib/Mvm/CommonThread/ctlock.cpp lib/Mvm/Compiler/JI
In-Reply-To: <CAKGWAO-+uzOhi3ZLLHFn9RBmVeJxtSOzhMKZvHVBP+4R224HPA@mail.gmail.com>
References: <CAKGWAO-+uzOhi3ZLLHFn9RBmVeJxtSOzhMKZvHVBP+4R224HPA@mail.gmail.com>
Message-ID: <CAPYwfipxow3fRWpgF_M3_UZhqb_HAhDFmDvajpHO7tJiiuPnsg@mail.gmail.com>

On Mon, Nov 7, 2011 at 8:34 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> On Mon, Nov 7, 2011 at 5:16 AM, Gael Thomas <gael.thomas at lip6.fr> wrote:
> > Author: gthomas
> > Date: Mon Nov  7 05:16:04 2011
> > New Revision: 143957
> >
> > URL: http://llvm.org/viewvc/llvm-project?rev=143957&view=rev
> > Log:
> > avoid warnings, LLVM_HOSTTRIPLE is now LLVM_DEFAULT_TARGET_TRIPLE
> >
> > Modified:
> >    vmkit/trunk/   (props changed)
> >    vmkit/trunk/lib/J3/ClassLib/   (props changed)
> >    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/   (props changed)
> >    vmkit/trunk/lib/J3/VMCore/JavaClass.cpp
> >    vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
> >    vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp
> >    vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
> >    vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
> >    vmkit/trunk/lib/Mvm/MMTk/   (props changed)
> >    vmkit/trunk/mmtk/inline/   (props changed)
> >    vmkit/trunk/mmtk/java/   (props changed)
> >    vmkit/trunk/mmtk/mmtk-alloc/   (props changed)
> >    vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp
> >    vmkit/trunk/tools/   (props changed)
> >
> > Propchange: vmkit/trunk/
> >
> ------------------------------------------------------------------------------
> > --- svn:ignore (original)
> > +++ svn:ignore Mon Nov  7 05:16:04 2011
> > @@ -1,5 +1,6 @@
> >  do-find
> >  Makefile.config
> > +Makefile.llvmbuild
> >  replace.sh
> >  config.log
> >  *.tmp
> >
> > Propchange: vmkit/trunk/lib/J3/ClassLib/
> >
> ------------------------------------------------------------------------------
> > --- svn:ignore (added)
> > +++ svn:ignore Mon Nov  7 05:16:04 2011
> > @@ -0,0 +1 @@
> > +Classpath.h
> >
> > Propchange: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/
> >
> ------------------------------------------------------------------------------
> > --- svn:ignore (added)
> > +++ svn:ignore Mon Nov  7 05:16:04 2011
> > @@ -0,0 +1 @@
> > +Release
> >
> > Modified: vmkit/trunk/lib/J3/VMCore/JavaClass.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaClass.cpp?rev=143957&r1=143956&r2=143957&view=diff
> >
> ==============================================================================
> > --- vmkit/trunk/lib/J3/VMCore/JavaClass.cpp (original)
> > +++ vmkit/trunk/lib/J3/VMCore/JavaClass.cpp Mon Nov  7 05:16:04 2011
> > @@ -877,7 +877,8 @@
> >   PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n",
> mvm::PrintBuffer(this).cString());
> >
> >   Reader reader(bytes);
> > -  uint32 magic = reader.readU4();
> > +  uint32 magic;
> > +  magic = reader.readU4();
> >   assert(magic == Jnjvm::Magic && "I've created a class but magic is no
> good!");
> >
> >   /* uint16 minor = */ reader.readU2();
> >
> > Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.cpp?rev=143957&r1=143956&r2=143957&view=diff
> >
> ==============================================================================
> > --- vmkit/trunk/lib/J3/VMCore/JavaObject.cpp (original)
> > +++ vmkit/trunk/lib/J3/VMCore/JavaObject.cpp Mon Nov  7 05:16:04 2011
> > @@ -34,7 +34,8 @@
> >   assert(mvm::HashBits != 0);
> >
> >   word_t header = self->header;
> > -  word_t GCBits = header & mvm::GCBitMask;
> > +  word_t GCBits;
> > +  GCBits = header & mvm::GCBitMask;
> >   word_t val = header & HashMask;
> >   if (val != 0) {
> >     return val ^ (word_t)getClass(self);
> >
> > Modified: vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp?rev=143957&r1=143956&r2=143957&view=diff
> >
> ==============================================================================
> > --- vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp (original)
> > +++ vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp Mon Nov  7 05:16:04
> 2011
> > @@ -45,10 +45,12 @@
> >  void ThinLock::removeFatLock(FatLock* fatLock, LockSystem& table) {
> >   gc* object = fatLock->associatedObject;
> >   llvm_gcroot(object, 0);
> > -  word_t ID = fatLock->getID();
> > +  word_t ID;
> >   word_t oldValue = 0;
> >   word_t newValue = 0;
> >   word_t yieldedValue = 0;
> > +
> > +  ID = fatLock->getID();
> >   do {
> >     oldValue = object->header;
> >     newValue = oldValue & NonLockBitsMask;
> >
> > Modified: vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp?rev=143957&r1=143956&r2=143957&view=diff
> >
> ==============================================================================
> > --- vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp (original)
> > +++ vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp Mon Nov  7 05:16:04 2011
> > @@ -130,7 +130,8 @@
> >  }
> >
> >  Cond::Cond() {
> > -  int errorcode = pthread_cond_init((pthread_cond_t*)&internalCond,
> NULL);
> > +  int errorcode;
> > +  errorcode = pthread_cond_init((pthread_cond_t*)&internalCond, NULL);
> >   assert(errorcode == 0);
> >  }
> >
> > @@ -145,11 +146,11 @@
> >  void Cond::wait(Lock* l) {
> >   assert(l->selfOwner());
> >   int n = l->unsafeUnlock();
> > -
> > +  int res;
> >   Thread* th = Thread::get();
> >   th->enterUncooperativeCode();
> > -  int res = pthread_cond_wait((pthread_cond_t*)&internalCond,
> > -                              (pthread_mutex_t*)&(l->internalLock));
> > +  res = pthread_cond_wait((pthread_cond_t*)&internalCond,
> > +
>                                 (pthread_mutex_t*)&(l->internalLock));
> >   th->leaveUncooperativeCode();
> >
> >   assert(!res && "Error on wait");
> >
> > Modified: vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/JIT.cpp?rev=143957&r1=143956&r2=143957&view=diff
> >
> ==============================================================================
> > --- vmkit/trunk/lib/Mvm/Compiler/JIT.cpp (original)
> > +++ vmkit/trunk/lib/Mvm/Compiler/JIT.cpp Mon Nov  7 05:16:04 2011
> > @@ -60,7 +60,11 @@
> >  }
> >
> >  const char* MvmModule::getHostTriple() {
> > -  return LLVM_HOSTTRIPLE;
> > +#ifdef LLVM_HOSTTRIPLE
> > +  return LLVM_HOSTTRIPLE
>
> But I needed that semicolon! :)
>

Yeah, thanks for putting it back Will :)


>
> Just wondering, what compiler are you using that's causing the
> warnings fixed in this commit?
>

This is due to a change in llvm that removes LLVM_HOSTTRIPLE. See:
http://llvm.org/viewvc/llvm-project?view=rev&revision=143501


>
> > +#else
> > +  return LLVM_DEFAULT_TARGET_TRIPLE;
> > +#endif
> >  }
> >
> >  cl::opt<bool>
> > @@ -416,7 +420,8 @@
> >     FrameIterator iterator(*frames);
> >     while (iterator.hasNext()) {
> >       FrameInfo* frame = iterator.next();
> > -      FrameInfo* other = VM->IPToFrameInfo(frame->ReturnAddress);
> > +      FrameInfo* other;
> > +      other = VM->IPToFrameInfo(frame->ReturnAddress);
> >       assert(frame->ReturnAddress == other->ReturnAddress);
> >     }
> >   }
> >
> > Propchange: vmkit/trunk/lib/Mvm/MMTk/
> >
> ------------------------------------------------------------------------------
> > --- svn:ignore (original)
> > +++ svn:ignore Mon Nov  7 05:16:04 2011
> > @@ -1 +1,3 @@
> >  Release+Asserts
> > +Release
> > +
> >
> > Propchange: vmkit/trunk/mmtk/inline/
> >
> ------------------------------------------------------------------------------
> > --- svn:ignore (original)
> > +++ svn:ignore Mon Nov  7 05:16:04 2011
> > @@ -1,2 +1,3 @@
> >  Release+Asserts
> > +Release
> >  *.inc
> >
> > Propchange: vmkit/trunk/mmtk/java/
> >
> ------------------------------------------------------------------------------
> > --- svn:ignore (original)
> > +++ svn:ignore Mon Nov  7 05:16:04 2011
> > @@ -1,5 +1,6 @@
> >  build.xml
> >  Release+Asserts
> > +Release
> >  mmtk-vmkit.bc
> >  mmtk-vmkit-optimized.bc
> >  mmtk-vmkit.jar
> >
> > Propchange: vmkit/trunk/mmtk/mmtk-alloc/
> >
> ------------------------------------------------------------------------------
> > --- svn:ignore (original)
> > +++ svn:ignore Mon Nov  7 05:16:04 2011
> > @@ -1 +1,3 @@
> >  Release+Asserts
> > +Release
> > +
> >
> > Modified: vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp?rev=143957&r1=143956&r2=143957&view=diff
> >
> ==============================================================================
> > --- vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp (original)
> > +++ vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp Mon Nov  7 05:16:04 2011
> > @@ -22,7 +22,8 @@
> >   int64_t result;
> >   struct timeval tp;
> >
> > -  int res = gettimeofday (&tp, NULL);
> > +  int res;
> > +       res = gettimeofday (&tp, NULL);
> >   assert(res != -1 && "failed gettimeofday.");
> >
> >   result = (int64_t) tp.tv_sec;
> >
> > Propchange: vmkit/trunk/tools/
> >
> ------------------------------------------------------------------------------
> > --- svn:ignore (added)
> > +++ svn:ignore Mon Nov  7 05:16:04 2011
> > @@ -0,0 +1 @@
> > +llvm-config-2
> >
> >
> > _______________________________________________
> > vmkit-commits mailing list
> > vmkit-commits at cs.uiuc.edu
> > http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
> >
>
> _______________________________________________
> 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/20111108/215a8167/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 12:51:28 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 21:51:28 +0100
Subject: [vmkit-commits] [PATCH] Fix LSHL to mask the shift operand.
In-Reply-To: <CAKGWAO8=2g=8XqXdFGs78Q58oC8OLZiNPfiHTzwfdXw9w_EPMA@mail.gmail.com>
References: <CAKGWAO9ME+PwJ+o_HZaVGfirf-TdnO0msVtpdP2e0KZ2chsZWA@mail.gmail.com>
	<CAKGWAO8=2g=8XqXdFGs78Q58oC8OLZiNPfiHTzwfdXw9w_EPMA@mail.gmail.com>
Message-ID: <CAPYwfirz7V+RMz-bQwmD8f4KNpLXybvb+X59N1FNSpKb+EZp8Q@mail.gmail.com>

Nice! Please apply.

On Mon, Nov 7, 2011 at 9:14 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> The masking logic is already used in LUSHR, FWIW.
>
> ~Will
>
> >From 029662fa7bd23532d8a5be59793efab715217356 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sun, 6 Nov 2011 23:26:17 -0600
> Subject: [PATCH] Fix LSHL to mask the shift operand.
>
> Simple test case illustrating failure:
>
> class Test {
>    public static void main(String[] args) {
>      long l = 1;
>      System.out.println(l);
>      System.out.println(l << 10);
>      System.out.println(l << 32);
>      System.out.println(l << 64);
>      System.out.println(l << 128);
>      System.out.println(l << -10);
>    }
> }
>

Could you add this test to the tests/ directory? Just do simple comparisons
between what is expected and what you get. If they don't match, throw an
exception.


> Should produce (java Hotspot 1.6.0_27)
> 1
> 1024
> 4294967296
> 1
> 1
> 18014398509481984
>
> Before this patch j3 produces:
> 1
> 1024
> 4294967296
> 4294967296
> 4294967296
> 4294967296
>
> This patch aligns j3 with java's behavior.
> Additionally, this causes j3 to pass Mauve's Long tests.
>

Very nice!


> ---
>  lib/J3/Compiler/JavaJITOpcodes.cpp |    2 ++
>  1 files changed, 2 insertions(+), 0 deletions(-)
>
> diff --git a/lib/J3/Compiler/JavaJITOpcodes.cpp
> b/lib/J3/Compiler/JavaJITOpcodes.cpp
> index 4c5e8cd..93b9c3c 100644
> --- a/lib/J3/Compiler/JavaJITOpcodes.cpp
> +++ b/lib/J3/Compiler/JavaJITOpcodes.cpp
> @@ -1185,6 +1185,8 @@ void JavaJIT::compileOpcodes(Reader& reader,
> uint32 codeLength) {
>
>       case LSHL : {
>         Value* val2 = new ZExtInst(pop(),
> Type::getInt64Ty(*llvmContext), "", currentBlock);
> +        Value* mask = ConstantInt::get(Type::getInt64Ty(*llvmContext),
> 0x3F);
> +        val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock);
>         pop(); // remove the 0 on the stack
>         Value* val1 = pop();
>         push(BinaryOperator::CreateShl(val1, val2, "", currentBlock),
> --
> 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/20111108/8deb4717/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 12:52:09 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 21:52:09 +0100
Subject: [vmkit-commits] [PATCH] Fix LSHR by masking the shift operand.
In-Reply-To: <CAKGWAO8-0ijaQ7OdO9RW9oKg2zKN_3kyzmNpCaSFun7QdtsdKw@mail.gmail.com>
References: <CAKGWAO8-0ijaQ7OdO9RW9oKg2zKN_3kyzmNpCaSFun7QdtsdKw@mail.gmail.com>
Message-ID: <CAPYwfiqzhQxB7JNb3+itdZvOZqb=BDNjP2jijjBRhezx=gfpKA@mail.gmail.com>

Please apply, with same comment of adding the test to the tests/ directory.
Thanks!

On Mon, Nov 7, 2011 at 9:16 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Same thing as previous LSHL patch, only for LSHR.
>
> ~Will
>
> >From fc51294c2ddb78189092fd87ed4950ecdb6f43c0 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Mon, 7 Nov 2011 13:56:25 -0600
> Subject: [PATCH] Fix LSHR by masking the shift operand.
>
> Sample test case:
>
> class Test {
>    public static void main(String[] args) {
>      long l = 1;
>      System.out.println(l);
>      System.out.println(l >> 10);
>      System.out.println(l >> 32);
>      System.out.println(l >> 64);
>      System.out.println(l >> 128);
>      System.out.println(l >> -10);
>    }
> }
>
> java produces (Hotspot 1.6.0_27):
> 1
> 0
> 0
> 1
> 1
> 0
>
> j3 before this patch produces:
> 1
> 0
> 0
> 0
> 0
> 0
> ---
>  lib/J3/Compiler/JavaJITOpcodes.cpp |    2 ++
>  1 files changed, 2 insertions(+), 0 deletions(-)
>
> diff --git a/lib/J3/Compiler/JavaJITOpcodes.cpp
> b/lib/J3/Compiler/JavaJITOpcodes.cpp
> index 93b9c3c..682e406 100644
> --- a/lib/J3/Compiler/JavaJITOpcodes.cpp
> +++ b/lib/J3/Compiler/JavaJITOpcodes.cpp
> @@ -1207,6 +1207,8 @@ void JavaJIT::compileOpcodes(Reader& reader,
> uint32 codeLength) {
>
>       case LSHR : {
>         Value* val2 = new ZExtInst(pop(),
> Type::getInt64Ty(*llvmContext), "", currentBlock);
> +        Value* mask = ConstantInt::get(Type::getInt64Ty(*llvmContext),
> 0x3F);
> +        val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock);
>         pop(); // remove the 0 on the stack
>         Value* val1 = pop();
>         push(BinaryOperator::CreateAShr(val1, val2, "", currentBlock),
> --
> 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/20111108/07cae55c/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 12:52:54 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 21:52:54 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_InvokeMethod,
 use existing proceedMethod from Classpath
In-Reply-To: <CAKGWAO_fbagmwMsx6uWBZgaUc2UJ9pFEX_msiAAovp7BAH_3Gg@mail.gmail.com>
References: <CAKGWAO_fbagmwMsx6uWBZgaUc2UJ9pFEX_msiAAovp7BAH_3Gg@mail.gmail.com>
Message-ID: <CAPYwfip3dTnj_RsdoM60q3n4F39tLj3qxCj7JK3H8hgq-O0JdQ@mail.gmail.com>

Looks good!

On Mon, Nov 7, 2011 at 9:25 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> >From 4dee86c7d7a61ef8b6e2cd911126ee5b72e517c4 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sun, 6 Nov 2011 22:04:20 -0600
> Subject: [PATCH 1/3] Impl JVM_InvokeMethod, use existing proceedMethod from
>  Classpath
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   25 +++++++++++++++++++++++--
>  1 files changed, 23 insertions(+), 2 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 92c646d..e625a9f 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -1515,8 +1515,29 @@ JVM_GetClassAccessFlags(JNIEnv *env, jclass cls) {
>  * java.lang.reflect.Method
>  */
>  JNIEXPORT jobject JNICALL
> -JVM_InvokeMethod(JNIEnv *env, jobject method, jobject _obj,
> jobjectArray args0) {
> -  NYI();
> +JVM_InvokeMethod(JNIEnv *env, jobject _m, jobject _obj, jobjectArray
> args0) {
> +  JavaObject * ret = 0;
> +  JavaObjectMethod * m = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(m, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +
> +  m = *(JavaObjectMethod**)_m;
> +
> +  ret = proceedMethod(
> +    m,
> +    _obj ? *(JavaObject**)_obj : 0,
> +    args0? *(ArrayObject**)args0 : 0,
> +    JavaObjectMethod::getClass(m)->getDelegatee(),
> +    0 /* unused */ );
> +
> +  RETURN_FROM_JNI((jobject)th->pushJNIRef(ret));
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /*
> --
> 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/20111108/eed0f7dc/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 12:53:19 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 21:53:19 +0100
Subject: [vmkit-commits] [PATCH] Don't abort on JVM_SetClassSigners,
 let it proceed.
In-Reply-To: <CAKGWAO_JXgAuJax6z_HUWeZeYuGErEk6-Qp1ng7HS=Yhx+VM3Q@mail.gmail.com>
References: <CAKGWAO_JXgAuJax6z_HUWeZeYuGErEk6-Qp1ng7HS=Yhx+VM3Q@mail.gmail.com>
Message-ID: <CAPYwfipb+LLdFg4ZXvgiMH68ku3YCLTop2tvOD=7EcPGzs=tBw@mail.gmail.com>

Looks good.

On Mon, Nov 7, 2011 at 9:26 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Seems benign, and helps get through code that insists on setting the
> signers.
>
> ~Will
>
> >From c4ed3b1df165e863a1cc0f0e7d1ebde188f82de4 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sun, 6 Nov 2011 23:31:03 -0600
> Subject: [PATCH 2/3] Don't abort on JVM_SetClassSigners, let it proceed.
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |    4 +++-
>  1 files changed, 3 insertions(+), 1 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index e625a9f..b86b56f 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -1160,7 +1160,9 @@ JVM_GetClassSigners(JNIEnv *env, jclass cls) {
>
>  JNIEXPORT void JNICALL
>  JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers) {
> -  NYI();
> +  // Let them 'set' signers, since we don't implement this yet and
> +  // don't allow them to 'get' the value back (above).
> +  //NYI();
>  }
>
>  JNIEXPORT jobject JNICALL
> --
> 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/20111108/b921d305/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 12:56:02 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 21:56:02 +0100
Subject: [vmkit-commits] [PATCH] Impl JVM_NewArray
In-Reply-To: <CAKGWAO9HHoXH7mRK3VDXyhP+hqzaJFR33fYUoUk+dYBqWp4RcQ@mail.gmail.com>
References: <CAKGWAO9HHoXH7mRK3VDXyhP+hqzaJFR33fYUoUk+dYBqWp4RcQ@mail.gmail.com>
Message-ID: <CAPYwfioOU+pGxLLW6QFp7wuSFXj0J3s0Ci-2Qj7WR5NGHsQqdg@mail.gmail.com>

Looks good, with two comments.

On Mon, Nov 7, 2011 at 9:28 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> ~Will
>
> >From 32f5d8efb6c9908c9bb36cdee3facfc3c91a7bf4 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sat, 5 Nov 2011 14:55:48 -0500
> Subject: [PATCH 3/3] Impl JVM_NewArray.
>
> ---
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc |   49
> ++++++++++++++++++++++++++++++++++-
>  1 files changed, 48 insertions(+), 1 deletions(-)
>
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index b86b56f..6342cfe 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -830,7 +830,54 @@ JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject
> arr, jint index, jvalue v,
>
>  JNIEXPORT jobject JNICALL
>  JVM_NewArray(JNIEnv *env, jclass eltClass, jint length) {
> -  NYI();
> +  ArrayObject * res = 0;
> +  llvm_gcroot(res, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  Jnjvm* vm = th->getJVM();
> +  if (length < 0) vm->negativeArraySizeException(length);
> +
> +  JavaObject * eltClassObj = *(JavaObject**)eltClass;
>

Add eltClassObj as gc_root at the top of the method.


> +  UserCommonClass* base =
> +    UserCommonClass::resolvedImplClass(vm, eltClassObj, true);
> +  JnjvmClassLoader* loader = base->classLoader;
> +  const UTF8* name = base->getName();
> +  const UTF8* arrayName = loader->constructArrayName(1, name);
> +  if (base->isPrimitive()) {
> +    UserClassArray *array = 0;
> +    if (base == vm->upcalls->OfBool) {
> +      array = vm->upcalls->ArrayOfBool;
> +    } else if (base == vm->upcalls->OfByte) {
> +      array = vm->upcalls->ArrayOfByte;
> +    } else if (base == vm->upcalls->OfShort) {
> +      array = vm->upcalls->ArrayOfShort;
> +    } else if (base == vm->upcalls->OfChar) {
> +      array = vm->upcalls->ArrayOfChar;
> +    } else if (base == vm->upcalls->OfInt) {
> +      array = vm->upcalls->ArrayOfInt;
> +    } else if (base == vm->upcalls->OfFloat) {
> +      array = vm->upcalls->ArrayOfFloat;
> +    } else if (base == vm->upcalls->OfLong) {
> +      array = vm->upcalls->ArrayOfLong;
> +    } else if (base == vm->upcalls->OfDouble) {
> +      array = vm->upcalls->ArrayOfDouble;
> +    } else {
> +      vm->illegalArgumentException("Invalid array primitive type!");
> +      abort();
> +    }
> +    res = (ArrayObject*)array->doNew(length, vm);
>

'res' should be typed JavaObject. A primitive array is not a ArrayObject.


> +  } else {
> +    UserClassArray* array = loader->constructArray(arrayName, base);
> +    res = (ArrayObject*)array->doNew(length, vm);
> +  }
> +
> +  jobject ret = (jobject)th->pushJNIRef(res);
> +  RETURN_FROM_JNI(ret);
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jobject JNICALL
> --
> 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/20111108/a92e56b1/attachment.html>

From wdietz2 at illinois.edu  Tue Nov  8 13:15:48 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 8 Nov 2011 15:15:48 -0600
Subject: [vmkit-commits] [PATCH] Don't try to emit methods from
 primitive classes' VT, they're bogus.
In-Reply-To: <CAPYwfiq6uiuUrEJ6_kWGve==2eTcc4asOHW=CDw7mUUpp84DuQ@mail.gmail.com>
References: <CAKGWAO-6a-wJ4HoK5oor1i8hKVS-xU9U0BwXKUVWRJnxPPsF3g@mail.gmail.com>
	<CAPYwfiq6uiuUrEJ6_kWGve==2eTcc4asOHW=CDw7mUUpp84DuQ@mail.gmail.com>
Message-ID: <CAKGWAO-7RtG7i0A9PnEPbyn-RkV2UJRJG8+GT-DUb4cNqgO7Eg@mail.gmail.com>

On Tue, Nov 8, 2011 at 2:41 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> That's ok to apply. Indeed it does look strange, do you have an error
> message?

The error manifests itself as an assertion failure in getMethodOrStub
when checking "isStatic", but the whole JavaMethod* is bogus.  This is
during the precompile stage.

> In any case, the fact that primitive classes have a VT should disappear. I
> haven't gone to doing that cleanup yet.
>

Okay, sounds good.

> On Mon, Nov 7, 2011 at 4:04 AM, Will Dietz <wdietz2 at illinois.edu> wrote:
>>
>> Inlined below.
>>
>> I honestly don't know why this didn't cause problems before, since we
>> explicitly attempt to emit the VT for primitive classes (while
>> precompiling) in a few places.  However, this is needed for the "emit
>> null for j.l.Class" patch to work, which was a bit unexpected :).
>>
>> Thanks!
>>
>> ~Will
>>
>> >From 8a795a7a5f6c69ef97407ef9582d8b8a524ba456 Mon Sep 17 00:00:00 2001
>> From: Will Dietz <w at wdtz.org>
>> Date: Sun, 6 Nov 2011 20:16:44 -0600
>> Subject: [PATCH 8/8] Don't try to emit methods from primitive classes' VT,
>>  they're bogus.
>>
>> ---
>>  lib/J3/Compiler/JavaAOTCompiler.cpp |    5 ++++-
>>  1 files changed, 4 insertions(+), 1 deletions(-)
>>
>> diff --git a/lib/J3/Compiler/JavaAOTCompiler.cpp
>> b/lib/J3/Compiler/JavaAOTCompiler.cpp
>> index 2ae8973..c4dc364 100644
>> --- a/lib/J3/Compiler/JavaAOTCompiler.cpp
>> +++ b/lib/J3/Compiler/JavaAOTCompiler.cpp
>> @@ -1775,7 +1775,10 @@ Constant*
>> JavaAOTCompiler::CreateConstantFromVT(JavaVirtualTable* VT) {
>>   // methods
>>   for (uint32 i = JavaVirtualTable::getFirstJavaMethodIndex(); i < size;
>> ++i) {
>>     JavaMethod* meth = ((JavaMethod**)RealVT)[i];
>> -    if (isAbstract(meth->access)) {
>> +    // Primitive classes don't have methods--abstract or otherwise.
>> +    // (But we do have placeholders for j.l.Object methods in their VTs,
>> +    // so just emit NULL's here)
>> +    if (isAbstract(meth->access) || classDef->isPrimitive()) {

FWIW I'm going to re-order this check since if the class is primitive,
we shouldn't very well be derefefencing it as a JavaMethod :).

>>       Elemts.push_back(Constant::getNullValue(PTy));
>>     } else {
>>       Function* F = getMethodOrStub(meth, maybeCustomize);
>> --
>> 1.7.5.1
>> _______________________________________________
>> vmkit-commits mailing list
>> vmkit-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>
>

Thanks!

~Will



From wdietz2 at illinois.edu  Tue Nov  8 13:44:21 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 08 Nov 2011 21:44:21 -0000
Subject: [vmkit-commits] [vmkit] r144126 - in /vmkit/trunk:
 include/j3/JavaAOTCompiler.h lib/J3/Compiler/JavaAOTCompiler.cpp
Message-ID: <20111108214421.6D9B61BE001@llvm.org>

Author: wdietz2
Date: Tue Nov  8 15:44:21 2011
New Revision: 144126

URL: http://llvm.org/viewvc/llvm-project?rev=144126&view=rev
Log:
Emit NULL for j.l.Class in AOT.

Modified:
    vmkit/trunk/include/j3/JavaAOTCompiler.h
    vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp

Modified: vmkit/trunk/include/j3/JavaAOTCompiler.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/JavaAOTCompiler.h?rev=144126&r1=144125&r2=144126&view=diff
==============================================================================
--- vmkit/trunk/include/j3/JavaAOTCompiler.h (original)
+++ vmkit/trunk/include/j3/JavaAOTCompiler.h Tue Nov  8 15:44:21 2011
@@ -94,7 +94,6 @@
   llvm::Constant* CreateConstantFromJavaMethod(JavaMethod& method);
   llvm::Constant* CreateConstantFromStaticInstance(Class* cl);
   llvm::Constant* CreateConstantFromJavaString(JavaString* str);
-  llvm::Constant* CreateConstantFromJavaClass(CommonClass* cl);
   llvm::Constant* CreateConstantForBaseObject(CommonClass* cl);
   llvm::Constant* CreateConstantFromJavaObject(JavaObject* obj);
   llvm::Constant* CreateConstantFromClassBytes(ClassBytes* bytes);

Modified: vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=144126&r1=144125&r2=144126&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp Tue Nov  8 15:44:21 2011
@@ -295,39 +295,7 @@
 }
 
 Constant* JavaAOTCompiler::getJavaClass(CommonClass* cl) {
-  Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
-  LLVMClassInfo* LCI = getClassInfo(javaClass);
-  llvm::Type* Ty = LCI->getVirtualType();
-
-  if (useCooperativeGC()) {
-    return Constant::getNullValue(JavaIntrinsics.JavaObjectType);
-  } else {
-    java_class_iterator End = javaClasses.end();
-    java_class_iterator I = javaClasses.find(cl);
-    if (I == End) {
-      final_object_iterator End = finalObjects.end();
-      final_object_iterator I = finalObjects.find(cl->delegatee[0]);
-      if (I == End) {
-      
-        Module& Mod = *getLLVMModule();
-      
-        GlobalVariable* varGV = 
-          new GlobalVariable(Mod, Ty->getContainedType(0), false,
-                             GlobalValue::InternalLinkage, 0, "");
-      
-        Constant* res = ConstantExpr::getCast(Instruction::BitCast, varGV,
-                                              JavaIntrinsics.JavaObjectType);
-    
-        javaClasses.insert(std::make_pair(cl, res));
-        varGV->setInitializer(CreateConstantFromJavaClass(cl));
-        return res;
-      } else {
-        return I->second;
-      }
-    } else {
-      return I->second;
-    }
-  }
+  return Constant::getNullValue(JavaIntrinsics.JavaObjectType);
 }
 
 Constant* JavaAOTCompiler::getJavaClassPtr(CommonClass* cl) {
@@ -688,36 +656,6 @@
   return ConstantStruct::get(STy, Elmts);
 }
 
-Constant* JavaAOTCompiler::CreateConstantFromJavaClass(CommonClass* cl) {
-  assert(!useCooperativeGC());
-  Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
-  LLVMClassInfo* LCI = getClassInfo(javaClass);
-  StructType* STy = 
-    dyn_cast<StructType>(LCI->getVirtualType()->getContainedType(0));
-
-  std::vector<Constant*> Elmts;
-
-  // JavaObject
-  Elmts.push_back(CreateConstantForBaseObject(javaClass));
-  
-  // signers
-  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
-  
-  // pd
-  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
-  
-  // vmdata
-  Constant* Cl = getNativeClass(cl);
-  Cl = ConstantExpr::getCast(Instruction::BitCast, Cl,
-                             JavaIntrinsics.JavaObjectType);
-  Elmts.push_back(Cl);
-
-  // constructor
-  Elmts.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
-
-  return ConstantStruct::get(STy, Elmts);
-}
-
 Constant* JavaAOTCompiler::CreateConstantFromJavaObject(JavaObject* obj) {
   assert(!useCooperativeGC());
   CommonClass* cl = JavaObject::getClass(obj);




From wdietz2 at illinois.edu  Tue Nov  8 13:44:19 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 08 Nov 2011 21:44:19 -0000
Subject: [vmkit-commits] [vmkit] r144125 - in /vmkit/trunk/lib/J3:
 ClassLib/Classpath.inc ClassLib/VMStaticInstance.h
 Compiler/JavaAOTCompiler.cpp Compiler/Makefile VMCore/Jnjvm.cpp
 VMCore/Makefile VMCore/VirtualTables.cpp
Message-ID: <20111108214419.609E12A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  8 15:44:19 2011
New Revision: 144125

URL: http://llvm.org/viewvc/llvm-project?rev=144125&view=rev
Log:
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.

Added:
    vmkit/trunk/lib/J3/ClassLib/VMStaticInstance.h
Modified:
    vmkit/trunk/lib/J3/ClassLib/Classpath.inc
    vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
    vmkit/trunk/lib/J3/Compiler/Makefile
    vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
    vmkit/trunk/lib/J3/VMCore/Makefile
    vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp

Modified: vmkit/trunk/lib/J3/ClassLib/Classpath.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/Classpath.inc?rev=144125&r1=144124&r2=144125&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/Classpath.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/Classpath.inc Tue Nov  8 15:44:19 2011
@@ -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,185 @@
   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());
+  cl->asClass()->resolveClass();
+  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) {
+  JavaObject* res = 0;
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(_field, 0);
+  llvm_gcroot(res, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  JavaField * field = JavaObjectField::getInternalField(_field);
+  assert(field);
+  field->classDef->initialiseClass(JavaThread::get()->getJVM());
+
+  res = VMStaticInstance::allocate(field->classDef);
+
+  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) {
+  UNIMPLEMENTED();
+  return 0;
+}
+
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* clazz) {
+  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()->throwException(obj);
+}
+
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
   // Nothing
 }
@@ -369,7 +559,7 @@
 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 +569,7 @@
 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 \
 }

Added: vmkit/trunk/lib/J3/ClassLib/VMStaticInstance.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/VMStaticInstance.h?rev=144125&view=auto
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/VMStaticInstance.h (added)
+++ vmkit/trunk/lib/J3/ClassLib/VMStaticInstance.h Tue Nov  8 15:44:19 2011
@@ -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 "ClasspathReflect.h"
+#include "JavaObject.h"
+#include "MvmGC.h"
+
+namespace j3 {
+
+/// VMStaticInstance - Used as a placeholder for a staticInstance, tracing to
+/// the corresponding Class to ensure it doesn't get improperly GC'd.
+/// This placeholder is used solely in getStaticFieldBase and the various
+/// put/get methods in sun.misc.Unsafe, any other use is invalid.
+/// Largely inspired by VMClassLoader.
+///
+class VMStaticInstance : public JavaObject {
+private:
+
+  /// OwningClass - The Class this is represents a static instance of.
+  Class * OwningClass;
+
+public:
+
+  static VMStaticInstance* allocate(Class * Class) {
+    VMStaticInstance* res = 0;
+    llvm_gcroot(res, 0);
+    llvm_gcroot(Class, 0);
+    res = (VMStaticInstance*)gc::operator new(sizeof(VMStaticInstance), &VT);
+    res->OwningClass = Class;
+
+    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 through to our Class
+  ///
+  static void staticTracer(VMStaticInstance* obj, word_t closure) {
+    llvm_gcroot(obj, 0);
+    assert(obj->OwningClass);
+    obj->OwningClass->classLoader->tracer(closure);
+  }
+
+  /// getStaticInstance - Get the static instance contained in this object
+  ///
+  void * getStaticInstance() {
+    assert(OwningClass);
+    return OwningClass->getStaticInstance();
+  }
+
+};
+
+}
+
+#endif // JNJVM_VMSTATICINSTANCE_H

Modified: vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=144125&r1=144124&r2=144125&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp Tue Nov  8 15:44:19 2011
@@ -32,6 +32,7 @@
 #include "JavaUpcalls.h"
 #include "Jnjvm.h"
 #include "Reader.h"
+#include "VMStaticInstance.h"
 #include "Zip.h"
 
 #include <cstdio>
@@ -2545,7 +2546,9 @@
 
   for (; I != E; ++I) {
     JavaObject* obj = (JavaObject*)(*I);
-    if (!VMClassLoader::isVMClassLoader(obj) && JavaObject::instanceOf(obj, cl)) {
+    if (!VMClassLoader::isVMClassLoader(obj) &&
+        !VMStaticInstance::isVMStaticInstance(obj) &&
+        JavaObject::instanceOf(obj, cl)) {
       if (currentClass != NULL) {
         if (JavaObject::getClass(obj) != currentClass) {
           return 0;

Modified: vmkit/trunk/lib/J3/Compiler/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/Makefile?rev=144125&r1=144124&r2=144125&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/Makefile (original)
+++ vmkit/trunk/lib/J3/Compiler/Makefile Tue Nov  8 15:44:19 2011
@@ -14,4 +14,4 @@
 
 include $(LEVEL)/Makefile.common
 
-CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime -I$(PROJ_SRC_DIR)/../ClassLib/$(CLASSPATH_DIR) -I$(PROJ_SRC_DIR)/../VMCore
+CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime -I$(PROJ_SRC_DIR)/../ClassLib/$(CLASSPATH_DIR) -I$(PROJ_SRC_DIR)/../ClassLib/ -I$(PROJ_SRC_DIR)/../VMCore

Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp?rev=144125&r1=144124&r2=144125&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp Tue Nov  8 15:44:19 2011
@@ -35,6 +35,7 @@
 #include "LockedMap.h"
 #include "Reader.h"
 #include "ReferenceQueue.h"
+#include "VMStaticInstance.h"
 #include "Zip.h"
 
 using namespace j3;
@@ -1394,6 +1395,8 @@
   JavaObject* src = (JavaObject*)object;
   if (VMClassLoader::isVMClassLoader(src)) {
     size = sizeof(VMClassLoader);
+  } else if (VMStaticInstance::isVMStaticInstance(src)) {
+    size = sizeof(VMStaticInstance);
   } else {
     CommonClass* cl = JavaObject::getClass(src);
     if (cl->isArray()) {
@@ -1416,6 +1419,8 @@
   JavaObject* src = (JavaObject*)object;
   if (VMClassLoader::isVMClassLoader(src)) {
     return "VMClassLoader";
+  } else if (VMStaticInstance::isVMStaticInstance(src)) {
+    return "VMStaticInstance";
   } else {
     CommonClass* cl = JavaObject::getClass(src);
     // This code is only used for debugging on a fatal error. It is fine to

Modified: vmkit/trunk/lib/J3/VMCore/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Makefile?rev=144125&r1=144124&r2=144125&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Makefile (original)
+++ vmkit/trunk/lib/J3/VMCore/Makefile Tue Nov  8 15:44:19 2011
@@ -14,4 +14,4 @@
 
 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

Modified: vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp?rev=144125&r1=144124&r2=144125&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp Tue Nov  8 15:44:19 2011
@@ -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 @@
 // 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 @@
 // 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.




From wdietz2 at illinois.edu  Tue Nov  8 13:44:23 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 08 Nov 2011 21:44:23 -0000
Subject: [vmkit-commits] [vmkit] r144127 -
	/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
Message-ID: <20111108214423.259631BE001@llvm.org>

Author: wdietz2
Date: Tue Nov  8 15:44:22 2011
New Revision: 144127

URL: http://llvm.org/viewvc/llvm-project?rev=144127&view=rev
Log:
Don't try to emit methods from primitive classes' VT, they're bogus.

Modified:
    vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp

Modified: vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=144127&r1=144126&r2=144127&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp Tue Nov  8 15:44:22 2011
@@ -1775,7 +1775,10 @@
   // methods
   for (uint32 i = JavaVirtualTable::getFirstJavaMethodIndex(); i < size; ++i) {
     JavaMethod* meth = ((JavaMethod**)RealVT)[i];
-    if (isAbstract(meth->access)) {
+    // Primitive classes don't have methods--abstract or otherwise.
+    // (But we do have placeholders for j.l.Object methods in their VTs,
+    // so just emit NULL's here)
+    if (classDef->isPrimitive() || isAbstract(meth->access)) {
       Elemts.push_back(Constant::getNullValue(PTy));
     } else {
       Function* F = getMethodOrStub(meth, maybeCustomize);




From wdietz2 at illinois.edu  Tue Nov  8 13:50:11 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 08 Nov 2011 21:50:11 -0000
Subject: [vmkit-commits] [vmkit] r144128 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111108215012.0BA1D2A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  8 15:50:11 2011
New Revision: 144128

URL: http://llvm.org/viewvc/llvm-project?rev=144128&view=rev
Log:
Impl JVM_InvokeMethod, use existing proceedMethod from Classpath

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144128&r1=144127&r2=144128&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov  8 15:50:11 2011
@@ -1553,8 +1553,29 @@
  * java.lang.reflect.Method
  */
 JNIEXPORT jobject JNICALL
-JVM_InvokeMethod(JNIEnv *env, jobject method, jobject _obj, jobjectArray args0) {
-  NYI();
+JVM_InvokeMethod(JNIEnv *env, jobject _m, jobject _obj, jobjectArray args0) {
+  JavaObject * ret = 0;
+  JavaObjectMethod * m = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(m, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+
+  m = *(JavaObjectMethod**)_m;
+
+  ret = proceedMethod(
+    m,
+    _obj ? *(JavaObject**)_obj : 0,
+    args0? *(ArrayObject**)args0 : 0,
+    JavaObjectMethod::getClass(m)->getDelegatee(),
+    0 /* unused */ );
+
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(ret));
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /*




From wdietz2 at illinois.edu  Tue Nov  8 13:50:52 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 08 Nov 2011 21:50:52 -0000
Subject: [vmkit-commits] [vmkit] r144129 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111108215052.149102A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  8 15:50:51 2011
New Revision: 144129

URL: http://llvm.org/viewvc/llvm-project?rev=144129&view=rev
Log:
Don't abort on JVM_SetClassSigners, let it proceed.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144129&r1=144128&r2=144129&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov  8 15:50:51 2011
@@ -1147,7 +1147,9 @@
 
 JNIEXPORT void JNICALL
 JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers) {
-  NYI();
+  // Let them 'set' signers, since we don't implement this yet and
+  // don't allow them to 'get' the value back (above).
+  //NYI();
 }
 
 JNIEXPORT jobject JNICALL




From nicolas.geoffray at gmail.com  Tue Nov  8 14:09:26 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 23:09:26 +0100
Subject: [vmkit-commits] OpenJDK for vmkit 0.30 (llvm 3.0)
In-Reply-To: <CAPYwfiqhOxjn0Dgz90Mk_EQHjqknmCVHMS-x6a5-rqJ62+CLkQ@mail.gmail.com>
References: <CAPYwfirvhfpwyriWZPVnS=aW5NRESWNcmeRS5fnsxG5iBSx-CA@mail.gmail.com>
	<CAPYwfiqhOxjn0Dgz90Mk_EQHjqknmCVHMS-x6a5-rqJ62+CLkQ@mail.gmail.com>
Message-ID: <CAPYwfioVTBE7EniJZKrL5ZLEoi3QPYeCAuCbiqWGktqk7fJxYg@mail.gmail.com>

Ping again Will?

On Tue, Nov 8, 2011 at 9:25 AM, Nicolas Geoffray <nicolas.geoffray at gmail.com
> wrote:

> Will, ping?
>
>
> On Sun, Nov 6, 2011 at 5:05 PM, Nicolas Geoffray <
> nicolas.geoffray at gmail.com> wrote:
>
>> Hi Will,
>>
>> In case you don't know, llvm will release version 3.0 in a few days.
>> Since llvm 2.3, I make a 'release' version of vmkit for each llvm release.
>> It's is more of a bundle that compiles with the released version of llvm.
>>
>> I'd like to create the 'release'  branch soon, so that I can start
>> testing vmkit 0.30 against llvm 3.0 and create the bundle. Are there extra
>> patches you'd like to integrate for the release? Also, should we promote
>> the OpenJDK port for the release notes, or should we wait until we have
>> something functional that you and I have tested and used for large-size
>> applications (eg dacapo)? Hopefully we'll be at that state the next version
>> (0.31)?
>>
>> Let me know!
>>
>> Thanks,
>> Nicolas
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111108/1dea26ba/attachment.html>

From wdietz2 at illinois.edu  Tue Nov  8 14:08:30 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 08 Nov 2011 22:08:30 -0000
Subject: [vmkit-commits] [vmkit] r144134 - in /vmkit/trunk:
 lib/J3/Compiler/JavaJITOpcodes.cpp test/ test/lshl.java
Message-ID: <20111108220831.0BBDF2A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  8 16:08:30 2011
New Revision: 144134

URL: http://llvm.org/viewvc/llvm-project?rev=144134&view=rev
Log:
Fix LSHL to mask the shift operand.

Simple test case illustrating failure added.

It should produce (java Hotspot 1.6.0_27)
1
1024
4294967296
1
1
18014398509481984

Before this patch j3 produces:
1
1024
4294967296
4294967296
4294967296
4294967296

This patch aligns j3 with java's behavior.
Additionally, this causes j3 to pass Mauve's Long tests.

Added:
    vmkit/trunk/test/
    vmkit/trunk/test/lshl.java
Modified:
    vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp

Modified: vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp?rev=144134&r1=144133&r2=144134&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp Tue Nov  8 16:08:30 2011
@@ -1185,6 +1185,8 @@
 
       case LSHL : {
         Value* val2 = new ZExtInst(pop(), Type::getInt64Ty(*llvmContext), "", currentBlock);
+        Value* mask = ConstantInt::get(Type::getInt64Ty(*llvmContext), 0x3F);
+        val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock);
         pop(); // remove the 0 on the stack
         Value* val1 = pop();
         push(BinaryOperator::CreateShl(val1, val2, "", currentBlock),

Added: vmkit/trunk/test/lshl.java
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/test/lshl.java?rev=144134&view=auto
==============================================================================
--- vmkit/trunk/test/lshl.java (added)
+++ vmkit/trunk/test/lshl.java Tue Nov  8 16:08:30 2011
@@ -0,0 +1,15 @@
+class lshl {
+  public static void check(boolean b) throws Exception {
+    if (!b) throw new Exception("Check failed!");
+  }
+
+  public static void main(String[] args) throws Exception {
+    long l = 1;
+    check(l == 1);
+    check(l << 10 == 1024);
+    check(l << 32 == 4294967296L);
+    check(l << 64 == 1);
+    check(l << 128 == 1);
+    check(l << -10 == 18014398509481984L);
+  }
+}




From wdietz2 at illinois.edu  Tue Nov  8 14:08:32 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 08 Nov 2011 22:08:32 -0000
Subject: [vmkit-commits] [vmkit] r144135 - in /vmkit/trunk:
 lib/J3/Compiler/JavaJITOpcodes.cpp test/lshr.java
Message-ID: <20111108220832.EF0862A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov  8 16:08:32 2011
New Revision: 144135

URL: http://llvm.org/viewvc/llvm-project?rev=144135&view=rev
Log:
Fix LSHR by masking the shift operand.

Sample test case added.

java produces (Hotspot 1.6.0_27):
1
0
0
1
1
0

j3 before this patch produces:
1
0
0
0
0
0

Added:
    vmkit/trunk/test/lshr.java
Modified:
    vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp

Modified: vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp?rev=144135&r1=144134&r2=144135&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp Tue Nov  8 16:08:32 2011
@@ -1207,6 +1207,8 @@
 
       case LSHR : {
         Value* val2 = new ZExtInst(pop(), Type::getInt64Ty(*llvmContext), "", currentBlock);
+        Value* mask = ConstantInt::get(Type::getInt64Ty(*llvmContext), 0x3F);
+        val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock);
         pop(); // remove the 0 on the stack
         Value* val1 = pop();
         push(BinaryOperator::CreateAShr(val1, val2, "", currentBlock),

Added: vmkit/trunk/test/lshr.java
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/test/lshr.java?rev=144135&view=auto
==============================================================================
--- vmkit/trunk/test/lshr.java (added)
+++ vmkit/trunk/test/lshr.java Tue Nov  8 16:08:32 2011
@@ -0,0 +1,15 @@
+class lshr {
+  public static void check(boolean b) throws Exception {
+    if (!b) throw new Exception("Check failed!");
+  }
+
+  public static void main(String[] args) throws Exception {
+    long l = 1;
+    check(l == 1);
+    check(l >> 10 == 0);
+    check(l >> 32 == 0);
+    check(l >> 64 == 1);
+    check(l >> 128 == 1);
+    check(l >> -10 == 0);
+  }
+}




From gael.thomas at lip6.fr  Tue Nov  8 14:16:09 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Tue, 08 Nov 2011 22:16:09 -0000
Subject: [vmkit-commits] [vmkit] r144137 - /vmkit/trunk/Makefile.rules
Message-ID: <20111108221609.DF8BA2A6C12C@llvm.org>

Author: gthomas
Date: Tue Nov  8 16:16:09 2011
New Revision: 144137

URL: http://llvm.org/viewvc/llvm-project?rev=144137&view=rev
Log:
generate object with gc by using relative names

Modified:
    vmkit/trunk/Makefile.rules

Modified: vmkit/trunk/Makefile.rules
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile.rules?rev=144137&r1=144136&r2=144137&view=diff
==============================================================================
--- vmkit/trunk/Makefile.rules (original)
+++ vmkit/trunk/Makefile.rules Tue Nov  8 16:16:09 2011
@@ -104,11 +104,11 @@
 
 $(ObjectsBCWithGC): $(ObjDir)/%_gc.bc: $(ObjDir)/%.ll $(LOPT)
 	$(Echo) "Compiling $*.ll to $*.bc for $(BuildMode) build (bytecode)"
-	$(Verb) $(LOPT) $< -load=$(LibDir)/StaticGCPass$(SHLIBEXT) -std-compile-opts -StaticGCPass -o $@
+	$(Verb) $(LOPT) $< -load=$(VMKIT_SRC_ROOT)/$(BuildMode)/lib/StaticGCPass$(SHLIBEXT) -std-compile-opts -StaticGCPass -o $@
 
 $(ObjectsSWithGC): $(ObjDir)/%_gc.s: $(ObjDir)/%_gc.bc $(LLC)
 	$(Echo) "Compiling $*.bc to $*.s for $(BuildMode) build"
-	$(Verb) $(LLC) -disable-cfi -disable-fp-elim -load=$(LibDir)/StaticGCPrinter$(SHLIBEXT) $< -o $@
+	$(Verb) $(LLC) -disable-cfi -disable-fp-elim -load=$(VMKIT_SRC_ROOT)/$(BuildMode)/lib/StaticGCPrinter$(SHLIBEXT) $< -o $@
 
 $(ObjectsWithGC): $(ObjDir)/%_gc.o: $(ObjDir)/%_gc.s $(ObjDir)/.dir
 	$(Echo) "Compiling $*.s for $(BuildMode) build" $(PIC_FLAG)




From wdietz2 at illinois.edu  Tue Nov  8 14:28:10 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 8 Nov 2011 16:28:10 -0600
Subject: [vmkit-commits] OpenJDK for vmkit 0.30 (llvm 3.0)
In-Reply-To: <CAPYwfioVTBE7EniJZKrL5ZLEoi3QPYeCAuCbiqWGktqk7fJxYg@mail.gmail.com>
References: <CAPYwfirvhfpwyriWZPVnS=aW5NRESWNcmeRS5fnsxG5iBSx-CA@mail.gmail.com>
	<CAPYwfiqhOxjn0Dgz90Mk_EQHjqknmCVHMS-x6a5-rqJ62+CLkQ@mail.gmail.com>
	<CAPYwfioVTBE7EniJZKrL5ZLEoi3QPYeCAuCbiqWGktqk7fJxYg@mail.gmail.com>
Message-ID: <CAKGWAO9d4TpRGrxHFiNC99W=MR2MLuG9r7_+bFe10dEoCjK4FQ@mail.gmail.com>

On Tue, Nov 8, 2011 at 4:09 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
>> On Sun, Nov 6, 2011 at 5:05 PM, Nicolas Geoffray
>> <nicolas.geoffray at gmail.com> wrote:
>>>
>>> Hi Will,
>>> In case you don't know, llvm will release version 3.0 in a few days.
>>> Since llvm 2.3, I make a 'release' version of vmkit for each llvm release.
>>> It's is more of a bundle that compiles with the released version of llvm.
>>> I'd like to create the 'release'  branch soon, so that I can start
>>> testing vmkit 0.30 against llvm 3.0 and create the bundle. Are there extra
>>> patches you'd like to integrate for the release? Also, should we promote the
>>> OpenJDK port for the release notes, or should we wait until we have
>>> something functional that you and I have tested and used for large-size
>>> applications (eg dacapo)? Hopefully we'll be at that state the next version
>>> (0.31)?

Hi!

Very sorry about not getting back to you sooner! I don't mean to keep
you blocking on my response, and thank you for asking.

In short, I'm not sure at all.  The OpenJDK port is a bit rough (I'd
say primarily in that not a single other person has even tried it yet
AFAIK) and while I'm eager to get it out there (release early, release
often), perhaps it's not ready.  Probably don't want to be supporting
users at this point, although on the other hand early adopters are
good for working out bugs and whatnot :).

Additionally, I'm don't really have much of an idea of what the normal
criterion for announcing such things is, so I'd be inclined to go with
whatever you thought was best :).  Would it be suitable to mention
it's a work-in-progress?  I'm okay with waiting longer if you feel
that's inappropriate.

I hope to get the OpenJDK port much more robust in the coming month
(in particular, for an internal deadline), so it's sad to miss the 3.0
deadline by so little :). If only I'd started this earlier... :D

Anyway, again my apologies regarding not responding earlier, I was
hoping to have a better answer than "I don't know"--but poor form
regardless.

Take care, and as always thoughts welcome :).

~Will



From nicolas.geoffray at gmail.com  Tue Nov  8 14:33:38 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 23:33:38 +0100
Subject: [vmkit-commits] [vmkit] r144137 - /vmkit/trunk/Makefile.rules
In-Reply-To: <20111108221609.DF8BA2A6C12C@llvm.org>
References: <20111108221609.DF8BA2A6C12C@llvm.org>
Message-ID: <CAPYwfio1yd7HU+Q=eYQKGxbWBpfdVVYVMdYJqGKJrLu2Fae6yQ@mail.gmail.com>

Hi Gael,

On Tue, Nov 8, 2011 at 11:16 PM, Gael Thomas <gael.thomas at lip6.fr> wrote:

> Author: gthomas
> Date: Tue Nov  8 16:16:09 2011
> New Revision: 144137
>
> URL: http://llvm.org/viewvc/llvm-project?rev=144137&view=rev
> Log:
> generate object with gc by using relative names
>
> Modified:
>    vmkit/trunk/Makefile.rules
>
> Modified: vmkit/trunk/Makefile.rules
> URL:
> http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile.rules?rev=144137&r1=144136&r2=144137&view=diff
>
> ==============================================================================
> --- vmkit/trunk/Makefile.rules (original)
> +++ vmkit/trunk/Makefile.rules Tue Nov  8 16:16:09 2011
> @@ -104,11 +104,11 @@
>
>  $(ObjectsBCWithGC): $(ObjDir)/%_gc.bc: $(ObjDir)/%.ll $(LOPT)
>        $(Echo) "Compiling $*.ll to $*.bc for $(BuildMode) build (bytecode)"
> -       $(Verb) $(LOPT) $< -load=$(LibDir)/StaticGCPass$(SHLIBEXT)
> -std-compile-opts -StaticGCPass -o $@
> +       $(Verb) $(LOPT) $<
> -load=$(VMKIT_SRC_ROOT)/$(BuildMode)/lib/StaticGCPass$(SHLIBEXT)
> -std-compile-opts -StaticGCPass -o $@
>
>  $(ObjectsSWithGC): $(ObjDir)/%_gc.s: $(ObjDir)/%_gc.bc $(LLC)
>        $(Echo) "Compiling $*.bc to $*.s for $(BuildMode) build"
> -       $(Verb) $(LLC) -disable-cfi -disable-fp-elim
> -load=$(LibDir)/StaticGCPrinter$(SHLIBEXT) $< -o $@
> +       $(Verb) $(LLC) -disable-cfi -disable-fp-elim
> -load=$(VMKIT_SRC_ROOT)/$(BuildMode)/lib/StaticGCPrinter$(SHLIBEXT) $< -o $@
>
>
This does not work if you build vmkit in another directory than the source
directory. Can you have a fix for handling both 'modes' (building in
source, building outside)? Otherwise, I'll revert the change.


>  $(ObjectsWithGC): $(ObjDir)/%_gc.o: $(ObjDir)/%_gc.s $(ObjDir)/.dir
>        $(Echo) "Compiling $*.s for $(BuildMode) build" $(PIC_FLAG)
>
>
> _______________________________________________
> 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/20111108/3d01a502/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov  8 14:43:08 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 8 Nov 2011 23:43:08 +0100
Subject: [vmkit-commits] OpenJDK for vmkit 0.30 (llvm 3.0)
In-Reply-To: <CAKGWAO9d4TpRGrxHFiNC99W=MR2MLuG9r7_+bFe10dEoCjK4FQ@mail.gmail.com>
References: <CAPYwfirvhfpwyriWZPVnS=aW5NRESWNcmeRS5fnsxG5iBSx-CA@mail.gmail.com>
	<CAPYwfiqhOxjn0Dgz90Mk_EQHjqknmCVHMS-x6a5-rqJ62+CLkQ@mail.gmail.com>
	<CAPYwfioVTBE7EniJZKrL5ZLEoi3QPYeCAuCbiqWGktqk7fJxYg@mail.gmail.com>
	<CAKGWAO9d4TpRGrxHFiNC99W=MR2MLuG9r7_+bFe10dEoCjK4FQ@mail.gmail.com>
Message-ID: <CAPYwfiq1KTQAgRzVMCtyvO6F0S3yOvaLubD67ysEFcuh8psvHQ@mail.gmail.com>

OK, Thanks Will. So I guess I can do the branching any time I want then :)

So I won't talk about openjdk support in the release notes, looks too
premature. And if you think you'll have a good working implementation for
the next release, I'd better tell about that one then! The openjdk port
will be in the bundle, if people are curious.

Besides, vmkit did have some nice improvements since llvm 2.9 that should
fill the release notes.

Cheers,
Nicolas


On Tue, Nov 8, 2011 at 11:28 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> On Tue, Nov 8, 2011 at 4:09 PM, Nicolas Geoffray
> <nicolas.geoffray at gmail.com> wrote:
> >> On Sun, Nov 6, 2011 at 5:05 PM, Nicolas Geoffray
> >> <nicolas.geoffray at gmail.com> wrote:
> >>>
> >>> Hi Will,
> >>> In case you don't know, llvm will release version 3.0 in a few days.
> >>> Since llvm 2.3, I make a 'release' version of vmkit for each llvm
> release.
> >>> It's is more of a bundle that compiles with the released version of
> llvm.
> >>> I'd like to create the 'release'  branch soon, so that I can start
> >>> testing vmkit 0.30 against llvm 3.0 and create the bundle. Are there
> extra
> >>> patches you'd like to integrate for the release? Also, should we
> promote the
> >>> OpenJDK port for the release notes, or should we wait until we have
> >>> something functional that you and I have tested and used for large-size
> >>> applications (eg dacapo)? Hopefully we'll be at that state the next
> version
> >>> (0.31)?
>
> Hi!
>
> Very sorry about not getting back to you sooner! I don't mean to keep
> you blocking on my response, and thank you for asking.
>
> In short, I'm not sure at all.  The OpenJDK port is a bit rough (I'd
> say primarily in that not a single other person has even tried it yet
> AFAIK) and while I'm eager to get it out there (release early, release
> often), perhaps it's not ready.  Probably don't want to be supporting
> users at this point, although on the other hand early adopters are
> good for working out bugs and whatnot :).
>
> Additionally, I'm don't really have much of an idea of what the normal
> criterion for announcing such things is, so I'd be inclined to go with
> whatever you thought was best :).  Would it be suitable to mention
> it's a work-in-progress?  I'm okay with waiting longer if you feel
> that's inappropriate.
>
> I hope to get the OpenJDK port much more robust in the coming month
> (in particular, for an internal deadline), so it's sad to miss the 3.0
> deadline by so little :). If only I'd started this earlier... :D
>
> Anyway, again my apologies regarding not responding earlier, I was
> hoping to have a better answer than "I don't know"--but poor form
> regardless.
>
> Take care, and as always thoughts welcome :).
>
> ~Will
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111108/cf7cbdb6/attachment.html>

From gael.thomas at lip6.fr  Wed Nov  9 03:12:44 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Wed, 09 Nov 2011 11:12:44 -0000
Subject: [vmkit-commits] [vmkit] r144181 - in /vmkit/trunk:
	Makefile.config.in Makefile.rules
Message-ID: <20111109111244.1627D2A6C12D@llvm.org>

Author: gthomas
Date: Wed Nov  9 05:12:43 2011
New Revision: 144181

URL: http://llvm.org/viewvc/llvm-project?rev=144181&view=rev
Log:
Can build from another directoy. I'm unable to build from another directory, but it is not related to my previous modification :)

Modified:
    vmkit/trunk/Makefile.config.in
    vmkit/trunk/Makefile.rules

Modified: vmkit/trunk/Makefile.config.in
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile.config.in?rev=144181&r1=144180&r2=144181&view=diff
==============================================================================
--- vmkit/trunk/Makefile.config.in (original)
+++ vmkit/trunk/Makefile.config.in Wed Nov  9 05:12:43 2011
@@ -7,7 +7,8 @@
 VMKIT_SRC_ROOT := $(PROJ_SRC_ROOT)
 
 # Set the root directory of this project's object files
-PROJ_OBJ_ROOT := $(subst //,/, at abs_top_objdir@)
+PROJ_OBJ_ROOT := $(subst //,/, at abs_top_builddir@)
+VMKIT_OBJ_ROOT := $(PROJ_OBJ_ROOT)
 
 # Set the root directory of this project's install prefix
 PROJ_INSTALL_ROOT := @prefix@

Modified: vmkit/trunk/Makefile.rules
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile.rules?rev=144181&r1=144180&r2=144181&view=diff
==============================================================================
--- vmkit/trunk/Makefile.rules (original)
+++ vmkit/trunk/Makefile.rules Wed Nov  9 05:12:43 2011
@@ -104,11 +104,11 @@
 
 $(ObjectsBCWithGC): $(ObjDir)/%_gc.bc: $(ObjDir)/%.ll $(LOPT)
 	$(Echo) "Compiling $*.ll to $*.bc for $(BuildMode) build (bytecode)"
-	$(Verb) $(LOPT) $< -load=$(VMKIT_SRC_ROOT)/$(BuildMode)/lib/StaticGCPass$(SHLIBEXT) -std-compile-opts -StaticGCPass -o $@
+	$(Verb) $(LOPT) $< -load=$(VMKIT_OBJ_ROOT)/$(BuildMode)/lib/StaticGCPass$(SHLIBEXT) -std-compile-opts -StaticGCPass -o $@
 
 $(ObjectsSWithGC): $(ObjDir)/%_gc.s: $(ObjDir)/%_gc.bc $(LLC)
 	$(Echo) "Compiling $*.bc to $*.s for $(BuildMode) build"
-	$(Verb) $(LLC) -disable-cfi -disable-fp-elim -load=$(VMKIT_SRC_ROOT)/$(BuildMode)/lib/StaticGCPrinter$(SHLIBEXT) $< -o $@
+	$(Verb) $(LLC) -disable-cfi -disable-fp-elim -load=$(VMKIT_OBJ_ROOT)/$(BuildMode)/lib/StaticGCPrinter$(SHLIBEXT) $< -o $@
 
 $(ObjectsWithGC): $(ObjDir)/%_gc.o: $(ObjDir)/%_gc.s $(ObjDir)/.dir
 	$(Echo) "Compiling $*.s for $(BuildMode) build" $(PIC_FLAG)




From gael.thomas at lip6.fr  Wed Nov  9 03:16:28 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Wed, 09 Nov 2011 11:16:28 -0000
Subject: [vmkit-commits] [vmkit] r144182 - /vmkit/trunk/Makefile.common.in
Message-ID: <20111109111628.6679E2A6C12D@llvm.org>

Author: gthomas
Date: Wed Nov  9 05:16:28 2011
New Revision: 144182

URL: http://llvm.org/viewvc/llvm-project?rev=144182&view=rev
Log:
My previous commit was good, I'm able to compile from another directory, that's cool\!

Modified:
    vmkit/trunk/Makefile.common.in

Modified: vmkit/trunk/Makefile.common.in
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile.common.in?rev=144182&r1=144181&r2=144182&view=diff
==============================================================================
--- vmkit/trunk/Makefile.common.in (original)
+++ vmkit/trunk/Makefile.common.in Wed Nov  9 05:16:28 2011
@@ -1,5 +1,4 @@
- 
-# Set this variable to the top of the LLVM source tree.
+ # Set this variable to the top of the LLVM source tree.
 LLVM_SRC_ROOT = @LLVM_SRC@
 
 # Set this variable to the top level directory where LLVM was built




From wdietz2 at illinois.edu  Wed Nov  9 10:16:11 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 09 Nov 2011 18:16:11 -0000
Subject: [vmkit-commits] [vmkit] r144193 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111109181611.4DC9A1BE001@llvm.org>

Author: wdietz2
Date: Wed Nov  9 12:16:11 2011
New Revision: 144193

URL: http://llvm.org/viewvc/llvm-project?rev=144193&view=rev
Log:
Impl JVM_NewArray.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144193&r1=144192&r2=144193&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Wed Nov  9 12:16:11 2011
@@ -828,7 +828,56 @@
 
 JNIEXPORT jobject JNICALL
 JVM_NewArray(JNIEnv *env, jclass eltClass, jint length) {
-  NYI();
+  JavaObject* res = 0;
+  JavaObject* eltClassObj = 0;
+  llvm_gcroot(res, 0);
+  llvm_gcroot(eltClassObj, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm* vm = th->getJVM();
+  if (length < 0) vm->negativeArraySizeException(length);
+
+  eltClassObj = *(JavaObject**)eltClass;
+  UserCommonClass* base =
+    UserCommonClass::resolvedImplClass(vm, eltClassObj, true);
+  JnjvmClassLoader* loader = base->classLoader;
+  const UTF8* name = base->getName();
+  const UTF8* arrayName = loader->constructArrayName(1, name);
+  if (base->isPrimitive()) {
+    UserClassArray *array = 0;
+    if (base == vm->upcalls->OfBool) {
+      array = vm->upcalls->ArrayOfBool;
+    } else if (base == vm->upcalls->OfByte) {
+      array = vm->upcalls->ArrayOfByte;
+    } else if (base == vm->upcalls->OfShort) {
+      array = vm->upcalls->ArrayOfShort;
+    } else if (base == vm->upcalls->OfChar) {
+      array = vm->upcalls->ArrayOfChar;
+    } else if (base == vm->upcalls->OfInt) {
+      array = vm->upcalls->ArrayOfInt;
+    } else if (base == vm->upcalls->OfFloat) {
+      array = vm->upcalls->ArrayOfFloat;
+    } else if (base == vm->upcalls->OfLong) {
+      array = vm->upcalls->ArrayOfLong;
+    } else if (base == vm->upcalls->OfDouble) {
+      array = vm->upcalls->ArrayOfDouble;
+    } else {
+      vm->illegalArgumentException("Invalid array primitive type!");
+      abort();
+    }
+    res = (JavaObject*)array->doNew(length, vm);
+  } else {
+    UserClassArray* array = loader->constructArray(arrayName, base);
+    res = (JavaObject*)array->doNew(length, vm);
+  }
+
+  jobject ret = (jobject)th->pushJNIRef(res);
+  RETURN_FROM_JNI(ret);
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jobject JNICALL




From wdietz2 at illinois.edu  Wed Nov  9 10:23:53 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 09 Nov 2011 18:23:53 -0000
Subject: [vmkit-commits] [vmkit] r144195 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111109182353.1AD161BE001@llvm.org>

Author: wdietz2
Date: Wed Nov  9 12:23:52 2011
New Revision: 144195

URL: http://llvm.org/viewvc/llvm-project?rev=144195&view=rev
Log:
Implement JVM_SetLength

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144195&r1=144194&r2=144195&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Wed Nov  9 12:23:52 2011
@@ -2360,14 +2360,13 @@
 /*
  * Set the length of the file associated with the given descriptor to the given
  * length.  If the new length is longer than the current length then the file
- * is extended; the contents of the extended portion are not defined.  Th {
-NYI();
-}
+ * is extended; the contents of the extended portion are not defined.  The
  * value of the file pointer is undefined after this procedure returns.
  */
 JNIEXPORT jint JNICALL
 JVM_SetLength(jint fd, jlong length) {
-  NYI();
+  int res = ftruncate64(fd, length);
+  return res != -1;
 }
 
 /*




From wdietz2 at illinois.edu  Wed Nov  9 10:23:54 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 09 Nov 2011 18:23:54 -0000
Subject: [vmkit-commits] [vmkit] r144196 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111109182354.CBF5C1BE002@llvm.org>

Author: wdietz2
Date: Wed Nov  9 12:23:54 2011
New Revision: 144196

URL: http://llvm.org/viewvc/llvm-project?rev=144196&view=rev
Log:
Implement various networking-related JVM_* methods (all are wrappers to C)

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144196&r1=144195&r2=144196&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Wed Nov  9 12:23:54 2011
@@ -19,6 +19,7 @@
 #include <fcntl.h>
 #include <signal.h>
 #include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
@@ -2375,7 +2376,7 @@
  */
 JNIEXPORT jint JNICALL
 JVM_Sync(jint fd) {
-  NYI();
+  return fsync(fd);
 }
 
 /*
@@ -2384,17 +2385,17 @@
 
 JNIEXPORT jint JNICALL
 JVM_InitializeSocketLibrary(void) {
-  NYI();
+  // Nothing to do here.
 }
 
 JNIEXPORT jint JNICALL
 JVM_Socket(jint domain, jint type, jint protocol) {
-  NYI();
+  return socket(domain, type, protocol);
 }
 
 JNIEXPORT jint JNICALL
 JVM_SocketClose(jint fd) {
-  NYI();
+  return close(fd);
 }
 
 JNIEXPORT jint JNICALL
@@ -2404,12 +2405,12 @@
 
 JNIEXPORT jint JNICALL
 JVM_Recv(jint fd, char *buf, jint nBytes, jint flags) {
-  NYI();
+  return recv(fd, buf, nBytes, flags);
 }
 
 JNIEXPORT jint JNICALL
 JVM_Send(jint fd, char *buf, jint nBytes, jint flags) {
-  NYI();
+  return send(fd, buf, nBytes, flags);
 }
 
 JNIEXPORT jint JNICALL
@@ -2419,22 +2420,22 @@
 
 JNIEXPORT jint JNICALL
 JVM_Listen(jint fd, jint count) {
-  NYI();
+  return listen(fd, count);
 }
 
 JNIEXPORT jint JNICALL
 JVM_Connect(jint fd, struct sockaddr *him, jint len) {
-  NYI();
+  return connect(fd, him, len);
 }
 
 JNIEXPORT jint JNICALL
 JVM_Bind(jint fd, struct sockaddr *him, jint len) {
-  NYI();
+  return bind(fd, him, len);
 }
 
 JNIEXPORT jint JNICALL
 JVM_Accept(jint fd, struct sockaddr *him, jint *len) {
-  NYI();
+  return accept(fd, him, (socklen_t*)len);
 }
 
 JNIEXPORT jint JNICALL
@@ -2457,7 +2458,7 @@
 
 JNIEXPORT jint JNICALL
 JVM_GetSockName(jint fd, struct sockaddr *him, int *len) {
-  NYI();
+  return getsockname(fd, him, (socklen_t*)len);
 }
 
 JNIEXPORT jint JNICALL




From wdietz2 at illinois.edu  Wed Nov  9 10:38:29 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 9 Nov 2011 12:38:29 -0600
Subject: [vmkit-commits] [PATCH] Refactor Class-related code into new
	Class.inc.
In-Reply-To: <CAPYwfiq19p6UQ-47WbX-CG7PVNOMuoJk5+ww9z0Zn_jRR1VeMQ@mail.gmail.com>
References: <CAKGWAO81ayMGHg9xuTNA9iaUT2h+46tGtFhqbGctaUY4KOyDnA@mail.gmail.com>
	<CAPYwfiq19p6UQ-47WbX-CG7PVNOMuoJk5+ww9z0Zn_jRR1VeMQ@mail.gmail.com>
Message-ID: <CAKGWAO89o-TEY44ooBicp=6pezytVNVpfVbT4LnLjR7JD5FZ_g@mail.gmail.com>

On Tue, Nov 8, 2011 at 2:36 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> Looks good, with one request.
>> +// Implementation-specific logic
>> +JavaObject* ClassLib_getConstructor(JavaMethod * cons, int i);
>> +JavaObject* ClassLib_getMethod(JavaMethod* meth, int i);
>> +JavaObject* ClassLib_getField(JavaField* field, int i);
>> +
>> +static inline ArrayObject* Class_getDeclaredConstructors(JavaObject*
>> Cl, jboolean publicOnly) {
>
> Please put this method as a static method of JavaObjectClass (I know, you
> have to add it to the file in gnu classpath, as well as openjdk).
> The reason I'm asking is because I just realized that you're using static
> inline. Note that if it was static only, the GC would not work with it
> (limitation in clang). Because you're putting inline, I guess that's the
> reason why it did not fail, but that's very brittle. Please do the same for
> all the other methods above. Thanks!
>

Sure thing :).  I put it as static inline to avoid any potential
issues like that, but not because I actually ran into any.  In
particular, as code gets shared into these .inc files, having them
static inline seemed like it would help for things that wanted to walk
the stack, for example.  Apparently I got lucky regarding the issue
with clang/GC you mentioned :).

Anyway, I think I understand your proposed change, just want to
confirm: go with the original patch set (that had two separate
definitions of each of these) but instead of the code living in
OpenJDK.inc and ClasspathVMClass.inc, put them into each runtime
library's ClasspathReflect.h?

Additionally, would they need to be inline-friendly (which suggests
the entirety of their definition goes into ClasspathReflect.h), or can
I just declare them in ClasspathReflect.h and define them in
ClasspathReflect.cpp?

I don't mean to be difficult or dense, but it sounds like you had a
particular organization in mind (which seems doubly important given
that some layouts apparently don't play nice with the GC), and I want
to make sure I match it :).  Implementation is just a straightforward
refactoring once I'm on the same page as you :).

Thanks!

~Will


From wdietz2 at illinois.edu  Wed Nov  9 11:44:38 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 09 Nov 2011 19:44:38 -0000
Subject: [vmkit-commits] [vmkit] r144206 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111109194438.E46F81BE002@llvm.org>

Author: wdietz2
Date: Wed Nov  9 13:44:38 2011
New Revision: 144206

URL: http://llvm.org/viewvc/llvm-project?rev=144206&view=rev
Log:
Fake impl JVM_GetSystemPackage

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144206&r1=144205&r2=144206&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Wed Nov  9 13:44:38 2011
@@ -760,7 +760,9 @@
  */
 JNIEXPORT jstring JNICALL
 JVM_GetSystemPackage(JNIEnv *env, jstring name) {
-  NYI();
+  // TODO: Actually implement this
+  // Not doing so doesn't seem to hurt anything, yet.
+  return NULL;
 }
 
 JNIEXPORT jobjectArray JNICALL




From wdietz2 at illinois.edu  Wed Nov  9 11:44:37 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 09 Nov 2011 19:44:37 -0000
Subject: [vmkit-commits] [vmkit] r144205 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111109194437.30E961BE001@llvm.org>

Author: wdietz2
Date: Wed Nov  9 13:44:36 2011
New Revision: 144205

URL: http://llvm.org/viewvc/llvm-project?rev=144205&view=rev
Log:
Impl JVM methods: GetArrayLength, SetArrayElement, GetArrayElement

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144205&r1=144204&r2=144205&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Wed Nov  9 13:44:36 2011
@@ -803,12 +803,34 @@
  */
 JNIEXPORT jint JNICALL
 JVM_GetArrayLength(JNIEnv *env, jobject arr) {
-  NYI();
+  ArrayObject* array = 0;
+  llvm_gcroot(array, 0);
+
+  BEGIN_JNI_EXCEPTION
+  array = *(ArrayObject**)arr;
+  RETURN_FROM_JNI(ArrayObject::getSize(array));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jobject JNICALL
 JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index) {
-  NYI();
+  ArrayObject* array = 0;
+  JavaObject* element = 0;
+  llvm_gcroot(array, 0);
+  llvm_gcroot(element, 0);
+
+  BEGIN_JNI_EXCEPTION
+  array = *(ArrayObject**)arr;
+  element = ArrayObject::getElement(array, index);
+
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(element));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jvalue JNICALL
@@ -818,7 +840,19 @@
 
 JNIEXPORT void JNICALL
 JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val) {
-  NYI();
+  ArrayObject* array = 0;
+  JavaObject* element = 0;
+  llvm_gcroot(array, 0);
+  llvm_gcroot(element, 0);
+
+  BEGIN_JNI_EXCEPTION
+  array = *(ArrayObject**)arr;
+  element = *(JavaObject**)val;
+
+  ArrayObject::setElement(array, element, index);
+
+  RETURN_VOID_FROM_JNI
+  END_JNI_EXCEPTION
 }
 
 JNIEXPORT void JNICALL




From wdietz2 at illinois.edu  Wed Nov  9 11:44:40 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 09 Nov 2011 19:44:40 -0000
Subject: [vmkit-commits] [vmkit] r144207 -
	/vmkit/trunk/lib/J3/ClassLib/Classpath.inc
Message-ID: <20111109194440.78C7B1BE002@llvm.org>

Author: wdietz2
Date: Wed Nov  9 13:44:40 2011
New Revision: 144207

URL: http://llvm.org/viewvc/llvm-project?rev=144207&view=rev
Log:
'Implement' arrayBaseOffset/arrayIndexScale.

Return '0' for offset, since it's accurate, and return '0' for index scale
indicating that we don't support using index scale for the given array's type.

For now we dont support index scale for anything, but this lets more codes run.

Modified:
    vmkit/trunk/lib/J3/ClassLib/Classpath.inc

Modified: vmkit/trunk/lib/J3/ClassLib/Classpath.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/Classpath.inc?rev=144207&r1=144206&r2=144207&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/Classpath.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/Classpath.inc Wed Nov  9 13:44:40 2011
@@ -475,7 +475,7 @@
 
 JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayBaseOffset(
 JavaObject* unsafe, JavaObject* clazz) {
-  UNIMPLEMENTED();
+  // Array starts at beginning of object
   return 0;
 }
 
@@ -484,7 +484,9 @@
 JNIEnv *env,
 #endif
 JavaObject* unsafe, JavaObject* clazz) {
-  UNIMPLEMENTED();
+  // Return '0' if we don't support indexing this way.
+  // (We might pack fields specially, etc)
+  // TODO: Implement this for the array types we support this way
   return 0;
 }
 




From nicolas.geoffray at lip6.fr  Wed Nov  9 13:49:15 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Wed, 09 Nov 2011 21:49:15 -0000
Subject: [vmkit-commits] [vmkit] r144214 - in /vmkit/trunk: include/debug.h
 lib/J3/ClassLib/GNUClasspath/Makefile lib/J3/ClassLib/Makefile
 lib/J3/ClassLib/OpenJDK/Makefile lib/J3/Compiler/Makefile
 lib/J3/VMCore/Makefile mmtk/mmtk-j3/Statistics.cpp test/
 tests/LshlTest.java tests/LshrTest.java tools/precompiler/trainer/Makefile
Message-ID: <20111109214915.291D91BE001@llvm.org>

Author: geoffray
Date: Wed Nov  9 15:49:14 2011
New Revision: 144214

URL: http://llvm.org/viewvc/llvm-project?rev=144214&view=rev
Log:
Small fixes to support make dist again.


Added:
    vmkit/trunk/tests/LshlTest.java
      - copied, changed from r144138, vmkit/trunk/test/lshl.java
    vmkit/trunk/tests/LshrTest.java
      - copied, changed from r144138, vmkit/trunk/test/lshr.java
Removed:
    vmkit/trunk/test/
Modified:
    vmkit/trunk/include/debug.h
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Makefile
    vmkit/trunk/lib/J3/ClassLib/Makefile
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/Makefile
    vmkit/trunk/lib/J3/Compiler/Makefile
    vmkit/trunk/lib/J3/VMCore/Makefile
    vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp
    vmkit/trunk/tools/precompiler/trainer/Makefile

Modified: vmkit/trunk/include/debug.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/debug.h?rev=144214&r1=144213&r2=144214&view=diff
==============================================================================
--- vmkit/trunk/include/debug.h (original)
+++ vmkit/trunk/include/debug.h Wed Nov  9 15:49:14 2011
@@ -85,4 +85,8 @@
 #endif
 #endif
 
+// Silence compiler warnings.
+template <typename T>
+static inline void USE(T) { }
+
 #endif

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Makefile?rev=144214&r1=144213&r2=144214&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Makefile (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Makefile Wed Nov  9 15:49:14 2011
@@ -9,8 +9,7 @@
 LEVEL = ../../../..
 
 
-EXTRA_DIST = ClasspathConstructor.inc ClasspathField.inc Classpath.inc ClasspathMethod.inc \
-	     ClasspathVMClass.inc ClasspathVMClassLoader.inc ClasspathVMObject.inc \
+EXTRA_DIST = ClasspathVMClass.inc ClasspathVMClassLoader.inc ClasspathVMObject.inc \
 	     ClasspathVMRuntime.inc ClasspathVMStackWalker.inc ClasspathVMSystem.inc \
 	     ClasspathVMSystemProperties.inc ClasspathVMThread.inc ClasspathVMThrowable.inc
 

Modified: vmkit/trunk/lib/J3/ClassLib/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/Makefile?rev=144214&r1=144213&r2=144214&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/Makefile (original)
+++ vmkit/trunk/lib/J3/ClassLib/Makefile Wed Nov  9 15:49:14 2011
@@ -8,6 +8,14 @@
 ##===----------------------------------------------------------------------===##
 LEVEL = ../../..
 
+EXTRA_DIST = ArrayCopy.inc \
+             ClassContext.inc \
+             ClasspathConstructor.inc \
+             ClasspathField.inc \
+             Classpath.inc \
+             ClasspathMethod.inc \
+             SetProperties.inc
+
 include $(LEVEL)/Makefile.config
 
 DIRS = $(CLASSPATH_DIR)

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/Makefile?rev=144214&r1=144213&r2=144214&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/Makefile (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/Makefile Wed Nov  9 15:49:14 2011
@@ -8,7 +8,7 @@
 ##===----------------------------------------------------------------------===##
 LEVEL = ../../../..
 
-EXTRA_DIST =
+EXTRA_DIST = OpenJDK.inc
 
 include $(LEVEL)/Makefile.config
 

Modified: vmkit/trunk/lib/J3/Compiler/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/Makefile?rev=144214&r1=144213&r2=144214&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/Makefile (original)
+++ vmkit/trunk/lib/J3/Compiler/Makefile Wed Nov  9 15:49:14 2011
@@ -1,4 +1,4 @@
-##===- lib/JnJVM/Compiler/Makefile -------------------------*- Makefile -*-===##
+##===- lib/J3/Compiler/Makefile ----------------------------*- Makefile -*-===##
 # 
 #                     The VMKit project
 #
@@ -8,6 +8,8 @@
 ##===----------------------------------------------------------------------===##
 LEVEL = ../../..
 
+EXTRA_DIST = JavaJITClasspath.inc JavaJITOpenJDK.inc
+
 include $(LEVEL)/Makefile.config
 
 MODULE_WITH_GC = J3Compiler

Modified: vmkit/trunk/lib/J3/VMCore/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Makefile?rev=144214&r1=144213&r2=144214&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Makefile (original)
+++ vmkit/trunk/lib/J3/VMCore/Makefile Wed Nov  9 15:49:14 2011
@@ -1,4 +1,4 @@
-##===- lib/JnJVM/VMCore/Makefile ---------------------------*- Makefile -*-===##
+##===- lib/J3/VMCore/Makefile ------------------------------*- Makefile -*-===##
 # 
 #                     The vmkit project
 #
@@ -8,6 +8,8 @@
 ##===----------------------------------------------------------------------===##
 LEVEL = ../../..
 
+EXTRA_DIST = JniClasspath.inc JniOpenJDK.inc
+
 include $(LEVEL)/Makefile.config
 
 MODULE_WITH_GC = J3

Modified: vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp?rev=144214&r1=144213&r2=144214&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Statistics.cpp Wed Nov  9 15:49:14 2011
@@ -22,8 +22,8 @@
   int64_t result;
   struct timeval tp; 
 
-  int res;
-	res = gettimeofday (&tp, NULL);
+  int res = gettimeofday (&tp, NULL);
+  USE(res);
   assert(res != -1 && "failed gettimeofday.");
 
   result = (int64_t) tp.tv_sec;

Copied: vmkit/trunk/tests/LshlTest.java (from r144138, vmkit/trunk/test/lshl.java)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tests/LshlTest.java?p2=vmkit/trunk/tests/LshlTest.java&p1=vmkit/trunk/test/lshl.java&r1=144138&r2=144214&rev=144214&view=diff
==============================================================================
--- vmkit/trunk/test/lshl.java (original)
+++ vmkit/trunk/tests/LshlTest.java Wed Nov  9 15:49:14 2011
@@ -1,4 +1,4 @@
-class lshl {
+class LshlTest {
   public static void check(boolean b) throws Exception {
     if (!b) throw new Exception("Check failed!");
   }

Copied: vmkit/trunk/tests/LshrTest.java (from r144138, vmkit/trunk/test/lshr.java)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tests/LshrTest.java?p2=vmkit/trunk/tests/LshrTest.java&p1=vmkit/trunk/test/lshr.java&r1=144138&r2=144214&rev=144214&view=diff
==============================================================================
--- vmkit/trunk/test/lshr.java (original)
+++ vmkit/trunk/tests/LshrTest.java Wed Nov  9 15:49:14 2011
@@ -1,4 +1,4 @@
-class lshr {
+class LshrTest {
   public static void check(boolean b) throws Exception {
     if (!b) throw new Exception("Check failed!");
   }

Modified: vmkit/trunk/tools/precompiler/trainer/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/precompiler/trainer/Makefile?rev=144214&r1=144213&r2=144214&view=diff
==============================================================================
--- vmkit/trunk/tools/precompiler/trainer/Makefile (original)
+++ vmkit/trunk/tools/precompiler/trainer/Makefile Wed Nov  9 15:49:14 2011
@@ -8,6 +8,8 @@
 ##===----------------------------------------------------------------------===##
 LEVEL = ../../..
 
+EXTRA_DIST = HelloWorld.java
+
 include $(LEVEL)/Makefile.config
 
 BUILT_SOURCES = Precompiled.bc BootstrapClasses.bc




From nicolas.geoffray at lip6.fr  Wed Nov  9 13:56:12 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Wed, 09 Nov 2011 21:56:12 -0000
Subject: [vmkit-commits] [vmkit] r144215 - /vmkit/branches/release_030/
Message-ID: <20111109215612.4AB361BE001@llvm.org>

Author: geoffray
Date: Wed Nov  9 15:56:12 2011
New Revision: 144215

URL: http://llvm.org/viewvc/llvm-project?rev=144215&view=rev
Log:
Create release 0.30.


Added:
    vmkit/branches/release_030/   (props changed)
      - copied from r144214, vmkit/trunk/

Propchange: vmkit/branches/release_030/
------------------------------------------------------------------------------
--- svn:ignore (added)
+++ svn:ignore Wed Nov  9 15:56:12 2011
@@ -0,0 +1,15 @@
+do-find
+Makefile.config
+Makefile.llvmbuild
+replace.sh
+config.log
+*.tmp
+Release
+do-conf
+configure.out
+config.status
+Makefile.common
+Release-Asserts
+Release+Asserts
+Debug
+

Propchange: vmkit/branches/release_030/
------------------------------------------------------------------------------
--- svn:mergeinfo (added)
+++ svn:mergeinfo Wed Nov  9 15:56:12 2011
@@ -0,0 +1,2 @@
+/vmkit/branches/precise:112509-120199
+/vmkit/branches/release_028:115466-116298




From nicolas.geoffray at lip6.fr  Wed Nov  9 14:26:54 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Wed, 09 Nov 2011 22:26:54 -0000
Subject: [vmkit-commits] [vmkit] r144217 -
	/vmkit/branches/release_030/autoconf/configure.ac
Message-ID: <20111109222654.14A3C1BE001@llvm.org>

Author: geoffray
Date: Wed Nov  9 16:26:53 2011
New Revision: 144217

URL: http://llvm.org/viewvc/llvm-project?rev=144217&view=rev
Log:
Move to version 0.30.


Modified:
    vmkit/branches/release_030/autoconf/configure.ac

Modified: vmkit/branches/release_030/autoconf/configure.ac
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/release_030/autoconf/configure.ac?rev=144217&r1=144216&r2=144217&view=diff
==============================================================================
--- vmkit/branches/release_030/autoconf/configure.ac (original)
+++ vmkit/branches/release_030/autoconf/configure.ac Wed Nov  9 16:26:53 2011
@@ -31,7 +31,7 @@
 dnl===-----------------------------------------------------------------------===
 dnl Initialize autoconf and define the package name, version number and
 dnl email address for reporting bugs.
-AC_INIT([vmkit],[0.30svn],[nicolas.geoffray at gmail.com])
+AC_INIT([vmkit],[0.30],[nicolas.geoffray at gmail.com])
 
 dnl Provide a copyright substitution and ensure the copyright notice is included
 dnl in the output of --version option of the generated configure script.




From nicolas.geoffray at lip6.fr  Wed Nov  9 14:28:52 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Wed, 09 Nov 2011 22:28:52 -0000
Subject: [vmkit-commits] [vmkit] r144218 - /vmkit/trunk/autoconf/configure.ac
Message-ID: <20111109222852.465E91BE001@llvm.org>

Author: geoffray
Date: Wed Nov  9 16:28:51 2011
New Revision: 144218

URL: http://llvm.org/viewvc/llvm-project?rev=144218&view=rev
Log:
Move to version 0.31svn.


Modified:
    vmkit/trunk/autoconf/configure.ac

Modified: vmkit/trunk/autoconf/configure.ac
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/autoconf/configure.ac?rev=144218&r1=144217&r2=144218&view=diff
==============================================================================
--- vmkit/trunk/autoconf/configure.ac (original)
+++ vmkit/trunk/autoconf/configure.ac Wed Nov  9 16:28:51 2011
@@ -31,7 +31,7 @@
 dnl===-----------------------------------------------------------------------===
 dnl Initialize autoconf and define the package name, version number and
 dnl email address for reporting bugs.
-AC_INIT([vmkit],[0.30svn],[nicolas.geoffray at gmail.com])
+AC_INIT([vmkit],[0.31svn],[nicolas.geoffray at gmail.com])
 
 dnl Provide a copyright substitution and ensure the copyright notice is included
 dnl in the output of --version option of the generated configure script.




From nicolas.geoffray at lip6.fr  Wed Nov  9 14:33:42 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Wed, 09 Nov 2011 22:33:42 -0000
Subject: [vmkit-commits] [vmkit] r144219 -
	/vmkit/branches/release_030/configure
Message-ID: <20111109223342.10C221BE001@llvm.org>

Author: geoffray
Date: Wed Nov  9 16:33:41 2011
New Revision: 144219

URL: http://llvm.org/viewvc/llvm-project?rev=144219&view=rev
Log:
Regnerate.


Modified:
    vmkit/branches/release_030/configure

Modified: vmkit/branches/release_030/configure
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/release_030/configure?rev=144219&r1=144218&r2=144219&view=diff
==============================================================================
--- vmkit/branches/release_030/configure (original)
+++ vmkit/branches/release_030/configure Wed Nov  9 16:33:41 2011
@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.68 for vmkit 0.30svn.
+# Generated by GNU Autoconf 2.68 for vmkit 0.30.
 #
 # Report bugs to <nicolas.geoffray at gmail.com>.
 #
@@ -562,8 +562,8 @@
 # Identity of this package.
 PACKAGE_NAME='vmkit'
 PACKAGE_TARNAME='vmkit'
-PACKAGE_VERSION='0.30svn'
-PACKAGE_STRING='vmkit 0.30svn'
+PACKAGE_VERSION='0.30'
+PACKAGE_STRING='vmkit 0.30'
 PACKAGE_BUGREPORT='nicolas.geoffray at gmail.com'
 PACKAGE_URL=''
 
@@ -1269,7 +1269,7 @@
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures vmkit 0.30svn to adapt to many kinds of systems.
+\`configure' configures vmkit 0.30 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1335,7 +1335,7 @@
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of vmkit 0.30svn:";;
+     short | recursive ) echo "Configuration of vmkit 0.30:";;
    esac
   cat <<\_ACEOF
 
@@ -1437,7 +1437,7 @@
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-vmkit configure 0.30svn
+vmkit configure 0.30
 generated by GNU Autoconf 2.68
 
 Copyright (C) 2010 Free Software Foundation, Inc.
@@ -1900,7 +1900,7 @@
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by vmkit $as_me 0.30svn, which was
+It was created by vmkit $as_me 0.30, which was
 generated by GNU Autoconf 2.68.  Invocation command line was
 
   $ $0 $@
@@ -6321,7 +6321,7 @@
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by vmkit $as_me 0.30svn, which was
+This file was extended by vmkit $as_me 0.30, which was
 generated by GNU Autoconf 2.68.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -6387,7 +6387,7 @@
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-vmkit config.status 0.30svn
+vmkit config.status 0.30
 configured by $0, generated by GNU Autoconf 2.68,
   with options \\"\$ac_cs_config\\"
 




From nicolas.geoffray at lip6.fr  Wed Nov  9 14:34:42 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Wed, 09 Nov 2011 22:34:42 -0000
Subject: [vmkit-commits] [vmkit] r144225 - /vmkit/trunk/configure
Message-ID: <20111109223442.56ABD1BE001@llvm.org>

Author: geoffray
Date: Wed Nov  9 16:34:42 2011
New Revision: 144225

URL: http://llvm.org/viewvc/llvm-project?rev=144225&view=rev
Log:
Regenerate configure.


Modified:
    vmkit/trunk/configure

Modified: vmkit/trunk/configure
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/configure?rev=144225&r1=144224&r2=144225&view=diff
==============================================================================
--- vmkit/trunk/configure (original)
+++ vmkit/trunk/configure Wed Nov  9 16:34:42 2011
@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.68 for vmkit 0.30svn.
+# Generated by GNU Autoconf 2.68 for vmkit 0.31svn.
 #
 # Report bugs to <nicolas.geoffray at gmail.com>.
 #
@@ -562,8 +562,8 @@
 # Identity of this package.
 PACKAGE_NAME='vmkit'
 PACKAGE_TARNAME='vmkit'
-PACKAGE_VERSION='0.30svn'
-PACKAGE_STRING='vmkit 0.30svn'
+PACKAGE_VERSION='0.31svn'
+PACKAGE_STRING='vmkit 0.31svn'
 PACKAGE_BUGREPORT='nicolas.geoffray at gmail.com'
 PACKAGE_URL=''
 
@@ -1269,7 +1269,7 @@
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures vmkit 0.30svn to adapt to many kinds of systems.
+\`configure' configures vmkit 0.31svn to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1335,7 +1335,7 @@
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of vmkit 0.30svn:";;
+     short | recursive ) echo "Configuration of vmkit 0.31svn:";;
    esac
   cat <<\_ACEOF
 
@@ -1437,7 +1437,7 @@
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-vmkit configure 0.30svn
+vmkit configure 0.31svn
 generated by GNU Autoconf 2.68
 
 Copyright (C) 2010 Free Software Foundation, Inc.
@@ -1900,7 +1900,7 @@
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by vmkit $as_me 0.30svn, which was
+It was created by vmkit $as_me 0.31svn, which was
 generated by GNU Autoconf 2.68.  Invocation command line was
 
   $ $0 $@
@@ -6321,7 +6321,7 @@
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by vmkit $as_me 0.30svn, which was
+This file was extended by vmkit $as_me 0.31svn, which was
 generated by GNU Autoconf 2.68.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -6387,7 +6387,7 @@
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-vmkit config.status 0.30svn
+vmkit config.status 0.31svn
 configured by $0, generated by GNU Autoconf 2.68,
   with options \\"\$ac_cs_config\\"
 




From gael.thomas at lip6.fr  Thu Nov 10 07:18:39 2011
From: gael.thomas at lip6.fr (=?ISO-8859-1?Q?Ga=EBl_Thomas?=)
Date: Thu, 10 Nov 2011 16:18:39 +0100
Subject: [vmkit-commits] Renaming
Message-ID: <CAOWuPDcvLXMNA+qZu_RFrsTQFdY2eiWhevpX13bsunf2g1=6gw@mail.gmail.com>

Hi all!

I will make some changes in the global design of vmkit: I will mainly
rename the package mvm into vmkit and replace all the names that
contain mvm to use vmkit. I will also modify the directories (Mvm will
be vmkit and include/mvm/*, include/mvm/Threads/*, include/mvm/* will
be in include/vmkit/*). If you have pending changes to commit (or even
pending branches!), be careful :). I will probably make these updates
on friday during the day, if you want, I can wait,

Gaël




-- 
-------------------------------------------------------------------------------------------------
Gaël Thomas, Associate Professor,
University of Pierre and Marie Curie
Boite courrier 169, 217 - 26-00, REGAL Team, INRIA/LIP6,
4, place Jussieu, 75252 Paris Cedex 05, France
Web: http://pagesperso-systeme.lip6.fr/Gael.Thomas/
Phone (mob): +33 6 10 39 31 17           Fax : +33 1 44 27 70 00
-------------------------------------------------------------------------------------------------



From nicolas.geoffray at gmail.com  Thu Nov 10 15:32:39 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Fri, 11 Nov 2011 00:32:39 +0100
Subject: [vmkit-commits] Renaming
In-Reply-To: <CAOWuPDcvLXMNA+qZu_RFrsTQFdY2eiWhevpX13bsunf2g1=6gw@mail.gmail.com>
References: <CAOWuPDcvLXMNA+qZu_RFrsTQFdY2eiWhevpX13bsunf2g1=6gw@mail.gmail.com>
Message-ID: <CAPYwfirOftiCH0Ww8mVya00nKoxOM=qLSCTwYQSiM64uZaTm=w@mail.gmail.com>

Hi Gael!

There's a big change I'd like to commit before the refactoring. Could you
do the changes on Monday instead? Thanks!

Nicolas

On Thu, Nov 10, 2011 at 4:18 PM, Gaël Thomas <gael.thomas at lip6.fr> wrote:

> Hi all!
>
> I will make some changes in the global design of vmkit: I will mainly
> rename the package mvm into vmkit and replace all the names that
> contain mvm to use vmkit. I will also modify the directories (Mvm will
> be vmkit and include/mvm/*, include/mvm/Threads/*, include/mvm/* will
> be in include/vmkit/*). If you have pending changes to commit (or even
> pending branches!), be careful :). I will probably make these updates
> on friday during the day, if you want, I can wait,
>
> Gaël
>
>
>
>
> --
>
> -------------------------------------------------------------------------------------------------
> Gaël Thomas, Associate Professor,
> University of Pierre and Marie Curie
> Boite courrier 169, 217 - 26-00, REGAL Team, INRIA/LIP6,
> 4, place Jussieu, 75252 Paris Cedex 05, France
> Web: http://pagesperso-systeme.lip6.fr/Gael.Thomas/
> Phone (mob): +33 6 10 39 31 17           Fax : +33 1 44 27 70 00
>
> -------------------------------------------------------------------------------------------------
>
> _______________________________________________
> 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/20111111/90d54305/attachment.html>

From nicolas.geoffray at lip6.fr  Fri Nov 11 08:23:15 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Fri, 11 Nov 2011 16:23:15 -0000
Subject: [vmkit-commits] [vmkit] r144390 -
	/vmkit/trunk/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp
Message-ID: <20111111162315.A0DA41BE001@llvm.org>

Author: geoffray
Date: Fri Nov 11 10:23:15 2011
New Revision: 144390

URL: http://llvm.org/viewvc/llvm-project?rev=144390&view=rev
Log:
Do not finf the first '.' but emit the full file name. Otherwise if the path contains a '.', files may end up having the same frametable symbol.


Modified:
    vmkit/trunk/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp

Modified: vmkit/trunk/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp?rev=144390&r1=144389&r2=144390&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp (original)
+++ vmkit/trunk/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp Fri Nov 11 10:23:15 2011
@@ -92,7 +92,7 @@
   std::string SymName;
   SymName += "vmkit";
   size_t Letter = SymName.size();
-  SymName.append(MId.begin(), std::find(MId.begin(), MId.end(), '.'));
+  SymName += MId;
   SymName += "__";
   SymName += Id;
 




From nicolas.geoffray at lip6.fr  Fri Nov 11 08:28:44 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Fri, 11 Nov 2011 16:28:44 -0000
Subject: [vmkit-commits] [vmkit] r144391 -
 /vmkit/branches/release_030/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp
Message-ID: <20111111162844.7585E1BE001@llvm.org>

Author: geoffray
Date: Fri Nov 11 10:28:44 2011
New Revision: 144391

URL: http://llvm.org/viewvc/llvm-project?rev=144391&view=rev
Log:
Import r144390 into release.


Modified:
    vmkit/branches/release_030/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp

Modified: vmkit/branches/release_030/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/release_030/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp?rev=144391&r1=144390&r2=144391&view=diff
==============================================================================
--- vmkit/branches/release_030/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp (original)
+++ vmkit/branches/release_030/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp Fri Nov 11 10:28:44 2011
@@ -92,7 +92,7 @@
   std::string SymName;
   SymName += "vmkit";
   size_t Letter = SymName.size();
-  SymName.append(MId.begin(), std::find(MId.begin(), MId.end(), '.'));
+  SymName += MId;
   SymName += "__";
   SymName += Id;
 




From nicolas.geoffray at lip6.fr  Fri Nov 11 10:38:38 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Fri, 11 Nov 2011 18:38:38 -0000
Subject: [vmkit-commits] [vmkit] r144401 - in /vmkit/trunk:
 include/mvm/System.h include/mvm/VirtualMachine.h
 lib/J3/Compiler/JavaJIT.cpp lib/J3/VMCore/Jnjvm.h
 lib/Mvm/CommonThread/Sigsegv.cpp lib/Mvm/CommonThread/ctthread.cpp
 lib/Mvm/Compiler/JIT.cpp lib/Mvm/Compiler/VmkitGC.cpp
 lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp
Message-ID: <20111111183838.627F81BE001@llvm.org>

Author: geoffray
Date: Fri Nov 11 12:38:37 2011
New Revision: 144401

URL: http://llvm.org/viewvc/llvm-project?rev=144401&view=rev
Log:
Make use of the new LLVM GCStrategy::findCustomSafepoint method and hardware null trap to remove explicit null checks in methods without a try/catch.


Modified:
    vmkit/trunk/include/mvm/System.h
    vmkit/trunk/include/mvm/VirtualMachine.h
    vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
    vmkit/trunk/lib/J3/VMCore/Jnjvm.h
    vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
    vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
    vmkit/trunk/lib/Mvm/Compiler/VmkitGC.cpp
    vmkit/trunk/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp

Modified: vmkit/trunk/include/mvm/System.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/System.h?rev=144401&r1=144400&r2=144401&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/System.h (original)
+++ vmkit/trunk/include/mvm/System.h Fri Nov 11 12:38:37 2011
@@ -214,6 +214,14 @@
   static void Exit(int value) {
     _exit(value);
   }
+
+  static bool SupportsHardwareNullCheck() {
+#if LINUX_OS && ARCH_X64
+    return true;
+#else
+    return false;
+#endif
+  }
 };
 
 }

Modified: vmkit/trunk/include/mvm/VirtualMachine.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/VirtualMachine.h?rev=144401&r1=144400&r2=144401&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/VirtualMachine.h (original)
+++ vmkit/trunk/include/mvm/VirtualMachine.h Fri Nov 11 12:38:37 2011
@@ -224,6 +224,12 @@
   /// runApplication - Run an application. The application name is in
   /// the arguments, hence it is the virtual machine's job to parse them.
   virtual void runApplication(int argc, char** argv) = 0;
+
+//===----------------------------------------------------------------------===//
+// (5) Exception-related methods.
+//===----------------------------------------------------------------------===//
+
+  virtual void nullPointerException() = 0;
 };
 
 } // end namespace mvm

Modified: vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp?rev=144401&r1=144400&r2=144401&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp Fri Nov 11 12:38:37 2011
@@ -1333,16 +1333,23 @@
 
 void JavaJIT::JITVerifyNull(Value* obj) {
   if (TheCompiler->hasExceptionsEnabled()) {
-    Constant* zero = intrinsics->JavaObjectNullConstant;
-    Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, obj, zero, "");
+    if (nbHandlers == 0 && mvm::System::SupportsHardwareNullCheck()) {
+      Value* indexes[2] = { intrinsics->constantZero, intrinsics->constantZero };
+      Value* VTPtr = GetElementPtrInst::Create(obj, indexes, "", currentBlock);
+      Instruction* VT = new LoadInst(VTPtr, "", true, currentBlock);
+      VT->setDebugLoc(DebugLoc::get(currentBytecodeIndex, 1, DbgSubprogram));
+    } else {
+      Constant* zero = intrinsics->JavaObjectNullConstant;
+      Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, obj, zero, "");
 
-    BasicBlock* exit = createBasicBlock("verifyNullExit");
-    BasicBlock* cont = createBasicBlock("verifyNullCont");
+      BasicBlock* exit = createBasicBlock("verifyNullExit");
+      BasicBlock* cont = createBasicBlock("verifyNullCont");
 
-    BranchInst::Create(exit, cont, test, currentBlock);
-    currentBlock = exit;
-    throwRuntimeException(intrinsics->NullPointerExceptionFunction, 0, 0);
-    currentBlock = cont;
+      BranchInst::Create(exit, cont, test, currentBlock);
+      currentBlock = exit;
+      throwRuntimeException(intrinsics->NullPointerExceptionFunction, 0, 0);
+      currentBlock = cont;
+    }
   } 
 }
 

Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.h?rev=144401&r1=144400&r2=144401&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.h Fri Nov 11 12:38:37 2011
@@ -268,7 +268,6 @@
   void arrayStoreException();
   void indexOutOfBounds(const JavaObject* obj, sint32 entry);
   void negativeArraySizeException(int size);
-  void nullPointerException();
   void illegalAccessException(const char* msg);
   void illegalMonitorStateException(const JavaObject* obj);
   void interruptedException(const JavaObject* obj);
@@ -287,6 +286,7 @@
   void classNotFoundException(JavaString* str);
   void noClassDefFoundError(UserClass* cl, const UTF8* name);
   void classFormatError(const char* str);
+  virtual void nullPointerException();
   
   /// asciizToStr - Constructs a java/lang/String object from the given asciiz.
   ///

Modified: vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp?rev=144401&r1=144400&r2=144401&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp Fri Nov 11 12:38:37 2011
@@ -1,4 +1,4 @@
-//===----------- Sigsegv.cc - Sigsegv default handling --------------------===//
+//===----------- Sigsegv.cpp - Sigsegv default handling -------------------===//
 //
 //                     The VMKit project
 //
@@ -8,6 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 
+#include "mvm/MethodInfo.h"
+#include "mvm/System.h"
 #include "mvm/VirtualMachine.h"
 #include "mvm/Threads/Thread.h"
 
@@ -16,51 +18,54 @@
 
 using namespace mvm;
 
-#if defined(__MACH__) && defined(__i386__)
-#include "ucontext.h"
-#endif
+#if defined(ARCH_X64) && defined(LINUX_OS)
+extern "C" {
+  void NativeHandleSignal(void);
+  asm(
+    ".text\n"
+    ".align 8\n"
+    ".globl NativeHandleSignal\n"
+  "NativeHandleSignal:\n"
+    // Save The faulting address to fake a reall method call
+    "pushq %rdi\n"
+    "jmp   ThrowNullPointerException\n"
+    );
+}
+
+#define UPDATE_REGS() \
+    ((ucontext_t*)context)->uc_mcontext.gregs[REG_RDI] = ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] + 1; \
+    ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] = (word_t)NativeHandleSignal;
 
-void sigsegvHandler(int n, siginfo_t *_info, void *context) {
-  word_t addr = (word_t)_info->si_addr;
-#if defined(__i386__)
-  struct frame {
-    struct frame *caller;
-    void         *ip;
-  };
-  
-  /* my frame */
-  struct frame *fp;
-  /* get it */
-  asm ("mov %%ebp, %0" : "=&r"(fp));
-  /* my caller */
-  struct frame *caller = fp->caller; 
-  /* preserve my caller if I return from the handler */
-  void *caller_ip = caller->ip; 
-
-#if defined(__MACH__)
-  //.gregs[REG_EIP]; /* just like it's on the stack.. */
-  caller->ip = (void *)((ucontext_t*)context)->uc_mcontext->__ss.__eip;
 #else
-  /* just like it's on the stack... */
-  caller->ip = (void *)((ucontext_t*)context)->uc_mcontext.gregs[REG_EIP]; 
-#endif
+#define UPDATE_REGS() UNIMPLEMENTED();
 #endif
 
+
+extern "C" void ThrowNullPointerException(word_t ip) {
+  mvm::Thread* th = mvm::Thread::get();
+  mvm::FrameInfo* FI = th->MyVM->IPToFrameInfo(ip);
+  if (FI->Metadata == NULL) {
+    fprintf(stderr, "Thread %p received a SIGSEGV: either the VM code or an external\n"
+                    "native method is bogus. Aborting...\n", (void*)th);
+    abort();
+  }
+  mvm::Thread::get()->MyVM->nullPointerException();
+  UNREACHABLE();
+}
+
+void sigsegvHandler(int n, siginfo_t *_info, void *context) {
   mvm::Thread* th = mvm::Thread::get();
+  word_t addr = (word_t)_info->si_addr;
   if (addr > (word_t)th->getThreadID() && addr < (word_t)th->baseSP) {
     fprintf(stderr, "Stack overflow in VM code or in JNI code. If it is from\n"
                     "the VM, it is either from the JIT, the GC or the runtime."
                     "\nThis has to be fixed in the VM: VMKit makes sure that\n"
                     "the bottom of the stack is always available when entering"
                     "\nthe VM.\n");
+    abort();
+  } else if (mvm::System::SupportsHardwareNullCheck()) {
+    UPDATE_REGS();
   } else {
-    fprintf(stderr, "Thread %p received a SIGSEGV: either the VM code or an external\n"
-                    "native method is bogus. Aborting...\n", (void*)th);
+    abort();
   }
-  th->printBacktrace();
-  abort();
-  
-#if defined(__i386__)
-  caller->ip = caller_ip; /* restore the caller ip */
-#endif
 }

Modified: vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp?rev=144401&r1=144400&r2=144401&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp Fri Nov 11 12:38:37 2011
@@ -318,6 +318,8 @@
 /// machine specific.
 StackThreadManager TheStackManager;
 
+extern void sigsegvHandler(int, siginfo_t*, void*);
+
 /// internalThreadStart - The initial function called by a thread. Sets some
 /// thread specific data, registers the thread to the GC and calls the
 /// given routine of th.
@@ -325,6 +327,15 @@
 void Thread::internalThreadStart(mvm::Thread* th) {
   th->baseSP  = System::GetCallerAddress();
 
+  // Set the SIGSEGV handler to diagnose errors.
+  struct sigaction sa;
+  sigset_t mask;
+  sigfillset(&mask);
+  sa.sa_flags = SA_SIGINFO;
+  sa.sa_mask = mask;
+  sa.sa_sigaction = sigsegvHandler;
+  sigaction(SIGSEGV, &sa, NULL);
+
   assert(th->MyVM && "VM not set in a thread");
   th->MyVM->rendezvous.addThread(th);
   th->routine(th);

Modified: vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/JIT.cpp?rev=144401&r1=144400&r2=144401&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/JIT.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/JIT.cpp Fri Nov 11 12:38:37 2011
@@ -407,6 +407,9 @@
     frame->Metadata = meta;
     frame->SourceIndex = I->Loc.getLine();
     frame->ReturnAddress = JCE->getLabelAddress(I->Label);
+    // If the safe point is fro an NPE, increment the return address to
+    // not clash with post calls.
+    if (I->Loc.getCol() == 1) frame->ReturnAddress += 1;
     int i = 0;
     for (llvm::GCFunctionInfo::live_iterator KI = FI->live_begin(I),
          KE = FI->live_end(I); KI != KE; ++KI) {

Modified: vmkit/trunk/lib/Mvm/Compiler/VmkitGC.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/VmkitGC.cpp?rev=144401&r1=144400&r2=144401&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/VmkitGC.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/VmkitGC.cpp Fri Nov 11 12:38:37 2011
@@ -10,7 +10,11 @@
 
 #include "llvm/CodeGen/GCs.h"
 #include "llvm/CodeGen/GCStrategy.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/MC/MCContext.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Target/TargetInstrInfo.h"
 
 #include "mvm/JIT.h"
 
@@ -20,6 +24,7 @@
   class VmkitGC : public GCStrategy {
   public:
     VmkitGC();
+    bool findCustomSafePoints(GCFunctionInfo& FI, MachineFunction &MF);
   };
 }
 
@@ -31,5 +36,33 @@
 X("vmkit", "VMKit GC for JIT-generated functions");
 
 VmkitGC::VmkitGC() {
-  NeededSafePoints = 1 << GC::PostCall;
+  CustomSafePoints = true;
+}
+
+static MCSymbol *InsertLabel(MachineBasicBlock &MBB, 
+                             MachineBasicBlock::iterator MI,
+                             DebugLoc DL) {
+  const TargetInstrInfo* TII = MBB.getParent()->getTarget().getInstrInfo();
+  MCSymbol *Label = MBB.getParent()->getContext().CreateTempSymbol();
+  BuildMI(MBB, MI, DL, TII->get(TargetOpcode::GC_LABEL)).addSym(Label);
+  return Label;
+}
+
+
+bool VmkitGC::findCustomSafePoints(GCFunctionInfo& FI, MachineFunction &MF) {
+  for (MachineFunction::iterator BBI = MF.begin(),
+                                 BBE = MF.end(); BBI != BBE; ++BBI) {
+    for (MachineBasicBlock::iterator MI = BBI->begin(),
+                                     ME = BBI->end(); MI != ME; ++MI) {
+      if (MI->getDesc().isCall()) {
+        MachineBasicBlock::iterator RAI = MI; ++RAI;                                
+        MCSymbol* Label = InsertLabel(*MI->getParent(), RAI, MI->getDebugLoc());
+        FI.addSafePoint(GC::PostCall, Label, MI->getDebugLoc());
+      } else if (MI->getDebugLoc().getCol() == 1) {
+        MCSymbol* Label = InsertLabel(*MI->getParent(), MI, MI->getDebugLoc());
+        FI.addSafePoint(GC::Loop, Label, MI->getDebugLoc());
+      }
+    }
+  }
+  return false;
 }

Modified: vmkit/trunk/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp?rev=144401&r1=144400&r2=144401&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp (original)
+++ vmkit/trunk/lib/Mvm/StaticGCPrinter/VmkitGCPrinter.cpp Fri Nov 11 12:38:37 2011
@@ -14,13 +14,17 @@
 #include "llvm/CodeGen/GCStrategy.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/GCMetadataPrinter.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/Module.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Target/Mangler.h"
 #include "llvm/Target/TargetData.h"
+#include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/ADT/SmallString.h"
@@ -37,6 +41,7 @@
   class VmkitAOTGC : public GCStrategy {
   public:
     VmkitAOTGC();
+    virtual bool findCustomSafePoints(GCFunctionInfo& FI, MachineFunction& MF);
   };
 }
 
@@ -44,10 +49,40 @@
 X("vmkit", "Vmkit GC for AOT-generated functions");
 
 VmkitAOTGC::VmkitAOTGC() {
-  NeededSafePoints = 1 << GC::PostCall;
+  CustomSafePoints = true;
   UsesMetadata = true;
 }
 
+
+static MCSymbol *InsertLabel(MachineBasicBlock &MBB, 
+                             MachineBasicBlock::iterator MI,
+                             DebugLoc DL) {
+  const TargetInstrInfo* TII = MBB.getParent()->getTarget().getInstrInfo();
+  MCSymbol *Label = MBB.getParent()->getContext().CreateTempSymbol();
+  BuildMI(MBB, MI, DL, TII->get(TargetOpcode::GC_LABEL)).addSym(Label);
+  return Label;
+}
+
+
+bool VmkitAOTGC::findCustomSafePoints(GCFunctionInfo& FI, MachineFunction &MF) {
+  for (MachineFunction::iterator BBI = MF.begin(),
+                                 BBE = MF.end(); BBI != BBE; ++BBI) {
+    for (MachineBasicBlock::iterator MI = BBI->begin(),
+                                     ME = BBI->end(); MI != ME; ++MI) {
+      if (MI->getDesc().isCall()) {
+        MachineBasicBlock::iterator RAI = MI; ++RAI;                                
+        MCSymbol* Label = InsertLabel(*MI->getParent(), RAI, MI->getDebugLoc());
+        FI.addSafePoint(GC::PostCall, Label, MI->getDebugLoc());
+      } else if (MI->getDebugLoc().getCol() == 1) {
+        MCSymbol* Label = InsertLabel(*MI->getParent(), MI, MI->getDebugLoc());
+        FI.addSafePoint(GC::Loop, Label, MI->getDebugLoc());
+      }
+    }
+  }
+  return false;
+}
+
+
 namespace {
 
   class VmkitAOTGCMetadataPrinter : public GCMetadataPrinter {
@@ -317,7 +352,13 @@
       }
 
       // Return address
-      AP.OutStreamer.EmitSymbolValue(J->Label, IntPtrSize, 0);
+      const MCExpr* address = MCSymbolRefExpr::Create(J->Label, AP.OutStreamer.getContext());
+      if (DL.getCol() == 1) {
+        const MCExpr* one = MCConstantExpr::Create(1, AP.OutStreamer.getContext());
+        address = MCBinaryExpr::CreateAdd(address, one, AP.OutStreamer.getContext());
+      }
+
+      AP.OutStreamer.EmitValue(address, IntPtrSize, 0);
       AP.EmitInt16(sourceIndex);
       AP.EmitInt16(FrameSize);
       AP.EmitInt16(LiveCount);




From nicolas.geoffray at lip6.fr  Sat Nov 12 00:50:26 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Sat, 12 Nov 2011 08:50:26 -0000
Subject: [vmkit-commits] [vmkit] r144456 - in /vmkit/trunk:
 include/mvm/System.h lib/Mvm/CommonThread/Sigsegv.cpp
Message-ID: <20111112085026.5937F1BE001@llvm.org>

Author: geoffray
Date: Sat Nov 12 02:50:26 2011
New Revision: 144456

URL: http://llvm.org/viewvc/llvm-project?rev=144456&view=rev
Log:
Support hardware null check on macos/x64.


Modified:
    vmkit/trunk/include/mvm/System.h
    vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp

Modified: vmkit/trunk/include/mvm/System.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/System.h?rev=144456&r1=144455&r2=144456&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/System.h (original)
+++ vmkit/trunk/include/mvm/System.h Sat Nov 12 02:50:26 2011
@@ -216,7 +216,7 @@
   }
 
   static bool SupportsHardwareNullCheck() {
-#if LINUX_OS && ARCH_X64
+#if (LINUX_OS && ARCH_X64) || (MACOS_OS && ARCH_X64)
     return true;
 #else
     return false;

Modified: vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp?rev=144456&r1=144455&r2=144456&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp Sat Nov 12 02:50:26 2011
@@ -19,6 +19,7 @@
 using namespace mvm;
 
 #if defined(ARCH_X64) && defined(LINUX_OS)
+
 extern "C" {
   void NativeHandleSignal(void);
   asm(
@@ -36,6 +37,23 @@
     ((ucontext_t*)context)->uc_mcontext.gregs[REG_RDI] = ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] + 1; \
     ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] = (word_t)NativeHandleSignal;
 
+#elif defined(ARCH_X64) && defined(MACOS_OS)
+extern "C" {
+  void NativeHandleSignal(void);
+  asm(
+    ".text\n"
+    ".align 8\n"
+    ".globl NativeHandleSignal\n"
+  "_NativeHandleSignal:\n"
+    // Save The faulting address to fake a reall method call
+    "pushq %rdi\n"
+    "jmp   _ThrowNullPointerException\n"
+    );
+}
+
+#define UPDATE_REGS() \
+    ((ucontext_t*)context)->uc_mcontext->__ss.__rdi = ((ucontext_t*)context)->uc_mcontext->__ss.__rip + 1; \
+    ((ucontext_t*)context)->uc_mcontext->__ss.__rip = (word_t)NativeHandleSignal;
 #else
 #define UPDATE_REGS() UNIMPLEMENTED();
 #endif




From nicolas.geoffray at lip6.fr  Sun Nov 13 13:54:06 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Sun, 13 Nov 2011 21:54:06 -0000
Subject: [vmkit-commits] [vmkit] r144506 - in /vmkit/trunk:
 include/mvm/System.h include/mvm/Threads/Thread.h
 include/mvm/VirtualMachine.h lib/J3/Compiler/JavaJIT.cpp
 lib/J3/VMCore/Jnjvm.cpp lib/J3/VMCore/Jnjvm.h lib/Mvm/CommonThread/Makefile
 lib/Mvm/CommonThread/Sigsegv-linux-x64.inc
 lib/Mvm/CommonThread/Sigsegv-macos-x64.inc lib/Mvm/CommonThread/Sigsegv.cpp
 lib/Mvm/CommonThread/ctthread.cpp
Message-ID: <20111113215406.CB9CA2A6C131@llvm.org>

Author: geoffray
Date: Sun Nov 13 15:54:06 2011
New Revision: 144506

URL: http://llvm.org/viewvc/llvm-project?rev=144506&view=rev
Log:
Use the segmentation fault handler to handle stack overflow errors.


Added:
    vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x64.inc
    vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-macos-x64.inc
Modified:
    vmkit/trunk/include/mvm/System.h
    vmkit/trunk/include/mvm/Threads/Thread.h
    vmkit/trunk/include/mvm/VirtualMachine.h
    vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
    vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
    vmkit/trunk/lib/J3/VMCore/Jnjvm.h
    vmkit/trunk/lib/Mvm/CommonThread/Makefile
    vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp

Modified: vmkit/trunk/include/mvm/System.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/System.h?rev=144506&r1=144505&r2=144506&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/System.h (original)
+++ vmkit/trunk/include/mvm/System.h Sun Nov 13 15:54:06 2011
@@ -127,6 +127,11 @@
     return kThreadStart;
   }
 
+  static uint32_t GetPageSize() {
+    static uint32_t pagesize = getpagesize();
+    return pagesize;
+  }
+
   static word_t GetCallerAddress() {
 #if defined(ARCH_X86) || defined(ARCH_X64)
     return (word_t)__builtin_frame_address(0);
@@ -215,13 +220,8 @@
     _exit(value);
   }
 
-  static bool SupportsHardwareNullCheck() {
-#if (LINUX_OS && ARCH_X64) || (MACOS_OS && ARCH_X64)
-    return true;
-#else
-    return false;
-#endif
-  }
+  static bool SupportsHardwareNullCheck();
+  static bool SupportsHardwareStackOverflow();
 };
 
 }

Modified: vmkit/trunk/include/mvm/Threads/Thread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=144506&r1=144505&r2=144506&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/Threads/Thread.h (original)
+++ vmkit/trunk/include/mvm/Threads/Thread.h Sun Nov 13 15:54:06 2011
@@ -279,6 +279,24 @@
   void endKnownFrame();
   void startUnknownFrame(KnownFrame& F) __attribute__ ((noinline));
   void endUnknownFrame();
+
+  word_t GetAlternativeStackEnd() {
+    return (word_t)this + System::GetPageSize();
+  }
+
+  word_t GetAlternativeStackStart() {
+    return GetAlternativeStackEnd() + GetAlternativeStackSize();
+  }
+
+  static word_t GetAlternativeStackSize() {
+    return 3 * System::GetPageSize();
+  }
+
+  bool IsStackOverflowAddr(word_t addr) {
+    word_t stackOverflowCheck = GetAlternativeStackStart();
+    return addr > stackOverflowCheck &&
+      addr <= stackOverflowCheck + System::GetPageSize();
+  }
 };
 
 class ExceptionBuffer {

Modified: vmkit/trunk/include/mvm/VirtualMachine.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/VirtualMachine.h?rev=144506&r1=144505&r2=144506&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/VirtualMachine.h (original)
+++ vmkit/trunk/include/mvm/VirtualMachine.h Sun Nov 13 15:54:06 2011
@@ -230,6 +230,7 @@
 //===----------------------------------------------------------------------===//
 
   virtual void nullPointerException() = 0;
+  virtual void stackOverflowError() = 0;
 };
 
 } // end namespace mvm

Modified: vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp?rev=144506&r1=144505&r2=144506&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp Sun Nov 13 15:54:06 2011
@@ -1120,7 +1120,8 @@
     currentBlock = continueBlock;
   }
   
-  if (TheCompiler->hasExceptionsEnabled()) {
+  if (TheCompiler->hasExceptionsEnabled() &&
+      !mvm::System::SupportsHardwareStackOverflow()) {
     // Variables have been allocated and the lock has been taken. Do the stack
     // check now: if there is an exception, we will go to the lock release code.
     currentExceptionBlock = opcodeInfos[0].exceptionBlock;

Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp?rev=144506&r1=144505&r2=144506&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp Sun Nov 13 15:54:06 2011
@@ -357,6 +357,11 @@
   return obj;
 }
 
+void Jnjvm::stackOverflowError() {
+  JavaThread::get()->throwException(CreateStackOverflowError());
+  UNREACHABLE();
+}
+
 JavaObject* Jnjvm::CreateArrayStoreException(JavaVirtualTable* VT) {
   JavaString* str = NULL;
   llvm_gcroot(str, 0);

Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.h?rev=144506&r1=144505&r2=144506&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.h Sun Nov 13 15:54:06 2011
@@ -287,6 +287,7 @@
   void noClassDefFoundError(UserClass* cl, const UTF8* name);
   void classFormatError(const char* str);
   virtual void nullPointerException();
+  virtual void stackOverflowError();
   
   /// asciizToStr - Constructs a java/lang/String object from the given asciiz.
   ///

Modified: vmkit/trunk/lib/Mvm/CommonThread/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/Makefile?rev=144506&r1=144505&r2=144506&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/Makefile (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/Makefile Sun Nov 13 15:54:06 2011
@@ -8,6 +8,8 @@
 ##===----------------------------------------------------------------------===##
 LEVEL = ../../..
 
+EXTRA_DIST = Sigsegv-linux-x64.inc Sigsegv-macos-x64.inc
+
 include $(LEVEL)/Makefile.config
 
 MODULE_WITH_GC = CommonThread

Added: vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x64.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x64.inc?rev=144506&view=auto
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x64.inc (added)
+++ vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x64.inc Sun Nov 13 15:54:06 2011
@@ -0,0 +1,53 @@
+//===-------- Sigsegv-linux-x64.inc - Sigsegv handling --------------------===//
+//
+//                     The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source 
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+extern "C" {
+  void HandleNullPointer(void);
+  asm(
+    ".text\n"
+    ".align 8\n"
+    ".globl HandleNullPointer\n"
+  "HandleNullPointer:\n"
+    // Save the faulting address to fake a real method call.
+    "pushq %rdi\n"
+    "jmp   ThrowNullPointerException\n"
+    );
+  
+  void HandleStackOverflow(void);
+  asm(
+    ".text\n"
+    ".align 8\n"
+    ".globl HandleStackOverflow\n"
+  "HandleStackOverflow:\n"
+    "pushq %rbp\n"
+    "movq %rsi, %rbp\n"
+    "callq   ThrowStackOverflowError\n"
+    );
+}
+
+void Handler::UpdateRegistersForNPE() {
+  ((ucontext_t*)context)->uc_mcontext.gregs[REG_RDI] = ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] + 1;
+  ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] = (word_t)HandleNullPointer;
+}
+
+void Handler::UpdateRegistersForStackOverflow() {
+  word_t alt_stack = mvm::Thread::get()->GetAlternativeStackStart();
+  ((ucontext_t*)context)->uc_mcontext.gregs[REG_RDI] = System::GetIPFromCallerAddress(((ucontext_t*)context)->uc_mcontext.gregs[REG_RBP]);
+  ((ucontext_t*)context)->uc_mcontext.gregs[REG_RSI] = ((ucontext_t*)context)->uc_mcontext.gregs[REG_RBP];
+  ((ucontext_t*)context)->uc_mcontext.gregs[REG_RSP] = alt_stack;
+  ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] = (word_t)HandleStackOverflow;
+}
+
+bool System::SupportsHardwareNullCheck() {
+  return true;
+}
+
+bool System::SupportsHardwareStackOverflow() {
+  return true;
+}

Added: vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-macos-x64.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-macos-x64.inc?rev=144506&view=auto
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-macos-x64.inc (added)
+++ vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-macos-x64.inc Sun Nov 13 15:54:06 2011
@@ -0,0 +1,38 @@
+//---------- Sigsegv-macos-x64.inc - Sigsegv handling ---------------------===//
+//
+//                     The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source 
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+extern "C" {
+  void HandleNullPointer(void);
+  asm(
+    ".text\n"
+    ".align 8\n"
+    ".globl HandleNullPointer\n"
+  "_HandleNullPointer:\n"
+    // Save the faulting address to fake a real method call.
+    "pushq %rdi\n"
+    "jmp   _ThrowNullPointerException\n"
+    );
+}
+
+void Handler::UpdateRegistersForNPE() {
+  ((ucontext_t*)context)->uc_mcontext->__ss.__rdi = ((ucontext_t*)context)->uc_mcontext->__ss.__rip + 1;
+  ((ucontext_t*)context)->uc_mcontext->__ss.__rip = (word_t)HandleNullPointer;
+}
+
+void Handler::UpdateRegistersForStackOverflow() {
+  UNREACHABLE();
+}
+
+bool System::SupportsHardwareNullCheck() {
+  return true;
+}
+
+bool System::SupportsHardwareStackOverflow() {
+  return false;
+}

Modified: vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp?rev=144506&r1=144505&r2=144506&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp Sun Nov 13 15:54:06 2011
@@ -18,46 +18,50 @@
 
 using namespace mvm;
 
-#if defined(ARCH_X64) && defined(LINUX_OS)
-
-extern "C" {
-  void NativeHandleSignal(void);
-  asm(
-    ".text\n"
-    ".align 8\n"
-    ".globl NativeHandleSignal\n"
-  "NativeHandleSignal:\n"
-    // Save The faulting address to fake a reall method call
-    "pushq %rdi\n"
-    "jmp   ThrowNullPointerException\n"
-    );
-}
-
-#define UPDATE_REGS() \
-    ((ucontext_t*)context)->uc_mcontext.gregs[REG_RDI] = ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] + 1; \
-    ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] = (word_t)NativeHandleSignal;
+namespace {
+  class Handler {
+    void* context;
+  public:
+    Handler(void* ucontext): context(ucontext) {}
+    void UpdateRegistersForNPE();
+    void UpdateRegistersForStackOverflow();
+  };
+}
 
+#if defined(ARCH_X64) && defined(LINUX_OS)
+#include "Sigsegv-linux-x64.inc"
 #elif defined(ARCH_X64) && defined(MACOS_OS)
-extern "C" {
-  void NativeHandleSignal(void);
-  asm(
-    ".text\n"
-    ".align 8\n"
-    ".globl NativeHandleSignal\n"
-  "_NativeHandleSignal:\n"
-    // Save The faulting address to fake a reall method call
-    "pushq %rdi\n"
-    "jmp   _ThrowNullPointerException\n"
-    );
-}
-
-#define UPDATE_REGS() \
-    ((ucontext_t*)context)->uc_mcontext->__ss.__rdi = ((ucontext_t*)context)->uc_mcontext->__ss.__rip + 1; \
-    ((ucontext_t*)context)->uc_mcontext->__ss.__rip = (word_t)NativeHandleSignal;
+#include "Sigsegv-macos-x64.inc"
 #else
-#define UPDATE_REGS() UNIMPLEMENTED();
+void Handler::UpdateRegistersForStackOverflow() {
+  UNREACHABLE();
+}
+
+void Handler::UpdateRegistersForNPE() {
+  UNREACHABLE();
+}
+
+bool System::SupportsHardwareNullCheck() {
+  return false;
+}
+
+bool System::SupportsHardwareStackOverflow() {
+  return false;
+}
 #endif
 
+extern "C" void ThrowStackOverflowError(word_t ip, word_t fp) {
+  mvm::Thread* th = mvm::Thread::get();
+  mvm::FrameInfo* FI = th->MyVM->IPToFrameInfo(ip);
+  if (FI->Metadata == NULL) {
+    fprintf(stderr, "Thread %p received a SIGSEGV: either the VM code or an external\n"
+                    "native method is bogus. Aborting...\n", (void*)th);
+    abort();
+  } else {
+    mvm::Thread::get()->MyVM->stackOverflowError();
+  }
+  UNREACHABLE();
+}
 
 extern "C" void ThrowNullPointerException(word_t ip) {
   mvm::Thread* th = mvm::Thread::get();
@@ -66,24 +70,34 @@
     fprintf(stderr, "Thread %p received a SIGSEGV: either the VM code or an external\n"
                     "native method is bogus. Aborting...\n", (void*)th);
     abort();
+  } else {
+    mvm::Thread::get()->MyVM->nullPointerException();
   }
-  mvm::Thread::get()->MyVM->nullPointerException();
   UNREACHABLE();
 }
 
-void sigsegvHandler(int n, siginfo_t *_info, void *context) {
+void sigsegvHandler(int n, siginfo_t *info, void *context) {
+  Handler handler(context);
   mvm::Thread* th = mvm::Thread::get();
-  word_t addr = (word_t)_info->si_addr;
-  if (addr > (word_t)th->getThreadID() && addr < (word_t)th->baseSP) {
-    fprintf(stderr, "Stack overflow in VM code or in JNI code. If it is from\n"
-                    "the VM, it is either from the JIT, the GC or the runtime."
-                    "\nThis has to be fixed in the VM: VMKit makes sure that\n"
-                    "the bottom of the stack is always available when entering"
-                    "\nthe VM.\n");
-    abort();
-  } else if (mvm::System::SupportsHardwareNullCheck()) {
-    UPDATE_REGS();
+  word_t addr = (word_t)info->si_addr;
+  if (th->IsStackOverflowAddr(addr)) {
+    if (mvm::System::SupportsHardwareStackOverflow()) {
+      handler.UpdateRegistersForStackOverflow();
+    } else {
+      fprintf(stderr, "Stack overflow in VM code or in JNI code. If it is from\n"
+                      "the VM, it is either from the JIT, the GC or the runtime."
+                      "\nThis has to be fixed in the VM: VMKit makes sure that\n"
+                      "the bottom of the stack is always available when entering"
+                      "\nthe VM.\n");
+      abort();
+    }
   } else {
-    abort();
+    if (mvm::System::SupportsHardwareNullCheck()) {
+      handler.UpdateRegistersForNPE();
+    } else {
+      fprintf(stderr, "Thread %p received a SIGSEGV: either the VM code or an external\n"
+                      "native method is bogus. Aborting...\n", (void*)th);
+      abort();
+    }
   }
 }

Modified: vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp?rev=144506&r1=144505&r2=144506&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp Sun Nov 13 15:54:06 2011
@@ -278,12 +278,11 @@
       abort();
     }
  
-    // Protect the page after the first page. The first page contains thread
-    // specific data. The second page has no access rights to catch stack
-    // overflows.
-    uint32 pagesize = getpagesize();
+    // Protect the page after the alternative stack.
+    uint32 pagesize = System::GetPageSize();
     for (uint32 i = 0; i < NR_THREADS; ++i) {
-      word_t addr = baseAddr + (i * STACK_SIZE) + pagesize;
+      word_t addr = baseAddr + (i * STACK_SIZE) + pagesize
+        + mvm::Thread::GetAlternativeStackSize();
       mprotect((void*)addr, pagesize, PROT_NONE);
     }
 
@@ -327,11 +326,19 @@
 void Thread::internalThreadStart(mvm::Thread* th) {
   th->baseSP  = System::GetCallerAddress();
 
+  // Set the alternate stack as the second page of the thread's
+  // stack.
+  stack_t st;
+  st.ss_sp = (void*)th->GetAlternativeStackEnd();
+  st.ss_flags = 0;
+  st.ss_size = th->GetAlternativeStackSize();
+  sigaltstack(&st, NULL);
+
   // Set the SIGSEGV handler to diagnose errors.
   struct sigaction sa;
   sigset_t mask;
   sigfillset(&mask);
-  sa.sa_flags = SA_SIGINFO;
+  sa.sa_flags = SA_SIGINFO | SA_ONSTACK;
   sa.sa_mask = mask;
   sa.sa_sigaction = sigsegvHandler;
   sigaction(SIGSEGV, &sa, NULL);




From wdietz2 at illinois.edu  Sun Nov 13 16:12:24 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sun, 13 Nov 2011 18:12:24 -0600
Subject: [vmkit-commits] Breakage on trunk?
In-Reply-To: <CAKGWAO-07HNDR9nyb6ZKUZ4gcddkTOVaRStA43nXkbWtX12M3w@mail.gmail.com>
References: <CAKGWAO-07HNDR9nyb6ZKUZ4gcddkTOVaRStA43nXkbWtX12M3w@mail.gmail.com>
Message-ID: <CAKGWAO98t0oY9WDNyTOKw_aRHM4piCk5ha=AKcJuiS0UKb15Wg@mail.gmail.com>

Hi,

I'm not sure what change introduced this, but as of r144456 I cannot
do a from-clean build on any of {32,64}x{classpath,openjdk}.  All
failures happen while building mmtk.

I'm building against LLVM r144492 for what it's worth.

The 32bit variants fail in the very first call to j3ResolveStaticStub
(which is the 1st or 2nd java instruction executed in both runtime
ports), with the following assertion failure:

vmjc: /home/will/vmkit-svn/lib/J3/VMCore/JavaRuntimeJIT.cpp:436: void
*j3ResolveStaticStub(): Assertion `FI->Metadata != __null && "Wrong
stack trace"' failed.

The 64bit variants fail later in the mmtk build process, with the following:

Thread 0x110000000 received a SIGSEGV: either the VM code or an external
native method is bogus. Aborting...

I believe this failure point is the same in both--its when the first
NullPointerException is thrown.

Interestingly, the 64bit builds *do* work when changing
"SupportsHardwareNullCheck" to 'false' in System.h.  Once MMTk is
built, re-enabling the hardware null checks seems to work great
(dacapo, etc).

(As an aside, the hardware null checks result in significantly faster
execution times! ~22s instead of 33s on dacapo's antlr, for example!).

Anyway, does anyone else see these failures or have any ideas towards
their cause?

Thanks!

~Will



From nicolas.geoffray at gmail.com  Mon Nov 14 00:15:26 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Mon, 14 Nov 2011 09:15:26 +0100
Subject: [vmkit-commits] Breakage on trunk?
In-Reply-To: <CAKGWAO98t0oY9WDNyTOKw_aRHM4piCk5ha=AKcJuiS0UKb15Wg@mail.gmail.com>
References: <CAKGWAO-07HNDR9nyb6ZKUZ4gcddkTOVaRStA43nXkbWtX12M3w@mail.gmail.com>
	<CAKGWAO98t0oY9WDNyTOKw_aRHM4piCk5ha=AKcJuiS0UKb15Wg@mail.gmail.com>
Message-ID: <CAPYwfioypy_Uk6hKP_Or6JfF9y6QJmfoqh5LB8rp39HA5ZGKuw@mail.gmail.com>

I think I know what's going on. Thanks for the bug report and sorry for the
breakage Will. I'm working on a fix for today.

On Mon, Nov 14, 2011 at 1:12 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Hi,
>
> I'm not sure what change introduced this, but as of r144456 I cannot
> do a from-clean build on any of {32,64}x{classpath,openjdk}.  All
> failures happen while building mmtk.
>
> I'm building against LLVM r144492 for what it's worth.
>
> The 32bit variants fail in the very first call to j3ResolveStaticStub
> (which is the 1st or 2nd java instruction executed in both runtime
> ports), with the following assertion failure:
>
> vmjc: /home/will/vmkit-svn/lib/J3/VMCore/JavaRuntimeJIT.cpp:436: void
> *j3ResolveStaticStub(): Assertion `FI->Metadata != __null && "Wrong
> stack trace"' failed.
>
> The 64bit variants fail later in the mmtk build process, with the
> following:
>
> Thread 0x110000000 received a SIGSEGV: either the VM code or an external
> native method is bogus. Aborting...
>
> I believe this failure point is the same in both--its when the first
> NullPointerException is thrown.
>
> Interestingly, the 64bit builds *do* work when changing
> "SupportsHardwareNullCheck" to 'false' in System.h.  Once MMTk is
> built, re-enabling the hardware null checks seems to work great
> (dacapo, etc).
>
> (As an aside, the hardware null checks result in significantly faster
> execution times! ~22s instead of 33s on dacapo's antlr, for example!).
>
> Anyway, does anyone else see these failures or have any ideas towards
> their cause?
>
> Thanks!
>
> ~Will
>
> _______________________________________________
> 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/20111114/1a3d7e8d/attachment.html>

From nicolas.geoffray at lip6.fr  Mon Nov 14 03:46:22 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Mon, 14 Nov 2011 11:46:22 -0000
Subject: [vmkit-commits] [vmkit] r144534 -
	/vmkit/trunk/mmtk/magic/LowerMagic.cpp
Message-ID: <20111114114622.1CE3A2A6C131@llvm.org>

Author: geoffray
Date: Mon Nov 14 05:46:21 2011
New Revision: 144534

URL: http://llvm.org/viewvc/llvm-project?rev=144534&view=rev
Log:
Unbreak MMTk compilation by recognizing the hardware null check instruction.


Modified:
    vmkit/trunk/mmtk/magic/LowerMagic.cpp

Modified: vmkit/trunk/mmtk/magic/LowerMagic.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/magic/LowerMagic.cpp?rev=144534&r1=144533&r2=144534&view=diff
==============================================================================
--- vmkit/trunk/mmtk/magic/LowerMagic.cpp (original)
+++ vmkit/trunk/mmtk/magic/LowerMagic.cpp Mon Nov 14 05:46:21 2011
@@ -20,6 +20,8 @@
 
 #include <cstdio>
 
+#include "mvm/System.h"
+
 using namespace llvm;
 
 namespace vmmagic {
@@ -353,21 +355,39 @@
 
 
 static bool removePotentialNullCheck(BasicBlock* Cur, Value* Obj) {
-  BasicBlock* BB = Cur->getUniquePredecessor();
-  LLVMContext& Context = Cur->getParent()->getContext();
-  if (BB) {
-    Instruction* T = BB->getTerminator();
-    if (dyn_cast<BranchInst>(T) && T != BB->begin()) {
-      BasicBlock::iterator BIE = BB->end();
-      --BIE; // Terminator
-      --BIE; // Null test
-      if (ICmpInst* IE = dyn_cast<ICmpInst>(BIE)) {
-        if (IE->getPredicate() == ICmpInst::ICMP_EQ &&
-            IE->getOperand(0) == Obj &&
-            IE->getOperand(1) == Constant::getNullValue(Obj->getType())) {
-          BIE->replaceAllUsesWith(ConstantInt::getFalse(Context));
-          BIE->eraseFromParent();
-          return true;
+  if (!Obj->getType()->isPointerTy()) return false;
+
+  if (mvm::System::SupportsHardwareNullCheck()) {
+    for (Value::use_iterator I = Obj->use_begin(), E = Obj->use_end(); I != E; I++) {
+      if (GetElementPtrInst* GE = dyn_cast<GetElementPtrInst>(*I)) {
+        for (Value::use_iterator II = GE->use_begin(), EE = GE->use_end(); II != EE; II++) {
+          if (LoadInst* LI = dyn_cast<LoadInst>(*II)) {
+            if (LI->isVolatile()) {
+              assert(LI->use_empty());
+              LI->eraseFromParent();
+              return true;
+            }
+          }
+        }
+      }
+    }
+  } else {
+    BasicBlock* BB = Cur->getUniquePredecessor();
+    LLVMContext& Context = Cur->getParent()->getContext();
+    if (BB) {
+      Instruction* T = BB->getTerminator();
+      if (dyn_cast<BranchInst>(T) && T != BB->begin()) {
+        BasicBlock::iterator BIE = BB->end();
+        --BIE; // Terminator
+        --BIE; // Null test
+        if (ICmpInst* IE = dyn_cast<ICmpInst>(BIE)) {
+          if (IE->getPredicate() == ICmpInst::ICMP_EQ &&
+              IE->getOperand(0) == Obj &&
+              IE->getOperand(1) == Constant::getNullValue(Obj->getType())) {
+            BIE->replaceAllUsesWith(ConstantInt::getFalse(Context));
+            BIE->eraseFromParent();
+            return true;
+          }
         }
       }
     }




From nicolas.geoffray at gmail.com  Mon Nov 14 03:59:06 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Mon, 14 Nov 2011 12:59:06 +0100
Subject: [vmkit-commits] Breakage on trunk?
In-Reply-To: <CAPYwfioypy_Uk6hKP_Or6JfF9y6QJmfoqh5LB8rp39HA5ZGKuw@mail.gmail.com>
References: <CAKGWAO-07HNDR9nyb6ZKUZ4gcddkTOVaRStA43nXkbWtX12M3w@mail.gmail.com>
	<CAKGWAO98t0oY9WDNyTOKw_aRHM4piCk5ha=AKcJuiS0UKb15Wg@mail.gmail.com>
	<CAPYwfioypy_Uk6hKP_Or6JfF9y6QJmfoqh5LB8rp39HA5ZGKuw@mail.gmail.com>
Message-ID: <CAPYwfiq9u1U-ogSNgvuv01-JCoj+dayZiEpeUdY+mnfXhBBcWA@mail.gmail.com>

Fixed! http://llvm.org/viewvc/llvm-project?rev=144534&view=rev

On Mon, Nov 14, 2011 at 9:15 AM, Nicolas Geoffray <
nicolas.geoffray at gmail.com> wrote:

> I think I know what's going on. Thanks for the bug report and sorry for
> the breakage Will. I'm working on a fix for today.
>
>
> On Mon, Nov 14, 2011 at 1:12 AM, Will Dietz <wdietz2 at illinois.edu> wrote:
>
>> Hi,
>>
>> I'm not sure what change introduced this, but as of r144456 I cannot
>> do a from-clean build on any of {32,64}x{classpath,openjdk}.  All
>> failures happen while building mmtk.
>>
>> I'm building against LLVM r144492 for what it's worth.
>>
>> The 32bit variants fail in the very first call to j3ResolveStaticStub
>> (which is the 1st or 2nd java instruction executed in both runtime
>> ports), with the following assertion failure:
>>
>> vmjc: /home/will/vmkit-svn/lib/J3/VMCore/JavaRuntimeJIT.cpp:436: void
>> *j3ResolveStaticStub(): Assertion `FI->Metadata != __null && "Wrong
>> stack trace"' failed.
>>
>> The 64bit variants fail later in the mmtk build process, with the
>> following:
>>
>> Thread 0x110000000 received a SIGSEGV: either the VM code or an external
>> native method is bogus. Aborting...
>>
>> I believe this failure point is the same in both--its when the first
>> NullPointerException is thrown.
>>
>> Interestingly, the 64bit builds *do* work when changing
>> "SupportsHardwareNullCheck" to 'false' in System.h.  Once MMTk is
>> built, re-enabling the hardware null checks seems to work great
>> (dacapo, etc).
>>
>> (As an aside, the hardware null checks result in significantly faster
>> execution times! ~22s instead of 33s on dacapo's antlr, for example!).
>>
>> Anyway, does anyone else see these failures or have any ideas towards
>> their cause?
>>
>> Thanks!
>>
>> ~Will
>>
>> _______________________________________________
>> 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/20111114/351b4acc/attachment.html>

From nicolas.geoffray at gmail.com  Mon Nov 14 06:29:35 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Mon, 14 Nov 2011 15:29:35 +0100
Subject: [vmkit-commits] Renaming
In-Reply-To: <CAPYwfirOftiCH0Ww8mVya00nKoxOM=qLSCTwYQSiM64uZaTm=w@mail.gmail.com>
References: <CAOWuPDcvLXMNA+qZu_RFrsTQFdY2eiWhevpX13bsunf2g1=6gw@mail.gmail.com>
	<CAPYwfirOftiCH0Ww8mVya00nKoxOM=qLSCTwYQSiM64uZaTm=w@mail.gmail.com>
Message-ID: <CAPYwfirvKSoejPD9o_0XAcrOj3sNbGCapKudJuVMJYGUaT7Rdg@mail.gmail.com>

Hi Gael,

I don't have any changes that I'd like to get in before your changes, so
for me you're good to go. Any estimate on where you're going to land it?

Nicolas

On Fri, Nov 11, 2011 at 12:32 AM, Nicolas Geoffray <
nicolas.geoffray at gmail.com> wrote:

> Hi Gael!
>
> There's a big change I'd like to commit before the refactoring. Could you
> do the changes on Monday instead? Thanks!
>
> Nicolas
>
>
> On Thu, Nov 10, 2011 at 4:18 PM, Gaël Thomas <gael.thomas at lip6.fr> wrote:
>
>> Hi all!
>>
>> I will make some changes in the global design of vmkit: I will mainly
>> rename the package mvm into vmkit and replace all the names that
>> contain mvm to use vmkit. I will also modify the directories (Mvm will
>> be vmkit and include/mvm/*, include/mvm/Threads/*, include/mvm/* will
>> be in include/vmkit/*). If you have pending changes to commit (or even
>> pending branches!), be careful :). I will probably make these updates
>> on friday during the day, if you want, I can wait,
>>
>> Gaël
>>
>>
>>
>>
>> --
>>
>> -------------------------------------------------------------------------------------------------
>> Gaël Thomas, Associate Professor,
>> University of Pierre and Marie Curie
>> Boite courrier 169, 217 - 26-00, REGAL Team, INRIA/LIP6,
>> 4, place Jussieu, 75252 Paris Cedex 05, France
>> Web: http://pagesperso-systeme.lip6.fr/Gael.Thomas/
>> Phone (mob): +33 6 10 39 31 17           Fax : +33 1 44 27 70 00
>>
>> -------------------------------------------------------------------------------------------------
>>
>> _______________________________________________
>> 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/20111114/c9938986/attachment.html>

From nicolas.geoffray at lip6.fr  Tue Nov 15 09:50:02 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Tue, 15 Nov 2011 17:50:02 -0000
Subject: [vmkit-commits] [vmkit] r144651 - in /vmkit/trunk/lib/J3/VMCore:
	JavaArray.cpp JavaArray.h
Message-ID: <20111115175002.1BA742A6C131@llvm.org>

Author: geoffray
Date: Tue Nov 15 11:50:01 2011
New Revision: 144651

URL: http://llvm.org/viewvc/llvm-project?rev=144651&view=rev
Log:
Remove warnings on 32bits.


Modified:
    vmkit/trunk/lib/J3/VMCore/JavaArray.cpp
    vmkit/trunk/lib/J3/VMCore/JavaArray.h

Modified: vmkit/trunk/lib/J3/VMCore/JavaArray.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaArray.cpp?rev=144651&r1=144650&r2=144651&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaArray.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaArray.cpp Tue Nov 15 11:50:01 2011
@@ -38,7 +38,7 @@
 void ArrayObject::setElement(ArrayObject* self, JavaObject* value, uint32_t i) {
   llvm_gcroot(self, 0);
   llvm_gcroot(value, 0);
-  assert(i < self->size);
+  assert((ssize_t)i < self->size);
   if (value != NULL) assert(value->getVirtualTable());
   mvm::Collector::objectReferenceArrayWriteBarrier(
       (gc*)self, (gc**)&(self->elements[i]), (gc*)value);

Modified: vmkit/trunk/lib/J3/VMCore/JavaArray.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaArray.h?rev=144651&r1=144650&r2=144651&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaArray.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaArray.h Tue Nov 15 11:50:01 2011
@@ -53,13 +53,13 @@
   
   static T getElement(const TJavaArray* self, uint32_t i) {
     llvm_gcroot(self, 0);
-    assert(i < self->size);
+    assert((ssize_t)i < self->size);
     return self->elements[i];
   }
 
   static void setElement(TJavaArray* self, T value, uint32_t i) {
     llvm_gcroot(self, 0);
-    assert(i < self->size);
+    assert((ssize_t)i < self->size);
     self->elements[i] = value;
   }
 
@@ -94,7 +94,7 @@
   
   static JavaObject* getElement(const ArrayObject* self, uint32_t i) {
     llvm_gcroot(self, 0);
-    assert(i < self->size);
+    assert((ssize_t)i < self->size);
     return self->elements[i];
   }
 




From nicolas.geoffray at lip6.fr  Tue Nov 15 10:55:49 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Tue, 15 Nov 2011 18:55:49 -0000
Subject: [vmkit-commits] [vmkit] r144667 - in
 /vmkit/trunk/lib/Mvm/CommonThread: Makefile Sigsegv-linux-x86.inc
 Sigsegv.cpp
Message-ID: <20111115185549.F07912A6C131@llvm.org>

Author: geoffray
Date: Tue Nov 15 12:55:49 2011
New Revision: 144667

URL: http://llvm.org/viewvc/llvm-project?rev=144667&view=rev
Log:
Support hardware NPE and stack overflow on linux/x86.


Added:
    vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x86.inc
      - copied, changed from r144574, vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x64.inc
Modified:
    vmkit/trunk/lib/Mvm/CommonThread/Makefile
    vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp

Modified: vmkit/trunk/lib/Mvm/CommonThread/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/Makefile?rev=144667&r1=144666&r2=144667&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/Makefile (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/Makefile Tue Nov 15 12:55:49 2011
@@ -8,7 +8,7 @@
 ##===----------------------------------------------------------------------===##
 LEVEL = ../../..
 
-EXTRA_DIST = Sigsegv-linux-x64.inc Sigsegv-macos-x64.inc
+EXTRA_DIST = Sigsegv-linux-x64.inc Sigsegv-macos-x64.inc Sigsegv-linux-x86.inc
 
 include $(LEVEL)/Makefile.config
 

Copied: vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x86.inc (from r144574, vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x64.inc)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x86.inc?p2=vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x86.inc&p1=vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x64.inc&r1=144574&r2=144667&rev=144667&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x64.inc (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-linux-x86.inc Tue Nov 15 12:55:49 2011
@@ -14,8 +14,9 @@
     ".align 8\n"
     ".globl HandleNullPointer\n"
   "HandleNullPointer:\n"
+    "push %eax\n"
     // Save the faulting address to fake a real method call.
-    "pushq %rdi\n"
+    "push %eax\n"
     "jmp   ThrowNullPointerException\n"
     );
   
@@ -25,23 +26,24 @@
     ".align 8\n"
     ".globl HandleStackOverflow\n"
   "HandleStackOverflow:\n"
-    "pushq %rbp\n"
-    "movq %rsi, %rbp\n"
-    "callq   ThrowStackOverflowError\n"
+    "push %ebp\n"
+    "mov %eax, %ebp\n"
+    "push %ebx\n"
+    "call   ThrowStackOverflowError\n"
     );
 }
 
 void Handler::UpdateRegistersForNPE() {
-  ((ucontext_t*)context)->uc_mcontext.gregs[REG_RDI] = ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] + 1;
-  ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] = (word_t)HandleNullPointer;
+  ((ucontext_t*)context)->uc_mcontext.gregs[REG_EAX] = ((ucontext_t*)context)->uc_mcontext.gregs[REG_EIP] + 1;
+  ((ucontext_t*)context)->uc_mcontext.gregs[REG_EIP] = (word_t)HandleNullPointer;
 }
 
 void Handler::UpdateRegistersForStackOverflow() {
   word_t alt_stack = mvm::Thread::get()->GetAlternativeStackStart();
-  ((ucontext_t*)context)->uc_mcontext.gregs[REG_RDI] = System::GetIPFromCallerAddress(((ucontext_t*)context)->uc_mcontext.gregs[REG_RBP]);
-  ((ucontext_t*)context)->uc_mcontext.gregs[REG_RSI] = ((ucontext_t*)context)->uc_mcontext.gregs[REG_RBP];
-  ((ucontext_t*)context)->uc_mcontext.gregs[REG_RSP] = alt_stack;
-  ((ucontext_t*)context)->uc_mcontext.gregs[REG_RIP] = (word_t)HandleStackOverflow;
+  ((ucontext_t*)context)->uc_mcontext.gregs[REG_EBX] = System::GetIPFromCallerAddress(((ucontext_t*)context)->uc_mcontext.gregs[REG_EBP]);
+  ((ucontext_t*)context)->uc_mcontext.gregs[REG_EAX] = ((ucontext_t*)context)->uc_mcontext.gregs[REG_EBP];
+  ((ucontext_t*)context)->uc_mcontext.gregs[REG_ESP] = alt_stack;
+  ((ucontext_t*)context)->uc_mcontext.gregs[REG_EIP] = (word_t)HandleStackOverflow;
 }
 
 bool System::SupportsHardwareNullCheck() {

Modified: vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp?rev=144667&r1=144666&r2=144667&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp Tue Nov 15 12:55:49 2011
@@ -30,6 +30,8 @@
 
 #if defined(ARCH_X64) && defined(LINUX_OS)
 #include "Sigsegv-linux-x64.inc"
+#elif defined(ARCH_X86) && defined(LINUX_OS)
+#include "Sigsegv-linux-x86.inc"
 #elif defined(ARCH_X64) && defined(MACOS_OS)
 #include "Sigsegv-macos-x64.inc"
 #else
@@ -50,7 +52,7 @@
 }
 #endif
 
-extern "C" void ThrowStackOverflowError(word_t ip, word_t fp) {
+extern "C" void ThrowStackOverflowError(word_t ip) {
   mvm::Thread* th = mvm::Thread::get();
   mvm::FrameInfo* FI = th->MyVM->IPToFrameInfo(ip);
   if (FI->Metadata == NULL) {




From nicolas.geoffray at lip6.fr  Tue Nov 15 11:59:47 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Tue, 15 Nov 2011 19:59:47 -0000
Subject: [vmkit-commits] [vmkit] r144686 - in /vmkit/trunk:
 include/mvm/System.h include/mvm/Threads/Thread.h
 lib/Mvm/CommonThread/ctthread.cpp
Message-ID: <20111115195947.8B62D2A6C131@llvm.org>

Author: geoffray
Date: Tue Nov 15 13:59:47 2011
New Revision: 144686

URL: http://llvm.org/viewvc/llvm-project?rev=144686&view=rev
Log:
Move GetAlternativeStackSize in System, and remove the use of a magic constant.


Modified:
    vmkit/trunk/include/mvm/System.h
    vmkit/trunk/include/mvm/Threads/Thread.h
    vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp

Modified: vmkit/trunk/include/mvm/System.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/System.h?rev=144686&r1=144685&r2=144686&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/System.h (original)
+++ vmkit/trunk/include/mvm/System.h Tue Nov 15 13:59:47 2011
@@ -13,6 +13,7 @@
 #include <csetjmp>
 #include <cstring>
 #include <dlfcn.h>
+#include <signal.h>
 #include <stdint.h>
 #include <unistd.h>
 
@@ -112,6 +113,22 @@
     return ptr;
   }
 
+  static bool IsPageAligned(word_t ptr) {
+    return (ptr & (GetPageSize() - 1)) == 0;
+  }
+
+  static word_t PageAlignUp(word_t ptr) {
+    if (!IsPageAligned(ptr)) {
+      return (ptr & ~(GetPageSize() - 1)) + GetPageSize();
+    }
+    return ptr;
+  }
+
+  static word_t GetAlternativeStackSize() {
+    static word_t size = PageAlignUp(SIGSTKSZ);
+    return size;
+  }
+
   // Apply this mask to the stack pointer to get the Thread object.
   static word_t GetThreadIDMask() {
     return kThreadIDMask;

Modified: vmkit/trunk/include/mvm/Threads/Thread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=144686&r1=144685&r2=144686&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/Threads/Thread.h (original)
+++ vmkit/trunk/include/mvm/Threads/Thread.h Tue Nov 15 13:59:47 2011
@@ -285,11 +285,7 @@
   }
 
   word_t GetAlternativeStackStart() {
-    return GetAlternativeStackEnd() + GetAlternativeStackSize();
-  }
-
-  static word_t GetAlternativeStackSize() {
-    return 3 * System::GetPageSize();
+    return GetAlternativeStackEnd() + System::GetAlternativeStackSize();
   }
 
   bool IsStackOverflowAddr(word_t addr) {

Modified: vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp?rev=144686&r1=144685&r2=144686&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp Tue Nov 15 13:59:47 2011
@@ -282,7 +282,7 @@
     uint32 pagesize = System::GetPageSize();
     for (uint32 i = 0; i < NR_THREADS; ++i) {
       word_t addr = baseAddr + (i * STACK_SIZE) + pagesize
-        + mvm::Thread::GetAlternativeStackSize();
+        + mvm::System::GetAlternativeStackSize();
       mprotect((void*)addr, pagesize, PROT_NONE);
     }
 
@@ -331,7 +331,7 @@
   stack_t st;
   st.ss_sp = (void*)th->GetAlternativeStackEnd();
   st.ss_flags = 0;
-  st.ss_size = th->GetAlternativeStackSize();
+  st.ss_size = System::GetAlternativeStackSize();
   sigaltstack(&st, NULL);
 
   // Set the SIGSEGV handler to diagnose errors.




From wdietz2 at illinois.edu  Tue Nov 15 12:00:35 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 15 Nov 2011 20:00:35 -0000
Subject: [vmkit-commits] [vmkit] r144687 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111115200035.20AF82A6C131@llvm.org>

Author: wdietz2
Date: Tue Nov 15 14:00:34 2011
New Revision: 144687

URL: http://llvm.org/viewvc/llvm-project?rev=144687&view=rev
Log:
Misc JVM_* method implementations --Compiler, CX8, HoldsLock.
* Ignore JVM_EnableCompiler/JVM_DisableCompiler
* Impl JVM_SupportsCX8--no, we don't.
* Impl JVM_HoldsLock

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144687&r1=144686&r2=144687&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov 15 14:00:34 2011
@@ -480,12 +480,12 @@
 
 JNIEXPORT void JNICALL
 JVM_EnableCompiler(JNIEnv *env, jclass compCls) {
-  NYI();
+  // Ignore.
 }
 
 JNIEXPORT void JNICALL
 JVM_DisableCompiler(JNIEnv *env, jclass compCls) {
-  NYI();
+  // Ignore.
 }
 
 void start(JavaThread* thread) {
@@ -699,7 +699,10 @@
 
 JNIEXPORT jboolean JNICALL
 JVM_HoldsLock(JNIEnv *env, jclass threadClass, jobject obj) {
-  NYI();
+  BEGIN_JNI_EXCEPTION
+  RETURN_FROM_JNI(JavaObject::owner(*(JavaObject**)obj));
+  END_JNI_EXCEPTION
+  return false;
 }
 
 JNIEXPORT void JNICALL
@@ -1893,7 +1896,7 @@
  */
 JNIEXPORT jboolean JNICALL
 JVM_SupportsCX8(void) {
-  NYI();
+  return JNI_FALSE;
 }
 
 /*************************************************************************




From wdietz2 at illinois.edu  Tue Nov 15 12:12:10 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 15 Nov 2011 14:12:10 -0600
Subject: [vmkit-commits] [PATCH] Define all sun.misc.Unsafe methods,
	refactor into new "Unsafe.inc"
In-Reply-To: <CAKGWAO_j2gi97iAB8r4Xea-yYJ0iL+GUvx4uC5=DH-0bkTh51g@mail.gmail.com>
References: <CAKGWAO_j2gi97iAB8r4Xea-yYJ0iL+GUvx4uC5=DH-0bkTh51g@mail.gmail.com>
Message-ID: <CAKGWAO8RnUZO6PJ4WxC8=OEs8t7AWY15XbUzPH5vn4NX2aEE5A@mail.gmail.com>

Inlined below, and attached.

Besides implementing the rest of Unsafe, move the Classpath-only code
from (what is currently) lib/J3/ClassLib/Classpath.inc into
GNUClasspath.

Thoughts welcome, and sorry for noisy diff.

Thanks!

~Will

>From d5a34423a7f917454af7b759f468dec02925110d Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Tue, 8 Nov 2011 19:22:46 -0600
Subject: [PATCH 1/2] Define all sun.misc.Unsafe methods, refactor into new
 "Unsafe.inc"

---
 lib/J3/ClassLib/Classpath.inc                |  588 --------------------------
 lib/J3/ClassLib/ClasspathField.inc           |   14 -
 lib/J3/ClassLib/GNUClasspath/Classpath.inc   |  289 +++++++++++++
 lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp |    3 +-
 lib/J3/ClassLib/GNUClasspath/Makefile        |    8 +-
 lib/J3/ClassLib/Makefile                     |    4 +-
 lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp      |    2 +-
 lib/J3/ClassLib/Unsafe.inc                   |  565 +++++++++++++++++++++++++
 8 files changed, 864 insertions(+), 609 deletions(-)
 delete mode 100644 lib/J3/ClassLib/Classpath.inc
 create mode 100644 lib/J3/ClassLib/GNUClasspath/Classpath.inc
 create mode 100644 lib/J3/ClassLib/Unsafe.inc

diff --git a/lib/J3/ClassLib/Classpath.inc b/lib/J3/ClassLib/Classpath.inc
deleted file mode 100644
index 4fb16a4..0000000
--- a/lib/J3/ClassLib/Classpath.inc
+++ /dev/null
@@ -1,588 +0,0 @@
-//===-------- Classpath.cpp - Configuration for classpath
-------------------===//
-//
-//                            The VMKit project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include "Classpath.h"
-#include "ClasspathReflect.h"
-#include "JavaClass.h"
-#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
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObject* Cl) {
-
-  llvm_gcroot(Cl, 0);
-  bool res = false;
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(Cl);
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
-
-  if (cl->isClass() &&
-      cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
-                                           vm->bootstrapLoader->clinitType,
-                                           true, false, 0))
-  res = true;
-
-  END_NATIVE_EXCEPTION
-
-  return res;
-}
-
-
-// Redefine some VMObjectStreamClass functions because of a slow implementation
-// in Classpath.
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jboolean val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt8Field(obj, (uint8)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jbyte val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt8Field(obj, (uint8)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jchar val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jshort val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt16Field(obj, (sint16)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jint val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt32Field(obj, (sint32)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jlong val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceLongField(obj, (sint64)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jfloat val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceFloatField(obj, (float)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jdouble val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceDoubleField(obj, (double)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  llvm_gcroot(val, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceObjectField(obj, val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT JavaObject* JNICALL Java_java_io_VMObjectInputStream_allocateObject(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
-
-  JavaObject* res = 0;
-  llvm_gcroot(res, 0);
-  llvm_gcroot(target, 0);
-  llvm_gcroot(constr, 0);
-  llvm_gcroot(cons, 0);
-
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClass* cl =
-    (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
-  res = cl->doNew(vm);
-  JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
-  meth->invokeIntSpecial(vm, cl, res);
-
-  END_NATIVE_EXCEPTION
-
-  return res;
-}
-
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMArray_createObjectArray(
-#ifdef NATIVE_JNI
-JNIEnv * env,
-jclass thisClass,
-#endif
-JavaObject* arrayType, jint arrayLength) {
-
-  JavaObject* res = 0;
-  llvm_gcroot(arrayType, 0);
-  llvm_gcroot(res, 0);
-
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* base =
-    UserCommonClass::resolvedImplClass(vm, arrayType, true);
-  JnjvmClassLoader* loader = base->classLoader;
-  const UTF8* name = base->getName();
-  // -1 because we're adding a new dimension in this method.
-  const int kLimit = 255 - 1;
-  const uint16* elements = name->elements;
-  if (name->size > kLimit && elements[kLimit] == '[') {
-    vm->illegalArgumentException("Too many dimensions for array");
-  }
-  const UTF8* arrayName = loader->constructArrayName(1, name);
-  UserClassArray* array = loader->constructArray(arrayName, base);
-  res = array->doNew(arrayLength, vm);
-
-  END_NATIVE_EXCEPTION
-
-  return res;
-}
-
-
-// Never throws.
-JNIEXPORT
-bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-) {
-  return false;
-}
-
-// Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
jlong update) {
-
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  jlong *ptr;
-  jlong  value;
-
-  ptr = (jlong *) (((uint8 *) obj) + offset);
-
-  value = *ptr;
-
-  if (value == expect) {
-    *ptr = update;
-    return true;
-  } else {
-    return false;
-  }
-
-}
-
-// Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) {
-
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  jint *ptr;
-
-  ptr = (jint *) (((uint8 *) obj) + offset);
-
-  return __sync_bool_compare_and_swap(ptr, expect, update);
-}
-
-// Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
-JavaObject* update) {
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  llvm_gcroot(expect, 0);
-  llvm_gcroot(update, 0);
-
-  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
-
-  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
(gc**)ptr, (gc*)expect, (gc*)update);
-}
-
-// Never throws.
-JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  llvm_gcroot(value, 0);
-
-  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
-  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());
-  cl->asClass()->resolveClass();
-  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) {
-  JavaObject* res = 0;
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(_field, 0);
-  llvm_gcroot(res, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  JavaField * field = JavaObjectField::getInternalField(_field);
-  assert(field);
-  field->classDef->initialiseClass(JavaThread::get()->getJVM());
-
-  res = VMStaticInstance::allocate(field->classDef);
-
-  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) {
-  // Array starts at beginning of object
-  return 0;
-}
-
-JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* clazz) {
-  // Return '0' if we don't support indexing this way.
-  // (We might pack fields specially, etc)
-  // TODO: Implement this for the array types we support this way
-  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()->throwException(obj);
-}
-
-JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
-  // Nothing
-}
-
-// TODO: Add the Volatile variants
-#define GET_PUT_OFFSET(Type,jtype,shorttype) \
-JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
__Ljava_lang_Object_2J( \
-JavaObject* unsafe, JavaObject* base, jlong offset) { \
-  jtype res = 0; \
-  BEGIN_NATIVE_EXCEPTION(0) \
-  jtype* ptr = (jtype*) (baseToPtr(base) + offset); \
-  res = *ptr; \
-  END_NATIVE_EXCEPTION \
- \
-  return res; \
-} \
- \
-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*) (baseToPtr(base) + offset); \
-  *ptr = val; \
-  END_NATIVE_EXCEPTION \
-}
-
-GET_PUT_OFFSET(Boolean,jboolean,Z)
-GET_PUT_OFFSET(Byte,jbyte,B)
-GET_PUT_OFFSET(Char,jchar,C)
-GET_PUT_OFFSET(Short,jshort,S)
-GET_PUT_OFFSET(Int,jint,I)
-GET_PUT_OFFSET(Long,jlong,J)
-GET_PUT_OFFSET(Float,jfloat,F)
-GET_PUT_OFFSET(Double,jdouble,D)
-
-}
diff --git a/lib/J3/ClassLib/ClasspathField.inc
b/lib/J3/ClassLib/ClasspathField.inc
index e56c82f..010c54b 100644
--- a/lib/J3/ClassLib/ClasspathField.inc
+++ b/lib/J3/ClassLib/ClasspathField.inc
@@ -1154,18 +1154,4 @@ JavaObjectField* Field, JavaObject* obj, jdouble val) {
  END_NATIVE_EXCEPTION
 }

-// Never throws.
-JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* Unsafe, JavaObjectField* Field) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(Unsafe, 0);
-
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  return (jlong)field->ptrOffset;
-}
-
 }
diff --git a/lib/J3/ClassLib/GNUClasspath/Classpath.inc
b/lib/J3/ClassLib/GNUClasspath/Classpath.inc
new file mode 100644
index 0000000..3354774
--- /dev/null
+++ b/lib/J3/ClassLib/GNUClasspath/Classpath.inc
@@ -0,0 +1,289 @@
+//===-------- Classpath.cpp - Configuration for classpath
-------------------===//
+//
+//                            The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#include "Classpath.h"
+#include "ClasspathReflect.h"
+#include "JavaClass.h"
+#include "JavaThread.h"
+#include "JavaUpcalls.h"
+#include "Jnjvm.h"
+#include "Reader.h"
+
+using namespace j3;
+
+extern "C" {
+
+// Define hasClassInitializer because of a buggy implementation in Classpath.
+JNIEXPORT bool JNICALL Java_java_io_VMObjectStreamClass_hasClassInitializer(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObject* Cl) {
+
+  llvm_gcroot(Cl, 0);
+  bool res = false;
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(Cl);
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
+
+  if (cl->isClass() &&
+      cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
+                                           vm->bootstrapLoader->clinitType,
+                                           true, false, 0))
+  res = true;
+
+  END_NATIVE_EXCEPTION
+
+  return res;
+}
+
+
+// Redefine some VMObjectStreamClass functions because of a slow implementation
+// in Classpath.
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jboolean val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt8Field(obj, (uint8)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jbyte val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt8Field(obj, (uint8)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jchar val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jshort val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt16Field(obj, (sint16)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jint val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt32Field(obj, (sint32)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jlong val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceLongField(obj, (sint64)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jfloat val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceFloatField(obj, (float)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jdouble val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceDoubleField(obj, (double)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  llvm_gcroot(val, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceObjectField(obj, val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT JavaObject* JNICALL Java_java_io_VMObjectInputStream_allocateObject(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
+
+  JavaObject* res = 0;
+  llvm_gcroot(res, 0);
+  llvm_gcroot(target, 0);
+  llvm_gcroot(constr, 0);
+  llvm_gcroot(cons, 0);
+
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* cl =
+    (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
+  res = cl->doNew(vm);
+  JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
+  meth->invokeIntSpecial(vm, cl, res);
+
+  END_NATIVE_EXCEPTION
+
+  return res;
+}
+
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMArray_createObjectArray(
+#ifdef NATIVE_JNI
+JNIEnv * env,
+jclass thisClass,
+#endif
+JavaObject* arrayType, jint arrayLength) {
+
+  JavaObject* res = 0;
+  llvm_gcroot(arrayType, 0);
+  llvm_gcroot(res, 0);
+
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* base =
+    UserCommonClass::resolvedImplClass(vm, arrayType, true);
+  JnjvmClassLoader* loader = base->classLoader;
+  const UTF8* name = base->getName();
+  // -1 because we're adding a new dimension in this method.
+  const int kLimit = 255 - 1;
+  const uint16* elements = name->elements;
+  if (name->size > kLimit && elements[kLimit] == '[') {
+    vm->illegalArgumentException("Too many dimensions for array");
+  }
+  const UTF8* arrayName = loader->constructArrayName(1, name);
+  UserClassArray* array = loader->constructArray(arrayName, base);
+  res = array->doNew(arrayLength, vm);
+
+  END_NATIVE_EXCEPTION
+
+  return res;
+}
+
+// Never throws.
+JNIEXPORT
+bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+) {
+  return false;
+}
+
+}
diff --git a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
index bc797d1..57197c4 100644
--- a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
+++ b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
@@ -1071,8 +1071,8 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {

 }

-#include "ClasspathConstructor.inc"
 #include "Classpath.inc"
+#include "ClasspathConstructor.inc"
 #include "ClasspathField.inc"
 #include "ClasspathMethod.inc"
 #include "ClasspathVMClass.inc"
@@ -1084,3 +1084,4 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {
 #include "ClasspathVMSystemProperties.inc"
 #include "ClasspathVMThread.inc"
 #include "ClasspathVMThrowable.inc"
+#include "Unsafe.inc"
diff --git a/lib/J3/ClassLib/GNUClasspath/Makefile
b/lib/J3/ClassLib/GNUClasspath/Makefile
index be80b9e..f5939c9 100644
--- a/lib/J3/ClassLib/GNUClasspath/Makefile
+++ b/lib/J3/ClassLib/GNUClasspath/Makefile
@@ -9,9 +9,11 @@
 LEVEL = ../../../..


-EXTRA_DIST = ClasspathVMClass.inc ClasspathVMClassLoader.inc
ClasspathVMObject.inc \
-            ClasspathVMRuntime.inc ClasspathVMStackWalker.inc
ClasspathVMSystem.inc \
-            ClasspathVMSystemProperties.inc ClasspathVMThread.inc
ClasspathVMThrowable.inc
+EXTRA_DIST = Classpath.inc ClasspathVMClass.inc ClasspathVMClassLoader.inc \
+             ClasspathVMObject.inc ClasspathVMRuntime.inc \
+             ClasspathVMStackWalker.inc ClasspathVMSystem.inc \
+             ClasspathVMSystemProperties.inc ClasspathVMThread.inc \
+             ClasspathVMThrowable.inc

 include $(LEVEL)/Makefile.config

diff --git a/lib/J3/ClassLib/Makefile b/lib/J3/ClassLib/Makefile
index 8252b92..8fd7e2a 100644
--- a/lib/J3/ClassLib/Makefile
+++ b/lib/J3/ClassLib/Makefile
@@ -12,9 +12,9 @@ EXTRA_DIST = ArrayCopy.inc \
             ClassContext.inc \
             ClasspathConstructor.inc \
             ClasspathField.inc \
-             Classpath.inc \
             ClasspathMethod.inc \
-             SetProperties.inc
+             SetProperties.inc \
+             Unsafe.inc

 include $(LEVEL)/Makefile.config

diff --git a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
index 22db276..3fa6390 100644
--- a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
+++ b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
@@ -897,7 +897,7 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {


 #include "ClasspathConstructor.inc"
-#include "Classpath.inc"
 #include "ClasspathField.inc"
 #include "ClasspathMethod.inc"
 #include "OpenJDK.inc"
+#include "Unsafe.inc"
diff --git a/lib/J3/ClassLib/Unsafe.inc b/lib/J3/ClassLib/Unsafe.inc
new file mode 100644
index 0000000..44ffe73
--- /dev/null
+++ b/lib/J3/ClassLib/Unsafe.inc
@@ -0,0 +1,565 @@
+//===-------- Unsafe.inc - sun.misc.Unsafe implementation
-----------------===//
+//
+//                            The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "VMStaticInstance.h"
+#include <stdlib.h>
+
+/// fieldPtr - Compute the address of the field specified by the given
+/// base/offset pair.  Non-trivial due to our handling of static instances,
+/// and this also handles null-checking as required.
+///
+static inline uint8 *fieldPtr(JavaObject *base, long long offset,
+  bool throwOnNull = true) {
+
+  // For most uses, a 'null' base should throw an exception.
+  if (throwOnNull) verifyNull(base);
+
+  if (base && VMStaticInstance::isVMStaticInstance(base))
+    return (uint8*)((VMStaticInstance*)base)->getStaticInstance() + offset;
+  else
+    return (uint8*)base + offset;
+}
+
+extern "C" {
+
+//===--- Base/Offset methods
----------------------------------------------===//
+
+/// staticFieldOffset - Return the offset of a particular static field
+/// Only valid to be used with the corresponding staticFieldBase
+///
+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;
+}
+
+/// staticFieldBase - Return a JavaObject* representing the static instance.
+/// Note that our static instances aren't actually java objects, so we use
+/// a placeholder object "VMStaticInstance" that also ensures that
+/// the corresponding class doesn't get GC'd underneath it.
+///
+JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_staticFieldBase(
+JavaObject* unsafe, JavaObjectField* _field) {
+  JavaObject* res = 0;
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(_field, 0);
+  llvm_gcroot(res, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  JavaField * field = JavaObjectField::getInternalField(_field);
+  assert(field);
+  field->classDef->initialiseClass(JavaThread::get()->getJVM());
+
+  res = VMStaticInstance::allocate(field->classDef);
+
+  END_NATIVE_EXCEPTION;
+
+  return res;
+}
+
+/// arrayBaseOffset - Offset from the array object where the actual
+/// element data begins.
+///
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayBaseOffset(
+JavaObject* unsafe, JavaObject* clazz) {
+  // Array starts at beginning of object
+  return 0;
+}
+
+/// arrayIndexScale - Indexing scale for the element type in
+/// the specified array.  For use with arrayBaseOffset,
+/// NthElementPtr = ArrayObject + BaseOffset + N*IndexScale
+/// Return '0' if our JVM stores the elements in a way that
+/// makes this type of access impossible or unsupported.
+///
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* clazz) {
+  // For now, just return '0', indicating we don't support this indexing.
+  // TODO: Implement this for the array types we /do/ support this way.
+  return 0;
+}
+
+
+
+/// objectFieldOffset - Pointer offset of the specified field
+///
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* Unsafe, JavaObjectField* Field) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(Unsafe, 0);
+
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  return (jlong)field->ptrOffset;
+}
+
+//===--- Double-register addressing field accessors
-----------------------===//
+// See objectFieldOffset, staticFieldOffset, staticFieldBase
+// Can also be an array, if/when we support arrayIndexScale/arrayBaseOffset
+#define GET_PUT_OFFSET(Type,jtype,shorttype) \
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
__Ljava_lang_Object_2J( \
+JavaObject* unsafe, JavaObject* base, jlong offset) { \
+  jtype res = 0; \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  jtype* ptr = (jtype*)fieldPtr(base,offset); \
+  res = *ptr; \
+  END_NATIVE_EXCEPTION \
+  return res; \
+} \
+ \
+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*)fieldPtr(base, offset); \
+  *ptr = val; \
+  END_NATIVE_EXCEPTION \
+}
+
+//===--- Direct address read/write acccessors
-----------------------------===//
+#define GET_PUT_DIRECT(Type,jtype,shorttype) \
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ## __J ## shorttype( \
+JavaObject* unsafe, jlong ptr, jtype val) { \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  *(jtype*)ptr = val; \
+  END_NATIVE_EXCEPTION \
+} \
+ \
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## __J( \
+JavaObject* unsafe, jlong ptr) { \
+  jtype res = 0; \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  res = *(jtype*)ptr; \
+  END_NATIVE_EXCEPTION \
+  return res; \
+}
+
+//===--- Volatile variant of field accessors
------------------------------===//
+// Memory barriers after writes to ensure new value is seen elsewhere
+#define GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##
Volatile__J ## shorttype( \
+JavaObject* unsafe, jlong ptr, jtype val) { \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  *(volatile jtype*)ptr = val; \
+  __sync_synchronize(); \
+  END_NATIVE_EXCEPTION \
+} \
+ \
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## Volatile__J( \
+JavaObject* unsafe, jlong ptr) { \
+  jtype res = 0; \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  res = *(volatile jtype*)ptr; \
+  END_NATIVE_EXCEPTION \
+  return res; \
+}
+
+//===--- Volatile variant of direct address accessors
---------------------===//
+#define GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype) \
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
Volatile__Ljava_lang_Object_2J( \
+JavaObject* unsafe, JavaObject* base, jlong offset) { \
+  jtype res = 0; \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
+  res = *ptr; \
+  END_NATIVE_EXCEPTION \
+ \
+  return res; \
+} \
+ \
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##
Volatile__Ljava_lang_Object_2J ## shorttype( \
+JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
+  *ptr = val; \
+  __sync_synchronize(); \
+  END_NATIVE_EXCEPTION \
+}
+
+//===--- Ordered variant of field accessors
-------------------------------===//
+#define GET_PUT_FIELD_ORDERED(Type,jtype,shorttype) \
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrdered ## Type( \
+JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
+  *ptr = val; \
+  /* No memory barrier */ \
+  END_NATIVE_EXCEPTION \
+}
+
+#define GET_PUT_ALL(Type,jtype,shorttype) \
+  GET_PUT_OFFSET(Type,jtype,shorttype) \
+  GET_PUT_DIRECT(Type,jtype,shorttype) \
+  GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \
+  GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype)
+
+GET_PUT_ALL(Boolean,jboolean,Z)
+GET_PUT_ALL(Byte,jbyte,B)
+GET_PUT_ALL(Char,jchar,C)
+GET_PUT_ALL(Short,jshort,S)
+GET_PUT_ALL(Int,jint,I)
+GET_PUT_ALL(Long,jlong,J) // TODO: Long needs special handling!
+GET_PUT_ALL(Float,jfloat,F)
+GET_PUT_ALL(Double,jdouble,D)
+
+// Ordered:
+GET_PUT_FIELD_ORDERED(Int,jint,I)
+GET_PUT_FIELD_ORDERED(Long,jlong,J)
+
+//===--- Get/Put of Objects, due to GC needs special handling
-------------===//
+// JavaObject field accessors:
+JNIEXPORT void JNICALL
Java_sun_misc_Unsafe_putObject__Ljava_lang_Object_2JLjava_lang_Object_2(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(base, 0);
+  llvm_gcroot(value, 0);
+
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
(gc*)value);
+}
+
+
+JNIEXPORT JavaObject* JNICALL
Java_sun_misc_Unsafe_getObject__Ljava_lang_Object_2J(
+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**)fieldPtr(base, offset);
+  res = *ptr;
+  END_NATIVE_EXCEPTION;
+
+  return res;
+}
+
+// Volatile JavaObject field accessors:
+// Never throws.
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(base, 0);
+  llvm_gcroot(value, 0);
+
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
(gc*)value);
+  // Ensure this value is seen.
+  __sync_synchronize();
+}
+
+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* volatile* ptr = (JavaObject* volatile*)fieldPtr(base, offset);
+  res = *ptr;
+  END_NATIVE_EXCEPTION;
+
+  return res;
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrderedObject(
+JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(base, 0);
+  llvm_gcroot(value, 0);
+
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
(gc*)value);
+  // No barrier (difference between volatile and ordered)
+}
+
+
+//===--- CompareAndSwap field accessors
-----------------------------------===//
+// Never throws.
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* base, jlong offset, jlong expect,
jlong update) {
+
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(base, 0);
+  jlong *ptr;
+  jlong  value;
+
+  // TODO: Why isn't this atomic?
+  ptr = (jlong*)fieldPtr(base, offset);
+
+  value = *ptr;
+
+  if (value == expect) {
+    *ptr = update;
+    return true;
+  } else {
+    return false;
+  }
+
+}
+
+// Never throws.
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* base, jlong offset, jint expect, jint update) {
+
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(base, 0);
+  jint *ptr;
+
+  ptr = (jint *)fieldPtr(base, offset);
+
+  return __sync_bool_compare_and_swap(ptr, expect, update);
+}
+
+// Never throws.
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* expect,
+JavaObject* update) {
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(base, 0);
+  llvm_gcroot(expect, 0);
+  llvm_gcroot(update, 0);
+
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  return mvm::Collector::objectReferenceTryCASBarrier((gc*)base,
(gc**)ptr, (gc*)expect, (gc*)update);
+}
+
+
+//===--- Class-related functions
------------------------------------------===//
+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());
+  cl->asClass()->resolveClass();
+  cl->asClass()->initialiseClass(vm);
+
+  END_NATIVE_EXCEPTION;
+}
+
+JNIEXPORT JavaObject* JNICALL
Java_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BII(
+JavaObject* unsafe, JavaString *name, ArrayObject * bytesArr, jint
off, jint len) {
+  UNIMPLEMENTED();
+}
+
+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 JavaObject* JNICALL Java_sun_Unsafe_defineAnonymousClass(
+JavaObject* unsafe, ...) {
+  UNIMPLEMENTED();
+}
+
+//===--- Memory functions
-------------------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_setMemory__JJB(
+JavaObject* unsafe, long address, long bytes, jbyte value) {
+  memset((void*)address, value, bytes);
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_copyMemory__JJJ(
+JavaObject* unsafe, jlong src, jlong dst, jlong size) {
+  memcpy((void*)dst, (void*)src, size);
+}
+
+JNIEXPORT void JNICALL
Java_sun_misc_Unsafe_copyMemory__Ljava_lang_Object_2JLjava_lang_Object_2JJ(
+JavaObject* unsafe,
+JavaObject* srcBase, jlong srcOffset,
+JavaObject* dstBase, jlong dstOffset,
+jlong size) {
+  BEGIN_NATIVE_EXCEPTION(0)
+  uint8_t* src = fieldPtr(srcBase, srcOffset, false /* Don't throw on
null base*/ );
+  uint8_t* dst = fieldPtr(dstBase, dstOffset, false /* Don't throw on
null base*/ );
+  memcpy(dst, src, size);
+  END_NATIVE_EXCEPTION
+}
+
+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 jlong JNICALL Java_sun_misc_Unsafe_reallocateMemory(
+JavaObject* unsafe, jlong ptr, jlong newsize) {
+  // TODO: Invalid size/OOM/etc handling!
+  jlong res = 0;
+  BEGIN_NATIVE_EXCEPTION(0)
+  res = (jlong)realloc((void*)ptr, newsize);
+  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 jlong JNICALL Java_sun_misc_Unsafe_getAddress(
+JavaObject* unsafe, jlong ptr) {
+  return (jlong)*(void**)ptr;
+}
+
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_putAddress(
+JavaObject* unsafe, jlong ptr, jlong val) {
+  *(void**)ptr = (void*)val;
+}
+
+//===--- Park/Unpark thread support
---------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_park(
+JavaObject* unsafe, jboolean isAbsolute, jlong time) {
+  // Nothing, for now.
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_unpark(
+JavaObject* unsafe, JavaObject* thread) {
+  // Nothing, for now.
+}
+
+//===--- Monitor support
--------------------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_tryMonitorEnter(
+JavaObject* unsafe, JavaObject * obj) {
+  //TODO: Implement me!
+  UNIMPLEMENTED();
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorEnter(
+JavaObject* unsafe, JavaObject * obj) {
+  //TODO: Implement me!
+  UNIMPLEMENTED();
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorExit(
+JavaObject* unsafe, JavaObject * obj) {
+  //TODO: Implement me!
+  UNIMPLEMENTED();
+}
+
+//===--- Misc support functions
-------------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
+  // Nothing, we define the Unsafe methods with the expected signatures.
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_throwException(
+JavaObject* unsafe, JavaObject * obj) {
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(obj, 0);
+
+  JavaThread::get()->throwException(obj);
+}
+
+JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_pageSize(
+JavaObject* unsafe) {
+  return mvm::System::GetPageSize();
+}
+
+JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_addressSize(
+JavaObject* unsafe) {
+  return mvm::kWordSize;
+}
+
+JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_getLoadAverage(
+JavaObject* unsafe, ...) {
+  UNIMPLEMENTED();
+}
+
+}
--
1.7.5.1
-------------- next part --------------
A non-text attachment was scrubbed...
Name: 0001-Define-all-sun.misc.Unsafe-methods-refactor-into-new.patch
Type: application/octet-stream
Size: 44834 bytes
Desc: not available
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111115/47e5fc63/attachment.obj>

From wdietz2 at illinois.edu  Tue Nov 15 12:13:45 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 15 Nov 2011 14:13:45 -0600
Subject: [vmkit-commits] [PATCH] Fix symbol search order to fix detection of
 symbols from vmkit or loaded libs
Message-ID: <CAKGWAO9iGU7UtXrxEZSvUKfXvkw=G-DaFX6rE+uL1FsP64skvA@mail.gmail.com>

Inlined below.

As described in the commit message, the existing way incorrectly sets
the 'j3' on symbols from loaded libraries, resulting in much badness
when we don't invoke them properly in nativeCompile().

I'm unsure if this was a bug on Mac, but regardless the reordering
should work correctly on both.

~Will

>From 6f485d65e595a1ecd90e4e90a8bbc12b481561bc Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Mon, 14 Nov 2011 09:45:35 -0600
Subject: [PATCH 2/2] Fix symbol search order to fix detection of symbols from
 vmkit or loaded libs

dlsym(NULL, *) in linux, for example, will not only search the vmkit process,
  but also all libraries we've opened.  This makes the setting of the 'j3' flag
  incorrect, and this is fixed by a simple reordering.
---
 lib/J3/VMCore/JnjvmClassLoader.cpp |   30 +++++++++++++++++-------------
 1 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/lib/J3/VMCore/JnjvmClassLoader.cpp
b/lib/J3/VMCore/JnjvmClassLoader.cpp
index bf825a8..df206bb 100644
--- a/lib/J3/VMCore/JnjvmClassLoader.cpp
+++ b/lib/J3/VMCore/JnjvmClassLoader.cpp
@@ -977,22 +977,26 @@ const UTF8*
JnjvmClassLoader::constructArrayName(uint32 steps,
 }

 word_t JnjvmClassLoader::loadInLib(const char* buf, bool& j3) {
-  word_t res =
(word_t)TheCompiler->loadMethod(mvm::System::GetSelfHandle(), buf);
-
-  if (!res) {
-    for (std::vector<void*>::iterator i = nativeLibs.begin(),
-              e = nativeLibs.end(); i!= e; ++i) {
-      res = (word_t)TheCompiler->loadMethod((*i), buf);
-      if (res) break;
-    }
-  } else {
+  word_t res;
+
+  // Search loaded libraries first
+  for (std::vector<void*>::iterator i = nativeLibs.begin(),
+      e = nativeLibs.end(); i!= e; ++i) {
+    res = (word_t)TheCompiler->loadMethod((*i), buf);
+    if (res) return res;
+  }
+
+  // Check 'self'
+  res = (word_t)TheCompiler->loadMethod(mvm::System::GetSelfHandle(), buf);
+  if (res) {
     j3 = true;
+    return res;
   }
-
-  if (!res && this != bootstrapLoader)
-    res = bootstrapLoader->loadInLib(buf, j3);

-  return (word_t)res;
+  if (this != bootstrapLoader)
+    return bootstrapLoader->loadInLib(buf, j3);
+
+  return 0;
 }

 void* JnjvmClassLoader::loadLib(const char* buf) {
-- 
1.7.5.1


From nicolas.geoffray at gmail.com  Tue Nov 15 12:24:18 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 15 Nov 2011 21:24:18 +0100
Subject: [vmkit-commits] [PATCH] Fix symbol search order to fix
 detection of symbols from vmkit or loaded libs
In-Reply-To: <CAKGWAO9iGU7UtXrxEZSvUKfXvkw=G-DaFX6rE+uL1FsP64skvA@mail.gmail.com>
References: <CAKGWAO9iGU7UtXrxEZSvUKfXvkw=G-DaFX6rE+uL1FsP64skvA@mail.gmail.com>
Message-ID: <CAPYwfipL3QRtg5R_UOs8aE03MjxHJ_+1roWHoA1BKAmfWXk80g@mail.gmail.com>

Hi Will,

I'm not sure that's right. With GNU Classpath, I also want to define my own
methods and not use the ones implemented in Classpath. If we reorder
things, the method defined in GNU Classpath will be used. Not mine.

vmkit is using RTLD_LOCAL when loading, so symbol resolution on a dlsym
must provide the loaded library. If you do dlsym(SELF_HANDLE, 'mysymbol'),
you'll only get symbols loaded in the j3 executable.

What is it that does not work for you?

Cheers,
Nicolas


On Tue, Nov 15, 2011 at 9:13 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> As described in the commit message, the existing way incorrectly sets
> the 'j3' on symbols from loaded libraries, resulting in much badness
> when we don't invoke them properly in nativeCompile().
>
> I'm unsure if this was a bug on Mac, but regardless the reordering
> should work correctly on both.
>
> ~Will
>
> >From 6f485d65e595a1ecd90e4e90a8bbc12b481561bc Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Mon, 14 Nov 2011 09:45:35 -0600
> Subject: [PATCH 2/2] Fix symbol search order to fix detection of symbols
> from
>  vmkit or loaded libs
>
> dlsym(NULL, *) in linux, for example, will not only search the vmkit
> process,
>  but also all libraries we've opened.  This makes the setting of the 'j3'
> flag
>  incorrect, and this is fixed by a simple reordering.
> ---
>  lib/J3/VMCore/JnjvmClassLoader.cpp |   30 +++++++++++++++++-------------
>  1 files changed, 17 insertions(+), 13 deletions(-)
>
> diff --git a/lib/J3/VMCore/JnjvmClassLoader.cpp
> b/lib/J3/VMCore/JnjvmClassLoader.cpp
> index bf825a8..df206bb 100644
> --- a/lib/J3/VMCore/JnjvmClassLoader.cpp
> +++ b/lib/J3/VMCore/JnjvmClassLoader.cpp
> @@ -977,22 +977,26 @@ const UTF8*
> JnjvmClassLoader::constructArrayName(uint32 steps,
>  }
>
>  word_t JnjvmClassLoader::loadInLib(const char* buf, bool& j3) {
> -  word_t res =
> (word_t)TheCompiler->loadMethod(mvm::System::GetSelfHandle(), buf);
> -
> -  if (!res) {
> -    for (std::vector<void*>::iterator i = nativeLibs.begin(),
> -              e = nativeLibs.end(); i!= e; ++i) {
> -      res = (word_t)TheCompiler->loadMethod((*i), buf);
> -      if (res) break;
> -    }
> -  } else {
> +  word_t res;
> +
> +  // Search loaded libraries first
> +  for (std::vector<void*>::iterator i = nativeLibs.begin(),
> +      e = nativeLibs.end(); i!= e; ++i) {
> +    res = (word_t)TheCompiler->loadMethod((*i), buf);
> +    if (res) return res;
> +  }
> +
> +  // Check 'self'
> +  res = (word_t)TheCompiler->loadMethod(mvm::System::GetSelfHandle(),
> buf);
> +  if (res) {
>     j3 = true;
> +    return res;
>   }
> -
> -  if (!res && this != bootstrapLoader)
> -    res = bootstrapLoader->loadInLib(buf, j3);
>
> -  return (word_t)res;
> +  if (this != bootstrapLoader)
> +    return bootstrapLoader->loadInLib(buf, j3);
> +
> +  return 0;
>  }
>
>  void* JnjvmClassLoader::loadLib(const char* buf) {
> --
> 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/20111115/a010809c/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov 15 12:26:36 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 15 Nov 2011 21:26:36 +0100
Subject: [vmkit-commits] [PATCH] Define all sun.misc.Unsafe methods,
 refactor into new "Unsafe.inc"
In-Reply-To: <CAKGWAO8RnUZO6PJ4WxC8=OEs8t7AWY15XbUzPH5vn4NX2aEE5A@mail.gmail.com>
References: <CAKGWAO_j2gi97iAB8r4Xea-yYJ0iL+GUvx4uC5=DH-0bkTh51g@mail.gmail.com>
	<CAKGWAO8RnUZO6PJ4WxC8=OEs8t7AWY15XbUzPH5vn4NX2aEE5A@mail.gmail.com>
Message-ID: <CAPYwfiqt_2QQCWu6C2Hes64R2tQFaXq-NUAzFwGfvsSf3Ux8tQ@mail.gmail.com>

Hi Will,

With this patch, it's hard to know what you added. Could you commit a first
patch that just moves files around, and then add your new code in a new
patch?

Thanks!
Nicolas

On Tue, Nov 15, 2011 at 9:12 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below, and attached.
>
> Besides implementing the rest of Unsafe, move the Classpath-only code
> from (what is currently) lib/J3/ClassLib/Classpath.inc into
> GNUClasspath.
>
> Thoughts welcome, and sorry for noisy diff.
>
> Thanks!
>
> ~Will
>
> >From d5a34423a7f917454af7b759f468dec02925110d Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Tue, 8 Nov 2011 19:22:46 -0600
> Subject: [PATCH 1/2] Define all sun.misc.Unsafe methods, refactor into new
>  "Unsafe.inc"
>
> ---
>  lib/J3/ClassLib/Classpath.inc                |  588
> --------------------------
>  lib/J3/ClassLib/ClasspathField.inc           |   14 -
>  lib/J3/ClassLib/GNUClasspath/Classpath.inc   |  289 +++++++++++++
>  lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp |    3 +-
>  lib/J3/ClassLib/GNUClasspath/Makefile        |    8 +-
>  lib/J3/ClassLib/Makefile                     |    4 +-
>  lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp      |    2 +-
>  lib/J3/ClassLib/Unsafe.inc                   |  565
> +++++++++++++++++++++++++
>  8 files changed, 864 insertions(+), 609 deletions(-)
>  delete mode 100644 lib/J3/ClassLib/Classpath.inc
>  create mode 100644 lib/J3/ClassLib/GNUClasspath/Classpath.inc
>  create mode 100644 lib/J3/ClassLib/Unsafe.inc
>
> diff --git a/lib/J3/ClassLib/Classpath.inc b/lib/J3/ClassLib/Classpath.inc
> deleted file mode 100644
> index 4fb16a4..0000000
> --- a/lib/J3/ClassLib/Classpath.inc
> +++ /dev/null
> @@ -1,588 +0,0 @@
> -//===-------- Classpath.cpp - Configuration for classpath
> -------------------===//
> -//
> -//                            The VMKit project
> -//
> -// This file is distributed under the University of Illinois Open Source
> -// License. See LICENSE.TXT for details.
> -//
>
> -//===----------------------------------------------------------------------===//
> -
> -
> -
> -#include "Classpath.h"
> -#include "ClasspathReflect.h"
> -#include "JavaClass.h"
> -#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
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> -
> -  llvm_gcroot(Cl, 0);
> -  bool res = false;
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(Cl);
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
> -
> -  if (cl->isClass() &&
> -
>  cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
> -
> vm->bootstrapLoader->clinitType,
> -                                           true, false, 0))
> -  res = true;
> -
> -  END_NATIVE_EXCEPTION
> -
> -  return res;
> -}
> -
> -
> -// Redefine some VMObjectStreamClass functions because of a slow
> implementation
> -// in Classpath.
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jboolean val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceInt8Field(obj, (uint8)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jbyte val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceInt8Field(obj, (uint8)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jchar val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jshort val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceInt16Field(obj, (sint16)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jint val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceInt32Field(obj, (sint32)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jlong val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceLongField(obj, (sint64)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jfloat val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceFloatField(obj, (float)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jdouble val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceDoubleField(obj, (double)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  llvm_gcroot(val, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceObjectField(obj, val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT JavaObject* JNICALL
> Java_java_io_VMObjectInputStream_allocateObject(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
> -
> -  JavaObject* res = 0;
> -  llvm_gcroot(res, 0);
> -  llvm_gcroot(target, 0);
> -  llvm_gcroot(constr, 0);
> -  llvm_gcroot(cons, 0);
> -
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClass* cl =
> -    (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
> -  res = cl->doNew(vm);
> -  JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> -  meth->invokeIntSpecial(vm, cl, res);
> -
> -  END_NATIVE_EXCEPTION
> -
> -  return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL
> Java_java_lang_reflect_VMArray_createObjectArray(
> -#ifdef NATIVE_JNI
> -JNIEnv * env,
> -jclass thisClass,
> -#endif
> -JavaObject* arrayType, jint arrayLength) {
> -
> -  JavaObject* res = 0;
> -  llvm_gcroot(arrayType, 0);
> -  llvm_gcroot(res, 0);
> -
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* base =
> -    UserCommonClass::resolvedImplClass(vm, arrayType, true);
> -  JnjvmClassLoader* loader = base->classLoader;
> -  const UTF8* name = base->getName();
> -  // -1 because we're adding a new dimension in this method.
> -  const int kLimit = 255 - 1;
> -  const uint16* elements = name->elements;
> -  if (name->size > kLimit && elements[kLimit] == '[') {
> -    vm->illegalArgumentException("Too many dimensions for array");
> -  }
> -  const UTF8* arrayName = loader->constructArrayName(1, name);
> -  UserClassArray* array = loader->constructArray(arrayName, base);
> -  res = array->doNew(arrayLength, vm);
> -
> -  END_NATIVE_EXCEPTION
> -
> -  return res;
> -}
> -
> -
> -// Never throws.
> -JNIEXPORT
> -bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -) {
> -  return false;
> -}
> -
> -// Never throws.
> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
> jlong update) {
> -
> -  llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> -  jlong *ptr;
> -  jlong  value;
> -
> -  ptr = (jlong *) (((uint8 *) obj) + offset);
> -
> -  value = *ptr;
> -
> -  if (value == expect) {
> -    *ptr = update;
> -    return true;
> -  } else {
> -    return false;
> -  }
> -
> -}
> -
> -// Never throws.
> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint
> update) {
> -
> -  llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> -  jint *ptr;
> -
> -  ptr = (jint *) (((uint8 *) obj) + offset);
> -
> -  return __sync_bool_compare_and_swap(ptr, expect, update);
> -}
> -
> -// Never throws.
> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
> -JavaObject* update) {
> -  llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> -  llvm_gcroot(expect, 0);
> -  llvm_gcroot(update, 0);
> -
> -  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
> -
> -  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
> (gc**)ptr, (gc*)expect, (gc*)update);
> -}
> -
> -// Never throws.
> -JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {
> -  llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> -  llvm_gcroot(value, 0);
> -
> -  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
> -  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());
> -  cl->asClass()->resolveClass();
> -  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) {
> -  JavaObject* res = 0;
> -  llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(_field, 0);
> -  llvm_gcroot(res, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  JavaField * field = JavaObjectField::getInternalField(_field);
> -  assert(field);
> -  field->classDef->initialiseClass(JavaThread::get()->getJVM());
> -
> -  res = VMStaticInstance::allocate(field->classDef);
> -
> -  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) {
> -  // Array starts at beginning of object
> -  return 0;
> -}
> -
> -JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* clazz) {
> -  // Return '0' if we don't support indexing this way.
> -  // (We might pack fields specially, etc)
> -  // TODO: Implement this for the array types we support this way
> -  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()->throwException(obj);
> -}
> -
> -JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
> -  // Nothing
> -}
> -
> -// TODO: Add the Volatile variants
> -#define GET_PUT_OFFSET(Type,jtype,shorttype) \
> -JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
> __Ljava_lang_Object_2J( \
> -JavaObject* unsafe, JavaObject* base, jlong offset) { \
> -  jtype res = 0; \
> -  BEGIN_NATIVE_EXCEPTION(0) \
> -  jtype* ptr = (jtype*) (baseToPtr(base) + offset); \
> -  res = *ptr; \
> -  END_NATIVE_EXCEPTION \
> - \
> -  return res; \
> -} \
> - \
> -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*) (baseToPtr(base) + offset); \
> -  *ptr = val; \
> -  END_NATIVE_EXCEPTION \
> -}
> -
> -GET_PUT_OFFSET(Boolean,jboolean,Z)
> -GET_PUT_OFFSET(Byte,jbyte,B)
> -GET_PUT_OFFSET(Char,jchar,C)
> -GET_PUT_OFFSET(Short,jshort,S)
> -GET_PUT_OFFSET(Int,jint,I)
> -GET_PUT_OFFSET(Long,jlong,J)
> -GET_PUT_OFFSET(Float,jfloat,F)
> -GET_PUT_OFFSET(Double,jdouble,D)
> -
> -}
> diff --git a/lib/J3/ClassLib/ClasspathField.inc
> b/lib/J3/ClassLib/ClasspathField.inc
> index e56c82f..010c54b 100644
> --- a/lib/J3/ClassLib/ClasspathField.inc
> +++ b/lib/J3/ClassLib/ClasspathField.inc
> @@ -1154,18 +1154,4 @@ JavaObjectField* Field, JavaObject* obj, jdouble
> val) {
>   END_NATIVE_EXCEPTION
>  }
>
> -// Never throws.
> -JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* Unsafe, JavaObjectField* Field) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(Unsafe, 0);
> -
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  return (jlong)field->ptrOffset;
> -}
> -
>  }
> diff --git a/lib/J3/ClassLib/GNUClasspath/Classpath.inc
> b/lib/J3/ClassLib/GNUClasspath/Classpath.inc
> new file mode 100644
> index 0000000..3354774
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/Classpath.inc
> @@ -0,0 +1,289 @@
> +//===-------- Classpath.cpp - Configuration for classpath
> -------------------===//
> +//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +
> +
> +#include "Classpath.h"
> +#include "ClasspathReflect.h"
> +#include "JavaClass.h"
> +#include "JavaThread.h"
> +#include "JavaUpcalls.h"
> +#include "Jnjvm.h"
> +#include "Reader.h"
> +
> +using namespace j3;
> +
> +extern "C" {
> +
> +// Define hasClassInitializer because of a buggy implementation in
> Classpath.
> +JNIEXPORT bool JNICALL
> Java_java_io_VMObjectStreamClass_hasClassInitializer(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> +
> +  llvm_gcroot(Cl, 0);
> +  bool res = false;
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(Cl);
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
> +
> +  if (cl->isClass() &&
> +
>  cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
> +
> vm->bootstrapLoader->clinitType,
> +                                           true, false, 0))
> +  res = true;
> +
> +  END_NATIVE_EXCEPTION
> +
> +  return res;
> +}
> +
> +
> +// Redefine some VMObjectStreamClass functions because of a slow
> implementation
> +// in Classpath.
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jboolean val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceInt8Field(obj, (uint8)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jbyte val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceInt8Field(obj, (uint8)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jchar val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jshort val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceInt16Field(obj, (sint16)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jint val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceInt32Field(obj, (sint32)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jlong val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceLongField(obj, (sint64)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jfloat val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceFloatField(obj, (float)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jdouble val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceDoubleField(obj, (double)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  llvm_gcroot(val, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceObjectField(obj, val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_java_io_VMObjectInputStream_allocateObject(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
> +
> +  JavaObject* res = 0;
> +  llvm_gcroot(res, 0);
> +  llvm_gcroot(target, 0);
> +  llvm_gcroot(constr, 0);
> +  llvm_gcroot(cons, 0);
> +
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* cl =
> +    (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
> +  res = cl->doNew(vm);
> +  JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> +  meth->invokeIntSpecial(vm, cl, res);
> +
> +  END_NATIVE_EXCEPTION
> +
> +  return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_java_lang_reflect_VMArray_createObjectArray(
> +#ifdef NATIVE_JNI
> +JNIEnv * env,
> +jclass thisClass,
> +#endif
> +JavaObject* arrayType, jint arrayLength) {
> +
> +  JavaObject* res = 0;
> +  llvm_gcroot(arrayType, 0);
> +  llvm_gcroot(res, 0);
> +
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* base =
> +    UserCommonClass::resolvedImplClass(vm, arrayType, true);
> +  JnjvmClassLoader* loader = base->classLoader;
> +  const UTF8* name = base->getName();
> +  // -1 because we're adding a new dimension in this method.
> +  const int kLimit = 255 - 1;
> +  const uint16* elements = name->elements;
> +  if (name->size > kLimit && elements[kLimit] == '[') {
> +    vm->illegalArgumentException("Too many dimensions for array");
> +  }
> +  const UTF8* arrayName = loader->constructArrayName(1, name);
> +  UserClassArray* array = loader->constructArray(arrayName, base);
> +  res = array->doNew(arrayLength, vm);
> +
> +  END_NATIVE_EXCEPTION
> +
> +  return res;
> +}
> +
> +// Never throws.
> +JNIEXPORT
> +bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +) {
> +  return false;
> +}
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> index bc797d1..57197c4 100644
> --- a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> +++ b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> @@ -1071,8 +1071,8 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {
>
>  }
>
> -#include "ClasspathConstructor.inc"
>  #include "Classpath.inc"
> +#include "ClasspathConstructor.inc"
>  #include "ClasspathField.inc"
>  #include "ClasspathMethod.inc"
>  #include "ClasspathVMClass.inc"
> @@ -1084,3 +1084,4 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {
>  #include "ClasspathVMSystemProperties.inc"
>  #include "ClasspathVMThread.inc"
>  #include "ClasspathVMThrowable.inc"
> +#include "Unsafe.inc"
> diff --git a/lib/J3/ClassLib/GNUClasspath/Makefile
> b/lib/J3/ClassLib/GNUClasspath/Makefile
> index be80b9e..f5939c9 100644
> --- a/lib/J3/ClassLib/GNUClasspath/Makefile
> +++ b/lib/J3/ClassLib/GNUClasspath/Makefile
> @@ -9,9 +9,11 @@
>  LEVEL = ../../../..
>
>
> -EXTRA_DIST = ClasspathVMClass.inc ClasspathVMClassLoader.inc
> ClasspathVMObject.inc \
> -            ClasspathVMRuntime.inc ClasspathVMStackWalker.inc
> ClasspathVMSystem.inc \
> -            ClasspathVMSystemProperties.inc ClasspathVMThread.inc
> ClasspathVMThrowable.inc
> +EXTRA_DIST = Classpath.inc ClasspathVMClass.inc
> ClasspathVMClassLoader.inc \
> +             ClasspathVMObject.inc ClasspathVMRuntime.inc \
> +             ClasspathVMStackWalker.inc ClasspathVMSystem.inc \
> +             ClasspathVMSystemProperties.inc ClasspathVMThread.inc \
> +             ClasspathVMThrowable.inc
>
>  include $(LEVEL)/Makefile.config
>
> diff --git a/lib/J3/ClassLib/Makefile b/lib/J3/ClassLib/Makefile
> index 8252b92..8fd7e2a 100644
> --- a/lib/J3/ClassLib/Makefile
> +++ b/lib/J3/ClassLib/Makefile
> @@ -12,9 +12,9 @@ EXTRA_DIST = ArrayCopy.inc \
>              ClassContext.inc \
>              ClasspathConstructor.inc \
>              ClasspathField.inc \
> -             Classpath.inc \
>              ClasspathMethod.inc \
> -             SetProperties.inc
> +             SetProperties.inc \
> +             Unsafe.inc
>
>  include $(LEVEL)/Makefile.config
>
> diff --git a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> index 22db276..3fa6390 100644
> --- a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> +++ b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> @@ -897,7 +897,7 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {
>
>
>  #include "ClasspathConstructor.inc"
> -#include "Classpath.inc"
>  #include "ClasspathField.inc"
>  #include "ClasspathMethod.inc"
>  #include "OpenJDK.inc"
> +#include "Unsafe.inc"
> diff --git a/lib/J3/ClassLib/Unsafe.inc b/lib/J3/ClassLib/Unsafe.inc
> new file mode 100644
> index 0000000..44ffe73
> --- /dev/null
> +++ b/lib/J3/ClassLib/Unsafe.inc
> @@ -0,0 +1,565 @@
> +//===-------- Unsafe.inc - sun.misc.Unsafe implementation
> -----------------===//
> +//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +#include "VMStaticInstance.h"
> +#include <stdlib.h>
> +
> +/// fieldPtr - Compute the address of the field specified by the given
> +/// base/offset pair.  Non-trivial due to our handling of static
> instances,
> +/// and this also handles null-checking as required.
> +///
> +static inline uint8 *fieldPtr(JavaObject *base, long long offset,
> +  bool throwOnNull = true) {
> +
> +  // For most uses, a 'null' base should throw an exception.
> +  if (throwOnNull) verifyNull(base);
> +
> +  if (base && VMStaticInstance::isVMStaticInstance(base))
> +    return (uint8*)((VMStaticInstance*)base)->getStaticInstance() +
> offset;
> +  else
> +    return (uint8*)base + offset;
> +}
> +
> +extern "C" {
> +
> +//===--- Base/Offset methods
> ----------------------------------------------===//
> +
> +/// staticFieldOffset - Return the offset of a particular static field
> +/// Only valid to be used with the corresponding staticFieldBase
> +///
> +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;
> +}
> +
> +/// staticFieldBase - Return a JavaObject* representing the static
> instance.
> +/// Note that our static instances aren't actually java objects, so we use
> +/// a placeholder object "VMStaticInstance" that also ensures that
> +/// the corresponding class doesn't get GC'd underneath it.
> +///
> +JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_staticFieldBase(
> +JavaObject* unsafe, JavaObjectField* _field) {
> +  JavaObject* res = 0;
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(_field, 0);
> +  llvm_gcroot(res, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  JavaField * field = JavaObjectField::getInternalField(_field);
> +  assert(field);
> +  field->classDef->initialiseClass(JavaThread::get()->getJVM());
> +
> +  res = VMStaticInstance::allocate(field->classDef);
> +
> +  END_NATIVE_EXCEPTION;
> +
> +  return res;
> +}
> +
> +/// arrayBaseOffset - Offset from the array object where the actual
> +/// element data begins.
> +///
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayBaseOffset(
> +JavaObject* unsafe, JavaObject* clazz) {
> +  // Array starts at beginning of object
> +  return 0;
> +}
> +
> +/// arrayIndexScale - Indexing scale for the element type in
> +/// the specified array.  For use with arrayBaseOffset,
> +/// NthElementPtr = ArrayObject + BaseOffset + N*IndexScale
> +/// Return '0' if our JVM stores the elements in a way that
> +/// makes this type of access impossible or unsupported.
> +///
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* clazz) {
> +  // For now, just return '0', indicating we don't support this indexing.
> +  // TODO: Implement this for the array types we /do/ support this way.
> +  return 0;
> +}
> +
> +
> +
> +/// objectFieldOffset - Pointer offset of the specified field
> +///
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* Unsafe, JavaObjectField* Field) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(Unsafe, 0);
> +
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  return (jlong)field->ptrOffset;
> +}
> +
> +//===--- Double-register addressing field accessors
> -----------------------===//
> +// See objectFieldOffset, staticFieldOffset, staticFieldBase
> +// Can also be an array, if/when we support
> arrayIndexScale/arrayBaseOffset
> +#define GET_PUT_OFFSET(Type,jtype,shorttype) \
> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
> __Ljava_lang_Object_2J( \
> +JavaObject* unsafe, JavaObject* base, jlong offset) { \
> +  jtype res = 0; \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  jtype* ptr = (jtype*)fieldPtr(base,offset); \
> +  res = *ptr; \
> +  END_NATIVE_EXCEPTION \
> +  return res; \
> +} \
> + \
> +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*)fieldPtr(base, offset); \
> +  *ptr = val; \
> +  END_NATIVE_EXCEPTION \
> +}
> +
> +//===--- Direct address read/write acccessors
> -----------------------------===//
> +#define GET_PUT_DIRECT(Type,jtype,shorttype) \
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ## __J ##
> shorttype( \
> +JavaObject* unsafe, jlong ptr, jtype val) { \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  *(jtype*)ptr = val; \
> +  END_NATIVE_EXCEPTION \
> +} \
> + \
> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## __J( \
> +JavaObject* unsafe, jlong ptr) { \
> +  jtype res = 0; \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  res = *(jtype*)ptr; \
> +  END_NATIVE_EXCEPTION \
> +  return res; \
> +}
> +
> +//===--- Volatile variant of field accessors
> ------------------------------===//
> +// Memory barriers after writes to ensure new value is seen elsewhere
> +#define GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##
> Volatile__J ## shorttype( \
> +JavaObject* unsafe, jlong ptr, jtype val) { \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  *(volatile jtype*)ptr = val; \
> +  __sync_synchronize(); \
> +  END_NATIVE_EXCEPTION \
> +} \
> + \
> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## Volatile__J( \
> +JavaObject* unsafe, jlong ptr) { \
> +  jtype res = 0; \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  res = *(volatile jtype*)ptr; \
> +  END_NATIVE_EXCEPTION \
> +  return res; \
> +}
> +
> +//===--- Volatile variant of direct address accessors
> ---------------------===//
> +#define GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype) \
> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
> Volatile__Ljava_lang_Object_2J( \
> +JavaObject* unsafe, JavaObject* base, jlong offset) { \
> +  jtype res = 0; \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
> +  res = *ptr; \
> +  END_NATIVE_EXCEPTION \
> + \
> +  return res; \
> +} \
> + \
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##
> Volatile__Ljava_lang_Object_2J ## shorttype( \
> +JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
> +  *ptr = val; \
> +  __sync_synchronize(); \
> +  END_NATIVE_EXCEPTION \
> +}
> +
> +//===--- Ordered variant of field accessors
> -------------------------------===//
> +#define GET_PUT_FIELD_ORDERED(Type,jtype,shorttype) \
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrdered ## Type( \
> +JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
> +  *ptr = val; \
> +  /* No memory barrier */ \
> +  END_NATIVE_EXCEPTION \
> +}
> +
> +#define GET_PUT_ALL(Type,jtype,shorttype) \
> +  GET_PUT_OFFSET(Type,jtype,shorttype) \
> +  GET_PUT_DIRECT(Type,jtype,shorttype) \
> +  GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \
> +  GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype)
> +
> +GET_PUT_ALL(Boolean,jboolean,Z)
> +GET_PUT_ALL(Byte,jbyte,B)
> +GET_PUT_ALL(Char,jchar,C)
> +GET_PUT_ALL(Short,jshort,S)
> +GET_PUT_ALL(Int,jint,I)
> +GET_PUT_ALL(Long,jlong,J) // TODO: Long needs special handling!
> +GET_PUT_ALL(Float,jfloat,F)
> +GET_PUT_ALL(Double,jdouble,D)
> +
> +// Ordered:
> +GET_PUT_FIELD_ORDERED(Int,jint,I)
> +GET_PUT_FIELD_ORDERED(Long,jlong,J)
> +
> +//===--- Get/Put of Objects, due to GC needs special handling
> -------------===//
> +// JavaObject field accessors:
> +JNIEXPORT void JNICALL
> Java_sun_misc_Unsafe_putObject__Ljava_lang_Object_2JLjava_lang_Object_2(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(base, 0);
> +  llvm_gcroot(value, 0);
> +
> +  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
> +  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
> (gc*)value);
> +}
> +
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_sun_misc_Unsafe_getObject__Ljava_lang_Object_2J(
> +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**)fieldPtr(base, offset);
> +  res = *ptr;
> +  END_NATIVE_EXCEPTION;
> +
> +  return res;
> +}
> +
> +// Volatile JavaObject field accessors:
> +// Never throws.
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(base, 0);
> +  llvm_gcroot(value, 0);
> +
> +  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
> +  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
> (gc*)value);
> +  // Ensure this value is seen.
> +  __sync_synchronize();
> +}
> +
> +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* volatile* ptr = (JavaObject* volatile*)fieldPtr(base,
> offset);
> +  res = *ptr;
> +  END_NATIVE_EXCEPTION;
> +
> +  return res;
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrderedObject(
> +JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(base, 0);
> +  llvm_gcroot(value, 0);
> +
> +  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
> +  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
> (gc*)value);
> +  // No barrier (difference between volatile and ordered)
> +}
> +
> +
> +//===--- CompareAndSwap field accessors
> -----------------------------------===//
> +// Never throws.
> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* base, jlong offset, jlong expect,
> jlong update) {
> +
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(base, 0);
> +  jlong *ptr;
> +  jlong  value;
> +
> +  // TODO: Why isn't this atomic?
> +  ptr = (jlong*)fieldPtr(base, offset);
> +
> +  value = *ptr;
> +
> +  if (value == expect) {
> +    *ptr = update;
> +    return true;
> +  } else {
> +    return false;
> +  }
> +
> +}
> +
> +// Never throws.
> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* base, jlong offset, jint expect, jint
> update) {
> +
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(base, 0);
> +  jint *ptr;
> +
> +  ptr = (jint *)fieldPtr(base, offset);
> +
> +  return __sync_bool_compare_and_swap(ptr, expect, update);
> +}
> +
> +// Never throws.
> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* expect,
> +JavaObject* update) {
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(base, 0);
> +  llvm_gcroot(expect, 0);
> +  llvm_gcroot(update, 0);
> +
> +  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
> +  return mvm::Collector::objectReferenceTryCASBarrier((gc*)base,
> (gc**)ptr, (gc*)expect, (gc*)update);
> +}
> +
> +
> +//===--- Class-related functions
> ------------------------------------------===//
> +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());
> +  cl->asClass()->resolveClass();
> +  cl->asClass()->initialiseClass(vm);
> +
> +  END_NATIVE_EXCEPTION;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BII(
> +JavaObject* unsafe, JavaString *name, ArrayObject * bytesArr, jint
> off, jint len) {
> +  UNIMPLEMENTED();
> +}
> +
> +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 JavaObject* JNICALL Java_sun_Unsafe_defineAnonymousClass(
> +JavaObject* unsafe, ...) {
> +  UNIMPLEMENTED();
> +}
> +
> +//===--- Memory functions
> -------------------------------------------------===//
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_setMemory__JJB(
> +JavaObject* unsafe, long address, long bytes, jbyte value) {
> +  memset((void*)address, value, bytes);
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_copyMemory__JJJ(
> +JavaObject* unsafe, jlong src, jlong dst, jlong size) {
> +  memcpy((void*)dst, (void*)src, size);
> +}
> +
> +JNIEXPORT void JNICALL
> Java_sun_misc_Unsafe_copyMemory__Ljava_lang_Object_2JLjava_lang_Object_2JJ(
> +JavaObject* unsafe,
> +JavaObject* srcBase, jlong srcOffset,
> +JavaObject* dstBase, jlong dstOffset,
> +jlong size) {
> +  BEGIN_NATIVE_EXCEPTION(0)
> +  uint8_t* src = fieldPtr(srcBase, srcOffset, false /* Don't throw on
> null base*/ );
> +  uint8_t* dst = fieldPtr(dstBase, dstOffset, false /* Don't throw on
> null base*/ );
> +  memcpy(dst, src, size);
> +  END_NATIVE_EXCEPTION
> +}
> +
> +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 jlong JNICALL Java_sun_misc_Unsafe_reallocateMemory(
> +JavaObject* unsafe, jlong ptr, jlong newsize) {
> +  // TODO: Invalid size/OOM/etc handling!
> +  jlong res = 0;
> +  BEGIN_NATIVE_EXCEPTION(0)
> +  res = (jlong)realloc((void*)ptr, newsize);
> +  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 jlong JNICALL Java_sun_misc_Unsafe_getAddress(
> +JavaObject* unsafe, jlong ptr) {
> +  return (jlong)*(void**)ptr;
> +}
> +
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_putAddress(
> +JavaObject* unsafe, jlong ptr, jlong val) {
> +  *(void**)ptr = (void*)val;
> +}
> +
> +//===--- Park/Unpark thread support
> ---------------------------------------===//
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_park(
> +JavaObject* unsafe, jboolean isAbsolute, jlong time) {
> +  // Nothing, for now.
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_unpark(
> +JavaObject* unsafe, JavaObject* thread) {
> +  // Nothing, for now.
> +}
> +
> +//===--- Monitor support
> --------------------------------------------------===//
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_tryMonitorEnter(
> +JavaObject* unsafe, JavaObject * obj) {
> +  //TODO: Implement me!
> +  UNIMPLEMENTED();
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorEnter(
> +JavaObject* unsafe, JavaObject * obj) {
> +  //TODO: Implement me!
> +  UNIMPLEMENTED();
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorExit(
> +JavaObject* unsafe, JavaObject * obj) {
> +  //TODO: Implement me!
> +  UNIMPLEMENTED();
> +}
> +
> +//===--- Misc support functions
> -------------------------------------------===//
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
> +  // Nothing, we define the Unsafe methods with the expected signatures.
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_throwException(
> +JavaObject* unsafe, JavaObject * obj) {
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(obj, 0);
> +
> +  JavaThread::get()->throwException(obj);
> +}
> +
> +JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_pageSize(
> +JavaObject* unsafe) {
> +  return mvm::System::GetPageSize();
> +}
> +
> +JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_addressSize(
> +JavaObject* unsafe) {
> +  return mvm::kWordSize;
> +}
> +
> +JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_getLoadAverage(
> +JavaObject* unsafe, ...) {
> +  UNIMPLEMENTED();
> +}
> +
> +}
> --
> 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/20111115/9f1e4872/attachment.html>

From nicolas.geoffray at lip6.fr  Tue Nov 15 12:25:38 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Tue, 15 Nov 2011 20:25:38 -0000
Subject: [vmkit-commits] [vmkit] r144690 - in
 /vmkit/trunk/lib/Mvm/CommonThread: Sigsegv-macos-x64.inc ctthread.cpp
Message-ID: <20111115202538.6B3D12A6C131@llvm.org>

Author: geoffray
Date: Tue Nov 15 14:25:38 2011
New Revision: 144690

URL: http://llvm.org/viewvc/llvm-project?rev=144690&view=rev
Log:
Use hardware overflow check to implement stack overflow on macos/x64.


Modified:
    vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-macos-x64.inc
    vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp

Modified: vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-macos-x64.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-macos-x64.inc?rev=144690&r1=144689&r2=144690&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-macos-x64.inc (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/Sigsegv-macos-x64.inc Tue Nov 15 14:25:38 2011
@@ -18,6 +18,17 @@
     "pushq %rdi\n"
     "jmp   _ThrowNullPointerException\n"
     );
+
+  void HandleStackOverflow(void);
+  asm(
+    ".text\n"
+    ".align 8\n"
+    ".globl HandleStackOverflow\n"
+  "_HandleStackOverflow:\n"
+    "pushq %rbp\n"
+    "movq %rsi, %rbp\n"
+    "callq   _ThrowStackOverflowError\n"
+    );
 }
 
 void Handler::UpdateRegistersForNPE() {
@@ -26,7 +37,11 @@
 }
 
 void Handler::UpdateRegistersForStackOverflow() {
-  UNREACHABLE();
+  word_t alt_stack = mvm::Thread::get()->GetAlternativeStackStart();
+  ((ucontext_t*)context)->uc_mcontext->__ss.__rdi = System::GetIPFromCallerAddress(((ucontext_t*)context)->uc_mcontext->__ss.__rbp);
+  ((ucontext_t*)context)->uc_mcontext->__ss.__rsi = ((ucontext_t*)context)->uc_mcontext->__ss.__rbp;
+  ((ucontext_t*)context)->uc_mcontext->__ss.__rsp = alt_stack;
+  ((ucontext_t*)context)->uc_mcontext->__ss.__rip = (word_t)HandleStackOverflow;
 }
 
 bool System::SupportsHardwareNullCheck() {
@@ -34,5 +49,5 @@
 }
 
 bool System::SupportsHardwareStackOverflow() {
-  return false;
+  return true;
 }

Modified: vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp?rev=144690&r1=144689&r2=144690&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp Tue Nov 15 14:25:38 2011
@@ -342,6 +342,7 @@
   sa.sa_mask = mask;
   sa.sa_sigaction = sigsegvHandler;
   sigaction(SIGSEGV, &sa, NULL);
+  sigaction(SIGBUS, &sa, NULL);
 
   assert(th->MyVM && "VM not set in a thread");
   th->MyVM->rendezvous.addThread(th);




From wdietz2 at illinois.edu  Tue Nov 15 12:41:14 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 15 Nov 2011 14:41:14 -0600
Subject: [vmkit-commits] [PATCH] Fix symbol search order to fix
 detection of symbols from vmkit or loaded libs
In-Reply-To: <CAPYwfipL3QRtg5R_UOs8aE03MjxHJ_+1roWHoA1BKAmfWXk80g@mail.gmail.com>
References: <CAKGWAO9iGU7UtXrxEZSvUKfXvkw=G-DaFX6rE+uL1FsP64skvA@mail.gmail.com>
	<CAPYwfipL3QRtg5R_UOs8aE03MjxHJ_+1roWHoA1BKAmfWXk80g@mail.gmail.com>
Message-ID: <CAKGWAO-ZEm=Tn96gR-daBx13=rn2k0pdQhK6zRGjbec=q_xCvg@mail.gmail.com>

On Tue, Nov 15, 2011 at 2:24 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> Hi Will,
>
> I'm not sure that's right. With GNU Classpath, I also want to define my own
> methods and not use the ones implemented in Classpath. If we reorder things,
> the method defined in GNU Classpath will be used. Not mine.
> vmkit is using RTLD_LOCAL when loading, so symbol resolution on a dlsym must
> provide the loaded library. If you do dlsym(SELF_HANDLE, 'mysymbol'), you'll
> only get symbols loaded in the j3 executable.
> What is it that does not work for you?
> Cheers,
> Nicolas
>

Hmm.

Well, to answer your question I'm seeing the 'j3' flag set for things
like Java_awt_Font_initIDs, resulting in calling the functions wrong.

As for whether or not it's correct: I'm not sure that
dlsym(RTLD_DEFAULT,...) is the same as dlsym(dlopen(NULL),...), which
might be the difference.  The latter clearly does what you suggest,
the former I'm not sure (from the man pages).

I'll double-check what's going on locally, and get back to you.

Thanks! :)

~Will


From wdietz2 at illinois.edu  Tue Nov 15 12:41:31 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 15 Nov 2011 14:41:31 -0600
Subject: [vmkit-commits] [PATCH] Define all sun.misc.Unsafe methods,
 refactor into new "Unsafe.inc"
In-Reply-To: <CAPYwfiqt_2QQCWu6C2Hes64R2tQFaXq-NUAzFwGfvsSf3Ux8tQ@mail.gmail.com>
References: <CAKGWAO_j2gi97iAB8r4Xea-yYJ0iL+GUvx4uC5=DH-0bkTh51g@mail.gmail.com>
	<CAKGWAO8RnUZO6PJ4WxC8=OEs8t7AWY15XbUzPH5vn4NX2aEE5A@mail.gmail.com>
	<CAPYwfiqt_2QQCWu6C2Hes64R2tQFaXq-NUAzFwGfvsSf3Ux8tQ@mail.gmail.com>
Message-ID: <CAKGWAO9wqhC9kS=ir3e7Qei=EHm=a5O3nRaMzBWNTU9cxDJggQ@mail.gmail.com>

Sure thing :).

~Will

On Tue, Nov 15, 2011 at 2:26 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> Hi Will,
> With this patch, it's hard to know what you added. Could you commit a first
> patch that just moves files around, and then add your new code in a new
> patch?
> Thanks!
> Nicolas
>
> On Tue, Nov 15, 2011 at 9:12 PM, Will Dietz <wdietz2 at illinois.edu> wrote:
>>
>> Inlined below, and attached.
>>
>> Besides implementing the rest of Unsafe, move the Classpath-only code
>> from (what is currently) lib/J3/ClassLib/Classpath.inc into
>> GNUClasspath.
>>
>> Thoughts welcome, and sorry for noisy diff.
>>
>> Thanks!
>>
>> ~Will
>>
>> >From d5a34423a7f917454af7b759f468dec02925110d Mon Sep 17 00:00:00 2001
>> From: Will Dietz <w at wdtz.org>
>> Date: Tue, 8 Nov 2011 19:22:46 -0600
>> Subject: [PATCH 1/2] Define all sun.misc.Unsafe methods, refactor into new
>>  "Unsafe.inc"
>>
>> ---
>>  lib/J3/ClassLib/Classpath.inc                |  588
>> --------------------------
>>  lib/J3/ClassLib/ClasspathField.inc           |   14 -
>>  lib/J3/ClassLib/GNUClasspath/Classpath.inc   |  289 +++++++++++++
>>  lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp |    3 +-
>>  lib/J3/ClassLib/GNUClasspath/Makefile        |    8 +-
>>  lib/J3/ClassLib/Makefile                     |    4 +-
>>  lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp      |    2 +-
>>  lib/J3/ClassLib/Unsafe.inc                   |  565
>> +++++++++++++++++++++++++
>>  8 files changed, 864 insertions(+), 609 deletions(-)
>>  delete mode 100644 lib/J3/ClassLib/Classpath.inc
>>  create mode 100644 lib/J3/ClassLib/GNUClasspath/Classpath.inc
>>  create mode 100644 lib/J3/ClassLib/Unsafe.inc
>>
>> diff --git a/lib/J3/ClassLib/Classpath.inc b/lib/J3/ClassLib/Classpath.inc
>> deleted file mode 100644
>> index 4fb16a4..0000000
>> --- a/lib/J3/ClassLib/Classpath.inc
>> +++ /dev/null
>> @@ -1,588 +0,0 @@
>> -//===-------- Classpath.cpp - Configuration for classpath
>> -------------------===//
>> -//
>> -//                            The VMKit project
>> -//
>> -// This file is distributed under the University of Illinois Open Source
>> -// License. See LICENSE.TXT for details.
>> -//
>>
>> -//===----------------------------------------------------------------------===//
>> -
>> -
>> -
>> -#include "Classpath.h"
>> -#include "ClasspathReflect.h"
>> -#include "JavaClass.h"
>> -#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
>> -JNIEnv *env,
>> -jclass clazz,
>> -#endif
>> -JavaObject* Cl) {
>> -
>> -  llvm_gcroot(Cl, 0);
>> -  bool res = false;
>> -  BEGIN_NATIVE_EXCEPTION(0)
>> -
>> -  verifyNull(Cl);
>> -  Jnjvm* vm = JavaThread::get()->getJVM();
>> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
>> -
>> -  if (cl->isClass() &&
>> -
>>  cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
>> -
>> vm->bootstrapLoader->clinitType,
>> -                                           true, false, 0))
>> -  res = true;
>> -
>> -  END_NATIVE_EXCEPTION
>> -
>> -  return res;
>> -}
>> -
>> -
>> -// Redefine some VMObjectStreamClass functions because of a slow
>> implementation
>> -// in Classpath.
>> -
>> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -jclass clazz,
>> -#endif
>> -JavaObjectField* Field, JavaObject* obj, jboolean val) {
>> -
>> -  llvm_gcroot(Field, 0);
>> -  llvm_gcroot(obj, 0);
>> -  BEGIN_NATIVE_EXCEPTION(0)
>> -
>> -  verifyNull(obj);
>> -  JavaField* field = JavaObjectField::getInternalField(Field);
>> -  field->setInstanceInt8Field(obj, (uint8)val);
>> -
>> -  END_NATIVE_EXCEPTION
>> -}
>> -
>> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -jclass clazz,
>> -#endif
>> -JavaObjectField* Field, JavaObject* obj, jbyte val) {
>> -
>> -  llvm_gcroot(Field, 0);
>> -  llvm_gcroot(obj, 0);
>> -  BEGIN_NATIVE_EXCEPTION(0)
>> -
>> -  verifyNull(obj);
>> -  JavaField* field = JavaObjectField::getInternalField(Field);
>> -  field->setInstanceInt8Field(obj, (uint8)val);
>> -
>> -  END_NATIVE_EXCEPTION
>> -}
>> -
>> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -jclass clazz,
>> -#endif
>> -JavaObjectField* Field, JavaObject* obj, jchar val) {
>> -
>> -  llvm_gcroot(Field, 0);
>> -  llvm_gcroot(obj, 0);
>> -  BEGIN_NATIVE_EXCEPTION(0)
>> -
>> -  verifyNull(obj);
>> -  JavaField* field = JavaObjectField::getInternalField(Field);
>> -  field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
>> -
>> -  END_NATIVE_EXCEPTION
>> -}
>> -
>> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -jclass clazz,
>> -#endif
>> -JavaObjectField* Field, JavaObject* obj, jshort val) {
>> -
>> -  llvm_gcroot(Field, 0);
>> -  llvm_gcroot(obj, 0);
>> -  BEGIN_NATIVE_EXCEPTION(0)
>> -
>> -  verifyNull(obj);
>> -  JavaField* field = JavaObjectField::getInternalField(Field);
>> -  field->setInstanceInt16Field(obj, (sint16)val);
>> -
>> -  END_NATIVE_EXCEPTION
>> -}
>> -
>> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -jclass clazz,
>> -#endif
>> -JavaObjectField* Field, JavaObject* obj, jint val) {
>> -
>> -  llvm_gcroot(Field, 0);
>> -  llvm_gcroot(obj, 0);
>> -  BEGIN_NATIVE_EXCEPTION(0)
>> -
>> -  verifyNull(obj);
>> -  JavaField* field = JavaObjectField::getInternalField(Field);
>> -  field->setInstanceInt32Field(obj, (sint32)val);
>> -
>> -  END_NATIVE_EXCEPTION
>> -}
>> -
>> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -jclass clazz,
>> -#endif
>> -JavaObjectField* Field, JavaObject* obj, jlong val) {
>> -
>> -  llvm_gcroot(Field, 0);
>> -  llvm_gcroot(obj, 0);
>> -  BEGIN_NATIVE_EXCEPTION(0)
>> -
>> -  verifyNull(obj);
>> -  JavaField* field = JavaObjectField::getInternalField(Field);
>> -  field->setInstanceLongField(obj, (sint64)val);
>> -
>> -  END_NATIVE_EXCEPTION
>> -}
>> -
>> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -jclass clazz,
>> -#endif
>> -JavaObjectField* Field, JavaObject* obj, jfloat val) {
>> -
>> -  llvm_gcroot(Field, 0);
>> -  llvm_gcroot(obj, 0);
>> -  BEGIN_NATIVE_EXCEPTION(0)
>> -
>> -  verifyNull(obj);
>> -  JavaField* field = JavaObjectField::getInternalField(Field);
>> -  field->setInstanceFloatField(obj, (float)val);
>> -
>> -  END_NATIVE_EXCEPTION
>> -}
>> -
>> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -jclass clazz,
>> -#endif
>> -JavaObjectField* Field, JavaObject* obj, jdouble val) {
>> -
>> -  llvm_gcroot(Field, 0);
>> -  llvm_gcroot(obj, 0);
>> -  BEGIN_NATIVE_EXCEPTION(0)
>> -
>> -  verifyNull(obj);
>> -  JavaField* field = JavaObjectField::getInternalField(Field);
>> -  field->setInstanceDoubleField(obj, (double)val);
>> -
>> -  END_NATIVE_EXCEPTION
>> -}
>> -
>> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -jclass clazz,
>> -#endif
>> -JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
>> -
>> -  llvm_gcroot(Field, 0);
>> -  llvm_gcroot(obj, 0);
>> -  llvm_gcroot(val, 0);
>> -  BEGIN_NATIVE_EXCEPTION(0)
>> -
>> -  verifyNull(obj);
>> -  JavaField* field = JavaObjectField::getInternalField(Field);
>> -  field->setInstanceObjectField(obj, val);
>> -
>> -  END_NATIVE_EXCEPTION
>> -}
>> -
>> -JNIEXPORT JavaObject* JNICALL
>> Java_java_io_VMObjectInputStream_allocateObject(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -jclass clazz,
>> -#endif
>> -JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
>> -
>> -  JavaObject* res = 0;
>> -  llvm_gcroot(res, 0);
>> -  llvm_gcroot(target, 0);
>> -  llvm_gcroot(constr, 0);
>> -  llvm_gcroot(cons, 0);
>> -
>> -  BEGIN_NATIVE_EXCEPTION(0)
>> -
>> -  Jnjvm* vm = JavaThread::get()->getJVM();
>> -  UserClass* cl =
>> -    (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
>> -  res = cl->doNew(vm);
>> -  JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
>> -  meth->invokeIntSpecial(vm, cl, res);
>> -
>> -  END_NATIVE_EXCEPTION
>> -
>> -  return res;
>> -}
>> -
>> -JNIEXPORT JavaObject* JNICALL
>> Java_java_lang_reflect_VMArray_createObjectArray(
>> -#ifdef NATIVE_JNI
>> -JNIEnv * env,
>> -jclass thisClass,
>> -#endif
>> -JavaObject* arrayType, jint arrayLength) {
>> -
>> -  JavaObject* res = 0;
>> -  llvm_gcroot(arrayType, 0);
>> -  llvm_gcroot(res, 0);
>> -
>> -  BEGIN_NATIVE_EXCEPTION(0)
>> -
>> -  Jnjvm* vm = JavaThread::get()->getJVM();
>> -  UserCommonClass* base =
>> -    UserCommonClass::resolvedImplClass(vm, arrayType, true);
>> -  JnjvmClassLoader* loader = base->classLoader;
>> -  const UTF8* name = base->getName();
>> -  // -1 because we're adding a new dimension in this method.
>> -  const int kLimit = 255 - 1;
>> -  const uint16* elements = name->elements;
>> -  if (name->size > kLimit && elements[kLimit] == '[') {
>> -    vm->illegalArgumentException("Too many dimensions for array");
>> -  }
>> -  const UTF8* arrayName = loader->constructArrayName(1, name);
>> -  UserClassArray* array = loader->constructArray(arrayName, base);
>> -  res = array->doNew(arrayLength, vm);
>> -
>> -  END_NATIVE_EXCEPTION
>> -
>> -  return res;
>> -}
>> -
>> -
>> -// Never throws.
>> -JNIEXPORT
>> -bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -jclass clazz,
>> -#endif
>> -) {
>> -  return false;
>> -}
>> -
>> -// Never throws.
>> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -#endif
>> -JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
>> jlong update) {
>> -
>> -  llvm_gcroot(unsafe, 0);
>> -  llvm_gcroot(obj, 0);
>> -  jlong *ptr;
>> -  jlong  value;
>> -
>> -  ptr = (jlong *) (((uint8 *) obj) + offset);
>> -
>> -  value = *ptr;
>> -
>> -  if (value == expect) {
>> -    *ptr = update;
>> -    return true;
>> -  } else {
>> -    return false;
>> -  }
>> -
>> -}
>> -
>> -// Never throws.
>> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -#endif
>> -JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint
>> update) {
>> -
>> -  llvm_gcroot(unsafe, 0);
>> -  llvm_gcroot(obj, 0);
>> -  jint *ptr;
>> -
>> -  ptr = (jint *) (((uint8 *) obj) + offset);
>> -
>> -  return __sync_bool_compare_and_swap(ptr, expect, update);
>> -}
>> -
>> -// Never throws.
>> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -#endif
>> -JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
>> -JavaObject* update) {
>> -  llvm_gcroot(unsafe, 0);
>> -  llvm_gcroot(obj, 0);
>> -  llvm_gcroot(expect, 0);
>> -  llvm_gcroot(update, 0);
>> -
>> -  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
>> -
>> -  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
>> (gc**)ptr, (gc*)expect, (gc*)update);
>> -}
>> -
>> -// Never throws.
>> -JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -#endif
>> -JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {
>> -  llvm_gcroot(unsafe, 0);
>> -  llvm_gcroot(obj, 0);
>> -  llvm_gcroot(value, 0);
>> -
>> -  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
>> -  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());
>> -  cl->asClass()->resolveClass();
>> -  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) {
>> -  JavaObject* res = 0;
>> -  llvm_gcroot(unsafe, 0);
>> -  llvm_gcroot(_field, 0);
>> -  llvm_gcroot(res, 0);
>> -  BEGIN_NATIVE_EXCEPTION(0)
>> -
>> -  JavaField * field = JavaObjectField::getInternalField(_field);
>> -  assert(field);
>> -  field->classDef->initialiseClass(JavaThread::get()->getJVM());
>> -
>> -  res = VMStaticInstance::allocate(field->classDef);
>> -
>> -  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) {
>> -  // Array starts at beginning of object
>> -  return 0;
>> -}
>> -
>> -JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -#endif
>> -JavaObject* unsafe, JavaObject* clazz) {
>> -  // Return '0' if we don't support indexing this way.
>> -  // (We might pack fields specially, etc)
>> -  // TODO: Implement this for the array types we support this way
>> -  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()->throwException(obj);
>> -}
>> -
>> -JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*)
>> {
>> -  // Nothing
>> -}
>> -
>> -// TODO: Add the Volatile variants
>> -#define GET_PUT_OFFSET(Type,jtype,shorttype) \
>> -JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
>> __Ljava_lang_Object_2J( \
>> -JavaObject* unsafe, JavaObject* base, jlong offset) { \
>> -  jtype res = 0; \
>> -  BEGIN_NATIVE_EXCEPTION(0) \
>> -  jtype* ptr = (jtype*) (baseToPtr(base) + offset); \
>> -  res = *ptr; \
>> -  END_NATIVE_EXCEPTION \
>> - \
>> -  return res; \
>> -} \
>> - \
>> -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*) (baseToPtr(base) + offset); \
>> -  *ptr = val; \
>> -  END_NATIVE_EXCEPTION \
>> -}
>> -
>> -GET_PUT_OFFSET(Boolean,jboolean,Z)
>> -GET_PUT_OFFSET(Byte,jbyte,B)
>> -GET_PUT_OFFSET(Char,jchar,C)
>> -GET_PUT_OFFSET(Short,jshort,S)
>> -GET_PUT_OFFSET(Int,jint,I)
>> -GET_PUT_OFFSET(Long,jlong,J)
>> -GET_PUT_OFFSET(Float,jfloat,F)
>> -GET_PUT_OFFSET(Double,jdouble,D)
>> -
>> -}
>> diff --git a/lib/J3/ClassLib/ClasspathField.inc
>> b/lib/J3/ClassLib/ClasspathField.inc
>> index e56c82f..010c54b 100644
>> --- a/lib/J3/ClassLib/ClasspathField.inc
>> +++ b/lib/J3/ClassLib/ClasspathField.inc
>> @@ -1154,18 +1154,4 @@ JavaObjectField* Field, JavaObject* obj, jdouble
>> val) {
>>   END_NATIVE_EXCEPTION
>>  }
>>
>> -// Never throws.
>> -JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
>> -#ifdef NATIVE_JNI
>> -JNIEnv *env,
>> -#endif
>> -JavaObject* Unsafe, JavaObjectField* Field) {
>> -
>> -  llvm_gcroot(Field, 0);
>> -  llvm_gcroot(Unsafe, 0);
>> -
>> -  JavaField* field = JavaObjectField::getInternalField(Field);
>> -  return (jlong)field->ptrOffset;
>> -}
>> -
>>  }
>> diff --git a/lib/J3/ClassLib/GNUClasspath/Classpath.inc
>> b/lib/J3/ClassLib/GNUClasspath/Classpath.inc
>> new file mode 100644
>> index 0000000..3354774
>> --- /dev/null
>> +++ b/lib/J3/ClassLib/GNUClasspath/Classpath.inc
>> @@ -0,0 +1,289 @@
>> +//===-------- Classpath.cpp - Configuration for classpath
>> -------------------===//
>> +//
>> +//                            The VMKit project
>> +//
>> +// This file is distributed under the University of Illinois Open Source
>> +// License. See LICENSE.TXT for details.
>> +//
>>
>> +//===----------------------------------------------------------------------===//
>> +
>> +
>> +
>> +#include "Classpath.h"
>> +#include "ClasspathReflect.h"
>> +#include "JavaClass.h"
>> +#include "JavaThread.h"
>> +#include "JavaUpcalls.h"
>> +#include "Jnjvm.h"
>> +#include "Reader.h"
>> +
>> +using namespace j3;
>> +
>> +extern "C" {
>> +
>> +// Define hasClassInitializer because of a buggy implementation in
>> Classpath.
>> +JNIEXPORT bool JNICALL
>> Java_java_io_VMObjectStreamClass_hasClassInitializer(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +jclass clazz,
>> +#endif
>> +JavaObject* Cl) {
>> +
>> +  llvm_gcroot(Cl, 0);
>> +  bool res = false;
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +
>> +  verifyNull(Cl);
>> +  Jnjvm* vm = JavaThread::get()->getJVM();
>> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
>> +
>> +  if (cl->isClass() &&
>> +
>>  cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
>> +
>> vm->bootstrapLoader->clinitType,
>> +                                           true, false, 0))
>> +  res = true;
>> +
>> +  END_NATIVE_EXCEPTION
>> +
>> +  return res;
>> +}
>> +
>> +
>> +// Redefine some VMObjectStreamClass functions because of a slow
>> implementation
>> +// in Classpath.
>> +
>> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +jclass clazz,
>> +#endif
>> +JavaObjectField* Field, JavaObject* obj, jboolean val) {
>> +
>> +  llvm_gcroot(Field, 0);
>> +  llvm_gcroot(obj, 0);
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +
>> +  verifyNull(obj);
>> +  JavaField* field = JavaObjectField::getInternalField(Field);
>> +  field->setInstanceInt8Field(obj, (uint8)val);
>> +
>> +  END_NATIVE_EXCEPTION
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +jclass clazz,
>> +#endif
>> +JavaObjectField* Field, JavaObject* obj, jbyte val) {
>> +
>> +  llvm_gcroot(Field, 0);
>> +  llvm_gcroot(obj, 0);
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +
>> +  verifyNull(obj);
>> +  JavaField* field = JavaObjectField::getInternalField(Field);
>> +  field->setInstanceInt8Field(obj, (uint8)val);
>> +
>> +  END_NATIVE_EXCEPTION
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +jclass clazz,
>> +#endif
>> +JavaObjectField* Field, JavaObject* obj, jchar val) {
>> +
>> +  llvm_gcroot(Field, 0);
>> +  llvm_gcroot(obj, 0);
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +
>> +  verifyNull(obj);
>> +  JavaField* field = JavaObjectField::getInternalField(Field);
>> +  field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
>> +
>> +  END_NATIVE_EXCEPTION
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +jclass clazz,
>> +#endif
>> +JavaObjectField* Field, JavaObject* obj, jshort val) {
>> +
>> +  llvm_gcroot(Field, 0);
>> +  llvm_gcroot(obj, 0);
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +
>> +  verifyNull(obj);
>> +  JavaField* field = JavaObjectField::getInternalField(Field);
>> +  field->setInstanceInt16Field(obj, (sint16)val);
>> +
>> +  END_NATIVE_EXCEPTION
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +jclass clazz,
>> +#endif
>> +JavaObjectField* Field, JavaObject* obj, jint val) {
>> +
>> +  llvm_gcroot(Field, 0);
>> +  llvm_gcroot(obj, 0);
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +
>> +  verifyNull(obj);
>> +  JavaField* field = JavaObjectField::getInternalField(Field);
>> +  field->setInstanceInt32Field(obj, (sint32)val);
>> +
>> +  END_NATIVE_EXCEPTION
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +jclass clazz,
>> +#endif
>> +JavaObjectField* Field, JavaObject* obj, jlong val) {
>> +
>> +  llvm_gcroot(Field, 0);
>> +  llvm_gcroot(obj, 0);
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +
>> +  verifyNull(obj);
>> +  JavaField* field = JavaObjectField::getInternalField(Field);
>> +  field->setInstanceLongField(obj, (sint64)val);
>> +
>> +  END_NATIVE_EXCEPTION
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +jclass clazz,
>> +#endif
>> +JavaObjectField* Field, JavaObject* obj, jfloat val) {
>> +
>> +  llvm_gcroot(Field, 0);
>> +  llvm_gcroot(obj, 0);
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +
>> +  verifyNull(obj);
>> +  JavaField* field = JavaObjectField::getInternalField(Field);
>> +  field->setInstanceFloatField(obj, (float)val);
>> +
>> +  END_NATIVE_EXCEPTION
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +jclass clazz,
>> +#endif
>> +JavaObjectField* Field, JavaObject* obj, jdouble val) {
>> +
>> +  llvm_gcroot(Field, 0);
>> +  llvm_gcroot(obj, 0);
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +
>> +  verifyNull(obj);
>> +  JavaField* field = JavaObjectField::getInternalField(Field);
>> +  field->setInstanceDoubleField(obj, (double)val);
>> +
>> +  END_NATIVE_EXCEPTION
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +jclass clazz,
>> +#endif
>> +JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
>> +
>> +  llvm_gcroot(Field, 0);
>> +  llvm_gcroot(obj, 0);
>> +  llvm_gcroot(val, 0);
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +
>> +  verifyNull(obj);
>> +  JavaField* field = JavaObjectField::getInternalField(Field);
>> +  field->setInstanceObjectField(obj, val);
>> +
>> +  END_NATIVE_EXCEPTION
>> +}
>> +
>> +JNIEXPORT JavaObject* JNICALL
>> Java_java_io_VMObjectInputStream_allocateObject(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +jclass clazz,
>> +#endif
>> +JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
>> +
>> +  JavaObject* res = 0;
>> +  llvm_gcroot(res, 0);
>> +  llvm_gcroot(target, 0);
>> +  llvm_gcroot(constr, 0);
>> +  llvm_gcroot(cons, 0);
>> +
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +
>> +  Jnjvm* vm = JavaThread::get()->getJVM();
>> +  UserClass* cl =
>> +    (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
>> +  res = cl->doNew(vm);
>> +  JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
>> +  meth->invokeIntSpecial(vm, cl, res);
>> +
>> +  END_NATIVE_EXCEPTION
>> +
>> +  return res;
>> +}
>> +
>> +JNIEXPORT JavaObject* JNICALL
>> Java_java_lang_reflect_VMArray_createObjectArray(
>> +#ifdef NATIVE_JNI
>> +JNIEnv * env,
>> +jclass thisClass,
>> +#endif
>> +JavaObject* arrayType, jint arrayLength) {
>> +
>> +  JavaObject* res = 0;
>> +  llvm_gcroot(arrayType, 0);
>> +  llvm_gcroot(res, 0);
>> +
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +
>> +  Jnjvm* vm = JavaThread::get()->getJVM();
>> +  UserCommonClass* base =
>> +    UserCommonClass::resolvedImplClass(vm, arrayType, true);
>> +  JnjvmClassLoader* loader = base->classLoader;
>> +  const UTF8* name = base->getName();
>> +  // -1 because we're adding a new dimension in this method.
>> +  const int kLimit = 255 - 1;
>> +  const uint16* elements = name->elements;
>> +  if (name->size > kLimit && elements[kLimit] == '[') {
>> +    vm->illegalArgumentException("Too many dimensions for array");
>> +  }
>> +  const UTF8* arrayName = loader->constructArrayName(1, name);
>> +  UserClassArray* array = loader->constructArray(arrayName, base);
>> +  res = array->doNew(arrayLength, vm);
>> +
>> +  END_NATIVE_EXCEPTION
>> +
>> +  return res;
>> +}
>> +
>> +// Never throws.
>> +JNIEXPORT
>> +bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +jclass clazz,
>> +#endif
>> +) {
>> +  return false;
>> +}
>> +
>> +}
>> diff --git a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
>> b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
>> index bc797d1..57197c4 100644
>> --- a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
>> +++ b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
>> @@ -1071,8 +1071,8 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {
>>
>>  }
>>
>> -#include "ClasspathConstructor.inc"
>>  #include "Classpath.inc"
>> +#include "ClasspathConstructor.inc"
>>  #include "ClasspathField.inc"
>>  #include "ClasspathMethod.inc"
>>  #include "ClasspathVMClass.inc"
>> @@ -1084,3 +1084,4 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {
>>  #include "ClasspathVMSystemProperties.inc"
>>  #include "ClasspathVMThread.inc"
>>  #include "ClasspathVMThrowable.inc"
>> +#include "Unsafe.inc"
>> diff --git a/lib/J3/ClassLib/GNUClasspath/Makefile
>> b/lib/J3/ClassLib/GNUClasspath/Makefile
>> index be80b9e..f5939c9 100644
>> --- a/lib/J3/ClassLib/GNUClasspath/Makefile
>> +++ b/lib/J3/ClassLib/GNUClasspath/Makefile
>> @@ -9,9 +9,11 @@
>>  LEVEL = ../../../..
>>
>>
>> -EXTRA_DIST = ClasspathVMClass.inc ClasspathVMClassLoader.inc
>> ClasspathVMObject.inc \
>> -            ClasspathVMRuntime.inc ClasspathVMStackWalker.inc
>> ClasspathVMSystem.inc \
>> -            ClasspathVMSystemProperties.inc ClasspathVMThread.inc
>> ClasspathVMThrowable.inc
>> +EXTRA_DIST = Classpath.inc ClasspathVMClass.inc
>> ClasspathVMClassLoader.inc \
>> +             ClasspathVMObject.inc ClasspathVMRuntime.inc \
>> +             ClasspathVMStackWalker.inc ClasspathVMSystem.inc \
>> +             ClasspathVMSystemProperties.inc ClasspathVMThread.inc \
>> +             ClasspathVMThrowable.inc
>>
>>  include $(LEVEL)/Makefile.config
>>
>> diff --git a/lib/J3/ClassLib/Makefile b/lib/J3/ClassLib/Makefile
>> index 8252b92..8fd7e2a 100644
>> --- a/lib/J3/ClassLib/Makefile
>> +++ b/lib/J3/ClassLib/Makefile
>> @@ -12,9 +12,9 @@ EXTRA_DIST = ArrayCopy.inc \
>>              ClassContext.inc \
>>              ClasspathConstructor.inc \
>>              ClasspathField.inc \
>> -             Classpath.inc \
>>              ClasspathMethod.inc \
>> -             SetProperties.inc
>> +             SetProperties.inc \
>> +             Unsafe.inc
>>
>>  include $(LEVEL)/Makefile.config
>>
>> diff --git a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
>> b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
>> index 22db276..3fa6390 100644
>> --- a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
>> +++ b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
>> @@ -897,7 +897,7 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {
>>
>>
>>  #include "ClasspathConstructor.inc"
>> -#include "Classpath.inc"
>>  #include "ClasspathField.inc"
>>  #include "ClasspathMethod.inc"
>>  #include "OpenJDK.inc"
>> +#include "Unsafe.inc"
>> diff --git a/lib/J3/ClassLib/Unsafe.inc b/lib/J3/ClassLib/Unsafe.inc
>> new file mode 100644
>> index 0000000..44ffe73
>> --- /dev/null
>> +++ b/lib/J3/ClassLib/Unsafe.inc
>> @@ -0,0 +1,565 @@
>> +//===-------- Unsafe.inc - sun.misc.Unsafe implementation
>> -----------------===//
>> +//
>> +//                            The VMKit project
>> +//
>> +// This file is distributed under the University of Illinois Open Source
>> +// License. See LICENSE.TXT for details.
>> +//
>>
>> +//===----------------------------------------------------------------------===//
>> +
>> +#include "VMStaticInstance.h"
>> +#include <stdlib.h>
>> +
>> +/// fieldPtr - Compute the address of the field specified by the given
>> +/// base/offset pair.  Non-trivial due to our handling of static
>> instances,
>> +/// and this also handles null-checking as required.
>> +///
>> +static inline uint8 *fieldPtr(JavaObject *base, long long offset,
>> +  bool throwOnNull = true) {
>> +
>> +  // For most uses, a 'null' base should throw an exception.
>> +  if (throwOnNull) verifyNull(base);
>> +
>> +  if (base && VMStaticInstance::isVMStaticInstance(base))
>> +    return (uint8*)((VMStaticInstance*)base)->getStaticInstance() +
>> offset;
>> +  else
>> +    return (uint8*)base + offset;
>> +}
>> +
>> +extern "C" {
>> +
>> +//===--- Base/Offset methods
>> ----------------------------------------------===//
>> +
>> +/// staticFieldOffset - Return the offset of a particular static field
>> +/// Only valid to be used with the corresponding staticFieldBase
>> +///
>> +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;
>> +}
>> +
>> +/// staticFieldBase - Return a JavaObject* representing the static
>> instance.
>> +/// Note that our static instances aren't actually java objects, so we
>> use
>> +/// a placeholder object "VMStaticInstance" that also ensures that
>> +/// the corresponding class doesn't get GC'd underneath it.
>> +///
>> +JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_staticFieldBase(
>> +JavaObject* unsafe, JavaObjectField* _field) {
>> +  JavaObject* res = 0;
>> +  llvm_gcroot(unsafe, 0);
>> +  llvm_gcroot(_field, 0);
>> +  llvm_gcroot(res, 0);
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +
>> +  JavaField * field = JavaObjectField::getInternalField(_field);
>> +  assert(field);
>> +  field->classDef->initialiseClass(JavaThread::get()->getJVM());
>> +
>> +  res = VMStaticInstance::allocate(field->classDef);
>> +
>> +  END_NATIVE_EXCEPTION;
>> +
>> +  return res;
>> +}
>> +
>> +/// arrayBaseOffset - Offset from the array object where the actual
>> +/// element data begins.
>> +///
>> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayBaseOffset(
>> +JavaObject* unsafe, JavaObject* clazz) {
>> +  // Array starts at beginning of object
>> +  return 0;
>> +}
>> +
>> +/// arrayIndexScale - Indexing scale for the element type in
>> +/// the specified array.  For use with arrayBaseOffset,
>> +/// NthElementPtr = ArrayObject + BaseOffset + N*IndexScale
>> +/// Return '0' if our JVM stores the elements in a way that
>> +/// makes this type of access impossible or unsupported.
>> +///
>> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +#endif
>> +JavaObject* unsafe, JavaObject* clazz) {
>> +  // For now, just return '0', indicating we don't support this indexing.
>> +  // TODO: Implement this for the array types we /do/ support this way.
>> +  return 0;
>> +}
>> +
>> +
>> +
>> +/// objectFieldOffset - Pointer offset of the specified field
>> +///
>> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +#endif
>> +JavaObject* Unsafe, JavaObjectField* Field) {
>> +
>> +  llvm_gcroot(Field, 0);
>> +  llvm_gcroot(Unsafe, 0);
>> +
>> +  JavaField* field = JavaObjectField::getInternalField(Field);
>> +  return (jlong)field->ptrOffset;
>> +}
>> +
>> +//===--- Double-register addressing field accessors
>> -----------------------===//
>> +// See objectFieldOffset, staticFieldOffset, staticFieldBase
>> +// Can also be an array, if/when we support
>> arrayIndexScale/arrayBaseOffset
>> +#define GET_PUT_OFFSET(Type,jtype,shorttype) \
>> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
>> __Ljava_lang_Object_2J( \
>> +JavaObject* unsafe, JavaObject* base, jlong offset) { \
>> +  jtype res = 0; \
>> +  BEGIN_NATIVE_EXCEPTION(0) \
>> +  jtype* ptr = (jtype*)fieldPtr(base,offset); \
>> +  res = *ptr; \
>> +  END_NATIVE_EXCEPTION \
>> +  return res; \
>> +} \
>> + \
>> +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*)fieldPtr(base, offset); \
>> +  *ptr = val; \
>> +  END_NATIVE_EXCEPTION \
>> +}
>> +
>> +//===--- Direct address read/write acccessors
>> -----------------------------===//
>> +#define GET_PUT_DIRECT(Type,jtype,shorttype) \
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ## __J ##
>> shorttype( \
>> +JavaObject* unsafe, jlong ptr, jtype val) { \
>> +  BEGIN_NATIVE_EXCEPTION(0) \
>> +  *(jtype*)ptr = val; \
>> +  END_NATIVE_EXCEPTION \
>> +} \
>> + \
>> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## __J( \
>> +JavaObject* unsafe, jlong ptr) { \
>> +  jtype res = 0; \
>> +  BEGIN_NATIVE_EXCEPTION(0) \
>> +  res = *(jtype*)ptr; \
>> +  END_NATIVE_EXCEPTION \
>> +  return res; \
>> +}
>> +
>> +//===--- Volatile variant of field accessors
>> ------------------------------===//
>> +// Memory barriers after writes to ensure new value is seen elsewhere
>> +#define GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##
>> Volatile__J ## shorttype( \
>> +JavaObject* unsafe, jlong ptr, jtype val) { \
>> +  BEGIN_NATIVE_EXCEPTION(0) \
>> +  *(volatile jtype*)ptr = val; \
>> +  __sync_synchronize(); \
>> +  END_NATIVE_EXCEPTION \
>> +} \
>> + \
>> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## Volatile__J(
>> \
>> +JavaObject* unsafe, jlong ptr) { \
>> +  jtype res = 0; \
>> +  BEGIN_NATIVE_EXCEPTION(0) \
>> +  res = *(volatile jtype*)ptr; \
>> +  END_NATIVE_EXCEPTION \
>> +  return res; \
>> +}
>> +
>> +//===--- Volatile variant of direct address accessors
>> ---------------------===//
>> +#define GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype) \
>> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
>> Volatile__Ljava_lang_Object_2J( \
>> +JavaObject* unsafe, JavaObject* base, jlong offset) { \
>> +  jtype res = 0; \
>> +  BEGIN_NATIVE_EXCEPTION(0) \
>> +  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
>> +  res = *ptr; \
>> +  END_NATIVE_EXCEPTION \
>> + \
>> +  return res; \
>> +} \
>> + \
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##
>> Volatile__Ljava_lang_Object_2J ## shorttype( \
>> +JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
>> +  BEGIN_NATIVE_EXCEPTION(0) \
>> +  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
>> +  *ptr = val; \
>> +  __sync_synchronize(); \
>> +  END_NATIVE_EXCEPTION \
>> +}
>> +
>> +//===--- Ordered variant of field accessors
>> -------------------------------===//
>> +#define GET_PUT_FIELD_ORDERED(Type,jtype,shorttype) \
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrdered ## Type( \
>> +JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
>> +  BEGIN_NATIVE_EXCEPTION(0) \
>> +  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
>> +  *ptr = val; \
>> +  /* No memory barrier */ \
>> +  END_NATIVE_EXCEPTION \
>> +}
>> +
>> +#define GET_PUT_ALL(Type,jtype,shorttype) \
>> +  GET_PUT_OFFSET(Type,jtype,shorttype) \
>> +  GET_PUT_DIRECT(Type,jtype,shorttype) \
>> +  GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \
>> +  GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype)
>> +
>> +GET_PUT_ALL(Boolean,jboolean,Z)
>> +GET_PUT_ALL(Byte,jbyte,B)
>> +GET_PUT_ALL(Char,jchar,C)
>> +GET_PUT_ALL(Short,jshort,S)
>> +GET_PUT_ALL(Int,jint,I)
>> +GET_PUT_ALL(Long,jlong,J) // TODO: Long needs special handling!
>> +GET_PUT_ALL(Float,jfloat,F)
>> +GET_PUT_ALL(Double,jdouble,D)
>> +
>> +// Ordered:
>> +GET_PUT_FIELD_ORDERED(Int,jint,I)
>> +GET_PUT_FIELD_ORDERED(Long,jlong,J)
>> +
>> +//===--- Get/Put of Objects, due to GC needs special handling
>> -------------===//
>> +// JavaObject field accessors:
>> +JNIEXPORT void JNICALL
>> Java_sun_misc_Unsafe_putObject__Ljava_lang_Object_2JLjava_lang_Object_2(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +#endif
>> +JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
>> +  llvm_gcroot(unsafe, 0);
>> +  llvm_gcroot(base, 0);
>> +  llvm_gcroot(value, 0);
>> +
>> +  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
>> +  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
>> (gc*)value);
>> +}
>> +
>> +
>> +JNIEXPORT JavaObject* JNICALL
>> Java_sun_misc_Unsafe_getObject__Ljava_lang_Object_2J(
>> +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**)fieldPtr(base, offset);
>> +  res = *ptr;
>> +  END_NATIVE_EXCEPTION;
>> +
>> +  return res;
>> +}
>> +
>> +// Volatile JavaObject field accessors:
>> +// Never throws.
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +#endif
>> +JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
>> +  llvm_gcroot(unsafe, 0);
>> +  llvm_gcroot(base, 0);
>> +  llvm_gcroot(value, 0);
>> +
>> +  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
>> +  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
>> (gc*)value);
>> +  // Ensure this value is seen.
>> +  __sync_synchronize();
>> +}
>> +
>> +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* volatile* ptr = (JavaObject* volatile*)fieldPtr(base,
>> offset);
>> +  res = *ptr;
>> +  END_NATIVE_EXCEPTION;
>> +
>> +  return res;
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrderedObject(
>> +JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
>> +  llvm_gcroot(unsafe, 0);
>> +  llvm_gcroot(base, 0);
>> +  llvm_gcroot(value, 0);
>> +
>> +  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
>> +  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
>> (gc*)value);
>> +  // No barrier (difference between volatile and ordered)
>> +}
>> +
>> +
>> +//===--- CompareAndSwap field accessors
>> -----------------------------------===//
>> +// Never throws.
>> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +#endif
>> +JavaObject* unsafe, JavaObject* base, jlong offset, jlong expect,
>> jlong update) {
>> +
>> +  llvm_gcroot(unsafe, 0);
>> +  llvm_gcroot(base, 0);
>> +  jlong *ptr;
>> +  jlong  value;
>> +
>> +  // TODO: Why isn't this atomic?
>> +  ptr = (jlong*)fieldPtr(base, offset);
>> +
>> +  value = *ptr;
>> +
>> +  if (value == expect) {
>> +    *ptr = update;
>> +    return true;
>> +  } else {
>> +    return false;
>> +  }
>> +
>> +}
>> +
>> +// Never throws.
>> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +#endif
>> +JavaObject* unsafe, JavaObject* base, jlong offset, jint expect, jint
>> update) {
>> +
>> +  llvm_gcroot(unsafe, 0);
>> +  llvm_gcroot(base, 0);
>> +  jint *ptr;
>> +
>> +  ptr = (jint *)fieldPtr(base, offset);
>> +
>> +  return __sync_bool_compare_and_swap(ptr, expect, update);
>> +}
>> +
>> +// Never throws.
>> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
>> +#ifdef NATIVE_JNI
>> +JNIEnv *env,
>> +#endif
>> +JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* expect,
>> +JavaObject* update) {
>> +  llvm_gcroot(unsafe, 0);
>> +  llvm_gcroot(base, 0);
>> +  llvm_gcroot(expect, 0);
>> +  llvm_gcroot(update, 0);
>> +
>> +  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
>> +  return mvm::Collector::objectReferenceTryCASBarrier((gc*)base,
>> (gc**)ptr, (gc*)expect, (gc*)update);
>> +}
>> +
>> +
>> +//===--- Class-related functions
>> ------------------------------------------===//
>> +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());
>> +  cl->asClass()->resolveClass();
>> +  cl->asClass()->initialiseClass(vm);
>> +
>> +  END_NATIVE_EXCEPTION;
>> +}
>> +
>> +JNIEXPORT JavaObject* JNICALL
>> Java_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BII(
>> +JavaObject* unsafe, JavaString *name, ArrayObject * bytesArr, jint
>> off, jint len) {
>> +  UNIMPLEMENTED();
>> +}
>> +
>> +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 JavaObject* JNICALL Java_sun_Unsafe_defineAnonymousClass(
>> +JavaObject* unsafe, ...) {
>> +  UNIMPLEMENTED();
>> +}
>> +
>> +//===--- Memory functions
>> -------------------------------------------------===//
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_setMemory__JJB(
>> +JavaObject* unsafe, long address, long bytes, jbyte value) {
>> +  memset((void*)address, value, bytes);
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_copyMemory__JJJ(
>> +JavaObject* unsafe, jlong src, jlong dst, jlong size) {
>> +  memcpy((void*)dst, (void*)src, size);
>> +}
>> +
>> +JNIEXPORT void JNICALL
>>
>> Java_sun_misc_Unsafe_copyMemory__Ljava_lang_Object_2JLjava_lang_Object_2JJ(
>> +JavaObject* unsafe,
>> +JavaObject* srcBase, jlong srcOffset,
>> +JavaObject* dstBase, jlong dstOffset,
>> +jlong size) {
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +  uint8_t* src = fieldPtr(srcBase, srcOffset, false /* Don't throw on
>> null base*/ );
>> +  uint8_t* dst = fieldPtr(dstBase, dstOffset, false /* Don't throw on
>> null base*/ );
>> +  memcpy(dst, src, size);
>> +  END_NATIVE_EXCEPTION
>> +}
>> +
>> +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 jlong JNICALL Java_sun_misc_Unsafe_reallocateMemory(
>> +JavaObject* unsafe, jlong ptr, jlong newsize) {
>> +  // TODO: Invalid size/OOM/etc handling!
>> +  jlong res = 0;
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +  res = (jlong)realloc((void*)ptr, newsize);
>> +  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 jlong JNICALL Java_sun_misc_Unsafe_getAddress(
>> +JavaObject* unsafe, jlong ptr) {
>> +  return (jlong)*(void**)ptr;
>> +}
>> +
>> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_putAddress(
>> +JavaObject* unsafe, jlong ptr, jlong val) {
>> +  *(void**)ptr = (void*)val;
>> +}
>> +
>> +//===--- Park/Unpark thread support
>> ---------------------------------------===//
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_park(
>> +JavaObject* unsafe, jboolean isAbsolute, jlong time) {
>> +  // Nothing, for now.
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_unpark(
>> +JavaObject* unsafe, JavaObject* thread) {
>> +  // Nothing, for now.
>> +}
>> +
>> +//===--- Monitor support
>> --------------------------------------------------===//
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_tryMonitorEnter(
>> +JavaObject* unsafe, JavaObject * obj) {
>> +  //TODO: Implement me!
>> +  UNIMPLEMENTED();
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorEnter(
>> +JavaObject* unsafe, JavaObject * obj) {
>> +  //TODO: Implement me!
>> +  UNIMPLEMENTED();
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorExit(
>> +JavaObject* unsafe, JavaObject * obj) {
>> +  //TODO: Implement me!
>> +  UNIMPLEMENTED();
>> +}
>> +
>> +//===--- Misc support functions
>> -------------------------------------------===//
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*)
>> {
>> +  // Nothing, we define the Unsafe methods with the expected signatures.
>> +}
>> +
>> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_throwException(
>> +JavaObject* unsafe, JavaObject * obj) {
>> +  llvm_gcroot(unsafe, 0);
>> +  llvm_gcroot(obj, 0);
>> +
>> +  JavaThread::get()->throwException(obj);
>> +}
>> +
>> +JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_pageSize(
>> +JavaObject* unsafe) {
>> +  return mvm::System::GetPageSize();
>> +}
>> +
>> +JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_addressSize(
>> +JavaObject* unsafe) {
>> +  return mvm::kWordSize;
>> +}
>> +
>> +JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_getLoadAverage(
>> +JavaObject* unsafe, ...) {
>> +  UNIMPLEMENTED();
>> +}
>> +
>> +}
>> --
>> 1.7.5.1
>>
>> _______________________________________________
>> vmkit-commits mailing list
>> vmkit-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>>
>
>



From wdietz2 at illinois.edu  Tue Nov 15 13:58:45 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 15 Nov 2011 15:58:45 -0600
Subject: [vmkit-commits] [PATCH] Fix symbol search order to fix
 detection of symbols from vmkit or loaded libs
In-Reply-To: <CAKGWAO-ZEm=Tn96gR-daBx13=rn2k0pdQhK6zRGjbec=q_xCvg@mail.gmail.com>
References: <CAKGWAO9iGU7UtXrxEZSvUKfXvkw=G-DaFX6rE+uL1FsP64skvA@mail.gmail.com>
	<CAPYwfipL3QRtg5R_UOs8aE03MjxHJ_+1roWHoA1BKAmfWXk80g@mail.gmail.com>
	<CAKGWAO-ZEm=Tn96gR-daBx13=rn2k0pdQhK6zRGjbec=q_xCvg@mail.gmail.com>
Message-ID: <CAKGWAO80EjjWnqXM8=k+SVypiSECOjUtLwfr5--cd8vBVpVFCg@mail.gmail.com>

On Tue, Nov 15, 2011 at 2:41 PM, Will Dietz <wdietz2 at illinois.edu> wrote:
> On Tue, Nov 15, 2011 at 2:24 PM, Nicolas Geoffray
> <nicolas.geoffray at gmail.com> wrote:
>> Hi Will,
>>
>> I'm not sure that's right. With GNU Classpath, I also want to define my own
>> methods and not use the ones implemented in Classpath. If we reorder things,
>> the method defined in GNU Classpath will be used. Not mine.
>> vmkit is using RTLD_LOCAL when loading, so symbol resolution on a dlsym must
>> provide the loaded library. If you do dlsym(SELF_HANDLE, 'mysymbol'), you'll
>> only get symbols loaded in the j3 executable.
>> What is it that does not work for you?
>> Cheers,
>> Nicolas
>>
>

Hmm, you're right that regardless of my discussion below, this changes
the behavior for symbols that are defined in both places.

Unfortunately, it appears that OpenJDK likes to dlopen() with
RTLD_GLOBAL, which complicates things.

> Hmm.
>
> Well, to answer your question I'm seeing the 'j3' flag set for things
> like Java_awt_Font_initIDs, resulting in calling the functions wrong.
>
> As for whether or not it's correct: I'm not sure that
> dlsym(RTLD_DEFAULT,...) is the same as dlsym(dlopen(NULL),...), which
> might be the difference.  The latter clearly does what you suggest,
> the former I'm not sure (from the man pages).
>

Nope, I'm just wrong here.  Sure seems to be identical in the cases I
put together, my mistake :).

So this leaves us with "what to do?".

One idea is we manually maintain the set of symbols that we want to
override, and teach vmkit to handle them appropriately.  I believe
this is what was done earlier.

Alternatively we could check what symbols we define and incorporate
those when building a tool.  Build a special file that contains an
array of the symbols defined in the tool's dependent libraries and
link the result in to the final tool.  Bit messy, but would work well
with what we already have.

(I'm ignoring having vmkit scan itself on startup since that seems
detrimental to startup times)

Finally, and I think this is ruled out due to some GC issue (right?),
but we could put all the methods we override in a special
"libOverride.so/dylib" (with a better name) and use an explicit handle
to that library to achieve the desired result.

Thoughts?

~Will



From wdietz2 at illinois.edu  Tue Nov 15 13:57:59 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 15 Nov 2011 21:57:59 -0000
Subject: [vmkit-commits] [vmkit] r144706 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111115215759.BF74D2A6C132@llvm.org>

Author: wdietz2
Date: Tue Nov 15 15:57:59 2011
New Revision: 144706

URL: http://llvm.org/viewvc/llvm-project?rev=144706&view=rev
Log:
Drop incorrect extra argument to run() in JVM_DoPrivileged.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144706&r1=144705&r2=144706&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov 15 15:57:59 2011
@@ -1805,7 +1805,7 @@
   JavaMethod * meth = cl->lookupMethodDontThrow(runName, runType, false, true, 0);
   assert(meth);
 
-  res = meth->invokeJavaObjectVirtual(vm, cl, obj, obj);
+  res = meth->invokeJavaObjectVirtual(vm, cl, obj);
 
   RETURN_FROM_JNI((jobject)th->pushJNIRef(res));
 




From wdietz2 at illinois.edu  Tue Nov 15 14:10:34 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 15 Nov 2011 22:10:34 -0000
Subject: [vmkit-commits] [vmkit] r144707 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111115221034.4B9382A6C132@llvm.org>

Author: wdietz2
Date: Tue Nov 15 16:10:34 2011
New Revision: 144707

URL: http://llvm.org/viewvc/llvm-project?rev=144707&view=rev
Log:
JVM_Open: correctly handle cases involving O_DELETE or EEXIST.

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144707&r1=144706&r2=144707&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov 15 16:10:34 2011
@@ -2269,10 +2269,27 @@
  */
 JNIEXPORT jint JNICALL
 JVM_Open(const char *fname, jint flags, jint mode) {
+  // Special flag the JVM uses
+  // means to delete the file after opening.
+  static const int O_DELETE = 0x10000;
+
   BEGIN_JNI_EXCEPTION
-  int result = open(fname, flags, mode);
 
-  result = (result == 0) ? -1 : result;
+  int result = open(fname, flags & ~O_DELETE, mode);
+
+  // Map EEXIST to special JVM_EEXIST, otherwise all errors are -1
+  if (result < 0) {
+    if (errno == EEXIST) {
+      RETURN_FROM_JNI(JVM_EEXIST);
+    } else {
+      RETURN_FROM_JNI(-1);
+    }
+  }
+
+  // Handle O_DELETE flag, if specified
+  if (flags & O_DELETE)
+    unlink(fname);
+
   RETURN_FROM_JNI(result);
   END_JNI_EXCEPTION
 




From wdietz2 at illinois.edu  Tue Nov 15 15:09:09 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 15 Nov 2011 23:09:09 -0000
Subject: [vmkit-commits] [vmkit] r144725 -
	/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111115230909.6604E2A6C132@llvm.org>

Author: wdietz2
Date: Tue Nov 15 17:09:09 2011
New Revision: 144725

URL: http://llvm.org/viewvc/llvm-project?rev=144725&view=rev
Log:
Fix minor typo in JVM_IsSupportedJNIVersion

Modified:
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144725&r1=144724&r2=144725&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov 15 17:09:09 2011
@@ -357,7 +357,7 @@
 JVM_IsSupportedJNIVersion(jint version) {
   return version == JNI_VERSION_1_1 ||
          version == JNI_VERSION_1_2 ||
-         version == JNI_VERSION_1_4 |
+         version == JNI_VERSION_1_4 ||
          version == JNI_VERSION_1_6;
 }
 




From wdietz2 at illinois.edu  Tue Nov 15 15:14:28 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 15 Nov 2011 17:14:28 -0600
Subject: [vmkit-commits] [PATCH 1/3] Split Classpath.inc into Unsafe.inc and
	GNUClasspath/Classpath.inc
Message-ID: <CAKGWAO_WZZVisNq1H0G8R2GixqgcXJDxJGQfexoJ-ZaBLAzKxQ@mail.gmail.com>

Inlined below.

Zero functionality change intended, just moving code around.

Besides subject, also pull objectFieldOffset from ClasspathField.inc

~Will

>From dd3f94eb84034dbdacf0fc346846392b9d6a8feb Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Tue, 15 Nov 2011 16:36:13 -0600
Subject: [PATCH 1/3] Split Classpath.inc into Unsafe.inc and
 GNUClasspath/Classpath.inc

---
 lib/J3/ClassLib/Classpath.inc                |  588 --------------------------
 lib/J3/ClassLib/ClasspathField.inc           |   14 -
 lib/J3/ClassLib/GNUClasspath/Classpath.inc   |  289 +++++++++++++
 lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp |    3 +-
 lib/J3/ClassLib/GNUClasspath/Makefile        |    8 +-
 lib/J3/ClassLib/Makefile                     |    4 +-
 lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp      |    2 +-
 lib/J3/ClassLib/Unsafe.inc                   |  326 ++++++++++++++
 8 files changed, 625 insertions(+), 609 deletions(-)
 delete mode 100644 lib/J3/ClassLib/Classpath.inc
 create mode 100644 lib/J3/ClassLib/GNUClasspath/Classpath.inc
 create mode 100644 lib/J3/ClassLib/Unsafe.inc

diff --git a/lib/J3/ClassLib/Classpath.inc b/lib/J3/ClassLib/Classpath.inc
deleted file mode 100644
index 4fb16a4..0000000
--- a/lib/J3/ClassLib/Classpath.inc
+++ /dev/null
@@ -1,588 +0,0 @@
-//===-------- Classpath.cpp - Configuration for classpath
-------------------===//
-//
-//                            The VMKit project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include "Classpath.h"
-#include "ClasspathReflect.h"
-#include "JavaClass.h"
-#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
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObject* Cl) {
-
-  llvm_gcroot(Cl, 0);
-  bool res = false;
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(Cl);
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
-
-  if (cl->isClass() &&
-      cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
-                                           vm->bootstrapLoader->clinitType,
-                                           true, false, 0))
-  res = true;
-
-  END_NATIVE_EXCEPTION
-
-  return res;
-}
-
-
-// Redefine some VMObjectStreamClass functions because of a slow implementation
-// in Classpath.
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jboolean val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt8Field(obj, (uint8)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jbyte val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt8Field(obj, (uint8)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jchar val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jshort val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt16Field(obj, (sint16)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jint val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt32Field(obj, (sint32)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jlong val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceLongField(obj, (sint64)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jfloat val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceFloatField(obj, (float)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jdouble val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceDoubleField(obj, (double)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  llvm_gcroot(val, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceObjectField(obj, val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT JavaObject* JNICALL Java_java_io_VMObjectInputStream_allocateObject(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
-
-  JavaObject* res = 0;
-  llvm_gcroot(res, 0);
-  llvm_gcroot(target, 0);
-  llvm_gcroot(constr, 0);
-  llvm_gcroot(cons, 0);
-
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClass* cl =
-    (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
-  res = cl->doNew(vm);
-  JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
-  meth->invokeIntSpecial(vm, cl, res);
-
-  END_NATIVE_EXCEPTION
-
-  return res;
-}
-
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMArray_createObjectArray(
-#ifdef NATIVE_JNI
-JNIEnv * env,
-jclass thisClass,
-#endif
-JavaObject* arrayType, jint arrayLength) {
-
-  JavaObject* res = 0;
-  llvm_gcroot(arrayType, 0);
-  llvm_gcroot(res, 0);
-
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* base =
-    UserCommonClass::resolvedImplClass(vm, arrayType, true);
-  JnjvmClassLoader* loader = base->classLoader;
-  const UTF8* name = base->getName();
-  // -1 because we're adding a new dimension in this method.
-  const int kLimit = 255 - 1;
-  const uint16* elements = name->elements;
-  if (name->size > kLimit && elements[kLimit] == '[') {
-    vm->illegalArgumentException("Too many dimensions for array");
-  }
-  const UTF8* arrayName = loader->constructArrayName(1, name);
-  UserClassArray* array = loader->constructArray(arrayName, base);
-  res = array->doNew(arrayLength, vm);
-
-  END_NATIVE_EXCEPTION
-
-  return res;
-}
-
-
-// Never throws.
-JNIEXPORT
-bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-) {
-  return false;
-}
-
-// Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
jlong update) {
-
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  jlong *ptr;
-  jlong  value;
-
-  ptr = (jlong *) (((uint8 *) obj) + offset);
-
-  value = *ptr;
-
-  if (value == expect) {
-    *ptr = update;
-    return true;
-  } else {
-    return false;
-  }
-
-}
-
-// Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) {
-
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  jint *ptr;
-
-  ptr = (jint *) (((uint8 *) obj) + offset);
-
-  return __sync_bool_compare_and_swap(ptr, expect, update);
-}
-
-// Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
-JavaObject* update) {
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  llvm_gcroot(expect, 0);
-  llvm_gcroot(update, 0);
-
-  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
-
-  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
(gc**)ptr, (gc*)expect, (gc*)update);
-}
-
-// Never throws.
-JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  llvm_gcroot(value, 0);
-
-  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
-  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());
-  cl->asClass()->resolveClass();
-  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) {
-  JavaObject* res = 0;
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(_field, 0);
-  llvm_gcroot(res, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  JavaField * field = JavaObjectField::getInternalField(_field);
-  assert(field);
-  field->classDef->initialiseClass(JavaThread::get()->getJVM());
-
-  res = VMStaticInstance::allocate(field->classDef);
-
-  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) {
-  // Array starts at beginning of object
-  return 0;
-}
-
-JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* clazz) {
-  // Return '0' if we don't support indexing this way.
-  // (We might pack fields specially, etc)
-  // TODO: Implement this for the array types we support this way
-  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()->throwException(obj);
-}
-
-JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
-  // Nothing
-}
-
-// TODO: Add the Volatile variants
-#define GET_PUT_OFFSET(Type,jtype,shorttype) \
-JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
__Ljava_lang_Object_2J( \
-JavaObject* unsafe, JavaObject* base, jlong offset) { \
-  jtype res = 0; \
-  BEGIN_NATIVE_EXCEPTION(0) \
-  jtype* ptr = (jtype*) (baseToPtr(base) + offset); \
-  res = *ptr; \
-  END_NATIVE_EXCEPTION \
- \
-  return res; \
-} \
- \
-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*) (baseToPtr(base) + offset); \
-  *ptr = val; \
-  END_NATIVE_EXCEPTION \
-}
-
-GET_PUT_OFFSET(Boolean,jboolean,Z)
-GET_PUT_OFFSET(Byte,jbyte,B)
-GET_PUT_OFFSET(Char,jchar,C)
-GET_PUT_OFFSET(Short,jshort,S)
-GET_PUT_OFFSET(Int,jint,I)
-GET_PUT_OFFSET(Long,jlong,J)
-GET_PUT_OFFSET(Float,jfloat,F)
-GET_PUT_OFFSET(Double,jdouble,D)
-
-}
diff --git a/lib/J3/ClassLib/ClasspathField.inc
b/lib/J3/ClassLib/ClasspathField.inc
index e56c82f..010c54b 100644
--- a/lib/J3/ClassLib/ClasspathField.inc
+++ b/lib/J3/ClassLib/ClasspathField.inc
@@ -1154,18 +1154,4 @@ JavaObjectField* Field, JavaObject* obj, jdouble val) {
   END_NATIVE_EXCEPTION
 }

-// Never throws.
-JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* Unsafe, JavaObjectField* Field) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(Unsafe, 0);
-
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  return (jlong)field->ptrOffset;
-}
-
 }
diff --git a/lib/J3/ClassLib/GNUClasspath/Classpath.inc
b/lib/J3/ClassLib/GNUClasspath/Classpath.inc
new file mode 100644
index 0000000..3354774
--- /dev/null
+++ b/lib/J3/ClassLib/GNUClasspath/Classpath.inc
@@ -0,0 +1,289 @@
+//===-------- Classpath.cpp - Configuration for classpath
-------------------===//
+//
+//                            The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#include "Classpath.h"
+#include "ClasspathReflect.h"
+#include "JavaClass.h"
+#include "JavaThread.h"
+#include "JavaUpcalls.h"
+#include "Jnjvm.h"
+#include "Reader.h"
+
+using namespace j3;
+
+extern "C" {
+
+// Define hasClassInitializer because of a buggy implementation in Classpath.
+JNIEXPORT bool JNICALL Java_java_io_VMObjectStreamClass_hasClassInitializer(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObject* Cl) {
+
+  llvm_gcroot(Cl, 0);
+  bool res = false;
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(Cl);
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
+
+  if (cl->isClass() &&
+      cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
+                                           vm->bootstrapLoader->clinitType,
+                                           true, false, 0))
+  res = true;
+
+  END_NATIVE_EXCEPTION
+
+  return res;
+}
+
+
+// Redefine some VMObjectStreamClass functions because of a slow implementation
+// in Classpath.
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jboolean val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt8Field(obj, (uint8)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jbyte val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt8Field(obj, (uint8)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jchar val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jshort val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt16Field(obj, (sint16)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jint val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt32Field(obj, (sint32)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jlong val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceLongField(obj, (sint64)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jfloat val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceFloatField(obj, (float)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jdouble val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceDoubleField(obj, (double)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  llvm_gcroot(val, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceObjectField(obj, val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT JavaObject* JNICALL Java_java_io_VMObjectInputStream_allocateObject(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
+
+  JavaObject* res = 0;
+  llvm_gcroot(res, 0);
+  llvm_gcroot(target, 0);
+  llvm_gcroot(constr, 0);
+  llvm_gcroot(cons, 0);
+
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* cl =
+    (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
+  res = cl->doNew(vm);
+  JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
+  meth->invokeIntSpecial(vm, cl, res);
+
+  END_NATIVE_EXCEPTION
+
+  return res;
+}
+
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMArray_createObjectArray(
+#ifdef NATIVE_JNI
+JNIEnv * env,
+jclass thisClass,
+#endif
+JavaObject* arrayType, jint arrayLength) {
+
+  JavaObject* res = 0;
+  llvm_gcroot(arrayType, 0);
+  llvm_gcroot(res, 0);
+
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* base =
+    UserCommonClass::resolvedImplClass(vm, arrayType, true);
+  JnjvmClassLoader* loader = base->classLoader;
+  const UTF8* name = base->getName();
+  // -1 because we're adding a new dimension in this method.
+  const int kLimit = 255 - 1;
+  const uint16* elements = name->elements;
+  if (name->size > kLimit && elements[kLimit] == '[') {
+    vm->illegalArgumentException("Too many dimensions for array");
+  }
+  const UTF8* arrayName = loader->constructArrayName(1, name);
+  UserClassArray* array = loader->constructArray(arrayName, base);
+  res = array->doNew(arrayLength, vm);
+
+  END_NATIVE_EXCEPTION
+
+  return res;
+}
+
+// Never throws.
+JNIEXPORT
+bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+) {
+  return false;
+}
+
+}
diff --git a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
index bc797d1..57197c4 100644
--- a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
+++ b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
@@ -1071,8 +1071,8 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {

 }

-#include "ClasspathConstructor.inc"
 #include "Classpath.inc"
+#include "ClasspathConstructor.inc"
 #include "ClasspathField.inc"
 #include "ClasspathMethod.inc"
 #include "ClasspathVMClass.inc"
@@ -1084,3 +1084,4 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {
 #include "ClasspathVMSystemProperties.inc"
 #include "ClasspathVMThread.inc"
 #include "ClasspathVMThrowable.inc"
+#include "Unsafe.inc"
diff --git a/lib/J3/ClassLib/GNUClasspath/Makefile
b/lib/J3/ClassLib/GNUClasspath/Makefile
index be80b9e..f5939c9 100644
--- a/lib/J3/ClassLib/GNUClasspath/Makefile
+++ b/lib/J3/ClassLib/GNUClasspath/Makefile
@@ -9,9 +9,11 @@
 LEVEL = ../../../..


-EXTRA_DIST = ClasspathVMClass.inc ClasspathVMClassLoader.inc
ClasspathVMObject.inc \
-	     ClasspathVMRuntime.inc ClasspathVMStackWalker.inc ClasspathVMSystem.inc \
-	     ClasspathVMSystemProperties.inc ClasspathVMThread.inc
ClasspathVMThrowable.inc
+EXTRA_DIST = Classpath.inc ClasspathVMClass.inc ClasspathVMClassLoader.inc \
+             ClasspathVMObject.inc ClasspathVMRuntime.inc \
+             ClasspathVMStackWalker.inc ClasspathVMSystem.inc \
+             ClasspathVMSystemProperties.inc ClasspathVMThread.inc \
+             ClasspathVMThrowable.inc

 include $(LEVEL)/Makefile.config

diff --git a/lib/J3/ClassLib/Makefile b/lib/J3/ClassLib/Makefile
index 8252b92..8fd7e2a 100644
--- a/lib/J3/ClassLib/Makefile
+++ b/lib/J3/ClassLib/Makefile
@@ -12,9 +12,9 @@ EXTRA_DIST = ArrayCopy.inc \
              ClassContext.inc \
              ClasspathConstructor.inc \
              ClasspathField.inc \
-             Classpath.inc \
              ClasspathMethod.inc \
-             SetProperties.inc
+             SetProperties.inc \
+             Unsafe.inc

 include $(LEVEL)/Makefile.config

diff --git a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
index 22db276..3fa6390 100644
--- a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
+++ b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
@@ -897,7 +897,7 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {


 #include "ClasspathConstructor.inc"
-#include "Classpath.inc"
 #include "ClasspathField.inc"
 #include "ClasspathMethod.inc"
 #include "OpenJDK.inc"
+#include "Unsafe.inc"
diff --git a/lib/J3/ClassLib/Unsafe.inc b/lib/J3/ClassLib/Unsafe.inc
new file mode 100644
index 0000000..dcccc65
--- /dev/null
+++ b/lib/J3/ClassLib/Unsafe.inc
@@ -0,0 +1,326 @@
+//===-------- Unsafe.inc - sun.misc.Unsafe implementation
-----------------===//
+//
+//                            The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "VMStaticInstance.h"
+#include <stdlib.h>
+
+// 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;
+}
+
+extern "C" {
+
+// Never throws.
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
jlong update) {
+
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(obj, 0);
+  jlong *ptr;
+  jlong  value;
+
+  ptr = (jlong *) (((uint8 *) obj) + offset);
+
+  value = *ptr;
+
+  if (value == expect) {
+    *ptr = update;
+    return true;
+  } else {
+    return false;
+  }
+
+}
+
+// Never throws.
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) {
+
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(obj, 0);
+  jint *ptr;
+
+  ptr = (jint *) (((uint8 *) obj) + offset);
+
+  return __sync_bool_compare_and_swap(ptr, expect, update);
+}
+
+// Never throws.
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
+JavaObject* update) {
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(obj, 0);
+  llvm_gcroot(expect, 0);
+  llvm_gcroot(update, 0);
+
+  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
+
+  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
(gc**)ptr, (gc*)expect, (gc*)update);
+}
+
+// Never throws.
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(obj, 0);
+  llvm_gcroot(value, 0);
+
+  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
+  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());
+  cl->asClass()->resolveClass();
+  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) {
+  JavaObject* res = 0;
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(_field, 0);
+  llvm_gcroot(res, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  JavaField * field = JavaObjectField::getInternalField(_field);
+  assert(field);
+  field->classDef->initialiseClass(JavaThread::get()->getJVM());
+
+  res = VMStaticInstance::allocate(field->classDef);
+
+  END_NATIVE_EXCEPTION;
+
+  return res;
+}
+
+/// objectFieldOffset - Pointer offset of the specified field
+///
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* Unsafe, JavaObjectField* Field) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(Unsafe, 0);
+
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  return (jlong)field->ptrOffset;
+}
+
+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) {
+  // Array starts at beginning of object
+  return 0;
+}
+
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* clazz) {
+  // Return '0' if we don't support indexing this way.
+  // (We might pack fields specially, etc)
+  // TODO: Implement this for the array types we support this way
+  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()->throwException(obj);
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
+  // Nothing
+}
+
+// TODO: Add the Volatile variants
+#define GET_PUT_OFFSET(Type,jtype,shorttype) \
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
__Ljava_lang_Object_2J( \
+JavaObject* unsafe, JavaObject* base, jlong offset) { \
+  jtype res = 0; \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  jtype* ptr = (jtype*) (baseToPtr(base) + offset); \
+  res = *ptr; \
+  END_NATIVE_EXCEPTION \
+ \
+  return res; \
+} \
+ \
+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*) (baseToPtr(base) + offset); \
+  *ptr = val; \
+  END_NATIVE_EXCEPTION \
+}
+
+GET_PUT_OFFSET(Boolean,jboolean,Z)
+GET_PUT_OFFSET(Byte,jbyte,B)
+GET_PUT_OFFSET(Char,jchar,C)
+GET_PUT_OFFSET(Short,jshort,S)
+GET_PUT_OFFSET(Int,jint,I)
+GET_PUT_OFFSET(Long,jlong,J)
+GET_PUT_OFFSET(Float,jfloat,F)
+GET_PUT_OFFSET(Double,jdouble,D)
+
+}
-- 
1.7.5.1


From wdietz2 at illinois.edu  Tue Nov 15 15:15:57 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 15 Nov 2011 17:15:57 -0600
Subject: [vmkit-commits] [PATCH 2/3] Unsafe.inc: Rearrange code into related
	groups of methods.
Message-ID: <CAKGWAO-v9x5hXrY0eEttJkZf+qoAajRw400+csq4bkRMPO8t4Q@mail.gmail.com>

Inlined below.

No functionality change other than switching baseToPtr to fieldPtr.

This patch mostly is to make the next patch cleaner.

~Will

>From 0c7a31e4a5fecae30ddf92cb4d2886e8f5cfae76 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Tue, 15 Nov 2011 16:55:11 -0600
Subject: [PATCH 2/3] Unsafe.inc: Rearrange code into related groups of
 methods.

Also, rename baseToPtr, with more useful fieldPtr.
---
 lib/J3/ClassLib/Unsafe.inc |  371 ++++++++++++++++++++++++--------------------
 1 files changed, 203 insertions(+), 168 deletions(-)

diff --git a/lib/J3/ClassLib/Unsafe.inc b/lib/J3/ClassLib/Unsafe.inc
index dcccc65..5fe64db 100644
--- a/lib/J3/ClassLib/Unsafe.inc
+++ b/lib/J3/ClassLib/Unsafe.inc
@@ -10,107 +10,175 @@
 #include "VMStaticInstance.h"
 #include <stdlib.h>

-// 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();
+/// fieldPtr - Compute the address of the field specified by the given
+/// base/offset pair.  Non-trivial due to our handling of static instances,
+/// and this also handles null-checking as required.
+///
+static inline uint8 *fieldPtr(JavaObject *base, long long offset,
+  bool throwOnNull = true) {
+
+  // For most uses, a 'null' base should throw an exception.
+  if (throwOnNull) verifyNull(base);
+
+  if (base && VMStaticInstance::isVMStaticInstance(base))
+    return (uint8*)((VMStaticInstance*)base)->getStaticInstance() + offset;
   else
-    return (uint8*)base;
+    return (uint8*)base + offset;
 }

 extern "C" {

-// Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
jlong update) {
+//===--- Base/Offset methods
----------------------------------------------===//

+/// staticFieldOffset - Return the offset of a particular static field
+/// Only valid to be used with the corresponding staticFieldBase
+///
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_staticFieldOffset(
+JavaObject* unsafe, JavaObjectField* _field) {
   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  jlong *ptr;
-  jlong  value;
+  llvm_gcroot(_field, 0);

-  ptr = (jlong *) (((uint8 *) obj) + offset);
+  jlong res = 0;
+  BEGIN_NATIVE_EXCEPTION(0)

-  value = *ptr;
+  JavaField * field = JavaObjectField::getInternalField(_field);
+  assert(field);

-  if (value == expect) {
-    *ptr = update;
-    return true;
-  } else {
-    return false;
-  }
+  res = field->ptrOffset;

+  END_NATIVE_EXCEPTION;
+
+  return res;
 }

-// Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
+/// staticFieldBase - Return a JavaObject* representing the static instance.
+/// Note that our static instances aren't actually java objects, so we use
+/// a placeholder object "VMStaticInstance" that also ensures that
+/// the corresponding class doesn't get GC'd underneath it.
+///
+JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_staticFieldBase(
+JavaObject* unsafe, JavaObjectField* _field) {
+  JavaObject* res = 0;
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(_field, 0);
+  llvm_gcroot(res, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  JavaField * field = JavaObjectField::getInternalField(_field);
+  assert(field);
+  field->classDef->initialiseClass(JavaThread::get()->getJVM());
+
+  res = VMStaticInstance::allocate(field->classDef);
+
+  END_NATIVE_EXCEPTION;
+
+  return res;
+}
+
+/// arrayBaseOffset - Offset from the array object where the actual
+/// element data begins.
+///
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayBaseOffset(
+JavaObject* unsafe, JavaObject* clazz) {
+  // Array starts at beginning of object
+  return 0;
+}
+
+/// arrayIndexScale - Indexing scale for the element type in
+/// the specified array.  For use with arrayBaseOffset,
+/// NthElementPtr = ArrayObject + BaseOffset + N*IndexScale
+/// Return '0' if our JVM stores the elements in a way that
+/// makes this type of access impossible or unsupported.
+///
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
+JavaObject* unsafe, JavaObject* clazz) {
+  // For now, just return '0', indicating we don't support this indexing.
+  // TODO: Implement this for the array types we /do/ support this way.
+  return 0;
+}
+
+
+
+/// objectFieldOffset - Pointer offset of the specified field
+///
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
 #ifdef NATIVE_JNI
 JNIEnv *env,
 #endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) {
+JavaObject* Unsafe, JavaObjectField* Field) {

-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  jint *ptr;
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(Unsafe, 0);

-  ptr = (jint *) (((uint8 *) obj) + offset);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  return (jlong)field->ptrOffset;
+}

-  return __sync_bool_compare_and_swap(ptr, expect, update);
+//===--- Double-register addressing field accessors
-----------------------===//
+// See objectFieldOffset, staticFieldOffset, staticFieldBase
+// Can also be an array, if/when we support arrayIndexScale/arrayBaseOffset
+#define GET_PUT_OFFSET(Type,jtype,shorttype) \
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
__Ljava_lang_Object_2J( \
+JavaObject* unsafe, JavaObject* base, jlong offset) { \
+  jtype res = 0; \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  jtype* ptr = (jtype*)fieldPtr(base,offset); \
+  res = *ptr; \
+  END_NATIVE_EXCEPTION \
+  return res; \
+} \
+ \
+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*)fieldPtr(base, offset); \
+  *ptr = val; \
+  END_NATIVE_EXCEPTION \
 }

+GET_PUT_OFFSET(Boolean,jboolean,Z)
+GET_PUT_OFFSET(Byte,jbyte,B)
+GET_PUT_OFFSET(Char,jchar,C)
+GET_PUT_OFFSET(Short,jshort,S)
+GET_PUT_OFFSET(Int,jint,I)
+GET_PUT_OFFSET(Long,jlong,J)
+GET_PUT_OFFSET(Float,jfloat,F)
+GET_PUT_OFFSET(Double,jdouble,D)
+
+//===--- Get/Put of Objects, due to GC needs special handling
-------------===//
+// JavaObject field accessors:
 // Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
-JavaObject* update) {
+JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObjectVolatile(
+JavaObject* unsafe, JavaObject* base, jlong offset) {
+  JavaObject * res = 0;
   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  llvm_gcroot(expect, 0);
-  llvm_gcroot(update, 0);
+  llvm_gcroot(base, 0);
+  llvm_gcroot(res, 0);

-  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
+  BEGIN_NATIVE_EXCEPTION(0)
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  res = *ptr;
+  END_NATIVE_EXCEPTION;

-  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
(gc**)ptr, (gc*)expect, (gc*)update);
+  return res;
 }

+// Volatile JavaObject field accessors:
 // Never throws.
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
 #ifdef NATIVE_JNI
 JNIEnv *env,
 #endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {
+JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
+  llvm_gcroot(base, 0);
   llvm_gcroot(value, 0);

-  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
-  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
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
(gc*)value);
 }

+//===--- Misc get/put defined, TODO: generalize!
--------------------------===//
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putLong__JJ(
 JavaObject* unsafe, jlong ptr, jlong value) {
   BEGIN_NATIVE_EXCEPTION(0)
@@ -128,104 +196,78 @@ JavaObject* unsafe, jlong ptr) {
   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());
-  cl->asClass()->resolveClass();
-  cl->asClass()->initialiseClass(vm);
-
-  END_NATIVE_EXCEPTION;
-}
+//===--- CompareAndSwap field accessors
-----------------------------------===//
+// Never throws.
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
+JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
jlong update) {

-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)
+  llvm_gcroot(obj, 0);
+  jlong *ptr;
+  jlong  value;

-  JavaField * field = JavaObjectField::getInternalField(_field);
-  assert(field);
+  ptr = (jlong *) (((uint8 *) obj) + offset);

-  res = field->ptrOffset;
+  value = *ptr;

-  END_NATIVE_EXCEPTION;
+  if (value == expect) {
+    *ptr = update;
+    return true;
+  } else {
+    return false;
+  }

-  return res;
 }

-JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_staticFieldBase(
-JavaObject* unsafe, JavaObjectField* _field) {
-  JavaObject* res = 0;
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(_field, 0);
-  llvm_gcroot(res, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  JavaField * field = JavaObjectField::getInternalField(_field);
-  assert(field);
-  field->classDef->initialiseClass(JavaThread::get()->getJVM());
+// Never throws.
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) {

-  res = VMStaticInstance::allocate(field->classDef);
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(obj, 0);
+  jint *ptr;

-  END_NATIVE_EXCEPTION;
+  ptr = (jint *) (((uint8 *) obj) + offset);

-  return res;
+  return __sync_bool_compare_and_swap(ptr, expect, update);
 }

-/// objectFieldOffset - Pointer offset of the specified field
-///
-JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
+// Never throws.
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
 #ifdef NATIVE_JNI
 JNIEnv *env,
 #endif
-JavaObject* Unsafe, JavaObjectField* Field) {
+JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
+JavaObject* update) {
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(obj, 0);
+  llvm_gcroot(expect, 0);
+  llvm_gcroot(update, 0);

-  llvm_gcroot(Field, 0);
-  llvm_gcroot(Unsafe, 0);
+  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);

-  JavaField* field = JavaObjectField::getInternalField(Field);
-  return (jlong)field->ptrOffset;
+  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
(gc**)ptr, (gc*)expect, (gc*)update);
 }

-JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObjectVolatile(
-JavaObject* unsafe, JavaObject* base, jlong offset) {
-  JavaObject * res = 0;
+//===--- Class-related functions
------------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_ensureClassInitialized(
+JavaObject* unsafe, JavaObject* clazz) {
   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(base, 0);
-  llvm_gcroot(res, 0);
-
+  llvm_gcroot(clazz, 0);
   BEGIN_NATIVE_EXCEPTION(0)
-  JavaObject** ptr = (JavaObject**) (baseToPtr(base) + offset);
-  res = *ptr;
-  END_NATIVE_EXCEPTION;

-  return res;
-}
+  Jnjvm* vm = JavaThread::get()->getJVM();

-JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayBaseOffset(
-JavaObject* unsafe, JavaObject* clazz) {
-  // Array starts at beginning of object
-  return 0;
-}
+  CommonClass * cl = JavaObject::getClass(clazz);
+  assert(cl && cl->isClass());
+  cl->asClass()->resolveClass();
+  cl->asClass()->initialiseClass(vm);

-JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* clazz) {
-  // Return '0' if we don't support indexing this way.
-  // (We might pack fields specially, etc)
-  // TODO: Implement this for the array types we support this way
-  return 0;
+  END_NATIVE_EXCEPTION;
 }

 JNIEXPORT JavaObject* JNICALL
Java_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BIILjava_lang_ClassLoader_2Ljava_security_ProtectionDomain_2(
@@ -281,6 +323,31 @@ JavaObject* unsafe, JavaObjectClass * clazz) {
 }


+//===--- Memory functions
-------------------------------------------------===//
+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
+}
+
+
+//===--- Misc support functions
-------------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
+  // Nothing, we define the Unsafe methods with the expected signatures.
+}
+
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_throwException(
 JavaObject* unsafe, JavaObject * obj) {
   llvm_gcroot(unsafe, 0);
@@ -289,38 +356,6 @@ JavaObject* unsafe, JavaObject * obj) {
   JavaThread::get()->throwException(obj);
 }

-JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
-  // Nothing
-}
-
-// TODO: Add the Volatile variants
-#define GET_PUT_OFFSET(Type,jtype,shorttype) \
-JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
__Ljava_lang_Object_2J( \
-JavaObject* unsafe, JavaObject* base, jlong offset) { \
-  jtype res = 0; \
-  BEGIN_NATIVE_EXCEPTION(0) \
-  jtype* ptr = (jtype*) (baseToPtr(base) + offset); \
-  res = *ptr; \
-  END_NATIVE_EXCEPTION \
- \
-  return res; \
-} \
- \
-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*) (baseToPtr(base) + offset); \
-  *ptr = val; \
-  END_NATIVE_EXCEPTION \
-}

-GET_PUT_OFFSET(Boolean,jboolean,Z)
-GET_PUT_OFFSET(Byte,jbyte,B)
-GET_PUT_OFFSET(Char,jchar,C)
-GET_PUT_OFFSET(Short,jshort,S)
-GET_PUT_OFFSET(Int,jint,I)
-GET_PUT_OFFSET(Long,jlong,J)
-GET_PUT_OFFSET(Float,jfloat,F)
-GET_PUT_OFFSET(Double,jdouble,D)

 }
-- 
1.7.5.1


From wdietz2 at illinois.edu  Tue Nov 15 15:17:39 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 15 Nov 2011 17:17:39 -0600
Subject: [vmkit-commits] [PATCH 3/3] Define all methods in sun.misc.Unsafe,
	fixes to existing.
Message-ID: <CAKGWAO9ofjQ79E3CKhSjcdoTncaotscL6LxAE2G+58eMNaKNSg@mail.gmail.com>

Inlined below.

Thanks! :)

~Will

>From 3ace0392fcfffe9398c876e5921e79b9f349c53a Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Tue, 15 Nov 2011 17:01:39 -0600
Subject: [PATCH 3/3] Define all methods in sun.misc.Unsafe, fixes to
 existing.

* Add full set of get/put, including volatile and ordered.  Update existing
  volatile to use memory barrier on writes.
* Fix all get/put to make use of fieldPtr, thereby correctly handling both
  staticInstances as well as throwing null pointer exceptions.
* Add memory methods: memcpy, memset, realloc
* Add empty park/unpark methods.  (Very) inefficient, but these methods are
  allowed to return arbitrarily, so this is allowed and gets code going.
* Add misc query functions (pageSize/addressSize/etc)
* Drop NATIVE_JNI in this file, while we're at it.

The functions that I've never seen called still have UNIMPLEMENTED,
the rest have been used in 'real' code and seem to work fine.
Only exception to this is the putOrdered variants.
---
 lib/J3/ClassLib/Unsafe.inc |  273 ++++++++++++++++++++++++++++++++++++-------
 1 files changed, 228 insertions(+), 45 deletions(-)

diff --git a/lib/J3/ClassLib/Unsafe.inc b/lib/J3/ClassLib/Unsafe.inc
index 5fe64db..240d0ec 100644
--- a/lib/J3/ClassLib/Unsafe.inc
+++ b/lib/J3/ClassLib/Unsafe.inc
@@ -102,9 +102,6 @@ JavaObject* unsafe, JavaObject* clazz) {
 /// objectFieldOffset - Pointer offset of the specified field
 ///
 JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
 JavaObject* Unsafe, JavaObjectField* Field) {

   llvm_gcroot(Field, 0);
@@ -136,19 +133,110 @@ JavaObject* unsafe, JavaObject* base, jlong
offset, jtype val) { \
   END_NATIVE_EXCEPTION \
 }

-GET_PUT_OFFSET(Boolean,jboolean,Z)
-GET_PUT_OFFSET(Byte,jbyte,B)
-GET_PUT_OFFSET(Char,jchar,C)
-GET_PUT_OFFSET(Short,jshort,S)
-GET_PUT_OFFSET(Int,jint,I)
-GET_PUT_OFFSET(Long,jlong,J)
-GET_PUT_OFFSET(Float,jfloat,F)
-GET_PUT_OFFSET(Double,jdouble,D)
+//===--- Direct address read/write acccessors
-----------------------------===//
+#define GET_PUT_DIRECT(Type,jtype,shorttype) \
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ## __J ## shorttype( \
+JavaObject* unsafe, jlong ptr, jtype val) { \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  *(jtype*)ptr = val; \
+  END_NATIVE_EXCEPTION \
+} \
+ \
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## __J( \
+JavaObject* unsafe, jlong ptr) { \
+  jtype res = 0; \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  res = *(jtype*)ptr; \
+  END_NATIVE_EXCEPTION \
+  return res; \
+}
+
+//===--- Volatile variant of field accessors
------------------------------===//
+// Memory barriers after writes to ensure new value is seen elsewhere
+#define GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##
Volatile__J ## shorttype( \
+JavaObject* unsafe, jlong ptr, jtype val) { \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  *(volatile jtype*)ptr = val; \
+  __sync_synchronize(); \
+  END_NATIVE_EXCEPTION \
+} \
+ \
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## Volatile__J( \
+JavaObject* unsafe, jlong ptr) { \
+  jtype res = 0; \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  res = *(volatile jtype*)ptr; \
+  END_NATIVE_EXCEPTION \
+  return res; \
+}
+
+//===--- Volatile variant of direct address accessors
---------------------===//
+#define GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype) \
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
Volatile__Ljava_lang_Object_2J( \
+JavaObject* unsafe, JavaObject* base, jlong offset) { \
+  jtype res = 0; \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
+  res = *ptr; \
+  END_NATIVE_EXCEPTION \
+ \
+  return res; \
+} \
+ \
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##
Volatile__Ljava_lang_Object_2J ## shorttype( \
+JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
+  *ptr = val; \
+  __sync_synchronize(); \
+  END_NATIVE_EXCEPTION \
+}
+
+//===--- Ordered variant of field accessors
-------------------------------===//
+#define GET_PUT_FIELD_ORDERED(Type,jtype,shorttype) \
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrdered ## Type( \
+JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
+  *ptr = val; \
+  /* No memory barrier */ \
+  END_NATIVE_EXCEPTION \
+}
+
+#define GET_PUT_ALL(Type,jtype,shorttype) \
+  GET_PUT_OFFSET(Type,jtype,shorttype) \
+  GET_PUT_DIRECT(Type,jtype,shorttype) \
+  GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \
+  GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype)
+
+GET_PUT_ALL(Boolean,jboolean,Z)
+GET_PUT_ALL(Byte,jbyte,B)
+GET_PUT_ALL(Char,jchar,C)
+GET_PUT_ALL(Short,jshort,S)
+GET_PUT_ALL(Int,jint,I)
+GET_PUT_ALL(Long,jlong,J) // TODO: Long needs special handling!
+GET_PUT_ALL(Float,jfloat,F)
+GET_PUT_ALL(Double,jdouble,D)
+
+// Ordered:
+GET_PUT_FIELD_ORDERED(Int,jint,I)
+GET_PUT_FIELD_ORDERED(Long,jlong,J)

 //===--- Get/Put of Objects, due to GC needs special handling
-------------===//
 // JavaObject field accessors:
-// Never throws.
-JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObjectVolatile(
+JNIEXPORT void JNICALL
Java_sun_misc_Unsafe_putObject__Ljava_lang_Object_2JLjava_lang_Object_2(
+JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(base, 0);
+  llvm_gcroot(value, 0);
+
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
(gc*)value);
+}
+
+
+JNIEXPORT JavaObject* JNICALL
Java_sun_misc_Unsafe_getObject__Ljava_lang_Object_2J(
 JavaObject* unsafe, JavaObject* base, jlong offset) {
   JavaObject * res = 0;
   llvm_gcroot(unsafe, 0);
@@ -166,9 +254,6 @@ JavaObject* unsafe, JavaObject* base, jlong offset) {
 // Volatile JavaObject field accessors:
 // Never throws.
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
 JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
   llvm_gcroot(unsafe, 0);
   llvm_gcroot(base, 0);
@@ -176,38 +261,49 @@ JavaObject* unsafe, JavaObject* base, jlong
offset, JavaObject* value) {

   JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
   mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
(gc*)value);
+  // Ensure this value is seen.
+  __sync_synchronize();
 }

-//===--- Misc get/put defined, TODO: generalize!
--------------------------===//
-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 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);

-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
+  JavaObject* volatile* ptr = (JavaObject* volatile*)fieldPtr(base, offset);
+  res = *ptr;
+  END_NATIVE_EXCEPTION;

   return res;
 }

+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrderedObject(
+JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(base, 0);
+  llvm_gcroot(value, 0);
+
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
(gc*)value);
+  // No barrier (difference between volatile and ordered)
+}
+

 //===--- CompareAndSwap field accessors
-----------------------------------===//
 // Never throws.
 JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
-JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
jlong update) {
+JavaObject* unsafe, JavaObject* base, jlong offset, jlong expect,
jlong update) {

   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
+  llvm_gcroot(base, 0);
   jlong *ptr;
   jlong  value;

-  ptr = (jlong *) (((uint8 *) obj) + offset);
+  // TODO: Why isn't this atomic?
+  ptr = (jlong*)fieldPtr(base, offset);

   value = *ptr;

@@ -222,37 +318,31 @@ JavaObject* unsafe, JavaObject* obj, jlong
offset, jlong expect, jlong update) {

 // Never throws.
 JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) {
+JavaObject* unsafe, JavaObject* base, jlong offset, jint expect, jint update) {

   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
+  llvm_gcroot(base, 0);
   jint *ptr;

-  ptr = (jint *) (((uint8 *) obj) + offset);
+  ptr = (jint *)fieldPtr(base, offset);

   return __sync_bool_compare_and_swap(ptr, expect, update);
 }

 // Never throws.
 JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
+JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* expect,
 JavaObject* update) {
   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
+  llvm_gcroot(base, 0);
   llvm_gcroot(expect, 0);
   llvm_gcroot(update, 0);

-  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
-
-  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
(gc**)ptr, (gc*)expect, (gc*)update);
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  return mvm::Collector::objectReferenceTryCASBarrier((gc*)base,
(gc**)ptr, (gc*)expect, (gc*)update);
 }

+
 //===--- Class-related functions
------------------------------------------===//
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_ensureClassInitialized(
 JavaObject* unsafe, JavaObject* clazz) {
@@ -270,6 +360,11 @@ JavaObject* unsafe, JavaObject* clazz) {
   END_NATIVE_EXCEPTION;
 }

+JNIEXPORT JavaObject* JNICALL
Java_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BII(
+JavaObject* unsafe, JavaString *name, ArrayObject * bytesArr, jint
off, jint len) {
+  UNIMPLEMENTED();
+}
+
 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;
@@ -322,8 +417,34 @@ JavaObject* unsafe, JavaObjectClass * clazz) {
   return res;
 }

+JNIEXPORT JavaObject* JNICALL Java_sun_Unsafe_defineAnonymousClass(
+JavaObject* unsafe, ...) {
+  UNIMPLEMENTED();
+}

 //===--- Memory functions
-------------------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_setMemory__JJB(
+JavaObject* unsafe, long address, long bytes, jbyte value) {
+  memset((void*)address, value, bytes);
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_copyMemory__JJJ(
+JavaObject* unsafe, jlong src, jlong dst, jlong size) {
+  memcpy((void*)dst, (void*)src, size);
+}
+
+JNIEXPORT void JNICALL
Java_sun_misc_Unsafe_copyMemory__Ljava_lang_Object_2JLjava_lang_Object_2JJ(
+JavaObject* unsafe,
+JavaObject* srcBase, jlong srcOffset,
+JavaObject* dstBase, jlong dstOffset,
+jlong size) {
+  BEGIN_NATIVE_EXCEPTION(0)
+  uint8_t* src = fieldPtr(srcBase, srcOffset, false /* Don't throw on
null base*/ );
+  uint8_t* dst = fieldPtr(dstBase, dstOffset, false /* Don't throw on
null base*/ );
+  memcpy(dst, src, size);
+  END_NATIVE_EXCEPTION
+}
+
 JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_allocateMemory(
 JavaObject* unsafe, jlong size) {
   // TODO: Invalid size/OOM/etc handling!
@@ -334,6 +455,16 @@ JavaObject* unsafe, jlong size) {
   return res;
 }

+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_reallocateMemory(
+JavaObject* unsafe, jlong ptr, jlong newsize) {
+  // TODO: Invalid size/OOM/etc handling!
+  jlong res = 0;
+  BEGIN_NATIVE_EXCEPTION(0)
+  res = (jlong)realloc((void*)ptr, newsize);
+  END_NATIVE_EXCEPTION
+  return res;
+}
+
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_freeMemory(
 JavaObject* unsafe, jlong ptr) {
   // TODO: Exception handling...
@@ -342,6 +473,45 @@ JavaObject* unsafe, jlong ptr) {
   END_NATIVE_EXCEPTION
 }

+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_getAddress(
+JavaObject* unsafe, jlong ptr) {
+  return (jlong)*(void**)ptr;
+}
+
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_putAddress(
+JavaObject* unsafe, jlong ptr, jlong val) {
+  *(void**)ptr = (void*)val;
+}
+
+//===--- Park/Unpark thread support
---------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_park(
+JavaObject* unsafe, jboolean isAbsolute, jlong time) {
+  // Nothing, for now.
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_unpark(
+JavaObject* unsafe, JavaObject* thread) {
+  // Nothing, for now.
+}
+
+//===--- Monitor support
--------------------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_tryMonitorEnter(
+JavaObject* unsafe, JavaObject * obj) {
+  //TODO: Implement me!
+  UNIMPLEMENTED();
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorEnter(
+JavaObject* unsafe, JavaObject * obj) {
+  //TODO: Implement me!
+  UNIMPLEMENTED();
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorExit(
+JavaObject* unsafe, JavaObject * obj) {
+  //TODO: Implement me!
+  UNIMPLEMENTED();
+}

 //===--- Misc support functions
-------------------------------------------===//
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
@@ -356,6 +526,19 @@ JavaObject* unsafe, JavaObject * obj) {
   JavaThread::get()->throwException(obj);
 }

+JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_pageSize(
+JavaObject* unsafe) {
+  return mvm::System::GetPageSize();
+}

+JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_addressSize(
+JavaObject* unsafe) {
+  return mvm::kWordSize;
+}
+
+JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_getLoadAverage(
+JavaObject* unsafe, ...) {
+  UNIMPLEMENTED();
+}

 }
-- 
1.7.5.1


From wdietz2 at illinois.edu  Tue Nov 15 19:19:09 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 15 Nov 2011 21:19:09 -0600
Subject: [vmkit-commits] [PATCH] Fix symbol search order to fix
 detection of symbols from vmkit or loaded libs
In-Reply-To: <CAKGWAO80EjjWnqXM8=k+SVypiSECOjUtLwfr5--cd8vBVpVFCg@mail.gmail.com>
References: <CAKGWAO9iGU7UtXrxEZSvUKfXvkw=G-DaFX6rE+uL1FsP64skvA@mail.gmail.com>
	<CAPYwfipL3QRtg5R_UOs8aE03MjxHJ_+1roWHoA1BKAmfWXk80g@mail.gmail.com>
	<CAKGWAO-ZEm=Tn96gR-daBx13=rn2k0pdQhK6zRGjbec=q_xCvg@mail.gmail.com>
	<CAKGWAO80EjjWnqXM8=k+SVypiSECOjUtLwfr5--cd8vBVpVFCg@mail.gmail.com>
Message-ID: <CAKGWAO_0HfuzcexYBAYZfYHp5LFdh_2FZn1xyTAN7GB8moK1zg@mail.gmail.com>

On Tue, Nov 15, 2011 at 3:58 PM, Will Dietz <wdietz2 at illinois.edu> wrote:
> On Tue, Nov 15, 2011 at 2:41 PM, Will Dietz <wdietz2 at illinois.edu> wrote:
>> On Tue, Nov 15, 2011 at 2:24 PM, Nicolas Geoffray
>> <nicolas.geoffray at gmail.com> wrote:
>>> Hi Will,
>>>
>>> I'm not sure that's right. With GNU Classpath, I also want to define my own
>>> methods and not use the ones implemented in Classpath. If we reorder things,
>>> the method defined in GNU Classpath will be used. Not mine.
>>> vmkit is using RTLD_LOCAL when loading, so symbol resolution on a dlsym must
>>> provide the loaded library. If you do dlsym(SELF_HANDLE, 'mysymbol'), you'll
>>> only get symbols loaded in the j3 executable.
>>> What is it that does not work for you?
>>> Cheers,
>>> Nicolas
>>>
>>
>
> Hmm, you're right that regardless of my discussion below, this changes
> the behavior for symbols that are defined in both places.
>
> Unfortunately, it appears that OpenJDK likes to dlopen() with
> RTLD_GLOBAL, which complicates things.
>

Inlined below is an updated patch that works here, and should
correctly handle all existing cases (except that we're doing more
dlsym's for each lookup than before).

Let me know if you like it, else there are a number of other options :).

~Will

>From ba8355a4b4b3bb39aaf64764b0b6998297419fbd Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Mon, 14 Nov 2011 09:45:35 -0600
Subject: [PATCH] Fix detection of whether or not symbols are from j3 or not.

Unfortunately, native code that's part of OpenJDK likes to dlopen things with
RTLD_GLOBAL, resulting in the existing mechanism for determining where a symbol
came from inaccurate.

Instead, search both our process (and any global libraries), but also search our
loaded libraries.

Using this, we can determine which symbols are in vmkit: they must be
in in the self
search AND be a different symbol from what was found in the library search.
---
 lib/J3/VMCore/JnjvmClassLoader.cpp |   45 ++++++++++++++++++++++++-----------
 1 files changed, 31 insertions(+), 14 deletions(-)

diff --git a/lib/J3/VMCore/JnjvmClassLoader.cpp
b/lib/J3/VMCore/JnjvmClassLoader.cpp
index bf825a8..98abde4 100644
--- a/lib/J3/VMCore/JnjvmClassLoader.cpp
+++ b/lib/J3/VMCore/JnjvmClassLoader.cpp
@@ -977,22 +977,39 @@ const UTF8*
JnjvmClassLoader::constructArrayName(uint32 steps,
 }

 word_t JnjvmClassLoader::loadInLib(const char* buf, bool& j3) {
-  word_t res =
(word_t)TheCompiler->loadMethod(mvm::System::GetSelfHandle(), buf);
-
-  if (!res) {
-    for (std::vector<void*>::iterator i = nativeLibs.begin(),
-              e = nativeLibs.end(); i!= e; ++i) {
-      res = (word_t)TheCompiler->loadMethod((*i), buf);
-      if (res) break;
-    }
-  } else {
-    j3 = true;
+  // Check 'self'.  Should only check our process, however it's possible native
+  // code dlopen'd something itself (with RTLD_GLOBAL; OpenJDK does this).
+  // To handle this, we search both ourselves and the libraries we loaded.
+  word_t sym =
+    (word_t)TheCompiler->loadMethod(mvm::System::GetSelfHandle(), buf);
+
+  // Search loaded libraries as well, both as fallback and to determine
+  // whether or not the symbol in question is defined by vmkit.
+  word_t symFromLib = 0;
+  for (std::vector<void*>::iterator i = nativeLibs.begin(),
+      e = nativeLibs.end(); i!= e; ++i) {
+    symFromLib = (word_t)TheCompiler->loadMethod((*i), buf);
+    if (symFromLib) break;
   }
-
-  if (!res && this != bootstrapLoader)
-    res = bootstrapLoader->loadInLib(buf, j3);

-  return (word_t)res;
+  if (sym) {
+    // Always use the definition from 'self', if it exists.
+    // Furthermore, claim it's defined in j3 iff it wasn't found in one of our
+    // libraries.  This might be wrong if we do a lookup on a symbol that's
+    // neither in vmkit nor a VM-loaded library (but /is/ in a
different library
+    // that has been dlopen'd by native code), but that should never
+    // be called from java code anyway.
+    j3 = (sym != symFromLib);
+    return sym;
+  }
+
+  // Otherwise return what we found in the libraries, if anything
+  if (symFromLib) return symFromLib;
+
+  if (this != bootstrapLoader)
+    return bootstrapLoader->loadInLib(buf, j3);
+
+  return 0;
 }

 void* JnjvmClassLoader::loadLib(const char* buf) {
-- 
1.7.5.1


From wdietz2 at illinois.edu  Wed Nov 16 10:50:19 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 16 Nov 2011 18:50:19 -0000
Subject: [vmkit-commits] [vmkit] r144808 -
	/vmkit/trunk/tests/InstanceOfThisTest.java
Message-ID: <20111116185019.73F0C1BE001@llvm.org>

Author: wdietz2
Date: Wed Nov 16 12:50:19 2011
New Revision: 144808

URL: http://llvm.org/viewvc/llvm-project?rev=144808&view=rev
Log:
Add "InstanceOfThis" test case, that causes assertion failure presently.

Failure is when try to get a customized version of 'foo' for 'A', (while
processing maybeFoo) but are unable to do so since 'foo' doesn't exist in A.

Added:
    vmkit/trunk/tests/InstanceOfThisTest.java

Added: vmkit/trunk/tests/InstanceOfThisTest.java
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tests/InstanceOfThisTest.java?rev=144808&view=auto
==============================================================================
--- vmkit/trunk/tests/InstanceOfThisTest.java (added)
+++ vmkit/trunk/tests/InstanceOfThisTest.java Wed Nov 16 12:50:19 2011
@@ -0,0 +1,27 @@
+public class InstanceOfThisTest {
+  public static void main(String[] args) {
+    new A().maybeFoo();
+    new B().maybeFoo();
+    new C().maybeFoo();
+  }
+
+  static class A {
+    void maybeFoo() {
+      if (this instanceof B)
+        ((B)this).foo();
+    }
+  }
+
+  static class B extends A {
+    void foo() {
+      System.out.println("B!");
+    }
+  }
+
+  static class C extends B {
+    void foo() {
+      System.out.println("C!");
+    }
+  }
+}
+




From wdietz2 at illinois.edu  Wed Nov 16 11:29:49 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 16 Nov 2011 13:29:49 -0600
Subject: [vmkit-commits] [PATCH] Better handle virtual calls through casted
	'this' pointers.
Message-ID: <CAKGWAO8Tp02JnNKmso51bB-W2BJfit=T+3QrvdPDFH=0B7U=tA@mail.gmail.com>

Inlined below.

I opted to do the assignable check, as opposed to just handling the
case when customizeFor->lookupMethod fails, because if the classes
aren't assignable then I'm concerned lookupMethod could conceivably
return the *wrong* method, although I can't make a test case
demonstrating that.

This fixes the test case I checked in earlier, as well as the
inspiration for that test case: java/awt/Toolkit.getDesktopProperty()
(in OpenJDK anyway).

Thoughts welcome, and thanks for your time! :)

~Will

>From 6295ae789713baf56d5cc49500f2193812151db6 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Wed, 16 Nov 2011 13:21:45 -0600
Subject: [PATCH] Better handle virtual calls through casted 'this' pointers.

* Being a 'thisReference' doesn't mean we don't need to dynamically resolve
* Only customize if the call is valid for the current customization class.
    This is checked by "if(customizeFor instanceof calleeClass)"
---
 lib/J3/Compiler/JavaJIT.cpp |    6 +++---
 1 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/J3/Compiler/JavaJIT.cpp b/lib/J3/Compiler/JavaJIT.cpp
index 202c1dc..0b87881 100644
--- a/lib/J3/Compiler/JavaJIT.cpp
+++ b/lib/J3/Compiler/JavaJIT.cpp
@@ -121,10 +121,10 @@ void JavaJIT::invokeVirtual(uint16 index) {
   bool customized = false;
   bool thisReference =
     isThisReference(stackSize() - signature->getNumberOfSlots() - 1);
-  if (thisReference) {
-    assert(meth != NULL);
+  if (thisReference && meth) {
     isCustomizable = true;
-    if (customizeFor != NULL) {
+    if ((customizeFor != NULL)
+        && cl->isAssignableFrom(customizeFor)) {
       meth = customizeFor->lookupMethodDontThrow(
           meth->name, meth->type, false, true, NULL);
       assert(meth);
-- 
1.7.5.1


From nicolas.geoffray at gmail.com  Wed Nov 16 12:06:32 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Wed, 16 Nov 2011 21:06:32 +0100
Subject: [vmkit-commits] [PATCH] Fix symbol search order to fix
 detection of symbols from vmkit or loaded libs
In-Reply-To: <CAKGWAO_0HfuzcexYBAYZfYHp5LFdh_2FZn1xyTAN7GB8moK1zg@mail.gmail.com>
References: <CAKGWAO9iGU7UtXrxEZSvUKfXvkw=G-DaFX6rE+uL1FsP64skvA@mail.gmail.com>
	<CAPYwfipL3QRtg5R_UOs8aE03MjxHJ_+1roWHoA1BKAmfWXk80g@mail.gmail.com>
	<CAKGWAO-ZEm=Tn96gR-daBx13=rn2k0pdQhK6zRGjbec=q_xCvg@mail.gmail.com>
	<CAKGWAO80EjjWnqXM8=k+SVypiSECOjUtLwfr5--cd8vBVpVFCg@mail.gmail.com>
	<CAKGWAO_0HfuzcexYBAYZfYHp5LFdh_2FZn1xyTAN7GB8moK1zg@mail.gmail.com>
Message-ID: <CAPYwfirhd9brLTrvSGcuxDFxtFaW2NaYhX8aipFMK5rZ52oDCQ@mail.gmail.com>

Hi Will,

The approach looks good to me. We could definitely do better by listing all
the methods vmkit defines, but for now what you're doing is fine.

Nicolas

On Wed, Nov 16, 2011 at 4:19 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> On Tue, Nov 15, 2011 at 3:58 PM, Will Dietz <wdietz2 at illinois.edu> wrote:
> > On Tue, Nov 15, 2011 at 2:41 PM, Will Dietz <wdietz2 at illinois.edu>
> wrote:
> >> On Tue, Nov 15, 2011 at 2:24 PM, Nicolas Geoffray
> >> <nicolas.geoffray at gmail.com> wrote:
> >>> Hi Will,
> >>>
> >>> I'm not sure that's right. With GNU Classpath, I also want to define
> my own
> >>> methods and not use the ones implemented in Classpath. If we reorder
> things,
> >>> the method defined in GNU Classpath will be used. Not mine.
> >>> vmkit is using RTLD_LOCAL when loading, so symbol resolution on a
> dlsym must
> >>> provide the loaded library. If you do dlsym(SELF_HANDLE, 'mysymbol'),
> you'll
> >>> only get symbols loaded in the j3 executable.
> >>> What is it that does not work for you?
> >>> Cheers,
> >>> Nicolas
> >>>
> >>
> >
> > Hmm, you're right that regardless of my discussion below, this changes
> > the behavior for symbols that are defined in both places.
> >
> > Unfortunately, it appears that OpenJDK likes to dlopen() with
> > RTLD_GLOBAL, which complicates things.
> >
>
> Inlined below is an updated patch that works here, and should
> correctly handle all existing cases (except that we're doing more
> dlsym's for each lookup than before).
>
> Let me know if you like it, else there are a number of other options :).
>
> ~Will
>
> From ba8355a4b4b3bb39aaf64764b0b6998297419fbd Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Mon, 14 Nov 2011 09:45:35 -0600
> Subject: [PATCH] Fix detection of whether or not symbols are from j3 or
> not.
>
> Unfortunately, native code that's part of OpenJDK likes to dlopen things
> with
> RTLD_GLOBAL, resulting in the existing mechanism for determining where a
> symbol
> came from inaccurate.
>
> Instead, search both our process (and any global libraries), but also
> search our
> loaded libraries.
>
> Using this, we can determine which symbols are in vmkit: they must be
> in in the self
> search AND be a different symbol from what was found in the library search.
> ---
>  lib/J3/VMCore/JnjvmClassLoader.cpp |   45
> ++++++++++++++++++++++++-----------
>  1 files changed, 31 insertions(+), 14 deletions(-)
>
> diff --git a/lib/J3/VMCore/JnjvmClassLoader.cpp
> b/lib/J3/VMCore/JnjvmClassLoader.cpp
> index bf825a8..98abde4 100644
> --- a/lib/J3/VMCore/JnjvmClassLoader.cpp
> +++ b/lib/J3/VMCore/JnjvmClassLoader.cpp
> @@ -977,22 +977,39 @@ const UTF8*
> JnjvmClassLoader::constructArrayName(uint32 steps,
>  }
>
>  word_t JnjvmClassLoader::loadInLib(const char* buf, bool& j3) {
> -  word_t res =
> (word_t)TheCompiler->loadMethod(mvm::System::GetSelfHandle(), buf);
> -
> -  if (!res) {
> -    for (std::vector<void*>::iterator i = nativeLibs.begin(),
> -              e = nativeLibs.end(); i!= e; ++i) {
> -      res = (word_t)TheCompiler->loadMethod((*i), buf);
> -      if (res) break;
> -    }
> -  } else {
> -    j3 = true;
> +  // Check 'self'.  Should only check our process, however it's possible
> native
> +  // code dlopen'd something itself (with RTLD_GLOBAL; OpenJDK does this).
> +  // To handle this, we search both ourselves and the libraries we loaded.
> +  word_t sym =
> +    (word_t)TheCompiler->loadMethod(mvm::System::GetSelfHandle(), buf);
> +
> +  // Search loaded libraries as well, both as fallback and to determine
> +  // whether or not the symbol in question is defined by vmkit.
> +  word_t symFromLib = 0;
> +  for (std::vector<void*>::iterator i = nativeLibs.begin(),
> +      e = nativeLibs.end(); i!= e; ++i) {
> +    symFromLib = (word_t)TheCompiler->loadMethod((*i), buf);
> +    if (symFromLib) break;
>    }
> -
> -  if (!res && this != bootstrapLoader)
> -    res = bootstrapLoader->loadInLib(buf, j3);
>
> -  return (word_t)res;
> +  if (sym) {
> +    // Always use the definition from 'self', if it exists.
> +    // Furthermore, claim it's defined in j3 iff it wasn't found in one
> of our
> +    // libraries.  This might be wrong if we do a lookup on a symbol
> that's
> +    // neither in vmkit nor a VM-loaded library (but /is/ in a
> different library
> +    // that has been dlopen'd by native code), but that should never
> +    // be called from java code anyway.
> +    j3 = (sym != symFromLib);
> +    return sym;
> +  }
> +
> +  // Otherwise return what we found in the libraries, if anything
> +  if (symFromLib) return symFromLib;
> +
> +  if (this != bootstrapLoader)
> +    return bootstrapLoader->loadInLib(buf, j3);
> +
> +  return 0;
>  }
>
>  void* JnjvmClassLoader::loadLib(const char* buf) {
> --
> 1.7.5.1
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111116/a695e53f/attachment.html>

From nicolas.geoffray at gmail.com  Wed Nov 16 12:09:06 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Wed, 16 Nov 2011 21:09:06 +0100
Subject: [vmkit-commits] [PATCH 1/3] Split Classpath.inc into Unsafe.inc
 and GNUClasspath/Classpath.inc
In-Reply-To: <CAKGWAO_WZZVisNq1H0G8R2GixqgcXJDxJGQfexoJ-ZaBLAzKxQ@mail.gmail.com>
References: <CAKGWAO_WZZVisNq1H0G8R2GixqgcXJDxJGQfexoJ-ZaBLAzKxQ@mail.gmail.com>
Message-ID: <CAPYwfiphBLXUHGQ91evq_NTjFFNOHakkGw-ApoD3D76Lsom4Ow@mail.gmail.com>

If it's just moving around, looks good! :)

On Wed, Nov 16, 2011 at 12:14 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Zero functionality change intended, just moving code around.
>
> Besides subject, also pull objectFieldOffset from ClasspathField.inc
>
> ~Will
>
> >From dd3f94eb84034dbdacf0fc346846392b9d6a8feb Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Tue, 15 Nov 2011 16:36:13 -0600
> Subject: [PATCH 1/3] Split Classpath.inc into Unsafe.inc and
>  GNUClasspath/Classpath.inc
>
> ---
>  lib/J3/ClassLib/Classpath.inc                |  588
> --------------------------
>  lib/J3/ClassLib/ClasspathField.inc           |   14 -
>  lib/J3/ClassLib/GNUClasspath/Classpath.inc   |  289 +++++++++++++
>  lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp |    3 +-
>  lib/J3/ClassLib/GNUClasspath/Makefile        |    8 +-
>  lib/J3/ClassLib/Makefile                     |    4 +-
>  lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp      |    2 +-
>  lib/J3/ClassLib/Unsafe.inc                   |  326 ++++++++++++++
>  8 files changed, 625 insertions(+), 609 deletions(-)
>  delete mode 100644 lib/J3/ClassLib/Classpath.inc
>  create mode 100644 lib/J3/ClassLib/GNUClasspath/Classpath.inc
>  create mode 100644 lib/J3/ClassLib/Unsafe.inc
>
> diff --git a/lib/J3/ClassLib/Classpath.inc b/lib/J3/ClassLib/Classpath.inc
> deleted file mode 100644
> index 4fb16a4..0000000
> --- a/lib/J3/ClassLib/Classpath.inc
> +++ /dev/null
> @@ -1,588 +0,0 @@
> -//===-------- Classpath.cpp - Configuration for classpath
> -------------------===//
> -//
> -//                            The VMKit project
> -//
> -// This file is distributed under the University of Illinois Open Source
> -// License. See LICENSE.TXT for details.
> -//
>
> -//===----------------------------------------------------------------------===//
> -
> -
> -
> -#include "Classpath.h"
> -#include "ClasspathReflect.h"
> -#include "JavaClass.h"
> -#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
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> -
> -  llvm_gcroot(Cl, 0);
> -  bool res = false;
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(Cl);
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
> -
> -  if (cl->isClass() &&
> -
>  cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
> -
> vm->bootstrapLoader->clinitType,
> -                                           true, false, 0))
> -  res = true;
> -
> -  END_NATIVE_EXCEPTION
> -
> -  return res;
> -}
> -
> -
> -// Redefine some VMObjectStreamClass functions because of a slow
> implementation
> -// in Classpath.
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jboolean val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceInt8Field(obj, (uint8)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jbyte val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceInt8Field(obj, (uint8)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jchar val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jshort val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceInt16Field(obj, (sint16)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jint val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceInt32Field(obj, (sint32)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jlong val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceLongField(obj, (sint64)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jfloat val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceFloatField(obj, (float)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jdouble val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceDoubleField(obj, (double)val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(obj, 0);
> -  llvm_gcroot(val, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  verifyNull(obj);
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  field->setInstanceObjectField(obj, val);
> -
> -  END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT JavaObject* JNICALL
> Java_java_io_VMObjectInputStream_allocateObject(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
> -
> -  JavaObject* res = 0;
> -  llvm_gcroot(res, 0);
> -  llvm_gcroot(target, 0);
> -  llvm_gcroot(constr, 0);
> -  llvm_gcroot(cons, 0);
> -
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClass* cl =
> -    (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
> -  res = cl->doNew(vm);
> -  JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> -  meth->invokeIntSpecial(vm, cl, res);
> -
> -  END_NATIVE_EXCEPTION
> -
> -  return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL
> Java_java_lang_reflect_VMArray_createObjectArray(
> -#ifdef NATIVE_JNI
> -JNIEnv * env,
> -jclass thisClass,
> -#endif
> -JavaObject* arrayType, jint arrayLength) {
> -
> -  JavaObject* res = 0;
> -  llvm_gcroot(arrayType, 0);
> -  llvm_gcroot(res, 0);
> -
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* base =
> -    UserCommonClass::resolvedImplClass(vm, arrayType, true);
> -  JnjvmClassLoader* loader = base->classLoader;
> -  const UTF8* name = base->getName();
> -  // -1 because we're adding a new dimension in this method.
> -  const int kLimit = 255 - 1;
> -  const uint16* elements = name->elements;
> -  if (name->size > kLimit && elements[kLimit] == '[') {
> -    vm->illegalArgumentException("Too many dimensions for array");
> -  }
> -  const UTF8* arrayName = loader->constructArrayName(1, name);
> -  UserClassArray* array = loader->constructArray(arrayName, base);
> -  res = array->doNew(arrayLength, vm);
> -
> -  END_NATIVE_EXCEPTION
> -
> -  return res;
> -}
> -
> -
> -// Never throws.
> -JNIEXPORT
> -bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -) {
> -  return false;
> -}
> -
> -// Never throws.
> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
> jlong update) {
> -
> -  llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> -  jlong *ptr;
> -  jlong  value;
> -
> -  ptr = (jlong *) (((uint8 *) obj) + offset);
> -
> -  value = *ptr;
> -
> -  if (value == expect) {
> -    *ptr = update;
> -    return true;
> -  } else {
> -    return false;
> -  }
> -
> -}
> -
> -// Never throws.
> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint
> update) {
> -
> -  llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> -  jint *ptr;
> -
> -  ptr = (jint *) (((uint8 *) obj) + offset);
> -
> -  return __sync_bool_compare_and_swap(ptr, expect, update);
> -}
> -
> -// Never throws.
> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
> -JavaObject* update) {
> -  llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> -  llvm_gcroot(expect, 0);
> -  llvm_gcroot(update, 0);
> -
> -  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
> -
> -  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
> (gc**)ptr, (gc*)expect, (gc*)update);
> -}
> -
> -// Never throws.
> -JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {
> -  llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> -  llvm_gcroot(value, 0);
> -
> -  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
> -  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());
> -  cl->asClass()->resolveClass();
> -  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) {
> -  JavaObject* res = 0;
> -  llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(_field, 0);
> -  llvm_gcroot(res, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  JavaField * field = JavaObjectField::getInternalField(_field);
> -  assert(field);
> -  field->classDef->initialiseClass(JavaThread::get()->getJVM());
> -
> -  res = VMStaticInstance::allocate(field->classDef);
> -
> -  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) {
> -  // Array starts at beginning of object
> -  return 0;
> -}
> -
> -JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* clazz) {
> -  // Return '0' if we don't support indexing this way.
> -  // (We might pack fields specially, etc)
> -  // TODO: Implement this for the array types we support this way
> -  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()->throwException(obj);
> -}
> -
> -JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
> -  // Nothing
> -}
> -
> -// TODO: Add the Volatile variants
> -#define GET_PUT_OFFSET(Type,jtype,shorttype) \
> -JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
> __Ljava_lang_Object_2J( \
> -JavaObject* unsafe, JavaObject* base, jlong offset) { \
> -  jtype res = 0; \
> -  BEGIN_NATIVE_EXCEPTION(0) \
> -  jtype* ptr = (jtype*) (baseToPtr(base) + offset); \
> -  res = *ptr; \
> -  END_NATIVE_EXCEPTION \
> - \
> -  return res; \
> -} \
> - \
> -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*) (baseToPtr(base) + offset); \
> -  *ptr = val; \
> -  END_NATIVE_EXCEPTION \
> -}
> -
> -GET_PUT_OFFSET(Boolean,jboolean,Z)
> -GET_PUT_OFFSET(Byte,jbyte,B)
> -GET_PUT_OFFSET(Char,jchar,C)
> -GET_PUT_OFFSET(Short,jshort,S)
> -GET_PUT_OFFSET(Int,jint,I)
> -GET_PUT_OFFSET(Long,jlong,J)
> -GET_PUT_OFFSET(Float,jfloat,F)
> -GET_PUT_OFFSET(Double,jdouble,D)
> -
> -}
> diff --git a/lib/J3/ClassLib/ClasspathField.inc
> b/lib/J3/ClassLib/ClasspathField.inc
> index e56c82f..010c54b 100644
> --- a/lib/J3/ClassLib/ClasspathField.inc
> +++ b/lib/J3/ClassLib/ClasspathField.inc
> @@ -1154,18 +1154,4 @@ JavaObjectField* Field, JavaObject* obj, jdouble
> val) {
>   END_NATIVE_EXCEPTION
>  }
>
> -// Never throws.
> -JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* Unsafe, JavaObjectField* Field) {
> -
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(Unsafe, 0);
> -
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  return (jlong)field->ptrOffset;
> -}
> -
>  }
> diff --git a/lib/J3/ClassLib/GNUClasspath/Classpath.inc
> b/lib/J3/ClassLib/GNUClasspath/Classpath.inc
> new file mode 100644
> index 0000000..3354774
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/Classpath.inc
> @@ -0,0 +1,289 @@
> +//===-------- Classpath.cpp - Configuration for classpath
> -------------------===//
> +//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +
> +
> +#include "Classpath.h"
> +#include "ClasspathReflect.h"
> +#include "JavaClass.h"
> +#include "JavaThread.h"
> +#include "JavaUpcalls.h"
> +#include "Jnjvm.h"
> +#include "Reader.h"
> +
> +using namespace j3;
> +
> +extern "C" {
> +
> +// Define hasClassInitializer because of a buggy implementation in
> Classpath.
> +JNIEXPORT bool JNICALL
> Java_java_io_VMObjectStreamClass_hasClassInitializer(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> +
> +  llvm_gcroot(Cl, 0);
> +  bool res = false;
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(Cl);
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
> +
> +  if (cl->isClass() &&
> +
>  cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
> +
> vm->bootstrapLoader->clinitType,
> +                                           true, false, 0))
> +  res = true;
> +
> +  END_NATIVE_EXCEPTION
> +
> +  return res;
> +}
> +
> +
> +// Redefine some VMObjectStreamClass functions because of a slow
> implementation
> +// in Classpath.
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jboolean val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceInt8Field(obj, (uint8)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jbyte val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceInt8Field(obj, (uint8)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jchar val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jshort val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceInt16Field(obj, (sint16)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jint val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceInt32Field(obj, (sint32)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jlong val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceLongField(obj, (sint64)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jfloat val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceFloatField(obj, (float)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jdouble val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceDoubleField(obj, (double)val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(obj, 0);
> +  llvm_gcroot(val, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  verifyNull(obj);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  field->setInstanceObjectField(obj, val);
> +
> +  END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_java_io_VMObjectInputStream_allocateObject(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
> +
> +  JavaObject* res = 0;
> +  llvm_gcroot(res, 0);
> +  llvm_gcroot(target, 0);
> +  llvm_gcroot(constr, 0);
> +  llvm_gcroot(cons, 0);
> +
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* cl =
> +    (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
> +  res = cl->doNew(vm);
> +  JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> +  meth->invokeIntSpecial(vm, cl, res);
> +
> +  END_NATIVE_EXCEPTION
> +
> +  return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_java_lang_reflect_VMArray_createObjectArray(
> +#ifdef NATIVE_JNI
> +JNIEnv * env,
> +jclass thisClass,
> +#endif
> +JavaObject* arrayType, jint arrayLength) {
> +
> +  JavaObject* res = 0;
> +  llvm_gcroot(arrayType, 0);
> +  llvm_gcroot(res, 0);
> +
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* base =
> +    UserCommonClass::resolvedImplClass(vm, arrayType, true);
> +  JnjvmClassLoader* loader = base->classLoader;
> +  const UTF8* name = base->getName();
> +  // -1 because we're adding a new dimension in this method.
> +  const int kLimit = 255 - 1;
> +  const uint16* elements = name->elements;
> +  if (name->size > kLimit && elements[kLimit] == '[') {
> +    vm->illegalArgumentException("Too many dimensions for array");
> +  }
> +  const UTF8* arrayName = loader->constructArrayName(1, name);
> +  UserClassArray* array = loader->constructArray(arrayName, base);
> +  res = array->doNew(arrayLength, vm);
> +
> +  END_NATIVE_EXCEPTION
> +
> +  return res;
> +}
> +
> +// Never throws.
> +JNIEXPORT
> +bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +) {
> +  return false;
> +}
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> index bc797d1..57197c4 100644
> --- a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> +++ b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> @@ -1071,8 +1071,8 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {
>
>  }
>
> -#include "ClasspathConstructor.inc"
>  #include "Classpath.inc"
> +#include "ClasspathConstructor.inc"
>  #include "ClasspathField.inc"
>  #include "ClasspathMethod.inc"
>  #include "ClasspathVMClass.inc"
> @@ -1084,3 +1084,4 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {
>  #include "ClasspathVMSystemProperties.inc"
>  #include "ClasspathVMThread.inc"
>  #include "ClasspathVMThrowable.inc"
> +#include "Unsafe.inc"
> diff --git a/lib/J3/ClassLib/GNUClasspath/Makefile
> b/lib/J3/ClassLib/GNUClasspath/Makefile
> index be80b9e..f5939c9 100644
> --- a/lib/J3/ClassLib/GNUClasspath/Makefile
> +++ b/lib/J3/ClassLib/GNUClasspath/Makefile
> @@ -9,9 +9,11 @@
>  LEVEL = ../../../..
>
>
> -EXTRA_DIST = ClasspathVMClass.inc ClasspathVMClassLoader.inc
> ClasspathVMObject.inc \
> -            ClasspathVMRuntime.inc ClasspathVMStackWalker.inc
> ClasspathVMSystem.inc \
> -            ClasspathVMSystemProperties.inc ClasspathVMThread.inc
> ClasspathVMThrowable.inc
> +EXTRA_DIST = Classpath.inc ClasspathVMClass.inc
> ClasspathVMClassLoader.inc \
> +             ClasspathVMObject.inc ClasspathVMRuntime.inc \
> +             ClasspathVMStackWalker.inc ClasspathVMSystem.inc \
> +             ClasspathVMSystemProperties.inc ClasspathVMThread.inc \
> +             ClasspathVMThrowable.inc
>
>  include $(LEVEL)/Makefile.config
>
> diff --git a/lib/J3/ClassLib/Makefile b/lib/J3/ClassLib/Makefile
> index 8252b92..8fd7e2a 100644
> --- a/lib/J3/ClassLib/Makefile
> +++ b/lib/J3/ClassLib/Makefile
> @@ -12,9 +12,9 @@ EXTRA_DIST = ArrayCopy.inc \
>              ClassContext.inc \
>              ClasspathConstructor.inc \
>              ClasspathField.inc \
> -             Classpath.inc \
>              ClasspathMethod.inc \
> -             SetProperties.inc
> +             SetProperties.inc \
> +             Unsafe.inc
>
>  include $(LEVEL)/Makefile.config
>
> diff --git a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> index 22db276..3fa6390 100644
> --- a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> +++ b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> @@ -897,7 +897,7 @@ void Classpath::InitializeSystem(Jnjvm * jvm) {
>
>
>  #include "ClasspathConstructor.inc"
> -#include "Classpath.inc"
>  #include "ClasspathField.inc"
>  #include "ClasspathMethod.inc"
>  #include "OpenJDK.inc"
> +#include "Unsafe.inc"
> diff --git a/lib/J3/ClassLib/Unsafe.inc b/lib/J3/ClassLib/Unsafe.inc
> new file mode 100644
> index 0000000..dcccc65
> --- /dev/null
> +++ b/lib/J3/ClassLib/Unsafe.inc
> @@ -0,0 +1,326 @@
> +//===-------- Unsafe.inc - sun.misc.Unsafe implementation
> -----------------===//
> +//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +#include "VMStaticInstance.h"
> +#include <stdlib.h>
> +
> +// 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;
> +}
> +
> +extern "C" {
> +
> +// Never throws.
> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
> jlong update) {
> +
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(obj, 0);
> +  jlong *ptr;
> +  jlong  value;
> +
> +  ptr = (jlong *) (((uint8 *) obj) + offset);
> +
> +  value = *ptr;
> +
> +  if (value == expect) {
> +    *ptr = update;
> +    return true;
> +  } else {
> +    return false;
> +  }
> +
> +}
> +
> +// Never throws.
> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint
> update) {
> +
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(obj, 0);
> +  jint *ptr;
> +
> +  ptr = (jint *) (((uint8 *) obj) + offset);
> +
> +  return __sync_bool_compare_and_swap(ptr, expect, update);
> +}
> +
> +// Never throws.
> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
> +JavaObject* update) {
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(obj, 0);
> +  llvm_gcroot(expect, 0);
> +  llvm_gcroot(update, 0);
> +
> +  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
> +
> +  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
> (gc**)ptr, (gc*)expect, (gc*)update);
> +}
> +
> +// Never throws.
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(obj, 0);
> +  llvm_gcroot(value, 0);
> +
> +  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
> +  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());
> +  cl->asClass()->resolveClass();
> +  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) {
> +  JavaObject* res = 0;
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(_field, 0);
> +  llvm_gcroot(res, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  JavaField * field = JavaObjectField::getInternalField(_field);
> +  assert(field);
> +  field->classDef->initialiseClass(JavaThread::get()->getJVM());
> +
> +  res = VMStaticInstance::allocate(field->classDef);
> +
> +  END_NATIVE_EXCEPTION;
> +
> +  return res;
> +}
> +
> +/// objectFieldOffset - Pointer offset of the specified field
> +///
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* Unsafe, JavaObjectField* Field) {
> +
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(Unsafe, 0);
> +
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  return (jlong)field->ptrOffset;
> +}
> +
> +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) {
> +  // Array starts at beginning of object
> +  return 0;
> +}
> +
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* clazz) {
> +  // Return '0' if we don't support indexing this way.
> +  // (We might pack fields specially, etc)
> +  // TODO: Implement this for the array types we support this way
> +  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()->throwException(obj);
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
> +  // Nothing
> +}
> +
> +// TODO: Add the Volatile variants
> +#define GET_PUT_OFFSET(Type,jtype,shorttype) \
> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
> __Ljava_lang_Object_2J( \
> +JavaObject* unsafe, JavaObject* base, jlong offset) { \
> +  jtype res = 0; \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  jtype* ptr = (jtype*) (baseToPtr(base) + offset); \
> +  res = *ptr; \
> +  END_NATIVE_EXCEPTION \
> + \
> +  return res; \
> +} \
> + \
> +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*) (baseToPtr(base) + offset); \
> +  *ptr = val; \
> +  END_NATIVE_EXCEPTION \
> +}
> +
> +GET_PUT_OFFSET(Boolean,jboolean,Z)
> +GET_PUT_OFFSET(Byte,jbyte,B)
> +GET_PUT_OFFSET(Char,jchar,C)
> +GET_PUT_OFFSET(Short,jshort,S)
> +GET_PUT_OFFSET(Int,jint,I)
> +GET_PUT_OFFSET(Long,jlong,J)
> +GET_PUT_OFFSET(Float,jfloat,F)
> +GET_PUT_OFFSET(Double,jdouble,D)
> +
> +}
> --
> 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/20111116/e6719802/attachment.html>

From nicolas.geoffray at gmail.com  Wed Nov 16 12:13:07 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Wed, 16 Nov 2011 21:13:07 +0100
Subject: [vmkit-commits] [PATCH 2/3] Unsafe.inc: Rearrange code into
 related groups of methods.
In-Reply-To: <CAKGWAO-v9x5hXrY0eEttJkZf+qoAajRw400+csq4bkRMPO8t4Q@mail.gmail.com>
References: <CAKGWAO-v9x5hXrY0eEttJkZf+qoAajRw400+csq4bkRMPO8t4Q@mail.gmail.com>
Message-ID: <CAPYwfiocE4GortrLbXkcLVXGG+rR5fBZ-u3gnfkzF59ghxjR2w@mail.gmail.com>

Looks good, with one comment.

On Wed, Nov 16, 2011 at 12:15 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> No functionality change other than switching baseToPtr to fieldPtr.
>
> This patch mostly is to make the next patch cleaner.
>
> ~Will
>
> >From 0c7a31e4a5fecae30ddf92cb4d2886e8f5cfae76 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Tue, 15 Nov 2011 16:55:11 -0600
> Subject: [PATCH 2/3] Unsafe.inc: Rearrange code into related groups of
>  methods.
>
> Also, rename baseToPtr, with more useful fieldPtr.
> ---
>  lib/J3/ClassLib/Unsafe.inc |  371
> ++++++++++++++++++++++++--------------------
>  1 files changed, 203 insertions(+), 168 deletions(-)
>
> diff --git a/lib/J3/ClassLib/Unsafe.inc b/lib/J3/ClassLib/Unsafe.inc
> index dcccc65..5fe64db 100644
> --- a/lib/J3/ClassLib/Unsafe.inc
> +++ b/lib/J3/ClassLib/Unsafe.inc
> @@ -10,107 +10,175 @@
>  #include "VMStaticInstance.h"
>  #include <stdlib.h>
>
> -// 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();
> +/// fieldPtr - Compute the address of the field specified by the given
> +/// base/offset pair.  Non-trivial due to our handling of static
> instances,
> +/// and this also handles null-checking as required.
> +///
> +static inline uint8 *fieldPtr(JavaObject *base, long long offset,
>

Please use int64_t instead of long long.


> +  bool throwOnNull = true) {
> +
> +  // For most uses, a 'null' base should throw an exception.
> +  if (throwOnNull) verifyNull(base);
> +
> +  if (base && VMStaticInstance::isVMStaticInstance(base))
> +    return (uint8*)((VMStaticInstance*)base)->getStaticInstance() +
> offset;
>   else
> -    return (uint8*)base;
> +    return (uint8*)base + offset;
>  }
>
>  extern "C" {
>
> -// Never throws.
> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
> jlong update) {
> +//===--- Base/Offset methods
> ----------------------------------------------===//
>
> +/// staticFieldOffset - Return the offset of a particular static field
> +/// Only valid to be used with the corresponding staticFieldBase
> +///
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_staticFieldOffset(
> +JavaObject* unsafe, JavaObjectField* _field) {
>   llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> -  jlong *ptr;
> -  jlong  value;
> +  llvm_gcroot(_field, 0);
>
> -  ptr = (jlong *) (((uint8 *) obj) + offset);
> +  jlong res = 0;
> +  BEGIN_NATIVE_EXCEPTION(0)
>
> -  value = *ptr;
> +  JavaField * field = JavaObjectField::getInternalField(_field);
> +  assert(field);
>
> -  if (value == expect) {
> -    *ptr = update;
> -    return true;
> -  } else {
> -    return false;
> -  }
> +  res = field->ptrOffset;
>
> +  END_NATIVE_EXCEPTION;
> +
> +  return res;
>  }
>
> -// Never throws.
> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
> +/// staticFieldBase - Return a JavaObject* representing the static
> instance.
> +/// Note that our static instances aren't actually java objects, so we use
> +/// a placeholder object "VMStaticInstance" that also ensures that
> +/// the corresponding class doesn't get GC'd underneath it.
> +///
> +JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_staticFieldBase(
> +JavaObject* unsafe, JavaObjectField* _field) {
> +  JavaObject* res = 0;
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(_field, 0);
> +  llvm_gcroot(res, 0);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +
> +  JavaField * field = JavaObjectField::getInternalField(_field);
> +  assert(field);
> +  field->classDef->initialiseClass(JavaThread::get()->getJVM());
> +
> +  res = VMStaticInstance::allocate(field->classDef);
> +
> +  END_NATIVE_EXCEPTION;
> +
> +  return res;
> +}
> +
> +/// arrayBaseOffset - Offset from the array object where the actual
> +/// element data begins.
> +///
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayBaseOffset(
> +JavaObject* unsafe, JavaObject* clazz) {
> +  // Array starts at beginning of object
> +  return 0;
> +}
> +
> +/// arrayIndexScale - Indexing scale for the element type in
> +/// the specified array.  For use with arrayBaseOffset,
> +/// NthElementPtr = ArrayObject + BaseOffset + N*IndexScale
> +/// Return '0' if our JVM stores the elements in a way that
> +/// makes this type of access impossible or unsupported.
> +///
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
> +JavaObject* unsafe, JavaObject* clazz) {
> +  // For now, just return '0', indicating we don't support this indexing.
> +  // TODO: Implement this for the array types we /do/ support this way.
> +  return 0;
> +}
> +
> +
> +
> +/// objectFieldOffset - Pointer offset of the specified field
> +///
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
>  #ifdef NATIVE_JNI
>  JNIEnv *env,
>  #endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint
> update) {
> +JavaObject* Unsafe, JavaObjectField* Field) {
>
> -  llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> -  jint *ptr;
> +  llvm_gcroot(Field, 0);
> +  llvm_gcroot(Unsafe, 0);
>
> -  ptr = (jint *) (((uint8 *) obj) + offset);
> +  JavaField* field = JavaObjectField::getInternalField(Field);
> +  return (jlong)field->ptrOffset;
> +}
>
> -  return __sync_bool_compare_and_swap(ptr, expect, update);
> +//===--- Double-register addressing field accessors
> -----------------------===//
> +// See objectFieldOffset, staticFieldOffset, staticFieldBase
> +// Can also be an array, if/when we support
> arrayIndexScale/arrayBaseOffset
> +#define GET_PUT_OFFSET(Type,jtype,shorttype) \
> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
> __Ljava_lang_Object_2J( \
> +JavaObject* unsafe, JavaObject* base, jlong offset) { \
> +  jtype res = 0; \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  jtype* ptr = (jtype*)fieldPtr(base,offset); \
> +  res = *ptr; \
> +  END_NATIVE_EXCEPTION \
> +  return res; \
> +} \
> + \
> +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*)fieldPtr(base, offset); \
> +  *ptr = val; \
> +  END_NATIVE_EXCEPTION \
>  }
>
> +GET_PUT_OFFSET(Boolean,jboolean,Z)
> +GET_PUT_OFFSET(Byte,jbyte,B)
> +GET_PUT_OFFSET(Char,jchar,C)
> +GET_PUT_OFFSET(Short,jshort,S)
> +GET_PUT_OFFSET(Int,jint,I)
> +GET_PUT_OFFSET(Long,jlong,J)
> +GET_PUT_OFFSET(Float,jfloat,F)
> +GET_PUT_OFFSET(Double,jdouble,D)
> +
> +//===--- Get/Put of Objects, due to GC needs special handling
> -------------===//
> +// JavaObject field accessors:
>  // Never throws.
> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
> -JavaObject* update) {
> +JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObjectVolatile(
> +JavaObject* unsafe, JavaObject* base, jlong offset) {
> +  JavaObject * res = 0;
>   llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> -  llvm_gcroot(expect, 0);
> -  llvm_gcroot(update, 0);
> +  llvm_gcroot(base, 0);
> +  llvm_gcroot(res, 0);
>
> -  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
> +  BEGIN_NATIVE_EXCEPTION(0)
> +  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
> +  res = *ptr;
> +  END_NATIVE_EXCEPTION;
>
> -  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
> (gc**)ptr, (gc*)expect, (gc*)update);
> +  return res;
>  }
>
> +// Volatile JavaObject field accessors:
>  // Never throws.
>  JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
>  #ifdef NATIVE_JNI
>  JNIEnv *env,
>  #endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {
> +JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
>   llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> +  llvm_gcroot(base, 0);
>   llvm_gcroot(value, 0);
>
> -  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
> -  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
> +  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
> +  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
> (gc*)value);
>  }
>
> +//===--- Misc get/put defined, TODO: generalize!
> --------------------------===//
>  JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putLong__JJ(
>  JavaObject* unsafe, jlong ptr, jlong value) {
>   BEGIN_NATIVE_EXCEPTION(0)
> @@ -128,104 +196,78 @@ JavaObject* unsafe, jlong ptr) {
>   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());
> -  cl->asClass()->resolveClass();
> -  cl->asClass()->initialiseClass(vm);
> -
> -  END_NATIVE_EXCEPTION;
> -}
> +//===--- CompareAndSwap field accessors
> -----------------------------------===//
> +// Never throws.
> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
> +JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
> jlong update) {
>
> -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)
> +  llvm_gcroot(obj, 0);
> +  jlong *ptr;
> +  jlong  value;
>
> -  JavaField * field = JavaObjectField::getInternalField(_field);
> -  assert(field);
> +  ptr = (jlong *) (((uint8 *) obj) + offset);
>
> -  res = field->ptrOffset;
> +  value = *ptr;
>
> -  END_NATIVE_EXCEPTION;
> +  if (value == expect) {
> +    *ptr = update;
> +    return true;
> +  } else {
> +    return false;
> +  }
>
> -  return res;
>  }
>
> -JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_staticFieldBase(
> -JavaObject* unsafe, JavaObjectField* _field) {
> -  JavaObject* res = 0;
> -  llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(_field, 0);
> -  llvm_gcroot(res, 0);
> -  BEGIN_NATIVE_EXCEPTION(0)
> -
> -  JavaField * field = JavaObjectField::getInternalField(_field);
> -  assert(field);
> -  field->classDef->initialiseClass(JavaThread::get()->getJVM());
> +// Never throws.
> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint
> update) {
>
> -  res = VMStaticInstance::allocate(field->classDef);
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(obj, 0);
> +  jint *ptr;
>
> -  END_NATIVE_EXCEPTION;
> +  ptr = (jint *) (((uint8 *) obj) + offset);
>
> -  return res;
> +  return __sync_bool_compare_and_swap(ptr, expect, update);
>  }
>
> -/// objectFieldOffset - Pointer offset of the specified field
> -///
> -JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
> +// Never throws.
> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
>  #ifdef NATIVE_JNI
>  JNIEnv *env,
>  #endif
> -JavaObject* Unsafe, JavaObjectField* Field) {
> +JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
> +JavaObject* update) {
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(obj, 0);
> +  llvm_gcroot(expect, 0);
> +  llvm_gcroot(update, 0);
>
> -  llvm_gcroot(Field, 0);
> -  llvm_gcroot(Unsafe, 0);
> +  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
>
> -  JavaField* field = JavaObjectField::getInternalField(Field);
> -  return (jlong)field->ptrOffset;
> +  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
> (gc**)ptr, (gc*)expect, (gc*)update);
>  }
>
> -JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObjectVolatile(
> -JavaObject* unsafe, JavaObject* base, jlong offset) {
> -  JavaObject * res = 0;
> +//===--- Class-related functions
> ------------------------------------------===//
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_ensureClassInitialized(
> +JavaObject* unsafe, JavaObject* clazz) {
>   llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(base, 0);
> -  llvm_gcroot(res, 0);
> -
> +  llvm_gcroot(clazz, 0);
>   BEGIN_NATIVE_EXCEPTION(0)
> -  JavaObject** ptr = (JavaObject**) (baseToPtr(base) + offset);
> -  res = *ptr;
> -  END_NATIVE_EXCEPTION;
>
> -  return res;
> -}
> +  Jnjvm* vm = JavaThread::get()->getJVM();
>
> -JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayBaseOffset(
> -JavaObject* unsafe, JavaObject* clazz) {
> -  // Array starts at beginning of object
> -  return 0;
> -}
> +  CommonClass * cl = JavaObject::getClass(clazz);
> +  assert(cl && cl->isClass());
> +  cl->asClass()->resolveClass();
> +  cl->asClass()->initialiseClass(vm);
>
> -JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* clazz) {
> -  // Return '0' if we don't support indexing this way.
> -  // (We might pack fields specially, etc)
> -  // TODO: Implement this for the array types we support this way
> -  return 0;
> +  END_NATIVE_EXCEPTION;
>  }
>
>  JNIEXPORT JavaObject* JNICALL
>
> Java_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BIILjava_lang_ClassLoader_2Ljava_security_ProtectionDomain_2(
> @@ -281,6 +323,31 @@ JavaObject* unsafe, JavaObjectClass * clazz) {
>  }
>
>
> +//===--- Memory functions
> -------------------------------------------------===//
> +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
> +}
> +
> +
> +//===--- Misc support functions
> -------------------------------------------===//
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
> +  // Nothing, we define the Unsafe methods with the expected signatures.
> +}
> +
>  JNIEXPORT void JNICALL Java_sun_misc_Unsafe_throwException(
>  JavaObject* unsafe, JavaObject * obj) {
>   llvm_gcroot(unsafe, 0);
> @@ -289,38 +356,6 @@ JavaObject* unsafe, JavaObject * obj) {
>   JavaThread::get()->throwException(obj);
>  }
>
> -JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
> -  // Nothing
> -}
> -
> -// TODO: Add the Volatile variants
> -#define GET_PUT_OFFSET(Type,jtype,shorttype) \
> -JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
> __Ljava_lang_Object_2J( \
> -JavaObject* unsafe, JavaObject* base, jlong offset) { \
> -  jtype res = 0; \
> -  BEGIN_NATIVE_EXCEPTION(0) \
> -  jtype* ptr = (jtype*) (baseToPtr(base) + offset); \
> -  res = *ptr; \
> -  END_NATIVE_EXCEPTION \
> - \
> -  return res; \
> -} \
> - \
> -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*) (baseToPtr(base) + offset); \
> -  *ptr = val; \
> -  END_NATIVE_EXCEPTION \
> -}
>
> -GET_PUT_OFFSET(Boolean,jboolean,Z)
> -GET_PUT_OFFSET(Byte,jbyte,B)
> -GET_PUT_OFFSET(Char,jchar,C)
> -GET_PUT_OFFSET(Short,jshort,S)
> -GET_PUT_OFFSET(Int,jint,I)
> -GET_PUT_OFFSET(Long,jlong,J)
> -GET_PUT_OFFSET(Float,jfloat,F)
> -GET_PUT_OFFSET(Double,jdouble,D)
>
>  }
> --
> 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/20111116/f24ac68e/attachment.html>

From nicolas.geoffray at gmail.com  Wed Nov 16 12:24:38 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Wed, 16 Nov 2011 21:24:38 +0100
Subject: [vmkit-commits] [PATCH 3/3] Define all methods in
 sun.misc.Unsafe, fixes to existing.
In-Reply-To: <CAKGWAO9ofjQ79E3CKhSjcdoTncaotscL6LxAE2G+58eMNaKNSg@mail.gmail.com>
References: <CAKGWAO9ofjQ79E3CKhSjcdoTncaotscL6LxAE2G+58eMNaKNSg@mail.gmail.com>
Message-ID: <CAPYwfipm2R-Q5nimMXPXthQ2a1fxYMiLf9efgTjR-yOiHLOFhg@mail.gmail.com>

Looks good with a few comments.

On Wed, Nov 16, 2011 at 12:17 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Thanks! :)
>
> ~Will
>
> >From 3ace0392fcfffe9398c876e5921e79b9f349c53a Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Tue, 15 Nov 2011 17:01:39 -0600
> Subject: [PATCH 3/3] Define all methods in sun.misc.Unsafe, fixes to
>  existing.
>
> * Add full set of get/put, including volatile and ordered.  Update existing
>  volatile to use memory barrier on writes.
> * Fix all get/put to make use of fieldPtr, thereby correctly handling both
>  staticInstances as well as throwing null pointer exceptions.
> * Add memory methods: memcpy, memset, realloc
> * Add empty park/unpark methods.  (Very) inefficient, but these methods are
>  allowed to return arbitrarily, so this is allowed and gets code going.
> * Add misc query functions (pageSize/addressSize/etc)
> * Drop NATIVE_JNI in this file, while we're at it.
>
> The functions that I've never seen called still have UNIMPLEMENTED,
> the rest have been used in 'real' code and seem to work fine.
> Only exception to this is the putOrdered variants.
> ---
>  lib/J3/ClassLib/Unsafe.inc |  273
> ++++++++++++++++++++++++++++++++++++-------
>  1 files changed, 228 insertions(+), 45 deletions(-)
>
> diff --git a/lib/J3/ClassLib/Unsafe.inc b/lib/J3/ClassLib/Unsafe.inc
> index 5fe64db..240d0ec 100644
> --- a/lib/J3/ClassLib/Unsafe.inc
> +++ b/lib/J3/ClassLib/Unsafe.inc
> @@ -102,9 +102,6 @@ JavaObject* unsafe, JavaObject* clazz) {
>  /// objectFieldOffset - Pointer offset of the specified field
>  ///
>  JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
>  JavaObject* Unsafe, JavaObjectField* Field) {
>
>   llvm_gcroot(Field, 0);
> @@ -136,19 +133,110 @@ JavaObject* unsafe, JavaObject* base, jlong
> offset, jtype val) { \
>   END_NATIVE_EXCEPTION \
>  }
>
> -GET_PUT_OFFSET(Boolean,jboolean,Z)
> -GET_PUT_OFFSET(Byte,jbyte,B)
> -GET_PUT_OFFSET(Char,jchar,C)
> -GET_PUT_OFFSET(Short,jshort,S)
> -GET_PUT_OFFSET(Int,jint,I)
> -GET_PUT_OFFSET(Long,jlong,J)
> -GET_PUT_OFFSET(Float,jfloat,F)
> -GET_PUT_OFFSET(Double,jdouble,D)
> +//===--- Direct address read/write acccessors
> -----------------------------===//
> +#define GET_PUT_DIRECT(Type,jtype,shorttype) \
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ## __J ##
> shorttype( \
> +JavaObject* unsafe, jlong ptr, jtype val) { \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  *(jtype*)ptr = val; \
> +  END_NATIVE_EXCEPTION \
> +} \
> + \
> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## __J( \
> +JavaObject* unsafe, jlong ptr) { \
> +  jtype res = 0; \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  res = *(jtype*)ptr; \
> +  END_NATIVE_EXCEPTION \
> +  return res; \
> +}
> +
> +//===--- Volatile variant of field accessors
> ------------------------------===//
> +// Memory barriers after writes to ensure new value is seen elsewhere
> +#define GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##
> Volatile__J ## shorttype( \
> +JavaObject* unsafe, jlong ptr, jtype val) { \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  *(volatile jtype*)ptr = val; \
> +  __sync_synchronize(); \
> +  END_NATIVE_EXCEPTION \
> +} \
> + \
> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## Volatile__J( \
> +JavaObject* unsafe, jlong ptr) { \
> +  jtype res = 0; \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  res = *(volatile jtype*)ptr; \
> +  END_NATIVE_EXCEPTION \
> +  return res; \
> +}
> +
> +//===--- Volatile variant of direct address accessors
> ---------------------===//
> +#define GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype) \
> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
> Volatile__Ljava_lang_Object_2J( \
> +JavaObject* unsafe, JavaObject* base, jlong offset) { \
> +  jtype res = 0; \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
> +  res = *ptr; \
> +  END_NATIVE_EXCEPTION \
> + \
> +  return res; \
> +} \
> + \
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##
> Volatile__Ljava_lang_Object_2J ## shorttype( \
> +JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
> +  *ptr = val; \
> +  __sync_synchronize(); \
> +  END_NATIVE_EXCEPTION \
> +}
> +
> +//===--- Ordered variant of field accessors
> -------------------------------===//
> +#define GET_PUT_FIELD_ORDERED(Type,jtype,shorttype) \
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrdered ## Type( \
> +JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
> +  BEGIN_NATIVE_EXCEPTION(0) \
> +  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
> +  *ptr = val; \
> +  /* No memory barrier */ \
> +  END_NATIVE_EXCEPTION \
> +}
> +
> +#define GET_PUT_ALL(Type,jtype,shorttype) \
> +  GET_PUT_OFFSET(Type,jtype,shorttype) \
> +  GET_PUT_DIRECT(Type,jtype,shorttype) \
> +  GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \
> +  GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype)
> +
> +GET_PUT_ALL(Boolean,jboolean,Z)
> +GET_PUT_ALL(Byte,jbyte,B)
> +GET_PUT_ALL(Char,jchar,C)
> +GET_PUT_ALL(Short,jshort,S)
> +GET_PUT_ALL(Int,jint,I)
> +GET_PUT_ALL(Long,jlong,J) // TODO: Long needs special handling!
> +GET_PUT_ALL(Float,jfloat,F)
> +GET_PUT_ALL(Double,jdouble,D)
> +
> +// Ordered:
> +GET_PUT_FIELD_ORDERED(Int,jint,I)
> +GET_PUT_FIELD_ORDERED(Long,jlong,J)
>
>  //===--- Get/Put of Objects, due to GC needs special handling
> -------------===//
>  // JavaObject field accessors:
> -// Never throws.
> -JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObjectVolatile(
> +JNIEXPORT void JNICALL
> Java_sun_misc_Unsafe_putObject__Ljava_lang_Object_2JLjava_lang_Object_2(
> +JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(base, 0);
> +  llvm_gcroot(value, 0);
> +
> +  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
> +  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
> (gc*)value);
> +}
> +
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_sun_misc_Unsafe_getObject__Ljava_lang_Object_2J(
>  JavaObject* unsafe, JavaObject* base, jlong offset) {
>   JavaObject * res = 0;
>   llvm_gcroot(unsafe, 0);
> @@ -166,9 +254,6 @@ JavaObject* unsafe, JavaObject* base, jlong offset) {
>  // Volatile JavaObject field accessors:
>  // Never throws.
>  JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
>  JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
>   llvm_gcroot(unsafe, 0);
>   llvm_gcroot(base, 0);
> @@ -176,38 +261,49 @@ JavaObject* unsafe, JavaObject* base, jlong
> offset, JavaObject* value) {
>
>   JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
>   mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
> (gc*)value);
> +  // Ensure this value is seen.
> +  __sync_synchronize();
>  }
>
> -//===--- Misc get/put defined, TODO: generalize!
> --------------------------===//
> -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 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);
>
> -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
> +  JavaObject* volatile* ptr = (JavaObject* volatile*)fieldPtr(base,
> offset);
> +  res = *ptr;
> +  END_NATIVE_EXCEPTION;
>
>   return res;
>  }
>
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrderedObject(
> +JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
> +  llvm_gcroot(unsafe, 0);
> +  llvm_gcroot(base, 0);
> +  llvm_gcroot(value, 0);
> +
> +  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
> +  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr,
> (gc*)value);
> +  // No barrier (difference between volatile and ordered)
> +}
> +
>
>  //===--- CompareAndSwap field accessors
> -----------------------------------===//
>  // Never throws.
>  JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
> -JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
> jlong update) {
> +JavaObject* unsafe, JavaObject* base, jlong offset, jlong expect,
> jlong update) {
>
>   llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> +  llvm_gcroot(base, 0);
>   jlong *ptr;
>   jlong  value;
>
> -  ptr = (jlong *) (((uint8 *) obj) + offset);
> +  // TODO: Why isn't this atomic?
>

Why would it be on a 32 bit system?


> +  ptr = (jlong*)fieldPtr(base, offset);
>
>   value = *ptr;
>
> @@ -222,37 +318,31 @@ JavaObject* unsafe, JavaObject* obj, jlong
> offset, jlong expect, jlong update) {
>
>  // Never throws.
>  JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint
> update) {
> +JavaObject* unsafe, JavaObject* base, jlong offset, jint expect, jint
> update) {
>
>   llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> +  llvm_gcroot(base, 0);
>   jint *ptr;
>
> -  ptr = (jint *) (((uint8 *) obj) + offset);
> +  ptr = (jint *)fieldPtr(base, offset);
>
>   return __sync_bool_compare_and_swap(ptr, expect, update);
>  }
>
>  // Never throws.
>  JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
> +JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* expect,
>  JavaObject* update) {
>   llvm_gcroot(unsafe, 0);
> -  llvm_gcroot(obj, 0);
> +  llvm_gcroot(base, 0);
>   llvm_gcroot(expect, 0);
>   llvm_gcroot(update, 0);
>
> -  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
> -
> -  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
> (gc**)ptr, (gc*)expect, (gc*)update);
> +  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
> +  return mvm::Collector::objectReferenceTryCASBarrier((gc*)base,
> (gc**)ptr, (gc*)expect, (gc*)update);
>  }
>
> +
>  //===--- Class-related functions
> ------------------------------------------===//
>  JNIEXPORT void JNICALL Java_sun_misc_Unsafe_ensureClassInitialized(
>  JavaObject* unsafe, JavaObject* clazz) {
> @@ -270,6 +360,11 @@ JavaObject* unsafe, JavaObject* clazz) {
>   END_NATIVE_EXCEPTION;
>  }
>
> +JNIEXPORT JavaObject* JNICALL
> Java_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BII(
> +JavaObject* unsafe, JavaString *name, ArrayObject * bytesArr, jint
> off, jint len) {
> +  UNIMPLEMENTED();
> +}
> +
>  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;
> @@ -322,8 +417,34 @@ JavaObject* unsafe, JavaObjectClass * clazz) {
>   return res;
>  }
>
> +JNIEXPORT JavaObject* JNICALL Java_sun_Unsafe_defineAnonymousClass(
> +JavaObject* unsafe, ...) {
> +  UNIMPLEMENTED();
> +}
>
>  //===--- Memory functions
> -------------------------------------------------===//
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_setMemory__JJB(
> +JavaObject* unsafe, long address, long bytes, jbyte value) {
> +  memset((void*)address, value, bytes);
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_copyMemory__JJJ(
> +JavaObject* unsafe, jlong src, jlong dst, jlong size) {
> +  memcpy((void*)dst, (void*)src, size);
> +}
> +
> +JNIEXPORT void JNICALL
> Java_sun_misc_Unsafe_copyMemory__Ljava_lang_Object_2JLjava_lang_Object_2JJ(
> +JavaObject* unsafe,
> +JavaObject* srcBase, jlong srcOffset,
> +JavaObject* dstBase, jlong dstOffset,
> +jlong size) {
> +  BEGIN_NATIVE_EXCEPTION(0)
> +  uint8_t* src = fieldPtr(srcBase, srcOffset, false /* Don't throw on
> null base*/ );
> +  uint8_t* dst = fieldPtr(dstBase, dstOffset, false /* Don't throw on
> null base*/ );
> +  memcpy(dst, src, size);
>

How does that deal with GC barriers?


> +  END_NATIVE_EXCEPTION
> +}
> +
>  JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_allocateMemory(
>  JavaObject* unsafe, jlong size) {
>   // TODO: Invalid size/OOM/etc handling!
> @@ -334,6 +455,16 @@ JavaObject* unsafe, jlong size) {
>   return res;
>  }
>
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_reallocateMemory(
> +JavaObject* unsafe, jlong ptr, jlong newsize) {
> +  // TODO: Invalid size/OOM/etc handling!
> +  jlong res = 0;
> +  BEGIN_NATIVE_EXCEPTION(0)
> +  res = (jlong)realloc((void*)ptr, newsize);
> +  END_NATIVE_EXCEPTION
> +  return res;
> +}
> +
>  JNIEXPORT void JNICALL Java_sun_misc_Unsafe_freeMemory(
>  JavaObject* unsafe, jlong ptr) {
>   // TODO: Exception handling...
> @@ -342,6 +473,45 @@ JavaObject* unsafe, jlong ptr) {
>   END_NATIVE_EXCEPTION
>  }
>
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_getAddress(
> +JavaObject* unsafe, jlong ptr) {
> +  return (jlong)*(void**)ptr;
> +}
> +
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_putAddress(
> +JavaObject* unsafe, jlong ptr, jlong val) {
> +  *(void**)ptr = (void*)val;
> +}
> +
> +//===--- Park/Unpark thread support
> ---------------------------------------===//
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_park(
> +JavaObject* unsafe, jboolean isAbsolute, jlong time) {
> +  // Nothing, for now.
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_unpark(
> +JavaObject* unsafe, JavaObject* thread) {
> +  // Nothing, for now.
> +}
> +
> +//===--- Monitor support
> --------------------------------------------------===//
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_tryMonitorEnter(
> +JavaObject* unsafe, JavaObject * obj) {
> +  //TODO: Implement me!
> +  UNIMPLEMENTED();
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorEnter(
> +JavaObject* unsafe, JavaObject * obj) {
> +  //TODO: Implement me!
> +  UNIMPLEMENTED();
> +}
> +
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorExit(
> +JavaObject* unsafe, JavaObject * obj) {
> +  //TODO: Implement me!
> +  UNIMPLEMENTED();
> +}
>
>  //===--- Misc support functions
> -------------------------------------------===//
>  JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
> @@ -356,6 +526,19 @@ JavaObject* unsafe, JavaObject * obj) {
>   JavaThread::get()->throwException(obj);
>  }
>
> +JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_pageSize(
> +JavaObject* unsafe) {
> +  return mvm::System::GetPageSize();
> +}
>
> +JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_addressSize(
> +JavaObject* unsafe) {
> +  return mvm::kWordSize;
> +}
> +
> +JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_getLoadAverage(
> +JavaObject* unsafe, ...) {
> +  UNIMPLEMENTED();
> +}
>
>  }
> --
> 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/20111116/34d0c6a8/attachment.html>

From nicolas.geoffray at gmail.com  Wed Nov 16 12:40:53 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Wed, 16 Nov 2011 21:40:53 +0100
Subject: [vmkit-commits] [PATCH] Better handle virtual calls through
 casted 'this' pointers.
In-Reply-To: <CAKGWAO8Tp02JnNKmso51bB-W2BJfit=T+3QrvdPDFH=0B7U=tA@mail.gmail.com>
References: <CAKGWAO8Tp02JnNKmso51bB-W2BJfit=T+3QrvdPDFH=0B7U=tA@mail.gmail.com>
Message-ID: <CAPYwfir0oz_wSc3x4FggNui1T53_K6WHcjv9CtLcu04Qm1dTDA@mail.gmail.com>

That's a great catch Will. Thanks very much for the test case. Please apply!

On Wed, Nov 16, 2011 at 8:29 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> I opted to do the assignable check, as opposed to just handling the
> case when customizeFor->lookupMethod fails, because if the classes
> aren't assignable


I think you're right. If we're casting 'this' to something unrelated, we'll
try to do bogus clever stuff. We won't it though, because of a runtime
CheckCastException, but, like you, I prefer to be on the safe side.


> then I'm concerned lookupMethod could conceivably
> return the *wrong* method, although I can't make a test case
> demonstrating that.
>

A way to have a test case is to write two files, one with class A and one
with class B extends A. Write the maybeFoo method like in the
InstanceofThisTest. And then change the file with class B to not extend A.

Then, I believe vmkit will try to do the 'bogus clever stuff'.

I don't have that framework in place for tests like that, so it's fine no
to think too much about it.


> This fixes the test case I checked in earlier, as well as the
> inspiration for that test case: java/awt/Toolkit.getDesktopProperty()
> (in OpenJDK anyway).
>
> Thoughts welcome, and thanks for your time! :)
>
> ~Will
>
> >From 6295ae789713baf56d5cc49500f2193812151db6 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 16 Nov 2011 13:21:45 -0600
> Subject: [PATCH] Better handle virtual calls through casted 'this'
> pointers.
>
> * Being a 'thisReference' doesn't mean we don't need to dynamically resolve
> * Only customize if the call is valid for the current customization class.
>    This is checked by "if(customizeFor instanceof calleeClass)"
> ---
>  lib/J3/Compiler/JavaJIT.cpp |    6 +++---
>  1 files changed, 3 insertions(+), 3 deletions(-)
>
> diff --git a/lib/J3/Compiler/JavaJIT.cpp b/lib/J3/Compiler/JavaJIT.cpp
> index 202c1dc..0b87881 100644
> --- a/lib/J3/Compiler/JavaJIT.cpp
> +++ b/lib/J3/Compiler/JavaJIT.cpp
> @@ -121,10 +121,10 @@ void JavaJIT::invokeVirtual(uint16 index) {
>   bool customized = false;
>   bool thisReference =
>     isThisReference(stackSize() - signature->getNumberOfSlots() - 1);
> -  if (thisReference) {
> -    assert(meth != NULL);
> +  if (thisReference && meth) {
>

Please add a comment on why 'meth' may be NULL (you could just reference
the test case).


>     isCustomizable = true;
> -    if (customizeFor != NULL) {
> +    if ((customizeFor != NULL)
> +        && cl->isAssignableFrom(customizeFor)) {
>

And another comment on why we check if it's assignable :)


>       meth = customizeFor->lookupMethodDontThrow(
>           meth->name, meth->type, false, true, NULL);
>       assert(meth);
> --
> 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/20111116/8587854d/attachment.html>

From wdietz2 at illinois.edu  Wed Nov 16 14:50:00 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 16 Nov 2011 16:50:00 -0600
Subject: [vmkit-commits] [PATCH 3/3] Define all methods in
 sun.misc.Unsafe, fixes to existing.
In-Reply-To: <CAPYwfipm2R-Q5nimMXPXthQ2a1fxYMiLf9efgTjR-yOiHLOFhg@mail.gmail.com>
References: <CAKGWAO9ofjQ79E3CKhSjcdoTncaotscL6LxAE2G+58eMNaKNSg@mail.gmail.com>
	<CAPYwfipm2R-Q5nimMXPXthQ2a1fxYMiLf9efgTjR-yOiHLOFhg@mail.gmail.com>
Message-ID: <CAKGWAO8M97KnEYiMaa0W2VogJQR9sQDeL_PRUxzc3ngP8oZAzQ@mail.gmail.com>

On Wed, Nov 16, 2011 at 2:24 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
>>  JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
>> -JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
>> jlong update) {
>> +JavaObject* unsafe, JavaObject* base, jlong offset, jlong expect,
>> jlong update) {
>>
>>   llvm_gcroot(unsafe, 0);
>> -  llvm_gcroot(obj, 0);
>> +  llvm_gcroot(base, 0);
>>   jlong *ptr;
>>   jlong  value;
>>
>> -  ptr = (jlong *) (((uint8 *) obj) + offset);
>> +  // TODO: Why isn't this atomic?
>
> Why would it be on a 32 bit system?
>

I'm not sure I understand what you're saying.  Are you saying that
when you're on a 32bit system it shouldn't be atomic?  I apologize,
I'm probably missing something.

>> Java_sun_misc_Unsafe_copyMemory__Ljava_lang_Object_2JLjava_lang_Object_2JJ(
>> +JavaObject* unsafe,
>> +JavaObject* srcBase, jlong srcOffset,
>> +JavaObject* dstBase, jlong dstOffset,
>> +jlong size) {
>> +  BEGIN_NATIVE_EXCEPTION(0)
>> +  uint8_t* src = fieldPtr(srcBase, srcOffset, false /* Don't throw on
>> null base*/ );
>> +  uint8_t* dst = fieldPtr(dstBase, dstOffset, false /* Don't throw on
>> null base*/ );
>> +  memcpy(dst, src, size);
>
> How does that deal with GC barriers?
>

It doesn't, but I don't think it's supposed to either.  It's part of
'Unsafe' after all--and the documentation seems clear when an
operation is supposed to deal with write barriers, but doesn't mention
that for copyMemory.

I just checked the hotspot implementation, and it's more or less the
same, with a comment indicating such:

----------------------------------------------------------------------------
  if (dstp != NULL && !dstp->is_typeArray()) {
    // NYI:  This works only for non-oop arrays at present.
    // Generalizing it would be reasonable, but requires card marking.
    // Also, autoboxing a Long from 0L in copyMemory(x,y, 0L,z, n) would be bad.
    THROW(vmSymbols::java_lang_IllegalArgumentException());
  }
----------------------------------------------------------------------------

Which AFAICT doesn't even check the array type, just that the
destination /is/ an array, but I'm not sure.  Anyway I can add a
similar check if you'd like, but honestly I'd rather just keep things
simple and let programmers who misuse Unsafe have code that's unsafe
:).

Anyway, hopefully that makes sense and is okay with you, let me know please :).

~Will



From wdietz2 at illinois.edu  Wed Nov 16 14:53:58 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 16 Nov 2011 22:53:58 -0000
Subject: [vmkit-commits] [vmkit] r144854 - in /vmkit/trunk/lib/J3/ClassLib:
 Classpath.inc ClasspathField.inc GNUClasspath/Classpath.inc
 GNUClasspath/JavaUpcalls.cpp GNUClasspath/Makefile Makefile
 OpenJDK/JavaUpcalls.cpp Unsafe.inc
Message-ID: <20111116225358.782881BE001@llvm.org>

Author: wdietz2
Date: Wed Nov 16 16:53:58 2011
New Revision: 144854

URL: http://llvm.org/viewvc/llvm-project?rev=144854&view=rev
Log:
Split Classpath.inc into Unsafe.inc and GNUClasspath/Classpath.inc

Added:
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Classpath.inc
    vmkit/trunk/lib/J3/ClassLib/Unsafe.inc
      - copied, changed from r144808, vmkit/trunk/lib/J3/ClassLib/Classpath.inc
Removed:
    vmkit/trunk/lib/J3/ClassLib/Classpath.inc
Modified:
    vmkit/trunk/lib/J3/ClassLib/ClasspathField.inc
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Makefile
    vmkit/trunk/lib/J3/ClassLib/Makefile
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp

Removed: vmkit/trunk/lib/J3/ClassLib/Classpath.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/Classpath.inc?rev=144853&view=auto
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/Classpath.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/Classpath.inc (removed)
@@ -1,588 +0,0 @@
-//===-------- Classpath.cpp - Configuration for classpath -------------------===//
-//
-//                            The VMKit project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include "Classpath.h"
-#include "ClasspathReflect.h"
-#include "JavaClass.h"
-#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
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObject* Cl) {
-
-  llvm_gcroot(Cl, 0);
-  bool res = false;
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(Cl);
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
-
-  if (cl->isClass() &&
-      cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
-                                           vm->bootstrapLoader->clinitType,
-                                           true, false, 0))
-  res = true;
-
-  END_NATIVE_EXCEPTION
-
-  return res;
-}
-
-
-// Redefine some VMObjectStreamClass functions because of a slow implementation
-// in Classpath.
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jboolean val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt8Field(obj, (uint8)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jbyte val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt8Field(obj, (uint8)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jchar val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jshort val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt16Field(obj, (sint16)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jint val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt32Field(obj, (sint32)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jlong val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceLongField(obj, (sint64)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jfloat val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceFloatField(obj, (float)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jdouble val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceDoubleField(obj, (double)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  llvm_gcroot(val, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceObjectField(obj, val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT JavaObject* JNICALL Java_java_io_VMObjectInputStream_allocateObject(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
-
-  JavaObject* res = 0;
-  llvm_gcroot(res, 0);
-  llvm_gcroot(target, 0);
-  llvm_gcroot(constr, 0);
-  llvm_gcroot(cons, 0);
-
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClass* cl =
-    (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
-  res = cl->doNew(vm);
-  JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
-  meth->invokeIntSpecial(vm, cl, res);
-
-  END_NATIVE_EXCEPTION
-
-  return res;
-}
-
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMArray_createObjectArray(
-#ifdef NATIVE_JNI
-JNIEnv * env,
-jclass thisClass,
-#endif
-JavaObject* arrayType, jint arrayLength) {
-
-  JavaObject* res = 0;
-  llvm_gcroot(arrayType, 0);
-  llvm_gcroot(res, 0);
-
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* base =
-    UserCommonClass::resolvedImplClass(vm, arrayType, true);
-  JnjvmClassLoader* loader = base->classLoader;
-  const UTF8* name = base->getName();
-  // -1 because we're adding a new dimension in this method.
-  const int kLimit = 255 - 1;
-  const uint16* elements = name->elements;
-  if (name->size > kLimit && elements[kLimit] == '[') {
-    vm->illegalArgumentException("Too many dimensions for array");
-  }
-  const UTF8* arrayName = loader->constructArrayName(1, name);
-  UserClassArray* array = loader->constructArray(arrayName, base);
-  res = array->doNew(arrayLength, vm);
-
-  END_NATIVE_EXCEPTION
-
-  return res;
-}
-
-
-// Never throws.
-JNIEXPORT
-bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-) {
-  return false;
-}
-
-// Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect, jlong update) {
-
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  jlong *ptr;
-  jlong  value;
-
-  ptr = (jlong *) (((uint8 *) obj) + offset);
-
-  value = *ptr;
-
-  if (value == expect) {
-    *ptr = update;
-    return true;
-  } else {
-    return false;
-  }
-
-}
-
-// Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) {
-
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  jint *ptr;
-
-  ptr = (jint *) (((uint8 *) obj) + offset);
-
-  return __sync_bool_compare_and_swap(ptr, expect, update);
-}
-
-// Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
-JavaObject* update) {
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  llvm_gcroot(expect, 0);
-  llvm_gcroot(update, 0);
-
-  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
-
-  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj, (gc**)ptr, (gc*)expect, (gc*)update);
-}
-
-// Never throws.
-JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  llvm_gcroot(value, 0);
-
-  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
-  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());
-  cl->asClass()->resolveClass();
-  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) {
-  JavaObject* res = 0;
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(_field, 0);
-  llvm_gcroot(res, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  JavaField * field = JavaObjectField::getInternalField(_field);
-  assert(field);
-  field->classDef->initialiseClass(JavaThread::get()->getJVM());
-
-  res = VMStaticInstance::allocate(field->classDef);
-
-  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) {
-  // Array starts at beginning of object
-  return 0;
-}
-
-JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* clazz) {
-  // Return '0' if we don't support indexing this way.
-  // (We might pack fields specially, etc)
-  // TODO: Implement this for the array types we support this way
-  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()->throwException(obj);
-}
-
-JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
-  // Nothing
-}
-
-// TODO: Add the Volatile variants
-#define GET_PUT_OFFSET(Type,jtype,shorttype) \
-JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## __Ljava_lang_Object_2J( \
-JavaObject* unsafe, JavaObject* base, jlong offset) { \
-  jtype res = 0; \
-  BEGIN_NATIVE_EXCEPTION(0) \
-  jtype* ptr = (jtype*) (baseToPtr(base) + offset); \
-  res = *ptr; \
-  END_NATIVE_EXCEPTION \
- \
-  return res; \
-} \
- \
-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*) (baseToPtr(base) + offset); \
-  *ptr = val; \
-  END_NATIVE_EXCEPTION \
-}
-
-GET_PUT_OFFSET(Boolean,jboolean,Z)
-GET_PUT_OFFSET(Byte,jbyte,B)
-GET_PUT_OFFSET(Char,jchar,C)
-GET_PUT_OFFSET(Short,jshort,S)
-GET_PUT_OFFSET(Int,jint,I)
-GET_PUT_OFFSET(Long,jlong,J)
-GET_PUT_OFFSET(Float,jfloat,F)
-GET_PUT_OFFSET(Double,jdouble,D)
-
-}

Modified: vmkit/trunk/lib/J3/ClassLib/ClasspathField.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/ClasspathField.inc?rev=144854&r1=144853&r2=144854&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/ClasspathField.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/ClasspathField.inc Wed Nov 16 16:53:58 2011
@@ -1154,18 +1154,4 @@
   END_NATIVE_EXCEPTION
 }
 
-// Never throws.
-JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* Unsafe, JavaObjectField* Field) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(Unsafe, 0);
-
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  return (jlong)field->ptrOffset;
-}
-
 }

Added: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Classpath.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Classpath.inc?rev=144854&view=auto
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Classpath.inc (added)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Classpath.inc Wed Nov 16 16:53:58 2011
@@ -0,0 +1,289 @@
+//===-------- Classpath.cpp - Configuration for classpath -------------------===//
+//
+//                            The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#include "Classpath.h"
+#include "ClasspathReflect.h"
+#include "JavaClass.h"
+#include "JavaThread.h"
+#include "JavaUpcalls.h"
+#include "Jnjvm.h"
+#include "Reader.h"
+
+using namespace j3;
+
+extern "C" {
+
+// Define hasClassInitializer because of a buggy implementation in Classpath.
+JNIEXPORT bool JNICALL Java_java_io_VMObjectStreamClass_hasClassInitializer(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObject* Cl) {
+
+  llvm_gcroot(Cl, 0);
+  bool res = false;
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(Cl);
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
+
+  if (cl->isClass() &&
+      cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
+                                           vm->bootstrapLoader->clinitType,
+                                           true, false, 0))
+  res = true;
+
+  END_NATIVE_EXCEPTION
+
+  return res;
+}
+
+
+// Redefine some VMObjectStreamClass functions because of a slow implementation
+// in Classpath.
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jboolean val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt8Field(obj, (uint8)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jbyte val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt8Field(obj, (uint8)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jchar val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jshort val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt16Field(obj, (sint16)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jint val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceInt32Field(obj, (sint32)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jlong val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceLongField(obj, (sint64)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jfloat val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceFloatField(obj, (float)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, jdouble val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceDoubleField(obj, (double)val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(obj, 0);
+  llvm_gcroot(val, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  verifyNull(obj);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  field->setInstanceObjectField(obj, val);
+
+  END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT JavaObject* JNICALL Java_java_io_VMObjectInputStream_allocateObject(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
+
+  JavaObject* res = 0;
+  llvm_gcroot(res, 0);
+  llvm_gcroot(target, 0);
+  llvm_gcroot(constr, 0);
+  llvm_gcroot(cons, 0);
+
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* cl =
+    (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
+  res = cl->doNew(vm);
+  JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
+  meth->invokeIntSpecial(vm, cl, res);
+
+  END_NATIVE_EXCEPTION
+
+  return res;
+}
+
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMArray_createObjectArray(
+#ifdef NATIVE_JNI
+JNIEnv * env,
+jclass thisClass,
+#endif
+JavaObject* arrayType, jint arrayLength) {
+
+  JavaObject* res = 0;
+  llvm_gcroot(arrayType, 0);
+  llvm_gcroot(res, 0);
+
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* base =
+    UserCommonClass::resolvedImplClass(vm, arrayType, true);
+  JnjvmClassLoader* loader = base->classLoader;
+  const UTF8* name = base->getName();
+  // -1 because we're adding a new dimension in this method.
+  const int kLimit = 255 - 1;
+  const uint16* elements = name->elements;
+  if (name->size > kLimit && elements[kLimit] == '[') {
+    vm->illegalArgumentException("Too many dimensions for array");
+  }
+  const UTF8* arrayName = loader->constructArrayName(1, name);
+  UserClassArray* array = loader->constructArray(arrayName, base);
+  res = array->doNew(arrayLength, vm);
+
+  END_NATIVE_EXCEPTION
+
+  return res;
+}
+
+// Never throws.
+JNIEXPORT
+bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+jclass clazz,
+#endif
+) {
+  return false;
+}
+
+}

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp?rev=144854&r1=144853&r2=144854&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp Wed Nov 16 16:53:58 2011
@@ -1071,8 +1071,8 @@
 
 }
 
-#include "ClasspathConstructor.inc"
 #include "Classpath.inc"
+#include "ClasspathConstructor.inc"
 #include "ClasspathField.inc"
 #include "ClasspathMethod.inc"
 #include "ClasspathVMClass.inc"
@@ -1084,3 +1084,4 @@
 #include "ClasspathVMSystemProperties.inc"
 #include "ClasspathVMThread.inc"
 #include "ClasspathVMThrowable.inc"
+#include "Unsafe.inc"

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Makefile?rev=144854&r1=144853&r2=144854&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Makefile (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/Makefile Wed Nov 16 16:53:58 2011
@@ -9,9 +9,11 @@
 LEVEL = ../../../..
 
 
-EXTRA_DIST = ClasspathVMClass.inc ClasspathVMClassLoader.inc ClasspathVMObject.inc \
-	     ClasspathVMRuntime.inc ClasspathVMStackWalker.inc ClasspathVMSystem.inc \
-	     ClasspathVMSystemProperties.inc ClasspathVMThread.inc ClasspathVMThrowable.inc
+EXTRA_DIST = Classpath.inc ClasspathVMClass.inc ClasspathVMClassLoader.inc \
+             ClasspathVMObject.inc ClasspathVMRuntime.inc \
+             ClasspathVMStackWalker.inc ClasspathVMSystem.inc \
+             ClasspathVMSystemProperties.inc ClasspathVMThread.inc \
+             ClasspathVMThrowable.inc
 
 include $(LEVEL)/Makefile.config
 

Modified: vmkit/trunk/lib/J3/ClassLib/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/Makefile?rev=144854&r1=144853&r2=144854&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/Makefile (original)
+++ vmkit/trunk/lib/J3/ClassLib/Makefile Wed Nov 16 16:53:58 2011
@@ -12,9 +12,9 @@
              ClassContext.inc \
              ClasspathConstructor.inc \
              ClasspathField.inc \
-             Classpath.inc \
              ClasspathMethod.inc \
-             SetProperties.inc
+             SetProperties.inc \
+             Unsafe.inc
 
 include $(LEVEL)/Makefile.config
 

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp?rev=144854&r1=144853&r2=144854&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp Wed Nov 16 16:53:58 2011
@@ -897,7 +897,7 @@
 
 
 #include "ClasspathConstructor.inc"
-#include "Classpath.inc"
 #include "ClasspathField.inc"
 #include "ClasspathMethod.inc"
 #include "OpenJDK.inc"
+#include "Unsafe.inc"

Copied: vmkit/trunk/lib/J3/ClassLib/Unsafe.inc (from r144808, vmkit/trunk/lib/J3/ClassLib/Classpath.inc)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/Unsafe.inc?p2=vmkit/trunk/lib/J3/ClassLib/Unsafe.inc&p1=vmkit/trunk/lib/J3/ClassLib/Classpath.inc&r1=144808&r2=144854&rev=144854&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/Classpath.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/Unsafe.inc Wed Nov 16 16:53:58 2011
@@ -1,4 +1,4 @@
-//===-------- Classpath.cpp - Configuration for classpath -------------------===//
+//===-------- Unsafe.inc - sun.misc.Unsafe implementation -----------------===//
 //
 //                            The VMKit project
 //
@@ -7,21 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-
-
-#include "Classpath.h"
-#include "ClasspathReflect.h"
-#include "JavaClass.h"
-#include "JavaThread.h"
-#include "JavaUpcalls.h"
-#include "Jnjvm.h"
-#include "Reader.h"
 #include "VMStaticInstance.h"
-
-
-using namespace j3;
-
-extern "C" {
+#include <stdlib.h>
 
 // Convert a 'base' JavaObject to its pointer representation.
 // Handles our special VMStaticInstance wrapper.
@@ -32,271 +19,7 @@
     return (uint8*)base;
 }
 
-// Define hasClassInitializer because of a buggy implementation in Classpath.
-JNIEXPORT bool JNICALL Java_java_io_VMObjectStreamClass_hasClassInitializer(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObject* Cl) {
-
-  llvm_gcroot(Cl, 0);
-  bool res = false;
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(Cl);
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
-
-  if (cl->isClass() &&
-      cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
-                                           vm->bootstrapLoader->clinitType,
-                                           true, false, 0))
-  res = true;
-
-  END_NATIVE_EXCEPTION
-
-  return res;
-}
-
-
-// Redefine some VMObjectStreamClass functions because of a slow implementation
-// in Classpath.
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jboolean val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt8Field(obj, (uint8)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jbyte val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt8Field(obj, (uint8)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jchar val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jshort val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt16Field(obj, (sint16)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jint val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceInt32Field(obj, (sint32)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jlong val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceLongField(obj, (sint64)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jfloat val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceFloatField(obj, (float)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, jdouble val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceDoubleField(obj, (double)val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
-
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(obj, 0);
-  llvm_gcroot(val, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  verifyNull(obj);
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  field->setInstanceObjectField(obj, val);
-
-  END_NATIVE_EXCEPTION
-}
-
-JNIEXPORT JavaObject* JNICALL Java_java_io_VMObjectInputStream_allocateObject(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
-
-  JavaObject* res = 0;
-  llvm_gcroot(res, 0);
-  llvm_gcroot(target, 0);
-  llvm_gcroot(constr, 0);
-  llvm_gcroot(cons, 0);
-
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClass* cl =
-    (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
-  res = cl->doNew(vm);
-  JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
-  meth->invokeIntSpecial(vm, cl, res);
-
-  END_NATIVE_EXCEPTION
-
-  return res;
-}
-
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMArray_createObjectArray(
-#ifdef NATIVE_JNI
-JNIEnv * env,
-jclass thisClass,
-#endif
-JavaObject* arrayType, jint arrayLength) {
-
-  JavaObject* res = 0;
-  llvm_gcroot(arrayType, 0);
-  llvm_gcroot(res, 0);
-
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* base =
-    UserCommonClass::resolvedImplClass(vm, arrayType, true);
-  JnjvmClassLoader* loader = base->classLoader;
-  const UTF8* name = base->getName();
-  // -1 because we're adding a new dimension in this method.
-  const int kLimit = 255 - 1;
-  const uint16* elements = name->elements;
-  if (name->size > kLimit && elements[kLimit] == '[') {
-    vm->illegalArgumentException("Too many dimensions for array");
-  }
-  const UTF8* arrayName = loader->constructArrayName(1, name);
-  UserClassArray* array = loader->constructArray(arrayName, base);
-  res = array->doNew(arrayLength, vm);
-
-  END_NATIVE_EXCEPTION
-
-  return res;
-}
-
-
-// Never throws.
-JNIEXPORT
-bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-jclass clazz,
-#endif
-) {
-  return false;
-}
+extern "C" {
 
 // Never throws.
 JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
@@ -458,6 +181,21 @@
   return res;
 }
 
+/// objectFieldOffset - Pointer offset of the specified field
+///
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* Unsafe, JavaObjectField* Field) {
+
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(Unsafe, 0);
+
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  return (jlong)field->ptrOffset;
+}
+
 JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObjectVolatile(
 JavaObject* unsafe, JavaObject* base, jlong offset) {
   JavaObject * res = 0;




From wdietz2 at illinois.edu  Wed Nov 16 14:54:00 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 16 Nov 2011 22:54:00 -0000
Subject: [vmkit-commits] [vmkit] r144855 -
	/vmkit/trunk/lib/J3/ClassLib/Unsafe.inc
Message-ID: <20111116225400.47E4B1BE001@llvm.org>

Author: wdietz2
Date: Wed Nov 16 16:54:00 2011
New Revision: 144855

URL: http://llvm.org/viewvc/llvm-project?rev=144855&view=rev
Log:
Unsafe.inc: Rearrange code into related groups of methods.

Also, rename baseToPtr, with more useful fieldPtr.

Modified:
    vmkit/trunk/lib/J3/ClassLib/Unsafe.inc

Modified: vmkit/trunk/lib/J3/ClassLib/Unsafe.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/Unsafe.inc?rev=144855&r1=144854&r2=144855&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/Unsafe.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/Unsafe.inc Wed Nov 16 16:54:00 2011
@@ -10,107 +10,175 @@
 #include "VMStaticInstance.h"
 #include <stdlib.h>
 
-// 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();
+/// fieldPtr - Compute the address of the field specified by the given
+/// base/offset pair.  Non-trivial due to our handling of static instances,
+/// and this also handles null-checking as required.
+///
+static inline uint8 *fieldPtr(JavaObject *base, int64_t offset,
+  bool throwOnNull = true) {
+
+  // For most uses, a 'null' base should throw an exception.
+  if (throwOnNull) verifyNull(base);
+
+  if (base && VMStaticInstance::isVMStaticInstance(base))
+    return (uint8*)((VMStaticInstance*)base)->getStaticInstance() + offset;
   else
-    return (uint8*)base;
+    return (uint8*)base + offset;
 }
 
 extern "C" {
 
-// Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect, jlong update) {
+//===--- Base/Offset methods ----------------------------------------------===//
 
+/// staticFieldOffset - Return the offset of a particular static field
+/// Only valid to be used with the corresponding staticFieldBase
+///
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_staticFieldOffset(
+JavaObject* unsafe, JavaObjectField* _field) {
   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  jlong *ptr;
-  jlong  value;
+  llvm_gcroot(_field, 0);
 
-  ptr = (jlong *) (((uint8 *) obj) + offset);
+  jlong res = 0;
+  BEGIN_NATIVE_EXCEPTION(0)
 
-  value = *ptr;
+  JavaField * field = JavaObjectField::getInternalField(_field);
+  assert(field);
 
-  if (value == expect) {
-    *ptr = update;
-    return true;
-  } else {
-    return false;
-  }
+  res = field->ptrOffset;
 
+  END_NATIVE_EXCEPTION;
+
+  return res;
 }
 
-// Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
+/// staticFieldBase - Return a JavaObject* representing the static instance.
+/// Note that our static instances aren't actually java objects, so we use
+/// a placeholder object "VMStaticInstance" that also ensures that
+/// the corresponding class doesn't get GC'd underneath it.
+///
+JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_staticFieldBase(
+JavaObject* unsafe, JavaObjectField* _field) {
+  JavaObject* res = 0;
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(_field, 0);
+  llvm_gcroot(res, 0);
+  BEGIN_NATIVE_EXCEPTION(0)
+
+  JavaField * field = JavaObjectField::getInternalField(_field);
+  assert(field);
+  field->classDef->initialiseClass(JavaThread::get()->getJVM());
+
+  res = VMStaticInstance::allocate(field->classDef);
+
+  END_NATIVE_EXCEPTION;
+
+  return res;
+}
+
+/// arrayBaseOffset - Offset from the array object where the actual
+/// element data begins.
+///
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayBaseOffset(
+JavaObject* unsafe, JavaObject* clazz) {
+  // Array starts at beginning of object
+  return 0;
+}
+
+/// arrayIndexScale - Indexing scale for the element type in
+/// the specified array.  For use with arrayBaseOffset,
+/// NthElementPtr = ArrayObject + BaseOffset + N*IndexScale
+/// Return '0' if our JVM stores the elements in a way that
+/// makes this type of access impossible or unsupported.
+///
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
+JavaObject* unsafe, JavaObject* clazz) {
+  // For now, just return '0', indicating we don't support this indexing.
+  // TODO: Implement this for the array types we /do/ support this way.
+  return 0;
+}
+
+
+
+/// objectFieldOffset - Pointer offset of the specified field
+///
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
 #ifdef NATIVE_JNI
 JNIEnv *env,
 #endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) {
+JavaObject* Unsafe, JavaObjectField* Field) {
 
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  jint *ptr;
+  llvm_gcroot(Field, 0);
+  llvm_gcroot(Unsafe, 0);
 
-  ptr = (jint *) (((uint8 *) obj) + offset);
+  JavaField* field = JavaObjectField::getInternalField(Field);
+  return (jlong)field->ptrOffset;
+}
 
-  return __sync_bool_compare_and_swap(ptr, expect, update);
+//===--- Double-register addressing field accessors -----------------------===//
+// See objectFieldOffset, staticFieldOffset, staticFieldBase
+// Can also be an array, if/when we support arrayIndexScale/arrayBaseOffset
+#define GET_PUT_OFFSET(Type,jtype,shorttype) \
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## __Ljava_lang_Object_2J( \
+JavaObject* unsafe, JavaObject* base, jlong offset) { \
+  jtype res = 0; \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  jtype* ptr = (jtype*)fieldPtr(base,offset); \
+  res = *ptr; \
+  END_NATIVE_EXCEPTION \
+  return res; \
+} \
+ \
+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*)fieldPtr(base, offset); \
+  *ptr = val; \
+  END_NATIVE_EXCEPTION \
 }
 
+GET_PUT_OFFSET(Boolean,jboolean,Z)
+GET_PUT_OFFSET(Byte,jbyte,B)
+GET_PUT_OFFSET(Char,jchar,C)
+GET_PUT_OFFSET(Short,jshort,S)
+GET_PUT_OFFSET(Int,jint,I)
+GET_PUT_OFFSET(Long,jlong,J)
+GET_PUT_OFFSET(Float,jfloat,F)
+GET_PUT_OFFSET(Double,jdouble,D)
+
+//===--- Get/Put of Objects, due to GC needs special handling -------------===//
+// JavaObject field accessors:
 // Never throws.
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
-JavaObject* update) {
+JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObjectVolatile(
+JavaObject* unsafe, JavaObject* base, jlong offset) {
+  JavaObject * res = 0;
   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
-  llvm_gcroot(expect, 0);
-  llvm_gcroot(update, 0);
+  llvm_gcroot(base, 0);
+  llvm_gcroot(res, 0);
 
-  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
+  BEGIN_NATIVE_EXCEPTION(0)
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  res = *ptr;
+  END_NATIVE_EXCEPTION;
 
-  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj, (gc**)ptr, (gc*)expect, (gc*)update);
+  return res;
 }
 
+// Volatile JavaObject field accessors:
 // Never throws.
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
 #ifdef NATIVE_JNI
 JNIEnv *env,
 #endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {
+JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
+  llvm_gcroot(base, 0);
   llvm_gcroot(value, 0);
 
-  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
-  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
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
 }
 
+//===--- Misc get/put defined, TODO: generalize! --------------------------===//
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putLong__JJ(
 JavaObject* unsafe, jlong ptr, jlong value) {
   BEGIN_NATIVE_EXCEPTION(0)
@@ -128,104 +196,78 @@
   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());
-  cl->asClass()->resolveClass();
-  cl->asClass()->initialiseClass(vm);
-
-  END_NATIVE_EXCEPTION;
-}
+//===--- CompareAndSwap field accessors -----------------------------------===//
+// Never throws.
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
+JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect, jlong update) {
 
-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)
+  llvm_gcroot(obj, 0);
+  jlong *ptr;
+  jlong  value;
 
-  JavaField * field = JavaObjectField::getInternalField(_field);
-  assert(field);
+  ptr = (jlong *) (((uint8 *) obj) + offset);
 
-  res = field->ptrOffset;
+  value = *ptr;
 
-  END_NATIVE_EXCEPTION;
+  if (value == expect) {
+    *ptr = update;
+    return true;
+  } else {
+    return false;
+  }
 
-  return res;
 }
 
-JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_staticFieldBase(
-JavaObject* unsafe, JavaObjectField* _field) {
-  JavaObject* res = 0;
-  llvm_gcroot(unsafe, 0);
-  llvm_gcroot(_field, 0);
-  llvm_gcroot(res, 0);
-  BEGIN_NATIVE_EXCEPTION(0)
-
-  JavaField * field = JavaObjectField::getInternalField(_field);
-  assert(field);
-  field->classDef->initialiseClass(JavaThread::get()->getJVM());
+// Never throws.
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) {
 
-  res = VMStaticInstance::allocate(field->classDef);
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(obj, 0);
+  jint *ptr;
 
-  END_NATIVE_EXCEPTION;
+  ptr = (jint *) (((uint8 *) obj) + offset);
 
-  return res;
+  return __sync_bool_compare_and_swap(ptr, expect, update);
 }
 
-/// objectFieldOffset - Pointer offset of the specified field
-///
-JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
+// Never throws.
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
 #ifdef NATIVE_JNI
 JNIEnv *env,
 #endif
-JavaObject* Unsafe, JavaObjectField* Field) {
+JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
+JavaObject* update) {
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(obj, 0);
+  llvm_gcroot(expect, 0);
+  llvm_gcroot(update, 0);
 
-  llvm_gcroot(Field, 0);
-  llvm_gcroot(Unsafe, 0);
+  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
 
-  JavaField* field = JavaObjectField::getInternalField(Field);
-  return (jlong)field->ptrOffset;
+  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj, (gc**)ptr, (gc*)expect, (gc*)update);
 }
 
-JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObjectVolatile(
-JavaObject* unsafe, JavaObject* base, jlong offset) {
-  JavaObject * res = 0;
+//===--- Class-related functions ------------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_ensureClassInitialized(
+JavaObject* unsafe, JavaObject* clazz) {
   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(base, 0);
-  llvm_gcroot(res, 0);
-
+  llvm_gcroot(clazz, 0);
   BEGIN_NATIVE_EXCEPTION(0)
-  JavaObject** ptr = (JavaObject**) (baseToPtr(base) + offset);
-  res = *ptr;
-  END_NATIVE_EXCEPTION;
 
-  return res;
-}
+  Jnjvm* vm = JavaThread::get()->getJVM();
 
-JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayBaseOffset(
-JavaObject* unsafe, JavaObject* clazz) {
-  // Array starts at beginning of object
-  return 0;
-}
+  CommonClass * cl = JavaObject::getClass(clazz);
+  assert(cl && cl->isClass());
+  cl->asClass()->resolveClass();
+  cl->asClass()->initialiseClass(vm);
 
-JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* clazz) {
-  // Return '0' if we don't support indexing this way.
-  // (We might pack fields specially, etc)
-  // TODO: Implement this for the array types we support this way
-  return 0;
+  END_NATIVE_EXCEPTION;
 }
 
 JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BIILjava_lang_ClassLoader_2Ljava_security_ProtectionDomain_2(
@@ -281,6 +323,31 @@
 }
 
 
+//===--- Memory functions -------------------------------------------------===//
+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
+}
+
+
+//===--- Misc support functions -------------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
+  // Nothing, we define the Unsafe methods with the expected signatures.
+}
+
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_throwException(
 JavaObject* unsafe, JavaObject * obj) {
   llvm_gcroot(unsafe, 0);
@@ -289,38 +356,6 @@
   JavaThread::get()->throwException(obj);
 }
 
-JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
-  // Nothing
-}
-
-// TODO: Add the Volatile variants
-#define GET_PUT_OFFSET(Type,jtype,shorttype) \
-JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## __Ljava_lang_Object_2J( \
-JavaObject* unsafe, JavaObject* base, jlong offset) { \
-  jtype res = 0; \
-  BEGIN_NATIVE_EXCEPTION(0) \
-  jtype* ptr = (jtype*) (baseToPtr(base) + offset); \
-  res = *ptr; \
-  END_NATIVE_EXCEPTION \
- \
-  return res; \
-} \
- \
-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*) (baseToPtr(base) + offset); \
-  *ptr = val; \
-  END_NATIVE_EXCEPTION \
-}
 
-GET_PUT_OFFSET(Boolean,jboolean,Z)
-GET_PUT_OFFSET(Byte,jbyte,B)
-GET_PUT_OFFSET(Char,jchar,C)
-GET_PUT_OFFSET(Short,jshort,S)
-GET_PUT_OFFSET(Int,jint,I)
-GET_PUT_OFFSET(Long,jlong,J)
-GET_PUT_OFFSET(Float,jfloat,F)
-GET_PUT_OFFSET(Double,jdouble,D)
 
 }




From wdietz2 at illinois.edu  Wed Nov 16 14:54:01 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 16 Nov 2011 22:54:01 -0000
Subject: [vmkit-commits] [vmkit] r144856 -
	/vmkit/trunk/lib/J3/ClassLib/Unsafe.inc
Message-ID: <20111116225401.E17A71BE001@llvm.org>

Author: wdietz2
Date: Wed Nov 16 16:54:01 2011
New Revision: 144856

URL: http://llvm.org/viewvc/llvm-project?rev=144856&view=rev
Log:
Define all methods in sun.misc.Unsafe, fixes to existing.

* Add full set of get/put, including volatile and ordered.  Update existing
  volatile to use memory barrier on writes.
* Fix all get/put to make use of fieldPtr, thereby correctly handling both
  staticInstances as well as throwing null pointer exceptions.
* Add memory methods: memcpy, memset, realloc
* Add empty park/unpark methods.  (Very) inefficient, but these methods are
  allowed to return arbitrarily, so this is allowed and gets code going.
* Add misc query functions (pageSize/addressSize/etc)
* Drop NATIVE_JNI in this file, while we're at it.

The functions that I've never seen called still have UNIMPLEMENTED,
the rest have been used in 'real' code and seem to work fine.
Only exception to this is the putOrdered variants.

Modified:
    vmkit/trunk/lib/J3/ClassLib/Unsafe.inc

Modified: vmkit/trunk/lib/J3/ClassLib/Unsafe.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/Unsafe.inc?rev=144856&r1=144855&r2=144856&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/Unsafe.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/Unsafe.inc Wed Nov 16 16:54:01 2011
@@ -102,9 +102,6 @@
 /// objectFieldOffset - Pointer offset of the specified field
 ///
 JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
 JavaObject* Unsafe, JavaObjectField* Field) {
 
   llvm_gcroot(Field, 0);
@@ -136,19 +133,110 @@
   END_NATIVE_EXCEPTION \
 }
 
-GET_PUT_OFFSET(Boolean,jboolean,Z)
-GET_PUT_OFFSET(Byte,jbyte,B)
-GET_PUT_OFFSET(Char,jchar,C)
-GET_PUT_OFFSET(Short,jshort,S)
-GET_PUT_OFFSET(Int,jint,I)
-GET_PUT_OFFSET(Long,jlong,J)
-GET_PUT_OFFSET(Float,jfloat,F)
-GET_PUT_OFFSET(Double,jdouble,D)
+//===--- Direct address read/write acccessors -----------------------------===//
+#define GET_PUT_DIRECT(Type,jtype,shorttype) \
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ## __J ## shorttype( \
+JavaObject* unsafe, jlong ptr, jtype val) { \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  *(jtype*)ptr = val; \
+  END_NATIVE_EXCEPTION \
+} \
+ \
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## __J( \
+JavaObject* unsafe, jlong ptr) { \
+  jtype res = 0; \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  res = *(jtype*)ptr; \
+  END_NATIVE_EXCEPTION \
+  return res; \
+}
+
+//===--- Volatile variant of field accessors ------------------------------===//
+// Memory barriers after writes to ensure new value is seen elsewhere
+#define GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ## Volatile__J ## shorttype( \
+JavaObject* unsafe, jlong ptr, jtype val) { \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  *(volatile jtype*)ptr = val; \
+  __sync_synchronize(); \
+  END_NATIVE_EXCEPTION \
+} \
+ \
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## Volatile__J( \
+JavaObject* unsafe, jlong ptr) { \
+  jtype res = 0; \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  res = *(volatile jtype*)ptr; \
+  END_NATIVE_EXCEPTION \
+  return res; \
+}
+
+//===--- Volatile variant of direct address accessors ---------------------===//
+#define GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype) \
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## Volatile__Ljava_lang_Object_2J( \
+JavaObject* unsafe, JavaObject* base, jlong offset) { \
+  jtype res = 0; \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
+  res = *ptr; \
+  END_NATIVE_EXCEPTION \
+ \
+  return res; \
+} \
+ \
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ## Volatile__Ljava_lang_Object_2J ## shorttype( \
+JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
+  *ptr = val; \
+  __sync_synchronize(); \
+  END_NATIVE_EXCEPTION \
+}
+
+//===--- Ordered variant of field accessors -------------------------------===//
+#define GET_PUT_FIELD_ORDERED(Type,jtype,shorttype) \
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrdered ## Type( \
+JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
+  BEGIN_NATIVE_EXCEPTION(0) \
+  volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \
+  *ptr = val; \
+  /* No memory barrier */ \
+  END_NATIVE_EXCEPTION \
+}
+
+#define GET_PUT_ALL(Type,jtype,shorttype) \
+  GET_PUT_OFFSET(Type,jtype,shorttype) \
+  GET_PUT_DIRECT(Type,jtype,shorttype) \
+  GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \
+  GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype)
+
+GET_PUT_ALL(Boolean,jboolean,Z)
+GET_PUT_ALL(Byte,jbyte,B)
+GET_PUT_ALL(Char,jchar,C)
+GET_PUT_ALL(Short,jshort,S)
+GET_PUT_ALL(Int,jint,I)
+GET_PUT_ALL(Long,jlong,J) // TODO: Long needs special handling!
+GET_PUT_ALL(Float,jfloat,F)
+GET_PUT_ALL(Double,jdouble,D)
+
+// Ordered:
+GET_PUT_FIELD_ORDERED(Int,jint,I)
+GET_PUT_FIELD_ORDERED(Long,jlong,J)
 
 //===--- Get/Put of Objects, due to GC needs special handling -------------===//
 // JavaObject field accessors:
-// Never throws.
-JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObjectVolatile(
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObject__Ljava_lang_Object_2JLjava_lang_Object_2(
+JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(base, 0);
+  llvm_gcroot(value, 0);
+
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
+}
+
+
+JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObject__Ljava_lang_Object_2J(
 JavaObject* unsafe, JavaObject* base, jlong offset) {
   JavaObject * res = 0;
   llvm_gcroot(unsafe, 0);
@@ -166,9 +254,6 @@
 // Volatile JavaObject field accessors:
 // Never throws.
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
 JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
   llvm_gcroot(unsafe, 0);
   llvm_gcroot(base, 0);
@@ -176,38 +261,48 @@
 
   JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
   mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
+  // Ensure this value is seen.
+  __sync_synchronize();
 }
 
-//===--- Misc get/put defined, TODO: generalize! --------------------------===//
-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 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);
 
-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
+  JavaObject* volatile* ptr = (JavaObject* volatile*)fieldPtr(base, offset);
+  res = *ptr;
+  END_NATIVE_EXCEPTION;
 
   return res;
 }
 
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrderedObject(
+JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) {
+  llvm_gcroot(unsafe, 0);
+  llvm_gcroot(base, 0);
+  llvm_gcroot(value, 0);
+
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
+  // No barrier (difference between volatile and ordered)
+}
+
 
 //===--- CompareAndSwap field accessors -----------------------------------===//
 // Never throws.
 JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
-JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect, jlong update) {
+JavaObject* unsafe, JavaObject* base, jlong offset, jlong expect, jlong update) {
 
   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
+  llvm_gcroot(base, 0);
   jlong *ptr;
   jlong  value;
 
-  ptr = (jlong *) (((uint8 *) obj) + offset);
+  ptr = (jlong*)fieldPtr(base, offset);
 
   value = *ptr;
 
@@ -222,37 +317,31 @@
 
 // Never throws.
 JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) {
+JavaObject* unsafe, JavaObject* base, jlong offset, jint expect, jint update) {
 
   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
+  llvm_gcroot(base, 0);
   jint *ptr;
 
-  ptr = (jint *) (((uint8 *) obj) + offset);
+  ptr = (jint *)fieldPtr(base, offset);
 
   return __sync_bool_compare_and_swap(ptr, expect, update);
 }
 
 // Never throws.
 JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
-#ifdef NATIVE_JNI
-JNIEnv *env,
-#endif
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
+JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* expect,
 JavaObject* update) {
   llvm_gcroot(unsafe, 0);
-  llvm_gcroot(obj, 0);
+  llvm_gcroot(base, 0);
   llvm_gcroot(expect, 0);
   llvm_gcroot(update, 0);
 
-  JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
-
-  return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj, (gc**)ptr, (gc*)expect, (gc*)update);
+  JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
+  return mvm::Collector::objectReferenceTryCASBarrier((gc*)base, (gc**)ptr, (gc*)expect, (gc*)update);
 }
 
+
 //===--- Class-related functions ------------------------------------------===//
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_ensureClassInitialized(
 JavaObject* unsafe, JavaObject* clazz) {
@@ -270,6 +359,11 @@
   END_NATIVE_EXCEPTION;
 }
 
+JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BII(
+JavaObject* unsafe, JavaString *name, ArrayObject * bytesArr, jint off, jint len) {
+  UNIMPLEMENTED();
+}
+
 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;
@@ -322,8 +416,34 @@
   return res;
 }
 
+JNIEXPORT JavaObject* JNICALL Java_sun_Unsafe_defineAnonymousClass(
+JavaObject* unsafe, ...) {
+  UNIMPLEMENTED();
+}
 
 //===--- Memory functions -------------------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_setMemory__JJB(
+JavaObject* unsafe, long address, long bytes, jbyte value) {
+  memset((void*)address, value, bytes);
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_copyMemory__JJJ(
+JavaObject* unsafe, jlong src, jlong dst, jlong size) {
+  memcpy((void*)dst, (void*)src, size);
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_copyMemory__Ljava_lang_Object_2JLjava_lang_Object_2JJ(
+JavaObject* unsafe,
+JavaObject* srcBase, jlong srcOffset,
+JavaObject* dstBase, jlong dstOffset,
+jlong size) {
+  BEGIN_NATIVE_EXCEPTION(0)
+  uint8_t* src = fieldPtr(srcBase, srcOffset, false /* Don't throw on null base*/ );
+  uint8_t* dst = fieldPtr(dstBase, dstOffset, false /* Don't throw on null base*/ );
+  memcpy(dst, src, size);
+  END_NATIVE_EXCEPTION
+}
+
 JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_allocateMemory(
 JavaObject* unsafe, jlong size) {
   // TODO: Invalid size/OOM/etc handling!
@@ -334,6 +454,16 @@
   return res;
 }
 
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_reallocateMemory(
+JavaObject* unsafe, jlong ptr, jlong newsize) {
+  // TODO: Invalid size/OOM/etc handling!
+  jlong res = 0;
+  BEGIN_NATIVE_EXCEPTION(0)
+  res = (jlong)realloc((void*)ptr, newsize);
+  END_NATIVE_EXCEPTION
+  return res;
+}
+
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_freeMemory(
 JavaObject* unsafe, jlong ptr) {
   // TODO: Exception handling...
@@ -342,6 +472,45 @@
   END_NATIVE_EXCEPTION
 }
 
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_getAddress(
+JavaObject* unsafe, jlong ptr) {
+  return (jlong)*(void**)ptr;
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putAddress(
+JavaObject* unsafe, jlong ptr, jlong val) {
+  *(void**)ptr = (void*)val;
+}
+
+//===--- Park/Unpark thread support ---------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_park(
+JavaObject* unsafe, jboolean isAbsolute, jlong time) {
+  // Nothing, for now.
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_unpark(
+JavaObject* unsafe, JavaObject* thread) {
+  // Nothing, for now.
+}
+
+//===--- Monitor support --------------------------------------------------===//
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_tryMonitorEnter(
+JavaObject* unsafe, JavaObject * obj) {
+  //TODO: Implement me!
+  UNIMPLEMENTED();
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorEnter(
+JavaObject* unsafe, JavaObject * obj) {
+  //TODO: Implement me!
+  UNIMPLEMENTED();
+}
+
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorExit(
+JavaObject* unsafe, JavaObject * obj) {
+  //TODO: Implement me!
+  UNIMPLEMENTED();
+}
 
 //===--- Misc support functions -------------------------------------------===//
 JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) {
@@ -356,6 +525,19 @@
   JavaThread::get()->throwException(obj);
 }
 
+JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_pageSize(
+JavaObject* unsafe) {
+  return mvm::System::GetPageSize();
+}
 
+JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_addressSize(
+JavaObject* unsafe) {
+  return mvm::kWordSize;
+}
+
+JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_getLoadAverage(
+JavaObject* unsafe, ...) {
+  UNIMPLEMENTED();
+}
 
 }




From wdietz2 at illinois.edu  Wed Nov 16 14:54:03 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 16 Nov 2011 22:54:03 -0000
Subject: [vmkit-commits] [vmkit] r144857 -
	/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
Message-ID: <20111116225403.8F3471BE001@llvm.org>

Author: wdietz2
Date: Wed Nov 16 16:54:03 2011
New Revision: 144857

URL: http://llvm.org/viewvc/llvm-project?rev=144857&view=rev
Log:
Fix detection of whether or not symbols are from j3 or not.

Unfortunately, native code that's part of OpenJDK likes to dlopen things with
RTLD_GLOBAL, resulting in the existing mechanism for determining where a symbol
came from inaccurate.

Instead, search both our process (and any global libraries), but also search our
loaded libraries.

Using this, we can determine which symbols are in vmkit: they must be in in the self
search AND be a different symbol from what was found in the library search.

Modified:
    vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp

Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp?rev=144857&r1=144856&r2=144857&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp Wed Nov 16 16:54:03 2011
@@ -977,22 +977,39 @@
 }
 
 word_t JnjvmClassLoader::loadInLib(const char* buf, bool& j3) {
-  word_t res = (word_t)TheCompiler->loadMethod(mvm::System::GetSelfHandle(), buf);
-  
-  if (!res) {
-    for (std::vector<void*>::iterator i = nativeLibs.begin(),
-              e = nativeLibs.end(); i!= e; ++i) {
-      res = (word_t)TheCompiler->loadMethod((*i), buf);
-      if (res) break;
-    }
-  } else {
-    j3 = true;
+  // Check 'self'.  Should only check our process, however it's possible native
+  // code dlopen'd something itself (with RTLD_GLOBAL; OpenJDK does this).
+  // To handle this, we search both ourselves and the libraries we loaded.
+  word_t sym =
+    (word_t)TheCompiler->loadMethod(mvm::System::GetSelfHandle(), buf);
+
+  // Search loaded libraries as well, both as fallback and to determine
+  // whether or not the symbol in question is defined by vmkit.
+  word_t symFromLib = 0;
+  for (std::vector<void*>::iterator i = nativeLibs.begin(),
+      e = nativeLibs.end(); i!= e; ++i) {
+    symFromLib = (word_t)TheCompiler->loadMethod((*i), buf);
+    if (symFromLib) break;
+  }
+
+  if (sym) {
+    // Always use the definition from 'self', if it exists.
+    // Furthermore, claim it's defined in j3 iff it wasn't found in one of our
+    // libraries.  This might be wrong if we do a lookup on a symbol that's
+    // neither in vmkit nor a VM-loaded library (but /is/ in a different library
+    // that has been dlopen'd by native code), but that should never
+    // be called from java code anyway.
+    j3 = (sym != symFromLib);
+    return sym;
   }
-  
-  if (!res && this != bootstrapLoader)
-    res = bootstrapLoader->loadInLib(buf, j3);
 
-  return (word_t)res;
+  // Otherwise return what we found in the libraries, if anything
+  if (symFromLib) return symFromLib;
+
+  if (this != bootstrapLoader)
+    return bootstrapLoader->loadInLib(buf, j3);
+
+  return 0;
 }
 
 void* JnjvmClassLoader::loadLib(const char* buf) {




From wdietz2 at illinois.edu  Wed Nov 16 14:54:05 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 16 Nov 2011 22:54:05 -0000
Subject: [vmkit-commits] [vmkit] r144858 -
	/vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
Message-ID: <20111116225405.2CE1D1BE001@llvm.org>

Author: wdietz2
Date: Wed Nov 16 16:54:04 2011
New Revision: 144858

URL: http://llvm.org/viewvc/llvm-project?rev=144858&view=rev
Log:
Better handle virtual calls through casted 'this' pointers.

* Being a 'thisReference' doesn't mean we don't need to dynamically resolve
* Only customize if the call is valid for the current customization class.
    This is checked by "if(customizeFor instanceof calleeClass)"

Modified:
    vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp

Modified: vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp?rev=144858&r1=144857&r2=144858&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp Wed Nov 16 16:54:04 2011
@@ -121,10 +121,10 @@
   bool customized = false;
   bool thisReference =
     isThisReference(stackSize() - signature->getNumberOfSlots() - 1);
-  if (thisReference) {
-    assert(meth != NULL);
+  if (thisReference && meth) {
     isCustomizable = true;
-    if (customizeFor != NULL) {
+    if ((customizeFor != NULL)
+        && cl->isAssignableFrom(customizeFor)) {
       meth = customizeFor->lookupMethodDontThrow(
           meth->name, meth->type, false, true, NULL);
       assert(meth);




From wdietz2 at illinois.edu  Wed Nov 16 16:05:58 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 16 Nov 2011 18:05:58 -0600
Subject: [vmkit-commits] [PATCH] Refactor Class-related code into new
	Class.inc.
In-Reply-To: <CAPYwfirYUxFtdPQesp_6x-ij8zVB8-o-wDVQXcB6GRSEyhw80A@mail.gmail.com>
References: <CAKGWAO81ayMGHg9xuTNA9iaUT2h+46tGtFhqbGctaUY4KOyDnA@mail.gmail.com>
	<CAPYwfiq19p6UQ-47WbX-CG7PVNOMuoJk5+ww9z0Zn_jRR1VeMQ@mail.gmail.com>
	<CAKGWAO89o-TEY44ooBicp=6pezytVNVpfVbT4LnLjR7JD5FZ_g@mail.gmail.com>
	<CAPYwfirYUxFtdPQesp_6x-ij8zVB8-o-wDVQXcB6GRSEyhw80A@mail.gmail.com>
Message-ID: <CAKGWAO98XeCghygL-7XYhoRcmNOq55x2i79nsgXf63UHwmxCrQ@mail.gmail.com>

On Wed, Nov 9, 2011 at 3:44 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> Actually, I'm just trying to be the less annoying  as possible for
> refactoring, as I guess there are much more we can do to get a nicer code
> base while still supporting two class libraries. But that would be in your
> way of getting openjdk support, and I surely prefer having openjdk support
> than a nice class library layer that supports classpath and openjdk, for now
> :)
> Nicolas

Okay, understood.

And thank you very much for being understanding about deferring a
better organization until later, and working with me to get all this
committed and cleaned up :)

Very much appreciated! :)

Anyway, here's an updated version of the patch that I think should
address the previously mentioned concerns.  Of course, if not let me
know :).

Inlined below.

~Will

>From 64a5a3448785ea04d24540b020c1cd8b5bc04c96 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Sat, 5 Nov 2011 23:53:56 -0500
Subject: [PATCH] Refactor reflection code into new Reflect.inc (shared) and
 ClasspathReflect

Also use this refactored layout to add implementations for the OpenJDK port
---
 lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp |   49 ++++
 lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h   |   12 +
 lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc |  191 +--------------
 lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp      |  119 +++++++++-
 lib/J3/ClassLib/OpenJDK/ClasspathReflect.h        |   12 +
 lib/J3/ClassLib/OpenJDK/OpenJDK.inc               |  262 +++++----------------
 lib/J3/ClassLib/Reflect.inc                       |  255 ++++++++++++++++++++
 7 files changed, 510 insertions(+), 390 deletions(-)
 create mode 100644 lib/J3/ClassLib/Reflect.inc

diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
index 90bd617..20fa7b1 100644
--- a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
@@ -12,6 +12,8 @@
 #include "JavaObject.h"
 #include "JavaThread.h"

+#include "Reflect.inc"
+
 namespace j3 {

 JavaMethod* JavaObjectConstructor::getInternalMethod(JavaObjectConstructor*
self) {
@@ -27,4 +29,51 @@ JavaMethod*
JavaObjectMethod::getInternalMethod(JavaObjectMethod* self) {
   return &(cls->asClass()->virtualMethods[self->slot]);
 }

+JavaObjectConstructor*
JavaObjectConstructor::createFromInternalConstructor(JavaMethod *
cons, int i) {
+  JavaObjectConstructor* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* Cons = vm->upcalls->newConstructor;
+  ret = (JavaObjectConstructor*)Cons->doNew(vm);
+  JavaObject* const* Cl = cons->classDef->getDelegateePtr();
+  vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
+    Cl, i);
+
+  return ret;
+}
+
+JavaObjectMethod*
JavaObjectMethod::createFromInternalMethod(JavaMethod* meth, int i) {
+  JavaObjectMethod* ret = 0;
+  JavaString* str = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(str, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* Meth = vm->upcalls->newMethod;
+  ret = (JavaObjectMethod*)Meth->doNew(vm);
+  str = vm->internalUTF8ToStr(meth->name);
+  JavaObject* const* Cl = meth->classDef->getDelegateePtr();
+  vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
+    Cl, &str, i);
+
+  return ret;
+}
+
+JavaObjectField* JavaObjectField::createFromInternalField(JavaField*
field, int i) {
+  JavaObjectField* ret = 0;
+  JavaString* name = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(name, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* Field = vm->upcalls->newField;
+  ret = (JavaObjectField*)Field->doNew(vm);
+  name = vm->internalUTF8ToStr(field->name);
+  JavaObject* const* Cl = field->classDef->getDelegateePtr();
+  vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
+    Cl, &name, i);
+
+  return ret;
+}
 }
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
index d847b98..23c79c5 100644
--- a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
@@ -60,6 +60,15 @@ public:
       if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
     }
   }
+
+  static ArrayObject* getDeclaredAnnotations(JavaObjectClass* Cl);
+  static ArrayObject* getDeclaredClasses(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getDeclaredConstructors(JavaObjectClass* Cl,
bool publicOnly);
+  static ArrayObject* getDeclaredFields(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getDeclaredMethods(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getInterfaces(JavaObjectClass* Cl);
+  static JavaObject* getDeclaringClass(JavaObjectClass* Cl);
+  static int getModifiers(JavaObjectClass* Cl);
 };

 class JavaObjectField : public JavaObject {
@@ -88,6 +97,7 @@ public:
     return cls->asClass();
   }

+  static JavaObjectField* createFromInternalField(JavaField* field, int i);
 };

 class JavaObjectMethod : public JavaObject {
@@ -112,6 +122,7 @@ public:
     return cls->asClass();
   }

+  static JavaObjectMethod* createFromInternalMethod(JavaMethod* meth, int i);
 };

 class JavaObjectConstructor : public JavaObject {
@@ -133,6 +144,7 @@ public:
     return cls->asClass();
   }

+  static JavaObjectConstructor*
createFromInternalConstructor(JavaMethod* cons, int i);
 };

 class JavaObjectVMThread : public JavaObject {
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
index 0c4d21c..0c8eb4f 100644
--- a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
@@ -86,48 +86,12 @@ JavaObject* Cl,
 jboolean publicOnly) {

   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
   llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
-  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
-    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();;
-    JnjvmClassLoader* classLoader = cl->classLoader;
-    uint32 size = 0;
-
-    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
-          (!publicOnly || pub)) {
-        ++size;
-      }
-    }
-
-    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
-          (!publicOnly || pub)) {
-        UserClass* Cons = vm->upcalls->newConstructor;
-        tmp = Cons->doNew(vm);
-        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp, &Cl, i);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = JavaObjectClass::getDeclaredConstructors((JavaObjectClass*)Cl,
publicOnly);

   END_NATIVE_EXCEPTION

@@ -143,58 +107,12 @@ JavaObject* Cl,
 jboolean publicOnly) {

   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaString* str = 0;
   llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
-  llvm_gcroot(str, 0);

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-  Classpath* upcalls = vm->upcalls;
-
-  if (cl->isArray() || cl->isPrimitive()) {
-    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();
-    JnjvmClassLoader* classLoader = cl->classLoader;
-    uint32 size = 0;
-
-    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
-         ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
-          !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
-          (!publicOnly || pub)) {
-        ++size;
-      }
-    }
-
-
-    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
-         ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
-          !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
-          (!publicOnly || pub)) {
-        // TODO: check parameter types
-        UserClass* Meth = vm->upcalls->newMethod;
-        tmp = Meth->doNew(vm);
-        str = vm->internalUTF8ToStr(meth->name);
-        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, &Cl, &str, i);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = JavaObjectClass::getDeclaredMethods((JavaObjectClass*)Cl, publicOnly);

   END_NATIVE_EXCEPTION

@@ -214,14 +132,7 @@ jboolean ignore) {

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-  res = cl->getAccess();
-
-  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
-    // javac may put that flag to inner classes of enum classes.
-    res &= ~ACC_ENUM;
-  }
+  res = JavaObjectClass::getModifiers((JavaObjectClass*)Cl);

   END_NATIVE_EXCEPTION
   return res;
@@ -428,49 +339,12 @@ jclass clazz,
 JavaObject* Cl, jboolean publicOnly) {

   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaString* name = 0;
   llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
-  llvm_gcroot(name, 0);

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
-  if (!cl->isClass()) {
-    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();
-    uint32 size = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
-         ++i) {
-      JavaField* field = &realCl->virtualFields[i];
-      if (!publicOnly || isPublic(field->access)) {
-        ++size;
-      }
-    }
-
-
-    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
-         ++i) {
-      JavaField* field = &realCl->virtualFields[i];
-      if (!publicOnly || isPublic(field->access)) {
-        // TODO: check parameter types
-        UserClass* Field = vm->upcalls->newField;
-        tmp = Field->doNew(vm);
-        name = vm->internalUTF8ToStr(field->name);
-        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, &Cl,
&name, i);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = JavaObjectClass::getDeclaredFields((JavaObjectClass*)Cl, publicOnly);

   END_NATIVE_EXCEPTION

@@ -490,14 +364,7 @@ JavaObject* Cl) {

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-  res = (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,
vm);
-
-  for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
-    UserClass* klass = cl->interfaces[i];
-    ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
-  }
+  res = JavaObjectClass::getInterfaces((JavaObjectClass*)Cl);

   END_NATIVE_EXCEPTION

@@ -518,16 +385,7 @@ JavaObject* Cl) {

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
-
-  if (cl) {
-    cl->resolveInnerOuterClasses();
-    UserClass* outer = cl->getOuterClass();
-    if (outer) {
-      res = outer->getClassDelegatee(vm);
-    }
-  }
+  res = JavaObjectClass::getDeclaringClass((JavaObjectClass*)Cl);

   END_NATIVE_EXCEPTION

@@ -548,33 +406,7 @@ JavaObject* Cl, bool publicOnly) {

   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
-  if (cl) {
-    cl->resolveInnerOuterClasses();
-    UserClassArray* array = vm->upcalls->constructorArrayClass;
-
-    uint16 sizeArray = 0;
-
-    if (publicOnly) {
-      for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
-        UserClass* klass = cl->innerClasses[i];
-        if (isPublic(klass->innerAccess)) ++sizeArray;
-      }
-    } else {
-      sizeArray = cl->nbInnerClasses;
-    }
-
-    result = (ArrayObject*)array->doNew(sizeArray, vm);
-    int index = 0;
-    for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
-      UserClass* klass = cl->innerClasses[i];
-      if (!publicOnly || isPublic(klass->innerAccess))
-        ArrayObject::setElement(result, klass->getClassDelegatee(vm),
index++);
-    }
-    assert(index == sizeArray);
-  }
-
+  result = JavaObjectClass::getDeclaredClasses((JavaObjectClass*)Cl,
publicOnly);

   END_NATIVE_EXCEPTION

@@ -603,16 +435,14 @@ jclass clazz,
 #endif
 JavaObject* Cl) {
   // TODO implement me
-
+
   ArrayObject* res = 0;
   llvm_gcroot(res, 0);
   llvm_gcroot(Cl, 0);
-
+
   BEGIN_NATIVE_EXCEPTION(0)

-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
-  res = (ArrayObject*)array->doNew(0, vm);
+  res = JavaObjectClass::getDeclaredAnnotations((JavaObjectClass*)Cl);

   END_NATIVE_EXCEPTION

@@ -641,5 +471,4 @@ JavaObject* Cl) {
   return res;
 }

-
 }
diff --git a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
index 4842bb9..f5be3c2 100644
--- a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
+++ b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
@@ -8,12 +8,14 @@
 //===----------------------------------------------------------------------===//

 #include "ClasspathReflect.h"
+#include "JavaArray.h"
 #include "JavaClass.h"
 #include "JavaObject.h"
 #include "JavaThread.h"
-#include "Jnjvm.h"
+#include "JavaTypes.h"
 #include "JavaUpcalls.h"
-#include "JavaArray.h"
+#include "Jnjvm.h"
+#include "Reflect.inc"

 namespace j3 {

@@ -80,4 +82,117 @@ int
JavaObjectThrowable::getStackTraceDepth(JavaObjectThrowable * self) {
   return size;
 }

+JavaObjectConstructor*
JavaObjectConstructor::createFromInternalConstructor(JavaMethod *
cons, int i) {
+  JavaObjectConstructor* ret = 0;
+  JavaObject* pArr = 0;
+  JavaObject* eArr = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(pArr, 0);
+  llvm_gcroot(eArr, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader * classLoader = cons->classDef->classLoader;
+
+  UserClass* Cons = vm->upcalls->newConstructor;
+  pArr = cons->getParameterTypes(classLoader);
+  eArr = cons->getExceptionTypes(classLoader);
+  ret = (JavaObjectConstructor*)Cons->doNew(vm);
+  JavaObject* const* Cl = cons->classDef->getDelegateePtr();
+  vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
+    Cl,           /* declaringClass */
+    &pArr,        /* parameterTypes */
+    &eArr,        /* checkedExceptions */
+    cons->access, /* modifiers */
+    i,            /* slot */
+    NULL,         /* String signature */
+    NULL,         /* annotations */
+    NULL          /* parameterAnnotations */
+  );
+
+  return ret;
+}
+
+JavaObjectMethod*
JavaObjectMethod::createFromInternalMethod(JavaMethod* meth, int i) {
+  JavaObjectMethod* ret = 0;
+  JavaString* str = 0;
+  JavaObject* pArr = 0;
+  JavaObject* eArr = 0;
+  JavaObject* retTy = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(str, 0);
+  llvm_gcroot(pArr, 0);
+  llvm_gcroot(eArr, 0);
+  llvm_gcroot(retTy, 0);
+
+  // TODO: check parameter types
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader * classLoader = meth->classDef->classLoader;
+
+  UserClass* Meth = vm->upcalls->newMethod;
+  ret = (JavaObjectMethod*)Meth->doNew(vm);
+  str = vm->internalUTF8ToStr(meth->name);
+  pArr = meth->getParameterTypes(classLoader);
+  eArr = meth->getExceptionTypes(classLoader);
+  retTy = meth->getReturnType(classLoader);
+  JavaObject* const* Cl = meth->classDef->getClassDelegateePtr(vm);
+  vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
+    Cl,           /* declaring class */
+    &str,         /* name */
+    &pArr,        /* parameter types */
+    &retTy,       /* return type */
+    &eArr,        /* exceptions */
+    meth->access, /* modifiers */
+    i,            /* slot */
+    NULL,         /* signature */
+    NULL,         /* annotations */
+    NULL,         /* parameter annotations */
+    NULL);        /* default annotations */
+
+  return ret;
 }
+
+JavaObjectField* JavaObjectField::createFromInternalField(JavaField*
field, int i) {
+  JavaObjectField* ret = 0;
+  JavaString* name = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(name, 0);
+
+  // TODO: check parameter types
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* Field = vm->upcalls->newField;
+  ret = (JavaObjectField*)Field->doNew(vm);
+  name = vm->internalUTF8ToStr(field->name);
+
+  //type->Class
+  JnjvmClassLoader* loader = field->classDef->classLoader;
+  UserCommonClass * fieldCl = field->getSignature()->assocClass(loader);
+  assert(fieldCl);
+  JavaObject* const* type = fieldCl->getClassDelegateePtr(vm);
+  JavaObject* const* Cl = field->classDef->getClassDelegateePtr(vm);
+
+  // TODO:Implement these!
+  JavaObject** sign = NULL;
+  JavaObject** annArray = NULL;
+
+  /* java.reflect.Field(
+  *   Class declaringClass,
+  *   String name,
+  *   Class type,
+  *   int modifiers,
+  *   int slot,
+  *   String signature,
+  *   byte[] annotations)
+  */
+  vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
+    Cl,
+    &name,
+    type,
+    field->access,
+    i,
+    sign,
+    annArray);
+
+  return ret;
+}
+
+} // end namespace j3
diff --git a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
index 0055a73..15e9574 100644
--- a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
+++ b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
@@ -92,6 +92,15 @@ public:
       if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
     }
   }
+
+  static ArrayObject* getDeclaredAnnotations(JavaObjectClass* Cl);
+  static ArrayObject* getDeclaredClasses(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getDeclaredConstructors(JavaObjectClass* Cl,
bool publicOnly);
+  static ArrayObject* getDeclaredFields(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getDeclaredMethods(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getInterfaces(JavaObjectClass* Cl);
+  static JavaObject* getDeclaringClass(JavaObjectClass* Cl);
+  static int getModifiers(JavaObjectClass* Cl);
 };

 class JavaObjectField : public JavaObject {
@@ -143,6 +152,7 @@ public:
     return cls->asClass();
   }

+  static JavaObjectField* createFromInternalField(JavaField* field, int i);
 };

 class JavaObjectMethod : public JavaObject {
@@ -196,6 +206,7 @@ public:
     return cls->asClass();
   }

+  static JavaObjectMethod* createFromInternalMethod(JavaMethod* meth, int i);
 };

 class JavaObjectConstructor : public JavaObject {
@@ -240,6 +251,7 @@ public:
     return cls->asClass();
   }

+  static JavaObjectConstructor*
createFromInternalConstructor(JavaMethod* cons, int i);
 };

 class JavaObjectThrowable : public JavaObject {
diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 016c067..ed84bf1 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -1186,7 +1186,18 @@ JVM_GetClassName(JNIEnv *env, jclass cls) {

 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassInterfaces(JNIEnv *env, jclass cls) {
-  NYI();
+  ArrayObject* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  ret = JavaObjectClass::getInterfaces(*(JavaObjectClass**)cls);
+
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT jobject JNICALL
@@ -1328,23 +1339,13 @@ JVM_GetComponentType(JNIEnv *env, jclass cls) {

 JNIEXPORT jint JNICALL
 JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
-  JavaObject * Cl = 0;
+  JavaObjectClass * Cl = 0;
   llvm_gcroot(Cl, 0);
   BEGIN_JNI_EXCEPTION

-  Cl = *(JavaObject**)cls;
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
false)->asClass();;
-
-  jint res = cl->getAccess();
+  Cl = *(JavaObjectClass**)cls;

-  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
-    // javac may put that flag to inner classes of enum classes.
-    res &= ~ACC_ENUM;
-  }
-
-  RETURN_FROM_JNI(res);
+  RETURN_FROM_JNI(JavaObjectClass::getModifiers(Cl));

   END_JNI_EXCEPTION

@@ -1353,12 +1354,35 @@ JVM_GetClassModifiers(JNIEnv *env, jclass cls) {

 JNIEXPORT jobjectArray JNICALL
 JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass) {
-  NYI();
+  ArrayObject* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  // TODO: Verify boolean parameter here, assuming should default to true.
+  ret = JavaObjectClass::getDeclaredClasses(*(JavaObjectClass**)ofClass,
false);
+
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 JNIEXPORT jclass JNICALL
 JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass) {
-  NYI();
+  JavaObject* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  ret = JavaObjectClass::getDeclaringClass(*(JavaObjectClass**)ofClass);
+
+  RETURN_FROM_JNI((jclass)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /* Generics support (JDK 1.5) */
@@ -1370,7 +1394,18 @@ JVM_GetClassSignature(JNIEnv *env, jclass cls) {
 /* Annotations support (JDK 1.5) */
 JNIEXPORT jbyteArray JNICALL
 JVM_GetClassAnnotations(JNIEnv *env, jclass cls) {
-  NYI();
+  ArrayObject* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  ret = JavaObjectClass::getDeclaredAnnotations(*(JavaObjectClass**)cls);
+
+  RETURN_FROM_JNI((jbyteArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }

 /*
@@ -1380,74 +1415,11 @@ JVM_GetClassAnnotations(JNIEnv *env, jclass cls) {
 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaString* str = 0;
-  JavaObject * Cl = 0;
-  llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
-  llvm_gcroot(str, 0);

   BEGIN_JNI_EXCEPTION

-  Cl = *(JavaObject**)ofClass;
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-  Classpath* upcalls = vm->upcalls;
-
-  if (cl->isArray() || cl->isPrimitive()) {
-    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();
-    JnjvmClassLoader* classLoader = cl->classLoader;
-    uint32 size = 0;
-
-    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
-         ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
-          (!publicOnly || pub)) {
-        ++size;
-      }
-    }
-
-
-    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
-         ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
-          (!publicOnly || pub)) {
-        // TODO: check parameter types
-        UserClass* Meth = vm->upcalls->newMethod;
-        tmp = Meth->doNew(vm);
-        str = vm->internalUTF8ToStr(meth->name);
-        JavaObject * pArr = meth->getParameterTypes(classLoader);
-        JavaObject * eArr = meth->getExceptionTypes(classLoader);
-        JavaObject * retTy = meth->getReturnType(classLoader);
-        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp,
-          &Cl,          /* declaring class */
-          &str,         /* name */
-          &pArr,        /* parameter types */
-          &retTy,       /* return type */
-          &eArr,        /* exceptions */
-          meth->access, /* modifiers */
-          i,            /* slot */
-          NULL,         /* signature */
-          NULL,         /* annotations */
-          NULL,         /* parameter annotations */
-          NULL,         /* default annotations */
-          i);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = JavaObjectClass::getDeclaredMethods(*(JavaObjectClass**)ofClass,
publicOnly);

   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));

@@ -1459,85 +1431,12 @@ JVM_GetClassDeclaredMethods(JNIEnv *env,
jclass ofClass, jboolean publicOnly) {
 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaString* name = 0;
-  JavaObject*const*  type = 0;
-  JavaString* sign = 0;
-  JavaObject* annArray = 0;
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
-  llvm_gcroot(name, 0);
-  llvm_gcroot(type, 0);
-  llvm_gcroot(sign, 0);
-  llvm_gcroot(annArray, 0);

   BEGIN_JNI_EXCEPTION

-  JavaObject * Cl = *(JavaObject**)ofClass;
-  llvm_gcroot(Cl, 0);
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
-  if (!cl->isClass()) {
-    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();
-    uint32 size = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
-         ++i) {
-      JavaField* field = &realCl->virtualFields[i];
-      if (!publicOnly || isPublic(field->access)) {
-        ++size;
-      }
-    }
-
+  ret = JavaObjectClass::getDeclaredFields(*(JavaObjectClass**)ofClass,
publicOnly);

-    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
-         ++i) {
-      JavaField* field = &realCl->virtualFields[i];
-      if (!publicOnly || isPublic(field->access)) {
-        // TODO: check parameter types
-        UserClass* Field = vm->upcalls->newField;
-        tmp = Field->doNew(vm);
-        name = vm->internalUTF8ToStr(field->name);
-
-        //type->Class
-        UserCommonClass * fieldCl =
field->getSignature()->assocClass(cl->classLoader);
-        assert(fieldCl);
-        type = fieldCl->getClassDelegateePtr(vm);
-
-        // TODO:Implement these!
-        sign = NULL;
-        annArray = NULL;
-
-        //Convert to string
-
-        /* java.reflect.Field(
-         *   Class declaringClass,
-         *   String name,
-         *   Class type,
-         *   int modifiers,
-         *   int slot,
-         *   String signature,
-         *   byte[] annotations)
-         */
-        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp,
-          &Cl,
-          &name,
-          type,
-          field->access,
-          i,
-          sign,
-          annArray);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));

   END_JNI_EXCEPTION
@@ -1548,62 +1447,11 @@ JVM_GetClassDeclaredFields(JNIEnv *env, jclass
ofClass, jboolean publicOnly) {
 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass,
jboolean publicOnly) {
   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaObject* Cl = 0;
-  llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);

   BEGIN_JNI_EXCEPTION

-  Cl = *(JavaObject**)ofClass;
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
-  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
-    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();;
-    JnjvmClassLoader* classLoader = cl->classLoader;
-    uint32 size = 0;
-
-    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
-          (!publicOnly || pub)) {
-        ++size;
-      }
-    }
-
-    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
-          (!publicOnly || pub)) {
-        UserClass* Cons = vm->upcalls->newConstructor;
-        JavaObject * pArr = meth->getParameterTypes(classLoader);
-        JavaObject * eArr = meth->getExceptionTypes(classLoader);
-        tmp = Cons->doNew(vm);
-        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp,
-          &Cl,          /* declaringClass */
-          &pArr,        /* parameterTypes */
-          &eArr,        /* checkedExceptions */
-          meth->access, /* modifiers */
-          i,            /* slot */
-          NULL,         /* String signature */
-          NULL,         /* annotations */
-          NULL          /* parameterAnnotations */
-        );
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = JavaObjectClass::getDeclaredConstructors(*(JavaObjectClass**)ofClass,
publicOnly);

   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));

diff --git a/lib/J3/ClassLib/Reflect.inc b/lib/J3/ClassLib/Reflect.inc
new file mode 100644
index 0000000..1d6effd
--- /dev/null
+++ b/lib/J3/ClassLib/Reflect.inc
@@ -0,0 +1,255 @@
+//===---- Reflect.inc - Shared reflecation code
---------------------------===//
+//
+//                            The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClasspathReflect.h"
+#include "JavaArray.h"
+#include "JavaUpcalls.h"
+#include "Jnjvm.h"
+
+namespace j3 {
+
+ArrayObject* JavaObjectClass::getDeclaredConstructors(JavaObjectClass*
Cl, bool publicOnly) {
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
+    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();;
+    JnjvmClassLoader* classLoader = cl->classLoader;
+    uint32 size = 0;
+
+    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+          (!publicOnly || pub)) {
+        ++size;
+      }
+    }
+
+    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+          (!publicOnly || pub)) {
+        tmp = JavaObjectConstructor::createFromInternalConstructor(meth, i);
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+
+  return ret;
+}
+
+ArrayObject* JavaObjectClass::getDeclaredMethods(JavaObjectClass* Cl,
bool publicOnly) {
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  JavaString* str = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+  llvm_gcroot(str, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  Classpath* upcalls = vm->upcalls;
+
+  if (cl->isArray() || cl->isPrimitive()) {
+    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();
+    JnjvmClassLoader* classLoader = cl->classLoader;
+    uint32 size = 0;
+
+    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+         ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+          !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
+          (!publicOnly || pub)) {
+        ++size;
+      }
+    }
+
+
+    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+         ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+          !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
+          (!publicOnly || pub)) {
+        tmp = JavaObjectMethod::createFromInternalMethod(meth, i);
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+
+  return ret;
+}
+
+JavaObject* JavaObjectClass::getDeclaringClass(JavaObjectClass* Cl) {
+  JavaObject* res = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(res, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
+
+  if (cl) {
+    cl->resolveInnerOuterClasses();
+    UserClass* outer = cl->getOuterClass();
+    if (outer) {
+      res = outer->getClassDelegatee(vm);
+    }
+  }
+
+  return res;
+}
+
+ArrayObject* JavaObjectClass::getDeclaredClasses(JavaObjectClass* Cl,
bool publicOnly) {
+  ArrayObject* result = 0;
+  llvm_gcroot(result, 0);
+  llvm_gcroot(Cl, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
+  if (cl) {
+    cl->resolveInnerOuterClasses();
+    UserClassArray* array = vm->upcalls->constructorArrayClass;
+
+    uint16 sizeArray = 0;
+
+    if (publicOnly) {
+      for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
+        UserClass* klass = cl->innerClasses[i];
+        if (isPublic(klass->innerAccess)) ++sizeArray;
+      }
+    } else {
+      sizeArray = cl->nbInnerClasses;
+    }
+
+    result = (ArrayObject*)array->doNew(sizeArray, vm);
+    int index = 0;
+    for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
+      UserClass* klass = cl->innerClasses[i];
+      if (!publicOnly || isPublic(klass->innerAccess))
+        ArrayObject::setElement(result, klass->getClassDelegatee(vm), index++);
+    }
+    assert(index == sizeArray);
+  }
+
+  return result;
+}
+
+ArrayObject* JavaObjectClass::getDeclaredFields(JavaObjectClass* Cl,
bool publicOnly) {
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  JavaString* name = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+  llvm_gcroot(name, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  if (!cl->isClass()) {
+    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();
+    uint32 size = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+         ++i) {
+      JavaField* field = &realCl->virtualFields[i];
+      if (!publicOnly || isPublic(field->access)) {
+        ++size;
+      }
+    }
+
+    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+         ++i) {
+      JavaField* field = &realCl->virtualFields[i];
+      if (!publicOnly || isPublic(field->access)) {
+        tmp = JavaObjectField::createFromInternalField(field, i);
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+
+  return ret;
+}
+
+ArrayObject* JavaObjectClass::getInterfaces(JavaObjectClass* Cl) {
+  ArrayObject* res = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(res, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  res = (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,
vm);
+
+  for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
+    UserClass* klass = cl->interfaces[i];
+    ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
+  }
+
+  return res;
+}
+
+ArrayObject* JavaObjectClass::getDeclaredAnnotations(JavaObjectClass* Cl) {
+  // TODO: Implement me (for now just returning empty array)
+  ArrayObject* res = 0;
+  llvm_gcroot(res, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
+  res = (ArrayObject*)array->doNew(0, vm);
+
+  return res;
+}
+
+int32_t JavaObjectClass::getModifiers(JavaObjectClass* Cl) {
+  llvm_gcroot(Cl, 0);
+  int32_t res;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  res = cl->getAccess();
+
+  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
+    // javac may put that flag to inner classes of enum classes.
+    res &= ~ACC_ENUM;
+  }
+
+  return res;
+}
+
+} // end namespace j3
-- 
1.7.5.1



From nicolas.geoffray at gmail.com  Thu Nov 17 11:02:58 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Thu, 17 Nov 2011 20:02:58 +0100
Subject: [vmkit-commits] [PATCH 3/3] Define all methods in
 sun.misc.Unsafe, fixes to existing.
In-Reply-To: <CAKGWAO8M97KnEYiMaa0W2VogJQR9sQDeL_PRUxzc3ngP8oZAzQ@mail.gmail.com>
References: <CAKGWAO9ofjQ79E3CKhSjcdoTncaotscL6LxAE2G+58eMNaKNSg@mail.gmail.com>
	<CAPYwfipm2R-Q5nimMXPXthQ2a1fxYMiLf9efgTjR-yOiHLOFhg@mail.gmail.com>
	<CAKGWAO8M97KnEYiMaa0W2VogJQR9sQDeL_PRUxzc3ngP8oZAzQ@mail.gmail.com>
Message-ID: <CAPYwfipLp8ZZMDawSdPNSFnnbhiXhWgKGRpreFavwKxhGQk1RQ@mail.gmail.com>

On Wed, Nov 16, 2011 at 11:50 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> On Wed, Nov 16, 2011 at 2:24 PM, Nicolas Geoffray
> <nicolas.geoffray at gmail.com> wrote:
> >>  JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
> >> -JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
> >> jlong update) {
> >> +JavaObject* unsafe, JavaObject* base, jlong offset, jlong expect,
> >> jlong update) {
> >>
> >>   llvm_gcroot(unsafe, 0);
> >> -  llvm_gcroot(obj, 0);
> >> +  llvm_gcroot(base, 0);
> >>   jlong *ptr;
> >>   jlong  value;
> >>
> >> -  ptr = (jlong *) (((uint8 *) obj) + offset);
> >> +  // TODO: Why isn't this atomic?
> >
> > Why would it be on a 32 bit system?
> >
>
> I'm not sure I understand what you're saying.  Are you saying that
> when you're on a 32bit system it shouldn't be atomic?  I apologize,
> I'm probably missing something.
>

Yes, a long store on a 32bits system is not atomic.


>
> >>
> Java_sun_misc_Unsafe_copyMemory__Ljava_lang_Object_2JLjava_lang_Object_2JJ(
> >> +JavaObject* unsafe,
> >> +JavaObject* srcBase, jlong srcOffset,
> >> +JavaObject* dstBase, jlong dstOffset,
> >> +jlong size) {
> >> +  BEGIN_NATIVE_EXCEPTION(0)
> >> +  uint8_t* src = fieldPtr(srcBase, srcOffset, false /* Don't throw on
> >> null base*/ );
> >> +  uint8_t* dst = fieldPtr(dstBase, dstOffset, false /* Don't throw on
> >> null base*/ );
> >> +  memcpy(dst, src, size);
> >
> > How does that deal with GC barriers?
> >
>
> It doesn't, but I don't think it's supposed to either.  It's part of
> 'Unsafe' after all--and the documentation seems clear when an
> operation is supposed to deal with write barriers, but doesn't mention
> that for copyMemory.
>
> I just checked the hotspot implementation, and it's more or less the
> same, with a comment indicating such:
>
>
> ----------------------------------------------------------------------------
>  if (dstp != NULL && !dstp->is_typeArray()) {
>    // NYI:  This works only for non-oop arrays at present.
>    // Generalizing it would be reasonable, but requires card marking.
>    // Also, autoboxing a Long from 0L in copyMemory(x,y, 0L,z, n) would be
> bad.
>    THROW(vmSymbols::java_lang_IllegalArgumentException());
>  }
>
> ----------------------------------------------------------------------------
>
> Which AFAICT doesn't even check the array type, just that the
> destination /is/ an array, but I'm not sure.  Anyway I can add a
> similar check if you'd like, but honestly I'd rather just keep things
> simple and let programmers who misuse Unsafe have code that's unsafe
> :).
>

I think I'd feel more secure with adding these checks. Making sure it's a
primitive array is easy in vmkit.

Cheers,
Nicolas


>
> Anyway, hopefully that makes sense and is okay with you, let me know
> please :).
>
> ~Will
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111117/ce27ad60/attachment.html>

From nicolas.geoffray at gmail.com  Thu Nov 17 11:07:50 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Thu, 17 Nov 2011 20:07:50 +0100
Subject: [vmkit-commits] [PATCH] Refactor Class-related code into new
	Class.inc.
In-Reply-To: <CAKGWAO98XeCghygL-7XYhoRcmNOq55x2i79nsgXf63UHwmxCrQ@mail.gmail.com>
References: <CAKGWAO81ayMGHg9xuTNA9iaUT2h+46tGtFhqbGctaUY4KOyDnA@mail.gmail.com>
	<CAPYwfiq19p6UQ-47WbX-CG7PVNOMuoJk5+ww9z0Zn_jRR1VeMQ@mail.gmail.com>
	<CAKGWAO89o-TEY44ooBicp=6pezytVNVpfVbT4LnLjR7JD5FZ_g@mail.gmail.com>
	<CAPYwfirYUxFtdPQesp_6x-ij8zVB8-o-wDVQXcB6GRSEyhw80A@mail.gmail.com>
	<CAKGWAO98XeCghygL-7XYhoRcmNOq55x2i79nsgXf63UHwmxCrQ@mail.gmail.com>
Message-ID: <CAPYwfir5PiQpcdUxBeSGnQcPyYNCBiw2EcaNPD=Avrz3Rt9u9g@mail.gmail.com>

Looks good, please apply :)

On Thu, Nov 17, 2011 at 1:05 AM, Will Dietz <wdietz2 at illinois.edu> wrote:

> On Wed, Nov 9, 2011 at 3:44 PM, Nicolas Geoffray
> <nicolas.geoffray at gmail.com> wrote:
> > Actually, I'm just trying to be the less annoying  as possible for
> > refactoring, as I guess there are much more we can do to get a nicer code
> > base while still supporting two class libraries. But that would be in
> your
> > way of getting openjdk support, and I surely prefer having openjdk
> support
> > than a nice class library layer that supports classpath and openjdk, for
> now
> > :)
> > Nicolas
>
> Okay, understood.
>
> And thank you very much for being understanding about deferring a
> better organization until later, and working with me to get all this
> committed and cleaned up :)
>
> Very much appreciated! :)
>
> Anyway, here's an updated version of the patch that I think should
> address the previously mentioned concerns.  Of course, if not let me
> know :).
>
> Inlined below.
>
> ~Will
>
> From 64a5a3448785ea04d24540b020c1cd8b5bc04c96 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Sat, 5 Nov 2011 23:53:56 -0500
> Subject: [PATCH] Refactor reflection code into new Reflect.inc (shared) and
>  ClasspathReflect
>
> Also use this refactored layout to add implementations for the OpenJDK port
> ---
>  lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp |   49 ++++
>  lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h   |   12 +
>  lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc |  191 +--------------
>  lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp      |  119 +++++++++-
>  lib/J3/ClassLib/OpenJDK/ClasspathReflect.h        |   12 +
>  lib/J3/ClassLib/OpenJDK/OpenJDK.inc               |  262
> +++++----------------
>  lib/J3/ClassLib/Reflect.inc                       |  255
> ++++++++++++++++++++
>  7 files changed, 510 insertions(+), 390 deletions(-)
>  create mode 100644 lib/J3/ClassLib/Reflect.inc
>
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
> b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
> index 90bd617..20fa7b1 100644
> --- a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
> @@ -12,6 +12,8 @@
>  #include "JavaObject.h"
>  #include "JavaThread.h"
>
> +#include "Reflect.inc"
> +
>  namespace j3 {
>
>  JavaMethod*
> JavaObjectConstructor::getInternalMethod(JavaObjectConstructor*
> self) {
> @@ -27,4 +29,51 @@ JavaMethod*
> JavaObjectMethod::getInternalMethod(JavaObjectMethod* self) {
>   return &(cls->asClass()->virtualMethods[self->slot]);
>  }
>
> +JavaObjectConstructor*
> JavaObjectConstructor::createFromInternalConstructor(JavaMethod *
> cons, int i) {
> +  JavaObjectConstructor* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* Cons = vm->upcalls->newConstructor;
> +  ret = (JavaObjectConstructor*)Cons->doNew(vm);
> +  JavaObject* const* Cl = cons->classDef->getDelegateePtr();
> +  vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
> +    Cl, i);
> +
> +  return ret;
> +}
> +
> +JavaObjectMethod*
> JavaObjectMethod::createFromInternalMethod(JavaMethod* meth, int i) {
> +  JavaObjectMethod* ret = 0;
> +  JavaString* str = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(str, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* Meth = vm->upcalls->newMethod;
> +  ret = (JavaObjectMethod*)Meth->doNew(vm);
> +  str = vm->internalUTF8ToStr(meth->name);
> +  JavaObject* const* Cl = meth->classDef->getDelegateePtr();
> +  vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
> +    Cl, &str, i);
> +
> +  return ret;
> +}
> +
> +JavaObjectField* JavaObjectField::createFromInternalField(JavaField*
> field, int i) {
> +  JavaObjectField* ret = 0;
> +  JavaString* name = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(name, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* Field = vm->upcalls->newField;
> +  ret = (JavaObjectField*)Field->doNew(vm);
> +  name = vm->internalUTF8ToStr(field->name);
> +  JavaObject* const* Cl = field->classDef->getDelegateePtr();
> +  vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
> +    Cl, &name, i);
> +
> +  return ret;
> +}
>  }
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
> b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
> index d847b98..23c79c5 100644
> --- a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
> @@ -60,6 +60,15 @@ public:
>       if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
>     }
>   }
> +
> +  static ArrayObject* getDeclaredAnnotations(JavaObjectClass* Cl);
> +  static ArrayObject* getDeclaredClasses(JavaObjectClass* Cl, bool
> publicOnly);
> +  static ArrayObject* getDeclaredConstructors(JavaObjectClass* Cl,
> bool publicOnly);
> +  static ArrayObject* getDeclaredFields(JavaObjectClass* Cl, bool
> publicOnly);
> +  static ArrayObject* getDeclaredMethods(JavaObjectClass* Cl, bool
> publicOnly);
> +  static ArrayObject* getInterfaces(JavaObjectClass* Cl);
> +  static JavaObject* getDeclaringClass(JavaObjectClass* Cl);
> +  static int getModifiers(JavaObjectClass* Cl);
>  };
>
>  class JavaObjectField : public JavaObject {
> @@ -88,6 +97,7 @@ public:
>     return cls->asClass();
>   }
>
> +  static JavaObjectField* createFromInternalField(JavaField* field, int
> i);
>  };
>
>  class JavaObjectMethod : public JavaObject {
> @@ -112,6 +122,7 @@ public:
>     return cls->asClass();
>   }
>
> +  static JavaObjectMethod* createFromInternalMethod(JavaMethod* meth, int
> i);
>  };
>
>  class JavaObjectConstructor : public JavaObject {
> @@ -133,6 +144,7 @@ public:
>     return cls->asClass();
>   }
>
> +  static JavaObjectConstructor*
> createFromInternalConstructor(JavaMethod* cons, int i);
>  };
>
>  class JavaObjectVMThread : public JavaObject {
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> index 0c4d21c..0c8eb4f 100644
> --- a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> @@ -86,48 +86,12 @@ JavaObject* Cl,
>  jboolean publicOnly) {
>
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
>   llvm_gcroot(Cl, 0);
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> -  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
> -    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();;
> -    JnjvmClassLoader* classLoader = cl->classLoader;
> -    uint32 size = 0;
> -
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> -          (!publicOnly || pub)) {
> -        ++size;
> -      }
> -    }
> -
> -    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size,
> vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> -          (!publicOnly || pub)) {
> -        UserClass* Cons = vm->upcalls->newConstructor;
> -        tmp = Cons->doNew(vm);
> -        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp,
> &Cl, i);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = JavaObjectClass::getDeclaredConstructors((JavaObjectClass*)Cl,
> publicOnly);
>
>   END_NATIVE_EXCEPTION
>
> @@ -143,58 +107,12 @@ JavaObject* Cl,
>  jboolean publicOnly) {
>
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> -  JavaString* str = 0;
>   llvm_gcroot(Cl, 0);
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
> -  llvm_gcroot(str, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -  Classpath* upcalls = vm->upcalls;
> -
> -  if (cl->isArray() || cl->isPrimitive()) {
> -    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();
> -    JnjvmClassLoader* classLoader = cl->classLoader;
> -    uint32 size = 0;
> -
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> -         ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> -          !(meth->name->equals(classLoader->bootstrapLoader->clinitName))
> &&
> -          (!publicOnly || pub)) {
> -        ++size;
> -      }
> -    }
> -
> -
> -    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> -         ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> -          !(meth->name->equals(classLoader->bootstrapLoader->clinitName))
> &&
> -          (!publicOnly || pub)) {
> -        // TODO: check parameter types
> -        UserClass* Meth = vm->upcalls->newMethod;
> -        tmp = Meth->doNew(vm);
> -        str = vm->internalUTF8ToStr(meth->name);
> -        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, &Cl, &str,
> i);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = JavaObjectClass::getDeclaredMethods((JavaObjectClass*)Cl,
> publicOnly);
>
>   END_NATIVE_EXCEPTION
>
> @@ -214,14 +132,7 @@ jboolean ignore) {
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -  res = cl->getAccess();
> -
> -  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
> -    // javac may put that flag to inner classes of enum classes.
> -    res &= ~ACC_ENUM;
> -  }
> +  res = JavaObjectClass::getModifiers((JavaObjectClass*)Cl);
>
>   END_NATIVE_EXCEPTION
>   return res;
> @@ -428,49 +339,12 @@ jclass clazz,
>  JavaObject* Cl, jboolean publicOnly) {
>
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> -  JavaString* name = 0;
>   llvm_gcroot(Cl, 0);
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
> -  llvm_gcroot(name, 0);
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> -  if (!cl->isClass()) {
> -    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();
> -    uint32 size = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> -         ++i) {
> -      JavaField* field = &realCl->virtualFields[i];
> -      if (!publicOnly || isPublic(field->access)) {
> -        ++size;
> -      }
> -    }
> -
> -
> -    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> -         ++i) {
> -      JavaField* field = &realCl->virtualFields[i];
> -      if (!publicOnly || isPublic(field->access)) {
> -        // TODO: check parameter types
> -        UserClass* Field = vm->upcalls->newField;
> -        tmp = Field->doNew(vm);
> -        name = vm->internalUTF8ToStr(field->name);
> -        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, &Cl,
> &name, i);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = JavaObjectClass::getDeclaredFields((JavaObjectClass*)Cl,
> publicOnly);
>
>   END_NATIVE_EXCEPTION
>
> @@ -490,14 +364,7 @@ JavaObject* Cl) {
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -  res =
> (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,
> vm);
> -
> -  for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
> -    UserClass* klass = cl->interfaces[i];
> -    ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
> -  }
> +  res = JavaObjectClass::getInterfaces((JavaObjectClass*)Cl);
>
>   END_NATIVE_EXCEPTION
>
> @@ -518,16 +385,7 @@ JavaObject* Cl) {
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> -
> -  if (cl) {
> -    cl->resolveInnerOuterClasses();
> -    UserClass* outer = cl->getOuterClass();
> -    if (outer) {
> -      res = outer->getClassDelegatee(vm);
> -    }
> -  }
> +  res = JavaObjectClass::getDeclaringClass((JavaObjectClass*)Cl);
>
>   END_NATIVE_EXCEPTION
>
> @@ -548,33 +406,7 @@ JavaObject* Cl, bool publicOnly) {
>
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> -  if (cl) {
> -    cl->resolveInnerOuterClasses();
> -    UserClassArray* array = vm->upcalls->constructorArrayClass;
> -
> -    uint16 sizeArray = 0;
> -
> -    if (publicOnly) {
> -      for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
> -        UserClass* klass = cl->innerClasses[i];
> -        if (isPublic(klass->innerAccess)) ++sizeArray;
> -      }
> -    } else {
> -      sizeArray = cl->nbInnerClasses;
> -    }
> -
> -    result = (ArrayObject*)array->doNew(sizeArray, vm);
> -    int index = 0;
> -    for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
> -      UserClass* klass = cl->innerClasses[i];
> -      if (!publicOnly || isPublic(klass->innerAccess))
> -        ArrayObject::setElement(result, klass->getClassDelegatee(vm),
> index++);
> -    }
> -    assert(index == sizeArray);
> -  }
> -
> +  result = JavaObjectClass::getDeclaredClasses((JavaObjectClass*)Cl,
> publicOnly);
>
>   END_NATIVE_EXCEPTION
>
> @@ -603,16 +435,14 @@ jclass clazz,
>  #endif
>  JavaObject* Cl) {
>   // TODO implement me
> -
> +
>   ArrayObject* res = 0;
>   llvm_gcroot(res, 0);
>   llvm_gcroot(Cl, 0);
> -
> +
>   BEGIN_NATIVE_EXCEPTION(0)
>
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
> -  res = (ArrayObject*)array->doNew(0, vm);
> +  res = JavaObjectClass::getDeclaredAnnotations((JavaObjectClass*)Cl);
>
>   END_NATIVE_EXCEPTION
>
> @@ -641,5 +471,4 @@ JavaObject* Cl) {
>   return res;
>  }
>
> -
>  }
> diff --git a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
> b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
> index 4842bb9..f5be3c2 100644
> --- a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
> +++ b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
> @@ -8,12 +8,14 @@
>
>  //===----------------------------------------------------------------------===//
>
>  #include "ClasspathReflect.h"
> +#include "JavaArray.h"
>  #include "JavaClass.h"
>  #include "JavaObject.h"
>  #include "JavaThread.h"
> -#include "Jnjvm.h"
> +#include "JavaTypes.h"
>  #include "JavaUpcalls.h"
> -#include "JavaArray.h"
> +#include "Jnjvm.h"
> +#include "Reflect.inc"
>
>  namespace j3 {
>
> @@ -80,4 +82,117 @@ int
> JavaObjectThrowable::getStackTraceDepth(JavaObjectThrowable * self) {
>   return size;
>  }
>
> +JavaObjectConstructor*
> JavaObjectConstructor::createFromInternalConstructor(JavaMethod *
> cons, int i) {
> +  JavaObjectConstructor* ret = 0;
> +  JavaObject* pArr = 0;
> +  JavaObject* eArr = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(pArr, 0);
> +  llvm_gcroot(eArr, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JnjvmClassLoader * classLoader = cons->classDef->classLoader;
> +
> +  UserClass* Cons = vm->upcalls->newConstructor;
> +  pArr = cons->getParameterTypes(classLoader);
> +  eArr = cons->getExceptionTypes(classLoader);
> +  ret = (JavaObjectConstructor*)Cons->doNew(vm);
> +  JavaObject* const* Cl = cons->classDef->getDelegateePtr();
> +  vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
> +    Cl,           /* declaringClass */
> +    &pArr,        /* parameterTypes */
> +    &eArr,        /* checkedExceptions */
> +    cons->access, /* modifiers */
> +    i,            /* slot */
> +    NULL,         /* String signature */
> +    NULL,         /* annotations */
> +    NULL          /* parameterAnnotations */
> +  );
> +
> +  return ret;
> +}
> +
> +JavaObjectMethod*
> JavaObjectMethod::createFromInternalMethod(JavaMethod* meth, int i) {
> +  JavaObjectMethod* ret = 0;
> +  JavaString* str = 0;
> +  JavaObject* pArr = 0;
> +  JavaObject* eArr = 0;
> +  JavaObject* retTy = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(str, 0);
> +  llvm_gcroot(pArr, 0);
> +  llvm_gcroot(eArr, 0);
> +  llvm_gcroot(retTy, 0);
> +
> +  // TODO: check parameter types
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  JnjvmClassLoader * classLoader = meth->classDef->classLoader;
> +
> +  UserClass* Meth = vm->upcalls->newMethod;
> +  ret = (JavaObjectMethod*)Meth->doNew(vm);
> +  str = vm->internalUTF8ToStr(meth->name);
> +  pArr = meth->getParameterTypes(classLoader);
> +  eArr = meth->getExceptionTypes(classLoader);
> +  retTy = meth->getReturnType(classLoader);
> +  JavaObject* const* Cl = meth->classDef->getClassDelegateePtr(vm);
> +  vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
> +    Cl,           /* declaring class */
> +    &str,         /* name */
> +    &pArr,        /* parameter types */
> +    &retTy,       /* return type */
> +    &eArr,        /* exceptions */
> +    meth->access, /* modifiers */
> +    i,            /* slot */
> +    NULL,         /* signature */
> +    NULL,         /* annotations */
> +    NULL,         /* parameter annotations */
> +    NULL);        /* default annotations */
> +
> +  return ret;
>  }
> +
> +JavaObjectField* JavaObjectField::createFromInternalField(JavaField*
> field, int i) {
> +  JavaObjectField* ret = 0;
> +  JavaString* name = 0;
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(name, 0);
> +
> +  // TODO: check parameter types
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* Field = vm->upcalls->newField;
> +  ret = (JavaObjectField*)Field->doNew(vm);
> +  name = vm->internalUTF8ToStr(field->name);
> +
> +  //type->Class
> +  JnjvmClassLoader* loader = field->classDef->classLoader;
> +  UserCommonClass * fieldCl = field->getSignature()->assocClass(loader);
> +  assert(fieldCl);
> +  JavaObject* const* type = fieldCl->getClassDelegateePtr(vm);
> +  JavaObject* const* Cl = field->classDef->getClassDelegateePtr(vm);
> +
> +  // TODO:Implement these!
> +  JavaObject** sign = NULL;
> +  JavaObject** annArray = NULL;
> +
> +  /* java.reflect.Field(
> +  *   Class declaringClass,
> +  *   String name,
> +  *   Class type,
> +  *   int modifiers,
> +  *   int slot,
> +  *   String signature,
> +  *   byte[] annotations)
> +  */
> +  vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
> +    Cl,
> +    &name,
> +    type,
> +    field->access,
> +    i,
> +    sign,
> +    annArray);
> +
> +  return ret;
> +}
> +
> +} // end namespace j3
> diff --git a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
> b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
> index 0055a73..15e9574 100644
> --- a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
> +++ b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
> @@ -92,6 +92,15 @@ public:
>       if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
>     }
>   }
> +
> +  static ArrayObject* getDeclaredAnnotations(JavaObjectClass* Cl);
> +  static ArrayObject* getDeclaredClasses(JavaObjectClass* Cl, bool
> publicOnly);
> +  static ArrayObject* getDeclaredConstructors(JavaObjectClass* Cl,
> bool publicOnly);
> +  static ArrayObject* getDeclaredFields(JavaObjectClass* Cl, bool
> publicOnly);
> +  static ArrayObject* getDeclaredMethods(JavaObjectClass* Cl, bool
> publicOnly);
> +  static ArrayObject* getInterfaces(JavaObjectClass* Cl);
> +  static JavaObject* getDeclaringClass(JavaObjectClass* Cl);
> +  static int getModifiers(JavaObjectClass* Cl);
>  };
>
>  class JavaObjectField : public JavaObject {
> @@ -143,6 +152,7 @@ public:
>     return cls->asClass();
>   }
>
> +  static JavaObjectField* createFromInternalField(JavaField* field, int
> i);
>  };
>
>  class JavaObjectMethod : public JavaObject {
> @@ -196,6 +206,7 @@ public:
>     return cls->asClass();
>   }
>
> +  static JavaObjectMethod* createFromInternalMethod(JavaMethod* meth, int
> i);
>  };
>
>  class JavaObjectConstructor : public JavaObject {
> @@ -240,6 +251,7 @@ public:
>     return cls->asClass();
>   }
>
> +  static JavaObjectConstructor*
> createFromInternalConstructor(JavaMethod* cons, int i);
>  };
>
>  class JavaObjectThrowable : public JavaObject {
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> index 016c067..ed84bf1 100644
> --- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -1186,7 +1186,18 @@ JVM_GetClassName(JNIEnv *env, jclass cls) {
>
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassInterfaces(JNIEnv *env, jclass cls) {
> -  NYI();
> +  ArrayObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  ret = JavaObjectClass::getInterfaces(*(JavaObjectClass**)cls);
> +
> +  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jobject JNICALL
> @@ -1328,23 +1339,13 @@ JVM_GetComponentType(JNIEnv *env, jclass cls) {
>
>  JNIEXPORT jint JNICALL
>  JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
> -  JavaObject * Cl = 0;
> +  JavaObjectClass * Cl = 0;
>   llvm_gcroot(Cl, 0);
>   BEGIN_JNI_EXCEPTION
>
> -  Cl = *(JavaObject**)cls;
> -
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();;
> -
> -  jint res = cl->getAccess();
> +  Cl = *(JavaObjectClass**)cls;
>
> -  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
> -    // javac may put that flag to inner classes of enum classes.
> -    res &= ~ACC_ENUM;
> -  }
> -
> -  RETURN_FROM_JNI(res);
> +  RETURN_FROM_JNI(JavaObjectClass::getModifiers(Cl));
>
>   END_JNI_EXCEPTION
>
> @@ -1353,12 +1354,35 @@ JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
>
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass) {
> -  NYI();
> +  ArrayObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  // TODO: Verify boolean parameter here, assuming should default to true.
> +  ret = JavaObjectClass::getDeclaredClasses(*(JavaObjectClass**)ofClass,
> false);
> +
> +  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  JNIEXPORT jclass JNICALL
>  JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass) {
> -  NYI();
> +  JavaObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  ret = JavaObjectClass::getDeclaringClass(*(JavaObjectClass**)ofClass);
> +
> +  RETURN_FROM_JNI((jclass)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /* Generics support (JDK 1.5) */
> @@ -1370,7 +1394,18 @@ JVM_GetClassSignature(JNIEnv *env, jclass cls) {
>  /* Annotations support (JDK 1.5) */
>  JNIEXPORT jbyteArray JNICALL
>  JVM_GetClassAnnotations(JNIEnv *env, jclass cls) {
> -  NYI();
> +  ArrayObject* ret = 0;
> +  llvm_gcroot(ret, 0);
> +
> +  BEGIN_JNI_EXCEPTION
> +
> +  ret = JavaObjectClass::getDeclaredAnnotations(*(JavaObjectClass**)cls);
> +
> +  RETURN_FROM_JNI((jbyteArray)th->pushJNIRef(ret));
> +
> +  END_JNI_EXCEPTION
> +
> +  return 0;
>  }
>
>  /*
> @@ -1380,74 +1415,11 @@ JVM_GetClassAnnotations(JNIEnv *env, jclass cls) {
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean
> publicOnly) {
>    ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> -  JavaString* str = 0;
> -  JavaObject * Cl = 0;
> -  llvm_gcroot(Cl, 0);
>    llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
> -  llvm_gcroot(str, 0);
>
>    BEGIN_JNI_EXCEPTION
>
> -  Cl = *(JavaObject**)ofClass;
> -
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -  Classpath* upcalls = vm->upcalls;
> -
> -  if (cl->isArray() || cl->isPrimitive()) {
> -    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();
> -    JnjvmClassLoader* classLoader = cl->classLoader;
> -    uint32 size = 0;
> -
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> -         ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> -          (!publicOnly || pub)) {
> -        ++size;
> -      }
> -    }
> -
> -
> -    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> -         ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> -          (!publicOnly || pub)) {
> -        // TODO: check parameter types
> -        UserClass* Meth = vm->upcalls->newMethod;
> -        tmp = Meth->doNew(vm);
> -        str = vm->internalUTF8ToStr(meth->name);
> -        JavaObject * pArr = meth->getParameterTypes(classLoader);
> -        JavaObject * eArr = meth->getExceptionTypes(classLoader);
> -        JavaObject * retTy = meth->getReturnType(classLoader);
> -        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp,
> -          &Cl,          /* declaring class */
> -          &str,         /* name */
> -          &pArr,        /* parameter types */
> -          &retTy,       /* return type */
> -          &eArr,        /* exceptions */
> -          meth->access, /* modifiers */
> -          i,            /* slot */
> -          NULL,         /* signature */
> -          NULL,         /* annotations */
> -          NULL,         /* parameter annotations */
> -          NULL,         /* default annotations */
> -          i);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret = JavaObjectClass::getDeclaredMethods(*(JavaObjectClass**)ofClass,
> publicOnly);
>
>   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
>
> @@ -1459,85 +1431,12 @@ JVM_GetClassDeclaredMethods(JNIEnv *env,
> jclass ofClass, jboolean publicOnly) {
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean
> publicOnly) {
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> -  JavaString* name = 0;
> -  JavaObject*const*  type = 0;
> -  JavaString* sign = 0;
> -  JavaObject* annArray = 0;
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
> -  llvm_gcroot(name, 0);
> -  llvm_gcroot(type, 0);
> -  llvm_gcroot(sign, 0);
> -  llvm_gcroot(annArray, 0);
>
>   BEGIN_JNI_EXCEPTION
>
> -  JavaObject * Cl = *(JavaObject**)ofClass;
> -  llvm_gcroot(Cl, 0);
> -
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> -  if (!cl->isClass()) {
> -    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();
> -    uint32 size = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> -         ++i) {
> -      JavaField* field = &realCl->virtualFields[i];
> -      if (!publicOnly || isPublic(field->access)) {
> -        ++size;
> -      }
> -    }
> -
> +  ret = JavaObjectClass::getDeclaredFields(*(JavaObjectClass**)ofClass,
> publicOnly);
>
> -    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> -         ++i) {
> -      JavaField* field = &realCl->virtualFields[i];
> -      if (!publicOnly || isPublic(field->access)) {
> -        // TODO: check parameter types
> -        UserClass* Field = vm->upcalls->newField;
> -        tmp = Field->doNew(vm);
> -        name = vm->internalUTF8ToStr(field->name);
> -
> -        //type->Class
> -        UserCommonClass * fieldCl =
> field->getSignature()->assocClass(cl->classLoader);
> -        assert(fieldCl);
> -        type = fieldCl->getClassDelegateePtr(vm);
> -
> -        // TODO:Implement these!
> -        sign = NULL;
> -        annArray = NULL;
> -
> -        //Convert to string
> -
> -        /* java.reflect.Field(
> -         *   Class declaringClass,
> -         *   String name,
> -         *   Class type,
> -         *   int modifiers,
> -         *   int slot,
> -         *   String signature,
> -         *   byte[] annotations)
> -         */
> -        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp,
> -          &Cl,
> -          &name,
> -          type,
> -          field->access,
> -          i,
> -          sign,
> -          annArray);
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
>   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
>
>   END_JNI_EXCEPTION
> @@ -1548,62 +1447,11 @@ JVM_GetClassDeclaredFields(JNIEnv *env, jclass
> ofClass, jboolean publicOnly) {
>  JNIEXPORT jobjectArray JNICALL
>  JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass,
> jboolean publicOnly) {
>   ArrayObject* ret = 0;
> -  JavaObject* tmp = 0;
> -  JavaObject* Cl = 0;
> -  llvm_gcroot(Cl, 0);
>   llvm_gcroot(ret, 0);
> -  llvm_gcroot(tmp, 0);
>
>   BEGIN_JNI_EXCEPTION
>
> -  Cl = *(JavaObject**)ofClass;
> -
> -  Jnjvm* vm = JavaThread::get()->getJVM();
> -  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> -  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
> -    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
> -  } else {
> -    UserClass* realCl = cl->asClass();;
> -    JnjvmClassLoader* classLoader = cl->classLoader;
> -    uint32 size = 0;
> -
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> -          (!publicOnly || pub)) {
> -        ++size;
> -      }
> -    }
> -
> -    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size,
> vm);
> -
> -    sint32 index = 0;
> -    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> -      JavaMethod* meth = &realCl->virtualMethods[i];
> -      bool pub = isPublic(meth->access);
> -      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> -          (!publicOnly || pub)) {
> -        UserClass* Cons = vm->upcalls->newConstructor;
> -        JavaObject * pArr = meth->getParameterTypes(classLoader);
> -        JavaObject * eArr = meth->getExceptionTypes(classLoader);
> -        tmp = Cons->doNew(vm);
> -        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp,
> -          &Cl,          /* declaringClass */
> -          &pArr,        /* parameterTypes */
> -          &eArr,        /* checkedExceptions */
> -          meth->access, /* modifiers */
> -          i,            /* slot */
> -          NULL,         /* String signature */
> -          NULL,         /* annotations */
> -          NULL          /* parameterAnnotations */
> -        );
> -        ArrayObject::setElement(ret, tmp, index);
> -        index++;
> -      }
> -    }
> -  }
> +  ret =
> JavaObjectClass::getDeclaredConstructors(*(JavaObjectClass**)ofClass,
> publicOnly);
>
>   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
>
> diff --git a/lib/J3/ClassLib/Reflect.inc b/lib/J3/ClassLib/Reflect.inc
> new file mode 100644
> index 0000000..1d6effd
> --- /dev/null
> +++ b/lib/J3/ClassLib/Reflect.inc
> @@ -0,0 +1,255 @@
> +//===---- Reflect.inc - Shared reflecation code
> ---------------------------===//
> +//
> +//                            The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +#include "ClasspathReflect.h"
> +#include "JavaArray.h"
> +#include "JavaUpcalls.h"
> +#include "Jnjvm.h"
> +
> +namespace j3 {
> +
> +ArrayObject* JavaObjectClass::getDeclaredConstructors(JavaObjectClass*
> Cl, bool publicOnly) {
> +  ArrayObject* ret = 0;
> +  JavaObject* tmp = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(tmp, 0);
> +
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> +  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
> +    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
> +  } else {
> +    UserClass* realCl = cl->asClass();;
> +    JnjvmClassLoader* classLoader = cl->classLoader;
> +    uint32 size = 0;
> +
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> +          (!publicOnly || pub)) {
> +        ++size;
> +      }
> +    }
> +
> +    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size,
> vm);
> +
> +    sint32 index = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
> +          (!publicOnly || pub)) {
> +        tmp = JavaObjectConstructor::createFromInternalConstructor(meth,
> i);
> +        ArrayObject::setElement(ret, tmp, index);
> +        index++;
> +      }
> +    }
> +  }
> +
> +  return ret;
> +}
> +
> +ArrayObject* JavaObjectClass::getDeclaredMethods(JavaObjectClass* Cl,
> bool publicOnly) {
> +  ArrayObject* ret = 0;
> +  JavaObject* tmp = 0;
> +  JavaString* str = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(tmp, 0);
> +  llvm_gcroot(str, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +  Classpath* upcalls = vm->upcalls;
> +
> +  if (cl->isArray() || cl->isPrimitive()) {
> +    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
> +  } else {
> +    UserClass* realCl = cl->asClass();
> +    JnjvmClassLoader* classLoader = cl->classLoader;
> +    uint32 size = 0;
> +
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> +         ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> +          !(meth->name->equals(classLoader->bootstrapLoader->clinitName))
> &&
> +          (!publicOnly || pub)) {
> +        ++size;
> +      }
> +    }
> +
> +
> +    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
> +
> +    sint32 index = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualMethods +
> realCl->nbStaticMethods;
> +         ++i) {
> +      JavaMethod* meth = &realCl->virtualMethods[i];
> +      bool pub = isPublic(meth->access);
> +      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
> +          !(meth->name->equals(classLoader->bootstrapLoader->clinitName))
> &&
> +          (!publicOnly || pub)) {
> +        tmp = JavaObjectMethod::createFromInternalMethod(meth, i);
> +        ArrayObject::setElement(ret, tmp, index);
> +        index++;
> +      }
> +    }
> +  }
> +
> +  return ret;
> +}
> +
> +JavaObject* JavaObjectClass::getDeclaringClass(JavaObjectClass* Cl) {
> +  JavaObject* res = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(res, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> +
> +  if (cl) {
> +    cl->resolveInnerOuterClasses();
> +    UserClass* outer = cl->getOuterClass();
> +    if (outer) {
> +      res = outer->getClassDelegatee(vm);
> +    }
> +  }
> +
> +  return res;
> +}
> +
> +ArrayObject* JavaObjectClass::getDeclaredClasses(JavaObjectClass* Cl,
> bool publicOnly) {
> +  ArrayObject* result = 0;
> +  llvm_gcroot(result, 0);
> +  llvm_gcroot(Cl, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> +  if (cl) {
> +    cl->resolveInnerOuterClasses();
> +    UserClassArray* array = vm->upcalls->constructorArrayClass;
> +
> +    uint16 sizeArray = 0;
> +
> +    if (publicOnly) {
> +      for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
> +        UserClass* klass = cl->innerClasses[i];
> +        if (isPublic(klass->innerAccess)) ++sizeArray;
> +      }
> +    } else {
> +      sizeArray = cl->nbInnerClasses;
> +    }
> +
> +    result = (ArrayObject*)array->doNew(sizeArray, vm);
> +    int index = 0;
> +    for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
> +      UserClass* klass = cl->innerClasses[i];
> +      if (!publicOnly || isPublic(klass->innerAccess))
> +        ArrayObject::setElement(result, klass->getClassDelegatee(vm),
> index++);
> +    }
> +    assert(index == sizeArray);
> +  }
> +
> +  return result;
> +}
> +
> +ArrayObject* JavaObjectClass::getDeclaredFields(JavaObjectClass* Cl,
> bool publicOnly) {
> +  ArrayObject* ret = 0;
> +  JavaObject* tmp = 0;
> +  JavaString* name = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(ret, 0);
> +  llvm_gcroot(tmp, 0);
> +  llvm_gcroot(name, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> +  if (!cl->isClass()) {
> +    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
> +  } else {
> +    UserClass* realCl = cl->asClass();
> +    uint32 size = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> +         ++i) {
> +      JavaField* field = &realCl->virtualFields[i];
> +      if (!publicOnly || isPublic(field->access)) {
> +        ++size;
> +      }
> +    }
> +
> +    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
> +
> +    sint32 index = 0;
> +    for (uint32 i = 0; i < realCl->nbVirtualFields +
> realCl->nbStaticFields;
> +         ++i) {
> +      JavaField* field = &realCl->virtualFields[i];
> +      if (!publicOnly || isPublic(field->access)) {
> +        tmp = JavaObjectField::createFromInternalField(field, i);
> +        ArrayObject::setElement(ret, tmp, index);
> +        index++;
> +      }
> +    }
> +  }
> +
> +  return ret;
> +}
> +
> +ArrayObject* JavaObjectClass::getInterfaces(JavaObjectClass* Cl) {
> +  ArrayObject* res = 0;
> +  llvm_gcroot(Cl, 0);
> +  llvm_gcroot(res, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +  res =
> (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,
> vm);
> +
> +  for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
> +    UserClass* klass = cl->interfaces[i];
> +    ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
> +  }
> +
> +  return res;
> +}
> +
> +ArrayObject* JavaObjectClass::getDeclaredAnnotations(JavaObjectClass* Cl)
> {
> +  // TODO: Implement me (for now just returning empty array)
> +  ArrayObject* res = 0;
> +  llvm_gcroot(res, 0);
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
> +  res = (ArrayObject*)array->doNew(0, vm);
> +
> +  return res;
> +}
> +
> +int32_t JavaObjectClass::getModifiers(JavaObjectClass* Cl) {
> +  llvm_gcroot(Cl, 0);
> +  int32_t res;
> +
> +  Jnjvm* vm = JavaThread::get()->getJVM();
> +  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +  res = cl->getAccess();
> +
> +  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
> +    // javac may put that flag to inner classes of enum classes.
> +    res &= ~ACC_ENUM;
> +  }
> +
> +  return res;
> +}
> +
> +} // end namespace j3
> --
> 1.7.5.1
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111117/c8b41405/attachment.html>

From wdietz2 at illinois.edu  Thu Nov 17 20:40:48 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Fri, 18 Nov 2011 04:40:48 -0000
Subject: [vmkit-commits] [vmkit] r144974 - in /vmkit/trunk/lib/J3/ClassLib:
 GNUClasspath/ClasspathReflect.cpp GNUClasspath/ClasspathReflect.h
 GNUClasspath/ClasspathVMClass.inc OpenJDK/ClasspathReflect.cpp
 OpenJDK/ClasspathReflect.h OpenJDK/OpenJDK.inc Reflect.inc
Message-ID: <20111118044048.E90192A6C133@llvm.org>

Author: wdietz2
Date: Thu Nov 17 22:40:48 2011
New Revision: 144974

URL: http://llvm.org/viewvc/llvm-project?rev=144974&view=rev
Log:
Refactor reflection code into new Reflect.inc (shared) and ClasspathReflect

Also use this refactored layout to add implementations for the OpenJDK port

Added:
    vmkit/trunk/lib/J3/ClassLib/Reflect.inc
Modified:
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp?rev=144974&r1=144973&r2=144974&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp Thu Nov 17 22:40:48 2011
@@ -12,6 +12,8 @@
 #include "JavaObject.h"
 #include "JavaThread.h"
 
+#include "Reflect.inc"
+
 namespace j3 {
 
 JavaMethod* JavaObjectConstructor::getInternalMethod(JavaObjectConstructor* self) {
@@ -27,4 +29,51 @@
   return &(cls->asClass()->virtualMethods[self->slot]);
 }
 
+JavaObjectConstructor* JavaObjectConstructor::createFromInternalConstructor(JavaMethod * cons, int i) {
+  JavaObjectConstructor* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* Cons = vm->upcalls->newConstructor;
+  ret = (JavaObjectConstructor*)Cons->doNew(vm);
+  JavaObject* const* Cl = cons->classDef->getDelegateePtr();
+  vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
+    Cl, i);
+
+  return ret;
+}
+
+JavaObjectMethod* JavaObjectMethod::createFromInternalMethod(JavaMethod* meth, int i) {
+  JavaObjectMethod* ret = 0;
+  JavaString* str = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(str, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* Meth = vm->upcalls->newMethod;
+  ret = (JavaObjectMethod*)Meth->doNew(vm);
+  str = vm->internalUTF8ToStr(meth->name);
+  JavaObject* const* Cl = meth->classDef->getDelegateePtr();
+  vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
+    Cl, &str, i);
+
+  return ret;
+}
+
+JavaObjectField* JavaObjectField::createFromInternalField(JavaField* field, int i) {
+  JavaObjectField* ret = 0;
+  JavaString* name = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(name, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* Field = vm->upcalls->newField;
+  ret = (JavaObjectField*)Field->doNew(vm);
+  name = vm->internalUTF8ToStr(field->name);
+  JavaObject* const* Cl = field->classDef->getDelegateePtr();
+  vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
+    Cl, &name, i);
+
+  return ret;
+}
 }

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h?rev=144974&r1=144973&r2=144974&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h Thu Nov 17 22:40:48 2011
@@ -60,6 +60,15 @@
       if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
     }
   }
+
+  static ArrayObject* getDeclaredAnnotations(JavaObjectClass* Cl);
+  static ArrayObject* getDeclaredClasses(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getDeclaredConstructors(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getDeclaredFields(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getDeclaredMethods(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getInterfaces(JavaObjectClass* Cl);
+  static JavaObject* getDeclaringClass(JavaObjectClass* Cl);
+  static int getModifiers(JavaObjectClass* Cl);
 };
 
 class JavaObjectField : public JavaObject {
@@ -88,6 +97,7 @@
     return cls->asClass();
   }
 
+  static JavaObjectField* createFromInternalField(JavaField* field, int i);
 };
 
 class JavaObjectMethod : public JavaObject {
@@ -112,6 +122,7 @@
     return cls->asClass();
   }
 
+  static JavaObjectMethod* createFromInternalMethod(JavaMethod* meth, int i);
 };
 
 class JavaObjectConstructor : public JavaObject {
@@ -133,6 +144,7 @@
     return cls->asClass();
   }
 
+  static JavaObjectConstructor* createFromInternalConstructor(JavaMethod* cons, int i);
 };
 
 class JavaObjectVMThread : public JavaObject {

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc?rev=144974&r1=144973&r2=144974&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc Thu Nov 17 22:40:48 2011
@@ -86,48 +86,12 @@
 jboolean publicOnly) {
 
   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
   llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
 
   BEGIN_NATIVE_EXCEPTION(0)
 
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
-  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
-    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();;
-    JnjvmClassLoader* classLoader = cl->classLoader;
-    uint32 size = 0;
-    
-    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (meth->name->equals(classLoader->bootstrapLoader->initName) && 
-          (!publicOnly || pub)) {
-        ++size;
-      }
-    }
-  
-    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (meth->name->equals(classLoader->bootstrapLoader->initName) && 
-          (!publicOnly || pub)) {
-        UserClass* Cons = vm->upcalls->newConstructor;
-        tmp = Cons->doNew(vm);
-        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp, &Cl, i);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = JavaObjectClass::getDeclaredConstructors((JavaObjectClass*)Cl, publicOnly);
 
   END_NATIVE_EXCEPTION
 
@@ -143,58 +107,12 @@
 jboolean publicOnly) {
 
   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaString* str = 0;
   llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
-  llvm_gcroot(str, 0);
 
   BEGIN_NATIVE_EXCEPTION(0)
 
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-  Classpath* upcalls = vm->upcalls;
-
-  if (cl->isArray() || cl->isPrimitive()) {
-    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();
-    JnjvmClassLoader* classLoader = cl->classLoader;
-    uint32 size = 0;
-
-    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
-         ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) && 
-          !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) && 
-          (!publicOnly || pub)) {
-        ++size; 
-      }
-    }
-
-    
-    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
-         ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) && 
-          !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) && 
-          (!publicOnly || pub)) {
-        // TODO: check parameter types
-        UserClass* Meth = vm->upcalls->newMethod;
-        tmp = Meth->doNew(vm);
-        str = vm->internalUTF8ToStr(meth->name);
-        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, &Cl, &str, i);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = JavaObjectClass::getDeclaredMethods((JavaObjectClass*)Cl, publicOnly);
 
   END_NATIVE_EXCEPTION
 
@@ -214,14 +132,7 @@
 
   BEGIN_NATIVE_EXCEPTION(0)
 
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-  res = cl->getAccess();
-
-  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
-    // javac may put that flag to inner classes of enum classes. 
-    res &= ~ACC_ENUM;
-  }
+  res = JavaObjectClass::getModifiers((JavaObjectClass*)Cl);
 
   END_NATIVE_EXCEPTION
   return res;
@@ -428,49 +339,12 @@
 JavaObject* Cl, jboolean publicOnly) {
 
   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaString* name = 0;
   llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
-  llvm_gcroot(name, 0);
 
   BEGIN_NATIVE_EXCEPTION(0)
 
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
-  if (!cl->isClass()) {
-    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass(); 
-    uint32 size = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
-         ++i) {
-      JavaField* field = &realCl->virtualFields[i];
-      if (!publicOnly || isPublic(field->access)) {
-        ++size;
-      }
-    }
-
-
-    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
-         ++i) {
-      JavaField* field = &realCl->virtualFields[i];
-      if (!publicOnly || isPublic(field->access)) {
-        // TODO: check parameter types
-        UserClass* Field = vm->upcalls->newField;
-        tmp = Field->doNew(vm);
-        name = vm->internalUTF8ToStr(field->name);
-        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, &Cl, &name, i);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = JavaObjectClass::getDeclaredFields((JavaObjectClass*)Cl, publicOnly);
 
   END_NATIVE_EXCEPTION
 
@@ -490,14 +364,7 @@
 
   BEGIN_NATIVE_EXCEPTION(0)
 
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-  res = (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces, vm);
-
-  for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
-    UserClass* klass = cl->interfaces[i];
-    ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
-  }
+  res = JavaObjectClass::getInterfaces((JavaObjectClass*)Cl);
 
   END_NATIVE_EXCEPTION
 
@@ -518,16 +385,7 @@
 
   BEGIN_NATIVE_EXCEPTION(0)
 
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
-
-  if (cl) {
-    cl->resolveInnerOuterClasses();
-    UserClass* outer = cl->getOuterClass();
-    if (outer) {
-      res = outer->getClassDelegatee(vm);
-    }
-  }
+  res = JavaObjectClass::getDeclaringClass((JavaObjectClass*)Cl);
 
   END_NATIVE_EXCEPTION
 
@@ -548,33 +406,7 @@
 
   BEGIN_NATIVE_EXCEPTION(0)
 
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
-  if (cl) {
-    cl->resolveInnerOuterClasses();
-    UserClassArray* array = vm->upcalls->constructorArrayClass;
-    
-    uint16 sizeArray = 0;
-
-    if (publicOnly) {
-      for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
-        UserClass* klass = cl->innerClasses[i];
-        if (isPublic(klass->innerAccess)) ++sizeArray;
-      }
-    } else {
-      sizeArray = cl->nbInnerClasses;
-    }
-
-    result = (ArrayObject*)array->doNew(sizeArray, vm);
-    int index = 0;
-    for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
-      UserClass* klass = cl->innerClasses[i];
-      if (!publicOnly || isPublic(klass->innerAccess))
-        ArrayObject::setElement(result, klass->getClassDelegatee(vm), index++); 
-    }
-    assert(index == sizeArray);
-  }
-  
+  result = JavaObjectClass::getDeclaredClasses((JavaObjectClass*)Cl, publicOnly);
 
   END_NATIVE_EXCEPTION
 
@@ -603,16 +435,14 @@
 #endif
 JavaObject* Cl) {
   // TODO implement me
-  
+
   ArrayObject* res = 0;
   llvm_gcroot(res, 0);
   llvm_gcroot(Cl, 0);
-  
+
   BEGIN_NATIVE_EXCEPTION(0)
 
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
-  res = (ArrayObject*)array->doNew(0, vm);
+  res = JavaObjectClass::getDeclaredAnnotations((JavaObjectClass*)Cl);
 
   END_NATIVE_EXCEPTION
 
@@ -641,5 +471,4 @@
   return res;
 }
 
-
 }

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp?rev=144974&r1=144973&r2=144974&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp Thu Nov 17 22:40:48 2011
@@ -8,12 +8,14 @@
 //===----------------------------------------------------------------------===//
 
 #include "ClasspathReflect.h"
+#include "JavaArray.h"
 #include "JavaClass.h"
 #include "JavaObject.h"
 #include "JavaThread.h"
-#include "Jnjvm.h"
+#include "JavaTypes.h"
 #include "JavaUpcalls.h"
-#include "JavaArray.h"
+#include "Jnjvm.h"
+#include "Reflect.inc"
 
 namespace j3 {
 
@@ -80,4 +82,117 @@
   return size;
 }
 
+JavaObjectConstructor* JavaObjectConstructor::createFromInternalConstructor(JavaMethod * cons, int i) {
+  JavaObjectConstructor* ret = 0;
+  JavaObject* pArr = 0;
+  JavaObject* eArr = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(pArr, 0);
+  llvm_gcroot(eArr, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader * classLoader = cons->classDef->classLoader;
+
+  UserClass* Cons = vm->upcalls->newConstructor;
+  pArr = cons->getParameterTypes(classLoader);
+  eArr = cons->getExceptionTypes(classLoader);
+  ret = (JavaObjectConstructor*)Cons->doNew(vm);
+  JavaObject* const* Cl = cons->classDef->getDelegateePtr();
+  vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
+    Cl,           /* declaringClass */
+    &pArr,        /* parameterTypes */
+    &eArr,        /* checkedExceptions */
+    cons->access, /* modifiers */
+    i,            /* slot */
+    NULL,         /* String signature */
+    NULL,         /* annotations */
+    NULL          /* parameterAnnotations */
+  );
+
+  return ret;
+}
+
+JavaObjectMethod* JavaObjectMethod::createFromInternalMethod(JavaMethod* meth, int i) {
+  JavaObjectMethod* ret = 0;
+  JavaString* str = 0;
+  JavaObject* pArr = 0;
+  JavaObject* eArr = 0;
+  JavaObject* retTy = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(str, 0);
+  llvm_gcroot(pArr, 0);
+  llvm_gcroot(eArr, 0);
+  llvm_gcroot(retTy, 0);
+
+  // TODO: check parameter types
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  JnjvmClassLoader * classLoader = meth->classDef->classLoader;
+
+  UserClass* Meth = vm->upcalls->newMethod;
+  ret = (JavaObjectMethod*)Meth->doNew(vm);
+  str = vm->internalUTF8ToStr(meth->name);
+  pArr = meth->getParameterTypes(classLoader);
+  eArr = meth->getExceptionTypes(classLoader);
+  retTy = meth->getReturnType(classLoader);
+  JavaObject* const* Cl = meth->classDef->getClassDelegateePtr(vm);
+  vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
+    Cl,           /* declaring class */
+    &str,         /* name */
+    &pArr,        /* parameter types */
+    &retTy,       /* return type */
+    &eArr,        /* exceptions */
+    meth->access, /* modifiers */
+    i,            /* slot */
+    NULL,         /* signature */
+    NULL,         /* annotations */
+    NULL,         /* parameter annotations */
+    NULL);        /* default annotations */
+
+  return ret;
+}
+
+JavaObjectField* JavaObjectField::createFromInternalField(JavaField* field, int i) {
+  JavaObjectField* ret = 0;
+  JavaString* name = 0;
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(name, 0);
+
+  // TODO: check parameter types
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* Field = vm->upcalls->newField;
+  ret = (JavaObjectField*)Field->doNew(vm);
+  name = vm->internalUTF8ToStr(field->name);
+
+  //type->Class
+  JnjvmClassLoader* loader = field->classDef->classLoader;
+  UserCommonClass * fieldCl = field->getSignature()->assocClass(loader);
+  assert(fieldCl);
+  JavaObject* const* type = fieldCl->getClassDelegateePtr(vm);
+  JavaObject* const* Cl = field->classDef->getClassDelegateePtr(vm);
+
+  // TODO:Implement these!
+  JavaObject** sign = NULL;
+  JavaObject** annArray = NULL;
+
+  /* java.reflect.Field(
+  *   Class declaringClass,
+  *   String name,
+  *   Class type,
+  *   int modifiers,
+  *   int slot,
+  *   String signature,
+  *   byte[] annotations)
+  */
+  vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
+    Cl,
+    &name,
+    type,
+    field->access,
+    i,
+    sign,
+    annArray);
+
+  return ret;
 }
+
+} // end namespace j3

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h?rev=144974&r1=144973&r2=144974&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h Thu Nov 17 22:40:48 2011
@@ -92,6 +92,15 @@
       if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
     }
   }
+
+  static ArrayObject* getDeclaredAnnotations(JavaObjectClass* Cl);
+  static ArrayObject* getDeclaredClasses(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getDeclaredConstructors(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getDeclaredFields(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getDeclaredMethods(JavaObjectClass* Cl, bool publicOnly);
+  static ArrayObject* getInterfaces(JavaObjectClass* Cl);
+  static JavaObject* getDeclaringClass(JavaObjectClass* Cl);
+  static int getModifiers(JavaObjectClass* Cl);
 };
 
 class JavaObjectField : public JavaObject {
@@ -143,6 +152,7 @@
     return cls->asClass();
   }
 
+  static JavaObjectField* createFromInternalField(JavaField* field, int i);
 };
 
 class JavaObjectMethod : public JavaObject {
@@ -196,6 +206,7 @@
     return cls->asClass();
   }
 
+  static JavaObjectMethod* createFromInternalMethod(JavaMethod* meth, int i);
 };
 
 class JavaObjectConstructor : public JavaObject {
@@ -240,6 +251,7 @@
     return cls->asClass();
   }
 
+  static JavaObjectConstructor* createFromInternalConstructor(JavaMethod* cons, int i);
 };
 
 class JavaObjectThrowable : public JavaObject {

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=144974&r1=144973&r2=144974&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Thu Nov 17 22:40:48 2011
@@ -1186,7 +1186,18 @@
 
 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassInterfaces(JNIEnv *env, jclass cls) {
-  NYI();
+  ArrayObject* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  ret = JavaObjectClass::getInterfaces(*(JavaObjectClass**)cls);
+
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jobject JNICALL
@@ -1328,23 +1339,13 @@
 
 JNIEXPORT jint JNICALL
 JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
-  JavaObject * Cl = 0;
+  JavaObjectClass * Cl = 0;
   llvm_gcroot(Cl, 0);
   BEGIN_JNI_EXCEPTION
 
-  Cl = *(JavaObject**)cls;
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();;
+  Cl = *(JavaObjectClass**)cls;
 
-  jint res = cl->getAccess();
-
-  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
-    // javac may put that flag to inner classes of enum classes.
-    res &= ~ACC_ENUM;
-  }
-
-  RETURN_FROM_JNI(res);
+  RETURN_FROM_JNI(JavaObjectClass::getModifiers(Cl));
 
   END_JNI_EXCEPTION
 
@@ -1353,12 +1354,35 @@
 
 JNIEXPORT jobjectArray JNICALL
 JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass) {
-  NYI();
+  ArrayObject* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  // TODO: Verify boolean parameter here, assuming should default to true.
+  ret = JavaObjectClass::getDeclaredClasses(*(JavaObjectClass**)ofClass, false);
+
+  RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 JNIEXPORT jclass JNICALL
 JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass) {
-  NYI();
+  JavaObject* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  ret = JavaObjectClass::getDeclaringClass(*(JavaObjectClass**)ofClass);
+
+  RETURN_FROM_JNI((jclass)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /* Generics support (JDK 1.5) */
@@ -1370,7 +1394,18 @@
 /* Annotations support (JDK 1.5) */
 JNIEXPORT jbyteArray JNICALL
 JVM_GetClassAnnotations(JNIEnv *env, jclass cls) {
-  NYI();
+  ArrayObject* ret = 0;
+  llvm_gcroot(ret, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  ret = JavaObjectClass::getDeclaredAnnotations(*(JavaObjectClass**)cls);
+
+  RETURN_FROM_JNI((jbyteArray)th->pushJNIRef(ret));
+
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /*
@@ -1380,74 +1415,11 @@
 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaString* str = 0;
-  JavaObject * Cl = 0;
-  llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
-  llvm_gcroot(str, 0);
 
   BEGIN_JNI_EXCEPTION
 
-  Cl = *(JavaObject**)ofClass;
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-  Classpath* upcalls = vm->upcalls;
-
-  if (cl->isArray() || cl->isPrimitive()) {
-    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();
-    JnjvmClassLoader* classLoader = cl->classLoader;
-    uint32 size = 0;
-
-    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
-         ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
-          (!publicOnly || pub)) {
-        ++size;
-      }
-    }
-
-
-    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
-         ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
-          (!publicOnly || pub)) {
-        // TODO: check parameter types
-        UserClass* Meth = vm->upcalls->newMethod;
-        tmp = Meth->doNew(vm);
-        str = vm->internalUTF8ToStr(meth->name);
-        JavaObject * pArr = meth->getParameterTypes(classLoader);
-        JavaObject * eArr = meth->getExceptionTypes(classLoader);
-        JavaObject * retTy = meth->getReturnType(classLoader);
-        upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp,
-          &Cl,          /* declaring class */
-          &str,         /* name */
-          &pArr,        /* parameter types */
-          &retTy,       /* return type */
-          &eArr,        /* exceptions */
-          meth->access, /* modifiers */
-          i,            /* slot */
-          NULL,         /* signature */
-          NULL,         /* annotations */
-          NULL,         /* parameter annotations */
-          NULL,         /* default annotations */
-          i);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = JavaObjectClass::getDeclaredMethods(*(JavaObjectClass**)ofClass, publicOnly);
 
   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
 
@@ -1459,85 +1431,12 @@
 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaString* name = 0;
-  JavaObject*const*  type = 0;
-  JavaString* sign = 0;
-  JavaObject* annArray = 0;
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
-  llvm_gcroot(name, 0);
-  llvm_gcroot(type, 0);
-  llvm_gcroot(sign, 0);
-  llvm_gcroot(annArray, 0);
 
   BEGIN_JNI_EXCEPTION
 
-  JavaObject * Cl = *(JavaObject**)ofClass;
-  llvm_gcroot(Cl, 0);
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  ret = JavaObjectClass::getDeclaredFields(*(JavaObjectClass**)ofClass, publicOnly);
 
-  if (!cl->isClass()) {
-    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();
-    uint32 size = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
-         ++i) {
-      JavaField* field = &realCl->virtualFields[i];
-      if (!publicOnly || isPublic(field->access)) {
-        ++size;
-      }
-    }
-
-
-    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
-         ++i) {
-      JavaField* field = &realCl->virtualFields[i];
-      if (!publicOnly || isPublic(field->access)) {
-        // TODO: check parameter types
-        UserClass* Field = vm->upcalls->newField;
-        tmp = Field->doNew(vm);
-        name = vm->internalUTF8ToStr(field->name);
-
-        //type->Class
-        UserCommonClass * fieldCl = field->getSignature()->assocClass(cl->classLoader);
-        assert(fieldCl);
-        type = fieldCl->getClassDelegateePtr(vm);
-
-        // TODO:Implement these!
-        sign = NULL;
-        annArray = NULL;
-
-        //Convert to string
-
-        /* java.reflect.Field(
-         *   Class declaringClass,
-         *   String name,
-         *   Class type,
-         *   int modifiers,
-         *   int slot,
-         *   String signature,
-         *   byte[] annotations)
-         */
-        vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp,
-          &Cl,
-          &name,
-          type,
-          field->access,
-          i,
-          sign,
-          annArray);
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
 
   END_JNI_EXCEPTION
@@ -1548,62 +1447,11 @@
 JNIEXPORT jobjectArray JNICALL
 JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
   ArrayObject* ret = 0;
-  JavaObject* tmp = 0;
-  JavaObject* Cl = 0;
-  llvm_gcroot(Cl, 0);
   llvm_gcroot(ret, 0);
-  llvm_gcroot(tmp, 0);
 
   BEGIN_JNI_EXCEPTION
 
-  Cl = *(JavaObject**)ofClass;
-
-  Jnjvm* vm = JavaThread::get()->getJVM();
-  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
-  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
-    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
-  } else {
-    UserClass* realCl = cl->asClass();;
-    JnjvmClassLoader* classLoader = cl->classLoader;
-    uint32 size = 0;
-
-    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
-          (!publicOnly || pub)) {
-        ++size;
-      }
-    }
-
-    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
-
-    sint32 index = 0;
-    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
-      JavaMethod* meth = &realCl->virtualMethods[i];
-      bool pub = isPublic(meth->access);
-      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
-          (!publicOnly || pub)) {
-        UserClass* Cons = vm->upcalls->newConstructor;
-        JavaObject * pArr = meth->getParameterTypes(classLoader);
-        JavaObject * eArr = meth->getExceptionTypes(classLoader);
-        tmp = Cons->doNew(vm);
-        vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp,
-          &Cl,          /* declaringClass */
-          &pArr,        /* parameterTypes */
-          &eArr,        /* checkedExceptions */
-          meth->access, /* modifiers */
-          i,            /* slot */
-          NULL,         /* String signature */
-          NULL,         /* annotations */
-          NULL          /* parameterAnnotations */
-        );
-        ArrayObject::setElement(ret, tmp, index);
-        index++;
-      }
-    }
-  }
+  ret = JavaObjectClass::getDeclaredConstructors(*(JavaObjectClass**)ofClass, publicOnly);
 
   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
 

Added: vmkit/trunk/lib/J3/ClassLib/Reflect.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/Reflect.inc?rev=144974&view=auto
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/Reflect.inc (added)
+++ vmkit/trunk/lib/J3/ClassLib/Reflect.inc Thu Nov 17 22:40:48 2011
@@ -0,0 +1,255 @@
+//===---- Reflect.inc - Shared reflecation code ---------------------------===//
+//
+//                            The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClasspathReflect.h"
+#include "JavaArray.h"
+#include "JavaUpcalls.h"
+#include "Jnjvm.h"
+
+namespace j3 {
+
+ArrayObject* JavaObjectClass::getDeclaredConstructors(JavaObjectClass* Cl, bool publicOnly) {
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
+    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();;
+    JnjvmClassLoader* classLoader = cl->classLoader;
+    uint32 size = 0;
+
+    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+          (!publicOnly || pub)) {
+        ++size;
+      }
+    }
+
+    ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+          (!publicOnly || pub)) {
+        tmp = JavaObjectConstructor::createFromInternalConstructor(meth, i);
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+
+  return ret;
+}
+
+ArrayObject* JavaObjectClass::getDeclaredMethods(JavaObjectClass* Cl, bool publicOnly) {
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  JavaString* str = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+  llvm_gcroot(str, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  Classpath* upcalls = vm->upcalls;
+
+  if (cl->isArray() || cl->isPrimitive()) {
+    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();
+    JnjvmClassLoader* classLoader = cl->classLoader;
+    uint32 size = 0;
+
+    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+         ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+          !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
+          (!publicOnly || pub)) {
+        ++size;
+      }
+    }
+
+
+    ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+         ++i) {
+      JavaMethod* meth = &realCl->virtualMethods[i];
+      bool pub = isPublic(meth->access);
+      if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+          !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
+          (!publicOnly || pub)) {
+        tmp = JavaObjectMethod::createFromInternalMethod(meth, i);
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+
+  return ret;
+}
+
+JavaObject* JavaObjectClass::getDeclaringClass(JavaObjectClass* Cl) {
+  JavaObject* res = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(res, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
+
+  if (cl) {
+    cl->resolveInnerOuterClasses();
+    UserClass* outer = cl->getOuterClass();
+    if (outer) {
+      res = outer->getClassDelegatee(vm);
+    }
+  }
+
+  return res;
+}
+
+ArrayObject* JavaObjectClass::getDeclaredClasses(JavaObjectClass* Cl, bool publicOnly) {
+  ArrayObject* result = 0;
+  llvm_gcroot(result, 0);
+  llvm_gcroot(Cl, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
+  if (cl) {
+    cl->resolveInnerOuterClasses();
+    UserClassArray* array = vm->upcalls->constructorArrayClass;
+
+    uint16 sizeArray = 0;
+
+    if (publicOnly) {
+      for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
+        UserClass* klass = cl->innerClasses[i];
+        if (isPublic(klass->innerAccess)) ++sizeArray;
+      }
+    } else {
+      sizeArray = cl->nbInnerClasses;
+    }
+
+    result = (ArrayObject*)array->doNew(sizeArray, vm);
+    int index = 0;
+    for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
+      UserClass* klass = cl->innerClasses[i];
+      if (!publicOnly || isPublic(klass->innerAccess))
+        ArrayObject::setElement(result, klass->getClassDelegatee(vm), index++);
+    }
+    assert(index == sizeArray);
+  }
+
+  return result;
+}
+
+ArrayObject* JavaObjectClass::getDeclaredFields(JavaObjectClass* Cl, bool publicOnly) {
+  ArrayObject* ret = 0;
+  JavaObject* tmp = 0;
+  JavaString* name = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(ret, 0);
+  llvm_gcroot(tmp, 0);
+  llvm_gcroot(name, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+  if (!cl->isClass()) {
+    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
+  } else {
+    UserClass* realCl = cl->asClass();
+    uint32 size = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+         ++i) {
+      JavaField* field = &realCl->virtualFields[i];
+      if (!publicOnly || isPublic(field->access)) {
+        ++size;
+      }
+    }
+
+    ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
+
+    sint32 index = 0;
+    for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+         ++i) {
+      JavaField* field = &realCl->virtualFields[i];
+      if (!publicOnly || isPublic(field->access)) {
+        tmp = JavaObjectField::createFromInternalField(field, i);
+        ArrayObject::setElement(ret, tmp, index);
+        index++;
+      }
+    }
+  }
+
+  return ret;
+}
+
+ArrayObject* JavaObjectClass::getInterfaces(JavaObjectClass* Cl) {
+  ArrayObject* res = 0;
+  llvm_gcroot(Cl, 0);
+  llvm_gcroot(res, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  res = (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces, vm);
+
+  for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
+    UserClass* klass = cl->interfaces[i];
+    ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
+  }
+
+  return res;
+}
+
+ArrayObject* JavaObjectClass::getDeclaredAnnotations(JavaObjectClass* Cl) {
+  // TODO: Implement me (for now just returning empty array)
+  ArrayObject* res = 0;
+  llvm_gcroot(res, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
+  res = (ArrayObject*)array->doNew(0, vm);
+
+  return res;
+}
+
+int32_t JavaObjectClass::getModifiers(JavaObjectClass* Cl) {
+  llvm_gcroot(Cl, 0);
+  int32_t res;
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+  res = cl->getAccess();
+
+  if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
+    // javac may put that flag to inner classes of enum classes.
+    res &= ~ACC_ENUM;
+  }
+
+  return res;
+}
+
+} // end namespace j3




From nicolas.geoffray at lip6.fr  Sun Nov 20 14:08:33 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Sun, 20 Nov 2011 22:08:33 -0000
Subject: [vmkit-commits] [vmkit] r145016 - in /vmkit/trunk/lib:
 J3/Compiler/JavaJIT.cpp J3/Compiler/JavaJIT.h
 J3/Compiler/JavaJITOpcodes.cpp J3/Compiler/JavaLLVMCompiler.cpp
 Mvm/Compiler/LoopSafePoints.cpp
Message-ID: <20111120220833.5A9A22A6C134@llvm.org>

Author: geoffray
Date: Sun Nov 20 16:08:32 2011
New Revision: 145016

URL: http://llvm.org/viewvc/llvm-project?rev=145016&view=rev
Log:
Remove the non-working safepoint loop pass (where objects could end up still being live in registers during the safe point), in favor of a back edge recognition in Java opcodes.


Removed:
    vmkit/trunk/lib/Mvm/Compiler/LoopSafePoints.cpp
Modified:
    vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
    vmkit/trunk/lib/J3/Compiler/JavaJIT.h
    vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp
    vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp

Modified: vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp?rev=145016&r1=145015&r2=145016&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp Sun Nov 20 16:08:32 2011
@@ -75,6 +75,23 @@
   return true;
 }
 
+void JavaJIT::checkYieldPoint() {
+  if (!TheCompiler->useCooperativeGC()) return;
+  Value* YieldPtr = getDoYieldPtr(getMutatorThreadPtr());
+
+  Value* Yield = new LoadInst(YieldPtr, "", currentBlock);
+
+  BasicBlock* continueBlock = createBasicBlock("After safe point");
+  BasicBlock* yieldBlock = createBasicBlock("In safe point");
+  BranchInst::Create(yieldBlock, continueBlock, Yield, currentBlock);
+
+  currentBlock = yieldBlock;
+  CallInst::Create(intrinsics->conditionalSafePoint, "", currentBlock);
+  BranchInst::Create(continueBlock, currentBlock);
+
+  currentBlock = continueBlock;
+}
+
 bool JavaJIT::canBeInlined(JavaMethod* meth, bool customizing) {
   if (inlineMethods[meth]) return false;
   if (isSynchro(meth->access)) return false;
@@ -1099,27 +1116,13 @@
   if (returnType != Type::getVoidTy(*llvmContext)) {
     endNode = llvm::PHINode::Create(returnType, 0, "", endBlock);
   }
+
+  checkYieldPoint();
   
   if (isSynchro(compilingMethod->access)) {
     beginSynchronize();
   }
   
-  if (TheCompiler->useCooperativeGC()) {
-    Value* YieldPtr = getDoYieldPtr(getMutatorThreadPtr());
-
-    Value* Yield = new LoadInst(YieldPtr, "", currentBlock);
-
-    BasicBlock* continueBlock = createBasicBlock("After safe point");
-    BasicBlock* yieldBlock = createBasicBlock("In safe point");
-    BranchInst::Create(yieldBlock, continueBlock, Yield, currentBlock);
-
-    currentBlock = yieldBlock;
-    CallInst::Create(intrinsics->conditionalSafePoint, "", currentBlock);
-    BranchInst::Create(continueBlock, currentBlock);
-
-    currentBlock = continueBlock;
-  }
-  
   if (TheCompiler->hasExceptionsEnabled() &&
       !mvm::System::SupportsHardwareStackOverflow()) {
     // Variables have been allocated and the lock has been taken. Do the stack

Modified: vmkit/trunk/lib/J3/Compiler/JavaJIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJIT.h?rev=145016&r1=145015&r2=145016&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJIT.h (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJIT.h Sun Nov 20 16:08:32 2011
@@ -64,6 +64,9 @@
   /// stack - The stack at this location if there is a new block
   ///
   std::vector<MetaInfo> stack;
+
+  /// backEdge - If this block is a back edge.
+  bool backEdge;
 };
 
 /// JavaJIT - The compilation engine of J3. Parses the bycode and returns

Modified: vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp?rev=145016&r1=145015&r2=145016&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp Sun Nov 20 16:08:32 2011
@@ -142,6 +142,10 @@
         stack = opinfo->stack;
         currentStackIndex = stack.size();
       }
+
+      if (opinfo->backEdge) {
+        checkYieldPoint();
+      }
     }
 
     currentExceptionBlock = opinfo->exceptionBlock;
@@ -2572,12 +2576,15 @@
       case IF_ICMPLE :
       case IF_ACMPEQ :
       case IF_ACMPNE :
-      case GOTO : {
+      case GOTO :
+      case IFNULL :
+      case IFNONNULL : {
         uint32 tmp = i;
         uint16 index = tmp + reader.readU2();
+        if (index < i) opcodeInfos[index].backEdge = true;
         i += 2;
         if (!(opcodeInfos[index].newBlock))
-          opcodeInfos[index].newBlock = createBasicBlock("GOTO or IF*");
+          opcodeInfos[index].newBlock = createBasicBlock("");
         break;
       }
       
@@ -2716,17 +2723,6 @@
         wide = true;
         break;
 
-      case IFNULL :
-      case IFNONNULL : {
-        uint32 tmp = i;
-        uint16 index = tmp + reader.readU2();
-        i += 2;
-        if (!(opcodeInfos[index].newBlock))
-          opcodeInfos[index].newBlock = createBasicBlock("true IF*NULL");
-        break;
-      }
-
-
       default : {
         fprintf(stderr, "I haven't verified your class file and it's malformed:"
                     " unknown bytecode %d in %s.%s!\n", bytecode,

Modified: vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp?rev=145016&r1=145015&r2=145016&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp Sun Nov 20 16:08:32 2011
@@ -21,9 +21,10 @@
 
 #include "j3/JavaLLVMCompiler.h"
 
-using namespace j3;
 using namespace llvm;
 
+namespace j3 {
+
 JavaLLVMCompiler::JavaLLVMCompiler(const std::string& str) :
   TheModule(new llvm::Module(str, *(new LLVMContext()))),
   DebugFactory(new DIBuilder(*TheModule)) {
@@ -103,26 +104,18 @@
   delete Context;
 }
 
-namespace mvm {
-  llvm::LoopPass* createLoopSafePointsPass();
-}
-
-namespace j3 {
-  llvm::FunctionPass* createLowerConstantCallsPass(JavaLLVMCompiler* I);
-}
+llvm::FunctionPass* createLowerConstantCallsPass(JavaLLVMCompiler* I);
 
 void JavaLLVMCompiler::addJavaPasses() {
   JavaNativeFunctionPasses = new FunctionPassManager(TheModule);
   JavaNativeFunctionPasses->add(new TargetData(TheModule));
+
   J3FunctionPasses = new FunctionPassManager(TheModule);
   J3FunctionPasses->add(createLowerConstantCallsPass(this));
   
-  if (cooperativeGC)
-    J3FunctionPasses->add(mvm::createLoopSafePointsPass());
-
-  // Add other passes after the loop pass, because safepoints may move objects.
-  // Moving objects disable many optimizations.
   JavaFunctionPasses = new FunctionPassManager(TheModule);
   JavaFunctionPasses->add(new TargetData(TheModule));
   mvm::MvmModule::addCommandLinePasses(JavaFunctionPasses);
 }
+
+} // end namespace j3

Removed: vmkit/trunk/lib/Mvm/Compiler/LoopSafePoints.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/LoopSafePoints.cpp?rev=145015&view=auto
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/LoopSafePoints.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/LoopSafePoints.cpp (removed)
@@ -1,117 +0,0 @@
-//===------- LoopSafePoints.cpp - Add safe points in loop headers ---------===//
-//
-//                     The VMKit project
-//
-// This file is distributed under the University of Illinois Open Source 
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-
-#include "llvm/Module.h"
-#include "llvm/Analysis/LoopPass.h"
-#include "llvm/Support/CallSite.h"
-#include "llvm/Support/Compiler.h"
-
-using namespace llvm;
-
-namespace {
-
-  class LoopSafePoints : public LoopPass {
-  public:
-    static char ID;
-    
-    LoopSafePoints() : LoopPass(ID) {}
-
-    virtual bool runOnLoop(Loop* L, LPPassManager& LPM);
-
-    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-      AU.addRequired<LoopInfo>();
-    }
-
-
-  private:
-    void insertSafePoint(BasicBlock* BB, Function* SafeFunction,
-                         Value* YieldPtr, Loop* L, LoopInfo* LI);
-  };
-
-  char LoopSafePoints::ID = 0;
-
-void LoopSafePoints::insertSafePoint(BasicBlock* BB, Function* SafeFunction,
-                                     Value* YieldPtr, Loop* L, LoopInfo* LI) {
-  Instruction* I = BB->getFirstNonPHI();
-  BasicBlock* NBB = BB->splitBasicBlock(I);
-  L->addBasicBlockToLoop(NBB, LI->getBase());
-
-  NBB = NBB->getSinglePredecessor();
-  I = NBB->getTerminator();
-  BasicBlock* SU = (static_cast<BranchInst*>(I))->getSuccessor(0);
-  I->eraseFromParent();
-  
-  Value* Ld = new LoadInst(YieldPtr, "", NBB);
-  BasicBlock* yield = BasicBlock::Create(SafeFunction->getContext(), "",
-                                         BB->getParent());
-  
-  BranchInst::Create(yield, SU, Ld, NBB);
-
-  CallInst::Create(SafeFunction, "", yield);
-  BranchInst::Create(SU, yield);
-
-  L->addBasicBlockToLoop(yield, LI->getBase());
-}
-
-
-bool LoopSafePoints::runOnLoop(Loop* L, LPPassManager& LPM) {
-
-  LoopInfo* LI = &getAnalysis<LoopInfo>();
-  BasicBlock* Header = L->getHeader();
-  Function *F = Header->getParent();  
-  Function* SafeFunction =
-    F->getParent()->getFunction("conditionalSafePoint");
-  if (!SafeFunction) return false;
-
-  Value* YieldPtr = 0;
-  
-  // Lookup the yield pointer.
-  for (Function::iterator BI = F->begin(), BE = F->end(); BI != BE; BI++) { 
-    BasicBlock *Cur = BI;
-
-    for (BasicBlock::iterator II = Cur->begin(), IE = Cur->end(); II != IE;) {
-      Instruction *I = II;
-      II++;
-      if (I->getOpcode() != Instruction::Call &&
-          I->getOpcode() != Instruction::Invoke) {
-        continue;
-      }
-
-      CallSite Call(I);
-      if (Call.getCalledValue() == SafeFunction) {
-        if (BasicBlock* Incoming = Cur->getSinglePredecessor()) {
-          if (BranchInst* T = dyn_cast<BranchInst>(Incoming->getTerminator())) {
-            if (LoadInst* LI = dyn_cast<LoadInst>(T->getCondition())) {
-              YieldPtr = LI->getPointerOperand();
-              break;
-            }
-          }
-        }
-      }
-    }
-    if (YieldPtr) break;
-  }
-
-  if (!YieldPtr) return false;
-
-  insertSafePoint(Header, SafeFunction, YieldPtr, L, LI);
-  return true;
-}
-
-}
-
-
-namespace mvm {
-
-LoopPass* createLoopSafePointsPass() {
-  return new LoopSafePoints();
-}
-
-}




From wdietz2 at illinois.edu  Sun Nov 20 19:27:03 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 21 Nov 2011 03:27:03 -0000
Subject: [vmkit-commits] [vmkit] r145023 -
	/vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp
Message-ID: <20111121032703.359052A6C134@llvm.org>

Author: wdietz2
Date: Sun Nov 20 21:27:02 2011
New Revision: 145023

URL: http://llvm.org/viewvc/llvm-project?rev=145023&view=rev
Log:
Drop use of getNameStr, removed from LLVM in r144657

Modified:
    vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp

Modified: vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp?rev=145023&r1=145022&r2=145023&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp Sun Nov 20 21:27:02 2011
@@ -218,7 +218,7 @@
         // we don't end up with tons of allocations on the stack.
         BasicBlock* BB = CurLoop->getLoopPreheader();
         assert(BB && "No Preheader!");
-        DEBUG(errs() << "Escape analysis hoisting to " << BB->getNameStr());
+        DEBUG(errs() << "Escape analysis hoisting to " << BB->getName().str());
         DEBUG(errs() << ": ");
         DEBUG(errs() << *Alloc);
         Alloc->removeFromParent();
@@ -229,7 +229,7 @@
                                       Alloc);
       BitCastInst* BI = new BitCastInst(AI, Alloc->getType(), "", Alloc);
       DEBUG(errs() << "escape");
-      DEBUG(errs() << Alloc->getParent()->getParent()->getNameStr() << "\n");
+      DEBUG(errs() << Alloc->getParent()->getParent()->getName().str() << "\n");
       Alloc->replaceAllUsesWith(BI);
       // If it's an invoke, replace the invoke with a direct branch.
       if (InvokeInst *CI = dyn_cast<InvokeInst>(Alloc)) {




From wdietz2 at illinois.edu  Sun Nov 20 19:27:03 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 21 Nov 2011 03:27:03 -0000
Subject: [vmkit-commits] [vmkit] r145024 -
	/vmkit/trunk/lib/J3/ClassLib/Unsafe.inc
Message-ID: <20111121032703.C69BB2A6C134@llvm.org>

Author: wdietz2
Date: Sun Nov 20 21:27:03 2011
New Revision: 145024

URL: http://llvm.org/viewvc/llvm-project?rev=145024&view=rev
Log:
Fix Unsafe's ensureClassInitialized to init the class given, not its class.

Modified:
    vmkit/trunk/lib/J3/ClassLib/Unsafe.inc

Modified: vmkit/trunk/lib/J3/ClassLib/Unsafe.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/Unsafe.inc?rev=145024&r1=145023&r2=145024&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/Unsafe.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/Unsafe.inc Sun Nov 20 21:27:03 2011
@@ -351,9 +351,8 @@
 
   Jnjvm* vm = JavaThread::get()->getJVM();
 
-  CommonClass * cl = JavaObject::getClass(clazz);
+  UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, clazz, false);
   assert(cl && cl->isClass());
-  cl->asClass()->resolveClass();
   cl->asClass()->initialiseClass(vm);
 
   END_NATIVE_EXCEPTION;




From gael.thomas at lip6.fr  Mon Nov 21 01:19:55 2011
From: gael.thomas at lip6.fr (=?ISO-8859-1?Q?Ga=EBl_Thomas?=)
Date: Mon, 21 Nov 2011 10:19:55 +0100
Subject: [vmkit-commits] [vmkit] r145023 -
	/vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp
In-Reply-To: <20111121032703.359052A6C134@llvm.org>
References: <20111121032703.359052A6C134@llvm.org>
Message-ID: <CAOWuPDdrLme_F07euyX-7xQgX80VZmtopcee0ysAH7Qjz8mivg@mail.gmail.com>

Hi all!
I will begin the refactoring now. I think that it will be ready in
4/5hours. I send you a mail when it is done,
Gaël
2011/11/21 Will Dietz <wdietz2 at illinois.edu>:
> Author: wdietz2
> Date: Sun Nov 20 21:27:02 2011
> New Revision: 145023
>
> URL: http://llvm.org/viewvc/llvm-project?rev=145023&view=rev
> Log:
> Drop use of getNameStr, removed from LLVM in r144657
>
> Modified:
>    vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp
>
> Modified: vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp
> URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp?rev=145023&r1=145022&r2=145023&view=diff
> ==============================================================================
> --- vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp (original)
> +++ vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp Sun Nov 20 21:27:02 2011
> @@ -218,7 +218,7 @@
>         // we don't end up with tons of allocations on the stack.
>         BasicBlock* BB = CurLoop->getLoopPreheader();
>         assert(BB && "No Preheader!");
> -        DEBUG(errs() << "Escape analysis hoisting to " << BB->getNameStr());
> +        DEBUG(errs() << "Escape analysis hoisting to " << BB->getName().str());
>         DEBUG(errs() << ": ");
>         DEBUG(errs() << *Alloc);
>         Alloc->removeFromParent();
> @@ -229,7 +229,7 @@
>                                       Alloc);
>       BitCastInst* BI = new BitCastInst(AI, Alloc->getType(), "", Alloc);
>       DEBUG(errs() << "escape");
> -      DEBUG(errs() << Alloc->getParent()->getParent()->getNameStr() << "\n");
> +      DEBUG(errs() << Alloc->getParent()->getParent()->getName().str() << "\n");
>       Alloc->replaceAllUsesWith(BI);
>       // If it's an invoke, replace the invoke with a direct branch.
>       if (InvokeInst *CI = dyn_cast<InvokeInst>(Alloc)) {
>
>
> _______________________________________________
> vmkit-commits mailing list
> vmkit-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>



-- 
-------------------------------------------------------------------------------------------------
Gaël Thomas, Associate Professor,
University of Pierre and Marie Curie
Boite courrier 169, 217 - 26-00, REGAL Team, INRIA/LIP6,
4, place Jussieu, 75252 Paris Cedex 05, France
Web: http://pagesperso-systeme.lip6.fr/Gael.Thomas/
Phone (mob): +33 6 10 39 31 17           Fax : +33 1 44 27 70 00
-------------------------------------------------------------------------------------------------



From gael.thomas at lip6.fr  Mon Nov 21 02:12:26 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Mon, 21 Nov 2011 10:12:26 -0000
Subject: [vmkit-commits] [vmkit] r145029 - in /vmkit/trunk: ./ autoconf/
 include/j3/ include/mvm/ include/mvm/Config/ include/mvm/GC/
 include/mvm/Threads/ lib/J3/Compiler/ lib/J3/VMCore/ lib/Mvm/CommonThread/
 lib/Mvm/Compiler/ lib/Mvm/MMTk/ mmtk/mmtk-j3/ tools/j3/ tools/precompiler/
 tools/vmjc/
Message-ID: <20111121101227.413CE2A6C134@llvm.org>

Author: gthomas
Date: Mon Nov 21 04:12:26 2011
New Revision: 145029

URL: http://llvm.org/viewvc/llvm-project?rev=145029&view=rev
Log:
Move mvm/include/GC/*, mvm/include/Config/* and mvm/include/Threads/* into mvm/include


Added:
    vmkit/trunk/include/mvm/CollectionRV.h
      - copied, changed from r145028, vmkit/trunk/include/mvm/Threads/CollectionRV.h
    vmkit/trunk/include/mvm/Cond.h
      - copied unchanged from r145028, vmkit/trunk/include/mvm/Threads/Cond.h
    vmkit/trunk/include/mvm/GC.h
      - copied unchanged from r145028, vmkit/trunk/include/mvm/GC/GC.h
    vmkit/trunk/include/mvm/Locks.h
      - copied, changed from r145028, vmkit/trunk/include/mvm/Threads/Locks.h
    vmkit/trunk/include/mvm/ObjectLocks.h
      - copied, changed from r145028, vmkit/trunk/include/mvm/Threads/ObjectLocks.h
    vmkit/trunk/include/mvm/Thread.h
      - copied unchanged from r145028, vmkit/trunk/include/mvm/Threads/Thread.h
    vmkit/trunk/include/mvm/config.h.in
      - copied unchanged from r145028, vmkit/trunk/include/mvm/Config/config.h.in
Removed:
    vmkit/trunk/include/mvm/Config/
    vmkit/trunk/include/mvm/GC/
    vmkit/trunk/include/mvm/Threads/
Modified:
    vmkit/trunk/autoconf/configure.ac
    vmkit/trunk/configure
    vmkit/trunk/include/j3/JavaCompiler.h
    vmkit/trunk/include/mvm/   (props changed)
    vmkit/trunk/include/mvm/Allocator.h
    vmkit/trunk/include/mvm/JIT.h
    vmkit/trunk/include/mvm/MethodInfo.h
    vmkit/trunk/include/mvm/VirtualMachine.h
    vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
    vmkit/trunk/lib/J3/VMCore/JavaClass.h
    vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
    vmkit/trunk/lib/J3/VMCore/JavaObject.h
    vmkit/trunk/lib/J3/VMCore/JavaThread.cpp
    vmkit/trunk/lib/J3/VMCore/JavaThread.h
    vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
    vmkit/trunk/lib/J3/VMCore/Jnjvm.h
    vmkit/trunk/lib/J3/VMCore/LockedMap.h
    vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h
    vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp
    vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
    vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp
    vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
    vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h
    vmkit/trunk/lib/Mvm/MMTk/MvmGC.h
    vmkit/trunk/mmtk/mmtk-j3/Strings.cpp
    vmkit/trunk/tools/j3/Main.cpp
    vmkit/trunk/tools/precompiler/Precompiler.cpp
    vmkit/trunk/tools/vmjc/vmjc.cpp

Modified: vmkit/trunk/autoconf/configure.ac
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/autoconf/configure.ac?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/autoconf/configure.ac (original)
+++ vmkit/trunk/autoconf/configure.ac Mon Nov 21 04:12:26 2011
@@ -50,7 +50,7 @@
 dnl Quit if the source directory has already been configured.
 dnl NOTE: This relies upon undocumented autoconf behavior.
 if test ${srcdir} != "." ; then
-  if test -f ${srcdir}/include/mvm/Config/config.h ; then
+  if test -f ${srcdir}/include/mvm/config.h ; then
     AC_MSG_ERROR([Already configured in ${srcdir}])
   fi
 fi
@@ -369,7 +369,7 @@
 dnl you MUST also update Makefile.rules so that the variable FilesToConfig
 dnl contains the same list of files as AC_CONFIG_HEADERS below. This ensures the
 dnl files can be updated automatically when their *.in sources change.
-AC_CONFIG_HEADERS([include/mvm/Config/config.h])
+AC_CONFIG_HEADERS([include/mvm/config.h])
 
 dnl Verify that the source directory is valid
 AC_CONFIG_SRCDIR(["Makefile.common.in"])

Modified: vmkit/trunk/configure
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/configure?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/configure (original)
+++ vmkit/trunk/configure Mon Nov 21 04:12:26 2011
@@ -2259,7 +2259,7 @@
 
 
 if test ${srcdir} != "." ; then
-  if test -f ${srcdir}/include/mvm/Config/config.h ; then
+  if test -f ${srcdir}/include/mvm/config.h ; then
     as_fn_error $? "Already configured in ${srcdir}" "$LINENO" 5
   fi
 fi
@@ -5780,7 +5780,7 @@
 
 
 
-ac_config_headers="$ac_config_headers include/mvm/Config/config.h"
+ac_config_headers="$ac_config_headers include/mvm/config.h"
 
 
 
@@ -6515,7 +6515,7 @@
 do
   case $ac_config_target in
     "setup") CONFIG_COMMANDS="$CONFIG_COMMANDS setup" ;;
-    "include/mvm/Config/config.h") CONFIG_HEADERS="$CONFIG_HEADERS include/mvm/Config/config.h" ;;
+    "include/mvm/config.h") CONFIG_HEADERS="$CONFIG_HEADERS include/mvm/config.h" ;;
     "Makefile.common") CONFIG_FILES="$CONFIG_FILES Makefile.common" ;;
     "Makefile.config") CONFIG_FILES="$CONFIG_FILES Makefile.config" ;;
     "lib/J3/ClassLib/Classpath.h") CONFIG_FILES="$CONFIG_FILES lib/J3/ClassLib/Classpath.h" ;;

Modified: vmkit/trunk/include/j3/JavaCompiler.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/JavaCompiler.h?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/include/j3/JavaCompiler.h (original)
+++ vmkit/trunk/include/j3/JavaCompiler.h Mon Nov 21 04:12:26 2011
@@ -15,7 +15,7 @@
 #include <string>
 #include <dlfcn.h>
 
-#include "mvm/GC/GC.h"
+#include "mvm/GC.h"
 #include "mvm/Allocator.h"
 
 namespace mvm {

Propchange: vmkit/trunk/include/mvm/
------------------------------------------------------------------------------
--- svn:ignore (added)
+++ svn:ignore Mon Nov 21 04:12:26 2011
@@ -0,0 +1 @@
+config.h

Modified: vmkit/trunk/include/mvm/Allocator.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Allocator.h?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/Allocator.h (original)
+++ vmkit/trunk/include/mvm/Allocator.h Mon Nov 21 04:12:26 2011
@@ -11,7 +11,7 @@
 #define MVM_ALLOCATOR_H
 
 #include "llvm/Support/Allocator.h"
-#include "mvm/Threads/Locks.h"
+#include "mvm/Locks.h"
 
 #include <cstring>
 

Copied: vmkit/trunk/include/mvm/CollectionRV.h (from r145028, vmkit/trunk/include/mvm/Threads/CollectionRV.h)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/CollectionRV.h?p2=vmkit/trunk/include/mvm/CollectionRV.h&p1=vmkit/trunk/include/mvm/Threads/CollectionRV.h&r1=145028&r2=145029&rev=145029&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/Threads/CollectionRV.h (original)
+++ vmkit/trunk/include/mvm/CollectionRV.h Mon Nov 21 04:12:26 2011
@@ -10,9 +10,9 @@
 #ifndef _MVM_COLLECTIONRV_H_
 #define _MVM_COLLECTIONRV_H_
 
-#include "mvm/Threads/Cond.h"
-#include "mvm/Threads/Locks.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Cond.h"
+#include "mvm/Locks.h"
+#include "mvm/Thread.h"
 
 namespace mvm {
 

Modified: vmkit/trunk/include/mvm/JIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/JIT.h?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/JIT.h (original)
+++ vmkit/trunk/include/mvm/JIT.h Mon Nov 21 04:12:26 2011
@@ -19,7 +19,7 @@
 #include "llvm/Target/TargetMachine.h"
 
 #include "mvm/MethodInfo.h"
-#include "mvm/GC/GC.h"
+#include "mvm/GC.h"
 
 namespace llvm {
   class Constant;

Copied: vmkit/trunk/include/mvm/Locks.h (from r145028, vmkit/trunk/include/mvm/Threads/Locks.h)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Locks.h?p2=vmkit/trunk/include/mvm/Locks.h&p1=vmkit/trunk/include/mvm/Threads/Locks.h&r1=145028&r2=145029&rev=145029&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/Threads/Locks.h (original)
+++ vmkit/trunk/include/mvm/Locks.h Mon Nov 21 04:12:26 2011
@@ -14,7 +14,7 @@
 #include <cassert>
 #include <cstdio>
 
-#include "mvm/Threads/Thread.h"
+#include "mvm/Thread.h"
 
 extern "C" void __llvm_gcroot(void**, void*) __attribute__((nothrow));
 #define llvm_gcroot(a, b) __llvm_gcroot((void**)&a, b)

Modified: vmkit/trunk/include/mvm/MethodInfo.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/MethodInfo.h?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/MethodInfo.h (original)
+++ vmkit/trunk/include/mvm/MethodInfo.h Mon Nov 21 04:12:26 2011
@@ -12,7 +12,7 @@
 
 #include "mvm/Allocator.h"
 #include "mvm/System.h"
-#include "mvm/GC/GC.h"
+#include "mvm/GC.h"
 
 namespace mvm {
 

Copied: vmkit/trunk/include/mvm/ObjectLocks.h (from r145028, vmkit/trunk/include/mvm/Threads/ObjectLocks.h)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/ObjectLocks.h?p2=vmkit/trunk/include/mvm/ObjectLocks.h&p1=vmkit/trunk/include/mvm/Threads/ObjectLocks.h&r1=145028&r2=145029&rev=145029&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/Threads/ObjectLocks.h (original)
+++ vmkit/trunk/include/mvm/ObjectLocks.h Mon Nov 21 04:12:26 2011
@@ -11,10 +11,10 @@
 #define MVM_OBJECT_LOCKS_H
 
 #include "mvm/Allocator.h"
-#include "mvm/GC/GC.h"
-#include "mvm/Threads/Cond.h"
-#include "mvm/Threads/Locks.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/GC.h"
+#include "mvm/Cond.h"
+#include "mvm/Locks.h"
+#include "mvm/Thread.h"
 
 namespace mvm {
 

Modified: vmkit/trunk/include/mvm/VirtualMachine.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/VirtualMachine.h?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/VirtualMachine.h (original)
+++ vmkit/trunk/include/mvm/VirtualMachine.h Mon Nov 21 04:12:26 2011
@@ -13,9 +13,9 @@
 #include "llvm/ADT/DenseMap.h"
 
 #include "mvm/Allocator.h"
-#include "mvm/Threads/CollectionRV.h"
-#include "mvm/Threads/Locks.h"
-#include "mvm/GC/GC.h"
+#include "mvm/CollectionRV.h"
+#include "mvm/Locks.h"
+#include "mvm/GC.h"
 
 #include <cassert>
 #include <map>

Modified: vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp Mon Nov 21 04:12:26 2011
@@ -18,7 +18,7 @@
 #include "llvm/Target/TargetData.h"
 
 #include "mvm/UTF8.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Thread.h"
 
 #include "j3/J3Intrinsics.h"
 #include "j3/JavaAOTCompiler.h"

Modified: vmkit/trunk/lib/J3/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaClass.h?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaClass.h Mon Nov 21 04:12:26 2011
@@ -15,8 +15,8 @@
 
 #include "mvm/Allocator.h"
 #include "mvm/MethodInfo.h"
-#include "mvm/Threads/Cond.h"
-#include "mvm/Threads/Locks.h"
+#include "mvm/Cond.h"
+#include "mvm/Locks.h"
 
 #include "JavaAccess.h"
 #include "JavaObject.h"

Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaObject.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaObject.cpp Mon Nov 21 04:12:26 2011
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "mvm/Threads/Locks.h"
+#include "mvm/Locks.h"
 
 #include "JavaArray.h"
 #include "JavaClass.h"

Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.h?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaObject.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaObject.h Mon Nov 21 04:12:26 2011
@@ -12,8 +12,8 @@
 
 #include "mvm/Allocator.h"
 #include "mvm/UTF8.h"
-#include "mvm/Threads/Locks.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Locks.h"
+#include "mvm/Thread.h"
 #include "MvmGC.h"
 
 #include "types.h"

Modified: vmkit/trunk/lib/J3/VMCore/JavaThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaThread.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaThread.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaThread.cpp Mon Nov 21 04:12:26 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "mvm/Threads/Locks.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Locks.h"
+#include "mvm/Thread.h"
 
 #include "JavaClass.h"
 #include "JavaObject.h"

Modified: vmkit/trunk/lib/J3/VMCore/JavaThread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaThread.h?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaThread.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaThread.h Mon Nov 21 04:12:26 2011
@@ -10,10 +10,10 @@
 #ifndef JNJVM_JAVA_THREAD_H
 #define JNJVM_JAVA_THREAD_H
 
-#include "mvm/Threads/Cond.h"
-#include "mvm/Threads/Locks.h"
-#include "mvm/Threads/ObjectLocks.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Cond.h"
+#include "mvm/Locks.h"
+#include "mvm/ObjectLocks.h"
+#include "mvm/Thread.h"
 
 #include "MutatorThread.h"
 

Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp Mon Nov 21 04:12:26 2011
@@ -18,7 +18,7 @@
 #include <string>
 #include "debug.h"
 
-#include "mvm/Threads/Thread.h"
+#include "mvm/Thread.h"
 #include "MvmGC.h"
 
 #include "ClasspathReflect.h"

Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.h?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.h Mon Nov 21 04:12:26 2011
@@ -17,9 +17,9 @@
 #include "mvm/Allocator.h"
 #include "mvm/MethodInfo.h"
 #include "mvm/VirtualMachine.h"
-#include "mvm/Threads/Cond.h"
-#include "mvm/Threads/Locks.h"
-#include "mvm/Threads/ObjectLocks.h"
+#include "mvm/Cond.h"
+#include "mvm/Locks.h"
+#include "mvm/ObjectLocks.h"
 
 #include "JnjvmConfig.h"
 #include "JNIReferences.h"

Modified: vmkit/trunk/lib/J3/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LockedMap.h?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LockedMap.h (original)
+++ vmkit/trunk/lib/J3/VMCore/LockedMap.h Mon Nov 21 04:12:26 2011
@@ -25,7 +25,7 @@
 
 #include "mvm/Allocator.h"
 #include "mvm/MvmDenseMap.h"
-#include "mvm/Threads/Locks.h"
+#include "mvm/Locks.h"
 #include "UTF8.h"
 
 namespace j3 {

Modified: vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h (original)
+++ vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h Mon Nov 21 04:12:26 2011
@@ -10,7 +10,7 @@
 #ifndef J3_REFERENCE_QUEUE_H
 #define J3_REFERENCE_QUEUE_H
 
-#include "mvm/Threads/Locks.h"
+#include "mvm/Locks.h"
 
 #include "JavaThread.h"
 

Modified: vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp Mon Nov 21 04:12:26 2011
@@ -11,7 +11,7 @@
 #include <signal.h>
 #include "MvmGC.h"
 #include "mvm/VirtualMachine.h"
-#include "mvm/Threads/CollectionRV.h"
+#include "mvm/CollectionRV.h"
 
 #include "debug.h"
 

Modified: vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp Mon Nov 21 04:12:26 2011
@@ -9,10 +9,10 @@
 
 #include <cassert>
 
-#include "mvm/Threads/Cond.h"
-#include "mvm/Threads/Locks.h"
-#include "mvm/Threads/ObjectLocks.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Cond.h"
+#include "mvm/Locks.h"
+#include "mvm/ObjectLocks.h"
+#include "mvm/Thread.h"
 #include "mvm/VirtualMachine.h"
 #include "MvmGC.h"
 #include <cerrno>

Modified: vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp Mon Nov 21 04:12:26 2011
@@ -11,7 +11,7 @@
 #include "mvm/MethodInfo.h"
 #include "mvm/System.h"
 #include "mvm/VirtualMachine.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Thread.h"
 
 #include <csignal>
 #include <cstdio>

Modified: vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp Mon Nov 21 04:12:26 2011
@@ -9,9 +9,9 @@
 
 #include <cassert>
 
-#include "mvm/Threads/Cond.h"
-#include "mvm/Threads/Locks.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Cond.h"
+#include "mvm/Locks.h"
+#include "mvm/Thread.h"
 #include "mvm/VirtualMachine.h"
 #include "MvmGC.h"
 #include <cerrno>

Modified: vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp Mon Nov 21 04:12:26 2011
@@ -12,9 +12,9 @@
 #include "MvmGC.h"
 #include "mvm/MethodInfo.h"
 #include "mvm/VirtualMachine.h"
-#include "mvm/Threads/Cond.h"
-#include "mvm/Threads/Locks.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Cond.h"
+#include "mvm/Locks.h"
+#include "mvm/Thread.h"
 
 #include <cassert>
 #include <cstdio>

Modified: vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp Mon Nov 21 04:12:26 2011
@@ -23,7 +23,7 @@
 #include <cstddef>
 #include <map>
 
-#include "mvm/GC/GC.h"
+#include "mvm/GC.h"
 
 using namespace llvm;
 

Modified: vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/JIT.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/JIT.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/JIT.cpp Mon Nov 21 04:12:26 2011
@@ -38,11 +38,11 @@
 #include <../lib/ExecutionEngine/JIT/JIT.h>
 
 #include "mvm/JIT.h"
-#include "mvm/Threads/Locks.h"
-#include "mvm/Threads/ObjectLocks.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Locks.h"
+#include "mvm/ObjectLocks.h"
+#include "mvm/Thread.h"
 #include "mvm/VirtualMachine.h"
-#include "mvm/GC/GC.h"
+#include "mvm/GC.h"
 #include "MutatorThread.h"
 #include "MvmGC.h"
 

Modified: vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h (original)
+++ vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h Mon Nov 21 04:12:26 2011
@@ -12,7 +12,7 @@
 #define MVM_MUTATOR_THREAD_H
 
 #include "mvm/Allocator.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Thread.h"
 
 namespace mvm {
 

Modified: vmkit/trunk/lib/Mvm/MMTk/MvmGC.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/MMTk/MvmGC.h?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/MMTk/MvmGC.h (original)
+++ vmkit/trunk/lib/Mvm/MMTk/MvmGC.h Mon Nov 21 04:12:26 2011
@@ -11,7 +11,7 @@
 #ifndef MVM_MMTK_GC_H
 #define MVM_MMTK_GC_H
 
-#include "mvm/GC/GC.h"
+#include "mvm/GC.h"
 #include <cstdlib>
 
 extern "C" void EmptyDestructor();

Modified: vmkit/trunk/mmtk/mmtk-j3/Strings.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Strings.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Strings.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Strings.cpp Mon Nov 21 04:12:26 2011
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "mvm/Threads/Thread.h"
+#include "mvm/Thread.h"
 
 #include "MMTkObject.h"
 

Modified: vmkit/trunk/tools/j3/Main.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/j3/Main.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/tools/j3/Main.cpp (original)
+++ vmkit/trunk/tools/j3/Main.cpp Mon Nov 21 04:12:26 2011
@@ -11,7 +11,7 @@
 #include "mvm/JIT.h"
 #include "mvm/MethodInfo.h"
 #include "mvm/VirtualMachine.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Thread.h"
 
 #include "j3/JavaJITCompiler.h"
 #include "../../lib/J3/VMCore/JnjvmClassLoader.h"

Modified: vmkit/trunk/tools/precompiler/Precompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/precompiler/Precompiler.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/tools/precompiler/Precompiler.cpp (original)
+++ vmkit/trunk/tools/precompiler/Precompiler.cpp Mon Nov 21 04:12:26 2011
@@ -19,7 +19,7 @@
 #include "mvm/JIT.h"
 #include "mvm/MethodInfo.h"
 #include "mvm/VirtualMachine.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Thread.h"
 
 #include "j3/JavaAOTCompiler.h"
 #include "j3/JavaJITCompiler.h"

Modified: vmkit/trunk/tools/vmjc/vmjc.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmjc/vmjc.cpp?rev=145029&r1=145028&r2=145029&view=diff
==============================================================================
--- vmkit/trunk/tools/vmjc/vmjc.cpp (original)
+++ vmkit/trunk/tools/vmjc/vmjc.cpp Mon Nov 21 04:12:26 2011
@@ -41,7 +41,7 @@
 #include "MvmGC.h"
 #include "mvm/JIT.h"
 #include "mvm/VirtualMachine.h"
-#include "mvm/Threads/Thread.h"
+#include "mvm/Thread.h"
 
 #include "j3/JavaAOTCompiler.h"
 




From gael.thomas at lip6.fr  Mon Nov 21 02:20:52 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Mon, 21 Nov 2011 10:20:52 -0000
Subject: [vmkit-commits] [vmkit] r145030 - in /vmkit/trunk: ./ autoconf/
 include/j3/ include/mvm/ include/vmkit/ lib/J3/ClassLib/GNUClasspath/
 lib/J3/ClassLib/OpenJDK/ lib/J3/Compiler/ lib/J3/VMCore/
 lib/Mvm/CommonThread/ lib/Mvm/Compiler/ lib/Mvm/MMTk/ lib/Mvm/Runtime/
 mmtk/magic/ mmtk/mmtk-alloc/ mmtk/mmtk-j3/ tools/j3/ tools/precompiler/
 tools/vmjc/
Message-ID: <20111121102053.3F4282A6C134@llvm.org>

Author: gthomas
Date: Mon Nov 21 04:20:51 2011
New Revision: 145030

URL: http://llvm.org/viewvc/llvm-project?rev=145030&view=rev
Log:
rename include/mvm into include/vmkit

Added:
    vmkit/trunk/include/vmkit/
      - copied from r145029, vmkit/trunk/include/mvm/
Removed:
    vmkit/trunk/include/mvm/
Modified:
    vmkit/trunk/autoconf/configure.ac
    vmkit/trunk/configure
    vmkit/trunk/include/j3/J3Intrinsics.h
    vmkit/trunk/include/j3/JavaAOTCompiler.h
    vmkit/trunk/include/j3/JavaCompiler.h
    vmkit/trunk/include/vmkit/Allocator.h
    vmkit/trunk/include/vmkit/CollectionRV.h
    vmkit/trunk/include/vmkit/GC.h
    vmkit/trunk/include/vmkit/JIT.h
    vmkit/trunk/include/vmkit/Locks.h
    vmkit/trunk/include/vmkit/MethodInfo.h
    vmkit/trunk/include/vmkit/ObjectLocks.h
    vmkit/trunk/include/vmkit/Thread.h
    vmkit/trunk/include/vmkit/UTF8.h
    vmkit/trunk/include/vmkit/VirtualMachine.h
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h
    vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp
    vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
    vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
    vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp
    vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp
    vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp
    vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp
    vmkit/trunk/lib/J3/VMCore/JNIReferences.h
    vmkit/trunk/lib/J3/VMCore/JavaArray.h
    vmkit/trunk/lib/J3/VMCore/JavaClass.h
    vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h
    vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
    vmkit/trunk/lib/J3/VMCore/JavaObject.h
    vmkit/trunk/lib/J3/VMCore/JavaThread.cpp
    vmkit/trunk/lib/J3/VMCore/JavaThread.h
    vmkit/trunk/lib/J3/VMCore/JavaTypes.h
    vmkit/trunk/lib/J3/VMCore/Jni.cpp
    vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
    vmkit/trunk/lib/J3/VMCore/Jnjvm.h
    vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
    vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h
    vmkit/trunk/lib/J3/VMCore/LockedMap.h
    vmkit/trunk/lib/J3/VMCore/Precompiled.cpp
    vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h
    vmkit/trunk/lib/J3/VMCore/UTF8.h
    vmkit/trunk/lib/J3/VMCore/Zip.cpp
    vmkit/trunk/lib/J3/VMCore/Zip.h
    vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp
    vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
    vmkit/trunk/lib/Mvm/Compiler/Disassembler.cpp
    vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp
    vmkit/trunk/lib/Mvm/Compiler/InlineMalloc.cpp
    vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
    vmkit/trunk/lib/Mvm/Compiler/VmkitGC.cpp
    vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h
    vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp
    vmkit/trunk/lib/Mvm/MMTk/MvmGC.h
    vmkit/trunk/lib/Mvm/Runtime/MethodInfo.cpp
    vmkit/trunk/lib/Mvm/Runtime/Object.cpp
    vmkit/trunk/lib/Mvm/Runtime/UTF8.cpp
    vmkit/trunk/mmtk/magic/LowerMagic.cpp
    vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp
    vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp
    vmkit/trunk/mmtk/mmtk-j3/Collection.cpp
    vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp
    vmkit/trunk/mmtk/mmtk-j3/Memory.cpp
    vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp
    vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp
    vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp
    vmkit/trunk/mmtk/mmtk-j3/Strings.cpp
    vmkit/trunk/tools/j3/Main.cpp
    vmkit/trunk/tools/precompiler/Precompiler.cpp
    vmkit/trunk/tools/vmjc/vmjc.cpp

Modified: vmkit/trunk/autoconf/configure.ac
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/autoconf/configure.ac?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/autoconf/configure.ac (original)
+++ vmkit/trunk/autoconf/configure.ac Mon Nov 21 04:20:51 2011
@@ -50,7 +50,7 @@
 dnl Quit if the source directory has already been configured.
 dnl NOTE: This relies upon undocumented autoconf behavior.
 if test ${srcdir} != "." ; then
-  if test -f ${srcdir}/include/mvm/config.h ; then
+  if test -f ${srcdir}/include/vmkit/config.h ; then
     AC_MSG_ERROR([Already configured in ${srcdir}])
   fi
 fi
@@ -369,7 +369,7 @@
 dnl you MUST also update Makefile.rules so that the variable FilesToConfig
 dnl contains the same list of files as AC_CONFIG_HEADERS below. This ensures the
 dnl files can be updated automatically when their *.in sources change.
-AC_CONFIG_HEADERS([include/mvm/config.h])
+AC_CONFIG_HEADERS([include/vmkit/config.h])
 
 dnl Verify that the source directory is valid
 AC_CONFIG_SRCDIR(["Makefile.common.in"])

Modified: vmkit/trunk/configure
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/configure?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/configure (original)
+++ vmkit/trunk/configure Mon Nov 21 04:20:51 2011
@@ -2259,7 +2259,7 @@
 
 
 if test ${srcdir} != "." ; then
-  if test -f ${srcdir}/include/mvm/config.h ; then
+  if test -f ${srcdir}/include/vmkit/config.h ; then
     as_fn_error $? "Already configured in ${srcdir}" "$LINENO" 5
   fi
 fi
@@ -5780,7 +5780,7 @@
 
 
 
-ac_config_headers="$ac_config_headers include/mvm/config.h"
+ac_config_headers="$ac_config_headers include/vmkit/config.h"
 
 
 
@@ -6515,7 +6515,7 @@
 do
   case $ac_config_target in
     "setup") CONFIG_COMMANDS="$CONFIG_COMMANDS setup" ;;
-    "include/mvm/config.h") CONFIG_HEADERS="$CONFIG_HEADERS include/mvm/config.h" ;;
+    "include/vmkit/config.h") CONFIG_HEADERS="$CONFIG_HEADERS include/vmkit/config.h" ;;
     "Makefile.common") CONFIG_FILES="$CONFIG_FILES Makefile.common" ;;
     "Makefile.config") CONFIG_FILES="$CONFIG_FILES Makefile.config" ;;
     "lib/J3/ClassLib/Classpath.h") CONFIG_FILES="$CONFIG_FILES lib/J3/ClassLib/Classpath.h" ;;

Modified: vmkit/trunk/include/j3/J3Intrinsics.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/J3Intrinsics.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/include/j3/J3Intrinsics.h (original)
+++ vmkit/trunk/include/j3/J3Intrinsics.h Mon Nov 21 04:20:51 2011
@@ -10,7 +10,7 @@
 #ifndef J3_INTRINSICS_H
 #define J3_INTRINSICS_H
 
-#include "mvm/JIT.h"
+#include "vmkit/JIT.h"
 
 namespace j3 {
 

Modified: vmkit/trunk/include/j3/JavaAOTCompiler.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/JavaAOTCompiler.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/include/j3/JavaAOTCompiler.h (original)
+++ vmkit/trunk/include/j3/JavaAOTCompiler.h Mon Nov 21 04:20:51 2011
@@ -10,8 +10,8 @@
 #ifndef J3_AOT_COMPILER_H
 #define J3_AOT_COMPILER_H
 
-#include "mvm/MvmDenseMap.h"
-#include "mvm/UTF8.h"
+#include "vmkit/MvmDenseMap.h"
+#include "vmkit/UTF8.h"
 #include "j3/JavaLLVMCompiler.h"
 
 namespace j3 {

Modified: vmkit/trunk/include/j3/JavaCompiler.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/JavaCompiler.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/include/j3/JavaCompiler.h (original)
+++ vmkit/trunk/include/j3/JavaCompiler.h Mon Nov 21 04:20:51 2011
@@ -15,8 +15,8 @@
 #include <string>
 #include <dlfcn.h>
 
-#include "mvm/GC.h"
-#include "mvm/Allocator.h"
+#include "vmkit/GC.h"
+#include "vmkit/Allocator.h"
 
 namespace mvm {
   class UTF8;

Modified: vmkit/trunk/include/vmkit/Allocator.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Allocator.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Allocator.h (original)
+++ vmkit/trunk/include/vmkit/Allocator.h Mon Nov 21 04:20:51 2011
@@ -11,7 +11,7 @@
 #define MVM_ALLOCATOR_H
 
 #include "llvm/Support/Allocator.h"
-#include "mvm/Locks.h"
+#include "vmkit/Locks.h"
 
 #include <cstring>
 

Modified: vmkit/trunk/include/vmkit/CollectionRV.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/CollectionRV.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/CollectionRV.h (original)
+++ vmkit/trunk/include/vmkit/CollectionRV.h Mon Nov 21 04:20:51 2011
@@ -10,9 +10,9 @@
 #ifndef _MVM_COLLECTIONRV_H_
 #define _MVM_COLLECTIONRV_H_
 
-#include "mvm/Cond.h"
-#include "mvm/Locks.h"
-#include "mvm/Thread.h"
+#include "vmkit/Cond.h"
+#include "vmkit/Locks.h"
+#include "vmkit/Thread.h"
 
 namespace mvm {
 

Modified: vmkit/trunk/include/vmkit/GC.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/GC.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/GC.h (original)
+++ vmkit/trunk/include/vmkit/GC.h Mon Nov 21 04:20:51 2011
@@ -12,7 +12,7 @@
 #define MVM_GC_H
 
 #include <stdint.h>
-#include "mvm/System.h"
+#include "vmkit/System.h"
 
 class VirtualTable;
 

Modified: vmkit/trunk/include/vmkit/JIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/JIT.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/JIT.h (original)
+++ vmkit/trunk/include/vmkit/JIT.h Mon Nov 21 04:20:51 2011
@@ -18,8 +18,8 @@
 
 #include "llvm/Target/TargetMachine.h"
 
-#include "mvm/MethodInfo.h"
-#include "mvm/GC.h"
+#include "vmkit/MethodInfo.h"
+#include "vmkit/GC.h"
 
 namespace llvm {
   class Constant;

Modified: vmkit/trunk/include/vmkit/Locks.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Locks.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Locks.h (original)
+++ vmkit/trunk/include/vmkit/Locks.h Mon Nov 21 04:20:51 2011
@@ -14,7 +14,7 @@
 #include <cassert>
 #include <cstdio>
 
-#include "mvm/Thread.h"
+#include "vmkit/Thread.h"
 
 extern "C" void __llvm_gcroot(void**, void*) __attribute__((nothrow));
 #define llvm_gcroot(a, b) __llvm_gcroot((void**)&a, b)

Modified: vmkit/trunk/include/vmkit/MethodInfo.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/MethodInfo.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/MethodInfo.h (original)
+++ vmkit/trunk/include/vmkit/MethodInfo.h Mon Nov 21 04:20:51 2011
@@ -10,9 +10,9 @@
 #ifndef MVM_METHODINFO_H
 #define MVM_METHODINFO_H
 
-#include "mvm/Allocator.h"
-#include "mvm/System.h"
-#include "mvm/GC.h"
+#include "vmkit/Allocator.h"
+#include "vmkit/System.h"
+#include "vmkit/GC.h"
 
 namespace mvm {
 

Modified: vmkit/trunk/include/vmkit/ObjectLocks.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/ObjectLocks.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/ObjectLocks.h (original)
+++ vmkit/trunk/include/vmkit/ObjectLocks.h Mon Nov 21 04:20:51 2011
@@ -10,11 +10,11 @@
 #ifndef MVM_OBJECT_LOCKS_H
 #define MVM_OBJECT_LOCKS_H
 
-#include "mvm/Allocator.h"
-#include "mvm/GC.h"
-#include "mvm/Cond.h"
-#include "mvm/Locks.h"
-#include "mvm/Thread.h"
+#include "vmkit/Allocator.h"
+#include "vmkit/GC.h"
+#include "vmkit/Cond.h"
+#include "vmkit/Locks.h"
+#include "vmkit/Thread.h"
 
 namespace mvm {
 

Modified: vmkit/trunk/include/vmkit/Thread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Thread.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Thread.h (original)
+++ vmkit/trunk/include/vmkit/Thread.h Mon Nov 21 04:20:51 2011
@@ -17,7 +17,7 @@
 #include "debug.h"
 #include "types.h"
 
-#include "mvm/System.h"
+#include "vmkit/System.h"
 
 
 namespace mvm {

Modified: vmkit/trunk/include/vmkit/UTF8.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/UTF8.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/UTF8.h (original)
+++ vmkit/trunk/include/vmkit/UTF8.h Mon Nov 21 04:20:51 2011
@@ -2,9 +2,9 @@
 #define _UTF8_INTERNAL_H_
 
 #include <map>
-#include "mvm/Allocator.h"
-#include "mvm/MvmDenseMap.h"
-#include "mvm/MvmDenseSet.h"
+#include "vmkit/Allocator.h"
+#include "vmkit/MvmDenseMap.h"
+#include "vmkit/MvmDenseSet.h"
 
 namespace mvm {
 

Modified: vmkit/trunk/include/vmkit/VirtualMachine.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/VirtualMachine.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/VirtualMachine.h (original)
+++ vmkit/trunk/include/vmkit/VirtualMachine.h Mon Nov 21 04:20:51 2011
@@ -12,10 +12,10 @@
 
 #include "llvm/ADT/DenseMap.h"
 
-#include "mvm/Allocator.h"
-#include "mvm/CollectionRV.h"
-#include "mvm/Locks.h"
-#include "mvm/GC.h"
+#include "vmkit/Allocator.h"
+#include "vmkit/CollectionRV.h"
+#include "vmkit/Locks.h"
+#include "vmkit/GC.h"
 
 #include <cassert>
 #include <map>

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h Mon Nov 21 04:20:51 2011
@@ -10,7 +10,7 @@
 #ifndef JNJVM_JAVA_UPCALLS_H
 #define JNJVM_JAVA_UPCALLS_H
 
-#include "mvm/Allocator.h"
+#include "vmkit/Allocator.h"
 
 #include "JnjvmConfig.h"
 

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h Mon Nov 21 04:20:51 2011
@@ -10,7 +10,7 @@
 #ifndef JNJVM_JAVA_UPCALLS_H
 #define JNJVM_JAVA_UPCALLS_H
 
-#include "mvm/Allocator.h"
+#include "vmkit/Allocator.h"
 
 #include "JnjvmConfig.h"
 

Modified: vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp Mon Nov 21 04:20:51 2011
@@ -12,7 +12,7 @@
 #include "llvm/LLVMContext.h"
 #include "llvm/Module.h"
 
-#include "mvm/JIT.h"
+#include "vmkit/JIT.h"
 
 #include "JavaAccess.h"
 #include "JavaArray.h"

Modified: vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp Mon Nov 21 04:20:51 2011
@@ -17,8 +17,8 @@
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Target/TargetData.h"
 
-#include "mvm/UTF8.h"
-#include "mvm/Thread.h"
+#include "vmkit/UTF8.h"
+#include "vmkit/Thread.h"
 
 #include "j3/J3Intrinsics.h"
 #include "j3/JavaAOTCompiler.h"

Modified: vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp Mon Nov 21 04:20:51 2011
@@ -24,7 +24,7 @@
 #include "llvm/Analysis/DIBuilder.h"
 #include <llvm/Support/CFG.h>
 
-#include "mvm/JIT.h"
+#include "vmkit/JIT.h"
 
 #include "debug.h"
 #include "JavaArray.h"

Modified: vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp Mon Nov 21 04:20:51 2011
@@ -26,7 +26,7 @@
 #include <../lib/ExecutionEngine/JIT/JIT.h>
 
 #include "MvmGC.h"
-#include "mvm/VirtualMachine.h"
+#include "vmkit/VirtualMachine.h"
 
 #include "JavaClass.h"
 #include "JavaConstantPool.h"

Modified: vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp Mon Nov 21 04:20:51 2011
@@ -20,7 +20,7 @@
 #include <llvm/Module.h>
 #include <llvm/Type.h>
 
-#include "mvm/JIT.h"
+#include "vmkit/JIT.h"
 
 #include "debug.h"
 

Modified: vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp Mon Nov 21 04:20:51 2011
@@ -14,7 +14,7 @@
 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/Target/TargetData.h"
 
-#include "mvm/JIT.h"
+#include "vmkit/JIT.h"
 
 #include "JavaClass.h"
 #include "JavaJIT.h"

Modified: vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp Mon Nov 21 04:20:51 2011
@@ -17,7 +17,7 @@
 #include "llvm/Target/TargetData.h"
 
 
-#include "mvm/JIT.h"
+#include "vmkit/JIT.h"
 
 #include "JavaConstantPool.h"
 #include "JavaString.h"

Modified: vmkit/trunk/lib/J3/VMCore/JNIReferences.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JNIReferences.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JNIReferences.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JNIReferences.h Mon Nov 21 04:20:51 2011
@@ -10,7 +10,7 @@
 #ifndef JNI_REFERENCES_H
 #define JNI_REFERENCES_H
 
-#include "mvm/Allocator.h"
+#include "vmkit/Allocator.h"
 
 namespace j3 {
 

Modified: vmkit/trunk/lib/J3/VMCore/JavaArray.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaArray.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaArray.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaArray.h Mon Nov 21 04:20:51 2011
@@ -14,7 +14,7 @@
 #ifndef JNJVM_JAVA_ARRAY_H
 #define JNJVM_JAVA_ARRAY_H
 
-#include "mvm/Allocator.h"
+#include "vmkit/Allocator.h"
 
 #include "types.h"
 

Modified: vmkit/trunk/lib/J3/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaClass.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaClass.h Mon Nov 21 04:20:51 2011
@@ -13,10 +13,10 @@
 
 #include "types.h"
 
-#include "mvm/Allocator.h"
-#include "mvm/MethodInfo.h"
-#include "mvm/Cond.h"
-#include "mvm/Locks.h"
+#include "vmkit/Allocator.h"
+#include "vmkit/MethodInfo.h"
+#include "vmkit/Cond.h"
+#include "vmkit/Locks.h"
 
 #include "JavaAccess.h"
 #include "JavaObject.h"

Modified: vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h Mon Nov 21 04:20:51 2011
@@ -10,7 +10,7 @@
 #ifndef JNJVM_JAVA_CONSTANT_POOL_H
 #define JNJVM_JAVA_CONSTANT_POOL_H
 
-#include "mvm/Allocator.h"
+#include "vmkit/Allocator.h"
 #include "types.h"
 
 #include "UTF8.h"

Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaObject.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaObject.cpp Mon Nov 21 04:20:51 2011
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "mvm/Locks.h"
+#include "vmkit/Locks.h"
 
 #include "JavaArray.h"
 #include "JavaClass.h"

Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaObject.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaObject.h Mon Nov 21 04:20:51 2011
@@ -10,10 +10,10 @@
 #ifndef JNJVM_JAVA_OBJECT_H
 #define JNJVM_JAVA_OBJECT_H
 
-#include "mvm/Allocator.h"
-#include "mvm/UTF8.h"
-#include "mvm/Locks.h"
-#include "mvm/Thread.h"
+#include "vmkit/Allocator.h"
+#include "vmkit/UTF8.h"
+#include "vmkit/Locks.h"
+#include "vmkit/Thread.h"
 #include "MvmGC.h"
 
 #include "types.h"

Modified: vmkit/trunk/lib/J3/VMCore/JavaThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaThread.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaThread.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaThread.cpp Mon Nov 21 04:20:51 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "mvm/Locks.h"
-#include "mvm/Thread.h"
+#include "vmkit/Locks.h"
+#include "vmkit/Thread.h"
 
 #include "JavaClass.h"
 #include "JavaObject.h"

Modified: vmkit/trunk/lib/J3/VMCore/JavaThread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaThread.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaThread.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaThread.h Mon Nov 21 04:20:51 2011
@@ -10,10 +10,10 @@
 #ifndef JNJVM_JAVA_THREAD_H
 #define JNJVM_JAVA_THREAD_H
 
-#include "mvm/Cond.h"
-#include "mvm/Locks.h"
-#include "mvm/ObjectLocks.h"
-#include "mvm/Thread.h"
+#include "vmkit/Cond.h"
+#include "vmkit/Locks.h"
+#include "vmkit/ObjectLocks.h"
+#include "vmkit/Thread.h"
 
 #include "MutatorThread.h"
 

Modified: vmkit/trunk/lib/J3/VMCore/JavaTypes.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaTypes.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaTypes.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaTypes.h Mon Nov 21 04:20:51 2011
@@ -12,7 +12,7 @@
 
 #include "types.h"
 
-#include "mvm/Allocator.h"
+#include "vmkit/Allocator.h"
 
 #include "JnjvmClassLoader.h"
 

Modified: vmkit/trunk/lib/J3/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jni.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Jni.cpp Mon Nov 21 04:20:51 2011
@@ -9,7 +9,7 @@
 
 #include <jni.h>
 
-#include "mvm/System.h"
+#include "vmkit/System.h"
 
 #include "ClasspathReflect.h"
 #include "JavaArray.h"

Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp Mon Nov 21 04:20:51 2011
@@ -18,7 +18,7 @@
 #include <string>
 #include "debug.h"
 
-#include "mvm/Thread.h"
+#include "vmkit/Thread.h"
 #include "MvmGC.h"
 
 #include "ClasspathReflect.h"

Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.h Mon Nov 21 04:20:51 2011
@@ -14,12 +14,12 @@
 
 #include "types.h"
 
-#include "mvm/Allocator.h"
-#include "mvm/MethodInfo.h"
-#include "mvm/VirtualMachine.h"
-#include "mvm/Cond.h"
-#include "mvm/Locks.h"
-#include "mvm/ObjectLocks.h"
+#include "vmkit/Allocator.h"
+#include "vmkit/MethodInfo.h"
+#include "vmkit/VirtualMachine.h"
+#include "vmkit/Cond.h"
+#include "vmkit/Locks.h"
+#include "vmkit/ObjectLocks.h"
 
 #include "JnjvmConfig.h"
 #include "JNIReferences.h"

Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp Mon Nov 21 04:20:51 2011
@@ -24,7 +24,7 @@
 #include <string>
 
 #include "debug.h"
-#include "mvm/Allocator.h"
+#include "vmkit/Allocator.h"
 
 #include "Classpath.h"
 #include "ClasspathReflect.h"

Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h Mon Nov 21 04:20:51 2011
@@ -17,7 +17,7 @@
 #include "types.h"
 
 
-#include "mvm/Allocator.h"
+#include "vmkit/Allocator.h"
 
 #include "JavaObject.h"
 #include "JnjvmConfig.h"

Modified: vmkit/trunk/lib/J3/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LockedMap.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LockedMap.h (original)
+++ vmkit/trunk/lib/J3/VMCore/LockedMap.h Mon Nov 21 04:20:51 2011
@@ -23,9 +23,9 @@
 
 #include "types.h"
 
-#include "mvm/Allocator.h"
-#include "mvm/MvmDenseMap.h"
-#include "mvm/Locks.h"
+#include "vmkit/Allocator.h"
+#include "vmkit/MvmDenseMap.h"
+#include "vmkit/Locks.h"
 #include "UTF8.h"
 
 namespace j3 {

Modified: vmkit/trunk/lib/J3/VMCore/Precompiled.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Precompiled.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Precompiled.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Precompiled.cpp Mon Nov 21 04:20:51 2011
@@ -9,7 +9,7 @@
 
 // for dlopen and dlsym
 #include <dlfcn.h> 
-#include "mvm/MethodInfo.h"
+#include "vmkit/MethodInfo.h"
 
 #include "JavaClass.h"
 #include "JavaUpcalls.h"

Modified: vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h (original)
+++ vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h Mon Nov 21 04:20:51 2011
@@ -10,7 +10,7 @@
 #ifndef J3_REFERENCE_QUEUE_H
 #define J3_REFERENCE_QUEUE_H
 
-#include "mvm/Locks.h"
+#include "vmkit/Locks.h"
 
 #include "JavaThread.h"
 

Modified: vmkit/trunk/lib/J3/VMCore/UTF8.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/UTF8.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/UTF8.h (original)
+++ vmkit/trunk/lib/J3/VMCore/UTF8.h Mon Nov 21 04:20:51 2011
@@ -12,7 +12,7 @@
 
 #include "types.h"
 
-#include "mvm/UTF8.h"
+#include "vmkit/UTF8.h"
 
 namespace j3 {
 	using mvm::UTF8;

Modified: vmkit/trunk/lib/J3/VMCore/Zip.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Zip.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Zip.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Zip.cpp Mon Nov 21 04:20:51 2011
@@ -9,7 +9,7 @@
 
 #include <zlib.h>
 
-#include "mvm/Allocator.h"
+#include "vmkit/Allocator.h"
 
 #include "JavaArray.h"
 #include "Reader.h"

Modified: vmkit/trunk/lib/J3/VMCore/Zip.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Zip.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Zip.h (original)
+++ vmkit/trunk/lib/J3/VMCore/Zip.h Mon Nov 21 04:20:51 2011
@@ -12,7 +12,7 @@
 
 #include <map>
 
-#include "mvm/Allocator.h"
+#include "vmkit/Allocator.h"
 
 namespace j3 {
 

Modified: vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp Mon Nov 21 04:20:51 2011
@@ -10,8 +10,8 @@
 #include <cassert>
 #include <signal.h>
 #include "MvmGC.h"
-#include "mvm/VirtualMachine.h"
-#include "mvm/CollectionRV.h"
+#include "vmkit/VirtualMachine.h"
+#include "vmkit/CollectionRV.h"
 
 #include "debug.h"
 

Modified: vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp Mon Nov 21 04:20:51 2011
@@ -9,11 +9,11 @@
 
 #include <cassert>
 
-#include "mvm/Cond.h"
-#include "mvm/Locks.h"
-#include "mvm/ObjectLocks.h"
-#include "mvm/Thread.h"
-#include "mvm/VirtualMachine.h"
+#include "vmkit/Cond.h"
+#include "vmkit/Locks.h"
+#include "vmkit/ObjectLocks.h"
+#include "vmkit/Thread.h"
+#include "vmkit/VirtualMachine.h"
 #include "MvmGC.h"
 #include <cerrno>
 #include <sys/time.h>

Modified: vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/Sigsegv.cpp Mon Nov 21 04:20:51 2011
@@ -8,10 +8,10 @@
 //===----------------------------------------------------------------------===//
 
 
-#include "mvm/MethodInfo.h"
-#include "mvm/System.h"
-#include "mvm/VirtualMachine.h"
-#include "mvm/Thread.h"
+#include "vmkit/MethodInfo.h"
+#include "vmkit/System.h"
+#include "vmkit/VirtualMachine.h"
+#include "vmkit/Thread.h"
 
 #include <csignal>
 #include <cstdio>

Modified: vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp Mon Nov 21 04:20:51 2011
@@ -9,10 +9,10 @@
 
 #include <cassert>
 
-#include "mvm/Cond.h"
-#include "mvm/Locks.h"
-#include "mvm/Thread.h"
-#include "mvm/VirtualMachine.h"
+#include "vmkit/Cond.h"
+#include "vmkit/Locks.h"
+#include "vmkit/Thread.h"
+#include "vmkit/VirtualMachine.h"
 #include "MvmGC.h"
 #include <cerrno>
 #include <sys/time.h>

Modified: vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp Mon Nov 21 04:20:51 2011
@@ -10,11 +10,11 @@
 #include "debug.h"
 
 #include "MvmGC.h"
-#include "mvm/MethodInfo.h"
-#include "mvm/VirtualMachine.h"
-#include "mvm/Cond.h"
-#include "mvm/Locks.h"
-#include "mvm/Thread.h"
+#include "vmkit/MethodInfo.h"
+#include "vmkit/VirtualMachine.h"
+#include "vmkit/Cond.h"
+#include "vmkit/Locks.h"
+#include "vmkit/Thread.h"
 
 #include <cassert>
 #include <cstdio>

Modified: vmkit/trunk/lib/Mvm/Compiler/Disassembler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/Disassembler.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/Disassembler.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/Disassembler.cpp Mon Nov 21 04:20:51 2011
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "mvm/JIT.h"
+#include "vmkit/JIT.h"
 
 #ifdef HAVE_DISASSEMBLER
 

Modified: vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp Mon Nov 21 04:20:51 2011
@@ -23,7 +23,7 @@
 #include <cstddef>
 #include <map>
 
-#include "mvm/GC.h"
+#include "vmkit/GC.h"
 
 using namespace llvm;
 

Modified: vmkit/trunk/lib/Mvm/Compiler/InlineMalloc.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/InlineMalloc.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/InlineMalloc.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/InlineMalloc.cpp Mon Nov 21 04:20:51 2011
@@ -19,7 +19,7 @@
 #include "llvm/Target/TargetData.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 
-#include "mvm/JIT.h"
+#include "vmkit/JIT.h"
 
 using namespace llvm;
 

Modified: vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/JIT.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/JIT.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/JIT.cpp Mon Nov 21 04:20:51 2011
@@ -37,12 +37,12 @@
 #include <llvm/Target/TargetOptions.h>
 #include <../lib/ExecutionEngine/JIT/JIT.h>
 
-#include "mvm/JIT.h"
-#include "mvm/Locks.h"
-#include "mvm/ObjectLocks.h"
-#include "mvm/Thread.h"
-#include "mvm/VirtualMachine.h"
-#include "mvm/GC.h"
+#include "vmkit/JIT.h"
+#include "vmkit/Locks.h"
+#include "vmkit/ObjectLocks.h"
+#include "vmkit/Thread.h"
+#include "vmkit/VirtualMachine.h"
+#include "vmkit/GC.h"
 #include "MutatorThread.h"
 #include "MvmGC.h"
 

Modified: vmkit/trunk/lib/Mvm/Compiler/VmkitGC.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/VmkitGC.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/VmkitGC.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/VmkitGC.cpp Mon Nov 21 04:20:51 2011
@@ -16,7 +16,7 @@
 #include "llvm/Support/Compiler.h"
 #include "llvm/Target/TargetInstrInfo.h"
 
-#include "mvm/JIT.h"
+#include "vmkit/JIT.h"
 
 using namespace llvm;
 

Modified: vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h (original)
+++ vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h Mon Nov 21 04:20:51 2011
@@ -11,8 +11,8 @@
 #ifndef MVM_MUTATOR_THREAD_H
 #define MVM_MUTATOR_THREAD_H
 
-#include "mvm/Allocator.h"
-#include "mvm/Thread.h"
+#include "vmkit/Allocator.h"
+#include "vmkit/Thread.h"
 
 namespace mvm {
 

Modified: vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp (original)
+++ vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp Mon Nov 21 04:20:51 2011
@@ -9,7 +9,7 @@
 
 #include "MvmGC.h"
 #include "MutatorThread.h"
-#include "mvm/VirtualMachine.h"
+#include "vmkit/VirtualMachine.h"
 
 #include <set>
 

Modified: vmkit/trunk/lib/Mvm/MMTk/MvmGC.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/MMTk/MvmGC.h?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/MMTk/MvmGC.h (original)
+++ vmkit/trunk/lib/Mvm/MMTk/MvmGC.h Mon Nov 21 04:20:51 2011
@@ -11,7 +11,7 @@
 #ifndef MVM_MMTK_GC_H
 #define MVM_MMTK_GC_H
 
-#include "mvm/GC.h"
+#include "vmkit/GC.h"
 #include <cstdlib>
 
 extern "C" void EmptyDestructor();

Modified: vmkit/trunk/lib/Mvm/Runtime/MethodInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/MethodInfo.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/MethodInfo.cpp (original)
+++ vmkit/trunk/lib/Mvm/Runtime/MethodInfo.cpp Mon Nov 21 04:20:51 2011
@@ -10,9 +10,9 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 
-#include "mvm/Allocator.h"
-#include "mvm/MethodInfo.h"
-#include "mvm/VirtualMachine.h"
+#include "vmkit/Allocator.h"
+#include "vmkit/MethodInfo.h"
+#include "vmkit/VirtualMachine.h"
 #include "MvmGC.h"
 
 #include <dlfcn.h>

Modified: vmkit/trunk/lib/Mvm/Runtime/Object.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/Object.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/Object.cpp (original)
+++ vmkit/trunk/lib/Mvm/Runtime/Object.cpp Mon Nov 21 04:20:51 2011
@@ -11,7 +11,7 @@
 #include <cstdlib>
 
 #include "MvmGC.h"
-#include "mvm/VirtualMachine.h"
+#include "vmkit/VirtualMachine.h"
 
 using namespace mvm;
 

Modified: vmkit/trunk/lib/Mvm/Runtime/UTF8.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/UTF8.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/UTF8.cpp (original)
+++ vmkit/trunk/lib/Mvm/Runtime/UTF8.cpp Mon Nov 21 04:20:51 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "mvm/Allocator.h"
-#include "mvm/UTF8.h"
+#include "vmkit/Allocator.h"
+#include "vmkit/UTF8.h"
 
 namespace mvm {
 

Modified: vmkit/trunk/mmtk/magic/LowerMagic.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/magic/LowerMagic.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/mmtk/magic/LowerMagic.cpp (original)
+++ vmkit/trunk/mmtk/magic/LowerMagic.cpp Mon Nov 21 04:20:51 2011
@@ -20,7 +20,7 @@
 
 #include <cstdio>
 
-#include "mvm/System.h"
+#include "vmkit/System.h"
 
 using namespace llvm;
 

Modified: vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp Mon Nov 21 04:20:51 2011
@@ -11,7 +11,7 @@
 #include "MvmGC.h"
 #include "../mmtk-j3/MMTkObject.h"
 
-#include "mvm/VirtualMachine.h"
+#include "vmkit/VirtualMachine.h"
 
 #include <sys/mman.h>
 #include <set>

Modified: vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp Mon Nov 21 04:20:51 2011
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "debug.h"
-#include "mvm/VirtualMachine.h"
+#include "vmkit/VirtualMachine.h"
 #include "MMTkObject.h"
 #include "MutatorThread.h"
 

Modified: vmkit/trunk/mmtk/mmtk-j3/Collection.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Collection.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Collection.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Collection.cpp Mon Nov 21 04:20:51 2011
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "debug.h"
-#include "mvm/VirtualMachine.h"
+#include "vmkit/VirtualMachine.h"
 #include "MMTkObject.h"
 #include "MvmGC.h"
 

Modified: vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp Mon Nov 21 04:20:51 2011
@@ -9,7 +9,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "debug.h"
-#include "mvm/VirtualMachine.h"
+#include "vmkit/VirtualMachine.h"
 #include "MMTkObject.h"
 
 namespace mmtk {

Modified: vmkit/trunk/mmtk/mmtk-j3/Memory.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Memory.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Memory.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Memory.cpp Mon Nov 21 04:20:51 2011
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "debug.h"
-#include "mvm/VirtualMachine.h"
+#include "vmkit/VirtualMachine.h"
 #include "MMTkObject.h"
 
 #include <sys/mman.h>

Modified: vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp Mon Nov 21 04:20:51 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "mvm/System.h"
-#include "mvm/VirtualMachine.h"
+#include "vmkit/System.h"
+#include "vmkit/VirtualMachine.h"
 #include "MMTkObject.h"
 #include "debug.h"
 

Modified: vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp Mon Nov 21 04:20:51 2011
@@ -9,7 +9,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "debug.h"
-#include "mvm/VirtualMachine.h"
+#include "vmkit/VirtualMachine.h"
 #include "MMTkObject.h"
 
 namespace mmtk {

Modified: vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp Mon Nov 21 04:20:51 2011
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "debug.h"
-#include "mvm/VirtualMachine.h"
+#include "vmkit/VirtualMachine.h"
 #include "MMTkObject.h"
 #include "MvmGC.h"
 

Modified: vmkit/trunk/mmtk/mmtk-j3/Strings.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Strings.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Strings.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Strings.cpp Mon Nov 21 04:20:51 2011
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "mvm/Thread.h"
+#include "vmkit/Thread.h"
 
 #include "MMTkObject.h"
 

Modified: vmkit/trunk/tools/j3/Main.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/j3/Main.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/tools/j3/Main.cpp (original)
+++ vmkit/trunk/tools/j3/Main.cpp Mon Nov 21 04:20:51 2011
@@ -8,10 +8,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "MvmGC.h"
-#include "mvm/JIT.h"
-#include "mvm/MethodInfo.h"
-#include "mvm/VirtualMachine.h"
-#include "mvm/Thread.h"
+#include "vmkit/JIT.h"
+#include "vmkit/MethodInfo.h"
+#include "vmkit/VirtualMachine.h"
+#include "vmkit/Thread.h"
 
 #include "j3/JavaJITCompiler.h"
 #include "../../lib/J3/VMCore/JnjvmClassLoader.h"

Modified: vmkit/trunk/tools/precompiler/Precompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/precompiler/Precompiler.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/tools/precompiler/Precompiler.cpp (original)
+++ vmkit/trunk/tools/precompiler/Precompiler.cpp Mon Nov 21 04:20:51 2011
@@ -16,10 +16,10 @@
 #include "llvm/Support/Signals.h"
 
 #include "MvmGC.h"
-#include "mvm/JIT.h"
-#include "mvm/MethodInfo.h"
-#include "mvm/VirtualMachine.h"
-#include "mvm/Thread.h"
+#include "vmkit/JIT.h"
+#include "vmkit/MethodInfo.h"
+#include "vmkit/VirtualMachine.h"
+#include "vmkit/Thread.h"
 
 #include "j3/JavaAOTCompiler.h"
 #include "j3/JavaJITCompiler.h"

Modified: vmkit/trunk/tools/vmjc/vmjc.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmjc/vmjc.cpp?rev=145030&r1=145029&r2=145030&view=diff
==============================================================================
--- vmkit/trunk/tools/vmjc/vmjc.cpp (original)
+++ vmkit/trunk/tools/vmjc/vmjc.cpp Mon Nov 21 04:20:51 2011
@@ -39,9 +39,9 @@
 
 
 #include "MvmGC.h"
-#include "mvm/JIT.h"
-#include "mvm/VirtualMachine.h"
-#include "mvm/Thread.h"
+#include "vmkit/JIT.h"
+#include "vmkit/VirtualMachine.h"
+#include "vmkit/Thread.h"
 
 #include "j3/JavaAOTCompiler.h"
 




From gael.thomas at lip6.fr  Mon Nov 21 02:22:22 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Mon, 21 Nov 2011 10:22:22 -0000
Subject: [vmkit-commits] [vmkit] r145031 - in /vmkit/trunk: include/types.h
 include/vmkit/Allocator.h include/vmkit/CollectionRV.h include/vmkit/Cond.h
 include/vmkit/GC.h include/vmkit/JIT.h include/vmkit/Locks.h
 include/vmkit/MethodInfo.h include/vmkit/MvmDenseMap.h
 include/vmkit/MvmDenseSet.h include/vmkit/ObjectLocks.h
 include/vmkit/System.h include/vmkit/Thread.h
 include/vmkit/VirtualMachine.h lib/Mvm/MMTk/MutatorThread.h
 lib/Mvm/MMTk/MvmGC.h
Message-ID: <20111121102223.2AF132A6C134@llvm.org>

Author: gthomas
Date: Mon Nov 21 04:22:22 2011
New Revision: 145031

URL: http://llvm.org/viewvc/llvm-project?rev=145031&view=rev
Log:
MVM in files is now VMKIT

Modified:
    vmkit/trunk/include/types.h
    vmkit/trunk/include/vmkit/Allocator.h
    vmkit/trunk/include/vmkit/CollectionRV.h
    vmkit/trunk/include/vmkit/Cond.h
    vmkit/trunk/include/vmkit/GC.h
    vmkit/trunk/include/vmkit/JIT.h
    vmkit/trunk/include/vmkit/Locks.h
    vmkit/trunk/include/vmkit/MethodInfo.h
    vmkit/trunk/include/vmkit/MvmDenseMap.h
    vmkit/trunk/include/vmkit/MvmDenseSet.h
    vmkit/trunk/include/vmkit/ObjectLocks.h
    vmkit/trunk/include/vmkit/System.h
    vmkit/trunk/include/vmkit/Thread.h
    vmkit/trunk/include/vmkit/VirtualMachine.h
    vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h
    vmkit/trunk/lib/Mvm/MMTk/MvmGC.h

Modified: vmkit/trunk/include/types.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/types.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/types.h (original)
+++ vmkit/trunk/include/types.h Mon Nov 21 04:22:22 2011
@@ -1,6 +1,6 @@
 //===------------------- types.h - bitsized types -------------------------===//
 //
-//                              MVM
+//                              VMKIT
 //
 // This file is distributed under the University of Illinois Open Source 
 // License. See LICENSE.TXT for details.

Modified: vmkit/trunk/include/vmkit/Allocator.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Allocator.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Allocator.h (original)
+++ vmkit/trunk/include/vmkit/Allocator.h Mon Nov 21 04:22:22 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MVM_ALLOCATOR_H
-#define MVM_ALLOCATOR_H
+#ifndef VMKIT_ALLOCATOR_H
+#define VMKIT_ALLOCATOR_H
 
 #include "llvm/Support/Allocator.h"
 #include "vmkit/Locks.h"
@@ -77,4 +77,4 @@
 
 } // end namespace mvm
 
-#endif // MVM_ALLOCATOR_H
+#endif // VMKIT_ALLOCATOR_H

Modified: vmkit/trunk/include/vmkit/CollectionRV.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/CollectionRV.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/CollectionRV.h (original)
+++ vmkit/trunk/include/vmkit/CollectionRV.h Mon Nov 21 04:22:22 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _MVM_COLLECTIONRV_H_
-#define _MVM_COLLECTIONRV_H_
+#ifndef _VMKIT_COLLECTIONRV_H_
+#define _VMKIT_COLLECTIONRV_H_
 
 #include "vmkit/Cond.h"
 #include "vmkit/Locks.h"

Modified: vmkit/trunk/include/vmkit/Cond.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Cond.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Cond.h (original)
+++ vmkit/trunk/include/vmkit/Cond.h Mon Nov 21 04:22:22 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MVM_COND_H
-#define MVM_COND_H
+#ifndef VMKIT_COND_H
+#define VMKIT_COND_H
 
 #include <cstdlib>
 #include <pthread.h>
@@ -31,4 +31,4 @@
 
 } // end namespace mvm
 
-#endif // MVM_COND_H
+#endif // VMKIT_COND_H

Modified: vmkit/trunk/include/vmkit/GC.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/GC.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/GC.h (original)
+++ vmkit/trunk/include/vmkit/GC.h Mon Nov 21 04:22:22 2011
@@ -8,8 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 
-#ifndef MVM_GC_H
-#define MVM_GC_H
+#ifndef VMKIT_GC_H
+#define VMKIT_GC_H
 
 #include <stdint.h>
 #include "vmkit/System.h"

Modified: vmkit/trunk/include/vmkit/JIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/JIT.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/JIT.h (original)
+++ vmkit/trunk/include/vmkit/JIT.h Mon Nov 21 04:22:22 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MVM_JIT_H
-#define MVM_JIT_H
+#ifndef VMKIT_JIT_H
+#define VMKIT_JIT_H
 
 #include <cfloat>
 #include <cmath>
@@ -194,4 +194,4 @@
 
 } // end namespace mvm
 
-#endif // MVM_JIT_H
+#endif // VMKIT_JIT_H

Modified: vmkit/trunk/include/vmkit/Locks.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Locks.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Locks.h (original)
+++ vmkit/trunk/include/vmkit/Locks.h Mon Nov 21 04:22:22 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MVM_LOCKS_H
-#define MVM_LOCKS_H
+#ifndef VMKIT_LOCKS_H
+#define VMKIT_LOCKS_H
 
 #include <pthread.h>
 #include <cassert>
@@ -178,4 +178,4 @@
 
 } // end namespace mvm
 
-#endif // MVM_LOCKS_H
+#endif // VMKIT_LOCKS_H

Modified: vmkit/trunk/include/vmkit/MethodInfo.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/MethodInfo.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/MethodInfo.h (original)
+++ vmkit/trunk/include/vmkit/MethodInfo.h Mon Nov 21 04:22:22 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MVM_METHODINFO_H
-#define MVM_METHODINFO_H
+#ifndef VMKIT_METHODINFO_H
+#define VMKIT_METHODINFO_H
 
 #include "vmkit/Allocator.h"
 #include "vmkit/System.h"
@@ -96,4 +96,4 @@
 };
 
 } // end namespace mvm
-#endif // MVM_METHODINFO_H
+#endif // VMKIT_METHODINFO_H

Modified: vmkit/trunk/include/vmkit/MvmDenseMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/MvmDenseMap.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/MvmDenseMap.h (original)
+++ vmkit/trunk/include/vmkit/MvmDenseMap.h Mon Nov 21 04:22:22 2011
@@ -12,8 +12,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MVM_DENSEMAP_H
-#define MVM_DENSEMAP_H
+#ifndef VMKIT_DENSEMAP_H
+#define VMKIT_DENSEMAP_H
 
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"

Modified: vmkit/trunk/include/vmkit/MvmDenseSet.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/MvmDenseSet.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/MvmDenseSet.h (original)
+++ vmkit/trunk/include/vmkit/MvmDenseSet.h Mon Nov 21 04:22:22 2011
@@ -12,8 +12,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MVM_DENSESET_H
-#define MVM_DENSESET_H
+#ifndef VMKIT_DENSESET_H
+#define VMKIT_DENSESET_H
 
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/Support/MathExtras.h"

Modified: vmkit/trunk/include/vmkit/ObjectLocks.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/ObjectLocks.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/ObjectLocks.h (original)
+++ vmkit/trunk/include/vmkit/ObjectLocks.h Mon Nov 21 04:22:22 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MVM_OBJECT_LOCKS_H
-#define MVM_OBJECT_LOCKS_H
+#ifndef VMKIT_OBJECT_LOCKS_H
+#define VMKIT_OBJECT_LOCKS_H
 
 #include "vmkit/Allocator.h"
 #include "vmkit/GC.h"
@@ -198,4 +198,4 @@
 
 } // end namespace mvm
 
-#endif // MVM_OBJECT_LOCKS_H
+#endif // VMKIT_OBJECT_LOCKS_H

Modified: vmkit/trunk/include/vmkit/System.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/System.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/System.h (original)
+++ vmkit/trunk/include/vmkit/System.h Mon Nov 21 04:22:22 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MVM_SYSTEM_H
-#define MVM_SYSTEM_H
+#ifndef VMKIT_SYSTEM_H
+#define VMKIT_SYSTEM_H
 
 #include <csetjmp>
 #include <cstring>

Modified: vmkit/trunk/include/vmkit/Thread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Thread.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Thread.h (original)
+++ vmkit/trunk/include/vmkit/Thread.h Mon Nov 21 04:22:22 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MVM_THREAD_H
-#define MVM_THREAD_H
+#ifndef VMKIT_THREAD_H
+#define VMKIT_THREAD_H
 
 #include <cassert>
 #include <cstdio>
@@ -340,4 +340,4 @@
 
 
 } // end namespace mvm
-#endif // MVM_THREAD_H
+#endif // VMKIT_THREAD_H

Modified: vmkit/trunk/include/vmkit/VirtualMachine.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/VirtualMachine.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/VirtualMachine.h (original)
+++ vmkit/trunk/include/vmkit/VirtualMachine.h Mon Nov 21 04:22:22 2011
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MVM_VIRTUALMACHINE_H
-#define MVM_VIRTUALMACHINE_H
+#ifndef VMKIT_VIRTUALMACHINE_H
+#define VMKIT_VIRTUALMACHINE_H
 
 #include "llvm/ADT/DenseMap.h"
 
@@ -234,4 +234,4 @@
 };
 
 } // end namespace mvm
-#endif // MVM_VIRTUALMACHINE_H
+#endif // VMKIT_VIRTUALMACHINE_H

Modified: vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h (original)
+++ vmkit/trunk/lib/Mvm/MMTk/MutatorThread.h Mon Nov 21 04:22:22 2011
@@ -8,8 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 
-#ifndef MVM_MUTATOR_THREAD_H
-#define MVM_MUTATOR_THREAD_H
+#ifndef VMKIT_MUTATOR_THREAD_H
+#define VMKIT_MUTATOR_THREAD_H
 
 #include "vmkit/Allocator.h"
 #include "vmkit/Thread.h"

Modified: vmkit/trunk/lib/Mvm/MMTk/MvmGC.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/MMTk/MvmGC.h?rev=145031&r1=145030&r2=145031&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/MMTk/MvmGC.h (original)
+++ vmkit/trunk/lib/Mvm/MMTk/MvmGC.h Mon Nov 21 04:22:22 2011
@@ -8,8 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 
-#ifndef MVM_MMTK_GC_H
-#define MVM_MMTK_GC_H
+#ifndef VMKIT_MMTK_GC_H
+#define VMKIT_MMTK_GC_H
 
 #include "vmkit/GC.h"
 #include <cstdlib>




From gael.thomas at lip6.fr  Mon Nov 21 02:28:44 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Mon, 21 Nov 2011 10:28:44 -0000
Subject: [vmkit-commits] [vmkit] r145032 - in /vmkit/trunk: lib/J3/ClassLib/
 lib/J3/ClassLib/GNUClasspath/ lib/J3/ClassLib/OpenJDK/ lib/J3/Compiler/
 lib/J3/VMCore/ lib/Mvm/CommonThread/ lib/Mvm/Compiler/ lib/Mvm/MMTk/
 lib/Mvm/Runtime/ mmtk/mmtk-alloc/ mmtk/mmtk-j3/ tools/j3/
 tools/precompiler/ tools/vmjc/
Message-ID: <20111121102844.B90312A6C134@llvm.org>

Author: gthomas
Date: Mon Nov 21 04:28:44 2011
New Revision: 145032

URL: http://llvm.org/viewvc/llvm-project?rev=145032&view=rev
Log:
MvmGC.* are now VmkitGC.*

Added:
    vmkit/trunk/lib/Mvm/MMTk/VmkitGC.cpp
      - copied, changed from r145030, vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp
    vmkit/trunk/lib/Mvm/MMTk/VmkitGC.h
      - copied, changed from r145031, vmkit/trunk/lib/Mvm/MMTk/MvmGC.h
Removed:
    vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp
    vmkit/trunk/lib/Mvm/MMTk/MvmGC.h
Modified:
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
    vmkit/trunk/lib/J3/ClassLib/VMStaticInstance.h
    vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp
    vmkit/trunk/lib/J3/VMCore/JavaObject.h
    vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
    vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
    vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
    vmkit/trunk/lib/Mvm/Runtime/MethodInfo.cpp
    vmkit/trunk/lib/Mvm/Runtime/Object.cpp
    vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp
    vmkit/trunk/mmtk/mmtk-j3/Collection.cpp
    vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h
    vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp
    vmkit/trunk/tools/j3/Main.cpp
    vmkit/trunk/tools/precompiler/Precompiler.cpp
    vmkit/trunk/tools/vmjc/vmjc.cpp

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h Mon Nov 21 04:28:44 2011
@@ -10,7 +10,7 @@
 #ifndef JNJVM_CLASSPATH_REFLECT_H
 #define JNJVM_CLASSPATH_REFLECT_H
 
-#include "MvmGC.h"
+#include "VmkitGC.h"
 
 #include "JavaClass.h"
 #include "JavaObject.h"

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc Mon Nov 21 04:28:44 2011
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 
-#include "MvmGC.h"
+#include "VmkitGC.h"
 
 #include "types.h"
 

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h Mon Nov 21 04:28:44 2011
@@ -10,7 +10,7 @@
 #ifndef JNJVM_CLASSPATH_REFLECT_H
 #define JNJVM_CLASSPATH_REFLECT_H
 
-#include "MvmGC.h"
+#include "VmkitGC.h"
 
 #include "JavaClass.h"
 #include "JavaObject.h"

Modified: vmkit/trunk/lib/J3/ClassLib/VMStaticInstance.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/VMStaticInstance.h?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/VMStaticInstance.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/VMStaticInstance.h Mon Nov 21 04:28:44 2011
@@ -12,7 +12,7 @@
 
 #include "ClasspathReflect.h"
 #include "JavaObject.h"
-#include "MvmGC.h"
+#include "VmkitGC.h"
 
 namespace j3 {
 

Modified: vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp Mon Nov 21 04:28:44 2011
@@ -25,7 +25,7 @@
 #include "llvm/Target/TargetData.h"
 #include <../lib/ExecutionEngine/JIT/JIT.h>
 
-#include "MvmGC.h"
+#include "VmkitGC.h"
 #include "vmkit/VirtualMachine.h"
 
 #include "JavaClass.h"

Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.h?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaObject.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaObject.h Mon Nov 21 04:28:44 2011
@@ -14,7 +14,7 @@
 #include "vmkit/UTF8.h"
 #include "vmkit/Locks.h"
 #include "vmkit/Thread.h"
-#include "MvmGC.h"
+#include "VmkitGC.h"
 
 #include "types.h"
 

Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp Mon Nov 21 04:28:44 2011
@@ -19,7 +19,7 @@
 #include "debug.h"
 
 #include "vmkit/Thread.h"
-#include "MvmGC.h"
+#include "VmkitGC.h"
 
 #include "ClasspathReflect.h"
 #include "JavaArray.h"

Modified: vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/CollectionRV.cpp Mon Nov 21 04:28:44 2011
@@ -9,7 +9,7 @@
 
 #include <cassert>
 #include <signal.h>
-#include "MvmGC.h"
+#include "VmkitGC.h"
 #include "vmkit/VirtualMachine.h"
 #include "vmkit/CollectionRV.h"
 

Modified: vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ObjectLocks.cpp Mon Nov 21 04:28:44 2011
@@ -14,7 +14,7 @@
 #include "vmkit/ObjectLocks.h"
 #include "vmkit/Thread.h"
 #include "vmkit/VirtualMachine.h"
-#include "MvmGC.h"
+#include "VmkitGC.h"
 #include <cerrno>
 #include <sys/time.h>
 #include <pthread.h>

Modified: vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp Mon Nov 21 04:28:44 2011
@@ -13,7 +13,7 @@
 #include "vmkit/Locks.h"
 #include "vmkit/Thread.h"
 #include "vmkit/VirtualMachine.h"
-#include "MvmGC.h"
+#include "VmkitGC.h"
 #include <cerrno>
 #include <sys/time.h>
 #include <pthread.h>

Modified: vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp Mon Nov 21 04:28:44 2011
@@ -9,7 +9,7 @@
 
 #include "debug.h"
 
-#include "MvmGC.h"
+#include "VmkitGC.h"
 #include "vmkit/MethodInfo.h"
 #include "vmkit/VirtualMachine.h"
 #include "vmkit/Cond.h"

Modified: vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/JIT.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/JIT.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/JIT.cpp Mon Nov 21 04:28:44 2011
@@ -44,7 +44,7 @@
 #include "vmkit/VirtualMachine.h"
 #include "vmkit/GC.h"
 #include "MutatorThread.h"
-#include "MvmGC.h"
+#include "VmkitGC.h"
 
 #include <dlfcn.h>
 #include <sys/mman.h>

Removed: vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp?rev=145031&view=auto
==============================================================================
--- vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp (original)
+++ vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp (removed)
@@ -1,155 +0,0 @@
-//===----------- MvmGC.cpp - Garbage Collection Interface -----------------===//
-//
-//                     The VMKit project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "MvmGC.h"
-#include "MutatorThread.h"
-#include "vmkit/VirtualMachine.h"
-
-#include <set>
-
-using namespace mvm;
-
-static mvm::SpinLock lock;
-std::set<gc*> __InternalSet__;
-int Collector::verbose = 0;
-
-extern "C" void* gcmalloc(uint32_t sz, void* _VT) {
-  gc* res = 0;
-  VirtualTable* VT = (VirtualTable*)_VT;
-  sz = llvm::RoundUpToAlignment(sz, sizeof(void*));
-  res = (gc*)malloc(sz);
-  memset((void*)res, 0, sz);
-  
-  lock.acquire();
-  __InternalSet__.insert(res);
-  lock.release();
-  
-  res->setVirtualTable(VT);
-  return res;
-}
-
-extern "C" void* gcmallocUnresolved(uint32_t sz, VirtualTable* VT) {
-  gc* res = (gc*)gcmalloc(sz, VT);
-  if (VT->hasDestructor())
-    mvm::Thread::get()->MyVM->addFinalizationCandidate(res);
-  return res;
-}
-
-extern "C" void addFinalizationCandidate(gc* obj) {
-  mvm::Thread::get()->MyVM->addFinalizationCandidate(obj);
-}
-
-extern "C" void* AllocateMagicArray(int32_t sz, void* length) {
-  gc* res = (gc*)malloc(sz);
-  memset((void*)res, 0, sz);
-  ((void**)res)[0] = length;
-  return res;
-}
-
-void* Collector::begOf(gc* obj) {
-  lock.acquire();
-  std::set<gc*>::iterator I = __InternalSet__.find(obj);
-  std::set<gc*>::iterator E = __InternalSet__.end();
-  lock.release();
-    
-  if (I != E) return obj;
-  return 0;
-}
-
-void MutatorThread::init(Thread* _th) {
-  MutatorThread* th = (MutatorThread*)_th;
-  th->realRoutine(_th);
-}
-
-bool Collector::isLive(gc* ptr, word_t closure) {
-  abort();
-  return false;
-}
-
-void Collector::scanObject(void** ptr, word_t closure) {
-  abort();
-}
- 
-void Collector::markAndTrace(void* source, void* ptr, word_t closure) {
-  abort();
-}
-  
-void Collector::markAndTraceRoot(void* ptr, word_t closure) {
-  abort();
-}
-
-gc* Collector::retainForFinalize(gc* val, word_t closure) {
-  abort();
-  return NULL;
-}
-  
-gc* Collector::retainReferent(gc* val, word_t closure) {
-  abort();
-  return NULL;
-}
-  
-gc* Collector::getForwardedFinalizable(gc* val, word_t closure) {
-  abort();
-  return NULL;
-}
-  
-gc* Collector::getForwardedReference(gc* val, word_t closure) {
-  abort();
-  return NULL;
-}
-  
-gc* Collector::getForwardedReferent(gc* val, word_t closure) {
-  abort();
-  return NULL;
-}
-
-extern "C" void arrayWriteBarrier(void* ref, void** ptr, void* value) {
-  *ptr = value;
-}
-
-extern "C" void fieldWriteBarrier(void* ref, void** ptr, void* value) {
-  *ptr = value;
-}
-
-extern "C" void nonHeapWriteBarrier(void** ptr, void* value) {
-  *ptr = value;
-}
-
-
-void Collector::objectReferenceWriteBarrier(gc* ref, gc** slot, gc* value) {
-  *slot = value;
-}
-
-void Collector::objectReferenceArrayWriteBarrier(gc* ref, gc** slot, gc* value) {
-  *slot = value;
-}
-
-void Collector::objectReferenceNonHeapWriteBarrier(gc** slot, gc* value) {
-  *slot = value;
-}
-
-bool Collector::objectReferenceTryCASBarrier(gc*ref, gc** slot, gc* old, gc* value) {
-  gc* res = __sync_val_compare_and_swap(slot, old, value);
-  return (old == res);
-}
-
-void Collector::collect() {
-  // Do nothing.
-}
-
-void Collector::initialise(int argc, char** argv) {
-}
-
-bool Collector::needsWriteBarrier() {
-  return false;
-}
-
-bool Collector::needsNonHeapWriteBarrier() {
-  return false;
-}

Removed: vmkit/trunk/lib/Mvm/MMTk/MvmGC.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/MMTk/MvmGC.h?rev=145031&view=auto
==============================================================================
--- vmkit/trunk/lib/Mvm/MMTk/MvmGC.h (original)
+++ vmkit/trunk/lib/Mvm/MMTk/MvmGC.h (removed)
@@ -1,123 +0,0 @@
-//===----------- MvmGC.h - Garbage Collection Interface -------------------===//
-//
-//                     The VMKit project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-
-#ifndef VMKIT_MMTK_GC_H
-#define VMKIT_MMTK_GC_H
-
-#include "vmkit/GC.h"
-#include <cstdlib>
-
-extern "C" void EmptyDestructor();
-
-class VirtualTable {
- public:
-  word_t destructor;
-  word_t operatorDelete;
-  word_t tracer;
-  word_t specializedTracers[1];
-  
-  static uint32_t numberOfBaseFunctions() {
-    return 4;
-  }
-
-  static uint32_t numberOfSpecializedTracers() {
-    return 1;
-  }
-
-  word_t* getFunctions() {
-    return &destructor;
-  }
-
-  VirtualTable(word_t d, word_t o, word_t t) {
-    destructor = d;
-    operatorDelete = o;
-    tracer = t;
-  }
-
-  VirtualTable() {
-    destructor = reinterpret_cast<word_t>(EmptyDestructor);
-  }
-
-  bool hasDestructor() {
-    return destructor != reinterpret_cast<word_t>(EmptyDestructor);
-  }
-
-  static void emptyTracer(void*) {}
-};
-
-extern "C" void* gcmallocUnresolved(uint32_t sz, VirtualTable* VT);
-extern "C" void* gcmalloc(uint32_t sz, void* VT);
-
-class gc : public gcRoot {
-public:
-
-  size_t objectSize() const {
-    abort();
-    return 0;
-  }
-
-  void* operator new(size_t sz, VirtualTable *VT) {
-    return gcmallocUnresolved(sz, VT);
-  }
-};
-
-extern "C" void arrayWriteBarrier(void* ref, void** ptr, void* value);
-extern "C" void fieldWriteBarrier(void* ref, void** ptr, void* value);
-extern "C" void nonHeapWriteBarrier(void** ptr, void* value);
-
-namespace mvm {
-  
-class Collector {
-public:
-  static int verbose;
-
-  static bool isLive(gc* ptr, word_t closure) __attribute__ ((always_inline)); 
-  static void scanObject(void** ptr, word_t closure) __attribute__ ((always_inline));
-  static void markAndTrace(void* source, void* ptr, word_t closure) __attribute__ ((always_inline));
-  static void markAndTraceRoot(void* ptr, word_t closure) __attribute__ ((always_inline));
-  static gc*  retainForFinalize(gc* val, word_t closure) __attribute__ ((always_inline));
-  static gc*  retainReferent(gc* val, word_t closure) __attribute__ ((always_inline));
-  static gc*  getForwardedFinalizable(gc* val, word_t closure) __attribute__ ((always_inline));
-  static gc*  getForwardedReference(gc* val, word_t closure) __attribute__ ((always_inline));
-  static gc*  getForwardedReferent(gc* val, word_t closure) __attribute__ ((always_inline));
-  static void objectReferenceWriteBarrier(gc* ref, gc** slot, gc* value) __attribute__ ((always_inline));
-  static void objectReferenceArrayWriteBarrier(gc* ref, gc** slot, gc* value) __attribute__ ((always_inline));
-  static void objectReferenceNonHeapWriteBarrier(gc** slot, gc* value) __attribute__ ((always_inline));
-  static bool objectReferenceTryCASBarrier(gc* ref, gc** slot, gc* old, gc* value) __attribute__ ((always_inline));
-  static bool needsWriteBarrier() __attribute__ ((always_inline));
-  static bool needsNonHeapWriteBarrier() __attribute__ ((always_inline));
-
-  static void collect();
-  
-  static void initialise(int argc, char** argv);
-  
-  static int getMaxMemory() {
-    return 0;
-  }
-  
-  static int getFreeMemory() {
-    return 0;
-  }
-  
-  static int getTotalMemory() {
-    return 0;
-  }
-
-  void setMaxMemory(size_t sz){
-  }
-
-  void setMinMemory(size_t sz){
-  }
-
-  static void* begOf(gc*);
-};
-
-}
-#endif

Copied: vmkit/trunk/lib/Mvm/MMTk/VmkitGC.cpp (from r145030, vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/MMTk/VmkitGC.cpp?p2=vmkit/trunk/lib/Mvm/MMTk/VmkitGC.cpp&p1=vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp&r1=145030&r2=145032&rev=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/MMTk/MvmGC.cpp (original)
+++ vmkit/trunk/lib/Mvm/MMTk/VmkitGC.cpp Mon Nov 21 04:28:44 2011
@@ -1,4 +1,4 @@
-//===----------- MvmGC.cpp - Garbage Collection Interface -----------------===//
+//===----------- VmkitGC.cpp - Garbage Collection Interface -----------------===//
 //
 //                     The VMKit project
 //
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "MvmGC.h"
+#include "VmkitGC.h"
 #include "MutatorThread.h"
 #include "vmkit/VirtualMachine.h"
 

Copied: vmkit/trunk/lib/Mvm/MMTk/VmkitGC.h (from r145031, vmkit/trunk/lib/Mvm/MMTk/MvmGC.h)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/MMTk/VmkitGC.h?p2=vmkit/trunk/lib/Mvm/MMTk/VmkitGC.h&p1=vmkit/trunk/lib/Mvm/MMTk/MvmGC.h&r1=145031&r2=145032&rev=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/MMTk/MvmGC.h (original)
+++ vmkit/trunk/lib/Mvm/MMTk/VmkitGC.h Mon Nov 21 04:28:44 2011
@@ -1,4 +1,4 @@
-//===----------- MvmGC.h - Garbage Collection Interface -------------------===//
+//===----------- VmkitGC.h - Garbage Collection Interface -------------------===//
 //
 //                     The VMKit project
 //

Modified: vmkit/trunk/lib/Mvm/Runtime/MethodInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/MethodInfo.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/MethodInfo.cpp (original)
+++ vmkit/trunk/lib/Mvm/Runtime/MethodInfo.cpp Mon Nov 21 04:28:44 2011
@@ -13,7 +13,7 @@
 #include "vmkit/Allocator.h"
 #include "vmkit/MethodInfo.h"
 #include "vmkit/VirtualMachine.h"
-#include "MvmGC.h"
+#include "VmkitGC.h"
 
 #include <dlfcn.h>
 

Modified: vmkit/trunk/lib/Mvm/Runtime/Object.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/Object.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/Object.cpp (original)
+++ vmkit/trunk/lib/Mvm/Runtime/Object.cpp Mon Nov 21 04:28:44 2011
@@ -10,7 +10,7 @@
 #include <cstdio>
 #include <cstdlib>
 
-#include "MvmGC.h"
+#include "VmkitGC.h"
 #include "vmkit/VirtualMachine.h"
 
 using namespace mvm;

Modified: vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp Mon Nov 21 04:28:44 2011
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "MutatorThread.h"
-#include "MvmGC.h"
+#include "VmkitGC.h"
 #include "../mmtk-j3/MMTkObject.h"
 
 #include "vmkit/VirtualMachine.h"

Modified: vmkit/trunk/mmtk/mmtk-j3/Collection.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Collection.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Collection.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Collection.cpp Mon Nov 21 04:28:44 2011
@@ -10,7 +10,7 @@
 #include "debug.h"
 #include "vmkit/VirtualMachine.h"
 #include "MMTkObject.h"
-#include "MvmGC.h"
+#include "VmkitGC.h"
 
 namespace mmtk {
 

Modified: vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h (original)
+++ vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h Mon Nov 21 04:28:44 2011
@@ -12,7 +12,7 @@
 
 #include <stdint.h>
 #include "MutatorThread.h"
-#include "MvmGC.h"
+#include "VmkitGC.h"
 
 namespace mmtk {
 

Modified: vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp Mon Nov 21 04:28:44 2011
@@ -10,7 +10,7 @@
 #include "debug.h"
 #include "vmkit/VirtualMachine.h"
 #include "MMTkObject.h"
-#include "MvmGC.h"
+#include "VmkitGC.h"
 
 namespace mmtk {
 

Modified: vmkit/trunk/tools/j3/Main.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/j3/Main.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/tools/j3/Main.cpp (original)
+++ vmkit/trunk/tools/j3/Main.cpp Mon Nov 21 04:28:44 2011
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "MvmGC.h"
+#include "VmkitGC.h"
 #include "vmkit/JIT.h"
 #include "vmkit/MethodInfo.h"
 #include "vmkit/VirtualMachine.h"

Modified: vmkit/trunk/tools/precompiler/Precompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/precompiler/Precompiler.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/tools/precompiler/Precompiler.cpp (original)
+++ vmkit/trunk/tools/precompiler/Precompiler.cpp Mon Nov 21 04:28:44 2011
@@ -15,7 +15,7 @@
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/Support/Signals.h"
 
-#include "MvmGC.h"
+#include "VmkitGC.h"
 #include "vmkit/JIT.h"
 #include "vmkit/MethodInfo.h"
 #include "vmkit/VirtualMachine.h"

Modified: vmkit/trunk/tools/vmjc/vmjc.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmjc/vmjc.cpp?rev=145032&r1=145031&r2=145032&view=diff
==============================================================================
--- vmkit/trunk/tools/vmjc/vmjc.cpp (original)
+++ vmkit/trunk/tools/vmjc/vmjc.cpp Mon Nov 21 04:28:44 2011
@@ -38,7 +38,7 @@
 #include "llvm/Target/TargetMachine.h"
 
 
-#include "MvmGC.h"
+#include "VmkitGC.h"
 #include "vmkit/JIT.h"
 #include "vmkit/VirtualMachine.h"
 #include "vmkit/Thread.h"




From gael.thomas at lip6.fr  Mon Nov 21 02:32:27 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Mon, 21 Nov 2011 10:32:27 -0000
Subject: [vmkit-commits] [vmkit] r145033 - in /vmkit/trunk:
 include/vmkit/JIT.h lib/J3/Compiler/JavaAOTCompiler.cpp
 lib/J3/Compiler/JavaJITCompiler.cpp lib/J3/Compiler/JavaLLVMCompiler.cpp
 lib/J3/Compiler/LLVMInfo.cpp lib/Mvm/Compiler/Disassembler.cpp
 lib/Mvm/Compiler/JIT.cpp tools/j3/Main.cpp
 tools/precompiler/Precompiler.cpp tools/vmjc/vmjc.cpp
Message-ID: <20111121103227.6D4A22A6C134@llvm.org>

Author: gthomas
Date: Mon Nov 21 04:32:27 2011
New Revision: 145033

URL: http://llvm.org/viewvc/llvm-project?rev=145033&view=rev
Log:
MvmModule is now VmkitModule

Modified:
    vmkit/trunk/include/vmkit/JIT.h
    vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
    vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp
    vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp
    vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp
    vmkit/trunk/lib/Mvm/Compiler/Disassembler.cpp
    vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
    vmkit/trunk/tools/j3/Main.cpp
    vmkit/trunk/tools/precompiler/Precompiler.cpp
    vmkit/trunk/tools/vmjc/vmjc.cpp

Modified: vmkit/trunk/include/vmkit/JIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/JIT.h?rev=145033&r1=145032&r2=145033&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/JIT.h (original)
+++ vmkit/trunk/include/vmkit/JIT.h Mon Nov 21 04:32:27 2011
@@ -169,7 +169,7 @@
 };
 
 
-class MvmModule {
+class VmkitModule {
 public:
    static mvm::LockRecursive protectEngine;
 

Modified: vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=145033&r1=145032&r2=145033&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp Mon Nov 21 04:32:27 2011
@@ -1795,8 +1795,8 @@
   JavaLLVMCompiler(ModuleID) {
 
   std::string Error;
-  const Target* TheTarget(TargetRegistry::lookupTarget(mvm::MvmModule::getHostTriple(), Error));
-  TargetMachine* TM = TheTarget->createTargetMachine(mvm::MvmModule::getHostTriple(), "", "");
+  const Target* TheTarget(TargetRegistry::lookupTarget(mvm::VmkitModule::getHostTriple(), Error));
+  TargetMachine* TM = TheTarget->createTargetMachine(mvm::VmkitModule::getHostTriple(), "", "");
   TheTargetData = TM->getTargetData();
   TheModule->setDataLayout(TheTargetData->getStringRepresentation());
   TheModule->setTargetTriple(TM->getTargetTriple());

Modified: vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp?rev=145033&r1=145032&r2=145033&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp Mon Nov 21 04:32:27 2011
@@ -163,7 +163,7 @@
   executionEngine->RegisterJITEventListener(&listener);
   TheTargetData = executionEngine->getTargetData();
   TheModule->setDataLayout(TheTargetData->getStringRepresentation());
-  TheModule->setTargetTriple(mvm::MvmModule::getHostTriple());
+  TheModule->setTargetTriple(mvm::VmkitModule::getHostTriple());
   JavaIntrinsics.init(TheModule);
   initialiseAssessorInfo();  
 
@@ -320,7 +320,7 @@
 }
 
 void* JavaJITCompiler::materializeFunction(JavaMethod* meth, Class* customizeFor) {
-  mvm::MvmModule::protectIR();
+  mvm::VmkitModule::protectIR();
   Function* func = parseFunction(meth, customizeFor);
   void* res = executionEngine->getPointerToGlobal(func);
 
@@ -328,12 +328,12 @@
     llvm::GCFunctionInfo& GFI = GCInfo->getFunctionInfo(*func);
   
     Jnjvm* vm = JavaThread::get()->getJVM();
-    mvm::MvmModule::addToVM(vm, &GFI, (JIT*)executionEngine, allocator, meth);
+    mvm::VmkitModule::addToVM(vm, &GFI, (JIT*)executionEngine, allocator, meth);
 
     // Now that it's compiled, we don't need the IR anymore
     func->deleteBody();
   }
-  mvm::MvmModule::unprotectIR();
+  mvm::VmkitModule::unprotectIR();
   if (customizeFor == NULL || !getMethodInfo(meth)->isCustomizable) {
     meth->code = res;
   }
@@ -341,7 +341,7 @@
 }
 
 void* JavaJITCompiler::GenerateStub(llvm::Function* F) {
-  mvm::MvmModule::protectIR();
+  mvm::VmkitModule::protectIR();
   void* res = executionEngine->getPointerToGlobal(F);
  
   // If the stub was already generated through an equivalent signature,
@@ -350,12 +350,12 @@
     llvm::GCFunctionInfo& GFI = GCInfo->getFunctionInfo(*F);
   
     Jnjvm* vm = JavaThread::get()->getJVM();
-    mvm::MvmModule::addToVM(vm, &GFI, (JIT*)executionEngine, allocator, NULL);
+    mvm::VmkitModule::addToVM(vm, &GFI, (JIT*)executionEngine, allocator, NULL);
   
     // Now that it's compiled, we don't need the IR anymore
     F->deleteBody();
   }
-  mvm::MvmModule::unprotectIR();
+  mvm::VmkitModule::unprotectIR();
   return res;
 }
 
@@ -363,7 +363,7 @@
 extern "C" int StartJnjvmWithJIT(int argc, char** argv, char* mainClass) {
   llvm::llvm_shutdown_obj X; 
    
-  mvm::MvmModule::initialise(argc, argv);
+  mvm::VmkitModule::initialise(argc, argv);
   mvm::Collector::initialise(argc, argv);
  
   mvm::ThreadAllocator allocator;

Modified: vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp?rev=145033&r1=145032&r2=145033&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp Mon Nov 21 04:32:27 2011
@@ -35,18 +35,18 @@
   
 void JavaLLVMCompiler::resolveVirtualClass(Class* cl) {
   // Lock here because we may be called by a class resolver
-  mvm::MvmModule::protectIR();
+  mvm::VmkitModule::protectIR();
   LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl);
   LCI->getVirtualType();
-  mvm::MvmModule::unprotectIR();
+  mvm::VmkitModule::unprotectIR();
 }
 
 void JavaLLVMCompiler::resolveStaticClass(Class* cl) {
   // Lock here because we may be called by a class initializer
-  mvm::MvmModule::protectIR();
+  mvm::VmkitModule::protectIR();
   LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl);
   LCI->getStaticType();
-  mvm::MvmModule::unprotectIR();
+  mvm::VmkitModule::unprotectIR();
 }
 
 Function* JavaLLVMCompiler::getMethod(JavaMethod* meth, Class* customizeFor) {
@@ -59,17 +59,17 @@
   Function* func = LMI->getMethod(customizeFor);
   
   // We are jitting. Take the lock.
-  mvm::MvmModule::protectIR();
+  mvm::VmkitModule::protectIR();
   if (func->getLinkage() == GlobalValue::ExternalWeakLinkage) {
     JavaJIT jit(this, meth, func, customizeFor);
     if (isNative(meth->access)) {
       jit.nativeCompile();
-      mvm::MvmModule::runPasses(func, JavaNativeFunctionPasses);
-      mvm::MvmModule::runPasses(func, J3FunctionPasses);
+      mvm::VmkitModule::runPasses(func, JavaNativeFunctionPasses);
+      mvm::VmkitModule::runPasses(func, J3FunctionPasses);
     } else {
       jit.javaCompile();
-      mvm::MvmModule::runPasses(func, JavaFunctionPasses);
-      mvm::MvmModule::runPasses(func, J3FunctionPasses);
+      mvm::VmkitModule::runPasses(func, JavaFunctionPasses);
+      mvm::VmkitModule::runPasses(func, J3FunctionPasses);
     }
     func->setLinkage(GlobalValue::ExternalLinkage);
     if (!LMI->isCustomizable && jit.isCustomizable) {
@@ -82,7 +82,7 @@
       }
     }
   }
-  mvm::MvmModule::unprotectIR();
+  mvm::VmkitModule::unprotectIR();
 
   return func;
 }
@@ -115,7 +115,7 @@
   
   JavaFunctionPasses = new FunctionPassManager(TheModule);
   JavaFunctionPasses->add(new TargetData(TheModule));
-  mvm::MvmModule::addCommandLinePasses(JavaFunctionPasses);
+  mvm::VmkitModule::addCommandLinePasses(JavaFunctionPasses);
 }
 
 } // end namespace j3

Modified: vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp?rev=145033&r1=145032&r2=145033&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp Mon Nov 21 04:32:27 2011
@@ -267,7 +267,7 @@
 llvm::FunctionType* LLVMSignatureInfo::getVirtualType() {
  if (!virtualType) {
     // Lock here because we are called by arbitrary code
-    mvm::MvmModule::protectIR();
+    mvm::VmkitModule::protectIR();
     std::vector<llvm::Type*> llvmArgs;
     uint32 size = signature->nbArguments;
     Typedef* const* arguments = signature->getArgumentsType();
@@ -283,7 +283,7 @@
     LLVMAssessorInfo& LAI =
       Compiler->getTypedefInfo(signature->getReturnType());
     virtualType = FunctionType::get(LAI.llvmType, llvmArgs, false);
-    mvm::MvmModule::unprotectIR();
+    mvm::VmkitModule::unprotectIR();
   }
   return virtualType;
 }
@@ -291,7 +291,7 @@
 llvm::FunctionType* LLVMSignatureInfo::getStaticType() {
  if (!staticType) {
     // Lock here because we are called by arbitrary code
-    mvm::MvmModule::protectIR();
+    mvm::VmkitModule::protectIR();
     std::vector<llvm::Type*> llvmArgs;
     uint32 size = signature->nbArguments;
     Typedef* const* arguments = signature->getArgumentsType();
@@ -305,7 +305,7 @@
     LLVMAssessorInfo& LAI =
       Compiler->getTypedefInfo(signature->getReturnType());
     staticType = FunctionType::get(LAI.llvmType, llvmArgs, false);
-    mvm::MvmModule::unprotectIR();
+    mvm::VmkitModule::unprotectIR();
   }
   return staticType;
 }
@@ -313,7 +313,7 @@
 llvm::FunctionType* LLVMSignatureInfo::getNativeType() {
   if (!nativeType) {
     // Lock here because we are called by arbitrary code
-    mvm::MvmModule::protectIR();
+    mvm::VmkitModule::protectIR();
     std::vector<llvm::Type*> llvmArgs;
     uint32 size = signature->nbArguments;
     Typedef* const* arguments = signature->getArgumentsType();
@@ -341,14 +341,14 @@
       LAI.llvmType == Compiler->getIntrinsics()->JavaObjectType ?
         LAI.llvmTypePtr : LAI.llvmType;
     nativeType = FunctionType::get(RetType, llvmArgs, false);
-    mvm::MvmModule::unprotectIR();
+    mvm::VmkitModule::unprotectIR();
   }
   return nativeType;
 }
 
 llvm::FunctionType* LLVMSignatureInfo::getNativeStubType() {
   // Lock here because we are called by arbitrary code
-  mvm::MvmModule::protectIR();
+  mvm::VmkitModule::protectIR();
   std::vector<llvm::Type*> llvmArgs;
   uint32 size = signature->nbArguments;
   Typedef* const* arguments = signature->getArgumentsType();
@@ -377,7 +377,7 @@
     LAI.llvmType == Compiler->getIntrinsics()->JavaObjectType ?
       LAI.llvmTypePtr : LAI.llvmType;
   FunctionType* FTy = FunctionType::get(RetType, llvmArgs, false);
-  mvm::MvmModule::unprotectIR();
+  mvm::VmkitModule::unprotectIR();
   return FTy;
 }
 
@@ -718,7 +718,7 @@
 FunctionType* LLVMSignatureInfo::getVirtualBufType() {
   if (!virtualBufType) {
     // Lock here because we are called by arbitrary code
-    mvm::MvmModule::protectIR();
+    mvm::VmkitModule::protectIR();
     std::vector<llvm::Type*> Args;
     Args.push_back(Compiler->getIntrinsics()->ResolvedConstantPoolType); // ctp
     Args.push_back(getVirtualPtrType());
@@ -727,7 +727,7 @@
     LLVMAssessorInfo& LAI =
       Compiler->getTypedefInfo(signature->getReturnType());
     virtualBufType = FunctionType::get(LAI.llvmType, Args, false);
-    mvm::MvmModule::unprotectIR();
+    mvm::VmkitModule::unprotectIR();
   }
   return virtualBufType;
 }
@@ -735,7 +735,7 @@
 FunctionType* LLVMSignatureInfo::getStaticBufType() {
   if (!staticBufType) {
     // Lock here because we are called by arbitrary code
-    mvm::MvmModule::protectIR();
+    mvm::VmkitModule::protectIR();
     std::vector<llvm::Type*> Args;
     Args.push_back(Compiler->getIntrinsics()->ResolvedConstantPoolType); // ctp
     Args.push_back(getStaticPtrType());
@@ -743,7 +743,7 @@
     LLVMAssessorInfo& LAI =
       Compiler->getTypedefInfo(signature->getReturnType());
     staticBufType = FunctionType::get(LAI.llvmType, Args, false);
-    mvm::MvmModule::unprotectIR();
+    mvm::VmkitModule::unprotectIR();
   }
   return staticBufType;
 }
@@ -751,84 +751,84 @@
 Function* LLVMSignatureInfo::getVirtualBuf() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on virtualBufFunction to have an address.
-  mvm::MvmModule::protectIR();
+  mvm::VmkitModule::protectIR();
   if (!virtualBufFunction) {
     virtualBufFunction = createFunctionCallBuf(true);
     signature->setVirtualCallBuf(Compiler->GenerateStub(virtualBufFunction));
   }
-  mvm::MvmModule::unprotectIR();
+  mvm::VmkitModule::unprotectIR();
   return virtualBufFunction;
 }
 
 Function* LLVMSignatureInfo::getVirtualAP() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on virtualAPFunction to have an address.
-  mvm::MvmModule::protectIR();
+  mvm::VmkitModule::protectIR();
   if (!virtualAPFunction) {
     virtualAPFunction = createFunctionCallAP(true);
     signature->setVirtualCallAP(Compiler->GenerateStub(virtualAPFunction));
   }
-  mvm::MvmModule::unprotectIR();
+  mvm::VmkitModule::unprotectIR();
   return virtualAPFunction;
 }
 
 Function* LLVMSignatureInfo::getStaticBuf() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on staticBufFunction to have an address.
-  mvm::MvmModule::protectIR();
+  mvm::VmkitModule::protectIR();
   if (!staticBufFunction) {
     staticBufFunction = createFunctionCallBuf(false);
     signature->setStaticCallBuf(Compiler->GenerateStub(staticBufFunction));
   }
-  mvm::MvmModule::unprotectIR();
+  mvm::VmkitModule::unprotectIR();
   return staticBufFunction;
 }
 
 Function* LLVMSignatureInfo::getStaticAP() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on staticAPFunction to have an address.
-  mvm::MvmModule::protectIR();
+  mvm::VmkitModule::protectIR();
   if (!staticAPFunction) {
     staticAPFunction = createFunctionCallAP(false);
     signature->setStaticCallAP(Compiler->GenerateStub(staticAPFunction));
   }
-  mvm::MvmModule::unprotectIR();
+  mvm::VmkitModule::unprotectIR();
   return staticAPFunction;
 }
 
 Function* LLVMSignatureInfo::getStaticStub() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on staticStubFunction to have an address.
-  mvm::MvmModule::protectIR();
+  mvm::VmkitModule::protectIR();
   if (!staticStubFunction) {
     staticStubFunction = createFunctionStub(false, false);
     signature->setStaticCallStub(Compiler->GenerateStub(staticStubFunction));
   }
-  mvm::MvmModule::unprotectIR();
+  mvm::VmkitModule::unprotectIR();
   return staticStubFunction;
 }
 
 Function* LLVMSignatureInfo::getSpecialStub() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on specialStubFunction to have an address.
-  mvm::MvmModule::protectIR();
+  mvm::VmkitModule::protectIR();
   if (!specialStubFunction) {
     specialStubFunction = createFunctionStub(true, false);
     signature->setSpecialCallStub(Compiler->GenerateStub(specialStubFunction));
   }
-  mvm::MvmModule::unprotectIR();
+  mvm::VmkitModule::unprotectIR();
   return specialStubFunction;
 }
 
 Function* LLVMSignatureInfo::getVirtualStub() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on virtualStubFunction to have an address.
-  mvm::MvmModule::protectIR();
+  mvm::VmkitModule::protectIR();
   if (!virtualStubFunction) {
     virtualStubFunction = createFunctionStub(false, true);
     signature->setVirtualCallStub(Compiler->GenerateStub(virtualStubFunction));
   }
-  mvm::MvmModule::unprotectIR();
+  mvm::VmkitModule::unprotectIR();
   return virtualStubFunction;
 }
 

Modified: vmkit/trunk/lib/Mvm/Compiler/Disassembler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/Disassembler.cpp?rev=145033&r1=145032&r2=145033&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/Disassembler.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/Disassembler.cpp Mon Nov 21 04:32:27 2011
@@ -25,7 +25,7 @@
 
 // this is the only function exported from this file
 
-int mvm::MvmModule::disassemble(unsigned int *addr)
+int mvm::VmkitModule::disassemble(unsigned int *addr)
 {
   
   if (!initialised)
@@ -56,7 +56,7 @@
 static int			initialised= 0;
 
 
-int mvm::MvmModule::disassemble(unsigned int *addr)
+int mvm::VmkitModule::disassemble(unsigned int *addr)
 {
   if (!initialised)
     {
@@ -74,7 +74,7 @@
 
 #else
 
-int mvm::MvmModule::disassemble(unsigned int* addr) {
+int mvm::VmkitModule::disassemble(unsigned int* addr) {
   return 0;
 }
 
@@ -82,7 +82,7 @@
 
 #else
 
-int mvm::MvmModule::disassemble(unsigned int* addr) {
+int mvm::VmkitModule::disassemble(unsigned int* addr) {
   return 0;
 }
 

Modified: vmkit/trunk/lib/Mvm/Compiler/JIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/JIT.cpp?rev=145033&r1=145032&r2=145033&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/JIT.cpp (original)
+++ vmkit/trunk/lib/Mvm/Compiler/JIT.cpp Mon Nov 21 04:32:27 2011
@@ -59,7 +59,7 @@
   void linkVmkitGC();
 }
 
-const char* MvmModule::getHostTriple() {
+const char* VmkitModule::getHostTriple() {
 #ifdef LLVM_HOSTTRIPLE
   return LLVM_HOSTTRIPLE;
 #else
@@ -81,7 +81,7 @@
 static llvm::cl::list<const llvm::PassInfo*, bool, llvm::PassNameParser>
 PassList(llvm::cl::desc("Optimizations available:"));
 
-void MvmModule::initialise(int argc, char** argv) {
+void VmkitModule::initialise(int argc, char** argv) {
   linkVmkitGC(); 
   llvm_start_multithreaded();
 
@@ -138,7 +138,7 @@
 }
 
 
-void MvmModule::runPasses(llvm::Function* func,
+void VmkitModule::runPasses(llvm::Function* func,
                           llvm::FunctionPassManager* pm) {
   pm->run(*func);
 }
@@ -194,7 +194,7 @@
   llvm::FunctionPass* createInlineMallocPass();
 }
 
-void MvmModule::addCommandLinePasses(FunctionPassManager* PM) {
+void VmkitModule::addCommandLinePasses(FunctionPassManager* PM) {
   addPass(PM, createVerifierPass());        // Verify that input is correct
 
   addPass(PM, createCFGSimplificationPass()); // Clean up disgusting code
@@ -241,15 +241,15 @@
   PM->doInitialization();
 }
 
-LockRecursive MvmModule::protectEngine;
+LockRecursive VmkitModule::protectEngine;
 
 // We protect the creation of IR with the protectEngine. Note that
 // codegen'ing a function may also create IR objects.
-void MvmModule::protectIR() {
+void VmkitModule::protectIR() {
   protectEngine.lock();
 }
 
-void MvmModule::unprotectIR() {
+void VmkitModule::unprotectIR() {
   protectEngine.unlock();
 }
 
@@ -382,7 +382,7 @@
 }
 
 
-Frames* MvmModule::addToVM(VirtualMachine* VM, GCFunctionInfo* FI, JIT* jit, BumpPtrAllocator& allocator, void* meta) {
+Frames* VmkitModule::addToVM(VirtualMachine* VM, GCFunctionInfo* FI, JIT* jit, BumpPtrAllocator& allocator, void* meta) {
   JITCodeEmitter* JCE = jit->getCodeEmitter();
   int NumDescriptors = 0;
   for (GCFunctionInfo::iterator J = FI->begin(), JE = FI->end(); J != JE; ++J) {

Modified: vmkit/trunk/tools/j3/Main.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/j3/Main.cpp?rev=145033&r1=145032&r2=145033&view=diff
==============================================================================
--- vmkit/trunk/tools/j3/Main.cpp (original)
+++ vmkit/trunk/tools/j3/Main.cpp Mon Nov 21 04:32:27 2011
@@ -34,7 +34,7 @@
   llvm::llvm_shutdown_obj X;
 
   // Initialize base components.  
-  MvmModule::initialise(argc, argv);
+  VmkitModule::initialise(argc, argv);
   Collector::initialise(argc, argv);
  
   // Create the allocator that will allocate the bootstrap loader and the JVM.

Modified: vmkit/trunk/tools/precompiler/Precompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/precompiler/Precompiler.cpp?rev=145033&r1=145032&r2=145033&view=diff
==============================================================================
--- vmkit/trunk/tools/precompiler/Precompiler.cpp (original)
+++ vmkit/trunk/tools/precompiler/Precompiler.cpp Mon Nov 21 04:32:27 2011
@@ -63,7 +63,7 @@
   std::string OutputFilename;
 
   // Initialize base components.  
-  MvmModule::initialise(argc, argv);
+  VmkitModule::initialise(argc, argv);
   Collector::initialise(argc, argv);
   
   // Create the allocator that will allocate the bootstrap loader and the JVM.

Modified: vmkit/trunk/tools/vmjc/vmjc.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmjc/vmjc.cpp?rev=145033&r1=145032&r2=145033&view=diff
==============================================================================
--- vmkit/trunk/tools/vmjc/vmjc.cpp (original)
+++ vmkit/trunk/tools/vmjc/vmjc.cpp Mon Nov 21 04:32:27 2011
@@ -121,7 +121,7 @@
     return 0;
   }
    
-  mvm::MvmModule::initialise(argc, argv);
+  mvm::VmkitModule::initialise(argc, argv);
   mvm::Collector::initialise(argc, argv);
 
   JavaAOTCompiler* Comp = new JavaAOTCompiler("AOT");




From gael.thomas at lip6.fr  Mon Nov 21 02:39:23 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Mon, 21 Nov 2011 10:39:23 -0000
Subject: [vmkit-commits] [vmkit] r145034 - in /vmkit/trunk:
 include/j3/JavaAOTCompiler.h include/vmkit/MvmDenseMap.h
 include/vmkit/MvmDenseSet.h include/vmkit/System.h include/vmkit/Thread.h
 include/vmkit/UTF8.h include/vmkit/VmkitDenseMap.h
 include/vmkit/VmkitDenseSet.h lib/J3/Compiler/JavaAOTCompiler.cpp
 lib/J3/VMCore/LockedMap.h lib/J3/VMCore/Precompiled.cpp
 lib/Mvm/CommonThread/ctthread.cpp
Message-ID: <20111121103923.AB6FE2A6C134@llvm.org>

Author: gthomas
Date: Mon Nov 21 04:39:23 2011
New Revision: 145034

URL: http://llvm.org/viewvc/llvm-project?rev=145034&view=rev
Log:
More renaming: 
MvmDenseSet.* -> VmkitDenseSet.*
MvmDenseMap.* -> VmkitDenseSet.*
MvmPair -> VmkitPair
kMvmThreadMask -> kVmkitThreadMask
GetMvmThreadMask -> GetVmkitThreadMask


Added:
    vmkit/trunk/include/vmkit/VmkitDenseMap.h
      - copied, changed from r145031, vmkit/trunk/include/vmkit/MvmDenseMap.h
    vmkit/trunk/include/vmkit/VmkitDenseSet.h
      - copied, changed from r145031, vmkit/trunk/include/vmkit/MvmDenseSet.h
Removed:
    vmkit/trunk/include/vmkit/MvmDenseMap.h
    vmkit/trunk/include/vmkit/MvmDenseSet.h
Modified:
    vmkit/trunk/include/j3/JavaAOTCompiler.h
    vmkit/trunk/include/vmkit/System.h
    vmkit/trunk/include/vmkit/Thread.h
    vmkit/trunk/include/vmkit/UTF8.h
    vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
    vmkit/trunk/lib/J3/VMCore/LockedMap.h
    vmkit/trunk/lib/J3/VMCore/Precompiled.cpp
    vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp

Modified: vmkit/trunk/include/j3/JavaAOTCompiler.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/JavaAOTCompiler.h?rev=145034&r1=145033&r2=145034&view=diff
==============================================================================
--- vmkit/trunk/include/j3/JavaAOTCompiler.h (original)
+++ vmkit/trunk/include/j3/JavaAOTCompiler.h Mon Nov 21 04:39:23 2011
@@ -10,7 +10,7 @@
 #ifndef J3_AOT_COMPILER_H
 #define J3_AOT_COMPILER_H
 
-#include "vmkit/MvmDenseMap.h"
+#include "vmkit/VmkitDenseMap.h"
 #include "vmkit/UTF8.h"
 #include "j3/JavaLLVMCompiler.h"
 
@@ -98,8 +98,8 @@
   llvm::Constant* CreateConstantFromJavaObject(JavaObject* obj);
   llvm::Constant* CreateConstantFromClassBytes(ClassBytes* bytes);
   llvm::Constant* CreateConstantFromJavaConstantPool(JavaConstantPool* ctp);
-  llvm::Constant* CreateConstantFromClassMap(const mvm::MvmDenseMap<const UTF8*, CommonClass*>& map);
-  llvm::Constant* CreateConstantFromUTF8Map(const mvm::MvmDenseSet<mvm::UTF8MapKey, const UTF8*>& set);
+  llvm::Constant* CreateConstantFromClassMap(const mvm::VmkitDenseMap<const UTF8*, CommonClass*>& map);
+  llvm::Constant* CreateConstantFromUTF8Map(const mvm::VmkitDenseSet<mvm::UTF8MapKey, const UTF8*>& set);
   void AddInitializerToClass(llvm::GlobalVariable* varGV, CommonClass* classDef);
   llvm::Constant* getUTF8(const UTF8* val);
   

Removed: vmkit/trunk/include/vmkit/MvmDenseMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/MvmDenseMap.h?rev=145033&view=auto
==============================================================================
--- vmkit/trunk/include/vmkit/MvmDenseMap.h (original)
+++ vmkit/trunk/include/vmkit/MvmDenseMap.h (removed)
@@ -1,512 +0,0 @@
-//===- MvmDenseMap.h - Dense probed hash table ------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the MvmDenseMap copied from llvm/ADT/DenseMap.h, but
-// without storing pairs.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef VMKIT_DENSEMAP_H
-#define VMKIT_DENSEMAP_H
-
-#include "llvm/Support/MathExtras.h"
-#include "llvm/Support/PointerLikeTypeTraits.h"
-#include "llvm/Support/type_traits.h"
-#include <algorithm>
-#include <iterator>
-#include <new>
-#include <utility>
-#include <cassert>
-#include <cstddef>
-#include <cstring>
-
-namespace mvm {
-
-template<typename T>
-struct MvmDenseMapInfo {
-  //static inline T getEmptyKey();
-  //static inline T getTombstoneKey();
-  //static unsigned getHashValue(const T &Val);
-  //static bool isEqual(const T &LHS, const T &RHS);
-};
-
-template<typename KeyT, typename ValueT,
-         typename KeyInfoT = MvmDenseMapInfo<KeyT>,
-         bool IsConst = false>
-class MvmDenseMapIterator;
-
-template<typename KeyT, typename ValueT>
-struct MvmPair {
-  KeyT first;
-  ValueT second;
-};
-
-template<typename KeyT, typename ValueT,
-         typename KeyInfoT = MvmDenseMapInfo<KeyT> >
-class MvmDenseMap {
-public:
-  typedef MvmPair<KeyT, ValueT> BucketT;
-  uint32_t NumBuckets;
-  BucketT *Buckets;
-
-  uint32_t NumEntries;
-  uint32_t NumTombstones;
-  bool IsPrecompiled;
-
-  typedef KeyT key_type;
-  typedef ValueT mapped_type;
-  typedef BucketT value_type;
-
-  explicit MvmDenseMap(unsigned NumInitBuckets = 0) {
-    IsPrecompiled = false;
-    init(NumInitBuckets);
-  }
-
-  ~MvmDenseMap() {
-    const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
-    for (BucketT *P = Buckets, *E = Buckets+NumBuckets; P != E; ++P) {
-      if (!KeyInfoT::isEqual(P->first, EmptyKey) &&
-          !KeyInfoT::isEqual(P->first, TombstoneKey))
-        P->second.~ValueT();
-      P->first.~KeyT();
-    }
-#ifndef NDEBUG
-    if (NumBuckets)
-      memset((void*)Buckets, 0x5a, sizeof(BucketT)*NumBuckets);
-#endif
-    if (!IsPrecompiled) {
-      operator delete(Buckets);
-    }
-  }
-
-  typedef MvmDenseMapIterator<KeyT, ValueT, KeyInfoT> iterator;
-  typedef MvmDenseMapIterator<KeyT, ValueT, KeyInfoT, true> const_iterator;
-  inline iterator begin() {
-    // When the map is empty, avoid the overhead of AdvancePastEmptyBuckets().
-    return empty() ? end() : iterator(Buckets, Buckets+NumBuckets);
-  }
-  inline iterator end() {
-    return iterator(Buckets+NumBuckets, Buckets+NumBuckets);
-  }
-  inline const_iterator begin() const {
-    return empty() ? end() : const_iterator(Buckets, Buckets+NumBuckets);
-  }
-  inline const_iterator end() const {
-    return const_iterator(Buckets+NumBuckets, Buckets+NumBuckets);
-  }
-
-  bool empty() const { return NumEntries == 0; }
-  unsigned size() const { return NumEntries; }
-
-  /// Grow the densemap so that it has at least Size buckets. Does not shrink
-  void resize(size_t Size) {
-    if (Size > NumBuckets)
-      grow(Size);
-  }
-
-  void clear() {
-    if (NumEntries == 0 && NumTombstones == 0) return;
-    
-    // If the capacity of the array is huge, and the # elements used is small,
-    // shrink the array.
-    if (NumEntries * 4 < NumBuckets && NumBuckets > 64) {
-      shrink_and_clear();
-      return;
-    }
-
-    const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
-    for (BucketT *P = Buckets, *E = Buckets+NumBuckets; P != E; ++P) {
-      if (!KeyInfoT::isEqual(P->first, EmptyKey)) {
-        if (!KeyInfoT::isEqual(P->first, TombstoneKey)) {
-          P->second.~ValueT();
-          --NumEntries;
-        }
-        P->first = EmptyKey;
-      }
-    }
-    assert(NumEntries == 0 && "Node count imbalance!");
-    NumTombstones = 0;
-  }
-
-  /// count - Return true if the specified key is in the map.
-  bool count(const KeyT &Val) const {
-    BucketT *TheBucket;
-    return LookupBucketFor(Val, TheBucket);
-  }
-
-  iterator find(const KeyT &Val) {
-    BucketT *TheBucket;
-    if (LookupBucketFor(Val, TheBucket))
-      return iterator(TheBucket, Buckets+NumBuckets);
-    return end();
-  }
-  const_iterator find(const KeyT &Val) const {
-    BucketT *TheBucket;
-    if (LookupBucketFor(Val, TheBucket))
-      return const_iterator(TheBucket, Buckets+NumBuckets);
-    return end();
-  }
-
-  /// lookup - Return the entry for the specified key, or a default
-  /// constructed value if no such entry exists.
-  ValueT lookup(const KeyT &Val) const {
-    BucketT *TheBucket;
-    if (LookupBucketFor(Val, TheBucket))
-      return TheBucket->second;
-    return ValueT();
-  }
-
-  // Inserts key,value pair into the map if the key isn't already in the map.
-  // If the key is already in the map, it returns false and doesn't update the
-  // value.
-  std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
-    BucketT *TheBucket;
-    if (LookupBucketFor(KV.first, TheBucket))
-      return std::make_pair(iterator(TheBucket, Buckets+NumBuckets),
-                            false); // Already in map.
-
-    // Otherwise, insert the new element.
-    TheBucket = InsertIntoBucket(KV.first, KV.second, TheBucket);
-    return std::make_pair(iterator(TheBucket, Buckets+NumBuckets),
-                          true);
-  }
-
-  /// insert - Range insertion of pairs.
-  template<typename InputIt>
-  void insert(InputIt I, InputIt E) {
-    for (; I != E; ++I)
-      insert(*I);
-  }
-
-
-  bool erase(const KeyT &Val) {
-    BucketT *TheBucket;
-    if (!LookupBucketFor(Val, TheBucket))
-      return false; // not in map.
-
-    TheBucket->second.~ValueT();
-    TheBucket->first = getTombstoneKey();
-    --NumEntries;
-    ++NumTombstones;
-    return true;
-  }
-  void erase(iterator I) {
-    BucketT *TheBucket = &*I;
-    TheBucket->second.~ValueT();
-    TheBucket->first = getTombstoneKey();
-    --NumEntries;
-    ++NumTombstones;
-  }
-
-  void swap(MvmDenseMap& RHS) {
-    std::swap(NumBuckets, RHS.NumBuckets);
-    std::swap(Buckets, RHS.Buckets);
-    std::swap(NumEntries, RHS.NumEntries);
-    std::swap(NumTombstones, RHS.NumTombstones);
-  }
-
-  value_type& FindAndConstruct(const KeyT &Key) {
-    BucketT *TheBucket;
-    if (LookupBucketFor(Key, TheBucket))
-      return *TheBucket;
-
-    return *InsertIntoBucket(Key, ValueT(), TheBucket);
-  }
-
-  ValueT &operator[](const KeyT &Key) {
-    return FindAndConstruct(Key).second;
-  }
-
-  /// isPointerIntoBucketsArray - Return true if the specified pointer points
-  /// somewhere into the MvmDenseMap's array of buckets (i.e. either to a key or
-  /// value in the MvmDenseMap).
-  bool isPointerIntoBucketsArray(const void *Ptr) const {
-    return Ptr >= Buckets && Ptr < Buckets+NumBuckets;
-  }
-
-  /// getPointerIntoBucketsArray() - Return an opaque pointer into the buckets
-  /// array.  In conjunction with the previous method, this can be used to
-  /// determine whether an insertion caused the MvmDenseMap to reallocate.
-  const void *getPointerIntoBucketsArray() const { return Buckets; }
-
-private:
-  BucketT *InsertIntoBucket(const KeyT &Key, const ValueT &Value,
-                            BucketT *TheBucket) {
-    // If the load of the hash table is more than 3/4, or if fewer than 1/8 of
-    // the buckets are empty (meaning that many are filled with tombstones),
-    // grow the table.
-    //
-    // The later case is tricky.  For example, if we had one empty bucket with
-    // tons of tombstones, failing lookups (e.g. for insertion) would have to
-    // probe almost the entire table until it found the empty bucket.  If the
-    // table completely filled with tombstones, no lookup would ever succeed,
-    // causing infinite loops in lookup.
-    ++NumEntries;
-    if (NumEntries*4 >= NumBuckets*3) {
-      this->grow(NumBuckets * 2);
-      LookupBucketFor(Key, TheBucket);
-    }
-    if (NumBuckets-(NumEntries+NumTombstones) < NumBuckets/8) {
-      this->grow(NumBuckets);
-      LookupBucketFor(Key, TheBucket);
-    }
-
-    // If we are writing over a tombstone, remember this.
-    if (!KeyInfoT::isEqual(TheBucket->first, getEmptyKey()))
-      --NumTombstones;
-
-    TheBucket->first = Key;
-    new (&TheBucket->second) ValueT(Value);
-    return TheBucket;
-  }
-
-  static unsigned getHashValue(const KeyT &Val) {
-    return KeyInfoT::getHashValue(Val);
-  }
-  static const KeyT getEmptyKey() {
-    return KeyInfoT::getEmptyKey();
-  }
-  static const KeyT getTombstoneKey() {
-    return KeyInfoT::getTombstoneKey();
-  }
-
-  /// LookupBucketFor - Lookup the appropriate bucket for Val, returning it in
-  /// FoundBucket.  If the bucket contains the key and a value, this returns
-  /// true, otherwise it returns a bucket with an empty marker or tombstone and
-  /// returns false.
-  bool LookupBucketFor(const KeyT &Val, BucketT *&FoundBucket) const {
-    unsigned BucketNo = getHashValue(Val);
-    unsigned ProbeAmt = 1;
-    BucketT *BucketsPtr = Buckets;
-
-    if (NumBuckets == 0) {
-      FoundBucket = 0;
-      return false;
-    }
-
-    // FoundTombstone - Keep track of whether we find a tombstone while probing.
-    BucketT *FoundTombstone = 0;
-    const KeyT EmptyKey = getEmptyKey();
-    const KeyT TombstoneKey = getTombstoneKey();
-    assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
-           !KeyInfoT::isEqual(Val, TombstoneKey) &&
-           "Empty/Tombstone value shouldn't be inserted into map!");
-
-    while (1) {
-      BucketT *ThisBucket = BucketsPtr + (BucketNo & (NumBuckets-1));
-      // Found Val's bucket?  If so, return it.
-      if (KeyInfoT::isEqual(ThisBucket->first, Val)) {
-        FoundBucket = ThisBucket;
-        return true;
-      }
-
-      // If we found an empty bucket, the key doesn't exist in the set.
-      // Insert it and return the default value.
-      if (KeyInfoT::isEqual(ThisBucket->first, EmptyKey)) {
-        // If we've already seen a tombstone while probing, fill it in instead
-        // of the empty bucket we eventually probed to.
-        if (FoundTombstone) ThisBucket = FoundTombstone;
-        FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
-        return false;
-      }
-
-      // If this is a tombstone, remember it.  If Val ends up not in the map, we
-      // prefer to return it than something that would require more probing.
-      if (KeyInfoT::isEqual(ThisBucket->first, TombstoneKey) && !FoundTombstone)
-        FoundTombstone = ThisBucket;  // Remember the first tombstone found.
-
-      // Otherwise, it's a hash collision or a tombstone, continue quadratic
-      // probing.
-      BucketNo += ProbeAmt++;
-    }
-  }
-
-  void init(unsigned InitBuckets) {
-    NumEntries = 0;
-    NumTombstones = 0;
-    NumBuckets = InitBuckets;
-
-    if (InitBuckets == 0) {
-      Buckets = 0;
-      return;
-    }
-
-    assert(InitBuckets && (InitBuckets & (InitBuckets-1)) == 0 &&
-           "# initial buckets must be a power of two!");
-    Buckets = static_cast<BucketT*>(operator new(sizeof(BucketT)*InitBuckets));
-    // Initialize all the keys to EmptyKey.
-    const KeyT EmptyKey = getEmptyKey();
-    for (unsigned i = 0; i != InitBuckets; ++i)
-      new (&Buckets[i].first) KeyT(EmptyKey);
-  }
-
-  void grow(unsigned AtLeast) {
-    unsigned OldNumBuckets = NumBuckets;
-    BucketT *OldBuckets = Buckets;
-
-    if (NumBuckets < 64)
-      NumBuckets = 64;
-
-    // Double the number of buckets.
-    while (NumBuckets < AtLeast)
-      NumBuckets <<= 1;
-    NumTombstones = 0;
-    Buckets = static_cast<BucketT*>(operator new(sizeof(BucketT)*NumBuckets));
-
-    // Initialize all the keys to EmptyKey.
-    const KeyT EmptyKey = getEmptyKey();
-    for (unsigned i = 0, e = NumBuckets; i != e; ++i)
-      new (&Buckets[i].first) KeyT(EmptyKey);
-
-    // Insert all the old elements.
-    const KeyT TombstoneKey = getTombstoneKey();
-    for (BucketT *B = OldBuckets, *E = OldBuckets+OldNumBuckets; B != E; ++B) {
-      if (!KeyInfoT::isEqual(B->first, EmptyKey) &&
-          !KeyInfoT::isEqual(B->first, TombstoneKey)) {
-        // Insert the key/value into the new table.
-        BucketT *DestBucket;
-        bool FoundVal = LookupBucketFor(B->first, DestBucket);
-        (void)FoundVal; // silence warning.
-        assert(!FoundVal && "Key already in new map?");
-        DestBucket->first = B->first;
-        new (&DestBucket->second) ValueT(B->second);
-
-        // Free the value.
-        B->second.~ValueT();
-      }
-      B->first.~KeyT();
-    }
-
-#ifndef NDEBUG
-    if (OldNumBuckets)
-      memset((void*)OldBuckets, 0x5a, sizeof(BucketT)*OldNumBuckets);
-#endif
-    // Free the old table.
-    if (!IsPrecompiled) {
-      operator delete(OldBuckets);
-    } else {
-      IsPrecompiled = false;
-    }
-  }
-
-  void shrink_and_clear() {
-    unsigned OldNumBuckets = NumBuckets;
-    BucketT *OldBuckets = Buckets;
-
-    // Reduce the number of buckets.
-    NumBuckets = NumEntries > 32 ? 1 << (llvm::Log2_32_Ceil(NumEntries) + 1)
-                                 : 64;
-    NumTombstones = 0;
-    Buckets = static_cast<BucketT*>(operator new(sizeof(BucketT)*NumBuckets));
-
-    // Initialize all the keys to EmptyKey.
-    const KeyT EmptyKey = getEmptyKey();
-    for (unsigned i = 0, e = NumBuckets; i != e; ++i)
-      new (&Buckets[i].first) KeyT(EmptyKey);
-
-    // Free the old buckets.
-    const KeyT TombstoneKey = getTombstoneKey();
-    for (BucketT *B = OldBuckets, *E = OldBuckets+OldNumBuckets; B != E; ++B) {
-      if (!KeyInfoT::isEqual(B->first, EmptyKey) &&
-          !KeyInfoT::isEqual(B->first, TombstoneKey)) {
-        // Free the value.
-        B->second.~ValueT();
-      }
-      B->first.~KeyT();
-    }
-
-#ifndef NDEBUG
-    memset((void*)OldBuckets, 0x5a, sizeof(BucketT)*OldNumBuckets);
-#endif
-    if (!IsPrecompiled) {
-      // Free the old table.
-      operator delete(OldBuckets);
-    } else {
-      IsPrecompiled = false;
-    }
-
-    NumEntries = 0;
-  }
-  
-public:
-  /// Return the approximate size (in bytes) of the actual map.
-  /// This is just the raw memory used by MvmDenseMap.
-  /// If entries are pointers to objects, the size of the referenced objects
-  /// are not included.
-  size_t getMemorySize() const {
-    return NumBuckets * sizeof(BucketT);
-  }
-};
-
-template<typename KeyT, typename ValueT,
-         typename KeyInfoT, bool IsConst>
-class MvmDenseMapIterator {
-  typedef MvmPair<KeyT, ValueT> Bucket;
-  typedef MvmDenseMapIterator<KeyT, ValueT, KeyInfoT, true> ConstIterator;
-  friend class MvmDenseMapIterator<KeyT, ValueT, KeyInfoT, true>;
-public:
-  typedef ptrdiff_t difference_type;
-  typedef typename llvm::conditional<IsConst, const Bucket, Bucket>::type value_type;
-  typedef value_type *pointer;
-  typedef value_type &reference;
-  typedef std::forward_iterator_tag iterator_category;
-private:
-  pointer Ptr, End;
-public:
-  MvmDenseMapIterator() : Ptr(0), End(0) {}
-
-  MvmDenseMapIterator(pointer Pos, pointer E) : Ptr(Pos), End(E) {
-    AdvancePastEmptyBuckets();
-  }
-
-  // If IsConst is true this is a converting constructor from iterator to
-  // const_iterator and the default copy constructor is used.
-  // Otherwise this is a copy constructor for iterator.
-  MvmDenseMapIterator(const MvmDenseMapIterator<KeyT, ValueT,
-                                          KeyInfoT, false>& I)
-    : Ptr(I.Ptr), End(I.End) {}
-
-  reference operator*() const {
-    return *Ptr;
-  }
-  pointer operator->() const {
-    return Ptr;
-  }
-
-  bool operator==(const ConstIterator &RHS) const {
-    return Ptr == RHS.operator->();
-  }
-  bool operator!=(const ConstIterator &RHS) const {
-    return Ptr != RHS.operator->();
-  }
-
-  inline MvmDenseMapIterator& operator++() {  // Preincrement
-    ++Ptr;
-    AdvancePastEmptyBuckets();
-    return *this;
-  }
-  MvmDenseMapIterator operator++(int) {  // Postincrement
-    MvmDenseMapIterator tmp = *this; ++*this; return tmp;
-  }
-
-private:
-  void AdvancePastEmptyBuckets() {
-    const KeyT Empty = KeyInfoT::getEmptyKey();
-    const KeyT Tombstone = KeyInfoT::getTombstoneKey();
-
-    while (Ptr != End &&
-           (KeyInfoT::isEqual(Ptr->first, Empty) ||
-            KeyInfoT::isEqual(Ptr->first, Tombstone)))
-      ++Ptr;
-  }
-};
-
-} // end namespace j3
-
-#endif

Removed: vmkit/trunk/include/vmkit/MvmDenseSet.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/MvmDenseSet.h?rev=145033&view=auto
==============================================================================
--- vmkit/trunk/include/vmkit/MvmDenseSet.h (original)
+++ vmkit/trunk/include/vmkit/MvmDenseSet.h (removed)
@@ -1,491 +0,0 @@
-//===- MvmDenseSet.h - Dense probed hash set --------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the MvmDenseSet class copied from llvm/ADT/DenseMap.h, but
-// without storing pairs.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef VMKIT_DENSESET_H
-#define VMKIT_DENSESET_H
-
-#include "llvm/ADT/DenseMapInfo.h"
-#include "llvm/Support/MathExtras.h"
-#include "llvm/Support/PointerLikeTypeTraits.h"
-#include "llvm/Support/type_traits.h"
-#include <algorithm>
-#include <iterator>
-#include <new>
-#include <utility>
-#include <cassert>
-#include <cstddef>
-#include <cstring>
-
-namespace mvm {
-
-template<typename ValueT,
-         typename ValueInfoT = MvmDenseMapInfo<ValueT>,
-         bool IsConst = false>
-class MvmDenseSetIterator;
-
-template<typename KeyT, typename ValueT,
-         typename KeyInfoT = MvmDenseMapInfo<KeyT>,
-         typename ValueInfoT = MvmDenseMapInfo<ValueT> >
-class MvmDenseSet {
-public:
-  typedef ValueT BucketT;
-  uint32_t NumBuckets;
-  BucketT *Buckets;
-
-  uint32_t NumEntries;
-  uint32_t NumTombstones;
-  bool IsPrecompiled;
-
-  typedef KeyT key_type;
-  typedef ValueT mapped_type;
-  typedef BucketT value_type;
-
-  explicit MvmDenseSet(unsigned NumInitBuckets = 0) {
-    IsPrecompiled = false;
-    init(NumInitBuckets);
-  }
-
-  ~MvmDenseSet() {
-    const ValueT EmptyValue = getEmptyValue(), TombstoneValue = getTombstoneValue();
-    for (BucketT *P = Buckets, *E = Buckets+NumBuckets; P != E; ++P) {
-      if (!ValueInfoT::isEqual(*P, EmptyValue) &&
-          !ValueInfoT::isEqual(*P, TombstoneValue))
-        (*P).~ValueT();
-    }
-#ifndef NDEBUG
-    if (NumBuckets)
-      memset((void*)Buckets, 0x5a, sizeof(BucketT)*NumBuckets);
-#endif
-    if (!IsPrecompiled) {
-      operator delete(Buckets);
-    }
-  }
-
-  typedef MvmDenseSetIterator<ValueT, ValueInfoT> iterator;
-  typedef MvmDenseSetIterator<ValueT, ValueInfoT, true> const_iterator;
-  inline iterator begin() {
-    // When the map is empty, avoid the overhead of AdvancePastEmptyBuckets().
-    return empty() ? end() : iterator(Buckets, Buckets+NumBuckets);
-  }
-  inline iterator end() {
-    return iterator(Buckets+NumBuckets, Buckets+NumBuckets);
-  }
-  inline const_iterator begin() const {
-    return empty() ? end() : const_iterator(Buckets, Buckets+NumBuckets);
-  }
-  inline const_iterator end() const {
-    return const_iterator(Buckets+NumBuckets, Buckets+NumBuckets);
-  }
-
-  bool empty() const { return NumEntries == 0; }
-  unsigned size() const { return NumEntries; }
-
-  /// Grow the denseset so that it has at least Size buckets. Does not shrink
-  void resize(size_t Size) {
-    if (Size > NumBuckets)
-      grow(Size);
-  }
-
-  void clear() {
-    if (NumEntries == 0 && NumTombstones == 0) return;
-    
-    // If the capacity of the array is huge, and the # elements used is small,
-    // shrink the array.
-    if (NumEntries * 4 < NumBuckets && NumBuckets > 64) {
-      shrink_and_clear();
-      return;
-    }
-
-    const ValueT EmptyValue = getEmptyValue(), TombstoneValue = getTombstoneValue();
-    for (BucketT *P = Buckets, *E = Buckets+NumBuckets; P != E; ++P) {
-      if (!ValueInfoT::isEqual(*P, EmptyValue)) {
-        if (!ValueInfoT::isEqual(*P, TombstoneValue)) {
-          P->~ValueT();
-          --NumEntries;
-        }
-        *P = EmptyValue;
-      }
-    }
-    assert(NumEntries == 0 && "Node count imbalance!");
-    NumTombstones = 0;
-  }
-
-  /// count - Return true if the specified key is in the set.
-  bool count(const KeyT &Val) const {
-    BucketT *TheBucket;
-    return LookupBucketFor(Val, TheBucket);
-  }
-
-  iterator find(const KeyT &Val) {
-    BucketT *TheBucket;
-    if (LookupBucketFor(Val, TheBucket))
-      return iterator(TheBucket, Buckets+NumBuckets);
-    return end();
-  }
-  const_iterator find(const KeyT &Val) const {
-    BucketT *TheBucket;
-    if (LookupBucketFor(Val, TheBucket))
-      return const_iterator(TheBucket, Buckets+NumBuckets);
-    return end();
-  }
-
-  /// lookup - Return the entry for the specified key, or a default
-  /// constructed value if no such entry exists.
-  ValueT lookup(const KeyT &Val) const {
-    BucketT *TheBucket;
-    if (LookupBucketFor(Val, TheBucket))
-      return *TheBucket;
-    return ValueT();
-  }
-
-  // Inserts key,value pair into the map if the key isn't already in the map.
-  // If the key is already in the map, it returns false and doesn't update the
-  // value.
-  std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
-    BucketT *TheBucket;
-    if (LookupBucketFor(KV.first, TheBucket))
-      return std::make_pair(iterator(TheBucket, Buckets+NumBuckets),
-                            false); // Already in map.
-
-    // Otherwise, insert the new element.
-    TheBucket = InsertIntoBucket(KV.first, KV.second, TheBucket);
-    return std::make_pair(iterator(TheBucket, Buckets+NumBuckets),
-                          true);
-  }
-
-  /// insert - Range insertion of pairs.
-  template<typename InputIt>
-  void insert(InputIt I, InputIt E) {
-    for (; I != E; ++I)
-      insert(*I);
-  }
-
-
-  bool erase(const KeyT &Val) {
-    BucketT *TheBucket;
-    if (!LookupBucketFor(Val, TheBucket))
-      return false; // not in map.
-
-    (*TheBucket).~ValueT();
-    *TheBucket = getTombstoneValue();
-    --NumEntries;
-    ++NumTombstones;
-    return true;
-  }
-  void erase(iterator I) {
-    BucketT *TheBucket = &*I;
-    (*TheBucket).~ValueT();
-    *TheBucket = getTombstoneValue();
-    --NumEntries;
-    ++NumTombstones;
-  }
-
-  void swap(MvmDenseSet& RHS) {
-    std::swap(NumBuckets, RHS.NumBuckets);
-    std::swap(Buckets, RHS.Buckets);
-    std::swap(NumEntries, RHS.NumEntries);
-    std::swap(NumTombstones, RHS.NumTombstones);
-  }
-
-  value_type& FindAndConstruct(const KeyT &Key) {
-    BucketT *TheBucket;
-    if (LookupBucketFor(Key, TheBucket))
-      return *TheBucket;
-
-    return *InsertIntoBucket(Key, ValueT(), TheBucket);
-  }
-
-  ValueT &operator[](const KeyT &Key) {
-    return FindAndConstruct(Key);
-  }
-
-  /// isPointerIntoBucketsArray - Return true if the specified pointer points
-  /// somewhere into the MvmDenseSet's array of buckets.
-  bool isPointerIntoBucketsArray(const void *Ptr) const {
-    return Ptr >= Buckets && Ptr < Buckets+NumBuckets;
-  }
-
-  /// getPointerIntoBucketsArray() - Return an opaque pointer into the buckets
-  /// array.  In conjunction with the previous method, this can be used to
-  /// determine whether an insertion caused the MvmDenseSet to reallocate.
-  const void *getPointerIntoBucketsArray() const { return Buckets; }
-
-private:
-  BucketT *InsertIntoBucket(const KeyT &Key, const ValueT &Value,
-                            BucketT *TheBucket) {
-    // If the load of the hash table is more than 3/4, or if fewer than 1/8 of
-    // the buckets are empty (meaning that many are filled with tombstones),
-    // grow the table.
-    //
-    // The later case is tricky.  For example, if we had one empty bucket with
-    // tons of tombstones, failing lookups (e.g. for insertion) would have to
-    // probe almost the entire table until it found the empty bucket.  If the
-    // table completely filled with tombstones, no lookup would ever succeed,
-    // causing infinite loops in lookup.
-    ++NumEntries;
-    if (NumEntries*4 >= NumBuckets*3) {
-      this->grow(NumBuckets * 2);
-      LookupBucketFor(Key, TheBucket);
-    }
-    if (NumBuckets-(NumEntries+NumTombstones) < NumBuckets/8) {
-      this->grow(NumBuckets);
-      LookupBucketFor(Key, TheBucket);
-    }
-
-    // If we are writing over a tombstone, remember this.
-    if (!ValueInfoT::isEqual(*TheBucket, getEmptyValue()))
-      --NumTombstones;
-
-    new (TheBucket) ValueT(Value);
-    return TheBucket;
-  }
-
-  static unsigned getHashValue(const KeyT &Val) {
-    return KeyInfoT::getHashValue(Val);
-  }
-  static const ValueT getEmptyValue() {
-    return ValueInfoT::getEmptyKey();
-  }
-  static const ValueT getTombstoneValue() {
-    return ValueInfoT::getTombstoneKey();
-  }
-
-  /// LookupBucketFor - Lookup the appropriate bucket for Val, returning it in
-  /// FoundBucket.  If the bucket contains the key and a value, this returns
-  /// true, otherwise it returns a bucket with an empty marker or tombstone and
-  /// returns false.
-  bool LookupBucketFor(const KeyT &Key, BucketT *&FoundBucket) const {
-    unsigned BucketNo = getHashValue(Key);
-    unsigned ProbeAmt = 1;
-    BucketT *BucketsPtr = Buckets;
-
-    if (NumBuckets == 0) {
-      FoundBucket = 0;
-      return false;
-    }
-
-    // FoundTombstone - Keep track of whether we find a tombstone while probing.
-    BucketT *FoundTombstone = 0;
-    const ValueT EmptyValue = getEmptyValue();
-    const ValueT TombstoneValue = getTombstoneValue();
-
-    while (1) {
-      BucketT *ThisBucket = BucketsPtr + (BucketNo & (NumBuckets-1));
-      // Found Val's bucket?  If so, return it.
-      if (ValueInfoT::isEqualKey(*ThisBucket, Key)) {
-        FoundBucket = ThisBucket;
-        return true;
-      }
-
-      // If we found an empty bucket, the key doesn't exist in the set.
-      // Insert it and return the default value.
-      if (ValueInfoT::isEqual(*ThisBucket, EmptyValue)) {
-        // If we've already seen a tombstone while probing, fill it in instead
-        // of the empty bucket we eventually probed to.
-        if (FoundTombstone) ThisBucket = FoundTombstone;
-        FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
-        return false;
-      }
-
-      // If this is a tombstone, remember it.  If Val ends up not in the map, we
-      // prefer to return it than something that would require more probing.
-      if (ValueInfoT::isEqual(*ThisBucket, TombstoneValue) && !FoundTombstone)
-        FoundTombstone = ThisBucket;  // Remember the first tombstone found.
-
-      // Otherwise, it's a hash collision or a tombstone, continue quadratic
-      // probing.
-      BucketNo += ProbeAmt++;
-    }
-  }
-
-  void init(unsigned InitBuckets) {
-    NumEntries = 0;
-    NumTombstones = 0;
-    NumBuckets = InitBuckets;
-
-    if (InitBuckets == 0) {
-      Buckets = 0;
-      return;
-    }
-
-    assert(InitBuckets && (InitBuckets & (InitBuckets-1)) == 0 &&
-           "# initial buckets must be a power of two!");
-    Buckets = static_cast<BucketT*>(operator new(sizeof(BucketT)*InitBuckets));
-    // Initialize all the entries to EmptyValue.
-    const ValueT EmptyValue = getEmptyValue();
-    for (unsigned i = 0; i != InitBuckets; ++i)
-      new (&Buckets[i]) ValueT(EmptyValue);
-  }
-
-  void grow(unsigned AtLeast) {
-    unsigned OldNumBuckets = NumBuckets;
-    BucketT *OldBuckets = Buckets;
-
-    if (NumBuckets < 64)
-      NumBuckets = 64;
-
-    // Double the number of buckets.
-    while (NumBuckets < AtLeast)
-      NumBuckets <<= 1;
-    NumTombstones = 0;
-    Buckets = static_cast<BucketT*>(operator new(sizeof(BucketT)*NumBuckets));
-
-    // Initialize all the values to EmptyValue.
-    const ValueT EmptyValue = getEmptyValue();
-    for (unsigned i = 0, e = NumBuckets; i != e; ++i)
-      new (&Buckets[i]) ValueT(EmptyValue);
-
-    // Insert all the old elements.
-    const ValueT TombstoneValue = getTombstoneValue();
-    for (BucketT *B = OldBuckets, *E = OldBuckets+OldNumBuckets; B != E; ++B) {
-      if (!ValueInfoT::isEqual(*B, EmptyValue) &&
-          !ValueInfoT::isEqual(*B, TombstoneValue)) {
-        // Insert the value into the new table.
-        BucketT *DestBucket;
-        KeyT key = ValueInfoT::toKey(*B);
-        bool FoundVal = LookupBucketFor(key, DestBucket);
-        (void)FoundVal; // silence warning.
-        assert(!FoundVal && "Key already in new map?");
-        new (DestBucket) ValueT(*B);
-
-        // Free the value.
-        (*B).~ValueT();
-      }
-    }
-
-#ifndef NDEBUG
-    if (OldNumBuckets)
-      memset((void*)OldBuckets, 0x5a, sizeof(BucketT)*OldNumBuckets);
-#endif
-    // Free the old table.
-    if (!IsPrecompiled) {
-      operator delete(OldBuckets);
-    } else {
-      IsPrecompiled = false;
-    }
-  }
-
-  void shrink_and_clear() {
-    unsigned OldNumBuckets = NumBuckets;
-    BucketT *OldBuckets = Buckets;
-
-    // Reduce the number of buckets.
-    NumBuckets = NumEntries > 32 ? 1 << (llvm::Log2_32_Ceil(NumEntries) + 1)
-                                 : 64;
-    NumTombstones = 0;
-    Buckets = static_cast<BucketT*>(operator new(sizeof(BucketT)*NumBuckets));
-
-    // Initialize all the entries to EmptyValue.
-    const ValueT EmptyValue = getEmptyValue();
-    for (unsigned i = 0, e = NumBuckets; i != e; ++i)
-      new (&Buckets[i]) ValueT(EmptyValue);
-
-    // Free the old buckets.
-    const ValueT TombstoneValue = getTombstoneValue();
-    for (BucketT *B = OldBuckets, *E = OldBuckets+OldNumBuckets; B != E; ++B) {
-      if (!ValueInfoT::isEqual(*B, EmptyValue) &&
-          !ValueInfoT::isEqual(*B, TombstoneValue)) {
-        // Free the value.
-        (*B).~ValueT();
-      }
-    }
-
-#ifndef NDEBUG
-    memset((void*)OldBuckets, 0x5a, sizeof(BucketT)*OldNumBuckets);
-#endif
-    if (!IsPrecompiled) {
-      // Free the old table.
-      operator delete(OldBuckets);
-    } else {
-      IsPrecompiled = false;
-    }
-
-    NumEntries = 0;
-  }
-  
-public:
-  /// Return the approximate size (in bytes) of the actual map.
-  /// This is just the raw memory used by MvmDenseSet.
-  /// If entries are pointers to objects, the size of the referenced objects
-  /// are not included.
-  size_t getMemorySize() const {
-    return NumBuckets * sizeof(BucketT);
-  }
-};
-
-template<typename ValueT,
-         typename ValueInfoT, bool IsConst>
-class MvmDenseSetIterator {
-  typedef ValueT Bucket;
-  typedef MvmDenseSetIterator<ValueT, ValueInfoT, true> ConstIterator;
-  friend class MvmDenseSetIterator<ValueT, ValueInfoT, true>;
-public:
-  typedef ptrdiff_t difference_type;
-  typedef typename llvm::conditional<IsConst, const Bucket, Bucket>::type value_type;
-  typedef value_type *pointer;
-  typedef value_type &reference;
-  typedef std::forward_iterator_tag iterator_category;
-private:
-  pointer Ptr, End;
-public:
-  MvmDenseSetIterator() : Ptr(0), End(0) {}
-
-  MvmDenseSetIterator(pointer Pos, pointer E) : Ptr(Pos), End(E) {
-    AdvancePastEmptyBuckets();
-  }
-
-  // If IsConst is true this is a converting constructor from iterator to
-  // const_iterator and the default copy constructor is used.
-  // Otherwise this is a copy constructor for iterator.
-  MvmDenseSetIterator(const MvmDenseSetIterator<ValueT, ValueInfoT, false>& I)
-    : Ptr(I.Ptr), End(I.End) {}
-
-  reference operator*() const {
-    return *Ptr;
-  }
-  pointer operator->() const {
-    return Ptr;
-  }
-
-  bool operator==(const ConstIterator &RHS) const {
-    return Ptr == RHS.operator->();
-  }
-  bool operator!=(const ConstIterator &RHS) const {
-    return Ptr != RHS.operator->();
-  }
-
-  inline MvmDenseSetIterator& operator++() {  // Preincrement
-    ++Ptr;
-    AdvancePastEmptyBuckets();
-    return *this;
-  }
-  MvmDenseSetIterator operator++(int) {  // Postincrement
-    MvmDenseSetIterator tmp = *this; ++*this; return tmp;
-  }
-
-private:
-  void AdvancePastEmptyBuckets() {
-    const ValueT Empty = ValueInfoT::getEmptyKey();
-    const ValueT Tombstone = ValueInfoT::getTombstoneKey();
-
-    while (Ptr != End &&
-           (ValueInfoT::isEqual(*Ptr, Empty) ||
-            ValueInfoT::isEqual(*Ptr, Tombstone)))
-      ++Ptr;
-  }
-};
-
-} // end namespace mvm
-
-#endif

Modified: vmkit/trunk/include/vmkit/System.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/System.h?rev=145034&r1=145033&r2=145034&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/System.h (original)
+++ vmkit/trunk/include/vmkit/System.h Mon Nov 21 04:39:23 2011
@@ -64,11 +64,11 @@
 #if ARCH_X64
 const word_t kThreadStart   = 0x0000000110000000LL;
 const word_t kThreadIDMask  = 0xFFFFFFFFFFF00000LL;
-const word_t kMvmThreadMask = 0xFFFFFFFFF0000000LL;
+const word_t kVmkitThreadMask = 0xFFFFFFFFF0000000LL;
 #else
 const word_t kThreadStart   = 0x10000000;
 const word_t kThreadIDMask  = 0x7FF00000;
-const word_t kMvmThreadMask = 0xF0000000;
+const word_t kVmkitThreadMask = 0xF0000000;
 #endif
 
 #if MACOS_OS
@@ -135,8 +135,8 @@
   }
 
   // Apply this mask to verify that the current thread was created by Mvm.
-  static word_t GetMvmThreadMask() {
-    return kMvmThreadMask;
+  static word_t GetVmkitThreadMask() {
+    return kVmkitThreadMask;
   }
 
   // Get the memory start of thread stack addresses.

Modified: vmkit/trunk/include/vmkit/Thread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Thread.h?rev=145034&r1=145033&r2=145034&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Thread.h (original)
+++ vmkit/trunk/include/vmkit/Thread.h Mon Nov 21 04:39:23 2011
@@ -219,9 +219,9 @@
     internalClearException();
   }
 
-  bool isMvmThread() {
+  bool isVmkitThread() {
     if (!baseAddr) return false;
-    else return (((word_t)this) & System::GetMvmThreadMask()) == baseAddr;
+    else return (((word_t)this) & System::GetVmkitThreadMask()) == baseAddr;
   }
 
   /// baseAddr - The base address for all threads.

Modified: vmkit/trunk/include/vmkit/UTF8.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/UTF8.h?rev=145034&r1=145033&r2=145034&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/UTF8.h (original)
+++ vmkit/trunk/include/vmkit/UTF8.h Mon Nov 21 04:39:23 2011
@@ -3,8 +3,8 @@
 
 #include <map>
 #include "vmkit/Allocator.h"
-#include "vmkit/MvmDenseMap.h"
-#include "vmkit/MvmDenseSet.h"
+#include "vmkit/VmkitDenseMap.h"
+#include "vmkit/VmkitDenseSet.h"
 
 namespace mvm {
 
@@ -76,9 +76,9 @@
   }
 };
 
-// Provide MvmDenseMapInfo for UTF8.
+// Provide VmkitDenseMapInfo for UTF8.
 template<>
-struct MvmDenseMapInfo<const UTF8*> {
+struct VmkitDenseMapInfo<const UTF8*> {
   static inline const UTF8* getEmptyKey() {
     return &EmptyKey;
   }
@@ -98,9 +98,9 @@
 };
 
 
-// Provide MvmDenseMapInfo for UTF8MapKey.
+// Provide VmkitDenseMapInfo for UTF8MapKey.
 template<>
-struct MvmDenseMapInfo<UTF8MapKey> {
+struct VmkitDenseMapInfo<UTF8MapKey> {
   static inline const UTF8MapKey getEmptyKey() {
     static UTF8MapKey EmptyKey(NULL, -1);
     return EmptyKey;
@@ -121,11 +121,11 @@
 
 class UTF8Map : public mvm::PermanentObject {
 public:
-  typedef MvmDenseSet<UTF8MapKey, const UTF8*>::iterator iterator;
+  typedef VmkitDenseSet<UTF8MapKey, const UTF8*>::iterator iterator;
   
   LockNormal lock;
   BumpPtrAllocator& allocator;
-  MvmDenseSet<UTF8MapKey, const UTF8*> map;
+  VmkitDenseSet<UTF8MapKey, const UTF8*> map;
 
   const UTF8* lookupOrCreateAsciiz(const char* asciiz); 
   const UTF8* lookupOrCreateReader(const uint16* buf, uint32 size);
@@ -133,7 +133,7 @@
   const UTF8* lookupReader(const uint16* buf, uint32 size);
   
   UTF8Map(BumpPtrAllocator& A) : allocator(A) {}
-  UTF8Map(BumpPtrAllocator& A, MvmDenseSet<UTF8MapKey, const UTF8*>* m)
+  UTF8Map(BumpPtrAllocator& A, VmkitDenseSet<UTF8MapKey, const UTF8*>* m)
       : allocator(A), map(*m) {}
 
   ~UTF8Map() {

Copied: vmkit/trunk/include/vmkit/VmkitDenseMap.h (from r145031, vmkit/trunk/include/vmkit/MvmDenseMap.h)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/VmkitDenseMap.h?p2=vmkit/trunk/include/vmkit/VmkitDenseMap.h&p1=vmkit/trunk/include/vmkit/MvmDenseMap.h&r1=145031&r2=145034&rev=145034&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/MvmDenseMap.h (original)
+++ vmkit/trunk/include/vmkit/VmkitDenseMap.h Mon Nov 21 04:39:23 2011
@@ -1,4 +1,4 @@
-//===- MvmDenseMap.h - Dense probed hash table ------------------*- C++ -*-===//
+//===- VmkitDenseMap.h - Dense probed hash table ------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the MvmDenseMap copied from llvm/ADT/DenseMap.h, but
+// This file defines the VmkitDenseMap copied from llvm/ADT/DenseMap.h, but
 // without storing pairs.
 //
 //===----------------------------------------------------------------------===//
@@ -29,7 +29,7 @@
 namespace mvm {
 
 template<typename T>
-struct MvmDenseMapInfo {
+struct VmkitDenseMapInfo {
   //static inline T getEmptyKey();
   //static inline T getTombstoneKey();
   //static unsigned getHashValue(const T &Val);
@@ -37,21 +37,21 @@
 };
 
 template<typename KeyT, typename ValueT,
-         typename KeyInfoT = MvmDenseMapInfo<KeyT>,
+         typename KeyInfoT = VmkitDenseMapInfo<KeyT>,
          bool IsConst = false>
-class MvmDenseMapIterator;
+class VmkitDenseMapIterator;
 
 template<typename KeyT, typename ValueT>
-struct MvmPair {
+struct VmkitPair {
   KeyT first;
   ValueT second;
 };
 
 template<typename KeyT, typename ValueT,
-         typename KeyInfoT = MvmDenseMapInfo<KeyT> >
-class MvmDenseMap {
+         typename KeyInfoT = VmkitDenseMapInfo<KeyT> >
+class VmkitDenseMap {
 public:
-  typedef MvmPair<KeyT, ValueT> BucketT;
+  typedef VmkitPair<KeyT, ValueT> BucketT;
   uint32_t NumBuckets;
   BucketT *Buckets;
 
@@ -63,12 +63,12 @@
   typedef ValueT mapped_type;
   typedef BucketT value_type;
 
-  explicit MvmDenseMap(unsigned NumInitBuckets = 0) {
+  explicit VmkitDenseMap(unsigned NumInitBuckets = 0) {
     IsPrecompiled = false;
     init(NumInitBuckets);
   }
 
-  ~MvmDenseMap() {
+  ~VmkitDenseMap() {
     const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
     for (BucketT *P = Buckets, *E = Buckets+NumBuckets; P != E; ++P) {
       if (!KeyInfoT::isEqual(P->first, EmptyKey) &&
@@ -85,8 +85,8 @@
     }
   }
 
-  typedef MvmDenseMapIterator<KeyT, ValueT, KeyInfoT> iterator;
-  typedef MvmDenseMapIterator<KeyT, ValueT, KeyInfoT, true> const_iterator;
+  typedef VmkitDenseMapIterator<KeyT, ValueT, KeyInfoT> iterator;
+  typedef VmkitDenseMapIterator<KeyT, ValueT, KeyInfoT, true> const_iterator;
   inline iterator begin() {
     // When the map is empty, avoid the overhead of AdvancePastEmptyBuckets().
     return empty() ? end() : iterator(Buckets, Buckets+NumBuckets);
@@ -204,7 +204,7 @@
     ++NumTombstones;
   }
 
-  void swap(MvmDenseMap& RHS) {
+  void swap(VmkitDenseMap& RHS) {
     std::swap(NumBuckets, RHS.NumBuckets);
     std::swap(Buckets, RHS.Buckets);
     std::swap(NumEntries, RHS.NumEntries);
@@ -224,15 +224,15 @@
   }
 
   /// isPointerIntoBucketsArray - Return true if the specified pointer points
-  /// somewhere into the MvmDenseMap's array of buckets (i.e. either to a key or
-  /// value in the MvmDenseMap).
+  /// somewhere into the VmkitDenseMap's array of buckets (i.e. either to a key or
+  /// value in the VmkitDenseMap).
   bool isPointerIntoBucketsArray(const void *Ptr) const {
     return Ptr >= Buckets && Ptr < Buckets+NumBuckets;
   }
 
   /// getPointerIntoBucketsArray() - Return an opaque pointer into the buckets
   /// array.  In conjunction with the previous method, this can be used to
-  /// determine whether an insertion caused the MvmDenseMap to reallocate.
+  /// determine whether an insertion caused the VmkitDenseMap to reallocate.
   const void *getPointerIntoBucketsArray() const { return Buckets; }
 
 private:
@@ -436,7 +436,7 @@
   
 public:
   /// Return the approximate size (in bytes) of the actual map.
-  /// This is just the raw memory used by MvmDenseMap.
+  /// This is just the raw memory used by VmkitDenseMap.
   /// If entries are pointers to objects, the size of the referenced objects
   /// are not included.
   size_t getMemorySize() const {
@@ -446,10 +446,10 @@
 
 template<typename KeyT, typename ValueT,
          typename KeyInfoT, bool IsConst>
-class MvmDenseMapIterator {
-  typedef MvmPair<KeyT, ValueT> Bucket;
-  typedef MvmDenseMapIterator<KeyT, ValueT, KeyInfoT, true> ConstIterator;
-  friend class MvmDenseMapIterator<KeyT, ValueT, KeyInfoT, true>;
+class VmkitDenseMapIterator {
+  typedef VmkitPair<KeyT, ValueT> Bucket;
+  typedef VmkitDenseMapIterator<KeyT, ValueT, KeyInfoT, true> ConstIterator;
+  friend class VmkitDenseMapIterator<KeyT, ValueT, KeyInfoT, true>;
 public:
   typedef ptrdiff_t difference_type;
   typedef typename llvm::conditional<IsConst, const Bucket, Bucket>::type value_type;
@@ -459,16 +459,16 @@
 private:
   pointer Ptr, End;
 public:
-  MvmDenseMapIterator() : Ptr(0), End(0) {}
+  VmkitDenseMapIterator() : Ptr(0), End(0) {}
 
-  MvmDenseMapIterator(pointer Pos, pointer E) : Ptr(Pos), End(E) {
+  VmkitDenseMapIterator(pointer Pos, pointer E) : Ptr(Pos), End(E) {
     AdvancePastEmptyBuckets();
   }
 
   // If IsConst is true this is a converting constructor from iterator to
   // const_iterator and the default copy constructor is used.
   // Otherwise this is a copy constructor for iterator.
-  MvmDenseMapIterator(const MvmDenseMapIterator<KeyT, ValueT,
+  VmkitDenseMapIterator(const VmkitDenseMapIterator<KeyT, ValueT,
                                           KeyInfoT, false>& I)
     : Ptr(I.Ptr), End(I.End) {}
 
@@ -486,13 +486,13 @@
     return Ptr != RHS.operator->();
   }
 
-  inline MvmDenseMapIterator& operator++() {  // Preincrement
+  inline VmkitDenseMapIterator& operator++() {  // Preincrement
     ++Ptr;
     AdvancePastEmptyBuckets();
     return *this;
   }
-  MvmDenseMapIterator operator++(int) {  // Postincrement
-    MvmDenseMapIterator tmp = *this; ++*this; return tmp;
+  VmkitDenseMapIterator operator++(int) {  // Postincrement
+    VmkitDenseMapIterator tmp = *this; ++*this; return tmp;
   }
 
 private:

Copied: vmkit/trunk/include/vmkit/VmkitDenseSet.h (from r145031, vmkit/trunk/include/vmkit/MvmDenseSet.h)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/VmkitDenseSet.h?p2=vmkit/trunk/include/vmkit/VmkitDenseSet.h&p1=vmkit/trunk/include/vmkit/MvmDenseSet.h&r1=145031&r2=145034&rev=145034&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/MvmDenseSet.h (original)
+++ vmkit/trunk/include/vmkit/VmkitDenseSet.h Mon Nov 21 04:39:23 2011
@@ -1,4 +1,4 @@
-//===- MvmDenseSet.h - Dense probed hash set --------------------*- C++ -*-===//
+//===- VmkitDenseSet.h - Dense probed hash set --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the MvmDenseSet class copied from llvm/ADT/DenseMap.h, but
+// This file defines the VmkitDenseSet class copied from llvm/ADT/DenseMap.h, but
 // without storing pairs.
 //
 //===----------------------------------------------------------------------===//
@@ -30,14 +30,14 @@
 namespace mvm {
 
 template<typename ValueT,
-         typename ValueInfoT = MvmDenseMapInfo<ValueT>,
+         typename ValueInfoT = VmkitDenseMapInfo<ValueT>,
          bool IsConst = false>
-class MvmDenseSetIterator;
+class VmkitDenseSetIterator;
 
 template<typename KeyT, typename ValueT,
-         typename KeyInfoT = MvmDenseMapInfo<KeyT>,
-         typename ValueInfoT = MvmDenseMapInfo<ValueT> >
-class MvmDenseSet {
+         typename KeyInfoT = VmkitDenseMapInfo<KeyT>,
+         typename ValueInfoT = VmkitDenseMapInfo<ValueT> >
+class VmkitDenseSet {
 public:
   typedef ValueT BucketT;
   uint32_t NumBuckets;
@@ -51,12 +51,12 @@
   typedef ValueT mapped_type;
   typedef BucketT value_type;
 
-  explicit MvmDenseSet(unsigned NumInitBuckets = 0) {
+  explicit VmkitDenseSet(unsigned NumInitBuckets = 0) {
     IsPrecompiled = false;
     init(NumInitBuckets);
   }
 
-  ~MvmDenseSet() {
+  ~VmkitDenseSet() {
     const ValueT EmptyValue = getEmptyValue(), TombstoneValue = getTombstoneValue();
     for (BucketT *P = Buckets, *E = Buckets+NumBuckets; P != E; ++P) {
       if (!ValueInfoT::isEqual(*P, EmptyValue) &&
@@ -72,8 +72,8 @@
     }
   }
 
-  typedef MvmDenseSetIterator<ValueT, ValueInfoT> iterator;
-  typedef MvmDenseSetIterator<ValueT, ValueInfoT, true> const_iterator;
+  typedef VmkitDenseSetIterator<ValueT, ValueInfoT> iterator;
+  typedef VmkitDenseSetIterator<ValueT, ValueInfoT, true> const_iterator;
   inline iterator begin() {
     // When the map is empty, avoid the overhead of AdvancePastEmptyBuckets().
     return empty() ? end() : iterator(Buckets, Buckets+NumBuckets);
@@ -191,7 +191,7 @@
     ++NumTombstones;
   }
 
-  void swap(MvmDenseSet& RHS) {
+  void swap(VmkitDenseSet& RHS) {
     std::swap(NumBuckets, RHS.NumBuckets);
     std::swap(Buckets, RHS.Buckets);
     std::swap(NumEntries, RHS.NumEntries);
@@ -211,14 +211,14 @@
   }
 
   /// isPointerIntoBucketsArray - Return true if the specified pointer points
-  /// somewhere into the MvmDenseSet's array of buckets.
+  /// somewhere into the VmkitDenseSet's array of buckets.
   bool isPointerIntoBucketsArray(const void *Ptr) const {
     return Ptr >= Buckets && Ptr < Buckets+NumBuckets;
   }
 
   /// getPointerIntoBucketsArray() - Return an opaque pointer into the buckets
   /// array.  In conjunction with the previous method, this can be used to
-  /// determine whether an insertion caused the MvmDenseSet to reallocate.
+  /// determine whether an insertion caused the VmkitDenseSet to reallocate.
   const void *getPointerIntoBucketsArray() const { return Buckets; }
 
 private:
@@ -416,7 +416,7 @@
   
 public:
   /// Return the approximate size (in bytes) of the actual map.
-  /// This is just the raw memory used by MvmDenseSet.
+  /// This is just the raw memory used by VmkitDenseSet.
   /// If entries are pointers to objects, the size of the referenced objects
   /// are not included.
   size_t getMemorySize() const {
@@ -426,10 +426,10 @@
 
 template<typename ValueT,
          typename ValueInfoT, bool IsConst>
-class MvmDenseSetIterator {
+class VmkitDenseSetIterator {
   typedef ValueT Bucket;
-  typedef MvmDenseSetIterator<ValueT, ValueInfoT, true> ConstIterator;
-  friend class MvmDenseSetIterator<ValueT, ValueInfoT, true>;
+  typedef VmkitDenseSetIterator<ValueT, ValueInfoT, true> ConstIterator;
+  friend class VmkitDenseSetIterator<ValueT, ValueInfoT, true>;
 public:
   typedef ptrdiff_t difference_type;
   typedef typename llvm::conditional<IsConst, const Bucket, Bucket>::type value_type;
@@ -439,16 +439,16 @@
 private:
   pointer Ptr, End;
 public:
-  MvmDenseSetIterator() : Ptr(0), End(0) {}
+  VmkitDenseSetIterator() : Ptr(0), End(0) {}
 
-  MvmDenseSetIterator(pointer Pos, pointer E) : Ptr(Pos), End(E) {
+  VmkitDenseSetIterator(pointer Pos, pointer E) : Ptr(Pos), End(E) {
     AdvancePastEmptyBuckets();
   }
 
   // If IsConst is true this is a converting constructor from iterator to
   // const_iterator and the default copy constructor is used.
   // Otherwise this is a copy constructor for iterator.
-  MvmDenseSetIterator(const MvmDenseSetIterator<ValueT, ValueInfoT, false>& I)
+  VmkitDenseSetIterator(const VmkitDenseSetIterator<ValueT, ValueInfoT, false>& I)
     : Ptr(I.Ptr), End(I.End) {}
 
   reference operator*() const {
@@ -465,13 +465,13 @@
     return Ptr != RHS.operator->();
   }
 
-  inline MvmDenseSetIterator& operator++() {  // Preincrement
+  inline VmkitDenseSetIterator& operator++() {  // Preincrement
     ++Ptr;
     AdvancePastEmptyBuckets();
     return *this;
   }
-  MvmDenseSetIterator operator++(int) {  // Postincrement
-    MvmDenseSetIterator tmp = *this; ++*this; return tmp;
+  VmkitDenseSetIterator operator++(int) {  // Postincrement
+    VmkitDenseSetIterator tmp = *this; ++*this; return tmp;
   }
 
 private:

Modified: vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=145034&r1=145033&r2=145034&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp Mon Nov 21 04:39:23 2011
@@ -1041,7 +1041,7 @@
   return ConstantStruct::get(STy, ClassElts);
 }
 
-Constant* JavaAOTCompiler::CreateConstantFromClassMap(const mvm::MvmDenseMap<const UTF8*, CommonClass*>& map) {
+Constant* JavaAOTCompiler::CreateConstantFromClassMap(const mvm::VmkitDenseMap<const UTF8*, CommonClass*>& map) {
   StructType* STy = 
     dyn_cast<StructType>(JavaIntrinsics.J3DenseMapType->getContainedType(0));
   Module& Mod = *getLLVMModule();
@@ -1055,7 +1055,7 @@
     ArrayType* ATy = ArrayType::get(JavaIntrinsics.ptrType, map.NumBuckets * 2);
 
     for (uint32 i = 0; i < map.NumBuckets; ++i) {
-      mvm::MvmPair<const UTF8*, CommonClass*> pair = map.Buckets[i];
+      mvm::VmkitPair<const UTF8*, CommonClass*> pair = map.Buckets[i];
       if (pair.first == &mvm::TombstoneKey) {
         TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, UTF8TombstoneGV, JavaIntrinsics.ptrType));
         TempElts.push_back(Constant::getNullValue(JavaIntrinsics.ptrType));
@@ -1086,7 +1086,7 @@
                             ConstantStruct::get(STy, elements), "ClassMap");
 }
 
-Constant* JavaAOTCompiler::CreateConstantFromUTF8Map(const mvm::MvmDenseSet<mvm::UTF8MapKey, const UTF8*>& set) {
+Constant* JavaAOTCompiler::CreateConstantFromUTF8Map(const mvm::VmkitDenseSet<mvm::UTF8MapKey, const UTF8*>& set) {
   StructType* STy = 
     dyn_cast<StructType>(JavaIntrinsics.J3DenseMapType->getContainedType(0));
   Module& Mod = *getLLVMModule();

Modified: vmkit/trunk/lib/J3/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LockedMap.h?rev=145034&r1=145033&r2=145034&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LockedMap.h (original)
+++ vmkit/trunk/lib/J3/VMCore/LockedMap.h Mon Nov 21 04:39:23 2011
@@ -24,7 +24,7 @@
 #include "types.h"
 
 #include "vmkit/Allocator.h"
-#include "vmkit/MvmDenseMap.h"
+#include "vmkit/VmkitDenseMap.h"
 #include "vmkit/Locks.h"
 #include "UTF8.h"
 
@@ -111,25 +111,25 @@
 class ClassMap : public mvm::PermanentObject {
 public:
   ClassMap() {}
-  ClassMap(mvm::MvmDenseMap<const mvm::UTF8*, UserCommonClass*>* precompiled) : map(*precompiled) {}
+  ClassMap(mvm::VmkitDenseMap<const mvm::UTF8*, UserCommonClass*>* precompiled) : map(*precompiled) {}
 
   mvm::LockRecursive lock;
-  mvm::MvmDenseMap<const mvm::UTF8*, UserCommonClass*> map;
-  typedef mvm::MvmDenseMap<const mvm::UTF8*, UserCommonClass*>::iterator iterator;
+  mvm::VmkitDenseMap<const mvm::UTF8*, UserCommonClass*> map;
+  typedef mvm::VmkitDenseMap<const mvm::UTF8*, UserCommonClass*>::iterator iterator;
 };
 
 class TypeMap : public mvm::PermanentObject {
 public:
   mvm::LockNormal lock;
-  mvm::MvmDenseMap<const mvm::UTF8*, Typedef*> map;
-  typedef mvm::MvmDenseMap<const mvm::UTF8*, Typedef*>::iterator iterator;
+  mvm::VmkitDenseMap<const mvm::UTF8*, Typedef*> map;
+  typedef mvm::VmkitDenseMap<const mvm::UTF8*, Typedef*>::iterator iterator;
 };
 
 class SignMap : public mvm::PermanentObject {
 public:
   mvm::LockNormal lock;
-  mvm::MvmDenseMap<const mvm::UTF8*, Signdef*> map;
-  typedef mvm::MvmDenseMap<const mvm::UTF8*, Signdef*>::iterator iterator;
+  mvm::VmkitDenseMap<const mvm::UTF8*, Signdef*> map;
+  typedef mvm::VmkitDenseMap<const mvm::UTF8*, Signdef*>::iterator iterator;
 };
 
 } // end namespace j3

Modified: vmkit/trunk/lib/J3/VMCore/Precompiled.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Precompiled.cpp?rev=145034&r1=145033&r2=145034&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Precompiled.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Precompiled.cpp Mon Nov 21 04:39:23 2011
@@ -150,12 +150,12 @@
   upcalls->OfLong->classLoader = loader;
   upcalls->OfDouble->classLoader = loader;
 
-  mvm::MvmDenseSet<mvm::UTF8MapKey, const UTF8*>* precompiledUTF8Map =
-    reinterpret_cast<mvm::MvmDenseSet<mvm::UTF8MapKey, const UTF8*>*>(dlsym(nativeHandle, "UTF8Map"));
+  mvm::VmkitDenseSet<mvm::UTF8MapKey, const UTF8*>* precompiledUTF8Map =
+    reinterpret_cast<mvm::VmkitDenseSet<mvm::UTF8MapKey, const UTF8*>*>(dlsym(nativeHandle, "UTF8Map"));
   loader->hashUTF8 = new (loader->allocator, "UTF8Map") UTF8Map(loader->allocator, precompiledUTF8Map);
   
-  mvm::MvmDenseMap<const UTF8*, CommonClass*>* precompiledClassMap =
-    reinterpret_cast<mvm::MvmDenseMap<const UTF8*, CommonClass*>*>(dlsym(nativeHandle, "ClassMap"));
+  mvm::VmkitDenseMap<const UTF8*, CommonClass*>* precompiledClassMap =
+    reinterpret_cast<mvm::VmkitDenseMap<const UTF8*, CommonClass*>*>(dlsym(nativeHandle, "ClassMap"));
   loader->classes = new (loader->allocator, "ClassMap") ClassMap(precompiledClassMap);
 
   for (ClassMap::iterator i = loader->getClasses()->map.begin(),

Modified: vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp?rev=145034&r1=145033&r2=145034&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp Mon Nov 21 04:39:23 2011
@@ -41,7 +41,7 @@
 
 void Thread::yield(void) {
   Thread* th = mvm::Thread::get();
-  if (th->isMvmThread()) {
+  if (th->isVmkitThread()) {
     if (th->doYield && !th->inRV) {
       th->MyVM->rendezvous.join();
     }
@@ -180,7 +180,7 @@
 }
 
 void Thread::enterUncooperativeCode(uint16_t level) {
-  if (isMvmThread()) {
+  if (isVmkitThread()) {
     if (!inRV) {
       assert(!lastSP && "SP already set when entering uncooperative code");
       // Get the caller.
@@ -197,7 +197,7 @@
 }
 
 void Thread::enterUncooperativeCode(word_t SP) {
-  if (isMvmThread()) {
+  if (isVmkitThread()) {
     if (!inRV) {
       assert(!lastSP && "SP already set when entering uncooperative code");
       // The cas is not necessary, but it does a memory barrier.
@@ -209,7 +209,7 @@
 }
 
 void Thread::leaveUncooperativeCode() {
-  if (isMvmThread()) {
+  if (isVmkitThread()) {
     if (!inRV) {
       assert(lastSP && "No last SP when leaving uncooperative code");
       word_t savedSP = lastSP;




From gael.thomas at lip6.fr  Mon Nov 21 02:50:42 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Mon, 21 Nov 2011 10:50:42 -0000
Subject: [vmkit-commits] [vmkit] r145035 - in /vmkit/trunk:
 lib/Mvm/Compiler/Makefile lib/Mvm/Runtime/Makefile tools/j3/Makefile
 tools/llcj/llcj.cpp tools/precompiler/Makefile tools/vmjc/Makefile
Message-ID: <20111121105042.F0C672A6C134@llvm.org>

Author: gthomas
Date: Mon Nov 21 04:50:42 2011
New Revision: 145035

URL: http://llvm.org/viewvc/llvm-project?rev=145035&view=rev
Log:
libMvm*.a are now libVmkit*.a

Modified:
    vmkit/trunk/lib/Mvm/Compiler/Makefile
    vmkit/trunk/lib/Mvm/Runtime/Makefile
    vmkit/trunk/tools/j3/Makefile
    vmkit/trunk/tools/llcj/llcj.cpp
    vmkit/trunk/tools/precompiler/Makefile
    vmkit/trunk/tools/vmjc/Makefile

Modified: vmkit/trunk/lib/Mvm/Compiler/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/Makefile?rev=145035&r1=145034&r2=145035&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/Makefile (original)
+++ vmkit/trunk/lib/Mvm/Compiler/Makefile Mon Nov 21 04:50:42 2011
@@ -10,7 +10,7 @@
 
 include $(LEVEL)/Makefile.config
 
-MODULE_WITH_GC = MvmCompiler
+MODULE_WITH_GC = VmkitCompiler
 
 VMKIT_RUNTIME = $(PROJ_SRC_DIR)/LLVMRuntime.ll
 BUILT_SOURCES = LLVMRuntime.inc

Modified: vmkit/trunk/lib/Mvm/Runtime/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/Makefile?rev=145035&r1=145034&r2=145035&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/Makefile (original)
+++ vmkit/trunk/lib/Mvm/Runtime/Makefile Mon Nov 21 04:50:42 2011
@@ -10,6 +10,6 @@
 
 include $(LEVEL)/Makefile.config
 
-MODULE_WITH_GC = Mvm
+MODULE_WITH_GC = Vmkit
 
 include $(LEVEL)/Makefile.common

Modified: vmkit/trunk/tools/j3/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/j3/Makefile?rev=145035&r1=145034&r2=145035&view=diff
==============================================================================
--- vmkit/trunk/tools/j3/Makefile (original)
+++ vmkit/trunk/tools/j3/Makefile Mon Nov 21 04:50:42 2011
@@ -11,7 +11,7 @@
 include $(LEVEL)/Makefile.config
 
 TOOLNAME = j3
-USEDLIBS = Classpath.a J3.a J3Compiler.a Mvm.a MvmCompiler.a CommonThread.a FinalMMTk.a InlineMMTk.a Precompiled.a BootstrapClasses.a
+USEDLIBS = Classpath.a J3.a J3Compiler.a Vmkit.a VmkitCompiler.a CommonThread.a FinalMMTk.a InlineMMTk.a Precompiled.a BootstrapClasses.a
 BUILD_FRAMETABLE = 1
 LINK_COMPONENTS = jit nativecodegen scalaropts instrumentation ipa ipo
 

Modified: vmkit/trunk/tools/llcj/llcj.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/llcj/llcj.cpp?rev=145035&r1=145034&r2=145035&view=diff
==============================================================================
--- vmkit/trunk/tools/llcj/llcj.cpp (original)
+++ vmkit/trunk/tools/llcj/llcj.cpp Mon Nov 21 04:50:42 2011
@@ -227,8 +227,8 @@
     }
     gccArgv[gccArgc++] = "-lAllocator";
     gccArgv[gccArgc++] = "-lCommonThread";
-    gccArgv[gccArgc++] = "-lMvm";
-    gccArgv[gccArgc++] = "-lMvmCompiler";
+    gccArgv[gccArgc++] = "-lVmkit";
+    gccArgv[gccArgc++] = "-lVmkitCompiler";
     gccArgv[gccArgc++] = "-lGCMmap2";
     gccArgv[gccArgc++] = "-lvmjc";
     gccArgv[gccArgc++] = "-lLLVMSupport";

Modified: vmkit/trunk/tools/precompiler/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/precompiler/Makefile?rev=145035&r1=145034&r2=145035&view=diff
==============================================================================
--- vmkit/trunk/tools/precompiler/Makefile (original)
+++ vmkit/trunk/tools/precompiler/Makefile Mon Nov 21 04:50:42 2011
@@ -12,7 +12,7 @@
 
 DIRS = trainer
 TOOLNAME = precompiler
-USEDLIBS = Classpath.a J3.a J3Compiler.a Mvm.a MvmCompiler.a CommonThread.a FinalMMTk.a
+USEDLIBS = Classpath.a J3.a J3Compiler.a Vmkit.a VmkitCompiler.a CommonThread.a FinalMMTk.a
 BUILD_FRAMETABLE = 1
 LINK_COMPONENTS = jit nativecodegen scalaropts instrumentation ipa ipo asmparser linker bitwriter
 

Modified: vmkit/trunk/tools/vmjc/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmjc/Makefile?rev=145035&r1=145034&r2=145035&view=diff
==============================================================================
--- vmkit/trunk/tools/vmjc/Makefile (original)
+++ vmkit/trunk/tools/vmjc/Makefile Mon Nov 21 04:50:42 2011
@@ -13,7 +13,7 @@
 EXTRA_DIST = libvmjc
 
 TOOLNAME = vmjc
-USEDLIBS = J3.a Classpath.a J3.a J3Compiler.a Mvm.a MvmCompiler.a MMTk.a CommonThread.a
+USEDLIBS = J3.a Classpath.a J3.a J3Compiler.a Vmkit.a VmkitCompiler.a MMTk.a CommonThread.a
 LINK_COMPONENTS = jit nativecodegen scalaropts instrumentation ipa ipo bitwriter
 
 include $(LEVEL)/Makefile.common




From gael.thomas at lip6.fr  Mon Nov 21 02:53:24 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Mon, 21 Nov 2011 10:53:24 -0000
Subject: [vmkit-commits] [vmkit] r145036 -
	/vmkit/trunk/include/vmkit/config.h.in
Message-ID: <20111121105324.634EB2A6C134@llvm.org>

Author: gthomas
Date: Mon Nov 21 04:53:24 2011
New Revision: 145036

URL: http://llvm.org/viewvc/llvm-project?rev=145036&view=rev
Log:
fix the comments in config.h.in by calling autoheader

Modified:
    vmkit/trunk/include/vmkit/config.h.in

Modified: vmkit/trunk/include/vmkit/config.h.in
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/config.h.in?rev=145036&r1=145035&r2=145036&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/config.h.in (original)
+++ vmkit/trunk/include/vmkit/config.h.in Mon Nov 21 04:53:24 2011
@@ -1,4 +1,4 @@
-/* include/mvm/Config/config.h.in.  Generated from autoconf/configure.ac by autoheader.  */
+/* include/vmkit/config.h.in.  Generated from autoconf/configure.ac by autoheader.  */
 
 /* Define to 1 if the system has the type `int64_t'. */
 #undef HAVE_INT64_T
@@ -6,12 +6,6 @@
 /* Define to 1 if you have the <inttypes.h> header file. */
 #undef HAVE_INTTYPES_H
 
-/* Define to 1 if you have the `gc' library (-lgc). */
-#undef HAVE_LIBGC
-
-/* Define to 1 if you have the `pthread' library (-lpthread). */
-#undef HAVE_LIBPTHREAD
-
 /* Define to 1 if you have the `z' library (-lz). */
 #undef HAVE_LIBZ
 
@@ -21,9 +15,6 @@
 /* Define to 1 if you have the <memory.h> header file. */
 #undef HAVE_MEMORY_H
 
-/* Using pthread library */
-#undef HAVE_PTHREAD
-
 /* Define to 1 if you have the `setjmp' function. */
 #undef HAVE_SETJMP
 
@@ -66,18 +57,21 @@
 /* Define to the one symbol short name of this package. */
 #undef PACKAGE_TARNAME
 
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
 /* Define to the version of this package. */
 #undef PACKAGE_VERSION
 
-/* Define as the return type of signal handlers (`int' or `void'). */
-#undef RETSIGTYPE
-
 /* Define to 1 if you have the ANSI C header files. */
 #undef STDC_HEADERS
 
 /* Define to 1 if your <sys/time.h> declares `struct tm'. */
 #undef TM_IN_SYS_TIME
 
+/* Building on a platform with 64bit cas */
+#undef WITH_64
+
 /* Define to `int' if <sys/types.h> does not define. */
 #undef pid_t
 




From gael.thomas at lip6.fr  Mon Nov 21 02:57:36 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Mon, 21 Nov 2011 10:57:36 -0000
Subject: [vmkit-commits] [vmkit] r145037 - in /vmkit/trunk: Makefile
 autoconf/configure.ac configure include/vmkit/System.h lib/Makefile
 lib/Mvm/ lib/vmkit/ lib/vmkit/CommonThread/Makefile
 lib/vmkit/Compiler/Makefile lib/vmkit/JITGCPass/Makefile
 lib/vmkit/MMTk/Makefile lib/vmkit/Makefile lib/vmkit/Runtime/Makefile
 lib/vmkit/StaticGCPass/Makefile lib/vmkit/StaticGCPrinter/Makefile
 mmtk/inline/Makefile
Message-ID: <20111121105736.55A052A6C134@llvm.org>

Author: gthomas
Date: Mon Nov 21 04:57:35 2011
New Revision: 145037

URL: http://llvm.org/viewvc/llvm-project?rev=145037&view=rev
Log:
Rename the directory lib/Mvm into lib/vmkit

Added:
    vmkit/trunk/lib/vmkit/
      - copied from r145034, vmkit/trunk/lib/Mvm/
    vmkit/trunk/lib/vmkit/Compiler/Makefile
      - copied, changed from r145035, vmkit/trunk/lib/Mvm/Compiler/Makefile
    vmkit/trunk/lib/vmkit/Runtime/Makefile
      - copied, changed from r145035, vmkit/trunk/lib/Mvm/Runtime/Makefile
Removed:
    vmkit/trunk/lib/Mvm/
Modified:
    vmkit/trunk/Makefile
    vmkit/trunk/autoconf/configure.ac
    vmkit/trunk/configure
    vmkit/trunk/include/vmkit/System.h
    vmkit/trunk/lib/Makefile
    vmkit/trunk/lib/vmkit/CommonThread/Makefile
    vmkit/trunk/lib/vmkit/JITGCPass/Makefile
    vmkit/trunk/lib/vmkit/MMTk/Makefile
    vmkit/trunk/lib/vmkit/Makefile
    vmkit/trunk/lib/vmkit/StaticGCPass/Makefile
    vmkit/trunk/lib/vmkit/StaticGCPrinter/Makefile
    vmkit/trunk/mmtk/inline/Makefile

Modified: vmkit/trunk/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile?rev=145037&r1=145036&r2=145037&view=diff
==============================================================================
--- vmkit/trunk/Makefile (original)
+++ vmkit/trunk/Makefile Mon Nov 21 04:57:35 2011
@@ -13,7 +13,7 @@
 
 # Top-Level vmkit Build Stages:
 #
-DIRS := lib/Mvm/StaticGCPass lib/Mvm/StaticGCPrinter lib tools/vmjc mmtk tools/precompiler tools
+DIRS := lib/vmkit/StaticGCPass lib/vmkit/StaticGCPrinter lib tools/vmjc mmtk tools/precompiler tools
 
 EXTRA_DIST=include
 

Modified: vmkit/trunk/autoconf/configure.ac
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/autoconf/configure.ac?rev=145037&r1=145036&r2=145037&view=diff
==============================================================================
--- vmkit/trunk/autoconf/configure.ac (original)
+++ vmkit/trunk/autoconf/configure.ac Mon Nov 21 04:57:35 2011
@@ -44,7 +44,7 @@
 
 dnl Verify that the source directory is valid. This makes sure that we are
 dnl configuring VMKit and not some other package (it validates --srcdir argument)
-AC_CONFIG_SRCDIR([lib/Mvm/Runtime/Object.cpp])
+AC_CONFIG_SRCDIR([lib/vmkit/Runtime/Object.cpp])
 
 
 dnl Quit if the source directory has already been configured.
@@ -174,7 +174,7 @@
        [[MMTK_PLAN=org.mmtk.plan.marksweep.MS]]
 )
 
-GC_FLAGS="-I\$(PROJ_SRC_ROOT)/lib/Mvm/MMTk"
+GC_FLAGS="-I\$(PROJ_SRC_ROOT)/lib/vmkit/MMTk"
 
 AC_SUBST([GC_FLAGS])
 AC_SUBST([MMTK_PLAN])

Modified: vmkit/trunk/configure
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/configure?rev=145037&r1=145036&r2=145037&view=diff
==============================================================================
--- vmkit/trunk/configure (original)
+++ vmkit/trunk/configure Mon Nov 21 04:57:35 2011
@@ -567,7 +567,7 @@
 PACKAGE_BUGREPORT='nicolas.geoffray at gmail.com'
 PACKAGE_URL=''
 
-ac_unique_file="lib/Mvm/Runtime/Object.cpp"
+ac_unique_file="lib/vmkit/Runtime/Object.cpp"
 # Factoring default headers for most tests.
 ac_includes_default="\
 #include <stdio.h>
@@ -2530,7 +2530,7 @@
 fi
 
 
-GC_FLAGS="-I\$(PROJ_SRC_ROOT)/lib/Mvm/MMTk"
+GC_FLAGS="-I\$(PROJ_SRC_ROOT)/lib/vmkit/MMTk"
 
 
 

Modified: vmkit/trunk/include/vmkit/System.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/System.h?rev=145037&r1=145036&r2=145037&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/System.h (original)
+++ vmkit/trunk/include/vmkit/System.h Mon Nov 21 04:57:35 2011
@@ -134,7 +134,7 @@
     return kThreadIDMask;
   }
 
-  // Apply this mask to verify that the current thread was created by Mvm.
+  // Apply this mask to verify that the current thread was created by vmkit.
   static word_t GetVmkitThreadMask() {
     return kVmkitThreadMask;
   }

Modified: vmkit/trunk/lib/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Makefile?rev=145037&r1=145036&r2=145037&view=diff
==============================================================================
--- vmkit/trunk/lib/Makefile (original)
+++ vmkit/trunk/lib/Makefile Mon Nov 21 04:57:35 2011
@@ -8,7 +8,7 @@
 ##===----------------------------------------------------------------------===##
 LEVEL = ..
 
-PARALLEL_DIRS = Mvm J3
+PARALLEL_DIRS = vmkit J3
 
 include $(LEVEL)/Makefile.config
 

Modified: vmkit/trunk/lib/vmkit/CommonThread/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/Makefile?rev=145037&r1=145034&r2=145037&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/Makefile (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/Makefile Mon Nov 21 04:57:35 2011
@@ -1,4 +1,4 @@
-##===- lib/Mvm/CommonThread/Makefile -----------------------*- Makefile -*-===##
+##===- lib/vmkit/CommonThread/Makefile -----------------------*- Makefile -*-===##
 # 
 #                     The vmkit project
 #

Copied: vmkit/trunk/lib/vmkit/Compiler/Makefile (from r145035, vmkit/trunk/lib/Mvm/Compiler/Makefile)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Compiler/Makefile?p2=vmkit/trunk/lib/vmkit/Compiler/Makefile&p1=vmkit/trunk/lib/Mvm/Compiler/Makefile&r1=145035&r2=145037&rev=145037&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Compiler/Makefile (original)
+++ vmkit/trunk/lib/vmkit/Compiler/Makefile Mon Nov 21 04:57:35 2011
@@ -1,4 +1,4 @@
-##===- lib/Mvm/Runtime/Makefile ----------------------------*- Makefile -*-===##
+##===- lib/vmkit/Runtime/Makefile ----------------------------*- Makefile -*-===##
 # 
 #                     The vmkit project
 #

Modified: vmkit/trunk/lib/vmkit/JITGCPass/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/JITGCPass/Makefile?rev=145037&r1=145034&r2=145037&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/JITGCPass/Makefile (original)
+++ vmkit/trunk/lib/vmkit/JITGCPass/Makefile Mon Nov 21 04:57:35 2011
@@ -1,4 +1,4 @@
-##===- lib/Mvm/StaticGCPass/Makefile -----------------------*- Makefile -*-===##
+##===- lib/vmkit/StaticGCPass/Makefile -----------------------*- Makefile -*-===##
 #
 #                            The VMKit project
 #

Modified: vmkit/trunk/lib/vmkit/MMTk/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/MMTk/Makefile?rev=145037&r1=145034&r2=145037&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/MMTk/Makefile (original)
+++ vmkit/trunk/lib/vmkit/MMTk/Makefile Mon Nov 21 04:57:35 2011
@@ -1,4 +1,4 @@
-##===- lib/Mvm/MMTk/Makefile -------------------------------*- Makefile -*-===##
+##===- lib/vmkit/MMTk/Makefile -------------------------------*- Makefile -*-===##
 # 
 #                     The vmkit project
 #

Modified: vmkit/trunk/lib/vmkit/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Makefile?rev=145037&r1=145034&r2=145037&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Makefile (original)
+++ vmkit/trunk/lib/vmkit/Makefile Mon Nov 21 04:57:35 2011
@@ -1,4 +1,4 @@
-##===- lib/Mvm/Makefile ------------------------------------*- Makefile -*-===##
+##===- lib/vmkit/Makefile ------------------------------------*- Makefile -*-===##
 # 
 #                     The vmkit project
 #

Copied: vmkit/trunk/lib/vmkit/Runtime/Makefile (from r145035, vmkit/trunk/lib/Mvm/Runtime/Makefile)
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Runtime/Makefile?p2=vmkit/trunk/lib/vmkit/Runtime/Makefile&p1=vmkit/trunk/lib/Mvm/Runtime/Makefile&r1=145035&r2=145037&rev=145037&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/Makefile (original)
+++ vmkit/trunk/lib/vmkit/Runtime/Makefile Mon Nov 21 04:57:35 2011
@@ -1,4 +1,4 @@
-##===- lib/Mvm/Runtime/Makefile ----------------------------*- Makefile -*-===##
+##===- lib/vmkit/Runtime/Makefile ----------------------------*- Makefile -*-===##
 # 
 #                     The vmkit project
 #

Modified: vmkit/trunk/lib/vmkit/StaticGCPass/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/StaticGCPass/Makefile?rev=145037&r1=145034&r2=145037&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/StaticGCPass/Makefile (original)
+++ vmkit/trunk/lib/vmkit/StaticGCPass/Makefile Mon Nov 21 04:57:35 2011
@@ -1,4 +1,4 @@
-##===- lib/Mvm/StaticGCPass/Makefile -----------------------*- Makefile -*-===##
+##===- lib/vmkit/StaticGCPass/Makefile -----------------------*- Makefile -*-===##
 #
 #                            The VMKit project
 #

Modified: vmkit/trunk/lib/vmkit/StaticGCPrinter/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/StaticGCPrinter/Makefile?rev=145037&r1=145034&r2=145037&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/StaticGCPrinter/Makefile (original)
+++ vmkit/trunk/lib/vmkit/StaticGCPrinter/Makefile Mon Nov 21 04:57:35 2011
@@ -1,4 +1,4 @@
-##===- lib/Mvm/StaticGCPrinter/Makefile --------------------*- Makefile -*-===##
+##===- lib/vmkit/StaticGCPrinter/Makefile --------------------*- Makefile -*-===##
 #
 #                            The VMKit project
 #

Modified: vmkit/trunk/mmtk/inline/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/inline/Makefile?rev=145037&r1=145036&r2=145037&view=diff
==============================================================================
--- vmkit/trunk/mmtk/inline/Makefile (original)
+++ vmkit/trunk/mmtk/inline/Makefile Mon Nov 21 04:57:35 2011
@@ -1,4 +1,4 @@
-##===- lib/Mvm/CommonThread/Makefile -----------------------*- Makefile -*-===##
+##===- lib/vmkit/CommonThread/Makefile -----------------------*- Makefile -*-===##
 # 
 #                     The vmkit project
 #




From gael.thomas at lip6.fr  Mon Nov 21 03:03:33 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Mon, 21 Nov 2011 11:03:33 -0000
Subject: [vmkit-commits] [vmkit] r145038 - in /vmkit/trunk: include/
 include/j3/ include/vmkit/ lib/J3/ClassLib/ lib/J3/ClassLib/GNUClasspath/
 lib/J3/ClassLib/OpenJDK/ lib/J3/Compiler/ lib/J3/VMCore/
 lib/vmkit/CommonThread/ lib/vmkit/Compiler/ lib/vmkit/MMTk/
 lib/vmkit/Runtime/ mmtk/magic/ mmtk/mmtk-alloc/ mmtk/mmtk-j3/ tools/j3/
 tools/precompiler/ tools/vmjc/
Message-ID: <20111121110335.875D91BE001@llvm.org>

Author: gthomas
Date: Mon Nov 21 05:03:32 2011
New Revision: 145038

URL: http://llvm.org/viewvc/llvm-project?rev=145038&view=rev
Log:
rename the namespace mvm into vmkit, no more mvm in the code\!

Modified:
    vmkit/trunk/include/debug.h
    vmkit/trunk/include/j3/J3Intrinsics.h
    vmkit/trunk/include/j3/JavaAOTCompiler.h
    vmkit/trunk/include/j3/JavaCompiler.h
    vmkit/trunk/include/j3/LLVMInfo.h
    vmkit/trunk/include/vmkit/Allocator.h
    vmkit/trunk/include/vmkit/CollectionRV.h
    vmkit/trunk/include/vmkit/Cond.h
    vmkit/trunk/include/vmkit/GC.h
    vmkit/trunk/include/vmkit/JIT.h
    vmkit/trunk/include/vmkit/Locks.h
    vmkit/trunk/include/vmkit/MethodInfo.h
    vmkit/trunk/include/vmkit/ObjectLocks.h
    vmkit/trunk/include/vmkit/System.h
    vmkit/trunk/include/vmkit/Thread.h
    vmkit/trunk/include/vmkit/UTF8.h
    vmkit/trunk/include/vmkit/VirtualMachine.h
    vmkit/trunk/include/vmkit/VmkitDenseMap.h
    vmkit/trunk/include/vmkit/VmkitDenseSet.h
    vmkit/trunk/lib/J3/ClassLib/ClassContext.inc
    vmkit/trunk/lib/J3/ClassLib/ClasspathConstructor.inc
    vmkit/trunk/lib/J3/ClassLib/ClasspathMethod.inc
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
    vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h
    vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
    vmkit/trunk/lib/J3/ClassLib/Unsafe.inc
    vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
    vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
    vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp
    vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp
    vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp
    vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp
    vmkit/trunk/lib/J3/VMCore/JavaArray.cpp
    vmkit/trunk/lib/J3/VMCore/JavaClass.cpp
    vmkit/trunk/lib/J3/VMCore/JavaClass.h
    vmkit/trunk/lib/J3/VMCore/JavaConstantPool.cpp
    vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h
    vmkit/trunk/lib/J3/VMCore/JavaMetaJIT.cpp
    vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
    vmkit/trunk/lib/J3/VMCore/JavaObject.h
    vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp
    vmkit/trunk/lib/J3/VMCore/JavaString.cpp
    vmkit/trunk/lib/J3/VMCore/JavaString.h
    vmkit/trunk/lib/J3/VMCore/JavaThread.cpp
    vmkit/trunk/lib/J3/VMCore/JavaThread.h
    vmkit/trunk/lib/J3/VMCore/JavaTypes.cpp
    vmkit/trunk/lib/J3/VMCore/JavaTypes.h
    vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
    vmkit/trunk/lib/J3/VMCore/Jnjvm.h
    vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
    vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h
    vmkit/trunk/lib/J3/VMCore/LinkJavaRuntime.h
    vmkit/trunk/lib/J3/VMCore/LockedMap.h
    vmkit/trunk/lib/J3/VMCore/Precompiled.cpp
    vmkit/trunk/lib/J3/VMCore/Reader.h
    vmkit/trunk/lib/J3/VMCore/ReferenceQueue.cpp
    vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h
    vmkit/trunk/lib/J3/VMCore/UTF8.h
    vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp
    vmkit/trunk/lib/J3/VMCore/Zip.cpp
    vmkit/trunk/lib/J3/VMCore/Zip.h
    vmkit/trunk/lib/vmkit/CommonThread/CollectionRV.cpp
    vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp
    vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x64.inc
    vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x86.inc
    vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-macos-x64.inc
    vmkit/trunk/lib/vmkit/CommonThread/Sigsegv.cpp
    vmkit/trunk/lib/vmkit/CommonThread/ctlock.cpp
    vmkit/trunk/lib/vmkit/CommonThread/ctthread.cpp
    vmkit/trunk/lib/vmkit/Compiler/Disassembler.cpp
    vmkit/trunk/lib/vmkit/Compiler/EscapeAnalysis.cpp
    vmkit/trunk/lib/vmkit/Compiler/InlineMalloc.cpp
    vmkit/trunk/lib/vmkit/Compiler/JIT.cpp
    vmkit/trunk/lib/vmkit/Compiler/VmkitGC.cpp
    vmkit/trunk/lib/vmkit/MMTk/MutatorThread.h
    vmkit/trunk/lib/vmkit/MMTk/VmkitGC.cpp
    vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h
    vmkit/trunk/lib/vmkit/Runtime/MethodInfo.cpp
    vmkit/trunk/lib/vmkit/Runtime/Object.cpp
    vmkit/trunk/lib/vmkit/Runtime/UTF8.cpp
    vmkit/trunk/mmtk/magic/LowerMagic.cpp
    vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp
    vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp
    vmkit/trunk/mmtk/mmtk-j3/Collection.cpp
    vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp
    vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h
    vmkit/trunk/mmtk/mmtk-j3/MMTk_Events.cpp
    vmkit/trunk/mmtk/mmtk-j3/Memory.cpp
    vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp
    vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp
    vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp
    vmkit/trunk/mmtk/mmtk-j3/Selected.cpp
    vmkit/trunk/mmtk/mmtk-j3/Strings.cpp
    vmkit/trunk/mmtk/mmtk-j3/VM.cpp
    vmkit/trunk/tools/j3/Main.cpp
    vmkit/trunk/tools/precompiler/Precompiler.cpp
    vmkit/trunk/tools/vmjc/vmjc.cpp

Modified: vmkit/trunk/include/debug.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/debug.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/debug.h (original)
+++ vmkit/trunk/include/debug.h Mon Nov 21 05:03:32 2011
@@ -65,7 +65,7 @@
 #endif
 
 #define UNIMPLEMENTED() {                           \
-  mvm::Thread::get()->printBacktrace();           \
+  vmkit::Thread::get()->printBacktrace();           \
   fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \
   abort(); }                                      \
 

Modified: vmkit/trunk/include/j3/J3Intrinsics.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/J3Intrinsics.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/j3/J3Intrinsics.h (original)
+++ vmkit/trunk/include/j3/J3Intrinsics.h Mon Nov 21 05:03:32 2011
@@ -14,7 +14,7 @@
 
 namespace j3 {
 
-class J3Intrinsics : public mvm::BaseIntrinsics {
+class J3Intrinsics : public vmkit::BaseIntrinsics {
 
 public:
   void init(llvm::Module* M);

Modified: vmkit/trunk/include/j3/JavaAOTCompiler.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/JavaAOTCompiler.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/j3/JavaAOTCompiler.h (original)
+++ vmkit/trunk/include/j3/JavaAOTCompiler.h Mon Nov 21 05:03:32 2011
@@ -21,7 +21,7 @@
 class ClassBytes;
 class JnjvmBootstrapLoader;
 
-using mvm::UTF8;
+using vmkit::UTF8;
 
 class JavaAOTCompiler : public JavaLLVMCompiler {
 
@@ -98,8 +98,8 @@
   llvm::Constant* CreateConstantFromJavaObject(JavaObject* obj);
   llvm::Constant* CreateConstantFromClassBytes(ClassBytes* bytes);
   llvm::Constant* CreateConstantFromJavaConstantPool(JavaConstantPool* ctp);
-  llvm::Constant* CreateConstantFromClassMap(const mvm::VmkitDenseMap<const UTF8*, CommonClass*>& map);
-  llvm::Constant* CreateConstantFromUTF8Map(const mvm::VmkitDenseSet<mvm::UTF8MapKey, const UTF8*>& set);
+  llvm::Constant* CreateConstantFromClassMap(const vmkit::VmkitDenseMap<const UTF8*, CommonClass*>& map);
+  llvm::Constant* CreateConstantFromUTF8Map(const vmkit::VmkitDenseSet<vmkit::UTF8MapKey, const UTF8*>& set);
   void AddInitializerToClass(llvm::GlobalVariable* varGV, CommonClass* classDef);
   llvm::Constant* getUTF8(const UTF8* val);
   

Modified: vmkit/trunk/include/j3/JavaCompiler.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/JavaCompiler.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/j3/JavaCompiler.h (original)
+++ vmkit/trunk/include/j3/JavaCompiler.h Mon Nov 21 05:03:32 2011
@@ -18,7 +18,7 @@
 #include "vmkit/GC.h"
 #include "vmkit/Allocator.h"
 
-namespace mvm {
+namespace vmkit {
   class UTF8;
 }
 
@@ -34,7 +34,7 @@
 class JavaCompiler {
 public:
   
-  mvm::BumpPtrAllocator allocator;
+  vmkit::BumpPtrAllocator allocator;
 
   virtual JavaCompiler* Create(const std::string&) {
     return this;
@@ -106,8 +106,8 @@
     return dlsym(handle, symbol);
   }
 
-  static const mvm::UTF8* InlinePragma;
-  static const mvm::UTF8* NoInlinePragma;
+  static const vmkit::UTF8* InlinePragma;
+  static const vmkit::UTF8* NoInlinePragma;
 
   virtual CommonClass* getUniqueBaseClass(CommonClass* cl) {
     return 0;

Modified: vmkit/trunk/include/j3/LLVMInfo.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/LLVMInfo.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/j3/LLVMInfo.h (original)
+++ vmkit/trunk/include/j3/LLVMInfo.h Mon Nov 21 05:03:32 2011
@@ -36,7 +36,7 @@
   uint8_t logSizeInBytesConstant;
 };
 
-class LLVMClassInfo : public mvm::PermanentObject {
+class LLVMClassInfo : public vmkit::PermanentObject {
   friend class JavaAOTCompiler;
   friend class JavaJITCompiler;
   friend class JavaLLVMCompiler;
@@ -75,7 +75,7 @@
   }
 };
 
-class LLVMMethodInfo : public mvm::PermanentObject {
+class LLVMMethodInfo : public vmkit::PermanentObject {
 private:
   /// Compiler - The compiler for this method info.
   JavaLLVMCompiler* Compiler;
@@ -111,7 +111,7 @@
 };
 
 
-class LLVMFieldInfo : public mvm::PermanentObject {
+class LLVMFieldInfo : public vmkit::PermanentObject {
 private:
   /// Compiler - The compiler for this field info.
   JavaLLVMCompiler* Compiler;
@@ -133,7 +133,7 @@
   }
 };
 
-class LLVMSignatureInfo : public mvm::PermanentObject {
+class LLVMSignatureInfo : public vmkit::PermanentObject {
 private:
   /// Compiler - The compiler for this signature info.
   JavaLLVMCompiler* Compiler;

Modified: vmkit/trunk/include/vmkit/Allocator.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Allocator.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Allocator.h (original)
+++ vmkit/trunk/include/vmkit/Allocator.h Mon Nov 21 05:03:32 2011
@@ -17,7 +17,7 @@
 
 class VirtualTable;
 
-namespace mvm {
+namespace vmkit {
 
 class BumpPtrAllocator {
 private:
@@ -75,6 +75,6 @@
   }
 };
 
-} // end namespace mvm
+} // end namespace vmkit
 
 #endif // VMKIT_ALLOCATOR_H

Modified: vmkit/trunk/include/vmkit/CollectionRV.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/CollectionRV.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/CollectionRV.h (original)
+++ vmkit/trunk/include/vmkit/CollectionRV.h Mon Nov 21 05:03:32 2011
@@ -14,7 +14,7 @@
 #include "vmkit/Locks.h"
 #include "vmkit/Thread.h"
 
-namespace mvm {
+namespace vmkit {
 
 class CollectionRV {
 protected: 
@@ -46,13 +46,13 @@
   void waitRV();
   
   void startRV() {
-    mvm::Thread::get()->inRV = true;
+    vmkit::Thread::get()->inRV = true;
     lockRV();
   }
 
   void cancelRV() {
     unlockRV();
-    mvm::Thread::get()->inRV = false;
+    vmkit::Thread::get()->inRV = false;
   }
   
   void another_mark();

Modified: vmkit/trunk/include/vmkit/Cond.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Cond.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Cond.h (original)
+++ vmkit/trunk/include/vmkit/Cond.h Mon Nov 21 05:03:32 2011
@@ -13,7 +13,7 @@
 #include <cstdlib>
 #include <pthread.h>
 
-namespace mvm {
+namespace vmkit {
 
 class Lock;
 
@@ -29,6 +29,6 @@
   void signal(void) __attribute__ ((noinline));
 };
 
-} // end namespace mvm
+} // end namespace vmkit
 
 #endif // VMKIT_COND_H

Modified: vmkit/trunk/include/vmkit/GC.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/GC.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/GC.h (original)
+++ vmkit/trunk/include/vmkit/GC.h Mon Nov 21 05:03:32 2011
@@ -35,7 +35,7 @@
   }
 };
 
-namespace mvm {
+namespace vmkit {
   // TODO(ngeoffray): Make these two constants easily configurable. For now they
   // work for all our supported GCs.
   static const uint32_t GCBits = 8;

Modified: vmkit/trunk/include/vmkit/JIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/JIT.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/JIT.h (original)
+++ vmkit/trunk/include/vmkit/JIT.h Mon Nov 21 05:03:32 2011
@@ -38,7 +38,7 @@
   class Type;
 }
 
-namespace mvm {
+namespace vmkit {
 
 class LockRecursive;
 
@@ -171,7 +171,7 @@
 
 class VmkitModule {
 public:
-   static mvm::LockRecursive protectEngine;
+   static vmkit::LockRecursive protectEngine;
 
    static void runPasses(llvm::Function* func, llvm::FunctionPassManager*);
    static void initialise(int argc, char** argv);
@@ -179,7 +179,7 @@
    static Frames* addToVM(VirtualMachine* VM,
                           llvm::GCFunctionInfo* GFI,
                           llvm::JIT* jit,
-                          mvm::BumpPtrAllocator& allocator,
+                          vmkit::BumpPtrAllocator& allocator,
                           void* meta);
 
    static int disassemble(unsigned int* addr);
@@ -192,6 +192,6 @@
    static const char* getHostTriple();
 };
 
-} // end namespace mvm
+} // end namespace vmkit
 
 #endif // VMKIT_JIT_H

Modified: vmkit/trunk/include/vmkit/Locks.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Locks.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Locks.h (original)
+++ vmkit/trunk/include/vmkit/Locks.h Mon Nov 21 05:03:32 2011
@@ -21,7 +21,7 @@
 
 class gc;
 
-namespace mvm {
+namespace vmkit {
 
 class Cond;
 class FatLock;
@@ -42,7 +42,7 @@
 protected:
   /// owner - Which thread is currently holding the lock?
   ///
-  mvm::Thread* owner;
+  vmkit::Thread* owner;
 
   /// internalLock - The lock implementation of the platform.
   ///
@@ -72,7 +72,7 @@
 
   /// getOwner - Get the thread that is holding the lock.
   ///
-  mvm::Thread* getOwner();
+  vmkit::Thread* getOwner();
   
 };
 
@@ -81,7 +81,7 @@
   friend class Cond;
 private:
   virtual void unsafeLock(int n) {
-    owner = mvm::Thread::get();
+    owner = vmkit::Thread::get();
   }
   
   virtual int unsafeUnlock() {
@@ -107,7 +107,7 @@
 
   virtual void unsafeLock(int a) {
     n = a;
-    owner = mvm::Thread::get();
+    owner = vmkit::Thread::get();
   }
   
   virtual int unsafeUnlock() {
@@ -162,7 +162,7 @@
     }
     
     while (__sync_val_compare_and_swap(&locked, 0, 1))
-      mvm::Thread::yield();
+      vmkit::Thread::yield();
   }
 
   void lock() { acquire(); }
@@ -176,6 +176,6 @@
 };
 
 
-} // end namespace mvm
+} // end namespace vmkit
 
 #endif // VMKIT_LOCKS_H

Modified: vmkit/trunk/include/vmkit/MethodInfo.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/MethodInfo.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/MethodInfo.h (original)
+++ vmkit/trunk/include/vmkit/MethodInfo.h Mon Nov 21 05:03:32 2011
@@ -14,7 +14,7 @@
 #include "vmkit/System.h"
 #include "vmkit/GC.h"
 
-namespace mvm {
+namespace vmkit {
 
 class FrameInfo {
 public:
@@ -48,7 +48,7 @@
         reinterpret_cast<word_t>(this) + kWordSize);
   }
 
-  void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator, uint32_t NumDescriptors, uint32_t NumOffsets) {
+  void* operator new(size_t sz, vmkit::BumpPtrAllocator& allocator, uint32_t NumDescriptors, uint32_t NumOffsets) {
     Frames* res = reinterpret_cast<Frames*>(
         allocator.Allocate(kWordSize + NumDescriptors * MethodInfoHelper::FrameInfoSize(NumOffsets), "Frames"));
     assert(System::IsWordAligned(reinterpret_cast<word_t>(res)));
@@ -95,5 +95,5 @@
   }
 };
 
-} // end namespace mvm
+} // end namespace vmkit
 #endif // VMKIT_METHODINFO_H

Modified: vmkit/trunk/include/vmkit/ObjectLocks.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/ObjectLocks.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/ObjectLocks.h (original)
+++ vmkit/trunk/include/vmkit/ObjectLocks.h Mon Nov 21 05:03:32 2011
@@ -16,7 +16,7 @@
 #include "vmkit/Locks.h"
 #include "vmkit/Thread.h"
 
-namespace mvm {
+namespace vmkit {
 
 class FatLock;
 class LockSystem;
@@ -26,7 +26,7 @@
   /// varcond - Condition variable when the thread needs to be awaken from
   /// a wait.
   ///
-  mvm::Cond varcond;
+  vmkit::Cond varcond;
 
   /// interruptFlag - Has this thread been interrupted?
   ///
@@ -65,10 +65,10 @@
 };
 
 
-class FatLock : public mvm::PermanentObject {
+class FatLock : public vmkit::PermanentObject {
 private:
-  mvm::LockRecursive internalLock;
-  mvm::SpinLock spinLock;
+  vmkit::LockRecursive internalLock;
+  vmkit::SpinLock spinLock;
   uint32_t waitingThreads;
   uint32_t lockingThreads;
   LockingThread* firstThread;
@@ -82,7 +82,7 @@
   bool acquire(gc* object);
   void acquireAll(gc* object, word_t count);
   void release(gc* object, LockSystem& table);
-  mvm::Thread* getOwner();
+  vmkit::Thread* getOwner();
   bool owner();
   gc* getAssociatedObject() { return associatedObject; }
   gc** getAssociatedObjectPtr() { return &associatedObject; }
@@ -108,7 +108,7 @@
   static const uint32_t BitMask = IndexSize - 1;
   static const uint32_t MaxLocks = GlobalSize * IndexSize;
 
-  mvm::BumpPtrAllocator& allocator;
+  vmkit::BumpPtrAllocator& allocator;
 
   /// LockTable - The global table that will hold the locks. The table is
   /// a two-dimensional array, and only one entry is created, so that
@@ -127,7 +127,7 @@
  
   /// threadLock - Spin lock to protect the currentIndex field.
   ///
-  mvm::SpinLock threadLock;
+  vmkit::SpinLock threadLock;
   
   /// allocate - Allocate a FatLock.
   ///
@@ -139,7 +139,7 @@
 
   /// LockSystem - Default constructor. Initialize the table.
   ///
-  LockSystem(mvm::BumpPtrAllocator& allocator);
+  LockSystem(vmkit::BumpPtrAllocator& allocator);
 
   /// getLock - Get a lock from an index in the table.
   ///
@@ -196,6 +196,6 @@
   static FatLock* getFatLock(gc* object, LockSystem& table);
 };
 
-} // end namespace mvm
+} // end namespace vmkit
 
 #endif // VMKIT_OBJECT_LOCKS_H

Modified: vmkit/trunk/include/vmkit/System.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/System.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/System.h (original)
+++ vmkit/trunk/include/vmkit/System.h Mon Nov 21 05:03:32 2011
@@ -56,7 +56,7 @@
 typedef uint32_t word_t;
 #endif
 
-namespace mvm {
+namespace vmkit {
 
 const int kWordSize = sizeof(word_t);
 const int kWordSizeLog2 = kWordSize == 4 ? 2 : 3;
@@ -95,9 +95,9 @@
 
 const word_t kGCMemorySize = 0x30000000;  
 
-#define TRY { mvm::ExceptionBuffer __buffer__; if (!SETJMP(__buffer__.buffer))
+#define TRY { vmkit::ExceptionBuffer __buffer__; if (!SETJMP(__buffer__.buffer))
 #define CATCH else
-#define IGNORE else { mvm::Thread::get()->clearException(); }}
+#define IGNORE else { vmkit::Thread::get()->clearException(); }}
 #define END_CATCH }
 
 class System {
@@ -223,9 +223,9 @@
 
   static uint8_t* GetLastBytePtr(word_t ptr) {
 #if ARCH_PPC
-  return ((uint8_t*)ptr) + 2 * mvm::kWordSize - 1;
+  return ((uint8_t*)ptr) + 2 * vmkit::kWordSize - 1;
 #else
-  return ((uint8_t*)ptr) + mvm::kWordSize;
+  return ((uint8_t*)ptr) + vmkit::kWordSize;
 #endif
   }
 

Modified: vmkit/trunk/include/vmkit/Thread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Thread.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Thread.h (original)
+++ vmkit/trunk/include/vmkit/Thread.h Mon Nov 21 05:03:32 2011
@@ -20,7 +20,7 @@
 #include "vmkit/System.h"
 
 
-namespace mvm {
+namespace vmkit {
 
 class FrameInfo;
 class VirtualMachine;
@@ -137,7 +137,7 @@
   
   /// start - Start the execution of a thread.
   ///
-  virtual int start(void (*fct)(mvm::Thread*));
+  virtual int start(void (*fct)(vmkit::Thread*));
   
   uint64_t getThreadID() {
     return (uint64_t)this;
@@ -188,7 +188,7 @@
   /// internalThreadStart - The implementation sepcific thread starter
   /// function.
   ///
-  static void internalThreadStart(mvm::Thread* th);
+  static void internalThreadStart(vmkit::Thread* th);
 
   /// internalClearException - Clear any pending exception.
   ///
@@ -247,11 +247,11 @@
   
   /// releaseThread - Free the stack so that another thread can use it.
   ///
-  static void releaseThread(mvm::Thread* th);
+  static void releaseThread(vmkit::Thread* th);
 
   /// routine - The function to invoke when the thread starts.
   ///
-  void (*routine)(mvm::Thread*);
+  void (*routine)(vmkit::Thread*);
  
   /// printBacktrace - Print the backtrace.
   ///
@@ -329,9 +329,9 @@
   word_t addr;
   word_t ip;
   KnownFrame* frame;
-  mvm::Thread* thread;
+  vmkit::Thread* thread;
 
-  StackWalker(mvm::Thread* th) __attribute__ ((noinline));
+  StackWalker(vmkit::Thread* th) __attribute__ ((noinline));
   void operator++();
   word_t operator*();
   FrameInfo* get();
@@ -339,5 +339,5 @@
 };
 
 
-} // end namespace mvm
+} // end namespace vmkit
 #endif // VMKIT_THREAD_H

Modified: vmkit/trunk/include/vmkit/UTF8.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/UTF8.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/UTF8.h (original)
+++ vmkit/trunk/include/vmkit/UTF8.h Mon Nov 21 05:03:32 2011
@@ -6,7 +6,7 @@
 #include "vmkit/VmkitDenseMap.h"
 #include "vmkit/VmkitDenseSet.h"
 
-namespace mvm {
+namespace vmkit {
 
 class UTF8Map;
 
@@ -16,7 +16,7 @@
   
   /// operator new - Redefines the new operator of this class to allocate
   /// its objects in permanent memory, not with the garbage collector.
-  void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator, sint32 n) {
+  void* operator new(size_t sz, vmkit::BumpPtrAllocator& allocator, sint32 n) {
     return allocator.Allocate(sizeof(UTF8) + (n - 1) * sizeof(uint16), "UTF8");
   }
   
@@ -119,7 +119,7 @@
   }
 };
 
-class UTF8Map : public mvm::PermanentObject {
+class UTF8Map : public vmkit::PermanentObject {
 public:
   typedef VmkitDenseSet<UTF8MapKey, const UTF8*>::iterator iterator;
   
@@ -185,6 +185,6 @@
 	}
 };
 
-} // end namespace mvm
+} // end namespace vmkit
 
 #endif

Modified: vmkit/trunk/include/vmkit/VirtualMachine.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/VirtualMachine.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/VirtualMachine.h (original)
+++ vmkit/trunk/include/vmkit/VirtualMachine.h Mon Nov 21 05:03:32 2011
@@ -20,7 +20,7 @@
 #include <cassert>
 #include <map>
 
-namespace mvm {
+namespace vmkit {
 
 class CompiledFrames;
 class FrameInfo;
@@ -36,7 +36,7 @@
 
   /// FunctionMapLock - Spin lock to protect the Functions map.
   ///
-  mvm::SpinLock FunctionMapLock;
+  vmkit::SpinLock FunctionMapLock;
 
   /// IPToFrameInfo - Map a code start instruction instruction to the FrameInfo.
   ///
@@ -57,7 +57,7 @@
 /// VirtualMachine - This class is the root of virtual machine classes. It
 /// defines what a VM should be.
 ///
-class VirtualMachine : public mvm::PermanentObject {
+class VirtualMachine : public vmkit::PermanentObject {
 protected:
   VirtualMachine(BumpPtrAllocator &Alloc, CompiledFrames** frames) :
 		  allocator(Alloc), FunctionsCache(Alloc, frames) {
@@ -75,7 +75,7 @@
   /// allocator - Bump pointer allocator to allocate permanent memory
   /// related to this VM.
   ///
-  mvm::BumpPtrAllocator& allocator;
+  vmkit::BumpPtrAllocator& allocator;
 
 //===----------------------------------------------------------------------===//
 // (1) Thread-related methods.
@@ -83,7 +83,7 @@
 
   /// mainThread - The main thread of this VM.
   ///
-  mvm::Thread* mainThread;
+  vmkit::Thread* mainThread;
 
   /// NumberOfThreads - The number of threads that currently run under this VM.
   ///
@@ -91,29 +91,29 @@
 
   /// ThreadLock - Lock to create or destroy a new thread.
   ///
-  mvm::LockNormal threadLock;
+  vmkit::LockNormal threadLock;
 
   /// ThreadVar - Condition variable to wake up the thread manager.
-  mvm::Cond threadVar;
+  vmkit::Cond threadVar;
 
   /// exitingThread - Thread that is currently exiting. Used by the thread
   /// manager to free the resources (stack) used by a thread.
-  mvm::Thread* exitingThread;
+  vmkit::Thread* exitingThread;
 
   /// doExit - Should the VM exit now?
   bool doExit;
   
   /// setMainThread - Set the main thread of this VM.
   ///
-  void setMainThread(mvm::Thread* th) { mainThread = th; }
+  void setMainThread(vmkit::Thread* th) { mainThread = th; }
   
   /// getMainThread - Get the main thread of this VM.
   ///
-  mvm::Thread* getMainThread() const { return mainThread; }
+  vmkit::Thread* getMainThread() const { return mainThread; }
 
   /// addThread - Add a new thread to the list of threads.
   ///
-  void addThread(mvm::Thread* th) {
+  void addThread(vmkit::Thread* th) {
     threadLock.lock();
     numberOfThreads++;
     if (th != mainThread) {
@@ -125,7 +125,7 @@
   
   /// removeThread - Remove the thread from the list of threads.
   ///
-  void removeThread(mvm::Thread* th) {
+  void removeThread(vmkit::Thread* th) {
     threadLock.lock();
     while (exitingThread != NULL) {
       // Make sure the thread manager had a chance to consume the previous
@@ -233,5 +233,5 @@
   virtual void stackOverflowError() = 0;
 };
 
-} // end namespace mvm
+} // end namespace vmkit
 #endif // VMKIT_VIRTUALMACHINE_H

Modified: vmkit/trunk/include/vmkit/VmkitDenseMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/VmkitDenseMap.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/VmkitDenseMap.h (original)
+++ vmkit/trunk/include/vmkit/VmkitDenseMap.h Mon Nov 21 05:03:32 2011
@@ -26,7 +26,7 @@
 #include <cstddef>
 #include <cstring>
 
-namespace mvm {
+namespace vmkit {
 
 template<typename T>
 struct VmkitDenseMapInfo {

Modified: vmkit/trunk/include/vmkit/VmkitDenseSet.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/VmkitDenseSet.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/VmkitDenseSet.h (original)
+++ vmkit/trunk/include/vmkit/VmkitDenseSet.h Mon Nov 21 05:03:32 2011
@@ -27,7 +27,7 @@
 #include <cstddef>
 #include <cstring>
 
-namespace mvm {
+namespace vmkit {
 
 template<typename ValueT,
          typename ValueInfoT = VmkitDenseMapInfo<ValueT>,
@@ -486,6 +486,6 @@
   }
 };
 
-} // end namespace mvm
+} // end namespace vmkit
 
 #endif

Modified: vmkit/trunk/lib/J3/ClassLib/ClassContext.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/ClassContext.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/ClassContext.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/ClassContext.inc Mon Nov 21 05:03:32 2011
@@ -17,7 +17,7 @@
   Jnjvm* vm = th->getJVM();
   uint32 length = th->getFrameContextLength();
 
-  mvm::ThreadAllocator allocator;
+  vmkit::ThreadAllocator allocator;
   uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length * sizeof(uintptr_t));
 
   uint32 finalSize = th->getJavaFrameContext((void**)buffer);

Modified: vmkit/trunk/lib/J3/ClassLib/ClasspathConstructor.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/ClasspathConstructor.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/ClasspathConstructor.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/ClasspathConstructor.inc Mon Nov 21 05:03:32 2011
@@ -95,7 +95,7 @@
 
   if (isAbstract(cl->access)) vm->instantiationException(cl);
 
-  mvm::ThreadAllocator allocator;
+  vmkit::ThreadAllocator allocator;
   // Allocate a buffer to store the arguments.
   jvalue* buf = size ?
       (jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;

Modified: vmkit/trunk/lib/J3/ClassLib/ClasspathMethod.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/ClasspathMethod.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/ClasspathMethod.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/ClasspathMethod.inc Mon Nov 21 05:03:32 2011
@@ -115,7 +115,7 @@
   Signdef* sign = meth->getSignature();
   sint32 size = sign->nbArguments;
 
-  mvm::ThreadAllocator allocator;
+  vmkit::ThreadAllocator allocator;
   jvalue* buf = size ?
       (jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;
 

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h Mon Nov 21 05:03:32 2011
@@ -42,7 +42,7 @@
   static void setProtectionDomain(JavaObjectClass* cl, JavaObject* pd) {
     llvm_gcroot(cl, 0);
     llvm_gcroot(pd, 0);
-    mvm::Collector::objectReferenceWriteBarrier(
+    vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)cl, (gc**)&(cl->pd), (gc*)pd);
   }
   
@@ -52,12 +52,12 @@
   }
 
   static void staticTracer(JavaObjectClass* obj, word_t closure) {
-    mvm::Collector::markAndTrace(obj, &obj->pd, closure);
-    mvm::Collector::markAndTrace(obj, &obj->signers, closure);
-    mvm::Collector::markAndTrace(obj, &obj->constructor, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->pd, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->signers, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->constructor, closure);
     if (obj->vmdata) {
       JavaObject** Obj = obj->vmdata->classLoader->getJavaClassLoaderPtr();
-      if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
+      if (*Obj) vmkit::Collector::markAndTraceRoot(Obj, closure);
     }
   }
 
@@ -81,8 +81,8 @@
 public:
 
   static void staticTracer(JavaObjectField* obj, word_t closure) {
-    mvm::Collector::markAndTrace(obj, &obj->name, closure);
-    mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->name, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->declaringClass, closure);
   }
 
   static JavaField* getInternalField(JavaObjectField* self) {
@@ -110,8 +110,8 @@
 public:
   
   static void staticTracer(JavaObjectMethod* obj, word_t closure) {
-    mvm::Collector::markAndTrace(obj, &obj->name, closure);
-    mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->name, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->declaringClass, closure);
   }
   
   static JavaMethod* getInternalMethod(JavaObjectMethod* self);
@@ -133,7 +133,7 @@
 
 public:
   static void staticTracer(JavaObjectConstructor* obj, word_t closure) {
-    mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->declaringClass, closure);
   }
   
   static JavaMethod* getInternalMethod(JavaObjectConstructor* self);
@@ -155,7 +155,7 @@
 
 public:
   static void staticTracer(JavaObjectVMThread* obj, word_t closure) {
-    mvm::Collector::markAndTrace(obj, &obj->thread, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->thread, closure);
   }
 
   static void setVmdata(JavaObjectVMThread* vmthread,
@@ -179,7 +179,7 @@
   static void setDetailedMessage(JavaObjectThrowable* self, JavaObject* obj) {
     llvm_gcroot(self, 0);
     llvm_gcroot(obj, 0);
-    mvm::Collector::objectReferenceWriteBarrier(
+    vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)self, (gc**)&(self->detailedMessage), (gc*)obj);
   }
 
@@ -189,10 +189,10 @@
     llvm_gcroot(stackTrace, 0);
 
     stackTrace = internalFillInStackTrace(self);
-    mvm::Collector::objectReferenceWriteBarrier(
+    vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)self, (gc**)&(self->vmState), (gc*)stackTrace);
 
-    mvm::Collector::objectReferenceWriteBarrier(
+    vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)self, (gc**)&(self->cause), (gc*)self);
 
     self->stackTrace = NULL;
@@ -210,9 +210,9 @@
     llvm_gcroot(self, 0);
     llvm_gcroot(r, 0);
     llvm_gcroot(q, 0);
-    mvm::Collector::objectReferenceWriteBarrier(
+    vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)self, (gc**)&(self->referent), (gc*)r);
-    mvm::Collector::objectReferenceWriteBarrier(
+    vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)self, (gc**)&(self->queue), (gc*)q);
   }
 

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc Mon Nov 21 05:03:32 2011
@@ -75,7 +75,7 @@
 
 typedef int (*onLoad_t)(const void**, void*);
 extern "C" void  j3EndJNI(uint32** old);
-extern "C" void  j3StartJNI(uint32* num, uint32** old, mvm::KnownFrame* Frame);
+extern "C" void  j3StartJNI(uint32* num, uint32** old, vmkit::KnownFrame* Frame);
 
 extern "C" void callOnLoad(void* res, JnjvmClassLoader* loader, Jnjvm* vm)
   __attribute__ ((noinline));
@@ -96,7 +96,7 @@
   if (onLoad) {
     uint32 num = 0;
     uint32* old = 0;
-    mvm::KnownFrame Frame;
+    vmkit::KnownFrame Frame;
     
     j3StartJNI(&num, &old, &Frame);
     doCall(onLoad, res, vm);
@@ -125,7 +125,7 @@
   JnjvmClassLoader* loader = 
     JnjvmClassLoader::getJnjvmLoaderFromJavaObject(javaLoader, vm);
 
-  mvm::ThreadAllocator allocator;
+  vmkit::ThreadAllocator allocator;
   char* buf = JavaString::strToAsciiz(str, &allocator);
   
   res = loader->loadLib(buf);
@@ -146,7 +146,7 @@
 ) {
   BEGIN_NATIVE_EXCEPTION(0)
   
-  mvm::Collector::collect();
+  vmkit::Collector::collect();
 
   END_NATIVE_EXCEPTION
 }
@@ -157,7 +157,7 @@
 jclass clazz,
 #endif
 ) {
-  mvm::Collector::collect();
+  vmkit::Collector::collect();
   // Sleep a bit.
   sleep(1);
   return;
@@ -188,7 +188,7 @@
 jclass clazz,
 #endif
 jint par1) {
-  mvm::System::Exit(par1);
+  vmkit::System::Exit(par1);
 }
 
 JNIEXPORT jlong Java_java_lang_VMRuntime_freeMemory(
@@ -197,7 +197,7 @@
 jclass clazz,
 #endif
 ) {
-  return (jlong)mvm::Collector::getFreeMemory();
+  return (jlong)vmkit::Collector::getFreeMemory();
 }
 
 JNIEXPORT jlong Java_java_lang_VMRuntime_totalMemory(
@@ -206,7 +206,7 @@
 jclass clazz,
 #endif
 ) {
-  return (jlong)mvm::Collector::getTotalMemory();
+  return (jlong)vmkit::Collector::getTotalMemory();
 }
 
 JNIEXPORT jlong Java_java_lang_VMRuntime_maxMemory(
@@ -215,7 +215,7 @@
 jclass clazz,
 #endif
 ) {
-  return (jlong)mvm::Collector::getMaxMemory();
+  return (jlong)vmkit::Collector::getMaxMemory();
 }
 
 JNIEXPORT jint Java_java_lang_VMRuntime_availableProcessors(){
@@ -223,7 +223,7 @@
 JNIEnv *env,
 jclass clazz,
 #endif
-  return mvm::System::GetNumberOfProcessors();
+  return vmkit::System::GetNumberOfProcessors();
 }
 }
 

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc Mon Nov 21 05:03:32 2011
@@ -42,7 +42,7 @@
   Jnjvm* vm = thread->getJVM();
   // Wait some time to let the creator initialise these fields.
   while ((thread->javaThread == NULL) || (thread->vmThread == NULL)) {
-    mvm::Thread::yield();
+    vmkit::Thread::yield();
   }
 
   // Ok, now that the thread is created we can set the the value of vmdata,
@@ -95,7 +95,7 @@
  
   JavaThread* th = new JavaThread(vm);
   if (!th) vm->outOfMemoryError();
-  th->start((void (*)(mvm::Thread*))start);
+  th->start((void (*)(vmkit::Thread*))start);
   // Now that the thread has been created, initialise its object fields.
   th->initialise(javaThread, vmThread);
 
@@ -118,16 +118,16 @@
   // It's possible that the thread to be interrupted has not finished
   // its initialization. Wait until the initialization is done.
   while (field->getInstanceObjectField(vmthread) == 0)
-    mvm::Thread::yield();
+    vmkit::Thread::yield();
   
   JavaThread* th = (JavaThread*)field->getInstanceObjectField(vmthread);
   th->lockingThread.interruptFlag = 1;
-  mvm::FatLock* lock = th->lockingThread.waitsOn;
+  vmkit::FatLock* lock = th->lockingThread.waitsOn;
 
   // If the thread is blocked on a wait. We also verify nextWaiting in case
   // the thread has been notified.
   if (lock && th->lockingThread.nextWaiting) {
-    th->lockingThread.state = mvm::LockingThread::StateInterrupted;
+    th->lockingThread.state = vmkit::LockingThread::StateInterrupted;
   
     // Make sure the thread is waiting.
     uint32 locked = 0;
@@ -135,7 +135,7 @@
       locked = (lock->tryAcquire() == 0);
       if (locked || (lock->getOwner() != th && lock->getOwner() != 0))
         break;
-      else mvm::Thread::yield();
+      else vmkit::Thread::yield();
     }
     
     // Interrupt the thread.
@@ -211,7 +211,7 @@
 jclass clazz,
 #endif
 ) {
-  mvm::Thread::yield();
+  vmkit::Thread::yield();
 }
 
 }

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc Mon Nov 21 05:03:32 2011
@@ -47,7 +47,7 @@
   }
   
   // Don't call th->getFrameContext because it is not GC-safe.
-  mvm::StackWalker Walker(th);
+  vmkit::StackWalker Walker(th);
   uint32_t i = 0;
 
   while (intptr_t ip = *Walker) {
@@ -83,7 +83,7 @@
 }
 
 
-JavaObject* consStackElement(mvm::FrameInfo* FI, intptr_t ip) {
+JavaObject* consStackElement(vmkit::FrameInfo* FI, intptr_t ip) {
 
   JavaString* methodName = 0;
   JavaString* className = 0;
@@ -144,7 +144,7 @@
   // on the stack.
   sint32 index = 2;;
   while (index != JavaArray::getSize(stack)) {
-    mvm::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
+    vmkit::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
     if (FI->Metadata == NULL) ++index;
     else {
       JavaMethod* meth = (JavaMethod*)FI->Metadata;
@@ -158,7 +158,7 @@
   sint32 size = 0;
   sint32 cur = index;
   while (cur < JavaArray::getSize(stack)) {
-    mvm::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
+    vmkit::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
     ++cur;
     if (FI->Metadata != NULL) ++size;
   }
@@ -168,7 +168,7 @@
   
   cur = 0;
   for (sint32 i = index; i < JavaArray::getSize(stack); ++i) {
-    mvm::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, i));
+    vmkit::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, i));
     if (FI->Metadata != NULL) {
       ArrayObject::setElement(result, consStackElement(FI, ArrayPtr::getElement((ArrayPtr*)stack, i)), cur);
       cur++;

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp Mon Nov 21 05:03:32 2011
@@ -523,7 +523,7 @@
   
   BEGIN_NATIVE_EXCEPTION(0)
 
-  mvm::ThreadAllocator allocator;
+  vmkit::ThreadAllocator allocator;
   char* buf = JavaString::strToAsciiz(str, &allocator);
   char* res = getenv(buf);
   if (res) {

Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h Mon Nov 21 05:03:32 2011
@@ -62,7 +62,7 @@
 class ClassArray;
 class JnjvmClassLoader;
 
-class Classpath : public mvm::PermanentObject {
+class Classpath : public vmkit::PermanentObject {
 public: 
   ISOLATE_STATIC UserClass*  newClassLoader;
   ISOLATE_STATIC JavaMethod* getSystemClassLoader;

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp Mon Nov 21 05:03:32 2011
@@ -44,7 +44,7 @@
   stack = self->backtrace;
   sint32 index = 2;;
   while (index != JavaArray::getSize(stack)) {
-    mvm::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
+    vmkit::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
     if (FI->Metadata == NULL) ++index;
     else {
       JavaMethod* meth = (JavaMethod*)FI->Metadata;
@@ -74,7 +74,7 @@
   sint32 size = 0;
   sint32 cur = index;
   while (cur < JavaArray::getSize(stack)) {
-    mvm::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
+    vmkit::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
     ++cur;
     if (FI->Metadata != NULL) ++size;
   }

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h Mon Nov 21 05:03:32 2011
@@ -59,7 +59,7 @@
   static void setProtectionDomain(JavaObjectClass* cl, JavaObject* pd) {
     llvm_gcroot(cl, 0);
     llvm_gcroot(pd, 0);
-    mvm::Collector::objectReferenceWriteBarrier(
+    vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)cl, (gc**)&(cl->pd), (gc*)pd);
   }
 
@@ -69,27 +69,27 @@
   }
 
   static void staticTracer(JavaObjectClass* obj, word_t closure) {
-    mvm::Collector::markAndTrace(obj, &obj->cachedConstructor, closure);
-    mvm::Collector::markAndTrace(obj, &obj->newInstanceCallerCache, closure);
-    mvm::Collector::markAndTrace(obj, &obj->name, closure);
-    mvm::Collector::markAndTrace(obj, &obj->declaredFields, closure);
-    mvm::Collector::markAndTrace(obj, &obj->publicFields, closure);
-    mvm::Collector::markAndTrace(obj, &obj->declaredMethods, closure);
-    mvm::Collector::markAndTrace(obj, &obj->publicMethods, closure);
-    mvm::Collector::markAndTrace(obj, &obj->declaredConstructors, closure);
-    mvm::Collector::markAndTrace(obj, &obj->publicConstructors, closure);
-    mvm::Collector::markAndTrace(obj, &obj->declaredPublicFields, closure);
-    mvm::Collector::markAndTrace(obj, &obj->genericInfo, closure);
-    mvm::Collector::markAndTrace(obj, &obj->enumConstants, closure);
-    mvm::Collector::markAndTrace(obj, &obj->enumConstantDictionary, closure);
-    mvm::Collector::markAndTrace(obj, &obj->annotations, closure);
-    mvm::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
-    mvm::Collector::markAndTrace(obj, &obj->annotationType, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->cachedConstructor, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->newInstanceCallerCache, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->name, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->declaredFields, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->publicFields, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->declaredMethods, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->publicMethods, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->declaredConstructors, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->publicConstructors, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->declaredPublicFields, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->genericInfo, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->enumConstants, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->enumConstantDictionary, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->annotations, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->annotationType, closure);
 
     UserCommonClass * cl = getClass(obj);
     if (cl) {
       JavaObject** Obj = cl->classLoader->getJavaClassLoaderPtr();
-      if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
+      if (*Obj) vmkit::Collector::markAndTraceRoot(Obj, closure);
     }
   }
 
@@ -126,18 +126,18 @@
 public:
 
   static void staticTracer(JavaObjectField* obj, word_t closure) {
-    mvm::Collector::markAndTrace(obj, &obj->clazz, closure);
-    mvm::Collector::markAndTrace(obj, &obj->name, closure);
-    mvm::Collector::markAndTrace(obj, &obj->type, closure);
-    mvm::Collector::markAndTrace(obj, &obj->signature, closure);
-    mvm::Collector::markAndTrace(obj, &obj->genericInfo, closure);
-    mvm::Collector::markAndTrace(obj, &obj->annotations, closure);
-    mvm::Collector::markAndTrace(obj, &obj->fieldAccessor, closure);
-    mvm::Collector::markAndTrace(obj, &obj->overrideFieldAccessor, closure);
-    mvm::Collector::markAndTrace(obj, &obj->root, closure);
-    mvm::Collector::markAndTrace(obj, &obj->securityCheckCache, closure);
-    mvm::Collector::markAndTrace(obj, &obj->securityCheckTargetClassCache, closure);
-    mvm::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->clazz, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->name, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->type, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->signature, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->genericInfo, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->annotations, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->fieldAccessor, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->overrideFieldAccessor, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->root, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->securityCheckCache, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->securityCheckTargetClassCache, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
   }
 
   static JavaField* getInternalField(JavaObjectField* self) {
@@ -181,21 +181,21 @@
 public:
 
   static void staticTracer(JavaObjectMethod* obj, word_t closure) {
-    mvm::Collector::markAndTrace(obj, &obj->clazz, closure);
-    mvm::Collector::markAndTrace(obj, &obj->name, closure);
-    mvm::Collector::markAndTrace(obj, &obj->returnType, closure);
-    mvm::Collector::markAndTrace(obj, &obj->parameterTypes, closure);
-    mvm::Collector::markAndTrace(obj, &obj->exceptionTypes, closure);
-    mvm::Collector::markAndTrace(obj, &obj->Signature, closure);
-    mvm::Collector::markAndTrace(obj, &obj->genericInfo, closure);
-    mvm::Collector::markAndTrace(obj, &obj->annotations, closure);
-    mvm::Collector::markAndTrace(obj, &obj->parameterAnnotations, closure);
-    mvm::Collector::markAndTrace(obj, &obj->annotationDefault, closure);
-    mvm::Collector::markAndTrace(obj, &obj->methodAccessor, closure);
-    mvm::Collector::markAndTrace(obj, &obj->root, closure);
-    mvm::Collector::markAndTrace(obj, &obj->securityCheckCache, closure);
-    mvm::Collector::markAndTrace(obj, &obj->securityCheckTargetClassCache, closure);
-    mvm::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->clazz, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->name, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->returnType, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->parameterTypes, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->exceptionTypes, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->Signature, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->genericInfo, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->annotations, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->parameterAnnotations, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->annotationDefault, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->methodAccessor, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->root, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->securityCheckCache, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->securityCheckTargetClassCache, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
   }
 
   static JavaMethod* getInternalMethod(JavaObjectMethod* self);
@@ -230,17 +230,17 @@
 
 public:
   static void staticTracer(JavaObjectConstructor* obj, word_t closure) {
-    mvm::Collector::markAndTrace(obj, &obj->clazz, closure);
-    mvm::Collector::markAndTrace(obj, &obj->parameterTypes, closure);
-    mvm::Collector::markAndTrace(obj, &obj->exceptionTypes, closure);
-    mvm::Collector::markAndTrace(obj, &obj->signature, closure);
-    mvm::Collector::markAndTrace(obj, &obj->genericInfo, closure);
-    mvm::Collector::markAndTrace(obj, &obj->annotations, closure);
-    mvm::Collector::markAndTrace(obj, &obj->parameterAnnotations, closure);
-    mvm::Collector::markAndTrace(obj, &obj->securityCheckCache, closure);
-    mvm::Collector::markAndTrace(obj, &obj->constructorAccessor, closure);
-    mvm::Collector::markAndTrace(obj, &obj->root, closure);
-    mvm::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->clazz, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->parameterTypes, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->exceptionTypes, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->signature, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->genericInfo, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->annotations, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->parameterAnnotations, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->securityCheckCache, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->constructorAccessor, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->root, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
   }
 
   static JavaMethod* getInternalMethod(JavaObjectConstructor* self);
@@ -266,7 +266,7 @@
   static void setDetailedMessage(JavaObjectThrowable* self, JavaObject* obj) {
     llvm_gcroot(self, 0);
     llvm_gcroot(obj, 0);
-    mvm::Collector::objectReferenceWriteBarrier(
+    vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)self, (gc**)&(self->detailedMessage), (gc*)obj);
   }
 
@@ -276,10 +276,10 @@
     llvm_gcroot(stackTrace, 0);
 
     stackTrace = internalFillInStackTrace(self);
-    mvm::Collector::objectReferenceWriteBarrier(
+    vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)self, (gc**)&(self->backtrace), (gc*)stackTrace);
 
-    mvm::Collector::objectReferenceWriteBarrier(
+    vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)self, (gc**)&(self->cause), (gc*)self);
 
     self->stackTrace = NULL;
@@ -301,9 +301,9 @@
     llvm_gcroot(self, 0);
     llvm_gcroot(r, 0);
     llvm_gcroot(q, 0);
-    mvm::Collector::objectReferenceWriteBarrier(
+    vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)self, (gc**)&(self->referent), (gc*)r);
-    mvm::Collector::objectReferenceWriteBarrier(
+    vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)self, (gc**)&(self->queue), (gc*)q);
   }
 

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h Mon Nov 21 05:03:32 2011
@@ -62,7 +62,7 @@
 class ClassArray;
 class JnjvmClassLoader;
 
-class Classpath : public mvm::PermanentObject {
+class Classpath : public vmkit::PermanentObject {
 public:
   ISOLATE_STATIC UserClass*  newClassLoader;
   ISOLATE_STATIC JavaMethod* getSystemClassLoader;

Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Mon Nov 21 05:03:32 2011
@@ -49,7 +49,7 @@
 #endif
 
   // Don't call th->getFrameContext because it is not GC-safe.
-  mvm::StackWalker Walker(th);
+  vmkit::StackWalker Walker(th);
   uint32_t i = 0;
 
   while (intptr_t ip = *Walker) {
@@ -61,7 +61,7 @@
   return result;
 }
 
-JavaObject* consStackElement(mvm::FrameInfo* FI, intptr_t ip) {
+JavaObject* consStackElement(vmkit::FrameInfo* FI, intptr_t ip) {
 
   JavaString* methodName = 0;
   JavaString* className = 0;
@@ -262,18 +262,18 @@
  */
 JNIEXPORT void JNICALL
 JVM_Exit(jint code) {
-  mvm::System::Exit(code);
+  vmkit::System::Exit(code);
 }
 
 JNIEXPORT void JNICALL
 JVM_Halt(jint code) {
-  mvm::System::Exit(code);
+  vmkit::System::Exit(code);
 }
 
 JNIEXPORT void JNICALL
 JVM_GC(void) {
   BEGIN_JNI_EXCEPTION
-  mvm::Collector::collect();
+  vmkit::Collector::collect();
   RETURN_VOID_FROM_JNI;
   END_JNI_EXCEPTION
 }
@@ -309,22 +309,22 @@
 
 JNIEXPORT jlong JNICALL
 JVM_TotalMemory(void) {
-  return (jlong)mvm::Collector::getTotalMemory();
+  return (jlong)vmkit::Collector::getTotalMemory();
 }
 
 JNIEXPORT jlong JNICALL
 JVM_FreeMemory(void) {
-  return (jlong)mvm::Collector::getFreeMemory();
+  return (jlong)vmkit::Collector::getFreeMemory();
 }
 
 JNIEXPORT jlong JNICALL
 JVM_MaxMemory(void) {
-  return (jlong)mvm::Collector::getMaxMemory();
+  return (jlong)vmkit::Collector::getMaxMemory();
 }
 
 JNIEXPORT jint JNICALL
 JVM_ActiveProcessorCount(void) {
-  return mvm::System::GetNumberOfProcessors();
+  return vmkit::System::GetNumberOfProcessors();
 }
 
 JNIEXPORT void * JNICALL
@@ -432,7 +432,7 @@
   sint32 cur = 0;
   for (sint32 i = base; i < JavaArray::getSize(stack); ++i) {
     intptr_t ip = ArrayPtr::getElement((ArrayPtr*)stack, i);
-    mvm::FrameInfo* FI = vm->IPToFrameInfo(ip);
+    vmkit::FrameInfo* FI = vm->IPToFrameInfo(ip);
     if (FI->Metadata != NULL) {
       if (cur == index) {
         result = consStackElement(FI, ip);
@@ -497,7 +497,7 @@
 
   // Wait some time to let the creator initialise this field
   while (thread->javaThread == NULL) {
-    mvm::Thread::yield();
+    vmkit::Thread::yield();
   }
 
   javaThread = thread->javaThread;
@@ -542,7 +542,7 @@
 
   JavaThread * newTh = new JavaThread(vm);
   if (!newTh) vm->outOfMemoryError();
-  newTh->start((void (*)(mvm::Thread*))start);
+  newTh->start((void (*)(vmkit::Thread*))start);
 
   newTh->initialise(thread, 0);
 
@@ -602,7 +602,7 @@
 
 JNIEXPORT void JNICALL
 JVM_Yield(JNIEnv *env, jclass threadClass) {
-  mvm::Thread::yield();
+  vmkit::Thread::yield();
 }
 
 JNIEXPORT void JNICALL
@@ -638,16 +638,16 @@
   // It's possible that the thread to be interrupted has not finished
   // its initialization. Wait until the initialization is done.
   while (field->getInstanceLongField(thread) == 0)
-    mvm::Thread::yield();
+    vmkit::Thread::yield();
 
   JavaThread* th = (JavaThread*)field->getInstanceLongField(thread);
   th->lockingThread.interruptFlag = 1;
-  mvm::FatLock* lock = th->lockingThread.waitsOn;
+  vmkit::FatLock* lock = th->lockingThread.waitsOn;
 
   // If the thread is blocked on a wait. We also verify nextWaiting in case
   // the thread has been notified.
   if (lock && th->lockingThread.nextWaiting) {
-    th->lockingThread.state = mvm::LockingThread::StateInterrupted;
+    th->lockingThread.state = vmkit::LockingThread::StateInterrupted;
 
     // Make sure the thread is waiting.
     uint32 locked = 0;
@@ -655,7 +655,7 @@
       locked = (lock->tryAcquire() == 0);
       if (locked || (lock->getOwner() != th && lock->getOwner() != 0))
         break;
-      else mvm::Thread::yield();
+      else vmkit::Thread::yield();
     }
 
     // Interrupt the thread.

Modified: vmkit/trunk/lib/J3/ClassLib/Unsafe.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/Unsafe.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/Unsafe.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/Unsafe.inc Mon Nov 21 05:03:32 2011
@@ -232,7 +232,7 @@
   llvm_gcroot(value, 0);
 
   JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
-  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
+  vmkit::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
 }
 
 
@@ -260,7 +260,7 @@
   llvm_gcroot(value, 0);
 
   JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
-  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
+  vmkit::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
   // Ensure this value is seen.
   __sync_synchronize();
 }
@@ -287,7 +287,7 @@
   llvm_gcroot(value, 0);
 
   JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
-  mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
+  vmkit::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
   // No barrier (difference between volatile and ordered)
 }
 
@@ -338,7 +338,7 @@
   llvm_gcroot(update, 0);
 
   JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
-  return mvm::Collector::objectReferenceTryCASBarrier((gc*)base, (gc**)ptr, (gc*)expect, (gc*)update);
+  return vmkit::Collector::objectReferenceTryCASBarrier((gc*)base, (gc**)ptr, (gc*)expect, (gc*)update);
 }
 
 
@@ -526,12 +526,12 @@
 
 JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_pageSize(
 JavaObject* unsafe) {
-  return mvm::System::GetPageSize();
+  return vmkit::System::GetPageSize();
 }
 
 JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_addressSize(
 JavaObject* unsafe) {
-  return mvm::kWordSize;
+  return vmkit::kWordSize;
 }
 
 JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_getLoadAverage(

Modified: vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp Mon Nov 21 05:03:32 2011
@@ -379,7 +379,7 @@
   final_object_iterator I = finalObjects.find(obj);
   if (I == End) {
   
-    if (mvm::Collector::begOf(obj)) {
+    if (vmkit::Collector::begOf(obj)) {
       Type* Ty = 0;
       CommonClass* cl = JavaObject::getClass(obj);
       
@@ -1041,7 +1041,7 @@
   return ConstantStruct::get(STy, ClassElts);
 }
 
-Constant* JavaAOTCompiler::CreateConstantFromClassMap(const mvm::VmkitDenseMap<const UTF8*, CommonClass*>& map) {
+Constant* JavaAOTCompiler::CreateConstantFromClassMap(const vmkit::VmkitDenseMap<const UTF8*, CommonClass*>& map) {
   StructType* STy = 
     dyn_cast<StructType>(JavaIntrinsics.J3DenseMapType->getContainedType(0));
   Module& Mod = *getLLVMModule();
@@ -1055,11 +1055,11 @@
     ArrayType* ATy = ArrayType::get(JavaIntrinsics.ptrType, map.NumBuckets * 2);
 
     for (uint32 i = 0; i < map.NumBuckets; ++i) {
-      mvm::VmkitPair<const UTF8*, CommonClass*> pair = map.Buckets[i];
-      if (pair.first == &mvm::TombstoneKey) {
+      vmkit::VmkitPair<const UTF8*, CommonClass*> pair = map.Buckets[i];
+      if (pair.first == &vmkit::TombstoneKey) {
         TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, UTF8TombstoneGV, JavaIntrinsics.ptrType));
         TempElts.push_back(Constant::getNullValue(JavaIntrinsics.ptrType));
-      } else if (pair.first == &mvm::EmptyKey) {
+      } else if (pair.first == &vmkit::EmptyKey) {
         TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, UTF8EmptyGV, JavaIntrinsics.ptrType));
         TempElts.push_back(Constant::getNullValue(JavaIntrinsics.ptrType));
       } else {
@@ -1086,7 +1086,7 @@
                             ConstantStruct::get(STy, elements), "ClassMap");
 }
 
-Constant* JavaAOTCompiler::CreateConstantFromUTF8Map(const mvm::VmkitDenseSet<mvm::UTF8MapKey, const UTF8*>& set) {
+Constant* JavaAOTCompiler::CreateConstantFromUTF8Map(const vmkit::VmkitDenseSet<vmkit::UTF8MapKey, const UTF8*>& set) {
   StructType* STy = 
     dyn_cast<StructType>(JavaIntrinsics.J3DenseMapType->getContainedType(0));
   Module& Mod = *getLLVMModule();
@@ -1101,9 +1101,9 @@
 
     for (uint32 i = 0; i < set.NumBuckets; ++i) {
       const UTF8* utf8 = set.Buckets[i];
-      if (utf8 == &mvm::EmptyKey) {
+      if (utf8 == &vmkit::EmptyKey) {
         TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, UTF8EmptyGV, JavaIntrinsics.ptrType));
-      } else if (utf8 == &mvm::TombstoneKey) {
+      } else if (utf8 == &vmkit::TombstoneKey) {
         TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, UTF8TombstoneGV, JavaIntrinsics.ptrType));
       } else {
         TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, getUTF8(utf8), JavaIntrinsics.ptrType));
@@ -1795,8 +1795,8 @@
   JavaLLVMCompiler(ModuleID) {
 
   std::string Error;
-  const Target* TheTarget(TargetRegistry::lookupTarget(mvm::VmkitModule::getHostTriple(), Error));
-  TargetMachine* TM = TheTarget->createTargetMachine(mvm::VmkitModule::getHostTriple(), "", "");
+  const Target* TheTarget(TargetRegistry::lookupTarget(vmkit::VmkitModule::getHostTriple(), Error));
+  TargetMachine* TM = TheTarget->createTargetMachine(vmkit::VmkitModule::getHostTriple(), "", "");
   TheTargetData = TM->getTargetData();
   TheModule->setDataLayout(TheTargetData->getStringRepresentation());
   TheModule->setTargetTriple(TM->getTargetTriple());
@@ -2047,7 +2047,7 @@
                   std::vector<Class*>& classes) {
   ZipArchive archive(bytes, bootstrapLoader->allocator);
    
-  mvm::BumpPtrAllocator allocator; 
+  vmkit::BumpPtrAllocator allocator; 
   char* realName = (char*)allocator.Allocate(4096, "temp");
   for (ZipArchive::table_iterator i = archive.filetable.begin(), 
        e = archive.filetable.end(); i != e; ++i) {
@@ -2225,7 +2225,7 @@
     }
 
   } else {
-    mvm::ThreadAllocator allocator;
+    vmkit::ThreadAllocator allocator;
     char* realName = (char*)allocator.Allocate(size + 1);
     if (size > 6 && !strcmp(&name[size - 6], ".class")) {
       memcpy(realName, name, size - 6);
@@ -2276,7 +2276,7 @@
   name = n;
   JavaThread* th = new JavaThread(vm);
   vm->setMainThread(th);
-  th->start((void (*)(mvm::Thread*))mainCompilerStart);
+  th->start((void (*)(vmkit::Thread*))mainCompilerStart);
   vm->waitForExit();
 }
 

Modified: vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp Mon Nov 21 05:03:32 2011
@@ -389,7 +389,7 @@
   sint32 mnlen = jniConsName->size;
   sint32 mtlen = jniConsType->size;
 
-  mvm::ThreadAllocator allocator;
+  vmkit::ThreadAllocator allocator;
   char* functionName = (char*)allocator.Allocate(
       3 + JNI_NAME_PRE_LEN + ((mnlen + clen + mtlen) << 3));
   
@@ -455,7 +455,7 @@
   Value* oldCLIN = new AllocaInst(PointerType::getUnqual(Type::getInt32Ty(*llvmContext)), "",
                                   currentBlock);
   
-  Constant* sizeF = ConstantInt::get(Type::getInt32Ty(*llvmContext), sizeof(mvm::KnownFrame));
+  Constant* sizeF = ConstantInt::get(Type::getInt32Ty(*llvmContext), sizeof(vmkit::KnownFrame));
   Value* Frame = new AllocaInst(Type::getInt8Ty(*llvmContext), sizeF, "", currentBlock);
   
   uint32 nargs = func->arg_size() + 1 + (stat ? 1 : 0); 
@@ -653,7 +653,7 @@
   Value* lock = new LoadInst(lockPtr, "", currentBlock);
   lock = new PtrToIntInst(lock, intrinsics->pointerSizeType, "", currentBlock);
   Value* NonLockBitsMask = ConstantInt::get(intrinsics->pointerSizeType,
-                                            mvm::ThinLock::NonLockBitsMask);
+                                            vmkit::ThinLock::NonLockBitsMask);
 
   lock = BinaryOperator::CreateAnd(lock, NonLockBitsMask, "", currentBlock);
 
@@ -697,7 +697,7 @@
                             "", currentBlock);
   Value* lock = new LoadInst(lockPtr, "", currentBlock);
   Value* NonLockBitsMask = ConstantInt::get(
-      intrinsics->pointerSizeType, mvm::ThinLock::NonLockBitsMask);
+      intrinsics->pointerSizeType, vmkit::ThinLock::NonLockBitsMask);
 
   Value* lockedMask = BinaryOperator::CreateAnd(
       lock, NonLockBitsMask, "", currentBlock);
@@ -1104,7 +1104,7 @@
 
   nbHandlers = readExceptionTable(reader, codeLen);
   if (nbHandlers != 0) {
-    jmpBuffer = new AllocaInst(ArrayType::get(Type::getInt8Ty(*llvmContext), sizeof(mvm::ExceptionBuffer)), "", currentBlock);
+    jmpBuffer = new AllocaInst(ArrayType::get(Type::getInt8Ty(*llvmContext), sizeof(vmkit::ExceptionBuffer)), "", currentBlock);
     jmpBuffer = new BitCastInst(jmpBuffer, intrinsics->ptrType, "", currentBlock);
   }
   
@@ -1124,7 +1124,7 @@
   }
   
   if (TheCompiler->hasExceptionsEnabled() &&
-      !mvm::System::SupportsHardwareStackOverflow()) {
+      !vmkit::System::SupportsHardwareStackOverflow()) {
     // Variables have been allocated and the lock has been taken. Do the stack
     // check now: if there is an exception, we will go to the lock release code.
     currentExceptionBlock = opcodeInfos[0].exceptionBlock;
@@ -1337,7 +1337,7 @@
 
 void JavaJIT::JITVerifyNull(Value* obj) {
   if (TheCompiler->hasExceptionsEnabled()) {
-    if (nbHandlers == 0 && mvm::System::SupportsHardwareNullCheck()) {
+    if (nbHandlers == 0 && vmkit::System::SupportsHardwareNullCheck()) {
       Value* indexes[2] = { intrinsics->constantZero, intrinsics->constantZero };
       Value* VTPtr = GetElementPtrInst::Create(obj, indexes, "", currentBlock);
       Instruction* VT = new LoadInst(VTPtr, "", true, currentBlock);
@@ -1397,7 +1397,7 @@
 void JavaJIT::makeArgs(FunctionType::param_iterator it,
                        uint32 index, std::vector<Value*>& Args, uint32 nb) {
   Args.reserve(nb + 2);
-  mvm::ThreadAllocator threadAllocator;
+  vmkit::ThreadAllocator threadAllocator;
   Value** args = (Value**)threadAllocator.Allocate(nb*sizeof(Value*));
   sint32 start = nb - 1;
 
@@ -1968,7 +1968,7 @@
     convertValue(val, type, currentBlock, false);
   }
   
-  if (mvm::Collector::needsNonHeapWriteBarrier() && type == intrinsics->JavaObjectType) {
+  if (vmkit::Collector::needsNonHeapWriteBarrier() && type == intrinsics->JavaObjectType) {
     ptr = new BitCastInst(ptr, intrinsics->ptrPtrType, "", currentBlock);
     val = new BitCastInst(val, intrinsics->ptrType, "", currentBlock);
     Value* args[2] = { ptr, val };
@@ -2025,7 +2025,7 @@
           JavaObject* val = field->getStaticObjectField();
           JnjvmClassLoader* JCL = field->classDef->classLoader;
           Value* V = TheCompiler->getFinalObject(val, sign->assocClass(JCL));
-          CommonClass* cl = mvm::Collector::begOf(val) ?
+          CommonClass* cl = vmkit::Collector::begOf(val) ?
               JavaObject::getClass(val) : NULL;
           push(V, false, cl);
         } else {
@@ -2074,7 +2074,7 @@
     convertValue(val, type, currentBlock, false);
   }
   
-  if (mvm::Collector::needsWriteBarrier() && type == intrinsics->JavaObjectType) {
+  if (vmkit::Collector::needsWriteBarrier() && type == intrinsics->JavaObjectType) {
     ptr = new BitCastInst(ptr, intrinsics->ptrPtrType, "", currentBlock);
     val = new BitCastInst(val, intrinsics->ptrType, "", currentBlock);
     object = new LoadInst(object, "", false, currentBlock);
@@ -2445,7 +2445,7 @@
   sint16 sync = isSynchro(compilingMethod->access) ? 1 : 0;
   nbe += sync;
  
-  mvm::ThreadAllocator allocator;
+  vmkit::ThreadAllocator allocator;
   // Loop over all handlers in the bytecode to initialize their values.
   Handler* handlers =
       (Handler*)allocator.Allocate(sizeof(Handler) * (nbe - sync));

Modified: vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp Mon Nov 21 05:03:32 2011
@@ -163,7 +163,7 @@
   executionEngine->RegisterJITEventListener(&listener);
   TheTargetData = executionEngine->getTargetData();
   TheModule->setDataLayout(TheTargetData->getStringRepresentation());
-  TheModule->setTargetTriple(mvm::VmkitModule::getHostTriple());
+  TheModule->setTargetTriple(vmkit::VmkitModule::getHostTriple());
   JavaIntrinsics.init(TheModule);
   initialiseAssessorInfo();  
 
@@ -217,8 +217,8 @@
   BEGIN_NATIVE_EXCEPTION(1);
 
   // Lookup the caller of this class.
-  mvm::StackWalker Walker(th);
-  mvm::FrameInfo* FI = Walker.get();
+  vmkit::StackWalker Walker(th);
+  vmkit::FrameInfo* FI = Walker.get();
   assert(FI->Metadata != NULL && "Wrong stack trace");
   JavaMethod* meth = (JavaMethod*)FI->Metadata;
 
@@ -320,7 +320,7 @@
 }
 
 void* JavaJITCompiler::materializeFunction(JavaMethod* meth, Class* customizeFor) {
-  mvm::VmkitModule::protectIR();
+  vmkit::VmkitModule::protectIR();
   Function* func = parseFunction(meth, customizeFor);
   void* res = executionEngine->getPointerToGlobal(func);
 
@@ -328,12 +328,12 @@
     llvm::GCFunctionInfo& GFI = GCInfo->getFunctionInfo(*func);
   
     Jnjvm* vm = JavaThread::get()->getJVM();
-    mvm::VmkitModule::addToVM(vm, &GFI, (JIT*)executionEngine, allocator, meth);
+    vmkit::VmkitModule::addToVM(vm, &GFI, (JIT*)executionEngine, allocator, meth);
 
     // Now that it's compiled, we don't need the IR anymore
     func->deleteBody();
   }
-  mvm::VmkitModule::unprotectIR();
+  vmkit::VmkitModule::unprotectIR();
   if (customizeFor == NULL || !getMethodInfo(meth)->isCustomizable) {
     meth->code = res;
   }
@@ -341,7 +341,7 @@
 }
 
 void* JavaJITCompiler::GenerateStub(llvm::Function* F) {
-  mvm::VmkitModule::protectIR();
+  vmkit::VmkitModule::protectIR();
   void* res = executionEngine->getPointerToGlobal(F);
  
   // If the stub was already generated through an equivalent signature,
@@ -350,12 +350,12 @@
     llvm::GCFunctionInfo& GFI = GCInfo->getFunctionInfo(*F);
   
     Jnjvm* vm = JavaThread::get()->getJVM();
-    mvm::VmkitModule::addToVM(vm, &GFI, (JIT*)executionEngine, allocator, NULL);
+    vmkit::VmkitModule::addToVM(vm, &GFI, (JIT*)executionEngine, allocator, NULL);
   
     // Now that it's compiled, we don't need the IR anymore
     F->deleteBody();
   }
-  mvm::VmkitModule::unprotectIR();
+  vmkit::VmkitModule::unprotectIR();
   return res;
 }
 
@@ -363,16 +363,16 @@
 extern "C" int StartJnjvmWithJIT(int argc, char** argv, char* mainClass) {
   llvm::llvm_shutdown_obj X; 
    
-  mvm::VmkitModule::initialise(argc, argv);
-  mvm::Collector::initialise(argc, argv);
+  vmkit::VmkitModule::initialise(argc, argv);
+  vmkit::Collector::initialise(argc, argv);
  
-  mvm::ThreadAllocator allocator;
+  vmkit::ThreadAllocator allocator;
   char** newArgv = (char**)allocator.Allocate((argc + 1) * sizeof(char*));
   memcpy(newArgv + 1, argv, argc * sizeof(void*));
   newArgv[0] = newArgv[1];
   newArgv[1] = mainClass;
 
-  mvm::BumpPtrAllocator Allocator;
+  vmkit::BumpPtrAllocator Allocator;
   JavaJITCompiler* Comp = JavaJITCompiler::CreateCompiler("JITModule");
   JnjvmBootstrapLoader* loader = new(Allocator, "Bootstrap loader")
     JnjvmBootstrapLoader(Allocator, Comp, true);

Modified: vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp Mon Nov 21 05:03:32 2011
@@ -102,7 +102,7 @@
   bool wide = false;
   uint32 jsrIndex = 0;
   uint32 start = reader.cursor;
-  mvm::ThreadAllocator allocator;
+  vmkit::ThreadAllocator allocator;
   for(uint32 i = 0; i < codeLength; ++i) {
     reader.cursor = start + i;
     uint8 bytecode = reader.readU1();
@@ -725,7 +725,7 @@
         Value* obj = pop();
         Value* ptr = verifyAndComputePtr(obj, index,
                                          intrinsics->JavaArrayObjectType, false);
-        if (mvm::Collector::needsWriteBarrier()) {
+        if (vmkit::Collector::needsWriteBarrier()) {
           ptr = new BitCastInst(ptr, intrinsics->ptrPtrType, "", currentBlock);
           val = new BitCastInst(val, intrinsics->ptrType, "", currentBlock);
           obj = new BitCastInst(obj, intrinsics->ptrType, "", currentBlock);

Modified: vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp Mon Nov 21 05:03:32 2011
@@ -35,18 +35,18 @@
   
 void JavaLLVMCompiler::resolveVirtualClass(Class* cl) {
   // Lock here because we may be called by a class resolver
-  mvm::VmkitModule::protectIR();
+  vmkit::VmkitModule::protectIR();
   LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl);
   LCI->getVirtualType();
-  mvm::VmkitModule::unprotectIR();
+  vmkit::VmkitModule::unprotectIR();
 }
 
 void JavaLLVMCompiler::resolveStaticClass(Class* cl) {
   // Lock here because we may be called by a class initializer
-  mvm::VmkitModule::protectIR();
+  vmkit::VmkitModule::protectIR();
   LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl);
   LCI->getStaticType();
-  mvm::VmkitModule::unprotectIR();
+  vmkit::VmkitModule::unprotectIR();
 }
 
 Function* JavaLLVMCompiler::getMethod(JavaMethod* meth, Class* customizeFor) {
@@ -59,17 +59,17 @@
   Function* func = LMI->getMethod(customizeFor);
   
   // We are jitting. Take the lock.
-  mvm::VmkitModule::protectIR();
+  vmkit::VmkitModule::protectIR();
   if (func->getLinkage() == GlobalValue::ExternalWeakLinkage) {
     JavaJIT jit(this, meth, func, customizeFor);
     if (isNative(meth->access)) {
       jit.nativeCompile();
-      mvm::VmkitModule::runPasses(func, JavaNativeFunctionPasses);
-      mvm::VmkitModule::runPasses(func, J3FunctionPasses);
+      vmkit::VmkitModule::runPasses(func, JavaNativeFunctionPasses);
+      vmkit::VmkitModule::runPasses(func, J3FunctionPasses);
     } else {
       jit.javaCompile();
-      mvm::VmkitModule::runPasses(func, JavaFunctionPasses);
-      mvm::VmkitModule::runPasses(func, J3FunctionPasses);
+      vmkit::VmkitModule::runPasses(func, JavaFunctionPasses);
+      vmkit::VmkitModule::runPasses(func, J3FunctionPasses);
     }
     func->setLinkage(GlobalValue::ExternalLinkage);
     if (!LMI->isCustomizable && jit.isCustomizable) {
@@ -82,7 +82,7 @@
       }
     }
   }
-  mvm::VmkitModule::unprotectIR();
+  vmkit::VmkitModule::unprotectIR();
 
   return func;
 }
@@ -115,7 +115,7 @@
   
   JavaFunctionPasses = new FunctionPassManager(TheModule);
   JavaFunctionPasses->add(new TargetData(TheModule));
-  mvm::VmkitModule::addCommandLinePasses(JavaFunctionPasses);
+  vmkit::VmkitModule::addCommandLinePasses(JavaFunctionPasses);
 }
 
 } // end namespace j3

Modified: vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp Mon Nov 21 05:03:32 2011
@@ -140,7 +140,7 @@
   extern bool JITEmitDebugInfo;
 }
 
-static char* GetMethodName(mvm::ThreadAllocator& allocator,
+static char* GetMethodName(vmkit::ThreadAllocator& allocator,
                            JavaMethod* methodDef,
                            Class* customizeFor) {
   const UTF8* jniConsClName = methodDef->classDef->name;
@@ -181,7 +181,7 @@
 
   if (result == NULL) {
     if (Compiler->emitFunctionName() || JITEmitDebugInfo) {
-      mvm::ThreadAllocator allocator;
+      vmkit::ThreadAllocator allocator;
       char* buf = GetMethodName(
           allocator, methodDef, customizing ? customizeFor : NULL);
       result = Function::Create(getFunctionType(), 
@@ -215,7 +215,7 @@
 
 void LLVMMethodInfo::setCustomizedVersion(Class* cl, llvm::Function* F) {
   assert(customizedVersions.size() == 0);
-  mvm::ThreadAllocator allocator;
+  vmkit::ThreadAllocator allocator;
   if (Compiler->emitFunctionName() || JITEmitDebugInfo) {
     char* buf = GetMethodName(allocator, methodDef, cl);
     F->setName(buf);
@@ -267,7 +267,7 @@
 llvm::FunctionType* LLVMSignatureInfo::getVirtualType() {
  if (!virtualType) {
     // Lock here because we are called by arbitrary code
-    mvm::VmkitModule::protectIR();
+    vmkit::VmkitModule::protectIR();
     std::vector<llvm::Type*> llvmArgs;
     uint32 size = signature->nbArguments;
     Typedef* const* arguments = signature->getArgumentsType();
@@ -283,7 +283,7 @@
     LLVMAssessorInfo& LAI =
       Compiler->getTypedefInfo(signature->getReturnType());
     virtualType = FunctionType::get(LAI.llvmType, llvmArgs, false);
-    mvm::VmkitModule::unprotectIR();
+    vmkit::VmkitModule::unprotectIR();
   }
   return virtualType;
 }
@@ -291,7 +291,7 @@
 llvm::FunctionType* LLVMSignatureInfo::getStaticType() {
  if (!staticType) {
     // Lock here because we are called by arbitrary code
-    mvm::VmkitModule::protectIR();
+    vmkit::VmkitModule::protectIR();
     std::vector<llvm::Type*> llvmArgs;
     uint32 size = signature->nbArguments;
     Typedef* const* arguments = signature->getArgumentsType();
@@ -305,7 +305,7 @@
     LLVMAssessorInfo& LAI =
       Compiler->getTypedefInfo(signature->getReturnType());
     staticType = FunctionType::get(LAI.llvmType, llvmArgs, false);
-    mvm::VmkitModule::unprotectIR();
+    vmkit::VmkitModule::unprotectIR();
   }
   return staticType;
 }
@@ -313,7 +313,7 @@
 llvm::FunctionType* LLVMSignatureInfo::getNativeType() {
   if (!nativeType) {
     // Lock here because we are called by arbitrary code
-    mvm::VmkitModule::protectIR();
+    vmkit::VmkitModule::protectIR();
     std::vector<llvm::Type*> llvmArgs;
     uint32 size = signature->nbArguments;
     Typedef* const* arguments = signature->getArgumentsType();
@@ -341,14 +341,14 @@
       LAI.llvmType == Compiler->getIntrinsics()->JavaObjectType ?
         LAI.llvmTypePtr : LAI.llvmType;
     nativeType = FunctionType::get(RetType, llvmArgs, false);
-    mvm::VmkitModule::unprotectIR();
+    vmkit::VmkitModule::unprotectIR();
   }
   return nativeType;
 }
 
 llvm::FunctionType* LLVMSignatureInfo::getNativeStubType() {
   // Lock here because we are called by arbitrary code
-  mvm::VmkitModule::protectIR();
+  vmkit::VmkitModule::protectIR();
   std::vector<llvm::Type*> llvmArgs;
   uint32 size = signature->nbArguments;
   Typedef* const* arguments = signature->getArgumentsType();
@@ -377,7 +377,7 @@
     LAI.llvmType == Compiler->getIntrinsics()->JavaObjectType ?
       LAI.llvmTypePtr : LAI.llvmType;
   FunctionType* FTy = FunctionType::get(RetType, llvmArgs, false);
-  mvm::VmkitModule::unprotectIR();
+  vmkit::VmkitModule::unprotectIR();
   return FTy;
 }
 
@@ -399,7 +399,7 @@
     return res;
   }
   if (Compiler->isStaticCompiling()) {
-    mvm::ThreadAllocator allocator;
+    vmkit::ThreadAllocator allocator;
     const char* type = virt ? "virtual_buf" : "static_buf";
     char* buf = (char*)allocator.Allocate(
         (signature->keyName->size << 1) + 1 + 11);
@@ -500,7 +500,7 @@
     return res;
   }
   if (Compiler->isStaticCompiling()) {
-    mvm::ThreadAllocator allocator;
+    vmkit::ThreadAllocator allocator;
     const char* type = virt ? "virtual_ap" : "static_ap";
     char* buf = (char*)allocator.Allocate(
         (signature->keyName->size << 1) + 1 + 11);
@@ -593,7 +593,7 @@
     return stub;
   }
   if (Compiler->isStaticCompiling()) {
-    mvm::ThreadAllocator allocator;
+    vmkit::ThreadAllocator allocator;
     const char* type = virt ? "virtual_stub" : special ? "special_stub" : "static_stub";
     char* buf = (char*)allocator.Allocate(
         (signature->keyName->size << 1) + 1 + 11);
@@ -718,7 +718,7 @@
 FunctionType* LLVMSignatureInfo::getVirtualBufType() {
   if (!virtualBufType) {
     // Lock here because we are called by arbitrary code
-    mvm::VmkitModule::protectIR();
+    vmkit::VmkitModule::protectIR();
     std::vector<llvm::Type*> Args;
     Args.push_back(Compiler->getIntrinsics()->ResolvedConstantPoolType); // ctp
     Args.push_back(getVirtualPtrType());
@@ -727,7 +727,7 @@
     LLVMAssessorInfo& LAI =
       Compiler->getTypedefInfo(signature->getReturnType());
     virtualBufType = FunctionType::get(LAI.llvmType, Args, false);
-    mvm::VmkitModule::unprotectIR();
+    vmkit::VmkitModule::unprotectIR();
   }
   return virtualBufType;
 }
@@ -735,7 +735,7 @@
 FunctionType* LLVMSignatureInfo::getStaticBufType() {
   if (!staticBufType) {
     // Lock here because we are called by arbitrary code
-    mvm::VmkitModule::protectIR();
+    vmkit::VmkitModule::protectIR();
     std::vector<llvm::Type*> Args;
     Args.push_back(Compiler->getIntrinsics()->ResolvedConstantPoolType); // ctp
     Args.push_back(getStaticPtrType());
@@ -743,7 +743,7 @@
     LLVMAssessorInfo& LAI =
       Compiler->getTypedefInfo(signature->getReturnType());
     staticBufType = FunctionType::get(LAI.llvmType, Args, false);
-    mvm::VmkitModule::unprotectIR();
+    vmkit::VmkitModule::unprotectIR();
   }
   return staticBufType;
 }
@@ -751,84 +751,84 @@
 Function* LLVMSignatureInfo::getVirtualBuf() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on virtualBufFunction to have an address.
-  mvm::VmkitModule::protectIR();
+  vmkit::VmkitModule::protectIR();
   if (!virtualBufFunction) {
     virtualBufFunction = createFunctionCallBuf(true);
     signature->setVirtualCallBuf(Compiler->GenerateStub(virtualBufFunction));
   }
-  mvm::VmkitModule::unprotectIR();
+  vmkit::VmkitModule::unprotectIR();
   return virtualBufFunction;
 }
 
 Function* LLVMSignatureInfo::getVirtualAP() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on virtualAPFunction to have an address.
-  mvm::VmkitModule::protectIR();
+  vmkit::VmkitModule::protectIR();
   if (!virtualAPFunction) {
     virtualAPFunction = createFunctionCallAP(true);
     signature->setVirtualCallAP(Compiler->GenerateStub(virtualAPFunction));
   }
-  mvm::VmkitModule::unprotectIR();
+  vmkit::VmkitModule::unprotectIR();
   return virtualAPFunction;
 }
 
 Function* LLVMSignatureInfo::getStaticBuf() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on staticBufFunction to have an address.
-  mvm::VmkitModule::protectIR();
+  vmkit::VmkitModule::protectIR();
   if (!staticBufFunction) {
     staticBufFunction = createFunctionCallBuf(false);
     signature->setStaticCallBuf(Compiler->GenerateStub(staticBufFunction));
   }
-  mvm::VmkitModule::unprotectIR();
+  vmkit::VmkitModule::unprotectIR();
   return staticBufFunction;
 }
 
 Function* LLVMSignatureInfo::getStaticAP() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on staticAPFunction to have an address.
-  mvm::VmkitModule::protectIR();
+  vmkit::VmkitModule::protectIR();
   if (!staticAPFunction) {
     staticAPFunction = createFunctionCallAP(false);
     signature->setStaticCallAP(Compiler->GenerateStub(staticAPFunction));
   }
-  mvm::VmkitModule::unprotectIR();
+  vmkit::VmkitModule::unprotectIR();
   return staticAPFunction;
 }
 
 Function* LLVMSignatureInfo::getStaticStub() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on staticStubFunction to have an address.
-  mvm::VmkitModule::protectIR();
+  vmkit::VmkitModule::protectIR();
   if (!staticStubFunction) {
     staticStubFunction = createFunctionStub(false, false);
     signature->setStaticCallStub(Compiler->GenerateStub(staticStubFunction));
   }
-  mvm::VmkitModule::unprotectIR();
+  vmkit::VmkitModule::unprotectIR();
   return staticStubFunction;
 }
 
 Function* LLVMSignatureInfo::getSpecialStub() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on specialStubFunction to have an address.
-  mvm::VmkitModule::protectIR();
+  vmkit::VmkitModule::protectIR();
   if (!specialStubFunction) {
     specialStubFunction = createFunctionStub(true, false);
     signature->setSpecialCallStub(Compiler->GenerateStub(specialStubFunction));
   }
-  mvm::VmkitModule::unprotectIR();
+  vmkit::VmkitModule::unprotectIR();
   return specialStubFunction;
 }
 
 Function* LLVMSignatureInfo::getVirtualStub() {
   // Lock here because we are called by arbitrary code. Also put that here
   // because we are waiting on virtualStubFunction to have an address.
-  mvm::VmkitModule::protectIR();
+  vmkit::VmkitModule::protectIR();
   if (!virtualStubFunction) {
     virtualStubFunction = createFunctionStub(false, true);
     signature->setVirtualCallStub(Compiler->GenerateStub(virtualStubFunction));
   }
-  mvm::VmkitModule::unprotectIR();
+  vmkit::VmkitModule::unprotectIR();
   return virtualStubFunction;
 }
 

Modified: vmkit/trunk/lib/J3/VMCore/JavaArray.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaArray.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaArray.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaArray.cpp Mon Nov 21 05:03:32 2011
@@ -40,6 +40,6 @@
   llvm_gcroot(value, 0);
   assert((ssize_t)i < self->size);
   if (value != NULL) assert(value->getVirtualTable());
-  mvm::Collector::objectReferenceArrayWriteBarrier(
+  vmkit::Collector::objectReferenceArrayWriteBarrier(
       (gc*)self, (gc**)&(self->elements[i]), (gc*)value);
 }

Modified: vmkit/trunk/lib/J3/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaClass.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaClass.cpp Mon Nov 21 05:03:32 2011
@@ -572,7 +572,7 @@
   void* obj = classDef->getStaticInstance();
   assert(isReference());
   JavaObject** ptr = (JavaObject**)((uint64)obj + ptrOffset);
-  mvm::Collector::objectReferenceNonHeapWriteBarrier((gc**)ptr, (gc*)val);
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)ptr, (gc*)val);
 }
 
 void JavaField::InitStaticField(double val) {
@@ -794,7 +794,7 @@
     }
   }
 
-  mvm::BumpPtrAllocator& allocator = classLoader->allocator;
+  vmkit::BumpPtrAllocator& allocator = classLoader->allocator;
   virtualVT = new(allocator, virtualTableSize) JavaVirtualTable(this);
 }
 
@@ -818,7 +818,7 @@
 
 void Class::readMethods(Reader& reader) {
   uint16 nbMethods = reader.readU2();
-  mvm::ThreadAllocator allocator;
+  vmkit::ThreadAllocator allocator;
   if (isAbstract(access)) {
     virtualMethods = (JavaMethod*)
       allocator.Allocate(nbMethods * sizeof(JavaMethod));
@@ -874,7 +874,7 @@
   
   PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "; ", 0);
   PRINT_DEBUG(JNJVM_LOAD, 0, LIGHT_GREEN, "reading ", 0);
-  PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", mvm::PrintBuffer(this).cString());
+  PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", vmkit::PrintBuffer(this).cString());
 
   Reader reader(bytes);
   uint32 magic;
@@ -1025,7 +1025,7 @@
   JavaObject** obj = &(delegatee[0]);
   classLoader->lock.lock();
   if (*obj == NULL) {
-    mvm::Collector::objectReferenceNonHeapWriteBarrier((gc**)obj, (gc*)val);
+    vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)obj, (gc*)val);
   }
   classLoader->lock.unlock();
   return getDelegatee();
@@ -1401,7 +1401,7 @@
       outOfDepth = 1;
     }
 
-    mvm::BumpPtrAllocator& allocator = C->classLoader->allocator;
+    vmkit::BumpPtrAllocator& allocator = C->classLoader->allocator;
     secondaryTypes = (JavaVirtualTable**)
       allocator.Allocate(sizeof(JavaVirtualTable*) * nbSecondaryTypes,
                          "Secondary types");  
@@ -1525,7 +1525,7 @@
         if (intf || depth != getDisplayLength()) addSuper = 1;
       }
         
-      mvm::BumpPtrAllocator& allocator = JCL->allocator;
+      vmkit::BumpPtrAllocator& allocator = JCL->allocator;
 
       if (!newSecondaryTypes) {
         if (base->nbInterfaces || addSuper) {
@@ -1619,7 +1619,7 @@
       offset = getCacheIndex() + 2;
       nbSecondaryTypes = 2;
       
-      mvm::BumpPtrAllocator& allocator = JCL->allocator;
+      vmkit::BumpPtrAllocator& allocator = JCL->allocator;
       secondaryTypes = (JavaVirtualTable**)
         allocator.Allocate(sizeof(JavaVirtualTable*) * nbSecondaryTypes,
                            "Secondary types");
@@ -1693,7 +1693,7 @@
   }
 }
 
-uint16 JavaMethod::lookupLineNumber(mvm::FrameInfo* info) {
+uint16 JavaMethod::lookupLineNumber(vmkit::FrameInfo* info) {
   Attribut* codeAtt = lookupAttribut(Attribut::codeAttribut);      
   if (codeAtt == NULL) return 0;
   Reader reader(codeAtt, classDef->bytes);
@@ -1723,7 +1723,7 @@
   return 0;
 }
 
-uint16 JavaMethod::lookupCtpIndex(mvm::FrameInfo* FI) {
+uint16 JavaMethod::lookupCtpIndex(vmkit::FrameInfo* FI) {
   Attribut* codeAtt = lookupAttribut(Attribut::codeAttribut);
   Reader reader(codeAtt, classDef->bytes);
   reader.cursor = reader.cursor + 2 + 2 + 4 + FI->SourceIndex + 1;
@@ -1765,7 +1765,7 @@
   if (val != NULL) assert(val->getVirtualTable());
   assert(classDef->isResolved());
   JavaObject** ptr = (JavaObject**)((uint64)obj + ptrOffset);
-  mvm::Collector::objectReferenceWriteBarrier((gc*)obj, (gc**)ptr, (gc*)val);
+  vmkit::Collector::objectReferenceWriteBarrier((gc*)obj, (gc**)ptr, (gc*)val);
 }
 
 void JavaField::setStaticObjectField(JavaObject* val) {
@@ -1773,5 +1773,5 @@
   if (val != NULL) assert(val->getVirtualTable());
   assert(classDef->isResolved());
   JavaObject** ptr = (JavaObject**)((uint64)classDef->getStaticInstance() + ptrOffset);
-  mvm::Collector::objectReferenceNonHeapWriteBarrier((gc**)ptr, (gc*)val);
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)ptr, (gc*)val);
 }

Modified: vmkit/trunk/lib/J3/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaClass.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaClass.h Mon Nov 21 05:03:32 2011
@@ -73,7 +73,7 @@
 /// Attribut - This class represents JVM attributes to Java class, methods and
 /// fields located in the .class file.
 ///
-class Attribut : public mvm::PermanentObject {
+class Attribut : public vmkit::PermanentObject {
 public:
   
   /// name - The name of the attribut. These are specified in the JVM book.
@@ -156,7 +156,7 @@
 /// object that stays in memory has a reference to the class. Same for
 /// super or interfaces.
 ///
-class CommonClass : public mvm::PermanentObject {
+class CommonClass : public vmkit::PermanentObject {
 
 public:
   
@@ -436,7 +436,7 @@
   
   /// ownerClass - Who is initializing this class.
   ///
-  mvm::Thread* ownerClass;
+  vmkit::Thread* ownerClass;
   
   /// bytes - The .class file of this class.
   ///
@@ -496,13 +496,13 @@
 
   /// getOwnerClass - Get the thread that is currently initializing the class.
   ///
-  mvm::Thread* getOwnerClass() const {
+  vmkit::Thread* getOwnerClass() const {
     return ownerClass;
   }
 
   /// setOwnerClass - Set the thread that is currently initializing the class.
   ///
-  void setOwnerClass(mvm::Thread* th) {
+  void setOwnerClass(vmkit::Thread* th) {
     ownerClass = th;
   }
  
@@ -822,7 +822,7 @@
 
 /// JavaMethod - This class represents Java methods.
 ///
-class JavaMethod : public mvm::PermanentObject {
+class JavaMethod : public vmkit::PermanentObject {
 private:
 
   /// _signature - The signature of this method. Null if not resolved.
@@ -899,12 +899,12 @@
 
   /// lookupLineNumber - Find the line number based on the given frame info.
   ///
-  uint16 lookupLineNumber(mvm::FrameInfo* FI);
+  uint16 lookupLineNumber(vmkit::FrameInfo* FI);
   
   /// lookupCtpIndex - Lookup the constant pool index pointed by the opcode
   /// related to the given frame info.
   ///
-  uint16 lookupCtpIndex(mvm::FrameInfo* FI);
+  uint16 lookupCtpIndex(vmkit::FrameInfo* FI);
   
   /// getSignature - Get the signature of thes method, resolving it if
   /// necessary.
@@ -1079,7 +1079,7 @@
 
 /// JavaField - This class represents a Java field.
 ///
-class JavaField  : public mvm::PermanentObject {
+class JavaField  : public vmkit::PermanentObject {
 private:
   /// _signature - The signature of the field. Null if not resolved.
   ///

Modified: vmkit/trunk/lib/J3/VMCore/JavaConstantPool.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaConstantPool.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaConstantPool.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaConstantPool.cpp Mon Nov 21 05:03:32 2011
@@ -155,7 +155,7 @@
 
 
 void*
-JavaConstantPool::operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
+JavaConstantPool::operator new(size_t sz, vmkit::BumpPtrAllocator& allocator,
                                uint32 ctpSize) {
   uint32 size = sz + ctpSize * (sizeof(void*) + sizeof(sint32) + sizeof(uint8));
   return allocator.Allocate(size, "Constant pool");
@@ -188,7 +188,7 @@
   }
   
   if (!ctpRes[entry]) {
-    mvm::ThreadAllocator allocator;
+    vmkit::ThreadAllocator allocator;
     Reader reader(classDef->bytes, ctpDef[entry]);
     uint32 len = reader.readU2();
     uint16* buf = (uint16*)allocator.Allocate(len * sizeof(uint16));

Modified: vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h Mon Nov 21 05:03:32 2011
@@ -29,7 +29,7 @@
 /// JavaConstantPool - This class represents a Java constant pool, a place where
 /// a Java class makes external references such as classes and methods and
 /// stores constants such as integers or UTF8s.
-class JavaConstantPool : public mvm::PermanentObject {
+class JavaConstantPool : public vmkit::PermanentObject {
 public:
   
   /// classDef - The owning class of this constant pool.
@@ -56,7 +56,7 @@
   
   /// operator new - Redefine the operator to allocate the arrays of a
   /// constant pool inline.
-  void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
+  void* operator new(size_t sz, vmkit::BumpPtrAllocator& allocator,
                      uint32 ctpSize);
 
   /// CtpReaderClass - Reads a class entry.

Modified: vmkit/trunk/lib/J3/VMCore/JavaMetaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaMetaJIT.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaMetaJIT.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaMetaJIT.cpp Mon Nov 21 05:03:32 2011
@@ -72,7 +72,7 @@
   llvm_gcroot(obj, 0); \
   verifyNull(obj); \
   Signdef* sign = getSignature(); \
-  mvm::ThreadAllocator allocator; \
+  vmkit::ThreadAllocator allocator; \
   jvalue* buf = (jvalue*)allocator.Allocate(sign->nbArguments * sizeof(jvalue)); \
   readArgs(buf, sign, ap, jni); \
   return invoke##TYPE_NAME##VirtualBuf(vm, cl, obj, buf); \
@@ -82,7 +82,7 @@
   llvm_gcroot(obj, 0); \
   verifyNull(obj); \
   Signdef* sign = getSignature(); \
-  mvm::ThreadAllocator allocator; \
+  vmkit::ThreadAllocator allocator; \
   jvalue* buf = (jvalue*)allocator.Allocate(sign->nbArguments * sizeof(jvalue)); \
   readArgs(buf, sign, ap, jni); \
   return invoke##TYPE_NAME##SpecialBuf(vm, cl, obj, buf); \
@@ -90,7 +90,7 @@
 \
 TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, UserClass* cl, va_list ap) {\
   Signdef* sign = getSignature(); \
-  mvm::ThreadAllocator allocator; \
+  vmkit::ThreadAllocator allocator; \
   jvalue* buf = (jvalue*)allocator.Allocate(sign->nbArguments * sizeof(jvalue)); \
   readArgs(buf, sign, ap, jni); \
   return invoke##TYPE_NAME##StaticBuf(vm, cl, buf); \

Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaObject.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaObject.cpp Mon Nov 21 05:03:32 2011
@@ -22,21 +22,21 @@
 
 using namespace j3;
 
-static const int hashCodeIncrement = mvm::GCBitMask + 1;
+static const int hashCodeIncrement = vmkit::GCBitMask + 1;
 uint16_t JavaObject::hashCodeGenerator = hashCodeIncrement;
-static const uint64_t HashMask = ((1 << mvm::HashBits) - 1) << mvm::GCBits;
+static const uint64_t HashMask = ((1 << vmkit::HashBits) - 1) << vmkit::GCBits;
 
 
 /// hashCode - Return the hash code of this object.
 uint32_t JavaObject::hashCode(JavaObject* self) {
   llvm_gcroot(self, 0);
-  if (!mvm::MovesObject) return (uint32_t)(long)self;
+  if (!vmkit::MovesObject) return (uint32_t)(long)self;
   assert(HashMask != 0);
-  assert(mvm::HashBits != 0);
+  assert(vmkit::HashBits != 0);
 
   word_t header = self->header;
   word_t GCBits;
-  GCBits = header & mvm::GCBitMask;
+  GCBits = header & vmkit::GCBitMask;
   word_t val = header & HashMask;
   if (val != 0) {
     return val ^ (word_t)getClass(self);
@@ -50,7 +50,7 @@
     val = hashCodeIncrement;
     hashCodeGenerator += hashCodeIncrement;
   }
-  assert(val > mvm::GCBitMask);
+  assert(val > vmkit::GCBitMask);
   assert(val <= HashMask);
 
   do {
@@ -62,7 +62,7 @@
   } while (true);
 
   assert((self->header & HashMask) != 0);
-  assert(GCBits == (self->header & mvm::GCBitMask));
+  assert(GCBits == (self->header & vmkit::GCBitMask));
   return (self->header & HashMask) ^ (word_t)getClass(self);
 }
 
@@ -71,7 +71,7 @@
     JavaObject* self, struct timeval* info, bool timed) {
   llvm_gcroot(self, 0);
   JavaThread* thread = JavaThread::get();
-  mvm::LockSystem& table = thread->getJVM()->lockSystem;
+  vmkit::LockSystem& table = thread->getJVM()->lockSystem;
 
   if (!owner(self)) {
     thread->getJVM()->illegalMonitorStateException(self);
@@ -121,7 +121,7 @@
 void JavaObject::notify(JavaObject* self) {
   llvm_gcroot(self, 0);
   JavaThread* thread = JavaThread::get();
-  mvm::LockSystem& table = thread->getJVM()->lockSystem;
+  vmkit::LockSystem& table = thread->getJVM()->lockSystem;
 
   if (!owner(self)) {
     thread->getJVM()->illegalMonitorStateException(self);
@@ -133,7 +133,7 @@
 void JavaObject::notifyAll(JavaObject* self) {
   llvm_gcroot(self, 0);
   JavaThread* thread = JavaThread::get();
-  mvm::LockSystem& table = thread->getJVM()->lockSystem;
+  vmkit::LockSystem& table = thread->getJVM()->lockSystem;
 
   if (!owner(self)) {
     thread->getJVM()->illegalMonitorStateException(self);
@@ -183,7 +183,7 @@
         if (field.isReference()) {
           tmp = field.getInstanceObjectField(src);
           JavaObject** ptr = field.getInstanceObjectFieldPtr(res);
-          mvm::Collector::objectReferenceWriteBarrier((gc*)res, (gc**)ptr, (gc*)tmp);
+          vmkit::Collector::objectReferenceWriteBarrier((gc*)res, (gc**)ptr, (gc*)tmp);
         } else if (field.isLong()) {
           field.setInstanceLongField(res, field.getInstanceLongField(src));
         } else if (field.isDouble()) {
@@ -209,22 +209,22 @@
 
 void JavaObject::overflowThinLock(JavaObject* self) {
   llvm_gcroot(self, 0);
-  mvm::ThinLock::overflowThinLock(self, JavaThread::get()->getJVM()->lockSystem);
+  vmkit::ThinLock::overflowThinLock(self, JavaThread::get()->getJVM()->lockSystem);
 }
 
 void JavaObject::acquire(JavaObject* self) {
   llvm_gcroot(self, 0);
-  mvm::ThinLock::acquire(self, JavaThread::get()->getJVM()->lockSystem);
+  vmkit::ThinLock::acquire(self, JavaThread::get()->getJVM()->lockSystem);
 }
 
 void JavaObject::release(JavaObject* self) {
   llvm_gcroot(self, 0);
-  mvm::ThinLock::release(self, JavaThread::get()->getJVM()->lockSystem);
+  vmkit::ThinLock::release(self, JavaThread::get()->getJVM()->lockSystem);
 }
 
 bool JavaObject::owner(JavaObject* self) {
   llvm_gcroot(self, 0);
-  return mvm::ThinLock::owner(self, JavaThread::get()->getJVM()->lockSystem);
+  return vmkit::ThinLock::owner(self, JavaThread::get()->getJVM()->lockSystem);
 }
 
 void JavaObject::decapsulePrimitive(JavaObject* obj, Jnjvm *vm, jvalue* buf,

Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaObject.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaObject.h Mon Nov 21 05:03:32 2011
@@ -30,12 +30,12 @@
 class Typedef;
 class UserCommonClass;
 
-class InterfaceMethodTable : public mvm::PermanentObject {
+class InterfaceMethodTable : public vmkit::PermanentObject {
 public:
 	static const uint32_t NumIndexes = 29;
 	word_t contents[NumIndexes];
 
-  static uint32_t getIndex(const mvm::UTF8* name, const mvm::UTF8* type) {
+  static uint32_t getIndex(const vmkit::UTF8* name, const vmkit::UTF8* type) {
     return (name->hash() + type->hash()) % NumIndexes;
   }
 };
@@ -107,7 +107,7 @@
   /// size must contain the additional information for type checking, as well
   /// as the function pointers.
   ///
-  void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
+  void* operator new(size_t sz, vmkit::BumpPtrAllocator& allocator,
                      uint32 nbMethods) {
     return allocator.Allocate(sizeof(word_t) * (nbMethods), "Virtual table");
   }

Modified: vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp Mon Nov 21 05:03:32 2011
@@ -224,7 +224,7 @@
 
   va_list ap;
   va_start(ap, len);
-  mvm::ThreadAllocator allocator;
+  vmkit::ThreadAllocator allocator;
   sint32* dims = (sint32*)allocator.Allocate(sizeof(sint32) * len);
   for (uint32 i = 0; i < len; ++i){
     dims[i] = va_arg(ap, int);
@@ -268,13 +268,13 @@
 
 extern "C" word_t j3StartJNI(uint32* localReferencesNumber,
                                uint32** oldLocalReferencesNumber,
-                               mvm::KnownFrame* Frame) 
+                               vmkit::KnownFrame* Frame) 
   __attribute__((noinline));
 
 // Never throws. Does not call Java code. Can not yield a GC. May join a GC.
 extern "C" word_t j3StartJNI(uint32* localReferencesNumber,
                                uint32** oldLocalReferencesNumber,
-                               mvm::KnownFrame* Frame) {
+                               vmkit::KnownFrame* Frame) {
   
   JavaThread* th = JavaThread::get();
  
@@ -370,9 +370,9 @@
   void* result = NULL;
   
   // Lookup the caller of this class.
-  mvm::StackWalker Walker(th);
+  vmkit::StackWalker Walker(th);
   ++Walker; // Remove the stub.
-  mvm::FrameInfo* FI = Walker.get();
+  vmkit::FrameInfo* FI = Walker.get();
   assert(FI->Metadata != NULL && "Wrong stack trace");
   JavaMethod* meth = (JavaMethod*)FI->Metadata;
 
@@ -430,9 +430,9 @@
   void* result = NULL;
 
   // Lookup the caller of this class.
-  mvm::StackWalker Walker(th);
+  vmkit::StackWalker Walker(th);
   ++Walker; // Remove the stub.
-  mvm::FrameInfo* FI = Walker.get();
+  vmkit::FrameInfo* FI = Walker.get();
   assert(FI->Metadata != NULL && "Wrong stack trace");
   JavaMethod* caller = (JavaMethod*)FI->Metadata;
 
@@ -463,9 +463,9 @@
   void* result = NULL;
 
   // Lookup the caller of this class.
-  mvm::StackWalker Walker(th);
+  vmkit::StackWalker Walker(th);
   ++Walker; // Remove the stub.
-  mvm::FrameInfo* FI = Walker.get();
+  vmkit::FrameInfo* FI = Walker.get();
   assert(FI->Metadata != NULL && "Wrong stack trace");
   JavaMethod* caller = (JavaMethod*)FI->Metadata;
 
@@ -525,20 +525,20 @@
 }
 
 extern "C" void j3PrintMethodStart(JavaMethod* meth) {
-  fprintf(stderr, "[%p] executing %s.%s\n", (void*)mvm::Thread::get(),
+  fprintf(stderr, "[%p] executing %s.%s\n", (void*)vmkit::Thread::get(),
           UTF8Buffer(meth->classDef->name).cString(),
           UTF8Buffer(meth->name).cString());
 }
 
 extern "C" void j3PrintMethodEnd(JavaMethod* meth) {
-  fprintf(stderr, "[%p] return from %s.%s\n", (void*)mvm::Thread::get(),
+  fprintf(stderr, "[%p] return from %s.%s\n", (void*)vmkit::Thread::get(),
           UTF8Buffer(meth->classDef->name).cString(),
           UTF8Buffer(meth->name).cString());
 }
 
 extern "C" void j3PrintExecution(uint32 opcode, uint32 index,
                                     JavaMethod* meth) {
-  fprintf(stderr, "[%p] executing %s.%s %s at %d\n", (void*)mvm::Thread::get(),
+  fprintf(stderr, "[%p] executing %s.%s %s at %d\n", (void*)vmkit::Thread::get(),
          UTF8Buffer(meth->classDef->name).cString(),
          UTF8Buffer(meth->name).cString(),
          OpcodeNames[opcode], index);

Modified: vmkit/trunk/lib/J3/VMCore/JavaString.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaString.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaString.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaString.cpp Mon Nov 21 05:03:32 2011
@@ -57,7 +57,7 @@
 }
 
 char* JavaString::strToAsciiz(JavaString* self,
-                              mvm::ThreadAllocator* allocator) {
+                              vmkit::ThreadAllocator* allocator) {
   const ArrayUInt16* value = NULL;
   llvm_gcroot(self, 0);
   llvm_gcroot(value, 0);
@@ -127,7 +127,7 @@
   llvm_gcroot(value, 0);
   value = JavaString::getValue(self);
  
-  mvm::ThreadAllocator allocator; 
+  vmkit::ThreadAllocator allocator; 
   uint16* java = (uint16*)allocator.Allocate(self->count * sizeof(uint16));
 
   for (sint32 i = 0; i < self->count; ++i) {

Modified: vmkit/trunk/lib/J3/VMCore/JavaString.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaString.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaString.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaString.h Mon Nov 21 05:03:32 2011
@@ -39,7 +39,7 @@
   static void setValue(JavaString* self, const ArrayUInt16* array) {
     llvm_gcroot(self, 0);
     llvm_gcroot(array, 0);
-    mvm::Collector::objectReferenceWriteBarrier(
+    vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)self, (gc**)&(self->value), (gc*)array);
   }
   static const ArrayUInt16* getValue(const JavaString* self) {
@@ -58,7 +58,7 @@
 
   static void stringDestructor(JavaString*);
   static char* strToAsciiz(JavaString* self);
-  static char* strToAsciiz(JavaString* self, mvm::ThreadAllocator* allocator);
+  static char* strToAsciiz(JavaString* self, vmkit::ThreadAllocator* allocator);
   static const ArrayUInt16* strToArray(JavaString* self, Jnjvm* vm);
 
   /// javaToInternal - Replaces all '/' into '.'.

Modified: vmkit/trunk/lib/J3/VMCore/JavaThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaThread.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaThread.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaThread.cpp Mon Nov 21 05:03:32 2011
@@ -67,10 +67,10 @@
 }
 
 uint32 JavaThread::getJavaFrameContext(void** buffer) {
-  mvm::StackWalker Walker(this);
+  vmkit::StackWalker Walker(this);
   uint32 i = 0;
 
-  while (mvm::FrameInfo* FI = Walker.get()) {
+  while (vmkit::FrameInfo* FI = Walker.get()) {
     if (FI->Metadata != NULL) {
       JavaMethod* M = (JavaMethod*)FI->Metadata;
       buffer[i++] = M;
@@ -81,10 +81,10 @@
 }
 
 JavaMethod* JavaThread::getCallingMethodLevel(uint32 level) {
-  mvm::StackWalker Walker(this);
+  vmkit::StackWalker Walker(this);
   uint32 index = 0;
 
-  while (mvm::FrameInfo* FI = Walker.get()) {
+  while (vmkit::FrameInfo* FI = Walker.get()) {
     if (FI->Metadata != NULL) {
       if (index == level) {
         return (JavaMethod*)FI->Metadata;
@@ -107,9 +107,9 @@
   JavaObject* obj = 0;
   llvm_gcroot(obj, 0);
   
-  mvm::StackWalker Walker(this);
+  vmkit::StackWalker Walker(this);
 
-  while (mvm::FrameInfo* FI = Walker.get()) {
+  while (vmkit::FrameInfo* FI = Walker.get()) {
     if (FI->Metadata != NULL) {
       JavaMethod* meth = (JavaMethod*)FI->Metadata;
       JnjvmClassLoader* loader = meth->classDef->classLoader;
@@ -123,9 +123,9 @@
 
 
 void JavaThread::printJavaBacktrace() {
-  mvm::StackWalker Walker(this);
+  vmkit::StackWalker Walker(this);
 
-  while (mvm::FrameInfo* FI = Walker.get()) {
+  while (vmkit::FrameInfo* FI = Walker.get()) {
     if (FI->Metadata != NULL) {
       MyVM->printMethod(FI, Walker.ip, Walker.addr);
     }

Modified: vmkit/trunk/lib/J3/VMCore/JavaThread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaThread.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaThread.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaThread.h Mon Nov 21 05:03:32 2011
@@ -35,7 +35,7 @@
   JavaThread* th = JavaThread::get(); \
   word_t SP = th->getLastSP(); \
   th->leaveUncooperativeCode(); \
-  mvm::KnownFrame Frame; \
+  vmkit::KnownFrame Frame; \
   th->startKnownFrame(Frame); \
   TRY {
 
@@ -59,7 +59,7 @@
 /// It maintains thread-specific information such as its state, the current
 /// exception if there is one, the layout of the stack, etc.
 ///
-class JavaThread : public mvm::MutatorThread {
+class JavaThread : public vmkit::MutatorThread {
 public:
   
   /// jniEnv - The JNI environment of the thread.
@@ -78,7 +78,7 @@
   ///
   JavaObject* vmThread;
 
-  mvm::LockingThread lockingThread;
+  vmkit::LockingThread lockingThread;
   
   /// currentAddedReferences - Current number of added local references.
   ///
@@ -120,7 +120,7 @@
   /// get - Get the current thread as a J3 object.
   ///
   static JavaThread* get() {
-    return (JavaThread*)mvm::Thread::get();
+    return (JavaThread*)vmkit::Thread::get();
   }
 
   /// getJVM - Get the Java VM in which this thread executes.

Modified: vmkit/trunk/lib/J3/VMCore/JavaTypes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaTypes.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaTypes.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaTypes.cpp Mon Nov 21 05:03:32 2011
@@ -59,7 +59,7 @@
 
 word_t Signdef::staticCallBuf() {
   if (!_staticCallBuf) {
-    mvm::ThreadAllocator allocator;
+    vmkit::ThreadAllocator allocator;
     char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
     nativeName(buf, "static_buf");
     bool unused = false;
@@ -75,7 +75,7 @@
 
 word_t Signdef::virtualCallBuf() {
   if (!_virtualCallBuf) {
-    mvm::ThreadAllocator allocator;
+    vmkit::ThreadAllocator allocator;
     char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
     nativeName(buf, "virtual_buf");
     bool unused = false;
@@ -91,7 +91,7 @@
 
 word_t Signdef::staticCallAP() {
   if (!_staticCallAP) {
-    mvm::ThreadAllocator allocator;
+    vmkit::ThreadAllocator allocator;
     char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
     nativeName(buf, "static_ap");
     bool unused = false;
@@ -107,7 +107,7 @@
 
 word_t Signdef::virtualCallAP() {
   if (!_virtualCallAP) {
-    mvm::ThreadAllocator allocator;
+    vmkit::ThreadAllocator allocator;
     char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
     nativeName(buf, "virtual_ap");
     bool unused = false;
@@ -123,7 +123,7 @@
 
 word_t Signdef::virtualCallStub() {
   if (!_virtualCallAP) {
-    mvm::ThreadAllocator allocator;
+    vmkit::ThreadAllocator allocator;
     char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
     nativeName(buf, "virtual_stub");
     bool unused = false;
@@ -139,7 +139,7 @@
 
 word_t Signdef::specialCallStub() {
   if (!_specialCallStub) {
-    mvm::ThreadAllocator allocator;
+    vmkit::ThreadAllocator allocator;
     char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
     nativeName(buf, "special_stub");
     bool unused = false;
@@ -155,7 +155,7 @@
 
 word_t Signdef::staticCallStub() {
   if (!_staticCallStub) {
-    mvm::ThreadAllocator allocator;
+    vmkit::ThreadAllocator allocator;
     char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
     nativeName(buf, "static_stub");
     bool unused = false;

Modified: vmkit/trunk/lib/J3/VMCore/JavaTypes.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaTypes.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaTypes.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaTypes.h Mon Nov 21 05:03:32 2011
@@ -55,7 +55,7 @@
 /// which has not been loaded yet. Typedefs are hashed on the name of the class.
 /// Hashing is for memory purposes, not for comparison.
 ///
-class Typedef : public mvm::PermanentObject {
+class Typedef : public vmkit::PermanentObject {
 public:
   
   /// keyName - The name of the Typedef. It is the representation of a class
@@ -274,7 +274,7 @@
 /// Java signature. Signdefs are hashed for memory purposes, not equality
 /// purposes.
 ///
-class Signdef : public mvm::PermanentObject {
+class Signdef : public vmkit::PermanentObject {
 private:
   
   /// _staticCallBuf - A dynamically generated method which calls a static Java
@@ -336,7 +336,7 @@
   /// operator new - Redefines the new operator of this class to allocate
   /// the arguments in the object itself.
   ///
-  void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
+  void* operator new(size_t sz, vmkit::BumpPtrAllocator& allocator,
                      sint32 size) {
     return allocator.Allocate(sizeof(Signdef) + size * sizeof(Typedef),
                               "Signdef");

Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp Mon Nov 21 05:03:32 2011
@@ -160,7 +160,7 @@
     
     PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "; ", 0);
     PRINT_DEBUG(JNJVM_LOAD, 0, LIGHT_GREEN, "clinit ", 0);
-    PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", mvm::PrintString(this).cString());
+    PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", vmkit::PrintString(this).cString());
 
     JavaField* fields = cl->getStaticFields();
     for (uint32 i = 0; i < cl->nbStaticFields; ++i) {
@@ -844,7 +844,7 @@
     return;
   }
 
-  mvm::BumpPtrAllocator allocator;
+  vmkit::BumpPtrAllocator allocator;
   ZipArchive* archive = new(allocator, "TempZipArchive")
       ZipArchive(bytes, allocator);
   if (archive->getOfscd() != -1) {
@@ -1005,7 +1005,7 @@
     } else if (!(strcmp(cur, "-verbosegc"))) {
       nyi();
     } else if (!(strcmp(cur, "-verbose:gc"))) {
-      mvm::Collector::verbose = 1;
+      vmkit::Collector::verbose = 1;
     } else if (!(strcmp(cur, "-verbose:jni"))) {
       nyi();
     } else if (!(strcmp(cur, "-version"))) {
@@ -1064,11 +1064,11 @@
   // First create system threads.
   finalizerThread = new FinalizerThread(this);
   finalizerThread->start(
-      (void (*)(mvm::Thread*))FinalizerThread::finalizerStart);
+      (void (*)(vmkit::Thread*))FinalizerThread::finalizerStart);
     
   referenceThread = new ReferenceThread(this);
   referenceThread->start(
-      (void (*)(mvm::Thread*))ReferenceThread::enqueueStart);
+      (void (*)(vmkit::Thread*))ReferenceThread::enqueueStart);
   
   // Initialise the bootstrap class loader if it's not
   // done already.
@@ -1200,7 +1200,7 @@
       method->invokeIntStatic(this, method->classDef, &args);
     } else {
       fprintf(stderr, "Main method not public.\n");
-      mvm::System::Exit(1);
+      vmkit::System::Exit(1);
     }
   } CATCH {
   } END_CATCH;
@@ -1219,7 +1219,7 @@
                       "Can not print stack trace.\n");
     } END_CATCH;
     // Program failed. Exit with return code not 0.
-    mvm::System::Exit(1);
+    vmkit::System::Exit(1);
   }
 }
 
@@ -1303,7 +1303,7 @@
 void ThreadSystem::leave() {
   nonDaemonLock.lock();
   --nonDaemonThreads;
-  if (nonDaemonThreads == 0) mvm::Thread::get()->MyVM->exit();
+  if (nonDaemonThreads == 0) vmkit::Thread::get()->MyVM->exit();
   nonDaemonLock.unlock();  
 }
 
@@ -1317,11 +1317,11 @@
   argumentsInfo.argc = argc;
   argumentsInfo.argv = argv;
   mainThread = new JavaThread(this);
-  mainThread->start((void (*)(mvm::Thread*))mainJavaStart);
+  mainThread->start((void (*)(vmkit::Thread*))mainJavaStart);
 }
 
-Jnjvm::Jnjvm(mvm::BumpPtrAllocator& Alloc,
-             mvm::CompiledFrames** frames,
+Jnjvm::Jnjvm(vmkit::BumpPtrAllocator& Alloc,
+             vmkit::CompiledFrames** frames,
              JnjvmBootstrapLoader* loader) : 
   VirtualMachine(Alloc, frames), lockSystem(Alloc) {
 
@@ -1436,15 +1436,15 @@
 
 // Helper function to run J3 without JIT.
 extern "C" int StartJnjvmWithoutJIT(int argc, char** argv, char* mainClass) {
-  mvm::Collector::initialise(argc, argv);
+  vmkit::Collector::initialise(argc, argv);
  
-  mvm::ThreadAllocator allocator; 
+  vmkit::ThreadAllocator allocator; 
   char** newArgv = (char**)allocator.Allocate((argc + 1) * sizeof(char*));
   memcpy(newArgv + 1, argv, argc * sizeof(char*));
   newArgv[0] = newArgv[1];
   newArgv[1] = mainClass;
  
-  mvm::BumpPtrAllocator Allocator;
+  vmkit::BumpPtrAllocator Allocator;
   JavaCompiler* Comp = new JavaCompiler();
   JnjvmBootstrapLoader* loader = new(Allocator, "Bootstrap loader")
     JnjvmBootstrapLoader(Allocator, Comp, true);
@@ -1456,9 +1456,9 @@
   return 0; 
 }
 
-void Jnjvm::printMethod(mvm::FrameInfo* FI, word_t ip, word_t addr) {
+void Jnjvm::printMethod(vmkit::FrameInfo* FI, word_t ip, word_t addr) {
   if (FI->Metadata == NULL) {
-    mvm::MethodInfoHelper::print(ip, addr);
+    vmkit::MethodInfoHelper::print(ip, addr);
     return;
   }
   JavaMethod* meth = (JavaMethod*)FI->Metadata;

Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.h Mon Nov 21 05:03:32 2011
@@ -59,7 +59,7 @@
 
   /// nonDaemonLock - Protection lock for the nonDaemonThreads variable.
   ///
-  mvm::SpinLock nonDaemonLock;
+  vmkit::SpinLock nonDaemonLock;
 
   /// ThreadSystem - Allocates a thread system management, initializing the
   /// lock, the condition variable and setting the initial number of non
@@ -104,7 +104,7 @@
 
 /// Jnjvm - A JVM. Each execution of a program allocates a Jnjvm.
 ///
-class Jnjvm : public mvm::VirtualMachine {
+class Jnjvm : public vmkit::VirtualMachine {
   friend class JnjvmClassLoader;
 public:
   /// throwable - The java/lang/Throwable class. In an isolate
@@ -130,7 +130,7 @@
   virtual void addFinalizationCandidate(gc* obj);
   virtual size_t getObjectSize(gc* obj);
   virtual const char* getObjectTypeName(gc* obj);
-  virtual void printMethod(mvm::FrameInfo* FI, word_t ip, word_t addr);
+  virtual void printMethod(vmkit::FrameInfo* FI, word_t ip, word_t addr);
 
 
   /// CreateError - Creates a Java object of the specified exception class
@@ -209,7 +209,7 @@
   
   /// lockSystem - The lock system to allocate and manage Java locks.
   ///
-  mvm::LockSystem lockSystem;
+  vmkit::LockSystem lockSystem;
   
   /// argumentsInfo - The command line arguments given to the vm
   ///
@@ -237,7 +237,7 @@
 
   /// globalRefsLock - Lock for adding a new global reference.
   ///
-  mvm::LockNormal globalRefsLock;
+  vmkit::LockNormal globalRefsLock;
   
   /// appClassLoader - The bootstrap class loader.
   ///
@@ -338,8 +338,8 @@
 
   /// Jnjvm - Allocates a new JVM.
   ///
-  Jnjvm(mvm::BumpPtrAllocator& Alloc,
-        mvm::CompiledFrames** frames,
+  Jnjvm(vmkit::BumpPtrAllocator& Alloc,
+        vmkit::CompiledFrames** frames,
         JnjvmBootstrapLoader* loader);
   
   /// runApplication - Runs the application with the given command line.

Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp Mon Nov 21 05:03:32 2011
@@ -50,7 +50,7 @@
 const UTF8* JavaCompiler::NoInlinePragma = 0;
 
 
-JnjvmBootstrapLoader::JnjvmBootstrapLoader(mvm::BumpPtrAllocator& Alloc,
+JnjvmBootstrapLoader::JnjvmBootstrapLoader(vmkit::BumpPtrAllocator& Alloc,
                                            JavaCompiler* Comp, 
                                            bool dlLoad) : 
     JnjvmClassLoader(Alloc) {
@@ -162,7 +162,7 @@
   clinitType = asciizConstructUTF8("()V");
   runName = asciizConstructUTF8("run");
   prelib = asciizConstructUTF8("lib");
-  postlib = asciizConstructUTF8(mvm::System::GetDyLibExtension());
+  postlib = asciizConstructUTF8(vmkit::System::GetDyLibExtension());
   mathName = asciizConstructUTF8("java/lang/Math");
   VMFloatName = asciizConstructUTF8("java/lang/VMFloat");
   VMDoubleName = asciizConstructUTF8("java/lang/VMDouble");
@@ -204,7 +204,7 @@
 #undef DEF_UTF8 
 }
 
-JnjvmClassLoader::JnjvmClassLoader(mvm::BumpPtrAllocator& Alloc,
+JnjvmClassLoader::JnjvmClassLoader(vmkit::BumpPtrAllocator& Alloc,
                                    JnjvmClassLoader& JCL, JavaObject* loader,
                                    VMClassLoader* vmdata,
                                    Jnjvm* I) : allocator(Alloc) {
@@ -220,7 +220,7 @@
   strings = new(allocator, "StringList") StringList();
 
   vmdata->JCL = this;
-  mvm::Collector::objectReferenceNonHeapWriteBarrier(
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier(
       (gc**)&javaLoader, (gc*)loader);
   isolate = I;
 
@@ -237,11 +237,11 @@
 }
 
 ClassBytes* JnjvmBootstrapLoader::openName(const UTF8* utf8) {
-  ClassBytes* res = reinterpret_cast<ClassBytes*>(dlsym(mvm::System::GetSelfHandle(),
+  ClassBytes* res = reinterpret_cast<ClassBytes*>(dlsym(vmkit::System::GetSelfHandle(),
       UTF8Buffer(utf8).toCompileName("_bytes")->cString()));
   if (res != NULL) return res;
 
-  mvm::ThreadAllocator threadAllocator;
+  vmkit::ThreadAllocator threadAllocator;
 
   char* asciiz = (char*)threadAllocator.Allocate(utf8->size + 1);
   for (sint32 i = 0; i < utf8->size; ++i) 
@@ -440,7 +440,7 @@
   if (name->size == 0) {
     return 0;
   } else if (name->elements[0] == I_TAB) {
-    mvm::ThreadAllocator threadAllocator;
+    vmkit::ThreadAllocator threadAllocator;
     bool prim = false;
     UTF8* holder = (UTF8*)threadAllocator.Allocate(
         sizeof(UTF8) + name->size * sizeof(uint16));
@@ -463,7 +463,7 @@
                                                        bool doResolve,
                                                        bool doThrow) {
   const UTF8* name = hashUTF8->lookupAsciiz(asciiz);
-  mvm::ThreadAllocator threadAllocator;
+  vmkit::ThreadAllocator threadAllocator;
   UserCommonClass* result = NULL;
   if (!name) name = bootstrapLoader->hashUTF8->lookupAsciiz(asciiz);
   if (!name) {
@@ -498,7 +498,7 @@
                                           bool doThrow) {
   
   llvm_gcroot(str, 0);
-  mvm::ThreadAllocator allocator; 
+  vmkit::ThreadAllocator allocator; 
   UTF8* name = (UTF8*)allocator.Allocate(sizeof(UTF8) + str->count * sizeof(uint16));
  
   name->size = str->count;
@@ -534,7 +534,7 @@
   llvm_gcroot(str, 0);
   llvm_gcroot(value, 0);
   value = JavaString::getValue(str);
-  mvm::ThreadAllocator allocator; 
+  vmkit::ThreadAllocator allocator; 
   
   UTF8* name = (UTF8*)allocator.Allocate(sizeof(UTF8) + str->count * sizeof(uint16));
   name->size = str->count;
@@ -817,7 +817,7 @@
       (VMClassLoader*)(upcalls->vmdataClassLoader->getInstanceObjectField(loader));
     if (!vmdata || !VMClassLoader::isVMClassLoader(vmdata)) {
       vmdata = VMClassLoader::allocate();
-      mvm::BumpPtrAllocator* A = new mvm::BumpPtrAllocator();
+      vmkit::BumpPtrAllocator* A = new vmkit::BumpPtrAllocator();
       JCL = new(*A, "Class loader") JnjvmClassLoader(*A, *vm->bootstrapLoader,
                                                      loader, vmdata, vm);
       upcalls->vmdataClassLoader->setInstanceObjectField(loader, (JavaObject*)vmdata);
@@ -898,7 +898,7 @@
 
 void JnjvmBootstrapLoader::analyseClasspathEnv(const char* str) {
   ClassBytes* bytes = NULL;
-  mvm::ThreadAllocator threadAllocator;
+  vmkit::ThreadAllocator threadAllocator;
   if (str != 0) {
     unsigned int len = strlen(str);
     char* buf = (char*)threadAllocator.Allocate((len + 1) * sizeof(char));
@@ -952,7 +952,7 @@
   uint32 pos = steps;
   bool isTab = (className->elements[0] == I_TAB ? true : false);
   uint32 n = steps + len + (isTab ? 0 : 2);
-  mvm::ThreadAllocator allocator;
+  vmkit::ThreadAllocator allocator;
   uint16* buf = (uint16*)allocator.Allocate(n * sizeof(uint16));
     
   for (uint32 i = 0; i < steps; i++) {
@@ -981,7 +981,7 @@
   // code dlopen'd something itself (with RTLD_GLOBAL; OpenJDK does this).
   // To handle this, we search both ourselves and the libraries we loaded.
   word_t sym =
-    (word_t)TheCompiler->loadMethod(mvm::System::GetSelfHandle(), buf);
+    (word_t)TheCompiler->loadMethod(vmkit::System::GetSelfHandle(), buf);
 
   // Search loaded libraries as well, both as fallback and to determine
   // whether or not the symbol in question is defined by vmkit.
@@ -1052,7 +1052,7 @@
     return next->addString(JCL, obj);
   } else {
     JCL->lock.lock();
-    mvm::Collector::objectReferenceNonHeapWriteBarrier(
+    vmkit::Collector::objectReferenceNonHeapWriteBarrier(
         (gc**)&(strings[length]), (gc*)obj);
     JavaString** res = &strings[length++];
     JCL->lock.unlock();

Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h Mon Nov 21 05:03:32 2011
@@ -50,7 +50,7 @@
 /// its own tables (signatures, UTF8, types) which are mapped to a single
 /// table for non-isolate environments.
 ///
-class JnjvmClassLoader : public mvm::PermanentObject {
+class JnjvmClassLoader : public vmkit::PermanentObject {
 private:
 
   /// isolate - Which isolate defined me? Null for the bootstrap class loader.
@@ -75,7 +75,7 @@
   /// JnjvmClassLoader - Allocate a user-defined class loader. Called on
   /// first use of a Java class loader.
   ///
-  JnjvmClassLoader(mvm::BumpPtrAllocator& Alloc, JnjvmClassLoader& JCL,
+  JnjvmClassLoader(vmkit::BumpPtrAllocator& Alloc, JnjvmClassLoader& JCL,
                    JavaObject* loader, VMClassLoader* vmdata, Jnjvm* isolate);
 
   /// lookupComponentName - Try to find the component name of the given array
@@ -86,7 +86,7 @@
 
 protected:
   
-  JnjvmClassLoader(mvm::BumpPtrAllocator& Alloc) : allocator(Alloc) {}
+  JnjvmClassLoader(vmkit::BumpPtrAllocator& Alloc) : allocator(Alloc) {}
   
   /// TheCompiler - The Java compiler for this class loader.
   ///
@@ -106,7 +106,7 @@
 
   /// lock - Lock when loading classes.
   ///
-  mvm::LockRecursive lock;
+  vmkit::LockRecursive lock;
 
   /// registeredNatives - Stores the native function pointers corresponding
   /// to methods that were defined through JNI's RegisterNatives mechanism.
@@ -115,14 +115,14 @@
 
   /// nativesLock - Locks the registeredNatives map above
   ///
-  mvm::LockRecursive nativesLock;
+  vmkit::LockRecursive nativesLock;
 
 public:
   
   /// allocator - Reference to the memory allocator, which will allocate UTF8s,
   /// signatures and types.
   ///
-  mvm::BumpPtrAllocator& allocator;
+  vmkit::BumpPtrAllocator& allocator;
  
   /// getIsolate - Returns the isolate that created this class loader.
   ///
@@ -370,7 +370,7 @@
   /// to do before any execution of a JVM. Also try to load libvmjc.so
   /// if dlLoad is not false.
   ///
-  JnjvmBootstrapLoader(mvm::BumpPtrAllocator& Alloc, JavaCompiler* Comp,
+  JnjvmBootstrapLoader(vmkit::BumpPtrAllocator& Alloc, JavaCompiler* Comp,
                        bool dlLoad);
   
   virtual JavaString** UTF8ToStr(const UTF8* utf8);
@@ -512,7 +512,7 @@
 
 #define MAXIMUM_STRINGS 100
 
-class StringList : public mvm::PermanentObject {
+class StringList : public vmkit::PermanentObject {
   friend class JnjvmClassLoader;
   friend class Jnjvm;
 

Modified: vmkit/trunk/lib/J3/VMCore/LinkJavaRuntime.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LinkJavaRuntime.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LinkJavaRuntime.h (original)
+++ vmkit/trunk/lib/J3/VMCore/LinkJavaRuntime.h Mon Nov 21 05:03:32 2011
@@ -23,7 +23,7 @@
   class Jnjvm;
 }
 
-namespace mvm {
+namespace vmkit {
   class KnownFrame;
 }
 
@@ -41,7 +41,7 @@
 extern "C" UserClassArray* j3GetArrayClass(UserCommonClass*,
                                               UserClassArray**);
 extern "C" void j3EndJNI(uint32**);
-extern "C" void* j3StartJNI(uint32*, uint32**, mvm::KnownFrame*);
+extern "C" void* j3StartJNI(uint32*, uint32**, vmkit::KnownFrame*);
 extern "C" void j3JavaObjectAquire(JavaObject* obj);
 extern "C" void j3JavaObjectRelease(JavaObject* obj);
 extern "C" void j3ThrowException(JavaObject* obj);

Modified: vmkit/trunk/lib/J3/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LockedMap.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LockedMap.h (original)
+++ vmkit/trunk/lib/J3/VMCore/LockedMap.h Mon Nov 21 05:03:32 2011
@@ -42,12 +42,12 @@
   bool operator()(const ArrayUInt16 *const s1, const ArrayUInt16 *const s2) const;
 };
 
-class StringMap : public mvm::PermanentObject {
+class StringMap : public vmkit::PermanentObject {
 public:
   typedef std::map<const ArrayUInt16 *const, JavaString*, ltarray16>::iterator iterator;
   typedef JavaString* (*funcCreate)(const ArrayUInt16 *const& V, Jnjvm* vm);
 
-  mvm::LockNormal lock;
+  vmkit::LockNormal lock;
   std::map<const ArrayUInt16 *const, JavaString*, ltarray16,
            std::allocator<std::pair<const ArrayUInt16 *const, JavaString*> > > map;
   
@@ -108,28 +108,28 @@
 };
 
 
-class ClassMap : public mvm::PermanentObject {
+class ClassMap : public vmkit::PermanentObject {
 public:
   ClassMap() {}
-  ClassMap(mvm::VmkitDenseMap<const mvm::UTF8*, UserCommonClass*>* precompiled) : map(*precompiled) {}
+  ClassMap(vmkit::VmkitDenseMap<const vmkit::UTF8*, UserCommonClass*>* precompiled) : map(*precompiled) {}
 
-  mvm::LockRecursive lock;
-  mvm::VmkitDenseMap<const mvm::UTF8*, UserCommonClass*> map;
-  typedef mvm::VmkitDenseMap<const mvm::UTF8*, UserCommonClass*>::iterator iterator;
+  vmkit::LockRecursive lock;
+  vmkit::VmkitDenseMap<const vmkit::UTF8*, UserCommonClass*> map;
+  typedef vmkit::VmkitDenseMap<const vmkit::UTF8*, UserCommonClass*>::iterator iterator;
 };
 
-class TypeMap : public mvm::PermanentObject {
+class TypeMap : public vmkit::PermanentObject {
 public:
-  mvm::LockNormal lock;
-  mvm::VmkitDenseMap<const mvm::UTF8*, Typedef*> map;
-  typedef mvm::VmkitDenseMap<const mvm::UTF8*, Typedef*>::iterator iterator;
+  vmkit::LockNormal lock;
+  vmkit::VmkitDenseMap<const vmkit::UTF8*, Typedef*> map;
+  typedef vmkit::VmkitDenseMap<const vmkit::UTF8*, Typedef*>::iterator iterator;
 };
 
-class SignMap : public mvm::PermanentObject {
+class SignMap : public vmkit::PermanentObject {
 public:
-  mvm::LockNormal lock;
-  mvm::VmkitDenseMap<const mvm::UTF8*, Signdef*> map;
-  typedef mvm::VmkitDenseMap<const mvm::UTF8*, Signdef*>::iterator iterator;
+  vmkit::LockNormal lock;
+  vmkit::VmkitDenseMap<const vmkit::UTF8*, Signdef*> map;
+  typedef vmkit::VmkitDenseMap<const vmkit::UTF8*, Signdef*>::iterator iterator;
 };
 
 } // end namespace j3

Modified: vmkit/trunk/lib/J3/VMCore/Precompiled.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Precompiled.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Precompiled.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Precompiled.cpp Mon Nov 21 05:03:32 2011
@@ -29,7 +29,7 @@
 void JnjvmClassLoader::loadLibFromJar(Jnjvm* vm, const char* name,
                                       const char* file) {
 
-  mvm::ThreadAllocator threadAllocator;
+  vmkit::ThreadAllocator threadAllocator;
   char* soName = (char*)threadAllocator.Allocate(
       strlen(name) + strlen(DYLD_EXTENSION));
   const char* ptr = strrchr(name, '/');
@@ -48,7 +48,7 @@
 
 
 void JnjvmClassLoader::loadLibFromFile(Jnjvm* vm, const char* name) {
-  mvm::ThreadAllocator threadAllocator;
+  vmkit::ThreadAllocator threadAllocator;
   assert(classes->map.size() == 0);
   char* soName = (char*)threadAllocator.Allocate(
       strlen(name) + strlen(DYLD_EXTENSION));
@@ -98,7 +98,7 @@
   sint32 mnlen = jniConsName->size;
   sint32 mtlen = jniConsType->size;
 
-  mvm::ThreadAllocator threadAllocator;
+  vmkit::ThreadAllocator threadAllocator;
   char* buf = (char*)threadAllocator.Allocate(
       3 + JNI_NAME_PRE_LEN + 1 + ((mnlen + clen + mtlen) << 3));
   word_t res = meth->classDef->classLoader->nativeLookup(meth, j3, buf);
@@ -114,7 +114,7 @@
 
 bool Precompiled::Init(JnjvmBootstrapLoader* loader) {
   Class* javaLangObject = (Class*)dlsym(SELF_HANDLE, "java_lang_Object");
-  void* nativeHandle = mvm::System::GetSelfHandle();
+  void* nativeHandle = vmkit::System::GetSelfHandle();
   if (javaLangObject == NULL) {
     void* handle = dlopen("libvmjc"DYLD_EXTENSION, RTLD_LAZY | RTLD_GLOBAL);
     if (handle != NULL) {
@@ -150,12 +150,12 @@
   upcalls->OfLong->classLoader = loader;
   upcalls->OfDouble->classLoader = loader;
 
-  mvm::VmkitDenseSet<mvm::UTF8MapKey, const UTF8*>* precompiledUTF8Map =
-    reinterpret_cast<mvm::VmkitDenseSet<mvm::UTF8MapKey, const UTF8*>*>(dlsym(nativeHandle, "UTF8Map"));
+  vmkit::VmkitDenseSet<vmkit::UTF8MapKey, const UTF8*>* precompiledUTF8Map =
+    reinterpret_cast<vmkit::VmkitDenseSet<vmkit::UTF8MapKey, const UTF8*>*>(dlsym(nativeHandle, "UTF8Map"));
   loader->hashUTF8 = new (loader->allocator, "UTF8Map") UTF8Map(loader->allocator, precompiledUTF8Map);
   
-  mvm::VmkitDenseMap<const UTF8*, CommonClass*>* precompiledClassMap =
-    reinterpret_cast<mvm::VmkitDenseMap<const UTF8*, CommonClass*>*>(dlsym(nativeHandle, "ClassMap"));
+  vmkit::VmkitDenseMap<const UTF8*, CommonClass*>* precompiledClassMap =
+    reinterpret_cast<vmkit::VmkitDenseMap<const UTF8*, CommonClass*>*>(dlsym(nativeHandle, "ClassMap"));
   loader->classes = new (loader->allocator, "ClassMap") ClassMap(precompiledClassMap);
 
   for (ClassMap::iterator i = loader->getClasses()->map.begin(),

Modified: vmkit/trunk/lib/J3/VMCore/Reader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Reader.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Reader.h (original)
+++ vmkit/trunk/lib/J3/VMCore/Reader.h Mon Nov 21 05:03:32 2011
@@ -28,7 +28,7 @@
     size = l;
   }
 
-  void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator, int n) {
+  void* operator new(size_t sz, vmkit::BumpPtrAllocator& allocator, int n) {
     return allocator.Allocate(sizeof(uint32_t) + n * sizeof(uint8_t),
                               "Class bytes");
   }
@@ -59,12 +59,12 @@
   }
 
   static double readDouble(int first, int second) {
-    return mvm::System::ReadDouble(first, second);
+    return vmkit::System::ReadDouble(first, second);
    }
 
 
   static sint64 readLong(int first, int second) {
-    return mvm::System::ReadLong(first, second);
+    return vmkit::System::ReadLong(first, second);
   }
 
   static const int SeekSet;

Modified: vmkit/trunk/lib/J3/VMCore/ReferenceQueue.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/ReferenceQueue.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/ReferenceQueue.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/ReferenceQueue.cpp Mon Nov 21 05:03:32 2011
@@ -40,7 +40,7 @@
   TRY {
     enqueueReference(res);
   } IGNORE;
-  mvm::Thread::get()->clearException();
+  vmkit::Thread::get()->clearException();
 }
 
 void ReferenceThread::enqueueStart(ReferenceThread* th) {
@@ -109,7 +109,7 @@
 }
 
 gc* ReferenceQueue::processReference(gc* reference, ReferenceThread* th, word_t closure) {
-  if (!mvm::Collector::isLive(reference, closure)) {
+  if (!vmkit::Collector::isLive(reference, closure)) {
     clearReferent(reference);
     return NULL;
   }
@@ -123,16 +123,16 @@
   if (semantics == SOFT) {
     // TODO: are we are out of memory? Consider that we always are for now.
     if (false) {
-      mvm::Collector::retainReferent(referent, closure);
+      vmkit::Collector::retainReferent(referent, closure);
     }
   } else if (semantics == PHANTOM) {
     // Nothing to do.
   }
 
   gc* newReference =
-      mvm::Collector::getForwardedReference(reference, closure);
-  if (mvm::Collector::isLive(referent, closure)) {
-    gc* newReferent = mvm::Collector::getForwardedReferent(referent, closure);
+      vmkit::Collector::getForwardedReference(reference, closure);
+  if (vmkit::Collector::isLive(referent, closure)) {
+    gc* newReferent = vmkit::Collector::getForwardedReferent(referent, closure);
     setReferent(newReference, newReferent);
     return newReference;
   } else {
@@ -215,8 +215,8 @@
   for (uint32 i = 0; i < CurrentIndex; ++i) {
     gc* obj = FinalizationQueue[i];
 
-    if (!mvm::Collector::isLive(obj, closure)) {
-      obj = mvm::Collector::retainForFinalize(FinalizationQueue[i], closure);
+    if (!vmkit::Collector::isLive(obj, closure)) {
+      obj = vmkit::Collector::retainForFinalize(FinalizationQueue[i], closure);
       
       if (CurrentFinalizedIndex >= ToBeFinalizedLength)
         growToBeFinalizedQueue();
@@ -225,7 +225,7 @@
       ToBeFinalized[CurrentFinalizedIndex++] = obj;
     } else {
       FinalizationQueue[NewIndex++] =
-        mvm::Collector::getForwardedFinalizable(obj, closure);
+        vmkit::Collector::getForwardedFinalizable(obj, closure);
     }
   }
   CurrentIndex = NewIndex;
@@ -247,7 +247,7 @@
   TRY {
     invokeFinalizer(res);
   } IGNORE;
-  mvm::Thread::get()->clearException();
+  vmkit::Thread::get()->clearException();
 }
 
 void FinalizerThread::finalizerStart(FinalizerThread* th) {

Modified: vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h (original)
+++ vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h Mon Nov 21 05:03:32 2011
@@ -28,7 +28,7 @@
   gc** References;
   uint32 QueueLength;
   uint32 CurrentIndex;
-  mvm::SpinLock QueueLock;
+  vmkit::SpinLock QueueLock;
   uint8_t semantics;
 
   gc* processReference(gc*, ReferenceThread*, word_t closure);
@@ -102,9 +102,9 @@
   
   /// ToEnqueueLock - A lock to protect access to the queue.
   ///
-  mvm::LockNormal EnqueueLock;
-  mvm::Cond EnqueueCond;
-  mvm::SpinLock ToEnqueueLock;
+  vmkit::LockNormal EnqueueLock;
+  vmkit::Cond EnqueueCond;
+  vmkit::SpinLock ToEnqueueLock;
 
   void addToEnqueue(gc* obj);
 
@@ -142,7 +142,7 @@
 public:
     /// FinalizationQueueLock - A lock to protect access to the queue.
   ///
-  mvm::SpinLock FinalizationQueueLock;
+  vmkit::SpinLock FinalizationQueueLock;
 
   /// finalizationQueue - A list of allocated objets that contain a finalize
   /// method.
@@ -181,11 +181,11 @@
   
   /// finalizationCond - Condition variable to wake up finalization threads.
   ///
-  mvm::Cond FinalizationCond;
+  vmkit::Cond FinalizationCond;
 
   /// finalizationLock - Lock for the condition variable.
   ///
-  mvm::LockNormal FinalizationLock;
+  vmkit::LockNormal FinalizationLock;
 
   static void finalizerStart(FinalizerThread*);
 

Modified: vmkit/trunk/lib/J3/VMCore/UTF8.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/UTF8.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/UTF8.h (original)
+++ vmkit/trunk/lib/J3/VMCore/UTF8.h Mon Nov 21 05:03:32 2011
@@ -15,8 +15,8 @@
 #include "vmkit/UTF8.h"
 
 namespace j3 {
-	using mvm::UTF8;
-	using mvm::UTF8Map;
+	using vmkit::UTF8;
+	using vmkit::UTF8Map;
 
 /// UTF8Buffer - Helper class to create char* buffers suitable for
 /// printf.

Modified: vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp Mon Nov 21 05:03:32 2011
@@ -86,7 +86,7 @@
 extern "C" void RegularObjectTracer(JavaObject* obj, word_t closure) {
   Class* cl = JavaObject::getClass(obj)->asClass();
   assert(cl && "Not a class in regular tracer");
-  mvm::Collector::markAndTraceRoot(
+  vmkit::Collector::markAndTraceRoot(
       cl->classLoader->getJavaClassLoaderPtr(), closure);
 
   while (cl->super != 0) {
@@ -94,7 +94,7 @@
       JavaField& field = cl->virtualFields[i];
       if (field.isReference()) {
         JavaObject** ptr = field.getInstanceObjectFieldPtr(obj);
-        mvm::Collector::markAndTrace(obj, ptr, closure);
+        vmkit::Collector::markAndTrace(obj, ptr, closure);
       }
     }
     cl = cl->super;
@@ -106,13 +106,13 @@
 extern "C" void ArrayObjectTracer(ArrayObject* obj, word_t closure) {
   CommonClass* cl = JavaObject::getClass(obj);
   assert(cl && "No class");
-  mvm::Collector::markAndTraceRoot(
+  vmkit::Collector::markAndTraceRoot(
       cl->classLoader->getJavaClassLoaderPtr(), closure);
   
 
   for (sint32 i = 0; i < ArrayObject::getSize(obj); i++) {
     if (ArrayObject::getElement(obj, i) != NULL) {
-      mvm::Collector::markAndTrace(
+      vmkit::Collector::markAndTrace(
           obj, ArrayObject::getElements(obj) + i, closure);
     }
   } 
@@ -123,7 +123,7 @@
     JavaObjectReference* obj, word_t closure) {
   Class* cl = JavaObject::getClass(obj)->asClass();
   assert(cl && "Not a class in reference tracer");
-  mvm::Collector::markAndTraceRoot(
+  vmkit::Collector::markAndTraceRoot(
       cl->classLoader->getJavaClassLoaderPtr(), closure);
 
   bool found = false;
@@ -133,7 +133,7 @@
       if (field.isReference()) {
         JavaObject** ptr = field.getInstanceObjectFieldPtr(obj);
         if (ptr != JavaObjectReference::getReferentPtr(obj)) {
-          mvm::Collector::markAndTrace(obj, ptr, closure);
+          vmkit::Collector::markAndTrace(obj, ptr, closure);
         } else {
           found = true;
         }
@@ -159,24 +159,24 @@
   
   if (super != NULL && super->classLoader != NULL) {
     JavaObject** Obj = super->classLoader->getJavaClassLoaderPtr();
-    if (*Obj != NULL) mvm::Collector::markAndTraceRoot(Obj, closure);
+    if (*Obj != NULL) vmkit::Collector::markAndTraceRoot(Obj, closure);
   
     for (uint32 i = 0; i < nbInterfaces; ++i) {
       if (interfaces[i]->classLoader) {
         JavaObject** Obj = interfaces[i]->classLoader->getJavaClassLoaderPtr();
-        if (*Obj != NULL) mvm::Collector::markAndTraceRoot(Obj, closure);
+        if (*Obj != NULL) vmkit::Collector::markAndTraceRoot(Obj, closure);
       }
     }
   }
 
   if (classLoader != NULL) {
-    mvm::Collector::markAndTraceRoot(
+    vmkit::Collector::markAndTraceRoot(
         classLoader->getJavaClassLoaderPtr(), closure);
   }
 
   for (uint32 i = 0; i < NR_ISOLATES; ++i) {
     if (delegatee[i] != NULL) {
-      mvm::Collector::markAndTraceRoot(delegatee + i, closure);
+      vmkit::Collector::markAndTraceRoot(delegatee + i, closure);
     }
   }
 }
@@ -191,7 +191,7 @@
         JavaField& field = staticFields[i];
         if (field.isReference()) {
           JavaObject** ptr = field.getStaticObjectFieldPtr();
-          mvm::Collector::markAndTraceRoot(ptr, closure);
+          vmkit::Collector::markAndTraceRoot(ptr, closure);
         }
       }
     }
@@ -228,12 +228,12 @@
   while (end != NULL) {
     for (uint32 i = 0; i < end->length; ++i) {
       JavaString** obj = end->strings + i;
-      mvm::Collector::markAndTraceRoot(obj, closure);
+      vmkit::Collector::markAndTraceRoot(obj, closure);
     }
     end = end->prev;
   }
   
-  mvm::Collector::markAndTraceRoot(&javaLoader, closure);
+  vmkit::Collector::markAndTraceRoot(&javaLoader, closure);
 }
 
 void JnjvmBootstrapLoader::tracer(word_t closure) {
@@ -270,7 +270,7 @@
   
   // (2) Trace the application class loader.
   if (appClassLoader != NULL) {
-    mvm::Collector::markAndTraceRoot(
+    vmkit::Collector::markAndTraceRoot(
         appClassLoader->getJavaClassLoaderPtr(), closure);
   }
   
@@ -279,7 +279,7 @@
   while (start != NULL) {
     for (uint32 i = 0; i < start->length; ++i) {
       JavaObject** obj = start->globalReferences + i;
-      mvm::Collector::markAndTraceRoot(obj, closure);
+      vmkit::Collector::markAndTraceRoot(obj, closure);
     }
     start = start->next;
   }
@@ -288,51 +288,51 @@
   for (StringMap::iterator i = hashStr.map.begin(), e = hashStr.map.end();
        i!= e; ++i) {
     JavaString** str = &(i->second);
-    mvm::Collector::markAndTraceRoot(str, closure);
+    vmkit::Collector::markAndTraceRoot(str, closure);
     ArrayUInt16** key = const_cast<ArrayUInt16**>(&(i->first));
-    mvm::Collector::markAndTraceRoot(key, closure);
+    vmkit::Collector::markAndTraceRoot(key, closure);
   }
 
   // (5) Trace the finalization queue.
   for (uint32 i = 0; i < finalizerThread->CurrentFinalizedIndex; ++i) {
-    mvm::Collector::markAndTraceRoot(finalizerThread->ToBeFinalized + i, closure);
+    vmkit::Collector::markAndTraceRoot(finalizerThread->ToBeFinalized + i, closure);
   }
   
   // (6) Trace the reference queue
   for (uint32 i = 0; i < referenceThread->ToEnqueueIndex; ++i) {
-    mvm::Collector::markAndTraceRoot(referenceThread->ToEnqueue + i, closure);
+    vmkit::Collector::markAndTraceRoot(referenceThread->ToEnqueue + i, closure);
   }
  
   // (7) Trace the locks and their associated object.
   uint32 i = 0;
-  for (; i < mvm::LockSystem::GlobalSize; i++) {
-    mvm::FatLock** array = lockSystem.LockTable[i];
+  for (; i < vmkit::LockSystem::GlobalSize; i++) {
+    vmkit::FatLock** array = lockSystem.LockTable[i];
     if (array == NULL) break;
     uint32 j = 0;
-    for (; j < mvm::LockSystem::IndexSize; j++) {
+    for (; j < vmkit::LockSystem::IndexSize; j++) {
       if (array[j] == NULL) break;
-      mvm::FatLock* lock = array[j];
-      mvm::Collector::markAndTraceRoot(lock->getAssociatedObjectPtr(), closure);
+      vmkit::FatLock* lock = array[j];
+      vmkit::Collector::markAndTraceRoot(lock->getAssociatedObjectPtr(), closure);
     }
-    for (j = j + 1; j < mvm::LockSystem::IndexSize; j++) {
+    for (j = j + 1; j < vmkit::LockSystem::IndexSize; j++) {
       assert(array[j] == NULL);
     }
   }
-  for (i = i + 1; i < mvm::LockSystem::GlobalSize; i++) {
+  for (i = i + 1; i < vmkit::LockSystem::GlobalSize; i++) {
     assert(lockSystem.LockTable[i] == NULL);
   }
 }
 
 void JavaThread::tracer(word_t closure) {
-  mvm::Collector::markAndTraceRoot(&pendingException, closure);
-  mvm::Collector::markAndTraceRoot(&javaThread, closure);
-  mvm::Collector::markAndTraceRoot(&vmThread, closure);
+  vmkit::Collector::markAndTraceRoot(&pendingException, closure);
+  vmkit::Collector::markAndTraceRoot(&javaThread, closure);
+  vmkit::Collector::markAndTraceRoot(&vmThread, closure);
   
   JNILocalReferences* end = localJNIRefs;
   while (end != NULL) {
     for (uint32 i = 0; i < end->length; ++i) {
       JavaObject** obj = end->localReferences + i;
-      mvm::Collector::markAndTraceRoot(obj, closure);
+      vmkit::Collector::markAndTraceRoot(obj, closure);
     }
     end = end->prev;
   }

Modified: vmkit/trunk/lib/J3/VMCore/Zip.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Zip.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Zip.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Zip.cpp Mon Nov 21 05:03:32 2011
@@ -17,7 +17,7 @@
 
 using namespace j3;
 
-ZipArchive::ZipArchive(ClassBytes* bytes, mvm::BumpPtrAllocator& A) : allocator(A) {
+ZipArchive::ZipArchive(ClassBytes* bytes, vmkit::BumpPtrAllocator& A) : allocator(A) {
   this->bytes = bytes;
   findOfscd();
   if (ofscd > -1) addFiles();

Modified: vmkit/trunk/lib/J3/VMCore/Zip.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Zip.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Zip.h (original)
+++ vmkit/trunk/lib/J3/VMCore/Zip.h Mon Nov 21 05:03:32 2011
@@ -19,7 +19,7 @@
 class classBytes;
 class JnjvmBootstrapLoader;
 
-struct ZipFile : public mvm::PermanentObject {
+struct ZipFile : public vmkit::PermanentObject {
   char* filename;
   int ucsize;
   int csize;
@@ -32,9 +32,9 @@
 
 
 
-class ZipArchive : public mvm::PermanentObject {
+class ZipArchive : public vmkit::PermanentObject {
   
-  mvm::BumpPtrAllocator& allocator;
+  vmkit::BumpPtrAllocator& allocator;
 
   struct ltstr
   {
@@ -70,7 +70,7 @@
   }
 
   int getOfscd() { return ofscd; }
-  ZipArchive(ClassBytes* bytes, mvm::BumpPtrAllocator& allocator);
+  ZipArchive(ClassBytes* bytes, vmkit::BumpPtrAllocator& allocator);
   ZipFile* getFile(const char* filename);
   int readFile(ClassBytes* array, const ZipFile* file);
 

Modified: vmkit/trunk/lib/vmkit/CommonThread/CollectionRV.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/CollectionRV.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/CollectionRV.cpp (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/CollectionRV.cpp Mon Nov 21 05:03:32 2011
@@ -15,10 +15,10 @@
 
 #include "debug.h"
 
-namespace mvm {
+namespace vmkit {
 
 void CollectionRV::another_mark() {
-  mvm::Thread* th = mvm::Thread::get();
+  vmkit::Thread* th = vmkit::Thread::get();
   assert(th->getLastSP() != 0);
   assert(nbJoined < th->MyVM->numberOfThreads);
   nbJoined++;
@@ -28,7 +28,7 @@
 }
 
 void CollectionRV::waitEndOfRV() {
-  mvm::Thread* th = mvm::Thread::get();
+  vmkit::Thread* th = vmkit::Thread::get();
   assert(th->getLastSP() != 0);
 
   while (th->doYield) {
@@ -37,7 +37,7 @@
 }
 
 void CollectionRV::waitRV() {
-  mvm::Thread* self = mvm::Thread::get(); 
+  vmkit::Thread* self = vmkit::Thread::get(); 
   // Add myself.
   nbJoined++;
 
@@ -48,26 +48,26 @@
 
 void CooperativeCollectionRV::synchronize() {
   assert(nbJoined == 0);
-  mvm::Thread* self = mvm::Thread::get();
+  vmkit::Thread* self = vmkit::Thread::get();
   // Lock thread lock, so that we can traverse the thread list safely. This will
   // be released on finishRV.
   self->MyVM->threadLock.lock();
 
-  mvm::Thread* cur = self;
+  vmkit::Thread* cur = self;
   assert(initiator == NULL);
   initiator = self;
   do {
     cur->doYield = true;
     assert(!cur->joinedRV);
-    cur = (mvm::Thread*)cur->next();
+    cur = (vmkit::Thread*)cur->next();
   } while (cur != self);
  
   // The CAS is not necessary but it does a memory barrier. 
   __sync_bool_compare_and_swap(&(self->joinedRV), false, true);
 
   // Lookup currently blocked threads.
-  for (cur = (mvm::Thread*)self->next(); cur != self; 
-       cur = (mvm::Thread*)cur->next()) {
+  for (cur = (vmkit::Thread*)self->next(); cur != self; 
+       cur = (vmkit::Thread*)cur->next()) {
     if (cur->getLastSP()) {
       nbJoined++;
       cur->joinedRV = true;
@@ -83,7 +83,7 @@
 }
 
 void CooperativeCollectionRV::join() {
-  mvm::Thread* th = mvm::Thread::get();
+  vmkit::Thread* th = vmkit::Thread::get();
   assert(th->doYield && "No yield");
   assert((th->getLastSP() == 0) && "SP present in cooperative code");
 
@@ -101,7 +101,7 @@
 }
 
 void CooperativeCollectionRV::joinBeforeUncooperative() {
-  mvm::Thread* th = mvm::Thread::get();
+  vmkit::Thread* th = vmkit::Thread::get();
   assert((th->getLastSP() != 0) &&
          "SP not set before entering uncooperative code");
 
@@ -121,7 +121,7 @@
 }
 
 void CooperativeCollectionRV::joinAfterUncooperative(word_t SP) {
-  mvm::Thread* th = mvm::Thread::get();
+  vmkit::Thread* th = vmkit::Thread::get();
   assert((th->getLastSP() == 0) &&
          "SP set after entering uncooperative code");
 
@@ -143,21 +143,21 @@
 }
 
 extern "C" void conditionalSafePoint() {
-  mvm::Thread* th = mvm::Thread::get();
+  vmkit::Thread* th = vmkit::Thread::get();
   th->MyVM->rendezvous.join();
 }
 
 void CooperativeCollectionRV::finishRV() {
   lockRV();
   
-  assert(mvm::Thread::get() == initiator);
-  mvm::Thread* cur = initiator;
+  assert(vmkit::Thread::get() == initiator);
+  vmkit::Thread* cur = initiator;
   do {
     assert(cur->doYield && "Inconsistent state");
     assert(cur->joinedRV && "Inconsistent state");
     cur->doYield = false;
     cur->joinedRV = false;
-    cur = (mvm::Thread*)cur->next();
+    cur = (vmkit::Thread*)cur->next();
   } while (cur != initiator);
 
   assert(nbJoined == initiator->MyVM->numberOfThreads && "Inconsistent state");
@@ -166,7 +166,7 @@
   condEndRV.broadcast();
   initiator = NULL;
   unlockRV();
-  mvm::Thread::get()->inRV = false;
+  vmkit::Thread::get()->inRV = false;
 }
 
 void CooperativeCollectionRV::addThread(Thread* th) {

Modified: vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp Mon Nov 21 05:03:32 2011
@@ -20,7 +20,7 @@
 #include <pthread.h>
 
 
-namespace mvm {
+namespace vmkit {
 
 void ThinLock::overflowThinLock(gc* object, LockSystem& table) {
   llvm_gcroot(object, 0);
@@ -89,7 +89,7 @@
   llvm_gcroot(object, 0);
   fprintf(stderr,
       "WARNING: [%p] has been waiting really long for %p (header = %p)\n",
-      (void*)mvm::Thread::get(),
+      (void*)vmkit::Thread::get(),
       (void*)object,
       (void*)object->header);
   FatLock* obj = table.getFatLockFromID(object->header);
@@ -97,7 +97,7 @@
     fprintf(stderr,
         "WARNING: [%p] is waiting on fatlock %p. "
         "Its associated object is %p. The owner is %p\n",
-        (void*)mvm::Thread::get(),
+        (void*)vmkit::Thread::get(),
         (void*)obj,
         (void*)obj->getAssociatedObject(),
         (void*)obj->owner());
@@ -106,7 +106,7 @@
 
 void ThinLock::acquire(gc* object, LockSystem& table) {
   llvm_gcroot(object, 0);
-  uint64_t id = mvm::Thread::get()->getThreadID();
+  uint64_t id = vmkit::Thread::get()->getThreadID();
   word_t oldValue = 0;
   word_t newValue = 0;
   word_t yieldedValue = 0;
@@ -160,7 +160,7 @@
       if (object->header & FatMask) {
         break;
       } else {
-        mvm::Thread::yield();
+        vmkit::Thread::yield();
       }
     }
     
@@ -193,7 +193,7 @@
 void ThinLock::release(gc* object, LockSystem& table) {
   llvm_gcroot(object, 0);
   assert(owner(object, table) && "Not owner when entering release!");
-  uint64 id = mvm::Thread::get()->getThreadID();
+  uint64 id = vmkit::Thread::get()->getThreadID();
   word_t oldValue = 0;
   word_t newValue = 0;
   word_t yieldedValue = 0;
@@ -226,7 +226,7 @@
     FatLock* obj = table.getFatLockFromID(object->header);
     if (obj != NULL) return obj->owner();
   } else {
-    uint64 id = mvm::Thread::get()->getThreadID();
+    uint64 id = vmkit::Thread::get()->getThreadID();
     if ((object->header & System::GetThreadIDMask()) == id) return true;
   }
   return false;
@@ -252,7 +252,7 @@
   return internalLock.selfOwner();
 }
  
-mvm::Thread* FatLock::getOwner() {
+vmkit::Thread* FatLock::getOwner() {
   return internalLock.getOwner();
 }
   
@@ -277,7 +277,7 @@
   assert(associatedObject == obj && "Mismatch object in lock");
   if (!waitingThreads && !lockingThreads &&
       internalLock.recursionCount() == 1) {
-    mvm::ThinLock::removeFatLock(this, table);
+    vmkit::ThinLock::removeFatLock(this, table);
     table.deallocate(this);
   }
   internalLock.unlock();
@@ -316,7 +316,7 @@
   threadLock.unlock();
 }
   
-LockSystem::LockSystem(mvm::BumpPtrAllocator& all) : allocator(all) {
+LockSystem::LockSystem(vmkit::BumpPtrAllocator& all) : allocator(all) {
   assert(ThinLock::ThinCountMask > 0);
   LockTable = (FatLock* **)
     allocator.Allocate(GlobalSize * sizeof(FatLock**), "Global LockTable");
@@ -349,7 +349,7 @@
   
     FatLock** tab = LockTable[index >> BitIndex];
   
-    VirtualMachine* vm = mvm::Thread::get()->MyVM;
+    VirtualMachine* vm = vmkit::Thread::get()->MyVM;
     if (tab == NULL) {
       tab = (FatLock**)vm->allocator.Allocate(
           IndexSize * sizeof(FatLock*), "Index LockTable");
@@ -385,11 +385,11 @@
 bool LockingThread::wait(
     gc* self, LockSystem& table, struct timeval* info, bool timed) {
   llvm_gcroot(self, 0);
-  assert(mvm::ThinLock::owner(self, table));
+  assert(vmkit::ThinLock::owner(self, table));
 
-  FatLock* l = mvm::ThinLock::changeToFatlock(self, table);
+  FatLock* l = vmkit::ThinLock::changeToFatlock(self, table);
   this->waitsOn = l;
-  mvm::Cond& varcondThread = this->varcond;
+  vmkit::Cond& varcondThread = this->varcond;
 
   if (this->interruptFlag != 0) {
     this->interruptFlag = 0;
@@ -431,7 +431,7 @@
       varcondThread.wait(&l->internalLock);
     }
   }
-  assert(mvm::ThinLock::owner(self, table) && "Not owner after wait");
+  assert(vmkit::ThinLock::owner(self, table) && "Not owner after wait");
       
   l->waitingThreads--;
      
@@ -477,14 +477,14 @@
     return true;
   }
   
-  assert(mvm::ThinLock::owner(self, table) && "Not owner after wait");
+  assert(vmkit::ThinLock::owner(self, table) && "Not owner after wait");
   return false;
 }
 
 void LockingThread::notify(gc* self, LockSystem& table) {
   llvm_gcroot(self, 0);
-  assert(mvm::ThinLock::owner(self, table));
-  FatLock* l = mvm::ThinLock::getFatLock(self, table);
+  assert(vmkit::ThinLock::owner(self, table));
+  FatLock* l = vmkit::ThinLock::getFatLock(self, table);
   
   if (l == NULL) return;
   LockingThread* cur = l->firstThread;
@@ -517,13 +517,13 @@
     }
   } while (cur != l->firstThread);
 
-  assert(mvm::ThinLock::owner(self, table) && "Not owner after notify");
+  assert(vmkit::ThinLock::owner(self, table) && "Not owner after notify");
 }
 
 void LockingThread::notifyAll(gc* self, LockSystem& table) {
   llvm_gcroot(self, 0);
-  assert(mvm::ThinLock::owner(self, table));
-  FatLock* l = mvm::ThinLock::getFatLock(self, table);
+  assert(vmkit::ThinLock::owner(self, table));
+  FatLock* l = vmkit::ThinLock::getFatLock(self, table);
   if (l == NULL) return;
   LockingThread* cur = l->firstThread;
   if (cur == NULL) return;
@@ -535,7 +535,7 @@
     cur = temp;
   } while (cur != l->firstThread);
   l->firstThread = NULL;
-  assert(mvm::ThinLock::owner(self, table) && "Not owner after notifyAll");
+  assert(vmkit::ThinLock::owner(self, table) && "Not owner after notifyAll");
 }
 
 }

Modified: vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x64.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x64.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x64.inc (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x64.inc Mon Nov 21 05:03:32 2011
@@ -37,7 +37,7 @@
 }
 
 void Handler::UpdateRegistersForStackOverflow() {
-  word_t alt_stack = mvm::Thread::get()->GetAlternativeStackStart();
+  word_t alt_stack = vmkit::Thread::get()->GetAlternativeStackStart();
   ((ucontext_t*)context)->uc_mcontext.gregs[REG_RDI] = System::GetIPFromCallerAddress(((ucontext_t*)context)->uc_mcontext.gregs[REG_RBP]);
   ((ucontext_t*)context)->uc_mcontext.gregs[REG_RSI] = ((ucontext_t*)context)->uc_mcontext.gregs[REG_RBP];
   ((ucontext_t*)context)->uc_mcontext.gregs[REG_RSP] = alt_stack;

Modified: vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x86.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x86.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x86.inc (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x86.inc Mon Nov 21 05:03:32 2011
@@ -39,7 +39,7 @@
 }
 
 void Handler::UpdateRegistersForStackOverflow() {
-  word_t alt_stack = mvm::Thread::get()->GetAlternativeStackStart();
+  word_t alt_stack = vmkit::Thread::get()->GetAlternativeStackStart();
   ((ucontext_t*)context)->uc_mcontext.gregs[REG_EBX] = System::GetIPFromCallerAddress(((ucontext_t*)context)->uc_mcontext.gregs[REG_EBP]);
   ((ucontext_t*)context)->uc_mcontext.gregs[REG_EAX] = ((ucontext_t*)context)->uc_mcontext.gregs[REG_EBP];
   ((ucontext_t*)context)->uc_mcontext.gregs[REG_ESP] = alt_stack;

Modified: vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-macos-x64.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-macos-x64.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-macos-x64.inc (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-macos-x64.inc Mon Nov 21 05:03:32 2011
@@ -37,7 +37,7 @@
 }
 
 void Handler::UpdateRegistersForStackOverflow() {
-  word_t alt_stack = mvm::Thread::get()->GetAlternativeStackStart();
+  word_t alt_stack = vmkit::Thread::get()->GetAlternativeStackStart();
   ((ucontext_t*)context)->uc_mcontext->__ss.__rdi = System::GetIPFromCallerAddress(((ucontext_t*)context)->uc_mcontext->__ss.__rbp);
   ((ucontext_t*)context)->uc_mcontext->__ss.__rsi = ((ucontext_t*)context)->uc_mcontext->__ss.__rbp;
   ((ucontext_t*)context)->uc_mcontext->__ss.__rsp = alt_stack;

Modified: vmkit/trunk/lib/vmkit/CommonThread/Sigsegv.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/Sigsegv.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/Sigsegv.cpp (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/Sigsegv.cpp Mon Nov 21 05:03:32 2011
@@ -16,7 +16,7 @@
 #include <csignal>
 #include <cstdio>
 
-using namespace mvm;
+using namespace vmkit;
 
 namespace {
   class Handler {
@@ -53,37 +53,37 @@
 #endif
 
 extern "C" void ThrowStackOverflowError(word_t ip) {
-  mvm::Thread* th = mvm::Thread::get();
-  mvm::FrameInfo* FI = th->MyVM->IPToFrameInfo(ip);
+  vmkit::Thread* th = vmkit::Thread::get();
+  vmkit::FrameInfo* FI = th->MyVM->IPToFrameInfo(ip);
   if (FI->Metadata == NULL) {
     fprintf(stderr, "Thread %p received a SIGSEGV: either the VM code or an external\n"
                     "native method is bogus. Aborting...\n", (void*)th);
     abort();
   } else {
-    mvm::Thread::get()->MyVM->stackOverflowError();
+    vmkit::Thread::get()->MyVM->stackOverflowError();
   }
   UNREACHABLE();
 }
 
 extern "C" void ThrowNullPointerException(word_t ip) {
-  mvm::Thread* th = mvm::Thread::get();
-  mvm::FrameInfo* FI = th->MyVM->IPToFrameInfo(ip);
+  vmkit::Thread* th = vmkit::Thread::get();
+  vmkit::FrameInfo* FI = th->MyVM->IPToFrameInfo(ip);
   if (FI->Metadata == NULL) {
     fprintf(stderr, "Thread %p received a SIGSEGV: either the VM code or an external\n"
                     "native method is bogus. Aborting...\n", (void*)th);
     abort();
   } else {
-    mvm::Thread::get()->MyVM->nullPointerException();
+    vmkit::Thread::get()->MyVM->nullPointerException();
   }
   UNREACHABLE();
 }
 
 void sigsegvHandler(int n, siginfo_t *info, void *context) {
   Handler handler(context);
-  mvm::Thread* th = mvm::Thread::get();
+  vmkit::Thread* th = vmkit::Thread::get();
   word_t addr = (word_t)info->si_addr;
   if (th->IsStackOverflowAddr(addr)) {
-    if (mvm::System::SupportsHardwareStackOverflow()) {
+    if (vmkit::System::SupportsHardwareStackOverflow()) {
       handler.UpdateRegistersForStackOverflow();
     } else {
       fprintf(stderr, "Stack overflow in VM code or in JNI code. If it is from\n"
@@ -94,7 +94,7 @@
       abort();
     }
   } else {
-    if (mvm::System::SupportsHardwareNullCheck()) {
+    if (vmkit::System::SupportsHardwareNullCheck()) {
       handler.UpdateRegistersForNPE();
     } else {
       fprintf(stderr, "Thread %p received a SIGSEGV: either the VM code or an external\n"

Modified: vmkit/trunk/lib/vmkit/CommonThread/ctlock.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/ctlock.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/ctlock.cpp (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/ctlock.cpp Mon Nov 21 05:03:32 2011
@@ -19,7 +19,7 @@
 #include <pthread.h>
 
 
-namespace mvm {
+namespace vmkit {
 
 Lock::Lock() {
   pthread_mutexattr_t attr;
@@ -56,10 +56,10 @@
 }
 
 bool Lock::selfOwner() {
-  return owner == mvm::Thread::get();
+  return owner == vmkit::Thread::get();
 }
 
-mvm::Thread* Lock::getOwner() {
+vmkit::Thread* Lock::getOwner() {
   return owner;
 }
 
@@ -92,7 +92,7 @@
   int res = 0;
   if (!selfOwner()) {
     res = pthread_mutex_trylock((pthread_mutex_t*)&internalLock);
-    owner = mvm::Thread::get();
+    owner = vmkit::Thread::get();
   }
   ++n;
   return res;

Modified: vmkit/trunk/lib/vmkit/CommonThread/ctthread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/ctthread.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/ctthread.cpp (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/ctthread.cpp Mon Nov 21 05:03:32 2011
@@ -25,7 +25,7 @@
 #include <signal.h>
 #include <unistd.h>
 
-using namespace mvm;
+using namespace vmkit;
 
 int Thread::kill(void* tid, int signo) {
   return pthread_kill((pthread_t)tid, signo);
@@ -40,7 +40,7 @@
 }
 
 void Thread::yield(void) {
-  Thread* th = mvm::Thread::get();
+  Thread* th = vmkit::Thread::get();
   if (th->isVmkitThread()) {
     if (th->doYield && !th->inRV) {
       th->MyVM->rendezvous.join();
@@ -102,7 +102,7 @@
 }
 
 void Thread::getFrameContext(word_t* buffer) {
-  mvm::StackWalker Walker(this);
+  vmkit::StackWalker Walker(this);
   uint32_t i = 0;
 
   while (word_t ip = *Walker) {
@@ -112,7 +112,7 @@
 }
 
 uint32_t Thread::getFrameContextLength() {
-  mvm::StackWalker Walker(this);
+  vmkit::StackWalker Walker(this);
   uint32_t i = 0;
 
   while (*Walker) {
@@ -151,10 +151,10 @@
   }
 }
 
-StackWalker::StackWalker(mvm::Thread* th) {
+StackWalker::StackWalker(vmkit::Thread* th) {
   thread = th;
   frame = th->lastKnownFrame;
-  if (mvm::Thread::get() == th) {
+  if (vmkit::Thread::get() == th) {
     addr = System::GetCallerAddress();
     addr = System::GetCallerOfAddress(addr);
   } else {
@@ -234,7 +234,7 @@
   }
   
   // Finally, yield until lastSP is not set.
-  while ((sp = lastSP) == 0) mvm::Thread::yield();
+  while ((sp = lastSP) == 0) vmkit::Thread::yield();
 
   assert(sp != 0 && "Still no sp");
   return sp;
@@ -282,13 +282,13 @@
     uint32 pagesize = System::GetPageSize();
     for (uint32 i = 0; i < NR_THREADS; ++i) {
       word_t addr = baseAddr + (i * STACK_SIZE) + pagesize
-        + mvm::System::GetAlternativeStackSize();
+        + vmkit::System::GetAlternativeStackSize();
       mprotect((void*)addr, pagesize, PROT_NONE);
     }
 
     memset((void*)used, 0, NR_THREADS * sizeof(uint32));
     allocPtr = 0;
-    mvm::Thread::baseAddr = baseAddr;
+    vmkit::Thread::baseAddr = baseAddr;
   }
 
   word_t allocate() {
@@ -323,7 +323,7 @@
 /// thread specific data, registers the thread to the GC and calls the
 /// given routine of th.
 ///
-void Thread::internalThreadStart(mvm::Thread* th) {
+void Thread::internalThreadStart(vmkit::Thread* th) {
   th->baseSP  = System::GetCallerAddress();
 
   // Set the alternate stack as the second page of the thread's
@@ -353,7 +353,7 @@
 
 
 /// start - Called by the creator of the thread to run the new thread.
-int Thread::start(void (*fct)(mvm::Thread*)) {
+int Thread::start(void (*fct)(vmkit::Thread*)) {
   pthread_attr_t attributs;
   pthread_attr_init(&attributs);
   pthread_attr_setstack(&attributs, this, STACK_SIZE);
@@ -381,7 +381,7 @@
 
 /// releaseThread - Remove the stack of the thread from the list of stacks
 /// in use.
-void Thread::releaseThread(mvm::Thread* th) {
+void Thread::releaseThread(vmkit::Thread* th) {
   // It seems like the pthread implementation in Linux is clearing with NULL
   // the stack of the thread. So we have to get the thread id before
   // calling pthread_join.

Modified: vmkit/trunk/lib/vmkit/Compiler/Disassembler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Compiler/Disassembler.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Compiler/Disassembler.cpp (original)
+++ vmkit/trunk/lib/vmkit/Compiler/Disassembler.cpp Mon Nov 21 05:03:32 2011
@@ -25,7 +25,7 @@
 
 // this is the only function exported from this file
 
-int mvm::VmkitModule::disassemble(unsigned int *addr)
+int vmkit::VmkitModule::disassemble(unsigned int *addr)
 {
   
   if (!initialised)
@@ -56,7 +56,7 @@
 static int			initialised= 0;
 
 
-int mvm::VmkitModule::disassemble(unsigned int *addr)
+int vmkit::VmkitModule::disassemble(unsigned int *addr)
 {
   if (!initialised)
     {
@@ -74,7 +74,7 @@
 
 #else
 
-int mvm::VmkitModule::disassemble(unsigned int* addr) {
+int vmkit::VmkitModule::disassemble(unsigned int* addr) {
   return 0;
 }
 
@@ -82,7 +82,7 @@
 
 #else
 
-int mvm::VmkitModule::disassemble(unsigned int* addr) {
+int vmkit::VmkitModule::disassemble(unsigned int* addr) {
   return 0;
 }
 

Modified: vmkit/trunk/lib/vmkit/Compiler/EscapeAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Compiler/EscapeAnalysis.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Compiler/EscapeAnalysis.cpp (original)
+++ vmkit/trunk/lib/vmkit/Compiler/EscapeAnalysis.cpp Mon Nov 21 05:03:32 2011
@@ -243,7 +243,7 @@
 }
 }
 
-namespace mvm {
+namespace vmkit {
 FunctionPass* createEscapeAnalysisPass() {
   return new EscapeAnalysis();
 }

Modified: vmkit/trunk/lib/vmkit/Compiler/InlineMalloc.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Compiler/InlineMalloc.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Compiler/InlineMalloc.cpp (original)
+++ vmkit/trunk/lib/vmkit/Compiler/InlineMalloc.cpp Mon Nov 21 05:03:32 2011
@@ -23,7 +23,7 @@
 
 using namespace llvm;
 
-namespace mvm {
+namespace vmkit {
 
   class InlineMalloc : public FunctionPass {
   public:

Modified: vmkit/trunk/lib/vmkit/Compiler/JIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Compiler/JIT.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Compiler/JIT.cpp (original)
+++ vmkit/trunk/lib/vmkit/Compiler/JIT.cpp Mon Nov 21 05:03:32 2011
@@ -49,10 +49,10 @@
 #include <dlfcn.h>
 #include <sys/mman.h>
 
-using namespace mvm;
+using namespace vmkit;
 using namespace llvm;
 
-namespace mvm {
+namespace vmkit {
   namespace llvm_runtime {
     #include "LLVMRuntime.inc"
   }
@@ -190,7 +190,7 @@
   addPass(PM, createCFGSimplificationPass());     // Merge & remove BBs
 }
 
-namespace mvm {
+namespace vmkit {
   llvm::FunctionPass* createInlineMallocPass();
 }
 
@@ -308,7 +308,7 @@
   constantDoubleMinusInfinity = ConstantFP::get(Type::getDoubleTy(Context), MinDouble);
   constantDoubleMinusZero = ConstantFP::get(Type::getDoubleTy(Context), -0.0);
   constantFloatMinusZero = ConstantFP::get(Type::getFloatTy(Context), -0.0f);
-  constantThreadIDMask = ConstantInt::get(pointerSizeType, mvm::System::GetThreadIDMask());
+  constantThreadIDMask = ConstantInt::get(pointerSizeType, vmkit::System::GetThreadIDMask());
   constantStackOverflowMask = 
     ConstantInt::get(pointerSizeType, Thread::StackOverflowMask);
   constantFatMask = ConstantInt::get(pointerSizeType, ThinLock::FatMask);

Modified: vmkit/trunk/lib/vmkit/Compiler/VmkitGC.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Compiler/VmkitGC.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Compiler/VmkitGC.cpp (original)
+++ vmkit/trunk/lib/vmkit/Compiler/VmkitGC.cpp Mon Nov 21 05:03:32 2011
@@ -28,7 +28,7 @@
   };
 }
 
-namespace mvm {
+namespace vmkit {
   void linkVmkitGC() { }
 }
 

Modified: vmkit/trunk/lib/vmkit/MMTk/MutatorThread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/MMTk/MutatorThread.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/MMTk/MutatorThread.h (original)
+++ vmkit/trunk/lib/vmkit/MMTk/MutatorThread.h Mon Nov 21 05:03:32 2011
@@ -14,30 +14,30 @@
 #include "vmkit/Allocator.h"
 #include "vmkit/Thread.h"
 
-namespace mvm {
+namespace vmkit {
 
-class MutatorThread : public mvm::Thread {
+class MutatorThread : public vmkit::Thread {
 public:
-  MutatorThread() : mvm::Thread() {
+  MutatorThread() : vmkit::Thread() {
     MutatorContext = 0;
     CollectionAttempts = 0;
   }
-  mvm::ThreadAllocator Allocator;
+  vmkit::ThreadAllocator Allocator;
   word_t MutatorContext;
   
   /// realRoutine - The function to invoke when the thread starts.
   ///
-  void (*realRoutine)(mvm::Thread*);
+  void (*realRoutine)(vmkit::Thread*);
 
   uint32_t CollectionAttempts;
 
   static void init(Thread* _th);
 
   static MutatorThread* get() {
-    return (MutatorThread*)mvm::Thread::get();
+    return (MutatorThread*)vmkit::Thread::get();
   }
 
-  virtual int start(void (*fct)(mvm::Thread*)) {
+  virtual int start(void (*fct)(vmkit::Thread*)) {
     realRoutine = fct;
     routine = init;
     return Thread::start(init);

Modified: vmkit/trunk/lib/vmkit/MMTk/VmkitGC.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/MMTk/VmkitGC.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/MMTk/VmkitGC.cpp (original)
+++ vmkit/trunk/lib/vmkit/MMTk/VmkitGC.cpp Mon Nov 21 05:03:32 2011
@@ -13,9 +13,9 @@
 
 #include <set>
 
-using namespace mvm;
+using namespace vmkit;
 
-static mvm::SpinLock lock;
+static vmkit::SpinLock lock;
 std::set<gc*> __InternalSet__;
 int Collector::verbose = 0;
 
@@ -37,12 +37,12 @@
 extern "C" void* gcmallocUnresolved(uint32_t sz, VirtualTable* VT) {
   gc* res = (gc*)gcmalloc(sz, VT);
   if (VT->hasDestructor())
-    mvm::Thread::get()->MyVM->addFinalizationCandidate(res);
+    vmkit::Thread::get()->MyVM->addFinalizationCandidate(res);
   return res;
 }
 
 extern "C" void addFinalizationCandidate(gc* obj) {
-  mvm::Thread::get()->MyVM->addFinalizationCandidate(obj);
+  vmkit::Thread::get()->MyVM->addFinalizationCandidate(obj);
 }
 
 extern "C" void* AllocateMagicArray(int32_t sz, void* length) {

Modified: vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h (original)
+++ vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h Mon Nov 21 05:03:32 2011
@@ -72,7 +72,7 @@
 extern "C" void fieldWriteBarrier(void* ref, void** ptr, void* value);
 extern "C" void nonHeapWriteBarrier(void** ptr, void* value);
 
-namespace mvm {
+namespace vmkit {
   
 class Collector {
 public:

Modified: vmkit/trunk/lib/vmkit/Runtime/MethodInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Runtime/MethodInfo.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Runtime/MethodInfo.cpp (original)
+++ vmkit/trunk/lib/vmkit/Runtime/MethodInfo.cpp Mon Nov 21 05:03:32 2011
@@ -17,7 +17,7 @@
 
 #include <dlfcn.h>
 
-namespace mvm {
+namespace vmkit {
 
 void MethodInfoHelper::scan(word_t closure, FrameInfo* FI, word_t ip, word_t addr) {
   //word_t spaddr = (word_t)addr + FI->FrameSize + sizeof(void*);

Modified: vmkit/trunk/lib/vmkit/Runtime/Object.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Runtime/Object.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Runtime/Object.cpp (original)
+++ vmkit/trunk/lib/vmkit/Runtime/Object.cpp Mon Nov 21 05:03:32 2011
@@ -13,7 +13,7 @@
 #include "VmkitGC.h"
 #include "vmkit/VirtualMachine.h"
 
-using namespace mvm;
+using namespace vmkit;
 
 extern "C" void printFloat(float f) {
   fprintf(stderr, "%f\n", f);
@@ -54,7 +54,7 @@
     if (exitingThread != NULL) {
       Thread* th = exitingThread;
       exitingThread = NULL;
-      mvm::Thread::releaseThread(th);
+      vmkit::Thread::releaseThread(th);
     }
   }
   

Modified: vmkit/trunk/lib/vmkit/Runtime/UTF8.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Runtime/UTF8.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Runtime/UTF8.cpp (original)
+++ vmkit/trunk/lib/vmkit/Runtime/UTF8.cpp Mon Nov 21 05:03:32 2011
@@ -10,7 +10,7 @@
 #include "vmkit/Allocator.h"
 #include "vmkit/UTF8.h"
 
-namespace mvm {
+namespace vmkit {
 
 extern "C" const UTF8 TombstoneKey(-1);
 extern "C" const UTF8 EmptyKey(-1);
@@ -92,4 +92,4 @@
   return res;
 }
 
-} // namespace mvm
+} // namespace vmkit

Modified: vmkit/trunk/mmtk/magic/LowerMagic.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/magic/LowerMagic.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/magic/LowerMagic.cpp (original)
+++ vmkit/trunk/mmtk/magic/LowerMagic.cpp Mon Nov 21 05:03:32 2011
@@ -357,7 +357,7 @@
 static bool removePotentialNullCheck(BasicBlock* Cur, Value* Obj) {
   if (!Obj->getType()->isPointerTy()) return false;
 
-  if (mvm::System::SupportsHardwareNullCheck()) {
+  if (vmkit::System::SupportsHardwareNullCheck()) {
     for (Value::use_iterator I = Obj->use_begin(), E = Obj->use_end(); I != E; I++) {
       if (GetElementPtrInst* GE = dyn_cast<GetElementPtrInst>(*I)) {
         for (Value::use_iterator II = GE->use_begin(), EE = GE->use_end(); II != EE; II++) {

Modified: vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp Mon Nov 21 05:03:32 2011
@@ -18,7 +18,7 @@
 
 #include "debug.h"
 
-using namespace mvm;
+using namespace vmkit;
 
 int Collector::verbose = 0;
 extern "C" void Java_org_j3_mmtk_Collection_triggerCollection__I(word_t, int32_t) ALWAYS_INLINE;
@@ -67,7 +67,7 @@
 
 extern "C" void addFinalizationCandidate(gc* obj) {
   llvm_gcroot(obj, 0);
-  mvm::Thread::get()->MyVM->addFinalizationCandidate(obj);
+  vmkit::Thread::get()->MyVM->addFinalizationCandidate(obj);
 }
 
 extern "C" void* gcmallocUnresolved(uint32_t sz, VirtualTable* VT) {
@@ -81,18 +81,18 @@
 extern "C" void arrayWriteBarrier(void* ref, void** ptr, void* value) {
   JnJVM_org_j3_bindings_Bindings_arrayWriteBarrier__Lorg_vmmagic_unboxed_ObjectReference_2Lorg_vmmagic_unboxed_Address_2Lorg_vmmagic_unboxed_ObjectReference_2(
       (gc*)ref, (gc**)ptr, (gc*)value);
-  if (mvm::Thread::get()->doYield) mvm::Collector::collect();
+  if (vmkit::Thread::get()->doYield) vmkit::Collector::collect();
 }
 
 extern "C" void fieldWriteBarrier(void* ref, void** ptr, void* value) {
   JnJVM_org_j3_bindings_Bindings_fieldWriteBarrier__Lorg_vmmagic_unboxed_ObjectReference_2Lorg_vmmagic_unboxed_Address_2Lorg_vmmagic_unboxed_ObjectReference_2(
       (gc*)ref, (gc**)ptr, (gc*)value);
-  if (mvm::Thread::get()->doYield) mvm::Collector::collect();
+  if (vmkit::Thread::get()->doYield) vmkit::Collector::collect();
 }
 
 extern "C" void nonHeapWriteBarrier(void** ptr, void* value) {
   JnJVM_org_j3_bindings_Bindings_nonHeapWriteBarrier__Lorg_vmmagic_unboxed_Address_2Lorg_vmmagic_unboxed_ObjectReference_2((gc**)ptr, (gc*)value);
-  if (mvm::Thread::get()->doYield) mvm::Collector::collect();
+  if (vmkit::Thread::get()->doYield) vmkit::Collector::collect();
 }
 
 void MutatorThread::init(Thread* _th) {
@@ -222,7 +222,7 @@
 
 bool Collector::objectReferenceTryCASBarrier(gc* ref, gc** slot, gc* old, gc* value) {
   bool res = JnJVM_org_j3_bindings_Bindings_writeBarrierCAS__Lorg_vmmagic_unboxed_ObjectReference_2Lorg_vmmagic_unboxed_Address_2Lorg_vmmagic_unboxed_ObjectReference_2Lorg_vmmagic_unboxed_ObjectReference_2(ref, slot, old, value);
-  if (mvm::Thread::get()->doYield) mvm::Collector::collect();
+  if (vmkit::Thread::get()->doYield) vmkit::Collector::collect();
   return res;
 }
 

Modified: vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp Mon Nov 21 05:03:32 2011
@@ -18,12 +18,12 @@
   assert(A && "No active plan");
   
   if (A->current == NULL) {
-    A->current = (mvm::MutatorThread*)mvm::Thread::get()->MyVM->mainThread;
-  } else if (A->current->next() == mvm::Thread::get()->MyVM->mainThread) {
+    A->current = (vmkit::MutatorThread*)vmkit::Thread::get()->MyVM->mainThread;
+  } else if (A->current->next() == vmkit::Thread::get()->MyVM->mainThread) {
     A->current = NULL;
     return NULL;
   } else {
-    A->current = (mvm::MutatorThread*)A->current->next();
+    A->current = (vmkit::MutatorThread*)A->current->next();
   }
 
   if (A->current->MutatorContext == 0) {

Modified: vmkit/trunk/mmtk/mmtk-j3/Collection.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Collection.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Collection.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Collection.cpp Mon Nov 21 05:03:32 2011
@@ -20,13 +20,13 @@
 }
 
 extern "C" void Java_org_j3_mmtk_Collection_reportAllocationSuccess__ (MMTkObject* C) {
-  mvm::MutatorThread::get()->CollectionAttempts = 0;
+  vmkit::MutatorThread::get()->CollectionAttempts = 0;
 }
 
 extern "C" void JnJVM_org_j3_bindings_Bindings_collect__I(int why);
 
 extern "C" void Java_org_j3_mmtk_Collection_triggerCollection__I (MMTkObject* C, int why) {
-  mvm::MutatorThread* th = mvm::MutatorThread::get();
+  vmkit::MutatorThread* th = vmkit::MutatorThread::get();
   if (why > 2) th->CollectionAttempts++;
 
   // Verify that another collection is not happening.
@@ -48,7 +48,7 @@
 }
 
 extern "C" void Java_org_j3_mmtk_Collection_joinCollection__ (MMTkObject* C) {
-  mvm::Thread* th = mvm::Thread::get();
+  vmkit::Thread* th = vmkit::Thread::get();
   assert(th->inRV && "Joining collection without a rendezvous");
   th->MyVM->rendezvous.join();
 }
@@ -58,15 +58,15 @@
 }
 
 extern "C" int Java_org_j3_mmtk_Collection_maximumCollectionAttempt__ (MMTkObject* C) {
-  mvm::MutatorThread* th = mvm::MutatorThread::get();
-  mvm::MutatorThread* tcur = th;
+  vmkit::MutatorThread* th = vmkit::MutatorThread::get();
+  vmkit::MutatorThread* tcur = th;
 
   uint32_t max = 0; 
   do {
     if (tcur->CollectionAttempts > max) {
       max = tcur->CollectionAttempts;
     }
-    tcur = (mvm::MutatorThread*)tcur->next();
+    tcur = (vmkit::MutatorThread*)tcur->next();
   } while (tcur != th);
 
   return max;
@@ -85,11 +85,11 @@
 
 extern "C" void Java_org_j3_mmtk_Collection_reportPhysicalAllocationFailed__ (MMTkObject* C) { UNIMPLEMENTED(); }
 extern "C" void Java_org_j3_mmtk_Collection_triggerAsyncCollection__I (MMTkObject* C, sint32 val) {
-  mvm::Thread::get()->doYield = true;
+  vmkit::Thread::get()->doYield = true;
 }
 
 extern "C" uint8_t Java_org_j3_mmtk_Collection_noThreadsInGC__ (MMTkObject* C) {
-  mvm::Thread* th = mvm::Thread::get();
+  vmkit::Thread* th = vmkit::Thread::get();
   bool threadInGC = th->doYield;
   return !threadInGC;
 }

Modified: vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp Mon Nov 21 05:03:32 2011
@@ -25,7 +25,7 @@
 
 extern "C" void
 Java_org_j3_mmtk_FinalizableProcessor_scan__Lorg_mmtk_plan_TraceLocal_2Z (MMTkObject* FP, MMTkObject* TL, uint8_t nursery) {
-  mvm::Thread* th = mvm::Thread::get();
+  vmkit::Thread* th = vmkit::Thread::get();
   th->MyVM->scanFinalizationQueue(reinterpret_cast<word_t>(TL));
 }
 

Modified: vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h (original)
+++ vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h Mon Nov 21 05:03:32 2011
@@ -54,7 +54,7 @@
 };
 
 struct MMTkActivePlan : public MMTkObject {
-  mvm::MutatorThread* current;
+  vmkit::MutatorThread* current;
 };
 
 struct MMTkReferenceProcessor : public MMTkObject {

Modified: vmkit/trunk/mmtk/mmtk-j3/MMTk_Events.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/MMTk_Events.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/MMTk_Events.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/MMTk_Events.cpp Mon Nov 21 05:03:32 2011
@@ -14,14 +14,14 @@
 extern "C" void Java_org_j3_mmtk_MMTk_1Events_tracePageAcquired__Lorg_mmtk_policy_Space_2Lorg_vmmagic_unboxed_Address_2I(
     MMTkObject* event, MMTkObject* space, word_t address, int numPages) {
 #if 0
-  fprintf(stderr, "Pages acquired by thread %p from space %p at %x (%d)\n", (void*)mvm::Thread::get(), (void*)space, address, numPages);
+  fprintf(stderr, "Pages acquired by thread %p from space %p at %x (%d)\n", (void*)vmkit::Thread::get(), (void*)space, address, numPages);
 #endif
 }
 
 extern "C" void Java_org_j3_mmtk_MMTk_1Events_tracePageReleased__Lorg_mmtk_policy_Space_2Lorg_vmmagic_unboxed_Address_2I(
     MMTkObject* event, MMTkObject* space, word_t address, int numPages) {
 #if 0
-  fprintf(stderr, "Pages released by thread %p from space %p at %x (%d)\n", (void*)mvm::Thread::get(), (void*)space, address, numPages);
+  fprintf(stderr, "Pages released by thread %p from space %p at %x (%d)\n", (void*)vmkit::Thread::get(), (void*)space, address, numPages);
 #endif
 }
 

Modified: vmkit/trunk/mmtk/mmtk-j3/Memory.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Memory.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Memory.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Memory.cpp Mon Nov 21 05:03:32 2011
@@ -19,7 +19,7 @@
 public:
   InitCollector() {
     uint32 flags = MAP_PRIVATE | MAP_ANON | MAP_FIXED;
-    void* baseAddr = mmap((void*)mvm::kGCMemoryStart, mvm::kGCMemorySize, PROT_READ | PROT_WRITE,
+    void* baseAddr = mmap((void*)vmkit::kGCMemoryStart, vmkit::kGCMemorySize, PROT_READ | PROT_WRITE,
                           flags, -1, 0);
     if (baseAddr == MAP_FAILED) {
       perror("mmap for GC memory");
@@ -32,11 +32,11 @@
 InitCollector initCollector;
 
 extern "C" word_t Java_org_j3_mmtk_Memory_getHeapStartConstant__ (MMTkObject* M) {
-  return mvm::kGCMemoryStart;
+  return vmkit::kGCMemoryStart;
 }
 
 extern "C" word_t Java_org_j3_mmtk_Memory_getHeapEndConstant__ (MMTkObject* M) {
-  return mvm::kGCMemoryStart + mvm::kGCMemorySize;
+  return vmkit::kGCMemoryStart + vmkit::kGCMemorySize;
 }
 
 extern "C" word_t Java_org_j3_mmtk_Memory_getAvailableStartConstant__ (MMTkObject* M) {

Modified: vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp Mon Nov 21 05:03:32 2011
@@ -40,11 +40,11 @@
 }
 
 extern "C" uint8_t Java_org_j3_mmtk_ObjectModel_readAvailableByte__Lorg_vmmagic_unboxed_ObjectReference_2 (MMTkObject* OM, gc* obj) {
-  return *mvm::System::GetLastBytePtr(reinterpret_cast<word_t>(obj));
+  return *vmkit::System::GetLastBytePtr(reinterpret_cast<word_t>(obj));
 }
 
 extern "C" void Java_org_j3_mmtk_ObjectModel_writeAvailableByte__Lorg_vmmagic_unboxed_ObjectReference_2B (MMTkObject* OM, gc* obj, uint8_t val) {
-  *mvm::System::GetLastBytePtr(reinterpret_cast<word_t>(obj)) = val;
+  *vmkit::System::GetLastBytePtr(reinterpret_cast<word_t>(obj)) = val;
 }
 
 extern "C" gc* Java_org_j3_mmtk_ObjectModel_getObjectFromStartAddress__Lorg_vmmagic_unboxed_Address_2 (MMTkObject* OM, gc* obj) {
@@ -78,11 +78,11 @@
 
 extern "C" word_t Java_org_j3_mmtk_ObjectModel_copy__Lorg_vmmagic_unboxed_ObjectReference_2I (
     MMTkObject* OM, gc* src, int allocator) {
-  size_t size = mvm::Thread::get()->MyVM->getObjectSize(src);
+  size_t size = vmkit::Thread::get()->MyVM->getObjectSize(src);
   size = llvm::RoundUpToAlignment(size, sizeof(void*));
   word_t res = JnJVM_org_j3_bindings_Bindings_copy__Lorg_vmmagic_unboxed_ObjectReference_2Lorg_vmmagic_unboxed_ObjectReference_2II(
       src, src->getVirtualTable(), size, allocator);
-  assert((((word_t*)res)[1] & ~mvm::GCBitMask) == (((word_t*)src)[1] & ~mvm::GCBitMask));
+  assert((((word_t*)res)[1] & ~vmkit::GCBitMask) == (((word_t*)src)[1] & ~vmkit::GCBitMask));
   return res;
 }
 
@@ -94,7 +94,7 @@
 
 extern "C" word_t Java_org_j3_mmtk_ObjectModel_getObjectEndAddress__Lorg_vmmagic_unboxed_ObjectReference_2 (
     MMTkObject* OM, gc* object) {
-  size_t size = mvm::Thread::get()->MyVM->getObjectSize(object);
+  size_t size = vmkit::Thread::get()->MyVM->getObjectSize(object);
   size = llvm::RoundUpToAlignment(size, sizeof(void*));
   return reinterpret_cast<word_t>(object) + size;
 }
@@ -134,7 +134,7 @@
 
 extern "C" FakeByteArray* Java_org_j3_mmtk_ObjectModel_getTypeDescriptor__Lorg_vmmagic_unboxed_ObjectReference_2 (
     MMTkObject* OM, gc* src) {
-  const char* name = mvm::Thread::get()->MyVM->getObjectTypeName(src);
+  const char* name = vmkit::Thread::get()->MyVM->getObjectTypeName(src);
   // This code is only used for debugging on a fatal error. It is fine to
   // allocate in the C++ heap.
   return new (strlen(name)) FakeByteArray(name);

Modified: vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp Mon Nov 21 05:03:32 2011
@@ -15,7 +15,7 @@
 namespace mmtk {
 
 extern "C" void Java_org_j3_mmtk_ReferenceProcessor_scan__Lorg_mmtk_plan_TraceLocal_2Z (MMTkReferenceProcessor* RP, word_t TL, uint8_t nursery) {
-  mvm::Thread* th = mvm::Thread::get();
+  vmkit::Thread* th = vmkit::Thread::get();
   uint32_t val = RP->ordinal;
 
   if (val == 0) {

Modified: vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp Mon Nov 21 05:03:32 2011
@@ -17,24 +17,24 @@
 extern "C" void Java_org_j3_mmtk_Scanning_computeThreadRoots__Lorg_mmtk_plan_TraceLocal_2 (MMTkObject* Scanning, MMTkObject* TL) {
   // When entering this function, all threads are waiting on the rendezvous to
   // finish.
-  mvm::Thread* th = mvm::Thread::get();
-  mvm::Thread* tcur = th;
+  vmkit::Thread* th = vmkit::Thread::get();
+  vmkit::Thread* tcur = th;
   
   do {
     tcur->scanStack(reinterpret_cast<word_t>(TL));
-    tcur = (mvm::Thread*)tcur->next();
+    tcur = (vmkit::Thread*)tcur->next();
   } while (tcur != th);
 }
 
 extern "C" void Java_org_j3_mmtk_Scanning_computeGlobalRoots__Lorg_mmtk_plan_TraceLocal_2 (MMTkObject* Scanning, MMTkObject* TL) { 
-  mvm::Thread::get()->MyVM->tracer(reinterpret_cast<word_t>(TL));
+  vmkit::Thread::get()->MyVM->tracer(reinterpret_cast<word_t>(TL));
   
-	mvm::Thread* th = mvm::Thread::get();
-  mvm::Thread* tcur = th;
+	vmkit::Thread* th = vmkit::Thread::get();
+  vmkit::Thread* tcur = th;
   
   do {
     tcur->tracer(reinterpret_cast<word_t>(TL));
-    tcur = (mvm::Thread*)tcur->next();
+    tcur = (vmkit::Thread*)tcur->next();
   } while (tcur != th);
 }
 

Modified: vmkit/trunk/mmtk/mmtk-j3/Selected.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Selected.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Selected.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Selected.cpp Mon Nov 21 05:03:32 2011
@@ -13,7 +13,7 @@
 namespace mmtk {
 
 extern "C" MMTkObject* Java_org_j3_config_Selected_00024Mutator_get__() {
-  return (MMTkObject*)mvm::MutatorThread::get()->MutatorContext;
+  return (MMTkObject*)vmkit::MutatorThread::get()->MutatorContext;
 }
 
 }

Modified: vmkit/trunk/mmtk/mmtk-j3/Strings.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Strings.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Strings.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Strings.cpp Mon Nov 21 05:03:32 2011
@@ -24,7 +24,7 @@
 extern "C" void Java_org_j3_mmtk_Strings_writeThreadId___3CI(MMTkObject* str,
                                                              MMTkArray* msg,
                                                              sint32 len) {
-  fprintf(stderr, "[%p] ", (void*)mvm::Thread::get());
+  fprintf(stderr, "[%p] ", (void*)vmkit::Thread::get());
   
   for (sint32 i = 0; i < len; ++i) {
     fprintf(stderr, "%c", msg->elements[i]);

Modified: vmkit/trunk/mmtk/mmtk-j3/VM.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/VM.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/VM.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/VM.cpp Mon Nov 21 05:03:32 2011
@@ -64,7 +64,7 @@
 }
 
 extern "C" bool Java_org_j3_runtime_VM_buildFor64Addr__ () { 
-  return mvm::kWordSize == 8;
+  return vmkit::kWordSize == 8;
 }
 
 extern "C" bool Java_org_j3_runtime_VM_buildForIA32__ () { 

Modified: vmkit/trunk/tools/j3/Main.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/j3/Main.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/tools/j3/Main.cpp (original)
+++ vmkit/trunk/tools/j3/Main.cpp Mon Nov 21 05:03:32 2011
@@ -21,7 +21,7 @@
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace j3;
-using namespace mvm;
+using namespace vmkit;
 
 #include "FrametablesExterns.inc"
 
@@ -38,7 +38,7 @@
   Collector::initialise(argc, argv);
  
   // Create the allocator that will allocate the bootstrap loader and the JVM.
-  mvm::BumpPtrAllocator Allocator;
+  vmkit::BumpPtrAllocator Allocator;
   JavaJITCompiler* Comp = JavaJITCompiler::CreateCompiler("JITModule");
   JnjvmBootstrapLoader* loader = new(Allocator, "Bootstrap loader")
     JnjvmBootstrapLoader(Allocator, Comp, true);

Modified: vmkit/trunk/tools/precompiler/Precompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/precompiler/Precompiler.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/tools/precompiler/Precompiler.cpp (original)
+++ vmkit/trunk/tools/precompiler/Precompiler.cpp Mon Nov 21 05:03:32 2011
@@ -30,7 +30,7 @@
 #include <string>
 
 using namespace j3;
-using namespace mvm;
+using namespace vmkit;
 
 #include "FrametablesExterns.inc"
 
@@ -67,7 +67,7 @@
   Collector::initialise(argc, argv);
   
   // Create the allocator that will allocate the bootstrap loader and the JVM.
-  mvm::BumpPtrAllocator Allocator;
+  vmkit::BumpPtrAllocator Allocator;
   JavaAOTCompiler* AOT;
   if (EmitClassBytes) {
     AOT = new JavaAOTCompiler("AOT");
@@ -90,7 +90,7 @@
     vm->doExit = false;
     JavaThread* th = new JavaThread(vm);
     vm->setMainThread(th);
-    th->start((void (*)(mvm::Thread*))mainCompilerLoaderStart);
+    th->start((void (*)(vmkit::Thread*))mainCompilerLoaderStart);
     vm->waitForExit();
 
     AOT = (JavaAOTCompiler*)loader->getCompiler();

Modified: vmkit/trunk/tools/vmjc/vmjc.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmjc/vmjc.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/tools/vmjc/vmjc.cpp (original)
+++ vmkit/trunk/tools/vmjc/vmjc.cpp Mon Nov 21 05:03:32 2011
@@ -121,12 +121,12 @@
     return 0;
   }
    
-  mvm::VmkitModule::initialise(argc, argv);
-  mvm::Collector::initialise(argc, argv);
+  vmkit::VmkitModule::initialise(argc, argv);
+  vmkit::Collector::initialise(argc, argv);
 
   JavaAOTCompiler* Comp = new JavaAOTCompiler("AOT");
 
-  mvm::BumpPtrAllocator allocator;
+  vmkit::BumpPtrAllocator allocator;
   JnjvmBootstrapLoader* loader = new(allocator, "Bootstrap loader")
     JnjvmBootstrapLoader(allocator, Comp, false);
 




From gael.thomas at lip6.fr  Mon Nov 21 03:12:46 2011
From: gael.thomas at lip6.fr (=?ISO-8859-1?Q?Ga=EBl_Thomas?=)
Date: Mon, 21 Nov 2011 12:12:46 +0100
Subject: [vmkit-commits] Renaming
Message-ID: <CAOWuPDeyGLTbd4LcqJMiLKpmYd-B=u=g=QAFA495qCvio9n6GQ@mail.gmail.com>

Hi all!

The renaming is now ok, you will no more find any mvm in the code
(except a JamVM :)),

Gaël


PS: I have a bug (since two weeks, not related to the renaming) in the
macos version (lion, pentium 64bits). It fails randomly with a
SIGSEGV. Any idea? I will try to fix this or at least to give you some
useful context.


-- 
-------------------------------------------------------------------------------------------------
Gaël Thomas, Associate Professor,
University of Pierre and Marie Curie
Boite courrier 169, 217 - 26-00, REGAL Team, INRIA/LIP6,
4, place Jussieu, 75252 Paris Cedex 05, France
Web: http://pagesperso-systeme.lip6.fr/Gael.Thomas/
Phone (mob): +33 6 10 39 31 17           Fax : +33 1 44 27 70 00
-------------------------------------------------------------------------------------------------



From nicolas.geoffray at gmail.com  Mon Nov 21 03:28:26 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Mon, 21 Nov 2011 12:28:26 +0100
Subject: [vmkit-commits] Renaming
In-Reply-To: <CAOWuPDeyGLTbd4LcqJMiLKpmYd-B=u=g=QAFA495qCvio9n6GQ@mail.gmail.com>
References: <CAOWuPDeyGLTbd4LcqJMiLKpmYd-B=u=g=QAFA495qCvio9n6GQ@mail.gmail.com>
Message-ID: <CAPYwfirMd1ms=g8_dXicY7ajWOPmkMk6CmkSZBfA3fX4HPtdVQ@mail.gmail.com>

Hi Gael!

On Mon, Nov 21, 2011 at 12:12 PM, Gaël Thomas <gael.thomas at lip6.fr> wrote:

> Hi all!
>
> The renaming is now ok, you will no more find any mvm in the code
> (except a JamVM :)),
>
> Gaël
>
>
> PS: I have a bug (since two weeks, not related to the renaming) in the
> macos version (lion, pentium 64bits).


I think you're our first developer using lion :)


> It fails randomly with a
> SIGSEGV. Any idea? I will try to fix this or at least to give you some
> useful context.
>

What program did you use? On snow leopard, 64bits, I generally run the
decapo benchmarks without problems.

Cheers,
Nicolas


>
> --
>
> -------------------------------------------------------------------------------------------------
> Gaël Thomas, Associate Professor,
> University of Pierre and Marie Curie
> Boite courrier 169, 217 - 26-00, REGAL Team, INRIA/LIP6,
> 4, place Jussieu, 75252 Paris Cedex 05, France
> Web: http://pagesperso-systeme.lip6.fr/Gael.Thomas/
> Phone (mob): +33 6 10 39 31 17           Fax : +33 1 44 27 70 00
>
> -------------------------------------------------------------------------------------------------
>
> _______________________________________________
> 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/20111121/68877a4a/attachment.html>

From gael.thomas at lip6.fr  Mon Nov 21 06:05:08 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Mon, 21 Nov 2011 14:05:08 -0000
Subject: [vmkit-commits] [vmkit] r145039 - in /vmkit/trunk: Makefile
 autoconf/configure.ac lib/J3/ lib/Makefile lib/j3/
 lib/j3/ClassLib/GNUClasspath/Makefile lib/j3/ClassLib/Makefile
 lib/j3/ClassLib/OpenJDK/Makefile lib/j3/Compiler/Makefile
 lib/j3/VMCore/Makefile mmtk/mmtk-alloc/Makefile mmtk/mmtk-j3/Makefile
 tools/j3/Main.cpp tools/precompiler/Precompiler.cpp tools/vmjc/vmjc.cpp
Message-ID: <20111121140508.E1C201BE001@llvm.org>

Author: gthomas
Date: Mon Nov 21 08:05:08 2011
New Revision: 145039

URL: http://llvm.org/viewvc/llvm-project?rev=145039&view=rev
Log:
lib/J3 is now lib/j3

Added:
    vmkit/trunk/lib/j3/
      - copied from r145038, vmkit/trunk/lib/J3/
Removed:
    vmkit/trunk/lib/J3/
Modified:
    vmkit/trunk/Makefile
    vmkit/trunk/autoconf/configure.ac
    vmkit/trunk/lib/Makefile
    vmkit/trunk/lib/j3/ClassLib/GNUClasspath/Makefile
    vmkit/trunk/lib/j3/ClassLib/Makefile
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/Makefile
    vmkit/trunk/lib/j3/Compiler/Makefile
    vmkit/trunk/lib/j3/VMCore/Makefile
    vmkit/trunk/mmtk/mmtk-alloc/Makefile
    vmkit/trunk/mmtk/mmtk-j3/Makefile
    vmkit/trunk/tools/j3/Main.cpp
    vmkit/trunk/tools/precompiler/Precompiler.cpp
    vmkit/trunk/tools/vmjc/vmjc.cpp

Modified: vmkit/trunk/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile?rev=145039&r1=145038&r2=145039&view=diff
==============================================================================
--- vmkit/trunk/Makefile (original)
+++ vmkit/trunk/Makefile Mon Nov 21 08:05:08 2011
@@ -25,5 +25,5 @@
 #------------------------------------------------------------------------
 FilesToConfig := \
   include/llvm/Config/config.h \
-  lib/J3/Classpath/Classpath.h \
+  lib/j3/Classpath/Classpath.h \
 FilesToConfigPATH  := $(addprefix $(LLVM_OBJ_ROOT)/,$(FilesToConfig))

Modified: vmkit/trunk/autoconf/configure.ac
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/autoconf/configure.ac?rev=145039&r1=145038&r2=145039&view=diff
==============================================================================
--- vmkit/trunk/autoconf/configure.ac (original)
+++ vmkit/trunk/autoconf/configure.ac Mon Nov 21 08:05:08 2011
@@ -377,7 +377,7 @@
 dnl Configure a common Makefile
 AC_CONFIG_FILES(Makefile.common)
 AC_CONFIG_FILES(Makefile.config)
-AC_CONFIG_FILES([lib/J3/ClassLib/Classpath.h])
+AC_CONFIG_FILES([lib/j3/ClassLib/Classpath.h])
 AC_CONFIG_FILES([tools/llcj/LinkPaths.h])
 AC_CONFIG_FILES([mmtk/java/src/org/j3/config/Selected.java])
 AC_CONFIG_FILES([mmtk/java/build.xml])

Modified: vmkit/trunk/lib/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Makefile?rev=145039&r1=145038&r2=145039&view=diff
==============================================================================
--- vmkit/trunk/lib/Makefile (original)
+++ vmkit/trunk/lib/Makefile Mon Nov 21 08:05:08 2011
@@ -8,7 +8,7 @@
 ##===----------------------------------------------------------------------===##
 LEVEL = ..
 
-PARALLEL_DIRS = vmkit J3
+PARALLEL_DIRS = vmkit j3
 
 include $(LEVEL)/Makefile.config
 

Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/Makefile?rev=145039&r1=145038&r2=145039&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/Makefile (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/Makefile Mon Nov 21 08:05:08 2011
@@ -1,4 +1,4 @@
-##===- lib/J3/ClassLib/GNUClasspath/Makefile ---------------*- Makefile -*-===##
+##===- lib/j3/ClassLib/GNUClasspath/Makefile ---------------*- Makefile -*-===##
 # 
 #                     The vmkit project
 #

Modified: vmkit/trunk/lib/j3/ClassLib/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/Makefile?rev=145039&r1=145038&r2=145039&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/Makefile (original)
+++ vmkit/trunk/lib/j3/ClassLib/Makefile Mon Nov 21 08:05:08 2011
@@ -1,4 +1,4 @@
-##===- lib/J3/ClassLib/Makefile ----------------------------*- Makefile -*-===##
+##===- lib/j3/ClassLib/Makefile ----------------------------*- Makefile -*-===##
 #
 #                     The vmkit project
 #

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/Makefile?rev=145039&r1=145038&r2=145039&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/Makefile (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/Makefile Mon Nov 21 08:05:08 2011
@@ -1,4 +1,4 @@
-##===- lib/J3/ClassLib/OpenJDK/Makefile --------------------*- Makefile -*-===##
+##===- lib/j3/ClassLib/OpenJDK/Makefile --------------------*- Makefile -*-===##
 # 
 #                     The vmkit project
 #

Modified: vmkit/trunk/lib/j3/Compiler/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/Compiler/Makefile?rev=145039&r1=145038&r2=145039&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/Compiler/Makefile (original)
+++ vmkit/trunk/lib/j3/Compiler/Makefile Mon Nov 21 08:05:08 2011
@@ -1,4 +1,4 @@
-##===- lib/J3/Compiler/Makefile ----------------------------*- Makefile -*-===##
+##===- lib/j3/Compiler/Makefile ----------------------------*- Makefile -*-===##
 # 
 #                     The VMKit project
 #

Modified: vmkit/trunk/lib/j3/VMCore/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/Makefile?rev=145039&r1=145038&r2=145039&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/Makefile (original)
+++ vmkit/trunk/lib/j3/VMCore/Makefile Mon Nov 21 08:05:08 2011
@@ -1,4 +1,4 @@
-##===- lib/J3/VMCore/Makefile ------------------------------*- Makefile -*-===##
+##===- lib/j3/VMCore/Makefile ------------------------------*- Makefile -*-===##
 # 
 #                     The vmkit project
 #

Modified: vmkit/trunk/mmtk/mmtk-alloc/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-alloc/Makefile?rev=145039&r1=145038&r2=145039&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-alloc/Makefile (original)
+++ vmkit/trunk/mmtk/mmtk-alloc/Makefile Mon Nov 21 08:05:08 2011
@@ -15,7 +15,7 @@
 LOADABLE_MODULE = 1
 USEDLIBS =
 
-CXX.Flags += -I$(PROJ_SRC_DIR)/../../lib/J3/VMCore
+CXX.Flags += -I$(PROJ_SRC_DIR)/../../lib/j3/VMCore
 
 include $(LEVEL)/Makefile.common
 

Modified: vmkit/trunk/mmtk/mmtk-j3/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Makefile?rev=145039&r1=145038&r2=145039&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Makefile (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Makefile Mon Nov 21 08:05:08 2011
@@ -15,7 +15,7 @@
 LIBRARYNAME = MMTKRuntime
 LOADABLE_MODULE = 1
 
-CXX.Flags += -I$(PROJ_SRC_DIR)/../../lib/J3/VMCore
+CXX.Flags += -I$(PROJ_SRC_DIR)/../../lib/j3/VMCore
 
 include $(LEVEL)/Makefile.common
 

Modified: vmkit/trunk/tools/j3/Main.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/j3/Main.cpp?rev=145039&r1=145038&r2=145039&view=diff
==============================================================================
--- vmkit/trunk/tools/j3/Main.cpp (original)
+++ vmkit/trunk/tools/j3/Main.cpp Mon Nov 21 08:05:08 2011
@@ -14,8 +14,8 @@
 #include "vmkit/Thread.h"
 
 #include "j3/JavaJITCompiler.h"
-#include "../../lib/J3/VMCore/JnjvmClassLoader.h"
-#include "../../lib/J3/VMCore/Jnjvm.h"
+#include "../../lib/j3/VMCore/JnjvmClassLoader.h"
+#include "../../lib/j3/VMCore/Jnjvm.h"
 
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ManagedStatic.h"

Modified: vmkit/trunk/tools/precompiler/Precompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/precompiler/Precompiler.cpp?rev=145039&r1=145038&r2=145039&view=diff
==============================================================================
--- vmkit/trunk/tools/precompiler/Precompiler.cpp (original)
+++ vmkit/trunk/tools/precompiler/Precompiler.cpp Mon Nov 21 08:05:08 2011
@@ -23,9 +23,9 @@
 
 #include "j3/JavaAOTCompiler.h"
 #include "j3/JavaJITCompiler.h"
-#include "../../lib/J3/VMCore/JavaThread.h"
-#include "../../lib/J3/VMCore/JnjvmClassLoader.h"
-#include "../../lib/J3/VMCore/Jnjvm.h"
+#include "../../lib/j3/VMCore/JavaThread.h"
+#include "../../lib/j3/VMCore/JnjvmClassLoader.h"
+#include "../../lib/j3/VMCore/Jnjvm.h"
 
 #include <string>
 

Modified: vmkit/trunk/tools/vmjc/vmjc.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmjc/vmjc.cpp?rev=145039&r1=145038&r2=145039&view=diff
==============================================================================
--- vmkit/trunk/tools/vmjc/vmjc.cpp (original)
+++ vmkit/trunk/tools/vmjc/vmjc.cpp Mon Nov 21 08:05:08 2011
@@ -45,8 +45,8 @@
 
 #include "j3/JavaAOTCompiler.h"
 
-#include "../../lib/J3/VMCore/JnjvmClassLoader.h"
-#include "../../lib/J3/VMCore/Jnjvm.h"
+#include "../../lib/j3/VMCore/JnjvmClassLoader.h"
+#include "../../lib/j3/VMCore/Jnjvm.h"
 
 #include <iostream>
 #include <fstream>




From wdietz2 at illinois.edu  Mon Nov 21 10:26:23 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 21 Nov 2011 18:26:23 -0000
Subject: [vmkit-commits] [vmkit] r145043 - in /vmkit/trunk/lib/j3:
 ClassLib/OpenJDK/JavaUpcalls.cpp VMCore/JniOpenJDK.inc
Message-ID: <20111121182623.170571BE002@llvm.org>

Author: wdietz2
Date: Mon Nov 21 12:26:22 2011
New Revision: 145043

URL: http://llvm.org/viewvc/llvm-project?rev=145043&view=rev
Log:
Impl DirectByteBuffers for OpenJDK

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp
    vmkit/trunk/lib/j3/VMCore/JniOpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp?rev=145043&r1=145042&r2=145043&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp Mon Nov 21 12:26:22 2011
@@ -471,7 +471,6 @@
   newDirectByteBuffer =
     UPCALL_CLASS(loader, "java/nio/DirectByteBuffer");
 
-  //TODO: Revisit this one, verify signature.
   InitDirectByteBuffer =
     UPCALL_METHOD(loader, "java/nio/DirectByteBuffer", "<init>", "(JI)V",
                   ACC_VIRTUAL);
@@ -549,7 +548,7 @@
     UPCALL_ARRAY_CLASS(loader, "java/lang/Class", 1);
 
   bufferAddress =
-    UPCALL_FIELD(loader, "java/nio/Buffer", "address", "Lgnu/classpath/Pointer;",
+    UPCALL_FIELD(loader, "java/nio/Buffer", "address", "J",
                  ACC_VIRTUAL);
 
   vmdataClassLoader =

Modified: vmkit/trunk/lib/j3/VMCore/JniOpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JniOpenJDK.inc?rev=145043&r1=145042&r2=145043&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JniOpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/VMCore/JniOpenJDK.inc Mon Nov 21 12:26:22 2011
@@ -1,14 +1,39 @@
 // OpenJDK-specific JNI implementation
 
-// We don't support DirectBuffer calls yet. TODO: Implement these!
 jobject NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity) {
-  NYI();
-  abort();
-  return NULL;
+  BEGIN_JNI_EXCEPTION
+
+  JavaObject* res = 0;
+  llvm_gcroot(res, 0);
+
+  JavaThread* th = JavaThread::get();
+  Jnjvm* myvm = th->getJVM();
+  UserClass* BB = myvm->upcalls->newDirectByteBuffer;
+
+  res = BB->doNew(myvm);
+
+  myvm->upcalls->InitDirectByteBuffer->invokeIntSpecial(myvm, BB, res,
+    (uint64_t)(uintptr_t)address, (int)capacity);
+
+  jobject ret = (jobject)th->pushJNIRef(res);
+  RETURN_FROM_JNI(ret);
+  END_JNI_EXCEPTION
+
+  RETURN_FROM_JNI(0);
 }
 
 void *GetDirectBufferAddress(JNIEnv *env, jobject _buf) {
-  NYI();
-  abort();
-  return NULL;
+  BEGIN_JNI_EXCEPTION
+
+  // Local object references.
+  JavaObject* buf = *(JavaObject**)_buf;
+  llvm_gcroot(buf, 0);
+  jlong address;
+
+  Jnjvm* vm = myVM(env);
+  address = vm->upcalls->bufferAddress->getInstanceLongField(buf);
+  RETURN_FROM_JNI((void*)address);
+
+  END_JNI_EXCEPTION
+  RETURN_FROM_JNI(0);
 }




From wdietz2 at illinois.edu  Mon Nov 21 10:26:20 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 21 Nov 2011 18:26:20 -0000
Subject: [vmkit-commits] [vmkit] r145042 - /vmkit/trunk/configure
Message-ID: <20111121182620.D46A91BE001@llvm.org>

Author: wdietz2
Date: Mon Nov 21 12:26:20 2011
New Revision: 145042

URL: http://llvm.org/viewvc/llvm-project?rev=145042&view=rev
Log:
Regenerated configure

Modified:
    vmkit/trunk/configure

Modified: vmkit/trunk/configure
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/configure?rev=145042&r1=145041&r2=145042&view=diff
==============================================================================
--- vmkit/trunk/configure (original)
+++ vmkit/trunk/configure Mon Nov 21 12:26:20 2011
@@ -5789,7 +5789,7 @@
 
 ac_config_files="$ac_config_files Makefile.config"
 
-ac_config_files="$ac_config_files lib/J3/ClassLib/Classpath.h"
+ac_config_files="$ac_config_files lib/j3/ClassLib/Classpath.h"
 
 ac_config_files="$ac_config_files tools/llcj/LinkPaths.h"
 
@@ -6518,7 +6518,7 @@
     "include/vmkit/config.h") CONFIG_HEADERS="$CONFIG_HEADERS include/vmkit/config.h" ;;
     "Makefile.common") CONFIG_FILES="$CONFIG_FILES Makefile.common" ;;
     "Makefile.config") CONFIG_FILES="$CONFIG_FILES Makefile.config" ;;
-    "lib/J3/ClassLib/Classpath.h") CONFIG_FILES="$CONFIG_FILES lib/J3/ClassLib/Classpath.h" ;;
+    "lib/j3/ClassLib/Classpath.h") CONFIG_FILES="$CONFIG_FILES lib/j3/ClassLib/Classpath.h" ;;
     "tools/llcj/LinkPaths.h") CONFIG_FILES="$CONFIG_FILES tools/llcj/LinkPaths.h" ;;
     "mmtk/java/src/org/j3/config/Selected.java") CONFIG_FILES="$CONFIG_FILES mmtk/java/src/org/j3/config/Selected.java" ;;
     "mmtk/java/build.xml") CONFIG_FILES="$CONFIG_FILES mmtk/java/build.xml" ;;




From wdietz2 at illinois.edu  Tue Nov 22 15:54:58 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 22 Nov 2011 23:54:58 -0000
Subject: [vmkit-commits] [vmkit] r145089 - in /vmkit/trunk/lib/j3/ClassLib:
 DefineClass.inc GNUClasspath/ClasspathVMClassLoader.inc OpenJDK/OpenJDK.inc
Message-ID: <20111122235458.8D4602A6C134@llvm.org>

Author: wdietz2
Date: Tue Nov 22 17:54:58 2011
New Revision: 145089

URL: http://llvm.org/viewvc/llvm-project?rev=145089&view=rev
Log:
Refactor class definition to DefineClass.inc

Lends OpenJDK's defineClass implementation the magic and duplicate checks.

Added:
    vmkit/trunk/lib/j3/ClassLib/DefineClass.inc
Modified:
    vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMClassLoader.inc
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Added: vmkit/trunk/lib/j3/ClassLib/DefineClass.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/DefineClass.inc?rev=145089&view=auto
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/DefineClass.inc (added)
+++ vmkit/trunk/lib/j3/ClassLib/DefineClass.inc Tue Nov 22 17:54:58 2011
@@ -0,0 +1,31 @@
+// DefineClass.inc
+
+UserClass* defineClass(JnjvmClassLoader * JCL, const UTF8* className,
+  const char* buf, size_t bufLen) {
+  JavaObject* excp = 0;
+  llvm_gcroot(excp, 0);
+
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  ClassBytes * classBytes = new (JCL->allocator, bufLen) ClassBytes(bufLen);
+  memcpy(classBytes->elements, buf, bufLen);
+  Reader reader(classBytes);
+
+  // Before creating a class, do a check on the bytes.
+  uint32 magic = reader.readU4();
+  if (magic != Jnjvm::Magic) {
+    JavaThread::get()->getJVM()->classFormatError("bad magic number");
+    UNREACHABLE();
+  }
+
+  // Also check that we don't already have a class for this name
+  if (JCL->lookupClass(className)) {
+    excp = vm->CreateLinkageError("duplicate class definition");
+    JavaThread::get()->throwException(excp);
+    UNREACHABLE();
+  }
+
+  // Construct the class
+  UserClass* cl = JCL->constructClass(className, classBytes);
+  cl->resolveClass();
+  return cl;
+}

Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMClassLoader.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMClassLoader.inc?rev=145089&r1=145088&r2=145089&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMClassLoader.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMClassLoader.inc Tue Nov 22 17:54:58 2011
@@ -10,6 +10,7 @@
 #include "types.h"
 
 #include "Classpath.h"
+#include "DefineClass.inc"
 #include "JavaArray.h"
 #include "JavaClass.h"
 #include "JavaObject.h"
@@ -120,48 +121,27 @@
 JavaObject* pd) {
   
   JavaObject* res = 0;
-  JavaObject* excp = 0;
   llvm_gcroot(loader, 0);
   llvm_gcroot(str, 0);
   llvm_gcroot(bytes, 0);
   llvm_gcroot(pd, 0);
   llvm_gcroot(res, 0);
-  llvm_gcroot(excp, 0);
 
   BEGIN_NATIVE_EXCEPTION(0)
-  
+
   // We need a name, which is unfortunately not required by the spec.
   verifyNull(str);
 
   Jnjvm* vm = JavaThread::get()->getJVM();
 
-  JnjvmClassLoader* JCL = 
+  JnjvmClassLoader* JCL =
     JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
- 
-  int32_t size = JavaArray::getSize(bytes);
-  ClassBytes* classBytes = new (JCL->allocator, size) ClassBytes(size);
-  memcpy(classBytes->elements, JavaArray::getElements(bytes), size);
-   
-  // Before creating a class, do a check on the bytes.  
-  Reader reader(classBytes);
-  uint32 magic = reader.readU4();
-  if (magic != Jnjvm::Magic) {
-    JavaThread::get()->getJVM()->classFormatError("bad magic number");
-  }
 
-  
   const UTF8* name = JavaString::javaToInternal(str, JCL->hashUTF8);
-  UserCommonClass* cl = JCL->lookupClass(name);
-  
-  if (!cl) {
-    UserClass* cl = JCL->constructClass(name, classBytes);
-    cl->resolveClass();
-
-    res = cl->getClassDelegatee(vm, pd);
-  } else {
-    excp = vm->CreateLinkageError("duplicate class definition");
-    JavaThread::get()->throwException(excp);
-  }
+
+  UserClass* cl = defineClass(JCL, name,
+    (const char*)JavaArray::getElements(bytes), JavaArray::getSize(bytes));
+  res = cl->getClassDelegatee(vm, pd);
 
   END_NATIVE_EXCEPTION
 

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145089&r1=145088&r2=145089&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov 22 17:54:58 2011
@@ -13,6 +13,7 @@
 
 #include "ArrayCopy.inc"
 #include "ClassContext.inc"
+#include "DefineClass.inc"
 #include "SetProperties.inc"
 
 #include <errno.h>
@@ -1115,18 +1116,16 @@
 
   loader = _loader ? *(JavaObject**)_loader : 0;
 
-  jclass res;
+  jclass res = 0;
 
   Jnjvm* vm = JavaThread::get()->getJVM();
   JnjvmClassLoader* JCL = NULL;
   JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
-
-  ClassBytes * bytes = new (JCL->allocator, len) ClassBytes(len);
-  memcpy(bytes->elements,buf,len);
   const UTF8* utfName = JCL->asciizConstructUTF8(name);
-  UserClass *cl = JCL->constructClass(utfName, bytes);
 
-  if (cl) res = (jclass)cl->getClassDelegateePtr(vm);
+  UserClass* cl = defineClass(JCL, utfName, (const char*)buf, len);
+
+  res = (jclass)cl->getClassDelegateePtr(vm, pd ? *(JavaObject**)pd : 0);
 
   RETURN_FROM_JNI(res);
 




From wdietz2 at illinois.edu  Tue Nov 22 15:55:00 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 22 Nov 2011 23:55:00 -0000
Subject: [vmkit-commits] [vmkit] r145090 - in /vmkit/trunk/lib/j3/ClassLib:
 ArrayCopy.inc OpenJDK/OpenJDK.inc
Message-ID: <20111122235500.960162A6C134@llvm.org>

Author: wdietz2
Date: Tue Nov 22 17:55:00 2011
New Revision: 145090

URL: http://llvm.org/viewvc/llvm-project?rev=145090&view=rev
Log:
Small robustness improvements when passed NULL JavaObjects.

Now passes mauve's j.l.System tests, other than j.l.System.security

Modified:
    vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc?rev=145090&r1=145089&r2=145090&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc Tue Nov 22 17:55:00 2011
@@ -14,8 +14,6 @@
   llvm_gcroot(src, 0);
   llvm_gcroot(dst, 0);
   llvm_gcroot(cur, 0);
-  assert(src->getVirtualTable());
-  assert(dst->getVirtualTable());
 
   JavaThread* th = JavaThread::get();
   Jnjvm *vm = th->getJVM();
@@ -32,6 +30,9 @@
     UNREACHABLE();
   }
 
+  assert(src->getVirtualTable());
+  assert(dst->getVirtualTable());
+
   UserClassArray* ts = (UserClassArray*)JavaObject::getClass(src);
   UserClassArray* td = (UserClassArray*)JavaObject::getClass(dst);
   UserCommonClass* dstType = td->baseClass();

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145090&r1=145089&r2=145090&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov 22 17:55:00 2011
@@ -110,7 +110,7 @@
 
 JNIEXPORT jint JNICALL
 JVM_IHashCode(JNIEnv *env, jobject _obj) {
-  JavaObject * obj = *(JavaObject**)_obj;
+  JavaObject * obj = _obj ? *(JavaObject**)_obj : 0;
   llvm_gcroot(obj, 0);
 
   jint hash = (obj == NULL) ? 0 : JavaObject::hashCode(obj);
@@ -226,8 +226,8 @@
 
   BEGIN_JNI_EXCEPTION
 
-  src = *(JavaObject**)jsrc;
-  dst = *(JavaObject**)jdst;
+  src = jsrc ? *(JavaObject**)jsrc : 0;
+  dst = jdst ? *(JavaObject**)jdst : 0;
 
   ArrayCopy(src, sstart, dst, dstart, len);
 




From wdietz2 at illinois.edu  Tue Nov 22 15:55:03 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 22 Nov 2011 23:55:03 -0000
Subject: [vmkit-commits] [vmkit] r145091 - in /vmkit/trunk/lib/j3:
 ClassLib/GNUClasspath/JavaUpcalls.cpp ClassLib/GNUClasspath/JavaUpcalls.h
 ClassLib/OpenJDK/JavaUpcalls.h VMCore/JavaObject.cpp VMCore/Jnjvm.cpp
 VMCore/Jnjvm.h
Message-ID: <20111122235503.62D952A6C134@llvm.org>

Author: wdietz2
Date: Tue Nov 22 17:55:02 2011
New Revision: 145091

URL: http://llvm.org/viewvc/llvm-project?rev=145091&view=rev
Log:
Add support for CloneNotSupportedException, do so from JavaObject::clone

Modified:
    vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp
    vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h
    vmkit/trunk/lib/j3/VMCore/JavaObject.cpp
    vmkit/trunk/lib/j3/VMCore/Jnjvm.cpp
    vmkit/trunk/lib/j3/VMCore/Jnjvm.h

Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp?rev=145091&r1=145090&r2=145091&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp Tue Nov 22 17:55:02 2011
@@ -93,6 +93,7 @@
 JavaField*  Classpath::vmdataClassLoader;
 JavaMethod* Classpath::InitDirectByteBuffer;
 Class*      Classpath::newClassLoader;
+Class*      Classpath::cloneableClass;
 
 
 JavaField*  Classpath::boolValue;
@@ -152,6 +153,7 @@
 Class* Classpath::UnknownError;
 Class* Classpath::ClassNotFoundException;
 Class* Classpath::ArithmeticException;
+Class* Classpath::CloneNotSupportedException;
 
 JavaMethod* Classpath::InitInvocationTargetException;
 JavaMethod* Classpath::InitArrayStoreException;
@@ -185,6 +187,7 @@
 JavaMethod* Classpath::InitUnknownError;
 JavaMethod* Classpath::InitClassNotFoundException;
 JavaMethod* Classpath::InitArithmeticException;
+JavaMethod* Classpath::InitCloneNotSupportedException;
 JavaMethod* Classpath::InitObject;
 JavaMethod* Classpath::FinalizeObject;
 JavaMethod* Classpath::IntToString;
@@ -783,6 +786,7 @@
   UPCALL_CLASS_EXCEPTION(loader, UnknownError);
   UPCALL_CLASS_EXCEPTION(loader, ClassNotFoundException);
   UPCALL_CLASS_EXCEPTION(loader, ArithmeticException);
+  UPCALL_CLASS_EXCEPTION(loader, CloneNotSupportedException);
   
   UPCALL_METHOD_EXCEPTION(loader, InvocationTargetException);
   UPCALL_METHOD_EXCEPTION(loader, ArrayStoreException);
@@ -816,6 +820,7 @@
   UPCALL_METHOD_EXCEPTION(loader, UnknownError);
   UPCALL_METHOD_EXCEPTION(loader, ClassNotFoundException);
   UPCALL_METHOD_EXCEPTION(loader, ArithmeticException);
+  UPCALL_METHOD_EXCEPTION(loader, CloneNotSupportedException);
   
   UPCALL_METHOD_WITH_EXCEPTION(loader, NoClassDefFoundError);
   UPCALL_METHOD_WITH_EXCEPTION(loader, ExceptionInInitializerError);
@@ -841,6 +846,8 @@
   SystemClass = UPCALL_CLASS(loader, "java/lang/System");
   EnumClass = UPCALL_CLASS(loader, "java/lang/Enum");
 
+  cloneableClass = UPCALL_CLASS(loader, "java/lang/Cloneable");
+
   newThread = 
     UPCALL_CLASS(loader, "java/lang/Thread");
   

Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h?rev=145091&r1=145090&r2=145091&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h Tue Nov 22 17:55:02 2011
@@ -103,6 +103,7 @@
   ISOLATE_STATIC UserClass*  newDirectByteBuffer;
   ISOLATE_STATIC JavaMethod* InitDirectByteBuffer;
   ISOLATE_STATIC JavaField*  vmdataClassLoader;
+  ISOLATE_STATIC UserClass*  cloneableClass;
   ISOLATE_STATIC UserClass*  enumClass;
 
   ISOLATE_STATIC JavaField* boolValue;
@@ -188,6 +189,7 @@
   ISOLATE_STATIC UserClass* UnknownError;
   ISOLATE_STATIC UserClass* ClassNotFoundException;
   ISOLATE_STATIC UserClass* ArithmeticException;
+  ISOLATE_STATIC UserClass* CloneNotSupportedException;
 
   ISOLATE_STATIC JavaMethod* InitInvocationTargetException;
   ISOLATE_STATIC JavaMethod* InitArrayStoreException;
@@ -221,6 +223,7 @@
   ISOLATE_STATIC JavaMethod* InitUnknownError;
   ISOLATE_STATIC JavaMethod* InitClassNotFoundException;
   ISOLATE_STATIC JavaMethod* InitArithmeticException;
+  ISOLATE_STATIC JavaMethod* InitCloneNotSupportedException;
   
   ISOLATE_STATIC JavaMethod* SystemArraycopy;
   ISOLATE_STATIC JavaMethod* VMSystemArraycopy;

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h?rev=145091&r1=145090&r2=145091&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h Tue Nov 22 17:55:02 2011
@@ -98,7 +98,7 @@
   ISOLATE_STATIC UserClass*  newDirectByteBuffer;
   ISOLATE_STATIC JavaMethod* InitDirectByteBuffer;
   ISOLATE_STATIC JavaField*  vmdataClassLoader;
-  ISOLATE_STATIC UserClass* cloneableClass;
+  ISOLATE_STATIC UserClass*  cloneableClass;
   ISOLATE_STATIC UserClass*  enumClass;
 
   ISOLATE_STATIC JavaField* boolValue;

Modified: vmkit/trunk/lib/j3/VMCore/JavaObject.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JavaObject.cpp?rev=145091&r1=145090&r2=145091&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JavaObject.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/JavaObject.cpp Tue Nov 22 17:55:02 2011
@@ -155,8 +155,8 @@
 
   // If this doesn't inherit the Cloneable interface, throw exception
   // TODO: Add support in both class libraries for the upcalls fields used here
-  //if (!JavaObject::instanceOf(src, vm->upcalls->cloneableClass))
-  //  vm->cloneNotSupportedException();
+  if (!JavaObject::instanceOf(src, vm->upcalls->cloneableClass))
+    vm->cloneNotSupportedException();
 
   if (cl->isArray()) {
     UserClassArray* array = cl->asArrayClass();

Modified: vmkit/trunk/lib/j3/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/Jnjvm.cpp?rev=145091&r1=145090&r2=145091&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/Jnjvm.cpp Tue Nov 22 17:55:02 2011
@@ -301,6 +301,11 @@
         upcalls->InitNullPointerException, (JavaString*)0);
 }
 
+void Jnjvm::cloneNotSupportedException() {
+  error(upcalls->CloneNotSupportedException,
+        upcalls->InitCloneNotSupportedException, (JavaString*)0);
+}
+
 JavaObject* Jnjvm::CreateIndexOutOfBoundsException(sint32 entry) {
   JavaString* str = NULL;
   llvm_gcroot(str, 0);
@@ -1153,6 +1158,8 @@
   LOAD_CLASS(upcalls->ArithmeticException); 
   LOAD_CLASS(upcalls->InstantiationException);
   LOAD_CLASS(upcalls->SystemClass);
+  LOAD_CLASS(upcalls->cloneableClass);
+  LOAD_CLASS(upcalls->CloneNotSupportedException);
 #undef LOAD_CLASS
 
   // Implementation-specific end-of-bootstrap initialization

Modified: vmkit/trunk/lib/j3/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/Jnjvm.h?rev=145091&r1=145090&r2=145091&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/j3/VMCore/Jnjvm.h Tue Nov 22 17:55:02 2011
@@ -286,6 +286,7 @@
   void classNotFoundException(JavaString* str);
   void noClassDefFoundError(UserClass* cl, const UTF8* name);
   void classFormatError(const char* str);
+  void cloneNotSupportedException();
   virtual void nullPointerException();
   virtual void stackOverflowError();
   




From nicolas.geoffray at lip6.fr  Thu Nov 24 13:11:59 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Thu, 24 Nov 2011 21:11:59 -0000
Subject: [vmkit-commits] [vmkit] r145123 -
	/vmkit/branches/release_030/www/releases/vmkit-0.30.tar.bz2
Message-ID: <20111124211159.489442A6C12D@llvm.org>

Author: geoffray
Date: Thu Nov 24 15:11:59 2011
New Revision: 145123

URL: http://llvm.org/viewvc/llvm-project?rev=145123&view=rev
Log:
Add vmkit release for llvm 3.0.


Added:
    vmkit/branches/release_030/www/releases/vmkit-0.30.tar.bz2   (with props)

Added: vmkit/branches/release_030/www/releases/vmkit-0.30.tar.bz2
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/release_030/www/releases/vmkit-0.30.tar.bz2?rev=145123&view=auto
==============================================================================
Binary file - no diff available.

Propchange: vmkit/branches/release_030/www/releases/vmkit-0.30.tar.bz2
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream




From gael.thomas at lip6.fr  Fri Nov 25 01:13:50 2011
From: gael.thomas at lip6.fr (Gael Thomas)
Date: Fri, 25 Nov 2011 09:13:50 -0000
Subject: [vmkit-commits] [vmkit] r145128 -
	/vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h
Message-ID: <20111125091350.42EB92A6C12D@llvm.org>

Author: gthomas
Date: Fri Nov 25 03:13:49 2011
New Revision: 145128

URL: http://llvm.org/viewvc/llvm-project?rev=145128&view=rev
Log:
add a virtual method in gc to properly align the vmkit virtual table with the C++ virtual table

Modified:
    vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h

Modified: vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h?rev=145128&r1=145127&r2=145128&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h (original)
+++ vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h Fri Nov 25 03:13:49 2011
@@ -58,6 +58,8 @@
 class gc : public gcRoot {
 public:
 
+	virtual void _fakeForSpecializedTracerSlot() {}
+
   size_t objectSize() const {
     abort();
     return 0;




From nicolas.geoffray at lip6.fr  Fri Nov 25 14:59:25 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Fri, 25 Nov 2011 22:59:25 -0000
Subject: [vmkit-commits] [vmkit] r145139 - in /vmkit/trunk/lib/j3/Compiler:
 JavaJIT.cpp JavaJITOpcodes.cpp
Message-ID: <20111125225925.692122A6C12D@llvm.org>

Author: geoffray
Date: Fri Nov 25 16:59:25 2011
New Revision: 145139

URL: http://llvm.org/viewvc/llvm-project?rev=145139&view=rev
Log:
Remove complexity of phi nodes on exception handlers.


Modified:
    vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp
    vmkit/trunk/lib/j3/Compiler/JavaJITOpcodes.cpp

Modified: vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp?rev=145139&r1=145138&r2=145139&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp Fri Nov 25 16:59:25 2011
@@ -2377,11 +2377,15 @@
     new UnreachableInst(*llvmContext, currentBlock);
   } else {
     Value* javaExceptionPtr = getJavaExceptionPtr(getJavaThreadPtr(getMutatorThreadPtr()));
-    new StoreInst(obj, javaExceptionPtr, currentBlock);
+    if (vmkit::Collector::needsNonHeapWriteBarrier()) {
+      Instruction* ptr = new BitCastInst(javaExceptionPtr, intrinsics->ptrPtrType, "", currentBlock);
+      Instruction* val = new BitCastInst(obj, intrinsics->ptrType, "", currentBlock);
+      Value* args[2] = { ptr, val };
+      CallInst::Create(intrinsics->NonHeapWriteBarrierFunction, args, "", currentBlock);
+    } else {
+      new StoreInst(obj, javaExceptionPtr, currentBlock);
+    }
 
-    Instruction* insn = currentExceptionBlock->begin();
-    PHINode* node = dyn_cast<PHINode>(insn);
-    if (node) node->addIncoming(obj, currentBlock);
     BranchInst::Create(currentExceptionBlock, currentBlock);
   }
 }
@@ -2470,9 +2474,6 @@
     
     ex->tester = createBasicBlock("testException");
     
-    // PHI Node for the exception object
-    PHINode::Create(intrinsics->JavaObjectType, 0, "", ex->tester);
-    
     // Set the unwind destination of the instructions in the range of this
     // handler to the test block of the handler. If an instruction already has
     // a handler and thus is not the synchronize or regular end handler block,
@@ -2491,18 +2492,12 @@
     // Set the Java handler for this exception.
     ex->javaHandler = opcodeInfos[ex->handlerpc].newBlock;
     opcodeInfos[ex->handlerpc].handler = true;
-    
-    if (ex->javaHandler->empty()) {
-      PHINode::Create(intrinsics->JavaObjectType, 0, "", ex->javaHandler);
-    }
-
   }
 
   // Loop over all handlers to implement their tester.
   for (sint16 i = 0; i < nbe - sync; ++i) {
     Handler* cur = &handlers[i];
     BasicBlock* bbNext = 0;
-    PHINode* javaNode = 0;
     currentExceptionBlock = opcodeInfos[cur->handlerpc].exceptionBlock;
 
     // Look out where we go if we're not the handler for the exception.
@@ -2516,8 +2511,6 @@
         // If there's a handler to goto, we jump to its tester block and record
         // the exception PHI node to give our exception to the tester.
         bbNext = next->tester;
-        javaNode = dyn_cast<PHINode>(bbNext->begin());
-        assert(javaNode);
       }
     } else {
       // If there's no handler after us, we jump to the end handler.
@@ -2532,7 +2525,8 @@
     Value* VTVar = TheCompiler->getVirtualTable(cur->catchClass->virtualVT);
 
     // Get the Java exception.
-    Value* obj = currentBlock->begin();
+    Value* javaExceptionPtr = getJavaExceptionPtr(getJavaThreadPtr(getMutatorThreadPtr()));
+    Value* obj = new LoadInst(javaExceptionPtr, "", currentBlock);
     
     Value* objVT = CallInst::Create(intrinsics->GetVTFunction, obj, "",
                                     currentBlock);
@@ -2560,28 +2554,11 @@
                          "");
     }
    
-    // Add the Java exception in the phi node of the handler.
-    Instruction* insn = cur->javaHandler->begin();
-    PHINode* node = dyn_cast<PHINode>(insn);
-    assert(node && "malformed exceptions");
-    node->addIncoming(obj, currentBlock);
-   
-    // Add the Java exception in the phi node of the next block.
-    if (javaNode)
-      javaNode->addIncoming(obj, currentBlock);
- 
     // If we are catching this exception, then jump to the Java Handler,
     // otherwise jump to our next handler.
     BranchInst::Create(cur->javaHandler, bbNext, cmp, currentBlock);
 
     currentBlock = cur->javaHandler;
-
-    // First thing in the handler: clear the exception.
-    Value* javaExceptionPtr = getJavaExceptionPtr(getJavaThreadPtr(getMutatorThreadPtr()));
-    
-    // Clear exception.
-    new StoreInst(intrinsics->JavaObjectNullConstant, javaExceptionPtr,
-                  currentBlock);
   }
  
   // Restore currentBlock.

Modified: vmkit/trunk/lib/j3/Compiler/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/Compiler/JavaJITOpcodes.cpp?rev=145139&r1=145138&r2=145139&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/Compiler/JavaJITOpcodes.cpp (original)
+++ vmkit/trunk/lib/j3/Compiler/JavaJITOpcodes.cpp Fri Nov 25 16:59:25 2011
@@ -132,10 +132,12 @@
       
       stack.clear();
       if (opinfo->handler) {
-        Instruction* I = opinfo->newBlock->begin();
-        assert(isa<PHINode>(I) && "Handler marlformed");
         // If it's a handler, put the exception object in the stack.
-        new StoreInst(I, objectStack[0], "", currentBlock);
+        Value* javaExceptionPtr = getJavaExceptionPtr(getJavaThreadPtr(getMutatorThreadPtr()));
+        Value* obj = new LoadInst(javaExceptionPtr, "", currentBlock);
+        new StoreInst(obj, objectStack[0], "", currentBlock);
+        // And clear the exception.
+        new StoreInst(intrinsics->JavaObjectNullConstant, javaExceptionPtr, currentBlock);
         stack.push_back(MetaInfo(upcalls->OfObject, NOP));
         currentStackIndex = 1;
       } else {




From nicolas.geoffray at lip6.fr  Fri Nov 25 16:31:19 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Sat, 26 Nov 2011 00:31:19 -0000
Subject: [vmkit-commits] [vmkit] r145140 - in /vmkit/trunk/lib/j3:
 Compiler/JavaJIT.cpp VMCore/JavaThread.cpp VMCore/Jni.cpp
Message-ID: <20111126003120.0FCDF2A6C12D@llvm.org>

Author: geoffray
Date: Fri Nov 25 18:31:19 2011
New Revision: 145140

URL: http://llvm.org/viewvc/llvm-project?rev=145140&view=rev
Log:
Use NonHeapWriteBarrier for GC objects in JavaThread.


Modified:
    vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp
    vmkit/trunk/lib/j3/VMCore/JavaThread.cpp
    vmkit/trunk/lib/j3/VMCore/Jni.cpp

Modified: vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp?rev=145140&r1=145139&r2=145140&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp Fri Nov 25 18:31:19 2011
@@ -2332,16 +2332,7 @@
     BranchInst::Create(ifNormal, currentBlock);
 
     currentBlock = ifException;
-    CallInst::Create(intrinsics->UnregisterSetjmpFunction, jmpBuffer, "", currentBlock);
- 
-    if (!currentExceptionBlock->empty()) {
-      // Get the Java exception.
-      Value* javaExceptionPtr = getJavaExceptionPtr(getJavaThreadPtr(getMutatorThreadPtr())); 
-      Value* obj = new LoadInst(javaExceptionPtr, "", currentBlock);
-      Instruction* insn = currentExceptionBlock->begin();
-      PHINode* node = dyn_cast<PHINode>(insn);
-      if (node) node->addIncoming(obj, currentBlock);
-    } 
+    CallInst::Create(intrinsics->UnregisterSetjmpFunction, jmpBuffer, "", currentBlock); 
     BranchInst::Create(currentExceptionBlock, currentBlock);
     currentBlock = ifNormal; 
   }

Modified: vmkit/trunk/lib/j3/VMCore/JavaThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JavaThread.cpp?rev=145140&r1=145139&r2=145140&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JavaThread.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/JavaThread.cpp Fri Nov 25 18:31:19 2011
@@ -32,8 +32,8 @@
 void JavaThread::initialise(JavaObject* thread, JavaObject* vmth) {
   llvm_gcroot(thread, 0);
   llvm_gcroot(vmth, 0);
-  javaThread = thread;
-  vmThread = vmth;
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)&javaThread, (gc*)thread);
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)&vmThread, (gc*)vmth);
 }
 
 JavaThread::~JavaThread() {
@@ -42,16 +42,14 @@
 
 void JavaThread::throwException(JavaObject* obj) {
   llvm_gcroot(obj, 0);
-  JavaThread* th = JavaThread::get();
-  assert(th->pendingException == 0 && "pending exception already there?");
-  th->pendingException = obj;
-  th->internalThrowException();
+  assert(pendingException == 0 && "pending exception already there?");
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)&pendingException, (gc*)obj);
+  internalThrowException();
 }
 
 void JavaThread::throwPendingException() {
-  JavaThread* th = JavaThread::get();
-  assert(th->pendingException);
-  th->internalThrowException();
+  assert(pendingException);
+  internalThrowException();
 }
 
 void JavaThread::startJNI() {
@@ -143,7 +141,8 @@
     next->prev = this;
     return next->addJNIReference(th, obj);
   } else {
-    localReferences[length] = obj;
+    vmkit::Collector::objectReferenceNonHeapWriteBarrier(
+        (gc**)&(localReferences[length]), (gc*)obj);
     return &localReferences[length++];
   }
 }

Modified: vmkit/trunk/lib/j3/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/Jni.cpp?rev=145140&r1=145139&r2=145140&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/Jni.cpp Fri Nov 25 18:31:19 2011
@@ -177,7 +177,11 @@
 
 jint Throw(JNIEnv *env, jthrowable obj) {
   BEGIN_JNI_EXCEPTION
-  JavaThread::get()->pendingException = *(JavaObject**)obj;
+  JavaObject* excp = *(JavaObject**)obj;
+  llvm_gcroot(excp, 0);
+  JavaThread* th = JavaThread::get();
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier(
+      (gc**)&(th->pendingException), (gc*)excp);
 
   RETURN_FROM_JNI(0);
 
@@ -212,7 +216,8 @@
                                           false, true, 0);
   str = vm->asciizToStr(msg);
   init->invokeIntSpecial(vm, realCl, res, &str);
-  th->pendingException = res;
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier(
+      (gc**)&(th->pendingException), (gc*)res);
   
   RETURN_FROM_JNI(0);
   




From nicolas.geoffray at lip6.fr  Sat Nov 26 13:13:43 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Sat, 26 Nov 2011 21:13:43 -0000
Subject: [vmkit-commits] [vmkit] r145150 - in /vmkit/trunk/lib/j3:
 Compiler/JavaJIT.cpp VMCore/JavaThread.cpp VMCore/Jni.cpp
Message-ID: <20111126211343.76F851BE002@llvm.org>

Author: geoffray
Date: Sat Nov 26 15:13:43 2011
New Revision: 145150

URL: http://llvm.org/viewvc/llvm-project?rev=145150&view=rev
Log:
Revert r145140, caused too many crashes.


Modified:
    vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp
    vmkit/trunk/lib/j3/VMCore/JavaThread.cpp
    vmkit/trunk/lib/j3/VMCore/Jni.cpp

Modified: vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp?rev=145150&r1=145149&r2=145150&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp Sat Nov 26 15:13:43 2011
@@ -2332,7 +2332,16 @@
     BranchInst::Create(ifNormal, currentBlock);
 
     currentBlock = ifException;
-    CallInst::Create(intrinsics->UnregisterSetjmpFunction, jmpBuffer, "", currentBlock); 
+    CallInst::Create(intrinsics->UnregisterSetjmpFunction, jmpBuffer, "", currentBlock);
+ 
+    if (!currentExceptionBlock->empty()) {
+      // Get the Java exception.
+      Value* javaExceptionPtr = getJavaExceptionPtr(getJavaThreadPtr(getMutatorThreadPtr())); 
+      Value* obj = new LoadInst(javaExceptionPtr, "", currentBlock);
+      Instruction* insn = currentExceptionBlock->begin();
+      PHINode* node = dyn_cast<PHINode>(insn);
+      if (node) node->addIncoming(obj, currentBlock);
+    } 
     BranchInst::Create(currentExceptionBlock, currentBlock);
     currentBlock = ifNormal; 
   }

Modified: vmkit/trunk/lib/j3/VMCore/JavaThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JavaThread.cpp?rev=145150&r1=145149&r2=145150&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JavaThread.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/JavaThread.cpp Sat Nov 26 15:13:43 2011
@@ -32,8 +32,8 @@
 void JavaThread::initialise(JavaObject* thread, JavaObject* vmth) {
   llvm_gcroot(thread, 0);
   llvm_gcroot(vmth, 0);
-  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)&javaThread, (gc*)thread);
-  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)&vmThread, (gc*)vmth);
+  javaThread = thread;
+  vmThread = vmth;
 }
 
 JavaThread::~JavaThread() {
@@ -42,14 +42,16 @@
 
 void JavaThread::throwException(JavaObject* obj) {
   llvm_gcroot(obj, 0);
-  assert(pendingException == 0 && "pending exception already there?");
-  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)&pendingException, (gc*)obj);
-  internalThrowException();
+  JavaThread* th = JavaThread::get();
+  assert(th->pendingException == 0 && "pending exception already there?");
+  th->pendingException = obj;
+  th->internalThrowException();
 }
 
 void JavaThread::throwPendingException() {
-  assert(pendingException);
-  internalThrowException();
+  JavaThread* th = JavaThread::get();
+  assert(th->pendingException);
+  th->internalThrowException();
 }
 
 void JavaThread::startJNI() {
@@ -141,8 +143,7 @@
     next->prev = this;
     return next->addJNIReference(th, obj);
   } else {
-    vmkit::Collector::objectReferenceNonHeapWriteBarrier(
-        (gc**)&(localReferences[length]), (gc*)obj);
+    localReferences[length] = obj;
     return &localReferences[length++];
   }
 }

Modified: vmkit/trunk/lib/j3/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/Jni.cpp?rev=145150&r1=145149&r2=145150&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/Jni.cpp Sat Nov 26 15:13:43 2011
@@ -177,11 +177,7 @@
 
 jint Throw(JNIEnv *env, jthrowable obj) {
   BEGIN_JNI_EXCEPTION
-  JavaObject* excp = *(JavaObject**)obj;
-  llvm_gcroot(excp, 0);
-  JavaThread* th = JavaThread::get();
-  vmkit::Collector::objectReferenceNonHeapWriteBarrier(
-      (gc**)&(th->pendingException), (gc*)excp);
+  JavaThread::get()->pendingException = *(JavaObject**)obj;
 
   RETURN_FROM_JNI(0);
 
@@ -216,8 +212,7 @@
                                           false, true, 0);
   str = vm->asciizToStr(msg);
   init->invokeIntSpecial(vm, realCl, res, &str);
-  vmkit::Collector::objectReferenceNonHeapWriteBarrier(
-      (gc**)&(th->pendingException), (gc*)res);
+  th->pendingException = res;
   
   RETURN_FROM_JNI(0);
   




From nicolas.geoffray at lip6.fr  Sat Nov 26 13:38:06 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Sat, 26 Nov 2011 21:38:06 -0000
Subject: [vmkit-commits] [vmkit] r145151 - in /vmkit/trunk/lib/j3:
 Compiler/JavaJIT.cpp VMCore/JavaThread.cpp VMCore/Jni.cpp
Message-ID: <20111126213806.7D1222A6C12D@llvm.org>

Author: geoffray
Date: Sat Nov 26 15:38:05 2011
New Revision: 145151

URL: http://llvm.org/viewvc/llvm-project?rev=145151&view=rev
Log:
Put a barrier on pendingException writes.


Modified:
    vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp
    vmkit/trunk/lib/j3/VMCore/JavaThread.cpp
    vmkit/trunk/lib/j3/VMCore/Jni.cpp

Modified: vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp?rev=145151&r1=145150&r2=145151&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp Sat Nov 26 15:38:05 2011
@@ -2333,15 +2333,6 @@
 
     currentBlock = ifException;
     CallInst::Create(intrinsics->UnregisterSetjmpFunction, jmpBuffer, "", currentBlock);
- 
-    if (!currentExceptionBlock->empty()) {
-      // Get the Java exception.
-      Value* javaExceptionPtr = getJavaExceptionPtr(getJavaThreadPtr(getMutatorThreadPtr())); 
-      Value* obj = new LoadInst(javaExceptionPtr, "", currentBlock);
-      Instruction* insn = currentExceptionBlock->begin();
-      PHINode* node = dyn_cast<PHINode>(insn);
-      if (node) node->addIncoming(obj, currentBlock);
-    } 
     BranchInst::Create(currentExceptionBlock, currentBlock);
     currentBlock = ifNormal; 
   }

Modified: vmkit/trunk/lib/j3/VMCore/JavaThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JavaThread.cpp?rev=145151&r1=145150&r2=145151&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JavaThread.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/JavaThread.cpp Sat Nov 26 15:38:05 2011
@@ -44,7 +44,7 @@
   llvm_gcroot(obj, 0);
   JavaThread* th = JavaThread::get();
   assert(th->pendingException == 0 && "pending exception already there?");
-  th->pendingException = obj;
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)&(th->pendingException), (gc*)obj);
   th->internalThrowException();
 }
 

Modified: vmkit/trunk/lib/j3/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/Jni.cpp?rev=145151&r1=145150&r2=145151&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/Jni.cpp Sat Nov 26 15:38:05 2011
@@ -177,7 +177,8 @@
 
 jint Throw(JNIEnv *env, jthrowable obj) {
   BEGIN_JNI_EXCEPTION
-  JavaThread::get()->pendingException = *(JavaObject**)obj;
+  JavaThread* th = JavaThread::get();
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)&(th->pendingException), *(gc**)obj);
 
   RETURN_FROM_JNI(0);
 
@@ -212,7 +213,7 @@
                                           false, true, 0);
   str = vm->asciizToStr(msg);
   init->invokeIntSpecial(vm, realCl, res, &str);
-  th->pendingException = res;
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)&(th->pendingException), (gc*)res);
   
   RETURN_FROM_JNI(0);
   




From wdietz2 at illinois.edu  Sat Nov 26 15:26:02 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 26 Nov 2011 23:26:02 -0000
Subject: [vmkit-commits] [vmkit] r145155 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111126232602.8F75C2A6C12D@llvm.org>

Author: wdietz2
Date: Sat Nov 26 17:26:02 2011
New Revision: 145155

URL: http://llvm.org/viewvc/llvm-project?rev=145155&view=rev
Log:
Impl jio_snprintf

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145155&r1=145154&r2=145155&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Sat Nov 26 17:26:02 2011
@@ -2399,7 +2399,14 @@
 
 int
 jio_snprintf(char *str, size_t count, const char *fmt, ...) {
-  NYI();
+  va_list args;
+  int res;
+
+  va_start(args, fmt);
+  res = vsnprintf(str, count, fmt, args);
+  va_end(args);
+
+  return res;
 }
 
 int




From wdietz2 at illinois.edu  Sat Nov 26 15:26:04 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Sat, 26 Nov 2011 23:26:04 -0000
Subject: [vmkit-commits] [vmkit] r145156 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111126232604.4F5652A6C12D@llvm.org>

Author: wdietz2
Date: Sat Nov 26 17:26:04 2011
New Revision: 145156

URL: http://llvm.org/viewvc/llvm-project?rev=145156&view=rev
Log:
Fix use of incorrect class when starting a thread's run() method (OpenJDK)

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145156&r1=145155&r2=145156&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Sat Nov 26 17:26:04 2011
@@ -518,7 +518,10 @@
 
   assert(javaThread->getVirtualTable());
   // Run the VMThread::run function
-  vm->upcalls->runThread->invokeIntSpecial(vm, vm->upcalls->newThread, javaThread);
+
+  UserClass* thClass = (UserClass*)JavaObject::getClass(javaThread);
+
+  vm->upcalls->runThread->invokeIntSpecial(vm, thClass, javaThread);
 
   // Remove the thread from the list.
   if (!isDaemon) {




From nicolas.geoffray at lip6.fr  Sun Nov 27 10:05:07 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Sun, 27 Nov 2011 18:05:07 -0000
Subject: [vmkit-commits] [vmkit] r145187 -
	/vmkit/trunk/lib/j3/VMCore/JavaThread.cpp
Message-ID: <20111127180507.928062A6C12D@llvm.org>

Author: geoffray
Date: Sun Nov 27 12:05:07 2011
New Revision: 145187

URL: http://llvm.org/viewvc/llvm-project?rev=145187&view=rev
Log:
Pute write barriers in JavaThread::init.


Modified:
    vmkit/trunk/lib/j3/VMCore/JavaThread.cpp

Modified: vmkit/trunk/lib/j3/VMCore/JavaThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JavaThread.cpp?rev=145187&r1=145186&r2=145187&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JavaThread.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/JavaThread.cpp Sun Nov 27 12:05:07 2011
@@ -32,8 +32,8 @@
 void JavaThread::initialise(JavaObject* thread, JavaObject* vmth) {
   llvm_gcroot(thread, 0);
   llvm_gcroot(vmth, 0);
-  javaThread = thread;
-  vmThread = vmth;
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)&javaThread, (gc*)thread);
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)&vmThread, (gc*)vmth);
 }
 
 JavaThread::~JavaThread() {




From nicolas.geoffray at lip6.fr  Sun Nov 27 14:34:51 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Sun, 27 Nov 2011 22:34:51 -0000
Subject: [vmkit-commits] [vmkit] r145205 - in /vmkit/trunk:
 include/vmkit/ObjectLocks.h lib/vmkit/CommonThread/ObjectLocks.cpp
Message-ID: <20111127223451.C82F92A6C12D@llvm.org>

Author: geoffray
Date: Sun Nov 27 16:34:51 2011
New Revision: 145205

URL: http://llvm.org/viewvc/llvm-project?rev=145205&view=rev
Log:
Put write barriers on FatLock.


Modified:
    vmkit/trunk/include/vmkit/ObjectLocks.h
    vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp

Modified: vmkit/trunk/include/vmkit/ObjectLocks.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/ObjectLocks.h?rev=145205&r1=145204&r2=145205&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/ObjectLocks.h (original)
+++ vmkit/trunk/include/vmkit/ObjectLocks.h Sun Nov 27 16:34:51 2011
@@ -84,6 +84,7 @@
   void release(gc* object, LockSystem& table);
   vmkit::Thread* getOwner();
   bool owner();
+  void setAssociatedObject(gc* obj);
   gc* getAssociatedObject() { return associatedObject; }
   gc** getAssociatedObjectPtr() { return &associatedObject; }
 

Modified: vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp?rev=145205&r1=145204&r2=145205&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp Sun Nov 27 16:34:51 2011
@@ -261,7 +261,7 @@
   assert(a != NULL);
   firstThread = NULL;
   index = i;
-  associatedObject = a;
+  setAssociatedObject(a);
   waitingThreads = 0;
   lockingThreads = 0;
   nextFreeLock = NULL;
@@ -338,7 +338,7 @@
     res->nextFreeLock = 0;
     assert(res->associatedObject == NULL);
     threadLock.unlock();
-    res->associatedObject = obj;
+    res->setAssociatedObject(obj);
   } else { 
     // Get an index.
     uint32_t index = currentIndex++;
@@ -538,4 +538,9 @@
   assert(vmkit::ThinLock::owner(self, table) && "Not owner after notifyAll");
 }
 
+void FatLock::setAssociatedObject(gc* obj) {
+  llvm_gcroot(obj, 0);
+  vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)&associatedObject, (gc*)obj);
+}
+
 }




From wdietz2 at illinois.edu  Mon Nov 28 13:09:58 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 28 Nov 2011 21:09:58 -0000
Subject: [vmkit-commits] [vmkit] r145278 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111128210958.A0BF62A6C12C@llvm.org>

Author: wdietz2
Date: Mon Nov 28 15:09:58 2011
New Revision: 145278

URL: http://llvm.org/viewvc/llvm-project?rev=145278&view=rev
Log:
Implement JVM_LatestUserDefinedLoader.

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145278&r1=145277&r2=145278&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Mon Nov 28 15:09:58 2011
@@ -794,7 +794,18 @@
 
 JNIEXPORT jobject JNICALL
 JVM_LatestUserDefinedLoader(JNIEnv *env) {
-  NYI();
+  JavaObject* res = 0;
+  llvm_gcroot(res, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  JavaThread* th = JavaThread::get();
+  res = th->getNonNullClassLoader();
+
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(res));
+  END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /*




From wdietz2 at illinois.edu  Mon Nov 28 13:16:06 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 28 Nov 2011 21:16:06 -0000
Subject: [vmkit-commits] [vmkit] r145279 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111128211606.1602B2A6C12C@llvm.org>

Author: wdietz2
Date: Mon Nov 28 15:16:05 2011
New Revision: 145279

URL: http://llvm.org/viewvc/llvm-project?rev=145279&view=rev
Log:
Implement JVM_NewMultiArray

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145279&r1=145278&r2=145279&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Mon Nov 28 15:16:05 2011
@@ -935,9 +935,89 @@
   return 0;
 }
 
+extern JavaObject* multiCallNewIntern(UserClassArray* cl, uint32 len,
+                               sint32* dims, Jnjvm* vm);
 JNIEXPORT jobject JNICALL
-JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim) {
-  NYI();
+JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray _dim) {
+  ArraySInt32* dim = 0;
+  JavaObjectClass * eltClassObj = 0;
+  JavaObject* array = 0;
+
+  llvm_gcroot(dim, 0);
+  llvm_gcroot(eltClassObj, 0);
+  llvm_gcroot(array, 0);
+
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm* vm = th->getJVM();
+
+  eltClassObj = *(JavaObjectClass**)eltClass;
+  dim = *(ArraySInt32**)_dim;
+
+  verifyNull(eltClassObj);
+  verifyNull(dim);
+
+  int dim_len = ArraySInt32::getSize(dim);
+  if(dim_len <= 0 || dim_len > 255) {
+    vm->illegalArgumentException("Too many dimensions for array");
+    UNREACHABLE();
+  }
+
+  UserCommonClass* base = JavaObjectClass::getClass(eltClassObj);
+  JnjvmClassLoader* loader = base->classLoader;
+
+  // Build array name
+  vmkit::ThreadAllocator allocator;
+  const UTF8* arrayName;
+  if (base->isPrimitive()) {
+    char baseChar;
+    if (base == vm->upcalls->OfBool) {
+      baseChar = I_BOOL;
+    } else if (base == vm->upcalls->OfByte) {
+      baseChar = I_BYTE;
+    } else if (base == vm->upcalls->OfShort) {
+      baseChar = I_SHORT;
+    } else if (base == vm->upcalls->OfChar) {
+      baseChar = I_CHAR;
+    } else if (base == vm->upcalls->OfInt) {
+      baseChar = I_INT;
+    } else if (base == vm->upcalls->OfFloat) {
+      baseChar = I_FLOAT;
+    } else if (base == vm->upcalls->OfLong) {
+      baseChar = I_LONG;
+    } else if (base == vm->upcalls->OfDouble) {
+      baseChar = I_DOUBLE;
+    } else {
+      vm->illegalArgumentException("Invalid array primitive type!");
+      UNREACHABLE();
+    }
+    char* buf = (char*)allocator.Allocate(dim_len+2);
+    for(unsigned i = 0; i < dim_len; ++i) buf[i] = I_TAB;
+    buf[dim_len] = baseChar;
+    buf[dim_len+1] = '\0';
+    arrayName = loader->asciizConstructUTF8(buf);
+  }
+  else {
+    const UTF8* baseName = base->getName();
+    arrayName = loader->constructArrayName(dim_len, baseName);
+  }
+
+  // Get class corresponding to array name
+  UserClassArray* arrayCl =
+    (UserClassArray*)loader->loadClassFromUserUTF8(arrayName, true, false, NULL);
+
+  // Convert dimensions array to internal representation
+  sint32* dims = (sint32*)allocator.Allocate(sizeof(sint32) * dim_len);
+  for (sint32 i = 0; i < dim_len; ++i){
+    dims[i] = ArraySInt32::getElement(dim, i);
+  }
+
+  // Invoke recursive helper to create this array
+  array = multiCallNewIntern(arrayCl, dim_len, dims, vm);
+
+  RETURN_FROM_JNI((jobject)th->pushJNIRef(array));
+
+  END_JNI_EXCEPTION
 }
 
 /*




From nicolas.geoffray at lip6.fr  Mon Nov 28 13:26:49 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Mon, 28 Nov 2011 21:26:49 -0000
Subject: [vmkit-commits] [vmkit] r145280 - in /vmkit/trunk/lib/j3/VMCore:
 JNIReferences.h JavaThread.cpp
Message-ID: <20111128212649.1F4A02A6C12C@llvm.org>

Author: geoffray
Date: Mon Nov 28 15:26:48 2011
New Revision: 145280

URL: http://llvm.org/viewvc/llvm-project?rev=145280&view=rev
Log:
Put write barriers for JNI local and global references.


Modified:
    vmkit/trunk/lib/j3/VMCore/JNIReferences.h
    vmkit/trunk/lib/j3/VMCore/JavaThread.cpp

Modified: vmkit/trunk/lib/j3/VMCore/JNIReferences.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JNIReferences.h?rev=145280&r1=145279&r2=145280&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JNIReferences.h (original)
+++ vmkit/trunk/lib/j3/VMCore/JNIReferences.h Mon Nov 28 15:26:48 2011
@@ -69,7 +69,8 @@
       return next->addJNIReference(obj);
     } else {
       ++count;
-      globalReferences[length] = obj;
+      vmkit::Collector::objectReferenceNonHeapWriteBarrier(
+          (gc**)&(globalReferences[length]), (gc*)obj);
       return &globalReferences[length++];
     }
   }

Modified: vmkit/trunk/lib/j3/VMCore/JavaThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JavaThread.cpp?rev=145280&r1=145279&r2=145280&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JavaThread.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/JavaThread.cpp Mon Nov 28 15:26:48 2011
@@ -143,7 +143,8 @@
     next->prev = this;
     return next->addJNIReference(th, obj);
   } else {
-    localReferences[length] = obj;
+    vmkit::Collector::objectReferenceNonHeapWriteBarrier(
+        (gc**)&(localReferences[length]), (gc*)obj);
     return &localReferences[length++];
   }
 }




From wdietz2 at illinois.edu  Mon Nov 28 14:27:01 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 28 Nov 2011 22:27:01 -0000
Subject: [vmkit-commits] [vmkit] r145294 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111128222701.85CE82A6C12C@llvm.org>

Author: wdietz2
Date: Mon Nov 28 16:27:01 2011
New Revision: 145294

URL: http://llvm.org/viewvc/llvm-project?rev=145294&view=rev
Log:
Rename th in JVM_Interrupted to jth to fix conflict with JNI_EXCEPTION macros

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145294&r1=145293&r2=145294&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Mon Nov 28 16:27:01 2011
@@ -644,26 +644,26 @@
   while (field->getInstanceLongField(thread) == 0)
     vmkit::Thread::yield();
 
-  JavaThread* th = (JavaThread*)field->getInstanceLongField(thread);
-  th->lockingThread.interruptFlag = 1;
-  vmkit::FatLock* lock = th->lockingThread.waitsOn;
+  JavaThread* jth = (JavaThread*)field->getInstanceLongField(thread);
+  jth->lockingThread.interruptFlag = 1;
+  vmkit::FatLock* lock = jth->lockingThread.waitsOn;
 
   // If the thread is blocked on a wait. We also verify nextWaiting in case
   // the thread has been notified.
-  if (lock && th->lockingThread.nextWaiting) {
-    th->lockingThread.state = vmkit::LockingThread::StateInterrupted;
+  if (lock && jth->lockingThread.nextWaiting) {
+    jth->lockingThread.state = vmkit::LockingThread::StateInterrupted;
 
     // Make sure the thread is waiting.
     uint32 locked = 0;
     while (true) {
       locked = (lock->tryAcquire() == 0);
-      if (locked || (lock->getOwner() != th && lock->getOwner() != 0))
+      if (locked || (lock->getOwner() != jth && lock->getOwner() != 0))
         break;
       else vmkit::Thread::yield();
     }
 
     // Interrupt the thread.
-    th->lockingThread.varcond.signal();
+    jth->lockingThread.varcond.signal();
 
     // Release the lock if we acquired it.
     if (locked) lock->release(lock->getAssociatedObject(), vm->lockSystem);




From wdietz2 at illinois.edu  Mon Nov 28 14:27:03 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 28 Nov 2011 22:27:03 -0000
Subject: [vmkit-commits] [vmkit] r145295 - in /vmkit/trunk/lib/j3:
 ClassLib/OpenJDK/JavaUpcalls.cpp ClassLib/OpenJDK/OpenJDK.inc
 VMCore/JavaThread.h
Message-ID: <20111128222703.BE9312A6C12C@llvm.org>

Author: wdietz2
Date: Mon Nov 28 16:27:03 2011
New Revision: 145295

URL: http://llvm.org/viewvc/llvm-project?rev=145295&view=rev
Log:
Impl JVM_Sleep; create dummy per-thread 'sleepObject' to wait on.

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
    vmkit/trunk/lib/j3/VMCore/JavaThread.h

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp?rev=145295&r1=145294&r2=145295&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp Mon Nov 28 16:27:03 2011
@@ -224,14 +224,19 @@
                                  const char* thName, JavaObject* Group) {
   JavaObject* th = NULL;
   JavaObject* name = NULL;
+  JavaObject* sleep = NULL;
   llvm_gcroot(Group, 0);
   llvm_gcroot(th, 0);
   llvm_gcroot(name, 0);
+  llvm_gcroot(sleep, 0);
 
   assert(thName && thName[0] && "Invalid thread name!");
 
   th = newThread->doNew(vm);
+  sleep = OfObject->doNew(vm);
+
   myth->javaThread = th;
+  myth->sleepObject = sleep;
 
   name = vm->asciizToStr(thName);
 

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145295&r1=145294&r2=145295&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Mon Nov 28 16:27:03 2011
@@ -18,6 +18,7 @@
 
 #include <errno.h>
 #include <fcntl.h>
+#include <limits.h>
 #include <signal.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
@@ -194,12 +195,16 @@
 /*
  * java.lang.System
  */
-JNIEXPORT jlong JNICALL
-JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored) {
+
+uint64 CurrentTimeMillis() {
   struct timeval tv;
   gettimeofday(&tv, NULL);
-  jlong time = (tv.tv_sec * 1000LL) + (tv.tv_usec / 1000LL);
-  return time;
+  return (tv.tv_sec * 1000LL) + (tv.tv_usec / 1000LL);
+}
+
+JNIEXPORT jlong JNICALL
+JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored) {
+  return CurrentTimeMillis();
 }
 
 JNIEXPORT jlong JNICALL
@@ -209,7 +214,7 @@
 
   gettimeofday(&tv, NULL);
 
-  jlong time = (tv.tv_sec * 1000000LL) + (tv.tv_usec / 1000000LL);
+  jlong time = tv.tv_sec * 1000000000LL + tv.tv_usec * 1000LL;
 
   return time;
 }
@@ -496,8 +501,8 @@
 
   Jnjvm* vm = thread->getJVM();
 
-  // Wait some time to let the creator initialise this field
-  while (thread->javaThread == NULL) {
+  // Wait some time to let the creator initialise the fields
+  while (thread->javaThread == NULL || thread->sleepObject == NULL) {
     vmkit::Thread::yield();
   }
 
@@ -517,10 +522,9 @@
   }
 
   assert(javaThread->getVirtualTable());
-  // Run the VMThread::run function
 
+  // Run the Thread::run() function
   UserClass* thClass = (UserClass*)JavaObject::getClass(javaThread);
-
   vm->upcalls->runThread->invokeIntSpecial(vm, thClass, javaThread);
 
   // Remove the thread from the list.
@@ -533,10 +537,12 @@
  */
 JNIEXPORT void JNICALL
 JVM_StartThread(JNIEnv *env, jobject _thread) {
+  JavaObject * sleepObject = 0;
   JavaObject * thread = 0;
   JavaThread * javaThread = 0;
   llvm_gcroot(thread, 0);
   llvm_gcroot(javaThread, 0);
+  llvm_gcroot(sleepObject, 0);
   BEGIN_JNI_EXCEPTION
 
   thread = *(JavaObject**)_thread;
@@ -544,11 +550,16 @@
   assert(thread->getVirtualTable());
   Jnjvm* vm = JavaThread::get()->getJVM();
 
+  // Create a placeholder 'sleepObject' that
+  // we track in same field as Classpath's VMThread,
+  // used solely for sleeping.
+  sleepObject = vm->upcalls->OfObject->doNew(vm);
+
   JavaThread * newTh = new JavaThread(vm);
   if (!newTh) vm->outOfMemoryError();
   newTh->start((void (*)(vmkit::Thread*))start);
 
-  newTh->initialise(thread, 0);
+  newTh->initialise(thread, sleepObject);
 
   RETURN_VOID_FROM_JNI
 
@@ -609,9 +620,63 @@
   vmkit::Thread::yield();
 }
 
+static struct timeval getTimeVal(long long ms) {
+  struct timeval ret;
+  long long seconds = ms / 1000LL;
+  ret.tv_usec = 1000LL * (ms % 1000LL);
+  ret.tv_sec = seconds > LONG_MAX ? LONG_MAX : seconds;
+  return ret;
+}
+
+
 JNIEXPORT void JNICALL
 JVM_Sleep(JNIEnv *env, jclass threadClass, jlong millis) {
-  NYI();
+
+  BEGIN_JNI_EXCEPTION
+
+  Jnjvm * vm = th->getJVM();
+
+  // Check for invalid sleep time
+  if (millis < 0)
+    th->getJVM()->illegalArgumentException("Negative sleep value");
+
+  // If Thread is interrupted, throw exception
+  if (th->lockingThread.interruptFlag != 0) {
+    th->lockingThread.interruptFlag = 0;
+    vm->interruptedException(NULL);
+    UNREACHABLE();
+  }
+
+  // Treat sleep(0) as yield.
+  if (millis == 0) {
+    vmkit::Thread::yield();
+    RETURN_VOID_FROM_JNI
+  }
+
+  // See the Classpath sleep() implementation for inspiration here.
+  // We use a dummy per-thread 'sleepObject' to wait on instead of using
+  // a VMThread, but otherwise same implementation.
+  assert(th->sleepObject && "Missing sleep object!");
+
+  uint64 now = CurrentTimeMillis();
+
+  JavaObject::acquire(th->sleepObject);
+  while(true) {
+    struct timeval tv = getTimeVal(millis);
+    JavaObject::timedWait(th->sleepObject, tv);
+
+    uint64 then = now;
+    now = CurrentTimeMillis();
+    uint64 timePassed = now - then;
+
+    if (timePassed >= millis) break;
+
+    millis -= timePassed;
+  }
+  JavaObject::release(th->sleepObject);
+
+  RETURN_VOID_FROM_JNI
+  END_JNI_EXCEPTION
 }
 
 JNIEXPORT jobject JNICALL

Modified: vmkit/trunk/lib/j3/VMCore/JavaThread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JavaThread.h?rev=145295&r1=145294&r2=145295&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JavaThread.h (original)
+++ vmkit/trunk/lib/j3/VMCore/JavaThread.h Mon Nov 28 16:27:03 2011
@@ -74,9 +74,13 @@
   ///
   JavaObject* javaThread;
 
-  /// vmThread - The VMThread object of this thread.
+  /// vmThread - The VMThread object of this thread. (GNU Classpath)
+  /// sleepObject - Empty Object used to wait on for sleeping (OpenJDK)
   ///
-  JavaObject* vmThread;
+  union {
+    JavaObject* vmThread;
+    JavaObject* sleepObject;
+  };
 
   vmkit::LockingThread lockingThread;
   




From wdietz2 at illinois.edu  Mon Nov 28 14:27:05 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 28 Nov 2011 22:27:05 -0000
Subject: [vmkit-commits] [vmkit] r145296 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111128222705.96A212A6C12C@llvm.org>

Author: wdietz2
Date: Mon Nov 28 16:27:05 2011
New Revision: 145296

URL: http://llvm.org/viewvc/llvm-project?rev=145296&view=rev
Log:
Fix various warnings in OpenJDK.inc

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145296&r1=145295&r2=145296&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Mon Nov 28 16:27:05 2011
@@ -630,16 +630,18 @@
 
 
 JNIEXPORT void JNICALL
-JVM_Sleep(JNIEnv *env, jclass threadClass, jlong millis) {
+JVM_Sleep(JNIEnv *env, jclass threadClass, jlong _millis) {
 
   BEGIN_JNI_EXCEPTION
 
   Jnjvm * vm = th->getJVM();
 
   // Check for invalid sleep time
-  if (millis < 0)
+  if (_millis < 0)
     th->getJVM()->illegalArgumentException("Negative sleep value");
 
+  uint64 millis = _millis;
+
   // If Thread is interrupted, throw exception
   if (th->lockingThread.interruptFlag != 0) {
     th->lockingThread.interruptFlag = 0;
@@ -1057,7 +1059,7 @@
       UNREACHABLE();
     }
     char* buf = (char*)allocator.Allocate(dim_len+2);
-    for(unsigned i = 0; i < dim_len; ++i) buf[i] = I_TAB;
+    for(int i = 0; i < dim_len; ++i) buf[i] = I_TAB;
     buf[dim_len] = baseChar;
     buf[dim_len+1] = '\0';
     arrayName = loader->asciizConstructUTF8(buf);
@@ -1083,6 +1085,8 @@
   RETURN_FROM_JNI((jobject)th->pushJNIRef(array));
 
   END_JNI_EXCEPTION
+
+  return 0;
 }
 
 /*
@@ -1658,8 +1662,6 @@
 
   BEGIN_JNI_EXCEPTION
 
-  Jnjvm* vm = JavaThread::get()->getJVM();
-
   m = *(JavaObjectMethod**)_m;
 
   ret = proceedMethod(
@@ -1687,8 +1689,6 @@
 
   BEGIN_JNI_EXCEPTION
 
-  Jnjvm* vm = JavaThread::get()->getJVM();
-
   c = *(JavaObjectConstructor**)_c;
 
   ret = proceedConstructor(
@@ -2448,6 +2448,7 @@
 JNIEXPORT jint JNICALL
 JVM_InitializeSocketLibrary(void) {
   // Nothing to do here.
+  return 0;
 }
 
 JNIEXPORT jint JNICALL




From wdietz2 at illinois.edu  Mon Nov 28 14:43:49 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Mon, 28 Nov 2011 22:43:49 -0000
Subject: [vmkit-commits] [vmkit] r145303 - in /vmkit/trunk/lib/j3/ClassLib:
 GNUClasspath/ClasspathVMSystemProperties.inc OpenJDK/OpenJDK.inc
 SetProperties.inc
Message-ID: <20111128224349.8CC172A6C12D@llvm.org>

Author: wdietz2
Date: Mon Nov 28 16:43:49 2011
New Revision: 145303

URL: http://llvm.org/viewvc/llvm-project?rev=145303&view=rev
Log:
Refactor the java.compiler property to ClassLib-specific locations.

OpenJDK doesn't support compiling code yet, so setting this value to 'gcj'
causes code to emit a warning that it can't find the specified compiler.

This is particularly important because this causes some dacapo failures due to
checksums on stderr output.

Modified:
    vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMSystemProperties.inc
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
    vmkit/trunk/lib/j3/ClassLib/SetProperties.inc

Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMSystemProperties.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMSystemProperties.inc?rev=145303&r1=145302&r2=145303&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMSystemProperties.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMSystemProperties.inc Mon Nov 28 16:43:49 2011
@@ -40,6 +40,11 @@
 
   setProperties(prop);
 
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  const char * tmp = getenv("JAVA_COMPILER");
+  if (!tmp) tmp = "gcj";
+  setProperty(vm, prop, "java.compiler", tmp);
+
   END_NATIVE_EXCEPTION
 }
 

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145303&r1=145302&r2=145303&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Mon Nov 28 16:43:49 2011
@@ -248,6 +248,11 @@
   setProperties(prop);
   setCommandLineProperties(prop);
 
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  const char * tmp = getenv("JAVA_COMPILER");
+  if (tmp)
+    setProperty(vm, prop, "java.compiler", tmp);
+
   RETURN_FROM_JNI(p);
 
   END_JNI_EXCEPTION

Modified: vmkit/trunk/lib/j3/ClassLib/SetProperties.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/SetProperties.inc?rev=145303&r1=145302&r2=145303&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/SetProperties.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/SetProperties.inc Mon Nov 28 16:43:49 2011
@@ -66,9 +66,6 @@
   setProperty(vm, prop, "java.specification.version", "1.5");
   setProperty(vm, prop, "java.io.tmpdir", "/tmp");
 
-  tmp = getenv("JAVA_COMPILER");
-  if (!tmp) tmp = "gcj";
-  setProperty(vm, prop, "java.compiler", tmp);
 
   setProperty(vm, prop, "build.compiler", "gcj");
   setProperty(vm, prop, "gcj.class.path", JCL->bootClasspathEnv);




From wdietz2 at illinois.edu  Mon Nov 28 21:30:25 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 29 Nov 2011 05:30:25 -0000
Subject: [vmkit-commits] [vmkit] r145373 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111129053025.E7AEF2A6C12C@llvm.org>

Author: wdietz2
Date: Mon Nov 28 23:30:25 2011
New Revision: 145373

URL: http://llvm.org/viewvc/llvm-project?rev=145373&view=rev
Log:
Fix thread status query, fixup thread join/end functionality (OpenJDK)

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145373&r1=145372&r2=145373&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Mon Nov 28 23:30:25 2011
@@ -528,14 +528,24 @@
 
   assert(javaThread->getVirtualTable());
 
+  // TODO: What happens if the thread throws an exception?
+
   // Run the Thread::run() function
   UserClass* thClass = (UserClass*)JavaObject::getClass(javaThread);
   vm->upcalls->runThread->invokeIntSpecial(vm, thClass, javaThread);
 
+  // Indicate that the thread is done by clearing the eetop field.
+  // and notify all waiting threads.
+  vm->upcalls->eetop->setInstanceLongField(javaThread, 0);
+  JavaObject::acquire(javaThread);
+  JavaObject::notifyAll(javaThread);
+  JavaObject::release(javaThread);
+
   // Remove the thread from the list.
   if (!isDaemon) {
     vm->threadSystem.leave();
   }
+
 }
 /*
  * java.lang.Thread
@@ -584,10 +594,9 @@
   assert(thread);
 
   Jnjvm* vm = JavaThread::get()->getJVM();
-  jint status = vm->upcalls->threadStatus->getInstanceInt32Field(thread);
+  jlong InternalThread =vm->upcalls->eetop->getInstanceLongField(thread);
 
-  // TODO: We don't actually maintain 'status'...
-  RETURN_FROM_JNI(status != 0);
+  RETURN_FROM_JNI(InternalThread != 0);
 
   END_JNI_EXCEPTION
 




From wdietz2 at illinois.edu  Mon Nov 28 21:30:29 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 29 Nov 2011 05:30:29 -0000
Subject: [vmkit-commits] [vmkit] r145375 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111129053029.968EE2A6C12D@llvm.org>

Author: wdietz2
Date: Mon Nov 28 23:30:29 2011
New Revision: 145375

URL: http://llvm.org/viewvc/llvm-project?rev=145375&view=rev
Log:
Don't halt on JVM_CompileClass(es), just claim the compilation failed (OpenJDK)

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145375&r1=145374&r2=145375&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Mon Nov 28 23:30:29 2011
@@ -476,12 +476,14 @@
 
 JNIEXPORT jboolean JNICALL
 JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls) {
-  NYI();
+  // Unsupported.
+  return false;
 }
 
 JNIEXPORT jboolean JNICALL
 JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname) {
-  NYI();
+  // Unsupported.
+  return false;
 }
 
 JNIEXPORT jobject JNICALL




From wdietz2 at illinois.edu  Mon Nov 28 21:30:27 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 29 Nov 2011 05:30:27 -0000
Subject: [vmkit-commits] [vmkit] r145374 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111129053027.A44702A6C12C@llvm.org>

Author: wdietz2
Date: Mon Nov 28 23:30:27 2011
New Revision: 145374

URL: http://llvm.org/viewvc/llvm-project?rev=145374&view=rev
Log:
Properly handle Threads that subclass java.lang.Thread (OpenJDK)

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145374&r1=145373&r2=145374&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Mon Nov 28 23:30:27 2011
@@ -528,11 +528,20 @@
 
   assert(javaThread->getVirtualTable());
 
-  // TODO: What happens if the thread throws an exception?
+  // Get the class for this Thread
+  UserClass* thClass = JavaObject::getClass(javaThread)->asClass();
+  assert(thClass);
+  assert(thClass->isResolved());
+
+  // Lookup the correct run() method to call...
+  const UTF8 * runName = thClass->classLoader->hashUTF8->lookupAsciiz("run");
+  const UTF8 * runType = thClass->classLoader->hashUTF8->lookupAsciiz("()V");
+  JavaMethod * meth = thClass->lookupMethodDontThrow(runName, runType, false, true, 0);
+  assert(meth);
 
-  // Run the Thread::run() function
-  UserClass* thClass = (UserClass*)JavaObject::getClass(javaThread);
-  vm->upcalls->runThread->invokeIntSpecial(vm, thClass, javaThread);
+  // Run the thread...
+  // TODO: What happens if the thread throws an exception?
+  meth->invokeIntSpecial(vm, thClass, javaThread);
 
   // Indicate that the thread is done by clearing the eetop field.
   // and notify all waiting threads.




From nicolas.geoffray at lip6.fr  Mon Nov 28 22:55:47 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Tue, 29 Nov 2011 06:55:47 -0000
Subject: [vmkit-commits] [vmkit] r145386 -
	/vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.cpp
Message-ID: <20111129065547.EA72A2A6C12C@llvm.org>

Author: geoffray
Date: Tue Nov 29 00:55:47 2011
New Revision: 145386

URL: http://llvm.org/viewvc/llvm-project?rev=145386&view=rev
Log:
Protect the strings link list of a class loader when creating a new link.


Modified:
    vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.cpp

Modified: vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.cpp?rev=145386&r1=145385&r2=145386&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.cpp Tue Nov 29 00:55:47 2011
@@ -1045,13 +1045,14 @@
 
 JavaString** StringList::addString(JnjvmClassLoader* JCL, JavaString* obj) {
   llvm_gcroot(obj, 0);
+  JCL->lock.lock();
   if (length == MAXIMUM_STRINGS) {
     StringList* next = new(JCL->allocator, "StringList") StringList();
     next->prev = this;
     JCL->strings = next;
+    JCL->lock.unlock();
     return next->addString(JCL, obj);
   } else {
-    JCL->lock.lock();
     vmkit::Collector::objectReferenceNonHeapWriteBarrier(
         (gc**)&(strings[length]), (gc*)obj);
     JavaString** res = &strings[length++];




From wdietz2 at illinois.edu  Mon Nov 28 23:15:35 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 29 Nov 2011 07:15:35 -0000
Subject: [vmkit-commits] [vmkit] r145387 - in
 /vmkit/trunk/lib/j3/ClassLib/OpenJDK: JavaUpcalls.cpp JavaUpcalls.h
 OpenJDK.inc
Message-ID: <20111129071535.F30B82A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov 29 01:15:35 2011
New Revision: 145387

URL: http://llvm.org/viewvc/llvm-project?rev=145387&view=rev
Log:
Skip Method.invoke() when returning CallerClass, fixes failing access control

With this change mauve's ReflectAccess, Method.invoke, and others now pass

OpenJDK-only.

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp?rev=145387&r1=145386&r2=145387&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp Tue Nov 29 01:15:35 2011
@@ -83,6 +83,7 @@
 JavaMethod* Classpath::InitDirectByteBuffer;
 Class*      Classpath::newClassLoader;
 Class*      Classpath::cloneableClass;
+JavaMethod* Classpath::ReflectInvokeMethod;
 
 
 JavaField*  Classpath::boolValue;
@@ -730,6 +731,10 @@
 
   cloneableClass = UPCALL_CLASS(loader, "java/lang/Cloneable");
 
+  ReflectInvokeMethod =
+    UPCALL_METHOD(loader, "java/lang/reflect/Method", "invoke",
+      "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;", ACC_VIRTUAL);
+
   newThread =
     UPCALL_CLASS(loader, "java/lang/Thread");
 

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h?rev=145387&r1=145386&r2=145387&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h Tue Nov 29 01:15:35 2011
@@ -100,6 +100,7 @@
   ISOLATE_STATIC JavaField*  vmdataClassLoader;
   ISOLATE_STATIC UserClass*  cloneableClass;
   ISOLATE_STATIC UserClass*  enumClass;
+  ISOLATE_STATIC JavaMethod* ReflectInvokeMethod;
 
   ISOLATE_STATIC JavaField* boolValue;
   ISOLATE_STATIC JavaField* byteValue;

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145387&r1=145386&r2=145387&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov 29 01:15:35 2011
@@ -1132,7 +1132,18 @@
   JavaThread* th = JavaThread::get();
 
   Jnjvm* vm = th->getJVM();
-  UserClass* cl = th->getCallingClassLevel(n);
+
+  // Find the requested frame
+  JavaMethod * meth = th->getCallingMethodLevel(n);
+
+  // Grab the next frame up if the frame requested is Method.invoke()
+  // TODO: Better integrate this throughout the reflection API?
+  // Note that this isn't necessary in the Classpath port only because
+  // it doesn't enforce any language access control for reflection
+  if (meth == vm->upcalls->ReflectInvokeMethod)
+    meth = th->getCallingMethodLevel(n+1);
+
+  UserClass *cl = meth->classDef;
   assert(cl);
   JavaObject * const * res = cl->getClassDelegateePtr(vm);
   RETURN_FROM_JNI((jclass)res);




From nicolas.geoffray at lip6.fr  Mon Nov 28 23:36:51 2011
From: nicolas.geoffray at lip6.fr (Nicolas Geoffray)
Date: Tue, 29 Nov 2011 07:36:51 -0000
Subject: [vmkit-commits] [vmkit] r145388 - in /vmkit/trunk/lib/j3/ClassLib:
 GNUClasspath/JavaUpcalls.cpp OpenJDK/JavaUpcalls.cpp
Message-ID: <20111129073651.CE0182A6C12C@llvm.org>

Author: geoffray
Date: Tue Nov 29 01:36:51 2011
New Revision: 145388

URL: http://llvm.org/viewvc/llvm-project?rev=145388&view=rev
Log:
Call JavaThread::initialise to initialise system threads. This also makes sure that we execute a write barrier.


Modified:
    vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp

Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp?rev=145388&r1=145387&r2=145388&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp Tue Nov 29 01:36:51 2011
@@ -242,8 +242,9 @@
   llvm_gcroot(name, 0);
 
   th = newThread->doNew(vm);
-  myth->javaThread = th;
   vmth = (JavaObjectVMThread*)newVMThread->doNew(vm);
+  myth->initialise(th, vmth);
+
   name = vm->asciizToStr(thName);
 
   initThread->invokeIntSpecial(vm, newThread, th, &vmth, &name, 1, 0); 

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp?rev=145388&r1=145387&r2=145388&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp Tue Nov 29 01:36:51 2011
@@ -235,9 +235,7 @@
 
   th = newThread->doNew(vm);
   sleep = OfObject->doNew(vm);
-
-  myth->javaThread = th;
-  myth->sleepObject = sleep;
+  myth->initialise(th, sleep);
 
   name = vm->asciizToStr(thName);
 




From wdietz2 at illinois.edu  Mon Nov 28 23:52:08 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 29 Nov 2011 07:52:08 -0000
Subject: [vmkit-commits] [vmkit] r145391 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111129075208.3D3C12A6C12C@llvm.org>

Author: wdietz2
Date: Tue Nov 29 01:52:07 2011
New Revision: 145391

URL: http://llvm.org/viewvc/llvm-project?rev=145391&view=rev
Log:
Robustify JVM_SetArrayElement and JVM_NewMultiArray (OpenJDK)

Passes mauve's reflect/Array tests.

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145391&r1=145390&r2=145391&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov 29 01:52:07 2011
@@ -958,8 +958,25 @@
   llvm_gcroot(element, 0);
 
   BEGIN_JNI_EXCEPTION
+  verifyNull(arr);
   array = *(ArrayObject**)arr;
-  element = *(JavaObject**)val;
+  element = val ? *(JavaObject**)val : NULL;
+
+  Jnjvm* vm = th->getJVM();
+
+  // Verify this is, in fact, an array
+  UserCommonClass * cl = JavaObject::getClass(array);
+  if (!cl || !cl->isArray())
+    vm->illegalArgumentException("Invalid object, expected array");
+
+  // Bounds check
+  if (index < 0 || index >= ArrayObject::getSize(array))
+    vm->indexOutOfBounds(array, index);
+
+  // Check the object is of the correct type
+  UserCommonClass * base = cl->asArrayClass()->baseClass();
+  if (element && !JavaObject::instanceOf(element, base))
+    vm->illegalArgumentException("Wrong object for array type");
 
   ArrayObject::setElement(array, element, index);
 
@@ -1043,12 +1060,12 @@
 
   Jnjvm* vm = th->getJVM();
 
+  verifyNull(eltClass);
+  verifyNull(_dim);
+
   eltClassObj = *(JavaObjectClass**)eltClass;
   dim = *(ArraySInt32**)_dim;
 
-  verifyNull(eltClassObj);
-  verifyNull(dim);
-
   int dim_len = ArraySInt32::getSize(dim);
   if(dim_len <= 0 || dim_len > 255) {
     vm->illegalArgumentException("Too many dimensions for array");




From wdietz2 at illinois.edu  Tue Nov 29 06:43:28 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 29 Nov 2011 14:43:28 -0000
Subject: [vmkit-commits] [vmkit] r145398 - /vmkit/trunk/lib/j3/VMCore/Jni.cpp
Message-ID: <20111129144328.E53151BE001@llvm.org>

Author: wdietz2
Date: Tue Nov 29 08:43:28 2011
New Revision: 145398

URL: http://llvm.org/viewvc/llvm-project?rev=145398&view=rev
Log:
Impl JNI CallLongMethod

Modified:
    vmkit/trunk/lib/j3/VMCore/Jni.cpp

Modified: vmkit/trunk/lib/j3/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/Jni.cpp?rev=145398&r1=145397&r2=145398&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/Jni.cpp Tue Nov 29 08:43:28 2011
@@ -908,9 +908,28 @@
 
 
 jlong CallLongMethod(JNIEnv *env, jobject _obj, jmethodID methodID, ...) {
-  NYI();
-  abort();
-  return 0;
+  BEGIN_JNI_EXCEPTION
+
+  verifyNull(_obj);
+
+  va_list ap;
+  va_start(ap, methodID);
+
+  // Local object references.
+  JavaObject* obj = *(JavaObject**)_obj;
+  llvm_gcroot(obj, 0);
+
+  JavaMethod* meth = (JavaMethod*)methodID;
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  UserClass* cl = getClassFromVirtualMethod(vm, meth, JavaObject::getClass(obj));
+
+  jlong res = meth->invokeLongVirtualAP(vm, cl, obj, ap);
+  va_end(ap);
+
+  RETURN_FROM_JNI(res);
+
+  END_JNI_EXCEPTION
+  RETURN_FROM_JNI(0);
 }
 
 




From wdietz2 at illinois.edu  Tue Nov 29 06:59:26 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 29 Nov 2011 08:59:26 -0600
Subject: [vmkit-commits] FatLock assertion failure?
Message-ID: <CAKGWAO9YXa6ehFk4_dX7v++518joWhWZjDFFXthWccxwCKwQuA@mail.gmail.com>

Hi,

On both runtimes, I'm seeing the following assertion occur
periodically (unpredictably, same code sometimes tickles it other
times not)

j3: /home/will/vmkit-svn/lib/vmkit/CommonThread/ObjectLocks.cpp:305:
bool vmkit::FatLock::acquire(gc *): Assertion `obj->header &
ThinLock::FatMask' failed.

Any ideas what might be causing this?

~Will


From wdietz2 at illinois.edu  Tue Nov 29 07:11:17 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 29 Nov 2011 15:11:17 -0000
Subject: [vmkit-commits] [vmkit] r145404 -
	/vmkit/trunk/lib/j3/ClassLib/SetProperties.inc
Message-ID: <20111129151117.C7B2D1BE001@llvm.org>

Author: wdietz2
Date: Tue Nov 29 09:11:17 2011
New Revision: 145404

URL: http://llvm.org/viewvc/llvm-project?rev=145404&view=rev
Log:
Set property to allow array syntax in strings describing classes to classloader

OpenJDK-only.

Modified:
    vmkit/trunk/lib/j3/ClassLib/SetProperties.inc

Modified: vmkit/trunk/lib/j3/ClassLib/SetProperties.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/SetProperties.inc?rev=145404&r1=145403&r2=145404&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/SetProperties.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/SetProperties.inc Tue Nov 29 09:11:17 2011
@@ -74,6 +74,8 @@
   //setProperty(vm, prop, "java.library.path", TODO: getenv("LD_LIBRARY_PATH"))
   setProperty(vm, prop, "sun.boot.library.path", JCL->libClasspathEnv);
 
+  // Align behavior with GNU Classpath for now, to pass mauve test
+  setProperty(vm, prop, "sun.lang.ClassLoader.allowArraySyntax", "true");
 
   setUnameProp(vm, prop);
 




From wdietz2 at illinois.edu  Tue Nov 29 07:11:19 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 29 Nov 2011 15:11:19 -0000
Subject: [vmkit-commits] [vmkit] r145405 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111129151119.A48B61BE002@llvm.org>

Author: wdietz2
Date: Tue Nov 29 09:11:19 2011
New Revision: 145405

URL: http://llvm.org/viewvc/llvm-project?rev=145405&view=rev
Log:
Minor change to non-implemented JVM_GetSystemPackage.

Makes mauve happy.

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145405&r1=145404&r2=145405&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov 29 09:11:19 2011
@@ -861,7 +861,7 @@
 JVM_GetSystemPackage(JNIEnv *env, jstring name) {
   // TODO: Actually implement this
   // Not doing so doesn't seem to hurt anything, yet.
-  return NULL;
+  return name;
 }
 
 JNIEXPORT jobjectArray JNICALL




From wdietz2 at illinois.edu  Tue Nov 29 07:17:46 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 29 Nov 2011 09:17:46 -0600
Subject: [vmkit-commits] [PATCH] Fix logic assumption that having the class
 for a method means its resolved.
Message-ID: <CAKGWAO9aSmd17ps3MVVtmDgbD56ZvKF055RpfMOJh0YdLXoD-Q@mail.gmail.com>

Inlined below.

I'm not sure about this, but if you look higher in the code we set
"canBeDirect" in the case that we a)got a class for the method and
b)that class is final.

This doesn't necessarily mean the method is non-null (potentially
because the class isn't resolved?), and as such we shouldn't call
canBeInlined on the method.

~Will

>From 12dbeb52ee9bb07d226dc98fa114e36099fdd1a8 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Mon, 21 Nov 2011 12:10:53 -0600
Subject: [PATCH 1/2] Fix logic assumption that having the class for a method
 means its resolved.

---
 lib/j3/Compiler/JavaJIT.cpp |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/j3/Compiler/JavaJIT.cpp b/lib/j3/Compiler/JavaJIT.cpp
index 56cf094..39fa148 100644
--- a/lib/j3/Compiler/JavaJIT.cpp
+++ b/lib/j3/Compiler/JavaJIT.cpp
@@ -192,11 +192,11 @@ void JavaJIT::invokeVirtual(uint16 index) {
   llvm::Type* retType = virtualType->getReturnType();

   bool needsInit = false;
-  if (canBeDirect && canBeInlined(meth, customized)) {
+  if (canBeDirect && meth && canBeInlined(meth, customized)) {
     makeArgs(it, index, args, signature->nbArguments + 1);
     if (!thisReference) JITVerifyNull(args[0]);
     val = invokeInline(meth, args, customized);
-  } else if (canBeDirect &&
+  } else if (canBeDirect && meth &&
       !TheCompiler->needsCallback(meth, customized ? customizeFor :
NULL, &needsInit)) {
     makeArgs(it, index, args, signature->nbArguments + 1);
     if (!thisReference) JITVerifyNull(args[0]);
-- 
1.7.5.1


From wdietz2 at illinois.edu  Tue Nov 29 07:23:07 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 29 Nov 2011 09:23:07 -0600
Subject: [vmkit-commits] [PATCH] Touchup ClassLoader class-caching policies.
Message-ID: <CAKGWAO-JKp3ZFMcGgeEsz+eXiFprGy+NMTW5BZOyo4+kufuxuA@mail.gmail.com>

Inlined below.

Refactor code that ensures a class is in a given classloader's
classmap into new method "ensureCached".

Additionally, drop some short-circuit logic that looks directly to
bootstrap loader and in a few places call ensureCached where we didn't
before.  Idea is to ensure that if a class is loaded through a
particular classloader that it should be cached there.

Also drop the redundant code in loadClassFromJavaString while we're at it :).

FWIW new behavior causes both runtimes to pass mauve's classloader
tests (neither did before), but of course this change should make
sense beyond that also.

~Will

>From d1d307c9e14a9a01d11f5dd382327ace5c9a8cd0 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Tue, 29 Nov 2011 09:11:27 -0600
Subject: [PATCH 2/2] Touchup ClassLoader class-caching policies.

Essentially, if a class is loaded by a call to a particular classloader it
should be cached there.
---
 lib/j3/ClassLib/OpenJDK/OpenJDK.inc |    3 +-
 lib/j3/VMCore/JnjvmClassLoader.cpp  |   66 ++++++++++------------------------
 lib/j3/VMCore/JnjvmClassLoader.h    |    4 ++
 3 files changed, 25 insertions(+), 48 deletions(-)

diff --git a/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
index 1b20596..f5e0c3c 100644
--- a/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
@@ -1312,8 +1312,7 @@ JVM_FindLoadedClass(JNIEnv *env, jobject
_loader, jstring name) {
   CommonClass * Cl = 0;

   JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
-  if (JCL)
-   Cl = JCL->lookupClassFromJavaString(str);
+  Cl = JCL->lookupClassFromJavaString(str);
   jclass res = Cl ? (jclass)Cl->getClassDelegateePtr(vm) : 0;
   RETURN_FROM_JNI(res);

diff --git a/lib/j3/VMCore/JnjvmClassLoader.cpp
b/lib/j3/VMCore/JnjvmClassLoader.cpp
index 2a77030..f8e5980 100644
--- a/lib/j3/VMCore/JnjvmClassLoader.cpp
+++ b/lib/j3/VMCore/JnjvmClassLoader.cpp
@@ -344,6 +344,12 @@ UserClass* JnjvmClassLoader::loadName(const UTF8*
name, bool doResolve,
     vm->noClassDefFoundError(name);
   }

+  ensureCached(cl);
+
+  return cl;
+}
+
+void JnjvmClassLoader::ensureCached(UserCommonClass* cl) {
   if (cl && cl->classLoader != this) {
     classes->lock.lock();
     ClassMap::iterator End = classes->map.end();
@@ -352,8 +358,6 @@ UserClass* JnjvmClassLoader::loadName(const UTF8*
name, bool doResolve,
       classes->map.insert(std::make_pair(cl->name, cl));
     classes->lock.unlock();
   }
-
-  return cl;
 }


@@ -414,6 +418,7 @@ UserCommonClass*
JnjvmClassLoader::lookupClassOrArray(const UTF8* name) {

   if (this != bootstrapLoader) {
     temp = bootstrapLoader->lookupClassOrArray(name);
+    ensureCached(temp);
     if (temp) return temp;
   }

@@ -450,6 +455,7 @@ UserCommonClass*
JnjvmClassLoader::loadClassFromUserUTF8(const UTF8* name,
     if (prim) return constructArray(name);
     if (componentName) {
       UserCommonClass* temp = loadName(componentName, doResolve,
doThrow, NULL);
+      ensureCached(temp);
       if (temp) return constructArray(name);
     }
   } else {
@@ -464,7 +470,6 @@ UserCommonClass*
JnjvmClassLoader::loadClassFromAsciiz(const char* asciiz,
                                                        bool doThrow) {
   const UTF8* name = hashUTF8->lookupAsciiz(asciiz);
   vmkit::ThreadAllocator threadAllocator;
-  UserCommonClass* result = NULL;
   if (!name) name = bootstrapLoader->hashUTF8->lookupAsciiz(asciiz);
   if (!name) {
     uint32 size = strlen(asciiz);
@@ -478,16 +483,6 @@ UserCommonClass*
JnjvmClassLoader::loadClassFromAsciiz(const char* asciiz,
     name = temp;
   }

-  result = lookupClass(name);
-  if ((result == NULL) && (this != bootstrapLoader)) {
-    result = bootstrapLoader->lookupClassOrArray(name);
-    if (result != NULL) {
-      if (result->isClass() && doResolve) {
-        result->asClass()->resolveClass();
-      }
-      return result;
-    }
-  }

   return loadClassFromUserUTF8(name, doResolve, doThrow, NULL);
 }
@@ -496,36 +491,22 @@ UserCommonClass*
JnjvmClassLoader::loadClassFromAsciiz(const char* asciiz,
 UserCommonClass*
 JnjvmClassLoader::loadClassFromJavaString(JavaString* str, bool doResolve,
                                           bool doThrow) {
-
+
   llvm_gcroot(str, 0);
   vmkit::ThreadAllocator allocator;
   UTF8* name = (UTF8*)allocator.Allocate(sizeof(UTF8) + str->count *
sizeof(uint16));
-
+
   name->size = str->count;
-  if (ArrayUInt16::getElement(JavaString::getValue(str), str->offset)
!= I_TAB) {
-    for (sint32 i = 0; i < str->count; ++i) {
-      uint16 cur = ArrayUInt16::getElement(JavaString::getValue(str),
str->offset + i);
-      if (cur == '.') name->elements[i] = '/';
-      else if (cur == '/') {
-        return 0;
-      }
-      else name->elements[i] = cur;
-    }
-  } else {
-    for (sint32 i = 0; i < str->count; ++i) {
-      uint16 cur = ArrayUInt16::getElement(JavaString::getValue(str),
str->offset + i);
-      if (cur == '.') {
-        name->elements[i] = '/';
-      } else if (cur == '/') {
-        return 0;
-      } else {
-        name->elements[i] = cur;
-      }
+  for (sint32 i = 0; i < str->count; ++i) {
+    uint16 cur = ArrayUInt16::getElement(JavaString::getValue(str),
str->offset + i);
+    if (cur == '.') name->elements[i] = '/';
+    else if (cur == '/') {
+      return 0;
     }
+    else name->elements[i] = cur;
   }
-
-  UserCommonClass* cls = loadClassFromUserUTF8(name, doResolve, doThrow, str);
-  return cls;
+
+  return loadClassFromUserUTF8(name, doResolve, doThrow, str);
 }

 UserCommonClass* JnjvmClassLoader::lookupClassFromJavaString(JavaString* str) {
@@ -585,15 +566,8 @@ UserClassArray*
JnjvmClassLoader::constructArray(const UTF8* name) {
   assert(cl && "no base class for an array");
   JnjvmClassLoader* ld = cl->classLoader;
   res = ld->constructArray(name, cl);
-
-  if (res && res->classLoader != this) {
-    classes->lock.lock();
-    ClassMap::iterator End = classes->map.end();
-    ClassMap::iterator I = classes->map.find(res->name);
-    if (I == End)
-      classes->map.insert(std::make_pair(res->name, res));
-    classes->lock.unlock();
-  }
+
+  ensureCached(res);
   return res;
 }

diff --git a/lib/j3/VMCore/JnjvmClassLoader.h b/lib/j3/VMCore/JnjvmClassLoader.h
index c0f8a4f..b3bce46 100644
--- a/lib/j3/VMCore/JnjvmClassLoader.h
+++ b/lib/j3/VMCore/JnjvmClassLoader.h
@@ -84,6 +84,10 @@ private:
   ///
   const UTF8* lookupComponentName(const UTF8* name, UTF8* holder, bool& prim);

+
+  /// ensureCached - Make sure the specified class is in our classes map
+  ///
+  void ensureCached(UserCommonClass* cl);
 protected:

   JnjvmClassLoader(vmkit::BumpPtrAllocator& Alloc) : allocator(Alloc) {}
-- 
1.7.5.1


From wdietz2 at illinois.edu  Tue Nov 29 07:43:32 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Tue, 29 Nov 2011 15:43:32 -0000
Subject: [vmkit-commits] [vmkit] r145406 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111129154332.8B5CF1BE001@llvm.org>

Author: wdietz2
Date: Tue Nov 29 09:43:32 2011
New Revision: 145406

URL: http://llvm.org/viewvc/llvm-project?rev=145406&view=rev
Log:
Impl JVM_SocketShutdown (nothing to do)

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145406&r1=145405&r2=145406&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov 29 09:43:32 2011
@@ -2516,7 +2516,8 @@
 
 JNIEXPORT jint JNICALL
 JVM_SocketShutdown(jint fd, jint howto) {
-  NYI();
+  // Nothing to do here.
+  return true;
 }
 
 JNIEXPORT jint JNICALL




From nicolas.geoffray at gmail.com  Tue Nov 29 08:01:29 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 29 Nov 2011 17:01:29 +0100
Subject: [vmkit-commits] FatLock assertion failure?
In-Reply-To: <CAKGWAO9YXa6ehFk4_dX7v++518joWhWZjDFFXthWccxwCKwQuA@mail.gmail.com>
References: <CAKGWAO9YXa6ehFk4_dX7v++518joWhWZjDFFXthWccxwCKwQuA@mail.gmail.com>
Message-ID: <CAPYwfirVfUNUNEiMdCYbjUGNtP-n_tvL3zbarzjq1o2hM=ZHEw@mail.gmail.com>

Hi Will,

On Tue, Nov 29, 2011 at 3:59 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Hi,
>
> On both runtimes, I'm seeing the following assertion occur
> periodically (unpredictably, same code sometimes tickles it other
> times not)
>
> j3: /home/will/vmkit-svn/lib/vmkit/CommonThread/ObjectLocks.cpp:305:
> bool vmkit::FatLock::acquire(gc *): Assertion `obj->header &
> ThinLock::FatMask' failed.
>

That's because you have too many cores :).... That's a lame answer. The
real answer is that there is a bug somewhere in the locking implementation.
I also experience in on my desktop machine (8 cores), but never on my
laptop (2 cores).

Nicolas


> Any ideas what might be causing this?
>
> ~Will
> _______________________________________________
> 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/20111129/8bd249cb/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov 29 11:52:56 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 29 Nov 2011 20:52:56 +0100
Subject: [vmkit-commits] [PATCH] Fix logic assumption that having the
 class for a method means its resolved.
In-Reply-To: <CAKGWAO9aSmd17ps3MVVtmDgbD56ZvKF055RpfMOJh0YdLXoD-Q@mail.gmail.com>
References: <CAKGWAO9aSmd17ps3MVVtmDgbD56ZvKF055RpfMOJh0YdLXoD-Q@mail.gmail.com>
Message-ID: <CAPYwfirmiZ9AroP8tMdy0LW6dABcFYDdJYCqJRq-NDFUUyCMWw@mail.gmail.com>

Hi Will,

I'd rather not set canBeDirect if meth is null. There's no point in calling
something directly if it's not there :)

Other than that, the change looks good to me. Feel free to apply w/ or w/o
my suggestion.

Cheers,
Nicolas

On Tue, Nov 29, 2011 at 4:17 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> I'm not sure about this, but if you look higher in the code we set
> "canBeDirect" in the case that we a)got a class for the method and
> b)that class is final.
>
> This doesn't necessarily mean the method is non-null (potentially
> because the class isn't resolved?), and as such we shouldn't call
> canBeInlined on the method.
>
> ~Will
>
> >From 12dbeb52ee9bb07d226dc98fa114e36099fdd1a8 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Mon, 21 Nov 2011 12:10:53 -0600
> Subject: [PATCH 1/2] Fix logic assumption that having the class for a
> method
>  means its resolved.
>
> ---
>  lib/j3/Compiler/JavaJIT.cpp |    4 ++--
>  1 files changed, 2 insertions(+), 2 deletions(-)
>
> diff --git a/lib/j3/Compiler/JavaJIT.cpp b/lib/j3/Compiler/JavaJIT.cpp
> index 56cf094..39fa148 100644
> --- a/lib/j3/Compiler/JavaJIT.cpp
> +++ b/lib/j3/Compiler/JavaJIT.cpp
> @@ -192,11 +192,11 @@ void JavaJIT::invokeVirtual(uint16 index) {
>   llvm::Type* retType = virtualType->getReturnType();
>
>   bool needsInit = false;
> -  if (canBeDirect && canBeInlined(meth, customized)) {
> +  if (canBeDirect && meth && canBeInlined(meth, customized)) {
>     makeArgs(it, index, args, signature->nbArguments + 1);
>     if (!thisReference) JITVerifyNull(args[0]);
>     val = invokeInline(meth, args, customized);
> -  } else if (canBeDirect &&
> +  } else if (canBeDirect && meth &&
>       !TheCompiler->needsCallback(meth, customized ? customizeFor :
> NULL, &needsInit)) {
>     makeArgs(it, index, args, signature->nbArguments + 1);
>     if (!thisReference) JITVerifyNull(args[0]);
> --
> 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/20111129/73b046fa/attachment.html>

From nicolas.geoffray at gmail.com  Tue Nov 29 11:57:21 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Tue, 29 Nov 2011 20:57:21 +0100
Subject: [vmkit-commits] [PATCH] Touchup ClassLoader class-caching
	policies.
In-Reply-To: <CAKGWAO-JKp3ZFMcGgeEsz+eXiFprGy+NMTW5BZOyo4+kufuxuA@mail.gmail.com>
References: <CAKGWAO-JKp3ZFMcGgeEsz+eXiFprGy+NMTW5BZOyo4+kufuxuA@mail.gmail.com>
Message-ID: <CAPYwfipEit9=h8x6VU6cJ4S2_Z4LR7Bg5BN+mvgj=HyaudxoGA@mail.gmail.com>

Looks good!

On Tue, Nov 29, 2011 at 4:23 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Inlined below.
>
> Refactor code that ensures a class is in a given classloader's
> classmap into new method "ensureCached".
>
> Additionally, drop some short-circuit logic that looks directly to
> bootstrap loader and in a few places call ensureCached where we didn't
> before.  Idea is to ensure that if a class is loaded through a
> particular classloader that it should be cached there.
>
> Also drop the redundant code in loadClassFromJavaString while we're at it
> :).
>
> FWIW new behavior causes both runtimes to pass mauve's classloader
> tests (neither did before), but of course this change should make
> sense beyond that also.
>
> ~Will
>
> >From d1d307c9e14a9a01d11f5dd382327ace5c9a8cd0 Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Tue, 29 Nov 2011 09:11:27 -0600
> Subject: [PATCH 2/2] Touchup ClassLoader class-caching policies.
>
> Essentially, if a class is loaded by a call to a particular classloader it
> should be cached there.
> ---
>  lib/j3/ClassLib/OpenJDK/OpenJDK.inc |    3 +-
>  lib/j3/VMCore/JnjvmClassLoader.cpp  |   66
> ++++++++++------------------------
>  lib/j3/VMCore/JnjvmClassLoader.h    |    4 ++
>  3 files changed, 25 insertions(+), 48 deletions(-)
>
> diff --git a/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
> index 1b20596..f5e0c3c 100644
> --- a/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
> +++ b/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -1312,8 +1312,7 @@ JVM_FindLoadedClass(JNIEnv *env, jobject
> _loader, jstring name) {
>   CommonClass * Cl = 0;
>
>   JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
> -  if (JCL)
> -   Cl = JCL->lookupClassFromJavaString(str);
> +  Cl = JCL->lookupClassFromJavaString(str);
>   jclass res = Cl ? (jclass)Cl->getClassDelegateePtr(vm) : 0;
>   RETURN_FROM_JNI(res);
>
> diff --git a/lib/j3/VMCore/JnjvmClassLoader.cpp
> b/lib/j3/VMCore/JnjvmClassLoader.cpp
> index 2a77030..f8e5980 100644
> --- a/lib/j3/VMCore/JnjvmClassLoader.cpp
> +++ b/lib/j3/VMCore/JnjvmClassLoader.cpp
> @@ -344,6 +344,12 @@ UserClass* JnjvmClassLoader::loadName(const UTF8*
> name, bool doResolve,
>     vm->noClassDefFoundError(name);
>   }
>
> +  ensureCached(cl);
> +
> +  return cl;
> +}
> +
> +void JnjvmClassLoader::ensureCached(UserCommonClass* cl) {
>   if (cl && cl->classLoader != this) {
>     classes->lock.lock();
>     ClassMap::iterator End = classes->map.end();
> @@ -352,8 +358,6 @@ UserClass* JnjvmClassLoader::loadName(const UTF8*
> name, bool doResolve,
>       classes->map.insert(std::make_pair(cl->name, cl));
>     classes->lock.unlock();
>   }
> -
> -  return cl;
>  }
>
>
> @@ -414,6 +418,7 @@ UserCommonClass*
> JnjvmClassLoader::lookupClassOrArray(const UTF8* name) {
>
>   if (this != bootstrapLoader) {
>     temp = bootstrapLoader->lookupClassOrArray(name);
> +    ensureCached(temp);
>     if (temp) return temp;
>   }
>
> @@ -450,6 +455,7 @@ UserCommonClass*
> JnjvmClassLoader::loadClassFromUserUTF8(const UTF8* name,
>     if (prim) return constructArray(name);
>     if (componentName) {
>       UserCommonClass* temp = loadName(componentName, doResolve,
> doThrow, NULL);
> +      ensureCached(temp);
>       if (temp) return constructArray(name);
>     }
>   } else {
> @@ -464,7 +470,6 @@ UserCommonClass*
> JnjvmClassLoader::loadClassFromAsciiz(const char* asciiz,
>                                                        bool doThrow) {
>   const UTF8* name = hashUTF8->lookupAsciiz(asciiz);
>   vmkit::ThreadAllocator threadAllocator;
> -  UserCommonClass* result = NULL;
>   if (!name) name = bootstrapLoader->hashUTF8->lookupAsciiz(asciiz);
>   if (!name) {
>     uint32 size = strlen(asciiz);
> @@ -478,16 +483,6 @@ UserCommonClass*
> JnjvmClassLoader::loadClassFromAsciiz(const char* asciiz,
>     name = temp;
>   }
>
> -  result = lookupClass(name);
> -  if ((result == NULL) && (this != bootstrapLoader)) {
> -    result = bootstrapLoader->lookupClassOrArray(name);
> -    if (result != NULL) {
> -      if (result->isClass() && doResolve) {
> -        result->asClass()->resolveClass();
> -      }
> -      return result;
> -    }
> -  }
>
>   return loadClassFromUserUTF8(name, doResolve, doThrow, NULL);
>  }
> @@ -496,36 +491,22 @@ UserCommonClass*
> JnjvmClassLoader::loadClassFromAsciiz(const char* asciiz,
>  UserCommonClass*
>  JnjvmClassLoader::loadClassFromJavaString(JavaString* str, bool doResolve,
>                                           bool doThrow) {
> -
> +
>   llvm_gcroot(str, 0);
>   vmkit::ThreadAllocator allocator;
>   UTF8* name = (UTF8*)allocator.Allocate(sizeof(UTF8) + str->count *
> sizeof(uint16));
> -
> +
>   name->size = str->count;
> -  if (ArrayUInt16::getElement(JavaString::getValue(str), str->offset)
> != I_TAB) {
> -    for (sint32 i = 0; i < str->count; ++i) {
> -      uint16 cur = ArrayUInt16::getElement(JavaString::getValue(str),
> str->offset + i);
> -      if (cur == '.') name->elements[i] = '/';
> -      else if (cur == '/') {
> -        return 0;
> -      }
> -      else name->elements[i] = cur;
> -    }
> -  } else {
> -    for (sint32 i = 0; i < str->count; ++i) {
> -      uint16 cur = ArrayUInt16::getElement(JavaString::getValue(str),
> str->offset + i);
> -      if (cur == '.') {
> -        name->elements[i] = '/';
> -      } else if (cur == '/') {
> -        return 0;
> -      } else {
> -        name->elements[i] = cur;
> -      }
> +  for (sint32 i = 0; i < str->count; ++i) {
> +    uint16 cur = ArrayUInt16::getElement(JavaString::getValue(str),
> str->offset + i);
> +    if (cur == '.') name->elements[i] = '/';
> +    else if (cur == '/') {
> +      return 0;
>     }
> +    else name->elements[i] = cur;
>   }
> -
> -  UserCommonClass* cls = loadClassFromUserUTF8(name, doResolve, doThrow,
> str);
> -  return cls;
> +
> +  return loadClassFromUserUTF8(name, doResolve, doThrow, str);
>  }
>
>  UserCommonClass* JnjvmClassLoader::lookupClassFromJavaString(JavaString*
> str) {
> @@ -585,15 +566,8 @@ UserClassArray*
> JnjvmClassLoader::constructArray(const UTF8* name) {
>   assert(cl && "no base class for an array");
>   JnjvmClassLoader* ld = cl->classLoader;
>   res = ld->constructArray(name, cl);
> -
> -  if (res && res->classLoader != this) {
> -    classes->lock.lock();
> -    ClassMap::iterator End = classes->map.end();
> -    ClassMap::iterator I = classes->map.find(res->name);
> -    if (I == End)
> -      classes->map.insert(std::make_pair(res->name, res));
> -    classes->lock.unlock();
> -  }
> +
> +  ensureCached(res);
>   return res;
>  }
>
> diff --git a/lib/j3/VMCore/JnjvmClassLoader.h
> b/lib/j3/VMCore/JnjvmClassLoader.h
> index c0f8a4f..b3bce46 100644
> --- a/lib/j3/VMCore/JnjvmClassLoader.h
> +++ b/lib/j3/VMCore/JnjvmClassLoader.h
> @@ -84,6 +84,10 @@ private:
>   ///
>   const UTF8* lookupComponentName(const UTF8* name, UTF8* holder, bool&
> prim);
>
> +
> +  /// ensureCached - Make sure the specified class is in our classes map
> +  ///
> +  void ensureCached(UserCommonClass* cl);
>  protected:
>
>   JnjvmClassLoader(vmkit::BumpPtrAllocator& Alloc) : allocator(Alloc) {}
> --
> 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/20111129/6b19a957/attachment.html>

From wdietz2 at illinois.edu  Tue Nov 29 19:52:33 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 30 Nov 2011 03:52:33 -0000
Subject: [vmkit-commits] [vmkit] r145474 - in /vmkit/trunk/lib/j3:
 ClassLib/OpenJDK/OpenJDK.inc VMCore/JnjvmClassLoader.cpp
 VMCore/JnjvmClassLoader.h
Message-ID: <20111130035233.BE1411BE002@llvm.org>

Author: wdietz2
Date: Tue Nov 29 21:52:33 2011
New Revision: 145474

URL: http://llvm.org/viewvc/llvm-project?rev=145474&view=rev
Log:
Touchup ClassLoader class-caching policies.

Essentially, if a class is loaded by a call to a particular classloader it
should be cached there.

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
    vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.cpp
    vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.h

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145474&r1=145473&r2=145474&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov 29 21:52:33 2011
@@ -1312,8 +1312,7 @@
   CommonClass * Cl = 0;
 
   JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
-  if (JCL)
-   Cl = JCL->lookupClassFromJavaString(str);
+  Cl = JCL->lookupClassFromJavaString(str);
   jclass res = Cl ? (jclass)Cl->getClassDelegateePtr(vm) : 0;
   RETURN_FROM_JNI(res);
 

Modified: vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.cpp?rev=145474&r1=145473&r2=145474&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.cpp Tue Nov 29 21:52:33 2011
@@ -344,6 +344,12 @@
     vm->noClassDefFoundError(name);
   }
 
+  ensureCached(cl);
+
+  return cl;
+}
+
+void JnjvmClassLoader::ensureCached(UserCommonClass* cl) {
   if (cl && cl->classLoader != this) {
     classes->lock.lock();
     ClassMap::iterator End = classes->map.end();
@@ -352,8 +358,6 @@
       classes->map.insert(std::make_pair(cl->name, cl));
     classes->lock.unlock();
   }
-
-  return cl;
 }
 
 
@@ -414,6 +418,7 @@
 
   if (this != bootstrapLoader) {
     temp = bootstrapLoader->lookupClassOrArray(name);
+    ensureCached(temp);
     if (temp) return temp;
   }
   
@@ -450,6 +455,7 @@
     if (prim) return constructArray(name);
     if (componentName) {
       UserCommonClass* temp = loadName(componentName, doResolve, doThrow, NULL);
+      ensureCached(temp);
       if (temp) return constructArray(name);
     }
   } else {
@@ -464,7 +470,6 @@
                                                        bool doThrow) {
   const UTF8* name = hashUTF8->lookupAsciiz(asciiz);
   vmkit::ThreadAllocator threadAllocator;
-  UserCommonClass* result = NULL;
   if (!name) name = bootstrapLoader->hashUTF8->lookupAsciiz(asciiz);
   if (!name) {
     uint32 size = strlen(asciiz);
@@ -478,16 +483,6 @@
     name = temp;
   }
   
-  result = lookupClass(name);
-  if ((result == NULL) && (this != bootstrapLoader)) {
-    result = bootstrapLoader->lookupClassOrArray(name);
-    if (result != NULL) {
-      if (result->isClass() && doResolve) {
-        result->asClass()->resolveClass();
-      }
-      return result;
-    }
-  }
  
   return loadClassFromUserUTF8(name, doResolve, doThrow, NULL);
 }
@@ -496,36 +491,22 @@
 UserCommonClass* 
 JnjvmClassLoader::loadClassFromJavaString(JavaString* str, bool doResolve,
                                           bool doThrow) {
-  
+
   llvm_gcroot(str, 0);
   vmkit::ThreadAllocator allocator; 
   UTF8* name = (UTF8*)allocator.Allocate(sizeof(UTF8) + str->count * sizeof(uint16));
- 
+
   name->size = str->count;
-  if (ArrayUInt16::getElement(JavaString::getValue(str), str->offset) != I_TAB) {
-    for (sint32 i = 0; i < str->count; ++i) {
-      uint16 cur = ArrayUInt16::getElement(JavaString::getValue(str), str->offset + i);
-      if (cur == '.') name->elements[i] = '/';
-      else if (cur == '/') {
-        return 0;
-      }
-      else name->elements[i] = cur;
-    }
-  } else {
-    for (sint32 i = 0; i < str->count; ++i) {
-      uint16 cur = ArrayUInt16::getElement(JavaString::getValue(str), str->offset + i);
-      if (cur == '.') {
-        name->elements[i] = '/';
-      } else if (cur == '/') {
-        return 0;
-      } else {
-        name->elements[i] = cur;
-      }
+  for (sint32 i = 0; i < str->count; ++i) {
+    uint16 cur = ArrayUInt16::getElement(JavaString::getValue(str), str->offset + i);
+    if (cur == '.') name->elements[i] = '/';
+    else if (cur == '/') {
+      return 0;
     }
+    else name->elements[i] = cur;
   }
-    
-  UserCommonClass* cls = loadClassFromUserUTF8(name, doResolve, doThrow, str);
-  return cls;
+
+  return loadClassFromUserUTF8(name, doResolve, doThrow, str);
 }
 
 UserCommonClass* JnjvmClassLoader::lookupClassFromJavaString(JavaString* str) {
@@ -585,15 +566,8 @@
   assert(cl && "no base class for an array");
   JnjvmClassLoader* ld = cl->classLoader;
   res = ld->constructArray(name, cl);
-  
-  if (res && res->classLoader != this) {
-    classes->lock.lock();
-    ClassMap::iterator End = classes->map.end();
-    ClassMap::iterator I = classes->map.find(res->name);
-    if (I == End)
-      classes->map.insert(std::make_pair(res->name, res));
-    classes->lock.unlock();
-  }
+
+  ensureCached(res);
   return res;
 }
 

Modified: vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.h?rev=145474&r1=145473&r2=145474&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/trunk/lib/j3/VMCore/JnjvmClassLoader.h Tue Nov 29 21:52:33 2011
@@ -84,6 +84,10 @@
   ///
   const UTF8* lookupComponentName(const UTF8* name, UTF8* holder, bool& prim);
 
+
+  /// ensureCached - Make sure the specified class is in our classes map
+  ///
+  void ensureCached(UserCommonClass* cl);
 protected:
   
   JnjvmClassLoader(vmkit::BumpPtrAllocator& Alloc) : allocator(Alloc) {}




From wdietz2 at illinois.edu  Tue Nov 29 19:52:31 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 30 Nov 2011 03:52:31 -0000
Subject: [vmkit-commits] [vmkit] r145473 -
	/vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp
Message-ID: <20111130035231.7C10F1BE001@llvm.org>

Author: wdietz2
Date: Tue Nov 29 21:52:31 2011
New Revision: 145473

URL: http://llvm.org/viewvc/llvm-project?rev=145473&view=rev
Log:
JavaJIT: Don't set canBeDirect if no method.

Modified:
    vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp

Modified: vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp?rev=145473&r1=145472&r2=145473&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/j3/Compiler/JavaJIT.cpp Tue Nov 29 21:52:31 2011
@@ -152,8 +152,8 @@
     }
   }
  
-  if ((cl && isFinal(cl->access)) || 
-      (meth && (isFinal(meth->access) || isPrivate(meth->access)))) {
+  if (meth && ((cl && isFinal(cl->access)) ||
+      isFinal(meth->access) || isPrivate(meth->access))) {
     canBeDirect = true;
   }
 
@@ -183,6 +183,7 @@
                                            true, 0);
     }
   }
+  assert((meth || !canBeDirect) && "Can't directly call a method we don't have");
  
   Typedef* retTypedef = signature->getReturnType();
   std::vector<Value*> args; // size = [signature->nbIn + 3];




From wdietz2 at illinois.edu  Tue Nov 29 19:53:13 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 30 Nov 2011 03:53:13 -0000
Subject: [vmkit-commits] [vmkit] r145475 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/ClasspathReflect.h
Message-ID: <20111130035313.D328D1BE001@llvm.org>

Author: wdietz2
Date: Tue Nov 29 21:53:13 2011
New Revision: 145475

URL: http://llvm.org/viewvc/llvm-project?rev=145475&view=rev
Log:
OpenJDK: Add missing declaredPublicFields to JavaObjectClass.

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/ClasspathReflect.h

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/ClasspathReflect.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/ClasspathReflect.h?rev=145475&r1=145474&r2=145475&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/ClasspathReflect.h (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/ClasspathReflect.h Tue Nov 29 21:53:13 2011
@@ -32,6 +32,7 @@
   JavaObject* declaredConstructors;
   JavaObject* publicConstructors;
   JavaObject* declaredPublicFields;
+  JavaObject* declaredPublicMethods;
   uint32_t classRedefinedCount;
   uint32_t lastRedefinedCount;
   JavaObject* genericInfo;
@@ -79,6 +80,7 @@
     vmkit::Collector::markAndTrace(obj, &obj->declaredConstructors, closure);
     vmkit::Collector::markAndTrace(obj, &obj->publicConstructors, closure);
     vmkit::Collector::markAndTrace(obj, &obj->declaredPublicFields, closure);
+    vmkit::Collector::markAndTrace(obj, &obj->declaredPublicMethods, closure);
     vmkit::Collector::markAndTrace(obj, &obj->genericInfo, closure);
     vmkit::Collector::markAndTrace(obj, &obj->enumConstants, closure);
     vmkit::Collector::markAndTrace(obj, &obj->enumConstantDictionary, closure);




From wdietz2 at illinois.edu  Tue Nov 29 19:55:45 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 30 Nov 2011 03:55:45 -0000
Subject: [vmkit-commits] [vmkit] r145476 - in
 /vmkit/trunk/lib/j3/ClassLib/OpenJDK: ClasspathReflect.h JavaUpcalls.cpp
 JavaUpcalls.h
Message-ID: <20111130035545.903511BE001@llvm.org>

Author: wdietz2
Date: Tue Nov 29 21:55:45 2011
New Revision: 145476

URL: http://llvm.org/viewvc/llvm-project?rev=145476&view=rev
Log:
OpenJDK: Put references on special NullQueue if no queue specified.

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/ClasspathReflect.h
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/ClasspathReflect.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/ClasspathReflect.h?rev=145476&r1=145475&r2=145476&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/ClasspathReflect.h (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/ClasspathReflect.h Tue Nov 29 21:55:45 2011
@@ -16,6 +16,8 @@
 #include "JavaObject.h"
 #include "JavaThread.h"
 #include "JavaString.h"
+#include "Jnjvm.h"
+#include "JavaUpcalls.h"
 
 extern "C" j3::JavaObject* internalFillInStackTrace(j3::JavaObject*);
 namespace j3 {
@@ -305,6 +307,11 @@
     llvm_gcroot(q, 0);
     vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)self, (gc**)&(self->referent), (gc*)r);
+    if (!q) {
+      JavaField * field = JavaThread::get()->getJVM()->upcalls->NullRefQueue;
+      q = field->getStaticObjectField();
+    }
+    assert(q);
     vmkit::Collector::objectReferenceWriteBarrier(
         (gc*)self, (gc**)&(self->queue), (gc*)q);
   }

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp?rev=145476&r1=145475&r2=145476&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp Tue Nov 29 21:55:45 2011
@@ -220,6 +220,7 @@
 
 JavaMethod* Classpath::EnqueueReference;
 Class*      Classpath::newReference;
+JavaField*  Classpath::NullRefQueue;
 
 void Classpath::CreateJavaThread(Jnjvm* vm, JavaThread* myth,
                                  const char* thName, JavaObject* Group) {
@@ -850,6 +851,10 @@
     UPCALL_METHOD(loader, "java/lang/ref/Reference",  "enqueue", "()Z",
                   ACC_VIRTUAL);
 
+  NullRefQueue =
+    UPCALL_FIELD(loader, "java/lang/ref/ReferenceQueue",
+        "NULL", "Ljava/lang/ref/ReferenceQueue;", ACC_STATIC);
+
   JavaMethod* initWeakReference =
     UPCALL_METHOD(loader, "java/lang/ref/WeakReference", "<init>",
                   "(Ljava/lang/Object;)V",

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h?rev=145476&r1=145475&r2=145476&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.h Tue Nov 29 21:55:45 2011
@@ -258,6 +258,7 @@
 
   ISOLATE_STATIC JavaMethod* EnqueueReference;
   ISOLATE_STATIC Class*      newReference;
+  ISOLATE_STATIC JavaField*  NullRefQueue;
 
   ISOLATE_STATIC UserClass*  EnumClass;
 




From wdietz2 at illinois.edu  Tue Nov 29 20:42:55 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 30 Nov 2011 04:42:55 -0000
Subject: [vmkit-commits] [vmkit] r145481 -
	/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
Message-ID: <20111130044255.597791BE001@llvm.org>

Author: wdietz2
Date: Tue Nov 29 22:42:55 2011
New Revision: 145481

URL: http://llvm.org/viewvc/llvm-project?rev=145481&view=rev
Log:
Impl JVM_ResolveClass

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145481&r1=145480&r2=145481&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Tue Nov 29 22:42:55 2011
@@ -1226,7 +1226,19 @@
  */
 JNIEXPORT void JNICALL
 JVM_ResolveClass(JNIEnv *env, jclass cls) {
-  NYI();
+  JavaObjectClass * Cl = 0;
+  llvm_gcroot(Cl, 0);
+  BEGIN_JNI_EXCEPTION
+
+  Cl = *(JavaObjectClass**)cls;
+
+  UserCommonClass * C = JavaObjectClass::getClass(Cl);
+  assert(C && C->isClass());
+
+  C->asClass()->resolveClass();
+
+  RETURN_VOID_FROM_JNI
+  END_JNI_EXCEPTION
 }
 
 /*




From wdietz2 at illinois.edu  Wed Nov 30 09:38:55 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 30 Nov 2011 17:38:55 -0000
Subject: [vmkit-commits] [vmkit] r145499 -
	/vmkit/trunk/tests/FieldWriteTest.java
Message-ID: <20111130173855.28C942A6C12C@llvm.org>

Author: wdietz2
Date: Wed Nov 30 11:38:54 2011
New Revision: 145499

URL: http://llvm.org/viewvc/llvm-project?rev=145499&view=rev
Log:
Add 'FieldWriteTest' that presently fails on OpenJDK port.

Added:
    vmkit/trunk/tests/FieldWriteTest.java

Added: vmkit/trunk/tests/FieldWriteTest.java
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tests/FieldWriteTest.java?rev=145499&view=auto
==============================================================================
--- vmkit/trunk/tests/FieldWriteTest.java (added)
+++ vmkit/trunk/tests/FieldWriteTest.java Wed Nov 30 11:38:54 2011
@@ -0,0 +1,31 @@
+import java.lang.Thread;
+
+public class FieldWriteTest {
+  static class FieldWriterThread extends Thread {
+    boolean val = false;
+
+    FieldWriterThread() { super(); }
+
+    public void run() {
+      val = true;
+    }
+  }
+
+  public static void check(boolean b) throws Exception {
+    if (!b) throw new Exception("Check failed!");
+  }
+
+  public static void main(String[] args) throws Exception {
+    // First time passes, the rest fail.
+    int fail = 0;
+    for (int i = 0; i < 100; ++i) {
+      FieldWriterThread t = new FieldWriterThread();
+      t.start();
+      t.join(); // Synchronization point!
+      if (!t.val) ++fail;
+    }
+    if (fail > 0)
+      System.out.println("Failed checks: " + fail);
+    check(fail == 0);
+  }
+}




From wdietz2 at illinois.edu  Wed Nov 30 10:17:26 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 30 Nov 2011 18:17:26 -0000
Subject: [vmkit-commits] [vmkit] r145503 - in /vmkit/trunk:
 lib/j3/ClassLib/OpenJDK/OpenJDK.inc tests/FieldWriteTest.java
Message-ID: <20111130181726.C5C442A6C12C@llvm.org>

Author: wdietz2
Date: Wed Nov 30 12:17:26 2011
New Revision: 145503

URL: http://llvm.org/viewvc/llvm-project?rev=145503&view=rev
Log:
OpenJDK: Fix race in 'vmThread' field setting.  Fixes FieldWriteTest.

This is particularly important since this field being set properly is how we
determine whether or not a given Thread is alive.

Also, touchup the FieldWriteTest to make it easier to debug.

Now passes mauve's Thread.join test.

Modified:
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
    vmkit/trunk/tests/FieldWriteTest.java

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145503&r1=145502&r2=145503&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Wed Nov 30 12:17:26 2011
@@ -516,10 +516,6 @@
   javaThread = thread->javaThread;
   assert(javaThread && "Didn't fix the javaThread of a j3 thread");
 
-  // Ok, now that the thread is created we can set the the value of eetop
-  // which points from the javaobject to our internal JavaThread
-  vm->upcalls->eetop->setInstanceLongField(javaThread, (long)thread);
-
   // If the thread is not a daemon, it is added to the list of threads to
   // wait until exit.
   bool isDaemon = vm->upcalls->daemon->getInstanceInt8Field(javaThread);
@@ -583,6 +579,10 @@
 
   JavaThread * newTh = new JavaThread(vm);
   if (!newTh) vm->outOfMemoryError();
+
+  // Set the eetop field
+  vm->upcalls->eetop->setInstanceLongField(thread, (long)newTh);
+
   newTh->start((void (*)(vmkit::Thread*))start);
 
   newTh->initialise(thread, sleepObject);

Modified: vmkit/trunk/tests/FieldWriteTest.java
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tests/FieldWriteTest.java?rev=145503&r1=145502&r2=145503&view=diff
==============================================================================
--- vmkit/trunk/tests/FieldWriteTest.java (original)
+++ vmkit/trunk/tests/FieldWriteTest.java Wed Nov 30 12:17:26 2011
@@ -16,16 +16,13 @@
   }
 
   public static void main(String[] args) throws Exception {
-    // First time passes, the rest fail.
-    int fail = 0;
     for (int i = 0; i < 100; ++i) {
       FieldWriterThread t = new FieldWriterThread();
       t.start();
+      check(t.isAlive());
       t.join(); // Synchronization point!
-      if (!t.val) ++fail;
+      check(!t.isAlive());
+      check(t.val);
     }
-    if (fail > 0)
-      System.out.println("Failed checks: " + fail);
-    check(fail == 0);
   }
 }




From wdietz2 at illinois.edu  Wed Nov 30 11:38:17 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 30 Nov 2011 19:38:17 -0000
Subject: [vmkit-commits] [vmkit] r145513 -
	/vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
Message-ID: <20111130193817.EBAA52A6C12C@llvm.org>

Author: wdietz2
Date: Wed Nov 30 13:38:17 2011
New Revision: 145513

URL: http://llvm.org/viewvc/llvm-project?rev=145513&view=rev
Log:
Fix ArrayCopy to (correctly) copy over null values.

Modified:
    vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc

Modified: vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc?rev=145513&r1=145512&r2=145513&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc Wed Nov 30 13:38:17 2011
@@ -68,11 +68,10 @@
         if (!(JavaObject::getClass(cur)->isAssignableFrom(dstType))) {
           th->throwException(vm->CreateArrayStoreException(
               (JavaVirtualTable*)dst->getVirtualTable()));
-          break;
-        } else {
-          ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);
+          UNREACHABLE();
         }
       }
+      ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);
     }
   } else {
     uint32 logSize = dstType->asPrimitiveClass()->logSize;




From wdietz2 at illinois.edu  Wed Nov 30 14:12:56 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 30 Nov 2011 22:12:56 -0000
Subject: [vmkit-commits] [vmkit] r145527 -
	/vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
Message-ID: <20111130221256.DA6F12A6C12C@llvm.org>

Author: wdietz2
Date: Wed Nov 30 16:12:56 2011
New Revision: 145527

URL: http://llvm.org/viewvc/llvm-project?rev=145527&view=rev
Log:
ArrayCopy: handle overlapping arrays of Objects

Modified:
    vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc

Modified: vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc?rev=145527&r1=145526&r2=145527&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc Wed Nov 30 16:12:56 2011
@@ -62,17 +62,30 @@
   }
 
   if (!(dstType->isPrimitive())) {
+    // Scan to ensure element compatibility, recording the first item
+    // that requires an exception be thrown.
+    int badEl = -1;
     for (int i = 0; i < len; i++) {
       cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);
       if (cur) {
         if (!(JavaObject::getClass(cur)->isAssignableFrom(dstType))) {
-          th->throwException(vm->CreateArrayStoreException(
-              (JavaVirtualTable*)dst->getVirtualTable()));
-          UNREACHABLE();
+          badEl = i;
+          break;
         }
       }
-      ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);
     }
+
+    // Copy over the non-conflicting elements, handling overlaps
+    void* ptrDst = (void*)((int64_t)ArrayObject::getElements((ArrayObject*)dst) + dstart*sizeof(void*));
+    void* ptrSrc = (void*)((int64_t)ArrayObject::getElements((ArrayObject*)src) + sstart*sizeof(void*));
+    int copyLen = badEl == -1 ? len : badEl - 1;
+    if (copyLen > 0)
+      memmove(ptrDst, ptrSrc, copyLen * sizeof(void*));
+
+    // TODO: Record the conflicting types in the exception message?
+    if (badEl != -1)
+      vm->arrayStoreException();
+
   } else {
     uint32 logSize = dstType->asPrimitiveClass()->logSize;
     void* ptrDst = (void*)((int64_t)JavaArray::getElements(dst) + (dstart << logSize));




From nicolas.geoffray at gmail.com  Wed Nov 30 14:45:11 2011
From: nicolas.geoffray at gmail.com (Nicolas Geoffray)
Date: Wed, 30 Nov 2011 23:45:11 +0100
Subject: [vmkit-commits] [vmkit] r145527 -
	/vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
In-Reply-To: <20111130221256.DA6F12A6C12C@llvm.org>
References: <20111130221256.DA6F12A6C12C@llvm.org>
Message-ID: <CAPYwfioUNmsXY5yxWyVafVhyLB5y3EAOdVMcgNuCZYr+-BFbvA@mail.gmail.com>

Hi Will,

On Wed, Nov 30, 2011 at 11:12 PM, Will Dietz <wdietz2 at illinois.edu> wrote:

> Author: wdietz2
> Date: Wed Nov 30 16:12:56 2011
> New Revision: 145527
>
> URL: http://llvm.org/viewvc/llvm-project?rev=145527&view=rev
> Log:
> ArrayCopy: handle overlapping arrays of Objects
>
> Modified:
>    vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
>
> Modified: vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
> URL:
> http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc?rev=145527&r1=145526&r2=145527&view=diff
>
> ==============================================================================
> --- vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc (original)
> +++ vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc Wed Nov 30 16:12:56 2011
> @@ -62,17 +62,30 @@
>   }
>
>   if (!(dstType->isPrimitive())) {
> +    // Scan to ensure element compatibility, recording the first item
> +    // that requires an exception be thrown.
> +    int badEl = -1;
>     for (int i = 0; i < len; i++) {
>       cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);
>       if (cur) {
>         if (!(JavaObject::getClass(cur)->isAssignableFrom(dstType))) {
> -          th->throwException(vm->CreateArrayStoreException(
> -              (JavaVirtualTable*)dst->getVirtualTable()));
> -          UNREACHABLE();
> +          badEl = i;
> +          break;
>         }
>       }
> -      ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);
>     }
> +
> +    // Copy over the non-conflicting elements, handling overlaps
> +    void* ptrDst =
> (void*)((int64_t)ArrayObject::getElements((ArrayObject*)dst) +
> dstart*sizeof(void*));
> +    void* ptrSrc =
> (void*)((int64_t)ArrayObject::getElements((ArrayObject*)src) +
> sstart*sizeof(void*));
> +    int copyLen = badEl == -1 ? len : badEl - 1;
> +    if (copyLen > 0)
> +      memmove(ptrDst, ptrSrc, copyLen * sizeof(void*));
>

Please do not do a memmove on ArrayObject. It is fine to do a memmove on
primitive arrays, but definitely not on arrays of objects. You need to
execute a write barrier for each copied element.

To fix overlaps, I guess you need to check the start indices for both
arrays, and see which one starts first to know in which side you need to
iterate (from end to start or from start to end).

Nicolas


> +
> +    // TODO: Record the conflicting types in the exception message?
> +    if (badEl != -1)
> +      vm->arrayStoreException();
> +
>   } else {
>     uint32 logSize = dstType->asPrimitiveClass()->logSize;
>     void* ptrDst = (void*)((int64_t)JavaArray::getElements(dst) + (dstart
> << logSize));
>
>
> _______________________________________________
> 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/20111130/f828e1b7/attachment.html>

From wdietz2 at illinois.edu  Wed Nov 30 14:58:48 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 30 Nov 2011 16:58:48 -0600
Subject: [vmkit-commits] [vmkit] r145527 -
	/vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
In-Reply-To: <CAPYwfioUNmsXY5yxWyVafVhyLB5y3EAOdVMcgNuCZYr+-BFbvA@mail.gmail.com>
References: <20111130221256.DA6F12A6C12C@llvm.org>
	<CAPYwfioUNmsXY5yxWyVafVhyLB5y3EAOdVMcgNuCZYr+-BFbvA@mail.gmail.com>
Message-ID: <CAKGWAO_KVHu6OEDUHW8aM7X=b7xOcnmQGC6X+gYBz299nS7bjg@mail.gmail.com>

On Wed, Nov 30, 2011 at 4:45 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> Hi Will,
>
> On Wed, Nov 30, 2011 at 11:12 PM, Will Dietz <wdietz2 at illinois.edu> wrote:
>>
>> Author: wdietz2
>> Date: Wed Nov 30 16:12:56 2011
>> New Revision: 145527
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=145527&view=rev
>> Log:
>> ArrayCopy: handle overlapping arrays of Objects
>>
>> Modified:
>>    vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
>>
>> Modified: vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
>> URL:
>> http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc?rev=145527&r1=145526&r2=145527&view=diff
>>
>> ==============================================================================
>> --- vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc (original)
>> +++ vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc Wed Nov 30 16:12:56 2011
>> @@ -62,17 +62,30 @@
>>   }
>>
>>   if (!(dstType->isPrimitive())) {
>> +    // Scan to ensure element compatibility, recording the first item
>> +    // that requires an exception be thrown.
>> +    int badEl = -1;
>>     for (int i = 0; i < len; i++) {
>>       cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);
>>       if (cur) {
>>         if (!(JavaObject::getClass(cur)->isAssignableFrom(dstType))) {
>> -          th->throwException(vm->CreateArrayStoreException(
>> -              (JavaVirtualTable*)dst->getVirtualTable()));
>> -          UNREACHABLE();
>> +          badEl = i;
>> +          break;
>>         }
>>       }
>> -      ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);
>>     }
>> +
>> +    // Copy over the non-conflicting elements, handling overlaps
>> +    void* ptrDst =
>> (void*)((int64_t)ArrayObject::getElements((ArrayObject*)dst) +
>> dstart*sizeof(void*));
>> +    void* ptrSrc =
>> (void*)((int64_t)ArrayObject::getElements((ArrayObject*)src) +
>> sstart*sizeof(void*));
>> +    int copyLen = badEl == -1 ? len : badEl - 1;
>> +    if (copyLen > 0)
>> +      memmove(ptrDst, ptrSrc, copyLen * sizeof(void*));
>
>
> Please do not do a memmove on ArrayObject. It is fine to do a memmove on
> primitive arrays, but definitely not on arrays of objects. You need to
> execute a write barrier for each copied element.
>
> To fix overlaps, I guess you need to check the start indices for both
> arrays, and see which one starts first to know in which side you need to
> iterate (from end to start or from start to end).
>
> Nicolas

Okay, sure thing.  I mistakenly thought we didn't have write barriers
in the existing version for some reason, probably was looking at wrong
part of JavaArray.h, whoops.

Anyway, sorry about this and I'll either revert or fix this in mainline shortly.

Thanks!

~Will



From wdietz2 at illinois.edu  Wed Nov 30 15:32:58 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 30 Nov 2011 23:32:58 -0000
Subject: [vmkit-commits] [vmkit] r145540 -
	/vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
Message-ID: <20111130233259.06C342A6C12C@llvm.org>

Author: wdietz2
Date: Wed Nov 30 17:32:58 2011
New Revision: 145540

URL: http://llvm.org/viewvc/llvm-project?rev=145540&view=rev
Log:
ArrayCopy: Don't use memmove for Object arrays--we need to use write barriers.

Fixes regression (regarding barriers) introduced in r145527.

Modified:
    vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc

Modified: vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc?rev=145540&r1=145539&r2=145540&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/ArrayCopy.inc Wed Nov 30 17:32:58 2011
@@ -62,28 +62,42 @@
   }
 
   if (!(dstType->isPrimitive())) {
+
     // Scan to ensure element compatibility, recording the first item
     // that requires an exception be thrown.
-    int badEl = -1;
+    // Unfortunately in the case that an element can't be assigned,
+    // System.arrayCopy is required to do the partial copy, hence this check.
+    int copyLen = len;
     for (int i = 0; i < len; i++) {
       cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);
       if (cur) {
         if (!(JavaObject::getClass(cur)->isAssignableFrom(dstType))) {
-          badEl = i;
+          copyLen = i; // copy up until this element
           break;
         }
       }
     }
 
-    // Copy over the non-conflicting elements, handling overlaps
-    void* ptrDst = (void*)((int64_t)ArrayObject::getElements((ArrayObject*)dst) + dstart*sizeof(void*));
-    void* ptrSrc = (void*)((int64_t)ArrayObject::getElements((ArrayObject*)src) + sstart*sizeof(void*));
-    int copyLen = badEl == -1 ? len : badEl - 1;
-    if (copyLen > 0)
-      memmove(ptrDst, ptrSrc, copyLen * sizeof(void*));
+    // If same array, then there's a potential for overlap.
+    // Check this now, and use it to determine iteration order.
+    bool backward = (src == dst) &&
+                    (sstart < dstart) &&
+                    (sstart + copyLen > dstart);
+
+    if (backward) {
+      for(int i = copyLen - 1; i >= 0; --i) {
+        cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);
+        ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);
+      }
+    } else {
+      for(int i = 0; i < copyLen; ++i) {
+        cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);
+        ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);
+      }
+    }
 
     // TODO: Record the conflicting types in the exception message?
-    if (badEl != -1)
+    if (copyLen != len)
       vm->arrayStoreException();
 
   } else {




From wdietz2 at illinois.edu  Wed Nov 30 15:49:32 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Wed, 30 Nov 2011 17:49:32 -0600
Subject: [vmkit-commits] FatLock assertion failure?
In-Reply-To: <CAPYwfirVfUNUNEiMdCYbjUGNtP-n_tvL3zbarzjq1o2hM=ZHEw@mail.gmail.com>
References: <CAKGWAO9YXa6ehFk4_dX7v++518joWhWZjDFFXthWccxwCKwQuA@mail.gmail.com>
	<CAPYwfirVfUNUNEiMdCYbjUGNtP-n_tvL3zbarzjq1o2hM=ZHEw@mail.gmail.com>
Message-ID: <CAKGWAO-9c73qBxPQH4gbrcFm+b30HPW1zAU-3TeiRB-O0Ho8gg@mail.gmail.com>

On Tue, Nov 29, 2011 at 10:01 AM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> Hi Will,
>
> On Tue, Nov 29, 2011 at 3:59 PM, Will Dietz <wdietz2 at illinois.edu> wrote:
>>
>> Hi,
>>
>> On both runtimes, I'm seeing the following assertion occur
>> periodically (unpredictably, same code sometimes tickles it other
>> times not)
>>
>> j3: /home/will/vmkit-svn/lib/vmkit/CommonThread/ObjectLocks.cpp:305:
>> bool vmkit::FatLock::acquire(gc *): Assertion `obj->header &
>> ThinLock::FatMask' failed.
>
> That's because you have too many cores :).... That's a lame answer. The real
> answer is that there is a bug somewhere in the locking implementation. I
> also experience in on my desktop machine (8 cores), but never on my laptop
> (2 cores).
> Nicolas
>

Thanks!

Inspired by your response, I looked into this a bit and seem to have a
bit more on the issue:

The problem occurs when we try to deflate a fat lock back to a thin
lock--there's a race on the object headers that makes the guard (that
wants to be "does anyone have a pointer to this lock anywhere") unsafe
(ObjectLocks.cpp:278-279).  Indeed (from my limited understanding of
the literature, gulp) this seems to be a tricky problem in general and
not just a bug of this implementation.

Given this, and that we probably want locks to work on SMP machines
(well, I sure do! :D), it seems we have at least two solutions:

* Implement a more complicated locking solution ("tasuki" locks?).
* Disallow deflating of fat locks altogether.  I've done this locally
to great success--a lot of mysterious crashes/assertion failures are
now gone.  Downside is potential performance hit in terms of locking
overhead and lock resource utilization.

I'm inclined to suggest we just go with the latter, and put the former
on the TODO list... but of course it's up to you, and I'm curious what
your thoughts on all this are :).

Thanks!

~Will


From wdietz2 at illinois.edu  Wed Nov 30 20:48:27 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 01 Dec 2011 04:48:27 -0000
Subject: [vmkit-commits] [vmkit] r145571 - in /vmkit/trunk/lib/j3/ClassLib:
 ClassContext.inc OpenJDK/OpenJDK.inc
Message-ID: <20111201044827.729E82A6C12C@llvm.org>

Author: wdietz2
Date: Wed Nov 30 22:48:27 2011
New Revision: 145571

URL: http://llvm.org/viewvc/llvm-project?rev=145571&view=rev
Log:
Fix GetClassContext for OpenJDK, need to skip JNI frame.

Important change that gets a lot of more complicated codes (particularly those
    using custom classloaders and j.u.ResourceBundle) working!

Modified:
    vmkit/trunk/lib/j3/ClassLib/ClassContext.inc
    vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc

Modified: vmkit/trunk/lib/j3/ClassLib/ClassContext.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/ClassContext.inc?rev=145571&r1=145570&r2=145571&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/ClassContext.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/ClassContext.inc Wed Nov 30 22:48:27 2011
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-ArrayObject* GetClassContext() {
+ArrayObject* GetClassContext(uint32 level = 0) {
   ArrayObject* result = NULL;
   JavaObject* delegatee = NULL;
   llvm_gcroot(result, 0);
@@ -22,14 +22,15 @@
 
   uint32 finalSize = th->getJavaFrameContext((void**)buffer);
 
+  assert(level < finalSize);
   result = (ArrayObject*)
-    vm->upcalls->classArrayClass->doNew(finalSize, vm);
+    vm->upcalls->classArrayClass->doNew(finalSize - level, vm);
 
-  for (uint32 i = 0; i != finalSize; ++i) {
+  for (uint32 i = level; i != finalSize; ++i) {
     JavaMethod* meth = ((JavaMethod**)buffer)[i];
     assert(meth && "Wrong stack trace");
     delegatee = meth->classDef->getClassDelegatee(vm);;
-    ArrayObject::setElement(result, delegatee, i);
+    ArrayObject::setElement(result, delegatee, i - level);
   }
 
   return result;

Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc?rev=145571&r1=145570&r2=145571&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/OpenJDK.inc Wed Nov 30 22:48:27 2011
@@ -836,7 +836,7 @@
   llvm_gcroot(res, 0);
   BEGIN_JNI_EXCEPTION
 
-  res = GetClassContext();
+  res = GetClassContext(1);
 
   RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(res));
   END_JNI_EXCEPTION




From wdietz2 at illinois.edu  Wed Nov 30 20:48:29 2011
From: wdietz2 at illinois.edu (Will Dietz)
Date: Thu, 01 Dec 2011 04:48:29 -0000
Subject: [vmkit-commits] [vmkit] r145572 - /vmkit/trunk/lib/j3/VMCore/Jni.cpp
Message-ID: <20111201044829.47BE92A6C12C@llvm.org>

Author: wdietz2
Date: Wed Nov 30 22:48:29 2011
New Revision: 145572

URL: http://llvm.org/viewvc/llvm-project?rev=145572&view=rev
Log:
Implement JNI's ExceptionClear.

Modified:
    vmkit/trunk/lib/j3/VMCore/Jni.cpp

Modified: vmkit/trunk/lib/j3/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/Jni.cpp?rev=145572&r1=145571&r2=145572&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/Jni.cpp Wed Nov 30 22:48:29 2011
@@ -246,8 +246,10 @@
 
 
 void ExceptionClear(JNIEnv *env) {
-  NYI();
-  abort();
+  BEGIN_JNI_EXCEPTION
+  JavaThread::get()->pendingException = NULL;
+  RETURN_VOID_FROM_JNI
+  END_JNI_EXCEPTION
 }
 
 




From gael.thomas00 at gmail.com  Wed Nov  9 03:04:14 2011
From: gael.thomas00 at gmail.com (=?ISO-8859-1?Q?Ga=EBl_Thomas?=)
Date: Wed, 09 Nov 2011 11:04:14 -0000
Subject: [vmkit-commits] [vmkit] r144137 - /vmkit/trunk/Makefile.rules
In-Reply-To: <CAPYwfio1yd7HU+Q=eYQKGxbWBpfdVVYVMdYJqGKJrLu2Fae6yQ@mail.gmail.com>
References: <20111108221609.DF8BA2A6C12C@llvm.org>
	<CAPYwfio1yd7HU+Q=eYQKGxbWBpfdVVYVMdYJqGKJrLu2Fae6yQ@mail.gmail.com>
Message-ID: <CAOWuPDddjwTdW0r+Z42GEGo1V+eqE6RJaLJUapFg4TE-dLedRA@mail.gmail.com>

Hi,

I will take a look.

Gaël

2011/11/8 Nicolas Geoffray <nicolas.geoffray at gmail.com>:
> Hi Gael,
>
> On Tue, Nov 8, 2011 at 11:16 PM, Gael Thomas <gael.thomas at lip6.fr> wrote:
>>
>> Author: gthomas
>> Date: Tue Nov  8 16:16:09 2011
>> New Revision: 144137
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=144137&view=rev
>> Log:
>> generate object with gc by using relative names
>>
>> Modified:
>>    vmkit/trunk/Makefile.rules
>>
>> Modified: vmkit/trunk/Makefile.rules
>> URL:
>> http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile.rules?rev=144137&r1=144136&r2=144137&view=diff
>>
>> ==============================================================================
>> --- vmkit/trunk/Makefile.rules (original)
>> +++ vmkit/trunk/Makefile.rules Tue Nov  8 16:16:09 2011
>> @@ -104,11 +104,11 @@
>>
>>  $(ObjectsBCWithGC): $(ObjDir)/%_gc.bc: $(ObjDir)/%.ll $(LOPT)
>>        $(Echo) "Compiling $*.ll to $*.bc for $(BuildMode) build
>> (bytecode)"
>> -       $(Verb) $(LOPT) $< -load=$(LibDir)/StaticGCPass$(SHLIBEXT)
>> -std-compile-opts -StaticGCPass -o $@
>> +       $(Verb) $(LOPT) $<
>> -load=$(VMKIT_SRC_ROOT)/$(BuildMode)/lib/StaticGCPass$(SHLIBEXT)
>> -std-compile-opts -StaticGCPass -o $@
>>
>>  $(ObjectsSWithGC): $(ObjDir)/%_gc.s: $(ObjDir)/%_gc.bc $(LLC)
>>        $(Echo) "Compiling $*.bc to $*.s for $(BuildMode) build"
>> -       $(Verb) $(LLC) -disable-cfi -disable-fp-elim
>> -load=$(LibDir)/StaticGCPrinter$(SHLIBEXT) $< -o $@
>> +       $(Verb) $(LLC) -disable-cfi -disable-fp-elim
>> -load=$(VMKIT_SRC_ROOT)/$(BuildMode)/lib/StaticGCPrinter$(SHLIBEXT) $< -o $@
>>
>
> This does not work if you build vmkit in another directory than the source
> directory. Can you have a fix for handling both 'modes' (building in source,
> building outside)? Otherwise, I'll revert the change.
>
>>
>>  $(ObjectsWithGC): $(ObjDir)/%_gc.o: $(ObjDir)/%_gc.s $(ObjDir)/.dir
>>        $(Echo) "Compiling $*.s for $(BuildMode) build" $(PIC_FLAG)
>>
>>
>> _______________________________________________
>> vmkit-commits mailing list
>> vmkit-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>
>
> _______________________________________________
> vmkit-commits mailing list
> vmkit-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>
>



-- 
-------------------------------------------------------------------------------------------------
Gaël Thomas, Associate Professor,
University of Pierre and Marie Curie
Boite courrier 169, 217 - 26-00, REGAL Team, INRIA/LIP6,
4, place Jussieu, 75252 Paris Cedex 05, France
Web: http://pagesperso-systeme.lip6.fr/Gael.Thomas/
Phone (mob): +33 6 10 39 31 17           Fax : +33 1 44 27 70 00
-------------------------------------------------------------------------------------------------



From gael.thomas00 at gmail.com  Fri Nov 11 09:07:26 2011
From: gael.thomas00 at gmail.com (=?ISO-8859-1?Q?Ga=EBl_Thomas?=)
Date: Fri, 11 Nov 2011 17:07:26 -0000
Subject: [vmkit-commits] Renaming
In-Reply-To: <CAPYwfirOftiCH0Ww8mVya00nKoxOM=qLSCTwYQSiM64uZaTm=w@mail.gmail.com>
References: <CAOWuPDcvLXMNA+qZu_RFrsTQFdY2eiWhevpX13bsunf2g1=6gw@mail.gmail.com>
	<CAPYwfirOftiCH0Ww8mVya00nKoxOM=qLSCTwYQSiM64uZaTm=w@mail.gmail.com>
Message-ID: <CAOWuPDfMqk9wvA_1+OREsddyQAOinVG6rr3k-j6u32d4YcLP-g@mail.gmail.com>

Hi!
No problem, I will not work this week-end :) Just let me know when you
are ready,
Gaël

2011/11/11 Nicolas Geoffray <nicolas.geoffray at gmail.com>:
> Hi Gael!
> There's a big change I'd like to commit before the refactoring. Could you do
> the changes on Monday instead? Thanks!
> Nicolas
>
> On Thu, Nov 10, 2011 at 4:18 PM, Gaël Thomas <gael.thomas at lip6.fr> wrote:
>>
>> Hi all!
>>
>> I will make some changes in the global design of vmkit: I will mainly
>> rename the package mvm into vmkit and replace all the names that
>> contain mvm to use vmkit. I will also modify the directories (Mvm will
>> be vmkit and include/mvm/*, include/mvm/Threads/*, include/mvm/* will
>> be in include/vmkit/*). If you have pending changes to commit (or even
>> pending branches!), be careful :). I will probably make these updates
>> on friday during the day, if you want, I can wait,
>>
>> Gaël
>>
>>
>>
>>
>> --
>>
>> -------------------------------------------------------------------------------------------------
>> Gaël Thomas, Associate Professor,
>> University of Pierre and Marie Curie
>> Boite courrier 169, 217 - 26-00, REGAL Team, INRIA/LIP6,
>> 4, place Jussieu, 75252 Paris Cedex 05, France
>> Web: http://pagesperso-systeme.lip6.fr/Gael.Thomas/
>> Phone (mob): +33 6 10 39 31 17           Fax : +33 1 44 27 70 00
>>
>> -------------------------------------------------------------------------------------------------
>>
>> _______________________________________________
>> vmkit-commits mailing list
>> vmkit-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>
>
> _______________________________________________
> vmkit-commits mailing list
> vmkit-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>
>



-- 
-------------------------------------------------------------------------------------------------
Gaël Thomas, Associate Professor,
University of Pierre and Marie Curie
Boite courrier 169, 217 - 26-00, REGAL Team, INRIA/LIP6,
4, place Jussieu, 75252 Paris Cedex 05, France
Web: http://pagesperso-systeme.lip6.fr/Gael.Thomas/
Phone (mob): +33 6 10 39 31 17           Fax : +33 1 44 27 70 00
-------------------------------------------------------------------------------------------------



From gael.thomas00 at gmail.com  Mon Nov 21 01:18:33 2011
From: gael.thomas00 at gmail.com (=?ISO-8859-1?Q?Ga=EBl_Thomas?=)
Date: Mon, 21 Nov 2011 09:18:33 -0000
Subject: [vmkit-commits] [vmkit] r145023 -
	/vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp
In-Reply-To: <20111121032703.359052A6C134@llvm.org>
References: <20111121032703.359052A6C134@llvm.org>
Message-ID: <CAOWuPDdwOZkNaB6VgmhAywbN_cAKN5PUyHvGnVhYgFenHQfVmA@mail.gmail.com>

Hi all!

I will begin the refactoring now. I think that it will be ready in 4/5
hours. I send you a mail when it is done,

Gaël

2011/11/21 Will Dietz <wdietz2 at illinois.edu>:
> Author: wdietz2
> Date: Sun Nov 20 21:27:02 2011
> New Revision: 145023
>
> URL: http://llvm.org/viewvc/llvm-project?rev=145023&view=rev
> Log:
> Drop use of getNameStr, removed from LLVM in r144657
>
> Modified:
>    vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp
>
> Modified: vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp
> URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp?rev=145023&r1=145022&r2=145023&view=diff
> ==============================================================================
> --- vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp (original)
> +++ vmkit/trunk/lib/Mvm/Compiler/EscapeAnalysis.cpp Sun Nov 20 21:27:02 2011
> @@ -218,7 +218,7 @@
>         // we don't end up with tons of allocations on the stack.
>         BasicBlock* BB = CurLoop->getLoopPreheader();
>         assert(BB && "No Preheader!");
> -        DEBUG(errs() << "Escape analysis hoisting to " << BB->getNameStr());
> +        DEBUG(errs() << "Escape analysis hoisting to " << BB->getName().str());
>         DEBUG(errs() << ": ");
>         DEBUG(errs() << *Alloc);
>         Alloc->removeFromParent();
> @@ -229,7 +229,7 @@
>                                       Alloc);
>       BitCastInst* BI = new BitCastInst(AI, Alloc->getType(), "", Alloc);
>       DEBUG(errs() << "escape");
> -      DEBUG(errs() << Alloc->getParent()->getParent()->getNameStr() << "\n");
> +      DEBUG(errs() << Alloc->getParent()->getParent()->getName().str() << "\n");
>       Alloc->replaceAllUsesWith(BI);
>       // If it's an invoke, replace the invoke with a direct branch.
>       if (InvokeInst *CI = dyn_cast<InvokeInst>(Alloc)) {
>
>
> _______________________________________________
> vmkit-commits mailing list
> vmkit-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>



-- 
-------------------------------------------------------------------------------------------------
Gaël Thomas, Associate Professor,
University of Pierre and Marie Curie
Boite courrier 169, 217 - 26-00, REGAL Team, INRIA/LIP6,
4, place Jussieu, 75252 Paris Cedex 05, France
Web: http://pagesperso-systeme.lip6.fr/Gael.Thomas/
Phone (mob): +33 6 10 39 31 17           Fax : +33 1 44 27 70 00
-------------------------------------------------------------------------------------------------