[vmkit-commits] [vmkit] r57637 - in /vmkit/trunk/lib: JnJVM/Classpath/ JnJVM/VMCore/ Mvm/Runtime/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Thu Oct 16 07:04:41 PDT 2008
Author: geoffray
Date: Thu Oct 16 09:04:41 2008
New Revision: 57637
URL: http://llvm.org/viewvc/llvm-project?rev=57637&view=rev
Log:
A JVM does not hash its utf8s, but use the GC to allocate them. This
helps in not having class loaders that creates lots of utf8s and keeping
them eternally in memory.
Modified:
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h
vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaString.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/Jnjvm.h
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h
vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
vmkit/trunk/lib/Mvm/Runtime/Object.cpp
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp Thu Oct 16 09:04:41 2008
@@ -56,7 +56,7 @@
Jnjvm* vm = JavaThread::get()->isolate;
JnjvmClassLoader* JCL =
JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm);
- UserCommonClass* cl = JCL->lookupClassFromJavaString((JavaString*)str,
+ UserCommonClass* cl = JCL->lookupClassFromJavaString((JavaString*)str, vm,
true, false);
if (cl != 0) {
if (clinit) {
@@ -130,7 +130,7 @@
// TODO: check parameter types
UserClass* Meth = vm->upcalls->newMethod;
JavaObject* tmp = Meth->doNew(vm);
- JavaString* str = vm->UTF8ToStr(meth->name);
+ JavaString* str = vm->internalUTF8ToStr(meth->name);
upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, Cl, str, meth);
ret->elements[index] = tmp;
}
@@ -162,7 +162,7 @@
(UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl);
const UTF8* iname = cl->getName();
- const UTF8* res = iname->internalToJava(vm->hashUTF8, 0, iname->size);
+ const UTF8* res = iname->internalToJava(vm, 0, iname->size);
return (jobject)(vm->UTF8ToStr(res));
}
@@ -293,8 +293,8 @@
// TODO: check parameter types
UserClass* Field = vm->upcalls->newField;
JavaObject* tmp = Field->doNew(vm);
- vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, Cl,
- vm->UTF8ToStr(field->name), field);
+ JavaString* name = vm->internalUTF8ToStr(field->name);
+ vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, Cl, name, field);
ret->elements[index] = tmp;
}
return (jobject)ret;
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp Thu Oct 16 09:04:41 2008
@@ -73,7 +73,8 @@
JavaString* str = (JavaString*)_str;
JnjvmClassLoader* JCL = vm->bootstrapLoader;
- UserCommonClass* cl = JCL->lookupClassFromJavaString(str, doResolve, false);
+ UserCommonClass* cl = JCL->lookupClassFromJavaString(str, vm, doResolve,
+ false);
if (cl != 0)
return (jclass)cl->getClassDelegatee(vm);
@@ -98,8 +99,7 @@
JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm);
JavaString* str = (JavaString*)_str;
- const UTF8* name = str->value->javaToInternal(vm->hashUTF8, str->offset,
- str->count);
+ const UTF8* name = str->value->javaToInternal(vm, str->offset, str->count);
UserClass* cl = JCL->constructClass(name, (ArrayUInt8*)bytes);
return (jclass)(cl->getClassDelegatee(vm, (JavaObject*)pd));
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Thu Oct 16 09:04:41 2008
@@ -20,6 +20,7 @@
#include "JavaString.h"
#include "JavaTypes.h"
#include "JavaThread.h"
+#include "JavaUpcalls.h"
#include "Jnjvm.h"
#include "LockedMap.h"
#include "NativeUtil.h"
@@ -47,7 +48,8 @@
sint32 lgPost = vm->postlib->size;
uint32 size = (uint32)(lgPre + lgLib + lgPost);
- uint16* elements = (uint16*)alloca(size * sizeof(uint16));
+ ArrayUInt16* array = (ArrayUInt16*)vm->upcalls->ArrayOfChar->doNew(size, vm);
+ uint16* elements = array->elements;
memmove(elements, vm->prelib->elements, lgPre * sizeof(uint16));
memmove(&(elements[lgPre]), &(utf8Lib->elements[stLib]),
@@ -55,9 +57,7 @@
memmove(&(elements[lgPre + lgLib]), vm->postlib->elements,
lgPost * sizeof(uint16));
- const UTF8* res = vm->hashUTF8->lookupOrCreateReader(elements, size);
-
- return (jobject)(vm->UTF8ToStr(res));
+ return (jobject)(vm->UTF8ToStr((const UTF8*)array));
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Thu Oct 16 09:04:41 2008
@@ -51,10 +51,9 @@
JavaObject* consStackElement(JavaMethod* meth, int* ip) {
Jnjvm* vm = JavaThread::get()->isolate;
- JavaObject* methodName = vm->UTF8ToStr(meth->name);
+ JavaObject* methodName = vm->internalUTF8ToStr(meth->name);
Class* cl = meth->classDef;
- const UTF8* internal = cl->name->internalToJava(vm->hashUTF8, 0,
- cl->name->size);
+ const UTF8* internal = cl->name->internalToJava(vm, 0, cl->name->size);
JavaObject* className = vm->UTF8ToStr(internal);
JavaObject* sourceName = 0;
@@ -63,7 +62,7 @@
if (sourceAtt) {
Reader reader(sourceAtt, cl->getBytes());
uint16 index = reader.readU2();
- sourceName = vm->UTF8ToStr(cl->getConstantPool()->UTF8At(index));
+ sourceName = vm->internalUTF8ToStr(cl->getConstantPool()->UTF8At(index));
}
bool native = isNative(meth->access);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp Thu Oct 16 09:04:41 2008
@@ -16,6 +16,7 @@
#include "JavaTypes.h"
#include "Jnjvm.h"
#include "JavaThread.h"
+#include "JavaUpcalls.h"
#include "LockedMap.h"
@@ -39,23 +40,25 @@
buf->writeChar((char)elements[i]);
}
-const UTF8* UTF8::javaToInternal(UTF8Map* map, unsigned int start,
+const UTF8* UTF8::javaToInternal(Jnjvm* vm, unsigned int start,
unsigned int len) const {
- uint16* java = (uint16*) alloca(len * sizeof(uint16));
+ UTF8* array = (UTF8*)vm->upcalls->ArrayOfChar->doNew(len, vm);
+ uint16* java = array->elements;
for (uint32 i = 0; i < len; i++) {
uint16 cur = elements[start + i];
if (cur == '.') java[i] = '/';
else java[i] = cur;
}
- return map->lookupOrCreateReader(java, len);
+ return (const UTF8*)array;
}
// We also define a checked java to internal function to disallow
// users to load classes with '/'.
-const UTF8* UTF8::checkedJavaToInternal(UTF8Map* map, unsigned int start,
+const UTF8* UTF8::checkedJavaToInternal(Jnjvm* vm, unsigned int start,
unsigned int len) const {
- uint16* java = (uint16*) alloca(len * sizeof(uint16));
+ UTF8* array = (UTF8*)vm->upcalls->ArrayOfChar->doNew(len, vm);
+ uint16* java = array->elements;
for (uint32 i = 0; i < len; i++) {
uint16 cur = elements[start + i];
if (cur == '.') java[i] = '/';
@@ -63,19 +66,20 @@
else java[i] = cur;
}
- return map->lookupOrCreateReader(java, len);
+ return (const UTF8*)array;
}
-const UTF8* UTF8::internalToJava(UTF8Map* map, unsigned int start,
+const UTF8* UTF8::internalToJava(Jnjvm* vm, unsigned int start,
unsigned int len) const {
- uint16* java = (uint16*) alloca(len * sizeof(uint16));
+ UTF8* array = (UTF8*)vm->upcalls->ArrayOfChar->doNew(len, vm);
+ uint16* java = array->elements;
for (uint32 i = 0; i < len; i++) {
uint16 cur = elements[start + i];
if (cur == '/') java[i] = '.';
else java[i] = cur;
}
- return map->lookupOrCreateReader(java, len);
+ return (const UTF8*)array;
}
const UTF8* UTF8::extract(UTF8Map* map, uint32 start, uint32 end) const {
@@ -89,6 +93,18 @@
return map->lookupOrCreateReader(buf, len);
}
+const UTF8* UTF8::extract(Jnjvm* vm, uint32 start, uint32 end) const {
+ uint32 len = end - start;
+ UTF8* array = (UTF8*) vm->upcalls->ArrayOfChar->doNew(len, vm);
+ uint16* buf = array->elements;
+
+ for (uint32 i = 0; i < len; i++) {
+ buf[i] = elements[i + start];
+ }
+
+ return (const UTF8*)array;
+}
+
char* UTF8::UTF8ToAsciiz() const {
#ifndef DEBUG
mvm::NativeString* buf = mvm::NativeString::alloc(size + 1);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Thu Oct 16 09:04:41 2008
@@ -112,30 +112,49 @@
/// instance hashes UTF8. UTF8 are not allocated by the application's garbage
/// collector, but resides in permanent memory (e.g malloc).
class UTF8 : public ArrayUInt16 {
-public:
+ friend class UTF8Map;
+private:
+
+ /// operator new - Redefines the new operator of this class to allocate
+ /// its objects in permanent memory, not with the garbage collector.
+ void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
+ sint32 size) {
+ return allocator.Allocate(sz + size * sizeof(uint16));
+ }
/// acons - Allocates an UTF8 in permanent memory. The class argument must be
/// JavaArray::ofChar.
static const UTF8* acons(sint32 n, UserClassArray* cl,
mvm::BumpPtrAllocator& allocator);
+public:
+
/// internalToJava - Creates a copy of the UTF8 at its given offset and size
/// woth all its '.' replaced by '/'. The JVM bytecode reference classes in
/// packages with the '.' as the separating character. The JVM language uses
/// the '/' character.
- const UTF8* internalToJava(UTF8Map* map, unsigned int start,
+ ///
+ const UTF8* internalToJava(Jnjvm* vm, unsigned int start,
unsigned int len) const;
/// javaToInternal - Replaces all '/' into '.'.
- const UTF8* javaToInternal(UTF8Map* map, unsigned int start,
+ const UTF8* javaToInternal(Jnjvm* vm, unsigned int start,
unsigned int len) const;
/// checkedJavaToInternal - Replaces all '/' into '.'. Returns null if the
/// UTF8 contains a '/', as Java does not allow things like
/// Class.forName("java/lang/Object")
- const UTF8* checkedJavaToInternal(UTF8Map* map, unsigned int start,
+ const UTF8* checkedJavaToInternal(Jnjvm* vm, unsigned int start,
unsigned int len) const;
+ /// extract - Creates an UTF8 by extracting the contents at the given size
+ /// of this.
+ const UTF8* extract(Jnjvm* vm, uint32 start, uint32 len) const;
+
+ /// extract - Similar, but creates it in the map.
+ const UTF8* extract(UTF8Map* map, uint32 start, uint32 len) const;
+
+
/// UTF8ToAsciiz - Allocates a C string with the contents of this UTF8.
char* UTF8ToAsciiz() const;
@@ -143,10 +162,6 @@
return UTF8ToAsciiz();
}
- /// extract - Creates an UTF8 by extracting the contents at the given size
- /// of this.
- const UTF8* extract(UTF8Map* map, uint32 start, uint32 len) const;
-
bool equals(const UTF8* other) const {
if (other == this) return true;
else if (size != other->size) return false;
@@ -163,13 +178,6 @@
/// print - Prints the UTF8 for debugging purposes.
virtual void print(mvm::PrintBuffer* buf) const;
- /// operator new - Redefines the new operator of this class to allocate
- /// its objects in permanent memory, not with the garbage collector.
- void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
- sint32 size) {
- return allocator.Allocate(sz + size * sizeof(uint16));
- }
-
};
} // 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=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Thu Oct 16 09:04:41 2008
@@ -546,8 +546,7 @@
}
return (Tname->elements[prof] == I_REF) &&
- (res && curS->inheritName(Tname->extract(vm->hashUTF8, prof + 1,
- len - 1)));
+ (res && curS->inheritName(Tname->extract(vm, prof + 1, len - 1)));
} else {
return false;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Thu Oct 16 09:04:41 2008
@@ -80,40 +80,9 @@
uint32 JavaConstantPool::CtpReaderUTF8(JavaConstantPool* ctp, Reader& reader,
uint32 index) {
+ ctp->ctpDef[index] = reader.cursor;
uint16 len = reader.readU2();
- uint16* buf = (uint16*)alloca(len * sizeof(uint16));
- uint32 n = 0;
- uint32 i = 0;
-
- while (i < len) {
- uint32 cur = reader.readU1();
- if (cur & 0x80) {
- uint32 y = reader.readU1();
- if (cur & 0x20) {
- uint32 z = reader.readU1();
- cur = ((cur & 0x0F) << 12) +
- ((y & 0x3F) << 6) +
- (z & 0x3F);
- i += 3;
- } else {
- cur = ((cur & 0x1F) << 6) +
- (y & 0x3F);
- i += 2;
- }
- } else {
- ++i;
- }
- buf[n] = ((uint16)cur);
- ++n;
- }
-
- Class* cl = ctp->classDef;
- const UTF8* utf8 = cl->classLoader->hashUTF8->lookupOrCreateReader(buf, n);
- ctp->ctpRes[index] = (UTF8*)utf8;
-
- PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, "; [%5d] <utf8>\t\t\"%s\"\n", index,
- utf8->printString());
-
+ reader.cursor += len;
return 1;
}
@@ -218,6 +187,44 @@
JavaThread::get()->isolate->classFormatError(
"bad constant pool number for utf8 at entry %d", entry);
}
+
+ if (!ctpRes[entry]) {
+ Reader reader(classDef->bytes, ctpDef[entry]);
+ uint32 len = reader.readU2();
+ uint16* buf = (uint16*)alloca(len * sizeof(uint16));
+ uint32 n = 0;
+ uint32 i = 0;
+
+ while (i < len) {
+ uint32 cur = reader.readU1();
+ if (cur & 0x80) {
+ uint32 y = reader.readU1();
+ if (cur & 0x20) {
+ uint32 z = reader.readU1();
+ cur = ((cur & 0x0F) << 12) +
+ ((y & 0x3F) << 6) +
+ (z & 0x3F);
+ i += 3;
+ } else {
+ cur = ((cur & 0x1F) << 6) +
+ (y & 0x3F);
+ i += 2;
+ }
+ } else {
+ ++i;
+ }
+ buf[n] = ((uint16)cur);
+ ++n;
+ }
+
+ JnjvmClassLoader* loader = classDef->classLoader;
+ const UTF8* utf8 = loader->hashUTF8->lookupOrCreateReader(buf, n);
+ ctpRes[entry] = (UTF8*)utf8;
+
+ PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, "; [%5d] <utf8>\t\t\"%s\"\n", entry,
+ utf8->printString());
+
+ }
return (const UTF8*)ctpRes[entry];
}
@@ -487,7 +494,8 @@
}
JavaString* JavaConstantPool::resolveString(const UTF8* utf8, uint16 index) {
- JavaString* str = JavaThread::get()->isolate->UTF8ToStr(utf8);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaString* str = vm->internalUTF8ToStr(utf8);
return str;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Thu Oct 16 09:04:41 2008
@@ -1155,7 +1155,8 @@
push(val, false);
#else
const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[index]);
- JavaString* str = JavaThread::get()->isolate->UTF8ToStr(utf8);
+ JavaString* str = compilingClass->classLoader->UTF8ToStr(utf8);
+
Value* val = module->getString(str, this);
push(val, false);
#endif
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Thu Oct 16 09:04:41 2008
@@ -140,7 +140,7 @@
extern "C" void* stringLookup(UserClass* cl, uint32 index) {
UserConstantPool* ctpInfo = cl->getConstantPool();
const UTF8* utf8 = ctpInfo->UTF8AtForString(index);
- JavaString* str = JavaThread::get()->isolate->UTF8ToStr(utf8);
+ JavaString* str = JavaThread::get()->isolate->internalUTF8ToStr(utf8);
#ifdef ISOLATE_SHARING
ctpInfo->ctpRes[index] = str;
#endif
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Thu Oct 16 09:04:41 2008
@@ -10,22 +10,17 @@
#include "JavaArray.h"
#include "JavaClass.h"
#include "JavaString.h"
+#include "JavaThread.h"
#include "JavaUpcalls.h"
#include "Jnjvm.h"
+#include "LockedMap.h"
using namespace jnjvm;
JavaString* JavaString::stringDup(const UTF8*& utf8, Jnjvm* vm) {
UserClass* cl = vm->upcalls->newString;
- JavaString* res = (JavaString*)vm->allocator.Allocate(cl->getVirtualSize());
-#ifdef ISOLATE_SHARING
- /// Do this for now, but we will have to change it to duplicate the UTF8.
- /// UTF8 that dont have a class are shared UTF8.
- if (!utf8->classOf) ((UTF8*)utf8)->classOf = vm->upcalls->ArrayOfChar;
-#endif
- ((void**)res)[0] = cl->getVirtualVT();
- res->classOf = cl;
+ JavaString* res = (JavaString*)cl->doNew(vm);
// No need to call the Java function: both the Java function and
// this function do the same thing.
@@ -48,8 +43,14 @@
const UTF8* JavaString::strToUTF8(Jnjvm* vm) {
const UTF8* utf8 = this->value;
if (offset || (offset + count <= utf8->size)) {
- return utf8->extract(vm->hashUTF8, offset, offset + count);
+ return utf8->extract(vm, offset, offset + count);
} else {
return utf8;
}
}
+
+void JavaString::stringDestructor(JavaString* str) {
+ Jnjvm* vm = JavaThread::get()->isolate;
+ assert(vm && "No vm when destroying a string");
+ if (str->value) vm->hashStr->remove(str->value, str);
+}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.h?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaString.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.h Thu Oct 16 09:04:41 2008
@@ -29,6 +29,7 @@
sint32 offset;
static JavaString* stringDup(const UTF8*& utf8, Jnjvm* vm);
+ static void stringDestructor(JavaString*);
char* strToAsciiz();
const UTF8* strToUTF8(Jnjvm* vm);
};
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Thu Oct 16 09:04:41 2008
@@ -87,11 +87,9 @@
if (currentClass) loader = currentClass->classLoader;
else loader = vm->bootstrapLoader;
- const UTF8* utf8 = loader->asciizConstructUTF8(asciiz);
- sint32 len = utf8->size;
+ const UTF8* utf8 = vm->asciizToInternalUTF8(asciiz);
- const UTF8* internal = utf8->javaToInternal(vm->hashUTF8, 0, len);
- UserCommonClass* cl = loader->lookupClassFromUTF8(internal, true, true);
+ UserCommonClass* cl = loader->lookupClassFromUTF8(utf8, vm, true, true);
cl->initialiseClass(vm);
return (jclass)(cl->getClassDelegatee(vm));
@@ -329,13 +327,10 @@
Jnjvm* vm = JavaThread::get()->isolate;
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true);
- const UTF8* name = cl->classLoader->asciizConstructUTF8(aname);
- const UTF8* type = cl->classLoader->asciizConstructUTF8(atype);
+ const UTF8* name = vm->asciizToInternalUTF8(aname);
+ const UTF8* type = vm->asciizToInternalUTF8(atype);
UserClass* methodCl = 0;
- JavaMethod* meth = cl->lookupMethod(
- name->javaToInternal(vm->hashUTF8, 0, name->size),
- type->javaToInternal(vm->hashUTF8, 0, type->size), false,
- true, methodCl);
+ JavaMethod* meth = cl->lookupMethod(name, type, false, true, methodCl);
return (jmethodID)meth;
@@ -1121,13 +1116,10 @@
Jnjvm* vm = JavaThread::get()->isolate;
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true);
- const UTF8* name = cl->classLoader->asciizConstructUTF8(aname);
- const UTF8* type = cl->classLoader->asciizConstructUTF8(atype);
+ const UTF8* name = vm->asciizToInternalUTF8(aname);
+ const UTF8* type = vm->asciizToInternalUTF8(atype);
UserClass* methodCl = 0;
- JavaMethod* meth = cl->lookupMethod(
- name->javaToInternal(vm->hashUTF8, 0, name->size),
- type->javaToInternal(vm->hashUTF8, 0, type->size), true,
- true, methodCl);
+ JavaMethod* meth = cl->lookupMethod(name, type, true, true, methodCl);
return (jmethodID)meth;
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Thu Oct 16 09:04:41 2008
@@ -318,15 +318,30 @@
fmt);
}
+JavaString* Jnjvm::internalUTF8ToStr(const UTF8* utf8) {
+ JavaString* res = hashStr->lookup(utf8);
+ if (!res) {
+ uint32 size = utf8->size;
+ UTF8* tmp = (UTF8*)upcalls->ArrayOfChar->doNew(size, this);
+ uint16* buf = tmp->elements;
+
+ for (uint32 i = 0; i < size; i++) {
+ buf[i] = utf8->elements[i];
+ }
+
+ const UTF8* newUTF8 = (const UTF8*)tmp;
+ res = hashStr->lookupOrCreate(newUTF8, this, JavaString::stringDup);
+ }
+ return res;
+}
+
JavaString* Jnjvm::UTF8ToStr(const UTF8* utf8) {
JavaString* res = hashStr->lookupOrCreate(utf8, this, JavaString::stringDup);
return res;
}
JavaString* Jnjvm::asciizToStr(const char* asciiz) {
- // asciizToStr is called by jnjvm code, so utf8s created
- // by this method are stored in the bootstrap class loader
- const UTF8* var = bootstrapLoader->asciizConstructUTF8(asciiz);
+ const UTF8* var = asciizToUTF8(asciiz);
return UTF8ToStr(var);
}
@@ -357,14 +372,9 @@
hashStr->~StringMap();
allocator.Deallocate(hashStr);
}
- if (hashUTF8) {
- hashUTF8->~UTF8Map();
- allocator.Deallocate(hashUTF8);
- }
}
Jnjvm::Jnjvm() {
- hashUTF8 = 0;
hashStr = 0;
}
@@ -666,6 +676,8 @@
LOAD_CLASS(upcalls->newClass);
LOAD_CLASS(upcalls->newConstructor);
LOAD_CLASS(upcalls->newString);
+ uintptr_t* ptr = ((uintptr_t*)upcalls->newString->getVirtualVT());
+ ptr[0] = (uintptr_t)JavaString::stringDestructor;
LOAD_CLASS(upcalls->newMethod);
LOAD_CLASS(upcalls->newField);
LOAD_CLASS(upcalls->newStackTraceElement);
@@ -847,5 +859,28 @@
upcalls->initialiseClasspath(bootstrapLoader);
hashStr = new(allocator) StringMap();
- hashUTF8 = new(allocator) UTF8Map(allocator, upcalls->ArrayOfChar);
+}
+
+const UTF8* Jnjvm::asciizToInternalUTF8(const char* asciiz) {
+ uint32 size = strlen(asciiz);
+ UTF8* tmp = (UTF8*)upcalls->ArrayOfChar->doNew(size, this);
+ uint16* buf = tmp->elements;
+
+ for (uint32 i = 0; i < size; i++) {
+ if (asciiz[i] == '.') buf[i] = '/';
+ else buf[i] = asciiz[i];
+ }
+ return (const UTF8*)tmp;
+
+}
+
+const UTF8* Jnjvm::asciizToUTF8(const char* asciiz) {
+ uint32 size = strlen(asciiz);
+ UTF8* tmp = (UTF8*)upcalls->ArrayOfChar->doNew(size, this);
+ uint16* buf = tmp->elements;
+
+ for (uint32 i = 0; i < size; i++) {
+ buf[i] = asciiz[i];
+ }
+ return (const UTF8*)tmp;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Thu Oct 16 09:04:41 2008
@@ -258,11 +258,6 @@
///
StringMap* hashStr;
- /// hashUTF8 - Tables of UTF8s defined by this class loader. Shared
- /// by all class loaders in a no isolation configuration.
- ///
- UTF8Map* hashUTF8;
-
public:
/// Exceptions - These are the only exceptions VMKit will make.
///
@@ -298,6 +293,22 @@
///
JavaString* UTF8ToStr(const UTF8* utf8);
+ /// UTF8ToStr - Constructs a java/lang/String object from the given internal
+ /// UTF8, thus duplicating the UTF8.
+ ///
+ JavaString* internalUTF8ToStr(const UTF8* utf8);
+
+
+
+ /// asciizToInternalUTF8 - Constructs an UTF8 out of the asciiz and changes
+ /// '.' into '/'.
+ ///
+ const UTF8* asciizToInternalUTF8(const char* asciiz);
+
+ /// asciizToUTF8 - Constructs an UTF8 out of the asciiz.
+ ///
+ const UTF8* asciizToUTF8(const char* asciiz);
+
/// ~Jnjvm - Destroy the JVM.
///
~Jnjvm();
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Thu Oct 16 09:04:41 2008
@@ -138,7 +138,7 @@
UserCommonClass* cl = lookupClass(name);
if (!cl) {
- const UTF8* javaName = name->internalToJava(hashUTF8, 0, name->size);
+ const UTF8* javaName = name->internalToJava(isolate, 0, name->size);
JavaString* str = isolate->UTF8ToStr(javaName);
Classpath* upcalls = bootstrapLoader->upcalls;
UserClass* forCtp = 0;
@@ -177,6 +177,7 @@
}
UserCommonClass* JnjvmClassLoader::lookupClassFromUTF8(const UTF8* name,
+ Jnjvm* vm,
bool doResolve,
bool doThrow) {
uint32 len = name->size;
@@ -203,8 +204,7 @@
(name->elements[origLen - 1] != I_END_REF)) {
doLoop = false;
} else {
- const UTF8* componentName = name->javaToInternal(hashUTF8,
- start + 1,
+ const UTF8* componentName = name->javaToInternal(vm, start + 1,
len - 2);
if (loadName(componentName, doResolve, doThrow)) {
ret = constructArray(name);
@@ -241,19 +241,18 @@
}
UserCommonClass*
-JnjvmClassLoader::lookupClassFromJavaString(JavaString* str,
+JnjvmClassLoader::lookupClassFromJavaString(JavaString* str, Jnjvm* vm,
bool doResolve, bool doThrow) {
const UTF8* name = 0;
if (str->value->elements[str->offset] != I_TAB)
- name = str->value->checkedJavaToInternal(hashUTF8, str->offset,
- str->count);
+ name = str->value->checkedJavaToInternal(vm, str->offset, str->count);
else
- name = str->value->javaToInternal(hashUTF8, str->offset, str->count);
+ name = str->value->javaToInternal(vm, str->offset, str->count);
if (name)
- return lookupClassFromUTF8(name, doResolve, doThrow);
+ return lookupClassFromUTF8(name, vm, doResolve, doThrow);
return 0;
}
@@ -300,8 +299,9 @@
ClassMap::iterator I = classes->map.find(name);
UserClass* res = 0;
if (I == End) {
- res = allocator_new(allocator, UserClass)(this, name, bytes);
- classes->map.insert(std::make_pair(name, res));
+ const UTF8* internalName = readerConstructUTF8(name->elements, name->size);
+ res = allocator_new(allocator, UserClass)(this, internalName, bytes);
+ classes->map.insert(std::make_pair(internalName, res));
} else {
res = ((UserClass*)(I->second));
}
@@ -319,8 +319,10 @@
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));
+ const UTF8* internalName = readerConstructUTF8(name->elements, name->size);
+ res = allocator_new(allocator, UserClassArray)(this, internalName,
+ baseClass);
+ classes->map.insert(std::make_pair(internalName, res));
} else {
res = ((UserClassArray*)(I->second));
}
@@ -425,6 +427,19 @@
delete TheModuleProvider;
}
+JavaString* JnjvmClassLoader::UTF8ToStr(const UTF8* val) {
+ JavaString* res = isolate->internalUTF8ToStr(val);
+ strings.push_back(res);
+ return res;
+}
+
+JavaString* JnjvmBootstrapLoader::UTF8ToStr(const UTF8* val) {
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaString* res = vm->internalUTF8ToStr(val);
+ strings.push_back(res);
+ return res;
+}
+
void JnjvmBootstrapLoader::analyseClasspathEnv(const char* str) {
if (str != 0) {
unsigned int len = strlen(str);
@@ -470,6 +485,9 @@
}
}
+// constructArrayName can allocate the UTF8 directly in the classloader
+// memory because it is called by safe places, ie only valid names are
+// created.
const UTF8* JnjvmClassLoader::constructArrayName(uint32 steps,
const UTF8* className) {
uint32 len = className->size;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Thu Oct 16 09:04:41 2008
@@ -145,13 +145,13 @@
/// lookupClassFromUTF8 - Lookup a class from an UTF8 name and load it.
///
- UserCommonClass* lookupClassFromUTF8(const UTF8* utf8, bool doResolve,
- bool doThrow);
+ UserCommonClass* lookupClassFromUTF8(const UTF8* utf8, Jnjvm* vm,
+ bool doResolve, bool doThrow);
/// lookupClassFromJavaString - Lookup a class from a Java String and load it.
///
- UserCommonClass* lookupClassFromJavaString(JavaString* str, bool doResolve,
- bool doThrow);
+ UserCommonClass* lookupClassFromJavaString(JavaString* str, Jnjvm* vm,
+ bool doResolve, bool doThrow);
/// lookupClass - Finds the class of th given name in the class loader's
/// table.
@@ -217,6 +217,11 @@
#endif
const UTF8* constructArrayName(uint32 steps, const UTF8* className);
+
+ virtual JavaString* UTF8ToStr(const UTF8* utf8);
+
+ /// Strings hashed by this classloader.
+ std::vector<JavaString*, gc_allocator<JavaString*> > strings;
};
/// JnjvmBootstrapLoader - This class is for the bootstrap class loader, which
@@ -275,6 +280,9 @@
///
JnjvmBootstrapLoader(uint32 memLimit);
JnjvmBootstrapLoader() {}
+
+ virtual JavaString* UTF8ToStr(const UTF8* utf8);
+
/// upcalls - Upcall classes, fields and methods so that C++ code can call
/// Java code.
Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Thu Oct 16 09:04:41 2008
@@ -75,6 +75,17 @@
map.erase(V);
lock.unlock();
}
+
+ inline void remove(Key V, Container C) {
+ lock.lock();
+ iterator End = map.end();
+ iterator I = map.find(V);
+
+ if (I != End && I->second == C)
+ map.erase(I);
+
+ lock.unlock();
+ }
inline Container lookup(Key V) {
lock.lock();
Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Thu Oct 16 09:04:41 2008
@@ -135,6 +135,7 @@
javaLoader->MARK_AND_TRACE;
traceClassMap(classes);
isolate->MARK_AND_TRACE;
+ TRACE_VECTOR(JavaString*, gc_allocator, strings);
}
void JnjvmBootstrapLoader::TRACER {
@@ -157,6 +158,7 @@
TRACE_DELEGATEE(upcalls->OfLong);
TRACE_DELEGATEE(upcalls->OfDouble);
#undef TRACE_DELEGATEE
+ TRACE_VECTOR(JavaString*, gc_allocator, strings);
}
#if defined(ISOLATE_SHARING)
Modified: vmkit/trunk/lib/Mvm/Runtime/Object.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/Object.cpp?rev=57637&r1=57636&r2=57637&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/Object.cpp (original)
+++ vmkit/trunk/lib/Mvm/Runtime/Object.cpp Thu Oct 16 09:04:41 2008
@@ -118,10 +118,12 @@
void* mvm::BumpPtrAllocator::VMAllocate(size_t sz) {
mvm::BumpPtrAllocator* allocator = mvm::Thread::get()->vmAllocator;
+ assert(allocator && "No allocator when vm allocating");
return allocator->Allocate(sz);
}
void* mvm::BumpPtrAllocator::ThreadAllocate(size_t sz) {
mvm::BumpPtrAllocator* allocator = mvm::Thread::get()->threadAllocator;
+ assert(allocator && "No allocator when thread allocating");
return allocator->Allocate(sz);
}
More information about the vmkit-commits
mailing list