[vmkit-commits] [vmkit] r60212 - in /vmkit/trunk: ./ autoconf/ lib/JnJVM/Classpath/ lib/JnJVM/LLVMRuntime/ lib/JnJVM/VMCore/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Fri Nov 28 13:20:44 PST 2008
Author: geoffray
Date: Fri Nov 28 15:20:44 2008
New Revision: 60212
URL: http://llvm.org/viewvc/llvm-project?rev=60212&view=rev
Log:
Major code cleanup for the CommonClass hierarchy. Now
CommonClass is minimal, ie fits with all types of classes:
arrays, primitives and regular classes. Specific informations
are placed in ArrayClass, PrimitiveClass and Class.
Modified:
vmkit/trunk/Makefile.config.in
vmkit/trunk/autoconf/configure.ac
vmkit/trunk/configure
vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp
vmkit/trunk/lib/JnJVM/LLVMRuntime/Makefile
vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll
vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll
vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll
vmkit/trunk/lib/JnJVM/VMCore/JavaAccess.h
vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h
vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h
vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h
vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaString.h
vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp
vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
vmkit/trunk/lib/JnJVM/VMCore/JnjvmConfig.h
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp
vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp
vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp
vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
Modified: vmkit/trunk/Makefile.config.in
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile.config.in?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/Makefile.config.in (original)
+++ vmkit/trunk/Makefile.config.in Fri Nov 28 15:20:44 2008
@@ -10,3 +10,4 @@
GC_MMAP2 = @GC_MMAP2@
ISOLATE_BUILD = @ISOLATE_BUILD@
SERVICE_BUILD = @SERVICE_BUILD@
+SINGLE_BUILD = @SINGLE_BUILD@
Modified: vmkit/trunk/autoconf/configure.ac
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/autoconf/configure.ac?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/autoconf/configure.ac (original)
+++ vmkit/trunk/autoconf/configure.ac Fri Nov 28 15:20:44 2008
@@ -224,13 +224,22 @@
if test "x$vmtype" = "xisolate"; then
VM_FLAGS="-DISOLATE"
ISOLATE_BUILD=1
+ SERVICE_BUILD=0
+ SINGLE_BUILD=0
else
if test "x$vmtype" = "xservice"; then
VM_FLAGS="-DISOLATE -DSERVICE"
SERVICE_BUILD=1
+ ISOLATE_BUILD=1
+ SINGLE_BUILD=0
+ else
+ SINGLE_BUILD=1
+ ISOLATE_BUILD=0
+ SERVICE_BUILD=0
fi
fi
+AC_SUBST([SINGLE_BUILD])
AC_SUBST([SERVICE_BUILD])
AC_SUBST([ISOLATE_BUILD])
AC_SUBST([VM_FLAGS])
Modified: vmkit/trunk/configure
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/configure?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/configure (original)
+++ vmkit/trunk/configure Fri Nov 28 15:20:44 2008
@@ -687,6 +687,7 @@
GC_SINGLE_MMAP
GC_FLAGS
GC_LIBS
+SINGLE_BUILD
SERVICE_BUILD
ISOLATE_BUILD
VM_FLAGS
@@ -3946,10 +3947,18 @@
if test "x$vmtype" = "xisolate"; then
VM_FLAGS="-DISOLATE"
ISOLATE_BUILD=1
+ SERVICE_BUILD=0
+ SINGLE_BUILD=0
else
if test "x$vmtype" = "xservice"; then
VM_FLAGS="-DISOLATE -DSERVICE"
SERVICE_BUILD=1
+ ISOLATE_BUILD=1
+ SINGLE_BUILD=0
+ else
+ SINGLE_BUILD=1
+ ISOLATE_BUILD=0
+ SERVICE_BUILD=0
fi
fi
@@ -3958,6 +3967,7 @@
+
classpathversion=0.97.2;
@@ -7852,6 +7862,7 @@
GC_SINGLE_MMAP!$GC_SINGLE_MMAP$ac_delim
GC_FLAGS!$GC_FLAGS$ac_delim
GC_LIBS!$GC_LIBS$ac_delim
+SINGLE_BUILD!$SINGLE_BUILD$ac_delim
SERVICE_BUILD!$SERVICE_BUILD$ac_delim
ISOLATE_BUILD!$ISOLATE_BUILD$ac_delim
VM_FLAGS!$VM_FLAGS$ac_delim
@@ -7879,7 +7890,6 @@
MKDIR!$MKDIR$ac_delim
MV!$MV$ac_delim
RANLIB!$RANLIB$ac_delim
-RM!$RM$ac_delim
_ACEOF
if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
@@ -7921,6 +7931,7 @@
ac_delim='%!_!# '
for ac_last_try in false false false false false :; do
cat >conf$$subs.sed <<_ACEOF
+RM!$RM$ac_delim
SED!$SED$ac_delim
TAR!$TAR$ac_delim
BINPWD!$BINPWD$ac_delim
@@ -7936,7 +7947,7 @@
LTLIBOBJS!$LTLIBOBJS$ac_delim
_ACEOF
- if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 13; then
+ if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 14; then
break
elif $ac_last_try; then
{ { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Fri Nov 28 15:20:44 2008
@@ -32,9 +32,10 @@
verifyNull(Cl);
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, true);
- if (cl->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
- vm->bootstrapLoader->clinitType, true,
- false, 0))
+ if (!cl->asClass()) return false;
+ if (cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
+ vm->bootstrapLoader->clinitType,
+ true, false, 0))
return true;
return false;
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp Fri Nov 28 15:20:44 2008
@@ -57,8 +57,8 @@
UserCommonClass* cl = JCL->lookupClassFromJavaString((JavaString*)str, vm,
true, false);
if (cl != 0) {
- if (clinit) {
- cl->initialiseClass(vm);
+ if (clinit && cl->asClass()) {
+ cl->asClass()->initialiseClass(vm);
}
return (jclass)(cl->getClassDelegatee(vm));
} else {
@@ -81,8 +81,9 @@
if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
return (jobject)vm->upcalls->constructorArrayClass->doNew(0, vm);
} else {
+ UserClass* realCl = (Class*)cl;
std::vector<JavaMethod*> res;
- cl->getDeclaredConstructors(res, publicOnly);
+ realCl->getDeclaredConstructors(res, publicOnly);
ArrayObject* ret =
(ArrayObject*)vm->upcalls->constructorArrayClass->doNew(res.size(), vm);
@@ -112,11 +113,12 @@
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false);
Classpath* upcalls = vm->upcalls;
- if (cl->isArray()) {
+ if (cl->isArray() || cl->isPrimitive()) {
return (jobject)upcalls->methodArrayClass->doNew(0, vm);
} else {
std::vector<JavaMethod*> res;
- cl->getDeclaredMethods(res, publicOnly);
+ UserClass* realCl = cl->asClass();
+ realCl->getDeclaredMethods(res, publicOnly);
ArrayObject* ret =
(ArrayObject*)upcalls->methodArrayClass->doNew(res.size(), vm);
@@ -223,7 +225,7 @@
UserCommonClass* cl1 = ((JavaObjectClass*)Cl1)->getClass();
UserCommonClass* cl2 = ((JavaObjectClass*)Cl2)->getClass();
- cl2->resolveClass();
+ if (cl2->asClass()) cl2->asClass()->resolveClass();
return cl2->isAssignableFrom(cl1);
}
@@ -239,7 +241,7 @@
if (cl->isInterface())
return 0;
else {
- cl->resolveClass();
+ if (cl->asClass()) cl->asClass()->resolveClass();
if (cl->getSuper()) return (jobject)cl->getSuper()->getClassDelegatee(vm);
else return 0;
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp Fri Nov 28 15:20:44 2008
@@ -35,10 +35,16 @@
Jnjvm* vm = JavaThread::get()->getJVM();
uint64 size = 0;
if (cl->isArray()) {
- size = sizeof(JavaArray) + ((JavaArray*)src)->size *
- ((UserClassArray*)cl)->baseClass()->getVirtualSize();
+ UserClassArray* array = cl->asArrayClass();
+ UserCommonClass* base = array->baseClass();
+ uint32 primSize = base->isPrimitive() ?
+ base->asPrimitiveClass()->primSize : sizeof(JavaObject*);
+
+ size = sizeof(JavaObject) + sizeof(ssize_t) +
+ ((JavaArray*)src)->size * primSize;
} else {
- size = cl->getVirtualSize();
+ assert(cl->isClass() && "Not a class!");
+ size = cl->asClass()->getVirtualSize();
}
JavaObject* res = (JavaObject*)
vm->gcAllocator.allocateManagedObject(size, src->getVirtualTable());
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp Fri Nov 28 15:20:44 2008
@@ -85,7 +85,7 @@
}
uint32 size = dstType->isPrimitive() ?
- dstType->virtualSize : sizeof(JavaObject*);
+ dstType->asPrimitiveClass()->primSize : sizeof(JavaObject*);
assert(size && "Size zero in a arraycopy");
void* ptrDst = (void*)((int64_t)(dst->elements) + size * dstart);
Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/Makefile?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/LLVMRuntime/Makefile (original)
+++ vmkit/trunk/lib/JnJVM/LLVMRuntime/Makefile Fri Nov 28 15:20:44 2008
@@ -32,11 +32,9 @@
endif
endif
-ifndef $(ISOLATE_BUILD)
-ifndef $(SERVICE_BUILD)
+ifeq ($(SINGLE_BUILD), 1)
VMKIT_RUNTIME += $(PROJ_SRC_DIR)/runtime-single.ll
endif
-endif
BUILT_SOURCES = LLVMRuntime.inc
Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll (original)
+++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll Fri Nov 28 15:20:44 2008
@@ -6,7 +6,7 @@
%VT = type i32 (...)**
;;; The root of all Java Objects: a VT, a class and a lock.
-%JavaObject = type { %VT, %JavaClass*, i8* }
+%JavaObject = type { %VT, %JavaCommonClass*, i8* }
;;; Types for Java arrays. A size of 0 means an undefined size.
%JavaArray = type { %JavaObject, i8* }
@@ -25,12 +25,28 @@
;;; to lookup in the constant pool.
%Enveloppe = type { %CacheNode*, i8**, i8*, i32 }
+;;; The task class mirror.
+;;; Field 1: The class state
+;;; Field 2: The static instance
+%TaskClassMirror = type { i32, i8* }
+
+%Attribut = type { %UTF8*, i32, i32 }
+
+%UTF8 = type { %JavaObject, i8*, [0 x i16] }
+
+
+%JavaField = type { i8*, i16, %UTF8*, %UTF8*, %Attribut*, i16, %JavaClass*, i64,
+ i16, i8* }
+
+%JavaMethod = type { i8*, i16, %Attribut*, i16, %Enveloppe*, i16, %JavaClass*,
+ %UTF8*, %UTF8*, i8, i8*, i32, i8* }
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;; Constant calls for Jnjvm runtime internal objects field accesses ;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; jnjvmRuntimeInitialiseClass - Initialises the class.
-declare %JavaClass* @jnjvmRuntimeInitialiseClass(%JavaClass*) readnone
+declare %JavaClass* @jnjvmRuntimeInitialiseClass(%JavaClass*) readnone
;;; arrayLength - Get the length of an array.
declare i32 @arrayLength(%JavaObject*) readnone
@@ -39,7 +55,7 @@
declare %VT @getVT(%JavaObject*) readnone
;;; getClass - Get the class of an object.
-declare %JavaClass* @getClass(%JavaObject*) readnone
+declare %JavaCommonClass* @getClass(%JavaObject*) readnone
;;; getLock - Get the lock of an object.
declare i8* @getLock(%JavaObject*)
@@ -52,13 +68,13 @@
declare i32 @getObjectSizeFromClass(%JavaClass*) readnone
;;; getDisplay - Get the display array of this class.
-declare %JavaClass** @getDisplay(%JavaClass*) readnone
+declare %JavaCommonClass** @getDisplay(%JavaCommonClass*) readnone
;;; getClassInDisplay - Get the super class at the given offset.
-declare %JavaClass* @getClassInDisplay(%JavaClass**, i32) readnone
+declare %JavaCommonClass* @getClassInDisplay(%JavaCommonClass**, i32) readnone
;;; getDepth - Get the depth of the class.
-declare i32 @getDepth(%JavaClass*) readnone
+declare i32 @getDepth(%JavaCommonClass*) readnone
;;; getStaticInstance - Get the static instance of this class.
declare i8* @getStaticInstance(%JavaClass*) readnone
@@ -73,7 +89,7 @@
;;; multiCallNew - Allocate multi-dimensional arrays. This will go to allocation
;;; specific methods.
-declare %JavaObject* @multiCallNew(%JavaClass*, i32, ...)
+declare %JavaObject* @multiCallNew(%JavaCommonClass*, i32, ...)
;;; initialisationCheck - Checks if the class has been initialized and
;;; initializes if not. This is used for initialization barriers in an isolate
@@ -122,30 +138,31 @@
declare void @overflowThinLock(%JavaObject*)
;;; isAssignableFrom - Returns if the objet's class implements the given class.
-declare i1 @instanceOf(%JavaObject*, %JavaClass*) readnone
+declare i1 @instanceOf(%JavaObject*, %JavaCommonClass*) readnone
;;; isAssignableFrom - Returns if the class implements the given class.
-declare i1 @isAssignableFrom(%JavaClass*, %JavaClass*) readnone
+declare i1 @isAssignableFrom(%JavaCommonClass*, %JavaCommonClass*) readnone
;;; implements - Returns if the class implements the given interface.
-declare i1 @implements(%JavaClass*, %JavaClass*) readnone
+declare i1 @implements(%JavaCommonClass*, %JavaCommonClass*) readnone
;;; instantiationOfArray - Returns if the class implements the given array.
-declare i1 @instantiationOfArray(%JavaClass*, %JavaClass*) readnone
+declare i1 @instantiationOfArray(%JavaCommonClass*, %JavaCommonClass*) readnone
;;; getClassDelegatee - Returns the java/lang/Class representation of the
;;; class.
-declare %JavaObject* @getClassDelegatee(%JavaClass*) readnone
+declare %JavaObject* @getClassDelegatee(%JavaCommonClass*) readnone
;;; getArrayClass - Get the array user class of the user class.
-declare %JavaClass* @getArrayClass(%JavaClass*, %JavaClass**) readnone
+declare %JavaCommonClass* @getArrayClass(%JavaCommonClass*,
+ %JavaCommonClass**) readnone
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Exception methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
declare void @jnjvmNullPointerException()
-declare void @jnjvmClassCastException(%JavaObject*, %JavaClass*)
+declare void @jnjvmClassCastException(%JavaObject*, %JavaCommonClass*)
declare void @indexOutOfBoundsException(%JavaObject*, i32)
declare void @negativeArraySizeException(i32)
declare void @outOfMemoryError(i32)
Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll (original)
+++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll Fri Nov 28 15:20:44 2008
@@ -4,27 +4,19 @@
%Jnjvm = type {%VT, %JavaClass*, [9 x %JavaClass*]}
-;;; The task class mirror in an isolate environment.
-;;; Field 1: The class state
-;;; Field 2: The class delegatee (java/lang/Class)
-;;; Field 3: The static instance
-%TaskClassMirror = type { i32, %JavaObject*, i8* }
-
-;;; The type of internal classes. This is not complete, but we only need
-;;; the first fields for now.
-;;; Field 1 - The VT of a class C++ object.
-;;; Field 2 - The size of instances of this class.
-;;; Field 3 - The VT of instances of this class.
-;;; Field 4 - The list of super classes of this class.
-;;; Field 5 - The depth of the class in its super hierarchy.
-;;; Field 6 - The class state (resolved, initialized, ...)
-;;; field 7 - The task class mirror, for an isolate environment
-%JavaClass = type { %VT, i32, %VT ,%JavaClass**, i32, i32,
- [0 x %TaskClassMirror] }
+%JavaCommonClass = type { %JavaCommonClass**, i32, [32 x %JavaObject*],
+ i16, %JavaClass**, i16, %UTF8*, %JavaClass*, i8* }
+
+
+%JavaClass = type { %JavaCommonClass, i32, %VT, [32 x %TaskClassMirror], i8*,
+ %JavaField*, i16, %JavaField*, i16, %JavaMethod*, i16,
+ %JavaMethod*, i16, i8*, %ArrayUInt8*, i8*, %Attribut*,
+ i16, %JavaClass**, i16, %JavaClass*, i16, i8, i32, i32, i8*,
+ void (i8*)* }
;;; The CacheNode type. The second field is the last called method. The
;;; last field is for multi vm environment.
-%CacheNode = type { i8*, %JavaClass*, %CacheNode*, %Enveloppe*, i8** }
+%CacheNode = type { i8*, %JavaCommonClass*, %CacheNode*, %Enveloppe*, i8** }
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;; Isolate specific methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll (original)
+++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll Fri Nov 28 15:20:44 2008
@@ -2,34 +2,16 @@
;;;;;;;;;;;;;;;;;;;;;;;;; Isolate specific types ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; The type of internal classes.
-;;; Field 1 - The VT of a class C++ object.
-;;; Field 2 - The size of instances of this class.
-;;; Field 3 - The VT of instances of this class.
-;;; Field 4 - The list of super classes of this class.
-;;; Field 5 - The depth of the class in its super hierarchy.
-;;; Field 6 - The class state (resolved, initialized, ...)
+%JavaCommonClass = type { %JavaCommonClass**, i32, [1 x %JavaObject*], i16,
+ %JavaClass**, i16, %UTF8*, %JavaClass*, i8* }
-%JavaClass = type { %VT, i32, %VT, %JavaClass**, i32, i32, i32, i8, i8,
- %Class**, i16, %UTF8*, %Class*, i8*, %JavaField*, i16,
- %JavaField*, i16, %JavaMethod*, i16, %JavaMethod*, i16,
- i8*, i8*, %JavaObject* }
+%JavaClass = type { %JavaCommonClass, i32, %VT, [1 x %TaskClassMirror], i8*,
+ %JavaField*, i16, %JavaField*, i16, %JavaMethod*, i16,
+ %JavaMethod*, i16, i8*, %ArrayUInt8*, i8*, %Attribut*,
+ i16, %JavaClass**, i16, %JavaClass*, i16, i8, i32, i32, i8*,
+ void (i8*)* }
-%Class = type { %JavaClass, %ArrayUInt8*, i8*, %Attribut*, i16, %Class**, i16,
- %Class*, i16, i8, i32, i32, void (i8*)*, i8*, i8* }
-
-
-%Attribut = type { %UTF8*, i32, i32 }
-
-%UTF8 = type { %ArrayUInt16 }
-
-
-%JavaField = type { i8*, i16, %UTF8*, %UTF8*, %Attribut*, i16, %Class*, i64,
- i16, i8* }
-
-%JavaMethod = type { i8*, i16, %Attribut*, i16, %Enveloppe*, i16, %Class*,
- %UTF8*, %UTF8*, i8, i8*, i32, i8* }
;;; The CacheNode type. The second field is the last called method.
-%CacheNode = type { i8*, %JavaClass*, %CacheNode*, %Enveloppe*}
+%CacheNode = type { i8*, %JavaCommonClass*, %CacheNode*, %Enveloppe*}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaAccess.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaAccess.h?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaAccess.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaAccess.h Fri Nov 28 15:20:44 2008
@@ -32,6 +32,10 @@
#define ACC_ABSTRACT 0x0400
#define ACC_STRICT 0x0800
+#define JNJVM_CLASS 0x1000
+#define JNJVM_ARRAY 0x2000
+#define JNJVM_PRIMITIVE 0x4000
+
#define MK_VERIFIER(name, flag) \
inline bool name(unsigned int param) { \
return (flag & param) != 0; \
@@ -47,11 +51,17 @@
MK_VERIFIER(isProtected, ACC_PROTECTED)
MK_VERIFIER(isFinal, ACC_FINAL)
MK_VERIFIER(isSuper, ACC_SUPER)
-
+
+
inline bool isVirtual(unsigned int param) {
return !(ACC_STATIC & param);
}
+MK_VERIFIER(isClass, JNJVM_CLASS)
+MK_VERIFIER(isPrimitive, JNJVM_PRIMITIVE)
+MK_VERIFIER(isArray, JNJVM_ARRAY)
+
+
#undef MK_VERIFIER
} // end namespace jnjvm
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Fri Nov 28 15:20:44 2008
@@ -85,22 +85,22 @@
CommonClass::CommonClass() {
display = 0;
- virtualVT = 0;
- nbVirtualFields = 0;
- nbStaticFields = 0;
- nbVirtualMethods = 0;
- nbStaticMethods = 0;
nbInterfaces = 0;
access = 0;
- ownerClass = 0;
}
Class::Class() : CommonClass() {
+ virtualVT = 0;
ctpInfo = 0;
JInfo = 0;
outerClass = 0;
innerOuterResolved = false;
nbInnerClasses = 0;
+ nbVirtualFields = 0;
+ nbStaticFields = 0;
+ nbVirtualMethods = 0;
+ nbStaticMethods = 0;
+ ownerClass = 0;
}
Class::~Class() {
@@ -139,9 +139,8 @@
classLoader->allocator.Deallocate(ctpInfo);
}
-#ifndef ISOLATE
- classLoader->allocator.Deallocate(_staticInstance);
-#endif
+ classLoader->allocator.Deallocate(IsolateInfo);
+
// Currently, only regular classes have a heap allocated virtualVT.
// Array classes have a C++ allocated virtualVT and primitive classes
// do not have a virtualVT.
@@ -202,7 +201,7 @@
}
void CommonClass::print(mvm::PrintBuffer* buf) const {
- buf->write("CommonClass<");
+ buf->write("Class<");
printClassName(name, buf);
buf->write(">");
}
@@ -261,31 +260,12 @@
CommonClass::CommonClass(JnjvmClassLoader* loader, const UTF8* n,
bool isArray) {
name = n;
- virtualVT = 0;
- status = loaded;
classLoader = loader;
- array = isArray;
- primitive = false;
- nbVirtualMethods = 0;
- nbStaticMethods = 0;
- nbStaticFields = 0;
- nbVirtualFields = 0;
nbInterfaces = 0;
interfaces = 0;
- virtualMethods = 0;
- staticMethods = 0;
- virtualFields = 0;
- staticFields = 0;
access = 0;
- ownerClass = 0;
super = 0;
-#if !defined(ISOLATE) && !defined(ISOLATE_SHARING)
- _delegatee = 0;
-#else
-#if defined(ISOLATE)
- memset(IsolateInfo, 0, sizeof(TaskClassMirror) * NR_ISOLATES);
-#endif
-#endif
+ memset(delegatee, 0, sizeof(JavaObject*) * NR_ISOLATES);
}
ClassPrimitive::ClassPrimitive(JnjvmClassLoader* loader, const UTF8* n,
@@ -294,14 +274,14 @@
display = (CommonClass**)loader->allocator.Allocate(sizeof(CommonClass*));
display[0] = this;
- primitive = true;
- status = ready;
- access = ACC_ABSTRACT | ACC_FINAL | ACC_PUBLIC;
- virtualSize = nb;
+ depth = 0;
+ access = ACC_ABSTRACT | ACC_FINAL | ACC_PUBLIC | JNJVM_PRIMITIVE;
+ primSize = nb;
}
Class::Class(JnjvmClassLoader* loader, const UTF8* n, ArrayUInt8* B) :
CommonClass(loader, n, false) {
+ virtualVT = 0;
bytes = B;
super = 0;
ctpInfo = 0;
@@ -311,9 +291,17 @@
display = 0;
nbInnerClasses = 0;
staticTracer = 0;
-#if !defined(ISOLATE) && !defined(ISOLATE_SHARING)
- _staticInstance = 0;
-#endif
+ nbVirtualMethods = 0;
+ nbStaticMethods = 0;
+ nbStaticFields = 0;
+ nbVirtualFields = 0;
+ virtualMethods = 0;
+ staticMethods = 0;
+ virtualFields = 0;
+ staticFields = 0;
+ ownerClass = 0;
+ access = JNJVM_CLASS;
+ memset(IsolateInfo, 0, sizeof(TaskClassMirror) * NR_ISOLATES);
}
ClassArray::ClassArray(JnjvmClassLoader* loader, const UTF8* n,
@@ -327,25 +315,7 @@
display = (CommonClass**)loader->allocator.Allocate(2 * sizeof(CommonClass*));
display[0] = ClassArray::SuperArray;
display[1] = this;
- access = ACC_FINAL | ACC_ABSTRACT | ACC_PUBLIC;
- if (base->isPrimitive()) {
- virtualVT = JavaArray::VT;
- } else {
- virtualVT = ArrayObject::VT;
- }
- status = ready;
-}
-
-void Class::print(mvm::PrintBuffer* buf) const {
- buf->write("Class<");
- printClassName(name, buf);
- buf->write(">");
-}
-
-void ClassArray::print(mvm::PrintBuffer* buf) const {
- buf->write("ClassArray<");
- printClassName(name, buf);
- buf->write(">");
+ access = ACC_FINAL | ACC_ABSTRACT | ACC_PUBLIC | JNJVM_ARRAY;
}
JavaArray* UserClassArray::doNew(sint32 n, Jnjvm* vm) {
@@ -359,12 +329,12 @@
JavaArray* UserClassArray::doNew(sint32 n, mvm::Allocator& allocator) {
UserCommonClass* cl = baseClass();
- assert(cl && virtualVT && "array class not resolved");
- uint32 primSize = cl->isPrimitive() ? cl->virtualSize : sizeof(JavaObject*);
+ uint32 primSize = cl->isPrimitive() ?
+ cl->asPrimitiveClass()->primSize : sizeof(JavaObject*);
+ VirtualTable* VT = cl->isPrimitive() ? JavaArray::VT : ArrayObject::VT;
uint32 size = sizeof(JavaObject) + sizeof(ssize_t) + n * primSize;
- JavaArray* res = (JavaArray*)allocator.allocateManagedObject(size,
- virtualVT);
+ JavaArray* res = (JavaArray*)allocator.allocateManagedObject(size, VT);
res->initialise(this);
res->size = n;
return res;
@@ -372,12 +342,14 @@
JavaArray* UserClassArray::doNew(sint32 n, mvm::BumpPtrAllocator& allocator) {
UserCommonClass* cl = baseClass();
- assert(cl && virtualVT && "array class not resolved");
- uint32 primSize = cl->isPrimitive() ? cl->virtualSize : sizeof(JavaObject*);
+ uint32 primSize = cl->isPrimitive() ?
+ cl->asPrimitiveClass()->primSize : sizeof(JavaObject*);
+ VirtualTable* VT = cl->isPrimitive() ? JavaArray::VT : ArrayObject::VT;
uint32 size = sizeof(JavaObject) + sizeof(ssize_t) + n * primSize;
+
JavaArray* res = (JavaArray*)allocator.Allocate(size);
- ((void**)res)[0] = virtualVT;
+ ((void**)res)[0] = VT;
res->initialise(this);
res->size = n;
return res;
@@ -420,8 +392,8 @@
return buf->contents()->cString();
}
-JavaMethod* CommonClass::lookupInterfaceMethodDontThrow(const UTF8* name,
- const UTF8* type) {
+JavaMethod* Class::lookupInterfaceMethodDontThrow(const UTF8* name,
+ const UTF8* type) {
JavaMethod* cur = lookupMethodDontThrow(name, type, false, false, 0);
if (!cur) {
for (uint16 i = 0; i < nbInterfaces; ++i) {
@@ -433,7 +405,7 @@
return cur;
}
-JavaMethod* CommonClass::lookupMethodDontThrow(const UTF8* name,
+JavaMethod* Class::lookupMethodDontThrow(const UTF8* name,
const UTF8* type,
bool isStatic,
bool recurse,
@@ -476,7 +448,7 @@
return 0;
}
-JavaMethod* CommonClass::lookupMethod(const UTF8* name, const UTF8* type,
+JavaMethod* Class::lookupMethod(const UTF8* name, const UTF8* type,
bool isStatic, bool recurse,
Class** methodCl) {
JavaMethod* res = lookupMethodDontThrow(name, type, isStatic, recurse,
@@ -488,9 +460,9 @@
}
JavaField*
-CommonClass::lookupFieldDontThrow(const UTF8* name, const UTF8* type,
+Class::lookupFieldDontThrow(const UTF8* name, const UTF8* type,
bool isStatic, bool recurse,
- CommonClass** definingClass) {
+ Class** definingClass) {
JavaField* fields = 0;
uint32 nb = 0;
if (isStatic) {
@@ -528,9 +500,9 @@
return 0;
}
-JavaField* CommonClass::lookupField(const UTF8* name, const UTF8* type,
+JavaField* Class::lookupField(const UTF8* name, const UTF8* type,
bool isStatic, bool recurse,
- CommonClass** definingClass) {
+ Class** definingClass) {
JavaField* res = lookupFieldDontThrow(name, type, isStatic, recurse,
definingClass);
@@ -579,7 +551,7 @@
while (res && Tname->elements[prof] == I_TAB) {
UserCommonClass* cl = ((UserClassArray*)curS)->baseClass();
++prof;
- cl->resolveClass();
+ if (cl->isClass()) cl->asClass()->resolveClass();
res = curS->isArray() && cl && (prof < len);
curS = cl;
}
@@ -720,33 +692,27 @@
}
-JavaMethod* CommonClass::constructMethod(JavaMethod& method,
- const UTF8* name,
- const UTF8* type, uint32 access) {
- method.name = name;
- method.type = type;
- method.classDef = (Class*)this;
- method._signature = 0;
- method.code = 0;
- method.access = access;
- method.canBeInlined = false;
- method.offset = 0;
- method.JInfo = 0;
- method.enveloppes = 0;
- return &method;
-}
-
-JavaField* CommonClass::constructField(JavaField& field,
- const UTF8* name,
- const UTF8* type, uint32 access) {
- field.name = name;
- field.type = type;
- field.classDef = (Class*)this;
- field._signature = 0;
- field.ptrOffset = 0;
- field.access = access;
- field.JInfo = 0;
- return &field;
+void JavaMethod::initialise(Class* cl, const UTF8* N, const UTF8* T, uint16 A) {
+ name = N;
+ type = T;
+ classDef = cl;
+ _signature = 0;
+ code = 0;
+ access = A;
+ canBeInlined = false;
+ offset = 0;
+ JInfo = 0;
+ enveloppes = 0;
+}
+
+void JavaField::initialise(Class* cl, const UTF8* N, const UTF8* T, uint16 A) {
+ name = N;
+ type = T;
+ classDef = cl;
+ _signature = 0;
+ ptrOffset = 0;
+ access = A;
+ JInfo = 0;
}
void Class::readParents(Reader& reader) {
@@ -822,10 +788,12 @@
JavaField* field = 0;
if (isStatic(access)) {
--staticFields;
- field = constructField(staticFields[0], name, type, access);
+ field = &(staticFields[0]);
+ field->initialise(this, name, type, access);
++nbStaticFields;
} else {
- field = constructField(virtualFields[nbVirtualFields], name, type, access);
+ field = &(virtualFields[nbVirtualFields]);
+ field->initialise(this, name, type, access);
++nbVirtualFields;
}
field->attributs = readAttributs(reader, field->nbAttributs);
@@ -843,10 +811,12 @@
JavaMethod* meth = 0;
if (isStatic(access)) {
--staticMethods;
- meth = constructMethod(staticMethods[0], name, type, access);
+ meth = &(staticMethods[0]);
+ meth->initialise(this, name, type, access);
++nbStaticMethods;
} else {
- meth = constructMethod(virtualMethods[nbVirtualMethods], name, type, access);
+ meth = &(virtualMethods[nbVirtualMethods]);
+ meth->initialise(this, name, type, access);
++nbVirtualMethods;
}
meth->attributs = readAttributs(reader, meth->nbAttributs);
@@ -869,7 +839,7 @@
uint32 ctpSize = reader.readU2();
ctpInfo = new(classLoader->allocator, ctpSize) JavaConstantPool(this, reader,
ctpSize);
- access = reader.readU2();
+ access |= (reader.readU2() & 0x0FFF);
if (!isPublic(access)) access |= ACC_PRIVATE;
@@ -886,38 +856,28 @@
readFields(reader);
readMethods(reader);
attributs = readAttributs(reader, nbAttributs);
+ setIsRead();
}
#ifndef ISOLATE_SHARING
-void CommonClass::resolveClass() {
- if (status < resolved) {
+void Class::resolveClass() {
+ if (!isResolved()) {
acquire();
- if (status >= resolved) {
+ if (isResolved()) {
release();
- } else if (status == loaded) {
- if (isArray()) {
- ClassArray* arrayCl = (ClassArray*)this;
- CommonClass* baseClass = arrayCl->baseClass();
- baseClass->resolveClass();
- status = resolved;
- // Primitives are resolved at boot time
- } else {
- Class* cl = (Class*)this;
- cl->readClass();
- cl->status = classRead;
- cl->release();
- cl->loadParents();
- cl->acquire();
- cl->status = prepared;
- JnjvmModule *Mod = classLoader->getModule();
- Mod->resolveVirtualClass(cl);
- Mod->resolveStaticClass(cl);
- cl->status = resolved;
- }
+ } else if (!isResolving()) {
+ readClass();
+ release();
+ loadParents();
+ acquire();
+ JnjvmModule *Mod = classLoader->getModule();
+ Mod->resolveVirtualClass(this);
+ Mod->resolveStaticClass(this);
+ setResolved();
broadcastClass();
release();
} else {
- while (status < resolved) {
+ while (!isResolved()) {
waitClass();
}
release();
@@ -925,7 +885,7 @@
}
}
#else
-void CommonClass::resolveClass() {
+void Class::resolveClass() {
assert(status >= resolved &&
"Asking to resolve a not resolved-class in a isolate environment");
}
@@ -963,7 +923,7 @@
}
}
-void CommonClass::getDeclaredConstructors(std::vector<JavaMethod*>& res,
+void Class::getDeclaredConstructors(std::vector<JavaMethod*>& res,
bool publicOnly) {
for (uint32 i = 0; i < nbVirtualMethods; ++i) {
JavaMethod* meth = &virtualMethods[i];
@@ -975,7 +935,7 @@
}
}
-void CommonClass::getDeclaredMethods(std::vector<JavaMethod*>& res,
+void Class::getDeclaredMethods(std::vector<JavaMethod*>& res,
bool publicOnly) {
for (uint32 i = 0; i < nbVirtualMethods; ++i) {
JavaMethod* meth = &virtualMethods[i];
@@ -996,7 +956,7 @@
}
}
-void CommonClass::getDeclaredFields(std::vector<JavaField*>& res,
+void Class::getDeclaredFields(std::vector<JavaField*>& res,
bool publicOnly) {
for (uint32 i = 0; i < nbVirtualFields; ++i) {
JavaField* field = &virtualFields[i];
@@ -1018,7 +978,32 @@
}
#ifdef ISOLATE
-TaskClassMirror& CommonClass::getCurrentTaskClassMirror() {
+TaskClassMirror& Class::getCurrentTaskClassMirror() {
return IsolateInfo[JavaThread::get()->getJVM()->IsolateID];
}
+
+JavaObject* CommonClass::getDelegatee() {
+ return delegatee[JavaThread::get()->getJVM()->IsolateID];
+}
+
+JavaObject* CommonClass::setDelegatee(JavaObject* val) {
+ JavaObject** obj = &(delegatee[JavaThread::get()->getJVM()->IsolateID]);
+
+ JavaObject* prev = (JavaObject*)
+ __sync_val_compare_and_swap((uintptr_t)obj, NULL, val);
+
+ if (!prev) return val;
+ else return prev;
+}
+
+#else
+
+JavaObject* CommonClass::setDelegatee(JavaObject* val) {
+ JavaObject* prev = (JavaObject*)
+ __sync_val_compare_and_swap((uintptr_t)&(delegatee[0]), NULL, val);
+
+ if (!prev) return val;
+ else return prev;
+}
+
#endif
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Fri Nov 28 15:20:44 2008
@@ -29,14 +29,12 @@
namespace jnjvm {
class ArrayUInt8;
-class AssessorDesc;
class Enveloppe;
class Class;
class ClassArray;
class JavaArray;
class JavaConstantPool;
class JavaField;
-class JavaJIT;
class JavaMethod;
class JavaObject;
class Signdef;
@@ -51,11 +49,10 @@
typedef enum JavaState {
loaded = 0, /// The .class file has been found.
classRead = 1, /// The .class file has been read.
- prepared = 2, /// The parents of this class has been resolved.
- resolved = 3, /// The class has been resolved.
- inClinit = 4, /// The class is cliniting.
- ready = 5, /// The class is ready to be used.
- erroneous = 6, /// The class is in an erroneous state.
+ resolved = 2, /// The class has been resolved.
+ inClinit = 3, /// The class is cliniting.
+ ready = 4, /// The class is ready to be used.
+ erroneous = 5, /// The class is in an erroneous state.
dontuseenums = 0xffffffff /// dummy value to force the enum to be int32
}JavaState;
@@ -73,11 +70,11 @@
/// start - The offset in the class of this attribut.
///
- unsigned int start;
+ uint32 start;
/// nbb - The size of the attribut.
///
- unsigned int nbb;
+ uint32 nbb;
/// Attribut - Create an attribut at the given length and offset.
///
@@ -119,14 +116,20 @@
};
-#ifdef ISOLATE
+/// TaskClassMirror - The isolate specific class information: the initialization
+/// state and the static instance. In a non-isolate environment, there is only
+/// one instance of a TaskClassMirror per Class.
class TaskClassMirror {
public:
+
+ /// status - The initialization state.
+ ///
JavaState status;
- JavaObject* delegatee;
+
+ /// staticInstance - Memory that holds the static variables of the class.
+ ///
void* staticInstance;
};
-#endif
/// CommonClass - This class is the root class of all Java classes. It is
/// GC-allocated because CommonClasses have to be traceable. A java/lang/Class
@@ -138,66 +141,16 @@
friend class UserCommonClass;
#endif
-private:
- class FatLock : public mvm::PermanentObject {
- public:
- /// lockVar - When multiple threads want to load/resolve/initialize a class,
- /// they must be synchronized so that these steps are only performed once
- /// for a given class.
- mvm::LockRecursive lockVar;
-
- /// condVar - Used to wake threads waiting on the load/resolve/initialize
- /// process of this class, done by another thread.
- mvm::Cond condVar;
-
-
- static FatLock* allocate(UserCommonClass* cl) {
- return new(cl->classLoader->allocator) FatLock();
- }
-
- void acquire() {
- lockVar.lock();
- }
-
- void acquireAll(uint32 nb) {
- lockVar.lockAll(nb);
- }
-
- void release() {
- lockVar.unlock();
- }
-
- void broadcast() {
- condVar.broadcast();
- }
-
- void wait() {
- condVar.wait(&lockVar);
- }
- };
-
public:
//===----------------------------------------------------------------------===//
//
-// Do not reorder these fields or add new ones! the LLVM runtime assumes that
-// classes have the following beginning layout.
+// If you want to add new fields or modify the types of fields, you must also
+// change their LLVM representation in LLVMRuntime/runtime-*.ll, and their
+// offsets in JnjvmModule.cpp.
//
//===----------------------------------------------------------------------===//
-
-
- /// virtualSize - The size of instances of this class. Array classes do
- /// not need this information, but to simplify accessing this field in
- /// the JIT, we put this in here.
- ///
- uint32 virtualSize;
-
- /// virtualVT - The virtual table of instances of this class. Like the
- /// virtualSize field, array classes do not need this information. But we
- /// simplify JIT generation to set it here.
- ///
- VirtualTable* virtualVT;
-
+
/// display - The class hierarchy of supers for this class.
///
CommonClass** display;
@@ -207,32 +160,14 @@
///
uint32 depth;
- /// status - The loading/resolve/initialization state of the class.
+ /// delegatees - The java/lang/Class delegatee.
///
- JavaState status;
-
-#ifdef ISOLATE
- TaskClassMirror IsolateInfo[NR_ISOLATES];
-#endif
+ JavaObject* delegatee[NR_ISOLATES];
-//===----------------------------------------------------------------------===//
-//
-// New fields can be added from now, or reordered.
-//
-//===----------------------------------------------------------------------===//
-
/// access - {public, private, protected}.
///
- uint32 access;
-
- /// isArray - Is the class an array class?
- ///
- bool array;
+ uint16 access;
- /// isPrimitive - Is the class a primitive class?
- ///
- bool primitive;
-
/// interfaces - The interfaces this class implements.
///
Class** interfaces;
@@ -249,58 +184,29 @@
/// classLoader - The Jnjvm class loader that loaded the class.
///
JnjvmClassLoader* classLoader;
-
- /// virtualFields - List of all the virtual fields defined in this class.
- /// This does not contain non-redefined super fields.
- JavaField* virtualFields;
- uint16 nbVirtualFields;
- /// staticFields - List of all the static fields defined in this class.
- ///
- JavaField* staticFields;
- uint16 nbStaticFields;
-
- /// virtualMethods - List of all the virtual methods defined by this class.
- /// This does not contain non-redefined super methods.
- JavaMethod* virtualMethods;
- uint16 nbVirtualMethods;
-
- /// staticMethods - List of all the static methods defined by this class.
- ///
- JavaMethod* staticMethods;
- uint16 nbStaticMethods;
-
- /// ownerClass - Who is initializing this class.
- ///
- mvm::Thread* ownerClass;
+//===----------------------------------------------------------------------===//
+//
+// End field declaration.
+//
+//===----------------------------------------------------------------------===//
- /// lock - The lock of this class. It should be very rare that this lock
- /// inflates.
- ///
- mvm::ThinLock<FatLock, CommonClass> lock;
-
// Assessor methods.
- uint32 getVirtualSize() { return virtualSize; }
- VirtualTable* getVirtualVT() { return virtualVT; }
- uint32 getAccess() { return access;}
- Class** getInterfaces() { return interfaces; }
- const UTF8* getName() { return name; }
- Class* getSuper() { return super; }
- JavaField* getStaticFields() { return staticFields; }
- JavaField* getVirtualFields() { return virtualFields; }
- JavaMethod* getStaticMethods() { return staticMethods; }
- JavaMethod* getVirtualMethods() { return virtualMethods; }
-
+ uint32 getAccess() { return access;}
+ Class** getInterfaces() { return interfaces; }
+ const UTF8* getName() { return name; }
+ Class* getSuper() { return super; }
+
/// isArray - Is the class an array class?
///
bool isArray() {
- return array;
+ return jnjvm::isArray(access);
}
/// isPrimitive - Is the class a primitive class?
///
bool isPrimitive() {
- return primitive;
+ return jnjvm::isPrimitive(access);
}
/// isInterface - Is the class an interface?
@@ -309,117 +215,46 @@
return jnjvm::isInterface(access);
}
+ /// isClass - Is the class a real, instantiable class?
+ ///
+ bool isClass() {
+ return jnjvm::isClass(access);
+ }
+
/// asClass - Returns the class as a user-defined class
/// if it is not a primitive or an array.
+ ///
UserClass* asClass() {
- if (!primitive && !array) return (UserClass*)this;
+ if (isClass()) return (UserClass*)this;
return 0;
}
/// asPrimitiveClass - Returns the class if it's a primitive class.
///
UserClassPrimitive* asPrimitiveClass() {
- if (primitive) return (UserClassPrimitive*)this;
+ if (isPrimitive()) return (UserClassPrimitive*)this;
return 0;
}
/// asArrayClass - Returns the class if it's an array class.
///
UserClassArray* asArrayClass() {
- if (array) return (UserClassArray*)this;
+ if (isArray()) return (UserClassArray*)this;
return 0;
}
- /// constructMethod - Create a new method.
- ///
- JavaMethod* constructMethod(JavaMethod& method, const UTF8* name,
- const UTF8* type, uint32 access);
-
- /// constructField - Create a new field.
- ///
- JavaField* constructField(JavaField& field, const UTF8* name,
- const UTF8* type, uint32 access);
-
/// printClassName - Adds a string representation of this class in the
/// given buffer.
///
static void printClassName(const UTF8* name, mvm::PrintBuffer* buf);
-
- /// acquire - Acquire this class lock.
- ///
- void acquire() {
- lock.acquire(this);
- }
-
- /// release - Release this class lock.
- ///
- void release() {
- lock.release();
- }
-
- /// waitClass - Wait for the class to be loaded/initialized/resolved.
- ///
- void waitClass() {
- FatLock* FL = lock.changeToFatlock(this);
- FL->wait();
- }
-
- /// broadcastClass - Unblock threads that were waiting on the class being
- /// loaded/initialized/resolved.
- ///
- void broadcastClass() {
- lock.broadcast();
- }
-
- /// getOwnerClass - Get the thread that is currently initializing the class.
- ///
- mvm::Thread* getOwnerClass() {
- return ownerClass;
- }
-
- /// setOwnerClass - Set the thread that is currently initializing the class.
- ///
- void setOwnerClass(mvm::Thread* th) {
- ownerClass = th;
- }
-
- /// lookupMethodDontThrow - Lookup a method in the method map of this class.
- /// Do not throw if the method is not found.
- ///
- JavaMethod* lookupMethodDontThrow(const UTF8* name, const UTF8* type,
- bool isStatic, bool recurse, Class** cl);
-
- /// lookupInterfaceMethodDontThrow - Lookup a method in the interfaces of
- /// this class.
- /// Do not throw if the method is not found.
- ///
- JavaMethod* lookupInterfaceMethodDontThrow(const UTF8* name,
- const UTF8* type);
-
- /// lookupMethod - Lookup a method and throw an exception if not found.
- ///
- JavaMethod* lookupMethod(const UTF8* name, const UTF8* type, bool isStatic,
- bool recurse, Class** cl);
-
- /// lookupFieldDontThrow - Lookup a field in the field map of this class. Do
- /// not throw if the field is not found.
- ///
- JavaField* lookupFieldDontThrow(const UTF8* name, const UTF8* type,
- bool isStatic, bool recurse,
- CommonClass** definingClass);
-
- /// lookupField - Lookup a field and throw an exception if not found.
- ///
- JavaField* lookupField(const UTF8* name, const UTF8* type, bool isStatic,
- bool recurse, CommonClass** definingClass);
-
+
/// print - Print the class for debugging purposes.
///
- virtual void print(mvm::PrintBuffer *buf) const;
+ void print(mvm::PrintBuffer *buf) const;
/// tracer - The tracer of this GC-allocated class.
///
- virtual void TRACER;
+ void TRACER;
/// printString - Prints the class.
///
@@ -464,22 +299,6 @@
/// class.
///
JavaObject* getClassDelegatee(Jnjvm* vm, JavaObject* pd = 0);
-
- /// resolveClass - If the class has not been resolved yet, resolve it.
- ///
- void resolveClass();
-
- /// initialiseClass - If the class has not been initialized yet,
- /// initialize it.
- ///
- void initialiseClass(Jnjvm* vm);
-
-
- /// isResolved - Has this class been resolved?
- ///
- bool isResolved() {
- return status >= resolved;
- }
/// CommonClass - Create a class with th given name.
///
@@ -488,25 +307,11 @@
/// ~CommonClass - Free memory used by this class, and remove it from
/// metadata.
///
- virtual ~CommonClass();
+ ~CommonClass();
/// CommonClass - Default constructor.
///
CommonClass();
-
- /// getDeclaredConstructors - Returns the methods defined in this class which
- /// are constructors.
- ///
- void getDeclaredConstructors(std::vector<JavaMethod*>& res, bool publicOnly);
-
- /// getDeclaredMethod - Returns the methods defined in this class which are
- /// not constructors.
- //
- void getDeclaredMethods(std::vector<JavaMethod*>& res, bool publicOnly);
-
- /// getDeclaredFields - Returns the fields defined in this class.
- ///
- void getDeclaredFields(std::vector<JavaField*>& res, bool publicOnly);
/// setInterfaces - Set the interfaces of the class.
///
@@ -530,74 +335,21 @@
CommonClass* getInternal() {
return this;
}
+
+ /// setDelegatee - Set the java/lang/Class object of this class.
+ ///
+ JavaObject* setDelegatee(JavaObject* val);
#if !defined(ISOLATE) && !defined(ISOLATE_SHARING)
- /// delegatee - The java/lang/Class object representing this class
+ /// getDelegatee - Get the java/lang/Class object representing this class.
///
- JavaObject* _delegatee;
-
JavaObject* getDelegatee() {
- return _delegatee;
- }
-
- void setDelegatee(JavaObject* val) {
- _delegatee = val;
- }
-
- JavaState getInitializationState() {
- return status;
- }
-
- void setInitializationState(JavaState st) {
- status = st;
- }
-
- /// isReady - Has this class been initialized?
- ///
- bool isReady() {
- return status == ready;
- }
-
- bool isReadyForCompilation() {
- return isReady();
- }
-
- bool isInitializing() {
- return status >= inClinit;
+ return delegatee[0];
}
#else
#if defined(ISOLATE)
-
- TaskClassMirror& getCurrentTaskClassMirror();
-
- JavaState getInitializationState() {
- return getCurrentTaskClassMirror().status;
- }
-
- void setInitializationState(JavaState st) {
- getCurrentTaskClassMirror().status = st;
- }
-
- JavaObject* getDelegatee() {
- return getCurrentTaskClassMirror().delegatee;
- }
-
- void setDelegatee(JavaObject* val) {
- getCurrentTaskClassMirror().delegatee = val;
- }
-
- bool isReady() {
- return getCurrentTaskClassMirror().status == ready;
- }
-
- bool isReadyForCompilation() {
- return false;
- }
-
- bool isInitializing() {
- return getCurrentTaskClassMirror().status >= inClinit;
- }
+ JavaObject* getDelegatee();
#endif
#endif
@@ -608,8 +360,20 @@
///
class ClassPrimitive : public CommonClass {
public:
+
+ /// primSize - The primitive size of this class, eg 4 for int.
+ ///
+ uint32 primSize;
+
+
+ /// ClassPrimitive - Constructs a primitive class. Only called at boot
+ /// time.
+ ///
ClassPrimitive(JnjvmClassLoader* loader, const UTF8* name, uint32 nb);
+ /// byteIdToPrimitive - Get the primitive class from its byte representation,
+ /// ie int for I.
+ ///
static UserClassPrimitive* byteIdToPrimitive(char id, Classpath* upcalls);
};
@@ -619,62 +383,223 @@
/// array or primitive). Theses classes have a constant pool.
///
class Class : public CommonClass {
+
+private:
+
+ /// FatLock - This class is the inflated lock of Class instances. It should
+ /// be very rare that such locks are allocated.
+ class FatLock : public mvm::PermanentObject {
+ public:
+ /// lockVar - When multiple threads want to load/resolve/initialize a class,
+ /// they must be synchronized so that these steps are only performed once
+ /// for a given class.
+ mvm::LockRecursive lockVar;
+
+ /// condVar - Used to wake threads waiting on the load/resolve/initialize
+ /// process of this class, done by another thread.
+ mvm::Cond condVar;
+
+
+ static FatLock* allocate(UserCommonClass* cl) {
+ return new(cl->classLoader->allocator) FatLock();
+ }
+
+ void acquire() {
+ lockVar.lock();
+ }
+
+ void acquireAll(uint32 nb) {
+ lockVar.lockAll(nb);
+ }
+
+ void release() {
+ lockVar.unlock();
+ }
+
+ void broadcast() {
+ condVar.broadcast();
+ }
+
+ void wait() {
+ condVar.wait(&lockVar);
+ }
+ };
+
public:
+ /// virtualSize - The size of instances of this class.
+ ///
+ uint32 virtualSize;
+
+ /// virtualVT - The virtual table of instances of this class.
+ ///
+ VirtualTable* virtualVT;
+
+ /// IsolateInfo - Per isolate informations for static instances and
+ /// initialization state.
+ ///
+ TaskClassMirror IsolateInfo[NR_ISOLATES];
+
+ /// lock - The lock of this class. It should be very rare that this lock
+ /// inflates.
+ ///
+ mvm::ThinLock<FatLock, CommonClass> lock;
+
+ /// virtualFields - List of all the virtual fields defined in this class.
+ /// This does not contain non-redefined super fields.
+ JavaField* virtualFields;
+ uint16 nbVirtualFields;
+
+ /// staticFields - List of all the static fields defined in this class.
+ ///
+ JavaField* staticFields;
+ uint16 nbStaticFields;
+
+ /// virtualMethods - List of all the virtual methods defined by this class.
+ /// This does not contain non-redefined super methods.
+ JavaMethod* virtualMethods;
+ uint16 nbVirtualMethods;
+
+ /// staticMethods - List of all the static methods defined by this class.
+ ///
+ JavaMethod* staticMethods;
+ uint16 nbStaticMethods;
+
+ /// ownerClass - Who is initializing this class.
+ ///
+ mvm::Thread* ownerClass;
+
/// bytes - The .class file of this class.
///
ArrayUInt8* bytes;
- /// ctpInfo - The constant pool info of this class.
+ /// ctpInfo - The constant pool info of this class.
+ ///
+ JavaConstantPool* ctpInfo;
+
+ /// attributs - JVM attributes of this class.
+ ///
+ Attribut* attributs;
+ uint16 nbAttributs;
+
+ /// innerClasses - The inner classes of this class.
+ ///
+ Class** innerClasses;
+ uint16 nbInnerClasses;
+
+ /// outerClass - The outer class, if this class is an inner class.
+ ///
+ Class* outerClass;
+
+ /// innerAccess - The access of this class, if this class is an inner class.
+ ///
+ uint16 innerAccess;
+
+ /// innerOuterResolved - Is the inner/outer resolution done?
+ ///
+ bool innerOuterResolved;
+
+ /// virtualTableSize - The size of the virtual table of this class.
+ ///
+ uint32 virtualTableSize;
+
+ /// staticSize - The size of the static instance of this class.
+ ///
+ uint32 staticSize;
+
+ /// JInfo - JIT specific information.
+ ///
+ mvm::JITInfo* JInfo;
+
+ /// staticTracer - The dynamically generated function that traces the
+ /// references of the static instance.
+ void (*staticTracer)(void*);
+
+ /// Assessor methods.
+ uint32 getVirtualSize() { return virtualSize; }
+ VirtualTable* getVirtualVT() { return virtualVT; }
+
+ /// getDeclaredConstructors - Returns the methods defined in this class which
+ /// are constructors.
///
- JavaConstantPool* ctpInfo;
+ void getDeclaredConstructors(std::vector<JavaMethod*>& res, bool publicOnly);
- /// attributs - JVM attributes of this class.
+ /// getDeclaredMethod - Returns the methods defined in this class which are
+ /// not constructors.
+ //
+ void getDeclaredMethods(std::vector<JavaMethod*>& res, bool publicOnly);
+
+ /// getDeclaredFields - Returns the fields defined in this class.
///
- Attribut* attributs;
- uint16 nbAttributs;
-
-#if !defined(ISOLATE_SHARING)
- /// innerClasses - The inner classes of this class.
+ void getDeclaredFields(std::vector<JavaField*>& res, bool publicOnly);
+
+ /// getOwnerClass - Get the thread that is currently initializing the class.
///
- Class** innerClasses;
- uint16 nbInnerClasses;
+ mvm::Thread* getOwnerClass() {
+ return ownerClass;
+ }
- /// outerClass - The outer class, if this class is an inner class.
+ /// setOwnerClass - Set the thread that is currently initializing the class.
+ ///
+ void setOwnerClass(mvm::Thread* th) {
+ ownerClass = th;
+ }
+
+ /// getOuterClass - Get the class that contains the definition of this class.
///
- Class* outerClass;
-
Class* getOuterClass() {
return outerClass;
}
+ /// getInnterClasses - Get the classes that this class defines.
+ ///
Class** getInnerClasses() {
return innerClasses;
}
-#endif
- /// innerAccess - The access of this class, if this class is an inner class.
+ /// lookupMethodDontThrow - Lookup a method in the method map of this class.
+ /// Do not throw if the method is not found.
///
- uint16 innerAccess;
-
- /// innerOuterResolved - Is the inner/outer resolution done?
+ JavaMethod* lookupMethodDontThrow(const UTF8* name, const UTF8* type,
+ bool isStatic, bool recurse, Class** cl);
+
+ /// lookupInterfaceMethodDontThrow - Lookup a method in the interfaces of
+ /// this class.
+ /// Do not throw if the method is not found.
///
- bool innerOuterResolved;
+ JavaMethod* lookupInterfaceMethodDontThrow(const UTF8* name,
+ const UTF8* type);
- /// setInnerAccess - Set the access flags of this inner class.
+ /// lookupMethod - Lookup a method and throw an exception if not found.
///
- void setInnerAccess(uint32 access) {
- innerAccess = access;
- }
+ JavaMethod* lookupMethod(const UTF8* name, const UTF8* type, bool isStatic,
+ bool recurse, Class** cl);
- /// virtualTableSize - The size of the virtual table of this class.
+ /// lookupFieldDontThrow - Lookup a field in the field map of this class. Do
+ /// not throw if the field is not found.
///
- uint32 virtualTableSize;
+ JavaField* lookupFieldDontThrow(const UTF8* name, const UTF8* type,
+ bool isStatic, bool recurse,
+ Class** definingClass);
- /// staticSize - The size of the static instance of this class.
+ /// lookupField - Lookup a field and throw an exception if not found.
///
- uint32 staticSize;
+ JavaField* lookupField(const UTF8* name, const UTF8* type, bool isStatic,
+ bool recurse, Class** definingClass);
+
+ /// Assessor methods.
+ JavaField* getStaticFields() { return staticFields; }
+ JavaField* getVirtualFields() { return virtualFields; }
+ JavaMethod* getStaticMethods() { return staticMethods; }
+ JavaMethod* getVirtualMethods() { return virtualMethods; }
+
+ /// setInnerAccess - Set the access flags of this inner class.
+ ///
+ void setInnerAccess(uint16 access) {
+ innerAccess = access;
+ }
+
/// getStaticSize - Get the size of the static instance.
///
uint32 getStaticSize() {
@@ -691,50 +616,17 @@
///
void resolveStaticClass();
- /// print - Prints a string representation of this class in the buffer.
- ///
- virtual void print(mvm::PrintBuffer *buf) const;
-
/// tracer - Tracer function of instances of Class.
///
- virtual void TRACER;
+ void TRACER;
- virtual ~Class();
+ ~Class();
Class();
/// lookupAttribut - Look up a JVM attribut of this class.
///
Attribut* lookupAttribut(const UTF8* key);
- void (*staticTracer)(void*);
-
- /// staticInstance - Get the static instance of this class. A static instance
- /// is inlined when the vm is in a single environment. In a multiple
- /// environment, the static instance is in a hashtable.
- ///
-#if !defined(ISOLATE_SHARING) && !defined(ISOLATE)
- void* _staticInstance;
-
- void* getStaticInstance() {
- return _staticInstance;
- }
-
- void setStaticInstance(void* val) {
- _staticInstance = val;
- }
-#else
-#if defined(ISOLATE)
- void* getStaticInstance() {
- return getCurrentTaskClassMirror().staticInstance;
- }
-
- void setStaticInstance(void* val) {
- getCurrentTaskClassMirror().staticInstance = val;
- }
-
-#endif
-#endif
-
/// allocateStaticInstance - Allocate the static instance of this class.
///
void* allocateStaticInstance(Jnjvm* vm);
@@ -767,19 +659,25 @@
/// readClass - Reads the class.
///
void readClass();
-
-
+
+ /// getConstantPool - Get the constant pool of the class.
+ ///
JavaConstantPool* getConstantPool() {
return ctpInfo;
}
+ /// getBytes - Get the bytes of the class file.
+ ///
ArrayUInt8* getBytes() {
return bytes;
}
+ /// resolveInnerOuterClasses - Resolve the inner/outer information.
+ ///
void resolveInnerOuterClasses();
- mvm::JITInfo* JInfo;
+ /// getInfo - Get the JIT specific information, allocating one if it
+ /// does not exist.
template<typename Ty>
Ty *getInfo() {
if (!JInfo) {
@@ -790,6 +688,183 @@
"Invalid concrete type or multiple inheritence for getInfo");
return static_cast<Ty*>(JInfo);
}
+
+ /// resolveClass - If the class has not been resolved yet, resolve it.
+ ///
+ void resolveClass();
+
+ /// initialiseClass - If the class has not been initialized yet,
+ /// initialize it.
+ ///
+ void initialiseClass(Jnjvm* vm);
+
+ /// acquire - Acquire this class lock.
+ ///
+ void acquire() {
+ lock.acquire(this);
+ }
+
+ /// release - Release this class lock.
+ ///
+ void release() {
+ lock.release();
+ }
+
+ /// waitClass - Wait for the class to be loaded/initialized/resolved.
+ ///
+ void waitClass() {
+ FatLock* FL = lock.changeToFatlock(this);
+ FL->wait();
+ }
+
+ /// broadcastClass - Unblock threads that were waiting on the class being
+ /// loaded/initialized/resolved.
+ ///
+ void broadcastClass() {
+ lock.broadcast();
+ }
+
+#ifndef ISOLATE
+
+ /// getStaticInstance - Get the memory that holds static variables.
+ ///
+ void* getStaticInstance() {
+ return IsolateInfo[0].staticInstance;
+ }
+
+ /// setStaticInstance - Set the memory that holds static variables.
+ ///
+ void setStaticInstance(void* val) {
+ IsolateInfo[0].staticInstance = val;
+ }
+
+ /// getInitializationState - Get the state of the class.
+ ///
+ JavaState getInitializationState() {
+ return IsolateInfo[0].status;
+ }
+
+ /// setInitializationState - Set the state of the class.
+ ///
+ void setInitializationState(JavaState st) {
+ IsolateInfo[0].status = st;
+ }
+
+ /// isReady - Has this class been initialized?
+ ///
+ bool isReady() {
+ return IsolateInfo[0].status == ready;
+ }
+
+ /// isReadyForCompilation - Can this class be inlined when JITing?
+ ///
+ bool isReadyForCompilation() {
+ return isReady();
+ }
+
+ /// isInitializing - Is the class currently being initialized?
+ ///
+ bool isInitializing() {
+ return IsolateInfo[0].status >= inClinit;
+ }
+
+ /// isResolved - Has this class been resolved?
+ ///
+ bool isResolved() {
+ return IsolateInfo[0].status >= resolved;
+ }
+
+ /// isErroneous - Is the class in an erroneous state.
+ ///
+ bool isErroneous() {
+ return IsolateInfo[0].status == erroneous;
+ }
+
+ /// setResolved - Set the status of the class as resolved.
+ ///
+ void setResolved() {
+ IsolateInfo[0].status = resolved;
+ }
+
+ /// setErroneous - Set the class as erroneous.
+ ///
+ void setErroneous() {
+ IsolateInfo[0].status = erroneous;
+ }
+
+ /// setIsRead - The class file has been read.
+ ///
+ void setIsRead() {
+ IsolateInfo[0].status = classRead;
+ }
+
+ /// isResolving - IS the class currently being resolved?
+ ///
+ bool isResolving() {
+ return IsolateInfo[0].status == classRead;
+ }
+
+#else
+ TaskClassMirror& getCurrentTaskClassMirror();
+
+ void* getStaticInstance() {
+ return getCurrentTaskClassMirror().staticInstance;
+ }
+
+ void setStaticInstance(void* val) {
+ getCurrentTaskClassMirror().staticInstance = val;
+ }
+
+ JavaState getInitializationState() {
+ return getCurrentTaskClassMirror().status;
+ }
+
+ void setInitializationState(JavaState st) {
+ getCurrentTaskClassMirror().status = st;
+ }
+
+ bool isReady() {
+ return getCurrentTaskClassMirror().status == ready;
+ }
+
+ bool isReadyForCompilation() {
+ return false;
+ }
+
+ bool isInitializing() {
+ return getCurrentTaskClassMirror().status >= inClinit;
+ }
+
+ bool isResolved() {
+ return getCurrentTaskClassMirror().status >= resolved;
+ }
+
+ void setResolved() {
+ for (uint32 i = 0; i < NR_ISOLATES; ++i) {
+ IsolateInfo[i].status = resolved;
+ }
+ }
+
+ void setIsRead() {
+ for (uint32 i = 0; i < NR_ISOLATES; ++i) {
+ IsolateInfo[i].status = classRead;
+ }
+ }
+
+ void setErroneous() {
+ for (uint32 i = 0; i < NR_ISOLATES; ++i) {
+ IsolateInfo[i].status = erroneous;
+ }
+ }
+
+ bool isResolving() {
+ return getCurrentTaskClassMirror().status == classRead;
+ }
+
+ bool isErroneous() {
+ return getCurrentTaskClassMirror().status == erroneous;
+ }
+#endif
};
@@ -810,23 +885,20 @@
public:
- /// _baseClass - The base class of the array, or null if not resolved.
+ /// _baseClass - The base class of the array.
///
CommonClass* _baseClass;
- /// baseClass - Get the base class of this array class. Resolve the array
- /// class if needed.
+ /// baseClass - Get the base class of this array class.
///
CommonClass* baseClass() {
return _baseClass;
}
-
/// doNew - Allocate a new array in the given vm.
///
JavaArray* doNew(sint32 n, Jnjvm* vm);
-
/// ClassArray - Empty constructor for VT.
///
ClassArray() {}
@@ -836,33 +908,18 @@
ClassArray(JnjvmClassLoader* loader, const UTF8* name,
UserCommonClass* baseClass);
-
- /// arrayLoader - Return the class loader of the class with the name 'name'.
- /// If the class has not been loaded, load it with the given loader and
- /// return the real class loader that loaded this class.
- ///
- static JnjvmClassLoader* arrayLoader(const UTF8* name,
- JnjvmClassLoader* loader,
- unsigned int start,
- unsigned int end);
-
- /// print - Print a string representation of this array class. Used for
- /// debugging purposes.
+ /// SuperArray - The super of class arrays. Namely java/lang/Object.
///
- virtual void print(mvm::PrintBuffer *buf) const;
+ static Class* SuperArray;
- /// tracer - Tracer of array classes.
+ /// InterfacesArray - The list of interfaces for array classes.
///
- virtual void TRACER;
-
- static Class* SuperArray;
static Class** InterfacesArray;
};
/// JavaMethod - This class represents Java methods.
///
class JavaMethod : public mvm::PermanentObject {
- friend class CommonClass;
private:
/// _signature - The signature of this method. Null if not resolved.
@@ -871,6 +928,10 @@
public:
+ /// constructMethod - Create a new method.
+ ///
+ void initialise(Class* cl, const UTF8* name, const UTF8* type, uint16 access);
+
/// compiledPtr - Return a pointer to the compiled code of this Java method,
/// compiling it if necessary.
///
@@ -1029,7 +1090,6 @@
/// JavaField - This class represents a Java field.
///
class JavaField : public mvm::PermanentObject {
- friend class CommonClass;
private:
/// _signature - The signature of the field. Null if not resolved.
///
@@ -1043,6 +1103,10 @@
void InitField(void* obj, float val);
public:
+
+ /// constructField - Create a new field.
+ ///
+ void initialise(Class* cl, const UTF8* name, const UTF8* type, uint16 access);
/// ~JavaField - Destroy the field as well as its attributs.
///
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Fri Nov 28 15:20:44 2008
@@ -287,7 +287,6 @@
const UTF8* name = UTF8At(ctpDef[index]);
if (name->elements[0] == I_TAB) {
temp = loader->constructArray(name);
- temp->resolveClass();
} else {
// Put into ctpRes because there is only one representation of the class
temp = loader->loadName(name, true, false);
@@ -362,16 +361,20 @@
sint32 ntIndex = entry & 0xFFFF;
const UTF8* utf8 = UTF8At(ctpDef[ntIndex] >> 16);
cl = getMethodClassIfLoaded(entry >> 16);
- if (cl && cl->status >= classRead) {
- // lookup the method
- meth = cl->lookupMethodDontThrow(utf8, sign->keyName, isStatic(access),
- true, 0);
- // OK, this is rare, but the Java bytecode may do an invokevirtual on an
- // interface method. Lookup the method as if it was static.
- // The caller is responsible for taking any action if the method is
- // an interface method.
- if (!meth) {
- meth = cl->lookupInterfaceMethodDontThrow(utf8, sign->keyName);
+ if (cl) {
+ Class* lookup = cl->isArray() ? cl->super : cl->asClass();
+ if (lookup->isResolved()) {
+
+ // lookup the method
+ meth = lookup->lookupMethodDontThrow(utf8, sign->keyName, isStatic(access),
+ true, 0);
+ // OK, this is rare, but the Java bytecode may do an invokevirtual on an
+ // interface method. Lookup the method as if it was static.
+ // The caller is responsible for taking any action if the method is
+ // an interface method.
+ if (!meth) {
+ meth = lookup->lookupInterfaceMethodDontThrow(utf8, sign->keyName);
+ }
}
}
}
@@ -412,15 +415,18 @@
sint32 ntIndex = entry & 0xFFFF;
const UTF8* utf8 = UTF8At(ctpDef[ntIndex] >> 16);
CommonClass* cl = getMethodClassIfLoaded(entry >> 16);
- if (cl && cl->status >= classRead) {
- // lookup the method
- meth = cl->lookupMethodDontThrow(utf8, sign->keyName, isStatic(access),
- true, 0);
- if (meth) {
- // don't throw if no meth, the exception will be thrown just in time
- JnjvmModule* M = classDef->classLoader->getModule();
- void* F = M->getMethod(meth);
- return F;
+ if (cl) {
+ Class* lookup = cl->isArray() ? cl->super : cl->asClass();
+ if (lookup->isResolved()) {
+ // lookup the method
+ meth = lookup->lookupMethodDontThrow(utf8, sign->keyName,
+ isStatic(access), true, 0);
+ if (meth) {
+ // don't throw if no meth, the exception will be thrown just in time
+ JnjvmModule* M = classDef->classLoader->getModule();
+ void* F = M->getMethod(meth);
+ return F;
+ }
}
}
@@ -462,7 +468,8 @@
utf8 = UTF8At(ctpDef[ntIndex] >> 16);
cl = loadClass(entry >> 16);
assert(cl && "No class after loadClass");
- assert(cl->isResolved() && "Class not resolved after loadClass");
+ assert((cl->isClass() && cl->asClass()->isResolved()) &&
+ "Class not resolved after loadClass");
}
void JavaConstantPool::resolveField(uint32 index, CommonClass*& cl,
@@ -474,7 +481,8 @@
utf8 = UTF8At(ctpDef[ntIndex] >> 16);
cl = loadClass(entry >> 16);
assert(cl && "No class after loadClass");
- assert(cl->isResolved() && "Class not resolved after loadClass");
+ assert((cl->isClass() && cl->asClass()->isResolved()) &&
+ "Class not resolved after loadClass");
}
JavaField* JavaConstantPool::lookupField(uint32 index, bool stat) {
@@ -483,22 +491,25 @@
Typedef* sign = (Typedef*)ctpRes[ntIndex];
const UTF8* utf8 = UTF8At(ctpDef[ntIndex] >> 16);
CommonClass* cl = getMethodClassIfLoaded(entry >> 16);
- if (cl && cl->status >= resolved) {
- JavaField* field = cl->lookupFieldDontThrow(utf8, sign->keyName, stat,
- true, 0);
- // don't throw if no field, the exception will be thrown just in time
- if (field) {
- if (!stat) {
- ctpRes[index] = (void*)field->ptrOffset;
- }
+ if (cl) {
+ Class* lookup = cl->isArray() ? cl->super : cl->asClass();
+ if (lookup->isResolved()) {
+ JavaField* field = lookup->lookupFieldDontThrow(utf8, sign->keyName, stat,
+ true, 0);
+ // don't throw if no field, the exception will be thrown just in time
+ if (field) {
+ if (!stat) {
+ ctpRes[index] = (void*)field->ptrOffset;
+ }
#ifndef ISOLATE_SHARING
- else if (cl->isReady()) {
- void* S = field->classDef->getStaticInstance();
- ctpRes[index] = (void*)((uint64)S + field->ptrOffset);
- }
+ else if (lookup->isReady()) {
+ void* S = field->classDef->getStaticInstance();
+ ctpRes[index] = (void*)((uint64)S + field->ptrOffset);
+ }
#endif
+ }
+ return field;
}
- return field;
}
return 0;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Fri Nov 28 15:20:44 2008
@@ -663,7 +663,7 @@
OldIsolateID = new LoadInst(IsolateIDPtr, "", currentBlock);
Value* MyID = ConstantInt::get(module->pointerSizeType,
- loader->isolate->IsolateID);
+ loader->getIsolate()->IsolateID);
Cmp = new ICmpInst(ICmpInst::ICMP_EQ, OldIsolateID, MyID, "", currentBlock);
BasicBlock* EndBB = createBasicBlock("After service check");
@@ -678,7 +678,7 @@
currentBlock);
OldIsolate = new LoadInst(IsolatePtr, "", currentBlock);
- NewIsolate = module->getIsolate(loader->isolate);
+ NewIsolate = module->getIsolate(loader->getIsolate());
NewIsolate = new LoadInst(NewIsolate, "", currentBlock);
new StoreInst(NewIsolate, IsolatePtr, currentBlock);
@@ -1057,14 +1057,14 @@
OldIsolateID = new LoadInst(IsolateIDPtr, "", cur->javaHandler);
Value* MyID = ConstantInt::get(module->pointerSizeType,
- loader->isolate->IsolateID);
+ loader->getIsolate()->IsolateID);
new StoreInst(MyID, IsolateIDPtr, cur->javaHandler);
IsolatePtr = GetElementPtrInst::Create(threadId, module->constantFour, "",
cur->javaHandler);
OldIsolate = new LoadInst(IsolatePtr, "", cur->javaHandler);
- NewIsolate = module->getIsolate(loader->isolate);
+ NewIsolate = module->getIsolate(loader->getIsolate());
NewIsolate = new LoadInst(NewIsolate, "", cur->javaHandler);
new StoreInst(NewIsolate, IsolatePtr, cur->javaHandler);
@@ -1134,7 +1134,7 @@
push(Val, false);
} else {
#endif
- Value* val = getResolvedClass(index, false);
+ Value* val = getResolvedCommonClass(index, false);
Value* res = CallInst::Create(module->GetClassDelegateeFunction,
val, "", currentBlock);
push(res, false);
@@ -1604,7 +1604,6 @@
Value* Cl = GetElementPtrInst::Create(CTP, module->ConstantOne, "",
currentBlock);
Cl = new LoadInst(Cl, "", currentBlock);
- Cl = new BitCastInst(Cl, module->JavaClassType, "", currentBlock);
#else
JavaConstantPool* ctp = compilingClass->ctpInfo;
Value* CTP = module->getConstantPool(ctp);
@@ -1640,6 +1639,26 @@
return res;
}
+Value* JavaJIT::getResolvedCommonClass(uint16 index, bool doThrow) {
+
+ JavaConstantPool* ctpInfo = compilingClass->ctpInfo;
+ CommonClass* cl = ctpInfo->getMethodClassIfLoaded(index);
+ Value* node = 0;
+ if (cl && (!cl->isClass() || cl->asClass()->isResolved())) {
+ node = module->getNativeClass(cl);
+ node = new LoadInst(node, "", currentBlock);
+ if (node->getType() != module->JavaCommonClassType) {
+ node = new BitCastInst(node, module->JavaCommonClassType, "",
+ currentBlock);
+ }
+ } else {
+ node = getConstantPoolAt(index, module->ClassLookupFunction,
+ module->JavaCommonClassType, 0, doThrow);
+ }
+
+ return node;
+}
+
Value* JavaJIT::getResolvedClass(uint16 index, bool clinit, bool doThrow) {
JavaConstantPool* ctpInfo = compilingClass->ctpInfo;
@@ -1650,14 +1669,18 @@
node = new LoadInst(node, "", currentBlock);
} else {
node = getConstantPoolAt(index, module->ClassLookupFunction,
- module->JavaClassType, 0, doThrow);
+ module->JavaCommonClassType, 0, doThrow);
}
- if (!(!clinit || (cl && !needsInitialisationCheck(cl, compilingClass))))
+ if (!(!clinit || (cl && !needsInitialisationCheck(cl, compilingClass)))) {
+ if (node->getType() != module->JavaClassType) {
+ node = new BitCastInst(node, module->JavaClassType, "", currentBlock);
+ }
return invoke(module->InitialisationCheckFunction, node, "",
currentBlock);
- else
+ } else {
return node;
+ }
}
void JavaJIT::invokeNew(uint16 index) {
@@ -1677,6 +1700,7 @@
module->JavaObjectClassOffsetConstant };
Value* GEP = GetElementPtrInst::Create(val, gep, gep + 2, "",
currentBlock);
+ Cl = new BitCastInst(Cl, module->JavaCommonClassType, "", currentBlock);
new StoreInst(Cl, GEP, currentBlock);
Value* gep2[2] = { module->constantZero, module->JavaObjectLockOffsetConstant };
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Fri Nov 28 15:20:44 2008
@@ -217,6 +217,7 @@
const llvm::Type* fieldType,
const llvm::Type* fieldTypePtr);
llvm::Value* getResolvedClass(uint16 index, bool clinit, bool doThrow = true);
+ llvm::Value* getResolvedCommonClass(uint16 index, bool doThrow = true);
// methods invoke
void makeArgs(llvm::FunctionType::param_iterator it,
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Fri Nov 28 15:20:44 2008
@@ -1854,17 +1854,18 @@
LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[charId];
sizeElement = LAI.sizeInBytesConstant;
+ TheVT = module->getPrimitiveArrayVT(this);
} else {
uint16 index = readU2(bytecodes, i);
- valCl = getResolvedClass(index, false);
- const llvm::Type* Ty = PointerType::getUnqual(module->JavaClassType);
+ valCl = getResolvedCommonClass(index);
+ const llvm::Type* Ty =
+ PointerType::getUnqual(module->JavaCommonClassType);
Value* args[2]= { valCl, Constant::getNullValue(Ty) };
valCl = CallInst::Create(module->GetArrayClassFunction, args,
args + 2, "", currentBlock);
sizeElement = module->constantPtrSize;
+ TheVT = module->getReferenceArrayVT(this);
}
- TheVT = CallInst::Create(module->GetVTFromClassFunction, valCl, "",
- currentBlock);
llvm::Value* arg1 = popAsInt();
Value* cmp = new ICmpInst(ICmpInst::ICMP_SLT, arg1,
@@ -1994,7 +1995,7 @@
BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock);
currentBlock = ifFalse;
- Value* clVar = getResolvedClass(index, false);
+ Value* clVar = getResolvedCommonClass(index);
Value* args[2] = { obj, clVar };
Value* call = CallInst::Create(module->InstanceOfFunction, args,
@@ -2019,7 +2020,7 @@
case INSTANCEOF : {
uint16 index = readU2(bytecodes, i);
- Value* clVar = getResolvedClass(index, false);
+ Value* clVar = getResolvedCommonClass(index);
Value* args[2] = { pop(), clVar };
Value* val = CallInst::Create(module->InstanceOfFunction,
@@ -2048,7 +2049,7 @@
uint8 dim = readU1(bytecodes, i);
- Value* valCl = getResolvedClass(index, true);
+ Value* valCl = getResolvedCommonClass(index);
Value** args = (Value**)alloca(sizeof(Value*) * (dim + 2));
args[0] = valCl;
args[1] = ConstantInt::get(Type::Int32Ty, dim);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Fri Nov 28 15:20:44 2008
@@ -31,11 +31,12 @@
UserCommonClass* cl = loader->loadName(loader->asciizConstructUTF8(className),
true, true);
- cl->initialiseClass(vm);
bool stat = access == ACC_STATIC ? true : false;
- JavaMethod* method = cl->lookupMethod(loader->asciizConstructUTF8(func),
- loader->asciizConstructUTF8(sign), stat,
- true, 0);
+ UserClass* lookup = cl->isArray() ? cl->super : cl->asClass();
+ lookup->initialiseClass(vm);
+ JavaMethod* method = lookup->lookupMethod(loader->asciizConstructUTF8(func),
+ loader->asciizConstructUTF8(sign),
+ stat, true, 0);
va_list ap;
va_start(ap, access);
if (stat) {
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h Fri Nov 28 15:20:44 2008
@@ -22,6 +22,7 @@
namespace jnjvm {
+class JavaClass;
class JavaField;
class JavaObject;
class JavaThread;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Fri Nov 28 15:20:44 2008
@@ -37,7 +37,8 @@
ctpInfo->resolveMethod(index, cl, utf8, sign);
#ifndef SERVICE
- assert(obj->classOf->isInitializing() &&
+ assert((obj->classOf->isClass() &&
+ obj->classOf->asClass()->isInitializing()) &&
"Class not ready in a virtual lookup.");
#endif
@@ -58,8 +59,9 @@
if (!rcache) {
UserClass* methodCl = 0;
- JavaMethod* dmeth = ocl->lookupMethod(utf8, sign->keyName, false, true,
- &methodCl);
+ UserClass* lookup = ocl->isArray() ? ocl->super : ocl->asClass();
+ JavaMethod* dmeth = lookup->lookupMethod(utf8, sign->keyName, false, true,
+ &methodCl);
#if !defined(ISOLATE_SHARING) && !defined(SERVICE)
assert(dmeth->classDef->isInitializing() &&
"Class not ready in a virtual lookup.");
@@ -102,8 +104,9 @@
Typedef* sign = 0;
ctpInfo->resolveField(index, cl, utf8, sign);
-
- JavaField* field = cl->lookupField(utf8, sign->keyName, false, true, 0);
+
+ UserClass* lookup = cl->isArray() ? cl->super : cl->asClass();
+ JavaField* field = lookup->lookupField(utf8, sign->keyName, false, true, 0);
ctpInfo->ctpRes[index] = (void*)field->ptrOffset;
@@ -118,13 +121,15 @@
}
UserCommonClass* cl = 0;
- UserCommonClass* fieldCl = 0;
+ UserClass* fieldCl = 0;
const UTF8* utf8 = 0;
Typedef* sign = 0;
ctpInfo->resolveField(index, cl, utf8, sign);
-
- JavaField* field = cl->lookupField(utf8, sign->keyName, true, true, &fieldCl);
+
+ assert(cl->asClass() && "Lookup a field of something not an array");
+ JavaField* field = cl->asClass()->lookupField(utf8, sign->keyName, true,
+ true, &fieldCl);
fieldCl->initialiseClass(JavaThread::get()->getJVM());
void* obj = ((UserClass*)fieldCl)->getStaticInstance();
@@ -206,18 +211,22 @@
Signdef* sign = 0;
caller->getConstantPool()->resolveMethod(index, cl, utf8, sign);
- JavaMethod* dmeth = cl->lookupMethodDontThrow(utf8, sign->keyName, false,
- true, 0);
+ UserClass* lookup = cl->isArray() ? cl->super : cl->asClass();
+ JavaMethod* dmeth = lookup->lookupMethodDontThrow(utf8, sign->keyName, false,
+ true, 0);
if (!dmeth) {
va_list ap;
va_start(ap, index);
JavaObject* obj = va_arg(ap, JavaObject*);
va_end(ap);
- assert(obj->classOf->isInitializing() &&
+ assert((obj->classOf->isClass() &&
+ obj->classOf->asClass()->isInitializing()) &&
"Class not ready in a virtual lookup.");
// Arg, the bytecode is buggy! Perform the lookup on the object class
// and do not update offset.
- dmeth = obj->classOf->lookupMethod(utf8, sign->keyName, false, true, 0);
+ lookup = obj->classOf->isArray() ? obj->classOf->super :
+ obj->classOf->asClass();
+ dmeth = lookup->lookupMethod(utf8, sign->keyName, false, true, 0);
} else {
caller->getConstantPool()->ctpRes[index] = (void*)dmeth->offset;
}
@@ -300,7 +309,7 @@
JavaThread::get()->getJVM()->indexOutOfBounds(obj, index);
}
-extern "C" UserCommonClass* jnjvmRuntimeInitialiseClass(UserCommonClass* cl) {
+extern "C" UserCommonClass* jnjvmRuntimeInitialiseClass(UserClass* cl) {
cl->initialiseClass(JavaThread::get()->getJVM());
return cl;
}
@@ -351,7 +360,7 @@
extern "C" UserClassArray* getArrayClass(UserCommonClass* cl,
UserClassArray** dcl) {
JnjvmClassLoader* JCL = cl->classLoader;
- cl->resolveClass();
+ if (cl->asClass()) cl->asClass()->resolveClass();
const UTF8* arrayName = JCL->constructArrayName(1, cl->getName());
UserClassArray* result = JCL->constructArray(arrayName);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.h?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaString.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.h Fri Nov 28 15:20:44 2008
@@ -16,7 +16,7 @@
namespace jnjvm {
-class UTF8;
+class ArrayUInt16;
class Jnjvm;
class JavaString : public JavaObject {
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Fri Nov 28 15:20:44 2008
@@ -90,7 +90,7 @@
const UTF8* utf8 = vm->asciizToInternalUTF8(asciiz);
UserCommonClass* cl = loader->lookupClassFromUTF8(utf8, vm, true, true);
- cl->initialiseClass(vm);
+ if (cl->asClass()) cl->asClass()->initialiseClass(vm);
return (jclass)(cl->getClassDelegatee(vm));
END_EXCEPTION
@@ -156,12 +156,13 @@
JavaThread* th = JavaThread::get();
Jnjvm* vm = th->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true);
- if (cl->isArray()) assert(0 && "implement me");
- JavaObject* res = ((UserClass*)cl)->doNew(vm);
- JavaMethod* init = cl->lookupMethod(vm->bootstrapLoader->initName,
+ if (!cl->asClass()) assert(0 && "implement me");
+ UserClass* realCl = cl->asClass();
+ JavaObject* res = realCl->doNew(vm);
+ JavaMethod* init = realCl->lookupMethod(vm->bootstrapLoader->initName,
cl->classLoader->asciizConstructUTF8("(Ljava/lang/String;)V"),
false, true, 0);
- init->invokeIntSpecial(vm, (UserClass*)cl, res, vm->asciizToStr(msg));
+ init->invokeIntSpecial(vm, realCl, res, vm->asciizToStr(msg));
th->pendingException = res;
th->returnFromNative();
return 1;
@@ -328,7 +329,8 @@
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true);
const UTF8* name = vm->asciizToInternalUTF8(aname);
const UTF8* type = vm->asciizToInternalUTF8(atype);
- JavaMethod* meth = cl->lookupMethod(name, type, false, true, 0);
+ JavaMethod* meth = cl->asClass() ?
+ cl->asClass()->lookupMethod(name, type, false, true, 0) : 0;
return (jmethodID)meth;
@@ -870,9 +872,10 @@
// TODO: find a better place to store the UTF8
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true);
- return (jfieldID)
- cl->lookupField(cl->classLoader->asciizConstructUTF8(name),
- cl->classLoader->asciizConstructUTF8(sig), 0, 1, 0);
+ return (jfieldID) (cl->asClass() ?
+ cl->asClass()->lookupField(cl->classLoader->asciizConstructUTF8(name),
+ cl->classLoader->asciizConstructUTF8(sig), 0, 1,
+ 0) : 0);
END_EXCEPTION
return 0;
@@ -1115,7 +1118,8 @@
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true);
const UTF8* name = vm->asciizToInternalUTF8(aname);
const UTF8* type = vm->asciizToInternalUTF8(atype);
- JavaMethod* meth = cl->lookupMethod(name, type, true, true, 0);
+ JavaMethod* meth = cl->asClass() ?
+ cl->asClass()->lookupMethod(name, type, true, true, 0) : 0;
return (jmethodID)meth;
@@ -1365,10 +1369,10 @@
// TODO: find a better place to store the UTF8
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true);
- return (jfieldID)
- cl->lookupField(cl->classLoader->asciizConstructUTF8(name),
- cl->classLoader->asciizConstructUTF8(sig), true, true,
- 0);
+ return (jfieldID) (cl->asClass() ?
+ cl->asClass()->lookupField(cl->classLoader->asciizConstructUTF8(name),
+ cl->classLoader->asciizConstructUTF8(sig),
+ true, true, 0) : 0);
END_EXCEPTION
return 0;
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Fri Nov 28 15:20:44 2008
@@ -52,7 +52,7 @@
/// initialiseClass - Java class initialisation. Java specification §2.17.5.
-void UserCommonClass::initialiseClass(Jnjvm* vm) {
+void UserClass::initialiseClass(Jnjvm* vm) {
// Primitives are initialized at boot time, arrays are initialized directly.
@@ -67,8 +67,8 @@
// verification step failed or because initialization was attempted and
// failed.
- assert(status >= resolved || getOwnerClass() || status == ready ||
- status == erroneous && "Class in wrong state");
+ assert(isResolved() || getOwnerClass() || isReady() ||
+ isErroneous() && "Class in wrong state");
if (getInitializationState() != ready) {
@@ -109,7 +109,7 @@
// 5. If the Class object is in an erroneous state, then initialization is
// not possible. Release the lock on the Class object and throw a
// NoClassDefFoundError.
- if (status == erroneous) {
+ if (isErroneous()) {
release();
vm->noClassDefFoundError(name);
}
@@ -144,7 +144,7 @@
// label it erroneous, notify all waiting threads, release the lock,
// and complete abruptly, throwing the same exception that resulted from
// the initializing the superclass.
- UserCommonClass* super = getSuper();
+ UserClass* super = getSuper();
if (super) {
JavaObject *exc = 0;
try {
@@ -157,7 +157,7 @@
if (exc) {
acquire();
- status = erroneous;
+ setErroneous();
setOwnerClass(0);
broadcastClass();
release();
@@ -168,7 +168,7 @@
#ifdef SERVICE
JavaObject* exc = 0;
if (classLoader == classLoader->bootstrapLoader ||
- classLoader->isolate == vm) {
+ classLoader->getIsolate() == vm) {
#endif
// 8. Next, execute either the class variable initializers and static
@@ -247,7 +247,7 @@
// threads, release the lock, and complete this procedure abruptly
// with reason E or its replacement as determined in the previous step.
acquire();
- status = erroneous;
+ setErroneous();
setOwnerClass(0);
broadcastClass();
release();
@@ -442,7 +442,6 @@
}
JavaObject* UserCommonClass::getClassDelegatee(Jnjvm* vm, JavaObject* pd) {
- acquire();
if (!getDelegatee()) {
UserClass* cl = vm->upcalls->newClass;
JavaObject* delegatee = cl->doNew(vm);
@@ -455,7 +454,6 @@
}
setDelegatee(delegatee);
}
- release();
return getDelegatee();
}
@@ -736,6 +734,12 @@
void Jnjvm::loadBootstrap() {
JnjvmClassLoader* loader = bootstrapLoader;
+
+ // Initialise the bootstrap class loader if it's not
+ // done already.
+ if (!bootstrapLoader->upcalls->newString)
+ bootstrapLoader->upcalls->initialiseClasspath(bootstrapLoader);
+
#define LOAD_CLASS(cl) \
cl->resolveClass(); \
cl->initialiseClass(this);
@@ -826,7 +830,7 @@
// libjavalang.so and we are optimizing some math operations
UserCommonClass* math =
loader->loadName(loader->asciizConstructUTF8("java/lang/Math"), true, true);
- math->initialiseClass(this);
+ math->asClass()->initialiseClass(this);
}
void Jnjvm::executeClass(const char* className, ArrayObject* args) {
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Fri Nov 28 15:20:44 2008
@@ -227,8 +227,6 @@
arrayTable[JavaArray::T_FLOAT - 4] = upcalls->ArrayOfFloat;
arrayTable[JavaArray::T_LONG - 4] = upcalls->ArrayOfLong;
arrayTable[JavaArray::T_DOUBLE - 4] = upcalls->ArrayOfDouble;
-
- upcalls->initialiseClasspath(this);
}
JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader,
@@ -248,8 +246,8 @@
isolate = I;
JavaMethod* meth = bootstrapLoader->upcalls->loadInClassLoader;
- loader->classOf->lookupMethodDontThrow(meth->name, meth->type, false, true,
- &loadClass);
+ loader->classOf->asClass()->lookupMethodDontThrow(meth->name, meth->type,
+ false, true, &loadClass);
assert(loadClass && "Loader does not have a loadClass function");
#if defined(SERVICE)
@@ -386,7 +384,6 @@
len - 2);
if (loadName(componentName, doResolve, doThrow)) {
ret = constructArray(name);
- if (doResolve) ret->resolveClass();
doLoop = false;
} else {
doLoop = false;
@@ -401,7 +398,6 @@
&& ((uint32)name->size) == start + 1) {
ret = constructArray(name);
- ret->resolveClass();
doLoop = false;
} else {
doLoop = false;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Fri Nov 28 15:20:44 2008
@@ -51,12 +51,8 @@
/// table for non-isolate environments.
///
class JnjvmClassLoader : public mvm::CompilationUnit {
- friend class JavaJIT;
- friend class Jnjvm;
- friend class UserCommonClass;
private:
-
-
+
/// isolate - Which isolate defined me? Null for the bootstrap class loader.
///
Jnjvm* isolate;
@@ -104,7 +100,11 @@
/// signatures and types.
///
mvm::BumpPtrAllocator allocator;
-
+
+ /// getIsolate - Returns the isolate that created this class loader.
+ ///
+ Jnjvm* getIsolate() { return isolate; }
+
/// getClasses - Returns the classes this class loader has loaded.
///
ClassMap* getClasses() { return classes; }
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmConfig.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmConfig.h?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmConfig.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmConfig.h Fri Nov 28 15:20:44 2008
@@ -36,6 +36,8 @@
#ifdef ISOLATE
#define NR_ISOLATES 32
+#else
+#define NR_ISOLATES 1
#endif
#endif // JNJVM_CONFIG_H
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Fri Nov 28 15:20:44 2008
@@ -14,6 +14,7 @@
#include "mvm/JIT.h"
+#include "JavaJIT.h"
#include "JavaThread.h"
#include "JavaTypes.h"
#include "Jnjvm.h"
@@ -25,6 +26,8 @@
using namespace jnjvm;
using namespace llvm;
+llvm::Value* JnjvmModule::PrimitiveArrayVT;
+llvm::Value* JnjvmModule::ReferenceArrayVT;
#ifdef WITH_TRACER
const llvm::FunctionType* JnjvmModule::MarkAndTraceType = 0;
@@ -51,21 +54,18 @@
#endif
llvm::Constant* JnjvmModule::JavaObjectNullConstant;
-llvm::Constant* JnjvmModule::UTF8NullConstant;
-llvm::Constant* JnjvmModule::JavaClassNullConstant;
llvm::Constant* JnjvmModule::MaxArraySizeConstant;
-llvm::Constant* JnjvmModule::JavaObjectSizeConstant;
llvm::Constant* JnjvmModule::JavaArraySizeConstant;
llvm::ConstantInt* JnjvmModule::OffsetObjectSizeInClassConstant;
llvm::ConstantInt* JnjvmModule::OffsetVTInClassConstant;
llvm::ConstantInt* JnjvmModule::OffsetDepthInClassConstant;
llvm::ConstantInt* JnjvmModule::OffsetDisplayInClassConstant;
-llvm::ConstantInt* JnjvmModule::OffsetStatusInClassConstant;
llvm::ConstantInt* JnjvmModule::OffsetTaskClassMirrorInClassConstant;
llvm::ConstantInt* JnjvmModule::OffsetStaticInstanceInTaskClassMirrorConstant;
llvm::ConstantInt* JnjvmModule::OffsetStatusInTaskClassMirrorConstant;
llvm::ConstantInt* JnjvmModule::ClassReadyConstant;
const llvm::Type* JnjvmModule::JavaClassType;
+const llvm::Type* JnjvmModule::JavaCommonClassType;
const llvm::Type* JnjvmModule::VTType;
llvm::ConstantInt* JnjvmModule::JavaArrayElementsOffsetConstant;
llvm::ConstantInt* JnjvmModule::JavaArraySizeOffsetConstant;
@@ -77,12 +77,14 @@
native_class_iterator End = nativeClasses.end();
native_class_iterator I = nativeClasses.find(classDef);
if (I == End) {
+ const llvm::Type* Ty = classDef->isClass() ?
+ JavaClassType : JavaCommonClassType;
Constant* cons =
ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty,
uint64_t (classDef)),
- JnjvmModule::JavaClassType);
+ Ty);
- varGV = new GlobalVariable(JnjvmModule::JavaClassType, !staticCompilation,
+ varGV = new GlobalVariable(Ty, !staticCompilation,
GlobalValue::ExternalLinkage,
cons, "", this);
@@ -210,7 +212,7 @@
return varGV;
}
-Value* JnjvmModule::getVirtualTable(CommonClass* classDef) {
+Value* JnjvmModule::getVirtualTable(Class* classDef) {
llvm::GlobalVariable* varGV = 0;
virtual_table_iterator End = virtualTables.end();
virtual_table_iterator I = virtualTables.find(classDef);
@@ -553,6 +555,7 @@
Value* LLVMClassInfo::getVirtualSize() {
if (!virtualSizeConstant) {
getVirtualType();
+ assert(classDef->virtualSize && "Zero size for a class?");
virtualSizeConstant =
ConstantInt::get(Type::Int32Ty, classDef->virtualSize);
}
@@ -951,6 +954,9 @@
JavaArrayType =
PointerType::getUnqual(module->getTypeByName("JavaArray"));
+ JavaCommonClassType =
+ PointerType::getUnqual(module->getTypeByName("JavaCommonClass"));
+
JavaClassType =
PointerType::getUnqual(module->getTypeByName("JavaClass"));
@@ -985,12 +991,9 @@
MarkAndTraceType = module->getFunction("MarkAndTrace")->getFunctionType();
#endif
- UTF8NullConstant = Constant::getNullValue(JavaArrayUInt16Type);
- JavaClassNullConstant = Constant::getNullValue(JavaClassType);
JavaObjectNullConstant = Constant::getNullValue(JnjvmModule::JavaObjectType);
MaxArraySizeConstant = ConstantInt::get(Type::Int32Ty,
JavaArray::MaxArraySize);
- JavaObjectSizeConstant = ConstantInt::get(Type::Int32Ty, sizeof(JavaObject));
JavaArraySizeConstant =
ConstantInt::get(Type::Int32Ty, sizeof(JavaObject) + sizeof(ssize_t));
@@ -1000,20 +1003,43 @@
JavaObjectLockOffsetConstant = mvm::MvmModule::constantTwo;
JavaObjectClassOffsetConstant = mvm::MvmModule::constantOne;
+ OffsetDisplayInClassConstant = mvm::MvmModule::constantZero;
+ OffsetDepthInClassConstant = mvm::MvmModule::constantOne;
+
OffsetObjectSizeInClassConstant = mvm::MvmModule::constantOne;
OffsetVTInClassConstant = mvm::MvmModule::constantTwo;
- OffsetDisplayInClassConstant = mvm::MvmModule::constantThree;
- OffsetDepthInClassConstant = mvm::MvmModule::constantFour;
- OffsetStatusInClassConstant = mvm::MvmModule::constantFive;
- OffsetTaskClassMirrorInClassConstant = mvm::MvmModule::constantSix;
- OffsetStaticInstanceInTaskClassMirrorConstant = mvm::MvmModule::constantTwo;
+ OffsetTaskClassMirrorInClassConstant = mvm::MvmModule::constantThree;
+ OffsetStaticInstanceInTaskClassMirrorConstant = mvm::MvmModule::constantOne;
OffsetStatusInTaskClassMirrorConstant = mvm::MvmModule::constantZero;
ClassReadyConstant = ConstantInt::get(Type::Int32Ty, ready);
+
+ Constant* cons =
+ ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty,
+ uint64(JavaArray::VT)),
+ VTType);
+ PrimitiveArrayVT = new GlobalVariable(VTType, !staticCompilation,
+ GlobalValue::ExternalLinkage,
+ cons, "", this);
+
+ cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty,
+ uint64(ArrayObject::VT)),
+ VTType);
+ ReferenceArrayVT = new GlobalVariable(VTType, !staticCompilation,
+ GlobalValue::ExternalLinkage,
+ cons, "", this);
LLVMAssessorInfo::initialise();
}
+Value* JnjvmModule::getReferenceArrayVT(JavaJIT* JIT) {
+ return new LoadInst(ReferenceArrayVT, "", JIT->currentBlock);
+}
+
+Value* JnjvmModule::getPrimitiveArrayVT(JavaJIT* JIT) {
+ return new LoadInst(PrimitiveArrayVT, "", JIT->currentBlock);
+}
+
void JnjvmModule::setMethod(JavaMethod* meth, const char* name) {
llvm::Function* func = getMethodInfo(meth)->getMethod();
func->setName(name);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Fri Nov 28 15:20:44 2008
@@ -52,7 +52,7 @@
class LLVMClassInfo : public mvm::JITInfo {
friend class JnjvmModule;
private:
- CommonClass* classDef;
+ Class* classDef;
/// virtualSizeLLVM - The LLVM constant size of instances of this class.
///
llvm::ConstantInt* virtualSizeConstant;
@@ -73,7 +73,7 @@
const llvm::Type* getVirtualType();
const llvm::Type* getStaticType();
- LLVMClassInfo(CommonClass* cl) :
+ LLVMClassInfo(Class* cl) :
classDef(cl),
virtualSizeConstant(0),
virtualTracerFunction(0),
@@ -216,7 +216,9 @@
llvm::Function* makeTracer(Class* cl, bool stat);
VirtualTable* makeVT(Class* cl);
VirtualTable* allocateVT(Class* cl);
-
+
+ static llvm::Value* PrimitiveArrayVT;
+ static llvm::Value* ReferenceArrayVT;
public:
@@ -247,6 +249,7 @@
static const llvm::Type* VTType;
static const llvm::Type* JavaObjectType;
static const llvm::Type* JavaArrayType;
+ static const llvm::Type* JavaCommonClassType;
static const llvm::Type* JavaClassType;
static const llvm::Type* JavaCacheType;
static const llvm::Type* EnveloppeType;
@@ -325,19 +328,14 @@
static llvm::ConstantInt* OffsetVTInClassConstant;
static llvm::ConstantInt* OffsetDepthInClassConstant;
static llvm::ConstantInt* OffsetDisplayInClassConstant;
- static llvm::ConstantInt* OffsetStatusInClassConstant;
static llvm::ConstantInt* OffsetTaskClassMirrorInClassConstant;
static llvm::ConstantInt* OffsetStaticInstanceInTaskClassMirrorConstant;
static llvm::ConstantInt* OffsetStatusInTaskClassMirrorConstant;
static llvm::ConstantInt* ClassReadyConstant;
- static llvm::Constant* JavaClassNullConstant;
-
static llvm::Constant* JavaObjectNullConstant;
- static llvm::Constant* UTF8NullConstant;
static llvm::Constant* MaxArraySizeConstant;
- static llvm::Constant* JavaObjectSizeConstant;
static llvm::Constant* JavaArraySizeConstant;
llvm::Function* GetExceptionFunction;
@@ -381,12 +379,15 @@
llvm::Value* getNativeClass(CommonClass* cl);
llvm::Value* getJavaClass(CommonClass* cl);
llvm::Value* getStaticInstance(Class* cl);
- llvm::Value* getVirtualTable(CommonClass* cl);
+ llvm::Value* getVirtualTable(Class* cl);
llvm::Value* getEnveloppe(Enveloppe* enveloppe);
llvm::Value* getString(JavaString* str);
llvm::Value* getConstantPool(JavaConstantPool* ctp);
llvm::Value* getNativeFunction(JavaMethod* meth, void* natPtr);
+
+ llvm::Value* getReferenceArrayVT(JavaJIT*);
+ llvm::Value* getPrimitiveArrayVT(JavaJIT*);
#ifdef SERVICE
std::map<const Jnjvm*, llvm::GlobalVariable*> isolates;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Fri Nov 28 15:20:44 2008
@@ -49,15 +49,16 @@
Signdef* sign = 0;
ctpInfo->resolveMethod(index, cl, utf8, sign);
- JavaMethod* meth = cl->lookupMethod(utf8, sign->keyName, isStatic, true,
- 0);
+ UserClass* lookup = cl->isArray() ? cl->super : cl->asClass();
+ JavaMethod* meth = lookup->lookupMethod(utf8, sign->keyName, isStatic, true,
+ 0);
#ifndef ISOLATE_SHARING
// A multi environment would have already initialized the class. Besides,
// a callback does not involve UserClass, therefore we wouldn't know
// which class to initialize.
if (!isVirtual(meth->access))
- cl->initialiseClass(JavaThread::get()->getJVM());
+ lookup->initialiseClass(JavaThread::get()->getJVM());
#endif
meth->compiledPtr();
Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Fri Nov 28 15:20:44 2008
@@ -87,6 +87,19 @@
CI);
return TCM;
}
+#else
+static Value* getTCM(JnjvmModule* module, Value* Arg, Instruction* CI) {
+ Value* GEP[2] = { module->constantZero,
+ module->OffsetTaskClassMirrorInClassConstant };
+ Value* TCMArray = GetElementPtrInst::Create(Arg, GEP, GEP + 2, "", CI);
+
+ Value* GEP2[2] = { module->constantZero, module->constantZero };
+
+ Value* TCM = GetElementPtrInst::Create(TCMArray, GEP2, GEP2 + 2, "",
+ CI);
+ return TCM;
+
+}
#endif
bool LowerConstantCalls::runOnFunction(Function& F) {
@@ -149,7 +162,7 @@
}
}
- Value* val = Call.getArgument(0);
+ Value* val = Call.getArgument(0);
Value* indexes[2] = { module->constantZero,
module->OffsetVTInClassConstant };
Value* VTPtr = GetElementPtrInst::Create(val, indexes, indexes + 2,
@@ -241,12 +254,9 @@
BranchInst::Create(ifTrue, notEquals, cmp, ifFalse);
node->addIncoming(ConstantInt::getTrue(), ifFalse);
- if (cl->status < classRead) {
- Value* args[2] = { objCl, CE };
- cmp = CallInst::Create(module->IsAssignableFromFunction,
- args, args + 2, "", notEquals);
- node->addIncoming(cmp, notEquals);
- BranchInst::Create(ifTrue, notEquals);
+ if (cl->isPrimitive()) {
+ fprintf(stderr, "implement me");
+ abort();
} else if (cl->isArray()) {
Value* args[2] = { objCl, CE };
Value* res =
@@ -256,7 +266,7 @@
BranchInst::Create(ifTrue, notEquals);
} else {
Value* depthCl;
- if (cl->isResolved()) {
+ if (cl->asClass()->isResolved()) {
depthCl = ConstantInt::get(Type::Int32Ty, cl->depth);
} else {
depthCl = CallInst::Create(module->GetDepthFunction,
@@ -332,19 +342,11 @@
}
Value* Cl = Call.getArgument(0);
-#if !defined(ISOLATE)
- Value* indexes[2] = { module->constantZero,
- module->OffsetStatusInClassConstant };
- Value* StatusPtr = GetElementPtrInst::Create(Cl, indexes,
- indexes + 2, "", CI);
-
-#else
Value* TCM = getTCM(module, Call.getArgument(0), CI);
Value* GEP[2] = { module->constantZero,
module->OffsetStatusInTaskClassMirrorConstant };
Value* StatusPtr = GetElementPtrInst::Create(TCM, GEP, GEP + 2, "",
CI);
-#endif
Value* Status = new LoadInst(StatusPtr, "", CI);
@@ -481,7 +483,8 @@
BranchInst::Create(NBB, trueCl);
break;
} else if (V == module->GetArrayClassFunction) {
- const llvm::Type* Ty = PointerType::getUnqual(module->JavaClassType);
+ const llvm::Type* Ty =
+ PointerType::getUnqual(module->JavaCommonClassType);
Constant* nullValue = Constant::getNullValue(Ty);
// Check if we have already proceed this call.
if (Call.getArgument(1) == nullValue) {
@@ -506,9 +509,10 @@
BasicBlock* NBB = II->getParent()->splitBasicBlock(II);
I->getParent()->getTerminator()->eraseFromParent();
- Constant* init = Constant::getNullValue(module->JavaClassType);
+ Constant* init =
+ Constant::getNullValue(module->JavaCommonClassType);
GlobalVariable* GV =
- new GlobalVariable(module->JavaClassType, false,
+ new GlobalVariable(module->JavaCommonClassType, false,
GlobalValue::ExternalLinkage,
init, "", module);
@@ -518,7 +522,8 @@
BasicBlock* OKBlock = BasicBlock::Create("", &F);
BasicBlock* NotOKBlock = BasicBlock::Create("", &F);
- PHINode* node = PHINode::Create(module->JavaClassType, "", OKBlock);
+ PHINode* node = PHINode::Create(module->JavaCommonClassType, "",
+ OKBlock);
node->addIncoming(LoadedGV, CI->getParent());
BranchInst::Create(NotOKBlock, OKBlock, cmp, CI);
Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Fri Nov 28 15:20:44 2008
@@ -190,8 +190,10 @@
UserCommonClass* NativeUtil::resolvedImplClass(Jnjvm* vm, jclass clazz,
bool doClinit) {
UserCommonClass* cl = ((JavaObjectClass*)clazz)->getClass();
- cl->resolveClass();
- if (doClinit) cl->initialiseClass(vm);
+ if (cl->asClass()) {
+ cl->asClass()->resolveClass();
+ cl->asClass()->initialiseClass(vm);
+ }
return cl;
}
@@ -377,7 +379,8 @@
for (uint16 i = 0; i < nbe; ++i) {
uint16 idx = reader.readU2();
UserCommonClass* cl = ctp->loadClass(idx);
- cl->resolveClass();
+ assert(cl->asClass() && "Wrong exception type");
+ cl->asClass()->resolveClass();
JavaObject* obj = cl->getClassDelegatee(vm);
res->elements[i] = obj;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=60212&r1=60211&r2=60212&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Fri Nov 28 15:20:44 2008
@@ -63,39 +63,27 @@
(*i)->MARK_AND_TRACE; }}
void CommonClass::TRACER {
- if (status >= prepared) {
- if (super) super->classLoader->MARK_AND_TRACE;
- for (uint32 i = 0; i < nbInterfaces; ++i) {
- interfaces[i]->classLoader->MARK_AND_TRACE;
- }
+ if (super) super->classLoader->MARK_AND_TRACE;
+ for (uint32 i = 0; i < nbInterfaces; ++i) {
+ interfaces[i]->classLoader->MARK_AND_TRACE;
}
classLoader->MARK_AND_TRACE;
-#if !defined(ISOLATE) && !defined(ISOLATE_SHARING)
- _delegatee->MARK_AND_TRACE;
-#endif
+ for (uint32 i = 0; i < NR_ISOLATES; ++i) {
+ delegatee[i]->MARK_AND_TRACE;
+ }
-#if defined(ISOLATE)
+}
+
+void Class::TRACER {
+ CommonClass::CALL_TRACER;
+ bytes->MARK_AND_TRACE;
+
for (uint32 i =0; i < NR_ISOLATES; ++i) {
TaskClassMirror &M = IsolateInfo[i];
- M.delegatee->MARK_AND_TRACE;
if (M.staticInstance) {
((Class*)this)->staticTracer(M.staticInstance);
}
}
-#endif
-}
-
-void Class::TRACER {
- CommonClass::CALL_TRACER;
- bytes->MARK_AND_TRACE;
-#if !defined(ISOLATE)
- if (_staticInstance)
- staticTracer(_staticInstance);
-#endif
-}
-
-void ClassArray::TRACER {
- CommonClass::CALL_TRACER;
}
void JavaObject::TRACER {
@@ -117,7 +105,9 @@
static void traceClassMap(ClassMap* classes) {
for (ClassMap::iterator i = classes->map.begin(), e = classes->map.end();
i!= e; ++i) {
- i->second->CALL_TRACER;
+ CommonClass* cl = i->second;
+ if (cl->isClass()) cl->asClass()->CALL_TRACER;
+ else cl->CALL_TRACER;
}
}
@@ -133,18 +123,10 @@
#if defined(ISOLATE_SHARING)
JnjvmSharedLoader::sharedLoader->MARK_AND_TRACE;
#endif
- traceClassMap(bootstrapLoader->classes);
+ traceClassMap(bootstrapLoader->getClasses());
-#if !defined(ISOLATE) && !defined(ISOLATE_SHARING)
-#define TRACE_DELEGATEE(prim) \
- prim->_delegatee->MARK_AND_TRACE
-
-#else
-#if defined(ISOLATE)
#define TRACE_DELEGATEE(prim) \
prim->CALL_TRACER;
-#endif
-#endif
TRACE_DELEGATEE(upcalls->OfVoid);
TRACE_DELEGATEE(upcalls->OfBool);
More information about the vmkit-commits
mailing list