[vmkit-commits] [vmkit] r56336 - in /vmkit/branches/isolate/lib/JnJVM: Classpath/ClasspathVMSystem.cpp.inc VMCore/JavaClass.cpp VMCore/JavaClass.h VMCore/JavaInitialise.cpp VMCore/JavaRuntimeJIT.cpp VMCore/JavaTypes.cpp VMCore/JavaTypes.h VMCore/JnjvmClassLoader.cpp VMCore/JnjvmClassLoader.h VMCore/JnjvmModule.cpp
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Fri Sep 19 00:16:01 PDT 2008
Author: geoffray
Date: Fri Sep 19 02:16:01 2008
New Revision: 56336
URL: http://llvm.org/viewvc/llvm-project?rev=56336&view=rev
Log:
Add a doNew function to arrays, and remove a reference to
an AssessorDesc (which was dRef or dTab for almost all
array classes).
Modified:
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp
Modified: vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc?rev=56336&r1=56335&r2=56336&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc Fri Sep 19 02:16:01 2008
@@ -47,10 +47,7 @@
UserClassArray* ts = (UserClassArray*)src->classOf;
UserClassArray* td = (UserClassArray*)dst->classOf;
UserCommonClass* dstType = td->baseClass();
- AssessorDesc* dstFuncs = td->funcs();
- AssessorDesc* srcFuncs = ts->funcs();
- UserCommonClass* srcPrim = srcFuncs->getPrimitiveClass();
- UserCommonClass* dstPrim = dstFuncs->getPrimitiveClass();
+ UserCommonClass* srcType = ts->baseClass();
if (len > src->size) {
vm->indexOutOfBounds(src, len);
@@ -66,13 +63,14 @@
vm->indexOutOfBounds(src, sstart);
} else if (len < 0) {
vm->indexOutOfBounds(src, len);
- } else if (srcPrim != dstPrim) {
+ } else if ((dstType->isPrimitive() || srcType->isPrimitive()) &&
+ srcType != dstType) {
vm->arrayStoreException();
}
jint i = sstart;
bool doThrow = false;
- if (srcFuncs->doTrace) {
+ if (!(dstType->isPrimitive())) {
while (i < sstart + len && !doThrow) {
JavaObject* cur = ((ArrayObject*)src)->elements[i];
if (cur) {
@@ -85,8 +83,10 @@
}
}
- uint32 size = srcFuncs->nbb;
- if (size == 0) size = sizeof(void*);
+ uint32 size = dstType->isPrimitive() ?
+ dstType->virtualSize : sizeof(JavaObject*);
+
+ assert(size && "Size zero in a arraycopy");
void* ptrDst = (void*)((int64_t)(dst->elements) + size * dstart);
void* ptrSrc = (void*)((int64_t)(src->elements) + size * sstart);
memmove(ptrDst, ptrSrc, size * len);
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp?rev=56336&r1=56335&r2=56336&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp Fri Sep 19 02:16:01 2008
@@ -242,10 +242,10 @@
#endif
}
-ClassArray::ClassArray(JnjvmClassLoader* loader, const UTF8* n) :
+ClassArray::ClassArray(JnjvmClassLoader* loader, const UTF8* n,
+ UserCommonClass* base) :
CommonClass(loader, n, true) {
- _funcs = 0;
- _baseClass = 0;
+ _baseClass = base;
super = ClassArray::SuperArray;
interfaces = ClassArray::InterfacesArray;
depth = 1;
@@ -253,6 +253,11 @@
display[0] = ClassArray::SuperArray;
display[1] = this;
access = ACC_FINAL | ACC_ABSTRACT;
+ if (base->isPrimitive()) {
+ virtualVT = JavaArray::VT;
+ } else {
+ virtualVT = ArrayObject::VT;
+ }
}
void Class::print(mvm::PrintBuffer* buf) const {
@@ -267,26 +272,21 @@
buf->write(">");
}
-void UserClassArray::resolveComponent() {
- AssessorDesc::introspectArray(classLoader, getName(), 0, _funcs,
- _baseClass);
-}
-
-JnjvmClassLoader* ClassArray::arrayLoader(const UTF8* name,
- JnjvmClassLoader* loader,
- unsigned int start,
- unsigned int len) {
-
- if (name->elements[start] == AssessorDesc::I_TAB) {
- return arrayLoader(name, loader, start + 1, len - 1);
- } else if (name->elements[start] == AssessorDesc::I_REF) {
- const UTF8* componentName = name->javaToInternal(loader->hashUTF8,
- start + 1, len - 2);
- UserCommonClass* cl = loader->loadName(componentName, false, true);
- return cl->classLoader;
- } else {
- return JavaThread::get()->isolate->bootstrapLoader;
- }
+JavaArray* UserClassArray::doNew(sint32 n, Jnjvm* vm) {
+ if (n < 0)
+ vm->negativeArraySizeException(n);
+ else if (n > JavaArray::MaxArraySize)
+ vm->outOfMemoryError(n);
+
+ UserCommonClass* cl = baseClass();
+ assert(cl && virtualVT && "array class not resolved");
+
+ uint32 primSize = cl->isPrimitive() ? cl->virtualSize : sizeof(JavaObject*);
+ JavaArray* res = (JavaArray*)
+ vm->allocator.allocateObject(sizeof(name) + n * primSize, virtualVT);
+ res->initialise(this);
+ res->size = n;
+ return res;
}
void* JavaMethod::compiledPtr() {
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h?rev=56336&r1=56335&r2=56336&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h Fri Sep 19 02:16:01 2008
@@ -32,6 +32,7 @@
class Enveloppe;
class Class;
class ClassArray;
+class JavaArray;
class JavaConstantPool;
class JavaField;
class JavaJIT;
@@ -682,39 +683,25 @@
///
CommonClass* _baseClass;
- /// _funcs - The type of the base class of the array (primitive or
- /// reference). Null if not resolved.
- ///
- AssessorDesc* _funcs;
-
- /// resolveComponent - Resolve the array class. The base class and the
- /// AssessorDesc are resolved.
- ///
- void resolveComponent();
-
/// baseClass - Get the base class of this array class. Resolve the array
/// class if needed.
///
CommonClass* baseClass() {
- if (_baseClass == 0)
- resolveComponent();
return _baseClass;
}
- /// funcs - Get the type of the base class/ Resolve the array if needed.
- AssessorDesc* funcs() {
- if (_funcs == 0)
- resolveComponent();
- return _funcs;
- }
+ /// funcs - Get the type of the base class/ Resolve the array if needed.
+ JavaArray* doNew(sint32 n, Jnjvm* vm);
+
/// ClassArray - Empty constructor for VT.
///
ClassArray() {}
/// ClassArray - Construct a Java array class with the given name.
///
- ClassArray(JnjvmClassLoader* loader, const UTF8* name);
+ ClassArray(JnjvmClassLoader* loader, const UTF8* name,
+ UserCommonClass* baseClass);
/// arrayLoader - Return the class loader of the class with the name 'name'.
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=56336&r1=56335&r2=56336&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp Fri Sep 19 02:16:01 2008
@@ -88,12 +88,28 @@
JnjvmBootstrapLoader* JCL = bootstrapLoader =
JnjvmBootstrapLoader::createBootstrapLoader();
- // Array initialization
+ // Create the name of char arrays.
const UTF8* utf8OfChar = JCL->asciizConstructUTF8("[C");
- JCL->upcalls->ArrayOfChar = JCL->constructArray(utf8OfChar);
+
+ // Create the base class of char arrays.
+ JCL->upcalls->OfChar = UPCALL_PRIMITIVE_CLASS(JCL, "char", 2);
+
+ // Create the char array.
+ JCL->upcalls->ArrayOfChar = JCL->constructArray(utf8OfChar,
+ JCL->upcalls->OfChar);
+
+ // Alright, now we can repair the damage: set the class to the UTF8s created
+ // and set the array class of UTF8s.
((UTF8*)utf8OfChar)->classOf = JCL->upcalls->ArrayOfChar;
+ ((UTF8*)JCL->upcalls->OfChar->name)->classOf = JCL->upcalls->ArrayOfChar;
JCL->hashUTF8->array = JCL->upcalls->ArrayOfChar;
+
+ // Create the byte array, so that bytes for classes can be created.
+ JCL->upcalls->OfByte = UPCALL_PRIMITIVE_CLASS(JCL, "byte", 1);
+ JCL->upcalls->ArrayOfByte =
+ JCL->constructArray(JCL->asciizConstructUTF8("[B"), JCL->upcalls->OfByte);
+ // Now we can create the super and interfaces of arrays.
JCL->InterfacesArray.push_back(
JCL->loadName(JCL->asciizConstructUTF8("java/lang/Cloneable"), false,
false));
@@ -116,41 +132,49 @@
ClassArray::SuperArray = JCL->SuperArray;
ClassArray::InterfacesArray = JCL->InterfacesArray;
#endif
-
+
+ // And repair the damage: set the interfaces and super of array classes already
+ // created.
JCL->upcalls->ArrayOfChar->setInterfaces(JCL->InterfacesArray);
JCL->upcalls->ArrayOfChar->setSuper(JCL->SuperArray);
+ JCL->upcalls->ArrayOfByte->setInterfaces(JCL->InterfacesArray);
+ JCL->upcalls->ArrayOfByte->setSuper(JCL->SuperArray);
- JCL->upcalls->ArrayOfByte = JCL->constructArray(JCL->asciizConstructUTF8("[B"));
- JCL->upcalls->ArrayOfString =
- JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/String;"));
+ // Yay, create the other primitive types.
+ JCL->upcalls->OfBool = UPCALL_PRIMITIVE_CLASS(JCL, "boolean", 1);
+ JCL->upcalls->OfShort = UPCALL_PRIMITIVE_CLASS(JCL, "short", 2);
+ JCL->upcalls->OfInt = UPCALL_PRIMITIVE_CLASS(JCL, "int", 4);
+ JCL->upcalls->OfLong = UPCALL_PRIMITIVE_CLASS(JCL, "long", 8);
+ JCL->upcalls->OfFloat = UPCALL_PRIMITIVE_CLASS(JCL, "float", 4);
+ JCL->upcalls->OfDouble = UPCALL_PRIMITIVE_CLASS(JCL, "double", 8);
+ JCL->upcalls->OfVoid = UPCALL_PRIMITIVE_CLASS(JCL, "void", 0);
- JCL->upcalls->ArrayOfObject =
- JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/Object;"));
+ // And finally create the primitive arrays.
+ JCL->upcalls->ArrayOfInt =
+ JCL->constructArray(JCL->asciizConstructUTF8("[I"), JCL->upcalls->OfInt);
- JCL->upcalls->ArrayOfInt = JCL->constructArray(JCL->asciizConstructUTF8("[I"));
+ JCL->upcalls->ArrayOfBool =
+ JCL->constructArray(JCL->asciizConstructUTF8("[Z"), JCL->upcalls->OfBool);
- JCL->upcalls->ArrayOfBool = JCL->constructArray(JCL->asciizConstructUTF8("[Z"));
+ JCL->upcalls->ArrayOfLong =
+ JCL->constructArray(JCL->asciizConstructUTF8("[J"), JCL->upcalls->OfLong);
- JCL->upcalls->ArrayOfLong = JCL->constructArray(JCL->asciizConstructUTF8("[J"));
+ JCL->upcalls->ArrayOfFloat =
+ JCL->constructArray(JCL->asciizConstructUTF8("[F"), JCL->upcalls->OfFloat);
- JCL->upcalls->ArrayOfFloat = JCL->constructArray(JCL->asciizConstructUTF8("[F"));
+ JCL->upcalls->ArrayOfDouble =
+ JCL->constructArray(JCL->asciizConstructUTF8("[D"), JCL->upcalls->OfDouble);
- JCL->upcalls->ArrayOfDouble = JCL->constructArray(JCL->asciizConstructUTF8("[D"));
+ JCL->upcalls->ArrayOfShort =
+ JCL->constructArray(JCL->asciizConstructUTF8("[S"), JCL->upcalls->OfShort);
- JCL->upcalls->ArrayOfShort = JCL->constructArray(JCL->asciizConstructUTF8("[S"));
+ JCL->upcalls->ArrayOfString =
+ JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/String;"));
+
+ JCL->upcalls->ArrayOfObject =
+ JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/Object;"));
- // End array initialization
- JCL->upcalls->OfByte = UPCALL_PRIMITIVE_CLASS(JCL, "byte", 1);
- JCL->upcalls->OfBool = UPCALL_PRIMITIVE_CLASS(JCL, "boolean", 1);
- JCL->upcalls->OfChar = UPCALL_PRIMITIVE_CLASS(JCL, "char", 2);
- JCL->upcalls->OfShort = UPCALL_PRIMITIVE_CLASS(JCL, "short", 2);
- JCL->upcalls->OfInt = UPCALL_PRIMITIVE_CLASS(JCL, "int", 4);
- JCL->upcalls->OfLong = UPCALL_PRIMITIVE_CLASS(JCL, "long", 8);
- JCL->upcalls->OfFloat = UPCALL_PRIMITIVE_CLASS(JCL, "float", 4);
- JCL->upcalls->OfDouble = UPCALL_PRIMITIVE_CLASS(JCL, "double", 8);
- JCL->upcalls->OfVoid = UPCALL_PRIMITIVE_CLASS(JCL, "void", 0);
-
AssessorDesc::initialise(JCL);
Attribut::codeAttribut = JCL->asciizConstructUTF8("Code");
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=56336&r1=56335&r2=56336&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Fri Sep 19 02:16:01 2008
@@ -306,22 +306,18 @@
return cl->getClassDelegatee(vm);
}
-static JavaArray* multiCallNewIntern(arrayCtor_t ctor, UserClassArray* cl,
- uint32 len,
- sint32* dims,
- Jnjvm* vm) {
+static JavaArray* multiCallNewIntern(UserClassArray* cl, uint32 len,
+ sint32* dims, Jnjvm* vm) {
if (len <= 0) JavaThread::get()->isolate->unknownError("Can not happen");
- JavaArray* _res = ctor(dims[0], cl, vm);
+ JavaArray* _res = cl->doNew(dims[0], vm);
if (len > 1) {
ArrayObject* res = (ArrayObject*)_res;
UserCommonClass* _base = cl->baseClass();
if (_base->isArray()) {
UserClassArray* base = (UserClassArray*)_base;
- AssessorDesc* func = base->funcs();
- arrayCtor_t newCtor = func->arrayCtor;
if (dims[0] > 0) {
for (sint32 i = 0; i < dims[0]; ++i) {
- res->elements[i] = multiCallNewIntern(newCtor, base, (len - 1),
+ res->elements[i] = multiCallNewIntern(base, (len - 1),
&dims[1], vm);
}
} else {
@@ -345,7 +341,7 @@
dims[i] = va_arg(ap, int);
}
Jnjvm* vm = JavaThread::get()->isolate;
- return multiCallNewIntern((arrayCtor_t)ArrayObject::acons, cl, len, dims, vm);
+ return multiCallNewIntern(cl, len, dims, vm);
}
extern "C" void JavaObjectAquire(JavaObject* obj) {
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.cpp?rev=56336&r1=56335&r2=56336&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.cpp Fri Sep 19 02:16:01 2008
@@ -57,8 +57,8 @@
const char* name,
JnjvmClassLoader* loader, uint8 nid,
const char* assocName,
- UserClassPrimitive* prim, UserClassArray* cl,
- arrayCtor_t ctor) {
+ UserClassPrimitive* prim, UserClassArray* cl) {
+
AssessorDesc* res = this;
res->numId = nid;
res->doTrace = dt;
@@ -67,7 +67,6 @@
res->nbw = nw;
res->asciizName = name;
res->UTF8Name = loader->asciizConstructUTF8(name);
- res->arrayCtor = ctor;
res->arrayClass = cl;
if (assocName)
@@ -79,7 +78,6 @@
res->primitiveClass = prim;
if (res->arrayClass) {
res->arrayClass->_baseClass = res->primitiveClass;
- res->arrayClass->_funcs = res;
res->arrayClass->status = ready;
}
} else {
@@ -90,63 +88,53 @@
void AssessorDesc::initialise(JnjvmBootstrapLoader* vm) {
dParg = new AssessorDesc(false, I_PARG, 0, 0, "(", vm, 0, 0, 0,
- 0, 0);
+ 0);
dPard = new AssessorDesc(false, I_PARD, 0, 0, ")", vm, 0, 0, 0,
- 0, 0);
+ 0);
dVoid = new AssessorDesc(false, I_VOID, 0, 0, "void",
vm, VOID_ID, "java/lang/Void",
- vm->upcalls->OfVoid, 0, 0);
+ vm->upcalls->OfVoid, 0);
dBool = new AssessorDesc(false, I_BOOL, 1, 1, "boolean",
vm,
BOOL_ID, "java/lang/Boolean",
vm->upcalls->OfBool,
- vm->upcalls->ArrayOfBool,
- (arrayCtor_t)ArrayUInt8::acons);
+ vm->upcalls->ArrayOfBool);
dByte = new AssessorDesc(false, I_BYTE, 1, 1, "byte",
vm, BYTE_ID, "java/lang/Byte",
vm->upcalls->OfByte,
- vm->upcalls->ArrayOfByte,
- (arrayCtor_t)ArraySInt8::acons);
+ vm->upcalls->ArrayOfByte);
dChar = new AssessorDesc(false, I_CHAR, 2, 1, "char",
vm, CHAR_ID, "java/lang/Character",
vm->upcalls->OfChar,
- vm->upcalls->ArrayOfChar,
- (arrayCtor_t)ArrayUInt16::acons);
+ vm->upcalls->ArrayOfChar);
dShort = new AssessorDesc(false, I_SHORT, 2, 1, "short",
vm, SHORT_ID,
"java/lang/Short",
vm->upcalls->OfShort,
- vm->upcalls->ArrayOfShort,
- (arrayCtor_t)ArraySInt16::acons);
+ vm->upcalls->ArrayOfShort);
dInt = new AssessorDesc(false, I_INT, 4, 1, "int", vm,
INT_ID, "java/lang/Integer",
vm->upcalls->OfInt,
- vm->upcalls->ArrayOfInt,
- (arrayCtor_t)ArraySInt32::acons);
+ vm->upcalls->ArrayOfInt);
dFloat = new AssessorDesc(false, I_FLOAT, 4, 1, "float",
vm,
FLOAT_ID, "java/lang/Float",
vm->upcalls->OfFloat,
- vm->upcalls->ArrayOfFloat,
- (arrayCtor_t)ArrayFloat::acons);
+ vm->upcalls->ArrayOfFloat);
dLong = new AssessorDesc(false, I_LONG, 8, 2, "long",
vm, LONG_ID, "java/lang/Long",
vm->upcalls->OfLong,
- vm->upcalls->ArrayOfLong,
- (arrayCtor_t)ArrayLong::acons);
+ vm->upcalls->ArrayOfLong);
dDouble = new AssessorDesc(false, I_DOUBLE, 8, 2, "double",
vm,
DOUBLE_ID, "java/lang/Double",
vm->upcalls->OfDouble,
- vm->upcalls->ArrayOfDouble,
- (arrayCtor_t)ArrayDouble::acons);
+ vm->upcalls->ArrayOfDouble);
dTab = new AssessorDesc(true, I_TAB, sizeof(void*), 1, "array",
- vm, ARRAY_ID, 0, 0, 0,
- (arrayCtor_t)ArrayObject::acons);
+ vm, ARRAY_ID, 0, 0, 0);
dRef = new AssessorDesc(true, I_REF, sizeof(void*), 1, "reference",
vm, OBJECT_ID,
- 0, 0, 0,
- (arrayCtor_t)ArrayObject::acons);
+ 0, 0, 0);
}
@@ -279,35 +267,6 @@
}
}
-void AssessorDesc::introspectArray(JnjvmClassLoader* loader,
- const UTF8* utf8, uint32 start,
- AssessorDesc*& ass, UserCommonClass*& res) {
- uint32 pos = 0;
- uint32 intern = 0;
- AssessorDesc* funcs = 0;
-
- analyseIntern(utf8, start, 1, funcs, intern);
-
- if (funcs != dTab) {
- Jnjvm* vm = JavaThread::get()->isolate;
- vm->unknownError("%s isn't an array", utf8->printString());
- }
-
- analyseIntern(utf8, intern, 0, funcs, pos);
-
- if (funcs == dRef) {
- ass = dRef;
- const UTF8* temp = utf8->extract(loader->hashUTF8, intern + 1, pos - 1);
- res = loader->loadName(temp, false, true);
- } else if (funcs == dTab) {
- ass = dTab;
- res = loader->constructArray(utf8->extract(loader->hashUTF8, intern, pos));
- } else {
- ass = funcs;
- res = funcs->getPrimitiveClass();
- }
-}
-
AssessorDesc* AssessorDesc::arrayType(unsigned int t) {
if (t == JavaArray::T_CHAR) {
return AssessorDesc::dChar;
@@ -487,9 +446,9 @@
res->initialLoader = loader;
res->keyName = name;
res->funcs = funcs;
- if (funcs == AssessorDesc::dRef) {
+ if (isReference()) {
res->pseudoAssocClassName = name->extract(loader->hashUTF8, 1, next - 1);
- } else if (funcs == AssessorDesc::dTab) {
+ } else if (isArray()) {
res->pseudoAssocClassName = name;
} else {
res->pseudoAssocClassName = 0;
@@ -497,6 +456,19 @@
}
+bool Typedef::isArray() {
+ return keyName->elements[0] == '[';
+}
+
+bool Typedef::isReference() {
+ return keyName->elements[0] == 'L';
+}
+
+bool Typedef::trace() {
+ uint16 val = keyName->elements[0];
+ return (val == '[' || val == 'L');
+}
+
intptr_t Signdef::staticCallBuf() {
if (!_staticCallBuf) {
LLVMSignatureInfo* LSI = initialLoader->TheModule->getSignatureInfo(this);
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.h?rev=56336&r1=56335&r2=56336&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.h Fri Sep 19 02:16:01 2008
@@ -43,9 +43,6 @@
#define OBJECT_ID 10
#define NUM_ASSESSORS 11
-typedef JavaArray* (*arrayCtor_t)(uint32 len, UserClassArray* cl, Jnjvm* vm);
-
-
/// AssessorDesc - Description of a Java assessor: these are the letters found
/// in Java signatures, e.g. "I" or "(".
///
@@ -111,10 +108,6 @@
///
UserClassArray* arrayClass;
- /// arrayCtor - The constructor of an array of this assessor.
- ///
- arrayCtor_t arrayCtor;
-
//===----------------------------------------------------------------------===//
//
// The set of assessors in Java. This set is unique and there are no other
@@ -187,8 +180,7 @@
const char* name,
JnjvmClassLoader* loader, uint8 nid,
const char* assocName,
- UserClassPrimitive* prim, UserClassArray* cl,
- arrayCtor_t ctor);
+ UserClassPrimitive* prim, UserClassArray* cl);
/// initialise - Construct all assessors.
@@ -207,10 +199,6 @@
static const UTF8* constructArrayName(JnjvmClassLoader* loader, AssessorDesc* ass,
uint32 steps, const UTF8* className);
- static void introspectArray(JnjvmClassLoader* loader, const UTF8* utf8,
- uint32 start, AssessorDesc*& ass,
- UserCommonClass*& res);
-
static AssessorDesc* arrayType(unsigned int t);
static AssessorDesc* byteIdToPrimitive(const char id);
@@ -277,6 +265,10 @@
/// tPrintBuf - Prints the name of the class this Typedef represents.
///
void tPrintBuf(mvm::PrintBuffer* buf) const;
+
+ bool isArray();
+ bool isReference();
+ bool trace();
};
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=56336&r1=56335&r2=56336&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Fri Sep 19 02:16:01 2008
@@ -253,21 +253,31 @@
return classes->lookup(utf8);
}
-static UserCommonClass* arrayDup(const UTF8*& name, JnjvmClassLoader* loader) {
- UserClassArray* cl = allocator_new(loader->allocator, UserClassArray)(loader, name);
- return cl;
+UserCommonClass* JnjvmClassLoader::loadBaseClass(const UTF8* name,
+ uint32 start, uint32 len) {
+
+ if (name->elements[start] == AssessorDesc::I_TAB) {
+ UserCommonClass* baseClass = loadBaseClass(name, start + 1, len - 1);
+ JnjvmClassLoader* loader = baseClass->classLoader;
+ const UTF8* arrayName = name->extract(loader->hashUTF8, start, start + len);
+ return loader->constructArray(arrayName);
+ } else if (name->elements[start] == AssessorDesc::I_REF) {
+ const UTF8* componentName = name->extract(hashUTF8,
+ start + 1, start + len - 1);
+ UserCommonClass* cl = loadName(componentName, false, true);
+ return cl;
+ } else {
+ AssessorDesc* ass = AssessorDesc::byteIdToPrimitive(name->elements[start]);
+ return ass ? ass->primitiveClass : 0;
+ }
}
+
UserClassArray* JnjvmClassLoader::constructArray(const UTF8* name) {
- if (javaLoader != 0) {
- JnjvmClassLoader * ld =
- ClassArray::arrayLoader(name, this, 1, name->size - 1);
- UserClassArray* res =
- (UserClassArray*)ld->classes->lookupOrCreate(name, this, arrayDup);
- return res;
- } else {
- return (UserClassArray*)classes->lookupOrCreate(name, this, arrayDup);
- }
+ UserCommonClass* cl = loadBaseClass(name, 1, name->size - 1);
+ assert(cl && "no base class for an array");
+ JnjvmClassLoader* ld = cl->classLoader;
+ return ld->constructArray(name, cl);
}
UserClass* JnjvmClassLoader::constructClass(const UTF8* name, ArrayUInt8* bytes) {
@@ -286,6 +296,25 @@
return res;
}
+UserClassArray* JnjvmClassLoader::constructArray(const UTF8* name,
+ UserCommonClass* baseClass) {
+ assert(baseClass && "constructing an array class without a base class");
+ assert(baseClass->classLoader == this &&
+ "constructing an array with wrong loader");
+ classes->lock->lock();
+ ClassMap::iterator End = classes->map.end();
+ ClassMap::iterator I = classes->map.find(name);
+ UserClassArray* res = 0;
+ if (I == End) {
+ res = allocator_new(allocator, UserClassArray)(this, name, baseClass);
+ classes->map.insert(std::make_pair(name, res));
+ } else {
+ res = ((UserClassArray*)(I->second));
+ }
+ classes->lock->unlock();
+ return res;
+}
+
Typedef* JnjvmClassLoader::constructType(const UTF8* name) {
Typedef* res = javaTypes->lookup(name);
if (res == 0) {
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=56336&r1=56335&r2=56336&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h Fri Sep 19 02:16:01 2008
@@ -158,6 +158,9 @@
/// the given name.
///
UserClassArray* constructArray(const UTF8* name);
+ UserClassArray* constructArray(const UTF8* name, UserCommonClass* base);
+
+ UserCommonClass* loadBaseClass(const UTF8* name, uint32 start, uint32 len);
/// constructClass - Hashes a runtime representation of a class with
/// the given name.
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=56336&r1=56335&r2=56336&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp Fri Sep 19 02:16:01 2008
@@ -330,7 +330,7 @@
for (CommonClass::field_iterator i = fields.begin(), e = fields.end();
i!= e; ++i) {
- if (i->second->getSignature()->funcs->doTrace) {
+ if (i->second->getSignature()->trace()) {
LLVMFieldInfo* LFI = getFieldInfo(i->second);
std::vector<Value*> args; //size = 2
args.push_back(zero);
More information about the vmkit-commits
mailing list